Merge branch 'master' into dp-rayon-prime-gen

Author: dvdplm

Diff for: benches/bench.rs

@@ -1,4 +1,4 @@
-use core::num::NonZeroU32;
+use core::num::NonZero;
 
 use criterion::{criterion_group, criterion_main, BatchSize, Criterion};
 use crypto_bigint::{nlimbs, BoxedUint, Integer, Odd, RandomBits, Uint, U1024, U128, U256};
@@ -26,12 +26,12 @@ fn make_rng() -> ChaCha8Rng {
 }
 
 fn random_odd_uint<T: RandomBits + Integer>(rng: &mut impl CryptoRngCore, bit_length: u32) -> Odd<T> {
-    random_odd_integer::<T>(rng, NonZeroU32::new(bit_length).unwrap())
+    random_odd_integer::<T>(rng, NonZero::new(bit_length).unwrap())
 }
 
 fn make_sieve<const L: usize>(rng: &mut impl CryptoRngCore) -> Sieve<Uint<L>> {
     let start = random_odd_uint::<Uint<L>>(rng, Uint::<L>::BITS);
-    Sieve::new(start.get(), NonZeroU32::new(Uint::<L>::BITS).unwrap(), false)
+    Sieve::new(start.get(), NonZero::new(Uint::<L>::BITS).unwrap(), false)
 }
 
 fn make_presieved_num<const L: usize>(rng: &mut impl CryptoRngCore) -> Odd<Uint<L>> {
@@ -49,7 +49,7 @@ fn bench_sieve(c: &mut Criterion) {
     group.bench_function("(U128) creation", |b| {
         b.iter_batched(
             || random_odd_uint::<U128>(&mut OsRng, 128),
-            |start| Sieve::new(start.get(), NonZeroU32::new(128).unwrap(), false),
+            |start| Sieve::new(start.get(), NonZero::new(128).unwrap(), false),
             BatchSize::SmallInput,
         )
     });
@@ -70,7 +70,7 @@ fn bench_sieve(c: &mut Criterion) {
     group.bench_function("(U1024) creation", |b| {
         b.iter_batched(
             || random_odd_uint::<U1024>(&mut OsRng, 1024),
-            |start| Sieve::new(start.get(), NonZeroU32::new(1024).unwrap(), false),
+            |start| Sieve::new(start.get(), NonZero::new(1024).unwrap(), false),
             BatchSize::SmallInput,
         )
     });
@@ -418,8 +418,8 @@ fn bench_glass_pumpkin(c: &mut Criterion) {
     // Mimics the sequence of checks `glass-pumpkin` does to find a prime.
     fn prime_like_gp(bit_length: u32, rng: &mut impl CryptoRngCore) -> BoxedUint {
         loop {
-            let start = random_odd_integer::<BoxedUint>(rng, NonZeroU32::new(bit_length).unwrap()).get();
-            let sieve = Sieve::new(start, NonZeroU32::new(bit_length).unwrap(), false);
+            let start = random_odd_integer::<BoxedUint>(rng, NonZero::new(bit_length).unwrap()).get();
+            let sieve = Sieve::new(start, NonZero::new(bit_length).unwrap(), false);
             for num in sieve {
                 let odd_num = Odd::new(num.clone()).unwrap();
 
@@ -442,8 +442,8 @@ fn bench_glass_pumpkin(c: &mut Criterion) {
     // Mimics the sequence of checks `glass-pumpkin` does to find a safe prime.
     fn safe_prime_like_gp(bit_length: u32, rng: &mut impl CryptoRngCore) -> BoxedUint {
         loop {
-            let start = random_odd_integer::<BoxedUint>(rng, NonZeroU32::new(bit_length).unwrap()).get();
-            let sieve = Sieve::new(start, NonZeroU32::new(bit_length).unwrap(), true);
+            let start = random_odd_integer::<BoxedUint>(rng, NonZero::new(bit_length).unwrap()).get();
+            let sieve = Sieve::new(start, NonZero::new(bit_length).unwrap(), true);
             for num in sieve {
                 let odd_num = Odd::new(num.clone()).unwrap();
 

Diff for: src/hazmat/gcd.rs

@@ -1,4 +1,5 @@
-use crypto_bigint::{Integer, Limb, NonZero, Word};
+use core::num::NonZero;
+use crypto_bigint::{Integer, Limb, NonZero as CTNonZero, Word};
 
 /// Calculates the greatest common divisor of `n` and `m`.
 /// By definition, `gcd(0, m) == m`.
@@ -14,7 +15,7 @@ pub(crate) fn gcd_vartime<T: Integer>(n: &T, m: NonZero<Word>) -> Word {
     // Normalize input: the resulting (a, b) are both small, a >= b, and b != 0.
     let (a, b): (Word, Word) = if n.bits() > Word::BITS {
         // `m` is non-zero, so we can unwrap.
-        let r = n.rem_limb(NonZero::new(Limb::from(m)).expect("divisor should be non-zero here"));
+        let r = n.rem_limb(CTNonZero::new(Limb::from(m)).expect("divisor should be non-zero here"));
         (m, r.0)
     } else {
         // In this branch `n` is `Word::BITS` bits or shorter,
@@ -74,7 +75,8 @@ fn binary_gcd(mut n: Word, mut m: Word) -> Word {
 
 #[cfg(test)]
 mod tests {
-    use crypto_bigint::{NonZero, Word, U128};
+    use core::num::NonZero;
+    use crypto_bigint::{Word, U128};
     use num_bigint::BigUint;
     use num_integer::Integer;
     use proptest::prelude::*;

Diff for: src/hazmat/jacobi.rs

@@ -1,6 +1,6 @@
 //! Jacobi symbol calculation.
 
-use crypto_bigint::{Integer, Limb, NonZero, Odd, Word};
+use crypto_bigint::{Integer, Limb, NonZero as CTNonZero, Odd, Word};
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
 pub(crate) enum JacobiSymbol {
@@ -99,7 +99,7 @@ pub(crate) fn jacobi_symbol_vartime<T: Integer>(abs_a: Word, a_is_negative: bool
         let (result, a_long, p) = swap_long(result, a, p_long);
         // Can unwrap here, since `p` is swapped with `a`,
         // and `a` would be odd after `reduce_numerator()`.
-        let a = a_long.rem_limb(NonZero::new(Limb::from(p)).expect("divisor should be non-zero here"));
+        let a = a_long.rem_limb(CTNonZero::new(Limb::from(p)).expect("divisor should be non-zero here"));
         (result, a.0, p)
     };
 

Diff for: src/hazmat/lucas.rs

@@ -1,5 +1,6 @@
 //! Lucas primality test.
-use crypto_bigint::{Integer, Limb, Monty, NonZero, Odd, Square, Word};
+use core::num::NonZero;
+use crypto_bigint::{Integer, Limb, Monty, Odd, Square, Word};
 
 use super::{
     gcd::gcd_vartime,

Diff for: src/hazmat/miller_rabin.rs

@@ -1,6 +1,6 @@
 //! Miller-Rabin primality test.
 
-use crypto_bigint::{Integer, Limb, Monty, NonZero, Odd, PowBoundedExp, RandomMod, Square};
+use crypto_bigint::{Integer, Limb, Monty, NonZero as CTNonZero, Odd, PowBoundedExp, RandomMod, Square};
 use rand_core::CryptoRngCore;
 
 use super::Primality;
@@ -115,7 +115,7 @@ impl<T: Integer + RandomMod> MillerRabin<T> {
 
         let range = self.candidate.wrapping_sub(&T::from(4u32));
         // Can unwrap here since `candidate` is odd, and `candidate >= 4` (as checked above)
-        let range_nonzero = NonZero::new(range).expect("the range should be non-zero by construction");
+        let range_nonzero = CTNonZero::new(range).expect("the range should be non-zero by construction");
         // This should not overflow as long as `random_mod()` behaves according to the contract
         // (that is, returns a number within the given range).
         let random = T::random_mod(rng, &range_nonzero)
@@ -136,9 +136,8 @@ impl<T: Integer + RandomMod> MillerRabin<T> {
 
 #[cfg(test)]
 mod tests {
-
     use alloc::format;
-    use core::num::NonZeroU32;
+    use core::num::NonZero;
 
     use crypto_bigint::{Integer, Odd, RandomMod, Uint, U1024, U128, U1536, U64};
     use rand_chacha::ChaCha8Rng;
@@ -197,8 +196,8 @@ mod tests {
     #[test]
     fn trivial() {
         let mut rng = ChaCha8Rng::from_seed(*b"01234567890123456789012345678901");
-        let start = random_odd_integer::<U1024>(&mut rng, NonZeroU32::new(1024).unwrap());
-        for num in Sieve::new(start.get(), NonZeroU32::new(1024).unwrap(), false).take(10) {
+        let start = random_odd_integer::<U1024>(&mut rng, NonZero::new(1024).unwrap());
+        for num in Sieve::new(start.get(), NonZero::new(1024).unwrap(), false).take(10) {
             let mr = MillerRabin::new(Odd::new(num).unwrap());
 
             // Trivial tests, must always be true.

Diff for: src/hazmat/sieve.rs

@@ -249,7 +249,7 @@ mod tests {
 
     use alloc::format;
     use alloc::vec::Vec;
-    use core::num::NonZeroU32;
+    use core::num::NonZero;
 
     use crypto_bigint::U64;
     use num_prime::nt_funcs::factorize64;
@@ -264,8 +264,8 @@ mod tests {
         let max_prime = SMALL_PRIMES[SMALL_PRIMES.len() - 1];
 
         let mut rng = ChaCha8Rng::from_seed(*b"01234567890123456789012345678901");
-        let start = random_odd_integer::<U64>(&mut rng, NonZeroU32::new(32).unwrap()).get();
-        for num in Sieve::new(start, NonZeroU32::new(32).unwrap(), false).take(100) {
+        let start = random_odd_integer::<U64>(&mut rng, NonZero::new(32).unwrap()).get();
+        for num in Sieve::new(start, NonZero::new(32).unwrap(), false).take(100) {
             let num_u64 = u64::from(num);
             assert!(num_u64.leading_zeros() == 32);
 
@@ -280,9 +280,9 @@ mod tests {
         let max_prime = SMALL_PRIMES[SMALL_PRIMES.len() - 1];
 
         let mut rng = ChaCha8Rng::from_seed(*b"01234567890123456789012345678901");
-        let start = random_odd_integer::<crypto_bigint::BoxedUint>(&mut rng, NonZeroU32::new(32).unwrap()).get();
+        let start = random_odd_integer::<crypto_bigint::BoxedUint>(&mut rng, NonZero::new(32).unwrap()).get();
 
-        for num in Sieve::new(start, NonZeroU32::new(32).unwrap(), false).take(100) {
+        for num in Sieve::new(start, NonZero::new(32).unwrap(), false).take(100) {
             // For 32-bit targets
             #[allow(clippy::useless_conversion)]
             let num_u64: u64 = num.as_words()[0].into();
@@ -296,7 +296,7 @@ mod tests {
     }
 
     fn check_sieve(start: u32, bit_length: u32, safe_prime: bool, reference: &[u32]) {
-        let test = Sieve::new(U64::from(start), NonZeroU32::new(bit_length).unwrap(), safe_prime).collect::<Vec<_>>();
+        let test = Sieve::new(U64::from(start), NonZero::new(bit_length).unwrap(), safe_prime).collect::<Vec<_>>();
         assert_eq!(test.len(), reference.len());
         for (x, y) in test.iter().zip(reference.iter()) {
             assert_eq!(x, &U64::from(*y));
@@ -351,42 +351,42 @@ mod tests {
     #[test]
     #[should_panic(expected = "The requested bit length (65) is larger than the precision of `start`")]
     fn sieve_too_many_bits() {
-        let _sieve = Sieve::new(U64::ONE, NonZeroU32::new(65).unwrap(), false);
+        let _sieve = Sieve::new(U64::ONE, NonZero::new(65).unwrap(), false);
     }
 
     #[test]
     fn random_below_max_length() {
         for _ in 0..10 {
-            let r = random_odd_integer::<U64>(&mut OsRng, NonZeroU32::new(50).unwrap()).get();
+            let r = random_odd_integer::<U64>(&mut OsRng, NonZero::new(50).unwrap()).get();
             assert_eq!(r.bits(), 50);
         }
     }
 
     #[test]
     #[should_panic(expected = "try_random_bits() failed: BitLengthTooLarge { bit_length: 65, bits_precision: 64 }")]
     fn random_odd_uint_too_many_bits() {
-        let _p = random_odd_integer::<U64>(&mut OsRng, NonZeroU32::new(65).unwrap());
+        let _p = random_odd_integer::<U64>(&mut OsRng, NonZero::new(65).unwrap());
     }
 
     #[test]
     fn sieve_derived_traits() {
-        let s = Sieve::new(U64::ONE, NonZeroU32::new(10).unwrap(), false);
+        let s = Sieve::new(U64::ONE, NonZero::new(10).unwrap(), false);
         // Debug
         assert!(format!("{s:?}").starts_with("Sieve"));
         // Clone
         assert_eq!(s.clone(), s);
 
         // PartialEq
-        let s2 = Sieve::new(U64::ONE, NonZeroU32::new(10).unwrap(), false);
+        let s2 = Sieve::new(U64::ONE, NonZero::new(10).unwrap(), false);
         assert_eq!(s, s2);
-        let s3 = Sieve::new(U64::ONE, NonZeroU32::new(12).unwrap(), false);
+        let s3 = Sieve::new(U64::ONE, NonZero::new(12).unwrap(), false);
         assert_ne!(s, s3);
     }
 
     #[test]
     fn sieve_with_max_start() {
         let start = U64::MAX;
-        let mut sieve = Sieve::new(start, NonZeroU32::new(U64::BITS).unwrap(), false);
+        let mut sieve = Sieve::new(start, NonZero::new(U64::BITS).unwrap(), false);
         assert!(sieve.next().is_none());
     }
 }