upgrade rand,rand_distr deps

Cargo.toml

@@ -11,6 +11,6 @@ resolver = "2"
 
 [workspace.dependencies]
 anyhow = "1.0.56"
-rand = "0.8.5"
+rand = "0.9.2"
-rand_distr = "0.4.3"
+rand_distr = "0.5.1"
 itertools = "0.14.0"

README.md

@@ -26,7 +26,7 @@ let param = Param {
     t: 128, // plaintext modulus
 };
 
-let mut rng = rand::thread_rng();
+let mut rng = rand::rng();
 let msg_dist = Uniform::new(0_u64, param.t);
 
 let (sk, pk) = TLWE::new_key(&mut rng, &param)?;

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 mut rng = rand::rng();
-        let uniform_distr = Uniform::new(0_f64, Q as f64);
+        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;
+        use rand::distr::Uniform;
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
-        let dist = Uniform::new(0_f64, q as f64);
+        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 mut rng = rand::rng();
-        let dist = Uniform::new(0_f64, Q as f64);
+        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 dist = Uniform::new(0_u64, q).unwrap();
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
 
         for _ in 0..1000 {
             let x = Zq::from_u64(q, dist.sample(&mut rng));

bfv/src/lib.rs

@@ -121,7 +121,7 @@ impl BFV {
         // WIP: review probabilities
 
         // let Xi_key = Uniform::new(-1_f64, 1_f64);
-        let Xi_key = Uniform::new(0_u64, 2_u64);
+        let Xi_key = Uniform::new(0_u64, 2_u64)?;
         let Xi_err = Normal::new(0_f64, ERR_SIGMA)?;
 
         // secret key
@@ -132,7 +132,7 @@ impl BFV {
         s.compute_evals();
 
         // pk = (-a * s + e, a)
-        let a = Rq::rand_u64(&mut rng, Uniform::new(0_u64, param.ring.q), &param.ring)?;
+        let a = Rq::rand_u64(&mut rng, Uniform::new(0_u64, param.ring.q)?, &param.ring)?;
         let e = Rq::rand_f64(&mut rng, Xi_err, &param.ring)?;
         let pk: PublicKey = PublicKey(&(&(-a.clone()) * &s) + &e, a.clone()); // TODO rm clones
         Ok((SecretKey(s), pk))
@@ -145,7 +145,7 @@ impl BFV {
         debug_assert_eq!(param.t, m.param.q);
         debug_assert_eq!(param.ring.n, m.param.n);
 
-        let Xi_key = Uniform::new(-1_f64, 1_f64);
+        let Xi_key = Uniform::new(-1_f64, 1_f64)?;
         // let Xi_key = Uniform::new(0_u64, 2_u64);
         let Xi_err = Normal::new(0_f64, ERR_SIGMA)?;
 
@@ -210,7 +210,7 @@ impl BFV {
         let Xi_err = Normal::new(0_f64, ERR_SIGMA)?;
         // let Xi_err = Normal::new(0_f64, 0.0)?;
         let s = s.0.remodule(pq);
-        let a = Rq::rand_u64(&mut rng, Uniform::new(0_u64, pq), &rlk_param)?;
+        let a = Rq::rand_u64(&mut rng, Uniform::new(0_u64, pq)?, &rlk_param)?;
         let e = Rq::rand_f64(&mut rng, Xi_err, &rlk_param)?;
 
         // let rlk: RLK<PQ, N> = RLK::<PQ, N>(-(&a * &s + e) + (s * s) * P, a.clone());
@@ -274,7 +274,7 @@ impl BFV {
 #[cfg(test)]
 mod tests {
     use anyhow::Result;
-    use rand::distributions::Uniform;
+    use rand::distr::Uniform;
 
     use super::*;
 
@@ -289,12 +289,12 @@ mod tests {
             p: 0,  // unused in this test
         };
 
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
 
         for _ in 0..100 {
             let (sk, pk) = BFV::new_key(&mut rng, &param)?;
 
-            let msg_dist = Uniform::new(0_u64, param.t);
+            let msg_dist = Uniform::new(0_u64, param.t)?;
             let m = Rq::rand_u64(&mut rng, msg_dist, &param.pt())?;
 
             let c = BFV::encrypt(&mut rng, &param, &pk, &m)?;
@@ -317,12 +317,12 @@ mod tests {
             p: 0,  // unused in this test
         };
 
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
 
         for _ in 0..100 {
             let (sk, pk) = BFV::new_key(&mut rng, &param)?;
 
-            let msg_dist = Uniform::new(0_u64, param.t);
+            let msg_dist = Uniform::new(0_u64, param.t)?;
             let m1 = Rq::rand_u64(&mut rng, msg_dist, &param.pt())?;
             let m2 = Rq::rand_u64(&mut rng, msg_dist, &param.pt())?;
 
@@ -348,11 +348,11 @@ mod tests {
             p: q * q,
         };
 
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
 
         let (sk, pk) = BFV::new_key(&mut rng, &param)?;
 
-        let msg_dist = Uniform::new(0_u64, param.t);
+        let msg_dist = Uniform::new(0_u64, param.t)?;
         let m1 = Rq::rand_u64(&mut rng, msg_dist, &param.pt())?;
         let m2_const = Rq::rand_u64(&mut rng, msg_dist, &param.pt())?;
         let c1 = BFV::encrypt(&mut rng, &param, &pk, &m1)?;
@@ -389,7 +389,7 @@ mod tests {
             const PQ: u64 = P * Q;
             const DELTA: u64 = Q / T; // floor
 
-            let mut rng = rand::thread_rng();
+            let mut rng = rand::rng();
 
             let Xi_key = Uniform::new(0_f64, 1_f64);
             let Xi_err = Normal::new(0_f64, ERR_SIGMA)?;
@@ -509,9 +509,9 @@ mod tests {
             t: 2, // plaintext modulus
             p: q * q,
         };
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
 
-        let msg_dist = Uniform::new(0_u64, param.t);
+        let msg_dist = Uniform::new(0_u64, param.t)?;
         for _ in 0..1_000 {
             let m1 = Rq::rand_u64(&mut rng, msg_dist, &param.pt())?;
             let m2 = Rq::rand_u64(&mut rng, msg_dist, &param.pt())?;
@@ -563,8 +563,8 @@ mod tests {
             p: q * q,
         };
 
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
-        let msg_dist = Uniform::new(0_u64, param.t);
+        let msg_dist = Uniform::new(0_u64, param.t)?;
 
         for _ in 0..1_000 {
             let m1 = Rq::rand_u64(&mut rng, msg_dist, &param.pt())?;

ckks/src/encoder.rs

@@ -159,11 +159,11 @@ mod tests {
         let n: usize = 32;
 
         let T = 128; // WIP
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
 
         for _ in 0..100 {
             let z: Vec<C<f64>> = std::iter::repeat_with(|| {
-                C::<f64>::new(rng.gen_range(0..T) as f64, rng.gen_range(0..T) as f64)
+                C::<f64>::new(rng.random_range(0..T) as f64, rng.random_range(0..T) as f64)
             })
             .take(N / 2)
             .collect();

ckks/src/lib.rs

@@ -46,7 +46,7 @@ impl CKKS {
     pub fn new_key(&self, mut rng: impl Rng) -> Result<(SecretKey, PublicKey)> {
         let param = &self.param;
 
-        let Xi_key = Uniform::new(-1_f64, 1_f64);
+        let Xi_key = Uniform::new(-1_f64, 1_f64)?;
         let Xi_err = Normal::new(0_f64, ERR_SIGMA)?;
 
         let e = Rq::rand_f64(&mut rng, Xi_err, &param.ring)?;
@@ -70,7 +70,7 @@ impl CKKS {
         m: &R,
     ) -> Result<(Rq, Rq)> {
         let param = self.param;
-        let Xi_key = Uniform::new(-1_f64, 1_f64);
+        let Xi_key = Uniform::new(-1_f64, 1_f64)?;
         let Xi_err = Normal::new(0_f64, ERR_SIGMA)?;
 
         let e_0 = Rq::rand_f64(&mut rng, Xi_err, &param.ring)?;
@@ -134,7 +134,7 @@ mod tests {
         let scale_factor_u64 = 512_u64; // delta
         let scale_factor = C::<f64>::new(scale_factor_u64 as f64, 0.0); // delta
 
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
 
         for _ in 0..1000 {
             let ckks = CKKS::new(&param, scale_factor);
@@ -142,7 +142,7 @@ mod tests {
             let (sk, pk) = ckks.new_key(&mut rng)?;
 
             let m_raw: R =
-                Rq::rand_f64(&mut rng, Uniform::new(0_f64, t as f64), &param.ring)?.to_r();
+                Rq::rand_f64(&mut rng, Uniform::new(0_f64, t as f64)?, &param.ring)?.to_r();
             let m = &m_raw * &scale_factor_u64;
 
             let ct = ckks.encrypt(&mut rng, &pk, &m)?;
@@ -171,7 +171,7 @@ mod tests {
         };
         let scale_factor = C::<f64>::new(512.0, 0.0); // delta
 
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
 
         for _ in 0..1000 {
             let ckks = CKKS::new(&param, scale_factor);
@@ -220,7 +220,7 @@ mod tests {
         };
         let scale_factor = C::<f64>::new(1024.0, 0.0); // delta
 
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
 
         for _ in 0..1000 {
             let ckks = CKKS::new(&param, scale_factor);
@@ -267,7 +267,7 @@ mod tests {
         };
         let scale_factor = C::<f64>::new(1024.0, 0.0); // delta
 
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
 
         for _ in 0..1000 {
             let ckks = CKKS::new(&param, scale_factor);

gfhe/src/glev.rs

@@ -82,7 +82,7 @@ impl<R: Ring> Mul<Vec<R>> for GLev<R> {
 #[cfg(test)]
 mod tests {
     use anyhow::Result;
-    use rand::distributions::Uniform;
+    use rand::distr::Uniform;
 
     use super::*;
     use arith::{RingParam, Rq};
@@ -103,8 +103,8 @@ mod tests {
         let beta: u32 = 2;
         let l: u32 = 16;
 
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
-        let msg_dist = Uniform::new(0_u64, param.t);
+        let msg_dist = Uniform::new(0_u64, param.t)?;
 
         for _ in 0..200 {
             let (sk, pk) = GLWE::<Rq>::new_key(&mut rng, &param)?;

gfhe/src/glwe.rs

@@ -74,13 +74,13 @@ impl<R: Ring> GLWE<R> {
     }
 
     pub fn new_key(mut rng: impl Rng, param: &Param) -> Result<(SecretKey<R>, PublicKey<R>)> {
-        let Xi_key = Uniform::new(0_f64, 2_f64);
+        let Xi_key = Uniform::new(0_f64, 2_f64)?;
         let Xi_err = Normal::new(0_f64, param.err_sigma)?;
 
         let s: TR<R> = TR::rand(&mut rng, Xi_key, param.k, &param.ring);
         let a: TR<R> = TR::rand(
             &mut rng,
-            Uniform::new(0_f64, param.ring.q as f64),
+            Uniform::new(0_f64, param.ring.q as f64)?,
             param.k,
             &param.ring,
         );
@@ -94,7 +94,7 @@ impl<R: Ring> GLWE<R> {
 
         let a: TR<R> = TR::rand(
             &mut rng,
-            Uniform::new(0_f64, param.ring.q as f64),
+            Uniform::new(0_f64, param.ring.q as f64)?,
             param.k,
             &param.ring,
         );
@@ -143,7 +143,7 @@ impl<R: Ring> GLWE<R> {
         sk: &SecretKey<R>,
         m: &R, // already scaled
     ) -> Result<Self> {
-        let Xi_key = Uniform::new(0_f64, 2_f64);
+        let Xi_key = Uniform::new(0_f64, 2_f64)?;
         let Xi_err = Normal::new(0_f64, param.err_sigma)?;
 
         let a: TR<R> = TR::rand(&mut rng, Xi_key, param.k, &param.ring);
@@ -158,7 +158,7 @@ impl<R: Ring> GLWE<R> {
         pk: &PublicKey<R>,
         m: &R, // already scaled
     ) -> Result<Self> {
-        let Xi_key = Uniform::new(0_f64, 2_f64);
+        let Xi_key = Uniform::new(0_f64, 2_f64)?;
         let Xi_err = Normal::new(0_f64, param.err_sigma)?;
 
         let u: R = R::rand(&mut rng, Xi_key, &param.ring);
@@ -319,7 +319,7 @@ impl<R: Ring> Mul<R> for GLWE<R> {
 #[cfg(test)]
 mod tests {
     use anyhow::Result;
-    use rand::distributions::Uniform;
+    use rand::distr::Uniform;
 
     use super::*;
 
@@ -336,8 +336,8 @@ mod tests {
         };
         type S = GLWE<Rq>;
 
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
-        let msg_dist = Uniform::new(0_u64, param.t);
+        let msg_dist = Uniform::new(0_u64, param.t)?;
 
         for _ in 0..200 {
             let (sk, pk) = S::new_key(&mut rng, &param)?;
@@ -389,8 +389,8 @@ mod tests {
         };
         type S = GLWE<Tn>;
 
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
-        let msg_dist = Uniform::new(0_f64, param.t as f64);
+        let msg_dist = Uniform::new(0_f64, param.t as f64)?;
 
         for _ in 0..200 {
             let (sk, pk) = S::new_key(&mut rng, &param)?;
@@ -428,8 +428,8 @@ mod tests {
         };
         type S = GLWE<Rq>;
 
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
-        let msg_dist = Uniform::new(0_u64, param.t);
+        let msg_dist = Uniform::new(0_u64, param.t)?;
 
         for _ in 0..200 {
             let (sk, pk) = S::new_key(&mut rng, &param)?;
@@ -466,8 +466,8 @@ mod tests {
         };
         type S = GLWE<Rq>;
 
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
-        let msg_dist = Uniform::new(0_u64, param.t);
+        let msg_dist = Uniform::new(0_u64, param.t)?;
 
         for _ in 0..200 {
             let (sk, pk) = S::new_key(&mut rng, &param)?;
@@ -503,8 +503,8 @@ mod tests {
         };
         type S = GLWE<Rq>;
 
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
-        let msg_dist = Uniform::new(0_u64, param.t);
+        let msg_dist = Uniform::new(0_u64, param.t)?;
 
         for _ in 0..200 {
             let (sk, pk) = S::new_key(&mut rng, &param)?;
@@ -541,8 +541,8 @@ mod tests {
         // note: wip, Q and P chosen so that P/Q is an integer
         type S = GLWE<Rq>;
 
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
-        let msg_dist = Uniform::new(0_u64, param.t);
+        let msg_dist = Uniform::new(0_u64, param.t)?;
 
         for _ in 0..200 {
             let (sk, pk) = S::new_key(&mut rng, &param)?;
@@ -593,14 +593,14 @@ mod tests {
         let beta: u32 = 2;
         let l: u32 = 16;
 
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
 
         let (sk, pk) = S::new_key(&mut rng, &param)?;
         let (sk2, _) = S::new_key(&mut rng, &param)?;
         // ksk to switch from sk to sk2
         let ksk = S::new_ksk(&mut rng, &param, beta, l, &sk, &sk2)?;
 
-        let msg_dist = Uniform::new(0_u64, param.t);
+        let msg_dist = Uniform::new(0_u64, param.t)?;
         let m = Rq::rand_u64(&mut rng, msg_dist, &param.pt())?;
         let p = S::encode(&param, &m); // plaintext
                                        //

tfhe/src/tggsw.rs

@@ -151,7 +151,7 @@ impl Mul<Vec<Tn>> for TGLev {
 #[cfg(test)]
 mod tests {
     use anyhow::Result;
-    use rand::distributions::Uniform;
+    use rand::distr::Uniform;
 
     use super::*;
     #[test]
@@ -166,8 +166,8 @@ mod tests {
         let beta: u32 = 2;
         let l: u32 = 64;
 
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
-        let msg_dist = Uniform::new(0_u64, param.t);
+        let msg_dist = Uniform::new(0_u64, param.t)?;
 
         for _ in 0..50 {
             let (sk, _) = TGLWE::new_key(&mut rng, &param)?;

tfhe/src/tglwe.rs

@@ -196,7 +196,7 @@ impl Mul<Tn> for TGLWE {
 #[cfg(test)]
 mod tests {
     use anyhow::Result;
-    use rand::distributions::Uniform;
+    use rand::distr::Uniform;
 
     use super::*;
 
@@ -209,8 +209,8 @@ mod tests {
             t: 128, // plaintext modulus
         };
 
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
-        let msg_dist = Uniform::new(0_u64, param.t);
+        let msg_dist = Uniform::new(0_u64, param.t)?;
 
         for _ in 0..200 {
             let (sk, pk) = TGLWE::new_key(&mut rng, &param)?;
@@ -244,8 +244,8 @@ mod tests {
             t: 128, // plaintext modulus
         };
 
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
-        let msg_dist = Uniform::new(0_u64, param.t);
+        let msg_dist = Uniform::new(0_u64, param.t)?;
 
         for _ in 0..200 {
             let (sk, pk) = TGLWE::new_key(&mut rng, &param)?;
@@ -278,8 +278,8 @@ mod tests {
             t: 128, // plaintext modulus
         };
 
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
-        let msg_dist = Uniform::new(0_u64, param.t);
+        let msg_dist = Uniform::new(0_u64, param.t)?;
 
         for _ in 0..200 {
             let (sk, pk) = TGLWE::new_key(&mut rng, &param)?;
@@ -311,8 +311,8 @@ mod tests {
             t: 128, // plaintext modulus
         };
 
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
-        let msg_dist = Uniform::new(0_u64, param.t);
+        let msg_dist = Uniform::new(0_u64, param.t)?;
 
         for _ in 0..200 {
             let (sk, pk) = TGLWE::new_key(&mut rng, &param)?;
@@ -343,8 +343,8 @@ mod tests {
             t: 128, // plaintext modulus
         };
 
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
-        let msg_dist = Uniform::new(0_u64, param.t);
+        let msg_dist = Uniform::new(0_u64, param.t)?;
 
         for _ in 0..20 {
             let (sk, pk) = TGLWE::new_key(&mut rng, &param)?;

tfhe/src/tgsw.rs

@@ -66,7 +66,7 @@ impl Mul<TLWE> for TGSW {
 #[cfg(test)]
 mod tests {
     use anyhow::Result;
-    use rand::distributions::Uniform;
+    use rand::distr::Uniform;
 
     use super::*;
     use arith::{RingParam, Rq};
@@ -82,8 +82,8 @@ mod tests {
         let beta: u32 = 2;
         let l: u32 = 16;
 
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
-        let msg_dist = Uniform::new(0_u64, param.t);
+        let msg_dist = Uniform::new(0_u64, param.t)?;
 
         for _ in 0..50 {
             let (sk, _) = TLWE::new_key(&mut rng, &param)?;
@@ -112,8 +112,8 @@ mod tests {
         let beta: u32 = 2;
         let l: u32 = 64;
 
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
-        let msg_dist = Uniform::new(0_u64, param.t);
+        let msg_dist = Uniform::new(0_u64, param.t)?;
 
         for _ in 0..50 {
             let (sk, _) = TLWE::new_key(&mut rng, &param)?;
@@ -152,8 +152,8 @@ mod tests {
         let beta: u32 = 2;
         let l: u32 = 64;
 
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
-        let msg_dist = Uniform::new(0_u64, param.t);
+        let msg_dist = Uniform::new(0_u64, param.t)?;
 
         for _ in 0..50 {
             let (sk, _) = TLWE::new_key(&mut rng, &param)?;

tfhe/src/tlev.rs

@@ -107,7 +107,7 @@ impl Mul<Vec<T64>> for TLev {
 #[cfg(test)]
 mod tests {
     use anyhow::Result;
-    use rand::distributions::Uniform;
+    use rand::distr::Uniform;
 
     use super::*;
 
@@ -123,8 +123,8 @@ mod tests {
         let beta: u32 = 2;
         let l: u32 = 16;
 
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
-        let msg_dist = Uniform::new(0_u64, param.t);
+        let msg_dist = Uniform::new(0_u64, param.t)?;
 
         for _ in 0..200 {
             let (sk, pk) = TLWE::new_key(&mut rng, &param)?;
@@ -155,8 +155,8 @@ mod tests {
         // let l: u32 = 16;
         let l: u32 = 64;
 
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
-        let msg_dist = Uniform::new(0_u64, param.t);
+        let msg_dist = Uniform::new(0_u64, param.t)?;
 
         for _ in 0..200 {
             let (sk, pk) = TLWE::new_key(&mut rng, &param)?;

tfhe/src/tlwe.rs

@@ -281,7 +281,7 @@ impl Mul<T64> for TLWE {
 #[cfg(test)]
 mod tests {
     use anyhow::Result;
-    use rand::distributions::Uniform;
+    use rand::distr::Uniform;
     use std::time::Instant;
 
     use super::*;
@@ -295,8 +295,8 @@ mod tests {
             t: 128, // plaintext modulus
         };
 
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
-        let msg_dist = Uniform::new(0_u64, param.t);
+        let msg_dist = Uniform::new(0_u64, param.t)?;
 
         for _ in 0..200 {
             let (sk, pk) = TLWE::new_key(&mut rng, &param)?;
@@ -330,8 +330,8 @@ mod tests {
             t: 128, // plaintext modulus
         };
 
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
-        let msg_dist = Uniform::new(0_u64, param.t);
+        let msg_dist = Uniform::new(0_u64, param.t)?;
 
         for _ in 0..200 {
             let (sk, pk) = TLWE::new_key(&mut rng, &param)?;
@@ -364,8 +364,8 @@ mod tests {
             t: 128, // plaintext modulus
         };
 
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
-        let msg_dist = Uniform::new(0_u64, param.t);
+        let msg_dist = Uniform::new(0_u64, param.t)?;
 
         for _ in 0..200 {
             let (sk, pk) = TLWE::new_key(&mut rng, &param)?;
@@ -397,8 +397,8 @@ mod tests {
             t: 128, // plaintext modulus
         };
 
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
-        let msg_dist = Uniform::new(0_u64, param.t);
+        let msg_dist = Uniform::new(0_u64, param.t)?;
 
         for _ in 0..200 {
             let (sk, pk) = TLWE::new_key(&mut rng, &param)?;
@@ -432,14 +432,14 @@ mod tests {
         let beta: u32 = 2;
         let l: u32 = 64;
 
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
 
         let (sk, pk) = TLWE::new_key(&mut rng, &param)?;
         let (sk2, _) = TLWE::new_key(&mut rng, &param)?;
         // ksk to switch from sk to sk2
         let ksk = TLWE::new_ksk(&mut rng, &param, beta, l, &sk, &sk2)?;
 
-        let msg_dist = Uniform::new(0_u64, param.t);
+        let msg_dist = Uniform::new(0_u64, param.t)?;
         let m = Rq::rand_u64(&mut rng, msg_dist, &param.pt())?;
         let p = TLWE::encode(&param, &m); // plaintext
 
@@ -473,7 +473,7 @@ mod tests {
             k: 1,
             t: 128, // plaintext modulus
         };
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
 
         let start = Instant::now();
         let table: TGLWE = compute_lookup_table(&param);
@@ -486,7 +486,7 @@ mod tests {
         let btk = BootstrappingKey::from_sk(&mut rng, &param, &sk)?;
         println!("btk took: {:?}", start.elapsed());
 
-        let msg_dist = Uniform::new(0_u64, param.t);
+        let msg_dist = Uniform::new(0_u64, param.t)?;
         let m = Rq::rand_u64(&mut rng, msg_dist, &param.lwe().pt())?; // q=t, n=1
         let p = TLWE::encode(&param.lwe(), &m); // plaintext