Fix Clippy Warnings

nalgebra-sparse/src/cs.rs

@@ -1,4 +1,3 @@
-use std::mem::replace;
 use std::ops::Range;
 
 use num_traits::One;
@@ -360,7 +359,7 @@ where
         if let Some(minor_indices) = lane {
             let count = minor_indices.len();
 
-            let remaining = replace(&mut self.remaining_values, &mut []);
+            let remaining = std::mem::take(&mut self.remaining_values);
             let (values_in_lane, remaining) = remaining.split_at_mut(count);
             self.remaining_values = remaining;
             self.current_lane_idx += 1;
@@ -569,7 +568,7 @@ where
     } else if sort {
         unreachable!("Internal error: Sorting currently not supported if no values are present.");
     }
-    if major_offsets.len() == 0 {
+    if major_offsets.is_empty() {
         return Err(SparseFormatError::from_kind_and_msg(
             SparseFormatErrorKind::InvalidStructure,
             "Number of offsets should be greater than 0.",
@@ -615,12 +614,12 @@ where
                 ));
             }
 
-            let minor_idx_in_lane = minor_indices.get(range_start..range_end).ok_or(
+            let minor_idx_in_lane = minor_indices.get(range_start..range_end).ok_or_else(|| {
                 SparseFormatError::from_kind_and_msg(
                     SparseFormatErrorKind::IndexOutOfBounds,
                     "A major offset is out of bounds.",
-                ),
-            )?;
+                )
+            })?;
 
             // We test for in-bounds, uniqueness and monotonicity at the same time
             // to ensure that we only visit each minor index once
