From c8dfb5e348432508d6c8bd58bfe3fd7ab0290e1a Mon Sep 17 00:00:00 2001 From: Andreas Longva Date: Fri, 11 Nov 2022 15:46:04 +0100 Subject: [PATCH 01/22] Rename SliceStorage(Mut) to ViewStorage(Mut) Additionally, we add type aliases with the old names to maintain backwards compatibility with deprecation warnings. --- src/base/alias_slice.rs | 242 ++++++++++++++++----------------- src/base/construction_slice.rs | 6 +- src/base/conversion.rs | 8 +- src/base/indexing.rs | 8 +- src/base/matrix_slice.rs | 89 ++++++------ 5 files changed, 182 insertions(+), 171 deletions(-) diff --git a/src/base/alias_slice.rs b/src/base/alias_slice.rs index 929d2f03..21cde51c 100644 --- a/src/base/alias_slice.rs +++ b/src/base/alias_slice.rs @@ -1,5 +1,5 @@ use crate::base::dimension::{Dynamic, U1, U2, U3, U4, U5, U6}; -use crate::base::matrix_slice::{SliceStorage, SliceStorageMut}; +use crate::base::matrix_slice::{ViewStorage, ViewStorageMut}; use crate::base::{Const, Matrix}; /* @@ -14,285 +14,285 @@ use crate::base::{Const, Matrix}; /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type SMatrixSlice<'a, T, const R: usize, const C: usize> = - Matrix, Const, SliceStorage<'a, T, Const, Const, Const<1>, Const>>; + Matrix, Const, ViewStorage<'a, T, Const, Const, Const<1>, Const>>; /// A column-major matrix slice dynamic numbers of rows and columns. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type DMatrixSlice<'a, T, RStride = U1, CStride = Dynamic> = - Matrix>; + Matrix>; /// A column-major 1x1 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSlice1<'a, T, RStride = U1, CStride = U1> = - Matrix>; + Matrix>; /// A column-major 2x2 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSlice2<'a, T, RStride = U1, CStride = U2> = - Matrix>; + Matrix>; /// A column-major 3x3 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSlice3<'a, T, RStride = U1, CStride = U3> = - Matrix>; + Matrix>; /// A column-major 4x4 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSlice4<'a, T, RStride = U1, CStride = U4> = - Matrix>; + Matrix>; /// A column-major 5x5 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSlice5<'a, T, RStride = U1, CStride = U5> = - Matrix>; + Matrix>; /// A column-major 6x6 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSlice6<'a, T, RStride = U1, CStride = U6> = - Matrix>; + Matrix>; /// A column-major 1x2 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSlice1x2<'a, T, RStride = U1, CStride = U1> = - Matrix>; + Matrix>; /// A column-major 1x3 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSlice1x3<'a, T, RStride = U1, CStride = U1> = - Matrix>; + Matrix>; /// A column-major 1x4 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSlice1x4<'a, T, RStride = U1, CStride = U1> = - Matrix>; + Matrix>; /// A column-major 1x5 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSlice1x5<'a, T, RStride = U1, CStride = U1> = - Matrix>; + Matrix>; /// A column-major 1x6 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSlice1x6<'a, T, RStride = U1, CStride = U1> = - Matrix>; + Matrix>; /// A column-major 2x1 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSlice2x1<'a, T, RStride = U1, CStride = U2> = - Matrix>; + Matrix>; /// A column-major 2x3 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSlice2x3<'a, T, RStride = U1, CStride = U2> = - Matrix>; + Matrix>; /// A column-major 2x4 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSlice2x4<'a, T, RStride = U1, CStride = U2> = - Matrix>; + Matrix>; /// A column-major 2x5 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSlice2x5<'a, T, RStride = U1, CStride = U2> = - Matrix>; + Matrix>; /// A column-major 2x6 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSlice2x6<'a, T, RStride = U1, CStride = U2> = - Matrix>; + Matrix>; /// A column-major 3x1 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSlice3x1<'a, T, RStride = U1, CStride = U3> = - Matrix>; + Matrix>; /// A column-major 3x2 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSlice3x2<'a, T, RStride = U1, CStride = U3> = - Matrix>; + Matrix>; /// A column-major 3x4 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSlice3x4<'a, T, RStride = U1, CStride = U3> = - Matrix>; + Matrix>; /// A column-major 3x5 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSlice3x5<'a, T, RStride = U1, CStride = U3> = - Matrix>; + Matrix>; /// A column-major 3x6 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSlice3x6<'a, T, RStride = U1, CStride = U3> = - Matrix>; + Matrix>; /// A column-major 4x1 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSlice4x1<'a, T, RStride = U1, CStride = U4> = - Matrix>; + Matrix>; /// A column-major 4x2 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSlice4x2<'a, T, RStride = U1, CStride = U4> = - Matrix>; + Matrix>; /// A column-major 4x3 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSlice4x3<'a, T, RStride = U1, CStride = U4> = - Matrix>; + Matrix>; /// A column-major 4x5 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSlice4x5<'a, T, RStride = U1, CStride = U4> = - Matrix>; + Matrix>; /// A column-major 4x6 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSlice4x6<'a, T, RStride = U1, CStride = U4> = - Matrix>; + Matrix>; /// A column-major 5x1 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSlice5x1<'a, T, RStride = U1, CStride = U5> = - Matrix>; + Matrix>; /// A column-major 5x2 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSlice5x2<'a, T, RStride = U1, CStride = U5> = - Matrix>; + Matrix>; /// A column-major 5x3 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSlice5x3<'a, T, RStride = U1, CStride = U5> = - Matrix>; + Matrix>; /// A column-major 5x4 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSlice5x4<'a, T, RStride = U1, CStride = U5> = - Matrix>; + Matrix>; /// A column-major 5x6 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSlice5x6<'a, T, RStride = U1, CStride = U5> = - Matrix>; + Matrix>; /// A column-major 6x1 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSlice6x1<'a, T, RStride = U1, CStride = U6> = - Matrix>; + Matrix>; /// A column-major 6x2 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSlice6x2<'a, T, RStride = U1, CStride = U6> = - Matrix>; + Matrix>; /// A column-major 6x3 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSlice6x3<'a, T, RStride = U1, CStride = U6> = - Matrix>; + Matrix>; /// A column-major 6x4 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSlice6x4<'a, T, RStride = U1, CStride = U6> = - Matrix>; + Matrix>; /// A column-major 6x5 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSlice6x5<'a, T, RStride = U1, CStride = U6> = - Matrix>; + Matrix>; /// A column-major matrix slice with 1 row and a number of columns chosen at runtime. pub type MatrixSlice1xX<'a, T, RStride = U1, CStride = U1> = - Matrix>; + Matrix>; /// A column-major matrix slice with 2 rows and a number of columns chosen at runtime. pub type MatrixSlice2xX<'a, T, RStride = U1, CStride = U2> = - Matrix>; + Matrix>; /// A column-major matrix slice with 3 rows and a number of columns chosen at runtime. pub type MatrixSlice3xX<'a, T, RStride = U1, CStride = U3> = - Matrix>; + Matrix>; /// A column-major matrix slice with 4 rows and a number of columns chosen at runtime. pub type MatrixSlice4xX<'a, T, RStride = U1, CStride = U4> = - Matrix>; + Matrix>; /// A column-major matrix slice with 5 rows and a number of columns chosen at runtime. pub type MatrixSlice5xX<'a, T, RStride = U1, CStride = U5> = - Matrix>; + Matrix>; /// A column-major matrix slice with 6 rows and a number of columns chosen at runtime. pub type MatrixSlice6xX<'a, T, RStride = U1, CStride = U6> = - Matrix>; + Matrix>; /// A column-major matrix slice with a number of rows chosen at runtime and 1 column. pub type MatrixSliceXx1<'a, T, RStride = U1, CStride = Dynamic> = - Matrix>; + Matrix>; /// A column-major matrix slice with a number of rows chosen at runtime and 2 columns. pub type MatrixSliceXx2<'a, T, RStride = U1, CStride = Dynamic> = - Matrix>; + Matrix>; /// A column-major matrix slice with a number of rows chosen at runtime and 3 columns. pub type MatrixSliceXx3<'a, T, RStride = U1, CStride = Dynamic> = - Matrix>; + Matrix>; /// A column-major matrix slice with a number of rows chosen at runtime and 4 columns. pub type MatrixSliceXx4<'a, T, RStride = U1, CStride = Dynamic> = - Matrix>; + Matrix>; /// A column-major matrix slice with a number of rows chosen at runtime and 5 columns. pub type MatrixSliceXx5<'a, T, RStride = U1, CStride = Dynamic> = - Matrix>; + Matrix>; /// A column-major matrix slice with a number of rows chosen at runtime and 6 columns. pub type MatrixSliceXx6<'a, T, RStride = U1, CStride = Dynamic> = - Matrix>; + Matrix>; /// A column vector slice with dimensions known at compile-time. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type VectorSlice<'a, T, D, RStride = U1, CStride = D> = - Matrix>; + Matrix>; /// A column vector slice with dimensions known at compile-time. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type SVectorSlice<'a, T, const D: usize> = - Matrix, Const<1>, SliceStorage<'a, T, Const, Const<1>, Const<1>, Const>>; + Matrix, Const<1>, ViewStorage<'a, T, Const, Const<1>, Const<1>, Const>>; /// A column vector slice dynamic numbers of rows and columns. pub type DVectorSlice<'a, T, RStride = U1, CStride = Dynamic> = - Matrix>; + Matrix>; /// A 1D column vector slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type VectorSlice1<'a, T, RStride = U1, CStride = U1> = - Matrix>; + Matrix>; /// A 2D column vector slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type VectorSlice2<'a, T, RStride = U1, CStride = U2> = - Matrix>; + Matrix>; /// A 3D column vector slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type VectorSlice3<'a, T, RStride = U1, CStride = U3> = - Matrix>; + Matrix>; /// A 4D column vector slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type VectorSlice4<'a, T, RStride = U1, CStride = U4> = - Matrix>; + Matrix>; /// A 5D column vector slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type VectorSlice5<'a, T, RStride = U1, CStride = U5> = - Matrix>; + Matrix>; /// A 6D column vector slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type VectorSlice6<'a, T, RStride = U1, CStride = U6> = - Matrix>; + Matrix>; /* * @@ -305,296 +305,296 @@ pub type VectorSlice6<'a, T, RStride = U1, CStride = U6> = /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSliceMutMN<'a, T, R, C, RStride = U1, CStride = R> = - Matrix>; + Matrix>; /// A column-major matrix slice with `D` rows and columns. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSliceMutN<'a, T, D, RStride = U1, CStride = D> = - Matrix>; + Matrix>; /// A column-major matrix slice with dimensions known at compile-time. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type SMatrixSliceMut<'a, T, const R: usize, const C: usize> = - Matrix, Const, SliceStorageMut<'a, T, Const, Const, Const<1>, Const>>; + Matrix, Const, ViewStorageMut<'a, T, Const, Const, Const<1>, Const>>; /// A column-major matrix slice dynamic numbers of rows and columns. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type DMatrixSliceMut<'a, T, RStride = U1, CStride = Dynamic> = - Matrix>; + Matrix>; /// A column-major 1x1 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSliceMut1<'a, T, RStride = U1, CStride = U1> = - Matrix>; + Matrix>; /// A column-major 2x2 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSliceMut2<'a, T, RStride = U1, CStride = U2> = - Matrix>; + Matrix>; /// A column-major 3x3 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSliceMut3<'a, T, RStride = U1, CStride = U3> = - Matrix>; + Matrix>; /// A column-major 4x4 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSliceMut4<'a, T, RStride = U1, CStride = U4> = - Matrix>; + Matrix>; /// A column-major 5x5 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSliceMut5<'a, T, RStride = U1, CStride = U5> = - Matrix>; + Matrix>; /// A column-major 6x6 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSliceMut6<'a, T, RStride = U1, CStride = U6> = - Matrix>; + Matrix>; /// A column-major 1x2 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSliceMut1x2<'a, T, RStride = U1, CStride = U1> = - Matrix>; + Matrix>; /// A column-major 1x3 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSliceMut1x3<'a, T, RStride = U1, CStride = U1> = - Matrix>; + Matrix>; /// A column-major 1x4 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSliceMut1x4<'a, T, RStride = U1, CStride = U1> = - Matrix>; + Matrix>; /// A column-major 1x5 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSliceMut1x5<'a, T, RStride = U1, CStride = U1> = - Matrix>; + Matrix>; /// A column-major 1x6 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSliceMut1x6<'a, T, RStride = U1, CStride = U1> = - Matrix>; + Matrix>; /// A column-major 2x1 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSliceMut2x1<'a, T, RStride = U1, CStride = U2> = - Matrix>; + Matrix>; /// A column-major 2x3 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSliceMut2x3<'a, T, RStride = U1, CStride = U2> = - Matrix>; + Matrix>; /// A column-major 2x4 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSliceMut2x4<'a, T, RStride = U1, CStride = U2> = - Matrix>; + Matrix>; /// A column-major 2x5 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSliceMut2x5<'a, T, RStride = U1, CStride = U2> = - Matrix>; + Matrix>; /// A column-major 2x6 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSliceMut2x6<'a, T, RStride = U1, CStride = U2> = - Matrix>; + Matrix>; /// A column-major 3x1 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSliceMut3x1<'a, T, RStride = U1, CStride = U3> = - Matrix>; + Matrix>; /// A column-major 3x2 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSliceMut3x2<'a, T, RStride = U1, CStride = U3> = - Matrix>; + Matrix>; /// A column-major 3x4 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSliceMut3x4<'a, T, RStride = U1, CStride = U3> = - Matrix>; + Matrix>; /// A column-major 3x5 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSliceMut3x5<'a, T, RStride = U1, CStride = U3> = - Matrix>; + Matrix>; /// A column-major 3x6 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSliceMut3x6<'a, T, RStride = U1, CStride = U3> = - Matrix>; + Matrix>; /// A column-major 4x1 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSliceMut4x1<'a, T, RStride = U1, CStride = U4> = - Matrix>; + Matrix>; /// A column-major 4x2 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSliceMut4x2<'a, T, RStride = U1, CStride = U4> = - Matrix>; + Matrix>; /// A column-major 4x3 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSliceMut4x3<'a, T, RStride = U1, CStride = U4> = - Matrix>; + Matrix>; /// A column-major 4x5 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSliceMut4x5<'a, T, RStride = U1, CStride = U4> = - Matrix>; + Matrix>; /// A column-major 4x6 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSliceMut4x6<'a, T, RStride = U1, CStride = U4> = - Matrix>; + Matrix>; /// A column-major 5x1 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSliceMut5x1<'a, T, RStride = U1, CStride = U5> = - Matrix>; + Matrix>; /// A column-major 5x2 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSliceMut5x2<'a, T, RStride = U1, CStride = U5> = - Matrix>; + Matrix>; /// A column-major 5x3 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSliceMut5x3<'a, T, RStride = U1, CStride = U5> = - Matrix>; + Matrix>; /// A column-major 5x4 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSliceMut5x4<'a, T, RStride = U1, CStride = U5> = - Matrix>; + Matrix>; /// A column-major 5x6 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSliceMut5x6<'a, T, RStride = U1, CStride = U5> = - Matrix>; + Matrix>; /// A column-major 6x1 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSliceMut6x1<'a, T, RStride = U1, CStride = U6> = - Matrix>; + Matrix>; /// A column-major 6x2 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSliceMut6x2<'a, T, RStride = U1, CStride = U6> = - Matrix>; + Matrix>; /// A column-major 6x3 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSliceMut6x3<'a, T, RStride = U1, CStride = U6> = - Matrix>; + Matrix>; /// A column-major 6x4 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSliceMut6x4<'a, T, RStride = U1, CStride = U6> = - Matrix>; + Matrix>; /// A column-major 6x5 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type MatrixSliceMut6x5<'a, T, RStride = U1, CStride = U6> = - Matrix>; + Matrix>; /// A column-major matrix slice with 1 row and a number of columns chosen at runtime. pub type MatrixSliceMut1xX<'a, T, RStride = U1, CStride = U1> = - Matrix>; + Matrix>; /// A column-major matrix slice with 2 rows and a number of columns chosen at runtime. pub type MatrixSliceMut2xX<'a, T, RStride = U1, CStride = U2> = - Matrix>; + Matrix>; /// A column-major matrix slice with 3 rows and a number of columns chosen at runtime. pub type MatrixSliceMut3xX<'a, T, RStride = U1, CStride = U3> = - Matrix>; + Matrix>; /// A column-major matrix slice with 4 rows and a number of columns chosen at runtime. pub type MatrixSliceMut4xX<'a, T, RStride = U1, CStride = U4> = - Matrix>; + Matrix>; /// A column-major matrix slice with 5 rows and a number of columns chosen at runtime. pub type MatrixSliceMut5xX<'a, T, RStride = U1, CStride = U5> = - Matrix>; + Matrix>; /// A column-major matrix slice with 6 rows and a number of columns chosen at runtime. pub type MatrixSliceMut6xX<'a, T, RStride = U1, CStride = U6> = - Matrix>; + Matrix>; /// A column-major matrix slice with a number of rows chosen at runtime and 1 column. pub type MatrixSliceMutXx1<'a, T, RStride = U1, CStride = Dynamic> = - Matrix>; + Matrix>; /// A column-major matrix slice with a number of rows chosen at runtime and 2 columns. pub type MatrixSliceMutXx2<'a, T, RStride = U1, CStride = Dynamic> = - Matrix>; + Matrix>; /// A column-major matrix slice with a number of rows chosen at runtime and 3 columns. pub type MatrixSliceMutXx3<'a, T, RStride = U1, CStride = Dynamic> = - Matrix>; + Matrix>; /// A column-major matrix slice with a number of rows chosen at runtime and 4 columns. pub type MatrixSliceMutXx4<'a, T, RStride = U1, CStride = Dynamic> = - Matrix>; + Matrix>; /// A column-major matrix slice with a number of rows chosen at runtime and 5 columns. pub type MatrixSliceMutXx5<'a, T, RStride = U1, CStride = Dynamic> = - Matrix>; + Matrix>; /// A column-major matrix slice with a number of rows chosen at runtime and 6 columns. pub type MatrixSliceMutXx6<'a, T, RStride = U1, CStride = Dynamic> = - Matrix>; + Matrix>; /// A column vector slice with dimensions known at compile-time. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type VectorSliceMut<'a, T, D, RStride = U1, CStride = D> = - Matrix>; + Matrix>; /// A column vector slice with dimensions known at compile-time. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type SVectorSliceMut<'a, T, const D: usize> = - Matrix, Const<1>, SliceStorageMut<'a, T, Const, Const<1>, Const<1>, Const>>; + Matrix, Const<1>, ViewStorageMut<'a, T, Const, Const<1>, Const<1>, Const>>; /// A column vector slice dynamic numbers of rows and columns. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type DVectorSliceMut<'a, T, RStride = U1, CStride = Dynamic> = - Matrix>; + Matrix>; /// A 1D column vector slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type VectorSliceMut1<'a, T, RStride = U1, CStride = U1> = - Matrix>; + Matrix>; /// A 2D column vector slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type VectorSliceMut2<'a, T, RStride = U1, CStride = U2> = - Matrix>; + Matrix>; /// A 3D column vector slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type VectorSliceMut3<'a, T, RStride = U1, CStride = U3> = - Matrix>; + Matrix>; /// A 4D column vector slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type VectorSliceMut4<'a, T, RStride = U1, CStride = U4> = - Matrix>; + Matrix>; /// A 5D column vector slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type VectorSliceMut5<'a, T, RStride = U1, CStride = U5> = - Matrix>; + Matrix>; /// A 6D column vector slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** pub type VectorSliceMut6<'a, T, RStride = U1, CStride = U6> = - Matrix>; + Matrix>; diff --git a/src/base/construction_slice.rs b/src/base/construction_slice.rs index 7094bdca..aad50685 100644 --- a/src/base/construction_slice.rs +++ b/src/base/construction_slice.rs @@ -1,5 +1,5 @@ use crate::base::dimension::{Const, Dim, DimName, Dynamic}; -use crate::base::matrix_slice::{SliceStorage, SliceStorageMut}; +use crate::base::matrix_slice::{ViewStorage, ViewStorageMut}; use crate::base::{MatrixSlice, MatrixSliceMutMN, Scalar}; use num_rational::Ratio; @@ -22,7 +22,7 @@ impl<'a, T: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim> rstride: RStride, cstride: CStride, ) -> Self { - let data = SliceStorage::from_raw_parts( + let data = ViewStorage::from_raw_parts( data.as_ptr().add(start), (nrows, ncols), (rstride, cstride), @@ -160,7 +160,7 @@ impl<'a, T: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim> rstride: RStride, cstride: CStride, ) -> Self { - let data = SliceStorageMut::from_raw_parts( + let data = ViewStorageMut::from_raw_parts( data.as_mut_ptr().add(start), (nrows, ncols), (rstride, cstride), diff --git a/src/base/conversion.rs b/src/base/conversion.rs index dd71186f..26e624a3 100644 --- a/src/base/conversion.rs +++ b/src/base/conversion.rs @@ -21,7 +21,7 @@ use crate::base::{ }; #[cfg(any(feature = "std", feature = "alloc"))] use crate::base::{DVector, RowDVector, VecStorage}; -use crate::base::{SliceStorage, SliceStorageMut}; +use crate::base::{ViewStorage, ViewStorageMut}; use crate::constraint::DimEq; use crate::{IsNotStaticOne, RowSVector, SMatrix, SVector, VectorSlice, VectorSliceMut}; use std::mem::MaybeUninit; @@ -397,7 +397,7 @@ where let cstride_slice = CStride::from_usize(cstride); unsafe { - let data = SliceStorage::from_raw_parts( + let data = ViewStorage::from_raw_parts( m.data.ptr(), (row_slice, col_slice), (rstride_slice, cstride_slice), @@ -434,7 +434,7 @@ where let cstride_slice = CStride::from_usize(cstride); unsafe { - let data = SliceStorage::from_raw_parts( + let data = ViewStorage::from_raw_parts( m.data.ptr(), (row_slice, col_slice), (rstride_slice, cstride_slice), @@ -471,7 +471,7 @@ where let cstride_slice = CStride::from_usize(cstride); unsafe { - let data = SliceStorageMut::from_raw_parts( + let data = ViewStorageMut::from_raw_parts( m.data.ptr_mut(), (row_slice, col_slice), (rstride_slice, cstride_slice), diff --git a/src/base/indexing.rs b/src/base/indexing.rs index 2c691bd1..5cc64db0 100644 --- a/src/base/indexing.rs +++ b/src/base/indexing.rs @@ -682,13 +682,13 @@ macro_rules! impl_index_pair { #[doc(hidden)] #[inline(always)] unsafe fn get_unchecked(self, matrix: &'a Matrix) -> Self::Output { - use crate::base::SliceStorage; + use crate::base::ViewStorage; let (rows, cols) = self; let (nrows, ncols) = matrix.shape_generic(); let data = - SliceStorage::new_unchecked(&matrix.data, + ViewStorage::new_unchecked(&matrix.data, (rows.lower(nrows), cols.lower(ncols)), (rows.length(nrows), cols.length(ncols))); @@ -710,13 +710,13 @@ macro_rules! impl_index_pair { #[doc(hidden)] #[inline(always)] unsafe fn get_unchecked_mut(self, matrix: &'a mut Matrix) -> Self::OutputMut { - use crate::base::SliceStorageMut; + use crate::base::ViewStorageMut; let (rows, cols) = self; let (nrows, ncols) = matrix.shape_generic(); let data = - SliceStorageMut::new_unchecked(&mut matrix.data, + ViewStorageMut::new_unchecked(&mut matrix.data, (rows.lower(nrows), cols.lower(ncols)), (rows.length(nrows), cols.length(ncols))); diff --git a/src/base/matrix_slice.rs b/src/base/matrix_slice.rs index 5fbd4b01..be646cee 100644 --- a/src/base/matrix_slice.rs +++ b/src/base/matrix_slice.rs @@ -9,17 +9,28 @@ use crate::base::iter::MatrixIter; use crate::base::storage::{IsContiguous, Owned, RawStorage, RawStorageMut, Storage}; use crate::base::{Matrix, Scalar}; -macro_rules! slice_storage_impl( - ($doc: expr; $Storage: ident as $SRef: ty; $T: ident.$get_addr: ident ($Ptr: ty as $Ref: ty)) => { +macro_rules! view_storage_impl ( + ($doc: expr; $Storage: ident as $SRef: ty; $legacy_name:ident => $T: ident.$get_addr: ident ($Ptr: ty as $Ref: ty)) => { #[doc = $doc] #[derive(Debug)] - pub struct $T<'a, T, R: Dim, C: Dim, RStride: Dim, CStride: Dim> { + pub struct $T<'a, T, R: Dim, C: Dim, RStride: Dim, CStride: Dim> { ptr: $Ptr, shape: (R, C), strides: (RStride, CStride), _phantoms: PhantomData<$Ref>, } + #[doc = $doc] + /// + /// This type alias exists only for legacy purposes and is deprecated. It will be removed + /// in a future release. Please use + /// [` + #[doc = stringify!($T)] + /// `] instead. See [issue #1076](https://github.com/dimforge/nalgebra/issues/1076) + /// for the rationale. + #[deprecated = "Use ViewStorage(Mut) instead."] + pub type $legacy_name<'a, T, R, C, RStride, CStride> = $T<'a, T, R, C, RStride, CStride>; + unsafe impl<'a, T: Send, R: Dim, C: Dim, RStride: Dim, CStride: Dim> Send for $T<'a, T, R, C, RStride, CStride> {} @@ -29,7 +40,7 @@ macro_rules! slice_storage_impl( {} impl<'a, T, R: Dim, C: Dim, RStride: Dim, CStride: Dim> $T<'a, T, R, C, RStride, CStride> { - /// Create a new matrix slice without bound checking and from a raw pointer. + /// Create a new matrix view without bounds checking and from a raw pointer. #[inline] pub unsafe fn from_raw_parts(ptr: $Ptr, shape: (R, C), @@ -49,7 +60,7 @@ macro_rules! slice_storage_impl( // Dynamic is arbitrary. It's just to be able to call the constructors with `Slice::` impl<'a, T, R: Dim, C: Dim> $T<'a, T, R, C, Dynamic, Dynamic> { - /// Create a new matrix slice without bound checking. + /// Create a new matrix view without bounds checking. #[inline] pub unsafe fn new_unchecked(storage: $SRef, start: (usize, usize), shape: (R, C)) -> $T<'a, T, R, C, S::RStride, S::CStride> @@ -61,7 +72,7 @@ macro_rules! slice_storage_impl( $T::new_with_strides_unchecked(storage, start, shape, strides) } - /// Create a new matrix slice without bound checking. + /// Create a new matrix view without bounds checking. #[inline] pub unsafe fn new_with_strides_unchecked(storage: $SRef, start: (usize, usize), @@ -82,7 +93,7 @@ macro_rules! slice_storage_impl( where Self: RawStorage + IsContiguous { - /// Extracts the original slice from this storage + /// Extracts the original slice from this storage. pub fn into_slice(self) -> &'a [T] { let (nrows, ncols) = self.shape(); if nrows.value() != 0 && ncols.value() != 0 { @@ -96,22 +107,22 @@ macro_rules! slice_storage_impl( } ); -slice_storage_impl!("A matrix data storage for a matrix slice. Only contains an internal reference \ +view_storage_impl!("A matrix data storage for a matrix view. Only contains an internal reference \ to another matrix data storage."; - RawStorage as &'a S; SliceStorage.get_address_unchecked(*const T as &'a T)); + RawStorage as &'a S; SliceStorage => ViewStorage.get_address_unchecked(*const T as &'a T)); -slice_storage_impl!("A mutable matrix data storage for mutable matrix slice. Only contains an \ +view_storage_impl!("A mutable matrix data storage for mutable matrix view. Only contains an \ internal mutable reference to another matrix data storage."; - RawStorageMut as &'a mut S; SliceStorageMut.get_address_unchecked_mut(*mut T as &'a mut T) + RawStorageMut as &'a mut S; SliceStorageMut => ViewStorageMut.get_address_unchecked_mut(*mut T as &'a mut T) ); impl<'a, T: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim> Copy - for SliceStorage<'a, T, R, C, RStride, CStride> + for ViewStorage<'a, T, R, C, RStride, CStride> { } impl<'a, T: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim> Clone - for SliceStorage<'a, T, R, C, RStride, CStride> + for ViewStorage<'a, T, R, C, RStride, CStride> { #[inline] fn clone(&self) -> Self { @@ -125,7 +136,7 @@ impl<'a, T: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim> Clone } impl<'a, T: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim> - SliceStorageMut<'a, T, R, C, RStride, CStride> + ViewStorageMut<'a, T, R, C, RStride, CStride> where Self: RawStorageMut + IsContiguous, { @@ -212,10 +223,10 @@ macro_rules! storage_impl( )*} ); -storage_impl!(SliceStorage, SliceStorageMut); +storage_impl!(ViewStorage, ViewStorageMut); unsafe impl<'a, T, R: Dim, C: Dim, RStride: Dim, CStride: Dim> RawStorageMut - for SliceStorageMut<'a, T, R, C, RStride, CStride> + for ViewStorageMut<'a, T, R, C, RStride, CStride> { #[inline] fn ptr_mut(&mut self) -> *mut T { @@ -234,18 +245,18 @@ unsafe impl<'a, T, R: Dim, C: Dim, RStride: Dim, CStride: Dim> RawStorageMut IsContiguous for SliceStorage<'a, T, R, U1, U1, CStride> {} +unsafe impl<'a, T, R: Dim, CStride: Dim> IsContiguous for ViewStorage<'a, T, R, U1, U1, CStride> {} unsafe impl<'a, T, R: Dim, CStride: Dim> IsContiguous - for SliceStorageMut<'a, T, R, U1, U1, CStride> + for ViewStorageMut<'a, T, R, U1, U1, CStride> { } unsafe impl<'a, T, R: DimName, C: Dim + IsNotStaticOne> IsContiguous - for SliceStorage<'a, T, R, C, U1, R> + for ViewStorage<'a, T, R, C, U1, R> { } unsafe impl<'a, T, R: DimName, C: Dim + IsNotStaticOne> IsContiguous - for SliceStorageMut<'a, T, R, C, U1, R> + for ViewStorageMut<'a, T, R, C, U1, R> { } @@ -273,8 +284,8 @@ impl> Matrix { } } -macro_rules! matrix_slice_impl( - ($me: ident: $Me: ty, $MatrixSlice: ident, $SliceStorage: ident, $Storage: ident.$get_addr: ident (), $data: expr; +macro_rules! matrix_slice_impl ( + ($me: ident: $Me: ty, $MatrixSlice: ident, $ViewStorage: ident, $Storage: ident.$get_addr: ident (), $data: expr; $row: ident, $row_part: ident, $rows: ident, @@ -361,7 +372,7 @@ macro_rules! matrix_slice_impl( let shape = (nrows, my_shape.1); unsafe { - let data = $SliceStorage::new_unchecked($data, (row_start, 0), shape); + let data = $ViewStorage::new_unchecked($data, (row_start, 0), shape); Matrix::from_data_statically_unchecked(data) } } @@ -381,7 +392,7 @@ macro_rules! matrix_slice_impl( let shape = (nrows, my_shape.1); unsafe { - let data = $SliceStorage::new_with_strides_unchecked($data, (row_start, 0), shape, strides); + let data = $ViewStorage::new_with_strides_unchecked($data, (row_start, 0), shape, strides); Matrix::from_data_statically_unchecked(data) } } @@ -448,7 +459,7 @@ macro_rules! matrix_slice_impl( let shape = (my_shape.0, ncols); unsafe { - let data = $SliceStorage::new_unchecked($data, (0, first_col), shape); + let data = $ViewStorage::new_unchecked($data, (0, first_col), shape); Matrix::from_data_statically_unchecked(data) } } @@ -469,7 +480,7 @@ macro_rules! matrix_slice_impl( let shape = (my_shape.0, ncols); unsafe { - let data = $SliceStorage::new_with_strides_unchecked($data, (0, first_col), shape, strides); + let data = $ViewStorage::new_with_strides_unchecked($data, (0, first_col), shape, strides); Matrix::from_data_statically_unchecked(data) } } @@ -489,7 +500,7 @@ macro_rules! matrix_slice_impl( let shape = (Dynamic::new(shape.0), Dynamic::new(shape.1)); unsafe { - let data = $SliceStorage::new_unchecked($data, start, shape); + let data = $ViewStorage::new_unchecked($data, start, shape); Matrix::from_data_statically_unchecked(data) } } @@ -517,7 +528,7 @@ macro_rules! matrix_slice_impl( let shape = (Const::, Const::); unsafe { - let data = $SliceStorage::new_unchecked($data, (irow, icol), shape); + let data = $ViewStorage::new_unchecked($data, (irow, icol), shape); Matrix::from_data_statically_unchecked(data) } } @@ -543,7 +554,7 @@ macro_rules! matrix_slice_impl( $me.assert_slice_index(start, (shape.0.value(), shape.1.value()), (0, 0)); unsafe { - let data = $SliceStorage::new_unchecked($data, start, shape); + let data = $ViewStorage::new_unchecked($data, start, shape); Matrix::from_data_statically_unchecked(data) } } @@ -565,7 +576,7 @@ macro_rules! matrix_slice_impl( Dynamic::new((steps.1 + 1) * my_strides.1.value())); unsafe { - let data = $SliceStorage::new_with_strides_unchecked($data, start, shape, strides); + let data = $ViewStorage::new_with_strides_unchecked($data, start, shape, strides); Matrix::from_data_statically_unchecked(data) } } @@ -602,8 +613,8 @@ macro_rules! matrix_slice_impl( let ptr1 = $data.$get_addr(start1, 0); let ptr2 = $data.$get_addr(start2, 0); - let data1 = $SliceStorage::from_raw_parts(ptr1, (nrows1, ncols), strides); - let data2 = $SliceStorage::from_raw_parts(ptr2, (nrows2, ncols), strides); + let data1 = $ViewStorage::from_raw_parts(ptr1, (nrows1, ncols), strides); + let data2 = $ViewStorage::from_raw_parts(ptr2, (nrows2, ncols), strides); let slice1 = Matrix::from_data_statically_unchecked(data1); let slice2 = Matrix::from_data_statically_unchecked(data2); @@ -638,8 +649,8 @@ macro_rules! matrix_slice_impl( let ptr1 = $data.$get_addr(0, start1); let ptr2 = $data.$get_addr(0, start2); - let data1 = $SliceStorage::from_raw_parts(ptr1, (nrows, ncols1), strides); - let data2 = $SliceStorage::from_raw_parts(ptr2, (nrows, ncols2), strides); + let data1 = $ViewStorage::from_raw_parts(ptr1, (nrows, ncols1), strides); + let data2 = $ViewStorage::from_raw_parts(ptr2, (nrows, ncols2), strides); let slice1 = Matrix::from_data_statically_unchecked(data1); let slice2 = Matrix::from_data_statically_unchecked(data2); @@ -651,15 +662,15 @@ macro_rules! matrix_slice_impl( /// A matrix slice. pub type MatrixSlice<'a, T, R, C, RStride = U1, CStride = R> = - Matrix>; + Matrix>; /// A mutable matrix slice. pub type MatrixSliceMut<'a, T, R, C, RStride = U1, CStride = R> = - Matrix>; + Matrix>; /// # Slicing based on index and length impl> Matrix { matrix_slice_impl!( - self: &Self, MatrixSlice, SliceStorage, RawStorage.get_address_unchecked(), &self.data; + self: &Self, MatrixSlice, ViewStorage, RawStorage.get_address_unchecked(), &self.data; row, row_part, rows, @@ -689,7 +700,7 @@ impl> Matrix { /// # Mutable slicing based on index and length impl> Matrix { matrix_slice_impl!( - self: &mut Self, MatrixSliceMut, SliceStorageMut, RawStorageMut.get_address_unchecked_mut(), &mut self.data; + self: &mut Self, MatrixSliceMut, ViewStorageMut, RawStorageMut.get_address_unchecked_mut(), &mut self.data; row_mut, row_part_mut, rows_mut, @@ -943,7 +954,7 @@ where CStride: Dim, { fn from(slice_mut: MatrixSliceMut<'a, T, R, C, RStride, CStride>) -> Self { - let data = SliceStorage { + let data = ViewStorage { ptr: slice_mut.data.ptr, shape: slice_mut.data.shape, strides: slice_mut.data.strides, From 29bff32d2dc3050a758d70c13e8d4b89e1f6a3e3 Mon Sep 17 00:00:00 2001 From: Andreas Longva Date: Fri, 11 Nov 2022 16:10:39 +0100 Subject: [PATCH 02/22] Rename MatrixSlice(Mut) to MatrixView(Mut) Additionally introduce deprecated type aliases with the old names to avoid a breaking change. --- src/base/construction_slice.rs | 10 ++-- src/base/conversion.rs | 42 +++++++-------- src/base/indexing.rs | 6 +-- src/base/iter.rs | 10 ++-- src/base/matrix_slice.rs | 97 +++++++++++++++++++++------------- src/geometry/quaternion.rs | 6 +-- 6 files changed, 96 insertions(+), 75 deletions(-) diff --git a/src/base/construction_slice.rs b/src/base/construction_slice.rs index aad50685..e54d824c 100644 --- a/src/base/construction_slice.rs +++ b/src/base/construction_slice.rs @@ -1,12 +1,12 @@ use crate::base::dimension::{Const, Dim, DimName, Dynamic}; use crate::base::matrix_slice::{ViewStorage, ViewStorageMut}; -use crate::base::{MatrixSlice, MatrixSliceMutMN, Scalar}; +use crate::base::{MatrixView, MatrixSliceMutMN, Scalar}; use num_rational::Ratio; /// # Creating matrix slices from `&[T]` impl<'a, T: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim> - MatrixSlice<'a, T, R, C, RStride, CStride> + MatrixView<'a, T, R, C, RStride, CStride> { /// Creates, without bound-checking, a matrix slice from an array and with dimensions and strides specified by generic types instances. /// @@ -57,7 +57,7 @@ impl<'a, T: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim> } } -impl<'a, T: Scalar, R: Dim, C: Dim> MatrixSlice<'a, T, R, C> { +impl<'a, T: Scalar, R: Dim, C: Dim> MatrixView<'a, T, R, C> { /// Creates, without bound-checking, a matrix slice from an array and with dimensions specified by generic types instances. /// /// # Safety @@ -87,7 +87,7 @@ impl<'a, T: Scalar, R: Dim, C: Dim> MatrixSlice<'a, T, R, C> { macro_rules! impl_constructors( ($($Dims: ty),*; $(=> $DimIdent: ident: $DimBound: ident),*; $($gargs: expr),*; $($args: ident),*) => { - impl<'a, T: Scalar, $($DimIdent: $DimBound),*> MatrixSlice<'a, T, $($Dims),*> { + impl<'a, T: Scalar, $($DimIdent: $DimBound),*> MatrixView<'a, T, $($Dims),*> { /// Creates a new matrix slice from the given data array. /// /// Panics if `data` does not contain enough elements. @@ -103,7 +103,7 @@ macro_rules! impl_constructors( } } - impl<'a, T: Scalar, $($DimIdent: $DimBound, )*> MatrixSlice<'a, T, $($Dims,)* Dynamic, Dynamic> { + impl<'a, T: Scalar, $($DimIdent: $DimBound, )*> MatrixView<'a, T, $($Dims,)* Dynamic, Dynamic> { /// Creates a new matrix slice with the specified strides from the given data array. /// /// Panics if `data` does not contain enough elements. diff --git a/src/base/conversion.rs b/src/base/conversion.rs index 26e624a3..9b6df2c2 100644 --- a/src/base/conversion.rs +++ b/src/base/conversion.rs @@ -16,8 +16,8 @@ use crate::base::dimension::{ use crate::base::iter::{MatrixIter, MatrixIterMut}; use crate::base::storage::{IsContiguous, RawStorage, RawStorageMut}; use crate::base::{ - ArrayStorage, DVectorSlice, DVectorSliceMut, DefaultAllocator, Matrix, MatrixSlice, - MatrixSliceMut, OMatrix, Scalar, + ArrayStorage, DVectorSlice, DVectorSliceMut, DefaultAllocator, Matrix, MatrixView, + MatrixViewMut, OMatrix, Scalar, }; #[cfg(any(feature = "std", feature = "alloc"))] use crate::base::{DVector, RowDVector, VecStorage}; @@ -221,19 +221,19 @@ impl From> for [[T; } impl<'a, T: Scalar, RStride: Dim, CStride: Dim, const R: usize, const C: usize> - From, Const, RStride, CStride>> for [[T; R]; C] + From, Const, RStride, CStride>> for [[T; R]; C] { #[inline] - fn from(mat: MatrixSlice<'a, T, Const, Const, RStride, CStride>) -> Self { + fn from(mat: MatrixView<'a, T, Const, Const, RStride, CStride>) -> Self { mat.into_owned().into() } } impl<'a, T: Scalar, RStride: Dim, CStride: Dim, const R: usize, const C: usize> - From, Const, RStride, CStride>> for [[T; R]; C] + From, Const, RStride, CStride>> for [[T; R]; C] { #[inline] - fn from(mat: MatrixSliceMut<'a, T, Const, Const, RStride, CStride>) -> Self { + fn from(mat: MatrixViewMut<'a, T, Const, Const, RStride, CStride>) -> Self { mat.into_owned().into() } } @@ -289,20 +289,20 @@ impl_from_into_asref_borrow_2D!( ); impl<'a, T, RStride, CStride, const R: usize, const C: usize> - From, Const, RStride, CStride>> + From, Const, RStride, CStride>> for Matrix, Const, ArrayStorage> where T: Scalar, RStride: Dim, CStride: Dim, { - fn from(matrix_slice: MatrixSlice<'a, T, Const, Const, RStride, CStride>) -> Self { + fn from(matrix_slice: MatrixView<'a, T, Const, Const, RStride, CStride>) -> Self { matrix_slice.into_owned() } } #[cfg(any(feature = "std", feature = "alloc"))] -impl<'a, T, C, RStride, CStride> From> +impl<'a, T, C, RStride, CStride> From> for Matrix> where T: Scalar, @@ -310,13 +310,13 @@ where RStride: Dim, CStride: Dim, { - fn from(matrix_slice: MatrixSlice<'a, T, Dynamic, C, RStride, CStride>) -> Self { + fn from(matrix_slice: MatrixView<'a, T, Dynamic, C, RStride, CStride>) -> Self { matrix_slice.into_owned() } } #[cfg(any(feature = "std", feature = "alloc"))] -impl<'a, T, R, RStride, CStride> From> +impl<'a, T, R, RStride, CStride> From> for Matrix> where T: Scalar, @@ -324,26 +324,26 @@ where RStride: Dim, CStride: Dim, { - fn from(matrix_slice: MatrixSlice<'a, T, R, Dynamic, RStride, CStride>) -> Self { + fn from(matrix_slice: MatrixView<'a, T, R, Dynamic, RStride, CStride>) -> Self { matrix_slice.into_owned() } } impl<'a, T, RStride, CStride, const R: usize, const C: usize> - From, Const, RStride, CStride>> + From, Const, RStride, CStride>> for Matrix, Const, ArrayStorage> where T: Scalar, RStride: Dim, CStride: Dim, { - fn from(matrix_slice: MatrixSliceMut<'a, T, Const, Const, RStride, CStride>) -> Self { + fn from(matrix_slice: MatrixViewMut<'a, T, Const, Const, RStride, CStride>) -> Self { matrix_slice.into_owned() } } #[cfg(any(feature = "std", feature = "alloc"))] -impl<'a, T, C, RStride, CStride> From> +impl<'a, T, C, RStride, CStride> From> for Matrix> where T: Scalar, @@ -351,13 +351,13 @@ where RStride: Dim, CStride: Dim, { - fn from(matrix_slice: MatrixSliceMut<'a, T, Dynamic, C, RStride, CStride>) -> Self { + fn from(matrix_slice: MatrixViewMut<'a, T, Dynamic, C, RStride, CStride>) -> Self { matrix_slice.into_owned() } } #[cfg(any(feature = "std", feature = "alloc"))] -impl<'a, T, R, RStride, CStride> From> +impl<'a, T, R, RStride, CStride> From> for Matrix> where T: Scalar, @@ -365,13 +365,13 @@ where RStride: Dim, CStride: Dim, { - fn from(matrix_slice: MatrixSliceMut<'a, T, R, Dynamic, RStride, CStride>) -> Self { + fn from(matrix_slice: MatrixViewMut<'a, T, R, Dynamic, RStride, CStride>) -> Self { matrix_slice.into_owned() } } impl<'a, T, R, C, RSlice, CSlice, RStride, CStride, S> From<&'a Matrix> - for MatrixSlice<'a, T, RSlice, CSlice, RStride, CStride> + for MatrixView<'a, T, RSlice, CSlice, RStride, CStride> where T: Scalar, R: Dim, @@ -408,7 +408,7 @@ where } impl<'a, T, R, C, RSlice, CSlice, RStride, CStride, S> From<&'a mut Matrix> - for MatrixSlice<'a, T, RSlice, CSlice, RStride, CStride> + for MatrixView<'a, T, RSlice, CSlice, RStride, CStride> where T: Scalar, R: Dim, @@ -445,7 +445,7 @@ where } impl<'a, T, R, C, RSlice, CSlice, RStride, CStride, S> From<&'a mut Matrix> - for MatrixSliceMut<'a, T, RSlice, CSlice, RStride, CStride> + for MatrixViewMut<'a, T, RSlice, CSlice, RStride, CStride> where T: Scalar, R: Dim, diff --git a/src/base/indexing.rs b/src/base/indexing.rs index 5cc64db0..df769163 100644 --- a/src/base/indexing.rs +++ b/src/base/indexing.rs @@ -3,7 +3,7 @@ use crate::base::storage::{RawStorage, RawStorageMut}; use crate::base::{ - Const, Dim, DimDiff, DimName, DimSub, Dynamic, Matrix, MatrixSlice, MatrixSliceMut, Scalar, U1, + Const, Dim, DimDiff, DimName, DimSub, Dynamic, Matrix, MatrixView, MatrixViewMut, Scalar, U1, }; use std::ops; @@ -669,7 +669,7 @@ macro_rules! impl_index_pair { $( $RConstraintType: $RConstraintBound $(<$( $RConstraintBoundParams $( = $REqBound )*),*>)* ,)* $( $CConstraintType: $CConstraintBound $(<$( $CConstraintBoundParams $( = $CEqBound )*),*>)* ),* { - type Output = MatrixSlice<'a, T, $ROut, $COut, S::RStride, S::CStride>; + type Output = MatrixView<'a, T, $ROut, $COut, S::RStride, S::CStride>; #[doc(hidden)] #[inline(always)] @@ -705,7 +705,7 @@ macro_rules! impl_index_pair { $( $RConstraintType: $RConstraintBound $(<$( $RConstraintBoundParams $( = $REqBound )*),*>)* ,)* $( $CConstraintType: $CConstraintBound $(<$( $CConstraintBoundParams $( = $CEqBound )*),*>)* ),* { - type OutputMut = MatrixSliceMut<'a, T, $ROut, $COut, S::RStride, S::CStride>; + type OutputMut = MatrixViewMut<'a, T, $ROut, $COut, S::RStride, S::CStride>; #[doc(hidden)] #[inline(always)] diff --git a/src/base/iter.rs b/src/base/iter.rs index b68e1051..991c24dc 100644 --- a/src/base/iter.rs +++ b/src/base/iter.rs @@ -6,7 +6,7 @@ use std::mem; use crate::base::dimension::{Dim, U1}; use crate::base::storage::{RawStorage, RawStorageMut}; -use crate::base::{Matrix, MatrixSlice, MatrixSliceMut, Scalar}; +use crate::base::{Matrix, MatrixView, MatrixViewMut, Scalar}; macro_rules! iterator { (struct $Name:ident for $Storage:ident.$ptr: ident -> $Ptr:ty, $Ref:ty, $SRef: ty) => { @@ -193,7 +193,7 @@ impl<'a, T, R: Dim, C: Dim, S: 'a + RawStorage> RowIter<'a, T, R, C, S> } impl<'a, T, R: Dim, C: Dim, S: 'a + RawStorage> Iterator for RowIter<'a, T, R, C, S> { - type Item = MatrixSlice<'a, T, U1, C, S::RStride, S::CStride>; + type Item = MatrixView<'a, T, U1, C, S::RStride, S::CStride>; #[inline] fn next(&mut self) -> Option { @@ -254,7 +254,7 @@ impl<'a, T, R: Dim, C: Dim, S: 'a + RawStorageMut> RowIterMut<'a, T, R, impl<'a, T, R: Dim, C: Dim, S: 'a + RawStorageMut> Iterator for RowIterMut<'a, T, R, C, S> { - type Item = MatrixSliceMut<'a, T, U1, C, S::RStride, S::CStride>; + type Item = MatrixViewMut<'a, T, U1, C, S::RStride, S::CStride>; #[inline] fn next(&mut self) -> Option { @@ -306,7 +306,7 @@ impl<'a, T, R: Dim, C: Dim, S: 'a + RawStorage> ColumnIter<'a, T, R, C, } impl<'a, T, R: Dim, C: Dim, S: 'a + RawStorage> Iterator for ColumnIter<'a, T, R, C, S> { - type Item = MatrixSlice<'a, T, R, U1, S::RStride, S::CStride>; + type Item = MatrixView<'a, T, R, U1, S::RStride, S::CStride>; #[inline] fn next(&mut self) -> Option { @@ -367,7 +367,7 @@ impl<'a, T, R: Dim, C: Dim, S: 'a + RawStorageMut> ColumnIterMut<'a, T, impl<'a, T, R: Dim, C: Dim, S: 'a + RawStorageMut> Iterator for ColumnIterMut<'a, T, R, C, S> { - type Item = MatrixSliceMut<'a, T, R, U1, S::RStride, S::CStride>; + type Item = MatrixViewMut<'a, T, R, U1, S::RStride, S::CStride>; #[inline] fn next(&mut self) -> Option { diff --git a/src/base/matrix_slice.rs b/src/base/matrix_slice.rs index be646cee..03d06778 100644 --- a/src/base/matrix_slice.rs +++ b/src/base/matrix_slice.rs @@ -285,7 +285,7 @@ impl> Matrix { } macro_rules! matrix_slice_impl ( - ($me: ident: $Me: ty, $MatrixSlice: ident, $ViewStorage: ident, $Storage: ident.$get_addr: ident (), $data: expr; + ($me: ident: $Me: ty, $MatrixView: ident, $ViewStorage: ident, $Storage: ident.$get_addr: ident (), $data: expr; $row: ident, $row_part: ident, $rows: ident, @@ -317,20 +317,20 @@ macro_rules! matrix_slice_impl ( */ /// Returns a slice containing the i-th row of this matrix. #[inline] - pub fn $row($me: $Me, i: usize) -> $MatrixSlice<'_, T, U1, C, S::RStride, S::CStride> { + pub fn $row($me: $Me, i: usize) -> $MatrixView<'_, T, U1, C, S::RStride, S::CStride> { $me.$fixed_rows::<1>(i) } /// Returns a slice containing the `n` first elements of the i-th row of this matrix. #[inline] - pub fn $row_part($me: $Me, i: usize, n: usize) -> $MatrixSlice<'_, T, U1, Dynamic, S::RStride, S::CStride> { + pub fn $row_part($me: $Me, i: usize, n: usize) -> $MatrixView<'_, T, U1, Dynamic, S::RStride, S::CStride> { $me.$generic_slice((i, 0), (Const::<1>, Dynamic::new(n))) } /// Extracts from this matrix a set of consecutive rows. #[inline] pub fn $rows($me: $Me, first_row: usize, nrows: usize) - -> $MatrixSlice<'_, T, Dynamic, C, S::RStride, S::CStride> { + -> $MatrixView<'_, T, Dynamic, C, S::RStride, S::CStride> { $me.$rows_generic(first_row, Dynamic::new(nrows)) } @@ -338,7 +338,7 @@ macro_rules! matrix_slice_impl ( /// Extracts from this matrix a set of consecutive rows regularly skipping `step` rows. #[inline] pub fn $rows_with_step($me: $Me, first_row: usize, nrows: usize, step: usize) - -> $MatrixSlice<'_, T, Dynamic, C, Dynamic, S::CStride> { + -> $MatrixView<'_, T, Dynamic, C, Dynamic, S::CStride> { $me.$rows_generic_with_step(first_row, Dynamic::new(nrows), step) } @@ -346,7 +346,7 @@ macro_rules! matrix_slice_impl ( /// Extracts a compile-time number of consecutive rows from this matrix. #[inline] pub fn $fixed_rows($me: $Me, first_row: usize) - -> $MatrixSlice<'_, T, Const, C, S::RStride, S::CStride> { + -> $MatrixView<'_, T, Const, C, S::RStride, S::CStride> { $me.$rows_generic(first_row, Const::) } @@ -355,7 +355,7 @@ macro_rules! matrix_slice_impl ( /// rows. #[inline] pub fn $fixed_rows_with_step($me: $Me, first_row: usize, step: usize) - -> $MatrixSlice<'_, T, Const, C, Dynamic, S::CStride> { + -> $MatrixView<'_, T, Const, C, Dynamic, S::CStride> { $me.$rows_generic_with_step(first_row, Const::, step) } @@ -364,7 +364,7 @@ macro_rules! matrix_slice_impl ( /// argument may or may not be values known at compile-time. #[inline] pub fn $rows_generic($me: $Me, row_start: usize, nrows: RSlice) - -> $MatrixSlice<'_, T, RSlice, C, S::RStride, S::CStride> { + -> $MatrixView<'_, T, RSlice, C, S::RStride, S::CStride> { let my_shape = $me.shape_generic(); $me.assert_slice_index((row_start, 0), (nrows.value(), my_shape.1.value()), (0, 0)); @@ -381,7 +381,7 @@ macro_rules! matrix_slice_impl ( /// argument may or may not be values known at compile-time. #[inline] pub fn $rows_generic_with_step($me: $Me, row_start: usize, nrows: RSlice, step: usize) - -> $MatrixSlice<'_, T, RSlice, C, Dynamic, S::CStride> + -> $MatrixView<'_, T, RSlice, C, Dynamic, S::CStride> where RSlice: Dim { let my_shape = $me.shape_generic(); @@ -404,20 +404,20 @@ macro_rules! matrix_slice_impl ( */ /// Returns a slice containing the i-th column of this matrix. #[inline] - pub fn $column($me: $Me, i: usize) -> $MatrixSlice<'_, T, R, U1, S::RStride, S::CStride> { + pub fn $column($me: $Me, i: usize) -> $MatrixView<'_, T, R, U1, S::RStride, S::CStride> { $me.$fixed_columns::<1>(i) } /// Returns a slice containing the `n` first elements of the i-th column of this matrix. #[inline] - pub fn $column_part($me: $Me, i: usize, n: usize) -> $MatrixSlice<'_, T, Dynamic, U1, S::RStride, S::CStride> { + pub fn $column_part($me: $Me, i: usize, n: usize) -> $MatrixView<'_, T, Dynamic, U1, S::RStride, S::CStride> { $me.$generic_slice((0, i), (Dynamic::new(n), Const::<1>)) } /// Extracts from this matrix a set of consecutive columns. #[inline] pub fn $columns($me: $Me, first_col: usize, ncols: usize) - -> $MatrixSlice<'_, T, R, Dynamic, S::RStride, S::CStride> { + -> $MatrixView<'_, T, R, Dynamic, S::RStride, S::CStride> { $me.$columns_generic(first_col, Dynamic::new(ncols)) } @@ -426,7 +426,7 @@ macro_rules! matrix_slice_impl ( /// columns. #[inline] pub fn $columns_with_step($me: $Me, first_col: usize, ncols: usize, step: usize) - -> $MatrixSlice<'_, T, R, Dynamic, S::RStride, Dynamic> { + -> $MatrixView<'_, T, R, Dynamic, S::RStride, Dynamic> { $me.$columns_generic_with_step(first_col, Dynamic::new(ncols), step) } @@ -434,7 +434,7 @@ macro_rules! matrix_slice_impl ( /// Extracts a compile-time number of consecutive columns from this matrix. #[inline] pub fn $fixed_columns($me: $Me, first_col: usize) - -> $MatrixSlice<'_, T, R, Const, S::RStride, S::CStride> { + -> $MatrixView<'_, T, R, Const, S::RStride, S::CStride> { $me.$columns_generic(first_col, Const::) } @@ -443,7 +443,7 @@ macro_rules! matrix_slice_impl ( /// `step` columns. #[inline] pub fn $fixed_columns_with_step($me: $Me, first_col: usize, step: usize) - -> $MatrixSlice<'_, T, R, Const, S::RStride, Dynamic> { + -> $MatrixView<'_, T, R, Const, S::RStride, Dynamic> { $me.$columns_generic_with_step(first_col, Const::, step) } @@ -452,7 +452,7 @@ macro_rules! matrix_slice_impl ( /// known at compile-time. #[inline] pub fn $columns_generic($me: $Me, first_col: usize, ncols: CSlice) - -> $MatrixSlice<'_, T, R, CSlice, S::RStride, S::CStride> { + -> $MatrixView<'_, T, R, CSlice, S::RStride, S::CStride> { let my_shape = $me.shape_generic(); $me.assert_slice_index((0, first_col), (my_shape.0.value(), ncols.value()), (0, 0)); @@ -469,7 +469,7 @@ macro_rules! matrix_slice_impl ( /// or may not be values known at compile-time. #[inline] pub fn $columns_generic_with_step($me: $Me, first_col: usize, ncols: CSlice, step: usize) - -> $MatrixSlice<'_, T, R, CSlice, S::RStride, Dynamic> { + -> $MatrixView<'_, T, R, CSlice, S::RStride, Dynamic> { let my_shape = $me.shape_generic(); let my_strides = $me.data.strides(); @@ -494,7 +494,7 @@ macro_rules! matrix_slice_impl ( /// consecutive elements. #[inline] pub fn $slice($me: $Me, start: (usize, usize), shape: (usize, usize)) - -> $MatrixSlice<'_, T, Dynamic, Dynamic, S::RStride, S::CStride> { + -> $MatrixView<'_, T, Dynamic, Dynamic, S::RStride, S::CStride> { $me.assert_slice_index(start, shape, (0, 0)); let shape = (Dynamic::new(shape.0), Dynamic::new(shape.1)); @@ -512,7 +512,7 @@ macro_rules! matrix_slice_impl ( /// original matrix. #[inline] pub fn $slice_with_steps($me: $Me, start: (usize, usize), shape: (usize, usize), steps: (usize, usize)) - -> $MatrixSlice<'_, T, Dynamic, Dynamic, Dynamic, Dynamic> { + -> $MatrixView<'_, T, Dynamic, Dynamic, Dynamic, Dynamic> { let shape = (Dynamic::new(shape.0), Dynamic::new(shape.1)); $me.$generic_slice_with_steps(start, shape, steps) @@ -522,7 +522,7 @@ macro_rules! matrix_slice_impl ( /// CSlice::dim())` consecutive components. #[inline] pub fn $fixed_slice($me: $Me, irow: usize, icol: usize) - -> $MatrixSlice<'_, T, Const, Const, S::RStride, S::CStride> { + -> $MatrixView<'_, T, Const, Const, S::RStride, S::CStride> { $me.assert_slice_index((irow, icol), (RSLICE, CSLICE), (0, 0)); let shape = (Const::, Const::); @@ -539,7 +539,7 @@ macro_rules! matrix_slice_impl ( /// the original matrix. #[inline] pub fn $fixed_slice_with_steps($me: $Me, start: (usize, usize), steps: (usize, usize)) - -> $MatrixSlice<'_, T, Const, Const, Dynamic, Dynamic> { + -> $MatrixView<'_, T, Const, Const, Dynamic, Dynamic> { let shape = (Const::, Const::); $me.$generic_slice_with_steps(start, shape, steps) } @@ -547,7 +547,7 @@ macro_rules! matrix_slice_impl ( /// Creates a slice that may or may not have a fixed size and stride. #[inline] pub fn $generic_slice($me: $Me, start: (usize, usize), shape: (RSlice, CSlice)) - -> $MatrixSlice<'_, T, RSlice, CSlice, S::RStride, S::CStride> + -> $MatrixView<'_, T, RSlice, CSlice, S::RStride, S::CStride> where RSlice: Dim, CSlice: Dim { @@ -565,7 +565,7 @@ macro_rules! matrix_slice_impl ( start: (usize, usize), shape: (RSlice, CSlice), steps: (usize, usize)) - -> $MatrixSlice<'_, T, RSlice, CSlice, Dynamic, Dynamic> + -> $MatrixView<'_, T, RSlice, CSlice, Dynamic, Dynamic> where RSlice: Dim, CSlice: Dim { @@ -591,8 +591,8 @@ macro_rules! matrix_slice_impl ( /// Panics if the ranges overlap or if the first range is empty. #[inline] pub fn $rows_range_pair, Range2: SliceRange>($me: $Me, r1: Range1, r2: Range2) - -> ($MatrixSlice<'_, T, Range1::Size, C, S::RStride, S::CStride>, - $MatrixSlice<'_, T, Range2::Size, C, S::RStride, S::CStride>) { + -> ($MatrixView<'_, T, Range1::Size, C, S::RStride, S::CStride>, + $MatrixView<'_, T, Range2::Size, C, S::RStride, S::CStride>) { let (nrows, ncols) = $me.shape_generic(); let strides = $me.data.strides(); @@ -627,8 +627,8 @@ macro_rules! matrix_slice_impl ( /// Panics if the ranges overlap or if the first range is empty. #[inline] pub fn $columns_range_pair, Range2: SliceRange>($me: $Me, r1: Range1, r2: Range2) - -> ($MatrixSlice<'_, T, R, Range1::Size, S::RStride, S::CStride>, - $MatrixSlice<'_, T, R, Range2::Size, S::RStride, S::CStride>) { + -> ($MatrixView<'_, T, R, Range1::Size, S::RStride, S::CStride>, + $MatrixView<'_, T, R, Range2::Size, S::RStride, S::CStride>) { let (nrows, ncols) = $me.shape_generic(); let strides = $me.data.strides(); @@ -661,16 +661,37 @@ macro_rules! matrix_slice_impl ( ); /// A matrix slice. +/// +/// This type alias exists only for legacy purposes and is deprecated. It will be removed +/// in a future release. Please use [`MatrixView`] instead. +/// See [issue #1076](https://github.com/dimforge/nalgebra/issues/1076) +/// for the rationale. +#[deprecated = "Use MatrixView instead."] pub type MatrixSlice<'a, T, R, C, RStride = U1, CStride = R> = + MatrixView<'a, T, R, C, RStride, CStride>; + +/// A matrix view. +pub type MatrixView<'a, T, R, C, RStride = U1, CStride = R> = Matrix>; + /// A mutable matrix slice. +/// +/// This type alias exists only for legacy purposes and is deprecated. It will be removed +/// in a future release. Please use [`MatrixViewMut`] instead. +/// See [issue #1076](https://github.com/dimforge/nalgebra/issues/1076) +/// for the rationale. +#[deprecated = "Use MatrixViewMut instead."] pub type MatrixSliceMut<'a, T, R, C, RStride = U1, CStride = R> = + MatrixViewMut<'a, T, R, C, RStride, CStride>; + +/// A mutable matrix view. +pub type MatrixViewMut<'a, T, R, C, RStride = U1, CStride = R> = Matrix>; /// # Slicing based on index and length impl> Matrix { matrix_slice_impl!( - self: &Self, MatrixSlice, ViewStorage, RawStorage.get_address_unchecked(), &self.data; + self: &Self, MatrixView, ViewStorage, RawStorage.get_address_unchecked(), &self.data; row, row_part, rows, @@ -700,7 +721,7 @@ impl> Matrix { /// # Mutable slicing based on index and length impl> Matrix { matrix_slice_impl!( - self: &mut Self, MatrixSliceMut, ViewStorageMut, RawStorageMut.get_address_unchecked_mut(), &mut self.data; + self: &mut Self, MatrixViewMut, ViewStorageMut, RawStorageMut.get_address_unchecked_mut(), &mut self.data; row_mut, row_part_mut, rows_mut, @@ -872,7 +893,7 @@ impl> Matrix { &self, rows: RowRange, cols: ColRange, - ) -> MatrixSlice<'_, T, RowRange::Size, ColRange::Size, S::RStride, S::CStride> + ) -> MatrixView<'_, T, RowRange::Size, ColRange::Size, S::RStride, S::CStride> where RowRange: SliceRange, ColRange: SliceRange, @@ -890,7 +911,7 @@ impl> Matrix { pub fn rows_range>( &self, rows: RowRange, - ) -> MatrixSlice<'_, T, RowRange::Size, C, S::RStride, S::CStride> { + ) -> MatrixView<'_, T, RowRange::Size, C, S::RStride, S::CStride> { self.slice_range(rows, ..) } @@ -900,7 +921,7 @@ impl> Matrix { pub fn columns_range>( &self, cols: ColRange, - ) -> MatrixSlice<'_, T, R, ColRange::Size, S::RStride, S::CStride> { + ) -> MatrixView<'_, T, R, ColRange::Size, S::RStride, S::CStride> { self.slice_range(.., cols) } } @@ -914,7 +935,7 @@ impl> Matrix { &mut self, rows: RowRange, cols: ColRange, - ) -> MatrixSliceMut<'_, T, RowRange::Size, ColRange::Size, S::RStride, S::CStride> + ) -> MatrixViewMut<'_, T, RowRange::Size, ColRange::Size, S::RStride, S::CStride> where RowRange: SliceRange, ColRange: SliceRange, @@ -931,7 +952,7 @@ impl> Matrix { pub fn rows_range_mut>( &mut self, rows: RowRange, - ) -> MatrixSliceMut<'_, T, RowRange::Size, C, S::RStride, S::CStride> { + ) -> MatrixViewMut<'_, T, RowRange::Size, C, S::RStride, S::CStride> { self.slice_range_mut(rows, ..) } @@ -940,20 +961,20 @@ impl> Matrix { pub fn columns_range_mut>( &mut self, cols: ColRange, - ) -> MatrixSliceMut<'_, T, R, ColRange::Size, S::RStride, S::CStride> { + ) -> MatrixViewMut<'_, T, R, ColRange::Size, S::RStride, S::CStride> { self.slice_range_mut(.., cols) } } -impl<'a, T, R, C, RStride, CStride> From> - for MatrixSlice<'a, T, R, C, RStride, CStride> +impl<'a, T, R, C, RStride, CStride> From> + for MatrixView<'a, T, R, C, RStride, CStride> where R: Dim, C: Dim, RStride: Dim, CStride: Dim, { - fn from(slice_mut: MatrixSliceMut<'a, T, R, C, RStride, CStride>) -> Self { + fn from(slice_mut: MatrixViewMut<'a, T, R, C, RStride, CStride>) -> Self { let data = ViewStorage { ptr: slice_mut.data.ptr, shape: slice_mut.data.shape, diff --git a/src/geometry/quaternion.rs b/src/geometry/quaternion.rs index 293ab125..34eda897 100755 --- a/src/geometry/quaternion.rs +++ b/src/geometry/quaternion.rs @@ -14,7 +14,7 @@ use simba::simd::{SimdBool, SimdOption, SimdRealField}; use crate::base::dimension::{U1, U3, U4}; use crate::base::storage::{CStride, RStride}; use crate::base::{ - Matrix3, Matrix4, MatrixSlice, MatrixSliceMut, Normed, Scalar, Unit, Vector3, Vector4, + Matrix3, Matrix4, MatrixView, MatrixViewMut, Normed, Scalar, Unit, Vector3, Vector4, }; use crate::geometry::{Point3, Rotation}; @@ -191,7 +191,7 @@ where /// ``` #[inline] #[must_use] - pub fn vector(&self) -> MatrixSlice<'_, T, U3, U1, RStride, CStride> { + pub fn vector(&self) -> MatrixView<'_, T, U3, U1, RStride, CStride> { self.coords.fixed_rows::<3>(0) } @@ -584,7 +584,7 @@ where #[inline] pub fn vector_mut( &mut self, - ) -> MatrixSliceMut<'_, T, U3, U1, RStride, CStride> { + ) -> MatrixViewMut<'_, T, U3, U1, RStride, CStride> { self.coords.fixed_rows_mut::<3>(0) } From 9a7e92e90232cac0ec2d5635c2dc705b0faae1d4 Mon Sep 17 00:00:00 2001 From: Andreas Longva Date: Fri, 11 Nov 2022 17:29:55 +0100 Subject: [PATCH 03/22] Rename matrix_slice.rs to matrix_view.rs --- src/base/alias_slice.rs | 2 +- src/base/construction_slice.rs | 2 +- src/base/{matrix_slice.rs => matrix_view.rs} | 0 src/base/mod.rs | 4 ++-- 4 files changed, 4 insertions(+), 4 deletions(-) rename src/base/{matrix_slice.rs => matrix_view.rs} (100%) diff --git a/src/base/alias_slice.rs b/src/base/alias_slice.rs index 21cde51c..6ed967b6 100644 --- a/src/base/alias_slice.rs +++ b/src/base/alias_slice.rs @@ -1,5 +1,5 @@ use crate::base::dimension::{Dynamic, U1, U2, U3, U4, U5, U6}; -use crate::base::matrix_slice::{ViewStorage, ViewStorageMut}; +use crate::base::matrix_view::{ViewStorage, ViewStorageMut}; use crate::base::{Const, Matrix}; /* diff --git a/src/base/construction_slice.rs b/src/base/construction_slice.rs index e54d824c..d6a1f708 100644 --- a/src/base/construction_slice.rs +++ b/src/base/construction_slice.rs @@ -1,5 +1,5 @@ use crate::base::dimension::{Const, Dim, DimName, Dynamic}; -use crate::base::matrix_slice::{ViewStorage, ViewStorageMut}; +use crate::base::matrix_view::{ViewStorage, ViewStorageMut}; use crate::base::{MatrixView, MatrixSliceMutMN, Scalar}; use num_rational::Ratio; diff --git a/src/base/matrix_slice.rs b/src/base/matrix_view.rs similarity index 100% rename from src/base/matrix_slice.rs rename to src/base/matrix_view.rs diff --git a/src/base/mod.rs b/src/base/mod.rs index c6279ba3..ed1b5d44 100644 --- a/src/base/mod.rs +++ b/src/base/mod.rs @@ -23,7 +23,7 @@ mod edition; pub mod indexing; mod matrix; mod matrix_simba; -mod matrix_slice; +mod matrix_view; mod norm; mod properties; mod scalar; @@ -52,7 +52,7 @@ pub use self::dimension::*; pub use self::alias::*; pub use self::alias_slice::*; pub use self::array_storage::*; -pub use self::matrix_slice::*; +pub use self::matrix_view::*; pub use self::storage::*; #[cfg(any(feature = "std", feature = "alloc"))] pub use self::vec_storage::*; From 4234883d234aed7389215ce5f1dc05b331c8a83c Mon Sep 17 00:00:00 2001 From: Andreas Longva Date: Fri, 11 Nov 2022 17:36:50 +0100 Subject: [PATCH 04/22] Add View type aliases --- src/base/alias_view.rs | 589 +++++++++++++++++++++++++++++++++++++++++ src/base/mod.rs | 2 + 2 files changed, 591 insertions(+) create mode 100644 src/base/alias_view.rs diff --git a/src/base/alias_view.rs b/src/base/alias_view.rs new file mode 100644 index 00000000..1bbee3f8 --- /dev/null +++ b/src/base/alias_view.rs @@ -0,0 +1,589 @@ +use crate::base::dimension::{Dynamic, U1, U2, U3, U4, U5, U6}; +use crate::base::matrix_view::{ViewStorage, ViewStorageMut}; +use crate::base::{Const, Matrix}; + +/* + * + * + * Matrix view aliases. + * + * + */ +// NOTE: we can't provide defaults for the strides because it's not supported yet by min_const_generics. +/// A column-major matrix view with dimensions known at compile-time. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type SMatrixView<'a, T, const R: usize, const C: usize> = + Matrix, Const, ViewStorage<'a, T, Const, Const, Const<1>, Const>>; + +/// A column-major matrix view dynamic numbers of rows and columns. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type DMatrixView<'a, T, RStride = U1, CStride = Dynamic> = + Matrix>; + +/// A column-major 1x1 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixView1<'a, T, RStride = U1, CStride = U1> = + Matrix>; +/// A column-major 2x2 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixView2<'a, T, RStride = U1, CStride = U2> = + Matrix>; +/// A column-major 3x3 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixView3<'a, T, RStride = U1, CStride = U3> = + Matrix>; +/// A column-major 4x4 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixView4<'a, T, RStride = U1, CStride = U4> = + Matrix>; +/// A column-major 5x5 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixView5<'a, T, RStride = U1, CStride = U5> = + Matrix>; +/// A column-major 6x6 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixView6<'a, T, RStride = U1, CStride = U6> = + Matrix>; + +/// A column-major 1x2 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixView1x2<'a, T, RStride = U1, CStride = U1> = + Matrix>; +/// A column-major 1x3 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixView1x3<'a, T, RStride = U1, CStride = U1> = + Matrix>; +/// A column-major 1x4 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixView1x4<'a, T, RStride = U1, CStride = U1> = + Matrix>; +/// A column-major 1x5 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixView1x5<'a, T, RStride = U1, CStride = U1> = + Matrix>; +/// A column-major 1x6 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixView1x6<'a, T, RStride = U1, CStride = U1> = + Matrix>; + +/// A column-major 2x1 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixView2x1<'a, T, RStride = U1, CStride = U2> = + Matrix>; +/// A column-major 2x3 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixView2x3<'a, T, RStride = U1, CStride = U2> = + Matrix>; +/// A column-major 2x4 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixView2x4<'a, T, RStride = U1, CStride = U2> = + Matrix>; +/// A column-major 2x5 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixView2x5<'a, T, RStride = U1, CStride = U2> = + Matrix>; +/// A column-major 2x6 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixView2x6<'a, T, RStride = U1, CStride = U2> = + Matrix>; + +/// A column-major 3x1 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixView3x1<'a, T, RStride = U1, CStride = U3> = + Matrix>; +/// A column-major 3x2 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixView3x2<'a, T, RStride = U1, CStride = U3> = + Matrix>; +/// A column-major 3x4 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixView3x4<'a, T, RStride = U1, CStride = U3> = + Matrix>; +/// A column-major 3x5 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixView3x5<'a, T, RStride = U1, CStride = U3> = + Matrix>; +/// A column-major 3x6 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixView3x6<'a, T, RStride = U1, CStride = U3> = + Matrix>; + +/// A column-major 4x1 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixView4x1<'a, T, RStride = U1, CStride = U4> = + Matrix>; +/// A column-major 4x2 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixView4x2<'a, T, RStride = U1, CStride = U4> = + Matrix>; +/// A column-major 4x3 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixView4x3<'a, T, RStride = U1, CStride = U4> = + Matrix>; +/// A column-major 4x5 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixView4x5<'a, T, RStride = U1, CStride = U4> = + Matrix>; +/// A column-major 4x6 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixView4x6<'a, T, RStride = U1, CStride = U4> = + Matrix>; + +/// A column-major 5x1 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixView5x1<'a, T, RStride = U1, CStride = U5> = + Matrix>; +/// A column-major 5x2 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixView5x2<'a, T, RStride = U1, CStride = U5> = + Matrix>; +/// A column-major 5x3 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixView5x3<'a, T, RStride = U1, CStride = U5> = + Matrix>; +/// A column-major 5x4 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixView5x4<'a, T, RStride = U1, CStride = U5> = + Matrix>; +/// A column-major 5x6 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixView5x6<'a, T, RStride = U1, CStride = U5> = + Matrix>; + +/// A column-major 6x1 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixView6x1<'a, T, RStride = U1, CStride = U6> = + Matrix>; +/// A column-major 6x2 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixView6x2<'a, T, RStride = U1, CStride = U6> = + Matrix>; +/// A column-major 6x3 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixView6x3<'a, T, RStride = U1, CStride = U6> = + Matrix>; +/// A column-major 6x4 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixView6x4<'a, T, RStride = U1, CStride = U6> = + Matrix>; +/// A column-major 6x5 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixView6x5<'a, T, RStride = U1, CStride = U6> = + Matrix>; + +/// A column-major matrix view with 1 row and a number of columns chosen at runtime. +pub type MatrixView1xX<'a, T, RStride = U1, CStride = U1> = + Matrix>; +/// A column-major matrix view with 2 rows and a number of columns chosen at runtime. +pub type MatrixView2xX<'a, T, RStride = U1, CStride = U2> = + Matrix>; +/// A column-major matrix view with 3 rows and a number of columns chosen at runtime. +pub type MatrixView3xX<'a, T, RStride = U1, CStride = U3> = + Matrix>; +/// A column-major matrix view with 4 rows and a number of columns chosen at runtime. +pub type MatrixView4xX<'a, T, RStride = U1, CStride = U4> = + Matrix>; +/// A column-major matrix view with 5 rows and a number of columns chosen at runtime. +pub type MatrixView5xX<'a, T, RStride = U1, CStride = U5> = + Matrix>; +/// A column-major matrix view with 6 rows and a number of columns chosen at runtime. +pub type MatrixView6xX<'a, T, RStride = U1, CStride = U6> = + Matrix>; + +/// A column-major matrix view with a number of rows chosen at runtime and 1 column. +pub type MatrixViewXx1<'a, T, RStride = U1, CStride = Dynamic> = + Matrix>; +/// A column-major matrix view with a number of rows chosen at runtime and 2 columns. +pub type MatrixViewXx2<'a, T, RStride = U1, CStride = Dynamic> = + Matrix>; +/// A column-major matrix view with a number of rows chosen at runtime and 3 columns. +pub type MatrixViewXx3<'a, T, RStride = U1, CStride = Dynamic> = + Matrix>; +/// A column-major matrix view with a number of rows chosen at runtime and 4 columns. +pub type MatrixViewXx4<'a, T, RStride = U1, CStride = Dynamic> = + Matrix>; +/// A column-major matrix view with a number of rows chosen at runtime and 5 columns. +pub type MatrixViewXx5<'a, T, RStride = U1, CStride = Dynamic> = + Matrix>; +/// A column-major matrix view with a number of rows chosen at runtime and 6 columns. +pub type MatrixViewXx6<'a, T, RStride = U1, CStride = Dynamic> = + Matrix>; + +/// A column vector view with dimensions known at compile-time. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type VectorView<'a, T, D, RStride = U1, CStride = D> = + Matrix>; + +/// A column vector view with dimensions known at compile-time. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type SVectorView<'a, T, const D: usize> = + Matrix, Const<1>, ViewStorage<'a, T, Const, Const<1>, Const<1>, Const>>; + +/// A column vector view dynamic numbers of rows and columns. +pub type DVectorView<'a, T, RStride = U1, CStride = Dynamic> = + Matrix>; + +/// A 1D column vector view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type VectorView1<'a, T, RStride = U1, CStride = U1> = + Matrix>; +/// A 2D column vector view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type VectorView2<'a, T, RStride = U1, CStride = U2> = + Matrix>; +/// A 3D column vector view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type VectorView3<'a, T, RStride = U1, CStride = U3> = + Matrix>; +/// A 4D column vector view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type VectorView4<'a, T, RStride = U1, CStride = U4> = + Matrix>; +/// A 5D column vector view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type VectorView5<'a, T, RStride = U1, CStride = U5> = + Matrix>; +/// A 6D column vector view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type VectorView6<'a, T, RStride = U1, CStride = U6> = + Matrix>; + +/* + * + * + * Same thing, but for mutable views. + * + * + */ + +/// A column-major matrix view with dimensions known at compile-time. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type SMatrixViewMut<'a, T, const R: usize, const C: usize> = + Matrix, Const, ViewStorageMut<'a, T, Const, Const, Const<1>, Const>>; + +/// A column-major matrix view dynamic numbers of rows and columns. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type DMatrixViewMut<'a, T, RStride = U1, CStride = Dynamic> = + Matrix>; + +/// A column-major 1x1 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixViewMut1<'a, T, RStride = U1, CStride = U1> = + Matrix>; +/// A column-major 2x2 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixViewMut2<'a, T, RStride = U1, CStride = U2> = + Matrix>; +/// A column-major 3x3 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixViewMut3<'a, T, RStride = U1, CStride = U3> = + Matrix>; +/// A column-major 4x4 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixViewMut4<'a, T, RStride = U1, CStride = U4> = + Matrix>; +/// A column-major 5x5 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixViewMut5<'a, T, RStride = U1, CStride = U5> = + Matrix>; +/// A column-major 6x6 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixViewMut6<'a, T, RStride = U1, CStride = U6> = + Matrix>; + +/// A column-major 1x2 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixViewMut1x2<'a, T, RStride = U1, CStride = U1> = + Matrix>; +/// A column-major 1x3 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixViewMut1x3<'a, T, RStride = U1, CStride = U1> = + Matrix>; +/// A column-major 1x4 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixViewMut1x4<'a, T, RStride = U1, CStride = U1> = + Matrix>; +/// A column-major 1x5 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixViewMut1x5<'a, T, RStride = U1, CStride = U1> = + Matrix>; +/// A column-major 1x6 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixViewMut1x6<'a, T, RStride = U1, CStride = U1> = + Matrix>; + +/// A column-major 2x1 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixViewMut2x1<'a, T, RStride = U1, CStride = U2> = + Matrix>; +/// A column-major 2x3 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixViewMut2x3<'a, T, RStride = U1, CStride = U2> = + Matrix>; +/// A column-major 2x4 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixViewMut2x4<'a, T, RStride = U1, CStride = U2> = + Matrix>; +/// A column-major 2x5 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixViewMut2x5<'a, T, RStride = U1, CStride = U2> = + Matrix>; +/// A column-major 2x6 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixViewMut2x6<'a, T, RStride = U1, CStride = U2> = + Matrix>; + +/// A column-major 3x1 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixViewMut3x1<'a, T, RStride = U1, CStride = U3> = + Matrix>; +/// A column-major 3x2 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixViewMut3x2<'a, T, RStride = U1, CStride = U3> = + Matrix>; +/// A column-major 3x4 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixViewMut3x4<'a, T, RStride = U1, CStride = U3> = + Matrix>; +/// A column-major 3x5 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixViewMut3x5<'a, T, RStride = U1, CStride = U3> = + Matrix>; +/// A column-major 3x6 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixViewMut3x6<'a, T, RStride = U1, CStride = U3> = + Matrix>; + +/// A column-major 4x1 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixViewMut4x1<'a, T, RStride = U1, CStride = U4> = + Matrix>; +/// A column-major 4x2 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixViewMut4x2<'a, T, RStride = U1, CStride = U4> = + Matrix>; +/// A column-major 4x3 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixViewMut4x3<'a, T, RStride = U1, CStride = U4> = + Matrix>; +/// A column-major 4x5 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixViewMut4x5<'a, T, RStride = U1, CStride = U4> = + Matrix>; +/// A column-major 4x6 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixViewMut4x6<'a, T, RStride = U1, CStride = U4> = + Matrix>; + +/// A column-major 5x1 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixViewMut5x1<'a, T, RStride = U1, CStride = U5> = + Matrix>; +/// A column-major 5x2 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixViewMut5x2<'a, T, RStride = U1, CStride = U5> = + Matrix>; +/// A column-major 5x3 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixViewMut5x3<'a, T, RStride = U1, CStride = U5> = + Matrix>; +/// A column-major 5x4 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixViewMut5x4<'a, T, RStride = U1, CStride = U5> = + Matrix>; +/// A column-major 5x6 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixViewMut5x6<'a, T, RStride = U1, CStride = U5> = + Matrix>; + +/// A column-major 6x1 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixViewMut6x1<'a, T, RStride = U1, CStride = U6> = + Matrix>; +/// A column-major 6x2 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixViewMut6x2<'a, T, RStride = U1, CStride = U6> = + Matrix>; +/// A column-major 6x3 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixViewMut6x3<'a, T, RStride = U1, CStride = U6> = + Matrix>; +/// A column-major 6x4 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixViewMut6x4<'a, T, RStride = U1, CStride = U6> = + Matrix>; +/// A column-major 6x5 matrix view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type MatrixViewMut6x5<'a, T, RStride = U1, CStride = U6> = + Matrix>; + +/// A column-major matrix view with 1 row and a number of columns chosen at runtime. +pub type MatrixViewMut1xX<'a, T, RStride = U1, CStride = U1> = + Matrix>; +/// A column-major matrix view with 2 rows and a number of columns chosen at runtime. +pub type MatrixViewMut2xX<'a, T, RStride = U1, CStride = U2> = + Matrix>; +/// A column-major matrix view with 3 rows and a number of columns chosen at runtime. +pub type MatrixViewMut3xX<'a, T, RStride = U1, CStride = U3> = + Matrix>; +/// A column-major matrix view with 4 rows and a number of columns chosen at runtime. +pub type MatrixViewMut4xX<'a, T, RStride = U1, CStride = U4> = + Matrix>; +/// A column-major matrix view with 5 rows and a number of columns chosen at runtime. +pub type MatrixViewMut5xX<'a, T, RStride = U1, CStride = U5> = + Matrix>; +/// A column-major matrix view with 6 rows and a number of columns chosen at runtime. +pub type MatrixViewMut6xX<'a, T, RStride = U1, CStride = U6> = + Matrix>; + +/// A column-major matrix view with a number of rows chosen at runtime and 1 column. +pub type MatrixViewMutXx1<'a, T, RStride = U1, CStride = Dynamic> = + Matrix>; +/// A column-major matrix view with a number of rows chosen at runtime and 2 columns. +pub type MatrixViewMutXx2<'a, T, RStride = U1, CStride = Dynamic> = + Matrix>; +/// A column-major matrix view with a number of rows chosen at runtime and 3 columns. +pub type MatrixViewMutXx3<'a, T, RStride = U1, CStride = Dynamic> = + Matrix>; +/// A column-major matrix view with a number of rows chosen at runtime and 4 columns. +pub type MatrixViewMutXx4<'a, T, RStride = U1, CStride = Dynamic> = + Matrix>; +/// A column-major matrix view with a number of rows chosen at runtime and 5 columns. +pub type MatrixViewMutXx5<'a, T, RStride = U1, CStride = Dynamic> = + Matrix>; +/// A column-major matrix view with a number of rows chosen at runtime and 6 columns. +pub type MatrixViewMutXx6<'a, T, RStride = U1, CStride = Dynamic> = + Matrix>; + +/// A column vector view with dimensions known at compile-time. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type VectorViewMut<'a, T, D, RStride = U1, CStride = D> = + Matrix>; + +/// A column vector view with dimensions known at compile-time. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type SVectorViewMut<'a, T, const D: usize> = + Matrix, Const<1>, ViewStorageMut<'a, T, Const, Const<1>, Const<1>, Const>>; + +/// A column vector view dynamic numbers of rows and columns. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type DVectorViewMut<'a, T, RStride = U1, CStride = Dynamic> = + Matrix>; + +/// A 1D column vector view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type VectorViewMut1<'a, T, RStride = U1, CStride = U1> = + Matrix>; +/// A 2D column vector view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type VectorViewMut2<'a, T, RStride = U1, CStride = U2> = + Matrix>; +/// A 3D column vector view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type VectorViewMut3<'a, T, RStride = U1, CStride = U3> = + Matrix>; +/// A 4D column vector view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type VectorViewMut4<'a, T, RStride = U1, CStride = U4> = + Matrix>; +/// A 5D column vector view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type VectorViewMut5<'a, T, RStride = U1, CStride = U5> = + Matrix>; +/// A 6D column vector view. +/// +/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +pub type VectorViewMut6<'a, T, RStride = U1, CStride = U6> = + Matrix>; diff --git a/src/base/mod.rs b/src/base/mod.rs index ed1b5d44..6fb3685d 100644 --- a/src/base/mod.rs +++ b/src/base/mod.rs @@ -12,6 +12,7 @@ pub mod storage; mod alias; mod alias_slice; +mod alias_view; mod array_storage; mod cg; mod componentwise; @@ -51,6 +52,7 @@ pub use self::dimension::*; pub use self::alias::*; pub use self::alias_slice::*; +pub use self::alias_view::*; pub use self::array_storage::*; pub use self::matrix_view::*; pub use self::storage::*; From e245e1148a07cffc2e4752d6679fd5b8495338eb Mon Sep 17 00:00:00 2001 From: Andreas Longva Date: Mon, 14 Nov 2022 09:26:45 +0100 Subject: [PATCH 05/22] Deprecate slice type aliases --- src/base/alias_slice.rs | 126 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 126 insertions(+) diff --git a/src/base/alias_slice.rs b/src/base/alias_slice.rs index 6ed967b6..d0fb6676 100644 --- a/src/base/alias_slice.rs +++ b/src/base/alias_slice.rs @@ -2,6 +2,14 @@ use crate::base::dimension::{Dynamic, U1, U2, U3, U4, U5, U6}; use crate::base::matrix_view::{ViewStorage, ViewStorageMut}; use crate::base::{Const, Matrix}; +/// Generates an appropriate deprecation note with a suggestion for replacement. +macro_rules! deprecation_note { + ($replacement:ident) => { + concat!("Use ", stringify!($replacement), + r###" instead. See [issue #1076](https://github.com/dimforge/nalgebra/issues/1076) for more information."###) + } +} + /* * * @@ -13,284 +21,343 @@ use crate::base::{Const, Matrix}; /// A column-major matrix slice with dimensions known at compile-time. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(SMatrixView)] pub type SMatrixSlice<'a, T, const R: usize, const C: usize> = Matrix, Const, ViewStorage<'a, T, Const, Const, Const<1>, Const>>; /// A column-major matrix slice dynamic numbers of rows and columns. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(DMatrixView)] pub type DMatrixSlice<'a, T, RStride = U1, CStride = Dynamic> = Matrix>; /// A column-major 1x1 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixView1)] pub type MatrixSlice1<'a, T, RStride = U1, CStride = U1> = Matrix>; /// A column-major 2x2 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixView2)] pub type MatrixSlice2<'a, T, RStride = U1, CStride = U2> = Matrix>; /// A column-major 3x3 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixView3)] pub type MatrixSlice3<'a, T, RStride = U1, CStride = U3> = Matrix>; /// A column-major 4x4 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixView4)] pub type MatrixSlice4<'a, T, RStride = U1, CStride = U4> = Matrix>; /// A column-major 5x5 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixView5)] pub type MatrixSlice5<'a, T, RStride = U1, CStride = U5> = Matrix>; /// A column-major 6x6 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixView6)] pub type MatrixSlice6<'a, T, RStride = U1, CStride = U6> = Matrix>; /// A column-major 1x2 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixView1x2)] pub type MatrixSlice1x2<'a, T, RStride = U1, CStride = U1> = Matrix>; /// A column-major 1x3 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixView1x3)] pub type MatrixSlice1x3<'a, T, RStride = U1, CStride = U1> = Matrix>; /// A column-major 1x4 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixView1x4)] pub type MatrixSlice1x4<'a, T, RStride = U1, CStride = U1> = Matrix>; /// A column-major 1x5 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixView1x5)] pub type MatrixSlice1x5<'a, T, RStride = U1, CStride = U1> = Matrix>; /// A column-major 1x6 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixView1x6)] pub type MatrixSlice1x6<'a, T, RStride = U1, CStride = U1> = Matrix>; /// A column-major 2x1 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixView2x1)] pub type MatrixSlice2x1<'a, T, RStride = U1, CStride = U2> = Matrix>; /// A column-major 2x3 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixView2x3)] pub type MatrixSlice2x3<'a, T, RStride = U1, CStride = U2> = Matrix>; /// A column-major 2x4 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixView2x4)] pub type MatrixSlice2x4<'a, T, RStride = U1, CStride = U2> = Matrix>; /// A column-major 2x5 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixView2x5)] pub type MatrixSlice2x5<'a, T, RStride = U1, CStride = U2> = Matrix>; /// A column-major 2x6 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixView2x6)] pub type MatrixSlice2x6<'a, T, RStride = U1, CStride = U2> = Matrix>; /// A column-major 3x1 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixView3x1)] pub type MatrixSlice3x1<'a, T, RStride = U1, CStride = U3> = Matrix>; /// A column-major 3x2 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixView3x2)] pub type MatrixSlice3x2<'a, T, RStride = U1, CStride = U3> = Matrix>; /// A column-major 3x4 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixView3x4)] pub type MatrixSlice3x4<'a, T, RStride = U1, CStride = U3> = Matrix>; /// A column-major 3x5 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixView3x5)] pub type MatrixSlice3x5<'a, T, RStride = U1, CStride = U3> = Matrix>; /// A column-major 3x6 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixView3x6)] pub type MatrixSlice3x6<'a, T, RStride = U1, CStride = U3> = Matrix>; /// A column-major 4x1 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixView4x1)] pub type MatrixSlice4x1<'a, T, RStride = U1, CStride = U4> = Matrix>; /// A column-major 4x2 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixView4x2)] pub type MatrixSlice4x2<'a, T, RStride = U1, CStride = U4> = Matrix>; /// A column-major 4x3 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixView4x3)] pub type MatrixSlice4x3<'a, T, RStride = U1, CStride = U4> = Matrix>; /// A column-major 4x5 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixView4x5)] pub type MatrixSlice4x5<'a, T, RStride = U1, CStride = U4> = Matrix>; /// A column-major 4x6 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixView4x6)] pub type MatrixSlice4x6<'a, T, RStride = U1, CStride = U4> = Matrix>; /// A column-major 5x1 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixView5x1)] pub type MatrixSlice5x1<'a, T, RStride = U1, CStride = U5> = Matrix>; /// A column-major 5x2 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixView5x2)] pub type MatrixSlice5x2<'a, T, RStride = U1, CStride = U5> = Matrix>; /// A column-major 5x3 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixView5x3)] pub type MatrixSlice5x3<'a, T, RStride = U1, CStride = U5> = Matrix>; /// A column-major 5x4 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixView5x4)] pub type MatrixSlice5x4<'a, T, RStride = U1, CStride = U5> = Matrix>; /// A column-major 5x6 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixView5x6)] pub type MatrixSlice5x6<'a, T, RStride = U1, CStride = U5> = Matrix>; /// A column-major 6x1 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixView6x1)] pub type MatrixSlice6x1<'a, T, RStride = U1, CStride = U6> = Matrix>; /// A column-major 6x2 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixView6x2)] pub type MatrixSlice6x2<'a, T, RStride = U1, CStride = U6> = Matrix>; /// A column-major 6x3 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixView6x3)] pub type MatrixSlice6x3<'a, T, RStride = U1, CStride = U6> = Matrix>; /// A column-major 6x4 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixView6x4)] pub type MatrixSlice6x4<'a, T, RStride = U1, CStride = U6> = Matrix>; /// A column-major 6x5 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixView6x5)] pub type MatrixSlice6x5<'a, T, RStride = U1, CStride = U6> = Matrix>; /// A column-major matrix slice with 1 row and a number of columns chosen at runtime. +#[deprecated = deprecation_note!(MatrixView1xX)] pub type MatrixSlice1xX<'a, T, RStride = U1, CStride = U1> = Matrix>; /// A column-major matrix slice with 2 rows and a number of columns chosen at runtime. +#[deprecated = deprecation_note!(MatrixView2xX)] pub type MatrixSlice2xX<'a, T, RStride = U1, CStride = U2> = Matrix>; /// A column-major matrix slice with 3 rows and a number of columns chosen at runtime. +#[deprecated = deprecation_note!(MatrixView3xX)] pub type MatrixSlice3xX<'a, T, RStride = U1, CStride = U3> = Matrix>; /// A column-major matrix slice with 4 rows and a number of columns chosen at runtime. +#[deprecated = deprecation_note!(MatrixView4xX)] pub type MatrixSlice4xX<'a, T, RStride = U1, CStride = U4> = Matrix>; /// A column-major matrix slice with 5 rows and a number of columns chosen at runtime. +#[deprecated = deprecation_note!(MatrixView5xX)] pub type MatrixSlice5xX<'a, T, RStride = U1, CStride = U5> = Matrix>; /// A column-major matrix slice with 6 rows and a number of columns chosen at runtime. +#[deprecated = deprecation_note!(MatrixView6xX)] pub type MatrixSlice6xX<'a, T, RStride = U1, CStride = U6> = Matrix>; /// A column-major matrix slice with a number of rows chosen at runtime and 1 column. +#[deprecated = deprecation_note!(MatrixViewXx1)] pub type MatrixSliceXx1<'a, T, RStride = U1, CStride = Dynamic> = Matrix>; /// A column-major matrix slice with a number of rows chosen at runtime and 2 columns. +#[deprecated = deprecation_note!(MatrixViewXx2)] pub type MatrixSliceXx2<'a, T, RStride = U1, CStride = Dynamic> = Matrix>; /// A column-major matrix slice with a number of rows chosen at runtime and 3 columns. +#[deprecated = deprecation_note!(MatrixViewXx3)] pub type MatrixSliceXx3<'a, T, RStride = U1, CStride = Dynamic> = Matrix>; /// A column-major matrix slice with a number of rows chosen at runtime and 4 columns. +#[deprecated = deprecation_note!(MatrixViewXx4)] pub type MatrixSliceXx4<'a, T, RStride = U1, CStride = Dynamic> = Matrix>; /// A column-major matrix slice with a number of rows chosen at runtime and 5 columns. +#[deprecated = deprecation_note!(MatrixViewXx5)] pub type MatrixSliceXx5<'a, T, RStride = U1, CStride = Dynamic> = Matrix>; /// A column-major matrix slice with a number of rows chosen at runtime and 6 columns. +#[deprecated = deprecation_note!(MatrixViewXx6)] pub type MatrixSliceXx6<'a, T, RStride = U1, CStride = Dynamic> = Matrix>; /// A column vector slice with dimensions known at compile-time. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(VectorView)] pub type VectorSlice<'a, T, D, RStride = U1, CStride = D> = Matrix>; /// A column vector slice with dimensions known at compile-time. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(SVectorView)] pub type SVectorSlice<'a, T, const D: usize> = Matrix, Const<1>, ViewStorage<'a, T, Const, Const<1>, Const<1>, Const>>; /// A column vector slice dynamic numbers of rows and columns. +#[deprecated = deprecation_note!(DVectorView)] pub type DVectorSlice<'a, T, RStride = U1, CStride = Dynamic> = Matrix>; /// A 1D column vector slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(VectorView1)] pub type VectorSlice1<'a, T, RStride = U1, CStride = U1> = Matrix>; /// A 2D column vector slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(VectorView2)] pub type VectorSlice2<'a, T, RStride = U1, CStride = U2> = Matrix>; /// A 3D column vector slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(VectorView3)] pub type VectorSlice3<'a, T, RStride = U1, CStride = U3> = Matrix>; /// A 4D column vector slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(VectorView4)] pub type VectorSlice4<'a, T, RStride = U1, CStride = U4> = Matrix>; /// A 5D column vector slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(VectorView5)] pub type VectorSlice5<'a, T, RStride = U1, CStride = U5> = Matrix>; /// A 6D column vector slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(VectorView6)] pub type VectorSlice6<'a, T, RStride = U1, CStride = U6> = Matrix>; @@ -316,285 +383,344 @@ pub type MatrixSliceMutN<'a, T, D, RStride = U1, CStride = D> = /// A column-major matrix slice with dimensions known at compile-time. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(SMatrixViewMut)] pub type SMatrixSliceMut<'a, T, const R: usize, const C: usize> = Matrix, Const, ViewStorageMut<'a, T, Const, Const, Const<1>, Const>>; /// A column-major matrix slice dynamic numbers of rows and columns. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(DMatrixViewMut)] pub type DMatrixSliceMut<'a, T, RStride = U1, CStride = Dynamic> = Matrix>; /// A column-major 1x1 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixViewMut1)] pub type MatrixSliceMut1<'a, T, RStride = U1, CStride = U1> = Matrix>; /// A column-major 2x2 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixViewMut2)] pub type MatrixSliceMut2<'a, T, RStride = U1, CStride = U2> = Matrix>; /// A column-major 3x3 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixViewMut3)] pub type MatrixSliceMut3<'a, T, RStride = U1, CStride = U3> = Matrix>; /// A column-major 4x4 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixViewMut4)] pub type MatrixSliceMut4<'a, T, RStride = U1, CStride = U4> = Matrix>; /// A column-major 5x5 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixViewMut5)] pub type MatrixSliceMut5<'a, T, RStride = U1, CStride = U5> = Matrix>; /// A column-major 6x6 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixViewMut6)] pub type MatrixSliceMut6<'a, T, RStride = U1, CStride = U6> = Matrix>; /// A column-major 1x2 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixViewMut1x2)] pub type MatrixSliceMut1x2<'a, T, RStride = U1, CStride = U1> = Matrix>; /// A column-major 1x3 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixViewMut1x3)] pub type MatrixSliceMut1x3<'a, T, RStride = U1, CStride = U1> = Matrix>; /// A column-major 1x4 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixViewMut1x4)] pub type MatrixSliceMut1x4<'a, T, RStride = U1, CStride = U1> = Matrix>; /// A column-major 1x5 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixViewMut1x5)] pub type MatrixSliceMut1x5<'a, T, RStride = U1, CStride = U1> = Matrix>; /// A column-major 1x6 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixViewMut1x6)] pub type MatrixSliceMut1x6<'a, T, RStride = U1, CStride = U1> = Matrix>; /// A column-major 2x1 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixViewMut2x1)] pub type MatrixSliceMut2x1<'a, T, RStride = U1, CStride = U2> = Matrix>; /// A column-major 2x3 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixViewMut2x3)] pub type MatrixSliceMut2x3<'a, T, RStride = U1, CStride = U2> = Matrix>; /// A column-major 2x4 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixViewMut2x4)] pub type MatrixSliceMut2x4<'a, T, RStride = U1, CStride = U2> = Matrix>; /// A column-major 2x5 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixViewMut2x5)] pub type MatrixSliceMut2x5<'a, T, RStride = U1, CStride = U2> = Matrix>; /// A column-major 2x6 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixViewMut2x6)] pub type MatrixSliceMut2x6<'a, T, RStride = U1, CStride = U2> = Matrix>; /// A column-major 3x1 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixViewMut3x1)] pub type MatrixSliceMut3x1<'a, T, RStride = U1, CStride = U3> = Matrix>; /// A column-major 3x2 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixViewMut3x2)] pub type MatrixSliceMut3x2<'a, T, RStride = U1, CStride = U3> = Matrix>; /// A column-major 3x4 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixViewMut3x4)] pub type MatrixSliceMut3x4<'a, T, RStride = U1, CStride = U3> = Matrix>; /// A column-major 3x5 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixViewMut3x5)] pub type MatrixSliceMut3x5<'a, T, RStride = U1, CStride = U3> = Matrix>; /// A column-major 3x6 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixViewMut3x6)] pub type MatrixSliceMut3x6<'a, T, RStride = U1, CStride = U3> = Matrix>; /// A column-major 4x1 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixViewMut4x1)] pub type MatrixSliceMut4x1<'a, T, RStride = U1, CStride = U4> = Matrix>; /// A column-major 4x2 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixViewMut4x2)] pub type MatrixSliceMut4x2<'a, T, RStride = U1, CStride = U4> = Matrix>; /// A column-major 4x3 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixViewMut4x3)] pub type MatrixSliceMut4x3<'a, T, RStride = U1, CStride = U4> = Matrix>; /// A column-major 4x5 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixViewMut4x5)] pub type MatrixSliceMut4x5<'a, T, RStride = U1, CStride = U4> = Matrix>; /// A column-major 4x6 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixViewMut4x6)] pub type MatrixSliceMut4x6<'a, T, RStride = U1, CStride = U4> = Matrix>; /// A column-major 5x1 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixViewMut5x1)] pub type MatrixSliceMut5x1<'a, T, RStride = U1, CStride = U5> = Matrix>; /// A column-major 5x2 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixViewMut5x2)] pub type MatrixSliceMut5x2<'a, T, RStride = U1, CStride = U5> = Matrix>; /// A column-major 5x3 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixViewMut5x3)] pub type MatrixSliceMut5x3<'a, T, RStride = U1, CStride = U5> = Matrix>; /// A column-major 5x4 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixViewMut5x4)] pub type MatrixSliceMut5x4<'a, T, RStride = U1, CStride = U5> = Matrix>; /// A column-major 5x6 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixViewMut5x6)] pub type MatrixSliceMut5x6<'a, T, RStride = U1, CStride = U5> = Matrix>; /// A column-major 6x1 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixViewMut6x1)] pub type MatrixSliceMut6x1<'a, T, RStride = U1, CStride = U6> = Matrix>; /// A column-major 6x2 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixViewMut6x2)] pub type MatrixSliceMut6x2<'a, T, RStride = U1, CStride = U6> = Matrix>; /// A column-major 6x3 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixViewMut6x3)] pub type MatrixSliceMut6x3<'a, T, RStride = U1, CStride = U6> = Matrix>; /// A column-major 6x4 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixViewMut6x4)] pub type MatrixSliceMut6x4<'a, T, RStride = U1, CStride = U6> = Matrix>; /// A column-major 6x5 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(MatrixViewMut6x5)] pub type MatrixSliceMut6x5<'a, T, RStride = U1, CStride = U6> = Matrix>; /// A column-major matrix slice with 1 row and a number of columns chosen at runtime. +#[deprecated = deprecation_note!(MatrixViewMut1xX)] pub type MatrixSliceMut1xX<'a, T, RStride = U1, CStride = U1> = Matrix>; /// A column-major matrix slice with 2 rows and a number of columns chosen at runtime. +#[deprecated = deprecation_note!(MatrixViewMut2xX)] pub type MatrixSliceMut2xX<'a, T, RStride = U1, CStride = U2> = Matrix>; /// A column-major matrix slice with 3 rows and a number of columns chosen at runtime. +#[deprecated = deprecation_note!(MatrixViewMut3xX)] pub type MatrixSliceMut3xX<'a, T, RStride = U1, CStride = U3> = Matrix>; /// A column-major matrix slice with 4 rows and a number of columns chosen at runtime. +#[deprecated = deprecation_note!(MatrixViewMut4xX)] pub type MatrixSliceMut4xX<'a, T, RStride = U1, CStride = U4> = Matrix>; /// A column-major matrix slice with 5 rows and a number of columns chosen at runtime. +#[deprecated = deprecation_note!(MatrixViewMut5xX)] pub type MatrixSliceMut5xX<'a, T, RStride = U1, CStride = U5> = Matrix>; /// A column-major matrix slice with 6 rows and a number of columns chosen at runtime. +#[deprecated = deprecation_note!(MatrixViewMut6xX)] pub type MatrixSliceMut6xX<'a, T, RStride = U1, CStride = U6> = Matrix>; /// A column-major matrix slice with a number of rows chosen at runtime and 1 column. +#[deprecated = deprecation_note!(MatrixViewMutXx1)] pub type MatrixSliceMutXx1<'a, T, RStride = U1, CStride = Dynamic> = Matrix>; /// A column-major matrix slice with a number of rows chosen at runtime and 2 columns. +#[deprecated = deprecation_note!(MatrixViewMutXx2)] pub type MatrixSliceMutXx2<'a, T, RStride = U1, CStride = Dynamic> = Matrix>; /// A column-major matrix slice with a number of rows chosen at runtime and 3 columns. +#[deprecated = deprecation_note!(MatrixViewMutXx3)] pub type MatrixSliceMutXx3<'a, T, RStride = U1, CStride = Dynamic> = Matrix>; /// A column-major matrix slice with a number of rows chosen at runtime and 4 columns. +#[deprecated = deprecation_note!(MatrixViewMutXx4)] pub type MatrixSliceMutXx4<'a, T, RStride = U1, CStride = Dynamic> = Matrix>; /// A column-major matrix slice with a number of rows chosen at runtime and 5 columns. +#[deprecated = deprecation_note!(MatrixViewMutXx5)] pub type MatrixSliceMutXx5<'a, T, RStride = U1, CStride = Dynamic> = Matrix>; /// A column-major matrix slice with a number of rows chosen at runtime and 6 columns. +#[deprecated = deprecation_note!(MatrixViewMutXx6)] pub type MatrixSliceMutXx6<'a, T, RStride = U1, CStride = Dynamic> = Matrix>; /// A column vector slice with dimensions known at compile-time. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(VectorViewMut)] pub type VectorSliceMut<'a, T, D, RStride = U1, CStride = D> = Matrix>; /// A column vector slice with dimensions known at compile-time. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(SVectorViewMut)] pub type SVectorSliceMut<'a, T, const D: usize> = Matrix, Const<1>, ViewStorageMut<'a, T, Const, Const<1>, Const<1>, Const>>; /// A column vector slice dynamic numbers of rows and columns. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(DVectorViewMut)] pub type DVectorSliceMut<'a, T, RStride = U1, CStride = Dynamic> = Matrix>; /// A 1D column vector slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(VectorViewMut1)] pub type VectorSliceMut1<'a, T, RStride = U1, CStride = U1> = Matrix>; /// A 2D column vector slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(VectorViewMut2)] pub type VectorSliceMut2<'a, T, RStride = U1, CStride = U2> = Matrix>; /// A 3D column vector slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(VectorViewMut3)] pub type VectorSliceMut3<'a, T, RStride = U1, CStride = U3> = Matrix>; /// A 4D column vector slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(VectorViewMut4)] pub type VectorSliceMut4<'a, T, RStride = U1, CStride = U4> = Matrix>; /// A 5D column vector slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(VectorViewMut5)] pub type VectorSliceMut5<'a, T, RStride = U1, CStride = U5> = Matrix>; /// A 6D column vector slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = deprecation_note!(VectorViewMut6)] pub type VectorSliceMut6<'a, T, RStride = U1, CStride = U6> = Matrix>; From 7d5097b0b2b98e0a17867ed28086dcb3c927cb6a Mon Sep 17 00:00:00 2001 From: Andreas Longva Date: Mon, 14 Nov 2022 09:33:08 +0100 Subject: [PATCH 06/22] Remove use of deprecated *Slice aliases in nalgebra --- src/base/blas.rs | 8 ++++---- src/base/conversion.rs | 24 ++++++++++++------------ src/base/ops.rs | 6 +++--- src/base/statistics.rs | 8 ++++---- src/linalg/solve.rs | 18 +++++++++--------- 5 files changed, 32 insertions(+), 32 deletions(-) diff --git a/src/base/blas.rs b/src/base/blas.rs index e65304b5..5f51cea9 100644 --- a/src/base/blas.rs +++ b/src/base/blas.rs @@ -11,7 +11,7 @@ use crate::base::dimension::{Const, Dim, Dynamic, U1, U2, U3, U4}; use crate::base::storage::{Storage, StorageMut}; use crate::base::uninit::Init; use crate::base::{ - DVectorSlice, DefaultAllocator, Matrix, Scalar, SquareMatrix, Vector, VectorSlice, + DVectorView, DefaultAllocator, Matrix, Scalar, SquareMatrix, Vector, VectorView, }; /// # Dot/scalar product @@ -363,8 +363,8 @@ where x: &Vector, beta: T, dot: impl Fn( - &DVectorSlice<'_, T, SB::RStride, SB::CStride>, - &DVectorSlice<'_, T, SC::RStride, SC::CStride>, + &DVectorView<'_, T, SB::RStride, SB::CStride>, + &DVectorView<'_, T, SC::RStride, SC::CStride>, ) -> T, ) where T: One, @@ -506,7 +506,7 @@ where a: &Matrix, x: &Vector, beta: T, - dot: impl Fn(&VectorSlice<'_, T, R2, SB::RStride, SB::CStride>, &Vector) -> T, + dot: impl Fn(&VectorView<'_, T, R2, SB::RStride, SB::CStride>, &Vector) -> T, ) where T: One, SB: Storage, diff --git a/src/base/conversion.rs b/src/base/conversion.rs index 9b6df2c2..4c83796e 100644 --- a/src/base/conversion.rs +++ b/src/base/conversion.rs @@ -16,14 +16,14 @@ use crate::base::dimension::{ use crate::base::iter::{MatrixIter, MatrixIterMut}; use crate::base::storage::{IsContiguous, RawStorage, RawStorageMut}; use crate::base::{ - ArrayStorage, DVectorSlice, DVectorSliceMut, DefaultAllocator, Matrix, MatrixView, + ArrayStorage, DVectorView, DVectorViewMut, DefaultAllocator, Matrix, MatrixView, MatrixViewMut, OMatrix, Scalar, }; #[cfg(any(feature = "std", feature = "alloc"))] use crate::base::{DVector, RowDVector, VecStorage}; use crate::base::{ViewStorage, ViewStorageMut}; use crate::constraint::DimEq; -use crate::{IsNotStaticOne, RowSVector, SMatrix, SVector, VectorSlice, VectorSliceMut}; +use crate::{IsNotStaticOne, RowSVector, SMatrix, SVector, VectorView, VectorViewMut}; use std::mem::MaybeUninit; // TODO: too bad this won't work for slice conversions. @@ -126,19 +126,19 @@ impl From> for [T; D] { } impl<'a, T: Scalar, RStride: Dim, CStride: Dim, const D: usize> - From, RStride, CStride>> for [T; D] + From, RStride, CStride>> for [T; D] { #[inline] - fn from(vec: VectorSlice<'a, T, Const, RStride, CStride>) -> Self { + fn from(vec: VectorView<'a, T, Const, RStride, CStride>) -> Self { vec.into_owned().into() } } impl<'a, T: Scalar, RStride: Dim, CStride: Dim, const D: usize> - From, RStride, CStride>> for [T; D] + From, RStride, CStride>> for [T; D] { #[inline] - fn from(vec: VectorSliceMut<'a, T, Const, RStride, CStride>) -> Self { + fn from(vec: VectorViewMut<'a, T, Const, RStride, CStride>) -> Self { vec.into_owned().into() } } @@ -515,28 +515,28 @@ impl<'a, T: Scalar + Copy, R: Dim, C: Dim, S: RawStorageMut + IsContigu } } -impl<'a, T: Scalar + Copy> From<&'a [T]> for DVectorSlice<'a, T> { +impl<'a, T: Scalar + Copy> From<&'a [T]> for DVectorView<'a, T> { #[inline] fn from(slice: &'a [T]) -> Self { Self::from_slice(slice, slice.len()) } } -impl<'a, T: Scalar> From> for &'a [T] { - fn from(vec: DVectorSlice<'a, T>) -> &'a [T] { +impl<'a, T: Scalar> From> for &'a [T] { + fn from(vec: DVectorView<'a, T>) -> &'a [T] { vec.data.into_slice() } } -impl<'a, T: Scalar + Copy> From<&'a mut [T]> for DVectorSliceMut<'a, T> { +impl<'a, T: Scalar + Copy> From<&'a mut [T]> for DVectorViewMut<'a, T> { #[inline] fn from(slice: &'a mut [T]) -> Self { Self::from_slice(slice, slice.len()) } } -impl<'a, T: Scalar> From> for &'a mut [T] { - fn from(vec: DVectorSliceMut<'a, T>) -> &'a mut [T] { +impl<'a, T: Scalar> From> for &'a mut [T] { + fn from(vec: DVectorViewMut<'a, T>) -> &'a mut [T] { vec.data.into_slice_mut() } } diff --git a/src/base/ops.rs b/src/base/ops.rs index 6b6d0c45..60ed5e26 100644 --- a/src/base/ops.rs +++ b/src/base/ops.rs @@ -14,7 +14,7 @@ use crate::base::constraint::{ use crate::base::dimension::{Dim, DimMul, DimName, DimProd, Dynamic}; use crate::base::storage::{Storage, StorageMut}; use crate::base::uninit::Uninit; -use crate::base::{DefaultAllocator, Matrix, MatrixSum, OMatrix, Scalar, VectorSlice}; +use crate::base::{DefaultAllocator, Matrix, MatrixSum, OMatrix, Scalar, VectorView}; use crate::storage::IsContiguous; use crate::uninit::{Init, InitStatus}; use crate::{RawStorage, RawStorageMut, SimdComplexField}; @@ -703,8 +703,8 @@ where rhs: &Matrix, out: &mut Matrix, dot: impl Fn( - &VectorSlice<'_, T, R1, SA::RStride, SA::CStride>, - &VectorSlice<'_, T, R2, SB::RStride, SB::CStride>, + &VectorView<'_, T, R1, SA::RStride, SA::CStride>, + &VectorView<'_, T, R2, SB::RStride, SB::CStride>, ) -> T, ) where Status: InitStatus, diff --git a/src/base/statistics.rs b/src/base/statistics.rs index 320cd12f..9f0e0ee6 100644 --- a/src/base/statistics.rs +++ b/src/base/statistics.rs @@ -1,6 +1,6 @@ use crate::allocator::Allocator; use crate::storage::RawStorage; -use crate::{Const, DefaultAllocator, Dim, Matrix, OVector, RowOVector, Scalar, VectorSlice, U1}; +use crate::{Const, DefaultAllocator, Dim, Matrix, OVector, RowOVector, Scalar, VectorView, U1}; use num::{One, Zero}; use simba::scalar::{ClosedAdd, ClosedMul, Field, SupersetOf}; use std::mem::MaybeUninit; @@ -13,7 +13,7 @@ impl> Matrix { #[must_use] pub fn compress_rows( &self, - f: impl Fn(VectorSlice<'_, T, R, S::RStride, S::CStride>) -> T, + f: impl Fn(VectorView<'_, T, R, S::RStride, S::CStride>) -> T, ) -> RowOVector where DefaultAllocator: Allocator, @@ -41,7 +41,7 @@ impl> Matrix { #[must_use] pub fn compress_rows_tr( &self, - f: impl Fn(VectorSlice<'_, T, R, S::RStride, S::CStride>) -> T, + f: impl Fn(VectorView<'_, T, R, S::RStride, S::CStride>) -> T, ) -> OVector where DefaultAllocator: Allocator, @@ -67,7 +67,7 @@ impl> Matrix { pub fn compress_columns( &self, init: OVector, - f: impl Fn(&mut OVector, VectorSlice<'_, T, R, S::RStride, S::CStride>), + f: impl Fn(&mut OVector, VectorView<'_, T, R, S::RStride, S::CStride>), ) -> OVector where DefaultAllocator: Allocator, diff --git a/src/linalg/solve.rs b/src/linalg/solve.rs index 7409e7fb..c355f2d0 100644 --- a/src/linalg/solve.rs +++ b/src/linalg/solve.rs @@ -5,7 +5,7 @@ use crate::base::allocator::Allocator; use crate::base::constraint::{SameNumberOfRows, ShapeConstraint}; use crate::base::dimension::{Dim, U1}; use crate::base::storage::{Storage, StorageMut}; -use crate::base::{DVectorSlice, DefaultAllocator, Matrix, OMatrix, SquareMatrix, Vector}; +use crate::base::{DVectorView, DefaultAllocator, Matrix, OMatrix, SquareMatrix, Vector}; impl> SquareMatrix { /// Computes the solution of the linear system `self . x = b` where `x` is the unknown and only @@ -376,8 +376,8 @@ impl> SquareMatrix { b: &mut Vector, conjugate: impl Fn(T) -> T, dot: impl Fn( - &DVectorSlice<'_, T, S::RStride, S::CStride>, - &DVectorSlice<'_, T, S2::RStride, S2::CStride>, + &DVectorView<'_, T, S::RStride, S::CStride>, + &DVectorView<'_, T, S2::RStride, S2::CStride>, ) -> T, ) -> bool where @@ -411,8 +411,8 @@ impl> SquareMatrix { b: &mut Vector, conjugate: impl Fn(T) -> T, dot: impl Fn( - &DVectorSlice<'_, T, S::RStride, S::CStride>, - &DVectorSlice<'_, T, S2::RStride, S2::CStride>, + &DVectorView<'_, T, S::RStride, S::CStride>, + &DVectorView<'_, T, S2::RStride, S2::CStride>, ) -> T, ) -> bool where @@ -734,8 +734,8 @@ impl> SquareMatrix { b: &mut Vector, conjugate: impl Fn(T) -> T, dot: impl Fn( - &DVectorSlice<'_, T, S::RStride, S::CStride>, - &DVectorSlice<'_, T, S2::RStride, S2::CStride>, + &DVectorView<'_, T, S::RStride, S::CStride>, + &DVectorView<'_, T, S2::RStride, S2::CStride>, ) -> T, ) where S2: StorageMut, @@ -760,8 +760,8 @@ impl> SquareMatrix { b: &mut Vector, conjugate: impl Fn(T) -> T, dot: impl Fn( - &DVectorSlice<'_, T, S::RStride, S::CStride>, - &DVectorSlice<'_, T, S2::RStride, S2::CStride>, + &DVectorView<'_, T, S::RStride, S::CStride>, + &DVectorView<'_, T, S2::RStride, S2::CStride>, ) -> T, ) where S2: StorageMut, From f792b5f5684f85c4eabacd5be6292361a69c4d5f Mon Sep 17 00:00:00 2001 From: Andreas Longva Date: Mon, 14 Nov 2022 09:37:21 +0100 Subject: [PATCH 07/22] Deprecate MatrixSliceMutMN In the past, MatrixSliceMut did not have the same defaults. However, for a while now MatrixSliceMut has served the exact same purpose (in fact their definitions are identical), so we should deprecate MatrixSliceMutMN. --- src/base/alias_slice.rs | 1 + src/base/construction_slice.rs | 10 +++++----- 2 files changed, 6 insertions(+), 5 deletions(-) diff --git a/src/base/alias_slice.rs b/src/base/alias_slice.rs index d0fb6676..3fb5d793 100644 --- a/src/base/alias_slice.rs +++ b/src/base/alias_slice.rs @@ -371,6 +371,7 @@ pub type VectorSlice6<'a, T, RStride = U1, CStride = U6> = /// A column-major matrix slice with `R` rows and `C` columns. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = "Use MatrixViewMut instead, which has an identical definition."] pub type MatrixSliceMutMN<'a, T, R, C, RStride = U1, CStride = R> = Matrix>; diff --git a/src/base/construction_slice.rs b/src/base/construction_slice.rs index d6a1f708..aa355264 100644 --- a/src/base/construction_slice.rs +++ b/src/base/construction_slice.rs @@ -1,6 +1,6 @@ use crate::base::dimension::{Const, Dim, DimName, Dynamic}; use crate::base::matrix_view::{ViewStorage, ViewStorageMut}; -use crate::base::{MatrixView, MatrixSliceMutMN, Scalar}; +use crate::base::{MatrixView, MatrixViewMut, Scalar}; use num_rational::Ratio; @@ -144,7 +144,7 @@ impl_constructors!(Dynamic, Dynamic; /// # Creating mutable matrix slices from `&mut [T]` impl<'a, T: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim> - MatrixSliceMutMN<'a, T, R, C, RStride, CStride> + MatrixViewMut<'a, T, R, C, RStride, CStride> { /// Creates, without bound-checking, a mutable matrix slice from an array and with dimensions and strides specified by generic types instances. /// @@ -217,7 +217,7 @@ impl<'a, T: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim> } } -impl<'a, T: Scalar, R: Dim, C: Dim> MatrixSliceMutMN<'a, T, R, C> { +impl<'a, T: Scalar, R: Dim, C: Dim> MatrixViewMut<'a, T, R, C> { /// Creates, without bound-checking, a mutable matrix slice from an array and with dimensions specified by generic types instances. /// /// # Safety @@ -247,7 +247,7 @@ impl<'a, T: Scalar, R: Dim, C: Dim> MatrixSliceMutMN<'a, T, R, C> { macro_rules! impl_constructors_mut( ($($Dims: ty),*; $(=> $DimIdent: ident: $DimBound: ident),*; $($gargs: expr),*; $($args: ident),*) => { - impl<'a, T: Scalar, $($DimIdent: $DimBound),*> MatrixSliceMutMN<'a, T, $($Dims),*> { + impl<'a, T: Scalar, $($DimIdent: $DimBound),*> MatrixViewMut<'a, T, $($Dims),*> { /// Creates a new mutable matrix slice from the given data array. /// /// Panics if `data` does not contain enough elements. @@ -263,7 +263,7 @@ macro_rules! impl_constructors_mut( } } - impl<'a, T: Scalar, $($DimIdent: $DimBound, )*> MatrixSliceMutMN<'a, T, $($Dims,)* Dynamic, Dynamic> { + impl<'a, T: Scalar, $($DimIdent: $DimBound, )*> MatrixViewMut<'a, T, $($Dims,)* Dynamic, Dynamic> { /// Creates a new mutable matrix slice with the specified strides from the given data array. /// /// Panics if `data` does not contain enough elements. From 2ca4b3b02d8ad96ebe9be1896ef9e4c2b44ae192 Mon Sep 17 00:00:00 2001 From: Andreas Longva Date: Mon, 14 Nov 2022 09:41:03 +0100 Subject: [PATCH 08/22] Deprecate MatrixSliceMutN There is no other type alias with this naming convention. I believe it is a remnant from the past, when we had e.g. MatrixN type aliases. But these no longer exist, therefore I believe this alias should also be removed, instead of updated to "MatrixViewMutN". --- src/base/alias_slice.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/src/base/alias_slice.rs b/src/base/alias_slice.rs index 3fb5d793..f71262d4 100644 --- a/src/base/alias_slice.rs +++ b/src/base/alias_slice.rs @@ -378,6 +378,7 @@ pub type MatrixSliceMutMN<'a, T, R, C, RStride = U1, CStride = R> = /// A column-major matrix slice with `D` rows and columns. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** +#[deprecated = "Use MatrixViewMut instead."] pub type MatrixSliceMutN<'a, T, D, RStride = U1, CStride = D> = Matrix>; From a68d9b5dedf84101b4ad4f0d6f10a3ef6c4f26e8 Mon Sep 17 00:00:00 2001 From: Andreas Longva Date: Mon, 14 Nov 2022 09:42:59 +0100 Subject: [PATCH 09/22] Rename construction_slice.rs -> construction_view.rs --- src/base/{construction_slice.rs => construction_view.rs} | 0 src/base/mod.rs | 2 +- 2 files changed, 1 insertion(+), 1 deletion(-) rename src/base/{construction_slice.rs => construction_view.rs} (100%) diff --git a/src/base/construction_slice.rs b/src/base/construction_view.rs similarity index 100% rename from src/base/construction_slice.rs rename to src/base/construction_view.rs diff --git a/src/base/mod.rs b/src/base/mod.rs index 6fb3685d..dfe7cc8d 100644 --- a/src/base/mod.rs +++ b/src/base/mod.rs @@ -18,7 +18,7 @@ mod cg; mod componentwise; #[macro_use] mod construction; -mod construction_slice; +mod construction_view; mod conversion; mod edition; pub mod indexing; From eb456f18bb89490f6538d383fcdfe87a46ed886b Mon Sep 17 00:00:00 2001 From: Andreas Longva Date: Mon, 14 Nov 2022 10:56:13 +0100 Subject: [PATCH 10/22] Move slice deprecation macro to lib.rs This way we can use it across the library, in changes that will follow this commit. --- src/base/alias_slice.rs | 245 +++++++++++++++++++--------------------- src/lib.rs | 13 +++ 2 files changed, 132 insertions(+), 126 deletions(-) diff --git a/src/base/alias_slice.rs b/src/base/alias_slice.rs index f71262d4..d3f8879a 100644 --- a/src/base/alias_slice.rs +++ b/src/base/alias_slice.rs @@ -1,14 +1,7 @@ use crate::base::dimension::{Dynamic, U1, U2, U3, U4, U5, U6}; use crate::base::matrix_view::{ViewStorage, ViewStorageMut}; use crate::base::{Const, Matrix}; - -/// Generates an appropriate deprecation note with a suggestion for replacement. -macro_rules! deprecation_note { - ($replacement:ident) => { - concat!("Use ", stringify!($replacement), - r###" instead. See [issue #1076](https://github.com/dimforge/nalgebra/issues/1076) for more information."###) - } -} +use crate::slice_deprecation_note; /* * @@ -21,343 +14,343 @@ macro_rules! deprecation_note { /// A column-major matrix slice with dimensions known at compile-time. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(SMatrixView)] +#[deprecated = slice_deprecation_note!(SMatrixView)] pub type SMatrixSlice<'a, T, const R: usize, const C: usize> = Matrix, Const, ViewStorage<'a, T, Const, Const, Const<1>, Const>>; /// A column-major matrix slice dynamic numbers of rows and columns. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(DMatrixView)] +#[deprecated = slice_deprecation_note!(DMatrixView)] pub type DMatrixSlice<'a, T, RStride = U1, CStride = Dynamic> = Matrix>; /// A column-major 1x1 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixView1)] +#[deprecated = slice_deprecation_note!(MatrixView1)] pub type MatrixSlice1<'a, T, RStride = U1, CStride = U1> = Matrix>; /// A column-major 2x2 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixView2)] +#[deprecated = slice_deprecation_note!(MatrixView2)] pub type MatrixSlice2<'a, T, RStride = U1, CStride = U2> = Matrix>; /// A column-major 3x3 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixView3)] +#[deprecated = slice_deprecation_note!(MatrixView3)] pub type MatrixSlice3<'a, T, RStride = U1, CStride = U3> = Matrix>; /// A column-major 4x4 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixView4)] +#[deprecated = slice_deprecation_note!(MatrixView4)] pub type MatrixSlice4<'a, T, RStride = U1, CStride = U4> = Matrix>; /// A column-major 5x5 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixView5)] +#[deprecated = slice_deprecation_note!(MatrixView5)] pub type MatrixSlice5<'a, T, RStride = U1, CStride = U5> = Matrix>; /// A column-major 6x6 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixView6)] +#[deprecated = slice_deprecation_note!(MatrixView6)] pub type MatrixSlice6<'a, T, RStride = U1, CStride = U6> = Matrix>; /// A column-major 1x2 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixView1x2)] +#[deprecated = slice_deprecation_note!(MatrixView1x2)] pub type MatrixSlice1x2<'a, T, RStride = U1, CStride = U1> = Matrix>; /// A column-major 1x3 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixView1x3)] +#[deprecated = slice_deprecation_note!(MatrixView1x3)] pub type MatrixSlice1x3<'a, T, RStride = U1, CStride = U1> = Matrix>; /// A column-major 1x4 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixView1x4)] +#[deprecated = slice_deprecation_note!(MatrixView1x4)] pub type MatrixSlice1x4<'a, T, RStride = U1, CStride = U1> = Matrix>; /// A column-major 1x5 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixView1x5)] +#[deprecated = slice_deprecation_note!(MatrixView1x5)] pub type MatrixSlice1x5<'a, T, RStride = U1, CStride = U1> = Matrix>; /// A column-major 1x6 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixView1x6)] +#[deprecated = slice_deprecation_note!(MatrixView1x6)] pub type MatrixSlice1x6<'a, T, RStride = U1, CStride = U1> = Matrix>; /// A column-major 2x1 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixView2x1)] +#[deprecated = slice_deprecation_note!(MatrixView2x1)] pub type MatrixSlice2x1<'a, T, RStride = U1, CStride = U2> = Matrix>; /// A column-major 2x3 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixView2x3)] +#[deprecated = slice_deprecation_note!(MatrixView2x3)] pub type MatrixSlice2x3<'a, T, RStride = U1, CStride = U2> = Matrix>; /// A column-major 2x4 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixView2x4)] +#[deprecated = slice_deprecation_note!(MatrixView2x4)] pub type MatrixSlice2x4<'a, T, RStride = U1, CStride = U2> = Matrix>; /// A column-major 2x5 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixView2x5)] +#[deprecated = slice_deprecation_note!(MatrixView2x5)] pub type MatrixSlice2x5<'a, T, RStride = U1, CStride = U2> = Matrix>; /// A column-major 2x6 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixView2x6)] +#[deprecated = slice_deprecation_note!(MatrixView2x6)] pub type MatrixSlice2x6<'a, T, RStride = U1, CStride = U2> = Matrix>; /// A column-major 3x1 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixView3x1)] +#[deprecated = slice_deprecation_note!(MatrixView3x1)] pub type MatrixSlice3x1<'a, T, RStride = U1, CStride = U3> = Matrix>; /// A column-major 3x2 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixView3x2)] +#[deprecated = slice_deprecation_note!(MatrixView3x2)] pub type MatrixSlice3x2<'a, T, RStride = U1, CStride = U3> = Matrix>; /// A column-major 3x4 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixView3x4)] +#[deprecated = slice_deprecation_note!(MatrixView3x4)] pub type MatrixSlice3x4<'a, T, RStride = U1, CStride = U3> = Matrix>; /// A column-major 3x5 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixView3x5)] +#[deprecated = slice_deprecation_note!(MatrixView3x5)] pub type MatrixSlice3x5<'a, T, RStride = U1, CStride = U3> = Matrix>; /// A column-major 3x6 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixView3x6)] +#[deprecated = slice_deprecation_note!(MatrixView3x6)] pub type MatrixSlice3x6<'a, T, RStride = U1, CStride = U3> = Matrix>; /// A column-major 4x1 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixView4x1)] +#[deprecated = slice_deprecation_note!(MatrixView4x1)] pub type MatrixSlice4x1<'a, T, RStride = U1, CStride = U4> = Matrix>; /// A column-major 4x2 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixView4x2)] +#[deprecated = slice_deprecation_note!(MatrixView4x2)] pub type MatrixSlice4x2<'a, T, RStride = U1, CStride = U4> = Matrix>; /// A column-major 4x3 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixView4x3)] +#[deprecated = slice_deprecation_note!(MatrixView4x3)] pub type MatrixSlice4x3<'a, T, RStride = U1, CStride = U4> = Matrix>; /// A column-major 4x5 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixView4x5)] +#[deprecated = slice_deprecation_note!(MatrixView4x5)] pub type MatrixSlice4x5<'a, T, RStride = U1, CStride = U4> = Matrix>; /// A column-major 4x6 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixView4x6)] +#[deprecated = slice_deprecation_note!(MatrixView4x6)] pub type MatrixSlice4x6<'a, T, RStride = U1, CStride = U4> = Matrix>; /// A column-major 5x1 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixView5x1)] +#[deprecated = slice_deprecation_note!(MatrixView5x1)] pub type MatrixSlice5x1<'a, T, RStride = U1, CStride = U5> = Matrix>; /// A column-major 5x2 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixView5x2)] +#[deprecated = slice_deprecation_note!(MatrixView5x2)] pub type MatrixSlice5x2<'a, T, RStride = U1, CStride = U5> = Matrix>; /// A column-major 5x3 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixView5x3)] +#[deprecated = slice_deprecation_note!(MatrixView5x3)] pub type MatrixSlice5x3<'a, T, RStride = U1, CStride = U5> = Matrix>; /// A column-major 5x4 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixView5x4)] +#[deprecated = slice_deprecation_note!(MatrixView5x4)] pub type MatrixSlice5x4<'a, T, RStride = U1, CStride = U5> = Matrix>; /// A column-major 5x6 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixView5x6)] +#[deprecated = slice_deprecation_note!(MatrixView5x6)] pub type MatrixSlice5x6<'a, T, RStride = U1, CStride = U5> = Matrix>; /// A column-major 6x1 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixView6x1)] +#[deprecated = slice_deprecation_note!(MatrixView6x1)] pub type MatrixSlice6x1<'a, T, RStride = U1, CStride = U6> = Matrix>; /// A column-major 6x2 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixView6x2)] +#[deprecated = slice_deprecation_note!(MatrixView6x2)] pub type MatrixSlice6x2<'a, T, RStride = U1, CStride = U6> = Matrix>; /// A column-major 6x3 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixView6x3)] +#[deprecated = slice_deprecation_note!(MatrixView6x3)] pub type MatrixSlice6x3<'a, T, RStride = U1, CStride = U6> = Matrix>; /// A column-major 6x4 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixView6x4)] +#[deprecated = slice_deprecation_note!(MatrixView6x4)] pub type MatrixSlice6x4<'a, T, RStride = U1, CStride = U6> = Matrix>; /// A column-major 6x5 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixView6x5)] +#[deprecated = slice_deprecation_note!(MatrixView6x5)] pub type MatrixSlice6x5<'a, T, RStride = U1, CStride = U6> = Matrix>; /// A column-major matrix slice with 1 row and a number of columns chosen at runtime. -#[deprecated = deprecation_note!(MatrixView1xX)] +#[deprecated = slice_deprecation_note!(MatrixView1xX)] pub type MatrixSlice1xX<'a, T, RStride = U1, CStride = U1> = Matrix>; /// A column-major matrix slice with 2 rows and a number of columns chosen at runtime. -#[deprecated = deprecation_note!(MatrixView2xX)] +#[deprecated = slice_deprecation_note!(MatrixView2xX)] pub type MatrixSlice2xX<'a, T, RStride = U1, CStride = U2> = Matrix>; /// A column-major matrix slice with 3 rows and a number of columns chosen at runtime. -#[deprecated = deprecation_note!(MatrixView3xX)] +#[deprecated = slice_deprecation_note!(MatrixView3xX)] pub type MatrixSlice3xX<'a, T, RStride = U1, CStride = U3> = Matrix>; /// A column-major matrix slice with 4 rows and a number of columns chosen at runtime. -#[deprecated = deprecation_note!(MatrixView4xX)] +#[deprecated = slice_deprecation_note!(MatrixView4xX)] pub type MatrixSlice4xX<'a, T, RStride = U1, CStride = U4> = Matrix>; /// A column-major matrix slice with 5 rows and a number of columns chosen at runtime. -#[deprecated = deprecation_note!(MatrixView5xX)] +#[deprecated = slice_deprecation_note!(MatrixView5xX)] pub type MatrixSlice5xX<'a, T, RStride = U1, CStride = U5> = Matrix>; /// A column-major matrix slice with 6 rows and a number of columns chosen at runtime. -#[deprecated = deprecation_note!(MatrixView6xX)] +#[deprecated = slice_deprecation_note!(MatrixView6xX)] pub type MatrixSlice6xX<'a, T, RStride = U1, CStride = U6> = Matrix>; /// A column-major matrix slice with a number of rows chosen at runtime and 1 column. -#[deprecated = deprecation_note!(MatrixViewXx1)] +#[deprecated = slice_deprecation_note!(MatrixViewXx1)] pub type MatrixSliceXx1<'a, T, RStride = U1, CStride = Dynamic> = Matrix>; /// A column-major matrix slice with a number of rows chosen at runtime and 2 columns. -#[deprecated = deprecation_note!(MatrixViewXx2)] +#[deprecated = slice_deprecation_note!(MatrixViewXx2)] pub type MatrixSliceXx2<'a, T, RStride = U1, CStride = Dynamic> = Matrix>; /// A column-major matrix slice with a number of rows chosen at runtime and 3 columns. -#[deprecated = deprecation_note!(MatrixViewXx3)] +#[deprecated = slice_deprecation_note!(MatrixViewXx3)] pub type MatrixSliceXx3<'a, T, RStride = U1, CStride = Dynamic> = Matrix>; /// A column-major matrix slice with a number of rows chosen at runtime and 4 columns. -#[deprecated = deprecation_note!(MatrixViewXx4)] +#[deprecated = slice_deprecation_note!(MatrixViewXx4)] pub type MatrixSliceXx4<'a, T, RStride = U1, CStride = Dynamic> = Matrix>; /// A column-major matrix slice with a number of rows chosen at runtime and 5 columns. -#[deprecated = deprecation_note!(MatrixViewXx5)] +#[deprecated = slice_deprecation_note!(MatrixViewXx5)] pub type MatrixSliceXx5<'a, T, RStride = U1, CStride = Dynamic> = Matrix>; /// A column-major matrix slice with a number of rows chosen at runtime and 6 columns. -#[deprecated = deprecation_note!(MatrixViewXx6)] +#[deprecated = slice_deprecation_note!(MatrixViewXx6)] pub type MatrixSliceXx6<'a, T, RStride = U1, CStride = Dynamic> = Matrix>; /// A column vector slice with dimensions known at compile-time. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(VectorView)] +#[deprecated = slice_deprecation_note!(VectorView)] pub type VectorSlice<'a, T, D, RStride = U1, CStride = D> = Matrix>; /// A column vector slice with dimensions known at compile-time. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(SVectorView)] +#[deprecated = slice_deprecation_note!(SVectorView)] pub type SVectorSlice<'a, T, const D: usize> = Matrix, Const<1>, ViewStorage<'a, T, Const, Const<1>, Const<1>, Const>>; /// A column vector slice dynamic numbers of rows and columns. -#[deprecated = deprecation_note!(DVectorView)] +#[deprecated = slice_deprecation_note!(DVectorView)] pub type DVectorSlice<'a, T, RStride = U1, CStride = Dynamic> = Matrix>; /// A 1D column vector slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(VectorView1)] +#[deprecated = slice_deprecation_note!(VectorView1)] pub type VectorSlice1<'a, T, RStride = U1, CStride = U1> = Matrix>; /// A 2D column vector slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(VectorView2)] +#[deprecated = slice_deprecation_note!(VectorView2)] pub type VectorSlice2<'a, T, RStride = U1, CStride = U2> = Matrix>; /// A 3D column vector slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(VectorView3)] +#[deprecated = slice_deprecation_note!(VectorView3)] pub type VectorSlice3<'a, T, RStride = U1, CStride = U3> = Matrix>; /// A 4D column vector slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(VectorView4)] +#[deprecated = slice_deprecation_note!(VectorView4)] pub type VectorSlice4<'a, T, RStride = U1, CStride = U4> = Matrix>; /// A 5D column vector slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(VectorView5)] +#[deprecated = slice_deprecation_note!(VectorView5)] pub type VectorSlice5<'a, T, RStride = U1, CStride = U5> = Matrix>; /// A 6D column vector slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(VectorView6)] +#[deprecated = slice_deprecation_note!(VectorView6)] pub type VectorSlice6<'a, T, RStride = U1, CStride = U6> = Matrix>; @@ -385,344 +378,344 @@ pub type MatrixSliceMutN<'a, T, D, RStride = U1, CStride = D> = /// A column-major matrix slice with dimensions known at compile-time. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(SMatrixViewMut)] +#[deprecated = slice_deprecation_note!(SMatrixViewMut)] pub type SMatrixSliceMut<'a, T, const R: usize, const C: usize> = Matrix, Const, ViewStorageMut<'a, T, Const, Const, Const<1>, Const>>; /// A column-major matrix slice dynamic numbers of rows and columns. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(DMatrixViewMut)] +#[deprecated = slice_deprecation_note!(DMatrixViewMut)] pub type DMatrixSliceMut<'a, T, RStride = U1, CStride = Dynamic> = Matrix>; /// A column-major 1x1 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixViewMut1)] +#[deprecated = slice_deprecation_note!(MatrixViewMut1)] pub type MatrixSliceMut1<'a, T, RStride = U1, CStride = U1> = Matrix>; /// A column-major 2x2 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixViewMut2)] +#[deprecated = slice_deprecation_note!(MatrixViewMut2)] pub type MatrixSliceMut2<'a, T, RStride = U1, CStride = U2> = Matrix>; /// A column-major 3x3 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixViewMut3)] +#[deprecated = slice_deprecation_note!(MatrixViewMut3)] pub type MatrixSliceMut3<'a, T, RStride = U1, CStride = U3> = Matrix>; /// A column-major 4x4 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixViewMut4)] +#[deprecated = slice_deprecation_note!(MatrixViewMut4)] pub type MatrixSliceMut4<'a, T, RStride = U1, CStride = U4> = Matrix>; /// A column-major 5x5 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixViewMut5)] +#[deprecated = slice_deprecation_note!(MatrixViewMut5)] pub type MatrixSliceMut5<'a, T, RStride = U1, CStride = U5> = Matrix>; /// A column-major 6x6 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixViewMut6)] +#[deprecated = slice_deprecation_note!(MatrixViewMut6)] pub type MatrixSliceMut6<'a, T, RStride = U1, CStride = U6> = Matrix>; /// A column-major 1x2 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixViewMut1x2)] +#[deprecated = slice_deprecation_note!(MatrixViewMut1x2)] pub type MatrixSliceMut1x2<'a, T, RStride = U1, CStride = U1> = Matrix>; /// A column-major 1x3 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixViewMut1x3)] +#[deprecated = slice_deprecation_note!(MatrixViewMut1x3)] pub type MatrixSliceMut1x3<'a, T, RStride = U1, CStride = U1> = Matrix>; /// A column-major 1x4 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixViewMut1x4)] +#[deprecated = slice_deprecation_note!(MatrixViewMut1x4)] pub type MatrixSliceMut1x4<'a, T, RStride = U1, CStride = U1> = Matrix>; /// A column-major 1x5 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixViewMut1x5)] +#[deprecated = slice_deprecation_note!(MatrixViewMut1x5)] pub type MatrixSliceMut1x5<'a, T, RStride = U1, CStride = U1> = Matrix>; /// A column-major 1x6 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixViewMut1x6)] +#[deprecated = slice_deprecation_note!(MatrixViewMut1x6)] pub type MatrixSliceMut1x6<'a, T, RStride = U1, CStride = U1> = Matrix>; /// A column-major 2x1 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixViewMut2x1)] +#[deprecated = slice_deprecation_note!(MatrixViewMut2x1)] pub type MatrixSliceMut2x1<'a, T, RStride = U1, CStride = U2> = Matrix>; /// A column-major 2x3 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixViewMut2x3)] +#[deprecated = slice_deprecation_note!(MatrixViewMut2x3)] pub type MatrixSliceMut2x3<'a, T, RStride = U1, CStride = U2> = Matrix>; /// A column-major 2x4 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixViewMut2x4)] +#[deprecated = slice_deprecation_note!(MatrixViewMut2x4)] pub type MatrixSliceMut2x4<'a, T, RStride = U1, CStride = U2> = Matrix>; /// A column-major 2x5 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixViewMut2x5)] +#[deprecated = slice_deprecation_note!(MatrixViewMut2x5)] pub type MatrixSliceMut2x5<'a, T, RStride = U1, CStride = U2> = Matrix>; /// A column-major 2x6 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixViewMut2x6)] +#[deprecated = slice_deprecation_note!(MatrixViewMut2x6)] pub type MatrixSliceMut2x6<'a, T, RStride = U1, CStride = U2> = Matrix>; /// A column-major 3x1 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixViewMut3x1)] +#[deprecated = slice_deprecation_note!(MatrixViewMut3x1)] pub type MatrixSliceMut3x1<'a, T, RStride = U1, CStride = U3> = Matrix>; /// A column-major 3x2 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixViewMut3x2)] +#[deprecated = slice_deprecation_note!(MatrixViewMut3x2)] pub type MatrixSliceMut3x2<'a, T, RStride = U1, CStride = U3> = Matrix>; /// A column-major 3x4 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixViewMut3x4)] +#[deprecated = slice_deprecation_note!(MatrixViewMut3x4)] pub type MatrixSliceMut3x4<'a, T, RStride = U1, CStride = U3> = Matrix>; /// A column-major 3x5 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixViewMut3x5)] +#[deprecated = slice_deprecation_note!(MatrixViewMut3x5)] pub type MatrixSliceMut3x5<'a, T, RStride = U1, CStride = U3> = Matrix>; /// A column-major 3x6 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixViewMut3x6)] +#[deprecated = slice_deprecation_note!(MatrixViewMut3x6)] pub type MatrixSliceMut3x6<'a, T, RStride = U1, CStride = U3> = Matrix>; /// A column-major 4x1 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixViewMut4x1)] +#[deprecated = slice_deprecation_note!(MatrixViewMut4x1)] pub type MatrixSliceMut4x1<'a, T, RStride = U1, CStride = U4> = Matrix>; /// A column-major 4x2 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixViewMut4x2)] +#[deprecated = slice_deprecation_note!(MatrixViewMut4x2)] pub type MatrixSliceMut4x2<'a, T, RStride = U1, CStride = U4> = Matrix>; /// A column-major 4x3 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixViewMut4x3)] +#[deprecated = slice_deprecation_note!(MatrixViewMut4x3)] pub type MatrixSliceMut4x3<'a, T, RStride = U1, CStride = U4> = Matrix>; /// A column-major 4x5 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixViewMut4x5)] +#[deprecated = slice_deprecation_note!(MatrixViewMut4x5)] pub type MatrixSliceMut4x5<'a, T, RStride = U1, CStride = U4> = Matrix>; /// A column-major 4x6 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixViewMut4x6)] +#[deprecated = slice_deprecation_note!(MatrixViewMut4x6)] pub type MatrixSliceMut4x6<'a, T, RStride = U1, CStride = U4> = Matrix>; /// A column-major 5x1 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixViewMut5x1)] +#[deprecated = slice_deprecation_note!(MatrixViewMut5x1)] pub type MatrixSliceMut5x1<'a, T, RStride = U1, CStride = U5> = Matrix>; /// A column-major 5x2 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixViewMut5x2)] +#[deprecated = slice_deprecation_note!(MatrixViewMut5x2)] pub type MatrixSliceMut5x2<'a, T, RStride = U1, CStride = U5> = Matrix>; /// A column-major 5x3 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixViewMut5x3)] +#[deprecated = slice_deprecation_note!(MatrixViewMut5x3)] pub type MatrixSliceMut5x3<'a, T, RStride = U1, CStride = U5> = Matrix>; /// A column-major 5x4 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixViewMut5x4)] +#[deprecated = slice_deprecation_note!(MatrixViewMut5x4)] pub type MatrixSliceMut5x4<'a, T, RStride = U1, CStride = U5> = Matrix>; /// A column-major 5x6 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixViewMut5x6)] +#[deprecated = slice_deprecation_note!(MatrixViewMut5x6)] pub type MatrixSliceMut5x6<'a, T, RStride = U1, CStride = U5> = Matrix>; /// A column-major 6x1 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixViewMut6x1)] +#[deprecated = slice_deprecation_note!(MatrixViewMut6x1)] pub type MatrixSliceMut6x1<'a, T, RStride = U1, CStride = U6> = Matrix>; /// A column-major 6x2 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixViewMut6x2)] +#[deprecated = slice_deprecation_note!(MatrixViewMut6x2)] pub type MatrixSliceMut6x2<'a, T, RStride = U1, CStride = U6> = Matrix>; /// A column-major 6x3 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixViewMut6x3)] +#[deprecated = slice_deprecation_note!(MatrixViewMut6x3)] pub type MatrixSliceMut6x3<'a, T, RStride = U1, CStride = U6> = Matrix>; /// A column-major 6x4 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixViewMut6x4)] +#[deprecated = slice_deprecation_note!(MatrixViewMut6x4)] pub type MatrixSliceMut6x4<'a, T, RStride = U1, CStride = U6> = Matrix>; /// A column-major 6x5 matrix slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(MatrixViewMut6x5)] +#[deprecated = slice_deprecation_note!(MatrixViewMut6x5)] pub type MatrixSliceMut6x5<'a, T, RStride = U1, CStride = U6> = Matrix>; /// A column-major matrix slice with 1 row and a number of columns chosen at runtime. -#[deprecated = deprecation_note!(MatrixViewMut1xX)] +#[deprecated = slice_deprecation_note!(MatrixViewMut1xX)] pub type MatrixSliceMut1xX<'a, T, RStride = U1, CStride = U1> = Matrix>; /// A column-major matrix slice with 2 rows and a number of columns chosen at runtime. -#[deprecated = deprecation_note!(MatrixViewMut2xX)] +#[deprecated = slice_deprecation_note!(MatrixViewMut2xX)] pub type MatrixSliceMut2xX<'a, T, RStride = U1, CStride = U2> = Matrix>; /// A column-major matrix slice with 3 rows and a number of columns chosen at runtime. -#[deprecated = deprecation_note!(MatrixViewMut3xX)] +#[deprecated = slice_deprecation_note!(MatrixViewMut3xX)] pub type MatrixSliceMut3xX<'a, T, RStride = U1, CStride = U3> = Matrix>; /// A column-major matrix slice with 4 rows and a number of columns chosen at runtime. -#[deprecated = deprecation_note!(MatrixViewMut4xX)] +#[deprecated = slice_deprecation_note!(MatrixViewMut4xX)] pub type MatrixSliceMut4xX<'a, T, RStride = U1, CStride = U4> = Matrix>; /// A column-major matrix slice with 5 rows and a number of columns chosen at runtime. -#[deprecated = deprecation_note!(MatrixViewMut5xX)] +#[deprecated = slice_deprecation_note!(MatrixViewMut5xX)] pub type MatrixSliceMut5xX<'a, T, RStride = U1, CStride = U5> = Matrix>; /// A column-major matrix slice with 6 rows and a number of columns chosen at runtime. -#[deprecated = deprecation_note!(MatrixViewMut6xX)] +#[deprecated = slice_deprecation_note!(MatrixViewMut6xX)] pub type MatrixSliceMut6xX<'a, T, RStride = U1, CStride = U6> = Matrix>; /// A column-major matrix slice with a number of rows chosen at runtime and 1 column. -#[deprecated = deprecation_note!(MatrixViewMutXx1)] +#[deprecated = slice_deprecation_note!(MatrixViewMutXx1)] pub type MatrixSliceMutXx1<'a, T, RStride = U1, CStride = Dynamic> = Matrix>; /// A column-major matrix slice with a number of rows chosen at runtime and 2 columns. -#[deprecated = deprecation_note!(MatrixViewMutXx2)] +#[deprecated = slice_deprecation_note!(MatrixViewMutXx2)] pub type MatrixSliceMutXx2<'a, T, RStride = U1, CStride = Dynamic> = Matrix>; /// A column-major matrix slice with a number of rows chosen at runtime and 3 columns. -#[deprecated = deprecation_note!(MatrixViewMutXx3)] +#[deprecated = slice_deprecation_note!(MatrixViewMutXx3)] pub type MatrixSliceMutXx3<'a, T, RStride = U1, CStride = Dynamic> = Matrix>; /// A column-major matrix slice with a number of rows chosen at runtime and 4 columns. -#[deprecated = deprecation_note!(MatrixViewMutXx4)] +#[deprecated = slice_deprecation_note!(MatrixViewMutXx4)] pub type MatrixSliceMutXx4<'a, T, RStride = U1, CStride = Dynamic> = Matrix>; /// A column-major matrix slice with a number of rows chosen at runtime and 5 columns. -#[deprecated = deprecation_note!(MatrixViewMutXx5)] +#[deprecated = slice_deprecation_note!(MatrixViewMutXx5)] pub type MatrixSliceMutXx5<'a, T, RStride = U1, CStride = Dynamic> = Matrix>; /// A column-major matrix slice with a number of rows chosen at runtime and 6 columns. -#[deprecated = deprecation_note!(MatrixViewMutXx6)] +#[deprecated = slice_deprecation_note!(MatrixViewMutXx6)] pub type MatrixSliceMutXx6<'a, T, RStride = U1, CStride = Dynamic> = Matrix>; /// A column vector slice with dimensions known at compile-time. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(VectorViewMut)] +#[deprecated = slice_deprecation_note!(VectorViewMut)] pub type VectorSliceMut<'a, T, D, RStride = U1, CStride = D> = Matrix>; /// A column vector slice with dimensions known at compile-time. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(SVectorViewMut)] +#[deprecated = slice_deprecation_note!(SVectorViewMut)] pub type SVectorSliceMut<'a, T, const D: usize> = Matrix, Const<1>, ViewStorageMut<'a, T, Const, Const<1>, Const<1>, Const>>; /// A column vector slice dynamic numbers of rows and columns. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(DVectorViewMut)] +#[deprecated = slice_deprecation_note!(DVectorViewMut)] pub type DVectorSliceMut<'a, T, RStride = U1, CStride = Dynamic> = Matrix>; /// A 1D column vector slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(VectorViewMut1)] +#[deprecated = slice_deprecation_note!(VectorViewMut1)] pub type VectorSliceMut1<'a, T, RStride = U1, CStride = U1> = Matrix>; /// A 2D column vector slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(VectorViewMut2)] +#[deprecated = slice_deprecation_note!(VectorViewMut2)] pub type VectorSliceMut2<'a, T, RStride = U1, CStride = U2> = Matrix>; /// A 3D column vector slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(VectorViewMut3)] +#[deprecated = slice_deprecation_note!(VectorViewMut3)] pub type VectorSliceMut3<'a, T, RStride = U1, CStride = U3> = Matrix>; /// A 4D column vector slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(VectorViewMut4)] +#[deprecated = slice_deprecation_note!(VectorViewMut4)] pub type VectorSliceMut4<'a, T, RStride = U1, CStride = U4> = Matrix>; /// A 5D column vector slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(VectorViewMut5)] +#[deprecated = slice_deprecation_note!(VectorViewMut5)] pub type VectorSliceMut5<'a, T, RStride = U1, CStride = U5> = Matrix>; /// A 6D column vector slice. /// /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.** -#[deprecated = deprecation_note!(VectorViewMut6)] +#[deprecated = slice_deprecation_note!(VectorViewMut6)] pub type VectorSliceMut6<'a, T, RStride = U1, CStride = U6> = Matrix>; diff --git a/src/lib.rs b/src/lib.rs index 86a5dc6b..e3e6b66b 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -97,6 +97,19 @@ an optimized set of tools for computer graphics and physics. Those features incl )] #![cfg_attr(not(feature = "std"), no_std)] +/// Generates an appropriate deprecation note with a suggestion for replacement. +/// +/// Used for deprecating slice types in various locations throughout the library. +/// See #1076 for more information. +macro_rules! slice_deprecation_note { + ($replacement:ident) => { + concat!("Use ", stringify!($replacement), + r###" instead. See [issue #1076](https://github.com/dimforge/nalgebra/issues/1076) for more information."###) + } +} + +pub(crate) use slice_deprecation_note; + #[cfg(feature = "rand-no-std")] extern crate rand_package as rand; From 0319d236af74b3960b493829ca245d37a8de7629 Mon Sep 17 00:00:00 2001 From: Andreas Longva Date: Mon, 14 Nov 2022 14:02:36 +0100 Subject: [PATCH 11/22] Deprecate+rename methods for slicing --- src/base/construction_view.rs | 36 ++--- src/base/indexing.rs | 2 +- src/base/matrix.rs | 14 +- src/base/matrix_view.rs | 277 +++++++++++++++++++++++----------- 4 files changed, 213 insertions(+), 116 deletions(-) diff --git a/src/base/construction_view.rs b/src/base/construction_view.rs index aa355264..fbb038cb 100644 --- a/src/base/construction_view.rs +++ b/src/base/construction_view.rs @@ -4,11 +4,11 @@ use crate::base::{MatrixView, MatrixViewMut, Scalar}; use num_rational::Ratio; -/// # Creating matrix slices from `&[T]` +/// # Creating matrix views from `&[T]` impl<'a, T: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim> MatrixView<'a, T, R, C, RStride, CStride> { - /// Creates, without bound-checking, a matrix slice from an array and with dimensions and strides specified by generic types instances. + /// Creates, without bounds checking, a matrix view from an array and with dimensions and strides specified by generic types instances. /// /// # Safety /// This method is unsafe because the input data array is not checked to contain enough elements. @@ -30,7 +30,7 @@ impl<'a, T: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim> Self::from_data(data) } - /// Creates a matrix slice from an array and with dimensions and strides specified by generic types instances. + /// Creates a matrix view from an array and with dimensions and strides specified by generic types instances. /// /// Panics if the input data array dose not contain enough elements. /// The generic types `R`, `C`, `RStride`, `CStride` can either be type-level integers or integers wrapped with `Dynamic::new()`. @@ -58,7 +58,7 @@ impl<'a, T: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim> } impl<'a, T: Scalar, R: Dim, C: Dim> MatrixView<'a, T, R, C> { - /// Creates, without bound-checking, a matrix slice from an array and with dimensions specified by generic types instances. + /// Creates, without bound-checking, a matrix view from an array and with dimensions specified by generic types instances. /// /// # Safety /// This method is unsafe because the input data array is not checked to contain enough elements. @@ -75,7 +75,7 @@ impl<'a, T: Scalar, R: Dim, C: Dim> MatrixView<'a, T, R, C> { ) } - /// Creates a matrix slice from an array and with dimensions and strides specified by generic types instances. + /// Creates a matrix view from an array and with dimensions and strides specified by generic types instances. /// /// Panics if the input data array dose not contain enough elements. /// The generic types `R` and `C` can either be type-level integers or integers wrapped with `Dynamic::new()`. @@ -88,7 +88,7 @@ impl<'a, T: Scalar, R: Dim, C: Dim> MatrixView<'a, T, R, C> { macro_rules! impl_constructors( ($($Dims: ty),*; $(=> $DimIdent: ident: $DimBound: ident),*; $($gargs: expr),*; $($args: ident),*) => { impl<'a, T: Scalar, $($DimIdent: $DimBound),*> MatrixView<'a, T, $($Dims),*> { - /// Creates a new matrix slice from the given data array. + /// Creates a new matrix view from the given data array. /// /// Panics if `data` does not contain enough elements. #[inline] @@ -96,7 +96,7 @@ macro_rules! impl_constructors( Self::from_slice_generic(data, $($gargs),*) } - /// Creates, without bound checking, a new matrix slice from the given data array. + /// Creates, without bound checking, a new matrix view from the given data array. #[inline] pub unsafe fn from_slice_unchecked(data: &'a [T], start: usize, $($args: usize),*) -> Self { Self::from_slice_generic_unchecked(data, start, $($gargs),*) @@ -104,7 +104,7 @@ macro_rules! impl_constructors( } impl<'a, T: Scalar, $($DimIdent: $DimBound, )*> MatrixView<'a, T, $($Dims,)* Dynamic, Dynamic> { - /// Creates a new matrix slice with the specified strides from the given data array. + /// Creates a new matrix view with the specified strides from the given data array. /// /// Panics if `data` does not contain enough elements. #[inline] @@ -112,7 +112,7 @@ macro_rules! impl_constructors( Self::from_slice_with_strides_generic(data, $($gargs,)* Dynamic::new(rstride), Dynamic::new(cstride)) } - /// Creates, without bound checking, a new matrix slice with the specified strides from the given data array. + /// Creates, without bound checking, a new matrix view with the specified strides from the given data array. #[inline] pub unsafe fn from_slice_with_strides_unchecked(data: &'a [T], start: usize, $($args: usize,)* rstride: usize, cstride: usize) -> Self { Self::from_slice_with_strides_generic_unchecked(data, start, $($gargs,)* Dynamic::new(rstride), Dynamic::new(cstride)) @@ -142,11 +142,11 @@ impl_constructors!(Dynamic, Dynamic; Dynamic::new(nrows), Dynamic::new(ncols); nrows, ncols); -/// # Creating mutable matrix slices from `&mut [T]` +/// # Creating mutable matrix views from `&mut [T]` impl<'a, T: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim> MatrixViewMut<'a, T, R, C, RStride, CStride> { - /// Creates, without bound-checking, a mutable matrix slice from an array and with dimensions and strides specified by generic types instances. + /// Creates, without bound-checking, a mutable matrix view from an array and with dimensions and strides specified by generic types instances. /// /// # Safety /// This method is unsafe because the input data array is not checked to contain enough elements. @@ -168,7 +168,7 @@ impl<'a, T: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim> Self::from_data(data) } - /// Creates a mutable matrix slice from an array and with dimensions and strides specified by generic types instances. + /// Creates a mutable matrix view from an array and with dimensions and strides specified by generic types instances. /// /// Panics if the input data array dose not contain enough elements. /// The generic types `R`, `C`, `RStride`, `CStride` can either be type-level integers or integers wrapped with `Dynamic::new()`. @@ -218,7 +218,7 @@ impl<'a, T: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim> } impl<'a, T: Scalar, R: Dim, C: Dim> MatrixViewMut<'a, T, R, C> { - /// Creates, without bound-checking, a mutable matrix slice from an array and with dimensions specified by generic types instances. + /// Creates, without bound-checking, a mutable matrix view from an array and with dimensions specified by generic types instances. /// /// # Safety /// This method is unsafe because the input data array is not checked to contain enough elements. @@ -235,7 +235,7 @@ impl<'a, T: Scalar, R: Dim, C: Dim> MatrixViewMut<'a, T, R, C> { ) } - /// Creates a mutable matrix slice from an array and with dimensions and strides specified by generic types instances. + /// Creates a mutable matrix view from an array and with dimensions and strides specified by generic types instances. /// /// Panics if the input data array dose not contain enough elements. /// The generic types `R` and `C` can either be type-level integers or integers wrapped with `Dynamic::new()`. @@ -248,7 +248,7 @@ impl<'a, T: Scalar, R: Dim, C: Dim> MatrixViewMut<'a, T, R, C> { macro_rules! impl_constructors_mut( ($($Dims: ty),*; $(=> $DimIdent: ident: $DimBound: ident),*; $($gargs: expr),*; $($args: ident),*) => { impl<'a, T: Scalar, $($DimIdent: $DimBound),*> MatrixViewMut<'a, T, $($Dims),*> { - /// Creates a new mutable matrix slice from the given data array. + /// Creates a new mutable matrix view from the given data array. /// /// Panics if `data` does not contain enough elements. #[inline] @@ -256,7 +256,7 @@ macro_rules! impl_constructors_mut( Self::from_slice_generic(data, $($gargs),*) } - /// Creates, without bound checking, a new mutable matrix slice from the given data array. + /// Creates, without bound checking, a new mutable matrix view from the given data array. #[inline] pub unsafe fn from_slice_unchecked(data: &'a mut [T], start: usize, $($args: usize),*) -> Self { Self::from_slice_generic_unchecked(data, start, $($gargs),*) @@ -264,7 +264,7 @@ macro_rules! impl_constructors_mut( } impl<'a, T: Scalar, $($DimIdent: $DimBound, )*> MatrixViewMut<'a, T, $($Dims,)* Dynamic, Dynamic> { - /// Creates a new mutable matrix slice with the specified strides from the given data array. + /// Creates a new mutable matrix view with the specified strides from the given data array. /// /// Panics if `data` does not contain enough elements. #[inline] @@ -273,7 +273,7 @@ macro_rules! impl_constructors_mut( data, $($gargs,)* Dynamic::new(rstride), Dynamic::new(cstride)) } - /// Creates, without bound checking, a new mutable matrix slice with the specified strides from the given data array. + /// Creates, without bound checking, a new mutable matrix view with the specified strides from the given data array. #[inline] pub unsafe fn from_slice_with_strides_unchecked(data: &'a mut [T], start: usize, $($args: usize,)* rstride: usize, cstride: usize) -> Self { Self::from_slice_with_strides_generic_unchecked( diff --git a/src/base/indexing.rs b/src/base/indexing.rs index df769163..ceefe91e 100644 --- a/src/base/indexing.rs +++ b/src/base/indexing.rs @@ -378,7 +378,7 @@ pub trait MatrixIndexMut<'a, T, R: Dim, C: Dim, S: RawStorageMut>: } } -/// # Slicing based on ranges +/// # Views based on ranges /// ## Indices to Individual Elements /// ### Two-Dimensional Indices /// ``` diff --git a/src/base/matrix.rs b/src/base/matrix.rs index 659d3a6e..ae2f51e9 100644 --- a/src/base/matrix.rs +++ b/src/base/matrix.rs @@ -99,13 +99,13 @@ pub type MatrixCross = /// - [Elementwise mapping and folding `map`, `fold`, `zip_map`…](#elementwise-mapping-and-folding) /// - [Folding or columns and rows `compress_rows`, `compress_columns`…](#folding-on-columns-and-rows) /// -/// #### Vector and matrix slicing -/// - [Creating matrix slices from `&[T]` `from_slice`, `from_slice_with_strides`…](#creating-matrix-slices-from-t) -/// - [Creating mutable matrix slices from `&mut [T]` `from_slice_mut`, `from_slice_with_strides_mut`…](#creating-mutable-matrix-slices-from-mut-t) -/// - [Slicing based on index and length `row`, `columns`, `slice`…](#slicing-based-on-index-and-length) -/// - [Mutable slicing based on index and length `row_mut`, `columns_mut`, `slice_mut`…](#mutable-slicing-based-on-index-and-length) -/// - [Slicing based on ranges `rows_range`, `columns_range`…](#slicing-based-on-ranges) -/// - [Mutable slicing based on ranges `rows_range_mut`, `columns_range_mut`…](#mutable-slicing-based-on-ranges) +/// #### Vector and matrix views +/// - [Creating matrix views from `&[T]` `from_slice`, `from_slice_with_strides`…](#creating-matrix-views-from-t) +/// - [Creating mutable matrix views from `&mut [T]` `from_slice_mut`, `from_slice_with_strides_mut`…](#creating-mutable-matrix-views-from-mut-t) +/// - [Views based on index and length `row`, `columns`, `view`…](#views-based-on-index-and-length) +/// - [Mutable views based on index and length `row_mut`, `columns_mut`, `view_mut`…](#mutable-views-based-on-index-and-length) +/// - [Views based on ranges `rows_range`, `columns_range`…](#views-based-on-ranges) +/// - [Mutable views based on ranges `rows_range_mut`, `columns_range_mut`…](#mutable-views-based-on-ranges) /// /// #### In-place modification of a single matrix or vector /// - [In-place filling `fill`, `fill_diagonal`, `fill_with_identity`…](#in-place-filling) diff --git a/src/base/matrix_view.rs b/src/base/matrix_view.rs index 03d06778..d37346a6 100644 --- a/src/base/matrix_view.rs +++ b/src/base/matrix_view.rs @@ -284,7 +284,7 @@ impl> Matrix { } } -macro_rules! matrix_slice_impl ( +macro_rules! matrix_view_impl ( ($me: ident: $Me: ty, $MatrixView: ident, $ViewStorage: ident, $Storage: ident.$get_addr: ident (), $data: expr; $row: ident, $row_part: ident, @@ -302,12 +302,12 @@ macro_rules! matrix_slice_impl ( $fixed_columns_with_step: ident, $columns_generic: ident, $columns_generic_with_step: ident, - $slice: ident, - $slice_with_steps: ident, - $fixed_slice: ident, - $fixed_slice_with_steps: ident, - $generic_slice: ident, - $generic_slice_with_steps: ident, + $slice: ident => $view:ident, + $slice_with_steps: ident => $view_with_steps:ident, + $fixed_slice: ident => $fixed_view:ident, + $fixed_slice_with_steps: ident => $fixed_view_with_steps:ident, + $generic_slice: ident => $generic_view:ident, + $generic_slice_with_steps: ident => $generic_view_with_steps:ident, $rows_range_pair: ident, $columns_range_pair: ident) => { /* @@ -315,13 +315,13 @@ macro_rules! matrix_slice_impl ( * Row slicing. * */ - /// Returns a slice containing the i-th row of this matrix. + /// Returns a view containing the i-th row of this matrix. #[inline] pub fn $row($me: $Me, i: usize) -> $MatrixView<'_, T, U1, C, S::RStride, S::CStride> { $me.$fixed_rows::<1>(i) } - /// Returns a slice containing the `n` first elements of the i-th row of this matrix. + /// Returns a view containing the `n` first elements of the i-th row of this matrix. #[inline] pub fn $row_part($me: $Me, i: usize, n: usize) -> $MatrixView<'_, T, U1, Dynamic, S::RStride, S::CStride> { $me.$generic_slice((i, 0), (Const::<1>, Dynamic::new(n))) @@ -345,26 +345,26 @@ macro_rules! matrix_slice_impl ( /// Extracts a compile-time number of consecutive rows from this matrix. #[inline] - pub fn $fixed_rows($me: $Me, first_row: usize) - -> $MatrixView<'_, T, Const, C, S::RStride, S::CStride> { + pub fn $fixed_rows($me: $Me, first_row: usize) + -> $MatrixView<'_, T, Const, C, S::RStride, S::CStride> { - $me.$rows_generic(first_row, Const::) + $me.$rows_generic(first_row, Const::) } /// Extracts from this matrix a compile-time number of rows regularly skipping `step` /// rows. #[inline] - pub fn $fixed_rows_with_step($me: $Me, first_row: usize, step: usize) - -> $MatrixView<'_, T, Const, C, Dynamic, S::CStride> { + pub fn $fixed_rows_with_step($me: $Me, first_row: usize, step: usize) + -> $MatrixView<'_, T, Const, C, Dynamic, S::CStride> { - $me.$rows_generic_with_step(first_row, Const::, step) + $me.$rows_generic_with_step(first_row, Const::, step) } /// Extracts from this matrix `nrows` rows regularly skipping `step` rows. Both /// argument may or may not be values known at compile-time. #[inline] - pub fn $rows_generic($me: $Me, row_start: usize, nrows: RSlice) - -> $MatrixView<'_, T, RSlice, C, S::RStride, S::CStride> { + pub fn $rows_generic($me: $Me, row_start: usize, nrows: RView) + -> $MatrixView<'_, T, RView, C, S::RStride, S::CStride> { let my_shape = $me.shape_generic(); $me.assert_slice_index((row_start, 0), (nrows.value(), my_shape.1.value()), (0, 0)); @@ -380,9 +380,9 @@ macro_rules! matrix_slice_impl ( /// Extracts from this matrix `nrows` rows regularly skipping `step` rows. Both /// argument may or may not be values known at compile-time. #[inline] - pub fn $rows_generic_with_step($me: $Me, row_start: usize, nrows: RSlice, step: usize) - -> $MatrixView<'_, T, RSlice, C, Dynamic, S::CStride> - where RSlice: Dim { + pub fn $rows_generic_with_step($me: $Me, row_start: usize, nrows: RView, step: usize) + -> $MatrixView<'_, T, RView, C, Dynamic, S::CStride> + where RView: Dim { let my_shape = $me.shape_generic(); let my_strides = $me.data.strides(); @@ -402,16 +402,16 @@ macro_rules! matrix_slice_impl ( * Column slicing. * */ - /// Returns a slice containing the i-th column of this matrix. + /// Returns a view containing the i-th column of this matrix. #[inline] pub fn $column($me: $Me, i: usize) -> $MatrixView<'_, T, R, U1, S::RStride, S::CStride> { $me.$fixed_columns::<1>(i) } - /// Returns a slice containing the `n` first elements of the i-th column of this matrix. + /// Returns a view containing the `n` first elements of the i-th column of this matrix. #[inline] pub fn $column_part($me: $Me, i: usize, n: usize) -> $MatrixView<'_, T, Dynamic, U1, S::RStride, S::CStride> { - $me.$generic_slice((0, i), (Dynamic::new(n), Const::<1>)) + $me.$generic_view((0, i), (Dynamic::new(n), Const::<1>)) } /// Extracts from this matrix a set of consecutive columns. @@ -433,26 +433,26 @@ macro_rules! matrix_slice_impl ( /// Extracts a compile-time number of consecutive columns from this matrix. #[inline] - pub fn $fixed_columns($me: $Me, first_col: usize) - -> $MatrixView<'_, T, R, Const, S::RStride, S::CStride> { + pub fn $fixed_columns($me: $Me, first_col: usize) + -> $MatrixView<'_, T, R, Const, S::RStride, S::CStride> { - $me.$columns_generic(first_col, Const::) + $me.$columns_generic(first_col, Const::) } /// Extracts from this matrix a compile-time number of columns regularly skipping /// `step` columns. #[inline] - pub fn $fixed_columns_with_step($me: $Me, first_col: usize, step: usize) - -> $MatrixView<'_, T, R, Const, S::RStride, Dynamic> { + pub fn $fixed_columns_with_step($me: $Me, first_col: usize, step: usize) + -> $MatrixView<'_, T, R, Const, S::RStride, Dynamic> { - $me.$columns_generic_with_step(first_col, Const::, step) + $me.$columns_generic_with_step(first_col, Const::, step) } /// Extracts from this matrix `ncols` columns. The number of columns may or may not be /// known at compile-time. #[inline] - pub fn $columns_generic($me: $Me, first_col: usize, ncols: CSlice) - -> $MatrixView<'_, T, R, CSlice, S::RStride, S::CStride> { + pub fn $columns_generic($me: $Me, first_col: usize, ncols: CView) + -> $MatrixView<'_, T, R, CView, S::RStride, S::CStride> { let my_shape = $me.shape_generic(); $me.assert_slice_index((0, first_col), (my_shape.0.value(), ncols.value()), (0, 0)); @@ -468,8 +468,8 @@ macro_rules! matrix_slice_impl ( /// Extracts from this matrix `ncols` columns skipping `step` columns. Both argument may /// or may not be values known at compile-time. #[inline] - pub fn $columns_generic_with_step($me: $Me, first_col: usize, ncols: CSlice, step: usize) - -> $MatrixView<'_, T, R, CSlice, S::RStride, Dynamic> { + pub fn $columns_generic_with_step($me: $Me, first_col: usize, ncols: CView, step: usize) + -> $MatrixView<'_, T, R, CView, S::RStride, Dynamic> { let my_shape = $me.shape_generic(); let my_strides = $me.data.strides(); @@ -493,8 +493,17 @@ macro_rules! matrix_slice_impl ( /// Slices this matrix starting at its component `(irow, icol)` and with `(nrows, ncols)` /// consecutive elements. #[inline] + #[deprecated = slice_deprecation_note!($view)] pub fn $slice($me: $Me, start: (usize, usize), shape: (usize, usize)) -> $MatrixView<'_, T, Dynamic, Dynamic, S::RStride, S::CStride> { + $me.$view(start, shape) + } + + /// Return a view of this matrix starting at its component `(irow, icol)` and with `(nrows, ncols)` + /// consecutive elements. + #[inline] + pub fn $view($me: $Me, start: (usize, usize), shape: (usize, usize)) + -> $MatrixView<'_, T, Dynamic, Dynamic, S::RStride, S::CStride> { $me.assert_slice_index(start, shape, (0, 0)); let shape = (Dynamic::new(shape.0), Dynamic::new(shape.1)); @@ -505,27 +514,45 @@ macro_rules! matrix_slice_impl ( } } - /// Slices this matrix starting at its component `(start.0, start.1)` and with /// `(shape.0, shape.1)` components. Each row (resp. column) of the sliced matrix is /// separated by `steps.0` (resp. `steps.1`) ignored rows (resp. columns) of the /// original matrix. #[inline] + #[deprecated = slice_deprecation_note!($view_with_steps)] pub fn $slice_with_steps($me: $Me, start: (usize, usize), shape: (usize, usize), steps: (usize, usize)) -> $MatrixView<'_, T, Dynamic, Dynamic, Dynamic, Dynamic> { - let shape = (Dynamic::new(shape.0), Dynamic::new(shape.1)); + $me.$view_with_steps(start, shape, steps) + } - $me.$generic_slice_with_steps(start, shape, steps) + /// Return a view of this matrix starting at its component `(start.0, start.1)` and with + /// `(shape.0, shape.1)` components. Each row (resp. column) of the matrix view is + /// separated by `steps.0` (resp. `steps.1`) ignored rows (resp. columns) of the + /// original matrix. + #[inline] + pub fn $view_with_steps($me: $Me, start: (usize, usize), shape: (usize, usize), steps: (usize, usize)) + -> $MatrixView<'_, T, Dynamic, Dynamic, Dynamic, Dynamic> { + let shape = (Dynamic::new(shape.0), Dynamic::new(shape.1)); + $me.$generic_view_with_steps(start, shape, steps) } /// Slices this matrix starting at its component `(irow, icol)` and with `(R::dim(), - /// CSlice::dim())` consecutive components. + /// CView::dim())` consecutive components. #[inline] - pub fn $fixed_slice($me: $Me, irow: usize, icol: usize) - -> $MatrixView<'_, T, Const, Const, S::RStride, S::CStride> { + #[deprecated = slice_deprecation_note!($fixed_view)] + pub fn $fixed_slice($me: $Me, irow: usize, icol: usize) + -> $MatrixView<'_, T, Const, Const, S::RStride, S::CStride> { + $me.$fixed_view(irow, icol) + } - $me.assert_slice_index((irow, icol), (RSLICE, CSLICE), (0, 0)); - let shape = (Const::, Const::); + /// Return a view of this matrix starting at its component `(irow, icol)` and with `(R::dim(), + /// CView::dim())` consecutive components. + #[inline] + pub fn $fixed_view($me: $Me, irow: usize, icol: usize) + -> $MatrixView<'_, T, Const, Const, S::RStride, S::CStride> { + + $me.assert_slice_index((irow, icol), (RVIEW, CVIEW), (0, 0)); + let shape = (Const::, Const::); unsafe { let data = $ViewStorage::new_unchecked($data, (irow, icol), shape); @@ -534,22 +561,43 @@ macro_rules! matrix_slice_impl ( } /// Slices this matrix starting at its component `(start.0, start.1)` and with - /// `(RSLICE, CSLICE)` components. Each row (resp. column) of the sliced + /// `(RVIEW, CVIEW)` components. Each row (resp. column) of the sliced /// matrix is separated by `steps.0` (resp. `steps.1`) ignored rows (resp. columns) of /// the original matrix. #[inline] - pub fn $fixed_slice_with_steps($me: $Me, start: (usize, usize), steps: (usize, usize)) - -> $MatrixView<'_, T, Const, Const, Dynamic, Dynamic> { - let shape = (Const::, Const::); - $me.$generic_slice_with_steps(start, shape, steps) + #[deprecated = slice_deprecation_note!($fixed_view_with_steps)] + pub fn $fixed_slice_with_steps($me: $Me, start: (usize, usize), steps: (usize, usize)) + -> $MatrixView<'_, T, Const, Const, Dynamic, Dynamic> { + $me.$fixed_view_with_steps(start, steps) + } + + /// Returns a view of this matrix starting at its component `(start.0, start.1)` and with + /// `(RVIEW, CVIEW)` components. Each row (resp. column) of the matrix view + /// is separated by `steps.0` (resp. `steps.1`) ignored rows (resp. columns) of + /// the original matrix. + #[inline] + pub fn $fixed_view_with_steps($me: $Me, start: (usize, usize), steps: (usize, usize)) + -> $MatrixView<'_, T, Const, Const, Dynamic, Dynamic> { + let shape = (Const::, Const::); + $me.$generic_view_with_steps(start, shape, steps) } /// Creates a slice that may or may not have a fixed size and stride. #[inline] - pub fn $generic_slice($me: $Me, start: (usize, usize), shape: (RSlice, CSlice)) - -> $MatrixView<'_, T, RSlice, CSlice, S::RStride, S::CStride> - where RSlice: Dim, - CSlice: Dim { + #[deprecated = slice_deprecation_note!($generic_view)] + pub fn $generic_slice($me: $Me, start: (usize, usize), shape: (RView, CView)) + -> $MatrixView<'_, T, RView, CView, S::RStride, S::CStride> + where RView: Dim, + CView: Dim { + $me.$generic_view(start, shape) + } + + /// Creates a matrix view that may or may not have a fixed size and stride. + #[inline] + pub fn $generic_view($me: $Me, start: (usize, usize), shape: (RView, CView)) + -> $MatrixView<'_, T, RView, CView, S::RStride, S::CStride> + where RView: Dim, + CView: Dim { $me.assert_slice_index(start, (shape.0.value(), shape.1.value()), (0, 0)); @@ -561,13 +609,26 @@ macro_rules! matrix_slice_impl ( /// Creates a slice that may or may not have a fixed size and stride. #[inline] - pub fn $generic_slice_with_steps($me: $Me, + #[deprecated = slice_deprecation_note!($generic_view_with_steps)] + pub fn $generic_slice_with_steps($me: $Me, start: (usize, usize), - shape: (RSlice, CSlice), + shape: (RView, CView), steps: (usize, usize)) - -> $MatrixView<'_, T, RSlice, CSlice, Dynamic, Dynamic> - where RSlice: Dim, - CSlice: Dim { + -> $MatrixView<'_, T, RView, CView, Dynamic, Dynamic> + where RView: Dim, + CView: Dim { + $me.$generic_view_with_steps(start, shape, steps) + } + + /// Creates a matrix view that may or may not have a fixed size and stride. + #[inline] + pub fn $generic_view_with_steps($me: $Me, + start: (usize, usize), + shape: (RView, CView), + steps: (usize, usize)) + -> $MatrixView<'_, T, RView, CView, Dynamic, Dynamic> + where RView: Dim, + CView: Dim { $me.assert_slice_index(start, (shape.0.value(), shape.1.value()), steps); @@ -615,10 +676,10 @@ macro_rules! matrix_slice_impl ( let data1 = $ViewStorage::from_raw_parts(ptr1, (nrows1, ncols), strides); let data2 = $ViewStorage::from_raw_parts(ptr2, (nrows2, ncols), strides); - let slice1 = Matrix::from_data_statically_unchecked(data1); - let slice2 = Matrix::from_data_statically_unchecked(data2); + let view1 = Matrix::from_data_statically_unchecked(data1); + let view2 = Matrix::from_data_statically_unchecked(data2); - (slice1, slice2) + (view1, view2) } } @@ -651,10 +712,10 @@ macro_rules! matrix_slice_impl ( let data1 = $ViewStorage::from_raw_parts(ptr1, (nrows, ncols1), strides); let data2 = $ViewStorage::from_raw_parts(ptr2, (nrows, ncols2), strides); - let slice1 = Matrix::from_data_statically_unchecked(data1); - let slice2 = Matrix::from_data_statically_unchecked(data2); + let view1 = Matrix::from_data_statically_unchecked(data1); + let view2 = Matrix::from_data_statically_unchecked(data2); - (slice1, slice2) + (view1, view2) } } } @@ -688,9 +749,9 @@ pub type MatrixSliceMut<'a, T, R, C, RStride = U1, CStride = R> = pub type MatrixViewMut<'a, T, R, C, RStride = U1, CStride = R> = Matrix>; -/// # Slicing based on index and length +/// # Views based on index and length impl> Matrix { - matrix_slice_impl!( + matrix_view_impl!( self: &Self, MatrixView, ViewStorage, RawStorage.get_address_unchecked(), &self.data; row, row_part, @@ -708,19 +769,19 @@ impl> Matrix { fixed_columns_with_step, columns_generic, columns_generic_with_step, - slice, - slice_with_steps, - fixed_slice, - fixed_slice_with_steps, - generic_slice, - generic_slice_with_steps, + slice => view, + slice_with_steps => view_with_steps, + fixed_slice => fixed_view, + fixed_slice_with_steps => fixed_view_with_steps, + generic_slice => generic_view, + generic_slice_with_steps => generic_view_with_steps, rows_range_pair, columns_range_pair); } -/// # Mutable slicing based on index and length +/// # Mutable views based on index and length impl> Matrix { - matrix_slice_impl!( + matrix_view_impl!( self: &mut Self, MatrixViewMut, ViewStorageMut, RawStorageMut.get_address_unchecked_mut(), &mut self.data; row_mut, row_part_mut, @@ -738,12 +799,12 @@ impl> Matrix { fixed_columns_with_step_mut, columns_generic_mut, columns_generic_with_step_mut, - slice_mut, - slice_with_steps_mut, - fixed_slice_mut, - fixed_slice_with_steps_mut, - generic_slice_mut, - generic_slice_with_steps_mut, + slice_mut => view_mut, + slice_with_steps_mut => view_with_steps_mut, + fixed_slice_mut => fixed_view_mut, + fixed_slice_with_steps_mut => fixed_view_with_steps_mut, + generic_slice_mut => generic_view_mut, + generic_slice_with_steps_mut => generic_view_with_steps_mut, rows_range_pair_mut, columns_range_pair_mut); } @@ -889,6 +950,7 @@ impl> Matrix { /// by the range `cols`. #[inline] #[must_use] + #[deprecated = slice_deprecation_note!(view_range)] pub fn slice_range( &self, rows: RowRange, @@ -905,24 +967,44 @@ impl> Matrix { ) } - /// Slice containing all the rows indexed by the range `rows`. + /// Returns a view containing the rows indexed by the range `rows` and the columns indexed + /// by the range `cols`. + #[inline] + #[must_use] + pub fn view_range( + &self, + rows: RowRange, + cols: ColRange, + ) -> MatrixView<'_, T, RowRange::Size, ColRange::Size, S::RStride, S::CStride> + where + RowRange: SliceRange, + ColRange: SliceRange, + { + let (nrows, ncols) = self.shape_generic(); + self.generic_view( + (rows.begin(nrows), cols.begin(ncols)), + (rows.size(nrows), cols.size(ncols)), + ) + } + + /// View containing all the rows indexed by the range `rows`. #[inline] #[must_use] pub fn rows_range>( &self, rows: RowRange, ) -> MatrixView<'_, T, RowRange::Size, C, S::RStride, S::CStride> { - self.slice_range(rows, ..) + self.view_range(rows, ..) } - /// Slice containing all the columns indexed by the range `rows`. + /// View containing all the columns indexed by the range `rows`. #[inline] #[must_use] pub fn columns_range>( &self, cols: ColRange, ) -> MatrixView<'_, T, R, ColRange::Size, S::RStride, S::CStride> { - self.slice_range(.., cols) + self.view_range(.., cols) } } @@ -931,6 +1013,7 @@ impl> Matrix { impl> Matrix { /// Slices a mutable sub-matrix containing the rows indexed by the range `rows` and the columns /// indexed by the range `cols`. + #[deprecated = slice_deprecation_note!(view_range_mut)] pub fn slice_range_mut( &mut self, rows: RowRange, @@ -939,30 +1022,44 @@ impl> Matrix { where RowRange: SliceRange, ColRange: SliceRange, + { + self.view_range_mut(rows, cols) + } + + /// Return a mutable view containing the rows indexed by the range `rows` and the columns + /// indexed by the range `cols`. + pub fn view_range_mut( + &mut self, + rows: RowRange, + cols: ColRange, + ) -> MatrixViewMut<'_, T, RowRange::Size, ColRange::Size, S::RStride, S::CStride> + where + RowRange: SliceRange, + ColRange: SliceRange, { let (nrows, ncols) = self.shape_generic(); - self.generic_slice_mut( + self.generic_view_mut( (rows.begin(nrows), cols.begin(ncols)), (rows.size(nrows), cols.size(ncols)), ) } - /// Slice containing all the rows indexed by the range `rows`. + /// Mutable view containing all the rows indexed by the range `rows`. #[inline] pub fn rows_range_mut>( &mut self, rows: RowRange, ) -> MatrixViewMut<'_, T, RowRange::Size, C, S::RStride, S::CStride> { - self.slice_range_mut(rows, ..) + self.view_range_mut(rows, ..) } - /// Slice containing all the columns indexed by the range `cols`. + /// Mutable view containing all the columns indexed by the range `cols`. #[inline] pub fn columns_range_mut>( &mut self, cols: ColRange, ) -> MatrixViewMut<'_, T, R, ColRange::Size, S::RStride, S::CStride> { - self.slice_range_mut(.., cols) + self.view_range_mut(.., cols) } } @@ -974,11 +1071,11 @@ where RStride: Dim, CStride: Dim, { - fn from(slice_mut: MatrixViewMut<'a, T, R, C, RStride, CStride>) -> Self { + fn from(view_mut: MatrixViewMut<'a, T, R, C, RStride, CStride>) -> Self { let data = ViewStorage { - ptr: slice_mut.data.ptr, - shape: slice_mut.data.shape, - strides: slice_mut.data.strides, + ptr: view_mut.data.ptr, + shape: view_mut.data.shape, + strides: view_mut.data.strides, _phantoms: PhantomData, }; From 34f453737653c3e273ad472fe72b4e45ee5e4b2f Mon Sep 17 00:00:00 2001 From: Andreas Longva Date: Mon, 14 Nov 2022 14:14:42 +0100 Subject: [PATCH 12/22] Use view* instead of slice* methods in src/ --- src/base/blas.rs | 4 +- src/base/cg.rs | 24 ++++++------ src/base/edition.rs | 2 +- src/base/matrix.rs | 8 ++-- src/base/matrix_view.rs | 4 +- src/geometry/isometry.rs | 2 +- src/geometry/isometry_conversion.rs | 6 +-- src/geometry/point.rs | 2 +- src/geometry/point_construction.rs | 2 +- src/geometry/point_conversion.rs | 2 +- src/geometry/rotation.rs | 2 +- src/geometry/rotation_conversion.rs | 6 +-- src/geometry/scale_conversion.rs | 2 +- src/geometry/similarity.rs | 2 +- src/geometry/similarity_conversion.rs | 20 +++++----- src/geometry/transform_ops.rs | 10 ++--- src/geometry/translation.rs | 2 +- src/geometry/translation_conversion.rs | 4 +- src/linalg/bidiagonal.rs | 12 +++--- src/linalg/cholesky.rs | 52 +++++++++++++------------- src/linalg/col_piv_qr.rs | 10 ++--- src/linalg/full_piv_lu.rs | 2 +- src/linalg/hessenberg.rs | 4 +- src/linalg/householder.rs | 4 +- src/linalg/lu.rs | 8 ++-- src/linalg/qr.rs | 8 ++-- src/linalg/schur.rs | 26 ++++++------- src/linalg/solve.rs | 20 +++++----- 28 files changed, 125 insertions(+), 125 deletions(-) diff --git a/src/base/blas.rs b/src/base/blas.rs index 5f51cea9..9d9dd2bd 100644 --- a/src/base/blas.rs +++ b/src/base/blas.rs @@ -393,7 +393,7 @@ where let col2 = a.column(0); let val = unsafe { x.vget_unchecked(0).clone() }; self.axpy(alpha.clone() * val, &col2, beta); - self[0] += alpha.clone() * dot(&a.slice_range(1.., 0), &x.rows_range(1..)); + self[0] += alpha.clone() * dot(&a.view_range(1.., 0), &x.rows_range(1..)); for j in 1..dim2 { let col2 = a.column(j); @@ -892,7 +892,7 @@ where let val = unsafe { conjugate(y.vget_unchecked(j).clone()) }; let subdim = Dynamic::new(dim1 - j); // TODO: avoid bound checks. - self.generic_slice_mut((j, j), (subdim, Const::<1>)).axpy( + self.generic_view_mut((j, j), (subdim, Const::<1>)).axpy( alpha.clone() * val, &x.rows_range(j..), beta.clone(), diff --git a/src/base/cg.rs b/src/base/cg.rs index ef3ad5b5..586c923e 100644 --- a/src/base/cg.rs +++ b/src/base/cg.rs @@ -59,7 +59,7 @@ where SB: Storage>, { let mut res = Self::identity(); - res.generic_slice_mut( + res.generic_view_mut( (0, D::dim() - 1), (DimNameDiff::::name(), Const::<1>), ) @@ -382,19 +382,19 @@ impl>, { let scale = self - .generic_slice( + .generic_view( (D::dim() - 1, 0), (Const::<1>, DimNameDiff::::name()), ) .tr_dot(shift); - let post_translation = self.generic_slice( + let post_translation = self.generic_view( (0, 0), (DimNameDiff::::name(), DimNameDiff::::name()), ) * shift; self[(D::dim() - 1, D::dim() - 1)] += scale; - let mut translation = self.generic_slice_mut( + let mut translation = self.generic_view_mut( (0, D::dim() - 1), (DimNameDiff::::name(), Const::<1>), ); @@ -415,11 +415,11 @@ where &self, v: &OVector>, ) -> OVector> { - let transform = self.generic_slice( + let transform = self.generic_view( (0, 0), (DimNameDiff::::name(), DimNameDiff::::name()), ); - let normalizer = self.generic_slice( + let normalizer = self.generic_view( (D::dim() - 1, 0), (Const::<1>, DimNameDiff::::name()), ); @@ -437,9 +437,9 @@ impl, Const<3>>> SquareMatrix, /// Transforms the given point, assuming the matrix `self` uses homogeneous coordinates. #[inline] pub fn transform_point(&self, pt: &Point) -> Point { - let transform = self.fixed_slice::<2, 2>(0, 0); - let translation = self.fixed_slice::<2, 1>(0, 2); - let normalizer = self.fixed_slice::<1, 2>(2, 0); + let transform = self.fixed_view::<2, 2>(0, 0); + let translation = self.fixed_view::<2, 1>(0, 2); + let normalizer = self.fixed_view::<1, 2>(2, 0); let n = normalizer.tr_dot(&pt.coords) + unsafe { self.get_unchecked((2, 2)).clone() }; if !n.is_zero() { @@ -454,9 +454,9 @@ impl, Const<4>>> SquareMatrix, /// Transforms the given point, assuming the matrix `self` uses homogeneous coordinates. #[inline] pub fn transform_point(&self, pt: &Point) -> Point { - let transform = self.fixed_slice::<3, 3>(0, 0); - let translation = self.fixed_slice::<3, 1>(0, 3); - let normalizer = self.fixed_slice::<1, 3>(3, 0); + let transform = self.fixed_view::<3, 3>(0, 0); + let translation = self.fixed_view::<3, 1>(0, 3); + let normalizer = self.fixed_view::<1, 3>(3, 0); let n = normalizer.tr_dot(&pt.coords) + unsafe { self.get_unchecked((3, 3)).clone() }; if !n.is_zero() { diff --git a/src/base/edition.rs b/src/base/edition.rs index 760b3950..104bd7fb 100644 --- a/src/base/edition.rs +++ b/src/base/edition.rs @@ -938,7 +938,7 @@ impl> Matrix { } if new_nrows.value() > nrows { - res.slice_range_mut(nrows.., ..cmp::min(ncols, new_ncols.value())) + res.view_range_mut(nrows.., ..cmp::min(ncols, new_ncols.value())) .fill_with(|| MaybeUninit::new(val.clone())); } diff --git a/src/base/matrix.rs b/src/base/matrix.rs index ae2f51e9..a263d761 100644 --- a/src/base/matrix.rs +++ b/src/base/matrix.rs @@ -446,7 +446,7 @@ impl> Matrix { /// ``` /// # use nalgebra::DMatrix; /// let mat = DMatrix::::zeros(10, 10); - /// let slice = mat.slice_with_steps((0, 0), (5, 3), (1, 2)); + /// let view = mat.view_with_steps((0, 0), (5, 3), (1, 2)); /// // The column strides is the number of steps (here 2) multiplied by the corresponding dimension. /// assert_eq!(mat.strides(), (1, 10)); /// ``` @@ -1633,7 +1633,7 @@ impl + IsNotStaticOne, S: RawStorage::from_usize(self.nrows() + 1); let mut res = OMatrix::identity_generic(dim, dim); - res.generic_slice_mut::((0, 0), self.shape_generic()) + res.generic_view_mut::((0, 0), self.shape_generic()) .copy_from(self); res } @@ -1661,7 +1661,7 @@ impl, S: RawStorage> Vector { { if v[v.len() - 1].is_zero() { let nrows = D::from_usize(v.len() - 1); - Some(v.generic_slice((0, 0), (nrows, Const::<1>)).into_owned()) + Some(v.generic_view((0, 0), (nrows, Const::<1>)).into_owned()) } else { None } @@ -1681,7 +1681,7 @@ impl, S: RawStorage> Vector { let mut res = Matrix::uninit(hnrows, Const::<1>); // This is basically a copy_from except that we warp the copied // values into MaybeUninit. - res.generic_slice_mut((0, 0), self.shape_generic()) + res.generic_view_mut((0, 0), self.shape_generic()) .zip_apply(self, |out, e| *out = MaybeUninit::new(e)); res[(len, 0)] = MaybeUninit::new(element); diff --git a/src/base/matrix_view.rs b/src/base/matrix_view.rs index d37346a6..0580546e 100644 --- a/src/base/matrix_view.rs +++ b/src/base/matrix_view.rs @@ -324,7 +324,7 @@ macro_rules! matrix_view_impl ( /// Returns a view containing the `n` first elements of the i-th row of this matrix. #[inline] pub fn $row_part($me: $Me, i: usize, n: usize) -> $MatrixView<'_, T, U1, Dynamic, S::RStride, S::CStride> { - $me.$generic_slice((i, 0), (Const::<1>, Dynamic::new(n))) + $me.$generic_view((i, 0), (Const::<1>, Dynamic::new(n))) } /// Extracts from this matrix a set of consecutive rows. @@ -961,7 +961,7 @@ impl> Matrix { ColRange: SliceRange, { let (nrows, ncols) = self.shape_generic(); - self.generic_slice( + self.generic_view( (rows.begin(nrows), cols.begin(ncols)), (rows.size(nrows), cols.size(ncols)), ) diff --git a/src/geometry/isometry.rs b/src/geometry/isometry.rs index d245c99b..67660800 100755 --- a/src/geometry/isometry.rs +++ b/src/geometry/isometry.rs @@ -428,7 +428,7 @@ impl Isometry { DefaultAllocator: Allocator, U1>, DimNameSum, U1>>, { let mut res: OMatrix = crate::convert_ref(&self.rotation); - res.fixed_slice_mut::(0, D) + res.fixed_view_mut::(0, D) .copy_from(&self.translation.vector); res diff --git a/src/geometry/isometry_conversion.rs b/src/geometry/isometry_conversion.rs index 627ea3ee..06507631 100644 --- a/src/geometry/isometry_conversion.rs +++ b/src/geometry/isometry_conversion.rs @@ -153,8 +153,8 @@ where #[inline] fn is_in_subset(m: &OMatrix, U1>, DimNameSum, U1>>) -> bool { - let rot = m.fixed_slice::(0, 0); - let bottom = m.fixed_slice::<1, D>(D, 0); + let rot = m.fixed_view::(0, 0); + let bottom = m.fixed_view::<1, D>(D, 0); // Scalar types agree. m.iter().all(|e| SupersetOf::::is_in_subset(e)) && @@ -168,7 +168,7 @@ where fn from_superset_unchecked( m: &OMatrix, U1>, DimNameSum, U1>>, ) -> Self { - let t = m.fixed_slice::(0, D).into_owned(); + let t = m.fixed_view::(0, D).into_owned(); let t = Translation { vector: crate::convert_unchecked(t), }; diff --git a/src/geometry/point.rs b/src/geometry/point.rs index e9a21439..3dd54b98 100644 --- a/src/geometry/point.rs +++ b/src/geometry/point.rs @@ -207,7 +207,7 @@ where let mut res = crate::Matrix::uninit(DimNameSum::::name(), Const::<1>); // This is basically a copy_from except that we warp the copied // values into MaybeUninit. - res.generic_slice_mut((0, 0), self.coords.shape_generic()) + res.generic_view_mut((0, 0), self.coords.shape_generic()) .zip_apply(&self.coords, |out, e| *out = MaybeUninit::new(e)); res[(len, 0)] = MaybeUninit::new(T::one()); diff --git a/src/geometry/point_construction.rs b/src/geometry/point_construction.rs index 598cf4ed..04228cd2 100644 --- a/src/geometry/point_construction.rs +++ b/src/geometry/point_construction.rs @@ -113,7 +113,7 @@ where DefaultAllocator: Allocator>, { if !v[D::dim()].is_zero() { - let coords = v.generic_slice((0, 0), (D::name(), Const::<1>)) / v[D::dim()].clone(); + let coords = v.generic_view((0, 0), (D::name(), Const::<1>)) / v[D::dim()].clone(); Some(Self::from(coords)) } else { None diff --git a/src/geometry/point_conversion.rs b/src/geometry/point_conversion.rs index ce1bd930..81870379 100644 --- a/src/geometry/point_conversion.rs +++ b/src/geometry/point_conversion.rs @@ -66,7 +66,7 @@ where #[inline] fn from_superset_unchecked(v: &OVector>) -> Self { - let coords = v.generic_slice((0, 0), (D::name(), Const::<1>)) / v[D::dim()].clone(); + let coords = v.generic_view((0, 0), (D::name(), Const::<1>)) / v[D::dim()].clone(); Self { coords: crate::convert_unchecked(coords), } diff --git a/src/geometry/rotation.rs b/src/geometry/rotation.rs index 4a71da0f..79f14eda 100755 --- a/src/geometry/rotation.rs +++ b/src/geometry/rotation.rs @@ -261,7 +261,7 @@ impl Rotation { // adding the additional traits `DimAdd` and `IsNotStaticOne`. Maybe // these things will get nicer once specialization lands in Rust. let mut res = OMatrix::, U1>, DimNameSum, U1>>::identity(); - res.fixed_slice_mut::(0, 0).copy_from(&self.matrix); + res.fixed_view_mut::(0, 0).copy_from(&self.matrix); res } diff --git a/src/geometry/rotation_conversion.rs b/src/geometry/rotation_conversion.rs index 517010a0..c37b5cdd 100644 --- a/src/geometry/rotation_conversion.rs +++ b/src/geometry/rotation_conversion.rs @@ -211,8 +211,8 @@ where #[inline] fn is_in_subset(m: &OMatrix, U1>, DimNameSum, U1>>) -> bool { - let rot = m.fixed_slice::(0, 0); - let bottom = m.fixed_slice::<1, D>(D, 0); + let rot = m.fixed_view::(0, 0); + let bottom = m.fixed_view::<1, D>(D, 0); // Scalar types agree. m.iter().all(|e| SupersetOf::::is_in_subset(e)) && @@ -226,7 +226,7 @@ where fn from_superset_unchecked( m: &OMatrix, U1>, DimNameSum, U1>>, ) -> Self { - let r = m.fixed_slice::(0, 0); + let r = m.fixed_view::(0, 0); Self::from_matrix_unchecked(crate::convert_unchecked(r.into_owned())) } } diff --git a/src/geometry/scale_conversion.rs b/src/geometry/scale_conversion.rs index 2dc670a1..2d807e3a 100644 --- a/src/geometry/scale_conversion.rs +++ b/src/geometry/scale_conversion.rs @@ -102,7 +102,7 @@ where fn from_superset_unchecked( m: &OMatrix, U1>, DimNameSum, U1>>, ) -> Self { - let v = m.fixed_slice::(0, 0).diagonal(); + let v = m.fixed_view::(0, 0).diagonal(); Self { vector: crate::convert_unchecked(v), } diff --git a/src/geometry/similarity.rs b/src/geometry/similarity.rs index a827246e..763f1db9 100755 --- a/src/geometry/similarity.rs +++ b/src/geometry/similarity.rs @@ -304,7 +304,7 @@ impl Similarity { { let mut res = self.isometry.to_homogeneous(); - for e in res.fixed_slice_mut::(0, 0).iter_mut() { + for e in res.fixed_view_mut::(0, 0).iter_mut() { *e *= self.scaling.clone() } diff --git a/src/geometry/similarity_conversion.rs b/src/geometry/similarity_conversion.rs index 6bc12814..e5d28906 100644 --- a/src/geometry/similarity_conversion.rs +++ b/src/geometry/similarity_conversion.rs @@ -106,7 +106,7 @@ where #[inline] fn is_in_subset(m: &OMatrix, U1>, DimNameSum, U1>>) -> bool { - let mut rot = m.fixed_slice::(0, 0).clone_owned(); + let mut rot = m.fixed_view::(0, 0).clone_owned(); if rot .fixed_columns_mut::<1>(0) .try_normalize_mut(T2::zero()) @@ -128,7 +128,7 @@ where rot.fixed_columns_mut::<1>(2).neg_mut(); } - let bottom = m.fixed_slice::<1, D>(D, 0); + let bottom = m.fixed_view::<1, D>(D, 0); // Scalar types agree. m.iter().all(|e| SupersetOf::::is_in_subset(e)) && // The normalized block part is a rotation. @@ -145,22 +145,22 @@ where m: &OMatrix, U1>, DimNameSum, U1>>, ) -> Self { let mut mm = m.clone_owned(); - let na = mm.fixed_slice_mut::(0, 0).normalize_mut(); - let nb = mm.fixed_slice_mut::(0, 1).normalize_mut(); - let nc = mm.fixed_slice_mut::(0, 2).normalize_mut(); + let na = mm.fixed_view_mut::(0, 0).normalize_mut(); + let nb = mm.fixed_view_mut::(0, 1).normalize_mut(); + let nc = mm.fixed_view_mut::(0, 2).normalize_mut(); let mut scale = (na + nb + nc) / crate::convert(3.0); // We take the mean, for robustness. // TODO: could we avoid the explicit computation of the determinant? // (its sign is needed to see if the scaling factor is negative). - if mm.fixed_slice::(0, 0).determinant() < T2::zero() { - mm.fixed_slice_mut::(0, 0).neg_mut(); - mm.fixed_slice_mut::(0, 1).neg_mut(); - mm.fixed_slice_mut::(0, 2).neg_mut(); + if mm.fixed_view::(0, 0).determinant() < T2::zero() { + mm.fixed_view_mut::(0, 0).neg_mut(); + mm.fixed_view_mut::(0, 1).neg_mut(); + mm.fixed_view_mut::(0, 2).neg_mut(); scale = -scale; } - let t = m.fixed_slice::(0, D).into_owned(); + let t = m.fixed_view::(0, D).into_owned(); let t = Translation { vector: crate::convert_unchecked(t), }; diff --git a/src/geometry/transform_ops.rs b/src/geometry/transform_ops.rs index 8a500676..4c6284d0 100644 --- a/src/geometry/transform_ops.rs +++ b/src/geometry/transform_ops.rs @@ -120,10 +120,10 @@ md_impl_all!( [ref val] => self * &rhs; [val ref] => &self * rhs; [ref ref] => { - let transform = self.matrix().fixed_slice::(0, 0); + let transform = self.matrix().fixed_view::(0, 0); if C::has_normalizer() { - let normalizer = self.matrix().fixed_slice::<1, D>(D, 0); + let normalizer = self.matrix().fixed_view::<1, D>(D, 0); let n = normalizer.tr_dot(rhs); if !n.is_zero() { @@ -148,11 +148,11 @@ md_impl_all!( [ref val] => self * &rhs; [val ref] => &self * rhs; [ref ref] => { - let transform = self.matrix().fixed_slice::(0, 0); - let translation = self.matrix().fixed_slice::(0, D); + let transform = self.matrix().fixed_view::(0, 0); + let translation = self.matrix().fixed_view::(0, D); if C::has_normalizer() { - let normalizer = self.matrix().fixed_slice::<1, D>(D, 0); + let normalizer = self.matrix().fixed_view::<1, D>(D, 0); #[allow(clippy::suspicious_arithmetic_impl)] let n = normalizer.tr_dot(&rhs.coords) + unsafe { self.matrix().get_unchecked((D, D)).clone() }; diff --git a/src/geometry/translation.rs b/src/geometry/translation.rs index 7e10ac4c..482d45ed 100755 --- a/src/geometry/translation.rs +++ b/src/geometry/translation.rs @@ -150,7 +150,7 @@ impl Translation { DefaultAllocator: Allocator, U1>, DimNameSum, U1>>, { let mut res = OMatrix::, U1>, DimNameSum, U1>>::identity(); - res.fixed_slice_mut::(0, D).copy_from(&self.vector); + res.fixed_view_mut::(0, D).copy_from(&self.vector); res } diff --git a/src/geometry/translation_conversion.rs b/src/geometry/translation_conversion.rs index 70000efb..73646780 100644 --- a/src/geometry/translation_conversion.rs +++ b/src/geometry/translation_conversion.rs @@ -159,7 +159,7 @@ where #[inline] fn is_in_subset(m: &OMatrix, U1>, DimNameSum, U1>>) -> bool { - let id = m.generic_slice((0, 0), (DimNameSum::, U1>::name(), Const::)); + let id = m.generic_view((0, 0), (DimNameSum::, U1>::name(), Const::)); // Scalar types agree. m.iter().all(|e| SupersetOf::::is_in_subset(e)) && @@ -173,7 +173,7 @@ where fn from_superset_unchecked( m: &OMatrix, U1>, DimNameSum, U1>>, ) -> Self { - let t = m.fixed_slice::(0, D); + let t = m.fixed_view::(0, D); Self { vector: crate::convert_unchecked(t.into_owned()), } diff --git a/src/linalg/bidiagonal.rs b/src/linalg/bidiagonal.rs index c6b02975..56591ab1 100644 --- a/src/linalg/bidiagonal.rs +++ b/src/linalg/bidiagonal.rs @@ -202,7 +202,7 @@ where ); let start = self.axis_shift(); - res.slice_mut(start, (d.value() - 1, d.value() - 1)) + res.view_mut(start, (d.value() - 1, d.value() - 1)) .set_partial_diagonal( self.off_diagonal .iter() @@ -226,11 +226,11 @@ where let shift = self.axis_shift().0; for i in (0..dim - shift).rev() { - let axis = self.uv.slice_range(i + shift.., i); + let axis = self.uv.view_range(i + shift.., i); // TODO: sometimes, the axis might have a zero magnitude. let refl = Reflection::new(Unit::new_unchecked(axis), T::zero()); - let mut res_rows = res.slice_range_mut(i + shift.., i..); + let mut res_rows = res.view_range_mut(i + shift.., i..); let sign = if self.upper_diagonal { self.diagonal[i].clone().signum() @@ -260,13 +260,13 @@ where let shift = self.axis_shift().1; for i in (0..min_nrows_ncols.value() - shift).rev() { - let axis = self.uv.slice_range(i, i + shift..); + let axis = self.uv.view_range(i, i + shift..); let mut axis_packed = axis_packed.rows_range_mut(i + shift..); axis_packed.tr_copy_from(&axis); // TODO: sometimes, the axis might have a zero magnitude. let refl = Reflection::new(Unit::new_unchecked(axis_packed), T::zero()); - let mut res_rows = res.slice_range_mut(i.., i + shift..); + let mut res_rows = res.view_range_mut(i.., i + shift..); let sign = if self.upper_diagonal { self.off_diagonal[i].clone().signum() @@ -346,7 +346,7 @@ where // *b.vget_unchecked_mut(i) = coeff; // } // -// b.rows_range_mut(.. i).axpy(-coeff, &self.uv.slice_range(.. i, i), T::one()); +// b.rows_range_mut(.. i).axpy(-coeff, &self.uv.view_range(.. i, i), T::one()); // } // } // } diff --git a/src/linalg/cholesky.rs b/src/linalg/cholesky.rs index f61a4e63..4d530927 100644 --- a/src/linalg/cholesky.rs +++ b/src/linalg/cholesky.rs @@ -67,7 +67,7 @@ where *matrix.get_unchecked_mut((j, j)) = denom.clone(); } - let mut col = matrix.slice_range_mut(j + 1.., j); + let mut col = matrix.view_range_mut(j + 1.., j); col /= denom; } @@ -228,7 +228,7 @@ where *matrix.get_unchecked_mut((j, j)) = denom.clone(); } - let mut col = matrix.slice_range_mut(j + 1.., j); + let mut col = matrix.view_range_mut(j + 1.., j); col /= denom; continue; } @@ -283,17 +283,17 @@ where self.chol.shape_generic().0.add(Const::<1>), self.chol.shape_generic().1.add(Const::<1>), ); - chol.slice_range_mut(..j, ..j) - .copy_from(&self.chol.slice_range(..j, ..j)); - chol.slice_range_mut(..j, j + 1..) - .copy_from(&self.chol.slice_range(..j, j..)); - chol.slice_range_mut(j + 1.., ..j) - .copy_from(&self.chol.slice_range(j.., ..j)); - chol.slice_range_mut(j + 1.., j + 1..) - .copy_from(&self.chol.slice_range(j.., j..)); + chol.view_range_mut(..j, ..j) + .copy_from(&self.chol.view_range(..j, ..j)); + chol.view_range_mut(..j, j + 1..) + .copy_from(&self.chol.view_range(..j, j..)); + chol.view_range_mut(j + 1.., ..j) + .copy_from(&self.chol.view_range(j.., ..j)); + chol.view_range_mut(j + 1.., j + 1..) + .copy_from(&self.chol.view_range(j.., j..)); // update the jth row - let top_left_corner = self.chol.slice_range(..j, ..j); + let top_left_corner = self.chol.view_range(..j, ..j); let col_j = col[j].clone(); let (mut new_rowj_adjoint, mut new_colj) = col.rows_range_pair_mut(..j, j + 1..); @@ -302,14 +302,14 @@ where "Cholesky::insert_column : Unable to solve lower triangular system!" ); - new_rowj_adjoint.adjoint_to(&mut chol.slice_range_mut(j, ..j)); + new_rowj_adjoint.adjoint_to(&mut chol.view_range_mut(j, ..j)); // update the center element let center_element = T::sqrt(col_j - T::from_real(new_rowj_adjoint.norm_squared())); chol[(j, j)] = center_element.clone(); // update the jth column - let bottom_left_corner = self.chol.slice_range(j.., ..j); + let bottom_left_corner = self.chol.view_range(j.., ..j); // new_colj = (col_jplus - bottom_left_corner * new_rowj.adjoint()) / center_element; new_colj.gemm( -T::one() / center_element.clone(), @@ -317,10 +317,10 @@ where &new_rowj_adjoint, T::one() / center_element, ); - chol.slice_range_mut(j + 1.., j).copy_from(&new_colj); + chol.view_range_mut(j + 1.., j).copy_from(&new_colj); // update the bottom right corner - let mut bottom_right_corner = chol.slice_range_mut(j + 1.., j + 1..); + let mut bottom_right_corner = chol.view_range_mut(j + 1.., j + 1..); Self::xx_rank_one_update( &mut bottom_right_corner, &mut new_colj, @@ -348,17 +348,17 @@ where self.chol.shape_generic().0.sub(Const::<1>), self.chol.shape_generic().1.sub(Const::<1>), ); - chol.slice_range_mut(..j, ..j) - .copy_from(&self.chol.slice_range(..j, ..j)); - chol.slice_range_mut(..j, j..) - .copy_from(&self.chol.slice_range(..j, j + 1..)); - chol.slice_range_mut(j.., ..j) - .copy_from(&self.chol.slice_range(j + 1.., ..j)); - chol.slice_range_mut(j.., j..) - .copy_from(&self.chol.slice_range(j + 1.., j + 1..)); + chol.view_range_mut(..j, ..j) + .copy_from(&self.chol.view_range(..j, ..j)); + chol.view_range_mut(..j, j..) + .copy_from(&self.chol.view_range(..j, j + 1..)); + chol.view_range_mut(j.., ..j) + .copy_from(&self.chol.view_range(j + 1.., ..j)); + chol.view_range_mut(j.., j..) + .copy_from(&self.chol.view_range(j + 1.., j + 1..)); // updates the bottom right corner - let mut bottom_right_corner = chol.slice_range_mut(j.., j..); + let mut bottom_right_corner = chol.view_range_mut(j.., j..); let mut workspace = self.chol.column(j).clone_owned(); let mut old_colj = workspace.rows_range_mut(j + 1..); Self::xx_rank_one_update(&mut bottom_right_corner, &mut old_colj, T::RealField::one()); @@ -370,7 +370,7 @@ where /// performs a rank one update such that we end up with the decomposition of `M + sigma * (x * x.adjoint())`. /// /// This helper method is called by `rank_one_update` but also `insert_column` and `remove_column` - /// where it is used on a square slice of the decomposition + /// where it is used on a square view of the decomposition fn xx_rank_one_update( chol: &mut Matrix, x: &mut Vector, @@ -404,7 +404,7 @@ where beta += sigma_xj2 / diag2; // updates the terms of L let mut xjplus = x.rows_range_mut(j + 1..); - let mut col_j = chol.slice_range_mut(j + 1.., j); + let mut col_j = chol.view_range_mut(j + 1.., j); // temp_jplus -= (wj / T::from_real(diag)) * col_j; xjplus.axpy(-xj.clone() / T::from_real(diag.clone()), &col_j, T::one()); if gamma != crate::zero::() { diff --git a/src/linalg/col_piv_qr.rs b/src/linalg/col_piv_qr.rs index 822448e3..bd234b60 100644 --- a/src/linalg/col_piv_qr.rs +++ b/src/linalg/col_piv_qr.rs @@ -78,7 +78,7 @@ where let mut diag = Matrix::uninit(min_nrows_ncols, Const::<1>); for i in 0..min_nrows_ncols.value() { - let piv = matrix.slice_range(i.., i..).icamax_full(); + let piv = matrix.view_range(i.., i..).icamax_full(); let col_piv = piv.1 + i; matrix.swap_columns(i, col_piv); p.append_permutation(i, col_piv); @@ -144,11 +144,11 @@ where let dim = self.diag.len(); for i in (0..dim).rev() { - let axis = self.col_piv_qr.slice_range(i.., i); + let axis = self.col_piv_qr.view_range(i.., i); // TODO: sometimes, the axis might have a zero magnitude. let refl = Reflection::new(Unit::new_unchecked(axis), T::zero()); - let mut res_rows = res.slice_range_mut(i.., i..); + let mut res_rows = res.view_range_mut(i.., i..); refl.reflect_with_sign(&mut res_rows, self.diag[i].clone().signum()); } @@ -191,7 +191,7 @@ where let dim = self.diag.len(); for i in 0..dim { - let axis = self.col_piv_qr.slice_range(i.., i); + let axis = self.col_piv_qr.view_range(i.., i); let refl = Reflection::new(Unit::new_unchecked(axis), T::zero()); let mut rhs_rows = rhs.rows_range_mut(i..); @@ -281,7 +281,7 @@ where } b.rows_range_mut(..i) - .axpy(-coeff, &self.col_piv_qr.slice_range(..i, i), T::one()); + .axpy(-coeff, &self.col_piv_qr.view_range(..i, i), T::one()); } } diff --git a/src/linalg/full_piv_lu.rs b/src/linalg/full_piv_lu.rs index b11bf4d6..2037e285 100644 --- a/src/linalg/full_piv_lu.rs +++ b/src/linalg/full_piv_lu.rs @@ -64,7 +64,7 @@ where } for i in 0..min_nrows_ncols.value() { - let piv = matrix.slice_range(i.., i..).icamax_full(); + let piv = matrix.view_range(i.., i..).icamax_full(); let row_piv = piv.0 + i; let col_piv = piv.1 + i; let diag = matrix[(row_piv, col_piv)].clone(); diff --git a/src/linalg/hessenberg.rs b/src/linalg/hessenberg.rs index 2f85d462..0313a0bb 100644 --- a/src/linalg/hessenberg.rs +++ b/src/linalg/hessenberg.rs @@ -113,7 +113,7 @@ where let dim = self.hess.nrows(); self.hess.fill_lower_triangle(T::zero(), 2); self.hess - .slice_mut((1, 0), (dim - 1, dim - 1)) + .view_mut((1, 0), (dim - 1, dim - 1)) .set_partial_diagonal( self.subdiag .iter() @@ -132,7 +132,7 @@ where let dim = self.hess.nrows(); let mut res = self.hess.clone(); res.fill_lower_triangle(T::zero(), 2); - res.slice_mut((1, 0), (dim - 1, dim - 1)) + res.view_mut((1, 0), (dim - 1, dim - 1)) .set_partial_diagonal( self.subdiag .iter() diff --git a/src/linalg/householder.rs b/src/linalg/householder.rs index 688930a3..79d7c768 100644 --- a/src/linalg/householder.rs +++ b/src/linalg/householder.rs @@ -128,10 +128,10 @@ where let mut res = OMatrix::identity_generic(dim, dim); for i in (0..dim.value() - 1).rev() { - let axis = m.slice_range(i + 1.., i); + let axis = m.view_range(i + 1.., i); let refl = Reflection::new(Unit::new_unchecked(axis), T::zero()); - let mut res_rows = res.slice_range_mut(i + 1.., i..); + let mut res_rows = res.view_range_mut(i + 1.., i..); refl.reflect_with_sign(&mut res_rows, signs[i].clone().signum()); } diff --git a/src/linalg/lu.rs b/src/linalg/lu.rs index 01ae46f0..a5e87072 100644 --- a/src/linalg/lu.rs +++ b/src/linalg/lu.rs @@ -64,7 +64,7 @@ where out.fill_with_identity(); for i in 0..dim { - let piv = matrix.slice_range(i.., i).icamax() + i; + let piv = matrix.view_range(i.., i).icamax() + i; let diag = matrix[(piv, i)].clone(); if diag.is_zero() { @@ -100,7 +100,7 @@ where } for i in 0..min_nrows_ncols.value() { - let piv = matrix.slice_range(i.., i).icamax() + i; + let piv = matrix.view_range(i.., i).icamax() + i; let diag = matrix[(piv, i)].clone(); if diag.is_zero() { @@ -338,7 +338,7 @@ where T: Scalar + Field, S: StorageMut, { - let mut submat = matrix.slice_range_mut(i.., i..); + let mut submat = matrix.view_range_mut(i.., i..); let inv_diag = T::one() / diag; @@ -368,7 +368,7 @@ pub fn gauss_step_swap( S: StorageMut, { let piv = piv - i; - let mut submat = matrix.slice_range_mut(i.., i..); + let mut submat = matrix.view_range_mut(i.., i..); let inv_diag = T::one() / diag; diff --git a/src/linalg/qr.rs b/src/linalg/qr.rs index 1b06e34b..54921939 100644 --- a/src/linalg/qr.rs +++ b/src/linalg/qr.rs @@ -116,11 +116,11 @@ where let dim = self.diag.len(); for i in (0..dim).rev() { - let axis = self.qr.slice_range(i.., i); + let axis = self.qr.view_range(i.., i); // TODO: sometimes, the axis might have a zero magnitude. let refl = Reflection::new(Unit::new_unchecked(axis), T::zero()); - let mut res_rows = res.slice_range_mut(i.., i..); + let mut res_rows = res.view_range_mut(i.., i..); refl.reflect_with_sign(&mut res_rows, self.diag[i].clone().signum()); } @@ -161,7 +161,7 @@ where let dim = self.diag.len(); for i in 0..dim { - let axis = self.qr.slice_range(i.., i); + let axis = self.qr.view_range(i.., i); let refl = Reflection::new(Unit::new_unchecked(axis), T::zero()); let mut rhs_rows = rhs.rows_range_mut(i..); @@ -247,7 +247,7 @@ where } b.rows_range_mut(..i) - .axpy(-coeff, &self.qr.slice_range(..i, i), T::one()); + .axpy(-coeff, &self.qr.view_range(..i, i), T::one()); } } diff --git a/src/linalg/schur.rs b/src/linalg/schur.rs index c7753cee..3388e7cf 100644 --- a/src/linalg/schur.rs +++ b/src/linalg/schur.rs @@ -174,19 +174,19 @@ where { let krows = cmp::min(k + 4, end + 1); let mut work = work.rows_mut(0, krows); - refl.reflect(&mut t.generic_slice_mut( + refl.reflect(&mut t.generic_view_mut( (k, k), (Const::<3>, Dynamic::new(dim.value() - k)), )); refl.reflect_rows( - &mut t.generic_slice_mut((0, k), (Dynamic::new(krows), Const::<3>)), + &mut t.generic_view_mut((0, k), (Dynamic::new(krows), Const::<3>)), &mut work, ); } if let Some(ref mut q) = q { refl.reflect_rows( - &mut q.generic_slice_mut((0, k), (dim, Const::<3>)), + &mut q.generic_view_mut((0, k), (dim, Const::<3>)), work, ); } @@ -211,38 +211,38 @@ where { let mut work = work.rows_mut(0, end + 1); - refl.reflect(&mut t.generic_slice_mut( + refl.reflect(&mut t.generic_view_mut( (m, m), (Const::<2>, Dynamic::new(dim.value() - m)), )); refl.reflect_rows( - &mut t.generic_slice_mut((0, m), (Dynamic::new(end + 1), Const::<2>)), + &mut t.generic_view_mut((0, m), (Dynamic::new(end + 1), Const::<2>)), &mut work, ); } if let Some(ref mut q) = q { refl.reflect_rows( - &mut q.generic_slice_mut((0, m), (dim, Const::<2>)), + &mut q.generic_view_mut((0, m), (dim, Const::<2>)), work, ); } } } else { // Decouple the 2x2 block if it has real eigenvalues. - if let Some(rot) = compute_2x2_basis(&t.fixed_slice::<2, 2>(start, start)) { + if let Some(rot) = compute_2x2_basis(&t.fixed_view::<2, 2>(start, start)) { let inv_rot = rot.inverse(); - inv_rot.rotate(&mut t.generic_slice_mut( + inv_rot.rotate(&mut t.generic_view_mut( (start, start), (Const::<2>, Dynamic::new(dim.value() - start)), )); rot.rotate_rows( - &mut t.generic_slice_mut((0, start), (Dynamic::new(end + 1), Const::<2>)), + &mut t.generic_view_mut((0, start), (Dynamic::new(end + 1), Const::<2>)), ); t[(end, start)] = T::zero(); if let Some(ref mut q) = q { - rot.rotate_rows(&mut q.generic_slice_mut((0, start), (dim, Const::<2>))); + rot.rotate_rows(&mut q.generic_view_mut((0, start), (dim, Const::<2>))); } } @@ -427,9 +427,9 @@ where { let dim = m.shape_generic().0; let mut q = None; - match compute_2x2_basis(&m.fixed_slice::<2, 2>(0, 0)) { + match compute_2x2_basis(&m.fixed_view::<2, 2>(0, 0)) { Some(rot) => { - let mut m = m.fixed_slice_mut::<2, 2>(0, 0); + let mut m = m.fixed_view_mut::<2, 2>(0, 0); let inv_rot = rot.inverse(); inv_rot.rotate(&mut m); rot.rotate_rows(&mut m); @@ -530,7 +530,7 @@ where if self.nrows() == 2 { // TODO: can we avoid this slicing // (which is needed here just to transform D to U2)? - let me = self.fixed_slice::<2, 2>(0, 0); + let me = self.fixed_view::<2, 2>(0, 0); return match compute_2x2_eigvals(&me) { Some((a, b)) => { work[0] = a; diff --git a/src/linalg/solve.rs b/src/linalg/solve.rs index c355f2d0..237986a8 100644 --- a/src/linalg/solve.rs +++ b/src/linalg/solve.rs @@ -93,7 +93,7 @@ impl> SquareMatrix { } b.rows_range_mut(i + 1..) - .axpy(-coeff, &self.slice_range(i + 1.., i), T::one()); + .axpy(-coeff, &self.view_range(i + 1.., i), T::one()); } true @@ -125,7 +125,7 @@ impl> SquareMatrix { for i in 0..dim - 1 { let coeff = unsafe { bcol.vget_unchecked(i).clone() } / diag.clone(); bcol.rows_range_mut(i + 1..) - .axpy(-coeff, &self.slice_range(i + 1.., i), T::one()); + .axpy(-coeff, &self.view_range(i + 1.., i), T::one()); } } @@ -175,7 +175,7 @@ impl> SquareMatrix { } b.rows_range_mut(..i) - .axpy(-coeff, &self.slice_range(..i, i), T::one()); + .axpy(-coeff, &self.view_range(..i, i), T::one()); } true @@ -387,7 +387,7 @@ impl> SquareMatrix { let dim = self.nrows(); for i in (0..dim).rev() { - let dot = dot(&self.slice_range(i + 1.., i), &b.slice_range(i + 1.., 0)); + let dot = dot(&self.view_range(i + 1.., i), &b.view_range(i + 1.., 0)); unsafe { let b_i = b.vget_unchecked_mut(i); @@ -422,7 +422,7 @@ impl> SquareMatrix { let dim = self.nrows(); for i in 0..dim { - let dot = dot(&self.slice_range(..i, i), &b.slice_range(..i, 0)); + let dot = dot(&self.view_range(..i, i), &b.view_range(..i, 0)); unsafe { let b_i = b.vget_unchecked_mut(i); @@ -514,7 +514,7 @@ impl> SquareMatrix { } b.rows_range_mut(i + 1..) - .axpy(-coeff.clone(), &self.slice_range(i + 1.., i), T::one()); + .axpy(-coeff.clone(), &self.view_range(i + 1.., i), T::one()); } } @@ -539,7 +539,7 @@ impl> SquareMatrix { for i in 0..dim - 1 { let coeff = unsafe { bcol.vget_unchecked(i).clone() } / diag.clone(); bcol.rows_range_mut(i + 1..) - .axpy(-coeff, &self.slice_range(i + 1.., i), T::one()); + .axpy(-coeff, &self.view_range(i + 1.., i), T::one()); } } } @@ -575,7 +575,7 @@ impl> SquareMatrix { } b.rows_range_mut(..i) - .axpy(-coeff, &self.slice_range(..i, i), T::one()); + .axpy(-coeff, &self.view_range(..i, i), T::one()); } } @@ -744,7 +744,7 @@ impl> SquareMatrix { let dim = self.nrows(); for i in (0..dim).rev() { - let dot = dot(&self.slice_range(i + 1.., i), &b.slice_range(i + 1.., 0)); + let dot = dot(&self.view_range(i + 1.., i), &b.view_range(i + 1.., 0)); unsafe { let b_i = b.vget_unchecked_mut(i); @@ -768,7 +768,7 @@ impl> SquareMatrix { ShapeConstraint: SameNumberOfRows, { for i in 0..self.nrows() { - let dot = dot(&self.slice_range(..i, i), &b.slice_range(..i, 0)); + let dot = dot(&self.view_range(..i, i), &b.view_range(..i, 0)); unsafe { let b_i = b.vget_unchecked_mut(i); From 8867b365e3a824981363a00ec62fc37237c7a21a Mon Sep 17 00:00:00 2001 From: Andreas Longva Date: Mon, 14 Nov 2022 14:40:53 +0100 Subject: [PATCH 13/22] Rename slice -> view in parameter names, comments etc. --- src/base/construction_view.rs | 6 +-- src/base/conversion.rs | 96 +++++++++++++++++------------------ src/base/matrix_view.rs | 4 +- src/base/storage.rs | 4 +- 4 files changed, 55 insertions(+), 55 deletions(-) diff --git a/src/base/construction_view.rs b/src/base/construction_view.rs index fbb038cb..910b2873 100644 --- a/src/base/construction_view.rs +++ b/src/base/construction_view.rs @@ -48,7 +48,7 @@ impl<'a, T: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim> assert!( data.len() + cstride.value() + rstride.value() >= ncols.value() * cstride.value() + nrows.value() * rstride.value() + 1, - "Matrix slice: input data buffer to small." + "Matrix view: input data buffer too small." ); unsafe { @@ -186,7 +186,7 @@ impl<'a, T: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim> assert!( data.len() + cstride.value() + rstride.value() >= ncols.value() * cstride.value() + nrows.value() * rstride.value() + 1, - "Matrix slice: input data buffer to small." + "Matrix view: input data buffer too small." ); assert!( @@ -208,7 +208,7 @@ impl<'a, T: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim> } } }, - "Matrix slice: dimensions and strides result in aliased indices." + "Matrix view: dimensions and strides result in aliased indices." ); unsafe { diff --git a/src/base/conversion.rs b/src/base/conversion.rs index 4c83796e..79a61461 100644 --- a/src/base/conversion.rs +++ b/src/base/conversion.rs @@ -296,8 +296,8 @@ where RStride: Dim, CStride: Dim, { - fn from(matrix_slice: MatrixView<'a, T, Const, Const, RStride, CStride>) -> Self { - matrix_slice.into_owned() + fn from(matrix_view: MatrixView<'a, T, Const, Const, RStride, CStride>) -> Self { + matrix_view.into_owned() } } @@ -310,8 +310,8 @@ where RStride: Dim, CStride: Dim, { - fn from(matrix_slice: MatrixView<'a, T, Dynamic, C, RStride, CStride>) -> Self { - matrix_slice.into_owned() + fn from(matrix_view: MatrixView<'a, T, Dynamic, C, RStride, CStride>) -> Self { + matrix_view.into_owned() } } @@ -324,8 +324,8 @@ where RStride: Dim, CStride: Dim, { - fn from(matrix_slice: MatrixView<'a, T, R, Dynamic, RStride, CStride>) -> Self { - matrix_slice.into_owned() + fn from(matrix_view: MatrixView<'a, T, R, Dynamic, RStride, CStride>) -> Self { + matrix_view.into_owned() } } @@ -337,8 +337,8 @@ where RStride: Dim, CStride: Dim, { - fn from(matrix_slice: MatrixViewMut<'a, T, Const, Const, RStride, CStride>) -> Self { - matrix_slice.into_owned() + fn from(matrix_view: MatrixViewMut<'a, T, Const, Const, RStride, CStride>) -> Self { + matrix_view.into_owned() } } @@ -351,8 +351,8 @@ where RStride: Dim, CStride: Dim, { - fn from(matrix_slice: MatrixViewMut<'a, T, Dynamic, C, RStride, CStride>) -> Self { - matrix_slice.into_owned() + fn from(matrix_view: MatrixViewMut<'a, T, Dynamic, C, RStride, CStride>) -> Self { + matrix_view.into_owned() } } @@ -365,116 +365,116 @@ where RStride: Dim, CStride: Dim, { - fn from(matrix_slice: MatrixViewMut<'a, T, R, Dynamic, RStride, CStride>) -> Self { - matrix_slice.into_owned() + fn from(matrix_view: MatrixViewMut<'a, T, R, Dynamic, RStride, CStride>) -> Self { + matrix_view.into_owned() } } -impl<'a, T, R, C, RSlice, CSlice, RStride, CStride, S> From<&'a Matrix> - for MatrixView<'a, T, RSlice, CSlice, RStride, CStride> +impl<'a, T, R, C, RView, CView, RStride, CStride, S> From<&'a Matrix> + for MatrixView<'a, T, RView, CView, RStride, CStride> where T: Scalar, R: Dim, C: Dim, - RSlice: Dim, - CSlice: Dim, + RView: Dim, + CView: Dim, RStride: Dim, CStride: Dim, S: RawStorage, - ShapeConstraint: DimEq - + DimEq + ShapeConstraint: DimEq + + DimEq + DimEq + DimEq, { fn from(m: &'a Matrix) -> Self { let (row, col) = m.shape_generic(); - let row_slice = RSlice::from_usize(row.value()); - let col_slice = CSlice::from_usize(col.value()); + let rows_result = RView::from_usize(row.value()); + let cols_result = CView::from_usize(col.value()); let (rstride, cstride) = m.strides(); - let rstride_slice = RStride::from_usize(rstride); - let cstride_slice = CStride::from_usize(cstride); + let rstride_result = RStride::from_usize(rstride); + let cstride_result = CStride::from_usize(cstride); unsafe { let data = ViewStorage::from_raw_parts( m.data.ptr(), - (row_slice, col_slice), - (rstride_slice, cstride_slice), + (rows_result, cols_result), + (rstride_result, cstride_result), ); Matrix::from_data_statically_unchecked(data) } } } -impl<'a, T, R, C, RSlice, CSlice, RStride, CStride, S> From<&'a mut Matrix> - for MatrixView<'a, T, RSlice, CSlice, RStride, CStride> +impl<'a, T, R, C, RView, CView, RStride, CStride, S> From<&'a mut Matrix> + for MatrixView<'a, T, RView, CView, RStride, CStride> where T: Scalar, R: Dim, C: Dim, - RSlice: Dim, - CSlice: Dim, + RView: Dim, + CView: Dim, RStride: Dim, CStride: Dim, S: RawStorage, - ShapeConstraint: DimEq - + DimEq + ShapeConstraint: DimEq + + DimEq + DimEq + DimEq, { fn from(m: &'a mut Matrix) -> Self { let (row, col) = m.shape_generic(); - let row_slice = RSlice::from_usize(row.value()); - let col_slice = CSlice::from_usize(col.value()); + let rows_result = RView::from_usize(row.value()); + let cols_result = CView::from_usize(col.value()); let (rstride, cstride) = m.strides(); - let rstride_slice = RStride::from_usize(rstride); - let cstride_slice = CStride::from_usize(cstride); + let rstride_result = RStride::from_usize(rstride); + let cstride_result = CStride::from_usize(cstride); unsafe { let data = ViewStorage::from_raw_parts( m.data.ptr(), - (row_slice, col_slice), - (rstride_slice, cstride_slice), + (rows_result, cols_result), + (rstride_result, cstride_result), ); Matrix::from_data_statically_unchecked(data) } } } -impl<'a, T, R, C, RSlice, CSlice, RStride, CStride, S> From<&'a mut Matrix> - for MatrixViewMut<'a, T, RSlice, CSlice, RStride, CStride> +impl<'a, T, R, C, RView, CView, RStride, CStride, S> From<&'a mut Matrix> + for MatrixViewMut<'a, T, RView, CView, RStride, CStride> where T: Scalar, R: Dim, C: Dim, - RSlice: Dim, - CSlice: Dim, + RView: Dim, + CView: Dim, RStride: Dim, CStride: Dim, S: RawStorageMut, - ShapeConstraint: DimEq - + DimEq + ShapeConstraint: DimEq + + DimEq + DimEq + DimEq, { fn from(m: &'a mut Matrix) -> Self { let (row, col) = m.shape_generic(); - let row_slice = RSlice::from_usize(row.value()); - let col_slice = CSlice::from_usize(col.value()); + let rows_result = RView::from_usize(row.value()); + let cols_result = CView::from_usize(col.value()); let (rstride, cstride) = m.strides(); - let rstride_slice = RStride::from_usize(rstride); - let cstride_slice = CStride::from_usize(cstride); + let rstride_result = RStride::from_usize(rstride); + let cstride_result = CStride::from_usize(cstride); unsafe { let data = ViewStorageMut::from_raw_parts( m.data.ptr_mut(), - (row_slice, col_slice), - (rstride_slice, cstride_slice), + (rows_result, cols_result), + (rstride_result, cstride_result), ); Matrix::from_data_statically_unchecked(data) } diff --git a/src/base/matrix_view.rs b/src/base/matrix_view.rs index 0580546e..4af0a7e9 100644 --- a/src/base/matrix_view.rs +++ b/src/base/matrix_view.rs @@ -667,7 +667,7 @@ macro_rules! matrix_view_impl ( let nrows1 = r1.size(nrows); let nrows2 = r2.size(nrows); - assert!(start2 >= end1 || start1 >= end2, "Rows range pair: the slice ranges must not overlap."); + assert!(start2 >= end1 || start1 >= end2, "Rows range pair: the ranges must not overlap."); assert!(end2 <= nrows.value(), "Rows range pair: index out of range."); unsafe { @@ -703,7 +703,7 @@ macro_rules! matrix_view_impl ( let ncols1 = r1.size(ncols); let ncols2 = r2.size(ncols); - assert!(start2 >= end1 || start1 >= end2, "Columns range pair: the slice ranges must not overlap."); + assert!(start2 >= end1 || start1 >= end2, "Columns range pair: the ranges must not overlap."); assert!(end2 <= ncols.value(), "Columns range pair: index out of range."); unsafe { diff --git a/src/base/storage.rs b/src/base/storage.rs index 76a60ce3..dd335014 100644 --- a/src/base/storage.rs +++ b/src/base/storage.rs @@ -122,7 +122,7 @@ pub unsafe trait RawStorage: Sized { /// # Safety /// The matrix components may not be stored in a contiguous way, depending on the strides. /// This method is unsafe because this can yield to invalid aliasing when called on some pairs - /// of matrix slices originating from the same matrix with strides. + /// of matrix views originating from the same matrix with strides. /// /// Call the safe alternative `matrix.as_slice()` instead. unsafe fn as_slice_unchecked(&self) -> &[T]; @@ -148,7 +148,7 @@ pub unsafe trait Storage: RawStorage { /// contains `MaybeUninit` elements. /// /// Note that a mutable access does not mean that the matrix owns its data. For example, a mutable -/// matrix slice can provide mutable access to its elements even if it does not own its data (it +/// matrix view can provide mutable access to its elements even if it does not own its data (it /// contains only an internal reference to them). pub unsafe trait RawStorageMut: RawStorage { /// The matrix mutable data pointer. From 0c402318ec16f67a3ebfb4387b93db9c27921d54 Mon Sep 17 00:00:00 2001 From: Andreas Longva Date: Mon, 14 Nov 2022 14:42:23 +0100 Subject: [PATCH 14/22] Rename internal assert_slice_index -> assert_view_index --- src/base/matrix_view.rs | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/src/base/matrix_view.rs b/src/base/matrix_view.rs index 4af0a7e9..497a1553 100644 --- a/src/base/matrix_view.rs +++ b/src/base/matrix_view.rs @@ -262,7 +262,7 @@ unsafe impl<'a, T, R: DimName, C: Dim + IsNotStaticOne> IsContiguous impl> Matrix { #[inline] - fn assert_slice_index( + fn assert_view_index( &self, start: (usize, usize), shape: (usize, usize), @@ -367,7 +367,7 @@ macro_rules! matrix_view_impl ( -> $MatrixView<'_, T, RView, C, S::RStride, S::CStride> { let my_shape = $me.shape_generic(); - $me.assert_slice_index((row_start, 0), (nrows.value(), my_shape.1.value()), (0, 0)); + $me.assert_view_index((row_start, 0), (nrows.value(), my_shape.1.value()), (0, 0)); let shape = (nrows, my_shape.1); @@ -386,7 +386,7 @@ macro_rules! matrix_view_impl ( let my_shape = $me.shape_generic(); let my_strides = $me.data.strides(); - $me.assert_slice_index((row_start, 0), (nrows.value(), my_shape.1.value()), (step, 0)); + $me.assert_view_index((row_start, 0), (nrows.value(), my_shape.1.value()), (step, 0)); let strides = (Dynamic::new((step + 1) * my_strides.0.value()), my_strides.1); let shape = (nrows, my_shape.1); @@ -455,7 +455,7 @@ macro_rules! matrix_view_impl ( -> $MatrixView<'_, T, R, CView, S::RStride, S::CStride> { let my_shape = $me.shape_generic(); - $me.assert_slice_index((0, first_col), (my_shape.0.value(), ncols.value()), (0, 0)); + $me.assert_view_index((0, first_col), (my_shape.0.value(), ncols.value()), (0, 0)); let shape = (my_shape.0, ncols); unsafe { @@ -474,7 +474,7 @@ macro_rules! matrix_view_impl ( let my_shape = $me.shape_generic(); let my_strides = $me.data.strides(); - $me.assert_slice_index((0, first_col), (my_shape.0.value(), ncols.value()), (0, step)); + $me.assert_view_index((0, first_col), (my_shape.0.value(), ncols.value()), (0, step)); let strides = (my_strides.0, Dynamic::new((step + 1) * my_strides.1.value())); let shape = (my_shape.0, ncols); @@ -505,7 +505,7 @@ macro_rules! matrix_view_impl ( pub fn $view($me: $Me, start: (usize, usize), shape: (usize, usize)) -> $MatrixView<'_, T, Dynamic, Dynamic, S::RStride, S::CStride> { - $me.assert_slice_index(start, shape, (0, 0)); + $me.assert_view_index(start, shape, (0, 0)); let shape = (Dynamic::new(shape.0), Dynamic::new(shape.1)); unsafe { @@ -551,7 +551,7 @@ macro_rules! matrix_view_impl ( pub fn $fixed_view($me: $Me, irow: usize, icol: usize) -> $MatrixView<'_, T, Const, Const, S::RStride, S::CStride> { - $me.assert_slice_index((irow, icol), (RVIEW, CVIEW), (0, 0)); + $me.assert_view_index((irow, icol), (RVIEW, CVIEW), (0, 0)); let shape = (Const::, Const::); unsafe { @@ -599,7 +599,7 @@ macro_rules! matrix_view_impl ( where RView: Dim, CView: Dim { - $me.assert_slice_index(start, (shape.0.value(), shape.1.value()), (0, 0)); + $me.assert_view_index(start, (shape.0.value(), shape.1.value()), (0, 0)); unsafe { let data = $ViewStorage::new_unchecked($data, start, shape); @@ -630,7 +630,7 @@ macro_rules! matrix_view_impl ( where RView: Dim, CView: Dim { - $me.assert_slice_index(start, (shape.0.value(), shape.1.value()), steps); + $me.assert_view_index(start, (shape.0.value(), shape.1.value()), steps); let my_strides = $me.data.strides(); let strides = (Dynamic::new((steps.0 + 1) * my_strides.0.value()), From 234d61faa20e41de8327820a107cb38fcb45abef Mon Sep 17 00:00:00 2001 From: Andreas Longva Date: Mon, 14 Nov 2022 14:47:43 +0100 Subject: [PATCH 15/22] Rename SliceRange to DimRange --- src/base/matrix_view.rs | 51 ++++++++++++++++++++++++----------------- 1 file changed, 30 insertions(+), 21 deletions(-) diff --git a/src/base/matrix_view.rs b/src/base/matrix_view.rs index 497a1553..ef024f19 100644 --- a/src/base/matrix_view.rs +++ b/src/base/matrix_view.rs @@ -651,7 +651,7 @@ macro_rules! matrix_view_impl ( /// /// Panics if the ranges overlap or if the first range is empty. #[inline] - pub fn $rows_range_pair, Range2: SliceRange>($me: $Me, r1: Range1, r2: Range2) + pub fn $rows_range_pair, Range2: DimRange>($me: $Me, r1: Range1, r2: Range2) -> ($MatrixView<'_, T, Range1::Size, C, S::RStride, S::CStride>, $MatrixView<'_, T, Range2::Size, C, S::RStride, S::CStride>) { @@ -687,7 +687,7 @@ macro_rules! matrix_view_impl ( /// /// Panics if the ranges overlap or if the first range is empty. #[inline] - pub fn $columns_range_pair, Range2: SliceRange>($me: $Me, r1: Range1, r2: Range2) + pub fn $columns_range_pair, Range2: DimRange>($me: $Me, r1: Range1, r2: Range2) -> ($MatrixView<'_, T, R, Range1::Size, S::RStride, S::CStride>, $MatrixView<'_, T, R, Range2::Size, S::RStride, S::CStride>) { @@ -816,7 +816,7 @@ impl> Matrix { /// * A left-open range `std::ops::RangeTo`, e.g., `.. 4` /// * A right-open range `std::ops::RangeFrom`, e.g., `4 ..` /// * A full range `std::ops::RangeFull`, e.g., `..` -pub trait SliceRange { +pub trait DimRange { /// Type of the range size. May be a type-level integer. type Size: Dim; @@ -829,7 +829,16 @@ pub trait SliceRange { fn size(&self, shape: D) -> Self::Size; } -impl SliceRange for usize { +/// A range with a size that may be known at compile-time. +/// +/// This is merely a legacy trait alias to minimize breakage. Use the [`DimRange`] trait instead. +#[deprecated = slice_deprecation_note!(DimRange)] +pub trait SliceRange: DimRange {} + +#[allow(deprecated)] +impl, D: Dim> SliceRange for R {} + +impl DimRange for usize { type Size = U1; #[inline(always)] @@ -848,7 +857,7 @@ impl SliceRange for usize { } } -impl SliceRange for Range { +impl DimRange for Range { type Size = Dynamic; #[inline(always)] @@ -867,7 +876,7 @@ impl SliceRange for Range { } } -impl SliceRange for RangeFrom { +impl DimRange for RangeFrom { type Size = Dynamic; #[inline(always)] @@ -886,7 +895,7 @@ impl SliceRange for RangeFrom { } } -impl SliceRange for RangeTo { +impl DimRange for RangeTo { type Size = Dynamic; #[inline(always)] @@ -905,7 +914,7 @@ impl SliceRange for RangeTo { } } -impl SliceRange for RangeFull { +impl DimRange for RangeFull { type Size = D; #[inline(always)] @@ -924,7 +933,7 @@ impl SliceRange for RangeFull { } } -impl SliceRange for RangeInclusive { +impl DimRange for RangeInclusive { type Size = Dynamic; #[inline(always)] @@ -957,8 +966,8 @@ impl> Matrix { cols: ColRange, ) -> MatrixView<'_, T, RowRange::Size, ColRange::Size, S::RStride, S::CStride> where - RowRange: SliceRange, - ColRange: SliceRange, + RowRange: DimRange, + ColRange: DimRange, { let (nrows, ncols) = self.shape_generic(); self.generic_view( @@ -977,8 +986,8 @@ impl> Matrix { cols: ColRange, ) -> MatrixView<'_, T, RowRange::Size, ColRange::Size, S::RStride, S::CStride> where - RowRange: SliceRange, - ColRange: SliceRange, + RowRange: DimRange, + ColRange: DimRange, { let (nrows, ncols) = self.shape_generic(); self.generic_view( @@ -990,7 +999,7 @@ impl> Matrix { /// View containing all the rows indexed by the range `rows`. #[inline] #[must_use] - pub fn rows_range>( + pub fn rows_range>( &self, rows: RowRange, ) -> MatrixView<'_, T, RowRange::Size, C, S::RStride, S::CStride> { @@ -1000,7 +1009,7 @@ impl> Matrix { /// View containing all the columns indexed by the range `rows`. #[inline] #[must_use] - pub fn columns_range>( + pub fn columns_range>( &self, cols: ColRange, ) -> MatrixView<'_, T, R, ColRange::Size, S::RStride, S::CStride> { @@ -1020,8 +1029,8 @@ impl> Matrix { cols: ColRange, ) -> MatrixViewMut<'_, T, RowRange::Size, ColRange::Size, S::RStride, S::CStride> where - RowRange: SliceRange, - ColRange: SliceRange, + RowRange: DimRange, + ColRange: DimRange, { self.view_range_mut(rows, cols) } @@ -1034,8 +1043,8 @@ impl> Matrix { cols: ColRange, ) -> MatrixViewMut<'_, T, RowRange::Size, ColRange::Size, S::RStride, S::CStride> where - RowRange: SliceRange, - ColRange: SliceRange, + RowRange: DimRange, + ColRange: DimRange, { let (nrows, ncols) = self.shape_generic(); self.generic_view_mut( @@ -1046,7 +1055,7 @@ impl> Matrix { /// Mutable view containing all the rows indexed by the range `rows`. #[inline] - pub fn rows_range_mut>( + pub fn rows_range_mut>( &mut self, rows: RowRange, ) -> MatrixViewMut<'_, T, RowRange::Size, C, S::RStride, S::CStride> { @@ -1055,7 +1064,7 @@ impl> Matrix { /// Mutable view containing all the columns indexed by the range `cols`. #[inline] - pub fn columns_range_mut>( + pub fn columns_range_mut>( &mut self, cols: ColRange, ) -> MatrixViewMut<'_, T, R, ColRange::Size, S::RStride, S::CStride> { From 6c8947ccc08d3dfdd48a6ca32400ea76e64c0c1f Mon Sep 17 00:00:00 2001 From: Andreas Longva Date: Mon, 14 Nov 2022 15:16:23 +0100 Subject: [PATCH 16/22] Replace slice->view in tests and benches --- benches/core/matrix.rs | 2 +- tests/core/conversion.rs | 70 ++++++++++++++++---------------- tests/core/matrix.rs | 48 +++++++++++----------- tests/core/matrix_slice.rs | 82 +++++++++++++++++++------------------- 4 files changed, 101 insertions(+), 101 deletions(-) diff --git a/benches/core/matrix.rs b/benches/core/matrix.rs index 3c483c35..8f3d6305 100644 --- a/benches/core/matrix.rs +++ b/benches/core/matrix.rs @@ -53,7 +53,7 @@ fn mat_div_scalar(b: &mut criterion::Criterion) { b.bench_function("mat_div_scalar", move |bh| { bh.iter(|| { let mut aa = a.clone(); - let mut b = aa.slice_mut((0, 0), (1000, 1000)); + let mut b = aa.view_mut((0, 0), (1000, 1000)); b /= n }) }); diff --git a/tests/core/conversion.rs b/tests/core/conversion.rs index 5374c399..096f235b 100644 --- a/tests/core/conversion.rs +++ b/tests/core/conversion.rs @@ -7,7 +7,7 @@ use na::{ RowVector5, RowVector6, Similarity3, Transform3, UnitQuaternion, Vector1, Vector2, Vector3, Vector4, Vector5, Vector6, }; -use na::{DMatrix, DMatrixSlice, DMatrixSliceMut, MatrixSlice, MatrixSliceMut}; +use na::{DMatrix, DMatrixView, DMatrixViewMut, MatrixView, MatrixViewMut}; use na::{U1, U3, U4}; use crate::proptest::*; @@ -266,24 +266,24 @@ fn matrix_slice_from_matrix_ref() { // Note: these have to be macros, and not functions, because the input type is different // across the different tests. Moreover, the output type depends on the stride of the input, // which is different for static and dynamic matrices. - macro_rules! dynamic_slice { + macro_rules! dynamic_view { ($mref:expr) => { - DMatrixSlice::<_>::from($mref) + DMatrixView::<_>::from($mref) }; } - macro_rules! dynamic_slice_mut { + macro_rules! dynamic_view_mut { ($mref:expr) => { - DMatrixSliceMut::<_>::from($mref) + DMatrixViewMut::<_>::from($mref) }; } - macro_rules! fixed_slice { + macro_rules! fixed_view { ($mref:expr) => { - MatrixSlice::<_, U3, U4, U1, U3>::from($mref) + MatrixView::<_, U3, U4, U1, U3>::from($mref) }; } - macro_rules! fixed_slice_mut { + macro_rules! fixed_view_mut { ($mref:expr) => { - MatrixSliceMut::<_, U3, U4, U1, U3>::from($mref) + MatrixViewMut::<_, U3, U4, U1, U3>::from($mref) }; } @@ -291,66 +291,66 @@ fn matrix_slice_from_matrix_ref() { // Self and RHS. See issue #674. Once this is implemented, we can remove `into_owned` // from the below tests. - // Construct slices from reference to a + // Construct views from reference to a { - assert_eq!(a, fixed_slice!(&a).into_owned()); - assert_eq!(d, dynamic_slice!(&a).into_owned()); + assert_eq!(a, fixed_view!(&a).into_owned()); + assert_eq!(d, dynamic_view!(&a).into_owned()); } - // Construct slices from mutable reference to a + // Construct views from mutable reference to a { let mut a_clone = a.clone(); - assert_eq!(a, fixed_slice!(&mut a_clone).into_owned()); - assert_eq!(d, dynamic_slice!(&mut a_clone).into_owned()); + assert_eq!(a, fixed_view!(&mut a_clone).into_owned()); + assert_eq!(d, dynamic_view!(&mut a_clone).into_owned()); } // Construct mutable slices from mutable reference to a { let mut a_clone = a.clone(); - assert_eq!(a, fixed_slice_mut!(&mut a_clone).into_owned()); - assert_eq!(d, dynamic_slice_mut!(&mut a_clone).into_owned()); + assert_eq!(a, fixed_view_mut!(&mut a_clone).into_owned()); + assert_eq!(d, dynamic_view_mut!(&mut a_clone).into_owned()); } // Construct slices from reference to d { - assert_eq!(a, fixed_slice!(&d).into_owned()); - assert_eq!(d, dynamic_slice!(&d).into_owned()); + assert_eq!(a, fixed_view!(&d).into_owned()); + assert_eq!(d, dynamic_view!(&d).into_owned()); } // Construct slices from mutable reference to d { let mut d_clone = a.clone(); - assert_eq!(a, fixed_slice!(&mut d_clone).into_owned()); - assert_eq!(d, dynamic_slice!(&mut d_clone).into_owned()); + assert_eq!(a, fixed_view!(&mut d_clone).into_owned()); + assert_eq!(d, dynamic_view!(&mut d_clone).into_owned()); } // Construct mutable slices from mutable reference to d { let mut d_clone = d.clone(); - assert_eq!(a, fixed_slice_mut!(&mut d_clone).into_owned()); - assert_eq!(d, dynamic_slice_mut!(&mut d_clone).into_owned()); + assert_eq!(a, fixed_view_mut!(&mut d_clone).into_owned()); + assert_eq!(d, dynamic_view_mut!(&mut d_clone).into_owned()); } // Construct slices from a slice of a { - let mut a_slice = fixed_slice!(&a); - assert_eq!(a, fixed_slice!(&a_slice).into_owned()); - assert_eq!(a, fixed_slice!(&mut a_slice).into_owned()); - assert_eq!(d, dynamic_slice!(&a_slice).into_owned()); - assert_eq!(d, dynamic_slice!(&mut a_slice).into_owned()); + let mut a_slice = fixed_view!(&a); + assert_eq!(a, fixed_view!(&a_slice).into_owned()); + assert_eq!(a, fixed_view!(&mut a_slice).into_owned()); + assert_eq!(d, dynamic_view!(&a_slice).into_owned()); + assert_eq!(d, dynamic_view!(&mut a_slice).into_owned()); } // Construct slices from a slice mut of a { // Need a clone of a here, so that we can both have a mutable borrow and compare equality let mut a_clone = a.clone(); - let mut a_slice = fixed_slice_mut!(&mut a_clone); + let mut a_slice = fixed_view_mut!(&mut a_clone); - assert_eq!(a, fixed_slice!(&a_slice).into_owned()); - assert_eq!(a, fixed_slice!(&mut a_slice).into_owned()); - assert_eq!(d, dynamic_slice!(&a_slice).into_owned()); - assert_eq!(d, dynamic_slice!(&mut a_slice).into_owned()); - assert_eq!(a, fixed_slice_mut!(&mut a_slice).into_owned()); - assert_eq!(d, dynamic_slice_mut!(&mut a_slice).into_owned()); + assert_eq!(a, fixed_view!(&a_slice).into_owned()); + assert_eq!(a, fixed_view!(&mut a_slice).into_owned()); + assert_eq!(d, dynamic_view!(&a_slice).into_owned()); + assert_eq!(d, dynamic_view!(&mut a_slice).into_owned()); + assert_eq!(a, fixed_view_mut!(&mut a_slice).into_owned()); + assert_eq!(d, dynamic_view_mut!(&mut a_slice).into_owned()); } } diff --git a/tests/core/matrix.rs b/tests/core/matrix.rs index 8a545e97..219845d4 100644 --- a/tests/core/matrix.rs +++ b/tests/core/matrix.rs @@ -1066,43 +1066,43 @@ fn partial_eq_different_types() { let static_mat = Matrix2x4::new(1, 2, 3, 4, 5, 6, 7, 8); let mut typenum_static_mat = OMatrix::, Const<4>>::zeros(); - let mut slice = typenum_static_mat.slice_mut((0, 0), (2, 4)); - slice += static_mat; + let mut view = typenum_static_mat.view_mut((0, 0), (2, 4)); + view += static_mat; - let fslice_of_dmat = dynamic_mat.fixed_slice::<2, 2>(0, 0); - let dslice_of_dmat = dynamic_mat.slice((0, 0), (2, 2)); - let fslice_of_smat = static_mat.fixed_slice::<2, 2>(0, 0); - let dslice_of_smat = static_mat.slice((0, 0), (2, 2)); + let fview_of_dmat = dynamic_mat.fixed_view::<2, 2>(0, 0); + let dview_of_dmat = dynamic_mat.view((0, 0), (2, 2)); + let fview_of_smat = static_mat.fixed_view::<2, 2>(0, 0); + let dview_of_smat = static_mat.view((0, 0), (2, 2)); assert_eq!(dynamic_mat, static_mat); assert_eq!(static_mat, dynamic_mat); - assert_eq!(dynamic_mat, slice); - assert_eq!(slice, dynamic_mat); + assert_eq!(dynamic_mat, view); + assert_eq!(view, dynamic_mat); - assert_eq!(static_mat, slice); - assert_eq!(slice, static_mat); + assert_eq!(static_mat, view); + assert_eq!(view, static_mat); - assert_eq!(fslice_of_dmat, dslice_of_dmat); - assert_eq!(dslice_of_dmat, fslice_of_dmat); + assert_eq!(fview_of_dmat, dview_of_dmat); + assert_eq!(dview_of_dmat, fview_of_dmat); - assert_eq!(fslice_of_dmat, fslice_of_smat); - assert_eq!(fslice_of_smat, fslice_of_dmat); + assert_eq!(fview_of_dmat, fview_of_smat); + assert_eq!(fview_of_smat, fview_of_dmat); - assert_eq!(fslice_of_dmat, dslice_of_smat); - assert_eq!(dslice_of_smat, fslice_of_dmat); + assert_eq!(fview_of_dmat, dview_of_smat); + assert_eq!(dview_of_smat, fview_of_dmat); - assert_eq!(dslice_of_dmat, fslice_of_smat); - assert_eq!(fslice_of_smat, dslice_of_dmat); + assert_eq!(dview_of_dmat, fview_of_smat); + assert_eq!(fview_of_smat, dview_of_dmat); - assert_eq!(dslice_of_dmat, dslice_of_smat); - assert_eq!(dslice_of_smat, dslice_of_dmat); + assert_eq!(dview_of_dmat, dview_of_smat); + assert_eq!(dview_of_smat, dview_of_dmat); - assert_eq!(fslice_of_smat, dslice_of_smat); - assert_eq!(dslice_of_smat, fslice_of_smat); + assert_eq!(fview_of_smat, dview_of_smat); + assert_eq!(dview_of_smat, fview_of_smat); - assert_ne!(dynamic_mat, dslice_of_smat); - assert_ne!(dslice_of_smat, dynamic_mat); + assert_ne!(dynamic_mat, dview_of_smat); + assert_ne!(dview_of_smat, dynamic_mat); // TODO - implement those comparisons // assert_ne!(static_mat, typenum_static_mat); diff --git a/tests/core/matrix_slice.rs b/tests/core/matrix_slice.rs index ada5297e..ce3a1c37 100644 --- a/tests/core/matrix_slice.rs +++ b/tests/core/matrix_slice.rs @@ -1,22 +1,22 @@ #![allow(non_snake_case)] use na::{ - DMatrix, DMatrixSlice, DMatrixSliceMut, Matrix2, Matrix2x3, Matrix2x4, Matrix2x6, Matrix3, - Matrix3x2, Matrix3x4, Matrix4x2, Matrix6x2, MatrixSlice2, MatrixSlice2x3, MatrixSlice2xX, - MatrixSlice3, MatrixSlice3x2, MatrixSliceMut2, MatrixSliceMut2x3, MatrixSliceMut2xX, - MatrixSliceMut3, MatrixSliceMut3x2, MatrixSliceMutXx3, MatrixSliceXx3, RowVector4, Vector3, + DMatrix, DMatrixView, DMatrixViewMut, Matrix2, Matrix2x3, Matrix2x4, Matrix2x6, Matrix3, + Matrix3x2, Matrix3x4, Matrix4x2, Matrix6x2, MatrixView2, MatrixView2x3, MatrixView2xX, + MatrixView3, MatrixView3x2, MatrixViewMut2, MatrixViewMut2x3, MatrixViewMut2xX, + MatrixViewMut3, MatrixViewMut3x2, MatrixViewMutXx3, MatrixViewXx3, RowVector4, Vector3, }; #[test] #[rustfmt::skip] -fn nested_fixed_slices() { +fn nested_fixed_views() { let a = Matrix3x4::new(11.0, 12.0, 13.0, 14.0, 21.0, 22.0, 23.0, 24.0, 31.0, 32.0, 33.0, 34.0); - let s1 = a.fixed_slice::<3, 3>(0, 1); // Simple slice. - let s2 = s1.fixed_slice::<2, 2>(1, 1); // Slice of slice. - let s3 = s1.fixed_slice_with_steps::<2, 2>((0, 0), (1, 1)); // Slice of slice with steps. + let s1 = a.fixed_view::<3, 3>(0, 1); // Simple view. + let s2 = s1.fixed_view::<2, 2>(1, 1); // View of view. + let s3 = s1.fixed_view_with_steps::<2, 2>((0, 0), (1, 1)); // View of view with steps. let expected_owned_s1 = Matrix3::new(12.0, 13.0, 14.0, 22.0, 23.0, 24.0, @@ -35,14 +35,14 @@ fn nested_fixed_slices() { #[test] #[rustfmt::skip] -fn nested_slices() { +fn nested_views() { let a = Matrix3x4::new(11.0, 12.0, 13.0, 14.0, 21.0, 22.0, 23.0, 24.0, 31.0, 32.0, 33.0, 34.0); - let s1 = a.slice((0, 1), (3, 3)); - let s2 = s1.slice((1, 1), (2, 2)); - let s3 = s1.slice_with_steps((0, 0), (2, 2), (1, 1)); + let s1 = a.view((0, 1), (3, 3)); + let s2 = s1.view((1, 1), (2, 2)); + let s3 = s1.view_with_steps((0, 0), (2, 2), (1, 1)); let expected_owned_s1 = DMatrix::from_row_slice(3, 3, &[ 12.0, 13.0, 14.0, 22.0, 23.0, 24.0, @@ -61,14 +61,14 @@ fn nested_slices() { #[test] #[rustfmt::skip] -fn slice_mut() { +fn view_mut() { let mut a = Matrix3x4::new(11.0, 12.0, 13.0, 14.0, 21.0, 22.0, 23.0, 24.0, 31.0, 32.0, 33.0, 34.0); { - // We modify `a` through the mutable slice. - let mut s1 = a.slice_with_steps_mut((0, 1), (2, 2), (1, 1)); + // We modify `a` through the mutable view. + let mut s1 = a.view_with_steps_mut((0, 1), (2, 2), (1, 1)); s1.fill(0.0); } @@ -81,7 +81,7 @@ fn slice_mut() { #[test] #[rustfmt::skip] -fn nested_row_slices() { +fn nested_row_views() { let a = Matrix6x2::new(11.0, 12.0, 21.0, 22.0, 31.0, 32.0, @@ -105,7 +105,7 @@ fn nested_row_slices() { #[test] #[rustfmt::skip] -fn row_slice_mut() { +fn row_view_mut() { let mut a = Matrix6x2::new(11.0, 12.0, 21.0, 22.0, 31.0, 32.0, @@ -113,7 +113,7 @@ fn row_slice_mut() { 51.0, 52.0, 61.0, 62.0); { - // We modify `a` through the mutable slice. + // We modify `a` through the mutable view. let mut s1 = a.rows_with_step_mut(1, 3, 1); s1.fill(0.0); } @@ -130,7 +130,7 @@ fn row_slice_mut() { #[test] #[rustfmt::skip] -fn nested_col_slices() { +fn nested_col_views() { let a = Matrix2x6::new(11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0); let s1 = a.fixed_columns::<4>(1); @@ -148,12 +148,12 @@ fn nested_col_slices() { #[test] #[rustfmt::skip] -fn col_slice_mut() { +fn col_view_mut() { let mut a = Matrix2x6::new(11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0); { - // We modify `a` through the mutable slice. + // We modify `a` through the mutable view. let mut s1 = a.columns_with_step_mut(1, 3, 1); s1.fill(0.0); } @@ -203,7 +203,7 @@ fn columns_range_pair() { #[test] #[rustfmt::skip] -fn new_slice() { +fn new_from_slice() { let data = [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ]; @@ -214,13 +214,13 @@ fn new_slice() { let expected3x2 = Matrix3x2::from_column_slice(&data); { - let m2 = MatrixSlice2::from_slice(&data); - let m3 = MatrixSlice3::from_slice(&data); - let m2x3 = MatrixSlice2x3::from_slice(&data); - let m3x2 = MatrixSlice3x2::from_slice(&data); - let m2xX = MatrixSlice2xX::from_slice(&data, 3); - let mXx3 = MatrixSliceXx3::from_slice(&data, 2); - let mXxX = DMatrixSlice::from_slice(&data, 2, 3); + let m2 = MatrixView2::from_slice(&data); + let m3 = MatrixView3::from_slice(&data); + let m2x3 = MatrixView2x3::from_slice(&data); + let m3x2 = MatrixView3x2::from_slice(&data); + let m2xX = MatrixView2xX::from_slice(&data, 3); + let mXx3 = MatrixViewXx3::from_slice(&data, 2); + let mXxX = DMatrixView::from_slice(&data, 2, 3); assert!(m2.eq(&expected2)); assert!(m3.eq(&expected3)); @@ -234,7 +234,7 @@ fn new_slice() { #[test] #[rustfmt::skip] -fn new_slice_mut() { +fn new_from_slice_mut() { let data = [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ]; @@ -252,31 +252,31 @@ fn new_slice_mut() { 9.0, 10.0, 11.0, 12.0 ]; let mut data_mut = data.clone(); - MatrixSliceMut2::from_slice(&mut data_mut).fill(0.0); + MatrixViewMut2::from_slice(&mut data_mut).fill(0.0); assert!(data_mut == expected2); let mut data_mut = data.clone(); - MatrixSliceMut3::from_slice(&mut data_mut).fill(0.0); + MatrixViewMut3::from_slice(&mut data_mut).fill(0.0); assert!(data_mut == expected3); let mut data_mut = data.clone(); - MatrixSliceMut2x3::from_slice(&mut data_mut).fill(0.0); + MatrixViewMut2x3::from_slice(&mut data_mut).fill(0.0); assert!(data_mut == expected2x3); let mut data_mut = data.clone(); - MatrixSliceMut3x2::from_slice(&mut data_mut).fill(0.0); + MatrixViewMut3x2::from_slice(&mut data_mut).fill(0.0); assert!(data_mut == expected3x2); let mut data_mut = data.clone(); - MatrixSliceMut2xX::from_slice(&mut data_mut, 3).fill(0.0); + MatrixViewMut2xX::from_slice(&mut data_mut, 3).fill(0.0); assert!(data_mut == expected2x3); let mut data_mut = data.clone(); - MatrixSliceMutXx3::from_slice(&mut data_mut, 2).fill(0.0); + MatrixViewMutXx3::from_slice(&mut data_mut, 2).fill(0.0); assert!(data_mut == expected2x3); let mut data_mut = data.clone(); - DMatrixSliceMut::from_slice(&mut data_mut, 2, 3).fill(0.0); + DMatrixViewMut::from_slice(&mut data_mut, 2, 3).fill(0.0); assert!(data_mut == expected2x3); } @@ -324,14 +324,14 @@ fn columns_with_step_out_of_bounds() { #[test] #[should_panic] -fn slice_out_of_bounds() { +fn view_out_of_bounds() { let a = Matrix3x4::::zeros(); - a.slice((1, 2), (3, 1)); + a.view((1, 2), (3, 1)); } #[test] #[should_panic] -fn slice_with_steps_out_of_bounds() { +fn view_with_steps_out_of_bounds() { let a = Matrix3x4::::zeros(); - a.slice_with_steps((1, 2), (2, 2), (0, 1)); + a.view_with_steps((1, 2), (2, 2), (0, 1)); } From f007772f4bce94ac1878fc6a73f23eba829aae0a Mon Sep 17 00:00:00 2001 From: Andreas Longva Date: Mon, 14 Nov 2022 15:18:28 +0100 Subject: [PATCH 17/22] Update slice->view in nalgebra-glm --- nalgebra-glm/src/gtx/quaternion.rs | 2 +- nalgebra-glm/src/gtx/transform2.rs | 8 ++++---- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/nalgebra-glm/src/gtx/quaternion.rs b/nalgebra-glm/src/gtx/quaternion.rs index f912c409..d4f82af2 100644 --- a/nalgebra-glm/src/gtx/quaternion.rs +++ b/nalgebra-glm/src/gtx/quaternion.rs @@ -93,6 +93,6 @@ pub fn mat3_to_quat(x: &TMat3) -> Qua { /// Converts a rotation matrix in homogeneous coordinates to a quaternion. pub fn to_quat(x: &TMat4) -> Qua { - let rot = x.fixed_slice::<3, 3>(0, 0).into_owned(); + let rot = x.fixed_view::<3, 3>(0, 0).into_owned(); mat3_to_quat(&rot) } diff --git a/nalgebra-glm/src/gtx/transform2.rs b/nalgebra-glm/src/gtx/transform2.rs index f389e4b1..56f736d7 100644 --- a/nalgebra-glm/src/gtx/transform2.rs +++ b/nalgebra-glm/src/gtx/transform2.rs @@ -7,7 +7,7 @@ pub fn proj2d(m: &TMat3, normal: &TVec2) -> TMat3 { let mut res = TMat3::identity(); { - let mut part = res.fixed_slice_mut::<2, 2>(0, 0); + let mut part = res.fixed_view_mut::<2, 2>(0, 0); part -= normal * normal.transpose(); } @@ -19,7 +19,7 @@ pub fn proj(m: &TMat4, normal: &TVec3) -> TMat4 { let mut res = TMat4::identity(); { - let mut part = res.fixed_slice_mut::<3, 3>(0, 0); + let mut part = res.fixed_view_mut::<3, 3>(0, 0); part -= normal * normal.transpose(); } @@ -31,7 +31,7 @@ pub fn reflect2d(m: &TMat3, normal: &TVec2) -> TMat3 { let mut res = TMat3::identity(); { - let mut part = res.fixed_slice_mut::<2, 2>(0, 0); + let mut part = res.fixed_view_mut::<2, 2>(0, 0); part -= (normal * T::from_subset(&2.0)) * normal.transpose(); } @@ -43,7 +43,7 @@ pub fn reflect(m: &TMat4, normal: &TVec3) -> TMat4 { let mut res = TMat4::identity(); { - let mut part = res.fixed_slice_mut::<3, 3>(0, 0); + let mut part = res.fixed_view_mut::<3, 3>(0, 0); part -= (normal * T::from_subset(&2.0)) * normal.transpose(); } From 660ee9c6f262a7bee2414441685385517c767bc7 Mon Sep 17 00:00:00 2001 From: Andreas Longva Date: Mon, 14 Nov 2022 15:21:20 +0100 Subject: [PATCH 18/22] Update slice->view in nalgebra-lapack --- nalgebra-lapack/src/qr.rs | 2 +- nalgebra-lapack/src/svd.rs | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/nalgebra-lapack/src/qr.rs b/nalgebra-lapack/src/qr.rs index 895e34f3..ade2e452 100644 --- a/nalgebra-lapack/src/qr.rs +++ b/nalgebra-lapack/src/qr.rs @@ -126,7 +126,7 @@ where let mut q = self .qr - .generic_slice((0, 0), (nrows, min_nrows_ncols)) + .generic_view((0, 0), (nrows, min_nrows_ncols)) .into_owned(); let mut info = 0; diff --git a/nalgebra-lapack/src/svd.rs b/nalgebra-lapack/src/svd.rs index 972ffa1b..804284d9 100644 --- a/nalgebra-lapack/src/svd.rs +++ b/nalgebra-lapack/src/svd.rs @@ -157,7 +157,7 @@ macro_rules! svd_impl( let mut res: OMatrix<_, R, C> = Matrix::zeros_generic(nrows, ncols); { - let mut sres = res.generic_slice_mut((0, 0), (min_nrows_ncols, ncols)); + let mut sres = res.generic_view_mut((0, 0), (min_nrows_ncols, ncols)); sres.copy_from(&self.vt.rows_generic(0, min_nrows_ncols)); for i in 0 .. min_nrows_ncols.value() { @@ -183,7 +183,7 @@ macro_rules! svd_impl( let mut res: OMatrix<_, C, R> = Matrix::zeros_generic(ncols, nrows); { - let mut sres = res.generic_slice_mut((0, 0), (min_nrows_ncols, nrows)); + let mut sres = res.generic_view_mut((0, 0), (min_nrows_ncols, nrows)); self.u.columns_generic(0, min_nrows_ncols).transpose_to(&mut sres); for i in 0 .. min_nrows_ncols.value() { From 02caca0ece5809f7082bcdfd70015081c8212d16 Mon Sep 17 00:00:00 2001 From: Andreas Longva Date: Mon, 14 Nov 2022 15:26:48 +0100 Subject: [PATCH 19/22] Update slice->view in nalgebra-sparse --- nalgebra-sparse/src/factorization/cholesky.rs | 6 +++--- nalgebra-sparse/src/ops/serial/cs.rs | 6 +++--- nalgebra-sparse/src/ops/serial/csc.rs | 16 ++++++++-------- nalgebra-sparse/src/ops/serial/csr.rs | 10 +++++----- nalgebra-sparse/tests/unit_tests/coo.rs | 4 ++-- nalgebra-sparse/tests/unit_tests/ops.rs | 8 ++++---- 6 files changed, 25 insertions(+), 25 deletions(-) diff --git a/nalgebra-sparse/src/factorization/cholesky.rs b/nalgebra-sparse/src/factorization/cholesky.rs index 1f653278..f84e621f 100644 --- a/nalgebra-sparse/src/factorization/cholesky.rs +++ b/nalgebra-sparse/src/factorization/cholesky.rs @@ -3,7 +3,7 @@ use crate::ops::serial::spsolve_csc_lower_triangular; use crate::ops::Op; use crate::pattern::SparsityPattern; use core::{iter, mem}; -use nalgebra::{DMatrix, DMatrixSlice, DMatrixSliceMut, RealField}; +use nalgebra::{DMatrix, DMatrixView, DMatrixViewMut, RealField}; use std::fmt::{Display, Formatter}; /// A symbolic sparse Cholesky factorization of a CSC matrix. @@ -264,7 +264,7 @@ impl CscCholesky { /// /// Panics if `B` is not square. #[must_use = "Did you mean to use solve_mut()?"] - pub fn solve<'a>(&'a self, b: impl Into>) -> DMatrix { + pub fn solve<'a>(&'a self, b: impl Into>) -> DMatrix { let b = b.into(); let mut output = b.clone_owned(); self.solve_mut(&mut output); @@ -278,7 +278,7 @@ impl CscCholesky { /// # Panics /// /// Panics if `b` is not square. - pub fn solve_mut<'a>(&'a self, b: impl Into>) { + pub fn solve_mut<'a>(&'a self, b: impl Into>) { let expect_msg = "If the Cholesky factorization succeeded,\ then the triangular solve should never fail"; // Solve LY = B diff --git a/nalgebra-sparse/src/ops/serial/cs.rs b/nalgebra-sparse/src/ops/serial/cs.rs index cc13c168..a2a132fc 100644 --- a/nalgebra-sparse/src/ops/serial/cs.rs +++ b/nalgebra-sparse/src/ops/serial/cs.rs @@ -2,7 +2,7 @@ use crate::cs::CsMatrix; use crate::ops::serial::{OperationError, OperationErrorKind}; use crate::ops::Op; use crate::SparseEntryMut; -use nalgebra::{ClosedAdd, ClosedMul, DMatrixSlice, DMatrixSliceMut, Scalar}; +use nalgebra::{ClosedAdd, ClosedMul, DMatrixView, DMatrixViewMut, Scalar}; use num_traits::{One, Zero}; fn spmm_cs_unexpected_entry() -> OperationError { @@ -176,10 +176,10 @@ where /// the transposed operation must be specified for the CSC matrix. pub fn spmm_cs_dense( beta: T, - mut c: DMatrixSliceMut<'_, T>, + mut c: DMatrixViewMut<'_, 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 6a691ef9..5cf8ab23 100644 --- a/nalgebra-sparse/src/ops/serial/csc.rs +++ b/nalgebra-sparse/src/ops/serial/csc.rs @@ -4,7 +4,7 @@ use crate::ops::serial::cs::{ }; use crate::ops::serial::{OperationError, OperationErrorKind}; use crate::ops::Op; -use nalgebra::{ClosedAdd, ClosedMul, DMatrixSlice, DMatrixSliceMut, RealField, Scalar}; +use nalgebra::{ClosedAdd, ClosedMul, DMatrixView, DMatrixViewMut, RealField, Scalar}; use num_traits::{One, Zero}; use std::borrow::Cow; @@ -16,10 +16,10 @@ use std::borrow::Cow; /// Panics if the dimensions of the matrices involved are not compatible with the expression. pub fn spmm_csc_dense<'a, T>( beta: T, - c: impl Into>, + c: impl Into>, alpha: T, a: Op<&CscMatrix>, - b: Op>>, + b: Op>>, ) where T: Scalar + ClosedAdd + ClosedMul + Zero + One, { @@ -29,10 +29,10 @@ pub fn spmm_csc_dense<'a, T>( fn spmm_csc_dense_( beta: T, - c: DMatrixSliceMut<'_, T>, + c: DMatrixViewMut<'_, T>, alpha: T, a: Op<&CscMatrix>, - b: Op>, + b: Op>, ) where T: Scalar + ClosedAdd + ClosedMul + Zero + One, { @@ -173,7 +173,7 @@ where /// Panics if `L` is not square, or if `L` and `B` are not dimensionally compatible. pub fn spsolve_csc_lower_triangular<'a, T: RealField>( l: Op<&CscMatrix>, - b: impl Into>, + b: impl Into>, ) -> Result<(), OperationError> { let b = b.into(); let l_matrix = l.into_inner(); @@ -195,7 +195,7 @@ pub fn spsolve_csc_lower_triangular<'a, T: RealField>( fn spsolve_csc_lower_triangular_no_transpose( l: &CscMatrix, - b: DMatrixSliceMut<'_, T>, + b: DMatrixViewMut<'_, T>, ) -> Result<(), OperationError> { let mut x = b; @@ -253,7 +253,7 @@ fn spsolve_encountered_zero_diagonal() -> Result<(), OperationError> { fn spsolve_csc_lower_triangular_transpose( l: &CscMatrix, - b: DMatrixSliceMut<'_, T>, + b: DMatrixViewMut<'_, 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 708c81a3..d69bc54c 100644 --- a/nalgebra-sparse/src/ops/serial/csr.rs +++ b/nalgebra-sparse/src/ops/serial/csr.rs @@ -4,17 +4,17 @@ use crate::ops::serial::cs::{ }; use crate::ops::serial::OperationError; use crate::ops::Op; -use nalgebra::{ClosedAdd, ClosedMul, DMatrixSlice, DMatrixSliceMut, Scalar}; +use nalgebra::{ClosedAdd, ClosedMul, DMatrixView, DMatrixViewMut, Scalar}; use num_traits::{One, Zero}; use std::borrow::Cow; /// Sparse-dense matrix-matrix multiplication `C <- beta * C + alpha * op(A) * op(B)`. pub fn spmm_csr_dense<'a, T>( beta: T, - c: impl Into>, + c: impl Into>, alpha: T, a: Op<&CsrMatrix>, - b: Op>>, + b: Op>>, ) where T: Scalar + ClosedAdd + ClosedMul + Zero + One, { @@ -24,10 +24,10 @@ pub fn spmm_csr_dense<'a, T>( fn spmm_csr_dense_( beta: T, - c: DMatrixSliceMut<'_, T>, + c: DMatrixViewMut<'_, T>, alpha: T, a: Op<&CsrMatrix>, - b: Op>, + b: Op>, ) where T: Scalar + ClosedAdd + ClosedMul + Zero + One, { diff --git a/nalgebra-sparse/tests/unit_tests/coo.rs b/nalgebra-sparse/tests/unit_tests/coo.rs index 8e46651f..8d7f740b 100644 --- a/nalgebra-sparse/tests/unit_tests/coo.rs +++ b/nalgebra-sparse/tests/unit_tests/coo.rs @@ -348,8 +348,8 @@ fn coo_push_matrix_valid_entries() { // Works with sliced { let source = nalgebra::SMatrix::::new(6, 7, 8, 9); - let sliced = source.fixed_slice::<2, 1>(0, 0); - coo.push_matrix(1, 0, &sliced); + let view = source.fixed_view::<2, 1>(0, 0); + coo.push_matrix(1, 0, &view); assert_eq!( coo.triplet_iter().collect::>(), diff --git a/nalgebra-sparse/tests/unit_tests/ops.rs b/nalgebra-sparse/tests/unit_tests/ops.rs index 0a335567..c8d80f32 100644 --- a/nalgebra-sparse/tests/unit_tests/ops.rs +++ b/nalgebra-sparse/tests/unit_tests/ops.rs @@ -14,7 +14,7 @@ use nalgebra_sparse::pattern::SparsityPattern; use nalgebra_sparse::proptest::{csc, csr, sparsity_pattern}; use nalgebra::proptest::{matrix, vector}; -use nalgebra::{DMatrix, DMatrixSlice, DMatrixSliceMut, Scalar}; +use nalgebra::{DMatrix, DMatrixView, DMatrixViewMut, Scalar}; use proptest::prelude::*; @@ -333,10 +333,10 @@ fn csc_square_with_non_zero_diagonals() -> impl Strategy> /// Helper function to help us call dense GEMM with our `Op` type fn dense_gemm<'a>( beta: i32, - c: impl Into>, + c: impl Into>, alpha: i32, - a: Op>>, - b: Op>>, + a: Op>>, + b: Op>>, ) { let mut c = c.into(); let a = a.convert(); From 31e687bd76b22430ed3f18e6af761e4a551fa78e Mon Sep 17 00:00:00 2001 From: Andreas Longva Date: Mon, 14 Nov 2022 16:41:01 +0100 Subject: [PATCH 20/22] Implement Matrix::{as_view, as_view_mut} methods --- src/base/conversion.rs | 3 -- src/base/matrix_view.rs | 85 +++++++++++++++++++++++++++++++++++++++++ 2 files changed, 85 insertions(+), 3 deletions(-) diff --git a/src/base/conversion.rs b/src/base/conversion.rs index 79a61461..20553257 100644 --- a/src/base/conversion.rs +++ b/src/base/conversion.rs @@ -373,7 +373,6 @@ where impl<'a, T, R, C, RView, CView, RStride, CStride, S> From<&'a Matrix> for MatrixView<'a, T, RView, CView, RStride, CStride> where - T: Scalar, R: Dim, C: Dim, RView: Dim, @@ -410,7 +409,6 @@ where impl<'a, T, R, C, RView, CView, RStride, CStride, S> From<&'a mut Matrix> for MatrixView<'a, T, RView, CView, RStride, CStride> where - T: Scalar, R: Dim, C: Dim, RView: Dim, @@ -447,7 +445,6 @@ where impl<'a, T, R, C, RView, CView, RStride, CStride, S> From<&'a mut Matrix> for MatrixViewMut<'a, T, RView, CView, RStride, CStride> where - T: Scalar, R: Dim, C: Dim, RView: Dim, diff --git a/src/base/matrix_view.rs b/src/base/matrix_view.rs index ef024f19..210e7a57 100644 --- a/src/base/matrix_view.rs +++ b/src/base/matrix_view.rs @@ -8,6 +8,7 @@ use crate::base::dimension::{Const, Dim, DimName, Dynamic, IsNotStaticOne, U1}; use crate::base::iter::MatrixIter; use crate::base::storage::{IsContiguous, Owned, RawStorage, RawStorageMut, Storage}; use crate::base::{Matrix, Scalar}; +use crate::constraint::{DimEq, ShapeConstraint}; macro_rules! view_storage_impl ( ($doc: expr; $Storage: ident as $SRef: ty; $legacy_name:ident => $T: ident.$get_addr: ident ($Ptr: ty as $Ref: ty)) => { @@ -1091,3 +1092,87 @@ where unsafe { Matrix::from_data_statically_unchecked(data) } } } + +impl Matrix +where + R: Dim, + C: Dim, + S: RawStorage, +{ + /// Returns this matrix as a view. + /// + /// The returned view type is generally ambiguous unless specified. + /// This is particularly useful when working with functions or methods that take + /// matrix views as input. + /// + /// # Panics + /// Panics if the dimensions of the view and the matrix are not compatible and this cannot + /// be proven at compile-time. This might happen, for example, when constructing a static + /// view of size 3x3 from a dynamically sized matrix of dimension 5x5. + /// + /// # Examples + /// ``` + /// use nalgebra::{DMatrixSlice, SMatrixView}; + /// + /// fn consume_view(_: DMatrixSlice) {} + /// + /// let matrix = nalgebra::Matrix3::zeros(); + /// consume_view(matrix.as_view()); + /// + /// let dynamic_view: DMatrixSlice = matrix.as_view(); + /// let static_view_from_dyn: SMatrixView = dynamic_view.as_view(); + /// ``` + pub fn as_view(&self) -> MatrixView<'_, T, RView, CView, RViewStride, CViewStride> + where + RView: Dim, + CView: Dim, + RViewStride: Dim, + CViewStride: Dim, + ShapeConstraint: DimEq + DimEq + DimEq + DimEq + { + // Defer to (&matrix).into() + self.into() + } +} + +impl Matrix +where + R: Dim, + C: Dim, + S: RawStorageMut, +{ + /// Returns this matrix as a mutable view. + /// + /// The returned view type is generally ambiguous unless specified. + /// This is particularly useful when working with functions or methods that take + /// matrix views as input. + /// + /// # Panics + /// Panics if the dimensions of the view and the matrix are not compatible and this cannot + /// be proven at compile-time. This might happen, for example, when constructing a static + /// view of size 3x3 from a dynamically sized matrix of dimension 5x5. + /// + /// # Examples + /// ``` + /// use nalgebra::{DMatrixViewMut, SMatrixViewMut}; + /// + /// fn consume_view(_: DMatrixViewMut) {} + /// + /// let mut matrix = nalgebra::Matrix3::zeros(); + /// consume_view(matrix.as_view_mut()); + /// + /// let mut dynamic_view: DMatrixViewMut = matrix.as_view_mut(); + /// let static_view_from_dyn: SMatrixViewMut = dynamic_view.as_view_mut(); + /// ``` + pub fn as_view_mut(&mut self) -> MatrixViewMut<'_, T, RView, CView, RViewStride, CViewStride> + where + RView: Dim, + CView: Dim, + RViewStride: Dim, + CViewStride: Dim, + ShapeConstraint: DimEq + DimEq + DimEq + DimEq + { + // Defer to (&mut matrix).into() + self.into() + } +} From 55c3a9c76408178411dbd71d3431f57b75cf589f Mon Sep 17 00:00:00 2001 From: Andreas Longva Date: Mon, 14 Nov 2022 16:43:47 +0100 Subject: [PATCH 21/22] Formatting --- src/base/conversion.rs | 22 ++++++++------------- src/base/matrix_view.rs | 40 ++++++++++++++++++++++++-------------- src/linalg/schur.rs | 15 +++++++------- tests/core/matrix_slice.rs | 4 ++-- 4 files changed, 42 insertions(+), 39 deletions(-) diff --git a/src/base/conversion.rs b/src/base/conversion.rs index 20553257..02f72a43 100644 --- a/src/base/conversion.rs +++ b/src/base/conversion.rs @@ -16,8 +16,8 @@ use crate::base::dimension::{ use crate::base::iter::{MatrixIter, MatrixIterMut}; use crate::base::storage::{IsContiguous, RawStorage, RawStorageMut}; use crate::base::{ - ArrayStorage, DVectorView, DVectorViewMut, DefaultAllocator, Matrix, MatrixView, - MatrixViewMut, OMatrix, Scalar, + ArrayStorage, DVectorView, DVectorViewMut, DefaultAllocator, Matrix, MatrixView, MatrixViewMut, + OMatrix, Scalar, }; #[cfg(any(feature = "std", feature = "alloc"))] use crate::base::{DVector, RowDVector, VecStorage}; @@ -380,10 +380,8 @@ where RStride: Dim, CStride: Dim, S: RawStorage, - ShapeConstraint: DimEq - + DimEq - + DimEq - + DimEq, + ShapeConstraint: + DimEq + DimEq + DimEq + DimEq, { fn from(m: &'a Matrix) -> Self { let (row, col) = m.shape_generic(); @@ -416,10 +414,8 @@ where RStride: Dim, CStride: Dim, S: RawStorage, - ShapeConstraint: DimEq - + DimEq - + DimEq - + DimEq, + ShapeConstraint: + DimEq + DimEq + DimEq + DimEq, { fn from(m: &'a mut Matrix) -> Self { let (row, col) = m.shape_generic(); @@ -452,10 +448,8 @@ where RStride: Dim, CStride: Dim, S: RawStorageMut, - ShapeConstraint: DimEq - + DimEq - + DimEq - + DimEq, + ShapeConstraint: + DimEq + DimEq + DimEq + DimEq, { fn from(m: &'a mut Matrix) -> Self { let (row, col) = m.shape_generic(); diff --git a/src/base/matrix_view.rs b/src/base/matrix_view.rs index 210e7a57..c3dbd215 100644 --- a/src/base/matrix_view.rs +++ b/src/base/matrix_view.rs @@ -986,9 +986,9 @@ impl> Matrix { rows: RowRange, cols: ColRange, ) -> MatrixView<'_, T, RowRange::Size, ColRange::Size, S::RStride, S::CStride> - where - RowRange: DimRange, - ColRange: DimRange, + where + RowRange: DimRange, + ColRange: DimRange, { let (nrows, ncols) = self.shape_generic(); self.generic_view( @@ -1043,9 +1043,9 @@ impl> Matrix { rows: RowRange, cols: ColRange, ) -> MatrixViewMut<'_, T, RowRange::Size, ColRange::Size, S::RStride, S::CStride> - where - RowRange: DimRange, - ColRange: DimRange, + where + RowRange: DimRange, + ColRange: DimRange, { let (nrows, ncols) = self.shape_generic(); self.generic_view_mut( @@ -1122,13 +1122,18 @@ where /// let dynamic_view: DMatrixSlice = matrix.as_view(); /// let static_view_from_dyn: SMatrixView = dynamic_view.as_view(); /// ``` - pub fn as_view(&self) -> MatrixView<'_, T, RView, CView, RViewStride, CViewStride> + pub fn as_view( + &self, + ) -> MatrixView<'_, T, RView, CView, RViewStride, CViewStride> where RView: Dim, CView: Dim, RViewStride: Dim, CViewStride: Dim, - ShapeConstraint: DimEq + DimEq + DimEq + DimEq + ShapeConstraint: DimEq + + DimEq + + DimEq + + DimEq, { // Defer to (&matrix).into() self.into() @@ -1164,13 +1169,18 @@ where /// let mut dynamic_view: DMatrixViewMut = matrix.as_view_mut(); /// let static_view_from_dyn: SMatrixViewMut = dynamic_view.as_view_mut(); /// ``` - pub fn as_view_mut(&mut self) -> MatrixViewMut<'_, T, RView, CView, RViewStride, CViewStride> - where - RView: Dim, - CView: Dim, - RViewStride: Dim, - CViewStride: Dim, - ShapeConstraint: DimEq + DimEq + DimEq + DimEq + pub fn as_view_mut( + &mut self, + ) -> MatrixViewMut<'_, T, RView, CView, RViewStride, CViewStride> + where + RView: Dim, + CView: Dim, + RViewStride: Dim, + CViewStride: Dim, + ShapeConstraint: DimEq + + DimEq + + DimEq + + DimEq, { // Defer to (&mut matrix).into() self.into() diff --git a/src/linalg/schur.rs b/src/linalg/schur.rs index 3388e7cf..06d8426b 100644 --- a/src/linalg/schur.rs +++ b/src/linalg/schur.rs @@ -211,10 +211,12 @@ where { let mut work = work.rows_mut(0, end + 1); - refl.reflect(&mut t.generic_view_mut( - (m, m), - (Const::<2>, Dynamic::new(dim.value() - m)), - )); + refl.reflect( + &mut t.generic_view_mut( + (m, m), + (Const::<2>, Dynamic::new(dim.value() - m)), + ), + ); refl.reflect_rows( &mut t.generic_view_mut((0, m), (Dynamic::new(end + 1), Const::<2>)), &mut work, @@ -222,10 +224,7 @@ where } if let Some(ref mut q) = q { - refl.reflect_rows( - &mut q.generic_view_mut((0, m), (dim, Const::<2>)), - work, - ); + refl.reflect_rows(&mut q.generic_view_mut((0, m), (dim, Const::<2>)), work); } } } else { diff --git a/tests/core/matrix_slice.rs b/tests/core/matrix_slice.rs index ce3a1c37..4ce49d02 100644 --- a/tests/core/matrix_slice.rs +++ b/tests/core/matrix_slice.rs @@ -3,8 +3,8 @@ use na::{ DMatrix, DMatrixView, DMatrixViewMut, Matrix2, Matrix2x3, Matrix2x4, Matrix2x6, Matrix3, Matrix3x2, Matrix3x4, Matrix4x2, Matrix6x2, MatrixView2, MatrixView2x3, MatrixView2xX, - MatrixView3, MatrixView3x2, MatrixViewMut2, MatrixViewMut2x3, MatrixViewMut2xX, - MatrixViewMut3, MatrixViewMut3x2, MatrixViewMutXx3, MatrixViewXx3, RowVector4, Vector3, + MatrixView3, MatrixView3x2, MatrixViewMut2, MatrixViewMut2x3, MatrixViewMut2xX, MatrixViewMut3, + MatrixViewMut3x2, MatrixViewMutXx3, MatrixViewXx3, RowVector4, Vector3, }; #[test] From acfd37c7283e0d46e67f601daddbe70559b230c3 Mon Sep 17 00:00:00 2001 From: Andreas Longva Date: Mon, 14 Nov 2022 16:59:54 +0100 Subject: [PATCH 22/22] Rename tests/core/matrix_slice.rs to tests/core/matrix_view.rs --- tests/core/{matrix_slice.rs => matrix_view.rs} | 0 tests/core/mod.rs | 2 +- 2 files changed, 1 insertion(+), 1 deletion(-) rename tests/core/{matrix_slice.rs => matrix_view.rs} (100%) diff --git a/tests/core/matrix_slice.rs b/tests/core/matrix_view.rs similarity index 100% rename from tests/core/matrix_slice.rs rename to tests/core/matrix_view.rs diff --git a/tests/core/mod.rs b/tests/core/mod.rs index acdcd236..667f10a7 100644 --- a/tests/core/mod.rs +++ b/tests/core/mod.rs @@ -4,7 +4,7 @@ mod conversion; mod edition; mod empty; mod matrix; -mod matrix_slice; +mod matrix_view; #[cfg(feature = "mint")] mod mint; #[cfg(feature = "rkyv-serialize-no-std")]