fix clippy and a deprecation warnings

Author: crepererum

benches/filters.rs

@@ -4,14 +4,19 @@ extern crate pdatastructs;
 
 use std::collections::HashSet;
 
-use criterion::{Bencher, Criterion, Fun, ParameterizedBenchmark};
+use criterion::{Bencher, BenchmarkId, Criterion};
 use pdatastructs::filters::bloomfilter::BloomFilter;
 use pdatastructs::filters::cuckoofilter::CuckooFilter;
 use pdatastructs::filters::quotientfilter::QuotientFilter;
 use pdatastructs::filters::Filter;
 use pdatastructs::rand::SeedableRng;
 use rand_chacha::ChaChaRng;
 
+const ID_BLOOMFILTER: &str = "bloomfilter";
+const ID_CUCKOOFILTER: &str = "cuckoofilter";
+const ID_HASHSET: &str = "hashset";
+const ID_QUOTIENTFILTER: &str = "quotientfilter";
+
 fn setup_bloomfilter() -> BloomFilter<u64> {
     let false_positive_rate = 0.02; // = 2%
     let expected_elements = 10_000;
@@ -71,49 +76,60 @@ where
 }
 
 fn benchmarks_setup(c: &mut Criterion) {
-    let functions = vec![
-        Fun::new("bloomfilter", |b, _| run_setup(setup_bloomfilter, b)),
-        Fun::new("cuckoofilter", |b, _| run_setup(setup_cuckoofilter, b)),
-        Fun::new("hashset", |b, _| run_setup(setup_hashset, b)),
-        Fun::new("quotientfilter", |b, _| run_setup(setup_quotientfilter, b)),
-    ];
-    c.bench_functions("setup", functions, ());
+    let mut g = c.benchmark_group("setup");
+
+    g.bench_function(ID_BLOOMFILTER, |b| run_setup(setup_bloomfilter, b));
+    g.bench_function(ID_CUCKOOFILTER, |b| run_setup(setup_cuckoofilter, b));
+    g.bench_function(ID_HASHSET, |b| run_setup(setup_hashset, b));
+    g.bench_function(ID_QUOTIENTFILTER, |b| run_setup(setup_quotientfilter, b));
+
+    g.finish();
 }
 
 fn benchmarks_insert_many(c: &mut Criterion) {
-    let parameters = vec![4_000, 8_000, 12_000, 16_000, 20_000];
-    let benchmark = ParameterizedBenchmark::new(
-        "bloomfilter",
-        |b, n| run_insert_many(setup_bloomfilter, b, *n),
-        parameters,
-    )
-    .with_function("cuckoofilter", |b, n| {
-        run_insert_many(setup_cuckoofilter, b, *n)
-    })
-    .with_function("hashset", |b, n| run_insert_many(setup_hashset, b, *n))
-    .with_function("quotientfilter", |b, n| {
-        run_insert_many(setup_quotientfilter, b, *n)
-    })
-    .sample_size(20);
-    c.bench("insert_many", benchmark);
+    let mut g = c.benchmark_group("insert_many");
+
+    g.sample_size(20);
+
+    for n in [4_000, 8_000, 12_000, 16_000, 20_000] {
+        g.bench_with_input(BenchmarkId::new(ID_BLOOMFILTER, &n), &n, |b, n| {
+            run_insert_many(setup_bloomfilter, b, *n)
+        });
+        g.bench_with_input(BenchmarkId::new(ID_CUCKOOFILTER, &n), &n, |b, n| {
+            run_insert_many(setup_cuckoofilter, b, *n)
+        });
+        g.bench_with_input(BenchmarkId::new(ID_HASHSET, &n), &n, |b, n| {
+            run_insert_many(setup_hashset, b, *n)
+        });
+        g.bench_with_input(BenchmarkId::new(ID_QUOTIENTFILTER, &n), &n, |b, n| {
+            run_insert_many(setup_quotientfilter, b, *n)
+        });
+    }
+
+    g.finish();
 }
 
 fn benchmarks_query_single(c: &mut Criterion) {
-    let parameters = vec![4_000, 8_000];
-    let benchmark = ParameterizedBenchmark::new(
-        "bloomfilter",
-        |b, n| run_query_single(setup_bloomfilter, b, *n),
-        parameters,
-    )
-    .with_function("cuckoofilter", |b, n| {
-        run_query_single(setup_cuckoofilter, b, *n)
-    })
-    .with_function("hashset", |b, n| run_query_single(setup_hashset, b, *n))
-    .with_function("quotientfilter", |b, n| {
-        run_query_single(setup_quotientfilter, b, *n)
-    })
-    .sample_size(20);
-    c.bench("query_single", benchmark);
+    let mut g = c.benchmark_group("query_single");
+
+    g.sample_size(20);
+
+    for n in [4_000, 8_000] {
+        g.bench_with_input(BenchmarkId::new(ID_BLOOMFILTER, &n), &n, |b, n| {
+            run_query_single(setup_bloomfilter, b, *n)
+        });
+        g.bench_with_input(BenchmarkId::new(ID_CUCKOOFILTER, &n), &n, |b, n| {
+            run_query_single(setup_cuckoofilter, b, *n)
+        });
+        g.bench_with_input(BenchmarkId::new(ID_HASHSET, &n), &n, |b, n| {
+            run_query_single(setup_hashset, b, *n)
+        });
+        g.bench_with_input(BenchmarkId::new(ID_QUOTIENTFILTER, &n), &n, |b, n| {
+            run_query_single(setup_quotientfilter, b, *n)
+        });
+    }
+
+    g.finish();
 }
 
 criterion_group!(

src/countminsketch.rs

@@ -216,7 +216,7 @@ where
     ///
     /// Returns guessed count after addition.
     pub fn add(&mut self, obj: &T) -> C {
-        self.add_n(&obj, &C::one())
+        self.add_n(obj, &C::one())
     }
 
     /// Add `n` to the counter of the given element.

src/filters/quotientfilter.rs

@@ -3,7 +3,6 @@ use std::collections::hash_map::DefaultHasher;
 use std::collections::VecDeque;
 use std::hash::{BuildHasher, BuildHasherDefault, Hash, Hasher};
 use std::marker::PhantomData;
-use std::mem::size_of;
 
 use fixedbitset::FixedBitSet;
 use succinct::{IntVec, IntVecMut, IntVector};
@@ -290,10 +289,10 @@ where
         buildhasher: B,
     ) -> Self {
         assert!(
-            (bits_remainder > 0) && (bits_remainder <= size_of::<usize>() * 8),
+            (bits_remainder > 0) && (bits_remainder <= (usize::BITS as usize)),
             "bits_remainder ({}) must be greater than 0 and smaller or equal than {}",
             bits_remainder,
-            size_of::<usize>() * 8,
+            usize::BITS,
         );
         assert!(
             bits_quotient > 0,

src/hash_utils.rs

@@ -111,7 +111,7 @@ where
     {
         let h1 = self.h_i(&obj, 0) % (self.m as u64);
         let h2 = self.h_i(&obj, 1) % (self.m as u64);
-        HashIter::new(&self, h1, h2)
+        HashIter::new(self, h1, h2)
     }
 
     /// Set up `f`.

src/hyperloglog.rs

@@ -102,12 +102,12 @@ where
     /// Same as `new` but with a specific `BuildHasher`.
     pub fn with_hash(b: usize, buildhasher: B) -> Self {
         assert!(
-            (b >= 4) & (b <= 18),
+            (4..=18).contains(&b),
             "b ({}) must be larger or equal than 4 and smaller or equal than 18",
             b
         );
 
-        let m = (1 as usize) << b;
+        let m = 1_usize << b;
         let registers = vec![0; m];
         Self {
             registers,
@@ -196,7 +196,7 @@ where
         const K: usize = 6;
         assert!(lookup_array.len() >= K);
         let mut neighbors = [0; K];
-        for i in 0..K {
+        for neighbor in &mut neighbors {
             let (right_instead_left, idx) = match (idx_left, idx_right) {
                 (Some(i_left), Some(i_right)) => {
                     // 2 candidates, find better one
@@ -218,7 +218,7 @@ where
                 }
                 _ => panic!("neighborhood search failed, this is bug!"),
             };
-            neighbors[i] = idx;
+            *neighbor = idx;
             if right_instead_left {
                 idx_right = if idx < lookup_array.len() - 1 {
                     Some(idx + 1)

src/hyperloglog_data.rs

@@ -4278,5 +4278,5 @@ pub(crate) const POW2MINX: [f64; 256] = [
 
 #[test]
 fn test_pow2minx() {
-    (0..256).for_each(|x| assert_eq!(POW2MINX[x as usize], 2f64.powi(-(i32::from(x)))))
+    (0..256).for_each(|x| assert_eq!(POW2MINX[x as usize], 2f64.powi(-x)))
 }

src/tdigest.rs

@@ -414,7 +414,7 @@ where
 
     #[inline(always)]
     fn interpolate(a: f64, b: f64, t: f64) -> f64 {
-        debug_assert!((t >= 0.) && (t <= 1.));
+        debug_assert!((0. ..=1.).contains(&t));
         debug_assert!(a <= b);
         t * b + (1. - t) * a
     }
@@ -853,7 +853,7 @@ where
     ///
     /// Panics if the quantile is not in range `[0, 1]`.
     pub fn quantile(&self, q: f64) -> f64 {
-        assert!((q >= 0.) && (q <= 1.), "q ({}) must be in [0, 1]", q);
+        assert!((0. ..=1.).contains(&q), "q ({}) must be in [0, 1]", q);
 
         // apply compression if required
         self.inner.borrow_mut().merge();

src/topk/cmsheap.rs

@@ -214,7 +214,7 @@ where
     ///
     /// The result may contain less than `k` values if less than `k` unique data points where
     /// observed.
-    pub fn iter<'a>(&'a self) -> impl 'a + Iterator<Item = T> {
+    pub fn iter(&self) -> impl '_ + Iterator<Item = T> {
         self.tree.iter().map(|x| (*x.obj).clone())
     }
 
@@ -324,10 +324,10 @@ mod tests {
     fn is_empty() {
         let cms = CountMinSketch::with_params(10, 20);
         let mut tk = CMSHeap::new(2, cms);
-        assert_eq!(tk.is_empty(), true);
+        assert!(tk.is_empty());
 
         tk.add(0);
-        assert_eq!(tk.is_empty(), false);
+        assert!(!tk.is_empty());
     }
 
     #[test]
@@ -337,7 +337,7 @@ mod tests {
         tk.add(0);
 
         tk.clear();
-        assert_eq!(tk.is_empty(), true);
+        assert!(tk.is_empty());
 
         tk.add(1);
         assert_eq!(tk.iter().collect::<Vec<u32>>(), vec![1]);

src/topk/lossycounter.rs

@@ -264,7 +264,7 @@ where
     /// ```
     ///
     /// The order of the elements is undefined.
-    pub fn query<'a>(&'a self, threshold: f64) -> impl 'a + Iterator<Item = T> {
+    pub fn query(&self, threshold: f64) -> impl '_ + Iterator<Item = T> {
         let bound = (((threshold - self.epsilon) * (self.n as f64)).ceil()).max(0.) as usize;
         self.known
             .iter()
@@ -340,7 +340,7 @@ mod tests {
         assert!(counter.add(42));
 
         let mut data: Vec<u64> = counter.query(0.).collect();
-        data.sort();
+        data.sort_unstable();
         assert_eq!(data, vec![13, 42]);
     }
 
@@ -352,7 +352,7 @@ mod tests {
         assert!(counter.add(42));
 
         let mut data: Vec<u64> = counter.query(0.6).collect();
-        data.sort();
+        data.sort_unstable();
         assert_eq!(data, vec![13]);
     }
 
@@ -369,7 +369,7 @@ mod tests {
         }
 
         let mut data: Vec<u64> = counter.query(0.02).collect();
-        data.sort();
+        data.sort_unstable();
         assert_eq!(data, vec![7, 8, 9]);
     }
 
@@ -385,11 +385,11 @@ mod tests {
         assert_eq!(counter2.n(), 2);
 
         let mut data1: Vec<u64> = counter1.query(0.).collect();
-        data1.sort();
+        data1.sort_unstable();
         assert_eq!(data1, vec![13]);
 
         let mut data2: Vec<u64> = counter2.query(0.).collect();
-        data2.sort();
+        data2.sort_unstable();
         assert_eq!(data2, vec![13, 42]);
     }
 
@@ -401,8 +401,7 @@ mod tests {
 
         counter.clear();
         assert_eq!(counter.n(), 0);
-        let data: Vec<u64> = counter.query(0.).collect();
-        assert!(data.is_empty());
+        assert!(counter.query(0.).next().is_none());
 
         assert!(counter.add(13));
         assert_eq!(counter.n(), 1);
@@ -421,7 +420,6 @@ mod tests {
 
         assert!(counter.add(42));
         assert_eq!(counter.n(), 2);
-        let data: Vec<u64> = counter.query(0.).collect();
-        assert!(data.is_empty());
+        assert!(counter.query(0.).next().is_none());
     }
 }