Various refactorings

nalgebra-glm/src/ext/quaternion_trigonometric.rs

@@ -1,7 +1,6 @@
 use na::{Unit, UnitQuaternion};
 
 use crate::aliases::{Qua, TVec3};
-use crate::RealNumber;
 
 /// The rotation angle of this quaternion assumed to be normalized.
 pub fn quat_angle<T: RealNumber>(x: &Qua<T>) -> T {
@@ -15,9 +14,8 @@ pub fn quat_angle_axis<T: RealNumber>(angle: T, axis: &TVec3<T>) -> Qua<T> {
 
 /// The rotation axis of a quaternion assumed to be normalized.
 pub fn quat_axis<T: RealNumber>(x: &Qua<T>) -> TVec3<T> {
-    if let Some(a) = UnitQuaternion::from_quaternion(*x).axis() {
-        a.into_inner()
-    } else {
-        TVec3::zeros()
-    }
+    UnitQuaternion::from_quaternion(*x)
+        .axis()
+        .map(|a| a.into_inner())
+        .unwrap_or_else(|| TVec3::zeros())
 }

nalgebra-glm/src/gtx/rotate_vector.rs

@@ -5,11 +5,9 @@ use crate::RealNumber;
 
 /// Build the rotation matrix needed to align `normal` and `up`.
 pub fn orientation<T: RealNumber>(normal: &TVec3<T>, up: &TVec3<T>) -> TMat4<T> {
-    if let Some(r) = Rotation3::rotation_between(normal, up) {
-        r.to_homogeneous()
-    } else {
-        TMat4::identity()
-    }
+    Rotation3::rotation_between(normal, up)
+        .map(|x| r.homogenous())
+        .unwrap_or(|| TMat4::identity())
 }
 
 /// Rotate a two dimensional vector.

nalgebra-sparse/src/cs.rs

@@ -321,20 +321,19 @@ where
         let lane = self.pattern.get_lane(self.current_lane_idx);
         let minor_dim = self.pattern.minor_dim();
 
-        if let Some(minor_indices) = lane {
-            let count = minor_indices.len();
-            let values_in_lane = &self.remaining_values[..count];
-            self.remaining_values = &self.remaining_values[count..];
-            self.current_lane_idx += 1;
-
-            Some(CsLane {
-                minor_dim,
-                minor_indices,
-                values: values_in_lane,
-            })
-        } else {
-            None
-        }
+        let Some(minor_indices) = lane else {
+            return None;
+        };
+        let count = minor_indices.len();
+        let values_in_lane = &self.remaining_values[..count];
+        self.remaining_values = &self.remaining_values[count..];
+        self.current_lane_idx += 1;
+
+        Some(CsLane {
+            minor_dim,
+            minor_indices,
+            values: values_in_lane,
+        })
     }
 }
 
@@ -365,22 +364,21 @@ where
         let lane = self.pattern.get_lane(self.current_lane_idx);
         let minor_dim = self.pattern.minor_dim();
 
-        if let Some(minor_indices) = lane {
-            let count = minor_indices.len();
-
-            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;
-
-            Some(CsLaneMut {
-                minor_dim,
-                minor_indices,
-                values: values_in_lane,
-            })
-        } else {
-            None
-        }
+        let Some(minor_indices) = lane else {
+            return None;
+        };
+        let count = minor_indices.len();
+
+        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;
+
+        Some(CsLaneMut {
+            minor_dim,
+            minor_indices,
+            values: values_in_lane,
+        })
     }
 }
 

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

