Fix Clippy errors

[squashme] more clippy fixes

Author: audy

Cargo.lock

@@ -413,7 +413,7 @@ pub fn update_sketch_params(
             if let Some(new_scale_num) = new_scale {
                 if matches.occurrences_of("scale") == 0 {
                     *scale = new_scale_num;
-                } else if (*scale - new_scale_num).abs() < std::f64::EPSILON {
+                } else if (*scale - new_scale_num).abs() < f64::EPSILON {
                     // TODO: maybe this should have a slightly larger delta?
                     bail!(
                         "Specified scale {} does not match {} from sketch {}",

cli/src/main.rs

@@ -97,7 +97,7 @@ pub fn raw_distance(
     // at this point we've exhausted one of the two sketches, but we may have
     // more counts in the other to compare if these were scaled sketches
     if scale > 0. {
-        let max_hash = u64::max_value() / scale.recip() as u64;
+        let max_hash = u64::MAX / scale.recip() as u64;
         while query_hashes
             .get(i)
             .map(|kmer_count| kmer_count.hash < max_hash)
@@ -125,6 +125,37 @@ pub fn raw_distance(
     (containment, jaccard, common, total)
 }
 
+/// This computes set statistics from one set of hashes to another.
+///
+/// Every hash in the reference set is considered while only those hashes in the
+/// query set that are in the same range as the reference set are compared. This
+/// should be a more accurate representation of the query set's containment in
+/// the reference set because we consider all of the reference set. In
+/// practice, there may be issues especially if the query is sketched to a
+/// different effective scale than the reference.
+pub fn old_distance(query_sketch: &[KmerCount], ref_sketch: &[KmerCount]) -> (f64, f64, u64, u64) {
+    let mut i: usize = 0;
+    let mut common: u64 = 0;
+    let mut total: u64 = 0;
+
+    for ref_hash in ref_sketch {
+        while (query_sketch[i].hash < ref_hash.hash) && (i < query_sketch.len() - 1) {
+            i += 1;
+        }
+
+        if query_sketch[i].hash == ref_hash.hash {
+            common += 1;
+        }
+
+        total += 1;
+    }
+
+    // Numerator is A-intersect-B, |A| is the denominator, we enforce |A| == |B|
+    let containment: f64 = common as f64 / total as f64;
+    let jaccard: f64 = common as f64 / (common + 2 * (total - common)) as f64;
+    (containment, jaccard, common, total)
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -306,37 +337,6 @@ mod tests {
     }
 }
 
-/// This computes set statistics from one set of hashes to another.
-///
-/// Every hash in the reference set is considered while only those hashes in the
-/// query set that are in the same range as the reference set are compared. This
-/// should be a more accurate representation of the query set's containment in
-/// the reference set because we consider all of the reference set. In
-/// practice, there may be issues especially if the query is sketched to a
-/// different effective scale than the reference.
-pub fn old_distance(query_sketch: &[KmerCount], ref_sketch: &[KmerCount]) -> (f64, f64, u64, u64) {
-    let mut i: usize = 0;
-    let mut common: u64 = 0;
-    let mut total: u64 = 0;
-
-    for ref_hash in ref_sketch {
-        while (query_sketch[i].hash < ref_hash.hash) && (i < query_sketch.len() - 1) {
-            i += 1;
-        }
-
-        if query_sketch[i].hash == ref_hash.hash {
-            common += 1;
-        }
-
-        total += 1;
-    }
-
-    // Numerator is A-intersect-B, |A| is the denominator, we enforce |A| == |B|
-    let containment: f64 = common as f64 / total as f64;
-    let jaccard: f64 = common as f64 / (common + 2 * (total - common)) as f64;
-    (containment, jaccard, common, total)
-}
-
 // TODO: add another method like this to allow 0's in ref sketch for hashes present in sketches?
 // TODO: maybe we want to do NNLS on these matrices in Rust? for example code, see:
 // https://github.com/igmanthony/fnnls/blob/master/src/fnnls.rs

lib/src/distance.rs

@@ -31,11 +31,7 @@ impl FilterParams {
                 Some(u32::max(l, sketch.filter_params.abun_filter.0.unwrap_or(0))),
                 Some(u32::min(
                     h,
-                    sketch
-                        .filter_params
-                        .abun_filter
-                        .1
-                        .unwrap_or(u32::max_value()),
+                    sketch.filter_params.abun_filter.1.unwrap_or(u32::MAX),
                 )),
             ),
             (Some(l), None) => (
@@ -46,11 +42,7 @@ impl FilterParams {
                 None,
                 Some(u32::min(
                     h,
-                    sketch
-                        .filter_params
-                        .abun_filter
-                        .1
-                        .unwrap_or(u32::max_value()),
+                    sketch.filter_params.abun_filter.1.unwrap_or(u32::MAX),
                 )),
             ),
             (None, None) => (None, None),
@@ -341,7 +333,7 @@ pub fn filter_abundance(
 ) -> Vec<KmerCount> {
     let mut filtered = Vec::new();
     let lo_threshold = low.unwrap_or(0u32);
-    let hi_threshold = high.unwrap_or(u32::max_value());
+    let hi_threshold = high.unwrap_or(u32::MAX);
     for kmer in sketch {
         if lo_threshold <= kmer.count && kmer.count <= hi_threshold {
             filtered.push(kmer.clone());

lib/src/filtering.rs

@@ -247,7 +247,7 @@ impl<'de> Deserialize<'de> for QuotedU64 {
     {
         struct QuotedU64Visitor;
 
-        impl<'de> Visitor<'de> for QuotedU64Visitor {
+        impl Visitor<'_> for QuotedU64Visitor {
             type Value = QuotedU64;
 
             fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {

lib/src/serialization/json.rs

@@ -151,13 +151,8 @@ pub fn write_finch_file(file: &mut dyn Write, sketches: &[Sketch]) -> FinchResul
         let mut cap_filter_params = cap_sketch.reborrow().init_filter_params();
         cap_filter_params.set_filtered(sketch.filter_params.filter_on.unwrap_or(false));
         cap_filter_params.set_low_abun_filter(sketch.filter_params.abun_filter.0.unwrap_or(0));
-        cap_filter_params.set_high_abun_filter(
-            sketch
-                .filter_params
-                .abun_filter
-                .1
-                .unwrap_or(::std::u32::MAX),
-        );
+        cap_filter_params
+            .set_high_abun_filter(sketch.filter_params.abun_filter.1.unwrap_or(u32::MAX));
         cap_filter_params.set_err_filter(sketch.filter_params.err_filter);
         cap_filter_params.set_strand_filter(sketch.filter_params.strand_filter);
 

lib/src/serialization/mod.rs

@@ -1,6 +1,5 @@
 use std::collections::{BinaryHeap, HashMap};
 use std::hash::BuildHasherDefault;
-use std::usize;
 
 use needletail::Sequence;
 

lib/src/sketch_schemes/mash.rs

@@ -1,6 +1,5 @@
 use std::collections::{BinaryHeap, HashMap};
 use std::hash::BuildHasherDefault;
-use std::usize;
 
 use needletail::Sequence;
 
@@ -29,7 +28,7 @@ impl ScaledSketcher {
             total_kmers: 0,
             total_bases: 0,
             size,
-            max_hash: u64::max_value() / iscale,
+            max_hash: u64::MAX / iscale,
             seed,
         }
     }

lib/src/sketch_schemes/scaled.rs

@@ -16,8 +16,10 @@ pub fn cardinality(sketch: &[KmerCount]) -> Result<u64, &'static str> {
     if sketch.is_empty() {
         return Ok(0u64);
     }
-    Ok(((sketch.len() - 1) as f32
-        / (sketch.last().unwrap().hash as f32 / usize::max_value() as f32)) as u64)
+    Ok(
+        ((sketch.len() - 1) as f32 / (sketch.last().unwrap().hash as f32 / usize::MAX as f32))
+            as u64,
+    )
 }
 
 /// Generates a Vec of numbers of kmers for each coverage level