From 39aa52d0194719fd9cf12381f2375767ebfffec2 Mon Sep 17 00:00:00 2001 From: Malte Tammena Date: Sun, 6 Jun 2021 14:46:36 +0200 Subject: [PATCH] Add must_use annotations in src/**/*.rs --- src/base/blas.rs | 3 ++ src/base/componentwise.rs | 5 ++ src/base/edition.rs | 4 ++ src/base/indexing.rs | 3 ++ src/base/interpolation.rs | 4 ++ src/base/matrix.rs | 31 ++++++++++++ src/base/matrix_slice.rs | 3 ++ src/base/min_max.rs | 15 ++++++ src/base/norm.rs | 12 ++++- src/base/ops.rs | 3 ++ src/base/properties.rs | 7 +++ src/base/statistics.rs | 15 ++++++ src/base/swizzle.rs | 1 + src/base/vec_storage.rs | 3 ++ src/geometry/dual_quaternion.rs | 17 ++++++- src/geometry/isometry.rs | 8 +++ src/geometry/isometry_interpolation.rs | 6 +++ src/geometry/orthographic.rs | 14 ++++++ src/geometry/perspective.rs | 12 +++++ src/geometry/point.rs | 8 +++ src/geometry/quaternion.rs | 61 +++++++++++++++++++++++ src/geometry/reflection.rs | 1 + src/geometry/rotation.rs | 7 +++ src/geometry/rotation_interpolation.rs | 3 ++ src/geometry/rotation_specialization.rs | 13 +++++ src/geometry/similarity.rs | 6 +++ src/geometry/swizzle.rs | 1 + src/geometry/transform.rs | 6 +++ src/geometry/translation.rs | 3 ++ src/geometry/unit_complex.rs | 14 ++++++ src/geometry/unit_complex_construction.rs | 3 ++ src/linalg/bidiagonal.rs | 6 +++ src/linalg/cholesky.rs | 4 ++ src/linalg/col_piv_qr.rs | 6 +++ src/linalg/convolution.rs | 1 + src/linalg/determinant.rs | 1 + src/linalg/full_piv_lu.rs | 7 +++ src/linalg/givens.rs | 2 + src/linalg/hessenberg.rs | 2 + src/linalg/lu.rs | 6 +++ src/linalg/permutation_sequence.rs | 3 ++ src/linalg/qr.rs | 4 ++ src/linalg/schur.rs | 4 ++ src/linalg/svd.rs | 3 ++ src/linalg/symmetric_eigen.rs | 2 + src/linalg/symmetric_tridiagonal.rs | 3 ++ src/linalg/udu.rs | 1 + src/sparse/cs_matrix.rs | 9 ++++ src/sparse/cs_matrix_cholesky.rs | 1 + 49 files changed, 354 insertions(+), 3 deletions(-) diff --git a/src/base/blas.rs b/src/base/blas.rs index 05705f17..f3e3fb91 100644 --- a/src/base/blas.rs +++ b/src/base/blas.rs @@ -193,6 +193,7 @@ where /// ``` /// #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn dot(&self, rhs: &Matrix) -> T where SB: Storage, @@ -221,6 +222,7 @@ where /// assert_ne!(vec1.dotc(&vec2), vec1.dot(&vec2)); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn dotc(&self, rhs: &Matrix) -> T where T: SimdComplexField, @@ -248,6 +250,7 @@ where /// assert_eq!(mat1.tr_dot(&mat2), 9.1); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn tr_dot(&self, rhs: &Matrix) -> T where SB: Storage, diff --git a/src/base/componentwise.rs b/src/base/componentwise.rs index 2ba49b2a..1a3ad284 100644 --- a/src/base/componentwise.rs +++ b/src/base/componentwise.rs @@ -28,6 +28,7 @@ impl> Matrix { /// assert_eq!(a.abs(), Matrix2::new(0.0, 1.0, 2.0, 3.0)) /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn abs(&self) -> OMatrix where T: Signed, @@ -49,6 +50,7 @@ macro_rules! component_binop_impl( ($($binop: ident, $binop_mut: ident, $binop_assign: ident, $cmpy: ident, $Trait: ident . $op: ident . $op_assign: ident, $desc:expr, $desc_cmpy:expr, $desc_mut:expr);* $(;)*) => {$( #[doc = $desc] #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn $binop(&self, rhs: &Matrix) -> MatrixComponentOp where T: $Trait, R2: Dim, C2: Dim, @@ -251,6 +253,7 @@ impl> Matrix /// assert_eq!(u.inf(&v), expected) /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn inf(&self, other: &Self) -> OMatrix where T: SimdPartialOrd, @@ -271,6 +274,7 @@ impl> Matrix /// assert_eq!(u.sup(&v), expected) /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn sup(&self, other: &Self) -> OMatrix where T: SimdPartialOrd, @@ -291,6 +295,7 @@ impl> Matrix /// assert_eq!(u.inf_sup(&v), expected) /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn inf_sup(&self, other: &Self) -> (OMatrix, OMatrix) where T: SimdPartialOrd, diff --git a/src/base/edition.rs b/src/base/edition.rs index 17c08c98..459dfcb2 100644 --- a/src/base/edition.rs +++ b/src/base/edition.rs @@ -18,6 +18,7 @@ use crate::base::{DefaultAllocator, Matrix, OMatrix, RowVector, Scalar, Vector}; impl> Matrix { /// Extracts the upper triangular part of this matrix (including the diagonal). #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn upper_triangle(&self) -> OMatrix where DefaultAllocator: Allocator, @@ -30,6 +31,7 @@ impl> Matrix { /// Extracts the lower triangular part of this matrix (including the diagonal). #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn lower_triangle(&self) -> OMatrix where DefaultAllocator: Allocator, @@ -42,6 +44,7 @@ impl> Matrix { /// Creates a new matrix by extracting the given set of rows from `self`. #[cfg(any(feature = "std", feature = "alloc"))] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn select_rows<'a, I>(&self, irows: I) -> OMatrix where I: IntoIterator, @@ -78,6 +81,7 @@ impl> Matrix { /// Creates a new matrix by extracting the given set of columns from `self`. #[cfg(any(feature = "std", feature = "alloc"))] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn select_columns<'a, I>(&self, icols: I) -> OMatrix where I: IntoIterator, diff --git a/src/base/indexing.rs b/src/base/indexing.rs index 3e0c085e..aa5ae942 100644 --- a/src/base/indexing.rs +++ b/src/base/indexing.rs @@ -485,6 +485,7 @@ impl> Matrix { /// Produces a view of the data at the given index, or /// `None` if the index is out of bounds. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn get<'a, I>(&'a self, index: I) -> Option where I: MatrixIndex<'a, T, R, C, S>, @@ -506,6 +507,7 @@ impl> Matrix { /// Produces a view of the data at the given index, or /// panics if the index is out of bounds. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn index<'a, I>(&'a self, index: I) -> I::Output where I: MatrixIndex<'a, T, R, C, S>, @@ -527,6 +529,7 @@ impl> Matrix { /// Produces a view of the data at the given index, without doing /// any bounds checking. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub unsafe fn get_unchecked<'a, I>(&'a self, index: I) -> I::Output where I: MatrixIndex<'a, T, R, C, S>, diff --git a/src/base/interpolation.rs b/src/base/interpolation.rs index c008743a..9dd72b5a 100644 --- a/src/base/interpolation.rs +++ b/src/base/interpolation.rs @@ -20,6 +20,7 @@ impl>(&self, rhs: &Vector, t: T) -> OVector where DefaultAllocator: Allocator, @@ -45,6 +46,7 @@ impl>(&self, rhs: &Vector, t: T) -> OVector where T: RealField, @@ -72,6 +74,7 @@ impl> Unit> { /// /// assert_eq!(v, v2); /// ``` + #[must_use = "This function does not mutate self. You should use the return value."] pub fn slerp>( &self, rhs: &Unit>, @@ -89,6 +92,7 @@ impl> Unit> { /// /// Returns `None` if the two vectors are almost collinear and with opposite direction /// (in this case, there is an infinity of possible results). + #[must_use = "This function does not mutate self. You should use the return value."] pub fn try_slerp>( &self, rhs: &Unit>, diff --git a/src/base/matrix.rs b/src/base/matrix.rs index bc9942be..ebd22d31 100644 --- a/src/base/matrix.rs +++ b/src/base/matrix.rs @@ -441,6 +441,7 @@ impl> Matrix { /// let mat = Matrix3x4::::zeros(); /// assert_eq!(mat.shape(), (3, 4)); #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn shape(&self) -> (usize, usize) { let (nrows, ncols) = self.data.shape(); (nrows.value(), ncols.value()) @@ -455,6 +456,7 @@ impl> Matrix { /// let mat = Matrix3x4::::zeros(); /// assert_eq!(mat.nrows(), 3); #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn nrows(&self) -> usize { self.shape().0 } @@ -468,6 +470,7 @@ impl> Matrix { /// let mat = Matrix3x4::::zeros(); /// assert_eq!(mat.ncols(), 4); #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn ncols(&self) -> usize { self.shape().1 } @@ -483,6 +486,7 @@ impl> Matrix { /// // The column strides is the number of steps (here 2) multiplied by the corresponding dimension. /// assert_eq!(mat.strides(), (1, 10)); #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn strides(&self) -> (usize, usize) { let (srows, scols) = self.data.strides(); (srows.value(), scols.value()) @@ -501,6 +505,7 @@ impl> Matrix { /// assert_eq!(m[i], m[3]); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn vector_to_matrix_index(&self, i: usize) -> (usize, usize) { let (nrows, ncols) = self.shape(); @@ -529,6 +534,7 @@ impl> Matrix { /// assert_eq!(unsafe { *ptr }, m[0]); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn as_ptr(&self) -> *const T { self.data.ptr() } @@ -537,6 +543,7 @@ impl> Matrix { /// /// See `relative_eq` from the `RelativeEq` trait for more details. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn relative_eq( &self, other: &Matrix, @@ -559,6 +566,7 @@ impl> Matrix { /// Tests whether `self` and `rhs` are exactly equal. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn eq(&self, other: &Matrix) -> bool where T: PartialEq, @@ -609,6 +617,7 @@ impl> Matrix { /// Clones this matrix to one that owns its data. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn clone_owned(&self) -> OMatrix where DefaultAllocator: Allocator, @@ -619,6 +628,7 @@ impl> Matrix { /// Clones this matrix into one that owns its data. The actual type of the result depends on /// matrix storage combination rules for addition. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn clone_owned_sum(&self) -> MatrixSum where R2: Dim, @@ -692,6 +702,7 @@ impl> Matrix { impl> Matrix { /// Returns a matrix containing the result of `f` applied to each of its entries. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn map T2>(&self, mut f: F) -> OMatrix where DefaultAllocator: Allocator, @@ -738,6 +749,7 @@ impl> Matrix { /// - If the matrix has has least one component, then `init_f` is called with the first component /// to compute the initial value. Folding then continues on all the remaining components of the matrix. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn fold_with( &self, init_f: impl FnOnce(Option<&T>) -> T2, @@ -751,6 +763,7 @@ impl> Matrix { /// Returns a matrix containing the result of `f` applied to each of its entries. Unlike `map`, /// `f` also gets passed the row and column index, i.e. `f(row, col, value)`. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn map_with_location T2>( &self, mut f: F, @@ -778,6 +791,7 @@ impl> Matrix { /// Returns a matrix containing the result of `f` applied to each entries of `self` and /// `rhs`. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn zip_map(&self, rhs: &Matrix, mut f: F) -> OMatrix where T2: Scalar, @@ -813,6 +827,7 @@ impl> Matrix { /// Returns a matrix containing the result of `f` applied to each entries of `self` and /// `b`, and `c`. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn zip_zip_map( &self, b: &Matrix, @@ -860,6 +875,7 @@ impl> Matrix { /// Folds a function `f` on each entry of `self`. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn fold(&self, init: Acc, mut f: impl FnMut(Acc, T) -> Acc) -> Acc { let (nrows, ncols) = self.data.shape(); @@ -879,6 +895,7 @@ impl> Matrix { /// Folds a function `f` on each pairs of entries from `self` and `rhs`. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn zip_fold( &self, rhs: &Matrix, @@ -1238,6 +1255,7 @@ impl> Matrix { impl> Vector { /// Gets a reference to the i-th element of this column vector without bound checking. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub unsafe fn vget_unchecked(&self, i: usize) -> &T { debug_assert!(i < self.nrows(), "Vector index out of bounds."); let i = i * self.strides().0; @@ -1258,6 +1276,7 @@ impl> Vector { impl> Matrix { /// Extracts a slice containing the entire matrix entries ordered column-by-columns. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn as_slice(&self) -> &[T] { self.data.as_slice() } @@ -1446,6 +1465,7 @@ impl> Matrix { impl> SquareMatrix { /// The diagonal of this matrix. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn diagonal(&self) -> OVector where DefaultAllocator: Allocator, @@ -1457,6 +1477,7 @@ impl> SquareMatrix { /// /// This is a more efficient version of `self.diagonal().map(f)` since this /// allocates only once. + #[must_use = "This function does not mutate self. You should use the return value."] pub fn map_diagonal(&self, mut f: impl FnMut(T) -> T2) -> OVector where DefaultAllocator: Allocator, @@ -1481,6 +1502,7 @@ impl> SquareMatrix { /// Computes a trace of a square matrix, i.e., the sum of its diagonal elements. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn trace(&self) -> T where T: Scalar + Zero + ClosedAdd, @@ -1504,6 +1526,7 @@ impl> SquareMatrix { impl> SquareMatrix { /// The symmetric part of `self`, i.e., `0.5 * (self + self.transpose())`. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn symmetric_part(&self) -> OMatrix where DefaultAllocator: Allocator, @@ -1520,6 +1543,7 @@ impl> SquareMatrix { /// The hermitian part of `self`, i.e., `0.5 * (self + self.adjoint())`. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn hermitian_part(&self) -> OMatrix where DefaultAllocator: Allocator, @@ -1542,6 +1566,7 @@ impl + IsNotStaticOne, S: Storage /// Yields the homogeneous matrix for this matrix, i.e., appending an additional dimension and /// and setting the diagonal element to `1`. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn to_homogeneous(&self) -> OMatrix, DimSum> where DefaultAllocator: Allocator, DimSum>, @@ -1562,6 +1587,7 @@ impl, S: Storage> Vector { /// Computes the coordinates in projective space of this vector, i.e., appends a `0` to its /// coordinates. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn to_homogeneous(&self) -> OVector> where DefaultAllocator: Allocator>, @@ -1589,6 +1615,7 @@ impl, S: Storage> Vector { impl, S: Storage> Vector { /// Constructs a new vector of higher dimension by appending `element` to the end of `self`. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn push(&self, element: T) -> OVector> where DefaultAllocator: Allocator>, @@ -1891,6 +1918,7 @@ impl(&self, b: &Matrix) -> T where R2: Dim, @@ -1920,6 +1948,7 @@ impl(&self, b: &Matrix) -> MatrixCross where R2: Dim, @@ -1993,6 +2022,7 @@ impl> Vector { /// Computes the matrix `M` such that for all vector `v` we have `M * v == self.cross(&v)`. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn cross_matrix(&self) -> OMatrix { OMatrix::::new( T::zero(), @@ -2011,6 +2041,7 @@ impl> Vector { impl> Matrix { /// The smallest angle between two vectors. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn angle(&self, other: &Matrix) -> T::SimdRealField where SB: Storage, diff --git a/src/base/matrix_slice.rs b/src/base/matrix_slice.rs index 6b03c7b2..646acbc6 100644 --- a/src/base/matrix_slice.rs +++ b/src/base/matrix_slice.rs @@ -812,6 +812,7 @@ impl> Matrix { /// Slices a sub-matrix containing the rows indexed by the range `rows` and the columns indexed /// by the range `cols`. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn slice_range( &self, rows: RowRange, @@ -830,6 +831,7 @@ impl> Matrix { /// Slice containing all the rows indexed by the range `rows`. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn rows_range>( &self, rows: RowRange, @@ -839,6 +841,7 @@ impl> Matrix { /// Slice containing all the columns indexed by the range `rows`. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn columns_range>( &self, cols: ColRange, diff --git a/src/base/min_max.rs b/src/base/min_max.rs index d532d87a..ba109380 100644 --- a/src/base/min_max.rs +++ b/src/base/min_max.rs @@ -13,6 +13,7 @@ impl> Matrix { /// assert_eq!(Vector3::new(-1.0, -2.0, -3.0).amax(), 3.0); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn amax(&self) -> T where T: Zero + SimdSigned + SimdPartialOrd, @@ -33,6 +34,7 @@ impl> Matrix { /// Complex::new(1.0, 3.0)).camax(), 5.0); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn camax(&self) -> T::SimdRealField where T: SimdComplexField, @@ -52,6 +54,7 @@ impl> Matrix { /// assert_eq!(Vector3::new(5u32, 2, 3).max(), 5); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn max(&self) -> T where T: SimdPartialOrd + Zero, @@ -70,6 +73,7 @@ impl> Matrix { /// assert_eq!(Vector3::new(10.0, 2.0, 30.0).amin(), 2.0); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn amin(&self) -> T where T: Zero + SimdPartialOrd + SimdSigned, @@ -90,6 +94,7 @@ impl> Matrix { /// Complex::new(1.0, 3.0)).camin(), 3.0); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn camin(&self) -> T::SimdRealField where T: SimdComplexField, @@ -112,6 +117,7 @@ impl> Matrix { /// assert_eq!(Vector3::new(5u32, 2, 3).min(), 2); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn min(&self) -> T where T: SimdPartialOrd + Zero, @@ -136,6 +142,7 @@ impl> Matrix { /// assert_eq!(mat.icamax_full(), (1, 0)); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn icamax_full(&self) -> (usize, usize) where T: ComplexField, @@ -172,6 +179,7 @@ impl> Matri /// assert_eq!(mat.iamax_full(), (1, 2)); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn iamax_full(&self) -> (usize, usize) { assert!(!self.is_empty(), "The input matrix must not be empty."); @@ -209,6 +217,7 @@ impl> Vector { /// assert_eq!(vec.icamax(), 2); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn icamax(&self) -> usize where T: ComplexField, @@ -240,6 +249,7 @@ impl> Vector { /// assert_eq!(vec.argmax(), (2, 13)); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn argmax(&self) -> (usize, T) where T: PartialOrd, @@ -271,6 +281,7 @@ impl> Vector { /// assert_eq!(vec.imax(), 2); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn imax(&self) -> usize where T: PartialOrd, @@ -288,6 +299,7 @@ impl> Vector { /// assert_eq!(vec.iamax(), 1); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn iamax(&self) -> usize where T: PartialOrd + Signed, @@ -319,6 +331,7 @@ impl> Vector { /// assert_eq!(vec.argmin(), (1, -15)); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn argmin(&self) -> (usize, T) where T: PartialOrd, @@ -350,6 +363,7 @@ impl> Vector { /// assert_eq!(vec.imin(), 1); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn imin(&self) -> usize where T: PartialOrd, @@ -367,6 +381,7 @@ impl> Vector { /// assert_eq!(vec.iamin(), 0); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn iamin(&self) -> usize where T: PartialOrd + Signed, diff --git a/src/base/norm.rs b/src/base/norm.rs index ab44ed02..0cf42906 100644 --- a/src/base/norm.rs +++ b/src/base/norm.rs @@ -158,6 +158,7 @@ impl Norm for UniformNorm { impl> Matrix { /// The squared L2 norm of this vector. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn norm_squared(&self) -> T::SimdRealField where T: SimdComplexField, @@ -176,6 +177,7 @@ impl> Matrix { /// /// Use `.apply_norm` to apply a custom norm. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn norm(&self) -> T::SimdRealField where T: SimdComplexField, @@ -187,6 +189,7 @@ impl> Matrix { /// /// Use `.apply_metric_distance` to apply a custom norm. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn metric_distance(&self, rhs: &Matrix) -> T::SimdRealField where T: SimdComplexField, @@ -211,6 +214,7 @@ impl> Matrix { /// assert_eq!(v.apply_norm(&EuclideanNorm), v.norm()); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn apply_norm(&self, norm: &impl Norm) -> T::SimdRealField where T: SimdComplexField, @@ -233,6 +237,7 @@ impl> Matrix { /// assert_eq!(v1.apply_metric_distance(&v2, &EuclideanNorm), (v1 - v2).norm()); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn apply_metric_distance( &self, rhs: &Matrix, @@ -254,6 +259,7 @@ impl> Matrix { /// /// This function is simply implemented as a call to `norm()` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn magnitude(&self) -> T::SimdRealField where T: SimdComplexField, @@ -267,6 +273,7 @@ impl> Matrix { /// /// This function is simply implemented as a call to `norm_squared()` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn magnitude_squared(&self) -> T::SimdRealField where T: SimdComplexField, @@ -298,6 +305,7 @@ impl> Matrix { /// The Lp norm of this matrix. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn lp_norm(&self, p: i32) -> T::SimdRealField where T: SimdComplexField, @@ -340,8 +348,8 @@ impl> Matrix { } /// Returns a new vector with the same magnitude as `self` clamped between `0.0` and `max`. - #[must_use = "This function does not mutate self but returns a new clamped version."] #[inline] + #[must_use = "This function does not mutate self but returns a new clamped version."] pub fn cap_magnitude(&self, max: T::RealField) -> OMatrix where T: ComplexField, @@ -357,8 +365,8 @@ impl> Matrix { } /// Returns a new vector with the same magnitude as `self` clamped between `0.0` and `max`. - #[must_use = "This function does not mutate self but returns a new clamped version."] #[inline] + #[must_use = "This function does not mutate self but returns a new clamped version."] pub fn simd_cap_magnitude(&self, max: T::SimdRealField) -> OMatrix where T: SimdComplexField, diff --git a/src/base/ops.rs b/src/base/ops.rs index 8917efb1..b23a85e6 100644 --- a/src/base/ops.rs +++ b/src/base/ops.rs @@ -676,6 +676,7 @@ where { /// Equivalent to `self.transpose() * rhs`. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn tr_mul(&self, rhs: &Matrix) -> OMatrix where SB: Storage, @@ -692,6 +693,7 @@ where /// Equivalent to `self.adjoint() * rhs`. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn ad_mul(&self, rhs: &Matrix) -> OMatrix where T: SimdComplexField, @@ -801,6 +803,7 @@ where /// The kronecker product of two matrices (aka. tensor product of the corresponding linear /// maps). + #[must_use = "This function does not mutate self. You should use the return value."] pub fn kronecker( &self, rhs: &Matrix, diff --git a/src/base/properties.rs b/src/base/properties.rs index 1cbff719..e5645ce0 100644 --- a/src/base/properties.rs +++ b/src/base/properties.rs @@ -20,6 +20,7 @@ impl> Matrix { /// assert_eq!(mat.len(), 12); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn len(&self) -> usize { let (nrows, ncols) = self.shape(); nrows * ncols @@ -35,12 +36,14 @@ impl> Matrix { /// assert!(!mat.is_empty()); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn is_empty(&self) -> bool { self.len() == 0 } /// Indicates if this is a square matrix. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn is_square(&self) -> bool { let (nrows, ncols) = self.shape(); nrows == ncols @@ -52,6 +55,7 @@ impl> Matrix { /// If the matrix is diagonal, this checks that diagonal elements (i.e. at coordinates `(i, i)` /// for i from `0` to `min(R, C)`) are equal one; and that all other elements are zero. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn is_identity(&self, eps: T::Epsilon) -> bool where T: Zero + One + RelativeEq, @@ -112,6 +116,7 @@ impl> Matrix { /// In this definition `Id` is approximately equal to the identity matrix with a relative error /// equal to `eps`. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn is_orthogonal(&self, eps: T::Epsilon) -> bool where T: Zero + One + ClosedAdd + ClosedMul + RelativeEq, @@ -129,6 +134,7 @@ where { /// Checks that this matrix is orthogonal and has a determinant equal to 1. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn is_special_orthogonal(&self, eps: T) -> bool where D: DimMin, @@ -139,6 +145,7 @@ where /// Returns `true` if this matrix is invertible. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn is_invertible(&self) -> bool { // TODO: improve this? self.clone_owned().try_inverse().is_some() diff --git a/src/base/statistics.rs b/src/base/statistics.rs index 8f6c77ce..0b3a8279 100644 --- a/src/base/statistics.rs +++ b/src/base/statistics.rs @@ -9,6 +9,7 @@ impl> Matrix { /// Returns a row vector where each element is the result of the application of `f` on the /// corresponding column of the original matrix. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn compress_rows( &self, f: impl Fn(VectorSlice) -> T, @@ -35,6 +36,7 @@ impl> Matrix { /// /// This is the same as `self.compress_rows(f).transpose()`. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn compress_rows_tr( &self, f: impl Fn(VectorSlice) -> T, @@ -58,6 +60,7 @@ impl> Matrix { /// Returns a column vector resulting from the folding of `f` on each column of this matrix. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn compress_columns( &self, init: OVector, @@ -95,6 +98,7 @@ impl> Matrix { /// assert_eq!(m.sum(), 21.0); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn sum(&self) -> T where T: ClosedAdd + Zero, @@ -120,6 +124,7 @@ impl> Matrix { /// assert_eq!(mint.row_sum(), RowVector2::new(9,12)); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn row_sum(&self) -> RowOVector where T: ClosedAdd + Zero, @@ -144,6 +149,7 @@ impl> Matrix { /// assert_eq!(mint.row_sum_tr(), Vector2::new(9,12)); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn row_sum_tr(&self) -> OVector where T: ClosedAdd + Zero, @@ -168,6 +174,7 @@ impl> Matrix { /// assert_eq!(mint.column_sum(), Vector3::new(3,7,11)); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn column_sum(&self) -> OVector where T: ClosedAdd + Zero, @@ -197,6 +204,7 @@ impl> Matrix { /// assert_relative_eq!(m.variance(), 35.0 / 12.0, epsilon = 1.0e-8); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn variance(&self) -> T where T: Field + SupersetOf, @@ -226,6 +234,7 @@ impl> Matrix { /// assert_eq!(m.row_variance(), RowVector3::new(2.25, 2.25, 2.25)); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn row_variance(&self) -> RowOVector where T: Field + SupersetOf, @@ -246,6 +255,7 @@ impl> Matrix { /// assert_eq!(m.row_variance_tr(), Vector3::new(2.25, 2.25, 2.25)); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn row_variance_tr(&self) -> OVector where T: Field + SupersetOf, @@ -267,6 +277,7 @@ impl> Matrix { /// assert_relative_eq!(m.column_variance(), Vector2::new(2.0 / 3.0, 2.0 / 3.0), epsilon = 1.0e-8); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn column_variance(&self) -> OVector where T: Field + SupersetOf, @@ -306,6 +317,7 @@ impl> Matrix { /// assert_eq!(m.mean(), 3.5); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn mean(&self) -> T where T: Field + SupersetOf, @@ -331,6 +343,7 @@ impl> Matrix { /// assert_eq!(m.row_mean(), RowVector3::new(2.5, 3.5, 4.5)); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn row_mean(&self) -> RowOVector where T: Field + SupersetOf, @@ -351,6 +364,7 @@ impl> Matrix { /// assert_eq!(m.row_mean_tr(), Vector3::new(2.5, 3.5, 4.5)); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn row_mean_tr(&self) -> OVector where T: Field + SupersetOf, @@ -371,6 +385,7 @@ impl> Matrix { /// assert_eq!(m.column_mean(), Vector2::new(2.0, 5.0)); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn column_mean(&self) -> OVector where T: Field + SupersetOf, diff --git a/src/base/swizzle.rs b/src/base/swizzle.rs index 1e2f0e4c..76fecda2 100644 --- a/src/base/swizzle.rs +++ b/src/base/swizzle.rs @@ -8,6 +8,7 @@ macro_rules! impl_swizzle { $( /// Builds a new vector from components of `self`. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn $name(&self) -> $Result where D::Typenum: Cmp { $Result::new($(self[$i].inlined_clone()),*) diff --git a/src/base/vec_storage.rs b/src/base/vec_storage.rs index 8b2d2ef2..48a25b20 100644 --- a/src/base/vec_storage.rs +++ b/src/base/vec_storage.rs @@ -95,6 +95,7 @@ impl VecStorage { /// The underlying data storage. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn as_vec(&self) -> &Vec { &self.data } @@ -129,12 +130,14 @@ impl VecStorage { /// The number of elements on the underlying vector. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn len(&self) -> usize { self.data.len() } /// Returns true if the underlying vector contains no elements. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn is_empty(&self) -> bool { self.len() == 0 } diff --git a/src/geometry/dual_quaternion.rs b/src/geometry/dual_quaternion.rs index b6b127ce..04252b22 100644 --- a/src/geometry/dual_quaternion.rs +++ b/src/geometry/dual_quaternion.rs @@ -232,6 +232,7 @@ where /// )); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn lerp(&self, other: &Self, t: T) -> Self { self * (T::one() - t) + other * t } @@ -381,6 +382,7 @@ where /// )); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn dual_quaternion(&self) -> &DualQuaternion { self.as_ref() } @@ -463,7 +465,6 @@ where /// assert_relative_eq!(inv * unit, UnitDualQuaternion::identity(), epsilon = 1.0e-6); /// ``` #[inline] - #[must_use = "Did you mean to use inverse_mut()?"] pub fn inverse_mut(&mut self) { let quat = self.as_mut_unchecked(); quat.real = Unit::new_unchecked(quat.real).inverse().into_inner(); @@ -486,6 +487,7 @@ where /// assert_relative_eq!(dq_to * dq1, dq2, epsilon = 1.0e-6); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn isometry_to(&self, other: &Self) -> Self { other / self } @@ -518,6 +520,7 @@ where /// ); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn lerp(&self, other: &Self, t: T) -> DualQuaternion { self.as_ref().lerp(other.as_ref(), t) } @@ -546,6 +549,7 @@ where /// ), epsilon = 1.0e-6); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn nlerp(&self, other: &Self, t: T) -> Self { let mut res = self.lerp(other, t); let _ = res.normalize_mut(); @@ -581,6 +585,7 @@ where /// ); /// assert_relative_eq!(dq.translation().vector.y, 3.0, epsilon = 1.0e-6); #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn sclerp(&self, other: &Self, t: T) -> Self where T: RealField, @@ -600,6 +605,7 @@ where /// * `epsilon`: the value below which the sinus of the angle separating both quaternion /// must be to return `None`. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn try_sclerp(&self, other: &Self, t: T, epsilon: T) -> Option where T: RealField, @@ -667,6 +673,7 @@ where /// ); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn rotation(&self) -> UnitQuaternion { Unit::new_unchecked(self.as_ref().real) } @@ -686,6 +693,7 @@ where /// ); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn translation(&self) -> Translation3 { let two = T::one() + T::one(); Translation3::from( @@ -712,6 +720,7 @@ where /// assert_relative_eq!(iso.translation.vector, translation, epsilon = 1.0e-6); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn to_isometry(&self) -> Isometry3 { Isometry3::from_parts(self.translation(), self.rotation()) } @@ -735,6 +744,7 @@ where /// ); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn transform_point(&self, pt: &Point3) -> Point3 { self * pt } @@ -758,6 +768,7 @@ where /// ); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn transform_vector(&self, v: &Vector3) -> Vector3 { self * v } @@ -781,6 +792,7 @@ where /// ); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn inverse_transform_point(&self, pt: &Point3) -> Point3 { self.inverse() * pt } @@ -805,6 +817,7 @@ where /// ); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn inverse_transform_vector(&self, v: &Vector3) -> Vector3 { self.inverse() * v } @@ -830,6 +843,7 @@ where /// ); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn inverse_transform_unit_vector(&self, v: &Unit>) -> Unit> { self.inverse() * v } @@ -857,6 +871,7 @@ where /// assert_relative_eq!(dq.to_homogeneous(), expected, epsilon = 1.0e-6); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn to_homogeneous(&self) -> Matrix4 { self.to_isometry().to_homogeneous() } diff --git a/src/geometry/isometry.rs b/src/geometry/isometry.rs index d307c393..19e2ed52 100755 --- a/src/geometry/isometry.rs +++ b/src/geometry/isometry.rs @@ -267,6 +267,7 @@ where /// assert_eq!(iso1.inverse() * iso2, iso1.inv_mul(&iso2)); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn inv_mul(&self, rhs: &Isometry) -> Self { let inv_rot1 = self.rotation.inverse(); let tr_12 = rhs.translation.vector.clone() - self.translation.vector.clone(); @@ -384,6 +385,7 @@ where /// assert_relative_eq!(transformed_point, Point3::new(3.0, 2.0, 2.0), epsilon = 1.0e-6); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn transform_point(&self, pt: &Point) -> Point { self * pt } @@ -407,6 +409,7 @@ where /// assert_relative_eq!(transformed_point, Vector3::new(3.0, 2.0, -1.0), epsilon = 1.0e-6); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn transform_vector(&self, v: &SVector) -> SVector { self * v } @@ -429,6 +432,7 @@ where /// assert_relative_eq!(transformed_point, Point3::new(0.0, 2.0, 1.0), epsilon = 1.0e-6); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn inverse_transform_point(&self, pt: &Point) -> Point { self.rotation .inverse_transform_point(&(pt - &self.translation.vector)) @@ -453,6 +457,7 @@ where /// assert_relative_eq!(transformed_point, Vector3::new(-3.0, 2.0, 1.0), epsilon = 1.0e-6); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn inverse_transform_vector(&self, v: &SVector) -> SVector { self.rotation.inverse_transform_vector(v) } @@ -476,6 +481,7 @@ where /// assert_relative_eq!(transformed_point, -Vector3::y_axis(), epsilon = 1.0e-6); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn inverse_transform_unit_vector(&self, v: &Unit>) -> Unit> { self.rotation.inverse_transform_unit_vector(v) } @@ -505,6 +511,7 @@ impl Isometry { /// assert_relative_eq!(iso.to_homogeneous(), expected, epsilon = 1.0e-6); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn to_homogeneous(&self) -> OMatrix, U1>, DimNameSum, U1>> where Const: DimNameAdd, @@ -536,6 +543,7 @@ impl Isometry { /// assert_relative_eq!(iso.to_matrix(), expected, epsilon = 1.0e-6); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn to_matrix(&self) -> OMatrix, U1>, DimNameSum, U1>> where Const: DimNameAdd, diff --git a/src/geometry/isometry_interpolation.rs b/src/geometry/isometry_interpolation.rs index 2ee5461a..1133ae26 100644 --- a/src/geometry/isometry_interpolation.rs +++ b/src/geometry/isometry_interpolation.rs @@ -26,6 +26,7 @@ impl Isometry3 { /// assert_eq!(iso3.rotation.euler_angles(), (std::f32::consts::FRAC_PI_2, 0.0, 0.0)); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn lerp_slerp(&self, other: &Self, t: T) -> Self where T: RealField, @@ -59,6 +60,7 @@ impl Isometry3 { /// assert_eq!(iso3.rotation.euler_angles(), (std::f32::consts::FRAC_PI_2, 0.0, 0.0)); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn try_lerp_slerp(&self, other: &Self, t: T, epsilon: T) -> Option where T: RealField, @@ -94,6 +96,7 @@ impl IsometryMatrix3 { /// assert_eq!(iso3.rotation.euler_angles(), (std::f32::consts::FRAC_PI_2, 0.0, 0.0)); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn lerp_slerp(&self, other: &Self, t: T) -> Self where T: RealField, @@ -127,6 +130,7 @@ impl IsometryMatrix3 { /// assert_eq!(iso3.rotation.euler_angles(), (std::f32::consts::FRAC_PI_2, 0.0, 0.0)); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn try_lerp_slerp(&self, other: &Self, t: T, epsilon: T) -> Option where T: RealField, @@ -163,6 +167,7 @@ impl Isometry2 { /// assert_relative_eq!(iso3.rotation.angle(), std::f32::consts::FRAC_PI_2); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn lerp_slerp(&self, other: &Self, t: T) -> Self where T: RealField, @@ -199,6 +204,7 @@ impl IsometryMatrix2 { /// assert_relative_eq!(iso3.rotation.angle(), std::f32::consts::FRAC_PI_2); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn lerp_slerp(&self, other: &Self, t: T) -> Self where T: RealField, diff --git a/src/geometry/orthographic.rs b/src/geometry/orthographic.rs index d6136cec..1a02ebc8 100644 --- a/src/geometry/orthographic.rs +++ b/src/geometry/orthographic.rs @@ -188,6 +188,7 @@ impl Orthographic3 { /// assert_relative_eq!(proj.as_matrix() * inv, Matrix4::identity()); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn inverse(&self) -> Matrix4 { let mut res = self.to_homogeneous(); @@ -221,6 +222,7 @@ impl Orthographic3 { /// assert_eq!(proj.to_homogeneous(), expected); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn to_homogeneous(&self) -> Matrix4 { self.matrix } @@ -240,6 +242,7 @@ impl Orthographic3 { /// assert_eq!(*proj.as_matrix(), expected); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn as_matrix(&self) -> &Matrix4 { &self.matrix } @@ -253,6 +256,7 @@ impl Orthographic3 { /// assert_eq!(proj.as_projective().to_homogeneous(), proj.to_homogeneous()); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn as_projective(&self) -> &Projective3 { unsafe { mem::transmute(self) } } @@ -266,6 +270,7 @@ impl Orthographic3 { /// assert_eq!(proj.to_projective().to_homogeneous(), proj.to_homogeneous()); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn to_projective(&self) -> Projective3 { Projective3::from_matrix_unchecked(self.matrix) } @@ -310,6 +315,7 @@ impl Orthographic3 { /// assert_relative_eq!(proj.left(), 10.0, epsilon = 1.0e-6); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn left(&self) -> T { (-T::one() - self.matrix[(0, 3)]) / self.matrix[(0, 0)] } @@ -326,6 +332,7 @@ impl Orthographic3 { /// assert_relative_eq!(proj.right(), 1.0, epsilon = 1.0e-6); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn right(&self) -> T { (T::one() - self.matrix[(0, 3)]) / self.matrix[(0, 0)] } @@ -342,6 +349,7 @@ impl Orthographic3 { /// assert_relative_eq!(proj.bottom(), 20.0, epsilon = 1.0e-6); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn bottom(&self) -> T { (-T::one() - self.matrix[(1, 3)]) / self.matrix[(1, 1)] } @@ -358,6 +366,7 @@ impl Orthographic3 { /// assert_relative_eq!(proj.top(), 2.0, epsilon = 1.0e-6); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn top(&self) -> T { (T::one() - self.matrix[(1, 3)]) / self.matrix[(1, 1)] } @@ -374,6 +383,7 @@ impl Orthographic3 { /// assert_relative_eq!(proj.znear(), 1000.0, epsilon = 1.0e-6); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn znear(&self) -> T { (T::one() + self.matrix[(2, 3)]) / self.matrix[(2, 2)] } @@ -390,6 +400,7 @@ impl Orthographic3 { /// assert_relative_eq!(proj.zfar(), 0.1, epsilon = 1.0e-6); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn zfar(&self) -> T { (-T::one() + self.matrix[(2, 3)]) / self.matrix[(2, 2)] } @@ -422,6 +433,7 @@ impl Orthographic3 { /// assert_relative_eq!(proj.project_point(&p8), Point3::new( 1.0, 1.0, 1.0)); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn project_point(&self, p: &Point3) -> Point3 { Point3::new( self.matrix[(0, 0)] * p[0] + self.matrix[(0, 3)], @@ -457,6 +469,7 @@ impl Orthographic3 { /// assert_relative_eq!(proj.unproject_point(&p8), Point3::new(10.0, 20.0, -1000.0), epsilon = 1.0e-6); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn unproject_point(&self, p: &Point3) -> Point3 { Point3::new( (p[0] - self.matrix[(0, 3)]) / self.matrix[(0, 0)], @@ -485,6 +498,7 @@ impl Orthographic3 { /// assert_relative_eq!(proj.project_vector(&v3), Vector3::z() * -2.0 / 999.9); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn project_vector(&self, p: &Vector) -> Vector3 where SB: Storage, diff --git a/src/geometry/perspective.rs b/src/geometry/perspective.rs index fac8fa99..c300b292 100644 --- a/src/geometry/perspective.rs +++ b/src/geometry/perspective.rs @@ -104,6 +104,7 @@ impl Perspective3 { /// Retrieves the inverse of the underlying homogeneous matrix. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn inverse(&self) -> Matrix4 { let mut res = self.to_homogeneous(); @@ -123,24 +124,28 @@ impl Perspective3 { /// Computes the corresponding homogeneous matrix. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn to_homogeneous(&self) -> Matrix4 { self.matrix.clone_owned() } /// A reference to the underlying homogeneous transformation matrix. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn as_matrix(&self) -> &Matrix4 { &self.matrix } /// A reference to this transformation seen as a `Projective3`. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn as_projective(&self) -> &Projective3 { unsafe { mem::transmute(self) } } /// This transformation seen as a `Projective3`. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn to_projective(&self) -> Projective3 { Projective3::from_matrix_unchecked(self.matrix) } @@ -161,18 +166,21 @@ impl Perspective3 { /// Gets the `width / height` aspect ratio of the view frustum. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn aspect(&self) -> T { self.matrix[(1, 1)] / self.matrix[(0, 0)] } /// Gets the y field of view of the view frustum. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn fovy(&self) -> T { (T::one() / self.matrix[(1, 1)]).atan() * crate::convert(2.0) } /// Gets the near plane offset of the view frustum. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn znear(&self) -> T { let ratio = (-self.matrix[(2, 2)] + T::one()) / (-self.matrix[(2, 2)] - T::one()); @@ -182,6 +190,7 @@ impl Perspective3 { /// Gets the far plane offset of the view frustum. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn zfar(&self) -> T { let ratio = (-self.matrix[(2, 2)] + T::one()) / (-self.matrix[(2, 2)] - T::one()); @@ -193,6 +202,7 @@ impl Perspective3 { // TODO: when we get specialization, specialize the Mul impl instead. /// Projects a point. Faster than matrix multiplication. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn project_point(&self, p: &Point3) -> Point3 { let inverse_denom = -T::one() / p[2]; Point3::new( @@ -204,6 +214,7 @@ impl Perspective3 { /// Un-projects a point. Faster than multiplication by the matrix inverse. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn unproject_point(&self, p: &Point3) -> Point3 { let inverse_denom = self.matrix[(2, 3)] / (p[2] + self.matrix[(2, 2)]); @@ -217,6 +228,7 @@ impl Perspective3 { // TODO: when we get specialization, specialize the Mul impl instead. /// Projects a vector. Faster than matrix multiplication. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn project_vector(&self, p: &Vector) -> Vector3 where SB: Storage, diff --git a/src/geometry/point.rs b/src/geometry/point.rs index 60fa9156..8a9bb040 100644 --- a/src/geometry/point.rs +++ b/src/geometry/point.rs @@ -122,6 +122,7 @@ impl Point { /// assert_eq!(p.map(|e| e as u32), Point3::new(1, 2, 3)); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn map T2>(&self, f: F) -> Point { self.coords.map(f).into() } @@ -161,6 +162,7 @@ impl Point { /// assert_eq!(p.to_homogeneous(), Vector4::new(10.0, 20.0, 30.0, 1.0)); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn to_homogeneous(&self) -> OVector, U1>> where T: One, @@ -199,6 +201,7 @@ impl Point { /// assert_eq!(p.len(), 3); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn len(&self) -> usize { self.coords.len() } @@ -212,6 +215,7 @@ impl Point { /// assert!(!p.is_empty()); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn is_empty(&self) -> bool { self.len() == 0 } @@ -246,6 +250,7 @@ impl Point { /// Gets a reference to i-th element of this point without bound-checking. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub unsafe fn get_unchecked(&self, i: usize) -> &T { self.coords.vget_unchecked(i) } @@ -378,18 +383,21 @@ impl PartialOrd for Point { impl Point { /// Computes the infimum (aka. componentwise min) of two points. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn inf(&self, other: &Self) -> Point { self.coords.inf(&other.coords).into() } /// Computes the supremum (aka. componentwise max) of two points. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn sup(&self, other: &Self) -> Point { self.coords.sup(&other.coords).into() } /// Computes the (infimum, supremum) of two points. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn inf_sup(&self, other: &Self) -> (Point, Point) { let (inf, sup) = self.coords.inf_sup(&other.coords); (inf.into(), sup.into()) diff --git a/src/geometry/quaternion.rs b/src/geometry/quaternion.rs index 6852335b..79bca5ac 100755 --- a/src/geometry/quaternion.rs +++ b/src/geometry/quaternion.rs @@ -191,6 +191,7 @@ where /// The imaginary part of this quaternion. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn imag(&self) -> Vector3 { self.coords.xyz() } @@ -223,6 +224,7 @@ where /// assert_eq!(q1.lerp(&q2, 0.1), Quaternion::new(1.9, 3.8, 5.7, 7.6)); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn lerp(&self, other: &Self, t: T) -> Self { self * (T::one() - t) + other * t } @@ -238,6 +240,7 @@ where /// assert_eq!(q.vector()[2], 4.0); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn vector(&self) -> MatrixSlice, CStride> { self.coords.fixed_rows::<3>(0) } @@ -251,6 +254,7 @@ where /// assert_eq!(q.scalar(), 1.0); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn scalar(&self) -> T { self.coords[3] } @@ -266,6 +270,7 @@ where /// assert_eq!(*q.as_vector(), Vector4::new(2.0, 3.0, 4.0, 1.0)); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn as_vector(&self) -> &Vector4 { &self.coords } @@ -280,6 +285,7 @@ where /// assert_relative_eq!(q.norm(), 5.47722557, epsilon = 1.0e-6); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn norm(&self) -> T { self.coords.norm() } @@ -297,6 +303,7 @@ where /// assert_relative_eq!(q.magnitude(), 5.47722557, epsilon = 1.0e-6); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn magnitude(&self) -> T { self.norm() } @@ -310,6 +317,7 @@ where /// assert_eq!(q.magnitude_squared(), 30.0); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn norm_squared(&self) -> T { self.coords.norm_squared() } @@ -326,6 +334,7 @@ where /// assert_eq!(q.magnitude_squared(), 30.0); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn magnitude_squared(&self) -> T { self.norm_squared() } @@ -340,6 +349,7 @@ where /// assert_eq!(q1.dot(&q2), 70.0); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn dot(&self, rhs: &Self) -> T { self.coords.dot(&rhs.coords) } @@ -409,6 +419,7 @@ where /// let result = a.inner(&b); /// assert_relative_eq!(expected, result, epsilon = 1.0e-5); #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn inner(&self, other: &Self) -> Self { (self * other + other * self).half() } @@ -428,6 +439,7 @@ where /// assert_relative_eq!(expected, result, epsilon = 1.0e-5); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn outer(&self, other: &Self) -> Self { #[allow(clippy::eq_op)] (self * other - other * self).half() @@ -448,6 +460,7 @@ where /// assert_relative_eq!(expected, result, epsilon = 1.0e-5); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn project(&self, other: &Self) -> Option where T: RealField, @@ -470,6 +483,7 @@ where /// assert_relative_eq!(expected, result, epsilon = 1.0e-5); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn reject(&self, other: &Self) -> Option where T: RealField, @@ -492,6 +506,7 @@ where /// assert_eq!(half_ang, f32::consts::FRAC_PI_2); /// assert_eq!(axis, Some(Vector3::x_axis())); /// ``` + #[must_use = "This function does not mutate self. You should use the return value."] pub fn polar_decomposition(&self) -> (T, T, Option>>) where T: RealField, @@ -519,6 +534,7 @@ where /// assert_relative_eq!(q.ln(), Quaternion::new(1.683647, 1.190289, 0.0, 0.0), epsilon = 1.0e-6) /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn ln(&self) -> Self { let n = self.norm(); let v = self.vector(); @@ -537,6 +553,7 @@ where /// assert_relative_eq!(q.exp(), Quaternion::new(2.0, 5.0, 0.0, 0.0), epsilon = 1.0e-5) /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn exp(&self) -> Self { self.exp_eps(T::simd_default_epsilon()) } @@ -556,6 +573,7 @@ where /// assert_eq!(q.exp_eps(1.0e-6), Quaternion::identity()); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn exp_eps(&self, eps: T) -> Self { let v = self.vector(); let nn = v.norm_squared(); @@ -579,6 +597,7 @@ where /// assert_relative_eq!(q.powf(1.5), Quaternion::new( -6.2576659, 4.1549037, 6.2323556, 8.3098075), epsilon = 1.0e-6); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn powf(&self, n: T) -> Self { (self.ln() * n).exp() } @@ -674,18 +693,21 @@ where /// Calculates square of a quaternion. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn squared(&self) -> Self { self * self } /// Divides quaternion into two. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn half(&self) -> Self { self / crate::convert(2.0f64) } /// Calculates square root. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn sqrt(&self) -> Self { self.powf(crate::convert(0.5)) } @@ -694,12 +716,14 @@ where /// /// A quaternion is pure if it has no real part (`self.w == 0.0`). #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn is_pure(&self) -> bool { self.w.is_zero() } /// Convert quaternion to pure quaternion. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn pure(&self) -> Self { Self::from_imag(self.imag()) } @@ -708,6 +732,7 @@ where /// /// Calculates B-1 * A where A = self, B = other. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn left_div(&self, other: &Self) -> Option where T: RealField, @@ -730,6 +755,7 @@ where /// assert_relative_eq!(expected, result, epsilon = 1.0e-7); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn right_div(&self, other: &Self) -> Option where T: RealField, @@ -749,6 +775,7 @@ where /// assert_relative_eq!(expected, result, epsilon = 1.0e-7); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn cos(&self) -> Self { let z = self.imag().magnitude(); let w = -self.w.simd_sin() * z.simd_sinhc(); @@ -766,6 +793,7 @@ where /// assert_relative_eq!(input, result, epsilon = 1.0e-7); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn acos(&self) -> Self { let u = Self::from_imag(self.imag().normalize()); let identity = Self::identity(); @@ -787,6 +815,7 @@ where /// assert_relative_eq!(expected, result, epsilon = 1.0e-7); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn sin(&self) -> Self { let z = self.imag().magnitude(); let w = self.w.simd_cos() * z.simd_sinhc(); @@ -804,6 +833,7 @@ where /// assert_relative_eq!(input, result, epsilon = 1.0e-7); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn asin(&self) -> Self { let u = Self::from_imag(self.imag().normalize()); let identity = Self::identity(); @@ -825,6 +855,7 @@ where /// assert_relative_eq!(expected, result, epsilon = 1.0e-7); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn tan(&self) -> Self where T: RealField, @@ -843,6 +874,7 @@ where /// assert_relative_eq!(input, result, epsilon = 1.0e-7); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn atan(&self) -> Self where T: RealField, @@ -867,6 +899,7 @@ where /// assert_relative_eq!(expected, result, epsilon = 1.0e-7); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn sinh(&self) -> Self { (self.exp() - (-self).exp()).half() } @@ -883,6 +916,7 @@ where /// assert_relative_eq!(expected, result, epsilon = 1.0e-7); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn asinh(&self) -> Self { let identity = Self::identity(); (self + (identity + self.squared()).sqrt()).ln() @@ -900,6 +934,7 @@ where /// assert_relative_eq!(expected, result, epsilon = 1.0e-7); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn cosh(&self) -> Self { (self.exp() + (-self).exp()).half() } @@ -916,6 +951,7 @@ where /// assert_relative_eq!(expected, result, epsilon = 1.0e-7); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn acosh(&self) -> Self { let identity = Self::identity(); (self + (self + identity).sqrt() * (self - identity).sqrt()).ln() @@ -933,6 +969,7 @@ where /// assert_relative_eq!(expected, result, epsilon = 1.0e-7); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn tanh(&self) -> Self where T: RealField, @@ -952,6 +989,7 @@ where /// assert_relative_eq!(expected, result, epsilon = 1.0e-7); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn atanh(&self) -> Self { let identity = Self::identity(); ((identity + self).ln() - (identity - self).ln()).half() @@ -1069,6 +1107,7 @@ where /// assert_eq!(rot.angle(), 1.78); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn angle(&self) -> T { let w = self.quaternion().scalar().simd_abs(); self.quaternion().imag().norm().simd_atan2(w) * crate::convert(2.0f64) @@ -1085,6 +1124,7 @@ where /// assert_eq!(*axis.quaternion(), Quaternion::new(1.0, 0.0, 0.0, 0.0)); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn quaternion(&self) -> &Quaternion { self.as_ref() } @@ -1133,6 +1173,7 @@ where /// assert_relative_eq!(rot1.angle_to(&rot2), 1.0045657, epsilon = 1.0e-6); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn angle_to(&self, other: &Self) -> T { let delta = self.rotation_to(other); delta.angle() @@ -1152,6 +1193,7 @@ where /// assert_relative_eq!(rot_to * rot1, rot2, epsilon = 1.0e-6); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn rotation_to(&self, other: &Self) -> Self { other / self } @@ -1168,6 +1210,7 @@ where /// assert_eq!(q1.lerp(&q2, 0.1), Quaternion::new(0.9, 0.1, 0.0, 0.0)); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn lerp(&self, other: &Self, t: T) -> Quaternion { self.as_ref().lerp(other.as_ref(), t) } @@ -1184,6 +1227,7 @@ where /// assert_eq!(q1.nlerp(&q2, 0.1), UnitQuaternion::new_normalize(Quaternion::new(0.9, 0.1, 0.0, 0.0))); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn nlerp(&self, other: &Self, t: T) -> Self { let mut res = self.lerp(other, t); let _ = res.normalize_mut(); @@ -1209,6 +1253,7 @@ where /// assert_eq!(q.euler_angles(), (std::f32::consts::FRAC_PI_2, 0.0, 0.0)); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn slerp(&self, other: &Self, t: T) -> Self where T: RealField, @@ -1228,6 +1273,7 @@ where /// * `epsilon`: the value below which the sinus of the angle separating both quaternion /// must be to return `None`. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn try_slerp(&self, other: &Self, t: T, epsilon: T) -> Option where T: RealField, @@ -1287,6 +1333,7 @@ where /// assert!(rot.axis().is_none()); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn axis(&self) -> Option>> where T: RealField, @@ -1311,6 +1358,7 @@ where /// assert_relative_eq!(rot.scaled_axis(), axisangle, epsilon = 1.0e-6); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn scaled_axis(&self) -> Vector3 where T: RealField, @@ -1339,6 +1387,7 @@ where /// assert!(rot.axis_angle().is_none()); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn axis_angle(&self) -> Option<(Unit>, T)> where T: RealField, @@ -1350,6 +1399,7 @@ where /// /// Note that this function yields a `Quaternion` because it loses the unit property. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn exp(&self) -> Quaternion { self.as_ref().exp() } @@ -1369,6 +1419,7 @@ where /// assert_relative_eq!(q.ln().vector().into_owned(), axisangle, epsilon = 1.0e-6); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn ln(&self) -> Quaternion where T: RealField, @@ -1397,6 +1448,7 @@ where /// assert_eq!(pow.angle(), 2.4); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn powf(&self, n: T) -> Self where T: RealField, @@ -1425,6 +1477,7 @@ where /// assert_relative_eq!(*rot.matrix(), expected, epsilon = 1.0e-6); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn to_rotation_matrix(&self) -> Rotation { let i = self.as_ref()[0]; let j = self.as_ref()[1]; @@ -1482,6 +1535,7 @@ where /// assert_relative_eq!(euler.2, 0.3, epsilon = 1.0e-6); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn euler_angles(&self) -> (T, T, T) where T: RealField, @@ -1506,6 +1560,7 @@ where /// assert_relative_eq!(rot.to_homogeneous(), expected, epsilon = 1.0e-6); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn to_homogeneous(&self) -> Matrix4 { self.to_rotation_matrix().to_homogeneous() } @@ -1526,6 +1581,7 @@ where /// assert_relative_eq!(transformed_point, Point3::new(3.0, 2.0, -1.0), epsilon = 1.0e-6); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn transform_point(&self, pt: &Point3) -> Point3 { self * pt } @@ -1546,6 +1602,7 @@ where /// assert_relative_eq!(transformed_vector, Vector3::new(3.0, 2.0, -1.0), epsilon = 1.0e-6); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn transform_vector(&self, v: &Vector3) -> Vector3 { self * v } @@ -1566,6 +1623,7 @@ where /// assert_relative_eq!(transformed_point, Point3::new(-3.0, 2.0, 1.0), epsilon = 1.0e-6); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn inverse_transform_point(&self, pt: &Point3) -> Point3 { // TODO: would it be useful performancewise not to call inverse explicitly (i-e. implement // the inverse transformation explicitly here) ? @@ -1588,6 +1646,7 @@ where /// assert_relative_eq!(transformed_vector, Vector3::new(-3.0, 2.0, 1.0), epsilon = 1.0e-6); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn inverse_transform_vector(&self, v: &Vector3) -> Vector3 { self.inverse() * v } @@ -1608,6 +1667,7 @@ where /// assert_relative_eq!(transformed_vector, -Vector3::y_axis(), epsilon = 1.0e-6); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn inverse_transform_unit_vector(&self, v: &Unit>) -> Unit> { self.inverse() * v } @@ -1616,6 +1676,7 @@ where /// /// This is faster, but approximate, way to compute `UnitQuaternion::new(axisangle) * self`. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn append_axisangle_linearized(&self, axisangle: &Vector3) -> Self { let half: T = crate::convert(0.5); let q1 = self.into_inner(); diff --git a/src/geometry/reflection.rs b/src/geometry/reflection.rs index e48c700a..7a34d972 100644 --- a/src/geometry/reflection.rs +++ b/src/geometry/reflection.rs @@ -34,6 +34,7 @@ impl> Reflection { } /// The reflexion axis. + #[must_use = "This function does not mutate self. You should use the return value."] pub fn axis(&self) -> &Vector { &self.axis } diff --git a/src/geometry/rotation.rs b/src/geometry/rotation.rs index 7b4d609a..9950568d 100755 --- a/src/geometry/rotation.rs +++ b/src/geometry/rotation.rs @@ -185,6 +185,7 @@ impl Rotation { /// assert_eq!(*rot.matrix(), expected); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn matrix(&self) -> &SMatrix { &self.matrix } @@ -262,6 +263,7 @@ impl Rotation { /// assert_eq!(rot.to_homogeneous(), expected); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn to_homogeneous(&self) -> OMatrix, U1>, DimNameSum, U1>> where T: Zero + One, @@ -403,6 +405,7 @@ where /// assert_relative_eq!(transformed_point, Point3::new(3.0, 2.0, -1.0), epsilon = 1.0e-6); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn transform_point(&self, pt: &Point) -> Point { self * pt } @@ -422,6 +425,7 @@ where /// assert_relative_eq!(transformed_vector, Vector3::new(3.0, 2.0, -1.0), epsilon = 1.0e-6); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn transform_vector(&self, v: &SVector) -> SVector { self * v } @@ -441,6 +445,7 @@ where /// assert_relative_eq!(transformed_point, Point3::new(-3.0, 2.0, 1.0), epsilon = 1.0e-6); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn inverse_transform_point(&self, pt: &Point) -> Point { Point::from(self.inverse_transform_vector(&pt.coords)) } @@ -460,6 +465,7 @@ where /// assert_relative_eq!(transformed_vector, Vector3::new(-3.0, 2.0, 1.0), epsilon = 1.0e-6); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn inverse_transform_vector(&self, v: &SVector) -> SVector { self.matrix().tr_mul(v) } @@ -479,6 +485,7 @@ where /// assert_relative_eq!(transformed_vector, -Vector3::y_axis(), epsilon = 1.0e-6); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn inverse_transform_unit_vector(&self, v: &Unit>) -> Unit> { Unit::new_unchecked(self.inverse_transform_vector(&**v)) } diff --git a/src/geometry/rotation_interpolation.rs b/src/geometry/rotation_interpolation.rs index bf1c9094..6c724b21 100644 --- a/src/geometry/rotation_interpolation.rs +++ b/src/geometry/rotation_interpolation.rs @@ -18,6 +18,7 @@ impl Rotation2 { /// assert_relative_eq!(rot.angle(), std::f32::consts::FRAC_PI_2); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn slerp(&self, other: &Self, t: T) -> Self where T::Element: SimdRealField, @@ -47,6 +48,7 @@ impl Rotation3 { /// assert_eq!(q.euler_angles(), (std::f32::consts::FRAC_PI_2, 0.0, 0.0)); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn slerp(&self, other: &Self, t: T) -> Self where T: RealField, @@ -67,6 +69,7 @@ impl Rotation3 { /// * `epsilon`: the value below which the sinus of the angle separating both rotations /// must be to return `None`. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn try_slerp(&self, other: &Self, t: T, epsilon: T) -> Option where T: RealField, diff --git a/src/geometry/rotation_specialization.rs b/src/geometry/rotation_specialization.rs index bb71f4f8..4000e239 100644 --- a/src/geometry/rotation_specialization.rs +++ b/src/geometry/rotation_specialization.rs @@ -186,6 +186,7 @@ impl Rotation2 { /// assert_relative_eq!(rot_to.inverse() * rot2, rot1); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn rotation_to(&self, other: &Self) -> Self { other * self.inverse() } @@ -215,6 +216,7 @@ impl Rotation2 { /// assert_relative_eq!(pow.angle(), 2.0 * 0.78); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn powf(&self, n: T) -> Self { Self::new(self.angle() * n) } @@ -232,6 +234,7 @@ impl Rotation2 { /// assert_relative_eq!(rot.angle(), 1.78); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn angle(&self) -> T { self.matrix()[(1, 0)].simd_atan2(self.matrix()[(0, 0)]) } @@ -247,6 +250,7 @@ impl Rotation2 { /// assert_relative_eq!(rot1.angle_to(&rot2), 1.6); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn angle_to(&self, other: &Self) -> T { self.rotation_to(other).angle() } @@ -256,6 +260,7 @@ impl Rotation2 { /// This is generally used in the context of generic programming. Using /// the `.angle()` method instead is more common. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn scaled_axis(&self) -> SVector { Vector1::new(self.angle()) } @@ -640,6 +645,7 @@ where /// assert_relative_eq!(rot_to * rot1, rot2, epsilon = 1.0e-6); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn rotation_to(&self, other: &Self) -> Self { other * self.inverse() } @@ -659,6 +665,7 @@ where /// assert_eq!(pow.angle(), 2.4); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn powf(&self, n: T) -> Self where T: RealField, @@ -765,6 +772,7 @@ impl Rotation3 { /// assert_relative_eq!(rot.angle(), 1.78); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn angle(&self) -> T { ((self.matrix()[(0, 0)] + self.matrix()[(1, 1)] + self.matrix()[(2, 2)] - T::one()) / crate::convert(2.0)) @@ -787,6 +795,7 @@ impl Rotation3 { /// assert!(rot.axis().is_none()); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn axis(&self) -> Option>> where T: RealField, @@ -811,6 +820,7 @@ impl Rotation3 { /// assert_relative_eq!(rot.scaled_axis(), axisangle, epsilon = 1.0e-6); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn scaled_axis(&self) -> Vector3 where T: RealField, @@ -842,6 +852,7 @@ impl Rotation3 { /// assert!(rot.axis_angle().is_none()); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn axis_angle(&self) -> Option<(Unit>, T)> where T: RealField, @@ -864,6 +875,7 @@ impl Rotation3 { /// assert_relative_eq!(rot1.angle_to(&rot2), 1.0045657, epsilon = 1.0e-6); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn angle_to(&self, other: &Self) -> T where T::Element: SimdRealField, @@ -896,6 +908,7 @@ impl Rotation3 { /// assert_relative_eq!(euler.1, 0.2, epsilon = 1.0e-6); /// assert_relative_eq!(euler.2, 0.3, epsilon = 1.0e-6); /// ``` + #[must_use = "This function does not mutate self. You should use the return value."] pub fn euler_angles(&self) -> (T, T, T) where T: RealField, diff --git a/src/geometry/similarity.rs b/src/geometry/similarity.rs index b6e2c379..6a1fe095 100755 --- a/src/geometry/similarity.rs +++ b/src/geometry/similarity.rs @@ -122,6 +122,7 @@ where impl Similarity { /// The scaling factor of this similarity transformation. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn scaling(&self) -> T { self.scaling.inlined_clone() } @@ -248,6 +249,7 @@ where /// assert_relative_eq!(transformed_point, Point3::new(19.0, 17.0, -9.0), epsilon = 1.0e-5); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn transform_point(&self, pt: &Point) -> Point { self * pt } @@ -269,6 +271,7 @@ where /// assert_relative_eq!(transformed_vector, Vector3::new(18.0, 15.0, -12.0), epsilon = 1.0e-5); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn transform_vector(&self, v: &SVector) -> SVector { self * v } @@ -289,6 +292,7 @@ where /// assert_relative_eq!(transformed_point, Point3::new(-1.5, 1.5, 1.5), epsilon = 1.0e-5); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn inverse_transform_point(&self, pt: &Point) -> Point { self.isometry.inverse_transform_point(pt) / self.scaling() } @@ -309,6 +313,7 @@ where /// assert_relative_eq!(transformed_vector, Vector3::new(-3.0, 2.5, 2.0), epsilon = 1.0e-5); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn inverse_transform_vector(&self, v: &SVector) -> SVector { self.isometry.inverse_transform_vector(v) / self.scaling() } @@ -321,6 +326,7 @@ where impl Similarity { /// Converts this similarity into its equivalent homogeneous transformation matrix. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn to_homogeneous(&self) -> OMatrix, U1>, DimNameSum, U1>> where Const: DimNameAdd, diff --git a/src/geometry/swizzle.rs b/src/geometry/swizzle.rs index 6e4c6df8..74f423ff 100644 --- a/src/geometry/swizzle.rs +++ b/src/geometry/swizzle.rs @@ -8,6 +8,7 @@ macro_rules! impl_swizzle { $( /// Builds a new point from components of `self`. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn $name(&self) -> $Result where as ToTypenum>::Typenum: Cmp { $Result::new($(self[$i].inlined_clone()),*) diff --git a/src/geometry/transform.rs b/src/geometry/transform.rs index c7fce902..a62c5ede 100755 --- a/src/geometry/transform.rs +++ b/src/geometry/transform.rs @@ -301,6 +301,7 @@ where /// assert_eq!(*t.matrix(), m); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn matrix(&self) -> &OMatrix, U1>, DimNameSum, U1>> { &self.matrix } @@ -367,6 +368,7 @@ where /// assert_eq!(t.into_inner(), m); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn to_homogeneous(&self) -> OMatrix, U1>, DimNameSum, U1>> { self.matrix().clone_owned() } @@ -498,6 +500,7 @@ where /// /// This is the same as the multiplication `self * pt`. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn transform_point(&self, pt: &Point) -> Point { self * pt } @@ -507,6 +510,7 @@ where /// /// This is the same as the multiplication `self * v`. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn transform_vector(&self, v: &SVector) -> SVector { self * v } @@ -524,6 +528,7 @@ where /// This may be cheaper than inverting the transformation and transforming /// the point. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn inverse_transform_point(&self, pt: &Point) -> Point { self.clone().inverse() * pt } @@ -532,6 +537,7 @@ where /// This may be cheaper than inverting the transformation and transforming /// the vector. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn inverse_transform_vector(&self, v: &SVector) -> SVector { self.clone().inverse() * v } diff --git a/src/geometry/translation.rs b/src/geometry/translation.rs index dcb7b603..98ee4636 100755 --- a/src/geometry/translation.rs +++ b/src/geometry/translation.rs @@ -190,6 +190,7 @@ impl Translation { /// assert_eq!(t.to_homogeneous(), expected); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn to_homogeneous(&self) -> OMatrix, U1>, DimNameSum, U1>> where T: Zero + One, @@ -241,6 +242,7 @@ impl Translation { /// let transformed_point = t.transform_point(&Point3::new(4.0, 5.0, 6.0)); /// assert_eq!(transformed_point, Point3::new(5.0, 7.0, 9.0)); #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn transform_point(&self, pt: &Point) -> Point { pt + &self.vector } @@ -256,6 +258,7 @@ impl Translation { /// let transformed_point = t.inverse_transform_point(&Point3::new(4.0, 5.0, 6.0)); /// assert_eq!(transformed_point, Point3::new(3.0, 3.0, 3.0)); #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn inverse_transform_point(&self, pt: &Point) -> Point { pt - &self.vector } diff --git a/src/geometry/unit_complex.rs b/src/geometry/unit_complex.rs index fe2e87ba..414ca425 100755 --- a/src/geometry/unit_complex.rs +++ b/src/geometry/unit_complex.rs @@ -84,6 +84,7 @@ where /// assert_eq!(rot.angle(), 1.78); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn angle(&self) -> T { self.im.simd_atan2(self.re) } @@ -98,6 +99,7 @@ where /// assert_eq!(rot.sin_angle(), angle.sin()); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn sin_angle(&self) -> T { self.im } @@ -112,6 +114,7 @@ where /// assert_eq!(rot.cos_angle(),angle.cos()); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn cos_angle(&self) -> T { self.re } @@ -121,6 +124,7 @@ where /// This is generally used in the context of generic programming. Using /// the `.angle()` method instead is more common. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn scaled_axis(&self) -> Vector1 { Vector1::new(self.angle()) } @@ -131,6 +135,7 @@ where /// the `.angle()` method instead is more common. /// Returns `None` if the angle is zero. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn axis_angle(&self) -> Option<(Unit>, T)> where T: RealField, @@ -157,6 +162,7 @@ where /// assert_relative_eq!(rot1.angle_to(&rot2), 1.6); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn angle_to(&self, other: &Self) -> T { let delta = self.rotation_to(other); delta.angle() @@ -254,6 +260,7 @@ where /// assert_eq!(rot.to_rotation_matrix(), expected); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn to_rotation_matrix(&self) -> Rotation2 { let r = self.re; let i = self.im; @@ -274,6 +281,7 @@ where /// assert_eq!(rot.to_homogeneous(), expected); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn to_homogeneous(&self) -> Matrix3 { self.to_rotation_matrix().to_homogeneous() } @@ -298,6 +306,7 @@ where /// assert_relative_eq!(transformed_point, Point2::new(-2.0, 1.0), epsilon = 1.0e-6); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn transform_point(&self, pt: &Point2) -> Point2 { self * pt } @@ -316,6 +325,7 @@ where /// assert_relative_eq!(transformed_vector, Vector2::new(-2.0, 1.0), epsilon = 1.0e-6); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn transform_vector(&self, v: &Vector2) -> Vector2 { self * v } @@ -332,6 +342,7 @@ where /// assert_relative_eq!(transformed_point, Point2::new(2.0, -1.0), epsilon = 1.0e-6); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn inverse_transform_point(&self, pt: &Point2) -> Point2 { // TODO: would it be useful performancewise not to call inverse explicitly (i-e. implement // the inverse transformation explicitly here) ? @@ -350,6 +361,7 @@ where /// assert_relative_eq!(transformed_vector, Vector2::new(2.0, -1.0), epsilon = 1.0e-6); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn inverse_transform_vector(&self, v: &Vector2) -> Vector2 { self.inverse() * v } @@ -366,6 +378,7 @@ where /// assert_relative_eq!(transformed_vector, -Vector2::y_axis(), epsilon = 1.0e-6); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn inverse_transform_unit_vector(&self, v: &Unit>) -> Unit> { self.inverse() * v } @@ -392,6 +405,7 @@ where /// assert_relative_eq!(rot.angle(), std::f32::consts::FRAC_PI_2); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn slerp(&self, other: &Self, t: T) -> Self { Self::new(self.angle() * (T::one() - t) + other.angle() * t) } diff --git a/src/geometry/unit_complex_construction.rs b/src/geometry/unit_complex_construction.rs index 62a9b416..6a3ad6de 100644 --- a/src/geometry/unit_complex_construction.rs +++ b/src/geometry/unit_complex_construction.rs @@ -148,6 +148,7 @@ where /// assert_eq!(*rot.complex(), Complex::new(angle.cos(), angle.sin())); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn complex(&self) -> &Complex { self.as_ref() } @@ -244,6 +245,7 @@ where /// assert_relative_eq!(rot_to.inverse() * rot2, rot1); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn rotation_to(&self, other: &Self) -> Self { other / self } @@ -262,6 +264,7 @@ where /// assert_relative_eq!(pow.angle(), 2.0 * 0.78); /// ``` #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn powf(&self, n: T) -> Self { Self::from_angle(self.angle() * n) } diff --git a/src/linalg/bidiagonal.rs b/src/linalg/bidiagonal.rs index a125ce18..d8997196 100644 --- a/src/linalg/bidiagonal.rs +++ b/src/linalg/bidiagonal.rs @@ -153,6 +153,7 @@ where /// Indicates whether this decomposition contains an upper-diagonal matrix. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn is_upper_diagonal(&self) -> bool { self.upper_diagonal } @@ -188,6 +189,7 @@ where /// Retrieves the upper trapezoidal submatrix `R` of this decomposition. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn d(&self) -> OMatrix, DimMinimum> where DefaultAllocator: Allocator, DimMinimum>, @@ -207,6 +209,7 @@ where /// Computes the orthogonal matrix `U` of this `U * D * V` decomposition. // TODO: code duplication with householder::assemble_q. // Except that we are returning a rectangular matrix here. + #[must_use = "This function does not mutate self. You should use the return value."] pub fn u(&self) -> OMatrix> where DefaultAllocator: Allocator>, @@ -237,6 +240,7 @@ where } /// Computes the orthogonal matrix `V_t` of this `U * D * V_t` decomposition. + #[must_use = "This function does not mutate self. You should use the return value."] pub fn v_t(&self) -> OMatrix, C> where DefaultAllocator: Allocator, C>, @@ -274,6 +278,7 @@ where } /// The diagonal part of this decomposed matrix. + #[must_use = "This function does not mutate self. You should use the return value."] pub fn diagonal(&self) -> OVector> where DefaultAllocator: Allocator>, @@ -282,6 +287,7 @@ where } /// The off-diagonal part of this decomposed matrix. + #[must_use = "This function does not mutate self. You should use the return value."] pub fn off_diagonal(&self) -> OVector, U1>> where DefaultAllocator: Allocator, U1>>, diff --git a/src/linalg/cholesky.rs b/src/linalg/cholesky.rs index fa090852..60f1f0f5 100644 --- a/src/linalg/cholesky.rs +++ b/src/linalg/cholesky.rs @@ -92,6 +92,7 @@ where /// Retrieves the lower-triangular factor of the Cholesky decomposition with its strictly /// uppen-triangular part filled with zeros. + #[must_use = "This function does not mutate self. You should use the return value."] pub fn l(&self) -> OMatrix { self.chol.lower_triangle() } @@ -101,6 +102,7 @@ where /// /// This is an allocation-less version of `self.l()`. The values of the strict upper-triangular /// part are garbage and should be ignored by further computations. + #[must_use = "This function does not mutate self. You should use the return value."] pub fn l_dirty(&self) -> &OMatrix { &self.chol } @@ -142,6 +144,7 @@ where } /// Computes the determinant of the decomposed matrix. + #[must_use = "This function does not mutate self. You should use the return value."] pub fn determinant(&self) -> T::SimdRealField { let dim = self.chol.nrows(); let mut prod_diag = T::one(); @@ -289,6 +292,7 @@ where /// Updates the decomposition such that we get the decomposition of the factored matrix with its `j`th column removed. /// Since the matrix is square, the `j`th row will also be removed. + #[must_use = "This function does not mutate self. You should use the return value."] pub fn remove_column(&self, j: usize) -> Cholesky> where D: DimSub, diff --git a/src/linalg/col_piv_qr.rs b/src/linalg/col_piv_qr.rs index 3640785d..e48263fd 100644 --- a/src/linalg/col_piv_qr.rs +++ b/src/linalg/col_piv_qr.rs @@ -95,6 +95,7 @@ where /// Retrieves the upper trapezoidal submatrix `R` of this decomposition. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn r(&self) -> OMatrix, C> where DefaultAllocator: Allocator, C>, @@ -126,6 +127,7 @@ where } /// Computes the orthogonal matrix `Q` of this decomposition. + #[must_use = "This function does not mutate self. You should use the return value."] pub fn q(&self) -> OMatrix> where DefaultAllocator: Allocator>, @@ -150,6 +152,7 @@ where } /// Retrieves the column permutation of this decomposition. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn p(&self) -> &PermutationSequence> { &self.p } @@ -284,6 +287,7 @@ where /// Computes the inverse of the decomposed matrix. /// /// Returns `None` if the decomposed matrix is not invertible. + #[must_use = "This function does not mutate self. You should use the return value."] pub fn try_inverse(&self) -> Option> { assert!( self.col_piv_qr.is_square(), @@ -302,6 +306,7 @@ where } /// Indicates if the decomposed matrix is invertible. + #[must_use = "This function does not mutate self. You should use the return value."] pub fn is_invertible(&self) -> bool { assert!( self.col_piv_qr.is_square(), @@ -318,6 +323,7 @@ where } /// Computes the determinant of the decomposed matrix. + #[must_use = "This function does not mutate self. You should use the return value."] pub fn determinant(&self) -> T { let dim = self.col_piv_qr.nrows(); assert!( diff --git a/src/linalg/convolution.rs b/src/linalg/convolution.rs index 2729b66b..075b3508 100644 --- a/src/linalg/convolution.rs +++ b/src/linalg/convolution.rs @@ -112,6 +112,7 @@ impl> Vector { /// /// # Errors /// Inputs must satisfy `self.len() >= kernel.len() > 0`. + #[must_use = "This function does not mutate self. You should use the return value."] pub fn convolve_same(&self, kernel: Vector) -> OVector where D2: Dim, diff --git a/src/linalg/determinant.rs b/src/linalg/determinant.rs index aa04ff3f..43478261 100644 --- a/src/linalg/determinant.rs +++ b/src/linalg/determinant.rs @@ -12,6 +12,7 @@ impl, S: Storage> SquareMatri /// /// If the matrix has a dimension larger than 3, an LU decomposition is used. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn determinant(&self) -> T where DefaultAllocator: Allocator + Allocator<(usize, usize), D>, diff --git a/src/linalg/full_piv_lu.rs b/src/linalg/full_piv_lu.rs index af9609de..9ce6c24d 100644 --- a/src/linalg/full_piv_lu.rs +++ b/src/linalg/full_piv_lu.rs @@ -96,6 +96,7 @@ where /// The lower triangular matrix of this decomposition. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn l(&self) -> OMatrix> where DefaultAllocator: Allocator>, @@ -109,6 +110,7 @@ where /// The upper triangular matrix of this decomposition. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn u(&self) -> OMatrix, C> where DefaultAllocator: Allocator, C>, @@ -119,12 +121,14 @@ where /// The row permutations of this decomposition. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn p(&self) -> &PermutationSequence> { &self.p } /// The column permutations of this decomposition. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn q(&self) -> &PermutationSequence> { &self.q } @@ -211,6 +215,7 @@ where /// Computes the inverse of the decomposed matrix. /// /// Returns `None` if the decomposed matrix is not invertible. + #[must_use = "This function does not mutate self. You should use the return value."] pub fn try_inverse(&self) -> Option> { assert!( self.lu.is_square(), @@ -228,6 +233,7 @@ where } /// Indicates if the decomposed matrix is invertible. + #[must_use = "This function does not mutate self. You should use the return value."] pub fn is_invertible(&self) -> bool { assert!( self.lu.is_square(), @@ -239,6 +245,7 @@ where } /// Computes the determinant of the decomposed matrix. + #[must_use = "This function does not mutate self. You should use the return value."] pub fn determinant(&self) -> T { assert!( self.lu.is_square(), diff --git a/src/linalg/givens.rs b/src/linalg/givens.rs index 9a65f331..e555cbfb 100644 --- a/src/linalg/givens.rs +++ b/src/linalg/givens.rs @@ -89,11 +89,13 @@ impl GivensRotation { } /// The cos part of this roration. + #[must_use = "This function does not mutate self. You should use the return value."] pub fn c(&self) -> T::RealField { self.c } /// The sin part of this roration. + #[must_use = "This function does not mutate self. You should use the return value."] pub fn s(&self) -> T { self.s } diff --git a/src/linalg/hessenberg.rs b/src/linalg/hessenberg.rs index be6f667c..e6201685 100644 --- a/src/linalg/hessenberg.rs +++ b/src/linalg/hessenberg.rs @@ -116,6 +116,7 @@ where /// /// This is less efficient than `.unpack_h()` as it allocates a new matrix. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn h(&self) -> OMatrix { let dim = self.hess.nrows(); let mut res = self.hess.clone(); @@ -126,6 +127,7 @@ where } /// Computes the orthogonal matrix `Q` of this decomposition. + #[must_use = "This function does not mutate self. You should use the return value."] pub fn q(&self) -> OMatrix { householder::assemble_q(&self.hess, self.subdiag.as_slice()) } diff --git a/src/linalg/lu.rs b/src/linalg/lu.rs index 855a53f7..0c5dfe15 100644 --- a/src/linalg/lu.rs +++ b/src/linalg/lu.rs @@ -127,6 +127,7 @@ where /// The lower triangular matrix of this decomposition. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn l(&self) -> OMatrix> where DefaultAllocator: Allocator>, @@ -170,6 +171,7 @@ where /// The upper triangular matrix of this decomposition. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn u(&self) -> OMatrix, C> where DefaultAllocator: Allocator, C>, @@ -180,6 +182,7 @@ where /// The row permutations of this decomposition. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn p(&self) -> &PermutationSequence> { &self.p } @@ -258,6 +261,7 @@ where /// Computes the inverse of the decomposed matrix. /// /// Returns `None` if the matrix is not invertible. + #[must_use = "This function does not mutate self. You should use the return value."] pub fn try_inverse(&self) -> Option> { assert!( self.lu.is_square(), @@ -292,6 +296,7 @@ where } /// Computes the determinant of the decomposed matrix. + #[must_use = "This function does not mutate self. You should use the return value."] pub fn determinant(&self) -> T { let dim = self.lu.nrows(); assert!( @@ -308,6 +313,7 @@ where } /// Indicates if the decomposed matrix is invertible. + #[must_use = "This function does not mutate self. You should use the return value."] pub fn is_invertible(&self) -> bool { assert!( self.lu.is_square(), diff --git a/src/linalg/permutation_sequence.rs b/src/linalg/permutation_sequence.rs index 4cc8cb25..a852f0c9 100644 --- a/src/linalg/permutation_sequence.rs +++ b/src/linalg/permutation_sequence.rs @@ -140,17 +140,20 @@ where } /// The number of non-identity permutations applied by this sequence. + #[must_use = "This function does not mutate self. You should use the return value."] pub fn len(&self) -> usize { self.len } /// Returns true if the permutation sequence contains no elements. + #[must_use = "This function does not mutate self. You should use the return value."] pub fn is_empty(&self) -> bool { self.len() == 0 } /// The determinant of the matrix corresponding to this permutation. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn determinant(&self) -> T { if self.len % 2 == 0 { T::one() diff --git a/src/linalg/qr.rs b/src/linalg/qr.rs index a0fd898e..2fa308ff 100644 --- a/src/linalg/qr.rs +++ b/src/linalg/qr.rs @@ -70,6 +70,7 @@ where /// Retrieves the upper trapezoidal submatrix `R` of this decomposition. #[inline] + #[must_use = "This function does not mutate self. You should use the return value."] pub fn r(&self) -> OMatrix, C> where DefaultAllocator: Allocator, C>, @@ -96,6 +97,7 @@ where } /// Computes the orthogonal matrix `Q` of this decomposition. + #[must_use = "This function does not mutate self. You should use the return value."] pub fn q(&self) -> OMatrix> where DefaultAllocator: Allocator>, @@ -244,6 +246,7 @@ where /// Computes the inverse of the decomposed matrix. /// /// Returns `None` if the decomposed matrix is not invertible. + #[must_use = "This function does not mutate self. You should use the return value."] pub fn try_inverse(&self) -> Option> { assert!( self.qr.is_square(), @@ -262,6 +265,7 @@ where } /// Indicates if the decomposed matrix is invertible. + #[must_use = "This function does not mutate self. You should use the return value."] pub fn is_invertible(&self) -> bool { assert!( self.qr.is_square(), diff --git a/src/linalg/schur.rs b/src/linalg/schur.rs index 1903b717..4f9271f7 100644 --- a/src/linalg/schur.rs +++ b/src/linalg/schur.rs @@ -385,6 +385,7 @@ where /// Computes the real eigenvalues of the decomposed matrix. /// /// Return `None` if some eigenvalues are complex. + #[must_use = "This function does not mutate self. You should use the return value."] pub fn eigenvalues(&self) -> Option> { let mut out = unsafe { crate::unimplemented_or_uninitialized_generic!(self.t.data.shape().0, Const::<1>) @@ -397,6 +398,7 @@ where } /// Computes the complex eigenvalues of the decomposed matrix. + #[must_use = "This function does not mutate self. You should use the return value."] pub fn complex_eigenvalues(&self) -> OVector, D> where T: RealField, @@ -509,6 +511,7 @@ where + Allocator, { /// Computes the eigenvalues of this matrix. + #[must_use = "This function does not mutate self. You should use the return value."] pub fn eigenvalues(&self) -> Option> { assert!( self.is_square(), @@ -551,6 +554,7 @@ where } /// Computes the eigenvalues of this matrix. + #[must_use = "This function does not mutate self. You should use the return value."] pub fn complex_eigenvalues(&self) -> OVector, D> // TODO: add balancing? where diff --git a/src/linalg/svd.rs b/src/linalg/svd.rs index 2f5e6a63..b579eb54 100644 --- a/src/linalg/svd.rs +++ b/src/linalg/svd.rs @@ -502,6 +502,7 @@ where /// Computes the rank of the decomposed matrix, i.e., the number of singular values greater /// than `eps`. + #[must_use = "This function does not mutate self. You should use the return value."] pub fn rank(&self, eps: T::RealField) -> usize { assert!( eps >= T::RealField::zero(), @@ -615,6 +616,7 @@ where + Allocator, U1>>, { /// Computes the singular values of this matrix. + #[must_use = "This function does not mutate self. You should use the return value."] pub fn singular_values(&self) -> OVector> { SVD::new(self.clone_owned(), false, false).singular_values } @@ -622,6 +624,7 @@ where /// Computes the rank of this matrix. /// /// All singular values below `eps` are considered equal to 0. + #[must_use = "This function does not mutate self. You should use the return value."] pub fn rank(&self, eps: T::RealField) -> usize { let svd = SVD::new(self.clone_owned(), false, false); svd.rank(eps) diff --git a/src/linalg/symmetric_eigen.rs b/src/linalg/symmetric_eigen.rs index 6e3b67fe..d0409e95 100644 --- a/src/linalg/symmetric_eigen.rs +++ b/src/linalg/symmetric_eigen.rs @@ -268,6 +268,7 @@ where /// Rebuild the original matrix. /// /// This is useful if some of the eigenvalues have been manually modified. + #[must_use = "This function does not mutate self. You should use the return value."] pub fn recompose(&self) -> OMatrix { let mut u_t = self.eigenvectors.clone(); for i in 0..self.eigenvalues.len() { @@ -311,6 +312,7 @@ where /// Computes the eigenvalues of this symmetric matrix. /// /// Only the lower-triangular part of the matrix is read. + #[must_use = "This function does not mutate self. You should use the return value."] pub fn symmetric_eigenvalues(&self) -> OVector { SymmetricEigen::do_decompose( self.clone_owned(), diff --git a/src/linalg/symmetric_tridiagonal.rs b/src/linalg/symmetric_tridiagonal.rs index 9937f76b..82a2433b 100644 --- a/src/linalg/symmetric_tridiagonal.rs +++ b/src/linalg/symmetric_tridiagonal.rs @@ -131,6 +131,7 @@ where } /// The diagonal components of this decomposition. + #[must_use = "This function does not mutate self. You should use the return value."] pub fn diagonal(&self) -> OVector where DefaultAllocator: Allocator, @@ -139,6 +140,7 @@ where } /// The off-diagonal components of this decomposition. + #[must_use = "This function does not mutate self. You should use the return value."] pub fn off_diagonal(&self) -> OVector> where DefaultAllocator: Allocator>, @@ -147,6 +149,7 @@ where } /// Computes the orthogonal matrix `Q` of this decomposition. + #[must_use = "This function does not mutate self. You should use the return value."] pub fn q(&self) -> OMatrix { householder::assemble_q(&self.tri, self.off_diagonal.as_slice()) } diff --git a/src/linalg/udu.rs b/src/linalg/udu.rs index 4d3aca6c..786e14bc 100644 --- a/src/linalg/udu.rs +++ b/src/linalg/udu.rs @@ -92,6 +92,7 @@ where } /// Returns the diagonal elements as a matrix + #[must_use = "This function does not mutate self. You should use the return value."] pub fn d_matrix(&self) -> OMatrix { OMatrix::from_diagonal(&self.d) } diff --git a/src/sparse/cs_matrix.rs b/src/sparse/cs_matrix.rs index 2dc8467e..f46dfdc2 100644 --- a/src/sparse/cs_matrix.rs +++ b/src/sparse/cs_matrix.rs @@ -119,16 +119,19 @@ where DefaultAllocator: Allocator, { /// The value buffer of this storage. + #[must_use = "This function does not mutate self. You should use the return value."] pub fn values(&self) -> &[T] { &self.vals } /// The column shifts buffer. + #[must_use = "This function does not mutate self. You should use the return value."] pub fn p(&self) -> &[usize] { self.p.as_slice() } /// The row index buffers. + #[must_use = "This function does not mutate self. You should use the return value."] pub fn i(&self) -> &[usize] { &self.i } @@ -356,27 +359,32 @@ impl> CsMatrix { } /// The size of the data buffer. + #[must_use = "This function does not mutate self. You should use the return value."] pub fn len(&self) -> usize { self.data.len() } /// The number of rows of this matrix. + #[must_use = "This function does not mutate self. You should use the return value."] pub fn nrows(&self) -> usize { self.data.shape().0.value() } /// The number of rows of this matrix. + #[must_use = "This function does not mutate self. You should use the return value."] pub fn ncols(&self) -> usize { self.data.shape().1.value() } /// The shape of this matrix. + #[must_use = "This function does not mutate self. You should use the return value."] pub fn shape(&self) -> (usize, usize) { let (nrows, ncols) = self.data.shape(); (nrows.value(), ncols.value()) } /// Whether this matrix is square or not. + #[must_use = "This function does not mutate self. You should use the return value."] pub fn is_square(&self) -> bool { let (nrows, ncols) = self.data.shape(); nrows.value() == ncols.value() @@ -391,6 +399,7 @@ impl> CsMatrix { /// If at any time this `is_sorted` method returns `false`, then, something went wrong /// and an issue should be open on the nalgebra repository with details on how to reproduce /// this. + #[must_use = "This function does not mutate self. You should use the return value."] pub fn is_sorted(&self) -> bool { for j in 0..self.ncols() { let mut curr = None; diff --git a/src/sparse/cs_matrix_cholesky.rs b/src/sparse/cs_matrix_cholesky.rs index 4cd61d2a..5891f0ad 100644 --- a/src/sparse/cs_matrix_cholesky.rs +++ b/src/sparse/cs_matrix_cholesky.rs @@ -67,6 +67,7 @@ where } /// The lower-triangular matrix of the cholesky decomposition. + #[must_use = "This function does not mutate self. You should use the return value."] pub fn l(&self) -> Option<&CsMatrix> { if self.ok { Some(&self.l)