From 3e8e5d2a68956dd39d75d4bb350ad8331170326f Mon Sep 17 00:00:00 2001 From: adamnemecek Date: Sat, 4 Jan 2025 20:19:50 -0800 Subject: [PATCH 01/17] refactoring in Quaternion, perf improvement in OMatrix:::sum, use let-else --- nalgebra-glm/src/gtx/rotate_vector.rs | 8 ++-- nalgebra-sparse/src/ops/serial/csc.rs | 42 +++++++++--------- src/base/ops.rs | 10 +++-- src/geometry/isometry.rs | 2 - src/geometry/quaternion.rs | 43 +++++++------------ src/linalg/symmetric_eigen.rs | 61 +++++++++++++-------------- 6 files changed, 75 insertions(+), 91 deletions(-) diff --git a/nalgebra-glm/src/gtx/rotate_vector.rs b/nalgebra-glm/src/gtx/rotate_vector.rs index 213adb559..0e512df74 100644 --- a/nalgebra-glm/src/gtx/rotate_vector.rs +++ b/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(normal: &TVec3, up: &TVec3) -> TMat4 { - 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. diff --git a/nalgebra-sparse/src/ops/serial/csc.rs b/nalgebra-sparse/src/ops/serial/csc.rs index a7a9104c5..186451757 100644 --- a/nalgebra-sparse/src/ops/serial/csc.rs +++ b/nalgebra-sparse/src/ops/serial/csc.rs @@ -212,31 +212,29 @@ fn spsolve_csc_lower_triangular_no_transpose( // 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(); - } + 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(); - x_col_j[k] = x_kj; - } else { - return spsolve_encountered_zero_diagonal(); - } - } else { + 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; } } diff --git a/src/base/ops.rs b/src/base/ops.rs index 882599570..7f9a8dcec 100644 --- a/src/base/ops.rs +++ b/src/base/ops.rs @@ -398,11 +398,13 @@ where /// iter::empty::>().sum::>(); // panics! /// ``` fn sum>>(mut iter: I) -> OMatrix { - 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 } } diff --git a/src/geometry/isometry.rs b/src/geometry/isometry.rs index 3fd3a014c..c52fa9877 100644 --- a/src/geometry/isometry.rs +++ b/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; diff --git a/src/geometry/quaternion.rs b/src/geometry/quaternion.rs index 160cb5455..7b13f4158 100644 --- a/src/geometry/quaternion.rs +++ b/src/geometry/quaternion.rs @@ -66,7 +66,7 @@ impl PartialEq for Quaternion { impl Default for Quaternion { 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. diff --git a/src/linalg/symmetric_eigen.rs b/src/linalg/symmetric_eigen.rs index 986d5383e..70fe2d70d 100644 --- a/src/linalg/symmetric_eigen.rs +++ b/src/linalg/symmetric_eigen.rs @@ -151,38 +151,37 @@ where for i in start..n { let j = i + 1; - if let Some((rot, norm)) = GivensRotation::cancel_y(&vec) { - if i > start { - // Not the first iteration. - off_diag[i - 1] = norm; - } - - let mii = diag[i].clone(); - let mjj = diag[j].clone(); - let mij = off_diag[i].clone(); - - let cc = rot.c() * rot.c(); - let ss = rot.s() * rot.s(); - let cs = rot.c() * rot.s(); - - let b = cs.clone() * crate::convert(2.0) * mij.clone(); - - diag[i] = (cc.clone() * mii.clone() + ss.clone() * mjj.clone()) - b.clone(); - diag[j] = (ss.clone() * mii.clone() + cc.clone() * mjj.clone()) + b; - off_diag[i] = cs * (mii - mjj) + mij * (cc - ss); - - if i != n - 1 { - vec.x = off_diag[i].clone(); - vec.y = -rot.s() * off_diag[i + 1].clone(); - off_diag[i + 1] *= rot.c(); - } - - if let Some(ref mut q) = q_mat { - let rot = GivensRotation::new_unchecked(rot.c(), T::from_real(rot.s())); - rot.inverse().rotate_rows(&mut q.fixed_columns_mut::<2>(i)); - } - } else { + let Some((rot, norm)) = GivensRotation::cancel_y(&vec) else { break; + }; + if i > start { + // Not the first iteration. + off_diag[i - 1] = norm; + } + + let mii = diag[i].clone(); + let mjj = diag[j].clone(); + let mij = off_diag[i].clone(); + + let cc = rot.c() * rot.c(); + let ss = rot.s() * rot.s(); + let cs = rot.c() * rot.s(); + + let b = cs.clone() * crate::convert(2.0) * mij.clone(); + + diag[i] = (cc.clone() * mii.clone() + ss.clone() * mjj.clone()) - b.clone(); + diag[j] = (ss.clone() * mii.clone() + cc.clone() * mjj.clone()) + b; + off_diag[i] = cs * (mii - mjj) + mij * (cc - ss); + + if i != n - 1 { + vec.x = off_diag[i].clone(); + vec.y = -rot.s() * off_diag[i + 1].clone(); + off_diag[i + 1] *= rot.c(); + } + + if let Some(ref mut q) = q_mat { + let rot = GivensRotation::new_unchecked(rot.c(), T::from_real(rot.s())); + rot.inverse().rotate_rows(&mut q.fixed_columns_mut::<2>(i)); } } From 8d6129cf6bd4b71a4ec6b054b9b92281bb4b9b36 Mon Sep 17 00:00:00 2001 From: adamnemecek Date: Sat, 4 Jan 2025 20:36:10 -0800 Subject: [PATCH 02/17] refactoring --- .../src/ext/quaternion_trigonometric.rs | 10 ++-- nalgebra-sparse/src/cs.rs | 58 +++++++++---------- nalgebra-sparse/src/ops/serial/csc.rs | 46 +++++++-------- src/lib.rs | 28 ++------- 4 files changed, 58 insertions(+), 84 deletions(-) diff --git a/nalgebra-glm/src/ext/quaternion_trigonometric.rs b/nalgebra-glm/src/ext/quaternion_trigonometric.rs index 59d37e03b..51148adbf 100644 --- a/nalgebra-glm/src/ext/quaternion_trigonometric.rs +++ b/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(x: &Qua) -> T { @@ -15,9 +14,8 @@ pub fn quat_angle_axis(angle: T, axis: &TVec3) -> Qua { /// The rotation axis of a quaternion assumed to be normalized. pub fn quat_axis(x: &Qua) -> TVec3 { - 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()) } diff --git a/nalgebra-sparse/src/cs.rs b/nalgebra-sparse/src/cs.rs index 30bdc9b89..aca6dd305 100644 --- a/nalgebra-sparse/src/cs.rs +++ b/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, + }) } } diff --git a/nalgebra-sparse/src/ops/serial/csc.rs b/nalgebra-sparse/src/ops/serial/csc.rs index 186451757..58bc247d6 100644 --- a/nalgebra-sparse/src/ops/serial/csc.rs +++ b/nalgebra-sparse/src/ops/serial/csc.rs @@ -268,32 +268,30 @@ fn spsolve_csc_lower_triangular_transpose( // 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; } } diff --git a/src/lib.rs b/src/lib.rs index 4cfa63319..07050a9af 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -339,27 +339,13 @@ pub fn partial_ge(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) }) } /* From 497f28387164bbc19bfd5d2fe4fe64751364a31d Mon Sep 17 00:00:00 2001 From: adamnemecek Date: Sat, 4 Jan 2025 20:40:23 -0800 Subject: [PATCH 03/17] refactoring --- src/lib.rs | 29 +++++++++++++++-------------- 1 file changed, 15 insertions(+), 14 deletions(-) diff --git a/src/lib.rs b/src/lib.rs index 07050a9af..1dc16bf48 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -339,37 +339,38 @@ pub fn partial_ge(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> { - a.partial_cmp(b).map(|ord| if ord.is_ge() { b } else { a }) + a.partial_cmp(b).map(|ord| if ord.is_gt() { 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> { - a.partial_cmp(b).map(|ord| if ord.is_le() { b } else { a }) + a.partial_cmp(b).map(|ord| if ord.is_lt() { b } else { a }) } /// Clamp `value` between `min` and `max`. Returns `None` if `value` is not comparable to /// `min` or `max`. #[inline] pub fn partial_clamp<'a, T: PartialOrd>(value: &'a T, min: &'a T, max: &'a T) -> Option<&'a T> { - if let (Some(cmp_min), Some(cmp_max)) = (value.partial_cmp(min), value.partial_cmp(max)) { - if cmp_min == Ordering::Less { - Some(min) - } else if cmp_max == Ordering::Greater { - Some(max) - } else { - Some(value) - } - } else { - None - } + value + .partial_cmp(min) + .zip(value.partial_cmp(max)) + .map(|(cmp_min, cmp_max)| { + if cmp_min.is_lt() { + min + } else if cmp_max.is_gt() { + max + } else { + value + } + }) } /// 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)> { a.partial_cmp(b) - .map(|ord| if ord.is_le() { (a, b) } else { (b, a) }) + .map(|ord| if ord.is_lt() { (a, b) } else { (b, a) }) } /* From 6b569f24cfaadfacefe852f4b5142acf65bf8ba7 Mon Sep 17 00:00:00 2001 From: adamnemecek Date: Sat, 4 Jan 2025 20:55:16 -0800 Subject: [PATCH 04/17] refactoring --- nalgebra-sparse/src/io/matrix_market.rs | 49 ++++++++----------------- src/base/matrix.rs | 32 ++++++++-------- 2 files changed, 32 insertions(+), 49 deletions(-) diff --git a/nalgebra-sparse/src/io/matrix_market.rs b/nalgebra-sparse/src/io/matrix_market.rs index 975c586ed..f0d084c5a 100644 --- a/nalgebra-sparse/src/io/matrix_market.rs +++ b/nalgebra-sparse/src/io/matrix_market.rs @@ -237,9 +237,9 @@ pub enum MatrixMarketErrorKind { } impl MatrixMarketError { - fn from_kind_and_message(error_type: MatrixMarketErrorKind, message: String) -> Self { + fn from_kind_and_message(error_kind: MatrixMarketErrorKind, message: String) -> Self { Self { - error_kind: error_type, + error_kind, message, } } @@ -260,38 +260,21 @@ impl MatrixMarketError { impl fmt::Display for MatrixMarketError { fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result { write!(f, "Matrix Market error: ")?; - match self.kind() { - MatrixMarketErrorKind::ParsingError => { - write!(f, "ParsingError,")?; + write!( + f, + match self.kind() { + MatrixMarketErrorKind::ParsingError => "ParsingError,", + MatrixMarketErrorKind::InvalidHeader => "InvalidHeader,", + MatrixMarketErrorKind::EntryMismatch => "EntryMismatch,", + MatrixMarketErrorKind::TypeMismatch => "TypeMismatch,", + MatrixMarketErrorKind::SparseFormatError(_) => "SparseFormatError,", + MatrixMarketErrorKind::ZeroError => "ZeroError,", + MatrixMarketErrorKind::IOError(_) => "IOError,", + MatrixMarketErrorKind::DiagonalError => "DiagonalError,", + MatrixMarketErrorKind::NotLowerTriangle => "NotLowerTriangle,", + MatrixMarketErrorKind::NonSquare => "NonSquare,", } - MatrixMarketErrorKind::InvalidHeader => { - write!(f, "InvalidHeader,")?; - } - MatrixMarketErrorKind::EntryMismatch => { - write!(f, "EntryMismatch,")?; - } - MatrixMarketErrorKind::TypeMismatch => { - write!(f, "TypeMismatch,")?; - } - MatrixMarketErrorKind::SparseFormatError(_) => { - write!(f, "SparseFormatError,")?; - } - MatrixMarketErrorKind::ZeroError => { - write!(f, "ZeroError,")?; - } - MatrixMarketErrorKind::IOError(_) => { - write!(f, "IOError,")?; - } - MatrixMarketErrorKind::DiagonalError => { - write!(f, "DiagonalError,")?; - } - MatrixMarketErrorKind::NotLowerTriangle => { - write!(f, "NotLowerTriangle,")?; - } - MatrixMarketErrorKind::NonSquare => { - write!(f, "NonSquare,")?; - } - } + )?; write!(f, " message: {}", self.message) } } diff --git a/src/base/matrix.rs b/src/base/matrix.rs index 77f6c1c88..0ca96def8 100644 --- a/src/base/matrix.rs +++ b/src/base/matrix.rs @@ -1797,7 +1797,7 @@ where return None; } - if self.nrows() == 0 || self.ncols() == 0 { + if self.nrows().is_zero() || self.ncols().is_zero() { return Some(Ordering::Equal); } @@ -1812,24 +1812,24 @@ where let _ = it.next(); // Drop the first elements (we already tested it). for (left, right) in it { - if let Some(ord) = left.partial_cmp(right) { - match ord { - Ordering::Equal => { /* Does not change anything. */ } - Ordering::Less => { - if *first_ord == Ordering::Greater { - return None; - } - *first_ord = ord + let Some(ord) = left.partial_cmp(right) else { + return None; + }; + + match ord { + Ordering::Equal => { /* Does not change anything. */ } + Ordering::Less => { + if first_ord.is_gt() { + return None; } - Ordering::Greater => { - if *first_ord == Ordering::Less { - return None; - } - *first_ord = ord + *first_ord = ord + } + Ordering::Greater => { + if first_ord.is_lt() { + return None; } + *first_ord = ord } - } else { - return None; } } } From 24c8e3cf9da207bcecb048d65a7bfd75fe94c1aa Mon Sep 17 00:00:00 2001 From: adamnemecek Date: Sat, 4 Jan 2025 21:01:00 -0800 Subject: [PATCH 05/17] refactoring --- src/base/matrix.rs | 4 ++-- src/geometry/rotation_construction.rs | 2 +- src/geometry/scale_construction.rs | 4 ++-- 3 files changed, 5 insertions(+), 5 deletions(-) diff --git a/src/base/matrix.rs b/src/base/matrix.rs index 0ca96def8..6773c954e 100644 --- a/src/base/matrix.rs +++ b/src/base/matrix.rs @@ -559,7 +559,7 @@ impl> Matrix { ShapeConstraint: SameNumberOfRows + SameNumberOfColumns, { assert!(self.shape() == other.shape()); - self.iter().zip(other.iter()).all(|(a, b)| *a == *b) + self.iter().eq(other.iter()) } /// Moves this matrix into one that owns its data. @@ -1897,7 +1897,7 @@ where { #[inline] fn eq(&self, right: &Matrix) -> bool { - self.shape() == right.shape() && self.iter().zip(right.iter()).all(|(l, r)| l == r) + self.shape() == right.shape() && self.iter().eq(right.iter()) } } diff --git a/src/geometry/rotation_construction.rs b/src/geometry/rotation_construction.rs index 7204c0d44..a71e64239 100644 --- a/src/geometry/rotation_construction.rs +++ b/src/geometry/rotation_construction.rs @@ -39,7 +39,7 @@ where /// assert_eq!(rot2 * rot1, rot2); /// ``` #[inline] - pub fn identity() -> Rotation { + pub fn identity() -> Self { Self::from_matrix_unchecked(SMatrix::::identity()) } } diff --git a/src/geometry/scale_construction.rs b/src/geometry/scale_construction.rs index a7e1489c6..2bfaee741 100644 --- a/src/geometry/scale_construction.rs +++ b/src/geometry/scale_construction.rs @@ -31,11 +31,11 @@ impl Scale { /// assert_eq!(t * p, p); /// ``` #[inline] - pub fn identity() -> Scale + pub fn identity() -> Self where T: One, { - Scale::from(SVector::from_element(T::one())) + Self::from(SVector::from_element(T::one())) } /// Cast the components of `self` to another type. From b9e0ff9e94a46e1c927eee4e9ed2e7f801ca1137 Mon Sep 17 00:00:00 2001 From: adamnemecek Date: Sat, 4 Jan 2025 21:09:06 -0800 Subject: [PATCH 06/17] refactoring --- nalgebra-sparse/src/csc.rs | 45 ++++++++++--------------- nalgebra-sparse/src/csr.rs | 24 +++++-------- nalgebra-sparse/src/io/matrix_market.rs | 28 +++++++-------- src/geometry/transform.rs | 2 +- 4 files changed, 41 insertions(+), 58 deletions(-) diff --git a/nalgebra-sparse/src/csc.rs b/nalgebra-sparse/src/csc.rs index de4af43d6..2fe83de26 100644 --- a/nalgebra-sparse/src/csc.rs +++ b/nalgebra-sparse/src/csc.rs @@ -592,30 +592,27 @@ fn pattern_format_error_to_csc_error(err: SparsityPatternFormatError) -> SparseF use SparsityPatternFormatError::DuplicateEntry as PatternDuplicateEntry; use SparsityPatternFormatError::*; - match err { - InvalidOffsetArrayLength => E::from_kind_and_msg( + let (kind, msg) = match err { + InvalidOffsetArrayLength => ( K::InvalidStructure, "Length of col offset array is not equal to ncols + 1.", ), - InvalidOffsetFirstLast => E::from_kind_and_msg( + InvalidOffsetFirstLast => ( K::InvalidStructure, "First or last col offset is inconsistent with format specification.", ), - NonmonotonicOffsets => E::from_kind_and_msg( + NonmonotonicOffsets => ( K::InvalidStructure, "Col offsets are not monotonically increasing.", ), - NonmonotonicMinorIndices => E::from_kind_and_msg( + NonmonotonicMinorIndices => ( K::InvalidStructure, "Row indices are not monotonically increasing (sorted) within each column.", ), - MinorIndexOutOfBounds => { - E::from_kind_and_msg(K::IndexOutOfBounds, "Row indices are out of bounds.") - } - PatternDuplicateEntry => { - E::from_kind_and_msg(K::DuplicateEntry, "Matrix data contains duplicate entries.") - } - } + MinorIndexOutOfBounds => (K::IndexOutOfBounds, "Row indices are out of bounds."), + PatternDuplicateEntry => (K::DuplicateEntry, "Matrix data contains duplicate entries."), + }; + E::from_kind_and_msg(kind, msg) } /// Iterator type for iterating over triplets in a CSC matrix. @@ -627,7 +624,7 @@ pub struct CscTripletIter<'a, T> { impl<'a, T> Clone for CscTripletIter<'a, T> { fn clone(&self) -> Self { - CscTripletIter { + Self { pattern_iter: self.pattern_iter.clone(), values_iter: self.values_iter.clone(), } @@ -649,13 +646,10 @@ impl<'a, T> Iterator for CscTripletIter<'a, T> { type Item = (usize, usize, &'a T); fn next(&mut self) -> Option { - let next_entry = self.pattern_iter.next(); - let next_value = self.values_iter.next(); - - match (next_entry, next_value) { - (Some((i, j)), Some(v)) => Some((j, i, v)), - _ => None, - } + self.pattern_iter + .next() + .zip(self.values_iter.next()) + .map(|((i, j), v)| (j, i, v)) } } @@ -671,13 +665,10 @@ impl<'a, T> Iterator for CscTripletIterMut<'a, T> { #[inline] fn next(&mut self) -> Option { - let next_entry = self.pattern_iter.next(); - let next_value = self.values_mut_iter.next(); - - match (next_entry, next_value) { - (Some((i, j)), Some(v)) => Some((j, i, v)), - _ => None, - } + self.pattern_iter + .next() + .zip(self.values_mut_iter.next()) + .map(|((i, j), v)| (j, i, v)) } } diff --git a/nalgebra-sparse/src/csr.rs b/nalgebra-sparse/src/csr.rs index 7a38aeeb0..ac70d085b 100644 --- a/nalgebra-sparse/src/csr.rs +++ b/nalgebra-sparse/src/csr.rs @@ -628,7 +628,7 @@ pub struct CsrTripletIter<'a, T> { impl<'a, T> Clone for CsrTripletIter<'a, T> { fn clone(&self) -> Self { - CsrTripletIter { + Self { pattern_iter: self.pattern_iter.clone(), values_iter: self.values_iter.clone(), } @@ -650,13 +650,10 @@ impl<'a, T> Iterator for CsrTripletIter<'a, T> { type Item = (usize, usize, &'a T); fn next(&mut self) -> Option { - let next_entry = self.pattern_iter.next(); - let next_value = self.values_iter.next(); - - match (next_entry, next_value) { - (Some((i, j)), Some(v)) => Some((i, j, v)), - _ => None, - } + self.pattern_iter + .next() + .zip(self.values_iter.next()) + .map(|((i, j), v)| (i, j, v)) } } @@ -672,13 +669,10 @@ impl<'a, T> Iterator for CsrTripletIterMut<'a, T> { #[inline] fn next(&mut self) -> Option { - let next_entry = self.pattern_iter.next(); - let next_value = self.values_mut_iter.next(); - - match (next_entry, next_value) { - (Some((i, j)), Some(v)) => Some((i, j, v)), - _ => None, - } + self.pattern_iter + .next() + .zip(self.values_mut_iter.next()) + .map(|((i, j), v)| (i, j, v)) } } diff --git a/nalgebra-sparse/src/io/matrix_market.rs b/nalgebra-sparse/src/io/matrix_market.rs index f0d084c5a..a14c21284 100644 --- a/nalgebra-sparse/src/io/matrix_market.rs +++ b/nalgebra-sparse/src/io/matrix_market.rs @@ -260,21 +260,19 @@ impl MatrixMarketError { impl fmt::Display for MatrixMarketError { fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result { write!(f, "Matrix Market error: ")?; - write!( - f, - match self.kind() { - MatrixMarketErrorKind::ParsingError => "ParsingError,", - MatrixMarketErrorKind::InvalidHeader => "InvalidHeader,", - MatrixMarketErrorKind::EntryMismatch => "EntryMismatch,", - MatrixMarketErrorKind::TypeMismatch => "TypeMismatch,", - MatrixMarketErrorKind::SparseFormatError(_) => "SparseFormatError,", - MatrixMarketErrorKind::ZeroError => "ZeroError,", - MatrixMarketErrorKind::IOError(_) => "IOError,", - MatrixMarketErrorKind::DiagonalError => "DiagonalError,", - MatrixMarketErrorKind::NotLowerTriangle => "NotLowerTriangle,", - MatrixMarketErrorKind::NonSquare => "NonSquare,", - } - )?; + let msg = match self.kind() { + MatrixMarketErrorKind::ParsingError => "ParsingError,", + MatrixMarketErrorKind::InvalidHeader => "InvalidHeader,", + MatrixMarketErrorKind::EntryMismatch => "EntryMismatch,", + MatrixMarketErrorKind::TypeMismatch => "TypeMismatch,", + MatrixMarketErrorKind::SparseFormatError(_) => "SparseFormatError,", + MatrixMarketErrorKind::ZeroError => "ZeroError,", + MatrixMarketErrorKind::IOError(_) => "IOError,", + MatrixMarketErrorKind::DiagonalError => "DiagonalError,", + MatrixMarketErrorKind::NotLowerTriangle => "NotLowerTriangle,", + MatrixMarketErrorKind::NonSquare => "NonSquare,", + }; + write!(f, {}, msg)?; write!(f, " message: {}", self.message) } } diff --git a/src/geometry/transform.rs b/src/geometry/transform.rs index 5366ea816..72df45d03 100755 --- a/src/geometry/transform.rs +++ b/src/geometry/transform.rs @@ -202,7 +202,7 @@ where { #[inline] fn clone(&self) -> Self { - Transform::from_matrix_unchecked(self.matrix.clone()) + Self::from_matrix_unchecked(self.matrix.clone()) } } From 4d8d0d9a34a34d3900041cc442f69214e8aa6a76 Mon Sep 17 00:00:00 2001 From: adamnemecek Date: Sat, 4 Jan 2025 21:10:22 -0800 Subject: [PATCH 07/17] readded an import that got removed --- nalgebra-glm/src/ext/quaternion_trigonometric.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/nalgebra-glm/src/ext/quaternion_trigonometric.rs b/nalgebra-glm/src/ext/quaternion_trigonometric.rs index 51148adbf..88305b5dd 100644 --- a/nalgebra-glm/src/ext/quaternion_trigonometric.rs +++ b/nalgebra-glm/src/ext/quaternion_trigonometric.rs @@ -1,6 +1,7 @@ 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(x: &Qua) -> T { From 3db6769033b3022222c108e264ba1025fc83f8cd Mon Sep 17 00:00:00 2001 From: adamnemecek Date: Sat, 4 Jan 2025 21:13:25 -0800 Subject: [PATCH 08/17] fixed buildbreak --- nalgebra-glm/src/gtx/rotate_vector.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/nalgebra-glm/src/gtx/rotate_vector.rs b/nalgebra-glm/src/gtx/rotate_vector.rs index 0e512df74..7eba6f0d1 100644 --- a/nalgebra-glm/src/gtx/rotate_vector.rs +++ b/nalgebra-glm/src/gtx/rotate_vector.rs @@ -6,7 +6,7 @@ use crate::RealNumber; /// Build the rotation matrix needed to align `normal` and `up`. pub fn orientation(normal: &TVec3, up: &TVec3) -> TMat4 { Rotation3::rotation_between(normal, up) - .map(|x| r.homogenous()) + .map(|r| r.homogenous()) .unwrap_or(|| TMat4::identity()) } From 08e34d73941917745bff160e9af2db6b73e5b93f Mon Sep 17 00:00:00 2001 From: adamnemecek Date: Sat, 4 Jan 2025 21:15:01 -0800 Subject: [PATCH 09/17] fixed more compilation errors --- nalgebra-glm/src/gtx/rotate_vector.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/nalgebra-glm/src/gtx/rotate_vector.rs b/nalgebra-glm/src/gtx/rotate_vector.rs index 7eba6f0d1..3802a1020 100644 --- a/nalgebra-glm/src/gtx/rotate_vector.rs +++ b/nalgebra-glm/src/gtx/rotate_vector.rs @@ -6,8 +6,8 @@ use crate::RealNumber; /// Build the rotation matrix needed to align `normal` and `up`. pub fn orientation(normal: &TVec3, up: &TVec3) -> TMat4 { Rotation3::rotation_between(normal, up) - .map(|r| r.homogenous()) - .unwrap_or(|| TMat4::identity()) + .map(|r| r.to_homogeneous()) + .unwrap_or_else(|| TMat4::identity()) } /// Rotate a two dimensional vector. From b6ebe64ecafc79b8f86f0abef4f4a1829a8a070f Mon Sep 17 00:00:00 2001 From: adamnemecek Date: Sat, 4 Jan 2025 21:21:38 -0800 Subject: [PATCH 10/17] refactoring --- nalgebra-sparse/src/pattern.rs | 36 ++++++++++++---------------------- 1 file changed, 13 insertions(+), 23 deletions(-) diff --git a/nalgebra-sparse/src/pattern.rs b/nalgebra-sparse/src/pattern.rs index 803e7f2dd..50cea10d9 100644 --- a/nalgebra-sparse/src/pattern.rs +++ b/nalgebra-sparse/src/pattern.rs @@ -360,32 +360,22 @@ impl From for SparseFormatError { } } } - impl fmt::Display for SparsityPatternFormatError { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - match self { - SparsityPatternFormatError::InvalidOffsetArrayLength => { - write!(f, "Length of offset array is not equal to (major_dim + 1).") - } - SparsityPatternFormatError::InvalidOffsetFirstLast => { - write!(f, "First or last offset is incompatible with format.") - } - SparsityPatternFormatError::NonmonotonicOffsets => { - write!(f, "Offsets are not monotonically increasing.") - } - SparsityPatternFormatError::MinorIndexOutOfBounds => { - write!(f, "A minor index is out of bounds.") + write!( + f, + "{}", + match self { + Self::InvalidOffsetArrayLength => + "Length of offset array is not equal to (major_dim + 1).", + Self::InvalidOffsetFirstLast => "First or last offset is incompatible with format.", + Self::NonmonotonicOffsets => "Offsets are not monotonically increasing.", + Self::MinorIndexOutOfBounds => "A minor index is out of bounds.", + Self::DuplicateEntry => "Input data contains duplicate entries.", + Self::NonmonotonicMinorIndices => + "Minor indices are not monotonically increasing within each lane.", } - SparsityPatternFormatError::DuplicateEntry => { - write!(f, "Input data contains duplicate entries.") - } - SparsityPatternFormatError::NonmonotonicMinorIndices => { - write!( - f, - "Minor indices are not monotonically increasing within each lane." - ) - } - } + ) } } From c97b069b823acb282c63c4a7c9522efb424eb99d Mon Sep 17 00:00:00 2001 From: adamnemecek Date: Sat, 4 Jan 2025 21:25:35 -0800 Subject: [PATCH 11/17] fixed + refactoring --- nalgebra-sparse/src/io/matrix_market.rs | 2 +- nalgebra-sparse/src/lib.rs | 8 ++++---- nalgebra-sparse/src/pattern.rs | 8 ++++---- 3 files changed, 9 insertions(+), 9 deletions(-) diff --git a/nalgebra-sparse/src/io/matrix_market.rs b/nalgebra-sparse/src/io/matrix_market.rs index a14c21284..01c3f797e 100644 --- a/nalgebra-sparse/src/io/matrix_market.rs +++ b/nalgebra-sparse/src/io/matrix_market.rs @@ -272,7 +272,7 @@ impl fmt::Display for MatrixMarketError { MatrixMarketErrorKind::NotLowerTriangle => "NotLowerTriangle,", MatrixMarketErrorKind::NonSquare => "NonSquare,", }; - write!(f, {}, msg)?; + write!(f, "{}", msg)?; write!(f, " message: {}", self.message) } } diff --git a/nalgebra-sparse/src/lib.rs b/nalgebra-sparse/src/lib.rs index a022dedbc..ea3075439 100644 --- a/nalgebra-sparse/src/lib.rs +++ b/nalgebra-sparse/src/lib.rs @@ -248,8 +248,8 @@ impl<'a, T: Clone + Zero> SparseEntry<'a, T> { /// stored. pub fn into_value(self) -> T { match self { - SparseEntry::NonZero(value) => value.clone(), - SparseEntry::Zero => T::zero(), + Self::NonZero(value) => value.clone(), + Self::Zero => T::zero(), } } } @@ -275,8 +275,8 @@ impl<'a, T: Clone + Zero> SparseEntryMut<'a, T> { /// stored. pub fn into_value(self) -> T { match self { - SparseEntryMut::NonZero(value) => value.clone(), - SparseEntryMut::Zero => T::zero(), + Self::NonZero(value) => value.clone(), + Self::Zero => T::zero(), } } } diff --git a/nalgebra-sparse/src/pattern.rs b/nalgebra-sparse/src/pattern.rs index 50cea10d9..792c194d3 100644 --- a/nalgebra-sparse/src/pattern.rs +++ b/nalgebra-sparse/src/pattern.rs @@ -347,18 +347,18 @@ impl From for SparseFormatError { | InvalidOffsetFirstLast | NonmonotonicOffsets | NonmonotonicMinorIndices => { - SparseFormatError::from_kind_and_error(InvalidStructure, Box::from(err)) + Self::from_kind_and_error(InvalidStructure, Box::from(err)) } MinorIndexOutOfBounds => { - SparseFormatError::from_kind_and_error(IndexOutOfBounds, Box::from(err)) + Self::from_kind_and_error(IndexOutOfBounds, Box::from(err)) } - PatternDuplicateEntry => SparseFormatError::from_kind_and_error( + PatternDuplicateEntry => Self::from_kind_and_error( #[allow(unused_qualifications)] SparseFormatErrorKind::DuplicateEntry, Box::from(err), ), } - } + }q } impl fmt::Display for SparsityPatternFormatError { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { From 3927acf1dfc1dc27245415d6188e16e1f88c6d27 Mon Sep 17 00:00:00 2001 From: adamnemecek Date: Sat, 4 Jan 2025 21:26:47 -0800 Subject: [PATCH 12/17] refactoring --- nalgebra-sparse/src/io/matrix_market.rs | 20 ++++++++++---------- nalgebra-sparse/src/pattern.rs | 2 +- 2 files changed, 11 insertions(+), 11 deletions(-) diff --git a/nalgebra-sparse/src/io/matrix_market.rs b/nalgebra-sparse/src/io/matrix_market.rs index 01c3f797e..431f71f87 100644 --- a/nalgebra-sparse/src/io/matrix_market.rs +++ b/nalgebra-sparse/src/io/matrix_market.rs @@ -372,8 +372,8 @@ impl FromStr for Sparsity { /// Assumes that `word` is already lower case. fn from_str(word: &str) -> Result { match word { - "coordinate" => Ok(Sparsity::Sparse), - "array" => Ok(Sparsity::Dense), + "coordinate" => Ok(Self::Sparse), + "array" => Ok(Self::Dense), _ => Err(MatrixMarketError::from_kind_and_message( MatrixMarketErrorKind::ParsingError, format!("keyword {} is unknown", word), @@ -387,10 +387,10 @@ impl FromStr for DataType { /// Assumes that `word` is already lower case. fn from_str(word: &str) -> Result { match word { - "real" => Ok(DataType::Real), - "complex" => Ok(DataType::Complex), - "integer" => Ok(DataType::Integer), - "pattern" => Ok(DataType::Pattern), + "real" => Ok(Self::Real), + "complex" => Ok(Self::Complex), + "integer" => Ok(Self::Integer), + "pattern" => Ok(Self::Pattern), _ => Err(MatrixMarketError::from_kind_and_message( MatrixMarketErrorKind::ParsingError, format!("keyword {} is unknown", word), @@ -404,10 +404,10 @@ impl FromStr for StorageScheme { /// Assumes that `word` is already lower case. fn from_str(word: &str) -> Result { match word { - "skew-symmetric" => Ok(StorageScheme::Skew), - "general" => Ok(StorageScheme::General), - "symmetric" => Ok(StorageScheme::Symmetric), - "hermitian" => Ok(StorageScheme::Hermitian), + "skew-symmetric" => Ok(Self::Skew), + "general" => Ok(Self::General), + "symmetric" => Ok(Self::Symmetric), + "hermitian" => Ok(Self::Hermitian), _ => Err(MatrixMarketError::from_kind_and_message( MatrixMarketErrorKind::ParsingError, format!("keyword {} is unknown", word), diff --git a/nalgebra-sparse/src/pattern.rs b/nalgebra-sparse/src/pattern.rs index 792c194d3..4951d4a01 100644 --- a/nalgebra-sparse/src/pattern.rs +++ b/nalgebra-sparse/src/pattern.rs @@ -358,7 +358,7 @@ impl From for SparseFormatError { Box::from(err), ), } - }q + } } impl fmt::Display for SparsityPatternFormatError { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { From e37f2991f1dc91c0e2d772f7f6c50a2042eb4f4d Mon Sep 17 00:00:00 2001 From: adamnemecek Date: Sat, 4 Jan 2025 21:28:32 -0800 Subject: [PATCH 13/17] use vec![] --- nalgebra-macros/src/matrix_vector_impl.rs | 4 ++-- nalgebra-sparse/src/convert/serial.rs | 20 +++++++++---------- nalgebra-sparse/src/coo.rs | 6 +++--- nalgebra-sparse/src/cs.rs | 10 +++++----- nalgebra-sparse/src/factorization/cholesky.rs | 6 +++--- nalgebra-sparse/src/io/matrix_market.rs | 6 +++--- nalgebra-sparse/src/ops/serial/pattern.rs | 8 ++++---- nalgebra-sparse/src/pattern.rs | 4 +--- nalgebra-sparse/tests/serde.rs | 4 ++-- nalgebra-sparse/tests/unit_tests/coo.rs | 2 +- nalgebra-sparse/tests/unit_tests/pattern.rs | 4 ++-- src/base/default_allocator.rs | 4 ++-- src/base/matrix.rs | 2 +- src/base/norm.rs | 2 +- src/base/vec_storage.rs | 8 ++++---- src/io/matrix_market.rs | 6 +++--- src/sparse/cs_matrix_cholesky.rs | 10 +++++----- src/sparse/cs_matrix_solve.rs | 6 +++--- src/third_party/alga/alga_matrix.rs | 2 +- tests/core/matrix.rs | 2 +- 20 files changed, 57 insertions(+), 59 deletions(-) diff --git a/nalgebra-macros/src/matrix_vector_impl.rs b/nalgebra-macros/src/matrix_vector_impl.rs index d4357e88f..13aba67a7 100644 --- a/nalgebra-macros/src/matrix_vector_impl.rs +++ b/nalgebra-macros/src/matrix_vector_impl.rs @@ -67,7 +67,7 @@ type MatrixRowSyntax = Punctuated; impl Parse for Matrix { fn parse(input: ParseStream<'_>) -> syn::Result { - let mut data = Vec::new(); + let mut data = vec![]; let mut ncols = None; let mut nrows = 0; @@ -127,7 +127,7 @@ impl Parse for Vector { // The syntax of a vector is just the syntax of a single matrix row if input.is_empty() { Ok(Self { - elements: Vec::new(), + elements: vec![], }) } else { let elements = MatrixRowSyntax::parse_terminated(input)? diff --git a/nalgebra-sparse/src/convert/serial.rs b/nalgebra-sparse/src/convert/serial.rs index 8cb8b16f3..9afc0e955 100644 --- a/nalgebra-sparse/src/convert/serial.rs +++ b/nalgebra-sparse/src/convert/serial.rs @@ -100,8 +100,8 @@ where S: RawStorage, { let mut row_offsets = Vec::with_capacity(dense.nrows() + 1); - let mut col_idx = Vec::new(); - let mut values = Vec::new(); + let mut col_idx = vec![]; + let mut values = vec![]; // We have to iterate row-by-row to build the CSR matrix, which is at odds with // nalgebra's column-major storage. The alternative would be to perform an initial sweep @@ -177,8 +177,8 @@ where S: RawStorage, { let mut col_offsets = Vec::with_capacity(dense.ncols() + 1); - let mut row_idx = Vec::new(); - let mut values = Vec::new(); + let mut row_idx = vec![]; + let mut values = vec![]; col_offsets.push(0); for j in 0..dense.ncols() { @@ -268,18 +268,18 @@ where // At this point, assembly is essentially complete. However, we must ensure // that minor indices are sorted within each lane and without duplicates. - let mut sorted_major_offsets = Vec::new(); - let mut sorted_minor_idx = Vec::new(); - let mut sorted_vals = Vec::new(); + let mut sorted_major_offsets = vec![]; + let mut sorted_minor_idx = vec![]; + let mut sorted_vals = vec![]; sorted_major_offsets.push(0); // We need some temporary storage when working with each lane. Since lanes often have a // very small number of non-zero entries, we try to amortize allocations across // lanes by reusing workspace vectors - let mut idx_workspace = Vec::new(); - let mut perm_workspace = Vec::new(); - let mut values_workspace = Vec::new(); + let mut idx_workspace = vec![]; + let mut perm_workspace = vec![]; + let mut values_workspace = vec![]; for lane in 0..major_dim { let begin = unsorted_major_offsets[lane]; diff --git a/nalgebra-sparse/src/coo.rs b/nalgebra-sparse/src/coo.rs index 6f9698143..c747818b8 100644 --- a/nalgebra-sparse/src/coo.rs +++ b/nalgebra-sparse/src/coo.rs @@ -95,9 +95,9 @@ impl CooMatrix { Self { nrows, ncols, - row_indices: Vec::new(), - col_indices: Vec::new(), - values: Vec::new(), + row_indices: vec![], + col_indices: vec![], + values: vec![], } } diff --git a/nalgebra-sparse/src/cs.rs b/nalgebra-sparse/src/cs.rs index aca6dd305..26634fcc1 100644 --- a/nalgebra-sparse/src/cs.rs +++ b/nalgebra-sparse/src/cs.rs @@ -187,8 +187,8 @@ impl CsMatrix { { let (major_dim, minor_dim) = (self.pattern().major_dim(), self.pattern().minor_dim()); let mut new_offsets = Vec::with_capacity(self.pattern().major_dim() + 1); - let mut new_indices = Vec::new(); - let mut new_values = Vec::new(); + let mut new_indices = vec![]; + let mut new_values = vec![]; new_offsets.push(0); for (i, lane) in self.lane_iter().enumerate() { @@ -601,9 +601,9 @@ where } // Set up required buffers up front - let mut minor_idx_buffer: Vec = Vec::new(); - let mut values_buffer: Vec = Vec::new(); - let mut minor_index_permutation: Vec = Vec::new(); + let mut minor_idx_buffer: Vec = vec![]; + let mut values_buffer: Vec = vec![]; + let mut minor_index_permutation: Vec = vec![]; // Test that each lane has strictly monotonically increasing minor indices, i.e. // minor indices within a lane are sorted, unique. Sort minor indices within a lane if needed. diff --git a/nalgebra-sparse/src/factorization/cholesky.rs b/nalgebra-sparse/src/factorization/cholesky.rs index f84e621f1..714ced02f 100644 --- a/nalgebra-sparse/src/factorization/cholesky.rs +++ b/nalgebra-sparse/src/factorization/cholesky.rs @@ -303,8 +303,8 @@ fn reach( marks.resize(tree.len(), false); // TODO: avoid all those allocations. - let mut tmp = Vec::new(); - let mut res = Vec::new(); + let mut tmp = vec![]; + let mut res = vec![]; for &irow in pattern.lane(j) { let mut curr = irow; @@ -329,7 +329,7 @@ fn nonzero_pattern(m: &SparsityPattern) -> (SparsityPattern, SparsityPattern) { let (nrows, ncols) = (m.minor_dim(), m.major_dim()); let mut rows = Vec::with_capacity(m.nnz()); let mut col_offsets = Vec::with_capacity(ncols + 1); - let mut marks = Vec::new(); + let mut marks = vec![]; // NOTE: the following will actually compute the non-zero pattern of // the transpose of l. diff --git a/nalgebra-sparse/src/io/matrix_market.rs b/nalgebra-sparse/src/io/matrix_market.rs index 431f71f87..6afa8ae1d 100644 --- a/nalgebra-sparse/src/io/matrix_market.rs +++ b/nalgebra-sparse/src/io/matrix_market.rs @@ -865,9 +865,9 @@ where .next() .unwrap(); - let mut rows: Vec = Vec::new(); - let mut cols: Vec = Vec::new(); - let mut data: Vec = Vec::new(); + let mut rows: Vec = vec![]; + let mut cols: Vec = vec![]; + let mut data: Vec = vec![]; let mut lines = file.into_inner(); let header_line = lines.next().unwrap(); diff --git a/nalgebra-sparse/src/ops/serial/pattern.rs b/nalgebra-sparse/src/ops/serial/pattern.rs index 8806b4fc5..e8b2e7058 100644 --- a/nalgebra-sparse/src/ops/serial/pattern.rs +++ b/nalgebra-sparse/src/ops/serial/pattern.rs @@ -24,8 +24,8 @@ pub fn spadd_pattern(a: &SparsityPattern, b: &SparsityPattern) -> SparsityPatter "Patterns must have identical minor dimensions." ); - let mut offsets = Vec::new(); - let mut indices = Vec::new(); + let mut offsets = vec![]; + let mut indices = vec![]; offsets.reserve(a.major_dim() + 1); indices.clear(); @@ -77,8 +77,8 @@ pub fn spmm_csr_pattern(a: &SparsityPattern, b: &SparsityPattern) -> SparsityPat "a and b must have compatible dimensions" ); - let mut offsets = Vec::new(); - let mut indices = Vec::new(); + let mut offsets = vec![]; + let mut indices = vec![]; offsets.push(0); // Keep a vector of whether we have visited a particular minor index when working diff --git a/nalgebra-sparse/src/pattern.rs b/nalgebra-sparse/src/pattern.rs index 4951d4a01..459352cc9 100644 --- a/nalgebra-sparse/src/pattern.rs +++ b/nalgebra-sparse/src/pattern.rs @@ -349,9 +349,7 @@ impl From for SparseFormatError { | NonmonotonicMinorIndices => { Self::from_kind_and_error(InvalidStructure, Box::from(err)) } - MinorIndexOutOfBounds => { - Self::from_kind_and_error(IndexOutOfBounds, Box::from(err)) - } + MinorIndexOutOfBounds => Self::from_kind_and_error(IndexOutOfBounds, Box::from(err)), PatternDuplicateEntry => Self::from_kind_and_error( #[allow(unused_qualifications)] SparseFormatErrorKind::DuplicateEntry, diff --git a/nalgebra-sparse/tests/serde.rs b/nalgebra-sparse/tests/serde.rs index 1ce1953f2..654ef136d 100644 --- a/nalgebra-sparse/tests/serde.rs +++ b/nalgebra-sparse/tests/serde.rs @@ -27,7 +27,7 @@ fn pattern_roundtrip() { { // A pattern with zero explicitly stored entries let pattern = - SparsityPattern::try_from_offsets_and_indices(3, 2, vec![0, 0, 0, 0], Vec::new()) + SparsityPattern::try_from_offsets_and_indices(3, 2, vec![0, 0, 0, 0], vec![]) .unwrap(); assert_eq!(json_roundtrip(&pattern), pattern); @@ -65,7 +65,7 @@ fn coo_roundtrip() { { // A COO matrix without entries let matrix = - CooMatrix::::try_from_triplets(3, 2, Vec::new(), Vec::new(), Vec::new()).unwrap(); + CooMatrix::::try_from_triplets(3, 2, vec![], vec![], vec![]).unwrap(); assert_eq!(json_roundtrip(&matrix), matrix); } diff --git a/nalgebra-sparse/tests/unit_tests/coo.rs b/nalgebra-sparse/tests/unit_tests/coo.rs index 1dacc7c2a..fc563a564 100644 --- a/nalgebra-sparse/tests/unit_tests/coo.rs +++ b/nalgebra-sparse/tests/unit_tests/coo.rs @@ -11,7 +11,7 @@ fn coo_construction_for_valid_data() { { // Zero matrix let coo = - CooMatrix::::try_from_triplets(3, 2, Vec::new(), Vec::new(), Vec::new()).unwrap(); + CooMatrix::::try_from_triplets(3, 2, vec![], vec![], vec![]).unwrap(); assert_eq!(coo.nrows(), 3); assert_eq!(coo.ncols(), 2); assert!(coo.triplet_iter().next().is_none()); diff --git a/nalgebra-sparse/tests/unit_tests/pattern.rs b/nalgebra-sparse/tests/unit_tests/pattern.rs index 013f6263a..8ebd76079 100644 --- a/nalgebra-sparse/tests/unit_tests/pattern.rs +++ b/nalgebra-sparse/tests/unit_tests/pattern.rs @@ -22,7 +22,7 @@ fn sparsity_pattern_valid_data() { { // A pattern with zero explicitly stored entries let pattern = - SparsityPattern::try_from_offsets_and_indices(3, 2, vec![0, 0, 0, 0], Vec::new()) + SparsityPattern::try_from_offsets_and_indices(3, 2, vec![0, 0, 0, 0], vec![]) .unwrap(); assert_eq!(pattern.major_dim(), 3); @@ -73,7 +73,7 @@ fn sparsity_pattern_valid_data() { fn sparsity_pattern_try_from_invalid_data() { { // Empty offset array (invalid length) - let pattern = SparsityPattern::try_from_offsets_and_indices(0, 0, Vec::new(), Vec::new()); + let pattern = SparsityPattern::try_from_offsets_and_indices(0, 0, vec![], vec![]); assert_eq!( pattern, Err(SparsityPatternFormatError::InvalidOffsetArrayLength) diff --git a/src/base/default_allocator.rs b/src/base/default_allocator.rs index 3b5d12811..bb265d028 100644 --- a/src/base/default_allocator.rs +++ b/src/base/default_allocator.rs @@ -93,7 +93,7 @@ impl Allocator for DefaultAllocator { #[inline] fn allocate_uninit(nrows: Dyn, ncols: C) -> VecStorage, Dyn, C> { - let mut data = Vec::new(); + let mut data = vec![]; let length = nrows.value() * ncols.value(); data.reserve_exact(length); data.resize_with(length, MaybeUninit::uninit); @@ -140,7 +140,7 @@ impl Allocator for DefaultAllocator { #[inline] fn allocate_uninit(nrows: R, ncols: Dyn) -> VecStorage, R, Dyn> { - let mut data = Vec::new(); + let mut data = vec![]; let length = nrows.value() * ncols.value(); data.reserve_exact(length); data.resize_with(length, MaybeUninit::uninit); diff --git a/src/base/matrix.rs b/src/base/matrix.rs index 6773c954e..d77d84857 100644 --- a/src/base/matrix.rs +++ b/src/base/matrix.rs @@ -1988,7 +1988,7 @@ impl_fmt!(fmt::Pointer, "{:p}", "{:.1$p}"); mod tests { #[test] fn empty_display() { - let vec: Vec = Vec::new(); + let vec: Vec = vec![]; let dvector = crate::DVector::from_vec(vec); assert_eq!(format!("{}", dvector), "[ ]") } diff --git a/src/base/norm.rs b/src/base/norm.rs index 90362be62..ca1ef7d82 100644 --- a/src/base/norm.rs +++ b/src/base/norm.rs @@ -607,7 +607,7 @@ where #[cfg(any(feature = "std", feature = "alloc"))] { // XXX: use a GenericArray instead. - let mut known_basis = Vec::new(); + let mut known_basis = vec![]; for v in vs.iter() { known_basis.push(v.normalize()) diff --git a/src/base/vec_storage.rs b/src/base/vec_storage.rs index f0a0593fa..35695db0e 100644 --- a/src/base/vec_storage.rs +++ b/src/base/vec_storage.rs @@ -34,7 +34,7 @@ pub struct VecStorage { impl Default for VecStorage { fn default() -> Self { Self { - data: Vec::new(), + data: vec![], nrows: Dyn::from_usize(0), ncols: Dyn::from_usize(0), } @@ -44,7 +44,7 @@ impl Default for VecStorage { impl Default for VecStorage { fn default() -> Self { Self { - data: Vec::new(), + data: vec![], nrows: R::name(), ncols: Dyn::from_usize(0), } @@ -54,7 +54,7 @@ impl Default for VecStorage { impl Default for VecStorage { fn default() -> Self { Self { - data: Vec::new(), + data: vec![], nrows: Dyn::from_usize(0), ncols: C::name(), } @@ -65,7 +65,7 @@ impl Default for VecStorage { fn default() -> Self { let nrows = R::name(); let ncols = C::name(); - let mut data = Vec::new(); + let mut data = vec![]; data.resize_with(nrows.value() * ncols.value(), Default::default); Self { data, nrows, ncols } } diff --git a/src/io/matrix_market.rs b/src/io/matrix_market.rs index 2b0a0182e..bf886620e 100644 --- a/src/io/matrix_market.rs +++ b/src/io/matrix_market.rs @@ -23,9 +23,9 @@ pub fn cs_matrix_from_matrix_market_str(data: &str) -> Option = Vec::new(); - let mut cols: Vec = Vec::new(); - let mut data: Vec = Vec::new(); + let mut rows: Vec = vec![]; + let mut cols: Vec = vec![]; + let mut data: Vec = vec![]; for line in file.into_inner() { match line.as_rule() { diff --git a/src/sparse/cs_matrix_cholesky.rs b/src/sparse/cs_matrix_cholesky.rs index fbd4051da..a4e07ba3e 100644 --- a/src/sparse/cs_matrix_cholesky.rs +++ b/src/sparse/cs_matrix_cholesky.rs @@ -270,8 +270,8 @@ where marks.resize(tree.len(), false); // TODO: avoid all those allocations. - let mut tmp = Vec::new(); - let mut res = Vec::new(); + let mut tmp = vec![]; + let mut res = vec![]; for irow in m.data.column_row_indices(j) { let mut curr = irow; @@ -295,7 +295,7 @@ where let (nrows, ncols) = m.data.shape(); let mut rows = Vec::with_capacity(m.len()); let mut cols = Matrix::zeros_generic(m.data.shape().0, Const::<1>); - let mut marks = Vec::new(); + let mut marks = vec![]; // NOTE: the following will actually compute the non-zero pattern of // the transpose of l. @@ -335,8 +335,8 @@ where ) -> Vec { let len = m.data.shape().0.value(); let mut counts: Vec<_> = iter::repeat(0).take(len).collect(); - let mut reach = Vec::new(); - let mut marks = Vec::new(); + let mut reach = vec![]; + let mut marks = vec![]; for i in 0..len { Self::reach(m, i, i, tree, &mut marks, &mut reach); diff --git a/src/sparse/cs_matrix_solve.rs b/src/sparse/cs_matrix_solve.rs index 0dbe65a35..0ab7f2418 100644 --- a/src/sparse/cs_matrix_solve.rs +++ b/src/sparse/cs_matrix_solve.rs @@ -147,7 +147,7 @@ impl> CsMatrix { DefaultAllocator: Allocator + Allocator, ShapeConstraint: SameNumberOfRows, { - let mut reach = Vec::new(); + let mut reach = vec![]; // We don't compute a postordered reach here because it will be sorted after anyway. self.lower_triangular_reach(b, &mut reach); // We sort the reach so the result matrix has sorted indices. @@ -211,7 +211,7 @@ impl> CsMatrix { DefaultAllocator: Allocator, { let mut visited = OVector::repeat_generic(self.data.shape().1, U1, false); - let mut stack = Vec::new(); + let mut stack = vec![]; for i in b.data.column_range(0) { let row_index = b.data.row_index(i); @@ -255,7 +255,7 @@ impl> CsMatrix { DefaultAllocator: Allocator, { let mut visited = OVector::repeat_generic(self.data.shape().1, Const::<1>, false); - let mut stack = Vec::new(); + let mut stack = vec![]; for irow in b.data.column_row_indices(0) { self.lower_triangular_bfs(irow, visited.as_mut_slice(), &mut stack, xi); diff --git a/src/third_party/alga/alga_matrix.rs b/src/third_party/alga/alga_matrix.rs index 83c08806a..49bf36f41 100644 --- a/src/third_party/alga/alga_matrix.rs +++ b/src/third_party/alga/alga_matrix.rs @@ -318,7 +318,7 @@ where #[cfg(any(feature = "std", feature = "alloc"))] { // XXX: use a GenericArray instead. - let mut known_basis = Vec::new(); + let mut known_basis = vec![]; for v in vs.iter() { known_basis.push(v.normalize()) diff --git a/tests/core/matrix.rs b/tests/core/matrix.rs index 50c0e426a..d8badc0ba 100644 --- a/tests/core/matrix.rs +++ b/tests/core/matrix.rs @@ -1020,7 +1020,7 @@ mod finite_dim_inner_space_tests { fn $orthonormal_subspace(vs in vec($vstrategy(), 0..10)) { let mut given_basis = vs.clone(); let given_basis_dim = $Vector::orthonormalize(&mut given_basis[..]); - let mut ortho_basis = Vec::new(); + let mut ortho_basis = vec![]; $Vector::orthonormal_subspace_basis( &given_basis[.. given_basis_dim], |e| { ortho_basis.push(*e); true } From d5d01f55e34ff6c6f0125cf736f699c058265087 Mon Sep 17 00:00:00 2001 From: adamnemecek Date: Sat, 4 Jan 2025 21:28:42 -0800 Subject: [PATCH 14/17] cargo fmt --- nalgebra-sparse/tests/serde.rs | 6 ++---- nalgebra-sparse/tests/unit_tests/coo.rs | 3 +-- nalgebra-sparse/tests/unit_tests/pattern.rs | 3 +-- 3 files changed, 4 insertions(+), 8 deletions(-) diff --git a/nalgebra-sparse/tests/serde.rs b/nalgebra-sparse/tests/serde.rs index 654ef136d..758b44adc 100644 --- a/nalgebra-sparse/tests/serde.rs +++ b/nalgebra-sparse/tests/serde.rs @@ -27,8 +27,7 @@ fn pattern_roundtrip() { { // A pattern with zero explicitly stored entries let pattern = - SparsityPattern::try_from_offsets_and_indices(3, 2, vec![0, 0, 0, 0], vec![]) - .unwrap(); + SparsityPattern::try_from_offsets_and_indices(3, 2, vec![0, 0, 0, 0], vec![]).unwrap(); assert_eq!(json_roundtrip(&pattern), pattern); } @@ -64,8 +63,7 @@ fn pattern_deserialize_invalid() { fn coo_roundtrip() { { // A COO matrix without entries - let matrix = - CooMatrix::::try_from_triplets(3, 2, vec![], vec![], vec![]).unwrap(); + let matrix = CooMatrix::::try_from_triplets(3, 2, vec![], vec![], vec![]).unwrap(); assert_eq!(json_roundtrip(&matrix), matrix); } diff --git a/nalgebra-sparse/tests/unit_tests/coo.rs b/nalgebra-sparse/tests/unit_tests/coo.rs index fc563a564..d7c973142 100644 --- a/nalgebra-sparse/tests/unit_tests/coo.rs +++ b/nalgebra-sparse/tests/unit_tests/coo.rs @@ -10,8 +10,7 @@ fn coo_construction_for_valid_data() { { // Zero matrix - let coo = - CooMatrix::::try_from_triplets(3, 2, vec![], vec![], vec![]).unwrap(); + let coo = CooMatrix::::try_from_triplets(3, 2, vec![], vec![], vec![]).unwrap(); assert_eq!(coo.nrows(), 3); assert_eq!(coo.ncols(), 2); assert!(coo.triplet_iter().next().is_none()); diff --git a/nalgebra-sparse/tests/unit_tests/pattern.rs b/nalgebra-sparse/tests/unit_tests/pattern.rs index 8ebd76079..dad940621 100644 --- a/nalgebra-sparse/tests/unit_tests/pattern.rs +++ b/nalgebra-sparse/tests/unit_tests/pattern.rs @@ -22,8 +22,7 @@ fn sparsity_pattern_valid_data() { { // A pattern with zero explicitly stored entries let pattern = - SparsityPattern::try_from_offsets_and_indices(3, 2, vec![0, 0, 0, 0], vec![]) - .unwrap(); + SparsityPattern::try_from_offsets_and_indices(3, 2, vec![0, 0, 0, 0], vec![]).unwrap(); assert_eq!(pattern.major_dim(), 3); assert_eq!(pattern.minor_dim(), 2); From bcbc450a690edd8e1eee2b2c07f7ea0ee04b72c9 Mon Sep 17 00:00:00 2001 From: adamnemecek Date: Sat, 4 Jan 2025 21:48:16 -0800 Subject: [PATCH 15/17] refactoring --- nalgebra-sparse/src/coo/coo_serde.rs | 4 ++-- nalgebra-sparse/src/csc/csc_serde.rs | 4 ++-- nalgebra-sparse/src/csr/csr_serde.rs | 4 ++-- 3 files changed, 6 insertions(+), 6 deletions(-) diff --git a/nalgebra-sparse/src/coo/coo_serde.rs b/nalgebra-sparse/src/coo/coo_serde.rs index 7ffcdf4aa..e49a17842 100644 --- a/nalgebra-sparse/src/coo/coo_serde.rs +++ b/nalgebra-sparse/src/coo/coo_serde.rs @@ -48,12 +48,12 @@ impl<'de, T> Deserialize<'de> for CooMatrix where T: Deserialize<'de> + Clone, { - fn deserialize(deserializer: D) -> Result, D::Error> + fn deserialize(deserializer: D) -> Result where D: Deserializer<'de>, { let de = CooMatrixSerializationData::, Vec>::deserialize(deserializer)?; - CooMatrix::try_from_triplets( + Self::try_from_triplets( de.nrows, de.ncols, de.row_indices, diff --git a/nalgebra-sparse/src/csc/csc_serde.rs b/nalgebra-sparse/src/csc/csc_serde.rs index aab12d478..959deb12a 100644 --- a/nalgebra-sparse/src/csc/csc_serde.rs +++ b/nalgebra-sparse/src/csc/csc_serde.rs @@ -48,12 +48,12 @@ impl<'de, T> Deserialize<'de> for CscMatrix where T: Deserialize<'de> + Clone, { - fn deserialize(deserializer: D) -> Result, D::Error> + fn deserialize(deserializer: D) -> Result where D: Deserializer<'de>, { let de = CscMatrixSerializationData::, Vec>::deserialize(deserializer)?; - CscMatrix::try_from_csc_data( + Self::try_from_csc_data( de.nrows, de.ncols, de.col_offsets, diff --git a/nalgebra-sparse/src/csr/csr_serde.rs b/nalgebra-sparse/src/csr/csr_serde.rs index 1b33fda02..f70487ad9 100644 --- a/nalgebra-sparse/src/csr/csr_serde.rs +++ b/nalgebra-sparse/src/csr/csr_serde.rs @@ -48,12 +48,12 @@ impl<'de, T> Deserialize<'de> for CsrMatrix where T: Deserialize<'de> + Clone, { - fn deserialize(deserializer: D) -> Result, D::Error> + fn deserialize(deserializer: D) -> Result where D: Deserializer<'de>, { let de = CsrMatrixSerializationData::, Vec>::deserialize(deserializer)?; - CsrMatrix::try_from_csr_data( + Self::try_from_csr_data( de.nrows, de.ncols, de.row_offsets, From f22072c2a6ea2ee73c082b66f195a053a9ee32bb Mon Sep 17 00:00:00 2001 From: adamnemecek Date: Sat, 4 Jan 2025 21:59:34 -0800 Subject: [PATCH 16/17] cargo fmt --- nalgebra-macros/src/matrix_vector_impl.rs | 4 +--- nalgebra-sparse/src/pattern.rs | 8 +++----- 2 files changed, 4 insertions(+), 8 deletions(-) diff --git a/nalgebra-macros/src/matrix_vector_impl.rs b/nalgebra-macros/src/matrix_vector_impl.rs index 13aba67a7..b3d639a98 100644 --- a/nalgebra-macros/src/matrix_vector_impl.rs +++ b/nalgebra-macros/src/matrix_vector_impl.rs @@ -126,9 +126,7 @@ impl Parse for Vector { fn parse(input: ParseStream<'_>) -> syn::Result { // The syntax of a vector is just the syntax of a single matrix row if input.is_empty() { - Ok(Self { - elements: vec![], - }) + Ok(Self { elements: vec![] }) } else { let elements = MatrixRowSyntax::parse_terminated(input)? .into_iter() diff --git a/nalgebra-sparse/src/pattern.rs b/nalgebra-sparse/src/pattern.rs index 459352cc9..4cad1caf1 100644 --- a/nalgebra-sparse/src/pattern.rs +++ b/nalgebra-sparse/src/pattern.rs @@ -346,14 +346,12 @@ impl From for SparseFormatError { InvalidOffsetArrayLength | InvalidOffsetFirstLast | NonmonotonicOffsets - | NonmonotonicMinorIndices => { - Self::from_kind_and_error(InvalidStructure, Box::from(err)) - } - MinorIndexOutOfBounds => Self::from_kind_and_error(IndexOutOfBounds, Box::from(err)), + | NonmonotonicMinorIndices => Self::from_kind_and_error(InvalidStructure, err.into()), + MinorIndexOutOfBounds => Self::from_kind_and_error(IndexOutOfBounds, err.into()), PatternDuplicateEntry => Self::from_kind_and_error( #[allow(unused_qualifications)] SparseFormatErrorKind::DuplicateEntry, - Box::from(err), + err.into(), ), } } From e5215afe8fa02e31d987725691b2e5c12cf9d50b Mon Sep 17 00:00:00 2001 From: adamnemecek Date: Sun, 5 Jan 2025 11:53:57 -0800 Subject: [PATCH 17/17] changed some vec![] back to Vec::new() --- src/base/default_allocator.rs | 4 ++-- src/base/norm.rs | 2 +- src/base/vec_storage.rs | 8 ++++---- 3 files changed, 7 insertions(+), 7 deletions(-) diff --git a/src/base/default_allocator.rs b/src/base/default_allocator.rs index bb265d028..3b5d12811 100644 --- a/src/base/default_allocator.rs +++ b/src/base/default_allocator.rs @@ -93,7 +93,7 @@ impl Allocator for DefaultAllocator { #[inline] fn allocate_uninit(nrows: Dyn, ncols: C) -> VecStorage, Dyn, C> { - let mut data = vec![]; + let mut data = Vec::new(); let length = nrows.value() * ncols.value(); data.reserve_exact(length); data.resize_with(length, MaybeUninit::uninit); @@ -140,7 +140,7 @@ impl Allocator for DefaultAllocator { #[inline] fn allocate_uninit(nrows: R, ncols: Dyn) -> VecStorage, R, Dyn> { - let mut data = vec![]; + let mut data = Vec::new(); let length = nrows.value() * ncols.value(); data.reserve_exact(length); data.resize_with(length, MaybeUninit::uninit); diff --git a/src/base/norm.rs b/src/base/norm.rs index ca1ef7d82..90362be62 100644 --- a/src/base/norm.rs +++ b/src/base/norm.rs @@ -607,7 +607,7 @@ where #[cfg(any(feature = "std", feature = "alloc"))] { // XXX: use a GenericArray instead. - let mut known_basis = vec![]; + let mut known_basis = Vec::new(); for v in vs.iter() { known_basis.push(v.normalize()) diff --git a/src/base/vec_storage.rs b/src/base/vec_storage.rs index 35695db0e..f0a0593fa 100644 --- a/src/base/vec_storage.rs +++ b/src/base/vec_storage.rs @@ -34,7 +34,7 @@ pub struct VecStorage { impl Default for VecStorage { fn default() -> Self { Self { - data: vec![], + data: Vec::new(), nrows: Dyn::from_usize(0), ncols: Dyn::from_usize(0), } @@ -44,7 +44,7 @@ impl Default for VecStorage { impl Default for VecStorage { fn default() -> Self { Self { - data: vec![], + data: Vec::new(), nrows: R::name(), ncols: Dyn::from_usize(0), } @@ -54,7 +54,7 @@ impl Default for VecStorage { impl Default for VecStorage { fn default() -> Self { Self { - data: vec![], + data: Vec::new(), nrows: Dyn::from_usize(0), ncols: C::name(), } @@ -65,7 +65,7 @@ impl Default for VecStorage { fn default() -> Self { let nrows = R::name(); let ncols = C::name(); - let mut data = vec![]; + let mut data = Vec::new(); data.resize_with(nrows.value() * ncols.value(), Default::default); Self { data, nrows, ncols } }