UPD: Update rand and rand_distr

Axect · Axect · commit e9f472191026 · 2025-04-11T15:41:50.000+09:00
diff --git a/src/fuga/mod.rs b/src/fuga/mod.rs
@@ -205,6 +205,7 @@ pub use crate::util::plot::*;
 
 pub use anyhow;
 pub use paste;
+pub use rand::prelude::*;
 
 // =============================================================================
 // Enums
diff --git a/src/macros/matlab_macro.rs b/src/macros/matlab_macro.rs
@@ -1,6 +1,3 @@
-extern crate rand;
-pub use self::rand::prelude::*;
-
 /// MATLAB like zeros - zero matrix
 ///
 /// # Examples
@@ -45,18 +42,18 @@ macro_rules! zeros {
 #[macro_export]
 macro_rules! rand {
     () => {{
-        let mut rng = thread_rng();
-        rng.gen_range(0f64..=1f64)
+        let mut rng = rand::rng();
+        rng.random_range(0f64..=1f64)
     }};
 
     ( $m:expr, $n:expr ) => {{
         let r = $m;
         let c = $n;
-        let mut rng = thread_rng();
+        let mut rng = rand::rng();
         let mut m = matrix(vec![0f64; r * c], r, c, Row);
         for i in 0..r {
             for j in 0..c {
-                m[(i, j)] = rng.gen_range(0f64..=1f64);
+                m[(i, j)] = rng.random_range(0f64..=1f64);
             }
         }
         m
diff --git a/src/macros/r_macro.rs b/src/macros/r_macro.rs
@@ -16,9 +16,6 @@
 //! * `pt`
 //! * `lm`
 
-extern crate rand;
-pub use self::rand::prelude::*;
-
 /// R like concatenate (Type: Vec\<f64\>)
 ///
 /// # Examples
@@ -278,10 +275,10 @@ macro_rules! runif {
         let n: usize = $x0;
         let mut v = vec![0f64; n];
 
-        let mut rng = thread_rng();
+        let mut rng = rand::rng();
 
         for i in 0..n {
-            v[i] = rng.gen_range($start as f64..=$end as f64);
+            v[i] = rng.random_range($start as f64..=$end as f64);
         }
         v
     }};
diff --git a/src/prelude/mod.rs b/src/prelude/mod.rs
@@ -229,3 +229,4 @@ pub use crate::util::plot::*;
 
 pub use anyhow;
 pub use paste;
+pub use rand::prelude::*;
diff --git a/src/statistics/dist.rs b/src/statistics/dist.rs
@@ -27,7 +27,8 @@
 //!     * `sample_with_rng`: Extract samples with specific rng
 //!     * `pdf` : Calculate pdf value at specific point
 //!     ```no_run
-//!     use rand::{Rng, distributions::uniform::SampleUniform};
+//!     use rand::Rng;
+//!     use rand_distr::uniform::SampleUniform;
 //!     pub trait RNG {
 //!         /// Extract samples of distributions
 //!         fn sample(&self, n: usize) -> Vec<f64>;
@@ -228,9 +229,9 @@
 
 extern crate rand;
 extern crate rand_distr;
-use rand_distr::WeightedAliasIndex;
+use rand_distr::weighted::WeightedAliasIndex;
 
-use self::rand::distributions::uniform::SampleUniform;
+use self::rand_distr::uniform::SampleUniform;
 use self::rand::prelude::*;
 pub use self::OPDist::*;
 pub use self::TPDist::*;
@@ -521,7 +522,7 @@ impl<T: PartialOrd + SampleUniform + Copy + Into<f64>> ParametricDist for Weight
 pub trait RNG {
     /// Extract samples of distributions
     fn sample(&self, n: usize) -> Vec<f64> {
-        let mut rng = thread_rng();
+        let mut rng = rand::rng();
         self.sample_with_rng(&mut rng, n)
     }
 
@@ -554,7 +555,7 @@ impl<T: PartialOrd + SampleUniform + Copy + Into<f64>> RNG for OPDist<T> {
                 let mut v = vec![0f64; n];
 
                 for i in 0..n {
-                    let uniform = rng.gen_range(0f64..=1f64);
+                    let uniform = rng.random_range(0f64..=1f64);
                     if uniform <= (*prob).into() {
                         v[i] = 1f64;
                     } else {
@@ -628,7 +629,7 @@ impl<T: PartialOrd + SampleUniform + Copy + Into<f64>> RNG for TPDist<T> {
                 let mut v = vec![0f64; n];
 
                 for i in 0..n {
-                    v[i] = rng.gen_range(*start..=*end).into();
+                    v[i] = rng.random_range(*start..=*end).into();
                 }
                 v
             }
@@ -643,7 +644,7 @@ impl<T: PartialOrd + SampleUniform + Copy + Into<f64>> RNG for TPDist<T> {
                 normal.sample_iter(rng).take(n).collect()
             }
             //            Normal(m, s) => {
-            //                let mut rng = thread_rng();
+            //                let mut rng = rand::rng();
             //                let mut v = vec![0f64; n];
             //
             //                for i in 0..n {
@@ -656,8 +657,8 @@ impl<T: PartialOrd + SampleUniform + Copy + Into<f64>> RNG for TPDist<T> {
                 beta.sample_iter(rng).take(n).collect()
             }
             //            Beta(a, b) => {
-            //                let mut rng1 = thread_rng();
-            //                let mut rng2 = thread_rng();
+            //                let mut rng1 = rand::rng();
+            //                let mut rng2 = rand::rng();
             //                let mut v = vec![0f64; n];
             //
             //                let a_f64 = (*a).into();
@@ -670,8 +671,8 @@ impl<T: PartialOrd + SampleUniform + Copy + Into<f64>> RNG for TPDist<T> {
             //                let mut iter_num = 0usize;
             //
             //                while iter_num < n {
-            //                    let u1 = rng1.gen_range(0f64, 1f64);
-            //                    let u2 = rng2.gen_range(0f64, 1f64);
+            //                    let u1 = rng1.random_range(0f64, 1f64);
+            //                    let u2 = rng2.random_range(0f64, 1f64);
             //
             //                    if u2 <= 1f64 / c * self.pdf(u1) {
             //                        v[iter_num] = u1;
@@ -692,14 +693,14 @@ impl<T: PartialOrd + SampleUniform + Copy + Into<f64>> RNG for TPDist<T> {
               //                let d = a_f64 - 1f64 / 3f64;
               //                let c = 1f64 / (9f64 * d).sqrt();
               //
-              //                let mut rng1 = thread_rng();
-              //                let mut rng2 = thread_rng();
+              //                let mut rng1 = rand::rng();
+              //                let mut rng2 = rand::rng();
               //
               //                let mut v = vec![0f64; n];
               //                let mut iter_num = 0usize;
               //
               //                while iter_num < n {
-              //                    let u = rng1.gen_range(0f64, 1f64);
+              //                    let u = rng1.random_range(0f64, 1f64);
               //                    let z = ziggurat(&mut rng2, 1f64);
               //                    let w = (1f64 + c * z).powi(3);
               //
@@ -804,7 +805,7 @@ impl RNG for WeightedUniform<f64> {
         ics.into_iter()
             .map(|idx| {
                 let (l, r) = self.intervals[idx];
-                rng.gen_range(l..=r)
+                rng.random_range(l..=r)
             })
             .collect::<Vec<f64>>()
     }
diff --git a/src/statistics/rand.rs b/src/statistics/rand.rs
@@ -8,9 +8,9 @@
 //!     use rand::prelude::*;
 //!
 //!     fn main() {
-//!         let mut rng = thread_rng();
+//!         let mut rng = rand::rng();
 //!
-//!         let a = rng.gen_range(0f64..=1f64); // Generate random f64 number ranges from 0 to 1
+//!         let a = rng.random_range(0f64..=1f64); // Generate random f64 number ranges from 0 to 1
 //!     }
 //!     ```
 //!
@@ -20,9 +20,8 @@
 //!
 //!
 
-extern crate rand;
-use self::rand::distributions::uniform::SampleUniform;
-use self::rand::prelude::*;
+use rand_distr::uniform::SampleUniform;
+use rand::prelude::*;
 
 use crate::statistics::dist::{WeightedUniform, RNG};
 #[allow(unused_imports)]
@@ -66,15 +65,15 @@ pub fn stdrng_from_seed(seed: u64) -> StdRng {
 /// ```
 /// use peroxide::fuga::*;
 ///
-/// let mut rng = thread_rng();
+/// let mut rng = rand::rng();
 /// println!("{}", rand_num(&mut rng, 1, 7));       // Roll a die
 /// println!("{}", rand_num(&mut rng, 0f64, 1f64)); // Uniform [0,1)
 /// ```
 pub fn rand_num<T>(rng: &mut ThreadRng, start: T, end: T) -> T
 where
     T: PartialOrd + SampleUniform + Copy,
 {
-    rng.gen_range(start..=end)
+    rng.random_range(start..=end)
 }
 
 // =============================================================================
@@ -89,8 +88,8 @@ pub fn marsaglia_polar(rng: &mut ThreadRng, m: f64, s: f64) -> f64 {
     let mut w = 0f64;
 
     while w == 0. || w >= 1. {
-        x1 = 2.0 * rng.gen_range(0f64..=1f64) - 1.0;
-        x2 = 2.0 * rng.gen_range(0f64..=1f64) - 1.0;
+        x1 = 2.0 * rng.random_range(0f64..=1f64) - 1.0;
+        x2 = 2.0 * rng.random_range(0f64..=1f64) - 1.0;
         w = x1 * x1 + x2 * x2;
     }
 
@@ -469,7 +468,7 @@ pub fn prs<F>(f: F, n: usize, (a, b): (f64, f64), m: usize, eps: f64) -> anyhow:
 where
     F: Fn(f64) -> f64 + Copy,
 {
-    let mut rng = thread_rng();
+    let mut rng = rand::rng();
 
     let mut result = vec![0f64; n];
 
@@ -484,7 +483,7 @@ where
             if weight <= 0f64 {
                 continue;
             } else {
-                let y = rng.gen_range(0f64..=weight);
+                let y = rng.random_range(0f64..=weight);
 
                 if y <= f(x) {
                     result[n - left_num] = x;
@@ -553,7 +552,7 @@ where
             if weight <= 0f64 {
                 continue;
             } else {
-                let y = rng.gen_range(0f64..=weight);
+                let y = rng.random_range(0f64..=weight);
 
                 if y <= f(x) {
                     result[n - left_num] = x;
diff --git a/src/util/non_macro.rs b/src/util/non_macro.rs
@@ -323,7 +323,7 @@ where
 ///
 /// Range = from 0 to 1
 pub fn rand(r: usize, c: usize) -> Matrix {
-    let mut rng = thread_rng();
+    let mut rng = rand::rng();
     rand_with_rng(r, c, &mut rng)
 }
 
@@ -333,7 +333,7 @@ pub fn rand(r: usize, c: usize) -> Matrix {
 ///
 /// Range = from 0 to 1
 pub fn rand_with_rng<R: Rng>(r: usize, c: usize, rng: &mut R) -> Matrix {
-    let uniform = Uniform::new_inclusive(0f64, 1f64);
+    let uniform = Uniform::new_inclusive(0f64, 1f64).unwrap();
     rand_with_dist(r, c, rng, uniform)
 }
 
diff --git a/src/util/print.rs b/src/util/print.rs
@@ -10,7 +10,7 @@ use crate::structure::{
     multinomial::Multinomial,
     polynomial::Polynomial,
 };
-use rand::distributions::uniform::SampleUniform;
+use rand_distr::uniform::SampleUniform;
 use std::fmt::{Debug, LowerExp, UpperExp};
 
 pub trait Printable {
diff --git a/src/util/wrapper.rs b/src/util/wrapper.rs
@@ -13,87 +13,87 @@ pub trait SampleRNG {
 impl SampleRNG for Vec<usize> {
     type Item = usize;
     fn sample(&self, n: usize) -> Vec<Self::Item> {
-        let mut rng = thread_rng();
+        let mut rng = rand::rng();
         self.iter().map(|x| *x).choose_multiple(&mut rng, n)
     }
 }
 
 impl SampleRNG for Vec<u32> {
     type Item = u32;
     fn sample(&self, n: usize) -> Vec<Self::Item> {
-        let mut rng = thread_rng();
+        let mut rng = rand::rng();
         self.iter().map(|x| *x).choose_multiple(&mut rng, n)
     }
 }
 
 impl SampleRNG for Vec<u64> {
     type Item = u64;
     fn sample(&self, n: usize) -> Vec<Self::Item> {
-        let mut rng = thread_rng();
+        let mut rng = rand::rng();
         self.iter().map(|x| *x).choose_multiple(&mut rng, n)
     }
 }
 
 impl SampleRNG for Vec<isize> {
     type Item = isize;
     fn sample(&self, n: usize) -> Vec<Self::Item> {
-        let mut rng = thread_rng();
+        let mut rng = rand::rng();
         self.iter().map(|x| *x).choose_multiple(&mut rng, n)
     }
 }
 
 impl SampleRNG for Vec<i32> {
     type Item = i32;
     fn sample(&self, n: usize) -> Vec<Self::Item> {
-        let mut rng = thread_rng();
+        let mut rng = rand::rng();
         self.iter().map(|x| *x).choose_multiple(&mut rng, n)
     }
 }
 
 impl SampleRNG for Vec<i64> {
     type Item = i64;
     fn sample(&self, n: usize) -> Vec<Self::Item> {
-        let mut rng = thread_rng();
+        let mut rng = rand::rng();
         self.iter().map(|x| *x).choose_multiple(&mut rng, n)
     }
 }
 
 impl SampleRNG for Vec<f64> {
     type Item = f64;
     fn sample(&self, n: usize) -> Vec<Self::Item> {
-        let mut rng = thread_rng();
+        let mut rng = rand::rng();
         self.iter().map(|x| *x).choose_multiple(&mut rng, n)
     }
 }
 
 impl SampleRNG for Vec<f32> {
     type Item = f32;
     fn sample(&self, n: usize) -> Vec<Self::Item> {
-        let mut rng = thread_rng();
+        let mut rng = rand::rng();
         self.iter().map(|x| *x).choose_multiple(&mut rng, n)
     }
 }
 
 impl SampleRNG for Vec<char> {
     type Item = char;
     fn sample(&self, n: usize) -> Vec<Self::Item> {
-        let mut rng = thread_rng();
+        let mut rng = rand::rng();
         self.iter().map(|x| *x).choose_multiple(&mut rng, n)
     }
 }
 
 impl<'a> SampleRNG for Vec<&'a str> {
     type Item = &'a str;
     fn sample(&self, n: usize) -> Vec<Self::Item> {
-        let mut rng = thread_rng();
+        let mut rng = rand::rng();
         self.iter().map(|x| *x).choose_multiple(&mut rng, n)
     }
 }
 
 impl SampleRNG for String {
     type Item = char;
     fn sample(&self, n: usize) -> Vec<Self::Item> {
-        let mut rng = thread_rng();
+        let mut rng = rand::rng();
         self.chars().choose_multiple(&mut rng, n)
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -229,3 +229,4 @@ pub use crate::util::plot::*;`
`229`	`229`
`230`	`230`	`pub use anyhow;`
`231`	`231`	`pub use paste;`
	`232`	`+pub use rand::prelude::*;`
Original file line number	Diff line number	Diff line change
`@@ -13,87 +13,87 @@ pub trait SampleRNG {`
`13`	`13`	`impl SampleRNG for Vec<usize> {`
`14`	`14`	`type Item = usize;`
`15`	`15`	`fn sample(&self, n: usize) -> Vec<Self::Item> {`
`16`		`- let mut rng = thread_rng();`
	`16`	`+ let mut rng = rand::rng();`
`17`	`17`	`self.iter().map(\|x\| *x).choose_multiple(&mut rng, n)`
`18`	`18`	`}`
`19`	`19`	`}`
`20`	`20`
`21`	`21`	`impl SampleRNG for Vec<u32> {`
`22`	`22`	`type Item = u32;`
`23`	`23`	`fn sample(&self, n: usize) -> Vec<Self::Item> {`
`24`		`- let mut rng = thread_rng();`
	`24`	`+ let mut rng = rand::rng();`
`25`	`25`	`self.iter().map(\|x\| *x).choose_multiple(&mut rng, n)`
`26`	`26`	`}`
`27`	`27`	`}`
`28`	`28`
`29`	`29`	`impl SampleRNG for Vec<u64> {`
`30`	`30`	`type Item = u64;`
`31`	`31`	`fn sample(&self, n: usize) -> Vec<Self::Item> {`
`32`		`- let mut rng = thread_rng();`
	`32`	`+ let mut rng = rand::rng();`
`33`	`33`	`self.iter().map(\|x\| *x).choose_multiple(&mut rng, n)`
`34`	`34`	`}`
`35`	`35`	`}`
`36`	`36`
`37`	`37`	`impl SampleRNG for Vec<isize> {`
`38`	`38`	`type Item = isize;`
`39`	`39`	`fn sample(&self, n: usize) -> Vec<Self::Item> {`
`40`		`- let mut rng = thread_rng();`
	`40`	`+ let mut rng = rand::rng();`
`41`	`41`	`self.iter().map(\|x\| *x).choose_multiple(&mut rng, n)`
`42`	`42`	`}`
`43`	`43`	`}`
`44`	`44`
`45`	`45`	`impl SampleRNG for Vec<i32> {`
`46`	`46`	`type Item = i32;`
`47`	`47`	`fn sample(&self, n: usize) -> Vec<Self::Item> {`
`48`		`- let mut rng = thread_rng();`
	`48`	`+ let mut rng = rand::rng();`
`49`	`49`	`self.iter().map(\|x\| *x).choose_multiple(&mut rng, n)`
`50`	`50`	`}`
`51`	`51`	`}`
`52`	`52`
`53`	`53`	`impl SampleRNG for Vec<i64> {`
`54`	`54`	`type Item = i64;`
`55`	`55`	`fn sample(&self, n: usize) -> Vec<Self::Item> {`
`56`		`- let mut rng = thread_rng();`
	`56`	`+ let mut rng = rand::rng();`
`57`	`57`	`self.iter().map(\|x\| *x).choose_multiple(&mut rng, n)`
`58`	`58`	`}`
`59`	`59`	`}`
`60`	`60`
`61`	`61`	`impl SampleRNG for Vec<f64> {`
`62`	`62`	`type Item = f64;`
`63`	`63`	`fn sample(&self, n: usize) -> Vec<Self::Item> {`
`64`		`- let mut rng = thread_rng();`
	`64`	`+ let mut rng = rand::rng();`
`65`	`65`	`self.iter().map(\|x\| *x).choose_multiple(&mut rng, n)`
`66`	`66`	`}`
`67`	`67`	`}`
`68`	`68`
`69`	`69`	`impl SampleRNG for Vec<f32> {`
`70`	`70`	`type Item = f32;`
`71`	`71`	`fn sample(&self, n: usize) -> Vec<Self::Item> {`
`72`		`- let mut rng = thread_rng();`
	`72`	`+ let mut rng = rand::rng();`
`73`	`73`	`self.iter().map(\|x\| *x).choose_multiple(&mut rng, n)`
`74`	`74`	`}`
`75`	`75`	`}`
`76`	`76`
`77`	`77`	`impl SampleRNG for Vec<char> {`
`78`	`78`	`type Item = char;`
`79`	`79`	`fn sample(&self, n: usize) -> Vec<Self::Item> {`
`80`		`- let mut rng = thread_rng();`
	`80`	`+ let mut rng = rand::rng();`
`81`	`81`	`self.iter().map(\|x\| *x).choose_multiple(&mut rng, n)`
`82`	`82`	`}`
`83`	`83`	`}`
`84`	`84`
`85`	`85`	`impl<'a> SampleRNG for Vec<&'a str> {`
`86`	`86`	`type Item = &'a str;`
`87`	`87`	`fn sample(&self, n: usize) -> Vec<Self::Item> {`
`88`		`- let mut rng = thread_rng();`
	`88`	`+ let mut rng = rand::rng();`
`89`	`89`	`self.iter().map(\|x\| *x).choose_multiple(&mut rng, n)`
`90`	`90`	`}`
`91`	`91`	`}`
`92`	`92`
`93`	`93`	`impl SampleRNG for String {`
`94`	`94`	`type Item = char;`
`95`	`95`	`fn sample(&self, n: usize) -> Vec<Self::Item> {`
`96`		`- let mut rng = thread_rng();`
	`96`	`+ let mut rng = rand::rng();`
`97`	`97`	`self.chars().choose_multiple(&mut rng, n)`
`98`	`98`	`}`
`99`	`99`	`}`