Update rand crate to 0.9 and bump related dependencies (#1445)

* Update rand crates in rustworkx-core

* Update rand crates in rustworkx for Python

* Incorporate PR feedback

Author: IvanIsCoding

Cargo.lock

@@ -33,8 +33,9 @@ num-traits = "0.2"
 petgraph = "0.8"
 hashbrown = { version = ">=0.13, <0.16", features = ["rayon"] }
 numpy = "0.24"
-rand = "0.8"
-rand_pcg = "0.3"
+rand = "0.9"
+rand_distr = "0.5"
+rand_pcg = "0.9"
 rayon = "1.10"
 
 [lib]
@@ -55,6 +56,7 @@ numpy.workspace = true
 petgraph.workspace = true
 quick-xml = "0.37"
 rand.workspace = true
+rand_distr.workspace = true
 rand_pcg.workspace = true
 rayon.workspace = true
 serde = { version = "1.0", features = ["derive"] }

Cargo.toml

@@ -21,6 +21,7 @@ num-traits.workspace = true
 petgraph.workspace = true
 priority-queue = "2.1"
 rand.workspace = true
+rand_distr.workspace = true
 rand_pcg.workspace = true
 rayon.workspace = true
 rayon-cond = "0.4"

rustworkx-core/Cargo.toml

@@ -25,8 +25,8 @@ use petgraph::visit::{
 use petgraph::{Incoming, Outgoing};
 
 use hashbrown::HashSet;
-use rand::distributions::{Distribution, Uniform};
 use rand::prelude::*;
+use rand_distr::{Distribution, Uniform};
 use rand_pcg::Pcg64;
 
 use super::star_graph;
@@ -97,7 +97,7 @@ where
     }
     let mut rng: Pcg64 = match seed {
         Some(seed) => Pcg64::seed_from_u64(seed),
-        None => Pcg64::from_entropy(),
+        None => Pcg64::from_os_rng(),
     };
 
     if (num_nodes * degree) % 2 != 0 {
@@ -262,7 +262,7 @@ where
     }
     let mut rng: Pcg64 = match seed {
         Some(seed) => Pcg64::seed_from_u64(seed),
-        None => Pcg64::from_entropy(),
+        None => Pcg64::from_os_rng(),
     };
     let mut graph = G::with_capacity(num_nodes, num_nodes);
     let directed = graph.is_directed();
@@ -293,7 +293,7 @@ where
                 Err(_) => return Err(InvalidInputError {}),
             };
             let lp: f64 = (1.0 - probability).ln();
-            let between = Uniform::new(0.0, 1.0);
+            let between = Uniform::new(0.0, 1.0).unwrap();
 
             // For directed, create inward edges to a v
             if directed {
@@ -432,7 +432,7 @@ where
 
     let mut rng: Pcg64 = match seed {
         Some(seed) => Pcg64::seed_from_u64(seed),
-        None => Pcg64::from_entropy(),
+        None => Pcg64::from_os_rng(),
     };
     let mut graph = G::with_capacity(num_nodes, num_edges);
     let directed = graph.is_directed();
@@ -457,7 +457,7 @@ where
         }
     } else {
         let mut created_edges: usize = 0;
-        let between = Uniform::new(0, num_nodes);
+        let between = Uniform::new(0, num_nodes).unwrap();
         while created_edges < num_edges {
             let u = between.sample(&mut rng);
             let v = between.sample(&mut rng);
@@ -549,7 +549,7 @@ where
     }
     let mut rng: Pcg64 = match seed {
         Some(seed) => Pcg64::seed_from_u64(seed),
-        None => Pcg64::from_entropy(),
+        None => Pcg64::from_os_rng(),
     };
     let mut blocks = Vec::new();
     {
@@ -565,7 +565,7 @@ where
         }
     }
 