@@ -653,9 +652,9 @@ where
             if !monotonic && sort {
                 let range_size = range_end - range_start;
                 minor_index_permutation.resize(range_size, 0);
-                compute_sort_permutation(&mut minor_index_permutation, &minor_idx_in_lane);
+                compute_sort_permutation(&mut minor_index_permutation, minor_idx_in_lane);
                 minor_idx_buffer.clear();
-                minor_idx_buffer.extend_from_slice(&minor_idx_in_lane);
+                minor_idx_buffer.extend_from_slice(minor_idx_in_lane);
                 apply_permutation(
                     &mut minor_indices[range_start..range_end],
                     &minor_idx_buffer,

nalgebra-sparse/src/ops/impl_std_ops.rs

@@ -59,7 +59,7 @@ macro_rules! impl_sp_plus_minus {
             let mut result = $matrix_type::try_from_pattern_and_values(pattern, values)
                 .unwrap();
             $spadd_fn(T::zero(), &mut result, T::one(), Op::NoOp(&a)).unwrap();
-            $spadd_fn(T::one(), &mut result, $factor * T::one(), Op::NoOp(&b)).unwrap();
+            $spadd_fn(T::one(), &mut result, $factor, Op::NoOp(&b)).unwrap();
             result
         });
 

nalgebra-sparse/src/ops/mod.rs

@@ -149,8 +149,8 @@ impl<T> Op<T> {
     #[must_use]
     pub fn as_ref(&self) -> Op<&T> {
         match self {
-            Op::NoOp(obj) => Op::NoOp(&obj),
-            Op::Transpose(obj) => Op::Transpose(&obj),
+            Op::NoOp(obj) => Op::NoOp(obj),
+            Op::Transpose(obj) => Op::Transpose(obj),
         }
     }
 

nalgebra-sparse/src/ops/serial/csc.rs

@@ -88,7 +88,7 @@ where
     use Op::NoOp;
 
     match (&a, &b) {
-        (NoOp(ref a), NoOp(ref b)) => {
+        (NoOp(a), NoOp(b)) => {
             // Note: We have to reverse the order for CSC matrices
             spmm_cs_prealloc(beta, &mut c.cs, alpha, &b.cs, &a.cs)
         }
@@ -116,7 +116,7 @@ where
     use Op::NoOp;
 
     match (&a, &b) {
-        (NoOp(ref a), NoOp(ref b)) => {
+        (NoOp(a), NoOp(b)) => {
             // Note: We have to reverse the order for CSC matrices
             spmm_cs_prealloc_unchecked(beta, &mut c.cs, alpha, &b.cs, &a.cs)
         }
@@ -152,9 +152,9 @@ where
         use Cow::*;
         match (&a, &b) {
             (NoOp(_), NoOp(_)) => unreachable!(),
-            (Transpose(ref a), NoOp(_)) => (Owned(a.transpose()), Borrowed(b_ref)),
-            (NoOp(_), Transpose(ref b)) => (Borrowed(a_ref), Owned(b.transpose())),
-            (Transpose(ref a), Transpose(ref b)) => (Owned(a.transpose()), Owned(b.transpose())),
+            (Transpose(a), NoOp(_)) => (Owned(a.transpose()), Borrowed(b_ref)),
+            (NoOp(_), Transpose(b)) => (Borrowed(a_ref), Owned(b.transpose())),
+            (Transpose(a), Transpose(b)) => (Owned(a.transpose()), Owned(b.transpose())),
         }
     };
     spmm_kernel(beta, c, alpha, NoOp(a.as_ref()), NoOp(b.as_ref()))

nalgebra-sparse/src/ops/serial/csr.rs

@@ -82,7 +82,7 @@ where
     use Op::NoOp;
 
     match (&a, &b) {
-        (NoOp(ref a), NoOp(ref b)) => spmm_cs_prealloc(beta, &mut c.cs, alpha, &a.cs, &b.cs),
+        (NoOp(a), NoOp(b)) => spmm_cs_prealloc(beta, &mut c.cs, alpha, &a.cs, &b.cs),
         _ => spmm_csr_transposed(beta, c, alpha, a, b, spmm_csr_prealloc),
     }
 }
@@ -107,9 +107,7 @@ where
     use Op::NoOp;
 
     match (&a, &b) {
-        (NoOp(ref a), NoOp(ref b)) => {
-            spmm_cs_prealloc_unchecked(beta, &mut c.cs, alpha, &a.cs, &b.cs)
-        }
+        (NoOp(a), NoOp(b)) => spmm_cs_prealloc_unchecked(beta, &mut c.cs, alpha, &a.cs, &b.cs),
         _ => spmm_csr_transposed(beta, c, alpha, a, b, spmm_csr_prealloc_unchecked),
     }
 }
@@ -142,9 +140,9 @@ where
         use Cow::*;
         match (&a, &b) {
             (NoOp(_), NoOp(_)) => unreachable!(),
-            (Transpose(ref a), NoOp(_)) => (Owned(a.transpose()), Borrowed(b_ref)),
-            (NoOp(_), Transpose(ref b)) => (Borrowed(a_ref), Owned(b.transpose())),
-            (Transpose(ref a), Transpose(ref b)) => (Owned(a.transpose()), Owned(b.transpose())),
+            (Transpose(a), NoOp(_)) => (Owned(a.transpose()), Borrowed(b_ref)),
+            (NoOp(_), Transpose(b)) => (Borrowed(a_ref), Owned(b.transpose())),
+            (Transpose(a), Transpose(b)) => (Owned(a.transpose()), Owned(b.transpose())),
         }
     };
     spmm_kernel(beta, c, alpha, NoOp(a.as_ref()), NoOp(b.as_ref()))

nalgebra-sparse/src/ops/serial/pattern.rs

@@ -125,18 +125,22 @@ fn iterate_union<'a>(
 ) -> impl Iterator<Item = usize> + 'a {
     iter::from_fn(move || {
         if let (Some(a_item), Some(b_item)) = (sorted_a.first(), sorted_b.first()) {
-            let item = if a_item < b_item {
-                sorted_a = &sorted_a[1..];
-                a_item
-            } else if b_item < a_item {
-                sorted_b = &sorted_b[1..];
-                b_item
-            } else {
-                // Both lists contain the same element, advance both slices to avoid
-                // duplicate entries in the result
-                sorted_a = &sorted_a[1..];
-                sorted_b = &sorted_b[1..];
-                a_item
+            let item = match a_item.cmp(b_item) {
+                std::cmp::Ordering::Less => {
+                    sorted_a = &sorted_a[1..];
+                    a_item
+                }
+                std::cmp::Ordering::Greater => {
+                    sorted_b = &sorted_b[1..];
+                    b_item
+                }
+                std::cmp::Ordering::Equal => {
+                    // Both lists contain the same element, advance both slices to avoid
+                    // duplicate entries in the result
+                    sorted_a = &sorted_a[1..];
+                    sorted_b = &sorted_b[1..];
+                    a_item
+                }
             };
             Some(*item)
         } else if let Some(a_item) = sorted_a.first() {

nalgebra-sparse/src/pattern.rs

@@ -80,7 +80,7 @@ impl SparsityPattern {
     #[inline]
     #[must_use]
     pub fn major_dim(&self) -> usize {
-        assert!(self.major_offsets.len() > 0);
+        assert!(!self.major_offsets.is_empty());
         self.major_offsets.len() - 1
     }
 
@@ -162,18 +162,18 @@ impl SparsityPattern {
                 // We test for in-bounds, uniqueness and monotonicity at the same time
                 // to ensure that we only visit each minor index once
                 let mut iter = minor_indices.iter();
-                let mut prev = None;
+                let mut prev: Option<usize> = None;
 
                 while let Some(next) = iter.next().copied() {
                     if next >= minor_dim {
                         return Err(MinorIndexOutOfBounds);
                     }
 
                     if let Some(prev) = prev {
-                        if prev > next {
-                            return Err(NonmonotonicMinorIndices);
-                        } else if prev == next {
-                            return Err(DuplicateEntry);
+                        match prev.cmp(&next) {
+                            std::cmp::Ordering::Greater => return Err(NonmonotonicMinorIndices),
+                            std::cmp::Ordering::Equal => return Err(DuplicateEntry),
+                            std::cmp::Ordering::Less => {}
                         }
                     }
                     prev = Some(next);
@@ -195,6 +195,14 @@ impl SparsityPattern {
     ///
     /// Panics if the number of major offsets is not exactly one greater than the major dimension
     /// or if major offsets do not start with 0 and end with the number of minor indices.
+    ///
+    /// # Safety
+    ///
+    /// Assumes that the major offsets and indices adhere to the requirements of being a valid
+    /// sparsity pattern.
+    /// Specifically, that major offsets is monotonically increasing, and
+    /// `major_offsets[i]..major_offsets[i+1]` refers to a major lane in the sparsity pattern,
+    /// and `minor_indices[major_offsets[i]..major_offsets[i+1]]` is monotonically increasing.
     pub unsafe fn from_offset_and_indices_unchecked(
         major_dim: usize,
         minor_dim: usize,