bump rand to 0.9.0-beta.3; renamed "gen" to "random"; test bigrand; fix test lints

Cargo.toml

@@ -8,14 +8,14 @@ categories = [ "algorithms", "data-structures", "science" ]
 license = "MIT OR Apache-2.0"
 name = "num-bigint"
 repository = "https://github.com/rust-num/num-bigint"
-version = "0.4.6"
+version = "0.5.0"
 readme = "README.md"
 exclude = ["/ci/*", "/.github/*"]
 edition = "2021"
 rust-version = "1.60"
 
 [features]
-default = ["std"]
+default = ["std", "rand"]
 std = ["num-integer/std", "num-traits/std"]
 arbitrary = ["dep:arbitrary"]
 quickcheck = ["dep:quickcheck"]
@@ -56,7 +56,7 @@ features = ["i128"]
 
 [dependencies.rand]
 optional = true
-version = "0.8"
+version = "0.9"
 default-features = false
 
 [dependencies.serde]
@@ -73,3 +73,15 @@ default-features = false
 optional = true
 version = "1"
 default-features = false
+
+[dev-dependencies]
+rand = { version = "0.9", features = ["thread_rng"]}
+
+[lints.clippy]
+correctness = "deny"
+perf = "deny"
+complexity = "deny"
+suspicious = "deny"
+style = "warn"
+pedantic = "warn"
+nursery = "warn"

README.md

@@ -13,7 +13,7 @@ Add this to your `Cargo.toml`:
 
 ```toml
 [dependencies]
-num-bigint = "0.4"
+num-bigint = "0.5"
 ```
 
 ## Features
@@ -29,12 +29,12 @@ if your compiler is not new enough.
 feature is enabled. To enable it include rand as
 
 ```toml
-rand = "0.8"
-num-bigint = { version = "0.4", features = ["rand"] }
+rand = " =0.9.0-beta.3"
+num-bigint = { version = "0.5", features = ["rand"] }
 ```
 
 Note that you must use the version of `rand` that `num-bigint` is compatible
-with: `0.8`.
+with: ` =0.9.0-beta.3`.
 
 ## Releases
 

benches/bigint.rs

@@ -13,24 +13,24 @@ use rng::get_rng;
 
 fn multiply_bench(b: &mut Bencher, xbits: u64, ybits: u64) {
     let mut rng = get_rng();
-    let x = rng.gen_bigint(xbits);
-    let y = rng.gen_bigint(ybits);
+    let x = rng.random_bigint(xbits);
+    let y = rng.random_bigint(ybits);
 
     b.iter(|| &x * &y);
 }
 
 fn divide_bench(b: &mut Bencher, xbits: u64, ybits: u64) {
     let mut rng = get_rng();
-    let x = rng.gen_bigint(xbits);
-    let y = rng.gen_bigint(ybits);
+    let x = rng.random_bigint(xbits);
+    let y = rng.random_bigint(ybits);
 
     b.iter(|| &x / &y);
 }
 
 fn remainder_bench(b: &mut Bencher, xbits: u64, ybits: u64) {
     let mut rng = get_rng();
-    let x = rng.gen_bigint(xbits);
-    let y = rng.gen_bigint(ybits);
+    let x = rng.random_bigint(xbits);
+    let y = rng.random_bigint(ybits);
 
     b.iter(|| &x % &y);
 }
@@ -186,7 +186,7 @@ fn fib_to_string(b: &mut Bencher) {
 
 fn to_str_radix_bench(b: &mut Bencher, radix: u32, bits: u64) {
     let mut rng = get_rng();
-    let x = rng.gen_bigint(bits);
+    let x = rng.random_bigint(bits);
     b.iter(|| x.to_str_radix(radix));
 }
 
@@ -222,7 +222,7 @@ fn to_str_radix_36(b: &mut Bencher) {
 
 fn from_str_radix_bench(b: &mut Bencher, radix: u32) {
     let mut rng = get_rng();
-    let x = rng.gen_bigint(1009);
+    let x = rng.random_bigint(1009);
     let s = x.to_str_radix(radix);
     assert_eq!(x, BigInt::from_str_radix(&s, radix).unwrap());
     b.iter(|| BigInt::from_str_radix(&s, radix));
@@ -256,7 +256,7 @@ fn from_str_radix_36(b: &mut Bencher) {
 fn rand_bench(b: &mut Bencher, bits: u64) {
     let mut rng = get_rng();
 
-    b.iter(|| rng.gen_bigint(bits));
+    b.iter(|| rng.random_bigint(bits));
 }
 
 #[bench]
@@ -308,7 +308,7 @@ fn shl(b: &mut Bencher) {
         for i in 0..50 {
             m <<= i;
         }
-    })
+    });
 }
 
 #[bench]