-    let between = Uniform::new(0.0, 1.0);
+    let between = Uniform::new(0.0, 1.0).unwrap();
     for v in 0..(if directed || loops {
         num_nodes
     } else {
@@ -681,12 +681,12 @@ where
     }
     let mut rng: Pcg64 = match seed {
         Some(seed) => Pcg64::seed_from_u64(seed),
-        None => Pcg64::from_entropy(),
+        None => Pcg64::from_os_rng(),
     };
     let mut graph = G::with_capacity(num_nodes, num_nodes);
 
     let radius_p = pnorm(radius, p);
-    let dist = Uniform::new(0.0, 1.0);
+    let dist = Uniform::new(0.0, 1.0).unwrap();
     let pos = pos.unwrap_or_else(|| {
         (0..num_nodes)
             .map(|_| (0..dim).map(|_| dist.sample(&mut rng)).collect())
@@ -784,7 +784,7 @@ where
     }
     let mut rng: Pcg64 = match seed {
         Some(seed) => Pcg64::seed_from_u64(seed),
-        None => Pcg64::from_entropy(),
+        None => Pcg64::from_os_rng(),
     };
     let mut graph = match initial_graph {
         Some(initial_graph) => initial_graph,
@@ -888,15 +888,15 @@ where
 
     let mut rng: Pcg64 = match seed {
         Some(seed) => Pcg64::seed_from_u64(seed),
-        None => Pcg64::from_entropy(),
+        None => Pcg64::from_os_rng(),
     };
     let mut graph = G::with_capacity(num_l_nodes + num_r_nodes, num_l_nodes + num_r_nodes);
 
     for _ in 0..num_l_nodes + num_r_nodes {
         graph.add_node(default_node_weight());
     }
 
-    let between = Uniform::new(0.0, 1.0);
+    let between = Uniform::new(0.0, 1.0).unwrap();
     for v in 0..num_l_nodes {
         for w in 0..num_r_nodes {
             let random: f64 = between.sample(&mut rng);
@@ -990,7 +990,7 @@ where
 
     let mut rng: Pcg64 = match seed {
         Some(seed) => Pcg64::seed_from_u64(seed),
-        None => Pcg64::from_entropy(),
+        None => Pcg64::from_os_rng(),
     };
     let mut graph = G::with_capacity(num_nodes, num_nodes);
     if graph.is_directed() {
@@ -1001,7 +1001,7 @@ where
         graph.add_node(default_node_weight());
     }
 
-    let between = Uniform::new(0.0, 1.0);
+    let between = Uniform::new(0.0, 1.0).unwrap();
     for (v, p1) in pos.iter().enumerate().take(num_nodes - 1) {
         for (w, p2) in pos.iter().enumerate().skip(v + 1) {
             let dist = hyperbolic_distance(p1, p2);

rustworkx-core/src/generators/random_graph.rs

@@ -10,8 +10,8 @@
 // License for the specific language governing permissions and limitations
 // under the License.
 
-use rand::distributions::{Standard, Uniform};
 use rand::prelude::*;
+use rand_distr::{StandardUniform, Uniform};
 use rand_pcg::Pcg64;
 use std::error::Error;
 use std::fmt;
@@ -161,10 +161,12 @@ where
         // into a Vec based on the given seed
         let outer_rng: Pcg64 = match self.seed {
             Some(rng_seed) => Pcg64::seed_from_u64(rng_seed),
-            None => Pcg64::from_entropy(),
+            None => Pcg64::from_os_rng(),
         };
-        let trial_seeds_vec: Vec<u64> =
-            outer_rng.sample_iter(&Standard).take(self.trials).collect();
+        let trial_seeds_vec: Vec<u64> = outer_rng
+            .sample_iter(&StandardUniform)
+            .take(self.trials)
+            .collect();
 
         CondIterator::new(
             trial_seeds_vec,
@@ -260,7 +262,7 @@ where
         let mut rng_seed: Pcg64 = Pcg64::seed_from_u64(trial_seed);
         while !todo_nodes.is_empty() && steps <= 4 * digraph.node_count().pow(2) {
             // Choose a random todo_node
-            let between = Uniform::new(0, todo_nodes.len());
+            let between = Uniform::new(0, todo_nodes.len()).map_err(|_| MapNotPossible {})?;
             let random: usize = between.sample(&mut rng_seed);
             let todo_node = todo_nodes[random];
 

rustworkx-core/src/token_swapper.rs

@@ -25,14 +25,14 @@ pub fn random_layout<Ty: EdgeType>(
 ) -> Pos2DMapping {
     let mut rng: Pcg64 = match seed {
         Some(seed) => Pcg64::seed_from_u64(seed),
-        None => Pcg64::from_entropy(),
+        None => Pcg64::from_os_rng(),
     };
 
     Pos2DMapping {
         pos_map: graph
             .node_indices()
             .map(|n| {
-                let random_tuple: [f64; 2] = rng.gen();
+                let random_tuple: [f64; 2] = rng.random();
                 match center {
                     Some(center) => (
                         n.index(),

src/layout/random.rs

@@ -17,16 +17,16 @@ use std::iter::Iterator;
 
 use hashbrown::{HashMap, HashSet};
 
-use pyo3::exceptions::PyValueError;
+use pyo3::exceptions::{PyRuntimeError, PyValueError};
 use pyo3::prelude::*;
 
 use petgraph::graph::NodeIndex;
 use petgraph::prelude::*;
 use petgraph::visit::{IntoEdgeReferences, NodeIndexable};
 use petgraph::EdgeType;
 
-use rand::distributions::{Distribution, Uniform};
 use rand::prelude::*;
+use rand_distr::{Distribution, Uniform};
 use rand_pcg::Pcg64;
 
 use crate::StablePyGraph;
@@ -322,10 +322,11 @@ where
 
     let mut rng: Pcg64 = match seed {
         Some(seed) => Pcg64::seed_from_u64(seed),
-        None => Pcg64::from_entropy(),
+        None => Pcg64::from_os_rng(),
     };
 
-    let dist = Uniform::new(0.0, 1.0);
+    let dist = Uniform::new(0.0, 1.0)
+        .map_err(|_| PyRuntimeError::new_err("Error creating uniform distribution"))?;
 
     let pos = pos.unwrap_or_default();
     let mut vpos: Vec<Point> = (0..graph.node_bound())