@@ -212,31 +212,29 @@ fn spsolve_csc_lower_triangular_no_transpose<T: RealField>(
             // and the matrix might actually *be* lower triangular, which would induce
             // a severe penalty)
             let diag_csc_index = l_col_k.row_indices().iter().position(|&i| i == k);
-            if let Some(diag_csc_index) = diag_csc_index {
-                let l_kk = l_col_k.values()[diag_csc_index].clone();
-
-                if l_kk != T::zero() {
-                    // Update entry associated with diagonal
-                    x_col_j[k] /= l_kk;
-                    // Copy value after updating (so we don't run into the borrow checker)
-                    let x_kj = x_col_j[k].clone();
-
-                    let row_indices = &l_col_k.row_indices()[(diag_csc_index + 1)..];
-                    let l_values = &l_col_k.values()[(diag_csc_index + 1)..];
-
-                    // Note: The remaining entries are below the diagonal
-                    for (&i, l_ik) in row_indices.iter().zip(l_values) {
-                        let x_ij = &mut x_col_j[i];
-                        *x_ij -= l_ik.clone() * x_kj.clone();
-                    }
-
-                    x_col_j[k] = x_kj;
-                } else {
-                    return spsolve_encountered_zero_diagonal();
-                }
-            } else {
+            let Some(diag_csc_index) = diag_csc_index else {
                 return spsolve_encountered_zero_diagonal();
+            };
+            let l_kk = l_col_k.values()[diag_csc_index].clone();
+
+            if l_kk.is_zero() {
+                return spsolve_encountered_zero_diagonal();
+            }
+            // Update entry associated with diagonal
+            x_col_j[k] /= l_kk;
+            // Copy value after updating (so we don't run into the borrow checker)
+            let x_kj = x_col_j[k].clone();
+
+            let row_indices = &l_col_k.row_indices()[(diag_csc_index + 1)..];
+            let l_values = &l_col_k.values()[(diag_csc_index + 1)..];
+
+            // Note: The remaining entries are below the diagonal
+            for (&i, l_ik) in row_indices.iter().zip(l_values) {
+                let x_ij = &mut x_col_j[i];
+                *x_ij -= l_ik.clone() * x_kj.clone();
             }
+
+            x_col_j[k] = x_kj;
         }
     }
 
@@ -270,32 +268,30 @@ fn spsolve_csc_lower_triangular_transpose<T: RealField>(
             // Skip entries above the diagonal
             // TODO: Can use exponential search here to quickly skip entries
             let diag_csc_index = l_col_i.row_indices().iter().position(|&k| i == k);
-            if let Some(diag_csc_index) = diag_csc_index {
-                let l_ii = l_col_i.values()[diag_csc_index].clone();
-
-                if l_ii != T::zero() {
-                    // // Update entry associated with diagonal
-                    // x_col_j[k] /= a_kk;
-
-                    // Copy value after updating (so we don't run into the borrow checker)
-                    let mut x_ii = x_col_j[i].clone();
-
-                    let row_indices = &l_col_i.row_indices()[(diag_csc_index + 1)..];
-                    let a_values = &l_col_i.values()[(diag_csc_index + 1)..];
-
-                    // Note: The remaining entries are below the diagonal
-                    for (k, l_ki) in row_indices.iter().zip(a_values) {
-                        let x_kj = x_col_j[*k].clone();
-                        x_ii -= l_ki.clone() * x_kj;
-                    }
-
-                    x_col_j[i] = x_ii / l_ii;
-                } else {
-                    return spsolve_encountered_zero_diagonal();
-                }
-            } else {
+            let Some(diag_csc_index) = diag_csc_index else {
+                return spsolve_encountered_zero_diagonal();
+            };
+            let l_ii = l_col_i.values()[diag_csc_index].clone();
+
+            if l_ii.is_zero() {
                 return spsolve_encountered_zero_diagonal();
             }
+            // // Update entry associated with diagonal
+            // x_col_j[k] /= a_kk;
+
+            // Copy value after updating (so we don't run into the borrow checker)
+            let mut x_ii = x_col_j[i].clone();
+
+            let row_indices = &l_col_i.row_indices()[(diag_csc_index + 1)..];
+            let a_values = &l_col_i.values()[(diag_csc_index + 1)..];
+
+            // Note: The remaining entries are below the diagonal
+            for (k, l_ki) in row_indices.iter().zip(a_values) {
+                let x_kj = x_col_j[*k].clone();
+                x_ii -= l_ki.clone() * x_kj;
+            }
+
+            x_col_j[i] = x_ii / l_ii;
         }
     }
 

src/base/ops.rs

@@ -398,11 +398,13 @@ where
     /// iter::empty::<DMatrix<f64>>().sum::<DMatrix<f64>>(); // panics!
     /// ```
     fn sum<I: Iterator<Item = OMatrix<T, Dyn, C>>>(mut iter: I) -> OMatrix<T, Dyn, C> {
-        if let Some(first) = iter.next() {
-            iter.fold(first, |acc, x| acc + x)
-        } else {
-            panic!("Cannot compute `sum` of empty iterator.")
+        let mut ret = iter
+            .next()
+            .expect("Cannot compute `sum` of empty iterator.");
+        while let Some(next) = iter.next() {
+            ret += next;
         }
+        ret
     }
 }
 

src/geometry/isometry.rs

@@ -14,8 +14,6 @@ use crate::base::storage::Owned;
 use crate::base::{Const, DefaultAllocator, OMatrix, SVector, Scalar, Unit};
 use crate::geometry::{AbstractRotation, Point, Translation};
 
-use crate::{Isometry3, Quaternion, Vector3, Vector4};
-
 #[cfg(feature = "rkyv-serialize")]
 use rkyv::bytecheck;
 

