test "readme" {
    const allocator = std.testing.allocator;

    const F = f64;
    const die_sides: usize = 6;
    const target_total: usize = 10;

    // Initialize the dynamic programming problem allowing you
    // to iterate over the probability mass function
    var iter = try PDynamic(F).init(allocator, die_sides, target_total);
    defer iter.deinit();

    // Iterate over all roll_counts which might not be
    // zero and fill a newly created array with them
    const pma = try iter.to_owned_array();
    defer allocator.free(pma);

    // You can also iterate lazily and find the
    // probability that the target will be reached
    // or exceeed in exactly a given roll_count
    // (iterating further results in probs of 0).
    //
    // for (0..target_total + 1) |roll_count| {
    //     const prob = iter.next();
    //     // then do something with prob, roll_count
    // }

    // If there is a non-zero chance of rolling a 0, the
    // resulting probability mass function has infinitely
    // many terms, and some of the intermediate computations
    // convolve over infinitely many terms. This truncates
    // the output to roll_counts maxing at 30 (31 elements
    // in the returned array, since we provide the probability
    // for reaching the target in zero rolls in the 0th entry).
    const max_roll_count: usize = 30;

    // The resulting probability mass array will be as if instead
    // of just rolling a die, you first flipped a biased coin.
    // With probability prob_zero you generate a 0 rather than
    // rolling the die.
    const prob_zero: F = 0.3;

    // Convert the probability mass array we computed earlier for a 6-sided
    // die to what we would expect if there were a 30% chance of outputting
    // 0 rather than always rolling 1d6.
    const zero_pma = try with_zeros(F, allocator, max_roll_count, prob_zero, pma);
    defer allocator.free(zero_pma);

    // If your probability of zero is not too high, a small constant
    // factor of the original pma length should suffice to capture
    // almost all the total probability available in the infinite
    // sequence described above.
    var total_prob: F = 0;
    for (zero_pma) |p|
        total_prob += p;
    try std.testing.expectApproxEqAbs(@as(F, 1), total_prob, 1e-9);
}