From c35f792b4f8d80f7cc1a18f06e1859d2fc6c1537 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?R=C3=A9mi=20Lauzier?= Date: Tue, 27 Jul 2021 19:18:29 -0400 Subject: [PATCH] Fix some warnings --- clippy.toml | 2 + nalgebra-glm/src/lib.rs | 10 +++ nalgebra-lapack/src/hessenberg.rs | 2 +- nalgebra-lapack/src/qr.rs | 4 +- nalgebra-lapack/src/schur.rs | 2 +- nalgebra-macros/src/lib.rs | 17 +++- nalgebra-sparse/src/cs.rs | 16 ++-- nalgebra-sparse/src/csc.rs | 28 +++--- nalgebra-sparse/src/csr.rs | 28 +++--- nalgebra-sparse/src/factorization/cholesky.rs | 2 +- nalgebra-sparse/src/lib.rs | 19 ++-- nalgebra-sparse/src/matrixcompare.rs | 4 +- nalgebra-sparse/src/ops/serial/cs.rs | 4 +- nalgebra-sparse/src/ops/serial/csc.rs | 8 +- nalgebra-sparse/src/ops/serial/csr.rs | 4 +- nalgebra-sparse/src/ops/serial/mod.rs | 2 +- nalgebra-sparse/src/pattern.rs | 4 +- rustfmt.toml | 3 + src/base/allocator.rs | 4 +- src/base/cg.rs | 6 +- src/base/constraint.rs | 1 + src/base/construction.rs | 10 +-- src/base/default_allocator.rs | 1 + src/base/iter.rs | 7 +- src/base/matrix.rs | 6 +- src/base/matrix_slice.rs | 4 +- src/base/norm.rs | 3 + src/base/unit.rs | 2 +- src/base/vec_storage.rs | 2 +- src/geometry/dual_quaternion.rs | 4 +- src/geometry/isometry_construction.rs | 2 +- src/geometry/orthographic.rs | 2 +- src/geometry/perspective.rs | 2 +- src/geometry/quaternion_construction.rs | 4 +- src/geometry/rotation.rs | 2 +- src/geometry/rotation_specialization.rs | 2 +- src/geometry/similarity_construction.rs | 2 +- src/geometry/transform.rs | 2 +- src/lib.rs | 90 +++++++++---------- src/linalg/balancing.rs | 2 +- src/linalg/col_piv_qr.rs | 2 +- src/linalg/schur.rs | 2 +- src/proptest/mod.rs | 6 +- src/sparse/cs_matrix.rs | 4 +- src/third_party/alga/alga_isometry.rs | 6 +- src/third_party/alga/alga_rotation.rs | 12 +-- src/third_party/alga/alga_similarity.rs | 2 +- src/third_party/alga/alga_translation.rs | 12 +-- 48 files changed, 201 insertions(+), 164 deletions(-) create mode 100644 clippy.toml diff --git a/clippy.toml b/clippy.toml new file mode 100644 index 00000000..77a873e1 --- /dev/null +++ b/clippy.toml @@ -0,0 +1,2 @@ +too-many-arguments-threshold = 8 +type-complexity-threshold = 675 diff --git a/nalgebra-glm/src/lib.rs b/nalgebra-glm/src/lib.rs index 391391f4..9ca3856f 100644 --- a/nalgebra-glm/src/lib.rs +++ b/nalgebra-glm/src/lib.rs @@ -110,6 +110,16 @@ and keep in mind it is possible to convert, e.g., an `Isometry3` to a `Mat4` and vice-versa (see the [conversions section](#conversions)). */ +#![deny( + nonstandard_style, + unused, + missing_docs, + rust_2018_idioms, + rust_2018_compatibility, + future_incompatible, + missing_copy_implementations, + missing_debug_implementations +)] #![doc(html_favicon_url = "https://nalgebra.org/img/favicon.ico")] #![cfg_attr(not(feature = "std"), no_std)] diff --git a/nalgebra-lapack/src/hessenberg.rs b/nalgebra-lapack/src/hessenberg.rs index c5765022..0d911cf8 100644 --- a/nalgebra-lapack/src/hessenberg.rs +++ b/nalgebra-lapack/src/hessenberg.rs @@ -84,7 +84,7 @@ where ); lapack_panic!(info); - Self { h: m, tau: tau } + Self { h: m, tau } } /// Computes the hessenberg matrix of this decomposition. diff --git a/nalgebra-lapack/src/qr.rs b/nalgebra-lapack/src/qr.rs index 7b2d5df6..7f00d058 100644 --- a/nalgebra-lapack/src/qr.rs +++ b/nalgebra-lapack/src/qr.rs @@ -62,7 +62,7 @@ where }; if nrows.value() == 0 || ncols.value() == 0 { - return Self { qr: m, tau: tau }; + return Self { qr: m, tau }; } let lwork = T::xgeqrf_work_size( @@ -87,7 +87,7 @@ where &mut info, ); - Self { qr: m, tau: tau } + Self { qr: m, tau } } /// Retrieves the upper trapezoidal submatrix `R` of this decomposition. diff --git a/nalgebra-lapack/src/schur.rs b/nalgebra-lapack/src/schur.rs index 3bee2635..644f8a5c 100644 --- a/nalgebra-lapack/src/schur.rs +++ b/nalgebra-lapack/src/schur.rs @@ -125,7 +125,7 @@ where re: wr, im: wi, t: m, - q: q, + q, }) } diff --git a/nalgebra-macros/src/lib.rs b/nalgebra-macros/src/lib.rs index beddfc74..9a403e0d 100644 --- a/nalgebra-macros/src/lib.rs +++ b/nalgebra-macros/src/lib.rs @@ -3,7 +3,18 @@ //! This crate is not intended for direct consumption. Instead, the macros are re-exported by //! `nalgebra` if the `macros` feature is enabled (enabled by default). -extern crate proc_macro; +#![deny( + nonstandard_style, + unused, + missing_docs, + rust_2018_idioms, + rust_2018_compatibility, + future_incompatible, + missing_copy_implementations, + missing_debug_implementations, + clippy::all, + clippy::pedantic +)] use proc_macro::TokenStream; use quote::{quote, ToTokens, TokenStreamExt}; @@ -60,7 +71,7 @@ impl Matrix { type MatrixRowSyntax = Punctuated; impl Parse for Matrix { - fn parse(input: ParseStream) -> Result { + fn parse(input: ParseStream<'_>) -> Result { let mut rows = Vec::new(); let mut ncols = None; @@ -205,7 +216,7 @@ impl Vector { } impl Parse for Vector { - fn parse(input: ParseStream) -> Result { + fn parse(input: ParseStream<'_>) -> Result { // The syntax of a vector is just the syntax of a single matrix row if input.is_empty() { Ok(Self { diff --git a/nalgebra-sparse/src/cs.rs b/nalgebra-sparse/src/cs.rs index cde0a3e2..e0775b26 100644 --- a/nalgebra-sparse/src/cs.rs +++ b/nalgebra-sparse/src/cs.rs @@ -116,7 +116,7 @@ impl CsMatrix { /// Returns an entry for the given major/minor indices, or `None` if the indices are out /// of bounds. #[must_use] - pub fn get_entry(&self, major_index: usize, minor_index: usize) -> Option> { + pub fn get_entry(&self, major_index: usize, minor_index: usize) -> Option> { let row_range = self.get_index_range(major_index)?; let (_, minor_indices, values) = self.cs_data(); let minor_indices = &minor_indices[row_range.clone()]; @@ -135,7 +135,7 @@ impl CsMatrix { &mut self, major_index: usize, minor_index: usize, - ) -> Option> { + ) -> Option> { let row_range = self.get_index_range(major_index)?; let minor_dim = self.pattern().minor_dim(); let (_, minor_indices, values) = self.cs_data_mut(); @@ -145,7 +145,7 @@ impl CsMatrix { } #[must_use] - pub fn get_lane(&self, index: usize) -> Option> { + pub fn get_lane(&self, index: usize) -> Option> { let range = self.get_index_range(index)?; let (_, minor_indices, values) = self.cs_data(); Some(CsLane { @@ -157,7 +157,7 @@ impl CsMatrix { #[inline] #[must_use] - pub fn get_lane_mut(&mut self, index: usize) -> Option> { + pub fn get_lane_mut(&mut self, index: usize) -> Option> { let range = self.get_index_range(index)?; let minor_dim = self.pattern().minor_dim(); let (_, minor_indices, values) = self.cs_data_mut(); @@ -169,12 +169,12 @@ impl CsMatrix { } #[inline] - pub fn lane_iter(&self) -> CsLaneIter { + pub fn lane_iter(&self) -> CsLaneIter<'_, T> { CsLaneIter::new(self.pattern(), self.values()) } #[inline] - pub fn lane_iter_mut(&mut self) -> CsLaneIterMut { + pub fn lane_iter_mut(&mut self) -> CsLaneIterMut<'_, T> { CsLaneIterMut::new(&self.sparsity_pattern, &mut self.values) } @@ -406,7 +406,7 @@ macro_rules! impl_cs_lane_common_methods { #[inline] #[must_use] - pub fn get_entry(&self, global_col_index: usize) -> Option> { + pub fn get_entry(&self, global_col_index: usize) -> Option> { get_entry_from_slices( self.minor_dim, self.minor_indices, @@ -431,7 +431,7 @@ impl<'a, T> CsLaneMut<'a, T> { } #[must_use] - pub fn get_entry_mut(&mut self, global_minor_index: usize) -> Option> { + pub fn get_entry_mut(&mut self, global_minor_index: usize) -> Option> { get_mut_entry_from_slices( self.minor_dim, self.minor_indices, diff --git a/nalgebra-sparse/src/csc.rs b/nalgebra-sparse/src/csc.rs index 15e0746c..607cc0cf 100644 --- a/nalgebra-sparse/src/csc.rs +++ b/nalgebra-sparse/src/csc.rs @@ -260,7 +260,7 @@ impl CscMatrix { /// let triplets: Vec<_> = csc.triplet_iter().map(|(i, j, v)| (i, j, *v)).collect(); /// assert_eq!(triplets, vec![(0, 0, 1), (2, 0, 3), (1, 1, 2), (0, 2, 4)]); /// ``` - pub fn triplet_iter(&self) -> CscTripletIter { + pub fn triplet_iter(&self) -> CscTripletIter<'_, T> { CscTripletIter { pattern_iter: self.pattern().entries(), values_iter: self.values().iter(), @@ -290,7 +290,7 @@ impl CscMatrix { /// let triplets: Vec<_> = csc.triplet_iter().map(|(i, j, v)| (i, j, *v)).collect(); /// assert_eq!(triplets, vec![(0, 0, 1), (2, 0, 0), (1, 1, 2), (0, 2, 4)]); /// ``` - pub fn triplet_iter_mut(&mut self) -> CscTripletIterMut { + pub fn triplet_iter_mut(&mut self) -> CscTripletIterMut<'_, T> { let (pattern, values) = self.cs.pattern_and_values_mut(); CscTripletIterMut { pattern_iter: pattern.entries(), @@ -305,7 +305,7 @@ impl CscMatrix { /// Panics if column index is out of bounds. #[inline] #[must_use] - pub fn col(&self, index: usize) -> CscCol { + pub fn col(&self, index: usize) -> CscCol<'_, T> { self.get_col(index).expect("Row index must be in bounds") } @@ -315,7 +315,7 @@ impl CscMatrix { /// ------ /// Panics if column index is out of bounds. #[inline] - pub fn col_mut(&mut self, index: usize) -> CscColMut { + pub fn col_mut(&mut self, index: usize) -> CscColMut<'_, T> { self.get_col_mut(index) .expect("Row index must be in bounds") } @@ -323,26 +323,26 @@ impl CscMatrix { /// Return the column at the given column index, or `None` if out of bounds. #[inline] #[must_use] - pub fn get_col(&self, index: usize) -> Option> { + pub fn get_col(&self, index: usize) -> Option> { self.cs.get_lane(index).map(|lane| CscCol { lane }) } /// Mutable column access for the given column index, or `None` if out of bounds. #[inline] #[must_use] - pub fn get_col_mut(&mut self, index: usize) -> Option> { + pub fn get_col_mut(&mut self, index: usize) -> Option> { self.cs.get_lane_mut(index).map(|lane| CscColMut { lane }) } /// An iterator over columns in the matrix. - pub fn col_iter(&self) -> CscColIter { + pub fn col_iter(&self) -> CscColIter<'_, T> { CscColIter { lane_iter: CsLaneIter::new(self.pattern(), self.values()), } } /// A mutable iterator over columns in the matrix. - pub fn col_iter_mut(&mut self) -> CscColIterMut { + pub fn col_iter_mut(&mut self) -> CscColIterMut<'_, T> { let (pattern, values) = self.cs.pattern_and_values_mut(); CscColIterMut { lane_iter: CsLaneIterMut::new(pattern, values), @@ -408,7 +408,7 @@ impl CscMatrix { /// Each call to this function incurs the cost of a binary search among the explicitly /// stored row entries for the given column. #[must_use] - pub fn get_entry(&self, row_index: usize, col_index: usize) -> Option> { + pub fn get_entry(&self, row_index: usize, col_index: usize) -> Option> { self.cs.get_entry(col_index, row_index) } @@ -421,7 +421,7 @@ impl CscMatrix { &mut self, row_index: usize, col_index: usize, - ) -> Option> { + ) -> Option> { self.cs.get_entry_mut(col_index, row_index) } @@ -434,7 +434,7 @@ impl CscMatrix { /// ------ /// Panics if `row_index` or `col_index` is out of bounds. #[must_use] - pub fn index_entry(&self, row_index: usize, col_index: usize) -> SparseEntry { + pub fn index_entry(&self, row_index: usize, col_index: usize) -> SparseEntry<'_, T> { self.get_entry(row_index, col_index) .expect("Out of bounds matrix indices encountered") } @@ -447,7 +447,7 @@ impl CscMatrix { /// Panics /// ------ /// Panics if `row_index` or `col_index` is out of bounds. - pub fn index_entry_mut(&mut self, row_index: usize, col_index: usize) -> SparseEntryMut { + pub fn index_entry_mut(&mut self, row_index: usize, col_index: usize) -> SparseEntryMut<'_, T> { self.get_entry_mut(row_index, col_index) .expect("Out of bounds matrix indices encountered") } @@ -666,7 +666,7 @@ macro_rules! impl_csc_col_common_methods { /// Each call to this function incurs the cost of a binary search among the explicitly /// stored row entries. #[must_use] - pub fn get_entry(&self, global_row_index: usize) -> Option> { + pub fn get_entry(&self, global_row_index: usize) -> Option> { self.lane.get_entry(global_row_index) } } @@ -693,7 +693,7 @@ impl<'a, T> CscColMut<'a, T> { /// Returns a mutable entry for the given global row index. #[must_use] - pub fn get_entry_mut(&mut self, global_row_index: usize) -> Option> { + pub fn get_entry_mut(&mut self, global_row_index: usize) -> Option> { self.lane.get_entry_mut(global_row_index) } } diff --git a/nalgebra-sparse/src/csr.rs b/nalgebra-sparse/src/csr.rs index 4c65908b..c64be915 100644 --- a/nalgebra-sparse/src/csr.rs +++ b/nalgebra-sparse/src/csr.rs @@ -262,7 +262,7 @@ impl CsrMatrix { /// let triplets: Vec<_> = csr.triplet_iter().map(|(i, j, v)| (i, j, *v)).collect(); /// assert_eq!(triplets, vec![(0, 0, 1), (0, 2, 2), (1, 1, 3), (2, 0, 4)]); /// ``` - pub fn triplet_iter(&self) -> CsrTripletIter { + pub fn triplet_iter(&self) -> CsrTripletIter<'_, T> { CsrTripletIter { pattern_iter: self.pattern().entries(), values_iter: self.values().iter(), @@ -292,7 +292,7 @@ impl CsrMatrix { /// let triplets: Vec<_> = csr.triplet_iter().map(|(i, j, v)| (i, j, *v)).collect(); /// assert_eq!(triplets, vec![(0, 0, 1), (0, 2, 2), (1, 1, 3), (2, 0, 0)]); /// ``` - pub fn triplet_iter_mut(&mut self) -> CsrTripletIterMut { + pub fn triplet_iter_mut(&mut self) -> CsrTripletIterMut<'_, T> { let (pattern, values) = self.cs.pattern_and_values_mut(); CsrTripletIterMut { pattern_iter: pattern.entries(), @@ -307,7 +307,7 @@ impl CsrMatrix { /// Panics if row index is out of bounds. #[inline] #[must_use] - pub fn row(&self, index: usize) -> CsrRow { + pub fn row(&self, index: usize) -> CsrRow<'_, T> { self.get_row(index).expect("Row index must be in bounds") } @@ -317,7 +317,7 @@ impl CsrMatrix { /// ------ /// Panics if row index is out of bounds. #[inline] - pub fn row_mut(&mut self, index: usize) -> CsrRowMut { + pub fn row_mut(&mut self, index: usize) -> CsrRowMut<'_, T> { self.get_row_mut(index) .expect("Row index must be in bounds") } @@ -325,26 +325,26 @@ impl CsrMatrix { /// Return the row at the given row index, or `None` if out of bounds. #[inline] #[must_use] - pub fn get_row(&self, index: usize) -> Option> { + pub fn get_row(&self, index: usize) -> Option> { self.cs.get_lane(index).map(|lane| CsrRow { lane }) } /// Mutable row access for the given row index, or `None` if out of bounds. #[inline] #[must_use] - pub fn get_row_mut(&mut self, index: usize) -> Option> { + pub fn get_row_mut(&mut self, index: usize) -> Option> { self.cs.get_lane_mut(index).map(|lane| CsrRowMut { lane }) } /// An iterator over rows in the matrix. - pub fn row_iter(&self) -> CsrRowIter { + pub fn row_iter(&self) -> CsrRowIter<'_, T> { CsrRowIter { lane_iter: CsLaneIter::new(self.pattern(), self.values()), } } /// A mutable iterator over rows in the matrix. - pub fn row_iter_mut(&mut self) -> CsrRowIterMut { + pub fn row_iter_mut(&mut self) -> CsrRowIterMut<'_, T> { let (pattern, values) = self.cs.pattern_and_values_mut(); CsrRowIterMut { lane_iter: CsLaneIterMut::new(pattern, values), @@ -410,7 +410,7 @@ impl CsrMatrix { /// Each call to this function incurs the cost of a binary search among the explicitly /// stored column entries for the given row. #[must_use] - pub fn get_entry(&self, row_index: usize, col_index: usize) -> Option> { + pub fn get_entry(&self, row_index: usize, col_index: usize) -> Option> { self.cs.get_entry(row_index, col_index) } @@ -423,7 +423,7 @@ impl CsrMatrix { &mut self, row_index: usize, col_index: usize, - ) -> Option> { + ) -> Option> { self.cs.get_entry_mut(row_index, col_index) } @@ -436,7 +436,7 @@ impl CsrMatrix { /// ------ /// Panics if `row_index` or `col_index` is out of bounds. #[must_use] - pub fn index_entry(&self, row_index: usize, col_index: usize) -> SparseEntry { + pub fn index_entry(&self, row_index: usize, col_index: usize) -> SparseEntry<'_, T> { self.get_entry(row_index, col_index) .expect("Out of bounds matrix indices encountered") } @@ -449,7 +449,7 @@ impl CsrMatrix { /// Panics /// ------ /// Panics if `row_index` or `col_index` is out of bounds. - pub fn index_entry_mut(&mut self, row_index: usize, col_index: usize) -> SparseEntryMut { + pub fn index_entry_mut(&mut self, row_index: usize, col_index: usize) -> SparseEntryMut<'_, T> { self.get_entry_mut(row_index, col_index) .expect("Out of bounds matrix indices encountered") } @@ -667,7 +667,7 @@ macro_rules! impl_csr_row_common_methods { /// stored column entries. #[inline] #[must_use] - pub fn get_entry(&self, global_col_index: usize) -> Option> { + pub fn get_entry(&self, global_col_index: usize) -> Option> { self.lane.get_entry(global_col_index) } } @@ -697,7 +697,7 @@ impl<'a, T> CsrRowMut<'a, T> { /// Returns a mutable entry for the given global column index. #[inline] #[must_use] - pub fn get_entry_mut(&mut self, global_col_index: usize) -> Option> { + pub fn get_entry_mut(&mut self, global_col_index: usize) -> Option> { self.lane.get_entry_mut(global_col_index) } } diff --git a/nalgebra-sparse/src/factorization/cholesky.rs b/nalgebra-sparse/src/factorization/cholesky.rs index 0acc428d..f2e2065b 100644 --- a/nalgebra-sparse/src/factorization/cholesky.rs +++ b/nalgebra-sparse/src/factorization/cholesky.rs @@ -72,7 +72,7 @@ pub struct CscCholesky { work_c: Vec, } -#[derive(Debug, PartialEq, Eq, Clone)] +#[derive(Debug, PartialEq, Eq, Copy, Clone)] #[non_exhaustive] /// Possible errors produced by the Cholesky factorization. pub enum CholeskyError { diff --git a/nalgebra-sparse/src/lib.rs b/nalgebra-sparse/src/lib.rs index d50d8e15..bf845757 100644 --- a/nalgebra-sparse/src/lib.rs +++ b/nalgebra-sparse/src/lib.rs @@ -131,12 +131,15 @@ //! assert_matrix_eq!(y, y_expected, comp = abs, tol = 1e-9); //! } //! ``` -#![deny(non_camel_case_types)] -#![deny(unused_parens)] -#![deny(non_upper_case_globals)] -#![deny(unused_qualifications)] -#![deny(unused_results)] -#![deny(missing_docs)] +#![deny( + nonstandard_style, + unused, + missing_docs, + rust_2018_idioms, + rust_2018_compatibility, + future_incompatible, + missing_copy_implementations +)] pub extern crate nalgebra as na; pub mod convert; @@ -190,7 +193,7 @@ impl SparseFormatError { /// The type of format error described by a [SparseFormatError](struct.SparseFormatError.html). #[non_exhaustive] -#[derive(Debug, Clone, PartialEq, Eq)] +#[derive(Debug, Copy, Clone, PartialEq, Eq)] pub enum SparseFormatErrorKind { /// Indicates that the index data associated with the format contains at least one index /// out of bounds. @@ -208,7 +211,7 @@ pub enum SparseFormatErrorKind { } impl fmt::Display for SparseFormatError { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "{}", self.error) } } diff --git a/nalgebra-sparse/src/matrixcompare.rs b/nalgebra-sparse/src/matrixcompare.rs index 9c48ae40..a5f614ab 100644 --- a/nalgebra-sparse/src/matrixcompare.rs +++ b/nalgebra-sparse/src/matrixcompare.rs @@ -28,7 +28,7 @@ macro_rules! impl_matrix_for_csr_csc { self.ncols() } - fn access(&self) -> Access { + fn access(&self) -> Access<'_, T> { Access::Sparse(self) } } @@ -59,7 +59,7 @@ impl matrixcompare_core::Matrix for CooMatrix { self.ncols() } - fn access(&self) -> Access { + fn access(&self) -> Access<'_, T> { Access::Sparse(self) } } diff --git a/nalgebra-sparse/src/ops/serial/cs.rs b/nalgebra-sparse/src/ops/serial/cs.rs index 66b0ad76..db057705 100644 --- a/nalgebra-sparse/src/ops/serial/cs.rs +++ b/nalgebra-sparse/src/ops/serial/cs.rs @@ -131,10 +131,10 @@ where /// the transposed operation must be specified for the CSC matrix. pub fn spmm_cs_dense( beta: T, - mut c: DMatrixSliceMut, + mut c: DMatrixSliceMut<'_, T>, alpha: T, a: Op<&CsMatrix>, - b: Op>, + b: Op>, ) where T: Scalar + ClosedAdd + ClosedMul + Zero + One, { diff --git a/nalgebra-sparse/src/ops/serial/csc.rs b/nalgebra-sparse/src/ops/serial/csc.rs index 95350d91..25e59f26 100644 --- a/nalgebra-sparse/src/ops/serial/csc.rs +++ b/nalgebra-sparse/src/ops/serial/csc.rs @@ -27,10 +27,10 @@ pub fn spmm_csc_dense<'a, T>( fn spmm_csc_dense_( beta: T, - c: DMatrixSliceMut, + c: DMatrixSliceMut<'_, T>, alpha: T, a: Op<&CscMatrix>, - b: Op>, + b: Op>, ) where T: Scalar + ClosedAdd + ClosedMul + Zero + One, { @@ -147,7 +147,7 @@ pub fn spsolve_csc_lower_triangular<'a, T: RealField>( fn spsolve_csc_lower_triangular_no_transpose( l: &CscMatrix, - b: DMatrixSliceMut, + b: DMatrixSliceMut<'_, T>, ) -> Result<(), OperationError> { let mut x = b; @@ -205,7 +205,7 @@ fn spsolve_encountered_zero_diagonal() -> Result<(), OperationError> { fn spsolve_csc_lower_triangular_transpose( l: &CscMatrix, - b: DMatrixSliceMut, + b: DMatrixSliceMut<'_, T>, ) -> Result<(), OperationError> { let mut x = b; diff --git a/nalgebra-sparse/src/ops/serial/csr.rs b/nalgebra-sparse/src/ops/serial/csr.rs index f6fcc62a..fa317bbf 100644 --- a/nalgebra-sparse/src/ops/serial/csr.rs +++ b/nalgebra-sparse/src/ops/serial/csr.rs @@ -22,10 +22,10 @@ pub fn spmm_csr_dense<'a, T>( fn spmm_csr_dense_( beta: T, - c: DMatrixSliceMut, + c: DMatrixSliceMut<'_, T>, alpha: T, a: Op<&CsrMatrix>, - b: Op>, + b: Op>, ) where T: Scalar + ClosedAdd + ClosedMul + Zero + One, { diff --git a/nalgebra-sparse/src/ops/serial/mod.rs b/nalgebra-sparse/src/ops/serial/mod.rs index 4b0cc904..87285525 100644 --- a/nalgebra-sparse/src/ops/serial/mod.rs +++ b/nalgebra-sparse/src/ops/serial/mod.rs @@ -74,7 +74,7 @@ pub struct OperationError { /// The different kinds of operation errors that may occur. #[non_exhaustive] -#[derive(Clone, Debug)] +#[derive(Copy, Clone, Debug)] pub enum OperationErrorKind { /// Indicates that one or more sparsity patterns involved in the operation violate the /// expectations of the routine. diff --git a/nalgebra-sparse/src/pattern.rs b/nalgebra-sparse/src/pattern.rs index 2e490285..85f6bc1a 100644 --- a/nalgebra-sparse/src/pattern.rs +++ b/nalgebra-sparse/src/pattern.rs @@ -205,7 +205,7 @@ impl SparsityPattern { /// ``` /// #[must_use] - pub fn entries(&self) -> SparsityPatternIter { + pub fn entries(&self) -> SparsityPatternIter<'_> { SparsityPatternIter::from_pattern(self) } @@ -260,7 +260,7 @@ impl SparsityPattern { /// Error type for `SparsityPattern` format errors. #[non_exhaustive] -#[derive(Debug, PartialEq, Eq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum SparsityPatternFormatError { /// Indicates an invalid number of offsets. /// diff --git a/rustfmt.toml b/rustfmt.toml index e69de29b..91b5446c 100644 --- a/rustfmt.toml +++ b/rustfmt.toml @@ -0,0 +1,3 @@ +edition = "2018" +use_try_shorthand = true +use_field_init_shorthand = true diff --git a/src/base/allocator.rs b/src/base/allocator.rs index 64871635..b0f6537b 100644 --- a/src/base/allocator.rs +++ b/src/base/allocator.rs @@ -32,8 +32,8 @@ pub trait Allocator: Any + Sized { ) -> Self::Buffer; } -/// A matrix reallocator. Changes the size of the memory buffer that initially contains (RFrom × -/// CFrom) elements to a smaller or larger size (RTo, CTo). +/// A matrix reallocator. Changes the size of the memory buffer that initially contains (`RFrom` × +/// `CFrom`) elements to a smaller or larger size (`RTo`, `CTo`). pub trait Reallocator: Allocator + Allocator { diff --git a/src/base/cg.rs b/src/base/cg.rs index 742824c7..a6ed784f 100644 --- a/src/base/cg.rs +++ b/src/base/cg.rs @@ -79,7 +79,7 @@ impl Matrix3 { /// Creates a new homogeneous matrix that applies a scaling factor for each dimension with respect to point. /// - /// Can be used to implement "zoom_to" functionality. + /// Can be used to implement `zoom_to` functionality. #[inline] pub fn new_nonuniform_scaling_wrt_point(scaling: &Vector2, pt: &Point2) -> Self { let zero = T::zero(); @@ -119,7 +119,7 @@ impl Matrix4 { /// Creates a new homogeneous matrix that applies a scaling factor for each dimension with respect to point. /// - /// Can be used to implement "zoom_to" functionality. + /// Can be used to implement `zoom_to` functionality. #[inline] pub fn new_nonuniform_scaling_wrt_point(scaling: &Vector3, pt: &Point3) -> Self { let zero = T::zero(); @@ -187,7 +187,7 @@ impl Matrix4 { IsometryMatrix3::face_towards(eye, target, up).to_homogeneous() } - /// Deprecated: Use [Matrix4::face_towards] instead. + /// Deprecated: Use [`Matrix4::face_towards`] instead. #[deprecated(note = "renamed to `face_towards`")] pub fn new_observer_frame(eye: &Point3, target: &Point3, up: &Vector3) -> Self { Matrix4::face_towards(eye, target, up) diff --git a/src/base/constraint.rs b/src/base/constraint.rs index f681dc25..b8febd03 100644 --- a/src/base/constraint.rs +++ b/src/base/constraint.rs @@ -3,6 +3,7 @@ use crate::base::dimension::{Dim, DimName, Dynamic}; /// A type used in `where` clauses for enforcing constraints. +#[derive(Copy, Clone, Debug)] pub struct ShapeConstraint; /// Constraints `C1` and `R2` to be equivalent. diff --git a/src/base/construction.rs b/src/base/construction.rs index d5ecc7c1..cde4f924 100644 --- a/src/base/construction.rs +++ b/src/base/construction.rs @@ -888,19 +888,19 @@ macro_rules! transpose_array( [$([$a]),*] }; [$($a: ident),*; $($b: ident),*;] => { - [$([$a, $b]),*]; + [$([$a, $b]),*] }; [$($a: ident),*; $($b: ident),*; $($c: ident),*;] => { - [$([$a, $b, $c]),*]; + [$([$a, $b, $c]),*] }; [$($a: ident),*; $($b: ident),*; $($c: ident),*; $($d: ident),*;] => { - [$([$a, $b, $c, $d]),*]; + [$([$a, $b, $c, $d]),*] }; [$($a: ident),*; $($b: ident),*; $($c: ident),*; $($d: ident),*; $($e: ident),*;] => { - [$([$a, $b, $c, $d, $e]),*]; + [$([$a, $b, $c, $d, $e]),*] }; [$($a: ident),*; $($b: ident),*; $($c: ident),*; $($d: ident),*; $($e: ident),*; $($f: ident),*;] => { - [$([$a, $b, $c, $d, $e, $f]),*]; + [$([$a, $b, $c, $d, $e, $f]),*] }; ); diff --git a/src/base/default_allocator.rs b/src/base/default_allocator.rs index 4bfa11a8..b053c829 100644 --- a/src/base/default_allocator.rs +++ b/src/base/default_allocator.rs @@ -28,6 +28,7 @@ use crate::base::Scalar; */ /// An allocator based on `GenericArray` and `VecStorage` for statically-sized and dynamically-sized /// matrices respectively. +#[derive(Copy, Clone, Debug)] pub struct DefaultAllocator; // Static - Static diff --git a/src/base/iter.rs b/src/base/iter.rs index 0e13e4d3..6baeab25 100644 --- a/src/base/iter.rs +++ b/src/base/iter.rs @@ -11,6 +11,7 @@ use crate::base::{Matrix, MatrixSlice, MatrixSliceMut, Scalar}; macro_rules! iterator { (struct $Name:ident for $Storage:ident.$ptr: ident -> $Ptr:ty, $Ref:ty, $SRef: ty) => { /// An iterator through a dense matrix with arbitrary strides matrix. + #[derive(Debug)] pub struct $Name<'a, T: Scalar, R: Dim, C: Dim, S: 'a + $Storage> { ptr: $Ptr, inner_ptr: $Ptr, @@ -180,7 +181,7 @@ iterator!(struct MatrixIterMut for StorageMut.ptr_mut -> *mut T, &'a mut T, &'a * Row iterators. * */ -#[derive(Clone)] +#[derive(Clone, Debug)] /// An iterator through the rows of a matrix. pub struct RowIter<'a, T: Scalar, R: Dim, C: Dim, S: Storage> { mat: &'a Matrix, @@ -231,6 +232,7 @@ impl<'a, T: Scalar, R: Dim, C: Dim, S: 'a + Storage> ExactSizeIterator } /// An iterator through the mutable rows of a matrix. +#[derive(Debug)] pub struct RowIterMut<'a, T: Scalar, R: Dim, C: Dim, S: StorageMut> { mat: *mut Matrix, curr: usize, @@ -292,7 +294,7 @@ impl<'a, T: Scalar, R: Dim, C: Dim, S: 'a + StorageMut> ExactSizeIterat * Column iterators. * */ -#[derive(Clone)] +#[derive(Clone, Debug)] /// An iterator through the columns of a matrix. pub struct ColumnIter<'a, T: Scalar, R: Dim, C: Dim, S: Storage> { mat: &'a Matrix, @@ -345,6 +347,7 @@ impl<'a, T: Scalar, R: Dim, C: Dim, S: 'a + Storage> ExactSizeIterator } /// An iterator through the mutable columns of a matrix. +#[derive(Debug)] pub struct ColumnIterMut<'a, T: Scalar, R: Dim, C: Dim, S: StorageMut> { mat: *mut Matrix, curr: usize, diff --git a/src/base/matrix.rs b/src/base/matrix.rs index ea2c2c40..2f3d9dff 100644 --- a/src/base/matrix.rs +++ b/src/base/matrix.rs @@ -368,7 +368,7 @@ impl Matrix { } impl SMatrix { - /// Creates a new statically-allocated matrix from the given [ArrayStorage]. + /// Creates a new statically-allocated matrix from the given [`ArrayStorage`]. /// /// This method exists primarily as a workaround for the fact that `from_data` can not /// work in `const fn` contexts. @@ -384,7 +384,7 @@ impl SMatrix { // `from_data` const fn compatible #[cfg(any(feature = "std", feature = "alloc"))] impl DMatrix { - /// Creates a new heap-allocated matrix from the given [VecStorage]. + /// Creates a new heap-allocated matrix from the given [`VecStorage`]. /// /// This method exists primarily as a workaround for the fact that `from_data` can not /// work in `const fn` contexts. @@ -399,7 +399,7 @@ impl DMatrix { // `from_data` const fn compatible #[cfg(any(feature = "std", feature = "alloc"))] impl DVector { - /// Creates a new heap-allocated matrix from the given [VecStorage]. + /// Creates a new heap-allocated matrix from the given [`VecStorage`]. /// /// This method exists primarily as a workaround for the fact that `from_data` can not /// work in `const fn` contexts. diff --git a/src/base/matrix_slice.rs b/src/base/matrix_slice.rs index bd4a66da..29aeb5ec 100644 --- a/src/base/matrix_slice.rs +++ b/src/base/matrix_slice.rs @@ -584,7 +584,7 @@ macro_rules! matrix_slice_impl( * Splitting. * */ - /// Splits this NxM matrix into two parts delimited by two ranges. + /// Splits this `NxM` matrix into two parts delimited by two ranges. /// /// Panics if the ranges overlap or if the first range is empty. #[inline] @@ -620,7 +620,7 @@ macro_rules! matrix_slice_impl( } } - /// Splits this NxM matrix into two parts delimited by two ranges. + /// Splits this `NxM` matrix into two parts delimited by two ranges. /// /// Panics if the ranges overlap or if the first range is empty. #[inline] diff --git a/src/base/norm.rs b/src/base/norm.rs index 09e11f7e..a8548ddd 100644 --- a/src/base/norm.rs +++ b/src/base/norm.rs @@ -40,10 +40,13 @@ pub trait Norm { } /// Euclidean norm. +#[derive(Copy, Clone, Debug)] pub struct EuclideanNorm; /// Lp norm. +#[derive(Copy, Clone, Debug)] pub struct LpNorm(pub i32); /// L-infinite norm aka. Chebytchev norm aka. uniform norm aka. suppremum norm. +#[derive(Copy, Clone, Debug)] pub struct UniformNorm; impl Norm for EuclideanNorm { diff --git a/src/base/unit.rs b/src/base/unit.rs index a6ca33f3..fb2f6efe 100644 --- a/src/base/unit.rs +++ b/src/base/unit.rs @@ -238,7 +238,7 @@ impl Unit { } /// Retrieves the underlying value. - /// Deprecated: use [Unit::into_inner] instead. + /// Deprecated: use [`Unit::into_inner`] instead. #[deprecated(note = "use `.into_inner()` instead")] #[inline] pub fn unwrap(self) -> T { diff --git a/src/base/vec_storage.rs b/src/base/vec_storage.rs index be567094..20cc5171 100644 --- a/src/base/vec_storage.rs +++ b/src/base/vec_storage.rs @@ -79,7 +79,7 @@ where } #[deprecated(note = "renamed to `VecStorage`")] -/// Renamed to [VecStorage]. +/// Renamed to [`VecStorage`]. pub type MatrixVec = VecStorage; impl VecStorage { diff --git a/src/geometry/dual_quaternion.rs b/src/geometry/dual_quaternion.rs index 6f54910b..6dd8936d 100644 --- a/src/geometry/dual_quaternion.rs +++ b/src/geometry/dual_quaternion.rs @@ -16,7 +16,7 @@ use simba::scalar::{ClosedNeg, RealField}; /// /// # Indexing /// -/// DualQuaternions are stored as \[..real, ..dual\]. +/// `DualQuaternions` are stored as \[..real, ..dual\]. /// Both of the quaternion components are laid out in `i, j, k, w` order. /// /// ``` @@ -36,7 +36,7 @@ use simba::scalar::{ClosedNeg, RealField}; /// NOTE: /// As of December 2020, dual quaternion support is a work in progress. /// If a feature that you need is missing, feel free to open an issue or a PR. -/// See https://github.com/dimforge/nalgebra/issues/487 +/// See #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct DualQuaternion { diff --git a/src/geometry/isometry_construction.rs b/src/geometry/isometry_construction.rs index 39a1d763..9b855599 100644 --- a/src/geometry/isometry_construction.rs +++ b/src/geometry/isometry_construction.rs @@ -308,7 +308,7 @@ macro_rules! look_at_isometry_construction_impl( $RotId::face_towards(&(target - eye), up)) } - /// Deprecated: Use [Isometry::face_towards] instead. + /// Deprecated: Use [`Isometry::face_towards`] instead. #[deprecated(note="renamed to `face_towards`")] pub fn new_observer_frame(eye: &Point3, target: &Point3, diff --git a/src/geometry/orthographic.rs b/src/geometry/orthographic.rs index 3a512d0b..b349a621 100644 --- a/src/geometry/orthographic.rs +++ b/src/geometry/orthographic.rs @@ -314,7 +314,7 @@ impl Orthographic3 { } /// Retrieves the underlying homogeneous matrix. - /// Deprecated: Use [Orthographic3::into_inner] instead. + /// Deprecated: Use [`Orthographic3::into_inner`] instead. #[deprecated(note = "use `.into_inner()` instead")] #[inline] pub fn unwrap(self) -> Matrix4 { diff --git a/src/geometry/perspective.rs b/src/geometry/perspective.rs index 86b4fd13..d5a6fe42 100644 --- a/src/geometry/perspective.rs +++ b/src/geometry/perspective.rs @@ -175,7 +175,7 @@ impl Perspective3 { } /// Retrieves the underlying homogeneous matrix. - /// Deprecated: Use [Perspective3::into_inner] instead. + /// Deprecated: Use [`Perspective3::into_inner`] instead. #[deprecated(note = "use `.into_inner()` instead")] #[inline] pub fn unwrap(self) -> Matrix4 { diff --git a/src/geometry/quaternion_construction.rs b/src/geometry/quaternion_construction.rs index f93069b4..61b1fe3e 100644 --- a/src/geometry/quaternion_construction.rs +++ b/src/geometry/quaternion_construction.rs @@ -591,7 +591,7 @@ where Self::from_rotation_matrix(&Rotation3::face_towards(dir, up)) } - /// Deprecated: Use [UnitQuaternion::face_towards] instead. + /// Deprecated: Use [`UnitQuaternion::face_towards`] instead. #[deprecated(note = "renamed to `face_towards`")] pub fn new_observer_frames(dir: &Vector, up: &Vector) -> Self where @@ -785,7 +785,7 @@ where Self::new_eps(axisangle, eps) } - /// Create the mean unit quaternion from a data structure implementing IntoIterator + /// Create the mean unit quaternion from a data structure implementing `IntoIterator` /// returning unit quaternions. /// /// The method will panic if the iterator does not return any quaternions. diff --git a/src/geometry/rotation.rs b/src/geometry/rotation.rs index dfaab9d7..33e42dda 100755 --- a/src/geometry/rotation.rs +++ b/src/geometry/rotation.rs @@ -244,7 +244,7 @@ impl Rotation { } /// Unwraps the underlying matrix. - /// Deprecated: Use [Rotation::into_inner] instead. + /// Deprecated: Use [`Rotation::into_inner`] instead. #[deprecated(note = "use `.into_inner()` instead")] #[inline] pub fn unwrap(self) -> SMatrix { diff --git a/src/geometry/rotation_specialization.rs b/src/geometry/rotation_specialization.rs index 2ad73c69..5cd44119 100644 --- a/src/geometry/rotation_specialization.rs +++ b/src/geometry/rotation_specialization.rs @@ -483,7 +483,7 @@ where )) } - /// Deprecated: Use [Rotation3::face_towards] instead. + /// Deprecated: Use [`Rotation3::face_towards`] instead. #[deprecated(note = "renamed to `face_towards`")] pub fn new_observer_frames(dir: &Vector, up: &Vector) -> Self where diff --git a/src/geometry/similarity_construction.rs b/src/geometry/similarity_construction.rs index 3c1b2b42..feb5719b 100644 --- a/src/geometry/similarity_construction.rs +++ b/src/geometry/similarity_construction.rs @@ -306,7 +306,7 @@ macro_rules! similarity_construction_impl( Self::from_isometry(Isometry::<_, $Rot, 3>::face_towards(eye, target, up), scaling) } - /// Deprecated: Use [SimilarityMatrix3::face_towards] instead. + /// Deprecated: Use [`SimilarityMatrix3::face_towards`] instead. #[deprecated(note="renamed to `face_towards`")] pub fn new_observer_frames(eye: &Point3, target: &Point3, diff --git a/src/geometry/transform.rs b/src/geometry/transform.rs index 435bac59..71544b59 100755 --- a/src/geometry/transform.rs +++ b/src/geometry/transform.rs @@ -305,7 +305,7 @@ where } /// Retrieves the underlying matrix. - /// Deprecated: Use [Transform::into_inner] instead. + /// Deprecated: Use [`Transform::into_inner`] instead. #[deprecated(note = "use `.into_inner()` instead")] #[inline] pub fn unwrap(self) -> OMatrix, U1>, DimNameSum, U1>> { diff --git a/src/lib.rs b/src/lib.rs index 28767346..e21f0709 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1,4 +1,3 @@ -#![allow(clippy::type_complexity)] /*! # nalgebra @@ -72,17 +71,18 @@ an optimized set of tools for computer graphics and physics. Those features incl * Insertion and removal of rows of columns of a matrix. */ -// #![feature(plugin)] -// -// #![plugin(clippy)] - -#![deny(non_camel_case_types)] -#![deny(unused_parens)] -#![deny(non_upper_case_globals)] -#![deny(unused_qualifications)] -#![deny(unused_results)] -#![deny(missing_docs)] -#![deny(rust_2018_idioms)] +#![allow(unused_variables, unused_mut)] +#![deny( + nonstandard_style, + unused_parens, + unused_qualifications, + unused_results, + missing_docs, + rust_2018_idioms, + rust_2018_compatibility, + future_incompatible, + missing_copy_implementations +)] #![doc( html_favicon_url = "https://nalgebra.org/img/favicon.ico", html_root_url = "https://docs.rs/nalgebra/0.25.0" @@ -246,7 +246,7 @@ pub fn min(a: T, b: T) -> T { /// The absolute value of `a`. /// -/// Deprecated: Use [Matrix::abs] or [RealField::abs] instead. +/// Deprecated: Use [`Matrix::abs`] or [`RealField::abs`] instead. #[deprecated(note = "use the inherent method `Matrix::abs` or `RealField::abs` instead")] #[inline] pub fn abs(a: &T) -> T { @@ -385,7 +385,7 @@ pub fn partial_sort2<'a, T: PartialOrd>(a: &'a T, b: &'a T) -> Option<(&'a T, &' /// # See also: /// /// * [distance](fn.distance.html) -/// * [distance_squared](fn.distance_squared.html) +/// * [`distance_squared`](fn.distance_squared.html) #[inline] pub fn center( p1: &Point, @@ -399,7 +399,7 @@ pub fn center( /// # See also: /// /// * [center](fn.center.html) -/// * [distance_squared](fn.distance_squared.html) +/// * [`distance_squared`](fn.distance_squared.html) #[inline] pub fn distance( p1: &Point, @@ -431,11 +431,11 @@ pub fn distance_squared( /// /// # See also: /// -/// * [convert_ref](fn.convert_ref.html) -/// * [convert_ref_unchecked](fn.convert_ref_unchecked.html) -/// * [is_convertible](../nalgebra/fn.is_convertible.html) -/// * [try_convert](fn.try_convert.html) -/// * [try_convert_ref](fn.try_convert_ref.html) +/// * [`convert_ref`](fn.convert_ref.html) +/// * [`convert_ref_unchecked`](fn.convert_ref_unchecked.html) +/// * [`is_convertible`](../nalgebra/fn.is_convertible.html) +/// * [`try_convert`](fn.try_convert.html) +/// * [`try_convert_ref`](fn.try_convert_ref.html) #[inline] pub fn convert>(t: From) -> To { To::from_subset(&t) @@ -448,10 +448,10 @@ pub fn convert>(t: From) -> To { /// # See also: /// /// * [convert](fn.convert.html) -/// * [convert_ref](fn.convert_ref.html) -/// * [convert_ref_unchecked](fn.convert_ref_unchecked.html) -/// * [is_convertible](../nalgebra/fn.is_convertible.html) -/// * [try_convert_ref](fn.try_convert_ref.html) +/// * [`convert_ref`](fn.convert_ref.html) +/// * [`convert_ref_unchecked`](fn.convert_ref_unchecked.html) +/// * [`is_convertible`](../nalgebra/fn.is_convertible.html) +/// * [`try_convert_ref`](fn.try_convert_ref.html) #[inline] pub fn try_convert, To>(t: From) -> Option { t.to_subset() @@ -463,10 +463,10 @@ pub fn try_convert, To>(t: From) -> Option { /// # See also: /// /// * [convert](fn.convert.html) -/// * [convert_ref](fn.convert_ref.html) -/// * [convert_ref_unchecked](fn.convert_ref_unchecked.html) -/// * [try_convert](fn.try_convert.html) -/// * [try_convert_ref](fn.try_convert_ref.html) +/// * [`convert_ref`](fn.convert_ref.html) +/// * [`convert_ref_unchecked`](fn.convert_ref_unchecked.html) +/// * [`try_convert`](fn.try_convert.html) +/// * [`try_convert_ref`](fn.try_convert_ref.html) #[inline] pub fn is_convertible, To>(t: &From) -> bool { t.is_in_subset() @@ -478,11 +478,11 @@ pub fn is_convertible, To>(t: &From) -> bool { /// # See also: /// /// * [convert](fn.convert.html) -/// * [convert_ref](fn.convert_ref.html) -/// * [convert_ref_unchecked](fn.convert_ref_unchecked.html) -/// * [is_convertible](../nalgebra/fn.is_convertible.html) -/// * [try_convert](fn.try_convert.html) -/// * [try_convert_ref](fn.try_convert_ref.html) +/// * [`convert_ref`](fn.convert_ref.html) +/// * [`convert_ref_unchecked`](fn.convert_ref_unchecked.html) +/// * [`is_convertible`](../nalgebra/fn.is_convertible.html) +/// * [`try_convert`](fn.try_convert.html) +/// * [`try_convert_ref`](fn.try_convert_ref.html) #[inline] pub fn convert_unchecked, To>(t: From) -> To { t.to_subset_unchecked() @@ -493,10 +493,10 @@ pub fn convert_unchecked, To>(t: From) -> To { /// # See also: /// /// * [convert](fn.convert.html) -/// * [convert_ref_unchecked](fn.convert_ref_unchecked.html) -/// * [is_convertible](../nalgebra/fn.is_convertible.html) -/// * [try_convert](fn.try_convert.html) -/// * [try_convert_ref](fn.try_convert_ref.html) +/// * [`convert_ref_unchecked`](fn.convert_ref_unchecked.html) +/// * [`is_convertible`](../nalgebra/fn.is_convertible.html) +/// * [`try_convert`](fn.try_convert.html) +/// * [`try_convert_ref`](fn.try_convert_ref.html) #[inline] pub fn convert_ref>(t: &From) -> To { To::from_subset(t) @@ -507,10 +507,10 @@ pub fn convert_ref>(t: &From) -> To { /// # See also: /// /// * [convert](fn.convert.html) -/// * [convert_ref](fn.convert_ref.html) -/// * [convert_ref_unchecked](fn.convert_ref_unchecked.html) -/// * [is_convertible](../nalgebra/fn.is_convertible.html) -/// * [try_convert](fn.try_convert.html) +/// * [`convert_ref`](fn.convert_ref.html) +/// * [`convert_ref_unchecked`](fn.convert_ref_unchecked.html) +/// * [`is_convertible`](../nalgebra/fn.is_convertible.html) +/// * [`try_convert`](fn.try_convert.html) #[inline] pub fn try_convert_ref, To>(t: &From) -> Option { t.to_subset() @@ -522,10 +522,10 @@ pub fn try_convert_ref, To>(t: &From) -> Option { /// # See also: /// /// * [convert](fn.convert.html) -/// * [convert_ref](fn.convert_ref.html) -/// * [is_convertible](../nalgebra/fn.is_convertible.html) -/// * [try_convert](fn.try_convert.html) -/// * [try_convert_ref](fn.try_convert_ref.html) +/// * [`convert_ref`](fn.convert_ref.html) +/// * [`is_convertible`](../nalgebra/fn.is_convertible.html) +/// * [`try_convert`](fn.try_convert.html) +/// * [`try_convert_ref`](fn.try_convert_ref.html) #[inline] pub fn convert_ref_unchecked, To>(t: &From) -> To { t.to_subset_unchecked() diff --git a/src/linalg/balancing.rs b/src/linalg/balancing.rs index 3965caf1..f4f8b659 100644 --- a/src/linalg/balancing.rs +++ b/src/linalg/balancing.rs @@ -11,7 +11,7 @@ use crate::base::{Const, DefaultAllocator, OMatrix, OVector}; /// Applies in-place a modified Parlett and Reinsch matrix balancing with 2-norm to the matrix and returns /// the corresponding diagonal transformation. /// -/// See https://arxiv.org/pdf/1401.5766.pdf +/// See pub fn balance_parlett_reinsch(matrix: &mut OMatrix) -> OVector where DefaultAllocator: Allocator + Allocator, diff --git a/src/linalg/col_piv_qr.rs b/src/linalg/col_piv_qr.rs index 1a56d2cb..fcd0f376 100644 --- a/src/linalg/col_piv_qr.rs +++ b/src/linalg/col_piv_qr.rs @@ -60,7 +60,7 @@ where + Allocator> + Allocator<(usize, usize), DimMinimum>, { - /// Computes the ColPivQR decomposition using householder reflections. + /// Computes the `ColPivQR` decomposition using householder reflections. pub fn new(mut matrix: OMatrix) -> Self { let (nrows, ncols) = matrix.data.shape(); let min_nrows_ncols = nrows.min(ncols); diff --git a/src/linalg/schur.rs b/src/linalg/schur.rs index c03f6f08..3b650c52 100644 --- a/src/linalg/schur.rs +++ b/src/linalg/schur.rs @@ -19,7 +19,7 @@ use crate::linalg::Hessenberg; /// Schur decomposition of a square matrix. /// -/// If this is a real matrix, this will be a RealField Schur decomposition. +/// If this is a real matrix, this will be a `RealField` Schur decomposition. #[cfg_attr(feature = "serde-serialize-no-std", derive(Serialize, Deserialize))] #[cfg_attr( feature = "serde-serialize-no-std", diff --git a/src/proptest/mod.rs b/src/proptest/mod.rs index 794080fe..a7cbe549 100644 --- a/src/proptest/mod.rs +++ b/src/proptest/mod.rs @@ -2,12 +2,12 @@ //! //! **This module is only available when the `proptest-support` feature is enabled in `nalgebra`**. //! -//! `proptest` is a library for *property-based testing*. While similar to QuickCheck, +//! `proptest` is a library for *property-based testing*. While similar to `QuickCheck`, //! which may be more familiar to some users, it has a more sophisticated design that //! provides users with automatic invariant-preserving shrinking. This means that when using //! `proptest`, you rarely need to write your own shrinkers - which is usually very difficult - //! and can instead get this "for free". Moreover, `proptest` does not rely on a canonical -//! `Arbitrary` trait implementation like QuickCheck, though it does also provide this. For +//! `Arbitrary` trait implementation like `QuickCheck`, though it does also provide this. For //! more information, check out the [proptest docs](https://docs.rs/proptest/0.10.1/proptest/) //! and the [proptest book](https://altsysrq.github.io/proptest-book/intro.html). //! @@ -316,7 +316,7 @@ where /// with length in the provided range. /// /// This is a convenience function for calling -/// [matrix(value_strategy, length, U1)](fn.matrix.html) and should +/// [`matrix(value_strategy, length, U1)`](fn.matrix.html) and should /// be used when you only want to generate column vectors, as it's simpler and makes the intent /// clear. pub fn vector( diff --git a/src/sparse/cs_matrix.rs b/src/sparse/cs_matrix.rs index cdacd044..0fc3fed7 100644 --- a/src/sparse/cs_matrix.rs +++ b/src/sparse/cs_matrix.rs @@ -46,7 +46,7 @@ impl<'a, T: Clone> Iterator for ColumnEntries<'a, T> { pub trait CsStorageIter<'a, T, R, C = U1> { /// Iterator through all the rows of a specific columns. /// - /// The elements are given as a tuple (row_index, value). + /// The elements are given as a tuple (`row_index`, value). type ColumnEntries: Iterator; /// Iterator through the row indices of a specific column. type ColumnRowIndices: Iterator; @@ -63,7 +63,7 @@ pub trait CsStorageIterMut<'a, T: 'a, R, C = U1> { type ValuesMut: Iterator; /// Mutable iterator through all the rows of a specific columns. /// - /// The elements are given as a tuple (row_index, value). + /// The elements are given as a tuple (`row_index`, value). type ColumnEntriesMut: Iterator; /// A mutable iterator through the values buffer of the sparse matrix. diff --git a/src/third_party/alga/alga_isometry.rs b/src/third_party/alga/alga_isometry.rs index e0ec2924..7633bf5c 100755 --- a/src/third_party/alga/alga_isometry.rs +++ b/src/third_party/alga/alga_isometry.rs @@ -120,7 +120,7 @@ where #[inline] fn decompose(&self) -> (Self::Translation, R, Id, R) { ( - self.translation.clone(), + self.translation, self.rotation.clone(), Id::new(), >::identity(), @@ -145,7 +145,7 @@ where #[inline] fn prepend_rotation(&self, r: &Self::Rotation) -> Self { - Isometry::from_parts(self.translation.clone(), self.rotation.prepend_rotation(r)) + Isometry::from_parts(self.translation, self.rotation.prepend_rotation(r)) } #[inline] @@ -175,7 +175,7 @@ where #[inline] fn translation(&self) -> Translation { - self.translation.clone() + self.translation } #[inline] diff --git a/src/third_party/alga/alga_rotation.rs b/src/third_party/alga/alga_rotation.rs index a63d7f84..cec4ae7d 100755 --- a/src/third_party/alga/alga_rotation.rs +++ b/src/third_party/alga/alga_rotation.rs @@ -105,17 +105,17 @@ impl AffineTransformati #[inline] fn decompose(&self) -> (Id, Self, Id, Self) { - (Id::new(), self.clone(), Id::new(), Self::identity()) + (Id::new(), *self, Id::new(), Self::identity()) } #[inline] fn append_translation(&self, _: &Self::Translation) -> Self { - self.clone() + *self } #[inline] fn prepend_translation(&self, _: &Self::Translation) -> Self { - self.clone() + *self } #[inline] @@ -130,12 +130,12 @@ impl AffineTransformati #[inline] fn append_scaling(&self, _: &Self::NonUniformScaling) -> Self { - self.clone() + *self } #[inline] fn prepend_scaling(&self, _: &Self::NonUniformScaling) -> Self { - self.clone() + *self } } @@ -151,7 +151,7 @@ impl Similarity Self { - self.clone() + *self } #[inline] diff --git a/src/third_party/alga/alga_similarity.rs b/src/third_party/alga/alga_similarity.rs index 3825b1c8..f0d29867 100755 --- a/src/third_party/alga/alga_similarity.rs +++ b/src/third_party/alga/alga_similarity.rs @@ -117,7 +117,7 @@ where #[inline] fn decompose(&self) -> (Translation, R, T, R) { ( - self.isometry.translation.clone(), + self.isometry.translation, self.isometry.rotation.clone(), self.scaling(), >::identity(), diff --git a/src/third_party/alga/alga_translation.rs b/src/third_party/alga/alga_translation.rs index 76a68355..246fe640 100755 --- a/src/third_party/alga/alga_translation.rs +++ b/src/third_party/alga/alga_translation.rs @@ -106,7 +106,7 @@ impl AffineTransformati #[inline] fn decompose(&self) -> (Self, Id, Id, Id) { - (self.clone(), Id::new(), Id::new(), Id::new()) + (*self, Id::new(), Id::new(), Id::new()) } #[inline] @@ -121,22 +121,22 @@ impl AffineTransformati #[inline] fn append_rotation(&self, _: &Self::Rotation) -> Self { - self.clone() + *self } #[inline] fn prepend_rotation(&self, _: &Self::Rotation) -> Self { - self.clone() + *self } #[inline] fn append_scaling(&self, _: &Self::NonUniformScaling) -> Self { - self.clone() + *self } #[inline] fn prepend_scaling(&self, _: &Self::NonUniformScaling) -> Self { - self.clone() + *self } } @@ -147,7 +147,7 @@ impl Similarity Self { - self.clone() + *self } #[inline]