src/geometry/quaternion.rs

@@ -66,7 +66,7 @@ impl<T: Scalar> PartialEq for Quaternion<T> {
 
 impl<T: Scalar + Zero> Default for Quaternion<T> {
     fn default() -> Self {
-        Quaternion {
+        Self {
             coords: Vector4::zeros(),
         }
     }
@@ -468,17 +468,14 @@ where
     where
         T: RealField,
     {
-        if let Some((q, n)) = Unit::try_new_and_get(self.clone(), T::zero()) {
-            if let Some(axis) = Unit::try_new(self.vector().clone_owned(), T::zero()) {
-                let angle = q.angle() / crate::convert(2.0f64);
-
-                (n, angle, Some(axis))
-            } else {
-                (n, T::zero(), None)
-            }
-        } else {
-            (T::zero(), T::zero(), None)
-        }
+        let Some((q, n)) = Unit::try_new_and_get(self.clone(), T::zero()) else {
+            return (T::zero(), T::zero(), None);
+        };
+        let Some(axis) = Unit::try_new(self.vector().clone_owned(), T::zero()) else {
+            return (n, T::zero(), None);
+        };
+        let angle = q.angle() / crate::convert(2.0f64);
+        (n, angle, Some(axis))
     }
 
     /// Compute the natural logarithm of a quaternion.
@@ -1319,11 +1316,9 @@ where
     where
         T: RealField,
     {
-        if let Some(axis) = self.axis() {
-            axis.into_inner() * self.angle()
-        } else {
-            Vector3::zero()
-        }
+        self.axis()
+            .map(|axis| axis.into_inner() * self.angle())
+            .unwrap_or_else(|| <_>::zero())
     }
 
     /// The rotation axis and angle in (0, pi] of this unit quaternion.
@@ -1380,11 +1375,7 @@ where
     where
         T: RealField,
     {
-        if let Some(v) = self.axis() {
-            Quaternion::from_imag(v.into_inner() * self.angle())
-        } else {
-            Quaternion::zero()
-        }
+        Quaternion::from_imag(self.scaled_axis())
     }
 
     /// Raise the quaternion to a given floating power.
@@ -1409,11 +1400,9 @@ where
     where
         T: RealField,
     {
-        if let Some(v) = self.axis() {
-            Self::from_axis_angle(&v, self.angle() * n)
-        } else {
-            Self::identity()
-        }
+        self.axis()
+            .map(|v| Self::from_axis_angle(&v, self.angle() * n))
+            .unwrap_or_else(|| Self::identity())
     }
 
     /// Builds a rotation matrix from this unit quaternion.

src/lib.rs

@@ -339,27 +339,13 @@ pub fn partial_ge<T: PartialOrd>(a: &T, b: &T) -> bool {
 /// Return the minimum of `a` and `b` if they are comparable.
 #[inline]
 pub fn partial_min<'a, T: PartialOrd>(a: &'a T, b: &'a T) -> Option<&'a T> {
-    if let Some(ord) = a.partial_cmp(b) {
-        match ord {
-            Ordering::Greater => Some(b),
-            _ => Some(a),
-        }
-    } else {
-        None
-    }
+    a.partial_cmp(b).map(|ord| if ord.is_ge() { b } else { a })
 }
 
 /// Return the maximum of `a` and `b` if they are comparable.
 #[inline]
 pub fn partial_max<'a, T: PartialOrd>(a: &'a T, b: &'a T) -> Option<&'a T> {
-    if let Some(ord) = a.partial_cmp(b) {
-        match ord {
-            Ordering::Less => Some(b),
-            _ => Some(a),
-        }
-    } else {
-        None
-    }
+    a.partial_cmp(b).map(|ord| if ord.is_le() { b } else { a })
 }
 
 /// Clamp `value` between `min` and `max`. Returns `None` if `value` is not comparable to
@@ -382,14 +368,8 @@ pub fn partial_clamp<'a, T: PartialOrd>(value: &'a T, min: &'a T, max: &'a T) ->
 /// Sorts two values in increasing order using a partial ordering.
 #[inline]
 pub fn partial_sort2<'a, T: PartialOrd>(a: &'a T, b: &'a T) -> Option<(&'a T, &'a T)> {
-    if let Some(ord) = a.partial_cmp(b) {
-        match ord {
-            Ordering::Less => Some((a, b)),
-            _ => Some((b, a)),
-        }
-    } else {
-        None
-    }
+    a.partial_cmp(b)
+        .map(|ord| if ord.is_le() { (a, b) } else { (b, a) })
 }
 
 /*