update to rand v0.9

Author: jcmgray

Cargo.lock

@@ -12,7 +12,7 @@ crate-type = ["cdylib"]
 bit-set = "0.8"
 ordered-float = "5.0"
 pyo3 = "0.23"
-rand = "0.8"
+rand = "0.9"
 rustc-hash = "2.1"
 
 [profile.release]

Cargo.toml

@@ -70,28 +70,28 @@ The following benchmarks illustrate performance and may be a useful comparison p
 
 ---
 
-First, the runtime of the optimal algorithm on random 3-regular graphs, 
+First, the runtime of the optimal algorithm on random 3-regular graphs,
 with all bond sizes set to 2, for different `mimimize` targets:
 
 <img src="https://github.com/user-attachments/assets/e1b906a8-e234-4558-b183-7141c41beb24" width="400">
 
 Taken over 20 instances, lines show mean and bands show standard error on mean. Note how much easier it is
 to find optimal paths for the *maximum* intermediate size or cost only (vs. *total* for all contractions).
-While the runtime generally scales exponentially, for some specific geometries it might reduce to 
+While the runtime generally scales exponentially, for some specific geometries it might reduce to
 polynomial.
 
 ---
 
 For very large graphs, the `random_greedy` optimizer is appropriate, and there is a tradeoff between how
-long one lets it run (`ntrials`) and the best cost it achieves. Here we plot these for various 
-$N=L\times L$ square grid graphs, with all bond sizes set to 2, for different `ntrials` 
+long one lets it run (`ntrials`) and the best cost it achieves. Here we plot these for various
+$N=L\times L$ square grid graphs, with all bond sizes set to 2, for different `ntrials`
 (labelled on each marker):
 
 <img src="https://github.com/user-attachments/assets/e319b5cf-25ea-4273-aa0f-4f3acb3beaa6" width="400">
 
 Again, data is taken over 20 runs, with lines and bands showing mean and standard error on the mean.
 In most cases 32-64 trials is sufficient to achieve close to convergence, but for larger or harder
-graphs you may need more. The empirical scaling of the random-greedy algorithm is very roughly 
+graphs you may need more. The empirical scaling of the random-greedy algorithm is very roughly
 $\mathcal{O}(N^{1.5})$ here.
 
 ---

README.md

@@ -425,7 +425,7 @@ impl ContractionProcessor {
         let mut rng = if coeff_t != 0.0 {
             Some(match seed {
                 Some(seed) => rand::rngs::StdRng::seed_from_u64(seed),
-                None => rand::rngs::StdRng::from_entropy(),
+                None => rand::rngs::StdRng::from_os_rng(),
             })
         } else {
             // zero temp - no need for rng
@@ -434,7 +434,7 @@ impl ContractionProcessor {
 
         let mut local_score = |sa: Score, sb: Score, sab: Score| -> Score {
             let gumbel = if let Some(rng) = &mut rng {
-                coeff_t * -f32::ln(-f32::ln(rng.gen()))
+                coeff_t * -f32::ln(-f32::ln(rng.random()))
             } else {
                 0.0 as f32
             };
@@ -1130,9 +1130,9 @@ fn optimize_random_greedy_track_flops(
 
         let mut rng = match seed {
             Some(seed) => rand::rngs::StdRng::seed_from_u64(seed),
-            None => rand::rngs::StdRng::from_entropy(),
+            None => rand::rngs::StdRng::from_os_rng(),
         };
-        let seeds = (0..ntrials).map(|_| rng.gen()).collect::<Vec<u64>>();
+        let seeds = (0..ntrials).map(|_| rng.random()).collect::<Vec<u64>>();
 
         let n: usize = inputs.len();
         // construct processor and perform simplifications once
@@ -1151,14 +1151,14 @@ fn optimize_random_greedy_track_flops(
             let costmod = if is_const_costmod {
                 costmod_min
             } else {
-                costmod_min + rng.gen::<f32>() * costmod_diff
+                costmod_min + rng.random::<f32>() * costmod_diff
             };
 
             // log-uniform sample for temperature
             let temperature = if is_const_temp {
                 temp_min
             } else {
-                f32::exp(log_temp_min + rng.gen::<f32>() * log_temp_diff)
+                f32::exp(log_temp_min + rng.random::<f32>() * log_temp_diff)
             };
 
             // greedily contract each connected subgraph