@@ -320,14 +320,14 @@ fn shr(b: &mut Bencher) {
         for i in 0..50 {
             m >>= i;
         }
-    })
+    });
 }
 
 #[bench]
 fn hash(b: &mut Bencher) {
     use std::collections::HashSet;
     let mut rng = get_rng();
-    let v: Vec<BigInt> = (1000..2000).map(|bits| rng.gen_bigint(bits)).collect();
+    let v: Vec<BigInt> = (1000..2000).map(|bits| rng.random_bigint(bits)).collect();
     b.iter(|| {
         let h: HashSet<&BigInt> = v.iter().collect();
         assert_eq!(h.len(), v.len());
@@ -342,7 +342,9 @@ fn pow_bench(b: &mut Bencher) {
         for _i in 2..=upper {
             i_big += 1u32;
             for j in 2..=upper {
-                i_big.pow(j);
+                let x = i_big.pow(j);
+                // added black box to prevent the compiler from optimizing out the pow
+                std::hint::black_box(&x);
             }
         }
     });
@@ -382,7 +384,7 @@ fn pow_bench_1e100000(b: &mut Bencher) {
 }
 
 /// This modulus is the prime from the 2048-bit MODP DH group:
-/// https://tools.ietf.org/html/rfc3526#section-3
+/// <https://tools.ietf.org/html/rfc3526#section-3>
 const RFC3526_2048BIT_MODP_GROUP: &str = "\
                                           FFFFFFFF_FFFFFFFF_C90FDAA2_2168C234_C4C6628B_80DC1CD1\
                                           29024E08_8A67CC74_020BBEA6_3B139B22_514A0879_8E3404DD\
@@ -399,8 +401,8 @@ const RFC3526_2048BIT_MODP_GROUP: &str = "\
 #[bench]
 fn modpow(b: &mut Bencher) {
     let mut rng = get_rng();
-    let base = rng.gen_biguint(2048);
-    let e = rng.gen_biguint(2048);
+    let base = rng.random_biguint(2048);
+    let e = rng.random_biguint(2048);
     let m = BigUint::from_str_radix(RFC3526_2048BIT_MODP_GROUP, 16).unwrap();
 
     b.iter(|| base.modpow(&e, &m));
@@ -409,8 +411,8 @@ fn modpow(b: &mut Bencher) {
 #[bench]
 fn modpow_even(b: &mut Bencher) {
     let mut rng = get_rng();
-    let base = rng.gen_biguint(2048);
-    let e = rng.gen_biguint(2048);
+    let base = rng.random_biguint(2048);
+    let e = rng.random_biguint(2048);
     // Make the modulus even, so monty (base-2^32) doesn't apply.
     let m = BigUint::from_str_radix(RFC3526_2048BIT_MODP_GROUP, 16).unwrap() - 1u32;
 
@@ -420,31 +422,31 @@ fn modpow_even(b: &mut Bencher) {
 #[bench]
 fn to_u32_digits(b: &mut Bencher) {
     let mut rng = get_rng();
-    let n = rng.gen_biguint(2048);
+    let n = rng.random_biguint(2048);
 
     b.iter(|| n.to_u32_digits());
 }
 
 #[bench]
 fn iter_u32_digits(b: &mut Bencher) {
     let mut rng = get_rng();
-    let n = rng.gen_biguint(2048);
+    let n = rng.random_biguint(2048);
 
     b.iter(|| n.iter_u32_digits().max());
 }
 
 #[bench]
 fn to_u64_digits(b: &mut Bencher) {
     let mut rng = get_rng();
-    let n = rng.gen_biguint(2048);
+    let n = rng.random_biguint(2048);
 
     b.iter(|| n.to_u64_digits());
 }
 
 #[bench]
 fn iter_u64_digits(b: &mut Bencher) {
     let mut rng = get_rng();
-    let n = rng.gen_biguint(2048);
+    let n = rng.random_biguint(2048);
 
     b.iter(|| n.iter_u64_digits().max());
 }

benches/gcd.rs

@@ -13,8 +13,8 @@ use rng::get_rng;
 
 fn bench(b: &mut Bencher, bits: u64, gcd: fn(&BigUint, &BigUint) -> BigUint) {
     let mut rng = get_rng();
-    let x = rng.gen_biguint(bits);
-    let y = rng.gen_biguint(bits);
+    let x = rng.random_biguint(bits);
+    let y = rng.random_biguint(bits);
 
     assert_eq!(euclid(&x, &y), x.gcd(&y));
 

benches/rng/mod.rs

@@ -28,11 +28,11 @@ impl RngCore for XorShiftStar {
         for chunk in dest.chunks_mut(8) {
             let bytes = self.next_u64().to_le_bytes();
             let slice = &bytes[..chunk.len()];
-            chunk.copy_from_slice(slice)
+            chunk.copy_from_slice(slice);
         }
     }
 
-    fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), rand::Error> {
-        Ok(self.fill_bytes(dest))
-    }
+    // fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), rand::Error> {
+    //     Ok(self.fill_bytes(dest))
+    // }
 }

benches/roots.rs

@@ -20,9 +20,9 @@ use rng::get_rng;
 fn check(x: &BigUint, n: u32) {
     let root = x.nth_root(n);
     if n == 2 {
-        assert_eq!(root, x.sqrt())
+        assert_eq!(root, x.sqrt());
     } else if n == 3 {
-        assert_eq!(root, x.cbrt())
+        assert_eq!(root, x.cbrt());
     }
 
     let lo = root.pow(n);
@@ -37,8 +37,8 @@ fn check(x: &BigUint, n: u32) {
 }
 
 fn bench_sqrt(b: &mut Bencher, bits: u64) {
-    let x = get_rng().gen_biguint(bits);
-    eprintln!("bench_sqrt({})", x);
+    let x = get_rng().random_biguint(bits);
+    eprintln!("bench_sqrt({x})");
 
     check(&x, 2);
     b.iter(|| x.sqrt());
@@ -65,8 +65,8 @@ fn big4k_sqrt(b: &mut Bencher) {
 }
 
 fn bench_cbrt(b: &mut Bencher, bits: u64) {
-    let x = get_rng().gen_biguint(bits);
-    eprintln!("bench_cbrt({})", x);
+    let x = get_rng().random_biguint(bits);
+    eprintln!("bench_cbrt({x})");
 
     check(&x, 3);
     b.iter(|| x.cbrt());
@@ -93,8 +93,8 @@ fn big4k_cbrt(b: &mut Bencher) {
 }
 
 fn bench_nth_root(b: &mut Bencher, bits: u64, n: u32) {
-    let x = get_rng().gen_biguint(bits);
-    eprintln!("bench_{}th_root({})", n, x);
+    let x = get_rng().random_biguint(bits);
+    eprintln!("bench_{n}th_root({x})");
 
     check(&x, n);
     b.iter(|| x.nth_root(n));

benches/shootout-pidigits.rs

@@ -52,8 +52,8 @@ struct Context {
 }
 
 impl Context {
-    fn new() -> Context {
-        Context {
+    fn new() -> Self {
+        Self {
             numer: One::one(),
             accum: Zero::zero(),
             denom: One::one(),
@@ -68,23 +68,23 @@ impl Context {
         if self.numer > self.accum {
             return -1;
         }
-        let (q, r) = (&self.numer * Context::from_i32(3) + &self.accum).div_rem(&self.denom);
+        let (q, r) = (&self.numer * Self::from_i32(3) + &self.accum).div_rem(&self.denom);
         if r + &self.numer >= self.denom {
             return -1;
         }
         q.to_i32().unwrap()
     }
 
     fn next_term(&mut self, k: i32) {
-        let y2 = Context::from_i32(k * 2 + 1);
+        let y2 = Self::from_i32(k * 2 + 1);
         self.accum = (&self.accum + (&self.numer << 1)) * &y2;
-        self.numer = &self.numer * Context::from_i32(k);
+        self.numer = &self.numer * Self::from_i32(k);
         self.denom = &self.denom * y2;
     }
 
     fn eliminate_digit(&mut self, d: i32) {
-        let d = Context::from_i32(d);
-        let ten = Context::from_i32(10);
+        let d = Self::from_i32(d);
+        let ten = Self::from_i32(10);
         self.accum = (&self.accum - &self.denom * d) * &ten;
         self.numer = &self.numer * ten;
     }
@@ -105,9 +105,9 @@ fn pidigits(n: isize, out: &mut dyn io::Write) -> io::Result<()> {
             }
         }
 
-        write!(out, "{}", d)?;
+        write!(out, "{d}")?;
         if i % 10 == 0 {
-            writeln!(out, "\t:{}", i)?;
+            writeln!(out, "\t:{i}")?;
         }
 
         context.eliminate_digit(d);
@@ -118,7 +118,7 @@ fn pidigits(n: isize, out: &mut dyn io::Write) -> io::Result<()> {
         for _ in m..10 {
             write!(out, " ")?;
         }
-        writeln!(out, "\t:{}", n)?;
+        writeln!(out, "\t:{n}")?;
     }
     Ok(())
 }