fix or silence clippy lints in workspace

Author: mulimoen

sprs-benches/src/main.rs

@@ -164,7 +164,7 @@ fn bench_densities() -> Result<(), Box<dyn std::error::Error>> {
     for spec in &bench_specs {
         let shape = spec.shape;
 
-        let is_shape_bench = spec.shapes.len() != 0;
+        let is_shape_bench = !spec.shapes.is_empty();
         let densities = if is_shape_bench {
             spec.shapes
                 .iter()

sprs-ldl/src/lib.rs

@@ -78,6 +78,16 @@ pub struct Ldl {
     fill_red_method: FillInReduction,
 }
 
+impl Default for Ldl {
+    fn default() -> Self {
+        Self {
+            check_symmetry: SymmetryCheck::CheckSymmetry,
+            fill_red_method: FillInReduction::ReverseCuthillMcKee,
+            check_perm: PermutationCheck::CheckPerm,
+        }
+    }
+}
+
 /// Structure to compute and hold a symbolic LDLT decomposition
 #[derive(Debug, Clone)]
 pub struct LdlSymbolic<I> {
@@ -101,11 +111,7 @@ pub struct LdlNumeric<N, I> {
 
 impl Ldl {
     pub fn new() -> Self {
-        Self {
-            check_symmetry: SymmetryCheck::CheckSymmetry,
-            fill_red_method: FillInReduction::ReverseCuthillMcKee,
-            check_perm: PermutationCheck::CheckPerm,
-        }
+        Self::default()
     }
 
     pub fn check_symmetry(self, check: SymmetryCheck) -> Self {
@@ -257,10 +263,10 @@ impl<I: SpIndex> LdlSymbolic<I> {
 
         LdlSymbolic {
             colptr: l_colptr,
-            parents: parents,
+            parents,
             nz: l_nz,
-            flag_workspace: flag_workspace,
-            perm: perm,
+            flag_workspace,
+            perm,
         }
     }
 
@@ -294,11 +300,11 @@ impl<I: SpIndex> LdlSymbolic<I> {
         let pattern_workspace = DStack::with_capacity(n);
         let mut ldl_numeric = LdlNumeric {
             symbolic: self,
-            l_indices: l_indices,
-            l_data: l_data,
-            diag: diag,
-            y_workspace: y_workspace,
-            pattern_workspace: pattern_workspace,
+            l_indices,
+            l_data,
+            diag,
+            y_workspace,
+            pattern_workspace,
         };
         ldl_numeric.update(mat).map(|_| ldl_numeric)
     }
@@ -466,6 +472,7 @@ pub fn ldl_symbolic<N, I, PStorage>(
 /// Perform numeric LDLT decomposition
 ///
 /// pattern_workspace is a DStack of capacity n
+#[allow(clippy::too_many_arguments)]
 pub fn ldl_numeric<N, I, PStorage>(
     mat: CsMatViewI<N, I>,
     l_colptr: &[I],

src/sparse/binop.rs

@@ -87,7 +87,7 @@ pub fn csmat_binop<N, I, Iptr, F>(
     binop: F,
 ) -> CsMatI<N, I, Iptr>
 where
-    N: Num,
+    N: Num + Clone,
     I: SpIndex,
     Iptr: SpIndex,
     F: Fn(&N, &N) -> N,
@@ -109,10 +109,7 @@ where
     // Sadly the vec! macro requires Clone, but we don't want to force
     // Clone on our consumers, so we have to use this workaround.
     // This should compile to decent code however.
-    let mut out_data = Vec::with_capacity(max_nnz);
-    for _ in 0..max_nnz {
-        out_data.push(N::zero());
-    }
+    let mut out_data = vec![N::zero(); max_nnz];
 
     let nnz = csmat_binop_same_storage_raw(
         lhs,

src/sparse/csmat.rs

@@ -702,10 +702,7 @@ impl<N, I: SpIndex, Iptr: SpIndex>
         if outer_ind >= outer_dims {
             // we need to add a new outer dimension
             let last_nnz = *self.indptr.last().unwrap(); // indptr never empty
-            self.indptr.reserve(1 + outer_ind - outer_dims);
-            for _ in outer_dims..outer_ind {
-                self.indptr.push(last_nnz);
-            }
+            self.indptr.resize(outer_ind + 1, last_nnz);
             self.set_outer_dims(outer_ind + 1);
             self.indptr.push(last_nnz + Iptr::one());
             self.indices.push(inner_ind_idx);
@@ -2996,14 +2993,15 @@ mod approx_impls {
             } else {
                 // Checks if all elements in self has a matching element
                 // in other
-                if !self.iter().all(|(n, (i, j))| {
+                let all_matching = self.iter().all(|(n, (i, j))| {
                     n.abs_diff_eq(
                         other
                             .get(i.to_usize().unwrap(), j.to_usize().unwrap())
                             .unwrap_or(&N::zero()),
                         epsilon.clone(),
                     )
-                }) {
+                });
+                if !all_matching {
                     return false;
                 }
 
@@ -3055,15 +3053,16 @@ mod approx_impls {
             } else {
                 // Checks if all elements in self has a matching element
                 // in other
-                if !self.iter().all(|(n, (i, j))| {
+                let all_matches = self.iter().all(|(n, (i, j))| {
                     n.ulps_eq(
                         other
                             .get(i.to_usize().unwrap(), j.to_usize().unwrap())
                             .unwrap_or(&N::zero()),
                         epsilon.clone(),
                         max_ulps,
                     )
-                }) {
+                });
+                if !all_matches {
                     return false;
                 }
 
@@ -3122,15 +3121,16 @@ mod approx_impls {
             } else {
                 // Checks if all elements in self has a matching element
                 // in other
-                if !self.iter().all(|(n, (i, j))| {
+                let all_matches = self.iter().all(|(n, (i, j))| {
                     n.relative_eq(
                         other
                             .get(i.to_usize().unwrap(), j.to_usize().unwrap())
                             .unwrap_or(&N::zero()),
                         epsilon.clone(),
                         max_relative.clone(),
                     )
-                }) {
+                });
+                if !all_matches {
                     return false;
                 }
 

src/sparse/smmp.rs

@@ -78,6 +78,7 @@ pub fn thread_threading_strategy() -> ThreadingStrategy {
 /// `a_indptr.last().unwrap() + b_indptr.last.unwrap()` in `c_indices`.
 /// Therefore, to prevent this function from allocating, it is required
 /// to have reserved at least this amount of memory.
+#[allow(clippy::too_many_arguments)]
 pub fn symbolic<Iptr: SpIndex, I: SpIndex>(
     a_indptr: &[Iptr],
     a_indices: &[I],
@@ -152,6 +153,7 @@ pub fn symbolic<Iptr: SpIndex, I: SpIndex>(
 /// (though some cases might go unnoticed).
 ///
 /// The parts for the C matrix should come from the `symbolic` function.
+#[allow(clippy::too_many_arguments)]
 pub fn numeric<
     Iptr: SpIndex,
     I: SpIndex,

src/sparse/vec.rs

@@ -183,6 +183,7 @@ pub trait SparseIterTools: Iterator {
     /// assert_eq!(nnz_zip.next(), Some((2, &2., &-2.)));
     /// assert_eq!(nnz_zip.next(), None);
     /// ```
+    #[allow(clippy::type_complexity)]
     fn nnz_zip<'a, I, N1, N2>(
         self,
         other: I,

suitesparse_bindings/sprs_suitesparse_ldl/src/lib.rs

@@ -106,9 +106,9 @@ macro_rules! ldl_impl {
                     lp: vec![0; n + 1],
                     parent: vec![0; n],
                     lnz: vec![0; n],
-                    flag: flag,
-                    p: p,
-                    pinv: pinv,
+                    flag,
+                    p,
+                    pinv,
                 };
                 unsafe {
                     $symbolic(
@@ -162,11 +162,11 @@ macro_rules! ldl_impl {
                 let pattern = vec![0; n];
                 let mut ldl_numeric = $Numeric {
                     symbolic: self,
-                    li: li,
-                    lx: lx,
-                    d: d,
-                    y: y,
-                    pattern: pattern,
+                    li,
+                    lx,
+                    d,
+                    y,
+                    pattern,
                 };
                 ldl_numeric.update(mat).map(|_| ldl_numeric)
             }