Macro pg 

macro_rules! pg {
    ($input: expr, $pgc: expr, $all: expr, $size:tt, $lim: expr) => { ... };
}

Flexible prime number generator.

Beware, macro returns Result<PrimeGenRes, PrimeGenErr>. Thus it can be directly unusable within fn body. Check with PrimeGenRes, PrimeGenErr for details.

Unity is not cosidered to be prime number.

2 variants available:

• PrimeGenClass::Nth — generation runs up to nth prime number inclusively.
• PrimeGenClass::Lim — generation runs up to limit inclusively.

Both variants can return only number required or whole row of prime numbers.

use big_num_math::{pg, PrimeGenClass, PrimeGenRes, PrimeGenErr, PrimeGenResAide};
use std::time::{Instant, Duration};

let all1 = || { pg!(11, PrimeGenClass::Nth, true, usize, None) };
let all2 = || { pg!(31, PrimeGenClass::Lim, true, usize, None) };

let proof: [usize; 11] = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31];

let all1 = all1().uproot_all();
let all2 = all2().uproot_all();

assert_eq!(all1, all2);
assert_eq!(proof, all1.as_slice());

In either case generation is limited by isize::MAX bytes. Expect memory reservation twice amount of $size type byte size per one prime number. For PrimeGenClass::Lim variant expect more. Given by formula (lim ÷⌊max(1, ㏑(lim))⌋) ⋅1.15.

Reason above implies that generating further large prime numbers can be impossible. Since direct generation of PlaceRows would be in-depth time demanding, this macro, sensibly, does use simpler numeric output.

Whole prime number row is generated and held, always. Since that, production can require considerable amount of time and be optionally time-limited.

use big_num_math::{pg, PrimeGenClass, PrimeGenRes, PrimeGenErr, PrimeGenResAide};
use std::time::{Instant, Duration};

let limit = Duration::from_secs(1);
let result = (|| { pg!(5_000, PrimeGenClass::Nth, false, u128, Some(limit)) })();

assert_eq!(48_611, result.uproot_max());

When confident about outputs, type setting can speed up computation. Use usize or wider type in contrary case.

use big_num_math::{pg, PrimeGenClass, PrimeGenRes, PrimeGenErr, PrimeGenResAide};
use std::time::{Instant, Duration};

let num = || { pg!(20_000, PrimeGenClass::Nth, false, u64, None) };
assert_eq!(224_737, num().uproot_max());

let num = || { pg!(20_000, PrimeGenClass::Nth, false, u32, None) };
assert_eq!(224_737, num().uproot_max());

u32 version of sample above will perform better. The gain stems from reduced data set size.