···
13
13
edition = "2024"
14
14
15
15
[dependencies]
16
16
-
rand = "0.8.5"
16
16
+
rand = { version = "0.9.1", features = ["std_rng"] }
17
17
regex = "1.10.4"
18
18
clap = { version = "4.5.4", features = ["cargo"] }
19
19
rustc-hash = "1.1.0"
20
20
21
21
[dev-dependencies]
22
22
-
rand = "0.8.5"
23
22
criterion = "0.5.1"
24
23
25
24
[lib]
···
8
8
9
9
use criterion::Criterion;
10
10
use cvmcount::CVM;
11
11
-
use rand::{Rng, thread_rng};
11
11
+
use rand::{Rng, rng};
12
12
use regex::Regex;
13
13
14
14
use std::collections::HashSet;
15
15
16
16
// generate 1 million 7-digit random positive integers
17
17
fn generate_random_numbers() -> Vec<i32> {
18
18
-
let mut rng = thread_rng();
18
18
+
let mut rng = rng();
19
19
20
20
(0..1_000_000)
21
21
-
.map(|_| rng.gen_range(1_000_000..10_000_000))
21
21
+
.map(|_| rng.random_range(1_000_000..10_000_000))
22
22
.collect()
23
23
}
24
24
···
6
6
mod treap;
7
7
8
8
use crate::treap::Treap;
9
9
+
use rand::Rng;
10
10
+
use rand::SeedableRng;
9
11
use rand::rngs::StdRng;
10
10
-
use rand::{Rng, SeedableRng};
11
12
12
13
/// Specification for confidence level in the CVM algorithm
13
14
#[derive(Debug, Clone, Copy)]
···
227
228
buf_size: bufsize,
228
229
buf: Treap::new(),
229
230
probability: 1.0,
230
230
-
rng: StdRng::from_entropy(),
231
231
+
rng: StdRng::from_os_rng(),
231
232
}
232
233
}
233
234
/// Add an element, potentially updating the unique element count
···
240
241
if self.buf.contains(&elem) {
241
242
self.buf.remove(&elem);
242
243
}
243
243
-
if self.rng.gen_bool(self.probability) {
244
244
+
if self.rng.random_bool(self.probability) {
244
245
self.buf.insert(elem, &mut self.rng);
245
246
}
246
247
while self.buf.len() == self.buf_size {
···
252
253
fn clear_about_half(&mut self) {
253
254
// Need to capture rng reference to use in closure
254
255
let rng = &mut self.rng;
255
255
-
self.buf.retain(|_| rng.gen_bool(0.5));
256
256
+
self.buf.retain(|_| rng.random_bool(0.5));
256
257
}
257
258
/// Process an entire iterator of owned values and return the final estimate
258
259
///
···
84
84
85
85
/// Insert a key with a random priority
86
86
pub fn insert<R: Rng>(&mut self, key: T, rng: &mut R) {
87
87
-
let priority = rng.r#gen();
87
87
+
let priority = rng.random();
88
88
self.root = Self::insert_node(self.root.take(), key, priority);
89
89
self.size += 1;
90
90
}