upgrade rand,rand_distr deps

arith/src/naive_ntt.rs

@@ -139,8 +139,8 @@ mod tests {
 
         let v_inv = NTT::<Q, N>::invert_vandermonde(&v);
 
-        let mut rng = rand::thread_rng();
-        let uniform_distr = Uniform::new(0_f64, Q as f64);
+        let mut rng = rand::rng();
+        let uniform_distr = Uniform::new(0_f64, Q as f64)?;
         let a = Rq::<Q, N>::rand_f64(&mut rng, uniform_distr)?;
         // let a = PR::<Q, N>::new_from_u64(vec![36, 21, 9, 19]);
 
@@ -185,7 +185,7 @@ mod tests {
         // let primitive = NTT::<Q, N>::get_primitive_root_of_unity((2*N) as u64)?;
         let ntt = NTT::<Q, N>::new()?;
 
-        let rng = rand::thread_rng();
+        let rng = rand::rng();
         let a = Rq::<Q, { 2 * N }>::rand_f64(rng, Uniform::new(0_f64, (Q - 1) as f64))?;
         let a = a.coeffs;
         dbg!(&a);

arith/src/ntt.rs

@@ -220,9 +220,9 @@ mod tests {
         let n: usize = 512;
         let param = RingParam { q, n };
 
-        use rand::distributions::Uniform;
-        let mut rng = rand::thread_rng();
-        let dist = Uniform::new(0_f64, q as f64);
+        use rand::distr::Uniform;
+        let mut rng = rand::rng();
+        let dist = Uniform::new(0_f64, q as f64)?;
 
         for _ in 0..1000 {
             let a: Rq = Rq::rand(&mut rng, dist, &param);

arith/src/ntt_fixedsize.rs

@@ -173,8 +173,8 @@ mod tests {
 
         use rand::distributions::Distribution;
         use rand::distributions::Uniform;
-        let mut rng = rand::thread_rng();
-        let dist = Uniform::new(0_f64, Q as f64);
+        let mut rng = rand::rng();
+        let dist = Uniform::new(0_f64, Q as f64)?;
 
         for _ in 0..100 {
             let a: [Zq<Q>; N] = array::from_fn(|_| Zq::from_f64(dist.sample(&mut rng)));

arith/src/ring.rs

@@ -1,4 +1,4 @@
-use rand::{distributions::Distribution, Rng};
+use rand::{distr::Distribution, Rng};
 use std::fmt::Debug;
 use std::iter::Sum;
 use std::ops::{Add, AddAssign, Mul, Neg, Sub, SubAssign};

arith/src/ring_n.rs

@@ -2,7 +2,7 @@
 //!
 
 use itertools::zip_eq;
-use rand::{distributions::Distribution, Rng};
+use rand::{distr::Distribution, Rng};
 use std::fmt;
 use std::iter::Sum;
 use std::ops::{Add, AddAssign, Mul, Neg, Sub, SubAssign};

arith/src/ring_nq.rs

@@ -3,7 +3,7 @@
 
 use anyhow::{anyhow, Result};
 use itertools::zip_eq;
-use rand::{distributions::Distribution, Rng};
+use rand::{distr::Distribution, Rng};
 use std::fmt;
 use std::iter::Sum;
 use std::ops::{Add, AddAssign, Mul, Neg, Sub, SubAssign};

arith/src/ring_torus.rs

@@ -8,7 +8,7 @@
 //! the 𝕋_<N,q> implementation with the other objects from the code.
 
 use itertools::zip_eq;
-use rand::{distributions::Distribution, Rng};
+use rand::{distr::Distribution, Rng};
 use std::iter::Sum;
 use std::ops::{Add, AddAssign, Mul, Neg, Sub, SubAssign};
 

arith/src/torus.rs

@@ -1,4 +1,4 @@
-use rand::{distributions::Distribution, Rng};
+use rand::{distr::Distribution, Rng};
 use std::{
     iter::Sum,
     ops::{Add, AddAssign, Mul, MulAssign, Neg, Sub, SubAssign},
@@ -155,7 +155,7 @@ impl Mul<&u64> for &T64 {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use rand::distributions::Standard;
+    use rand::distr::StandardUniform;
 
     fn recompose(d: Vec<T64>) -> T64 {
         T64(d.iter().fold(0u64, |acc, &b| (acc << 1) | b.0))
@@ -181,9 +181,9 @@ mod tests {
             q: u64::MAX, // WIP
             n: 1,
         };
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
         for _ in 0..1000 {
-            let x = T64::rand(&mut rng, Standard, &param);
+            let x = T64::rand(&mut rng, StandardUniform, &param);
             let d = x.decompose(beta, l);
             assert_eq!(recompose(d), x);
         }

arith/src/tuple_ring.rs

@@ -2,7 +2,7 @@
 //! operations, which are performed element-wise.
 
 use itertools::zip_eq;
-use rand::{distributions::Distribution, Rng};
+use rand::{distr::Distribution, Rng};
 use std::ops::{Add, Mul, Neg, Sub};
 
 use crate::{Ring, RingParam};

arith/src/zq.rs

@@ -1,4 +1,4 @@
-use rand::{distributions::Distribution, Rng};
+use rand::{distr::Distribution, Rng};
 use std::fmt;
 use std::ops::{Add, AddAssign, Div, Mul, Neg, Sub, SubAssign};
 
@@ -350,7 +350,7 @@ impl fmt::Debug for Zq {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use rand::distributions::Uniform;
+    use rand::distr::Uniform;
 
     #[test]
     fn exp() {
@@ -393,8 +393,8 @@ mod tests {
         let beta: u32 = 5;
         let l: u32 = 3;
 
-        let dist = Uniform::new(0_u64, q);
-        let mut rng = rand::thread_rng();
+        let dist = Uniform::new(0_u64, q).unwrap();
+        let mut rng = rand::rng();
 
         for _ in 0..1000 {
             let x = Zq::from_u64(q, dist.sample(&mut rng));