Bump rand to 0.9 and associated crates (#13806)

* Bump `rand` to 0.9 and associated crates

This is a breaking API change, but our exposure is mostly just to some
minor renames.  Unfortunately the whole ecosystem hasn't migrated yet,
so we're still compiling in multiple versions of `rand`, but with any
luck, bumping hashbrown and dropping faer will help.

* Fix random tests for new seeded behaviour

* Fix mistaken test

* Fix lint

* Choose seed to match visual reference

* Fix randomisation change in new test

crates/accelerate/Cargo.toml

@@ -15,9 +15,9 @@ workspace = true
 [dependencies]
 rayon.workspace = true
 numpy.workspace = true
-rand = "0.8"
-rand_pcg = "0.3"
-rand_distr = "0.4.3"
+rand = "0.9"
+rand_pcg = "0.9"
+rand_distr = "0.5"
 ahash.workspace = true
 num-traits = "0.2"
 num-complex.workspace = true

crates/accelerate/src/circuit_library/iqp.rs

@@ -80,14 +80,14 @@ fn generate_random_interactions(num_qubits: u32, seed: Option<u64>) -> Array2<i6
     let num_qubits = num_qubits as usize;
     let mut rng = match seed {
         Some(seed) => Pcg64Mcg::seed_from_u64(seed),
-        None => Pcg64Mcg::from_entropy(),
+        None => Pcg64Mcg::from_os_rng(),
     };
 
     let mut mat = Array2::zeros((num_qubits, num_qubits));
     for i in 0..num_qubits {
-        mat[[i, i]] = rng.gen_range(0..8) as i64;
+        mat[[i, i]] = rng.random_range(0..8) as i64;
         for j in 0..i {
-            mat[[i, j]] = rng.gen_range(0..8) as i64;
+            mat[[i, j]] = rng.random_range(0..8) as i64;
             mat[[j, i]] = mat[[i, j]];
         }
     }

crates/accelerate/src/circuit_library/quantum_volume.rs

@@ -125,9 +125,9 @@ pub fn quantum_volume(
     }
     let mut outer_rng = match seed {
         Some(seed) => Pcg64Mcg::seed_from_u64(seed),
-        None => Pcg64Mcg::from_entropy(),
+        None => Pcg64Mcg::from_os_rng(),
     };
-    let seed_vec: Vec<u64> = rand::distributions::Standard
+    let seed_vec: Vec<u64> = rand::distr::StandardUniform
         .sample_iter(&mut outer_rng)
         .take(num_unitaries)
         .collect();

crates/accelerate/src/sabre/layout.rs

@@ -128,10 +128,10 @@ pub fn sabre_layout_and_routing(
     }
     let outer_rng = match seed {
         Some(seed) => Pcg64Mcg::seed_from_u64(seed),
-        None => Pcg64Mcg::from_entropy(),
+        None => Pcg64Mcg::from_os_rng(),
     };
     let seed_vec: Vec<u64> = outer_rng
-        .sample_iter(&rand::distributions::Standard)
+        .sample_iter(&rand::distr::StandardUniform)
         .take(starting_layouts.len())
         .collect();
     let res = if run_in_parallel && starting_layouts.len() > 1 {

crates/accelerate/src/sabre/route.rs

@@ -502,10 +502,10 @@ pub fn swap_map(
     };
     let outer_rng = match seed {
         Some(seed) => Pcg64Mcg::seed_from_u64(seed),
-        None => Pcg64Mcg::from_entropy(),
+        None => Pcg64Mcg::from_os_rng(),
     };
     let seed_vec: Vec<u64> = outer_rng
-        .sample_iter(&rand::distributions::Standard)
+        .sample_iter(&rand::distr::StandardUniform)
         .take(num_trials)
         .collect();
     if run_in_parallel {

crates/accelerate/src/stochastic_swap.rs

@@ -260,10 +260,10 @@ pub fn swap_trials(
         RwLock::new(&mut best_possible);
     let outer_rng: Pcg64Mcg = match seed {
         Some(seed) => Pcg64Mcg::seed_from_u64(seed),
-        None => Pcg64Mcg::from_entropy(),
+        None => Pcg64Mcg::from_os_rng(),
     };
     let seed_vec: Vec<u64> = outer_rng
-        .sample_iter(&rand::distributions::Standard)
+        .sample_iter(&rand::distr::StandardUniform)
         .take(num_trials as usize)
         .collect();
     // Run in parallel only if we're not already in a multiprocessing context

crates/accelerate/src/synthesis/clifford/random_clifford.rs

@@ -29,7 +29,7 @@ fn sample_qmallows(n: usize, rng: &mut Pcg64Mcg) -> (Array1<bool>, Array1<usize>
     for i in 0..n {
         let m = n - i;
         let eps: f64 = 4f64.powi(-(m as i32));
-        let r: f64 = rng.gen();
+        let r: f64 = rng.random();
         let index: usize = -((r + (1f64 - r) * eps).log2().ceil() as isize) as usize;
         had[i] = index < m;
         let k = if index < m { index } else { 2 * m - index - 1 };
@@ -44,7 +44,7 @@ fn fill_tril(mut mat: ArrayViewMut2<bool>, rng: &mut Pcg64Mcg, symmetric: bool)
     let n = mat.shape()[0];
     for i in 0..n {
         for j in 0..i {
-            mat[[i, j]] = rng.gen();
+            mat[[i, j]] = rng.random();
             if symmetric {
                 mat[[j, i]] = mat[[i, j]];
             }
@@ -67,20 +67,20 @@ fn inverse_tril(mat: ArrayView2<bool>) -> Array2<bool> {
 pub fn random_clifford_tableau_inner(num_qubits: usize, seed: Option<u64>) -> Array2<bool> {
     let mut rng = match seed {
         Some(seed) => Pcg64Mcg::seed_from_u64(seed),
-        None => Pcg64Mcg::from_entropy(),
+        None => Pcg64Mcg::from_os_rng(),
     };
 
     let (had, perm) = sample_qmallows(num_qubits, &mut rng);
 
     let mut gamma1: Array2<bool> = Array2::from_elem((num_qubits, num_qubits), false);
     for i in 0..num_qubits {
-        gamma1[[i, i]] = rng.gen();
+        gamma1[[i, i]] = rng.random();
     }
     fill_tril(gamma1.view_mut(), &mut rng, true);
 
     let mut gamma2: Array2<bool> = Array2::from_elem((num_qubits, num_qubits), false);
     for i in 0..num_qubits {
-        gamma2[[i, i]] = rng.gen();
+        gamma2[[i, i]] = rng.random();
     }
     fill_tril(gamma2.view_mut(), &mut rng, true);
 
@@ -149,7 +149,7 @@ pub fn random_clifford_tableau_inner(num_qubits: usize, seed: Option<u64>) -> Ar
     let random_symplectic_mat = binary_matmul_inner(table1.view(), table.view()).unwrap();
 
     // Generate random phases
-    let random_phases: Array2<bool> = Array2::from_shape_fn((2 * num_qubits, 1), |_| rng.gen());
+    let random_phases: Array2<bool> = Array2::from_shape_fn((2 * num_qubits, 1), |_| rng.random());
 
     let random_tableau: Array2<bool> = concatenate(
         Axis(1),