468 lines
14 KiB
Rust
468 lines
14 KiB
Rust
#![cfg(feature = "rand")]
|
|
|
|
extern crate num_bigint_dig as num_bigint;
|
|
extern crate num_traits;
|
|
extern crate rand;
|
|
extern crate rand_chacha;
|
|
extern crate rand_isaac;
|
|
extern crate rand_xorshift;
|
|
|
|
mod biguint {
|
|
use num_bigint::{BigUint, RandBigInt, RandomBits};
|
|
use num_traits::Zero;
|
|
use rand::distributions::Uniform;
|
|
use rand::{Rng, SeedableRng};
|
|
|
|
#[cfg(feature = "std")]
|
|
fn thread_rng() -> impl Rng {
|
|
rand::thread_rng()
|
|
}
|
|
#[cfg(not(feature = "std"))]
|
|
fn thread_rng() -> impl Rng {
|
|
// Chosen by fair dice roll
|
|
rand::rngs::StdRng::seed_from_u64(4)
|
|
}
|
|
|
|
#[test]
|
|
fn test_rand() {
|
|
let mut rng = thread_rng();
|
|
let n: BigUint = rng.gen_biguint(137);
|
|
assert!(n.bits() <= 137);
|
|
assert!(rng.gen_biguint(0).is_zero());
|
|
}
|
|
|
|
#[test]
|
|
fn test_rand_bits() {
|
|
let mut rng = thread_rng();
|
|
let n: BigUint = rng.sample(&RandomBits::new(137));
|
|
assert!(n.bits() <= 137);
|
|
let z: BigUint = rng.sample(&RandomBits::new(0));
|
|
assert!(z.is_zero());
|
|
}
|
|
|
|
#[test]
|
|
fn test_rand_range() {
|
|
let mut rng = thread_rng();
|
|
|
|
for _ in 0..10 {
|
|
assert_eq!(
|
|
rng.gen_biguint_range(&BigUint::from(236u32), &BigUint::from(237u32)),
|
|
BigUint::from(236u32)
|
|
);
|
|
}
|
|
|
|
let l = BigUint::from(403469000u32 + 2352);
|
|
let u = BigUint::from(403469000u32 + 3513);
|
|
for _ in 0..1000 {
|
|
let n: BigUint = rng.gen_biguint_below(&u);
|
|
assert!(n < u);
|
|
|
|
let n: BigUint = rng.gen_biguint_range(&l, &u);
|
|
assert!(n >= l);
|
|
assert!(n < u);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
#[should_panic]
|
|
fn test_zero_rand_range() {
|
|
thread_rng().gen_biguint_range(&BigUint::from(54u32), &BigUint::from(54u32));
|
|
}
|
|
|
|
#[test]
|
|
#[should_panic]
|
|
fn test_negative_rand_range() {
|
|
let mut rng = thread_rng();
|
|
let l = BigUint::from(2352u32);
|
|
let u = BigUint::from(3513u32);
|
|
// Switching u and l should fail:
|
|
let _n: BigUint = rng.gen_biguint_range(&u, &l);
|
|
}
|
|
|
|
#[test]
|
|
fn test_rand_uniform() {
|
|
let mut rng = thread_rng();
|
|
|
|
let tiny = Uniform::new(BigUint::from(236u32), BigUint::from(237u32));
|
|
for _ in 0..10 {
|
|
assert_eq!(rng.sample(&tiny), BigUint::from(236u32));
|
|
}
|
|
|
|
let l = BigUint::from(403469000u32 + 2352);
|
|
let u = BigUint::from(403469000u32 + 3513);
|
|
let below = Uniform::new(BigUint::zero(), u.clone());
|
|
let range = Uniform::new(l.clone(), u.clone());
|
|
for _ in 0..1000 {
|
|
let n: BigUint = rng.sample(&below);
|
|
assert!(n < u);
|
|
|
|
let n: BigUint = rng.sample(&range);
|
|
assert!(n >= l);
|
|
assert!(n < u);
|
|
}
|
|
}
|
|
|
|
fn seeded_value_stability<R: SeedableRng + RandBigInt>(expected: &[&str]) {
|
|
let mut seed = <R::Seed>::default();
|
|
for (i, x) in seed.as_mut().iter_mut().enumerate() {
|
|
*x = (i as u8).wrapping_mul(191);
|
|
}
|
|
let mut rng = R::from_seed(seed);
|
|
for (i, &s) in expected.iter().enumerate() {
|
|
let n: BigUint = s.parse().unwrap();
|
|
let r = rng.gen_biguint((1 << i) + i);
|
|
assert_eq!(n, r, "expected {}, got {}", n, r);
|
|
}
|
|
}
|
|
|
|
#[cfg(not(feature = "u64_digit"))]
|
|
const EXPECTED_CHACHA: &[&str] = &[
|
|
"0",
|
|
"0",
|
|
"52",
|
|
"84",
|
|
"23780",
|
|
"86502865016",
|
|
"187057847319509867386",
|
|
"34045731223080904464438757488196244981910",
|
|
"23813754422987836414755953516143692594193066497413249270287126597896871975915808",
|
|
"57401636903146945411652549098818446911814352529449356393690984105383482703074355\
|
|
67088360974672291353736011718191813678720755501317478656550386324355699624671",
|
|
];
|
|
|
|
#[cfg(feature = "u64_digit")]
|
|
const EXPECTED_CHACHA: &[&str] = &[
|
|
"0",
|
|
"0",
|
|
"8",
|
|
"1861",
|
|
"172076",
|
|
"5194801951",
|
|
"259202797457072892019",
|
|
"2806086822955830608275100562233284760859",
|
|
"28771276448190704455825316568337256462972770861366848469339788407170414346460023",
|
|
"501572804396703231264118826164515310701005506447150057229826006447721882571235378\
|
|
4765127362270091441643338804096337494157874113908470083557122824480944132407",
|
|
];
|
|
|
|
#[test]
|
|
fn test_chacha_value_stability() {
|
|
use rand_chacha::ChaChaRng;
|
|
seeded_value_stability::<ChaChaRng>(EXPECTED_CHACHA);
|
|
}
|
|
|
|
#[cfg(not(feature = "u64_digit"))]
|
|
const EXPECTED_ISAAC: &[&str] = &[
|
|
"1",
|
|
"4",
|
|
"3",
|
|
"649",
|
|
"89116",
|
|
"7730042024",
|
|
"20773149082453254949",
|
|
"35999009049239918667571895439206839620281",
|
|
"10191757312714088681302309313551624007714035309632506837271600807524767413673006",
|
|
"37805949268912387809989378008822038725134260145886913321084097194957861133272558\
|
|
43458183365174899239251448892645546322463253898288141861183340823194379722556",
|
|
];
|
|
|
|
#[cfg(feature = "u64_digit")]
|
|
const EXPECTED_ISAAC: &[&str] = &[
|
|
"1",
|
|
"2",
|
|
"51",
|
|
"1198",
|
|
"29707",
|
|
"35688018574",
|
|
"365090200586541225112",
|
|
"14051533166427520604648370582738617763816",
|
|
"26319846996091585801307964353534339679417889504909644767909019559631059772127122",
|
|
"14567336733062747693583250833667292276083519237160662196899060257293814346680656\
|
|
30951609693408423310563908301065751714778956255122249041917698392245727713420",
|
|
];
|
|
#[test]
|
|
fn test_isaac_value_stability() {
|
|
use rand_isaac::IsaacRng;
|
|
seeded_value_stability::<IsaacRng>(EXPECTED_ISAAC);
|
|
}
|
|
|
|
#[cfg(not(feature = "u64_digit"))]
|
|
const EXPECTED_XOR: &[&str] = &[
|
|
"1",
|
|
"0",
|
|
"37",
|
|
"395",
|
|
"181116",
|
|
"122718231117",
|
|
"1068467172329355695001",
|
|
"28246925743544411614293300167064395633287",
|
|
"12750053187017853048648861493745244146555950255549630854523304068318587267293038",
|
|
"53041498719137109355568081064978196049094604705283682101683207799515709404788873\
|
|
53417136457745727045473194367732849819278740266658219147356315674940229288531",
|
|
];
|
|
#[cfg(feature = "u64_digit")]
|
|
const EXPECTED_XOR: &[&str] = &[
|
|
"0",
|
|
"1",
|
|
"36",
|
|
"970",
|
|
"940965",
|
|
"61158366130",
|
|
"590484965100191554896",
|
|
"34050066418951688801044382442803594076612",
|
|
"29147581645599998811521651062569705291155276949983132826461704326818089074318948",
|
|
"4990842894093964353439376569956547459232523176881032246435842690389845516810345611554402412893818283310117202233021355634125020654279500443420515862554775828",
|
|
];
|
|
|
|
#[test]
|
|
fn test_xorshift_value_stability() {
|
|
use rand_xorshift::XorShiftRng;
|
|
seeded_value_stability::<XorShiftRng>(EXPECTED_XOR);
|
|
}
|
|
}
|
|
|
|
mod bigint {
|
|
use num_bigint::{BigInt, RandBigInt, RandomBits};
|
|
use num_traits::Zero;
|
|
use rand::distributions::Uniform;
|
|
use rand::{Rng, SeedableRng};
|
|
|
|
#[cfg(feature = "std")]
|
|
fn thread_rng() -> impl Rng {
|
|
rand::thread_rng()
|
|
}
|
|
#[cfg(not(feature = "std"))]
|
|
fn thread_rng() -> impl Rng {
|
|
// Chosen by fair dice roll
|
|
rand::rngs::StdRng::seed_from_u64(4)
|
|
}
|
|
|
|
#[test]
|
|
fn test_rand() {
|
|
let mut rng = thread_rng();
|
|
let n: BigInt = rng.gen_bigint(137);
|
|
assert!(n.bits() <= 137);
|
|
assert!(rng.gen_bigint(0).is_zero());
|
|
}
|
|
|
|
#[test]
|
|
fn test_rand_bits() {
|
|
let mut rng = thread_rng();
|
|
let n: BigInt = rng.sample(&RandomBits::new(137));
|
|
assert!(n.bits() <= 137);
|
|
let z: BigInt = rng.sample(&RandomBits::new(0));
|
|
assert!(z.is_zero());
|
|
}
|
|
|
|
#[test]
|
|
fn test_rand_range() {
|
|
let mut rng = thread_rng();
|
|
|
|
for _ in 0..10 {
|
|
assert_eq!(
|
|
rng.gen_bigint_range(&BigInt::from(236), &BigInt::from(237)),
|
|
BigInt::from(236)
|
|
);
|
|
}
|
|
|
|
fn check(l: BigInt, u: BigInt) {
|
|
let mut rng = thread_rng();
|
|
for _ in 0..1000 {
|
|
let n: BigInt = rng.gen_bigint_range(&l, &u);
|
|
assert!(n >= l);
|
|
assert!(n < u);
|
|
}
|
|
}
|
|
let l: BigInt = BigInt::from(403469000 + 2352);
|
|
let u: BigInt = BigInt::from(403469000 + 3513);
|
|
check(l.clone(), u.clone());
|
|
check(-l.clone(), u.clone());
|
|
check(-u.clone(), -l.clone());
|
|
}
|
|
|
|
#[test]
|
|
#[should_panic]
|
|
fn test_zero_rand_range() {
|
|
thread_rng().gen_bigint_range(&BigInt::from(54), &BigInt::from(54));
|
|
}
|
|
|
|
#[test]
|
|
#[should_panic]
|
|
fn test_negative_rand_range() {
|
|
let mut rng = thread_rng();
|
|
let l = BigInt::from(2352);
|
|
let u = BigInt::from(3513);
|
|
// Switching u and l should fail:
|
|
let _n: BigInt = rng.gen_bigint_range(&u, &l);
|
|
}
|
|
|
|
#[test]
|
|
fn test_rand_uniform() {
|
|
let mut rng = thread_rng();
|
|
|
|
let tiny = Uniform::new(BigInt::from(236u32), BigInt::from(237u32));
|
|
for _ in 0..10 {
|
|
assert_eq!(rng.sample(&tiny), BigInt::from(236u32));
|
|
}
|
|
|
|
fn check(l: BigInt, u: BigInt) {
|
|
let mut rng = thread_rng();
|
|
let range = Uniform::new(l.clone(), u.clone());
|
|
for _ in 0..1000 {
|
|
let n: BigInt = rng.sample(&range);
|
|
assert!(n >= l);
|
|
assert!(n < u);
|
|
}
|
|
}
|
|
let l: BigInt = BigInt::from(403469000 + 2352);
|
|
let u: BigInt = BigInt::from(403469000 + 3513);
|
|
check(l.clone(), u.clone());
|
|
check(-l.clone(), u.clone());
|
|
check(-u.clone(), -l.clone());
|
|
}
|
|
|
|
fn seeded_value_stability<R: SeedableRng + RandBigInt>(expected: &[&str]) {
|
|
let mut seed = <R::Seed>::default();
|
|
for (i, x) in seed.as_mut().iter_mut().enumerate() {
|
|
*x = (i as u8).wrapping_mul(191);
|
|
}
|
|
let mut rng = R::from_seed(seed);
|
|
for (i, &s) in expected.iter().enumerate() {
|
|
let n: BigInt = s.parse().unwrap();
|
|
let r = rng.gen_bigint((1 << i) + i);
|
|
assert_eq!(n, r, "expected {}, got {}", n, r);
|
|
}
|
|
}
|
|
#[cfg(not(feature = "u64_digit"))]
|
|
const EXPECTED_CHACHA: &[&str] = &[
|
|
"0",
|
|
"-6",
|
|
"-1",
|
|
"1321",
|
|
"-147247",
|
|
"8486373526",
|
|
"-272736656290199720696",
|
|
"2731152629387534140535423510744221288522",
|
|
"-28820024790651190394679732038637785320661450462089347915910979466834461433196572",
|
|
"501454570554170484799723603981439288209930393334472085317977614690773821680884844\
|
|
8530978478667288338327570972869032358120588620346111979053742269317702532328",
|
|
];
|
|
|
|
#[cfg(feature = "u64_digit")]
|
|
const EXPECTED_CHACHA: &[&str] = &[
|
|
"0",
|
|
"-7",
|
|
"-62",
|
|
"105",
|
|
"13025",
|
|
"-33857814162",
|
|
"768483926407291599143",
|
|
"-42356168828789885585553598574661841382586",
|
|
"28813250216034838684899917677182169473483558650956121225920149068989083656174824",
|
|
"27056553770481404639717657695702187062015359344716548489861498121037858109133467\
|
|
99640556108506718020020878739044048067894089601665199172215093468287730555599",
|
|
];
|
|
|
|
#[test]
|
|
fn test_chacha_value_stability() {
|
|
use rand_chacha::ChaChaRng;
|
|
seeded_value_stability::<ChaChaRng>(EXPECTED_CHACHA);
|
|
}
|
|
|
|
#[cfg(not(feature = "u64_digit"))]
|
|
const EXPECTED_ISAAC: &[&str] = &[
|
|
"1",
|
|
"0",
|
|
"5",
|
|
"113",
|
|
"-132240",
|
|
"-36348760761",
|
|
"-365690596708430705434",
|
|
"-14090753008246284277803606722552430292432",
|
|
"-26313941628626248579319341019368550803676255307056857978955881718727601479436059",
|
|
"-14563174552421101848999036239003801073335703811160945137332228646111920972691151\
|
|
88341090358094331641182310792892459091016794928947242043358702692294695845817",
|
|
];
|
|
#[cfg(feature = "u64_digit")]
|
|
const EXPECTED_ISAAC: &[&str] = &[
|
|
"-1",
|
|
"-4",
|
|
"-29",
|
|
"1621",
|
|
"23872",
|
|
"-40371956434",
|
|
"-350815272425024298187",
|
|
"-38554888817044546636456097200348998322457",
|
|
"7474426176220721712055446211154990065592106428397966654956172383998793852911545",
|
|
"6168955541726830487961394166772329653532583907235825721475483003506842180688827\
|
|
391385624898257369023912466314791483731902392667906094226608113824795883754631",
|
|
];
|
|
|
|
#[test]
|
|
fn test_isaac_value_stability() {
|
|
use rand_isaac::IsaacRng;
|
|
seeded_value_stability::<IsaacRng>(EXPECTED_ISAAC);
|
|
}
|
|
|
|
#[cfg(not(feature = "u64_digit"))]
|
|
const EXPECTED_XOR: &[&str] = &[
|
|
"-1",
|
|
"-4",
|
|
"11",
|
|
"-1802",
|
|
"966495",
|
|
"-62592045703",
|
|
"-602281783447192077116",
|
|
"-34335811410223060575607987996861632509125",
|
|
"29156580925282215857325937227200350542000244609280383263289720243118706105351199",
|
|
"49920038676141573457451407325930326489996232208489690499754573826911037849083623\
|
|
24546142615325187412887314466195222441945661833644117700809693098722026764846",
|
|
];
|
|
|
|
#[cfg(feature = "u64_digit")]
|
|
const EXPECTED_XOR: &[&str] = &[
|
|
"-1",
|
|
"-3",
|
|
"4",
|
|
"-228",
|
|
"377276",
|
|
"32032893086",
|
|
"885120221048601050706",
|
|
"33404877924318663206979407569537287223622",
|
|
"-15253093455306269007559295940333933266263385975865952571271093251749752787075084",
|
|
"4502641950394305250103130679458759592222756470562408577296380915684757985604969904\
|
|
381774527626485128207406911227296090734227576935034372181808818486328078978",
|
|
];
|
|
|
|
#[test]
|
|
fn test_xorshift_value_stability() {
|
|
use rand_xorshift::XorShiftRng;
|
|
seeded_value_stability::<XorShiftRng>(EXPECTED_XOR);
|
|
}
|
|
}
|
|
|
|
#[cfg(feature = "prime")]
|
|
mod prime {
|
|
use num_bigint::prime::probably_prime;
|
|
use num_bigint::RandPrime;
|
|
use rand::prelude::*;
|
|
|
|
#[test]
|
|
fn test_prime_small() {
|
|
let mut rng = StdRng::from_seed([0u8; 32]);
|
|
for n in 2..10 {
|
|
let p = rng.gen_prime(n);
|
|
|
|
assert_eq!(p.bits(), n);
|
|
assert!(probably_prime(&p, 32));
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_gen_prime_1024() {
|
|
let mut rng = StdRng::from_seed([0u8; 32]);
|
|
let p = rng.gen_prime(1024);
|
|
assert_eq!(p.bits(), 1024);
|
|
}
|
|
}
|