Merge pull request #12 from urschrei/shugel/push-yoztvtyqqvol

Update rand dep

Cargo.toml

···
 edition = "2024"
 
 [dependencies]
-rand = "0.8.5"
+rand = { version = "0.9.1", features = ["std_rng"] }
 regex = "1.10.4"
 clap = { version = "4.5.4", features = ["cargo"] }
 rustc-hash = "2.1.1"
 
 [dev-dependencies]
-rand = "0.8.5"
 criterion = "0.5.1"
 
 [lib]

benches/benchmarks.rs

···
 
 use criterion::Criterion;
 use cvmcount::CVM;
-use rand::{Rng, thread_rng};
+use rand::{Rng, rng};
 use regex::Regex;
 
 use std::collections::HashSet;
 
 // generate 1 million 7-digit random positive integers
 fn generate_random_numbers() -> Vec<i32> {
-    let mut rng = thread_rng();
+    let mut rng = rng();
 
     (0..1_000_000)
-        .map(|_| rng.gen_range(1_000_000..10_000_000))
+        .map(|_| rng.random_range(1_000_000..10_000_000))
         .collect()
 }
 

src/lib.rs

···
 mod treap;
 
 use crate::treap::Treap;
+use rand::Rng;
+use rand::SeedableRng;
 use rand::rngs::StdRng;
-use rand::{Rng, SeedableRng};
 
 /// Specification for confidence level in the CVM algorithm
 #[derive(Debug, Clone, Copy)]
···
             buf_size: bufsize,
             buf: Treap::new(),
             probability: 1.0,
-            rng: StdRng::from_entropy(),
+            rng: StdRng::from_os_rng(),
         }
     }
     /// Add an element, potentially updating the unique element count
···
         if self.buf.contains(&elem) {
             self.buf.remove(&elem);
         }
-        if self.rng.gen_bool(self.probability) {
+        if self.rng.random_bool(self.probability) {
             self.buf.insert(elem, &mut self.rng);
         }
         while self.buf.len() == self.buf_size {
···
     fn clear_about_half(&mut self) {
         // Need to capture rng reference to use in closure
         let rng = &mut self.rng;
-        self.buf.retain(|_| rng.gen_bool(0.5));
+        self.buf.retain(|_| rng.random_bool(0.5));
     }
     /// Process an entire iterator of owned values and return the final estimate
     ///

src/treap.rs

···
 
     /// Insert a key with a random priority
     pub fn insert<R: Rng>(&mut self, key: T, rng: &mut R) {
-        let priority = rng.r#gen();
+        let priority = rng.random();
         self.root = Self::insert_node(self.root.take(), key, priority);
         self.size += 1;
     }