From 9f8cfa207af0b71d141d2eba3f9ce7ecb719d8e3 Mon Sep 17 00:00:00 2001
From: Marc Haubenstock <marc.dhaubenstock@gmail.com>
Date: Mon, 2 May 2022 21:55:51 +0200
Subject: [PATCH 001/119] enabled complex eigenvalues for lapack

---
 nalgebra-lapack/src/eigen.rs | 157 ++++++++++++++++++++++++++++-------
 1 file changed, 129 insertions(+), 28 deletions(-)

diff --git a/nalgebra-lapack/src/eigen.rs b/nalgebra-lapack/src/eigen.rs
index 8eab62d8..594cb080 100644
--- a/nalgebra-lapack/src/eigen.rs
+++ b/nalgebra-lapack/src/eigen.rs
@@ -69,8 +69,8 @@ where
             "Unable to compute the eigenvalue decomposition of a non-square matrix."
         );
 
-        let ljob = if left_eigenvectors { b'V' } else { b'T' };
-        let rjob = if eigenvectors { b'V' } else { b'T' };
+        let ljob = if left_eigenvectors { b'V' } else { b'N' };
+        let rjob = if eigenvectors { b'V' } else { b'N' };
 
         let (nrows, ncols) = m.shape_generic();
         let n = nrows.value();
@@ -232,22 +232,27 @@ where
     /// The complex eigenvalues of the given matrix.
     ///
     /// Panics if the eigenvalue computation does not converge.
-    pub fn complex_eigenvalues(mut m: OMatrix<T, D, D>) -> OVector<Complex<T>, D>
+    pub fn complex_eigenvalues(mut m: OMatrix<T, D, D>, left_eigenvectors: bool, eigenvectors: bool) 
+        -> (OVector<Complex<T>, D>,  Option<OMatrix<T, D, D>>,  Option<OMatrix<T, D, D>>)
     where
-        DefaultAllocator: Allocator<Complex<T>, D>,
+        DefaultAllocator: Allocator<Complex<T>, D> + Allocator<Complex<T>, D, D>,
     {
         assert!(
             m.is_square(),
             "Unable to compute the eigenvalue decomposition of a non-square matrix."
         );
 
-        let nrows = m.shape_generic().0;
+        let ljob = if left_eigenvectors { b'V' } else { b'N' };
+        let rjob = if eigenvectors { b'V' } else { b'N' };
+
+        let (nrows, ncols) = m.shape_generic();
         let n = nrows.value();
 
         let lda = n as i32;
 
         // TODO: avoid the initialization?
         let mut wr = Matrix::zeros_generic(nrows, Const::<1>);
+        // TODO: Tap into the workspace.
         let mut wi = Matrix::zeros_generic(nrows, Const::<1>);
 
         let mut info = 0;
@@ -255,8 +260,8 @@ where
         let mut placeholder2 = [T::zero()];
 
         let lwork = T::xgeev_work_size(
-            b'T',
-            b'T',
+            ljob,
+            rjob,
             n as i32,
             m.as_mut_slice(),
             lda,
@@ -273,31 +278,127 @@ where
 
         let mut work = vec![T::zero(); lwork as usize];
 
-        T::xgeev(
-            b'T',
-            b'T',
-            n as i32,
-            m.as_mut_slice(),
-            lda,
-            wr.as_mut_slice(),
-            wi.as_mut_slice(),
-            &mut placeholder1,
-            1 as i32,
-            &mut placeholder2,
-            1 as i32,
-            &mut work,
-            lwork,
-            &mut info,
-        );
-        lapack_panic!(info);
+        match (left_eigenvectors, eigenvectors) {
+            (true, true) => {
+                // TODO: avoid the initializations?
+                let mut vl = Matrix::zeros_generic(nrows, ncols);
+                let mut vr = Matrix::zeros_generic(nrows, ncols);
 
-        let mut res = Matrix::zeros_generic(nrows, Const::<1>);
+                T::xgeev(
+                    ljob,
+                    rjob,
+                    n as i32,
+                    m.as_mut_slice(),
+                    lda,
+                    wr.as_mut_slice(),
+                    wi.as_mut_slice(),
+                    &mut vl.as_mut_slice(),
+                    n as i32,
+                    &mut vr.as_mut_slice(),
+                    n as i32,
+                    &mut work,
+                    lwork,
+                    &mut info,
+                );
+                lapack_panic!(info);
 
-        for i in 0..res.len() {
-            res[i] = Complex::new(wr[i].clone(), wi[i].clone());
+                let mut res = Matrix::zeros_generic(nrows, Const::<1>);
+
+                for i in 0..res.len() {
+                    res[i] = Complex::new(wr[i].clone(), wi[i].clone());
+                }
+        
+                return (res, Some(vl), Some(vr))
+            }
+            (true, false) => {
+                // TODO: avoid the initialization?
+                let mut vl = Matrix::zeros_generic(nrows, ncols);
+
+                T::xgeev(
+                    ljob,
+                    rjob,
+                    n as i32,
+                    m.as_mut_slice(),
+                    lda,
+                    wr.as_mut_slice(),
+                    wi.as_mut_slice(),
+                    &mut vl.as_mut_slice(),
+                    n as i32,
+                    &mut placeholder2,
+                    1 as i32,
+                    &mut work,
+                    lwork,
+                    &mut info,
+                );
+                lapack_panic!(info);
+
+                let mut res = Matrix::zeros_generic(nrows, Const::<1>);
+
+                for i in 0..res.len() {
+                    res[i] = Complex::new(wr[i].clone(), wi[i].clone());
+                }
+        
+                return (res, Some(vl), None)
+            }
+            (false, true) => {
+                // TODO: avoid the initialization?
+                let mut vr = Matrix::zeros_generic(nrows, ncols);
+
+                T::xgeev(
+                    ljob,
+                    rjob,
+                    n as i32,
+                    m.as_mut_slice(),
+                    lda,
+                    wr.as_mut_slice(),
+                    wi.as_mut_slice(),
+                    &mut placeholder1,
+                    1 as i32,
+                    &mut vr.as_mut_slice(),
+                    n as i32,
+                    &mut work,
+                    lwork,
+                    &mut info,
+                );
+                lapack_panic!(info);
+
+                let mut res = Matrix::zeros_generic(nrows, Const::<1>);
+
+                for i in 0..res.len() {
+                    res[i] = Complex::new(wr[i].clone(), wi[i].clone());
+                }
+        
+                return (res, None, Some(vr))
+            }
+            (false, false) => {
+                T::xgeev(
+                    ljob,
+                    rjob,
+                    n as i32,
+                    m.as_mut_slice(),
+                    lda,
+                    wr.as_mut_slice(),
+                    wi.as_mut_slice(),
+                    &mut placeholder1,
+                    1 as i32,
+                    &mut placeholder2,
+                    1 as i32,
+                    &mut work,
+                    lwork,
+                    &mut info,
+                );
+                lapack_panic!(info);
+
+                let mut res = Matrix::zeros_generic(nrows, Const::<1>);
+
+                for i in 0..res.len() {
+                    res[i] = Complex::new(wr[i].clone(), wi[i].clone());
+                }
+        
+                return (res, None, None)
+            }
         }
 
-        res
     }
 
     /// The determinant of the decomposed matrix.

From 71ef287fead3449a9914020b016b0207dc68d039 Mon Sep 17 00:00:00 2001
From: Marc Haubenstock <marc.dhaubenstock@gmail.com>
Date: Mon, 2 May 2022 22:49:07 +0200
Subject: [PATCH 002/119] removed return statements

---
 nalgebra-lapack/src/eigen.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/nalgebra-lapack/src/eigen.rs b/nalgebra-lapack/src/eigen.rs
index 594cb080..6c63ee33 100644
--- a/nalgebra-lapack/src/eigen.rs
+++ b/nalgebra-lapack/src/eigen.rs
@@ -308,7 +308,7 @@ where
                     res[i] = Complex::new(wr[i].clone(), wi[i].clone());
                 }
         
-                return (res, Some(vl), Some(vr))
+                (res, Some(vl), Some(vr))
             }
             (true, false) => {
                 // TODO: avoid the initialization?
@@ -338,7 +338,7 @@ where
                     res[i] = Complex::new(wr[i].clone(), wi[i].clone());
                 }
         
-                return (res, Some(vl), None)
+                (res, Some(vl), None)
             }
             (false, true) => {
                 // TODO: avoid the initialization?
@@ -368,7 +368,7 @@ where
                     res[i] = Complex::new(wr[i].clone(), wi[i].clone());
                 }
         
-                return (res, None, Some(vr))
+                (res, None, Some(vr))
             }
             (false, false) => {
                 T::xgeev(
@@ -395,7 +395,7 @@ where
                     res[i] = Complex::new(wr[i].clone(), wi[i].clone());
                 }
         
-                return (res, None, None)
+                (res, None, None)
             }
         }
 

From aafb7138489e9cb48072e9d7ecc0f52365f908fa Mon Sep 17 00:00:00 2001
From: Marc Haubenstock <marc.dhaubenstock@gmail.com>
Date: Tue, 3 May 2022 19:11:56 +0200
Subject: [PATCH 003/119] removed whitespace

---
 nalgebra-lapack/src/eigen.rs | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/nalgebra-lapack/src/eigen.rs b/nalgebra-lapack/src/eigen.rs
index 6c63ee33..0c2106ad 100644
--- a/nalgebra-lapack/src/eigen.rs
+++ b/nalgebra-lapack/src/eigen.rs
@@ -307,7 +307,6 @@ where
                 for i in 0..res.len() {
                     res[i] = Complex::new(wr[i].clone(), wi[i].clone());
                 }
-        
                 (res, Some(vl), Some(vr))
             }
             (true, false) => {
@@ -337,7 +336,6 @@ where
                 for i in 0..res.len() {
                     res[i] = Complex::new(wr[i].clone(), wi[i].clone());
                 }
-        
                 (res, Some(vl), None)
             }
             (false, true) => {
@@ -367,7 +365,6 @@ where
                 for i in 0..res.len() {
                     res[i] = Complex::new(wr[i].clone(), wi[i].clone());
                 }
-        
                 (res, None, Some(vr))
             }
             (false, false) => {
@@ -394,7 +391,6 @@ where
                 for i in 0..res.len() {
                     res[i] = Complex::new(wr[i].clone(), wi[i].clone());
                 }
-        
                 (res, None, None)
             }
         }

From 7cc885e86191d8ae34a850a1d3eb0aed192185d7 Mon Sep 17 00:00:00 2001
From: zyansheep <zyansheep@protonmail.com>
Date: Mon, 11 Jul 2022 22:36:52 -0400
Subject: [PATCH 004/119] fix some rkyv impls

---
 src/base/array_storage.rs | 8 ++++++--
 src/base/matrix.rs        | 8 ++++++--
 src/lib.rs                | 2 +-
 3 files changed, 13 insertions(+), 5 deletions(-)

diff --git a/src/base/array_storage.rs b/src/base/array_storage.rs
index 3bc71e1a..cd534baa 100644
--- a/src/base/array_storage.rs
+++ b/src/base/array_storage.rs
@@ -27,11 +27,15 @@ use std::mem;
 /// A array-based statically sized matrix data storage.
 #[repr(transparent)]
 #[derive(Copy, Clone, PartialEq, Eq, Hash)]
-#[cfg_attr(feature = "rkyv-serialize", derive(bytecheck::CheckBytes))]
 #[cfg_attr(
     feature = "rkyv-serialize-no-std",
-    derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
+    derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize),
+    archive(as = "Self", bound(archive = "
+        T: rkyv::Archive<Archived = T>,
+        [[T; R]; C]: rkyv::Archive<Archived = [[T; R]; C]>
+    "))
 )]
+#[cfg_attr(feature = "rkyv-serialize", derive(bytecheck::CheckBytes))]
 #[cfg_attr(feature = "cuda", derive(cust_core::DeviceCopy))]
 pub struct ArrayStorage<T, const R: usize, const C: usize>(pub [[T; R]; C]);
 
diff --git a/src/base/matrix.rs b/src/base/matrix.rs
index 8f8786c1..5eb58737 100644
--- a/src/base/matrix.rs
+++ b/src/base/matrix.rs
@@ -150,11 +150,15 @@ pub type MatrixCross<T, R1, C1, R2, C2> =
 /// some concrete types for `T` and a compatible data storage type `S`).
 #[repr(C)]
 #[derive(Clone, Copy)]
-#[cfg_attr(feature = "rkyv-serialize", derive(bytecheck::CheckBytes))]
 #[cfg_attr(
     feature = "rkyv-serialize-no-std",
-    derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
+    derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize),
+    archive(as = "Self", bound(archive = "
+        S: rkyv::Archive<Archived = S>,
+        PhantomData<(T, R, C)>: rkyv::Archive<Archived = PhantomData<(T, R, C)>>
+    "))
 )]
+#[cfg_attr(feature = "rkyv-serialize", derive(bytecheck::CheckBytes))]
 #[cfg_attr(feature = "cuda", derive(cust_core::DeviceCopy))]
 pub struct Matrix<T, R, C, S> {
     /// The data storage that contains all the matrix components. Disappointed?
diff --git a/src/lib.rs b/src/lib.rs
index 1ee1a3ba..028dac38 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -77,7 +77,7 @@ an optimized set of tools for computer graphics and physics. Those features incl
     unused_variables,
     unused_mut,
     unused_parens,
-    unused_qualifications,
+    // unused_qualifications,
     rust_2018_idioms,
     rust_2018_compatibility,
     future_incompatible,

From 67f04e39ace523cf092d1abdcaafbd78a7c03b52 Mon Sep 17 00:00:00 2001
From: zyansheep <zyansheep@protonmail.com>
Date: Wed, 13 Jul 2022 09:22:55 -0400
Subject: [PATCH 005/119] add rkyv tests

---
 tests/core/mod.rs  |  1 +
 tests/core/rkyv.rs | 43 +++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 44 insertions(+)
 create mode 100644 tests/core/rkyv.rs

diff --git a/tests/core/mod.rs b/tests/core/mod.rs
index 5fb8c82b..d4504c83 100644
--- a/tests/core/mod.rs
+++ b/tests/core/mod.rs
@@ -8,6 +8,7 @@ mod matrix_slice;
 #[cfg(feature = "mint")]
 mod mint;
 mod serde;
+mod rkyv;
 
 #[cfg(feature = "compare")]
 mod matrixcompare;
diff --git a/tests/core/rkyv.rs b/tests/core/rkyv.rs
new file mode 100644
index 00000000..13522e86
--- /dev/null
+++ b/tests/core/rkyv.rs
@@ -0,0 +1,43 @@
+#![cfg(feature = "rkyv-serialize")]
+
+use na::{
+    DMatrix, Isometry2, Isometry3, IsometryMatrix2, IsometryMatrix3, Matrix2x3, Matrix3x4, Point2,
+    Point3, Quaternion, Rotation2, Rotation3, Similarity2, Similarity3, SimilarityMatrix2,
+    SimilarityMatrix3, Translation2, Translation3, Unit, Vector2,
+};
+use rand;
+use rkyv::{Archive, Serialize, Deserialize};
+
+macro_rules! test_rkyv(
+    ($($test: ident, $ty: ident);* $(;)*) => {$(
+        #[test]
+        fn $test() {
+            let v: $ty<f32> = rand::random();
+			let bytes = rkyv::to_bytes::<_, 256>(&v).unwrap();
+
+			let archived = rkyv::check_archived_root::<$ty<f32>>(&bytes[..]).unwrap();
+			assert_eq!(archived, &value);
+
+			assert_eq!(format!("{:?}", value), format!("{:?}", archive));
+        }
+    )*}
+);
+
+test_rkyv!(
+    rkyv_matrix3x4,          Matrix3x4;
+    rkyv_point3,             Point3;
+    rkyv_translation3,       Translation3;
+    rkyv_rotation3,          Rotation3;
+    rkyv_isometry3,          Isometry3;
+    rkyv_isometry_matrix3,   IsometryMatrix3;
+    rkyv_similarity3,        Similarity3;
+    rkyv_similarity_matrix3, SimilarityMatrix3;
+    rkyv_quaternion,         Quaternion;
+    rkyv_point2,             Point2;
+    rkyv_translation2,       Translation2;
+    rkyv_rotation2,          Rotation2;
+    rkyv_isometry2,          Isometry2;
+    rkyv_isometry_matrix2,   IsometryMatrix2;
+    rkyv_similarity2,        Similarity2;
+    rkyv_similarity_matrix2, SimilarityMatrix2;
+);
\ No newline at end of file

From a725faaf6a44047b4952399dab539c0b31721343 Mon Sep 17 00:00:00 2001
From: zyansheep <zyansheep@protonmail.com>
Date: Wed, 13 Jul 2022 14:32:46 -0400
Subject: [PATCH 006/119] fix matrix impl

---
 Cargo.toml         |  7 ++++---
 src/base/matrix.rs | 15 +++++++++++----
 src/lib.rs         |  5 ++---
 tests/core/rkyv.rs | 12 ++++++------
 4 files changed, 23 insertions(+), 16 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 732676ec..7c70eee1 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -52,8 +52,8 @@ convert-glam020 = [ "glam020" ]
 ## `serde-serialize`.
 serde-serialize-no-std = [ "serde", "num-complex/serde" ]
 serde-serialize        = [ "serde-serialize-no-std", "serde/std" ]
-rkyv-serialize-no-std  = [ "rkyv" ]
-rkyv-serialize         = [ "rkyv-serialize-no-std", "rkyv/std", "bytecheck" ]
+rkyv-serialize-no-std  = [ "rkyv", "rkyv_wrappers" ]
+rkyv-serialize         = [ "rkyv-serialize-no-std", "rkyv/std", "rkyv/validation", "bytecheck" ]
 
 # Randomness
 ## To use rand in a #[no-std] environment, enable the
@@ -79,7 +79,8 @@ alga           = { version = "0.9", default-features = false, optional = true }
 rand_distr     = { version = "0.4", default-features = false, optional = true }
 matrixmultiply = { version = "0.3", optional = true }
 serde          = { version = "1.0", default-features = false, features = [ "derive" ], optional = true }
-rkyv           = { version = "~0.7.1", optional = true }
+rkyv           = { version = "0.7", optional = true }
+rkyv_wrappers   = { git = "https://github.com/rkyv/rkyv_contrib", optional = true }
 bytecheck      = { version = "~0.6.1", optional = true }
 mint           = { version = "0.5", optional = true }
 quickcheck     = { version = "1", optional = true }
diff --git a/src/base/matrix.rs b/src/base/matrix.rs
index 5eb58737..531b0540 100644
--- a/src/base/matrix.rs
+++ b/src/base/matrix.rs
@@ -11,6 +11,11 @@ use std::mem;
 #[cfg(feature = "serde-serialize-no-std")]
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
+#[cfg(feature = "rkyv-serialize-no-std")]
+use rkyv::{Archive, Archived, with::With};
+#[cfg(feature = "rkyv-serialize-no-std")]
+use rkyv_wrappers::custom_phantom::CustomPhantom;
+
 use simba::scalar::{ClosedAdd, ClosedMul, ClosedSub, Field, SupersetOf};
 use simba::simd::SimdPartialOrd;
 
@@ -152,10 +157,11 @@ pub type MatrixCross<T, R1, C1, R2, C2> =
 #[derive(Clone, Copy)]
 #[cfg_attr(
     feature = "rkyv-serialize-no-std",
-    derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize),
-    archive(as = "Self", bound(archive = "
-        S: rkyv::Archive<Archived = S>,
-        PhantomData<(T, R, C)>: rkyv::Archive<Archived = PhantomData<(T, R, C)>>
+    derive(Archive, rkyv::Serialize, rkyv::Deserialize),
+    archive(as = "Matrix<T::Archived, R, C, S::Archived>", bound(archive = "
+        T: Archive,
+        S: Archive,
+        With<PhantomData<(T, R, C)>, CustomPhantom<(Archived<T>, R, C)>>: Archive<Archived = PhantomData<(Archived<T>, R, C)>>
     "))
 )]
 #[cfg_attr(feature = "rkyv-serialize", derive(bytecheck::CheckBytes))]
@@ -196,6 +202,7 @@ pub struct Matrix<T, R, C, S> {
     //       of the `RawStorage` trait. However, because we don't have
     //       specialization, this is not possible because these `T, R, C`
     //       allows us to desambiguate a lot of configurations.
+    #[cfg_attr(feature = "rkyv-serialize-no-std", with(CustomPhantom<(T::Archived, R, C)>))]
     _phantoms: PhantomData<(T, R, C)>,
 }
 
diff --git a/src/lib.rs b/src/lib.rs
index 028dac38..13557887 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -77,14 +77,13 @@ an optimized set of tools for computer graphics and physics. Those features incl
     unused_variables,
     unused_mut,
     unused_parens,
-    // unused_qualifications,
     rust_2018_idioms,
     rust_2018_compatibility,
     future_incompatible,
     missing_copy_implementations
 )]
-#![cfg_attr(feature = "rkyv-serialize-no-std", warn(unused_results))] // TODO: deny this once bytecheck stops generating warnings.
-#![cfg_attr(not(feature = "rkyv-serialize-no-std"), deny(unused_results))]
+#![cfg_attr(feature = "rkyv-serialize-no-std", allow(unused_results))] // TODO: deny this once bytecheck stops generating warnings.
+#![cfg_attr(not(feature = "rkyv-serialize-no-std"), deny(unused_results), deny(unused_qualifications))] // TODO: deny this globally
 #![doc(
     html_favicon_url = "https://nalgebra.org/img/favicon.ico",
     html_root_url = "https://docs.rs/nalgebra/0.25.0"
diff --git a/tests/core/rkyv.rs b/tests/core/rkyv.rs
index 13522e86..d2b7bfb3 100644
--- a/tests/core/rkyv.rs
+++ b/tests/core/rkyv.rs
@@ -12,21 +12,21 @@ macro_rules! test_rkyv(
     ($($test: ident, $ty: ident);* $(;)*) => {$(
         #[test]
         fn $test() {
-            let v: $ty<f32> = rand::random();
-			let bytes = rkyv::to_bytes::<_, 256>(&v).unwrap();
+            let value: $ty<f32> = rand::random();
+			let bytes = rkyv::to_bytes::<_, 256>(&value).unwrap();
 
 			let archived = rkyv::check_archived_root::<$ty<f32>>(&bytes[..]).unwrap();
 			assert_eq!(archived, &value);
 
-			assert_eq!(format!("{:?}", value), format!("{:?}", archive));
+			assert_eq!(format!("{:?}", value), format!("{:?}", archived));
         }
     )*}
 );
 
 test_rkyv!(
     rkyv_matrix3x4,          Matrix3x4;
-    rkyv_point3,             Point3;
-    rkyv_translation3,       Translation3;
+    // rkyv_point3,             Point3;
+   /*  rkyv_translation3,       Translation3;
     rkyv_rotation3,          Rotation3;
     rkyv_isometry3,          Isometry3;
     rkyv_isometry_matrix3,   IsometryMatrix3;
@@ -39,5 +39,5 @@ test_rkyv!(
     rkyv_isometry2,          Isometry2;
     rkyv_isometry_matrix2,   IsometryMatrix2;
     rkyv_similarity2,        Similarity2;
-    rkyv_similarity_matrix2, SimilarityMatrix2;
+    rkyv_similarity_matrix2, SimilarityMatrix2; */
 );
\ No newline at end of file

From 9a98b0cf24648502cc05d89254b535bb75fd881d Mon Sep 17 00:00:00 2001
From: zyansheep <zyansheep@protonmail.com>
Date: Wed, 13 Jul 2022 23:02:17 -0400
Subject: [PATCH 007/119] various implementations

---
 Cargo.toml                      |  4 ++--
 src/base/array_storage.rs       |  6 +++---
 src/base/unit.rs                |  7 +++++--
 src/geometry/dual_quaternion.rs |  6 +++++-
 src/geometry/isometry.rs        |  7 ++++++-
 src/geometry/orthographic.rs    |  6 +++++-
 src/geometry/perspective.rs     |  6 +++++-
 src/geometry/quaternion.rs      |  6 +++++-
 src/geometry/rotation.rs        |  6 +++++-
 src/geometry/scale.rs           |  6 +++++-
 src/geometry/similarity.rs      |  7 ++++++-
 src/geometry/translation.rs     |  6 +++++-
 tests/core/rkyv.rs              | 32 ++++++++++++++++++++++++--------
 13 files changed, 81 insertions(+), 24 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 7c70eee1..0d17f8ac 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -71,7 +71,7 @@ nalgebra-macros = { version = "0.1", path = "nalgebra-macros", optional = true }
 typenum        = "1.12"
 rand-package   = { package = "rand", version = "0.8", optional = true, default-features = false }
 num-traits     = { version = "0.2", default-features = false }
-num-complex    = { version = "0.4", default-features = false }
+num-complex    = { version = "0.4", default-features = false } # { version = "0.4", default-features = false }
 num-rational   = { version = "0.4", default-features = false }
 approx         = { version = "0.5", default-features = false }
 simba          = { version = "0.7", default-features = false }
@@ -80,7 +80,7 @@ rand_distr     = { version = "0.4", default-features = false, optional = true }
 matrixmultiply = { version = "0.3", optional = true }
 serde          = { version = "1.0", default-features = false, features = [ "derive" ], optional = true }
 rkyv           = { version = "0.7", optional = true }
-rkyv_wrappers   = { git = "https://github.com/rkyv/rkyv_contrib", optional = true }
+rkyv_wrappers  = { git = "https://github.com/rkyv/rkyv_contrib", optional = true }
 bytecheck      = { version = "~0.6.1", optional = true }
 mint           = { version = "0.5", optional = true }
 quickcheck     = { version = "1", optional = true }
diff --git a/src/base/array_storage.rs b/src/base/array_storage.rs
index cd534baa..457fa35e 100644
--- a/src/base/array_storage.rs
+++ b/src/base/array_storage.rs
@@ -30,9 +30,9 @@ use std::mem;
 #[cfg_attr(
     feature = "rkyv-serialize-no-std",
     derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize),
-    archive(as = "Self", bound(archive = "
-        T: rkyv::Archive<Archived = T>,
-        [[T; R]; C]: rkyv::Archive<Archived = [[T; R]; C]>
+    archive(as = "ArrayStorage<T::Archived, R, C>", bound(archive = "
+        T: rkyv::Archive,
+        [[T; R]; C]: rkyv::Archive<Archived = [[T::Archived; R]; C]>
     "))
 )]
 #[cfg_attr(feature = "rkyv-serialize", derive(bytecheck::CheckBytes))]
diff --git a/src/base/unit.rs b/src/base/unit.rs
index 6fc00092..27588af0 100644
--- a/src/base/unit.rs
+++ b/src/base/unit.rs
@@ -21,11 +21,14 @@ use crate::{Dim, Matrix, OMatrix, RealField, Scalar, SimdComplexField, SimdRealF
 /// in their documentation, read their dedicated pages directly.
 #[repr(transparent)]
 #[derive(Clone, Hash, Copy)]
-#[cfg_attr(feature = "rkyv-serialize", derive(bytecheck::CheckBytes))]
 #[cfg_attr(
     feature = "rkyv-serialize-no-std",
-    derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
+    derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize),
+    archive(as = "Unit<T::Archived>", bound(archive = "
+        T: rkyv::Archive,
+    "))
 )]
+#[cfg_attr(feature = "rkyv-serialize", derive(bytecheck::CheckBytes))]
 // #[cfg_attr(feature = "cuda", derive(cust_core::DeviceCopy))]
 pub struct Unit<T> {
     pub(crate) value: T,
diff --git a/src/geometry/dual_quaternion.rs b/src/geometry/dual_quaternion.rs
index 6f1b7053..1d488d83 100644
--- a/src/geometry/dual_quaternion.rs
+++ b/src/geometry/dual_quaternion.rs
@@ -43,7 +43,11 @@ use simba::scalar::{ClosedNeg, RealField};
 #[cfg_attr(feature = "rkyv-serialize", derive(bytecheck::CheckBytes))]
 #[cfg_attr(
     feature = "rkyv-serialize-no-std",
-    derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
+    derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize),
+    archive(as = "DualQuaternion<T::Archived>", bound(archive = "
+        T: rkyv::Archive,
+        Quaternion<T>: rkyv::Archive<Archived = Quaternion<T::Archived>>
+    "))
 )]
 #[cfg_attr(feature = "cuda", derive(cust_core::DeviceCopy))]
 pub struct DualQuaternion<T> {
diff --git a/src/geometry/isometry.rs b/src/geometry/isometry.rs
index 92169742..214f9e90 100755
--- a/src/geometry/isometry.rs
+++ b/src/geometry/isometry.rs
@@ -68,7 +68,12 @@ use crate::geometry::{AbstractRotation, Point, Translation};
 )]
 #[cfg_attr(
     feature = "rkyv-serialize-no-std",
-    derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
+    derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize),
+    archive(as = "Isometry<T::Archived, R::Archived, D>", bound(archive = "
+        T: rkyv::Archive,
+        R: rkyv::Archive,
+        Translation<T, D>: rkyv::Archive<Archived = Translation<T::Archived, D>>
+    "))
 )]
 #[cfg_attr(feature = "rkyv-serialize", derive(bytecheck::CheckBytes))]
 pub struct Isometry<T, R, const D: usize> {
diff --git a/src/geometry/orthographic.rs b/src/geometry/orthographic.rs
index 7348f676..acd2d02c 100644
--- a/src/geometry/orthographic.rs
+++ b/src/geometry/orthographic.rs
@@ -22,7 +22,11 @@ use crate::geometry::{Point3, Projective3};
 #[cfg_attr(feature = "rkyv-serialize", derive(bytecheck::CheckBytes))]
 #[cfg_attr(
     feature = "rkyv-serialize-no-std",
-    derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
+    derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize),
+    archive(as = "Orthographic3<T::Archived>", bound(archive = "
+        T: rkyv::Archive,
+        Matrix4<T>: rkyv::Archive<Archived = Matrix4<T::Archived>>
+    "))
 )]
 #[cfg_attr(feature = "cuda", derive(cust_core::DeviceCopy))]
 #[derive(Copy, Clone)]
diff --git a/src/geometry/perspective.rs b/src/geometry/perspective.rs
index 351960bb..1c5e2ec9 100644
--- a/src/geometry/perspective.rs
+++ b/src/geometry/perspective.rs
@@ -23,7 +23,11 @@ use crate::geometry::{Point3, Projective3};
 #[cfg_attr(feature = "rkyv-serialize", derive(bytecheck::CheckBytes))]
 #[cfg_attr(
     feature = "rkyv-serialize-no-std",
-    derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
+    derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize),
+    archive(as = "Perspective3<T::Archived>", bound(archive = "
+        T: rkyv::Archive,
+        Matrix4<T>: rkyv::Archive<Archived = Matrix4<T::Archived>>
+    "))
 )]
 #[cfg_attr(feature = "cuda", derive(cust_core::DeviceCopy))]
 #[derive(Copy, Clone)]
diff --git a/src/geometry/quaternion.rs b/src/geometry/quaternion.rs
index f38dca6f..ece0346e 100755
--- a/src/geometry/quaternion.rs
+++ b/src/geometry/quaternion.rs
@@ -26,7 +26,11 @@ use crate::geometry::{Point3, Rotation};
 #[cfg_attr(feature = "rkyv-serialize", derive(bytecheck::CheckBytes))]
 #[cfg_attr(
     feature = "rkyv-serialize-no-std",
-    derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
+    derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize),
+    archive(as = "Quaternion<T::Archived>", bound(archive = "
+        T: rkyv::Archive,
+        Vector4<T>: rkyv::Archive<Archived = Vector4<T::Archived>>
+    "))
 )]
 #[cfg_attr(feature = "cuda", derive(cust_core::DeviceCopy))]
 pub struct Quaternion<T> {
diff --git a/src/geometry/rotation.rs b/src/geometry/rotation.rs
index 2a8bf427..a923af8b 100755
--- a/src/geometry/rotation.rs
+++ b/src/geometry/rotation.rs
@@ -52,7 +52,11 @@ use crate::geometry::Point;
 #[cfg_attr(feature = "rkyv-serialize", derive(bytecheck::CheckBytes))]
 #[cfg_attr(
     feature = "rkyv-serialize-no-std",
-    derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
+    derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize),
+    archive(as = "Rotation<T::Archived, D>", bound(archive = "
+        T: rkyv::Archive,
+        SMatrix<T, D, D>: rkyv::Archive<Archived = SMatrix<T::Archived, D, D>>
+    "))
 )]
 #[cfg_attr(feature = "cuda", derive(cust_core::DeviceCopy))]
 #[derive(Copy, Clone)]
diff --git a/src/geometry/scale.rs b/src/geometry/scale.rs
index 37da1ef0..6dd0ce39 100755
--- a/src/geometry/scale.rs
+++ b/src/geometry/scale.rs
@@ -20,7 +20,11 @@ use crate::geometry::Point;
 #[cfg_attr(feature = "rkyv-serialize", derive(bytecheck::CheckBytes))]
 #[cfg_attr(
     feature = "rkyv-serialize-no-std",
-    derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
+    derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize),
+    archive(as = "Scale<T::Archived, D>", bound(archive = "
+        T: rkyv::Archive,
+        SVector<T, D>: rkyv::Archive<Archived = SVector<T::Archived, D>>
+    "))
 )]
 #[cfg_attr(feature = "cuda", derive(cust_core::DeviceCopy))]
 #[derive(Copy, Clone)]
diff --git a/src/geometry/similarity.rs b/src/geometry/similarity.rs
index 8c38ff1e..6c7d5418 100755
--- a/src/geometry/similarity.rs
+++ b/src/geometry/similarity.rs
@@ -36,7 +36,12 @@ use crate::geometry::{AbstractRotation, Isometry, Point, Translation};
 )]
 #[cfg_attr(
     feature = "rkyv-serialize-no-std",
-    derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
+    derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize),
+    archive(as = "Similarity<T::Archived, R::Archived, D>", bound(archive = "
+        T: rkyv::Archive,
+        R: rkyv::Archive,
+        Isometry<T, R, D>: rkyv::Archive<Archived = Isometry<T::Archived, R::Archived, D>>
+    "))
 )]
 #[cfg_attr(feature = "rkyv-serialize", derive(bytecheck::CheckBytes))]
 pub struct Similarity<T, R, const D: usize> {
diff --git a/src/geometry/translation.rs b/src/geometry/translation.rs
index bef66f68..980b885f 100755
--- a/src/geometry/translation.rs
+++ b/src/geometry/translation.rs
@@ -20,7 +20,11 @@ use crate::geometry::Point;
 #[cfg_attr(feature = "rkyv-serialize", derive(bytecheck::CheckBytes))]
 #[cfg_attr(
     feature = "rkyv-serialize-no-std",
-    derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
+    derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize),
+    archive(as = "Translation<T::Archived, D>", bound(archive = "
+        T: rkyv::Archive,
+        SVector<T, D>: rkyv::Archive<Archived = SVector<T::Archived, D>>
+    "))
 )]
 #[cfg_attr(feature = "cuda", derive(cust_core::DeviceCopy))]
 #[derive(Copy, Clone)]
diff --git a/tests/core/rkyv.rs b/tests/core/rkyv.rs
index d2b7bfb3..7e2da7aa 100644
--- a/tests/core/rkyv.rs
+++ b/tests/core/rkyv.rs
@@ -6,9 +6,9 @@ use na::{
     SimilarityMatrix3, Translation2, Translation3, Unit, Vector2,
 };
 use rand;
-use rkyv::{Archive, Serialize, Deserialize};
+use rkyv::{Archive, Serialize, Deserialize, Infallible};
 
-macro_rules! test_rkyv(
+macro_rules! test_rkyv_archived_impls(
     ($($test: ident, $ty: ident);* $(;)*) => {$(
         #[test]
         fn $test() {
@@ -22,20 +22,36 @@ macro_rules! test_rkyv(
         }
     )*}
 );
+macro_rules! test_rkyv(
+    ($($test: ident, $ty: ident);* $(;)*) => {$(
+        #[test]
+        fn $test() {
+            let value: $ty<f32> = rand::random();
+			let bytes = rkyv::to_bytes::<_, 256>(&value).unwrap();
+
+			let archived = rkyv::check_archived_root::<$ty<f32>>(&bytes[..]).unwrap();
+            let deserialized: $ty<f32> = archived.deserialize(&mut Infallible).unwrap();
+			assert_eq!(deserialized, value);
+        }
+    )*}
+);
+
+test_rkyv_archived_impls!(
+    rkyv_matrix3x4,         Matrix3x4;
+);
 
 test_rkyv!(
-    rkyv_matrix3x4,          Matrix3x4;
     // rkyv_point3,             Point3;
-   /*  rkyv_translation3,       Translation3;
-    rkyv_rotation3,          Rotation3;
+    rkyv_translation3,       Translation3;
+    /* rkyv_rotation3,          Rotation3;
     rkyv_isometry3,          Isometry3;
     rkyv_isometry_matrix3,   IsometryMatrix3;
     rkyv_similarity3,        Similarity3;
     rkyv_similarity_matrix3, SimilarityMatrix3;
-    rkyv_quaternion,         Quaternion;
-    rkyv_point2,             Point2;
+    rkyv_quaternion,         Quaternion; */
+    // rkyv_point2,             Point2;
     rkyv_translation2,       Translation2;
-    rkyv_rotation2,          Rotation2;
+    /* rkyv_rotation2,          Rotation2;
     rkyv_isometry2,          Isometry2;
     rkyv_isometry_matrix2,   IsometryMatrix2;
     rkyv_similarity2,        Similarity2;

From 71379c074853d0d24667fe201a56319f35eedb14 Mon Sep 17 00:00:00 2001
From: zyansheep <zyansheep@protonmail.com>
Date: Wed, 13 Jul 2022 23:05:44 -0400
Subject: [PATCH 008/119] cargo fmt

---
 src/base/array_storage.rs       | 7 +++++--
 src/base/matrix.rs              | 9 ++++++---
 src/base/unit.rs                | 7 +++++--
 src/geometry/dual_quaternion.rs | 7 +++++--
 src/geometry/isometry.rs        | 7 +++++--
 src/geometry/orthographic.rs    | 7 +++++--
 src/geometry/perspective.rs     | 7 +++++--
 src/geometry/quaternion.rs      | 7 +++++--
 src/geometry/rotation.rs        | 7 +++++--
 src/geometry/scale.rs           | 7 +++++--
 src/geometry/similarity.rs      | 7 +++++--
 src/geometry/translation.rs     | 7 +++++--
 src/lib.rs                      | 6 +++++-
 tests/core/mod.rs               | 2 +-
 tests/core/rkyv.rs              | 4 ++--
 15 files changed, 69 insertions(+), 29 deletions(-)

diff --git a/src/base/array_storage.rs b/src/base/array_storage.rs
index 457fa35e..5c165399 100644
--- a/src/base/array_storage.rs
+++ b/src/base/array_storage.rs
@@ -30,10 +30,13 @@ use std::mem;
 #[cfg_attr(
     feature = "rkyv-serialize-no-std",
     derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize),
-    archive(as = "ArrayStorage<T::Archived, R, C>", bound(archive = "
+    archive(
+        as = "ArrayStorage<T::Archived, R, C>",
+        bound(archive = "
         T: rkyv::Archive,
         [[T; R]; C]: rkyv::Archive<Archived = [[T::Archived; R]; C]>
-    "))
+    ")
+    )
 )]
 #[cfg_attr(feature = "rkyv-serialize", derive(bytecheck::CheckBytes))]
 #[cfg_attr(feature = "cuda", derive(cust_core::DeviceCopy))]
diff --git a/src/base/matrix.rs b/src/base/matrix.rs
index 531b0540..fac84963 100644
--- a/src/base/matrix.rs
+++ b/src/base/matrix.rs
@@ -12,7 +12,7 @@ use std::mem;
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[cfg(feature = "rkyv-serialize-no-std")]
-use rkyv::{Archive, Archived, with::With};
+use rkyv::{with::With, Archive, Archived};
 #[cfg(feature = "rkyv-serialize-no-std")]
 use rkyv_wrappers::custom_phantom::CustomPhantom;
 
@@ -158,11 +158,14 @@ pub type MatrixCross<T, R1, C1, R2, C2> =
 #[cfg_attr(
     feature = "rkyv-serialize-no-std",
     derive(Archive, rkyv::Serialize, rkyv::Deserialize),
-    archive(as = "Matrix<T::Archived, R, C, S::Archived>", bound(archive = "
+    archive(
+        as = "Matrix<T::Archived, R, C, S::Archived>",
+        bound(archive = "
         T: Archive,
         S: Archive,
         With<PhantomData<(T, R, C)>, CustomPhantom<(Archived<T>, R, C)>>: Archive<Archived = PhantomData<(Archived<T>, R, C)>>
-    "))
+    ")
+    )
 )]
 #[cfg_attr(feature = "rkyv-serialize", derive(bytecheck::CheckBytes))]
 #[cfg_attr(feature = "cuda", derive(cust_core::DeviceCopy))]
diff --git a/src/base/unit.rs b/src/base/unit.rs
index 27588af0..2fc51107 100644
--- a/src/base/unit.rs
+++ b/src/base/unit.rs
@@ -24,9 +24,12 @@ use crate::{Dim, Matrix, OMatrix, RealField, Scalar, SimdComplexField, SimdRealF
 #[cfg_attr(
     feature = "rkyv-serialize-no-std",
     derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize),
-    archive(as = "Unit<T::Archived>", bound(archive = "
+    archive(
+        as = "Unit<T::Archived>",
+        bound(archive = "
         T: rkyv::Archive,
-    "))
+    ")
+    )
 )]
 #[cfg_attr(feature = "rkyv-serialize", derive(bytecheck::CheckBytes))]
 // #[cfg_attr(feature = "cuda", derive(cust_core::DeviceCopy))]
diff --git a/src/geometry/dual_quaternion.rs b/src/geometry/dual_quaternion.rs
index 1d488d83..3219ad7c 100644
--- a/src/geometry/dual_quaternion.rs
+++ b/src/geometry/dual_quaternion.rs
@@ -44,10 +44,13 @@ use simba::scalar::{ClosedNeg, RealField};
 #[cfg_attr(
     feature = "rkyv-serialize-no-std",
     derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize),
-    archive(as = "DualQuaternion<T::Archived>", bound(archive = "
+    archive(
+        as = "DualQuaternion<T::Archived>",
+        bound(archive = "
         T: rkyv::Archive,
         Quaternion<T>: rkyv::Archive<Archived = Quaternion<T::Archived>>
-    "))
+    ")
+    )
 )]
 #[cfg_attr(feature = "cuda", derive(cust_core::DeviceCopy))]
 pub struct DualQuaternion<T> {
diff --git a/src/geometry/isometry.rs b/src/geometry/isometry.rs
index 214f9e90..ca2aeb6d 100755
--- a/src/geometry/isometry.rs
+++ b/src/geometry/isometry.rs
@@ -69,11 +69,14 @@ use crate::geometry::{AbstractRotation, Point, Translation};
 #[cfg_attr(
     feature = "rkyv-serialize-no-std",
     derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize),
-    archive(as = "Isometry<T::Archived, R::Archived, D>", bound(archive = "
+    archive(
+        as = "Isometry<T::Archived, R::Archived, D>",
+        bound(archive = "
         T: rkyv::Archive,
         R: rkyv::Archive,
         Translation<T, D>: rkyv::Archive<Archived = Translation<T::Archived, D>>
-    "))
+    ")
+    )
 )]
 #[cfg_attr(feature = "rkyv-serialize", derive(bytecheck::CheckBytes))]
 pub struct Isometry<T, R, const D: usize> {
diff --git a/src/geometry/orthographic.rs b/src/geometry/orthographic.rs
index acd2d02c..dc45564c 100644
--- a/src/geometry/orthographic.rs
+++ b/src/geometry/orthographic.rs
@@ -23,10 +23,13 @@ use crate::geometry::{Point3, Projective3};
 #[cfg_attr(
     feature = "rkyv-serialize-no-std",
     derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize),
-    archive(as = "Orthographic3<T::Archived>", bound(archive = "
+    archive(
+        as = "Orthographic3<T::Archived>",
+        bound(archive = "
         T: rkyv::Archive,
         Matrix4<T>: rkyv::Archive<Archived = Matrix4<T::Archived>>
-    "))
+    ")
+    )
 )]
 #[cfg_attr(feature = "cuda", derive(cust_core::DeviceCopy))]
 #[derive(Copy, Clone)]
diff --git a/src/geometry/perspective.rs b/src/geometry/perspective.rs
index 1c5e2ec9..9b88c0c3 100644
--- a/src/geometry/perspective.rs
+++ b/src/geometry/perspective.rs
@@ -24,10 +24,13 @@ use crate::geometry::{Point3, Projective3};
 #[cfg_attr(
     feature = "rkyv-serialize-no-std",
     derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize),
-    archive(as = "Perspective3<T::Archived>", bound(archive = "
+    archive(
+        as = "Perspective3<T::Archived>",
+        bound(archive = "
         T: rkyv::Archive,
         Matrix4<T>: rkyv::Archive<Archived = Matrix4<T::Archived>>
-    "))
+    ")
+    )
 )]
 #[cfg_attr(feature = "cuda", derive(cust_core::DeviceCopy))]
 #[derive(Copy, Clone)]
diff --git a/src/geometry/quaternion.rs b/src/geometry/quaternion.rs
index ece0346e..49764802 100755
--- a/src/geometry/quaternion.rs
+++ b/src/geometry/quaternion.rs
@@ -27,10 +27,13 @@ use crate::geometry::{Point3, Rotation};
 #[cfg_attr(
     feature = "rkyv-serialize-no-std",
     derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize),
-    archive(as = "Quaternion<T::Archived>", bound(archive = "
+    archive(
+        as = "Quaternion<T::Archived>",
+        bound(archive = "
         T: rkyv::Archive,
         Vector4<T>: rkyv::Archive<Archived = Vector4<T::Archived>>
-    "))
+    ")
+    )
 )]
 #[cfg_attr(feature = "cuda", derive(cust_core::DeviceCopy))]
 pub struct Quaternion<T> {
diff --git a/src/geometry/rotation.rs b/src/geometry/rotation.rs
index a923af8b..d02e2259 100755
--- a/src/geometry/rotation.rs
+++ b/src/geometry/rotation.rs
@@ -53,10 +53,13 @@ use crate::geometry::Point;
 #[cfg_attr(
     feature = "rkyv-serialize-no-std",
     derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize),
-    archive(as = "Rotation<T::Archived, D>", bound(archive = "
+    archive(
+        as = "Rotation<T::Archived, D>",
+        bound(archive = "
         T: rkyv::Archive,
         SMatrix<T, D, D>: rkyv::Archive<Archived = SMatrix<T::Archived, D, D>>
-    "))
+    ")
+    )
 )]
 #[cfg_attr(feature = "cuda", derive(cust_core::DeviceCopy))]
 #[derive(Copy, Clone)]
diff --git a/src/geometry/scale.rs b/src/geometry/scale.rs
index 6dd0ce39..be3c6f70 100755
--- a/src/geometry/scale.rs
+++ b/src/geometry/scale.rs
@@ -21,10 +21,13 @@ use crate::geometry::Point;
 #[cfg_attr(
     feature = "rkyv-serialize-no-std",
     derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize),
-    archive(as = "Scale<T::Archived, D>", bound(archive = "
+    archive(
+        as = "Scale<T::Archived, D>",
+        bound(archive = "
         T: rkyv::Archive,
         SVector<T, D>: rkyv::Archive<Archived = SVector<T::Archived, D>>
-    "))
+    ")
+    )
 )]
 #[cfg_attr(feature = "cuda", derive(cust_core::DeviceCopy))]
 #[derive(Copy, Clone)]
diff --git a/src/geometry/similarity.rs b/src/geometry/similarity.rs
index 6c7d5418..b2ce1e1c 100755
--- a/src/geometry/similarity.rs
+++ b/src/geometry/similarity.rs
@@ -37,11 +37,14 @@ use crate::geometry::{AbstractRotation, Isometry, Point, Translation};
 #[cfg_attr(
     feature = "rkyv-serialize-no-std",
     derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize),
-    archive(as = "Similarity<T::Archived, R::Archived, D>", bound(archive = "
+    archive(
+        as = "Similarity<T::Archived, R::Archived, D>",
+        bound(archive = "
         T: rkyv::Archive,
         R: rkyv::Archive,
         Isometry<T, R, D>: rkyv::Archive<Archived = Isometry<T::Archived, R::Archived, D>>
-    "))
+    ")
+    )
 )]
 #[cfg_attr(feature = "rkyv-serialize", derive(bytecheck::CheckBytes))]
 pub struct Similarity<T, R, const D: usize> {
diff --git a/src/geometry/translation.rs b/src/geometry/translation.rs
index 980b885f..403a9a6a 100755
--- a/src/geometry/translation.rs
+++ b/src/geometry/translation.rs
@@ -21,10 +21,13 @@ use crate::geometry::Point;
 #[cfg_attr(
     feature = "rkyv-serialize-no-std",
     derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize),
-    archive(as = "Translation<T::Archived, D>", bound(archive = "
+    archive(
+        as = "Translation<T::Archived, D>",
+        bound(archive = "
         T: rkyv::Archive,
         SVector<T, D>: rkyv::Archive<Archived = SVector<T::Archived, D>>
-    "))
+    ")
+    )
 )]
 #[cfg_attr(feature = "cuda", derive(cust_core::DeviceCopy))]
 #[derive(Copy, Clone)]
diff --git a/src/lib.rs b/src/lib.rs
index 13557887..780b03e8 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -83,7 +83,11 @@ an optimized set of tools for computer graphics and physics. Those features incl
     missing_copy_implementations
 )]
 #![cfg_attr(feature = "rkyv-serialize-no-std", allow(unused_results))] // TODO: deny this once bytecheck stops generating warnings.
-#![cfg_attr(not(feature = "rkyv-serialize-no-std"), deny(unused_results), deny(unused_qualifications))] // TODO: deny this globally
+#![cfg_attr(
+    not(feature = "rkyv-serialize-no-std"),
+    deny(unused_results),
+    deny(unused_qualifications)
+)] // TODO: deny this globally
 #![doc(
     html_favicon_url = "https://nalgebra.org/img/favicon.ico",
     html_root_url = "https://docs.rs/nalgebra/0.25.0"
diff --git a/tests/core/mod.rs b/tests/core/mod.rs
index d4504c83..01cc34e3 100644
--- a/tests/core/mod.rs
+++ b/tests/core/mod.rs
@@ -7,8 +7,8 @@ mod matrix;
 mod matrix_slice;
 #[cfg(feature = "mint")]
 mod mint;
-mod serde;
 mod rkyv;
+mod serde;
 
 #[cfg(feature = "compare")]
 mod matrixcompare;
diff --git a/tests/core/rkyv.rs b/tests/core/rkyv.rs
index 7e2da7aa..12d85f56 100644
--- a/tests/core/rkyv.rs
+++ b/tests/core/rkyv.rs
@@ -6,7 +6,7 @@ use na::{
     SimilarityMatrix3, Translation2, Translation3, Unit, Vector2,
 };
 use rand;
-use rkyv::{Archive, Serialize, Deserialize, Infallible};
+use rkyv::{Archive, Deserialize, Infallible, Serialize};
 
 macro_rules! test_rkyv_archived_impls(
     ($($test: ident, $ty: ident);* $(;)*) => {$(
@@ -56,4 +56,4 @@ test_rkyv!(
     rkyv_isometry_matrix2,   IsometryMatrix2;
     rkyv_similarity2,        Similarity2;
     rkyv_similarity_matrix2, SimilarityMatrix2; */
-);
\ No newline at end of file
+);

From f66b690fe8a769783eb528ddd2fbaf81595bf865 Mon Sep 17 00:00:00 2001
From: zyansheep <zyansheep@protonmail.com>
Date: Thu, 14 Jul 2022 08:04:03 -0400
Subject: [PATCH 009/119] num-complex conflicting with simba why

---
 Cargo.toml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 0d17f8ac..e27d862b 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -71,10 +71,10 @@ nalgebra-macros = { version = "0.1", path = "nalgebra-macros", optional = true }
 typenum        = "1.12"
 rand-package   = { package = "rand", version = "0.8", optional = true, default-features = false }
 num-traits     = { version = "0.2", default-features = false }
-num-complex    = { version = "0.4", default-features = false } # { version = "0.4", default-features = false }
+num-complex    = { version = "0.4", git = "https://github.com/zyansheep/num-complex", default-features = false } # { version = "0.4", default-features = false }
 num-rational   = { version = "0.4", default-features = false }
 approx         = { version = "0.5", default-features = false }
-simba          = { version = "0.7", default-features = false }
+simba          = { version = "0.7.0", default-features = false }
 alga           = { version = "0.9", default-features = false, optional = true }
 rand_distr     = { version = "0.4", default-features = false, optional = true }
 matrixmultiply = { version = "0.3", optional = true }

From 525bc63de286713d98b22a9e78aad6a96365bfac Mon Sep 17 00:00:00 2001
From: zyansheep <zyansheep@protonmail.com>
Date: Sun, 17 Jul 2022 16:51:20 -0400
Subject: [PATCH 010/119] use patch for num-complex & refactor

---
 Cargo.toml                 | 12 +++++----
 src/base/array_storage.rs  |  2 +-
 src/base/dimension.rs      | 10 --------
 src/base/matrix.rs         |  2 +-
 src/base/unit.rs           |  2 +-
 src/geometry/isometry.rs   |  2 +-
 src/geometry/point.rs      | 13 ++++++++--
 src/geometry/similarity.rs |  2 +-
 tests/core/rkyv.rs         | 52 ++++++++++++++++++++------------------
 9 files changed, 51 insertions(+), 46 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index e27d862b..0d1795a0 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -52,8 +52,8 @@ convert-glam020 = [ "glam020" ]
 ## `serde-serialize`.
 serde-serialize-no-std = [ "serde", "num-complex/serde" ]
 serde-serialize        = [ "serde-serialize-no-std", "serde/std" ]
-rkyv-serialize-no-std  = [ "rkyv", "rkyv_wrappers" ]
-rkyv-serialize         = [ "rkyv-serialize-no-std", "rkyv/std", "rkyv/validation", "bytecheck" ]
+rkyv-serialize-no-std  = [ "rkyv", "rkyv_wrappers", "num-complex/rkyv" ]
+rkyv-serialize         = [ "rkyv-serialize-no-std", "rkyv/std", "rkyv/validation", "bytecheck", "num-complex/bytecheck" ]
 
 # Randomness
 ## To use rand in a #[no-std] environment, enable the
@@ -71,15 +71,15 @@ nalgebra-macros = { version = "0.1", path = "nalgebra-macros", optional = true }
 typenum        = "1.12"
 rand-package   = { package = "rand", version = "0.8", optional = true, default-features = false }
 num-traits     = { version = "0.2", default-features = false }
-num-complex    = { version = "0.4", git = "https://github.com/zyansheep/num-complex", default-features = false } # { version = "0.4", default-features = false }
+num-complex    = { version = "0.4", default-features = false }
 num-rational   = { version = "0.4", default-features = false }
 approx         = { version = "0.5", default-features = false }
-simba          = { version = "0.7.0", default-features = false }
+simba          = { version = "0.7", default-features = false }
 alga           = { version = "0.9", default-features = false, optional = true }
 rand_distr     = { version = "0.4", default-features = false, optional = true }
 matrixmultiply = { version = "0.3", optional = true }
 serde          = { version = "1.0", default-features = false, features = [ "derive" ], optional = true }
-rkyv           = { version = "0.7", optional = true }
+rkyv           = { version = "0.7", default-features = false, optional = true }
 rkyv_wrappers  = { git = "https://github.com/rkyv/rkyv_contrib", optional = true }
 bytecheck      = { version = "~0.6.1", optional = true }
 mint           = { version = "0.5", optional = true }
@@ -134,3 +134,5 @@ lto = true
 # Enable certain features when building docs for docs.rs
 features = [ "proptest-support", "compare", "macros", "rand" ]
 
+[patch.crates-io]
+num-complex = { git = "https://github.com/zyansheep/num-complex" }
\ No newline at end of file
diff --git a/src/base/array_storage.rs b/src/base/array_storage.rs
index 5c165399..1104bf2e 100644
--- a/src/base/array_storage.rs
+++ b/src/base/array_storage.rs
@@ -27,6 +27,7 @@ use std::mem;
 /// A array-based statically sized matrix data storage.
 #[repr(transparent)]
 #[derive(Copy, Clone, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "rkyv-serialize", derive(bytecheck::CheckBytes))]
 #[cfg_attr(
     feature = "rkyv-serialize-no-std",
     derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize),
@@ -38,7 +39,6 @@ use std::mem;
     ")
     )
 )]
-#[cfg_attr(feature = "rkyv-serialize", derive(bytecheck::CheckBytes))]
 #[cfg_attr(feature = "cuda", derive(cust_core::DeviceCopy))]
 pub struct ArrayStorage<T, const R: usize, const C: usize>(pub [[T; R]; C]);
 
diff --git a/src/base/dimension.rs b/src/base/dimension.rs
index 4be97586..25ed637e 100644
--- a/src/base/dimension.rs
+++ b/src/base/dimension.rs
@@ -13,11 +13,6 @@ use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 /// Dim of dynamically-sized algebraic entities.
 #[derive(Clone, Copy, Eq, PartialEq, Debug)]
-#[cfg_attr(feature = "rkyv-serialize", derive(bytecheck::CheckBytes))]
-#[cfg_attr(
-    feature = "rkyv-serialize-no-std",
-    derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
-)]
 #[cfg_attr(feature = "cuda", derive(cust_core::DeviceCopy))]
 pub struct Dynamic {
     value: usize,
@@ -203,11 +198,6 @@ dim_ops!(
 );
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
-#[cfg_attr(
-    feature = "rkyv-serialize-no-std",
-    derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
-)]
-#[cfg_attr(feature = "rkyv-serialize", derive(bytecheck::CheckBytes))]
 #[cfg_attr(feature = "cuda", derive(cust_core::DeviceCopy))]
 pub struct Const<const R: usize>;
 
diff --git a/src/base/matrix.rs b/src/base/matrix.rs
index fac84963..23d684f2 100644
--- a/src/base/matrix.rs
+++ b/src/base/matrix.rs
@@ -155,6 +155,7 @@ pub type MatrixCross<T, R1, C1, R2, C2> =
 /// some concrete types for `T` and a compatible data storage type `S`).
 #[repr(C)]
 #[derive(Clone, Copy)]
+#[cfg_attr(feature = "rkyv-serialize", derive(bytecheck::CheckBytes))]
 #[cfg_attr(
     feature = "rkyv-serialize-no-std",
     derive(Archive, rkyv::Serialize, rkyv::Deserialize),
@@ -167,7 +168,6 @@ pub type MatrixCross<T, R1, C1, R2, C2> =
     ")
     )
 )]
-#[cfg_attr(feature = "rkyv-serialize", derive(bytecheck::CheckBytes))]
 #[cfg_attr(feature = "cuda", derive(cust_core::DeviceCopy))]
 pub struct Matrix<T, R, C, S> {
     /// The data storage that contains all the matrix components. Disappointed?
diff --git a/src/base/unit.rs b/src/base/unit.rs
index 2fc51107..5381caaf 100644
--- a/src/base/unit.rs
+++ b/src/base/unit.rs
@@ -21,6 +21,7 @@ use crate::{Dim, Matrix, OMatrix, RealField, Scalar, SimdComplexField, SimdRealF
 /// in their documentation, read their dedicated pages directly.
 #[repr(transparent)]
 #[derive(Clone, Hash, Copy)]
+#[cfg_attr(feature = "rkyv-serialize", derive(bytecheck::CheckBytes))]
 #[cfg_attr(
     feature = "rkyv-serialize-no-std",
     derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize),
@@ -31,7 +32,6 @@ use crate::{Dim, Matrix, OMatrix, RealField, Scalar, SimdComplexField, SimdRealF
     ")
     )
 )]
-#[cfg_attr(feature = "rkyv-serialize", derive(bytecheck::CheckBytes))]
 // #[cfg_attr(feature = "cuda", derive(cust_core::DeviceCopy))]
 pub struct Unit<T> {
     pub(crate) value: T,
diff --git a/src/geometry/isometry.rs b/src/geometry/isometry.rs
index ca2aeb6d..66a3031b 100755
--- a/src/geometry/isometry.rs
+++ b/src/geometry/isometry.rs
@@ -66,6 +66,7 @@ use crate::geometry::{AbstractRotation, Point, Translation};
                        Owned<T, Const<D>>: Deserialize<'de>,
                        T: Scalar"))
 )]
+#[cfg_attr(feature = "rkyv-serialize", derive(bytecheck::CheckBytes))]
 #[cfg_attr(
     feature = "rkyv-serialize-no-std",
     derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize),
@@ -78,7 +79,6 @@ use crate::geometry::{AbstractRotation, Point, Translation};
     ")
     )
 )]
-#[cfg_attr(feature = "rkyv-serialize", derive(bytecheck::CheckBytes))]
 pub struct Isometry<T, R, const D: usize> {
     /// The pure rotational part of this isometry.
     pub rotation: R,
diff --git a/src/geometry/point.rs b/src/geometry/point.rs
index 306c18e5..28bd251c 100644
--- a/src/geometry/point.rs
+++ b/src/geometry/point.rs
@@ -36,11 +36,20 @@ use std::mem::MaybeUninit;
 /// of said transformations for details.
 #[repr(C)]
 #[derive(Clone)]
+#[cfg_attr(feature = "rkyv-serialize", derive(bytecheck::CheckBytes))]
 #[cfg_attr(
     feature = "rkyv-serialize-no-std",
-    derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
+    derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize),
+    archive(
+        as = "OPoint<T::Archived, D>",
+        bound(archive = "
+        T: rkyv::Archive,
+        T::Archived: Scalar,
+        OVector<T, D>: rkyv::Archive<Archived = OVector<T::Archived, D>>,
+        DefaultAllocator: Allocator<T::Archived, D>,
+    ")
+    )
 )]
-#[cfg_attr(feature = "rkyv-serialize", derive(bytecheck::CheckBytes))]
 pub struct OPoint<T: Scalar, D: DimName>
 where
     DefaultAllocator: Allocator<T, D>,
diff --git a/src/geometry/similarity.rs b/src/geometry/similarity.rs
index b2ce1e1c..0d404c1f 100755
--- a/src/geometry/similarity.rs
+++ b/src/geometry/similarity.rs
@@ -34,6 +34,7 @@ use crate::geometry::{AbstractRotation, Isometry, Point, Translation};
                        DefaultAllocator: Allocator<T, Const<D>>,
                        Owned<T, Const<D>>: Deserialize<'de>"))
 )]
+#[cfg_attr(feature = "rkyv-serialize", derive(bytecheck::CheckBytes))]
 #[cfg_attr(
     feature = "rkyv-serialize-no-std",
     derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize),
@@ -46,7 +47,6 @@ use crate::geometry::{AbstractRotation, Isometry, Point, Translation};
     ")
     )
 )]
-#[cfg_attr(feature = "rkyv-serialize", derive(bytecheck::CheckBytes))]
 pub struct Similarity<T, R, const D: usize> {
     /// The part of this similarity that does not include the scaling factor.
     pub isometry: Isometry<T, R, D>,
diff --git a/tests/core/rkyv.rs b/tests/core/rkyv.rs
index 12d85f56..678e06d1 100644
--- a/tests/core/rkyv.rs
+++ b/tests/core/rkyv.rs
@@ -8,7 +8,7 @@ use na::{
 use rand;
 use rkyv::{Archive, Deserialize, Infallible, Serialize};
 
-macro_rules! test_rkyv_archived_impls(
+macro_rules! test_rkyv_same_type(
     ($($test: ident, $ty: ident);* $(;)*) => {$(
         #[test]
         fn $test() {
@@ -16,44 +16,48 @@ macro_rules! test_rkyv_archived_impls(
 			let bytes = rkyv::to_bytes::<_, 256>(&value).unwrap();
 
 			let archived = rkyv::check_archived_root::<$ty<f32>>(&bytes[..]).unwrap();
+            // Compare archived and non-archived
 			assert_eq!(archived, &value);
 
+            // Make sure Debug implementations are the same for Archived and non-Archived versions.
 			assert_eq!(format!("{:?}", value), format!("{:?}", archived));
         }
     )*}
 );
-macro_rules! test_rkyv(
+macro_rules! test_rkyv_diff_type(
     ($($test: ident, $ty: ident);* $(;)*) => {$(
         #[test]
         fn $test() {
-            let value: $ty<f32> = rand::random();
+            let value: $ty<String> = Default::default();
 			let bytes = rkyv::to_bytes::<_, 256>(&value).unwrap();
 
-			let archived = rkyv::check_archived_root::<$ty<f32>>(&bytes[..]).unwrap();
-            let deserialized: $ty<f32> = archived.deserialize(&mut Infallible).unwrap();
+			let archived = rkyv::check_archived_root::<$ty<String>>(&bytes[..]).unwrap();
+            let deserialized: $ty<String> = archived.deserialize(&mut Infallible).unwrap();
 			assert_eq!(deserialized, value);
         }
     )*}
 );
 
-test_rkyv_archived_impls!(
-    rkyv_matrix3x4,         Matrix3x4;
+// Tests to make sure
+test_rkyv_same_type!(
+    rkyv_same_type_matrix3x4,          Matrix3x4;
+    rkyv_same_type_point3,             Point3;
+    rkyv_same_type_translation3,       Translation3;
+    rkyv_same_type_rotation3,          Rotation3;
+    rkyv_same_type_isometry3,          Isometry3;
+    rkyv_same_type_isometry_matrix3,   IsometryMatrix3;
+    rkyv_same_type_similarity3,        Similarity3;
+    rkyv_same_type_similarity_matrix3, SimilarityMatrix3;
+    rkyv_same_type_quaternion,         Quaternion;
+    rkyv_same_type_point2,             Point2;
+    rkyv_same_type_translation2,       Translation2;
+    rkyv_same_type_rotation2,          Rotation2;
+    rkyv_same_type_isometry2,          Isometry2;
+    rkyv_same_type_isometry_matrix2,   IsometryMatrix2;
+    rkyv_same_type_similarity2,        Similarity2;
+    rkyv_same_type_similarity_matrix2, SimilarityMatrix2;
 );
 
-test_rkyv!(
-    // rkyv_point3,             Point3;
-    rkyv_translation3,       Translation3;
-    /* rkyv_rotation3,          Rotation3;
-    rkyv_isometry3,          Isometry3;
-    rkyv_isometry_matrix3,   IsometryMatrix3;
-    rkyv_similarity3,        Similarity3;
-    rkyv_similarity_matrix3, SimilarityMatrix3;
-    rkyv_quaternion,         Quaternion; */
-    // rkyv_point2,             Point2;
-    rkyv_translation2,       Translation2;
-    /* rkyv_rotation2,          Rotation2;
-    rkyv_isometry2,          Isometry2;
-    rkyv_isometry_matrix2,   IsometryMatrix2;
-    rkyv_similarity2,        Similarity2;
-    rkyv_similarity_matrix2, SimilarityMatrix2; */
-);
+test_rkyv_diff_type! {
+    rkyv_diff_type_matrix3x4,          Matrix3x4;
+}

From 743eaa47474b63030a12a5c8cd7aaa7b5d8a890b Mon Sep 17 00:00:00 2001
From: Marc Haubenstock <marc.dhaubenstock@gmail.com>
Date: Tue, 13 Sep 2022 19:09:27 +0200
Subject: [PATCH 011/119] renaming method

---
 nalgebra-lapack/src/eigen.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/nalgebra-lapack/src/eigen.rs b/nalgebra-lapack/src/eigen.rs
index 0c2106ad..1d78d036 100644
--- a/nalgebra-lapack/src/eigen.rs
+++ b/nalgebra-lapack/src/eigen.rs
@@ -229,10 +229,10 @@ where
         None
     }
 
-    /// The complex eigenvalues of the given matrix.
+    /// The complex eigen decomposition of the given matrix.
     ///
     /// Panics if the eigenvalue computation does not converge.
-    pub fn complex_eigenvalues(mut m: OMatrix<T, D, D>, left_eigenvectors: bool, eigenvectors: bool) 
+    pub fn complex_eigen_decomposition(mut m: OMatrix<T, D, D>, left_eigenvectors: bool, eigenvectors: bool) 
         -> (OVector<Complex<T>, D>,  Option<OMatrix<T, D, D>>,  Option<OMatrix<T, D, D>>)
     where
         DefaultAllocator: Allocator<Complex<T>, D> + Allocator<Complex<T>, D, D>,

From c62801114b3c123ead9c9aba48a1905e9ed373d0 Mon Sep 17 00:00:00 2001
From: Marc Haubenstock <marc.dhaubenstock@gmail.com>
Date: Wed, 14 Sep 2022 18:15:16 +0200
Subject: [PATCH 012/119] fixed formatting

---
 nalgebra-lapack/src/eigen.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/nalgebra-lapack/src/eigen.rs b/nalgebra-lapack/src/eigen.rs
index 1d78d036..77c0f873 100644
--- a/nalgebra-lapack/src/eigen.rs
+++ b/nalgebra-lapack/src/eigen.rs
@@ -394,7 +394,6 @@ where
                 (res, None, None)
             }
         }
-
     }
 
     /// The determinant of the decomposed matrix.

From a0412c39f260adf146a52c2b44fc7d212f07be1d Mon Sep 17 00:00:00 2001
From: Marc Haubenstock <marc.dhaubenstock@gmail.com>
Date: Wed, 14 Sep 2022 19:07:38 +0200
Subject: [PATCH 013/119] formatting

---
 nalgebra-lapack/src/eigen.rs | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/nalgebra-lapack/src/eigen.rs b/nalgebra-lapack/src/eigen.rs
index 77c0f873..bab9de83 100644
--- a/nalgebra-lapack/src/eigen.rs
+++ b/nalgebra-lapack/src/eigen.rs
@@ -232,8 +232,15 @@ where
     /// The complex eigen decomposition of the given matrix.
     ///
     /// Panics if the eigenvalue computation does not converge.
-    pub fn complex_eigen_decomposition(mut m: OMatrix<T, D, D>, left_eigenvectors: bool, eigenvectors: bool) 
-        -> (OVector<Complex<T>, D>,  Option<OMatrix<T, D, D>>,  Option<OMatrix<T, D, D>>)
+    pub fn complex_eigen_decomposition(
+        mut m: OMatrix<T, D, D>,
+        left_eigenvectors: bool,
+        eigenvectors: bool,
+    ) -> (
+        OVector<Complex<T>, D>,
+        Option<OMatrix<T, D, D>>,
+        Option<OMatrix<T, D, D>>,
+    )
     where
         DefaultAllocator: Allocator<Complex<T>, D> + Allocator<Complex<T>, D, D>,
     {

From b37eeee636284c6d54e36a9ac3dea8780bb814a9 Mon Sep 17 00:00:00 2001
From: lukas <lukashermann28@gmail.com>
Date: Fri, 30 Sep 2022 19:49:47 -0700
Subject: [PATCH 014/119] add mutable triplet iter

---
 nalgebra-sparse/src/coo.rs | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/nalgebra-sparse/src/coo.rs b/nalgebra-sparse/src/coo.rs
index 25dc07fb..b71cb0b6 100644
--- a/nalgebra-sparse/src/coo.rs
+++ b/nalgebra-sparse/src/coo.rs
@@ -170,6 +170,16 @@ impl<T> CooMatrix<T> {
             .map(|((i, j), v)| (*i, *j, v))
     }
 
+    /// A mutable iterator over triplets (i, j, v).
+    // TODO: Consider giving the iterator a concrete type instead of impl trait...?
+    pub fn triplet_iter_mut(&mut self) -> impl Iterator<Item = (usize, usize, &mut T)> {
+        self.row_indices
+            .iter()
+            .zip(&self.col_indices)
+            .zip(self.values.iter_mut())
+            .map(|((i, j), v)| (*i, *j, v))
+    }
+
     /// Reserves capacity for COO matrix by at least `additional` elements.
     ///
     /// This increase the capacities of triplet holding arrays by reserving more space to avoid

From 9a38c554af63ac3dc147e6376c670a43afec18f4 Mon Sep 17 00:00:00 2001
From: lukas <lukashermann28@gmail.com>
Date: Sun, 2 Oct 2022 11:57:37 -0700
Subject: [PATCH 015/119] add test case

---
 nalgebra-sparse/tests/unit_tests/coo.rs | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/nalgebra-sparse/tests/unit_tests/coo.rs b/nalgebra-sparse/tests/unit_tests/coo.rs
index d232b041..fae0144a 100644
--- a/nalgebra-sparse/tests/unit_tests/coo.rs
+++ b/nalgebra-sparse/tests/unit_tests/coo.rs
@@ -87,6 +87,26 @@ fn coo_construction_for_valid_data() {
     }
 }
 
+#[test]
+fn coo_triplets_iter_mut() {
+    // Arbitrary matrix, with duplicates
+    let i = vec![0, 1, 0, 0, 0, 0, 2, 1];
+    let j = vec![0, 2, 0, 1, 0, 3, 3, 2];
+    let v = vec![2, 3, 4, 7, 1, 3, 1, 5];
+    let mut coo =
+        CooMatrix::<i32>::try_from_triplets(3, 5, i.clone(), j.clone(), v.clone()).unwrap();
+    coo.triplet_iter_mut().for_each(|(_i, _j, v)| *v = *v * *v);
+
+    let expected_triplets: Vec<_> = i
+        .iter()
+        .zip(&j)
+        .zip(&v)
+        .map(|((i, j), v)| (*i, *j, v * v))
+        .collect();
+    let actual_triplets: Vec<_> = coo.triplet_iter().map(|(i, j, v)| (i, j, *v)).collect();
+    assert_eq!(expected_triplets, actual_triplets)
+}
+
 #[test]
 fn coo_try_from_triplets_reports_out_of_bounds_indices() {
     {

From 3d52327f8298c1769a5b0a2e8e7a340a4d7cd46b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=A9bastien=20Crozet?= <developer@crozet.re>
Date: Sun, 9 Oct 2022 16:26:26 +0200
Subject: [PATCH 016/119] nalgebra-lapack: merge both Eigen decomposition
 function into a single one.

---
 nalgebra-lapack/src/eigen.rs | 336 +++++------------------------------
 1 file changed, 45 insertions(+), 291 deletions(-)

diff --git a/nalgebra-lapack/src/eigen.rs b/nalgebra-lapack/src/eigen.rs
index bab9de83..68b34b56 100644
--- a/nalgebra-lapack/src/eigen.rs
+++ b/nalgebra-lapack/src/eigen.rs
@@ -13,7 +13,7 @@ use na::{DefaultAllocator, Matrix, OMatrix, OVector, Scalar};
 
 use lapack;
 
-/// Eigendecomposition of a real square matrix with real eigenvalues.
+/// Eigendecomposition of a real square matrix with real or complex eigenvalues.
 #[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
 #[cfg_attr(
     feature = "serde-serialize",
@@ -36,8 +36,10 @@ pub struct Eigen<T: Scalar, D: Dim>
 where
     DefaultAllocator: Allocator<T, D> + Allocator<T, D, D>,
 {
-    /// The eigenvalues of the decomposed matrix.
-    pub eigenvalues: OVector<T, D>,
+    /// The real parts of eigenvalues of the decomposed matrix.
+    pub eigenvalues_re: OVector<T, D>,
+    /// The imaginary parts of the eigenvalues of the decomposed matrix.
+    pub eigenvalues_im: OVector<T, D>,
     /// The (right) eigenvectors of the decomposed matrix.
     pub eigenvectors: Option<OMatrix<T, D, D>>,
     /// The left eigenvectors of the decomposed matrix.
@@ -104,169 +106,27 @@ where
         lapack_check!(info);
 
         let mut work = vec![T::zero(); lwork as usize];
+        let mut vl = if left_eigenvectors {
+            Some(Matrix::zeros_generic(nrows, ncols))
+        } else {
+            None
+        };
+        let mut vr = if eigenvectors {
+            Some(Matrix::zeros_generic(nrows, ncols))
+        } else {
+            None
+        };
 
-        match (left_eigenvectors, eigenvectors) {
-            (true, true) => {
-                // TODO: avoid the initializations?
-                let mut vl = Matrix::zeros_generic(nrows, ncols);
-                let mut vr = Matrix::zeros_generic(nrows, ncols);
+        let vl_ref = vl
+            .as_mut()
+            .map(|m| m.as_mut_slice())
+            .unwrap_or(&mut placeholder1);
+        let vr_ref = vr
+            .as_mut()
+            .map(|m| m.as_mut_slice())
+            .unwrap_or(&mut placeholder2);
 
-                T::xgeev(
-                    ljob,
-                    rjob,
-                    n as i32,
-                    m.as_mut_slice(),
-                    lda,
-                    wr.as_mut_slice(),
-                    wi.as_mut_slice(),
-                    &mut vl.as_mut_slice(),
-                    n as i32,
-                    &mut vr.as_mut_slice(),
-                    n as i32,
-                    &mut work,
-                    lwork,
-                    &mut info,
-                );
-                lapack_check!(info);
-
-                if wi.iter().all(|e| e.is_zero()) {
-                    return Some(Self {
-                        eigenvalues: wr,
-                        left_eigenvectors: Some(vl),
-                        eigenvectors: Some(vr),
-                    });
-                }
-            }
-            (true, false) => {
-                // TODO: avoid the initialization?
-                let mut vl = Matrix::zeros_generic(nrows, ncols);
-
-                T::xgeev(
-                    ljob,
-                    rjob,
-                    n as i32,
-                    m.as_mut_slice(),
-                    lda,
-                    wr.as_mut_slice(),
-                    wi.as_mut_slice(),
-                    &mut vl.as_mut_slice(),
-                    n as i32,
-                    &mut placeholder2,
-                    1 as i32,
-                    &mut work,
-                    lwork,
-                    &mut info,
-                );
-                lapack_check!(info);
-
-                if wi.iter().all(|e| e.is_zero()) {
-                    return Some(Self {
-                        eigenvalues: wr,
-                        left_eigenvectors: Some(vl),
-                        eigenvectors: None,
-                    });
-                }
-            }
-            (false, true) => {
-                // TODO: avoid the initialization?
-                let mut vr = Matrix::zeros_generic(nrows, ncols);
-
-                T::xgeev(
-                    ljob,
-                    rjob,
-                    n as i32,
-                    m.as_mut_slice(),
-                    lda,
-                    wr.as_mut_slice(),
-                    wi.as_mut_slice(),
-                    &mut placeholder1,
-                    1 as i32,
-                    &mut vr.as_mut_slice(),
-                    n as i32,
-                    &mut work,
-                    lwork,
-                    &mut info,
-                );
-                lapack_check!(info);
-
-                if wi.iter().all(|e| e.is_zero()) {
-                    return Some(Self {
-                        eigenvalues: wr,
-                        left_eigenvectors: None,
-                        eigenvectors: Some(vr),
-                    });
-                }
-            }
-            (false, false) => {
-                T::xgeev(
-                    ljob,
-                    rjob,
-                    n as i32,
-                    m.as_mut_slice(),
-                    lda,
-                    wr.as_mut_slice(),
-                    wi.as_mut_slice(),
-                    &mut placeholder1,
-                    1 as i32,
-                    &mut placeholder2,
-                    1 as i32,
-                    &mut work,
-                    lwork,
-                    &mut info,
-                );
-                lapack_check!(info);
-
-                if wi.iter().all(|e| e.is_zero()) {
-                    return Some(Self {
-                        eigenvalues: wr,
-                        left_eigenvectors: None,
-                        eigenvectors: None,
-                    });
-                }
-            }
-        }
-
-        None
-    }
-
-    /// The complex eigen decomposition of the given matrix.
-    ///
-    /// Panics if the eigenvalue computation does not converge.
-    pub fn complex_eigen_decomposition(
-        mut m: OMatrix<T, D, D>,
-        left_eigenvectors: bool,
-        eigenvectors: bool,
-    ) -> (
-        OVector<Complex<T>, D>,
-        Option<OMatrix<T, D, D>>,
-        Option<OMatrix<T, D, D>>,
-    )
-    where
-        DefaultAllocator: Allocator<Complex<T>, D> + Allocator<Complex<T>, D, D>,
-    {
-        assert!(
-            m.is_square(),
-            "Unable to compute the eigenvalue decomposition of a non-square matrix."
-        );
-
-        let ljob = if left_eigenvectors { b'V' } else { b'N' };
-        let rjob = if eigenvectors { b'V' } else { b'N' };
-
-        let (nrows, ncols) = m.shape_generic();
-        let n = nrows.value();
-
-        let lda = n as i32;
-
-        // TODO: avoid the initialization?
-        let mut wr = Matrix::zeros_generic(nrows, Const::<1>);
-        // TODO: Tap into the workspace.
-        let mut wi = Matrix::zeros_generic(nrows, Const::<1>);
-
-        let mut info = 0;
-        let mut placeholder1 = [T::zero()];
-        let mut placeholder2 = [T::zero()];
-
-        let lwork = T::xgeev_work_size(
+        T::xgeev(
             ljob,
             rjob,
             n as i32,
@@ -274,142 +134,36 @@ where
             lda,
             wr.as_mut_slice(),
             wi.as_mut_slice(),
-            &mut placeholder1,
-            n as i32,
-            &mut placeholder2,
-            n as i32,
+            vl_ref,
+            if left_eigenvectors { n as i32 } else { 1 },
+            vr_ref,
+            if eigenvectors { n as i32 } else { 1 },
+            &mut work,
+            lwork,
             &mut info,
         );
+        lapack_check!(info);
 
-        lapack_panic!(info);
+        Some(Self {
+            eigenvalues_re: wr,
+            eigenvalues_im: wi,
+            left_eigenvectors: vl,
+            eigenvectors: vr,
+        })
+    }
 
-        let mut work = vec![T::zero(); lwork as usize];
-
-        match (left_eigenvectors, eigenvectors) {
-            (true, true) => {
-                // TODO: avoid the initializations?
-                let mut vl = Matrix::zeros_generic(nrows, ncols);
-                let mut vr = Matrix::zeros_generic(nrows, ncols);
-
-                T::xgeev(
-                    ljob,
-                    rjob,
-                    n as i32,
-                    m.as_mut_slice(),
-                    lda,
-                    wr.as_mut_slice(),
-                    wi.as_mut_slice(),
-                    &mut vl.as_mut_slice(),
-                    n as i32,
-                    &mut vr.as_mut_slice(),
-                    n as i32,
-                    &mut work,
-                    lwork,
-                    &mut info,
-                );
-                lapack_panic!(info);
-
-                let mut res = Matrix::zeros_generic(nrows, Const::<1>);
-
-                for i in 0..res.len() {
-                    res[i] = Complex::new(wr[i].clone(), wi[i].clone());
-                }
-                (res, Some(vl), Some(vr))
-            }
-            (true, false) => {
-                // TODO: avoid the initialization?
-                let mut vl = Matrix::zeros_generic(nrows, ncols);
-
-                T::xgeev(
-                    ljob,
-                    rjob,
-                    n as i32,
-                    m.as_mut_slice(),
-                    lda,
-                    wr.as_mut_slice(),
-                    wi.as_mut_slice(),
-                    &mut vl.as_mut_slice(),
-                    n as i32,
-                    &mut placeholder2,
-                    1 as i32,
-                    &mut work,
-                    lwork,
-                    &mut info,
-                );
-                lapack_panic!(info);
-
-                let mut res = Matrix::zeros_generic(nrows, Const::<1>);
-
-                for i in 0..res.len() {
-                    res[i] = Complex::new(wr[i].clone(), wi[i].clone());
-                }
-                (res, Some(vl), None)
-            }
-            (false, true) => {
-                // TODO: avoid the initialization?
-                let mut vr = Matrix::zeros_generic(nrows, ncols);
-
-                T::xgeev(
-                    ljob,
-                    rjob,
-                    n as i32,
-                    m.as_mut_slice(),
-                    lda,
-                    wr.as_mut_slice(),
-                    wi.as_mut_slice(),
-                    &mut placeholder1,
-                    1 as i32,
-                    &mut vr.as_mut_slice(),
-                    n as i32,
-                    &mut work,
-                    lwork,
-                    &mut info,
-                );
-                lapack_panic!(info);
-
-                let mut res = Matrix::zeros_generic(nrows, Const::<1>);
-
-                for i in 0..res.len() {
-                    res[i] = Complex::new(wr[i].clone(), wi[i].clone());
-                }
-                (res, None, Some(vr))
-            }
-            (false, false) => {
-                T::xgeev(
-                    ljob,
-                    rjob,
-                    n as i32,
-                    m.as_mut_slice(),
-                    lda,
-                    wr.as_mut_slice(),
-                    wi.as_mut_slice(),
-                    &mut placeholder1,
-                    1 as i32,
-                    &mut placeholder2,
-                    1 as i32,
-                    &mut work,
-                    lwork,
-                    &mut info,
-                );
-                lapack_panic!(info);
-
-                let mut res = Matrix::zeros_generic(nrows, Const::<1>);
-
-                for i in 0..res.len() {
-                    res[i] = Complex::new(wr[i].clone(), wi[i].clone());
-                }
-                (res, None, None)
-            }
-        }
+    /// Returns `true` if all the eigenvalues are real.
+    pub fn eigenvalues_are_real(&self) -> bool {
+        self.eigenvalues_im.iter().all(|e| e.is_zero())
     }
 
     /// The determinant of the decomposed matrix.
     #[inline]
     #[must_use]
-    pub fn determinant(&self) -> T {
-        let mut det = T::one();
-        for e in self.eigenvalues.iter() {
-            det *= e.clone();
+    pub fn determinant(&self) -> Complex<T> {
+        let mut det: Complex<T> = na::one();
+        for (re, im) in self.eigenvalues_re.iter().zip(self.eigenvalues_im.iter()) {
+            det *= Complex::new(re.clone(), im.clone());
         }
 
         det

From e227dd693e233cc2819277ffe0f0b252bdb84bf8 Mon Sep 17 00:00:00 2001
From: lukas <lukashermann28@gmail.com>
Date: Mon, 10 Oct 2022 19:05:47 -0700
Subject: [PATCH 017/119] Refactor unit tests

---
 nalgebra-sparse/tests/unit_tests/coo.rs | 22 ++++++++++++++++++----
 1 file changed, 18 insertions(+), 4 deletions(-)

diff --git a/nalgebra-sparse/tests/unit_tests/coo.rs b/nalgebra-sparse/tests/unit_tests/coo.rs
index fae0144a..8e46651f 100644
--- a/nalgebra-sparse/tests/unit_tests/coo.rs
+++ b/nalgebra-sparse/tests/unit_tests/coo.rs
@@ -95,16 +95,30 @@ fn coo_triplets_iter_mut() {
     let v = vec![2, 3, 4, 7, 1, 3, 1, 5];
     let mut coo =
         CooMatrix::<i32>::try_from_triplets(3, 5, i.clone(), j.clone(), v.clone()).unwrap();
-    coo.triplet_iter_mut().for_each(|(_i, _j, v)| *v = *v * *v);
+
+    let actual_triplets: Vec<_> = coo.triplet_iter_mut().map(|(i, j, v)| (i, j, *v)).collect();
 
     let expected_triplets: Vec<_> = i
         .iter()
         .zip(&j)
         .zip(&v)
-        .map(|((i, j), v)| (*i, *j, v * v))
+        .map(|((i, j), v)| (*i, *j, *v))
         .collect();
-    let actual_triplets: Vec<_> = coo.triplet_iter().map(|(i, j, v)| (i, j, *v)).collect();
-    assert_eq!(expected_triplets, actual_triplets)
+    assert_eq!(expected_triplets, actual_triplets);
+
+    for (_i, _j, v) in coo.triplet_iter_mut() {
+        *v += *v;
+    }
+
+    let actual_triplets: Vec<_> = coo.triplet_iter_mut().map(|(i, j, v)| (i, j, *v)).collect();
+    let v = vec![4, 6, 8, 14, 2, 6, 2, 10];
+    let expected_triplets: Vec<_> = i
+        .iter()
+        .zip(&j)
+        .zip(&v)
+        .map(|((i, j), v)| (*i, *j, *v))
+        .collect();
+    assert_eq!(expected_triplets, actual_triplets);
 }
 
 #[test]

From 2cbb27c6f83b36a997b19b3a100d08a7e4fb0d48 Mon Sep 17 00:00:00 2001
From: Peng Guanwen <pg999w@outlook.com>
Date: Thu, 15 Sep 2022 08:40:16 +0000
Subject: [PATCH 018/119] Derive CheckBytes trait on Archive struct

---
 src/base/array_storage.rs       |  5 ++++-
 src/base/dimension.rs           | 10 ++++++++--
 src/base/matrix.rs              |  5 ++++-
 src/base/unit.rs                |  5 ++++-
 src/geometry/dual_quaternion.rs |  5 ++++-
 src/geometry/isometry.rs        |  5 ++++-
 src/geometry/orthographic.rs    |  5 ++++-
 src/geometry/perspective.rs     |  5 ++++-
 src/geometry/point.rs           |  5 ++++-
 src/geometry/quaternion.rs      |  5 ++++-
 src/geometry/rotation.rs        |  5 ++++-
 src/geometry/scale.rs           |  5 ++++-
 src/geometry/similarity.rs      |  5 ++++-
 src/geometry/translation.rs     |  5 ++++-
 14 files changed, 60 insertions(+), 15 deletions(-)

diff --git a/src/base/array_storage.rs b/src/base/array_storage.rs
index 3bc71e1a..d155cba7 100644
--- a/src/base/array_storage.rs
+++ b/src/base/array_storage.rs
@@ -27,11 +27,14 @@ use std::mem;
 /// A array-based statically sized matrix data storage.
 #[repr(transparent)]
 #[derive(Copy, Clone, PartialEq, Eq, Hash)]
-#[cfg_attr(feature = "rkyv-serialize", derive(bytecheck::CheckBytes))]
 #[cfg_attr(
     feature = "rkyv-serialize-no-std",
     derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
 )]
+#[cfg_attr(
+    feature = "rkyv-serialize",
+    archive_attr(derive(bytecheck::CheckBytes))
+)]
 #[cfg_attr(feature = "cuda", derive(cust_core::DeviceCopy))]
 pub struct ArrayStorage<T, const R: usize, const C: usize>(pub [[T; R]; C]);
 
diff --git a/src/base/dimension.rs b/src/base/dimension.rs
index b1b700d7..06697618 100644
--- a/src/base/dimension.rs
+++ b/src/base/dimension.rs
@@ -13,11 +13,14 @@ use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 /// Dim of dynamically-sized algebraic entities.
 #[derive(Clone, Copy, Eq, PartialEq, Debug)]
-#[cfg_attr(feature = "rkyv-serialize", derive(bytecheck::CheckBytes))]
 #[cfg_attr(
     feature = "rkyv-serialize-no-std",
     derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
 )]
+#[cfg_attr(
+    feature = "rkyv-serialize",
+    archive_attr(derive(bytecheck::CheckBytes))
+)]
 #[cfg_attr(feature = "cuda", derive(cust_core::DeviceCopy))]
 pub struct Dynamic {
     value: usize,
@@ -207,7 +210,10 @@ dim_ops!(
     feature = "rkyv-serialize-no-std",
     derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
 )]
-#[cfg_attr(feature = "rkyv-serialize", derive(bytecheck::CheckBytes))]
+#[cfg_attr(
+    feature = "rkyv-serialize",
+    archive_attr(derive(bytecheck::CheckBytes))
+)]
 #[cfg_attr(feature = "cuda", derive(cust_core::DeviceCopy))]
 pub struct Const<const R: usize>;
 
diff --git a/src/base/matrix.rs b/src/base/matrix.rs
index d9294c9e..e9cc5258 100644
--- a/src/base/matrix.rs
+++ b/src/base/matrix.rs
@@ -150,11 +150,14 @@ pub type MatrixCross<T, R1, C1, R2, C2> =
 /// some concrete types for `T` and a compatible data storage type `S`).
 #[repr(C)]
 #[derive(Clone, Copy)]
-#[cfg_attr(feature = "rkyv-serialize", derive(bytecheck::CheckBytes))]
 #[cfg_attr(
     feature = "rkyv-serialize-no-std",
     derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
 )]
+#[cfg_attr(
+    feature = "rkyv-serialize",
+    archive_attr(derive(bytecheck::CheckBytes))
+)]
 #[cfg_attr(feature = "cuda", derive(cust_core::DeviceCopy))]
 pub struct Matrix<T, R, C, S> {
     /// The data storage that contains all the matrix components. Disappointed?
diff --git a/src/base/unit.rs b/src/base/unit.rs
index 6fc00092..1596b71a 100644
--- a/src/base/unit.rs
+++ b/src/base/unit.rs
@@ -21,11 +21,14 @@ use crate::{Dim, Matrix, OMatrix, RealField, Scalar, SimdComplexField, SimdRealF
 /// in their documentation, read their dedicated pages directly.
 #[repr(transparent)]
 #[derive(Clone, Hash, Copy)]
-#[cfg_attr(feature = "rkyv-serialize", derive(bytecheck::CheckBytes))]
 #[cfg_attr(
     feature = "rkyv-serialize-no-std",
     derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
 )]
+#[cfg_attr(
+    feature = "rkyv-serialize",
+    archive_attr(derive(bytecheck::CheckBytes))
+)]
 // #[cfg_attr(feature = "cuda", derive(cust_core::DeviceCopy))]
 pub struct Unit<T> {
     pub(crate) value: T,
diff --git a/src/geometry/dual_quaternion.rs b/src/geometry/dual_quaternion.rs
index 6f1b7053..3b283629 100644
--- a/src/geometry/dual_quaternion.rs
+++ b/src/geometry/dual_quaternion.rs
@@ -40,11 +40,14 @@ use simba::scalar::{ClosedNeg, RealField};
 ///  See <https://github.com/dimforge/nalgebra/issues/487>
 #[repr(C)]
 #[derive(Debug, Copy, Clone)]
-#[cfg_attr(feature = "rkyv-serialize", derive(bytecheck::CheckBytes))]
 #[cfg_attr(
     feature = "rkyv-serialize-no-std",
     derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
 )]
+#[cfg_attr(
+    feature = "rkyv-serialize",
+    archive_attr(derive(bytecheck::CheckBytes))
+)]
 #[cfg_attr(feature = "cuda", derive(cust_core::DeviceCopy))]
 pub struct DualQuaternion<T> {
     /// The real component of the quaternion
diff --git a/src/geometry/isometry.rs b/src/geometry/isometry.rs
index 92169742..d245c99b 100755
--- a/src/geometry/isometry.rs
+++ b/src/geometry/isometry.rs
@@ -70,7 +70,10 @@ use crate::geometry::{AbstractRotation, Point, Translation};
     feature = "rkyv-serialize-no-std",
     derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
 )]
-#[cfg_attr(feature = "rkyv-serialize", derive(bytecheck::CheckBytes))]
+#[cfg_attr(
+    feature = "rkyv-serialize",
+    archive_attr(derive(bytecheck::CheckBytes))
+)]
 pub struct Isometry<T, R, const D: usize> {
     /// The pure rotational part of this isometry.
     pub rotation: R,
diff --git a/src/geometry/orthographic.rs b/src/geometry/orthographic.rs
index 7348f676..ede7f587 100644
--- a/src/geometry/orthographic.rs
+++ b/src/geometry/orthographic.rs
@@ -19,11 +19,14 @@ use crate::geometry::{Point3, Projective3};
 
 /// A 3D orthographic projection stored as a homogeneous 4x4 matrix.
 #[repr(C)]
-#[cfg_attr(feature = "rkyv-serialize", derive(bytecheck::CheckBytes))]
 #[cfg_attr(
     feature = "rkyv-serialize-no-std",
     derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
 )]
+#[cfg_attr(
+    feature = "rkyv-serialize",
+    archive_attr(derive(bytecheck::CheckBytes))
+)]
 #[cfg_attr(feature = "cuda", derive(cust_core::DeviceCopy))]
 #[derive(Copy, Clone)]
 pub struct Orthographic3<T> {
diff --git a/src/geometry/perspective.rs b/src/geometry/perspective.rs
index 351960bb..de29747f 100644
--- a/src/geometry/perspective.rs
+++ b/src/geometry/perspective.rs
@@ -20,11 +20,14 @@ use crate::geometry::{Point3, Projective3};
 
 /// A 3D perspective projection stored as a homogeneous 4x4 matrix.
 #[repr(C)]
-#[cfg_attr(feature = "rkyv-serialize", derive(bytecheck::CheckBytes))]
 #[cfg_attr(
     feature = "rkyv-serialize-no-std",
     derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
 )]
+#[cfg_attr(
+    feature = "rkyv-serialize",
+    archive_attr(derive(bytecheck::CheckBytes))
+)]
 #[cfg_attr(feature = "cuda", derive(cust_core::DeviceCopy))]
 #[derive(Copy, Clone)]
 pub struct Perspective3<T> {
diff --git a/src/geometry/point.rs b/src/geometry/point.rs
index 306c18e5..e9a21439 100644
--- a/src/geometry/point.rs
+++ b/src/geometry/point.rs
@@ -40,7 +40,10 @@ use std::mem::MaybeUninit;
     feature = "rkyv-serialize-no-std",
     derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
 )]
-#[cfg_attr(feature = "rkyv-serialize", derive(bytecheck::CheckBytes))]
+#[cfg_attr(
+    feature = "rkyv-serialize",
+    archive_attr(derive(bytecheck::CheckBytes))
+)]
 pub struct OPoint<T: Scalar, D: DimName>
 where
     DefaultAllocator: Allocator<T, D>,
diff --git a/src/geometry/quaternion.rs b/src/geometry/quaternion.rs
index f38dca6f..53da24e3 100755
--- a/src/geometry/quaternion.rs
+++ b/src/geometry/quaternion.rs
@@ -23,11 +23,14 @@ use crate::geometry::{Point3, Rotation};
 /// that may be used as a rotation.
 #[repr(C)]
 #[derive(Copy, Clone)]
-#[cfg_attr(feature = "rkyv-serialize", derive(bytecheck::CheckBytes))]
 #[cfg_attr(
     feature = "rkyv-serialize-no-std",
     derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
 )]
+#[cfg_attr(
+    feature = "rkyv-serialize",
+    archive_attr(derive(bytecheck::CheckBytes))
+)]
 #[cfg_attr(feature = "cuda", derive(cust_core::DeviceCopy))]
 pub struct Quaternion<T> {
     /// This quaternion as a 4D vector of coordinates in the `[ x, y, z, w ]` storage order.
diff --git a/src/geometry/rotation.rs b/src/geometry/rotation.rs
index 2a8bf427..4a71da0f 100755
--- a/src/geometry/rotation.rs
+++ b/src/geometry/rotation.rs
@@ -49,11 +49,14 @@ use crate::geometry::Point;
 /// * [Conversion to a matrix <span style="float:right;">`matrix`, `to_homogeneous`…</span>](#conversion-to-a-matrix)
 ///
 #[repr(C)]
-#[cfg_attr(feature = "rkyv-serialize", derive(bytecheck::CheckBytes))]
 #[cfg_attr(
     feature = "rkyv-serialize-no-std",
     derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
 )]
+#[cfg_attr(
+    feature = "rkyv-serialize",
+    archive_attr(derive(bytecheck::CheckBytes))
+)]
 #[cfg_attr(feature = "cuda", derive(cust_core::DeviceCopy))]
 #[derive(Copy, Clone)]
 pub struct Rotation<T, const D: usize> {
diff --git a/src/geometry/scale.rs b/src/geometry/scale.rs
index 37da1ef0..e6c46e47 100755
--- a/src/geometry/scale.rs
+++ b/src/geometry/scale.rs
@@ -17,11 +17,14 @@ use crate::geometry::Point;
 
 /// A scale which supports non-uniform scaling.
 #[repr(C)]
-#[cfg_attr(feature = "rkyv-serialize", derive(bytecheck::CheckBytes))]
 #[cfg_attr(
     feature = "rkyv-serialize-no-std",
     derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
 )]
+#[cfg_attr(
+    feature = "rkyv-serialize",
+    archive_attr(derive(bytecheck::CheckBytes))
+)]
 #[cfg_attr(feature = "cuda", derive(cust_core::DeviceCopy))]
 #[derive(Copy, Clone)]
 pub struct Scale<T, const D: usize> {
diff --git a/src/geometry/similarity.rs b/src/geometry/similarity.rs
index 8c38ff1e..a827246e 100755
--- a/src/geometry/similarity.rs
+++ b/src/geometry/similarity.rs
@@ -38,7 +38,10 @@ use crate::geometry::{AbstractRotation, Isometry, Point, Translation};
     feature = "rkyv-serialize-no-std",
     derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
 )]
-#[cfg_attr(feature = "rkyv-serialize", derive(bytecheck::CheckBytes))]
+#[cfg_attr(
+    feature = "rkyv-serialize",
+    archive_attr(derive(bytecheck::CheckBytes))
+)]
 pub struct Similarity<T, R, const D: usize> {
     /// The part of this similarity that does not include the scaling factor.
     pub isometry: Isometry<T, R, D>,
diff --git a/src/geometry/translation.rs b/src/geometry/translation.rs
index bef66f68..7e10ac4c 100755
--- a/src/geometry/translation.rs
+++ b/src/geometry/translation.rs
@@ -17,11 +17,14 @@ use crate::geometry::Point;
 
 /// A translation.
 #[repr(C)]
-#[cfg_attr(feature = "rkyv-serialize", derive(bytecheck::CheckBytes))]
 #[cfg_attr(
     feature = "rkyv-serialize-no-std",
     derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
 )]
+#[cfg_attr(
+    feature = "rkyv-serialize",
+    archive_attr(derive(bytecheck::CheckBytes))
+)]
 #[cfg_attr(feature = "cuda", derive(cust_core::DeviceCopy))]
 #[derive(Copy, Clone)]
 pub struct Translation<T, const D: usize> {

From bc566d91bf5dd1082eca5cddfa6009dc80b9c41c Mon Sep 17 00:00:00 2001
From: Peng Guanwen <pg999w@outlook.com>
Date: Thu, 15 Sep 2022 09:35:21 +0000
Subject: [PATCH 019/119] Add test for rkyv

---
 .github/workflows/nalgebra-ci-build.yml |  2 +-
 Cargo.toml                              |  1 +
 tests/core/mod.rs                       |  2 ++
 tests/core/rkyv.rs                      | 44 +++++++++++++++++++++++++
 4 files changed, 48 insertions(+), 1 deletion(-)
 create mode 100644 tests/core/rkyv.rs

diff --git a/.github/workflows/nalgebra-ci-build.yml b/.github/workflows/nalgebra-ci-build.yml
index c00b6cbc..d1a6c923 100644
--- a/.github/workflows/nalgebra-ci-build.yml
+++ b/.github/workflows/nalgebra-ci-build.yml
@@ -61,7 +61,7 @@ jobs:
     steps:
       - uses: actions/checkout@v2
       - name: test
-        run: cargo test --features arbitrary,rand,serde-serialize,sparse,debug,io,compare,libm,proptest-support,slow-tests;
+        run: cargo test --features arbitrary,rand,serde-serialize,sparse,debug,io,compare,libm,proptest-support,slow-tests,rkyv-safe-deser;
   test-nalgebra-glm:
     runs-on: ubuntu-latest
     steps:
diff --git a/Cargo.toml b/Cargo.toml
index 89de73e5..4bd1e12f 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -66,6 +66,7 @@ rand        = [ "rand-no-std", "rand-package/std", "rand-package/std_rng", "rand
 arbitrary        = [ "quickcheck" ]
 proptest-support = [ "proptest" ]
 slow-tests       = []
+rkyv-safe-deser  = [ "rkyv-serialize", "rkyv/validation" ]
 
 [dependencies]
 nalgebra-macros = { version = "0.1", path = "nalgebra-macros", optional = true }
diff --git a/tests/core/mod.rs b/tests/core/mod.rs
index 5fb8c82b..3c968a5d 100644
--- a/tests/core/mod.rs
+++ b/tests/core/mod.rs
@@ -8,6 +8,8 @@ mod matrix_slice;
 #[cfg(feature = "mint")]
 mod mint;
 mod serde;
+#[cfg(feature = "rkyv-serialize-no-std")]
+mod rkyv;
 
 #[cfg(feature = "compare")]
 mod matrixcompare;
diff --git a/tests/core/rkyv.rs b/tests/core/rkyv.rs
new file mode 100644
index 00000000..b89f5211
--- /dev/null
+++ b/tests/core/rkyv.rs
@@ -0,0 +1,44 @@
+use na::{
+    Isometry3, IsometryMatrix2, IsometryMatrix3, Matrix3x4, Point2, Point3, Quaternion, Rotation2,
+    Rotation3, Similarity3, SimilarityMatrix2, SimilarityMatrix3, Translation2, Translation3,
+};
+use rkyv::ser::{serializers::AllocSerializer, Serializer};
+
+macro_rules! test_rkyv(
+    ($($test: ident, $ty: ident);* $(;)*) => {$(
+        #[test]
+        fn $test() {
+            let v: $ty<f32> = rand::random();
+            // serialize
+            let mut serializer = AllocSerializer::<0>::default();
+            serializer.serialize_value(&v).unwrap();
+            let serialized = serializer.into_serializer().into_inner();
+
+            let deserialized: $ty<f32> = unsafe { rkyv::from_bytes_unchecked(&serialized).unwrap() };
+            assert_eq!(v, deserialized);
+
+            #[cfg(feature = "rkyv-safe-deser")]
+            {
+                let deserialized: $ty<f32> = rkyv::from_bytes(&serialized).unwrap();
+                assert_eq!(v, deserialized);
+            }
+        }
+    )*}
+);
+
+test_rkyv!(
+    rkyv_matrix3x4,          Matrix3x4;
+    rkyv_point3,             Point3;
+    rkyv_translation3,       Translation3;
+    rkyv_rotation3,          Rotation3;
+    rkyv_isometry3,          Isometry3;
+    rkyv_isometry_matrix3,   IsometryMatrix3;
+    rkyv_similarity3,        Similarity3;
+    rkyv_similarity_matrix3, SimilarityMatrix3;
+    rkyv_quaternion,         Quaternion;
+    rkyv_point2,             Point2;
+    rkyv_translation2,       Translation2;
+    rkyv_rotation2,          Rotation2;
+    rkyv_isometry_matrix2,   IsometryMatrix2;
+    rkyv_similarity_matrix2, SimilarityMatrix2;
+);

From f485806782283b9d5568598f7c363a95be64dac7 Mon Sep 17 00:00:00 2001
From: Peng Guanwen <pg999w@outlook.com>
Date: Fri, 16 Sep 2022 08:06:44 +0000
Subject: [PATCH 020/119] rustfmt

---
 tests/core/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/core/mod.rs b/tests/core/mod.rs
index 3c968a5d..acdcd236 100644
--- a/tests/core/mod.rs
+++ b/tests/core/mod.rs
@@ -7,9 +7,9 @@ mod matrix;
 mod matrix_slice;
 #[cfg(feature = "mint")]
 mod mint;
-mod serde;
 #[cfg(feature = "rkyv-serialize-no-std")]
 mod rkyv;
+mod serde;
 
 #[cfg(feature = "compare")]
 mod matrixcompare;

From c596e4985d5b6dee193c0e68a3d60baf6bf71ec5 Mon Sep 17 00:00:00 2001
From: David Stansby <dstansby@gmail.com>
Date: Fri, 14 Oct 2022 13:52:56 +0100
Subject: [PATCH 021/119] Make CSR/CSC matrix examples more self contained

---
 nalgebra-sparse/src/csc.rs | 6 ++++--
 nalgebra-sparse/src/csr.rs | 6 ++++--
 2 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/nalgebra-sparse/src/csc.rs b/nalgebra-sparse/src/csc.rs
index d926dafb..0cd89f5c 100644
--- a/nalgebra-sparse/src/csc.rs
+++ b/nalgebra-sparse/src/csc.rs
@@ -24,6 +24,7 @@ use std::slice::{Iter, IterMut};
 /// # Usage
 ///
 /// ```
+/// use nalgebra_sparse::coo::CooMatrix;
 /// use nalgebra_sparse::csc::CscMatrix;
 /// use nalgebra::{DMatrix, Matrix3x4};
 /// use matrixcompare::assert_matrix_eq;
@@ -32,8 +33,9 @@ use std::slice::{Iter, IterMut};
 /// // change the sparsity pattern of the matrix after it has been constructed. The easiest
 /// // way to construct a CSC matrix is to first incrementally construct a COO matrix,
 /// // and then convert it to CSC.
-/// # use nalgebra_sparse::coo::CooMatrix;
-/// # let coo = CooMatrix::<f64>::new(3, 3);
+///
+/// let mut coo = CooMatrix::<f64>::new(3, 3);
+/// coo.push(2, 0, 1.0);
 /// let csc = CscMatrix::from(&coo);
 ///
 /// // Alternatively, a CSC matrix can be constructed directly from raw CSC data.
diff --git a/nalgebra-sparse/src/csr.rs b/nalgebra-sparse/src/csr.rs
index 90be35f1..255e8404 100644
--- a/nalgebra-sparse/src/csr.rs
+++ b/nalgebra-sparse/src/csr.rs
@@ -25,6 +25,7 @@ use std::slice::{Iter, IterMut};
 /// # Usage
 ///
 /// ```
+/// use nalgebra_sparse::coo::CooMatrix;
 /// use nalgebra_sparse::csr::CsrMatrix;
 /// use nalgebra::{DMatrix, Matrix3x4};
 /// use matrixcompare::assert_matrix_eq;
@@ -33,8 +34,9 @@ use std::slice::{Iter, IterMut};
 /// // change the sparsity pattern of the matrix after it has been constructed. The easiest
 /// // way to construct a CSR matrix is to first incrementally construct a COO matrix,
 /// // and then convert it to CSR.
-/// # use nalgebra_sparse::coo::CooMatrix;
-/// # let coo = CooMatrix::<f64>::new(3, 3);
+///
+/// let mut coo = CooMatrix::<f64>::new(3, 3);
+/// coo.push(2, 0, 1.0);
 /// let csr = CsrMatrix::from(&coo);
 ///
 /// // Alternatively, a CSR matrix can be constructed directly from raw CSR data.

From d61f9e29ba1e4dd6a70dc26c9606af2f81350db4 Mon Sep 17 00:00:00 2001
From: Marc Haubenstock <marc.dhaubenstock@gmail.com>
Date: Sat, 15 Oct 2022 16:49:13 +0200
Subject: [PATCH 022/119] working on issue 1106

---
 nalgebra-lapack/src/eigen.rs | 65 +++++++++++++++++++++++++++++++++---
 1 file changed, 61 insertions(+), 4 deletions(-)

diff --git a/nalgebra-lapack/src/eigen.rs b/nalgebra-lapack/src/eigen.rs
index 68b34b56..d6dc90d0 100644
--- a/nalgebra-lapack/src/eigen.rs
+++ b/nalgebra-lapack/src/eigen.rs
@@ -7,9 +7,8 @@ use num_complex::Complex;
 use simba::scalar::RealField;
 
 use crate::ComplexHelper;
-use na::allocator::Allocator;
-use na::dimension::{Const, Dim};
-use na::{DefaultAllocator, Matrix, OMatrix, OVector, Scalar};
+use na::dimension::{Const, Dim, DimName};
+use na::{DefaultAllocator, Matrix, OMatrix, OVector, Scalar, allocator::Allocator};
 
 use lapack;
 
@@ -148,7 +147,7 @@ where
             eigenvalues_re: wr,
             eigenvalues_im: wi,
             left_eigenvectors: vl,
-            eigenvectors: vr,
+            eigenvectors: vr
         })
     }
 
@@ -168,6 +167,64 @@ where
 
         det
     }
+
+    /// Returns a tuple of vectors. The elements of the tuple are the complex eigenvalues, complex left eigenvectors and complex right eigenvectors respectively. 
+    /// The elements appear as conjugate pairs within each vector, with the positive of the pair always being first.
+    pub fn get_complex_elements(&self) -> (Option<Vec<Complex<T>>>, Option<Vec<OVector<Complex<T>, D>>>, Option<Vec<OVector<Complex<T>, D>>>) where DefaultAllocator: Allocator<Complex<T>, D> {
+        match !self.eigenvalues_are_real() {
+            true => (None, None, None),
+            false => {
+                let number_of_elements = self.eigenvalues_re.nrows();
+                let number_of_complex_entries = self.eigenvalues_im.iter().fold(0, |acc, e| if !e.is_zero() {acc + 1} else {acc});
+                let mut eigenvalues = Vec::<Complex<T>>::with_capacity(2*number_of_complex_entries);
+                let mut eigenvectors = match self.eigenvectors.is_some() {
+                    true => Some(Vec::<OVector<Complex<T>, D>>::with_capacity(2*number_of_complex_entries)),
+                    false => None
+                };
+                let mut left_eigenvectors = match self.left_eigenvectors.is_some() {
+                    true => Some(Vec::<OVector<Complex<T>, D>>::with_capacity(2*number_of_complex_entries)),
+                    false => None
+                };
+
+                let eigenvectors_raw = self.eigenvectors;
+                let left_eigenvectors_raw = self.left_eigenvectors;
+
+                for mut i in 0..number_of_elements {
+                    if self.eigenvalues_im[i] != T::zero() {
+                        //Complex conjugate pairs of eigenvalues appear consecutively with the eigenvalue having the positive imaginary part first.
+                        eigenvalues.push(Complex::<T>::new(self.eigenvalues_re[i].clone(), self.eigenvalues_im[i].clone()));
+                        eigenvalues.push(Complex::<T>::new(self.eigenvalues_re[i].clone(), -self.eigenvalues_im[i].clone()));
+
+                        if eigenvectors.is_some() {
+                            let mut r1_vec = OVector::<Complex<T>, D>::zeros(number_of_elements);
+                            let mut r1_vec_conj = OVector::<Complex<T>, D>::zeros(number_of_elements);
+
+                            for j in 0..number_of_elements {
+                                r1_vec[j] = Complex::<T>::new(self.eigenvectors.unwrap()[(i,j)].clone(),self.eigenvectors.unwrap()[(i,j+1)].clone());
+                                r1_vec_conj[j] = Complex::<T>::new(self.eigenvectors.unwrap()[(i,j)].clone(),-self.eigenvectors.unwrap()[(i,j+1)].clone());
+                            }
+    
+                            eigenvectors.unwrap().push(r1_vec);
+                            eigenvectors.unwrap().push(r1_vec_conj);
+                        }
+
+
+                        if left_eigenvectors.is_some() {
+                            //TODO: Do the same for left
+                        }
+
+
+                        i += 1;
+                    }
+                    
+                }
+                (Some(eigenvalues), left_eigenvectors, eigenvectors)
+            }
+        }
+
+
+    }
+
 }
 
 /*

From b732b75a774b2c51b97b9b0a1df192de8208b809 Mon Sep 17 00:00:00 2001
From: Marc Haubenstock <marc.dhaubenstock@gmail.com>
Date: Sat, 15 Oct 2022 19:10:31 +0200
Subject: [PATCH 023/119] added panic so that the code compiles

---
 nalgebra-lapack/src/eigen.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/nalgebra-lapack/src/eigen.rs b/nalgebra-lapack/src/eigen.rs
index d6dc90d0..0448679c 100644
--- a/nalgebra-lapack/src/eigen.rs
+++ b/nalgebra-lapack/src/eigen.rs
@@ -171,6 +171,7 @@ where
     /// Returns a tuple of vectors. The elements of the tuple are the complex eigenvalues, complex left eigenvectors and complex right eigenvectors respectively. 
     /// The elements appear as conjugate pairs within each vector, with the positive of the pair always being first.
     pub fn get_complex_elements(&self) -> (Option<Vec<Complex<T>>>, Option<Vec<OVector<Complex<T>, D>>>, Option<Vec<OVector<Complex<T>, D>>>) where DefaultAllocator: Allocator<Complex<T>, D> {
+        panic!("TODO");
         match !self.eigenvalues_are_real() {
             true => (None, None, None),
             false => {

From 8ee68afaacfdbe5016727968a1a8e2212e0f4ed6 Mon Sep 17 00:00:00 2001
From: Marc Haubenstock <marc.dhaubenstock@gmail.com>
Date: Sat, 15 Oct 2022 19:17:05 +0200
Subject: [PATCH 024/119] commented out so that code compiles

---
 nalgebra-lapack/src/eigen.rs | 80 ++++++++++++++++++------------------
 1 file changed, 40 insertions(+), 40 deletions(-)

diff --git a/nalgebra-lapack/src/eigen.rs b/nalgebra-lapack/src/eigen.rs
index 0448679c..d81468ef 100644
--- a/nalgebra-lapack/src/eigen.rs
+++ b/nalgebra-lapack/src/eigen.rs
@@ -172,56 +172,56 @@ where
     /// The elements appear as conjugate pairs within each vector, with the positive of the pair always being first.
     pub fn get_complex_elements(&self) -> (Option<Vec<Complex<T>>>, Option<Vec<OVector<Complex<T>, D>>>, Option<Vec<OVector<Complex<T>, D>>>) where DefaultAllocator: Allocator<Complex<T>, D> {
         panic!("TODO");
-        match !self.eigenvalues_are_real() {
-            true => (None, None, None),
-            false => {
-                let number_of_elements = self.eigenvalues_re.nrows();
-                let number_of_complex_entries = self.eigenvalues_im.iter().fold(0, |acc, e| if !e.is_zero() {acc + 1} else {acc});
-                let mut eigenvalues = Vec::<Complex<T>>::with_capacity(2*number_of_complex_entries);
-                let mut eigenvectors = match self.eigenvectors.is_some() {
-                    true => Some(Vec::<OVector<Complex<T>, D>>::with_capacity(2*number_of_complex_entries)),
-                    false => None
-                };
-                let mut left_eigenvectors = match self.left_eigenvectors.is_some() {
-                    true => Some(Vec::<OVector<Complex<T>, D>>::with_capacity(2*number_of_complex_entries)),
-                    false => None
-                };
+        // match !self.eigenvalues_are_real() {
+        //     true => (None, None, None),
+        //     false => {
+        //         let number_of_elements = self.eigenvalues_re.nrows();
+        //         let number_of_complex_entries = self.eigenvalues_im.iter().fold(0, |acc, e| if !e.is_zero() {acc + 1} else {acc});
+        //         let mut eigenvalues = Vec::<Complex<T>>::with_capacity(2*number_of_complex_entries);
+        //         let mut eigenvectors = match self.eigenvectors.is_some() {
+        //             true => Some(Vec::<OVector<Complex<T>, D>>::with_capacity(2*number_of_complex_entries)),
+        //             false => None
+        //         };
+        //         let mut left_eigenvectors = match self.left_eigenvectors.is_some() {
+        //             true => Some(Vec::<OVector<Complex<T>, D>>::with_capacity(2*number_of_complex_entries)),
+        //             false => None
+        //         };
 
-                let eigenvectors_raw = self.eigenvectors;
-                let left_eigenvectors_raw = self.left_eigenvectors;
+        //         let eigenvectors_raw = self.eigenvectors;
+        //         let left_eigenvectors_raw = self.left_eigenvectors;
 
-                for mut i in 0..number_of_elements {
-                    if self.eigenvalues_im[i] != T::zero() {
-                        //Complex conjugate pairs of eigenvalues appear consecutively with the eigenvalue having the positive imaginary part first.
-                        eigenvalues.push(Complex::<T>::new(self.eigenvalues_re[i].clone(), self.eigenvalues_im[i].clone()));
-                        eigenvalues.push(Complex::<T>::new(self.eigenvalues_re[i].clone(), -self.eigenvalues_im[i].clone()));
+        //         for mut i in 0..number_of_elements {
+        //             if self.eigenvalues_im[i] != T::zero() {
+        //                 //Complex conjugate pairs of eigenvalues appear consecutively with the eigenvalue having the positive imaginary part first.
+        //                 eigenvalues.push(Complex::<T>::new(self.eigenvalues_re[i].clone(), self.eigenvalues_im[i].clone()));
+        //                 eigenvalues.push(Complex::<T>::new(self.eigenvalues_re[i].clone(), -self.eigenvalues_im[i].clone()));
 
-                        if eigenvectors.is_some() {
-                            let mut r1_vec = OVector::<Complex<T>, D>::zeros(number_of_elements);
-                            let mut r1_vec_conj = OVector::<Complex<T>, D>::zeros(number_of_elements);
+        //                 if eigenvectors.is_some() {
+        //                     let mut r1_vec = OVector::<Complex<T>, D>::zeros(number_of_elements);
+        //                     let mut r1_vec_conj = OVector::<Complex<T>, D>::zeros(number_of_elements);
 
-                            for j in 0..number_of_elements {
-                                r1_vec[j] = Complex::<T>::new(self.eigenvectors.unwrap()[(i,j)].clone(),self.eigenvectors.unwrap()[(i,j+1)].clone());
-                                r1_vec_conj[j] = Complex::<T>::new(self.eigenvectors.unwrap()[(i,j)].clone(),-self.eigenvectors.unwrap()[(i,j+1)].clone());
-                            }
+        //                     for j in 0..number_of_elements {
+        //                         r1_vec[j] = Complex::<T>::new(self.eigenvectors.unwrap()[(i,j)].clone(),self.eigenvectors.unwrap()[(i,j+1)].clone());
+        //                         r1_vec_conj[j] = Complex::<T>::new(self.eigenvectors.unwrap()[(i,j)].clone(),-self.eigenvectors.unwrap()[(i,j+1)].clone());
+        //                     }
     
-                            eigenvectors.unwrap().push(r1_vec);
-                            eigenvectors.unwrap().push(r1_vec_conj);
-                        }
+        //                     eigenvectors.unwrap().push(r1_vec);
+        //                     eigenvectors.unwrap().push(r1_vec_conj);
+        //                 }
 
 
-                        if left_eigenvectors.is_some() {
-                            //TODO: Do the same for left
-                        }
+        //                 if left_eigenvectors.is_some() {
+        //                     //TODO: Do the same for left
+        //                 }
 
 
-                        i += 1;
-                    }
+        //                 i += 1;
+        //             }
                     
-                }
-                (Some(eigenvalues), left_eigenvectors, eigenvectors)
-            }
-        }
+        //         }
+        //         (Some(eigenvalues), left_eigenvectors, eigenvectors)
+        //     }
+        // }
 
 
     }

From ee3f84abba0fdb027401d0e747f7accf41f2af23 Mon Sep 17 00:00:00 2001
From: Marc Haubenstock <marc.dhaubenstock@gmail.com>
Date: Sun, 16 Oct 2022 11:52:32 +0200
Subject: [PATCH 025/119] first version

---
 nalgebra-lapack/src/eigen.rs | 98 ++++++++++++++++++------------------
 1 file changed, 50 insertions(+), 48 deletions(-)

diff --git a/nalgebra-lapack/src/eigen.rs b/nalgebra-lapack/src/eigen.rs
index d81468ef..c49c6dd3 100644
--- a/nalgebra-lapack/src/eigen.rs
+++ b/nalgebra-lapack/src/eigen.rs
@@ -31,7 +31,7 @@ use lapack;
     )
 )]
 #[derive(Clone, Debug)]
-pub struct Eigen<T: Scalar, D: Dim>
+pub struct Eigen<T: Scalar, D: DimName>
 where
     DefaultAllocator: Allocator<T, D> + Allocator<T, D, D>,
 {
@@ -45,7 +45,7 @@ where
     pub left_eigenvectors: Option<OMatrix<T, D, D>>,
 }
 
-impl<T: Scalar + Copy, D: Dim> Copy for Eigen<T, D>
+impl<T: Scalar + Copy, D: DimName> Copy for Eigen<T, D>
 where
     DefaultAllocator: Allocator<T, D> + Allocator<T, D, D>,
     OVector<T, D>: Copy,
@@ -53,7 +53,7 @@ where
 {
 }
 
-impl<T: EigenScalar + RealField, D: Dim> Eigen<T, D>
+impl<T: EigenScalar + RealField, D: DimName> Eigen<T, D>
 where
     DefaultAllocator: Allocator<T, D, D> + Allocator<T, D>,
 {
@@ -171,57 +171,59 @@ where
     /// Returns a tuple of vectors. The elements of the tuple are the complex eigenvalues, complex left eigenvectors and complex right eigenvectors respectively. 
     /// The elements appear as conjugate pairs within each vector, with the positive of the pair always being first.
     pub fn get_complex_elements(&self) -> (Option<Vec<Complex<T>>>, Option<Vec<OVector<Complex<T>, D>>>, Option<Vec<OVector<Complex<T>, D>>>) where DefaultAllocator: Allocator<Complex<T>, D> {
-        panic!("TODO");
-        // match !self.eigenvalues_are_real() {
-        //     true => (None, None, None),
-        //     false => {
-        //         let number_of_elements = self.eigenvalues_re.nrows();
-        //         let number_of_complex_entries = self.eigenvalues_im.iter().fold(0, |acc, e| if !e.is_zero() {acc + 1} else {acc});
-        //         let mut eigenvalues = Vec::<Complex<T>>::with_capacity(2*number_of_complex_entries);
-        //         let mut eigenvectors = match self.eigenvectors.is_some() {
-        //             true => Some(Vec::<OVector<Complex<T>, D>>::with_capacity(2*number_of_complex_entries)),
-        //             false => None
-        //         };
-        //         let mut left_eigenvectors = match self.left_eigenvectors.is_some() {
-        //             true => Some(Vec::<OVector<Complex<T>, D>>::with_capacity(2*number_of_complex_entries)),
-        //             false => None
-        //         };
+        match !self.eigenvalues_are_real() {
+            true => (None, None, None),
+            false => {
+                let number_of_elements = self.eigenvalues_re.nrows();
+                let number_of_complex_entries = self.eigenvalues_im.iter().fold(0, |acc, e| if !e.is_zero() {acc + 1} else {acc});
+                let mut eigenvalues = Vec::<Complex<T>>::with_capacity(2*number_of_complex_entries);
+                let mut eigenvectors = match self.eigenvectors.is_some() {
+                    true => Some(Vec::<OVector<Complex<T>, D>>::with_capacity(2*number_of_complex_entries)),
+                    false => None
+                };
+                let mut left_eigenvectors = match self.left_eigenvectors.is_some() {
+                    true => Some(Vec::<OVector<Complex<T>, D>>::with_capacity(2*number_of_complex_entries)),
+                    false => None
+                };
 
-        //         let eigenvectors_raw = self.eigenvectors;
-        //         let left_eigenvectors_raw = self.left_eigenvectors;
+                for mut c in 0..number_of_elements {
+                    if self.eigenvalues_im[c] != T::zero() {
+                        //Complex conjugate pairs of eigenvalues appear consecutively with the eigenvalue having the positive imaginary part first.
+                        eigenvalues.push(Complex::<T>::new(self.eigenvalues_re[c].clone(), self.eigenvalues_im[c].clone()));
+                        eigenvalues.push(Complex::<T>::new(self.eigenvalues_re[c].clone(), -self.eigenvalues_im[c].clone()));
 
-        //         for mut i in 0..number_of_elements {
-        //             if self.eigenvalues_im[i] != T::zero() {
-        //                 //Complex conjugate pairs of eigenvalues appear consecutively with the eigenvalue having the positive imaginary part first.
-        //                 eigenvalues.push(Complex::<T>::new(self.eigenvalues_re[i].clone(), self.eigenvalues_im[i].clone()));
-        //                 eigenvalues.push(Complex::<T>::new(self.eigenvalues_re[i].clone(), -self.eigenvalues_im[i].clone()));
+                        if eigenvectors.is_some() {
+                            let mut vec = OVector::<Complex<T>, D>::zeros();
+                            let mut vec_conj = OVector::<Complex<T>, D>::zeros();
 
-        //                 if eigenvectors.is_some() {
-        //                     let mut r1_vec = OVector::<Complex<T>, D>::zeros(number_of_elements);
-        //                     let mut r1_vec_conj = OVector::<Complex<T>, D>::zeros(number_of_elements);
-
-        //                     for j in 0..number_of_elements {
-        //                         r1_vec[j] = Complex::<T>::new(self.eigenvectors.unwrap()[(i,j)].clone(),self.eigenvectors.unwrap()[(i,j+1)].clone());
-        //                         r1_vec_conj[j] = Complex::<T>::new(self.eigenvectors.unwrap()[(i,j)].clone(),-self.eigenvectors.unwrap()[(i,j+1)].clone());
-        //                     }
+                            for r in 0..number_of_elements {
+                                vec[r] = Complex::<T>::new((&self.eigenvectors.as_ref()).unwrap()[(r,c)].clone(),(&self.eigenvectors.as_ref()).unwrap()[(r,c+1)].clone());
+                                vec_conj[r] = Complex::<T>::new((&self.eigenvectors.as_ref()).unwrap()[(r,c)].clone(),-(&self.eigenvectors.as_ref()).unwrap()[(r,c+1)].clone());
+                            }
     
-        //                     eigenvectors.unwrap().push(r1_vec);
-        //                     eigenvectors.unwrap().push(r1_vec_conj);
-        //                 }
+                            eigenvectors.as_mut().unwrap().push(vec);
+                            eigenvectors.as_mut().unwrap().push(vec_conj);
+                        }
 
+                        if left_eigenvectors.is_some() {
+                            let mut vec = OVector::<Complex<T>, D>::zeros();
+                            let mut vec_conj = OVector::<Complex<T>, D>::zeros();
 
-        //                 if left_eigenvectors.is_some() {
-        //                     //TODO: Do the same for left
-        //                 }
-
-
-        //                 i += 1;
-        //             }
-                    
-        //         }
-        //         (Some(eigenvalues), left_eigenvectors, eigenvectors)
-        //     }
-        // }
+                            for r in 0..number_of_elements {
+                                vec[r] = Complex::<T>::new((&self.left_eigenvectors.as_ref()).unwrap()[(r,c)].clone(),(&self.left_eigenvectors.as_ref()).unwrap()[(r,c+1)].clone());
+                                vec_conj[r] = Complex::<T>::new((&self.left_eigenvectors.as_ref()).unwrap()[(r,c)].clone(),-(&self.left_eigenvectors.as_ref()).unwrap()[(r,c+1)].clone());
+                            }
+    
+                            left_eigenvectors.as_mut().unwrap().push(vec);
+                            left_eigenvectors.as_mut().unwrap().push(vec_conj);
+                        }
+                        //skip next entry
+                        c += 1;
+                    }
+                }
+                (Some(eigenvalues), left_eigenvectors, eigenvectors)
+            }
+        }
 
 
     }

From 01c5b9ea564d7b5be6c061423c659df9711b550f Mon Sep 17 00:00:00 2001
From: Marc Haubenstock <marc.dhaubenstock@gmail.com>
Date: Sun, 16 Oct 2022 11:55:07 +0200
Subject: [PATCH 026/119] switch back to Dim + zero_generic

---
 nalgebra-lapack/src/eigen.rs | 25 +++++++++++++------------
 1 file changed, 13 insertions(+), 12 deletions(-)

diff --git a/nalgebra-lapack/src/eigen.rs b/nalgebra-lapack/src/eigen.rs
index c49c6dd3..7048ee35 100644
--- a/nalgebra-lapack/src/eigen.rs
+++ b/nalgebra-lapack/src/eigen.rs
@@ -7,7 +7,7 @@ use num_complex::Complex;
 use simba::scalar::RealField;
 
 use crate::ComplexHelper;
-use na::dimension::{Const, Dim, DimName};
+use na::dimension::{Const, Dim};
 use na::{DefaultAllocator, Matrix, OMatrix, OVector, Scalar, allocator::Allocator};
 
 use lapack;
@@ -31,7 +31,7 @@ use lapack;
     )
 )]
 #[derive(Clone, Debug)]
-pub struct Eigen<T: Scalar, D: DimName>
+pub struct Eigen<T: Scalar, D: Dim>
 where
     DefaultAllocator: Allocator<T, D> + Allocator<T, D, D>,
 {
@@ -45,7 +45,7 @@ where
     pub left_eigenvectors: Option<OMatrix<T, D, D>>,
 }
 
-impl<T: Scalar + Copy, D: DimName> Copy for Eigen<T, D>
+impl<T: Scalar + Copy, D: Dim> Copy for Eigen<T, D>
 where
     DefaultAllocator: Allocator<T, D> + Allocator<T, D, D>,
     OVector<T, D>: Copy,
@@ -53,7 +53,7 @@ where
 {
 }
 
-impl<T: EigenScalar + RealField, D: DimName> Eigen<T, D>
+impl<T: EigenScalar + RealField, D: Dim> Eigen<T, D>
 where
     DefaultAllocator: Allocator<T, D, D> + Allocator<T, D>,
 {
@@ -174,7 +174,8 @@ where
         match !self.eigenvalues_are_real() {
             true => (None, None, None),
             false => {
-                let number_of_elements = self.eigenvalues_re.nrows();
+                let (number_of_elements, _) = self.eigenvalues_re.shape_generic();
+                let number_of_elements_value = number_of_elements.value();
                 let number_of_complex_entries = self.eigenvalues_im.iter().fold(0, |acc, e| if !e.is_zero() {acc + 1} else {acc});
                 let mut eigenvalues = Vec::<Complex<T>>::with_capacity(2*number_of_complex_entries);
                 let mut eigenvectors = match self.eigenvectors.is_some() {
@@ -186,17 +187,17 @@ where
                     false => None
                 };
 
-                for mut c in 0..number_of_elements {
+                for mut c in 0..number_of_elements_value {
                     if self.eigenvalues_im[c] != T::zero() {
                         //Complex conjugate pairs of eigenvalues appear consecutively with the eigenvalue having the positive imaginary part first.
                         eigenvalues.push(Complex::<T>::new(self.eigenvalues_re[c].clone(), self.eigenvalues_im[c].clone()));
                         eigenvalues.push(Complex::<T>::new(self.eigenvalues_re[c].clone(), -self.eigenvalues_im[c].clone()));
 
                         if eigenvectors.is_some() {
-                            let mut vec = OVector::<Complex<T>, D>::zeros();
-                            let mut vec_conj = OVector::<Complex<T>, D>::zeros();
+                            let mut vec = OVector::<Complex<T>, D>::zeros_generic(number_of_elements, Const::<1>);
+                            let mut vec_conj = OVector::<Complex<T>, D>::zeros_generic(number_of_elements, Const::<1>);
 
-                            for r in 0..number_of_elements {
+                            for r in 0..number_of_elements_value {
                                 vec[r] = Complex::<T>::new((&self.eigenvectors.as_ref()).unwrap()[(r,c)].clone(),(&self.eigenvectors.as_ref()).unwrap()[(r,c+1)].clone());
                                 vec_conj[r] = Complex::<T>::new((&self.eigenvectors.as_ref()).unwrap()[(r,c)].clone(),-(&self.eigenvectors.as_ref()).unwrap()[(r,c+1)].clone());
                             }
@@ -206,10 +207,10 @@ where
                         }
 
                         if left_eigenvectors.is_some() {
-                            let mut vec = OVector::<Complex<T>, D>::zeros();
-                            let mut vec_conj = OVector::<Complex<T>, D>::zeros();
+                            let mut vec = OVector::<Complex<T>, D>::zeros_generic(number_of_elements, Const::<1>);
+                            let mut vec_conj = OVector::<Complex<T>, D>::zeros_generic(number_of_elements, Const::<1>);
 
-                            for r in 0..number_of_elements {
+                            for r in 0..number_of_elements_value {
                                 vec[r] = Complex::<T>::new((&self.left_eigenvectors.as_ref()).unwrap()[(r,c)].clone(),(&self.left_eigenvectors.as_ref()).unwrap()[(r,c+1)].clone());
                                 vec_conj[r] = Complex::<T>::new((&self.left_eigenvectors.as_ref()).unwrap()[(r,c)].clone(),-(&self.left_eigenvectors.as_ref()).unwrap()[(r,c+1)].clone());
                             }

From 81f1a6d87e350314c5c293a4aab58fbc156f3b8a Mon Sep 17 00:00:00 2001
From: Marc Haubenstock <marc.dhaubenstock@gmail.com>
Date: Sun, 16 Oct 2022 12:03:08 +0200
Subject: [PATCH 027/119] review conjugate indexing

---
 nalgebra-lapack/src/eigen.rs | 14 ++++++--------
 1 file changed, 6 insertions(+), 8 deletions(-)

diff --git a/nalgebra-lapack/src/eigen.rs b/nalgebra-lapack/src/eigen.rs
index 7048ee35..995d765e 100644
--- a/nalgebra-lapack/src/eigen.rs
+++ b/nalgebra-lapack/src/eigen.rs
@@ -177,13 +177,13 @@ where
                 let (number_of_elements, _) = self.eigenvalues_re.shape_generic();
                 let number_of_elements_value = number_of_elements.value();
                 let number_of_complex_entries = self.eigenvalues_im.iter().fold(0, |acc, e| if !e.is_zero() {acc + 1} else {acc});
-                let mut eigenvalues = Vec::<Complex<T>>::with_capacity(2*number_of_complex_entries);
+                let mut eigenvalues = Vec::<Complex<T>>::with_capacity(number_of_complex_entries);
                 let mut eigenvectors = match self.eigenvectors.is_some() {
-                    true => Some(Vec::<OVector<Complex<T>, D>>::with_capacity(2*number_of_complex_entries)),
+                    true => Some(Vec::<OVector<Complex<T>, D>>::with_capacity(number_of_complex_entries)),
                     false => None
                 };
                 let mut left_eigenvectors = match self.left_eigenvectors.is_some() {
-                    true => Some(Vec::<OVector<Complex<T>, D>>::with_capacity(2*number_of_complex_entries)),
+                    true => Some(Vec::<OVector<Complex<T>, D>>::with_capacity(number_of_complex_entries)),
                     false => None
                 };
 
@@ -191,7 +191,7 @@ where
                     if self.eigenvalues_im[c] != T::zero() {
                         //Complex conjugate pairs of eigenvalues appear consecutively with the eigenvalue having the positive imaginary part first.
                         eigenvalues.push(Complex::<T>::new(self.eigenvalues_re[c].clone(), self.eigenvalues_im[c].clone()));
-                        eigenvalues.push(Complex::<T>::new(self.eigenvalues_re[c].clone(), -self.eigenvalues_im[c].clone()));
+                        eigenvalues.push(Complex::<T>::new(self.eigenvalues_re[c+1].clone(), self.eigenvalues_im[c+1].clone()));
 
                         if eigenvectors.is_some() {
                             let mut vec = OVector::<Complex<T>, D>::zeros_generic(number_of_elements, Const::<1>);
@@ -199,7 +199,7 @@ where
 
                             for r in 0..number_of_elements_value {
                                 vec[r] = Complex::<T>::new((&self.eigenvectors.as_ref()).unwrap()[(r,c)].clone(),(&self.eigenvectors.as_ref()).unwrap()[(r,c+1)].clone());
-                                vec_conj[r] = Complex::<T>::new((&self.eigenvectors.as_ref()).unwrap()[(r,c)].clone(),-(&self.eigenvectors.as_ref()).unwrap()[(r,c+1)].clone());
+                                vec_conj[r] = Complex::<T>::new((&self.eigenvectors.as_ref()).unwrap()[(r,c)].clone(),(&self.eigenvectors.as_ref()).unwrap()[(r,c+1)].clone());
                             }
     
                             eigenvectors.as_mut().unwrap().push(vec);
@@ -212,7 +212,7 @@ where
 
                             for r in 0..number_of_elements_value {
                                 vec[r] = Complex::<T>::new((&self.left_eigenvectors.as_ref()).unwrap()[(r,c)].clone(),(&self.left_eigenvectors.as_ref()).unwrap()[(r,c+1)].clone());
-                                vec_conj[r] = Complex::<T>::new((&self.left_eigenvectors.as_ref()).unwrap()[(r,c)].clone(),-(&self.left_eigenvectors.as_ref()).unwrap()[(r,c+1)].clone());
+                                vec_conj[r] = Complex::<T>::new((&self.left_eigenvectors.as_ref()).unwrap()[(r,c)].clone(),(&self.left_eigenvectors.as_ref()).unwrap()[(r,c+1)].clone());
                             }
     
                             left_eigenvectors.as_mut().unwrap().push(vec);
@@ -225,8 +225,6 @@ where
                 (Some(eigenvalues), left_eigenvectors, eigenvectors)
             }
         }
-
-
     }
 
 }

From 9acaa35e33964915507a6124fdae318af6503a7f Mon Sep 17 00:00:00 2001
From: Marc Haubenstock <marc.dhaubenstock@gmail.com>
Date: Sat, 22 Oct 2022 21:26:09 +0200
Subject: [PATCH 028/119] fixed iteration

---
 nalgebra-lapack/src/eigen.rs | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/nalgebra-lapack/src/eigen.rs b/nalgebra-lapack/src/eigen.rs
index 995d765e..5f621dbf 100644
--- a/nalgebra-lapack/src/eigen.rs
+++ b/nalgebra-lapack/src/eigen.rs
@@ -186,8 +186,9 @@ where
                     true => Some(Vec::<OVector<Complex<T>, D>>::with_capacity(number_of_complex_entries)),
                     false => None
                 };
-
-                for mut c in 0..number_of_elements_value {
+                
+                let mut c = 0;
+                while c < number_of_elements_value {
                     if self.eigenvalues_im[c] != T::zero() {
                         //Complex conjugate pairs of eigenvalues appear consecutively with the eigenvalue having the positive imaginary part first.
                         eigenvalues.push(Complex::<T>::new(self.eigenvalues_re[c].clone(), self.eigenvalues_im[c].clone()));

From 4a1fd605e40afe7064cc4b3c306a75868466cdfb Mon Sep 17 00:00:00 2001
From: Marc Haubenstock <marc.dhaubenstock@gmail.com>
Date: Sun, 23 Oct 2022 19:23:13 +0200
Subject: [PATCH 029/119] fixed iteration

---
 nalgebra-lapack/src/eigen.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/nalgebra-lapack/src/eigen.rs b/nalgebra-lapack/src/eigen.rs
index 5f621dbf..3a848d0a 100644
--- a/nalgebra-lapack/src/eigen.rs
+++ b/nalgebra-lapack/src/eigen.rs
@@ -222,6 +222,7 @@ where
                         //skip next entry
                         c += 1;
                     }
+                    c+=1;
                 }
                 (Some(eigenvalues), left_eigenvectors, eigenvectors)
             }

From aa89cda0cd9474cf040adbfe55e4c26d75e6d9fd Mon Sep 17 00:00:00 2001
From: Marc Haubenstock <marc.dhaubenstock@gmail.com>
Date: Sun, 23 Oct 2022 20:36:06 +0200
Subject: [PATCH 030/119] testing complex eigenvalues

---
 nalgebra-lapack/Cargo.toml                    |  4 +++-
 nalgebra-lapack/examples/complex_eigen.rs     | 24 +++++++++++++++++++
 nalgebra-lapack/src/eigen.rs                  |  3 ++-
 nalgebra-lapack/tests/linalg/complex_eigen.rs | 19 +++++++++++++++
 nalgebra-lapack/tests/linalg/mod.rs           |  1 +
 5 files changed, 49 insertions(+), 2 deletions(-)
 create mode 100644 nalgebra-lapack/examples/complex_eigen.rs
 create mode 100644 nalgebra-lapack/tests/linalg/complex_eigen.rs

diff --git a/nalgebra-lapack/Cargo.toml b/nalgebra-lapack/Cargo.toml
index 91517a8d..3f165f76 100644
--- a/nalgebra-lapack/Cargo.toml
+++ b/nalgebra-lapack/Cargo.toml
@@ -22,7 +22,7 @@ proptest-support = [ "nalgebra/proptest-support" ]
 arbitrary        = [ "nalgebra/arbitrary" ]
 
 # For BLAS/LAPACK
-default    = ["netlib"]
+default    = ["openblas"]
 openblas   = ["lapack-src/openblas"]
 netlib     = ["lapack-src/netlib"]
 accelerate = ["lapack-src/accelerate"]
@@ -36,6 +36,7 @@ simba         = "0.7"
 serde         = { version = "1.0", features = [ "derive" ], optional = true }
 lapack        = { version = "0.19", default-features = false }
 lapack-src    = { version = "0.8", default-features = false }
+openblas-src = {version = "*", features = ["static"]}
 # clippy = "*"
 
 [dev-dependencies]
@@ -44,3 +45,4 @@ proptest   = { version = "1", default-features = false, features = ["std"] }
 quickcheck = "1"
 approx     = "0.5"
 rand       = "0.8"
+
diff --git a/nalgebra-lapack/examples/complex_eigen.rs b/nalgebra-lapack/examples/complex_eigen.rs
new file mode 100644
index 00000000..8a359d69
--- /dev/null
+++ b/nalgebra-lapack/examples/complex_eigen.rs
@@ -0,0 +1,24 @@
+extern crate nalgebra as na;
+extern crate nalgebra_lapack;
+#[macro_use]
+extern crate approx; // for assert_relative_eq
+
+use na::Matrix3;
+use nalgebra_lapack::Eigen;
+use num_complex::Complex;
+
+
+fn main() {
+    let m = Matrix3::<f64>::new(4.0/5.0, -3.0/5.0, 0.0, 3.0/5.0, 4.0/5.0, 0.0, 1.0, 2.0, 2.0);
+    let eigen = Eigen::new(m,true,true).expect("Eigen Creation Failed!");
+    let (some_eigenvalues, some_left_vec, some_right_vec) = eigen.get_complex_elements();
+    let eigenvalues = some_eigenvalues.expect("Eigenvalues Failed");
+    let left_eigenvectors = some_left_vec.expect("Left Eigenvectors Failed");
+    let eigenvectors = some_right_vec.expect("Right Eigenvectors Failed");
+
+    assert_relative_eq!(eigenvalues[0].re, Complex::<f64>::new(4.0/5.0,3.0/5.0).re);
+    assert_relative_eq!(eigenvalues[0].im, Complex::<f64>::new(4.0/5.0,3.0/5.0).im);
+    assert_relative_eq!(eigenvalues[1].re, Complex::<f64>::new(4.0/5.0,-3.0/5.0).re);
+    assert_relative_eq!(eigenvalues[1].im, Complex::<f64>::new(4.0/5.0,-3.0/5.0).im);
+    
+}
\ No newline at end of file
diff --git a/nalgebra-lapack/src/eigen.rs b/nalgebra-lapack/src/eigen.rs
index 3a848d0a..d98c500d 100644
--- a/nalgebra-lapack/src/eigen.rs
+++ b/nalgebra-lapack/src/eigen.rs
@@ -171,7 +171,8 @@ where
     /// Returns a tuple of vectors. The elements of the tuple are the complex eigenvalues, complex left eigenvectors and complex right eigenvectors respectively. 
     /// The elements appear as conjugate pairs within each vector, with the positive of the pair always being first.
     pub fn get_complex_elements(&self) -> (Option<Vec<Complex<T>>>, Option<Vec<OVector<Complex<T>, D>>>, Option<Vec<OVector<Complex<T>, D>>>) where DefaultAllocator: Allocator<Complex<T>, D> {
-        match !self.eigenvalues_are_real() {
+
+        match self.eigenvalues_are_real() {
             true => (None, None, None),
             false => {
                 let (number_of_elements, _) = self.eigenvalues_re.shape_generic();
diff --git a/nalgebra-lapack/tests/linalg/complex_eigen.rs b/nalgebra-lapack/tests/linalg/complex_eigen.rs
new file mode 100644
index 00000000..10869470
--- /dev/null
+++ b/nalgebra-lapack/tests/linalg/complex_eigen.rs
@@ -0,0 +1,19 @@
+use std::cmp;
+
+use na::{Matrix3};
+use nalgebra_lapack::Eigen;
+
+use crate::proptest::*;
+use proptest::{prop_assert, proptest};
+
+proptest! {
+    //#[test]
+    // fn complex_eigen() {
+    //     let n = cmp::max(1, cmp::min(n, 10));
+    //     let m = DMatrix::<f64>::new_random(n, n);
+    //     let eig = SymmetricEigen::new(m.clone());
+    //     let recomp = eig.recompose();
+    //     prop_assert!(relative_eq!(m.lower_triangle(), recomp.lower_triangle(), epsilon = 1.0e-5))
+    // }
+
+}
diff --git a/nalgebra-lapack/tests/linalg/mod.rs b/nalgebra-lapack/tests/linalg/mod.rs
index 251bbe7b..8fc8deeb 100644
--- a/nalgebra-lapack/tests/linalg/mod.rs
+++ b/nalgebra-lapack/tests/linalg/mod.rs
@@ -7,3 +7,4 @@ mod real_eigensystem;
 mod schur;
 mod svd;
 mod symmetric_eigen;
+mod complex_eigen;

From 84c37b79ddcfb97f961b76da0cee69d1a07f42b9 Mon Sep 17 00:00:00 2001
From: Marc Haubenstock <marc.dhaubenstock@gmail.com>
Date: Sun, 23 Oct 2022 21:43:33 +0200
Subject: [PATCH 031/119] testing eigenvectors

---
 nalgebra-lapack/examples/complex_eigen.rs | 13 +++++++++++--
 1 file changed, 11 insertions(+), 2 deletions(-)

diff --git a/nalgebra-lapack/examples/complex_eigen.rs b/nalgebra-lapack/examples/complex_eigen.rs
index 8a359d69..ebf5e48c 100644
--- a/nalgebra-lapack/examples/complex_eigen.rs
+++ b/nalgebra-lapack/examples/complex_eigen.rs
@@ -7,18 +7,27 @@ use na::Matrix3;
 use nalgebra_lapack::Eigen;
 use num_complex::Complex;
 
-
+//Matrix taken from https://textbooks.math.gatech.edu/ila/1553/complex-eigenvalues.html
 fn main() {
     let m = Matrix3::<f64>::new(4.0/5.0, -3.0/5.0, 0.0, 3.0/5.0, 4.0/5.0, 0.0, 1.0, 2.0, 2.0);
     let eigen = Eigen::new(m,true,true).expect("Eigen Creation Failed!");
     let (some_eigenvalues, some_left_vec, some_right_vec) = eigen.get_complex_elements();
     let eigenvalues = some_eigenvalues.expect("Eigenvalues Failed");
-    let left_eigenvectors = some_left_vec.expect("Left Eigenvectors Failed");
+    let _left_eigenvectors = some_left_vec.expect("Left Eigenvectors Failed");
     let eigenvectors = some_right_vec.expect("Right Eigenvectors Failed");
 
     assert_relative_eq!(eigenvalues[0].re, Complex::<f64>::new(4.0/5.0,3.0/5.0).re);
     assert_relative_eq!(eigenvalues[0].im, Complex::<f64>::new(4.0/5.0,3.0/5.0).im);
     assert_relative_eq!(eigenvalues[1].re, Complex::<f64>::new(4.0/5.0,-3.0/5.0).re);
     assert_relative_eq!(eigenvalues[1].im, Complex::<f64>::new(4.0/5.0,-3.0/5.0).im);
+
+
+    assert_relative_eq!(eigenvectors[0][0].re, -12.0/32.7871926215100059134410999);
+    assert_relative_eq!(eigenvectors[0][0].im, -9.0/32.7871926215100059134410999);
+    assert_relative_eq!(eigenvectors[0][1].re, -9.0/32.7871926215100059134410999);
+    assert_relative_eq!(eigenvectors[0][1].im, 12.0/32.7871926215100059134410999);
+    assert_relative_eq!(eigenvectors[0][2].re, 25.0/32.7871926215100059134410999);
+    assert_relative_eq!(eigenvectors[0][2].im, 0.0);
+
     
 }
\ No newline at end of file

From 9c8b5f0f385a24d8be3e5b1625f511e6957498a8 Mon Sep 17 00:00:00 2001
From: Marc Haubenstock <marc.dhaubenstock@gmail.com>
Date: Wed, 26 Oct 2022 16:26:06 +0200
Subject: [PATCH 032/119] added a function to get all the real elements

---
 nalgebra-lapack/examples/complex_eigen.rs |  4 +--
 nalgebra-lapack/src/eigen.rs              | 37 ++++++++++++++++++++++-
 2 files changed, 37 insertions(+), 4 deletions(-)

diff --git a/nalgebra-lapack/examples/complex_eigen.rs b/nalgebra-lapack/examples/complex_eigen.rs
index ebf5e48c..6c452d66 100644
--- a/nalgebra-lapack/examples/complex_eigen.rs
+++ b/nalgebra-lapack/examples/complex_eigen.rs
@@ -27,7 +27,5 @@ fn main() {
     assert_relative_eq!(eigenvectors[0][1].re, -9.0/32.7871926215100059134410999);
     assert_relative_eq!(eigenvectors[0][1].im, 12.0/32.7871926215100059134410999);
     assert_relative_eq!(eigenvectors[0][2].re, 25.0/32.7871926215100059134410999);
-    assert_relative_eq!(eigenvectors[0][2].im, 0.0);
-
-    
+    assert_relative_eq!(eigenvectors[0][2].im, 0.0); 
 }
\ No newline at end of file
diff --git a/nalgebra-lapack/src/eigen.rs b/nalgebra-lapack/src/eigen.rs
index d98c500d..e76b8ef4 100644
--- a/nalgebra-lapack/src/eigen.rs
+++ b/nalgebra-lapack/src/eigen.rs
@@ -168,10 +168,45 @@ where
         det
     }
 
+    /// Returns a tuple of vectors. The elements of the tuple are the real parts of the eigenvalues, left eigenvectors and right eigenvectors respectively. 
+    pub fn get_real_elements(&self) -> (Vec<T>, Option<Vec<OVector<T, D>>>, Option<Vec<OVector<T, D>>>) where DefaultAllocator: Allocator<T, D> {
+        let (number_of_elements, _) = self.eigenvalues_re.shape_generic();
+        let number_of_elements_value = number_of_elements.value();
+        let mut eigenvalues = Vec::<T>::with_capacity(number_of_elements_value);
+        let mut eigenvectors = match self.eigenvectors.is_some() {
+            true => Some(Vec::<OVector<T, D>>::with_capacity(number_of_elements_value)),
+            false => None
+        };
+        let mut left_eigenvectors = match self.left_eigenvectors.is_some() {
+            true => Some(Vec::<OVector<T, D>>::with_capacity(number_of_elements_value)),
+            false => None
+        };
+        
+        let mut c = 0;
+        while c < number_of_elements_value {
+            eigenvalues.push(self.eigenvalues_re[c].clone());
+
+            if eigenvectors.is_some() {
+                eigenvectors.as_mut().unwrap().push((&self.eigenvectors.as_ref()).unwrap().column(c).into_owned());
+            }
+
+            if left_eigenvectors.is_some() {
+                left_eigenvectors.as_mut().unwrap().push((&self.left_eigenvectors.as_ref()).unwrap().column(c).into_owned());
+            }
+            if self.eigenvalues_im[c] != T::zero() {
+                //skip next entry
+                c += 1;
+            }
+            c+=1;
+        }
+        (eigenvalues, left_eigenvectors, eigenvectors)
+            
+        
+    }
+
     /// Returns a tuple of vectors. The elements of the tuple are the complex eigenvalues, complex left eigenvectors and complex right eigenvectors respectively. 
     /// The elements appear as conjugate pairs within each vector, with the positive of the pair always being first.
     pub fn get_complex_elements(&self) -> (Option<Vec<Complex<T>>>, Option<Vec<OVector<Complex<T>, D>>>, Option<Vec<OVector<Complex<T>, D>>>) where DefaultAllocator: Allocator<Complex<T>, D> {
-
         match self.eigenvalues_are_real() {
             true => (None, None, None),
             false => {

From c9fa7a35e7d7613cac738f102e85000402b43ba0 Mon Sep 17 00:00:00 2001
From: _ <>
Date: Thu, 27 Oct 2022 19:56:38 +0000
Subject: [PATCH 033/119] Added try_cast() to Matrix

---
 src/base/matrix.rs | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/src/base/matrix.rs b/src/base/matrix.rs
index e9cc5258..659d3a6e 100644
--- a/src/base/matrix.rs
+++ b/src/base/matrix.rs
@@ -739,6 +739,24 @@ impl<T, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S> {
         crate::convert(self)
     }
 
+    /// Attempts to cast the components of `self` to another type.
+    ///
+    /// # Example
+    /// ```
+    /// # use nalgebra::Vector3;
+    /// let q = Vector3::new(1.0f64, 2.0, 3.0);
+    /// let q2 = q.try_cast::<i32>();
+    /// assert_eq!(q2, Some(Vector3::new(1, 2, 3)));
+    /// ```
+    pub fn try_cast<T2: Scalar>(self) -> Option<OMatrix<T2, R, C>>
+    where
+        T: Scalar,
+        Self: SupersetOf<OMatrix<T2, R, C>>,
+        DefaultAllocator: Allocator<T2, R, C>,
+    {
+        crate::try_convert(self)
+    }
+
     /// Similar to `self.iter().fold(init, f)` except that `init` is replaced by a closure.
     ///
     /// The initialization closure is given the first component of this matrix:

From e32f4ee16f402296e4da0fb2a824ac966c90c89d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=A9bastien=20Crozet?= <developer@crozet.re>
Date: Sun, 30 Oct 2022 17:22:08 +0100
Subject: [PATCH 034/119] cargo fmt + tests

---
 nalgebra-lapack/examples/complex_eigen.rs     |  31 ----
 nalgebra-lapack/src/eigen.rs                  | 138 +++++++++++++-----
 nalgebra-lapack/tests/linalg/cholesky.rs      |   6 +-
 nalgebra-lapack/tests/linalg/complex_eigen.rs |  56 +++++--
 nalgebra-lapack/tests/linalg/lu.rs            |  16 +-
 nalgebra-lapack/tests/linalg/mod.rs           |   2 +-
 .../tests/linalg/real_eigensystem.rs          |  34 +++--
 nalgebra-lapack/tests/linalg/schur.rs         |  13 +-
 8 files changed, 184 insertions(+), 112 deletions(-)
 delete mode 100644 nalgebra-lapack/examples/complex_eigen.rs

diff --git a/nalgebra-lapack/examples/complex_eigen.rs b/nalgebra-lapack/examples/complex_eigen.rs
deleted file mode 100644
index 6c452d66..00000000
--- a/nalgebra-lapack/examples/complex_eigen.rs
+++ /dev/null
@@ -1,31 +0,0 @@
-extern crate nalgebra as na;
-extern crate nalgebra_lapack;
-#[macro_use]
-extern crate approx; // for assert_relative_eq
-
-use na::Matrix3;
-use nalgebra_lapack::Eigen;
-use num_complex::Complex;
-
-//Matrix taken from https://textbooks.math.gatech.edu/ila/1553/complex-eigenvalues.html
-fn main() {
-    let m = Matrix3::<f64>::new(4.0/5.0, -3.0/5.0, 0.0, 3.0/5.0, 4.0/5.0, 0.0, 1.0, 2.0, 2.0);
-    let eigen = Eigen::new(m,true,true).expect("Eigen Creation Failed!");
-    let (some_eigenvalues, some_left_vec, some_right_vec) = eigen.get_complex_elements();
-    let eigenvalues = some_eigenvalues.expect("Eigenvalues Failed");
-    let _left_eigenvectors = some_left_vec.expect("Left Eigenvectors Failed");
-    let eigenvectors = some_right_vec.expect("Right Eigenvectors Failed");
-
-    assert_relative_eq!(eigenvalues[0].re, Complex::<f64>::new(4.0/5.0,3.0/5.0).re);
-    assert_relative_eq!(eigenvalues[0].im, Complex::<f64>::new(4.0/5.0,3.0/5.0).im);
-    assert_relative_eq!(eigenvalues[1].re, Complex::<f64>::new(4.0/5.0,-3.0/5.0).re);
-    assert_relative_eq!(eigenvalues[1].im, Complex::<f64>::new(4.0/5.0,-3.0/5.0).im);
-
-
-    assert_relative_eq!(eigenvectors[0][0].re, -12.0/32.7871926215100059134410999);
-    assert_relative_eq!(eigenvectors[0][0].im, -9.0/32.7871926215100059134410999);
-    assert_relative_eq!(eigenvectors[0][1].re, -9.0/32.7871926215100059134410999);
-    assert_relative_eq!(eigenvectors[0][1].im, 12.0/32.7871926215100059134410999);
-    assert_relative_eq!(eigenvectors[0][2].re, 25.0/32.7871926215100059134410999);
-    assert_relative_eq!(eigenvectors[0][2].im, 0.0); 
-}
\ No newline at end of file
diff --git a/nalgebra-lapack/src/eigen.rs b/nalgebra-lapack/src/eigen.rs
index e76b8ef4..08f16115 100644
--- a/nalgebra-lapack/src/eigen.rs
+++ b/nalgebra-lapack/src/eigen.rs
@@ -8,7 +8,7 @@ use simba::scalar::RealField;
 
 use crate::ComplexHelper;
 use na::dimension::{Const, Dim};
-use na::{DefaultAllocator, Matrix, OMatrix, OVector, Scalar, allocator::Allocator};
+use na::{allocator::Allocator, DefaultAllocator, Matrix, OMatrix, OVector, Scalar};
 
 use lapack;
 
@@ -147,7 +147,7 @@ where
             eigenvalues_re: wr,
             eigenvalues_im: wi,
             left_eigenvectors: vl,
-            eigenvectors: vr
+            eigenvectors: vr,
         })
     }
 
@@ -168,103 +168,169 @@ where
         det
     }
 
-    /// Returns a tuple of vectors. The elements of the tuple are the real parts of the eigenvalues, left eigenvectors and right eigenvectors respectively. 
-    pub fn get_real_elements(&self) -> (Vec<T>, Option<Vec<OVector<T, D>>>, Option<Vec<OVector<T, D>>>) where DefaultAllocator: Allocator<T, D> {
+    /// Returns a tuple of vectors. The elements of the tuple are the real parts of the eigenvalues, left eigenvectors and right eigenvectors respectively.
+    pub fn get_real_elements(
+        &self,
+    ) -> (
+        Vec<T>,
+        Option<Vec<OVector<T, D>>>,
+        Option<Vec<OVector<T, D>>>,
+    )
+    where
+        DefaultAllocator: Allocator<T, D>,
+    {
         let (number_of_elements, _) = self.eigenvalues_re.shape_generic();
         let number_of_elements_value = number_of_elements.value();
         let mut eigenvalues = Vec::<T>::with_capacity(number_of_elements_value);
         let mut eigenvectors = match self.eigenvectors.is_some() {
-            true => Some(Vec::<OVector<T, D>>::with_capacity(number_of_elements_value)),
-            false => None
+            true => Some(Vec::<OVector<T, D>>::with_capacity(
+                number_of_elements_value,
+            )),
+            false => None,
         };
         let mut left_eigenvectors = match self.left_eigenvectors.is_some() {
-            true => Some(Vec::<OVector<T, D>>::with_capacity(number_of_elements_value)),
-            false => None
+            true => Some(Vec::<OVector<T, D>>::with_capacity(
+                number_of_elements_value,
+            )),
+            false => None,
         };
-        
+
         let mut c = 0;
         while c < number_of_elements_value {
             eigenvalues.push(self.eigenvalues_re[c].clone());
 
             if eigenvectors.is_some() {
-                eigenvectors.as_mut().unwrap().push((&self.eigenvectors.as_ref()).unwrap().column(c).into_owned());
+                eigenvectors.as_mut().unwrap().push(
+                    (&self.eigenvectors.as_ref())
+                        .unwrap()
+                        .column(c)
+                        .into_owned(),
+                );
             }
 
             if left_eigenvectors.is_some() {
-                left_eigenvectors.as_mut().unwrap().push((&self.left_eigenvectors.as_ref()).unwrap().column(c).into_owned());
+                left_eigenvectors.as_mut().unwrap().push(
+                    (&self.left_eigenvectors.as_ref())
+                        .unwrap()
+                        .column(c)
+                        .into_owned(),
+                );
             }
             if self.eigenvalues_im[c] != T::zero() {
                 //skip next entry
                 c += 1;
             }
-            c+=1;
+            c += 1;
         }
         (eigenvalues, left_eigenvectors, eigenvectors)
-            
-        
     }
 
-    /// Returns a tuple of vectors. The elements of the tuple are the complex eigenvalues, complex left eigenvectors and complex right eigenvectors respectively. 
+    /// Returns a tuple of vectors. The elements of the tuple are the complex eigenvalues, complex left eigenvectors and complex right eigenvectors respectively.
     /// The elements appear as conjugate pairs within each vector, with the positive of the pair always being first.
-    pub fn get_complex_elements(&self) -> (Option<Vec<Complex<T>>>, Option<Vec<OVector<Complex<T>, D>>>, Option<Vec<OVector<Complex<T>, D>>>) where DefaultAllocator: Allocator<Complex<T>, D> {
+    pub fn get_complex_elements(
+        &self,
+    ) -> (
+        Option<Vec<Complex<T>>>,
+        Option<Vec<OVector<Complex<T>, D>>>,
+        Option<Vec<OVector<Complex<T>, D>>>,
+    )
+    where
+        DefaultAllocator: Allocator<Complex<T>, D>,
+    {
         match self.eigenvalues_are_real() {
             true => (None, None, None),
             false => {
                 let (number_of_elements, _) = self.eigenvalues_re.shape_generic();
                 let number_of_elements_value = number_of_elements.value();
-                let number_of_complex_entries = self.eigenvalues_im.iter().fold(0, |acc, e| if !e.is_zero() {acc + 1} else {acc});
+                let number_of_complex_entries =
+                    self.eigenvalues_im
+                        .iter()
+                        .fold(0, |acc, e| if !e.is_zero() { acc + 1 } else { acc });
                 let mut eigenvalues = Vec::<Complex<T>>::with_capacity(number_of_complex_entries);
                 let mut eigenvectors = match self.eigenvectors.is_some() {
-                    true => Some(Vec::<OVector<Complex<T>, D>>::with_capacity(number_of_complex_entries)),
-                    false => None
+                    true => Some(Vec::<OVector<Complex<T>, D>>::with_capacity(
+                        number_of_complex_entries,
+                    )),
+                    false => None,
                 };
                 let mut left_eigenvectors = match self.left_eigenvectors.is_some() {
-                    true => Some(Vec::<OVector<Complex<T>, D>>::with_capacity(number_of_complex_entries)),
-                    false => None
+                    true => Some(Vec::<OVector<Complex<T>, D>>::with_capacity(
+                        number_of_complex_entries,
+                    )),
+                    false => None,
                 };
-                
+
                 let mut c = 0;
                 while c < number_of_elements_value {
                     if self.eigenvalues_im[c] != T::zero() {
                         //Complex conjugate pairs of eigenvalues appear consecutively with the eigenvalue having the positive imaginary part first.
-                        eigenvalues.push(Complex::<T>::new(self.eigenvalues_re[c].clone(), self.eigenvalues_im[c].clone()));
-                        eigenvalues.push(Complex::<T>::new(self.eigenvalues_re[c+1].clone(), self.eigenvalues_im[c+1].clone()));
+                        eigenvalues.push(Complex::<T>::new(
+                            self.eigenvalues_re[c].clone(),
+                            self.eigenvalues_im[c].clone(),
+                        ));
+                        eigenvalues.push(Complex::<T>::new(
+                            self.eigenvalues_re[c + 1].clone(),
+                            self.eigenvalues_im[c + 1].clone(),
+                        ));
 
                         if eigenvectors.is_some() {
-                            let mut vec = OVector::<Complex<T>, D>::zeros_generic(number_of_elements, Const::<1>);
-                            let mut vec_conj = OVector::<Complex<T>, D>::zeros_generic(number_of_elements, Const::<1>);
+                            let mut vec = OVector::<Complex<T>, D>::zeros_generic(
+                                number_of_elements,
+                                Const::<1>,
+                            );
+                            let mut vec_conj = OVector::<Complex<T>, D>::zeros_generic(
+                                number_of_elements,
+                                Const::<1>,
+                            );
 
                             for r in 0..number_of_elements_value {
-                                vec[r] = Complex::<T>::new((&self.eigenvectors.as_ref()).unwrap()[(r,c)].clone(),(&self.eigenvectors.as_ref()).unwrap()[(r,c+1)].clone());
-                                vec_conj[r] = Complex::<T>::new((&self.eigenvectors.as_ref()).unwrap()[(r,c)].clone(),(&self.eigenvectors.as_ref()).unwrap()[(r,c+1)].clone());
+                                vec[r] = Complex::<T>::new(
+                                    (&self.eigenvectors.as_ref()).unwrap()[(r, c)].clone(),
+                                    (&self.eigenvectors.as_ref()).unwrap()[(r, c + 1)].clone(),
+                                );
+                                vec_conj[r] = Complex::<T>::new(
+                                    (&self.eigenvectors.as_ref()).unwrap()[(r, c)].clone(),
+                                    (&self.eigenvectors.as_ref()).unwrap()[(r, c + 1)].clone(),
+                                );
                             }
-    
+
                             eigenvectors.as_mut().unwrap().push(vec);
                             eigenvectors.as_mut().unwrap().push(vec_conj);
                         }
 
                         if left_eigenvectors.is_some() {
-                            let mut vec = OVector::<Complex<T>, D>::zeros_generic(number_of_elements, Const::<1>);
-                            let mut vec_conj = OVector::<Complex<T>, D>::zeros_generic(number_of_elements, Const::<1>);
+                            let mut vec = OVector::<Complex<T>, D>::zeros_generic(
+                                number_of_elements,
+                                Const::<1>,
+                            );
+                            let mut vec_conj = OVector::<Complex<T>, D>::zeros_generic(
+                                number_of_elements,
+                                Const::<1>,
+                            );
 
                             for r in 0..number_of_elements_value {
-                                vec[r] = Complex::<T>::new((&self.left_eigenvectors.as_ref()).unwrap()[(r,c)].clone(),(&self.left_eigenvectors.as_ref()).unwrap()[(r,c+1)].clone());
-                                vec_conj[r] = Complex::<T>::new((&self.left_eigenvectors.as_ref()).unwrap()[(r,c)].clone(),(&self.left_eigenvectors.as_ref()).unwrap()[(r,c+1)].clone());
+                                vec[r] = Complex::<T>::new(
+                                    (&self.left_eigenvectors.as_ref()).unwrap()[(r, c)].clone(),
+                                    (&self.left_eigenvectors.as_ref()).unwrap()[(r, c + 1)].clone(),
+                                );
+                                vec_conj[r] = Complex::<T>::new(
+                                    (&self.left_eigenvectors.as_ref()).unwrap()[(r, c)].clone(),
+                                    (&self.left_eigenvectors.as_ref()).unwrap()[(r, c + 1)].clone(),
+                                );
                             }
-    
+
                             left_eigenvectors.as_mut().unwrap().push(vec);
                             left_eigenvectors.as_mut().unwrap().push(vec_conj);
                         }
                         //skip next entry
                         c += 1;
                     }
-                    c+=1;
+                    c += 1;
                 }
                 (Some(eigenvalues), left_eigenvectors, eigenvectors)
             }
         }
     }
-
 }
 
 /*
diff --git a/nalgebra-lapack/tests/linalg/cholesky.rs b/nalgebra-lapack/tests/linalg/cholesky.rs
index 632347b8..0bf74dd4 100644
--- a/nalgebra-lapack/tests/linalg/cholesky.rs
+++ b/nalgebra-lapack/tests/linalg/cholesky.rs
@@ -58,8 +58,8 @@ proptest! {
             let sol1 = chol.solve(&b1).unwrap();
             let sol2 = chol.solve(&b2).unwrap();
 
-            prop_assert!(relative_eq!(m * sol1, b1, epsilon = 1.0e-7));
-            prop_assert!(relative_eq!(m * sol2, b2, epsilon = 1.0e-7));
+            prop_assert!(relative_eq!(m * sol1, b1, epsilon = 1.0e-4));
+            prop_assert!(relative_eq!(m * sol2, b2, epsilon = 1.0e-4));
         }
     }
 
@@ -84,7 +84,7 @@ proptest! {
             let id1 = &m  * &m1;
             let id2 = &m1 * &m;
 
-            prop_assert!(id1.is_identity(1.0e-5) && id2.is_identity(1.0e-5))
+            prop_assert!(id1.is_identity(1.0e-4) && id2.is_identity(1.0e-4))
         }
     }
 }
diff --git a/nalgebra-lapack/tests/linalg/complex_eigen.rs b/nalgebra-lapack/tests/linalg/complex_eigen.rs
index 10869470..aa3474b9 100644
--- a/nalgebra-lapack/tests/linalg/complex_eigen.rs
+++ b/nalgebra-lapack/tests/linalg/complex_eigen.rs
@@ -1,19 +1,47 @@
-use std::cmp;
-
-use na::{Matrix3};
+use na::Matrix3;
 use nalgebra_lapack::Eigen;
+use num_complex::Complex;
 
-use crate::proptest::*;
-use proptest::{prop_assert, proptest};
+#[test]
+fn complex_eigen() {
+    let m = Matrix3::<f64>::new(
+        4.0 / 5.0,
+        -3.0 / 5.0,
+        0.0,
+        3.0 / 5.0,
+        4.0 / 5.0,
+        0.0,
+        1.0,
+        2.0,
+        2.0,
+    );
+    let eigen = Eigen::new(m, true, true).expect("Eigen Creation Failed!");
+    let (some_eigenvalues, some_left_vec, some_right_vec) = eigen.get_complex_elements();
+    let eigenvalues = some_eigenvalues.expect("Eigenvalues Failed");
+    let _left_eigenvectors = some_left_vec.expect("Left Eigenvectors Failed");
+    let eigenvectors = some_right_vec.expect("Right Eigenvectors Failed");
 
-proptest! {
-    //#[test]
-    // fn complex_eigen() {
-    //     let n = cmp::max(1, cmp::min(n, 10));
-    //     let m = DMatrix::<f64>::new_random(n, n);
-    //     let eig = SymmetricEigen::new(m.clone());
-    //     let recomp = eig.recompose();
-    //     prop_assert!(relative_eq!(m.lower_triangle(), recomp.lower_triangle(), epsilon = 1.0e-5))
-    // }
+    assert_relative_eq!(
+        eigenvalues[0].re,
+        Complex::<f64>::new(4.0 / 5.0, 3.0 / 5.0).re
+    );
+    assert_relative_eq!(
+        eigenvalues[0].im,
+        Complex::<f64>::new(4.0 / 5.0, 3.0 / 5.0).im
+    );
+    assert_relative_eq!(
+        eigenvalues[1].re,
+        Complex::<f64>::new(4.0 / 5.0, -3.0 / 5.0).re
+    );
+    assert_relative_eq!(
+        eigenvalues[1].im,
+        Complex::<f64>::new(4.0 / 5.0, -3.0 / 5.0).im
+    );
 
+    assert_relative_eq!(eigenvectors[0][0].re, -12.0 / 32.7871926215100059134410999);
+    assert_relative_eq!(eigenvectors[0][0].im, -9.0 / 32.7871926215100059134410999);
+    assert_relative_eq!(eigenvectors[0][1].re, -9.0 / 32.7871926215100059134410999);
+    assert_relative_eq!(eigenvectors[0][1].im, 12.0 / 32.7871926215100059134410999);
+    assert_relative_eq!(eigenvectors[0][2].re, 25.0 / 32.7871926215100059134410999);
+    assert_relative_eq!(eigenvectors[0][2].im, 0.0);
 }
diff --git a/nalgebra-lapack/tests/linalg/lu.rs b/nalgebra-lapack/tests/linalg/lu.rs
index 9665964e..b9d45208 100644
--- a/nalgebra-lapack/tests/linalg/lu.rs
+++ b/nalgebra-lapack/tests/linalg/lu.rs
@@ -51,10 +51,10 @@ proptest! {
         let tr_sol1 = lup.solve_transpose(&b1).unwrap();
         let tr_sol2 = lup.solve_transpose(&b2).unwrap();
 
-        prop_assert!(relative_eq!(&m * sol1, b1, epsilon = 1.0e-7));
-        prop_assert!(relative_eq!(&m * sol2, b2, epsilon = 1.0e-7));
-        prop_assert!(relative_eq!(m.transpose() * tr_sol1, b1, epsilon = 1.0e-7));
-        prop_assert!(relative_eq!(m.transpose() * tr_sol2, b2, epsilon = 1.0e-7));
+        prop_assert!(relative_eq!(&m * sol1, b1, epsilon = 1.0e-5));
+        prop_assert!(relative_eq!(&m * sol2, b2, epsilon = 1.0e-5));
+        prop_assert!(relative_eq!(m.transpose() * tr_sol1, b1, epsilon = 1.0e-5));
+        prop_assert!(relative_eq!(m.transpose() * tr_sol2, b2, epsilon = 1.0e-5));
     }
 
     #[test]
@@ -68,10 +68,10 @@ proptest! {
         let tr_sol1 = lup.solve_transpose(&b1).unwrap();
         let tr_sol2 = lup.solve_transpose(&b2).unwrap();
 
-        prop_assert!(relative_eq!(m * sol1, b1, epsilon = 1.0e-7));
-        prop_assert!(relative_eq!(m * sol2, b2, epsilon = 1.0e-7));
-        prop_assert!(relative_eq!(m.transpose() * tr_sol1, b1, epsilon = 1.0e-7));
-        prop_assert!(relative_eq!(m.transpose() * tr_sol2, b2, epsilon = 1.0e-7));
+        prop_assert!(relative_eq!(m * sol1, b1, epsilon = 1.0e-5));
+        prop_assert!(relative_eq!(m * sol2, b2, epsilon = 1.0e-5));
+        prop_assert!(relative_eq!(m.transpose() * tr_sol1, b1, epsilon = 1.0e-5));
+        prop_assert!(relative_eq!(m.transpose() * tr_sol2, b2, epsilon = 1.0e-5));
     }
 
     #[test]
diff --git a/nalgebra-lapack/tests/linalg/mod.rs b/nalgebra-lapack/tests/linalg/mod.rs
index 8fc8deeb..92425293 100644
--- a/nalgebra-lapack/tests/linalg/mod.rs
+++ b/nalgebra-lapack/tests/linalg/mod.rs
@@ -1,4 +1,5 @@
 mod cholesky;
+mod complex_eigen;
 mod generalized_eigenvalues;
 mod lu;
 mod qr;
@@ -7,4 +8,3 @@ mod real_eigensystem;
 mod schur;
 mod svd;
 mod symmetric_eigen;
-mod complex_eigen;
diff --git a/nalgebra-lapack/tests/linalg/real_eigensystem.rs b/nalgebra-lapack/tests/linalg/real_eigensystem.rs
index 3d1c91eb..599d1b2a 100644
--- a/nalgebra-lapack/tests/linalg/real_eigensystem.rs
+++ b/nalgebra-lapack/tests/linalg/real_eigensystem.rs
@@ -13,30 +13,36 @@ proptest! {
         let m = DMatrix::<f64>::new_random(n, n);
 
         if let Some(eig) = Eigen::new(m.clone(), true, true) {
-            let eigvals                = DMatrix::from_diagonal(&eig.eigenvalues);
-            let transformed_eigvectors = &m * eig.eigenvectors.as_ref().unwrap();
-            let scaled_eigvectors      = eig.eigenvectors.as_ref().unwrap() * &eigvals;
+            // TODO: test the complex case too.
+            if eig.eigenvalues_are_real() {
+                let eigvals                = DMatrix::from_diagonal(&eig.eigenvalues_re);
+                let transformed_eigvectors = &m * eig.eigenvectors.as_ref().unwrap();
+                let scaled_eigvectors      = eig.eigenvectors.as_ref().unwrap() * &eigvals;
 
-            let transformed_left_eigvectors = m.transpose() * eig.left_eigenvectors.as_ref().unwrap();
-            let scaled_left_eigvectors      = eig.left_eigenvectors.as_ref().unwrap() * &eigvals;
+                let transformed_left_eigvectors = m.transpose() * eig.left_eigenvectors.as_ref().unwrap();
+                let scaled_left_eigvectors      = eig.left_eigenvectors.as_ref().unwrap() * &eigvals;
 
-            prop_assert!(relative_eq!(transformed_eigvectors, scaled_eigvectors, epsilon = 1.0e-7));
-            prop_assert!(relative_eq!(transformed_left_eigvectors, scaled_left_eigvectors, epsilon = 1.0e-7));
+                prop_assert!(relative_eq!(transformed_eigvectors, scaled_eigvectors, epsilon = 1.0e-5));
+                prop_assert!(relative_eq!(transformed_left_eigvectors, scaled_left_eigvectors, epsilon = 1.0e-5));
+            }
         }
     }
 
     #[test]
     fn eigensystem_static(m in matrix4()) {
         if let Some(eig) = Eigen::new(m, true, true) {
-            let eigvals                = Matrix4::from_diagonal(&eig.eigenvalues);
-            let transformed_eigvectors = m * eig.eigenvectors.unwrap();
-            let scaled_eigvectors      = eig.eigenvectors.unwrap() * eigvals;
+            // TODO: test the complex case too.
+            if eig.eigenvalues_are_real() {
+                let eigvals                = Matrix4::from_diagonal(&eig.eigenvalues_re);
+                let transformed_eigvectors = m * eig.eigenvectors.unwrap();
+                let scaled_eigvectors      = eig.eigenvectors.unwrap() * eigvals;
 
-            let transformed_left_eigvectors = m.transpose() * eig.left_eigenvectors.unwrap();
-            let scaled_left_eigvectors      = eig.left_eigenvectors.unwrap() * eigvals;
+                let transformed_left_eigvectors = m.transpose() * eig.left_eigenvectors.unwrap();
+                let scaled_left_eigvectors      = eig.left_eigenvectors.unwrap() * eigvals;
 
-            prop_assert!(relative_eq!(transformed_eigvectors, scaled_eigvectors, epsilon = 1.0e-7));
-            prop_assert!(relative_eq!(transformed_left_eigvectors, scaled_left_eigvectors, epsilon = 1.0e-7));
+                prop_assert!(relative_eq!(transformed_eigvectors, scaled_eigvectors, epsilon = 1.0e-5));
+                prop_assert!(relative_eq!(transformed_left_eigvectors, scaled_left_eigvectors, epsilon = 1.0e-5));
+            }
         }
     }
 }
diff --git a/nalgebra-lapack/tests/linalg/schur.rs b/nalgebra-lapack/tests/linalg/schur.rs
index 0fd1cc33..ee7bad90 100644
--- a/nalgebra-lapack/tests/linalg/schur.rs
+++ b/nalgebra-lapack/tests/linalg/schur.rs
@@ -11,14 +11,17 @@ proptest! {
         let n = cmp::max(1, cmp::min(n, 10));
         let m = DMatrix::<f64>::new_random(n, n);
 
-        let (vecs, vals) = Schur::new(m.clone()).unpack();
-
-        prop_assert!(relative_eq!(&vecs * vals * vecs.transpose(), m, epsilon = 1.0e-7))
+        if let Some(schur) = Schur::try_new(m.clone()) {
+            let (vecs, vals) = schur.unpack();
+            prop_assert!(relative_eq!(&vecs * vals * vecs.transpose(), m, epsilon = 1.0e-5))
+        }
     }
 
     #[test]
     fn schur_static(m in matrix4()) {
-        let (vecs, vals) = Schur::new(m.clone()).unpack();
-        prop_assert!(relative_eq!(vecs * vals * vecs.transpose(), m, epsilon = 1.0e-7))
+        if let Some(schur) = Schur::try_new(m.clone()) {
+            let (vecs, vals) = schur.unpack();
+            prop_assert!(relative_eq!(vecs * vals * vecs.transpose(), m, epsilon = 1.0e-5))
+        }
     }
 }

From 24e85b9883e1bd4793dc9be327e5972a4934e0a0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=A9bastien=20Crozet?= <developer@crozet.re>
Date: Sun, 30 Oct 2022 17:22:46 +0100
Subject: [PATCH 035/119] Reset nalgebra-lapack cargo.toml to its previous
 defaults

---
 nalgebra-lapack/Cargo.toml | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/nalgebra-lapack/Cargo.toml b/nalgebra-lapack/Cargo.toml
index 3f165f76..16baf4b7 100644
--- a/nalgebra-lapack/Cargo.toml
+++ b/nalgebra-lapack/Cargo.toml
@@ -22,7 +22,7 @@ proptest-support = [ "nalgebra/proptest-support" ]
 arbitrary        = [ "nalgebra/arbitrary" ]
 
 # For BLAS/LAPACK
-default    = ["openblas"]
+default    = ["netlib"]
 openblas   = ["lapack-src/openblas"]
 netlib     = ["lapack-src/netlib"]
 accelerate = ["lapack-src/accelerate"]
@@ -36,7 +36,6 @@ simba         = "0.7"
 serde         = { version = "1.0", features = [ "derive" ], optional = true }
 lapack        = { version = "0.19", default-features = false }
 lapack-src    = { version = "0.8", default-features = false }
-openblas-src = {version = "*", features = ["static"]}
 # clippy = "*"
 
 [dev-dependencies]

From 1eb5cc2851289011b6411f8c74aa7c7178563c51 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=A9bastien=20Crozet?= <developer@crozet.re>
Date: Sun, 30 Oct 2022 17:41:21 +0100
Subject: [PATCH 036/119] Release v0.31.3

---
 CHANGELOG.md | 9 +++++++++
 Cargo.toml   | 2 +-
 2 files changed, 10 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index e035e084..ac297f20 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,15 @@ documented here.
 
 This project adheres to [Semantic Versioning](https://semver.org/).
 
+
+## [0.31.3] (30 Oct. 2022)
+
+### Added
+- Add `Matrix::try_cast` to attempt casting the inner scalar types when that cast may fail.
+
+### Fixed
+- Fixed the usage of `CheckBytes` with `rkyv`.
+
 ## [0.31.2] (09 Oct. 2022)
 
 ### Modified
diff --git a/Cargo.toml b/Cargo.toml
index 4bd1e12f..746b62b3 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name    = "nalgebra"
-version = "0.31.2"
+version = "0.31.3"
 authors = [ "Sébastien Crozet <developer@crozet.re>" ]
 
 description = "General-purpose linear algebra library with transformations and statically-sized or dynamically-sized matrices."

From 79c85ac4be57103c1aae7780aa0cc699d99205f7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=A9bastien=20Crozet?= <developer@crozet.re>
Date: Sun, 30 Oct 2022 17:42:59 +0100
Subject: [PATCH 037/119] Release nalgebra-lapack v0.23

---
 nalgebra-lapack/Cargo.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/nalgebra-lapack/Cargo.toml b/nalgebra-lapack/Cargo.toml
index 16baf4b7..af86224a 100644
--- a/nalgebra-lapack/Cargo.toml
+++ b/nalgebra-lapack/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name    = "nalgebra-lapack"
-version = "0.22.0"
+version = "0.23.0"
 authors = [ "Sébastien Crozet <developer@crozet.re>", "Andrew Straw <strawman@astraw.com>" ]
 
 description   = "Matrix decompositions using nalgebra matrices and Lapack bindings."

From fd644d914a2af8b120a71f416cce190efb2a65c1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=A9bastien=20Crozet?= <developer@crozet.re>
Date: Sun, 30 Oct 2022 17:43:24 +0100
Subject: [PATCH 038/119] Release nalgebra-sparse v0.8

---
 nalgebra-sparse/Cargo.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/nalgebra-sparse/Cargo.toml b/nalgebra-sparse/Cargo.toml
index b9c343e4..fc95ddad 100644
--- a/nalgebra-sparse/Cargo.toml
+++ b/nalgebra-sparse/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "nalgebra-sparse"
-version = "0.7.1"
+version = "0.8.0"
 authors = [ "Andreas Longva", "Sébastien Crozet <developer@crozet.re>" ]
 edition = "2018"
 description = "Sparse matrix computation based on nalgebra."

From 20dbfbd6f9fcaec47fca3b847994e6889d244bcf Mon Sep 17 00:00:00 2001
From: Allan Zhang <al@ayz.ai>
Date: Fri, 4 Nov 2022 09:32:01 -0400
Subject: [PATCH 039/119] Use parenthesis for exclusive lower bound

Changes `]0, pi]` to `(0, pi]`.

Replaces PR #1173 and resolves Issue #1164.
---
 src/geometry/quaternion.rs              | 2 +-
 src/geometry/rotation_specialization.rs | 2 +-
 src/geometry/unit_complex.rs            | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/geometry/quaternion.rs b/src/geometry/quaternion.rs
index 53da24e3..293ab125 100755
--- a/src/geometry/quaternion.rs
+++ b/src/geometry/quaternion.rs
@@ -1323,7 +1323,7 @@ where
         }
     }
 
-    /// The rotation axis and angle in ]0, pi] of this unit quaternion.
+    /// The rotation axis and angle in (0, pi] of this unit quaternion.
     ///
     /// Returns `None` if the angle is zero.
     ///
diff --git a/src/geometry/rotation_specialization.rs b/src/geometry/rotation_specialization.rs
index c9197fd6..bba92512 100644
--- a/src/geometry/rotation_specialization.rs
+++ b/src/geometry/rotation_specialization.rs
@@ -877,7 +877,7 @@ impl<T: SimdRealField> Rotation3<T> {
         }
     }
 
-    /// The rotation axis and angle in ]0, pi] of this rotation matrix.
+    /// The rotation axis and angle in (0, pi] of this rotation matrix.
     ///
     /// Returns `None` if the angle is zero.
     ///
diff --git a/src/geometry/unit_complex.rs b/src/geometry/unit_complex.rs
index efe0dac2..8e44f71a 100755
--- a/src/geometry/unit_complex.rs
+++ b/src/geometry/unit_complex.rs
@@ -132,7 +132,7 @@ where
         Vector1::new(self.angle())
     }
 
-    /// The rotation axis and angle in ]0, pi] of this complex number.
+    /// The rotation axis and angle in (0, pi] of this complex number.
     ///
     /// This is generally used in the context of generic programming. Using
     /// the `.angle()` method instead is more common.

From 8601c655de48e98bebe499c7009cbb189a1982ca Mon Sep 17 00:00:00 2001
From: devil-ira <justthecooldude@gmail.com>
Date: Sat, 5 Nov 2022 00:33:38 +0100
Subject: [PATCH 040/119] Support conversion for glam 0.22

---
 Cargo.toml                       |  2 ++
 src/third_party/glam/mod.rs      |  2 ++
 src/third_party/glam/v022/mod.rs | 18 ++++++++++++++++++
 3 files changed, 22 insertions(+)
 create mode 100644 src/third_party/glam/v022/mod.rs

diff --git a/Cargo.toml b/Cargo.toml
index 746b62b3..bcfa07d2 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -45,6 +45,7 @@ convert-glam018 = [ "glam018" ]
 convert-glam019 = [ "glam019" ]
 convert-glam020 = [ "glam020" ]
 convert-glam021 = [ "glam021" ]
+convert-glam022 = [ "glam022" ]
 
 # Serialization
 ## To use serde in a #[no-std] environment, enable the
@@ -98,6 +99,7 @@ glam018        = { package = "glam", version = "0.18", optional = true }
 glam019        = { package = "glam", version = "0.19", optional = true }
 glam020        = { package = "glam", version = "0.20", optional = true }
 glam021        = { package = "glam", version = "0.21", optional = true }
+glam022        = { package = "glam", version = "0.22", optional = true }
 cust_core      = { version = "0.1", optional = true }
 
 
diff --git a/src/third_party/glam/mod.rs b/src/third_party/glam/mod.rs
index 06bdcfb7..811e88b2 100644
--- a/src/third_party/glam/mod.rs
+++ b/src/third_party/glam/mod.rs
@@ -14,3 +14,5 @@ mod v019;
 mod v020;
 #[cfg(feature = "glam021")]
 mod v021;
+#[cfg(feature = "glam022")]
+mod v022;
diff --git a/src/third_party/glam/v022/mod.rs b/src/third_party/glam/v022/mod.rs
new file mode 100644
index 00000000..de27f929
--- /dev/null
+++ b/src/third_party/glam/v022/mod.rs
@@ -0,0 +1,18 @@
+#[path = "../common/glam_isometry.rs"]
+mod glam_isometry;
+#[path = "../common/glam_matrix.rs"]
+mod glam_matrix;
+#[path = "../common/glam_point.rs"]
+mod glam_point;
+#[path = "../common/glam_quaternion.rs"]
+mod glam_quaternion;
+#[path = "../common/glam_rotation.rs"]
+mod glam_rotation;
+#[path = "../common/glam_similarity.rs"]
+mod glam_similarity;
+#[path = "../common/glam_translation.rs"]
+mod glam_translation;
+#[path = "../common/glam_unit_complex.rs"]
+mod glam_unit_complex;
+
+pub(self) use glam022 as glam;

From c8dfb5e348432508d6c8bd58bfe3fd7ab0290e1a Mon Sep 17 00:00:00 2001
From: Andreas Longva <andreas.b.longva@gmail.com>
Date: Fri, 11 Nov 2022 15:46:04 +0100
Subject: [PATCH 041/119] 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<T, Const<R>, Const<C>, SliceStorage<'a, T, Const<R>, Const<C>, Const<1>, Const<R>>>;
+    Matrix<T, Const<R>, Const<C>, ViewStorage<'a, T, Const<R>, Const<C>, Const<1>, Const<R>>>;
 
 /// 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<T, Dynamic, Dynamic, SliceStorage<'a, T, Dynamic, Dynamic, RStride, CStride>>;
+    Matrix<T, Dynamic, Dynamic, ViewStorage<'a, T, Dynamic, Dynamic, RStride, CStride>>;
 
 /// 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<T, U1, U1, SliceStorage<'a, T, U1, U1, RStride, CStride>>;
+    Matrix<T, U1, U1, ViewStorage<'a, T, U1, U1, RStride, CStride>>;
 /// 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<T, U2, U2, SliceStorage<'a, T, U2, U2, RStride, CStride>>;
+    Matrix<T, U2, U2, ViewStorage<'a, T, U2, U2, RStride, CStride>>;
 /// 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<T, U3, U3, SliceStorage<'a, T, U3, U3, RStride, CStride>>;
+    Matrix<T, U3, U3, ViewStorage<'a, T, U3, U3, RStride, CStride>>;
 /// 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<T, U4, U4, SliceStorage<'a, T, U4, U4, RStride, CStride>>;
+    Matrix<T, U4, U4, ViewStorage<'a, T, U4, U4, RStride, CStride>>;
 /// 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<T, U5, U5, SliceStorage<'a, T, U5, U5, RStride, CStride>>;
+    Matrix<T, U5, U5, ViewStorage<'a, T, U5, U5, RStride, CStride>>;
 /// 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<T, U6, U6, SliceStorage<'a, T, U6, U6, RStride, CStride>>;
+    Matrix<T, U6, U6, ViewStorage<'a, T, U6, U6, RStride, CStride>>;
 
 /// 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<T, U1, U2, SliceStorage<'a, T, U1, U2, RStride, CStride>>;
+    Matrix<T, U1, U2, ViewStorage<'a, T, U1, U2, RStride, CStride>>;
 /// 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<T, U1, U3, SliceStorage<'a, T, U1, U3, RStride, CStride>>;
+    Matrix<T, U1, U3, ViewStorage<'a, T, U1, U3, RStride, CStride>>;
 /// 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<T, U1, U4, SliceStorage<'a, T, U1, U4, RStride, CStride>>;
+    Matrix<T, U1, U4, ViewStorage<'a, T, U1, U4, RStride, CStride>>;
 /// 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<T, U1, U5, SliceStorage<'a, T, U1, U5, RStride, CStride>>;
+    Matrix<T, U1, U5, ViewStorage<'a, T, U1, U5, RStride, CStride>>;
 /// 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<T, U1, U6, SliceStorage<'a, T, U1, U6, RStride, CStride>>;
+    Matrix<T, U1, U6, ViewStorage<'a, T, U1, U6, RStride, CStride>>;
 
 /// 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<T, U2, U1, SliceStorage<'a, T, U2, U1, RStride, CStride>>;
+    Matrix<T, U2, U1, ViewStorage<'a, T, U2, U1, RStride, CStride>>;
 /// 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<T, U2, U3, SliceStorage<'a, T, U2, U3, RStride, CStride>>;
+    Matrix<T, U2, U3, ViewStorage<'a, T, U2, U3, RStride, CStride>>;
 /// 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<T, U2, U4, SliceStorage<'a, T, U2, U4, RStride, CStride>>;
+    Matrix<T, U2, U4, ViewStorage<'a, T, U2, U4, RStride, CStride>>;
 /// 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<T, U2, U5, SliceStorage<'a, T, U2, U5, RStride, CStride>>;
+    Matrix<T, U2, U5, ViewStorage<'a, T, U2, U5, RStride, CStride>>;
 /// 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<T, U2, U6, SliceStorage<'a, T, U2, U6, RStride, CStride>>;
+    Matrix<T, U2, U6, ViewStorage<'a, T, U2, U6, RStride, CStride>>;
 
 /// 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<T, U3, U1, SliceStorage<'a, T, U3, U1, RStride, CStride>>;
+    Matrix<T, U3, U1, ViewStorage<'a, T, U3, U1, RStride, CStride>>;
 /// 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<T, U3, U2, SliceStorage<'a, T, U3, U2, RStride, CStride>>;
+    Matrix<T, U3, U2, ViewStorage<'a, T, U3, U2, RStride, CStride>>;
 /// 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<T, U3, U4, SliceStorage<'a, T, U3, U4, RStride, CStride>>;
+    Matrix<T, U3, U4, ViewStorage<'a, T, U3, U4, RStride, CStride>>;
 /// 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<T, U3, U5, SliceStorage<'a, T, U3, U5, RStride, CStride>>;
+    Matrix<T, U3, U5, ViewStorage<'a, T, U3, U5, RStride, CStride>>;
 /// 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<T, U3, U6, SliceStorage<'a, T, U3, U6, RStride, CStride>>;
+    Matrix<T, U3, U6, ViewStorage<'a, T, U3, U6, RStride, CStride>>;
 
 /// 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<T, U4, U1, SliceStorage<'a, T, U4, U1, RStride, CStride>>;
+    Matrix<T, U4, U1, ViewStorage<'a, T, U4, U1, RStride, CStride>>;
 /// 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<T, U4, U2, SliceStorage<'a, T, U4, U2, RStride, CStride>>;
+    Matrix<T, U4, U2, ViewStorage<'a, T, U4, U2, RStride, CStride>>;
 /// 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<T, U4, U3, SliceStorage<'a, T, U4, U3, RStride, CStride>>;
+    Matrix<T, U4, U3, ViewStorage<'a, T, U4, U3, RStride, CStride>>;
 /// 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<T, U4, U5, SliceStorage<'a, T, U4, U5, RStride, CStride>>;
+    Matrix<T, U4, U5, ViewStorage<'a, T, U4, U5, RStride, CStride>>;
 /// 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<T, U4, U6, SliceStorage<'a, T, U4, U6, RStride, CStride>>;
+    Matrix<T, U4, U6, ViewStorage<'a, T, U4, U6, RStride, CStride>>;
 
 /// 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<T, U5, U1, SliceStorage<'a, T, U5, U1, RStride, CStride>>;
+    Matrix<T, U5, U1, ViewStorage<'a, T, U5, U1, RStride, CStride>>;
 /// 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<T, U5, U2, SliceStorage<'a, T, U5, U2, RStride, CStride>>;
+    Matrix<T, U5, U2, ViewStorage<'a, T, U5, U2, RStride, CStride>>;
 /// 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<T, U5, U3, SliceStorage<'a, T, U5, U3, RStride, CStride>>;
+    Matrix<T, U5, U3, ViewStorage<'a, T, U5, U3, RStride, CStride>>;
 /// 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<T, U5, U4, SliceStorage<'a, T, U5, U4, RStride, CStride>>;
+    Matrix<T, U5, U4, ViewStorage<'a, T, U5, U4, RStride, CStride>>;
 /// 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<T, U5, U6, SliceStorage<'a, T, U5, U6, RStride, CStride>>;
+    Matrix<T, U5, U6, ViewStorage<'a, T, U5, U6, RStride, CStride>>;
 
 /// 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<T, U6, U1, SliceStorage<'a, T, U6, U1, RStride, CStride>>;
+    Matrix<T, U6, U1, ViewStorage<'a, T, U6, U1, RStride, CStride>>;
 /// 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<T, U6, U2, SliceStorage<'a, T, U6, U2, RStride, CStride>>;
+    Matrix<T, U6, U2, ViewStorage<'a, T, U6, U2, RStride, CStride>>;
 /// 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<T, U6, U3, SliceStorage<'a, T, U6, U3, RStride, CStride>>;
+    Matrix<T, U6, U3, ViewStorage<'a, T, U6, U3, RStride, CStride>>;
 /// 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<T, U6, U4, SliceStorage<'a, T, U6, U4, RStride, CStride>>;
+    Matrix<T, U6, U4, ViewStorage<'a, T, U6, U4, RStride, CStride>>;
 /// 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<T, U6, U5, SliceStorage<'a, T, U6, U5, RStride, CStride>>;
+    Matrix<T, U6, U5, ViewStorage<'a, T, U6, U5, RStride, CStride>>;
 
 /// 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<T, U1, Dynamic, SliceStorage<'a, T, U1, Dynamic, RStride, CStride>>;
+    Matrix<T, U1, Dynamic, ViewStorage<'a, T, U1, Dynamic, RStride, CStride>>;
 /// 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<T, U2, Dynamic, SliceStorage<'a, T, U2, Dynamic, RStride, CStride>>;
+    Matrix<T, U2, Dynamic, ViewStorage<'a, T, U2, Dynamic, RStride, CStride>>;
 /// 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<T, U3, Dynamic, SliceStorage<'a, T, U3, Dynamic, RStride, CStride>>;
+    Matrix<T, U3, Dynamic, ViewStorage<'a, T, U3, Dynamic, RStride, CStride>>;
 /// 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<T, U4, Dynamic, SliceStorage<'a, T, U4, Dynamic, RStride, CStride>>;
+    Matrix<T, U4, Dynamic, ViewStorage<'a, T, U4, Dynamic, RStride, CStride>>;
 /// 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<T, U5, Dynamic, SliceStorage<'a, T, U5, Dynamic, RStride, CStride>>;
+    Matrix<T, U5, Dynamic, ViewStorage<'a, T, U5, Dynamic, RStride, CStride>>;
 /// 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<T, U6, Dynamic, SliceStorage<'a, T, U6, Dynamic, RStride, CStride>>;
+    Matrix<T, U6, Dynamic, ViewStorage<'a, T, U6, Dynamic, RStride, CStride>>;
 
 /// 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<T, Dynamic, U1, SliceStorage<'a, T, Dynamic, U1, RStride, CStride>>;
+    Matrix<T, Dynamic, U1, ViewStorage<'a, T, Dynamic, U1, RStride, CStride>>;
 /// 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<T, Dynamic, U2, SliceStorage<'a, T, Dynamic, U2, RStride, CStride>>;
+    Matrix<T, Dynamic, U2, ViewStorage<'a, T, Dynamic, U2, RStride, CStride>>;
 /// 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<T, Dynamic, U3, SliceStorage<'a, T, Dynamic, U3, RStride, CStride>>;
+    Matrix<T, Dynamic, U3, ViewStorage<'a, T, Dynamic, U3, RStride, CStride>>;
 /// 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<T, Dynamic, U4, SliceStorage<'a, T, Dynamic, U4, RStride, CStride>>;
+    Matrix<T, Dynamic, U4, ViewStorage<'a, T, Dynamic, U4, RStride, CStride>>;
 /// 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<T, Dynamic, U5, SliceStorage<'a, T, Dynamic, U5, RStride, CStride>>;
+    Matrix<T, Dynamic, U5, ViewStorage<'a, T, Dynamic, U5, RStride, CStride>>;
 /// 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<T, Dynamic, U6, SliceStorage<'a, T, Dynamic, U6, RStride, CStride>>;
+    Matrix<T, Dynamic, U6, ViewStorage<'a, T, Dynamic, U6, RStride, CStride>>;
 
 /// 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<T, D, U1, SliceStorage<'a, T, D, U1, RStride, CStride>>;
+    Matrix<T, D, U1, ViewStorage<'a, T, D, U1, RStride, CStride>>;
 
 /// 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<T, Const<D>, Const<1>, SliceStorage<'a, T, Const<D>, Const<1>, Const<1>, Const<D>>>;
+    Matrix<T, Const<D>, Const<1>, ViewStorage<'a, T, Const<D>, Const<1>, Const<1>, Const<D>>>;
 
 /// A column vector slice dynamic numbers of rows and columns.
 pub type DVectorSlice<'a, T, RStride = U1, CStride = Dynamic> =
-    Matrix<T, Dynamic, U1, SliceStorage<'a, T, Dynamic, U1, RStride, CStride>>;
+    Matrix<T, Dynamic, U1, ViewStorage<'a, T, Dynamic, U1, RStride, CStride>>;
 
 /// 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<T, U1, U1, SliceStorage<'a, T, U1, U1, RStride, CStride>>;
+    Matrix<T, U1, U1, ViewStorage<'a, T, U1, U1, RStride, CStride>>;
 /// 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<T, U2, U1, SliceStorage<'a, T, U2, U1, RStride, CStride>>;
+    Matrix<T, U2, U1, ViewStorage<'a, T, U2, U1, RStride, CStride>>;
 /// 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<T, U3, U1, SliceStorage<'a, T, U3, U1, RStride, CStride>>;
+    Matrix<T, U3, U1, ViewStorage<'a, T, U3, U1, RStride, CStride>>;
 /// 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<T, U4, U1, SliceStorage<'a, T, U4, U1, RStride, CStride>>;
+    Matrix<T, U4, U1, ViewStorage<'a, T, U4, U1, RStride, CStride>>;
 /// 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<T, U5, U1, SliceStorage<'a, T, U5, U1, RStride, CStride>>;
+    Matrix<T, U5, U1, ViewStorage<'a, T, U5, U1, RStride, CStride>>;
 /// 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<T, U6, U1, SliceStorage<'a, T, U6, U1, RStride, CStride>>;
+    Matrix<T, U6, U1, ViewStorage<'a, T, U6, U1, RStride, CStride>>;
 
 /*
  *
@@ -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<T, R, C, SliceStorageMut<'a, T, R, C, RStride, CStride>>;
+    Matrix<T, R, C, ViewStorageMut<'a, T, R, C, RStride, CStride>>;
 
 /// 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<T, D, D, SliceStorageMut<'a, T, D, D, RStride, CStride>>;
+    Matrix<T, D, D, ViewStorageMut<'a, T, D, D, RStride, CStride>>;
 
 /// 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<T, Const<R>, Const<C>, SliceStorageMut<'a, T, Const<R>, Const<C>, Const<1>, Const<R>>>;
+    Matrix<T, Const<R>, Const<C>, ViewStorageMut<'a, T, Const<R>, Const<C>, Const<1>, Const<R>>>;
 
 /// 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<T, Dynamic, Dynamic, SliceStorageMut<'a, T, Dynamic, Dynamic, RStride, CStride>>;
+    Matrix<T, Dynamic, Dynamic, ViewStorageMut<'a, T, Dynamic, Dynamic, RStride, CStride>>;
 
 /// 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<T, U1, U1, SliceStorageMut<'a, T, U1, U1, RStride, CStride>>;
+    Matrix<T, U1, U1, ViewStorageMut<'a, T, U1, U1, RStride, CStride>>;
 /// 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<T, U2, U2, SliceStorageMut<'a, T, U2, U2, RStride, CStride>>;
+    Matrix<T, U2, U2, ViewStorageMut<'a, T, U2, U2, RStride, CStride>>;
 /// 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<T, U3, U3, SliceStorageMut<'a, T, U3, U3, RStride, CStride>>;
+    Matrix<T, U3, U3, ViewStorageMut<'a, T, U3, U3, RStride, CStride>>;
 /// 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<T, U4, U4, SliceStorageMut<'a, T, U4, U4, RStride, CStride>>;
+    Matrix<T, U4, U4, ViewStorageMut<'a, T, U4, U4, RStride, CStride>>;
 /// 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<T, U5, U5, SliceStorageMut<'a, T, U5, U5, RStride, CStride>>;
+    Matrix<T, U5, U5, ViewStorageMut<'a, T, U5, U5, RStride, CStride>>;
 /// 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<T, U6, U6, SliceStorageMut<'a, T, U6, U6, RStride, CStride>>;
+    Matrix<T, U6, U6, ViewStorageMut<'a, T, U6, U6, RStride, CStride>>;
 
 /// 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<T, U1, U2, SliceStorageMut<'a, T, U1, U2, RStride, CStride>>;
+    Matrix<T, U1, U2, ViewStorageMut<'a, T, U1, U2, RStride, CStride>>;
 /// 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<T, U1, U3, SliceStorageMut<'a, T, U1, U3, RStride, CStride>>;
+    Matrix<T, U1, U3, ViewStorageMut<'a, T, U1, U3, RStride, CStride>>;
 /// 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<T, U1, U4, SliceStorageMut<'a, T, U1, U4, RStride, CStride>>;
+    Matrix<T, U1, U4, ViewStorageMut<'a, T, U1, U4, RStride, CStride>>;
 /// 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<T, U1, U5, SliceStorageMut<'a, T, U1, U5, RStride, CStride>>;
+    Matrix<T, U1, U5, ViewStorageMut<'a, T, U1, U5, RStride, CStride>>;
 /// 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<T, U1, U6, SliceStorageMut<'a, T, U1, U6, RStride, CStride>>;
+    Matrix<T, U1, U6, ViewStorageMut<'a, T, U1, U6, RStride, CStride>>;
 
 /// 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<T, U2, U1, SliceStorageMut<'a, T, U2, U1, RStride, CStride>>;
+    Matrix<T, U2, U1, ViewStorageMut<'a, T, U2, U1, RStride, CStride>>;
 /// 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<T, U2, U3, SliceStorageMut<'a, T, U2, U3, RStride, CStride>>;
+    Matrix<T, U2, U3, ViewStorageMut<'a, T, U2, U3, RStride, CStride>>;
 /// 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<T, U2, U4, SliceStorageMut<'a, T, U2, U4, RStride, CStride>>;
+    Matrix<T, U2, U4, ViewStorageMut<'a, T, U2, U4, RStride, CStride>>;
 /// 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<T, U2, U5, SliceStorageMut<'a, T, U2, U5, RStride, CStride>>;
+    Matrix<T, U2, U5, ViewStorageMut<'a, T, U2, U5, RStride, CStride>>;
 /// 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<T, U2, U6, SliceStorageMut<'a, T, U2, U6, RStride, CStride>>;
+    Matrix<T, U2, U6, ViewStorageMut<'a, T, U2, U6, RStride, CStride>>;
 
 /// 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<T, U3, U1, SliceStorageMut<'a, T, U3, U1, RStride, CStride>>;
+    Matrix<T, U3, U1, ViewStorageMut<'a, T, U3, U1, RStride, CStride>>;
 /// 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<T, U3, U2, SliceStorageMut<'a, T, U3, U2, RStride, CStride>>;
+    Matrix<T, U3, U2, ViewStorageMut<'a, T, U3, U2, RStride, CStride>>;
 /// 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<T, U3, U4, SliceStorageMut<'a, T, U3, U4, RStride, CStride>>;
+    Matrix<T, U3, U4, ViewStorageMut<'a, T, U3, U4, RStride, CStride>>;
 /// 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<T, U3, U5, SliceStorageMut<'a, T, U3, U5, RStride, CStride>>;
+    Matrix<T, U3, U5, ViewStorageMut<'a, T, U3, U5, RStride, CStride>>;
 /// 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<T, U3, U6, SliceStorageMut<'a, T, U3, U6, RStride, CStride>>;
+    Matrix<T, U3, U6, ViewStorageMut<'a, T, U3, U6, RStride, CStride>>;
 
 /// 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<T, U4, U1, SliceStorageMut<'a, T, U4, U1, RStride, CStride>>;
+    Matrix<T, U4, U1, ViewStorageMut<'a, T, U4, U1, RStride, CStride>>;
 /// 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<T, U4, U2, SliceStorageMut<'a, T, U4, U2, RStride, CStride>>;
+    Matrix<T, U4, U2, ViewStorageMut<'a, T, U4, U2, RStride, CStride>>;
 /// 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<T, U4, U3, SliceStorageMut<'a, T, U4, U3, RStride, CStride>>;
+    Matrix<T, U4, U3, ViewStorageMut<'a, T, U4, U3, RStride, CStride>>;
 /// 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<T, U4, U5, SliceStorageMut<'a, T, U4, U5, RStride, CStride>>;
+    Matrix<T, U4, U5, ViewStorageMut<'a, T, U4, U5, RStride, CStride>>;
 /// 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<T, U4, U6, SliceStorageMut<'a, T, U4, U6, RStride, CStride>>;
+    Matrix<T, U4, U6, ViewStorageMut<'a, T, U4, U6, RStride, CStride>>;
 
 /// 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<T, U5, U1, SliceStorageMut<'a, T, U5, U1, RStride, CStride>>;
+    Matrix<T, U5, U1, ViewStorageMut<'a, T, U5, U1, RStride, CStride>>;
 /// 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<T, U5, U2, SliceStorageMut<'a, T, U5, U2, RStride, CStride>>;
+    Matrix<T, U5, U2, ViewStorageMut<'a, T, U5, U2, RStride, CStride>>;
 /// 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<T, U5, U3, SliceStorageMut<'a, T, U5, U3, RStride, CStride>>;
+    Matrix<T, U5, U3, ViewStorageMut<'a, T, U5, U3, RStride, CStride>>;
 /// 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<T, U5, U4, SliceStorageMut<'a, T, U5, U4, RStride, CStride>>;
+    Matrix<T, U5, U4, ViewStorageMut<'a, T, U5, U4, RStride, CStride>>;
 /// 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<T, U5, U6, SliceStorageMut<'a, T, U5, U6, RStride, CStride>>;
+    Matrix<T, U5, U6, ViewStorageMut<'a, T, U5, U6, RStride, CStride>>;
 
 /// 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<T, U6, U1, SliceStorageMut<'a, T, U6, U1, RStride, CStride>>;
+    Matrix<T, U6, U1, ViewStorageMut<'a, T, U6, U1, RStride, CStride>>;
 /// 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<T, U6, U2, SliceStorageMut<'a, T, U6, U2, RStride, CStride>>;
+    Matrix<T, U6, U2, ViewStorageMut<'a, T, U6, U2, RStride, CStride>>;
 /// 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<T, U6, U3, SliceStorageMut<'a, T, U6, U3, RStride, CStride>>;
+    Matrix<T, U6, U3, ViewStorageMut<'a, T, U6, U3, RStride, CStride>>;
 /// 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<T, U6, U4, SliceStorageMut<'a, T, U6, U4, RStride, CStride>>;
+    Matrix<T, U6, U4, ViewStorageMut<'a, T, U6, U4, RStride, CStride>>;
 /// 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<T, U6, U5, SliceStorageMut<'a, T, U6, U5, RStride, CStride>>;
+    Matrix<T, U6, U5, ViewStorageMut<'a, T, U6, U5, RStride, CStride>>;
 
 /// 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<T, U1, Dynamic, SliceStorageMut<'a, T, U1, Dynamic, RStride, CStride>>;
+    Matrix<T, U1, Dynamic, ViewStorageMut<'a, T, U1, Dynamic, RStride, CStride>>;
 /// 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<T, U2, Dynamic, SliceStorageMut<'a, T, U2, Dynamic, RStride, CStride>>;
+    Matrix<T, U2, Dynamic, ViewStorageMut<'a, T, U2, Dynamic, RStride, CStride>>;
 /// 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<T, U3, Dynamic, SliceStorageMut<'a, T, U3, Dynamic, RStride, CStride>>;
+    Matrix<T, U3, Dynamic, ViewStorageMut<'a, T, U3, Dynamic, RStride, CStride>>;
 /// 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<T, U4, Dynamic, SliceStorageMut<'a, T, U4, Dynamic, RStride, CStride>>;
+    Matrix<T, U4, Dynamic, ViewStorageMut<'a, T, U4, Dynamic, RStride, CStride>>;
 /// 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<T, U5, Dynamic, SliceStorageMut<'a, T, U5, Dynamic, RStride, CStride>>;
+    Matrix<T, U5, Dynamic, ViewStorageMut<'a, T, U5, Dynamic, RStride, CStride>>;
 /// 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<T, U6, Dynamic, SliceStorageMut<'a, T, U6, Dynamic, RStride, CStride>>;
+    Matrix<T, U6, Dynamic, ViewStorageMut<'a, T, U6, Dynamic, RStride, CStride>>;
 
 /// 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<T, Dynamic, U1, SliceStorageMut<'a, T, Dynamic, U1, RStride, CStride>>;
+    Matrix<T, Dynamic, U1, ViewStorageMut<'a, T, Dynamic, U1, RStride, CStride>>;
 /// 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<T, Dynamic, U2, SliceStorageMut<'a, T, Dynamic, U2, RStride, CStride>>;
+    Matrix<T, Dynamic, U2, ViewStorageMut<'a, T, Dynamic, U2, RStride, CStride>>;
 /// 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<T, Dynamic, U3, SliceStorageMut<'a, T, Dynamic, U3, RStride, CStride>>;
+    Matrix<T, Dynamic, U3, ViewStorageMut<'a, T, Dynamic, U3, RStride, CStride>>;
 /// 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<T, Dynamic, U4, SliceStorageMut<'a, T, Dynamic, U4, RStride, CStride>>;
+    Matrix<T, Dynamic, U4, ViewStorageMut<'a, T, Dynamic, U4, RStride, CStride>>;
 /// 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<T, Dynamic, U5, SliceStorageMut<'a, T, Dynamic, U5, RStride, CStride>>;
+    Matrix<T, Dynamic, U5, ViewStorageMut<'a, T, Dynamic, U5, RStride, CStride>>;
 /// 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<T, Dynamic, U6, SliceStorageMut<'a, T, Dynamic, U6, RStride, CStride>>;
+    Matrix<T, Dynamic, U6, ViewStorageMut<'a, T, Dynamic, U6, RStride, CStride>>;
 
 /// 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<T, D, U1, SliceStorageMut<'a, T, D, U1, RStride, CStride>>;
+    Matrix<T, D, U1, ViewStorageMut<'a, T, D, U1, RStride, CStride>>;
 
 /// 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<T, Const<D>, Const<1>, SliceStorageMut<'a, T, Const<D>, Const<1>, Const<1>, Const<D>>>;
+    Matrix<T, Const<D>, Const<1>, ViewStorageMut<'a, T, Const<D>, Const<1>, Const<1>, Const<D>>>;
 
 /// 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<T, Dynamic, U1, SliceStorageMut<'a, T, Dynamic, U1, RStride, CStride>>;
+    Matrix<T, Dynamic, U1, ViewStorageMut<'a, T, Dynamic, U1, RStride, CStride>>;
 
 /// 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<T, U1, U1, SliceStorageMut<'a, T, U1, U1, RStride, CStride>>;
+    Matrix<T, U1, U1, ViewStorageMut<'a, T, U1, U1, RStride, CStride>>;
 /// 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<T, U2, U1, SliceStorageMut<'a, T, U2, U1, RStride, CStride>>;
+    Matrix<T, U2, U1, ViewStorageMut<'a, T, U2, U1, RStride, CStride>>;
 /// 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<T, U3, U1, SliceStorageMut<'a, T, U3, U1, RStride, CStride>>;
+    Matrix<T, U3, U1, ViewStorageMut<'a, T, U3, U1, RStride, CStride>>;
 /// 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<T, U4, U1, SliceStorageMut<'a, T, U4, U1, RStride, CStride>>;
+    Matrix<T, U4, U1, ViewStorageMut<'a, T, U4, U1, RStride, CStride>>;
 /// 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<T, U5, U1, SliceStorageMut<'a, T, U5, U1, RStride, CStride>>;
+    Matrix<T, U5, U1, ViewStorageMut<'a, T, U5, U1, RStride, CStride>>;
 /// 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<T, U6, U1, SliceStorageMut<'a, T, U6, U1, RStride, CStride>>;
+    Matrix<T, U6, U1, ViewStorageMut<'a, T, U6, U1, RStride, CStride>>;
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<T, $R, $C, S>) -> 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<T, $R, $C, S>) -> 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<RStor, CStor, S>(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<S, RStor, CStor, RStride, CStride>(storage: $SRef,
                                                                                         start:   (usize, usize),
@@ -82,7 +93,7 @@ macro_rules! slice_storage_impl(
         where
             Self: RawStorage<T, R, C> + 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<T, R, C> + 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<T, R, C>
-    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<T,
     }
 }
 
-unsafe impl<'a, T, R: Dim, CStride: Dim> 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<T, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S> {
     }
 }
 
-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::<RSLICE>, Const::<CSLICE>);
 
             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<T, R, C, SliceStorage<'a, T, R, C, RStride, CStride>>;
+    Matrix<T, R, C, ViewStorage<'a, T, R, C, RStride, CStride>>;
 /// A mutable matrix slice.
 pub type MatrixSliceMut<'a, T, R, C, RStride = U1, CStride = R> =
-    Matrix<T, R, C, SliceStorageMut<'a, T, R, C, RStride, CStride>>;
+    Matrix<T, R, C, ViewStorageMut<'a, T, R, C, RStride, CStride>>;
 
 /// # Slicing based on index and length
 impl<T, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S> {
     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<T, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S> {
 /// # Mutable slicing based on index and length
 impl<T, R: Dim, C: Dim, S: RawStorageMut<T, R, C>> Matrix<T, R, C, S> {
     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 <andreas.b.longva@gmail.com>
Date: Fri, 11 Nov 2022 16:10:39 +0100
Subject: [PATCH 042/119] 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<T: Scalar, const R: usize, const C: usize> From<SMatrix<T, R, C>> for [[T;
 }
 
 impl<'a, T: Scalar, RStride: Dim, CStride: Dim, const R: usize, const C: usize>
-    From<MatrixSlice<'a, T, Const<R>, Const<C>, RStride, CStride>> for [[T; R]; C]
+    From<MatrixView<'a, T, Const<R>, Const<C>, RStride, CStride>> for [[T; R]; C]
 {
     #[inline]
-    fn from(mat: MatrixSlice<'a, T, Const<R>, Const<C>, RStride, CStride>) -> Self {
+    fn from(mat: MatrixView<'a, T, Const<R>, Const<C>, RStride, CStride>) -> Self {
         mat.into_owned().into()
     }
 }
 
 impl<'a, T: Scalar, RStride: Dim, CStride: Dim, const R: usize, const C: usize>
-    From<MatrixSliceMut<'a, T, Const<R>, Const<C>, RStride, CStride>> for [[T; R]; C]
+    From<MatrixViewMut<'a, T, Const<R>, Const<C>, RStride, CStride>> for [[T; R]; C]
 {
     #[inline]
-    fn from(mat: MatrixSliceMut<'a, T, Const<R>, Const<C>, RStride, CStride>) -> Self {
+    fn from(mat: MatrixViewMut<'a, T, Const<R>, Const<C>, 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<MatrixSlice<'a, T, Const<R>, Const<C>, RStride, CStride>>
+    From<MatrixView<'a, T, Const<R>, Const<C>, RStride, CStride>>
     for Matrix<T, Const<R>, Const<C>, ArrayStorage<T, R, C>>
 where
     T: Scalar,
     RStride: Dim,
     CStride: Dim,
 {
-    fn from(matrix_slice: MatrixSlice<'a, T, Const<R>, Const<C>, RStride, CStride>) -> Self {
+    fn from(matrix_slice: MatrixView<'a, T, Const<R>, Const<C>, RStride, CStride>) -> Self {
         matrix_slice.into_owned()
     }
 }
 
 #[cfg(any(feature = "std", feature = "alloc"))]
-impl<'a, T, C, RStride, CStride> From<MatrixSlice<'a, T, Dynamic, C, RStride, CStride>>
+impl<'a, T, C, RStride, CStride> From<MatrixView<'a, T, Dynamic, C, RStride, CStride>>
     for Matrix<T, Dynamic, C, VecStorage<T, Dynamic, C>>
 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<MatrixSlice<'a, T, R, Dynamic, RStride, CStride>>
+impl<'a, T, R, RStride, CStride> From<MatrixView<'a, T, R, Dynamic, RStride, CStride>>
     for Matrix<T, R, Dynamic, VecStorage<T, R, Dynamic>>
 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<MatrixSliceMut<'a, T, Const<R>, Const<C>, RStride, CStride>>
+    From<MatrixViewMut<'a, T, Const<R>, Const<C>, RStride, CStride>>
     for Matrix<T, Const<R>, Const<C>, ArrayStorage<T, R, C>>
 where
     T: Scalar,
     RStride: Dim,
     CStride: Dim,
 {
-    fn from(matrix_slice: MatrixSliceMut<'a, T, Const<R>, Const<C>, RStride, CStride>) -> Self {
+    fn from(matrix_slice: MatrixViewMut<'a, T, Const<R>, Const<C>, RStride, CStride>) -> Self {
         matrix_slice.into_owned()
     }
 }
 
 #[cfg(any(feature = "std", feature = "alloc"))]
-impl<'a, T, C, RStride, CStride> From<MatrixSliceMut<'a, T, Dynamic, C, RStride, CStride>>
+impl<'a, T, C, RStride, CStride> From<MatrixViewMut<'a, T, Dynamic, C, RStride, CStride>>
     for Matrix<T, Dynamic, C, VecStorage<T, Dynamic, C>>
 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<MatrixSliceMut<'a, T, R, Dynamic, RStride, CStride>>
+impl<'a, T, R, RStride, CStride> From<MatrixViewMut<'a, T, R, Dynamic, RStride, CStride>>
     for Matrix<T, R, Dynamic, VecStorage<T, R, Dynamic>>
 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<T, R, C, S>>
-    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<T, R, C, S>>
-    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<T, R, C, S>>
-    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<T, R, C>> RowIter<'a, T, R, C, S>
 }
 
 impl<'a, T, R: Dim, C: Dim, S: 'a + RawStorage<T, R, C>> 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<Self::Item> {
@@ -254,7 +254,7 @@ impl<'a, T, R: Dim, C: Dim, S: 'a + RawStorageMut<T, R, C>> RowIterMut<'a, T, R,
 impl<'a, T, R: Dim, C: Dim, S: 'a + RawStorageMut<T, R, C>> 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<Self::Item> {
@@ -306,7 +306,7 @@ impl<'a, T, R: Dim, C: Dim, S: 'a + RawStorage<T, R, C>> ColumnIter<'a, T, R, C,
 }
 
 impl<'a, T, R: Dim, C: Dim, S: 'a + RawStorage<T, R, C>> 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<Self::Item> {
@@ -367,7 +367,7 @@ impl<'a, T, R: Dim, C: Dim, S: 'a + RawStorageMut<T, R, C>> ColumnIterMut<'a, T,
 impl<'a, T, R: Dim, C: Dim, S: 'a + RawStorageMut<T, R, C>> 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<Self::Item> {
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<T, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S> {
 }
 
 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<const RSLICE: usize>($me: $Me, first_row: usize)
-            -> $MatrixSlice<'_, T, Const<RSLICE>, C, S::RStride, S::CStride> {
+            -> $MatrixView<'_, T, Const<RSLICE>, C, S::RStride, S::CStride> {
 
             $me.$rows_generic(first_row, Const::<RSLICE>)
         }
@@ -355,7 +355,7 @@ macro_rules! matrix_slice_impl (
         /// rows.
         #[inline]
         pub fn $fixed_rows_with_step<const RSLICE: usize>($me: $Me, first_row: usize, step: usize)
-            -> $MatrixSlice<'_, T, Const<RSLICE>, C, Dynamic, S::CStride> {
+            -> $MatrixView<'_, T, Const<RSLICE>, C, Dynamic, S::CStride> {
 
             $me.$rows_generic_with_step(first_row, Const::<RSLICE>, 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<RSlice: Dim>($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<RSlice>($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<const CSLICE: usize>($me: $Me, first_col: usize)
-            -> $MatrixSlice<'_, T, R, Const<CSLICE>, S::RStride, S::CStride> {
+            -> $MatrixView<'_, T, R, Const<CSLICE>, S::RStride, S::CStride> {
 
             $me.$columns_generic(first_col, Const::<CSLICE>)
         }
@@ -443,7 +443,7 @@ macro_rules! matrix_slice_impl (
         /// `step` columns.
         #[inline]
         pub fn $fixed_columns_with_step<const CSLICE: usize>($me: $Me, first_col: usize, step: usize)
-            -> $MatrixSlice<'_, T, R, Const<CSLICE>, S::RStride, Dynamic> {
+            -> $MatrixView<'_, T, R, Const<CSLICE>, S::RStride, Dynamic> {
 
             $me.$columns_generic_with_step(first_col, Const::<CSLICE>, step)
         }
@@ -452,7 +452,7 @@ macro_rules! matrix_slice_impl (
         /// known at compile-time.
         #[inline]
         pub fn $columns_generic<CSlice: Dim>($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<CSlice: Dim>($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<const RSLICE: usize, const CSLICE: usize>($me: $Me, irow: usize, icol: usize)
-            -> $MatrixSlice<'_, T, Const<RSLICE>, Const<CSLICE>, S::RStride, S::CStride> {
+            -> $MatrixView<'_, T, Const<RSLICE>, Const<CSLICE>, S::RStride, S::CStride> {
 
             $me.assert_slice_index((irow, icol), (RSLICE, CSLICE), (0, 0));
             let shape = (Const::<RSLICE>, Const::<CSLICE>);
@@ -539,7 +539,7 @@ macro_rules! matrix_slice_impl (
         /// the original matrix.
         #[inline]
         pub fn $fixed_slice_with_steps<const RSLICE: usize, const CSLICE: usize>($me: $Me, start: (usize, usize), steps: (usize, usize))
-            -> $MatrixSlice<'_, T, Const<RSLICE>, Const<CSLICE>, Dynamic, Dynamic> {
+            -> $MatrixView<'_, T, Const<RSLICE>, Const<CSLICE>, Dynamic, Dynamic> {
             let shape = (Const::<RSLICE>, Const::<CSLICE>);
             $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<RSlice, CSlice>($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<Range1: SliceRange<R>, Range2: SliceRange<R>>($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<Range1: SliceRange<C>, Range2: SliceRange<C>>($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<T, R, C, ViewStorage<'a, T, R, C, RStride, CStride>>;
+
 /// 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<T, R, C, ViewStorageMut<'a, T, R, C, RStride, CStride>>;
 
 /// # Slicing based on index and length
 impl<T, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S> {
     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<T, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S> {
 /// # Mutable slicing based on index and length
 impl<T, R: Dim, C: Dim, S: RawStorageMut<T, R, C>> Matrix<T, R, C, S> {
     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<T, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S> {
         &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<R>,
         ColRange: SliceRange<C>,
@@ -890,7 +911,7 @@ impl<T, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S> {
     pub fn rows_range<RowRange: SliceRange<R>>(
         &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<T, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S> {
     pub fn columns_range<ColRange: SliceRange<C>>(
         &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<T, R: Dim, C: Dim, S: RawStorageMut<T, R, C>> Matrix<T, R, C, S> {
         &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<R>,
         ColRange: SliceRange<C>,
@@ -931,7 +952,7 @@ impl<T, R: Dim, C: Dim, S: RawStorageMut<T, R, C>> Matrix<T, R, C, S> {
     pub fn rows_range_mut<RowRange: SliceRange<R>>(
         &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<T, R: Dim, C: Dim, S: RawStorageMut<T, R, C>> Matrix<T, R, C, S> {
     pub fn columns_range_mut<ColRange: SliceRange<C>>(
         &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<MatrixSliceMut<'a, T, R, C, RStride, CStride>>
-    for MatrixSlice<'a, T, R, C, RStride, CStride>
+impl<'a, T, R, C, RStride, CStride> From<MatrixViewMut<'a, T, R, C, RStride, CStride>>
+    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<T, U4, U1>, CStride<T, U4, U1>> {
+    pub fn vector(&self) -> MatrixView<'_, T, U3, U1, RStride<T, U4, U1>, CStride<T, U4, U1>> {
         self.coords.fixed_rows::<3>(0)
     }
 
@@ -584,7 +584,7 @@ where
     #[inline]
     pub fn vector_mut(
         &mut self,
-    ) -> MatrixSliceMut<'_, T, U3, U1, RStride<T, U4, U1>, CStride<T, U4, U1>> {
+    ) -> MatrixViewMut<'_, T, U3, U1, RStride<T, U4, U1>, CStride<T, U4, U1>> {
         self.coords.fixed_rows_mut::<3>(0)
     }
 

From 9a7e92e90232cac0ec2d5635c2dc705b0faae1d4 Mon Sep 17 00:00:00 2001
From: Andreas Longva <andreas.b.longva@gmail.com>
Date: Fri, 11 Nov 2022 17:29:55 +0100
Subject: [PATCH 043/119] 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 <andreas.b.longva@gmail.com>
Date: Fri, 11 Nov 2022 17:36:50 +0100
Subject: [PATCH 044/119] 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<T, Const<R>, Const<C>, ViewStorage<'a, T, Const<R>, Const<C>, Const<1>, Const<R>>>;
+
+/// 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<T, Dynamic, Dynamic, ViewStorage<'a, T, Dynamic, Dynamic, RStride, CStride>>;
+
+/// 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<T, U1, U1, ViewStorage<'a, T, U1, U1, RStride, CStride>>;
+/// 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<T, U2, U2, ViewStorage<'a, T, U2, U2, RStride, CStride>>;
+/// 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<T, U3, U3, ViewStorage<'a, T, U3, U3, RStride, CStride>>;
+/// 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<T, U4, U4, ViewStorage<'a, T, U4, U4, RStride, CStride>>;
+/// 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<T, U5, U5, ViewStorage<'a, T, U5, U5, RStride, CStride>>;
+/// 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<T, U6, U6, ViewStorage<'a, T, U6, U6, RStride, CStride>>;
+
+/// 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<T, U1, U2, ViewStorage<'a, T, U1, U2, RStride, CStride>>;
+/// 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<T, U1, U3, ViewStorage<'a, T, U1, U3, RStride, CStride>>;
+/// 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<T, U1, U4, ViewStorage<'a, T, U1, U4, RStride, CStride>>;
+/// 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<T, U1, U5, ViewStorage<'a, T, U1, U5, RStride, CStride>>;
+/// 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<T, U1, U6, ViewStorage<'a, T, U1, U6, RStride, CStride>>;
+
+/// 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<T, U2, U1, ViewStorage<'a, T, U2, U1, RStride, CStride>>;
+/// 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<T, U2, U3, ViewStorage<'a, T, U2, U3, RStride, CStride>>;
+/// 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<T, U2, U4, ViewStorage<'a, T, U2, U4, RStride, CStride>>;
+/// 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<T, U2, U5, ViewStorage<'a, T, U2, U5, RStride, CStride>>;
+/// 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<T, U2, U6, ViewStorage<'a, T, U2, U6, RStride, CStride>>;
+
+/// 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<T, U3, U1, ViewStorage<'a, T, U3, U1, RStride, CStride>>;
+/// 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<T, U3, U2, ViewStorage<'a, T, U3, U2, RStride, CStride>>;
+/// 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<T, U3, U4, ViewStorage<'a, T, U3, U4, RStride, CStride>>;
+/// 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<T, U3, U5, ViewStorage<'a, T, U3, U5, RStride, CStride>>;
+/// 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<T, U3, U6, ViewStorage<'a, T, U3, U6, RStride, CStride>>;
+
+/// 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<T, U4, U1, ViewStorage<'a, T, U4, U1, RStride, CStride>>;
+/// 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<T, U4, U2, ViewStorage<'a, T, U4, U2, RStride, CStride>>;
+/// 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<T, U4, U3, ViewStorage<'a, T, U4, U3, RStride, CStride>>;
+/// 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<T, U4, U5, ViewStorage<'a, T, U4, U5, RStride, CStride>>;
+/// 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<T, U4, U6, ViewStorage<'a, T, U4, U6, RStride, CStride>>;
+
+/// 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<T, U5, U1, ViewStorage<'a, T, U5, U1, RStride, CStride>>;
+/// 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<T, U5, U2, ViewStorage<'a, T, U5, U2, RStride, CStride>>;
+/// 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<T, U5, U3, ViewStorage<'a, T, U5, U3, RStride, CStride>>;
+/// 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<T, U5, U4, ViewStorage<'a, T, U5, U4, RStride, CStride>>;
+/// 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<T, U5, U6, ViewStorage<'a, T, U5, U6, RStride, CStride>>;
+
+/// 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<T, U6, U1, ViewStorage<'a, T, U6, U1, RStride, CStride>>;
+/// 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<T, U6, U2, ViewStorage<'a, T, U6, U2, RStride, CStride>>;
+/// 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<T, U6, U3, ViewStorage<'a, T, U6, U3, RStride, CStride>>;
+/// 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<T, U6, U4, ViewStorage<'a, T, U6, U4, RStride, CStride>>;
+/// 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<T, U6, U5, ViewStorage<'a, T, U6, U5, RStride, CStride>>;
+
+/// 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<T, U1, Dynamic, ViewStorage<'a, T, U1, Dynamic, RStride, CStride>>;
+/// 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<T, U2, Dynamic, ViewStorage<'a, T, U2, Dynamic, RStride, CStride>>;
+/// 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<T, U3, Dynamic, ViewStorage<'a, T, U3, Dynamic, RStride, CStride>>;
+/// 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<T, U4, Dynamic, ViewStorage<'a, T, U4, Dynamic, RStride, CStride>>;
+/// 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<T, U5, Dynamic, ViewStorage<'a, T, U5, Dynamic, RStride, CStride>>;
+/// 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<T, U6, Dynamic, ViewStorage<'a, T, U6, Dynamic, RStride, CStride>>;
+
+/// 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<T, Dynamic, U1, ViewStorage<'a, T, Dynamic, U1, RStride, CStride>>;
+/// 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<T, Dynamic, U2, ViewStorage<'a, T, Dynamic, U2, RStride, CStride>>;
+/// 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<T, Dynamic, U3, ViewStorage<'a, T, Dynamic, U3, RStride, CStride>>;
+/// 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<T, Dynamic, U4, ViewStorage<'a, T, Dynamic, U4, RStride, CStride>>;
+/// 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<T, Dynamic, U5, ViewStorage<'a, T, Dynamic, U5, RStride, CStride>>;
+/// 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<T, Dynamic, U6, ViewStorage<'a, T, Dynamic, U6, RStride, CStride>>;
+
+/// 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<T, D, U1, ViewStorage<'a, T, D, U1, RStride, CStride>>;
+
+/// 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<T, Const<D>, Const<1>, ViewStorage<'a, T, Const<D>, Const<1>, Const<1>, Const<D>>>;
+
+/// A column vector view dynamic numbers of rows and columns.
+pub type DVectorView<'a, T, RStride = U1, CStride = Dynamic> =
+    Matrix<T, Dynamic, U1, ViewStorage<'a, T, Dynamic, U1, RStride, CStride>>;
+
+/// 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<T, U1, U1, ViewStorage<'a, T, U1, U1, RStride, CStride>>;
+/// 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<T, U2, U1, ViewStorage<'a, T, U2, U1, RStride, CStride>>;
+/// 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<T, U3, U1, ViewStorage<'a, T, U3, U1, RStride, CStride>>;
+/// 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<T, U4, U1, ViewStorage<'a, T, U4, U1, RStride, CStride>>;
+/// 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<T, U5, U1, ViewStorage<'a, T, U5, U1, RStride, CStride>>;
+/// 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<T, U6, U1, ViewStorage<'a, T, U6, U1, RStride, CStride>>;
+
+/*
+ *
+ *
+ * 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<T, Const<R>, Const<C>, ViewStorageMut<'a, T, Const<R>, Const<C>, Const<1>, Const<R>>>;
+
+/// 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<T, Dynamic, Dynamic, ViewStorageMut<'a, T, Dynamic, Dynamic, RStride, CStride>>;
+
+/// 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<T, U1, U1, ViewStorageMut<'a, T, U1, U1, RStride, CStride>>;
+/// 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<T, U2, U2, ViewStorageMut<'a, T, U2, U2, RStride, CStride>>;
+/// 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<T, U3, U3, ViewStorageMut<'a, T, U3, U3, RStride, CStride>>;
+/// 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<T, U4, U4, ViewStorageMut<'a, T, U4, U4, RStride, CStride>>;
+/// 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<T, U5, U5, ViewStorageMut<'a, T, U5, U5, RStride, CStride>>;
+/// 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<T, U6, U6, ViewStorageMut<'a, T, U6, U6, RStride, CStride>>;
+
+/// 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<T, U1, U2, ViewStorageMut<'a, T, U1, U2, RStride, CStride>>;
+/// 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<T, U1, U3, ViewStorageMut<'a, T, U1, U3, RStride, CStride>>;
+/// 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<T, U1, U4, ViewStorageMut<'a, T, U1, U4, RStride, CStride>>;
+/// 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<T, U1, U5, ViewStorageMut<'a, T, U1, U5, RStride, CStride>>;
+/// 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<T, U1, U6, ViewStorageMut<'a, T, U1, U6, RStride, CStride>>;
+
+/// 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<T, U2, U1, ViewStorageMut<'a, T, U2, U1, RStride, CStride>>;
+/// 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<T, U2, U3, ViewStorageMut<'a, T, U2, U3, RStride, CStride>>;
+/// 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<T, U2, U4, ViewStorageMut<'a, T, U2, U4, RStride, CStride>>;
+/// 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<T, U2, U5, ViewStorageMut<'a, T, U2, U5, RStride, CStride>>;
+/// 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<T, U2, U6, ViewStorageMut<'a, T, U2, U6, RStride, CStride>>;
+
+/// 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<T, U3, U1, ViewStorageMut<'a, T, U3, U1, RStride, CStride>>;
+/// 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<T, U3, U2, ViewStorageMut<'a, T, U3, U2, RStride, CStride>>;
+/// 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<T, U3, U4, ViewStorageMut<'a, T, U3, U4, RStride, CStride>>;
+/// 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<T, U3, U5, ViewStorageMut<'a, T, U3, U5, RStride, CStride>>;
+/// 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<T, U3, U6, ViewStorageMut<'a, T, U3, U6, RStride, CStride>>;
+
+/// 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<T, U4, U1, ViewStorageMut<'a, T, U4, U1, RStride, CStride>>;
+/// 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<T, U4, U2, ViewStorageMut<'a, T, U4, U2, RStride, CStride>>;
+/// 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<T, U4, U3, ViewStorageMut<'a, T, U4, U3, RStride, CStride>>;
+/// 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<T, U4, U5, ViewStorageMut<'a, T, U4, U5, RStride, CStride>>;
+/// 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<T, U4, U6, ViewStorageMut<'a, T, U4, U6, RStride, CStride>>;
+
+/// 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<T, U5, U1, ViewStorageMut<'a, T, U5, U1, RStride, CStride>>;
+/// 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<T, U5, U2, ViewStorageMut<'a, T, U5, U2, RStride, CStride>>;
+/// 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<T, U5, U3, ViewStorageMut<'a, T, U5, U3, RStride, CStride>>;
+/// 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<T, U5, U4, ViewStorageMut<'a, T, U5, U4, RStride, CStride>>;
+/// 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<T, U5, U6, ViewStorageMut<'a, T, U5, U6, RStride, CStride>>;
+
+/// 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<T, U6, U1, ViewStorageMut<'a, T, U6, U1, RStride, CStride>>;
+/// 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<T, U6, U2, ViewStorageMut<'a, T, U6, U2, RStride, CStride>>;
+/// 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<T, U6, U3, ViewStorageMut<'a, T, U6, U3, RStride, CStride>>;
+/// 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<T, U6, U4, ViewStorageMut<'a, T, U6, U4, RStride, CStride>>;
+/// 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<T, U6, U5, ViewStorageMut<'a, T, U6, U5, RStride, CStride>>;
+
+/// 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<T, U1, Dynamic, ViewStorageMut<'a, T, U1, Dynamic, RStride, CStride>>;
+/// 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<T, U2, Dynamic, ViewStorageMut<'a, T, U2, Dynamic, RStride, CStride>>;
+/// 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<T, U3, Dynamic, ViewStorageMut<'a, T, U3, Dynamic, RStride, CStride>>;
+/// 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<T, U4, Dynamic, ViewStorageMut<'a, T, U4, Dynamic, RStride, CStride>>;
+/// 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<T, U5, Dynamic, ViewStorageMut<'a, T, U5, Dynamic, RStride, CStride>>;
+/// 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<T, U6, Dynamic, ViewStorageMut<'a, T, U6, Dynamic, RStride, CStride>>;
+
+/// 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<T, Dynamic, U1, ViewStorageMut<'a, T, Dynamic, U1, RStride, CStride>>;
+/// 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<T, Dynamic, U2, ViewStorageMut<'a, T, Dynamic, U2, RStride, CStride>>;
+/// 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<T, Dynamic, U3, ViewStorageMut<'a, T, Dynamic, U3, RStride, CStride>>;
+/// 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<T, Dynamic, U4, ViewStorageMut<'a, T, Dynamic, U4, RStride, CStride>>;
+/// 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<T, Dynamic, U5, ViewStorageMut<'a, T, Dynamic, U5, RStride, CStride>>;
+/// 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<T, Dynamic, U6, ViewStorageMut<'a, T, Dynamic, U6, RStride, CStride>>;
+
+/// 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<T, D, U1, ViewStorageMut<'a, T, D, U1, RStride, CStride>>;
+
+/// 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<T, Const<D>, Const<1>, ViewStorageMut<'a, T, Const<D>, Const<1>, Const<1>, Const<D>>>;
+
+/// 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<T, Dynamic, U1, ViewStorageMut<'a, T, Dynamic, U1, RStride, CStride>>;
+
+/// 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<T, U1, U1, ViewStorageMut<'a, T, U1, U1, RStride, CStride>>;
+/// 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<T, U2, U1, ViewStorageMut<'a, T, U2, U1, RStride, CStride>>;
+/// 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<T, U3, U1, ViewStorageMut<'a, T, U3, U1, RStride, CStride>>;
+/// 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<T, U4, U1, ViewStorageMut<'a, T, U4, U1, RStride, CStride>>;
+/// 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<T, U5, U1, ViewStorageMut<'a, T, U5, U1, RStride, CStride>>;
+/// 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<T, U6, U1, ViewStorageMut<'a, T, U6, U1, RStride, CStride>>;
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 0981f9c66098958ae887220f9972fdde58395182 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=A9bastien=20Crozet?= <developer@crozet.re>
Date: Sun, 13 Nov 2022 18:40:03 +0100
Subject: [PATCH 045/119] Release v0.31.4

---
 CHANGELOG.md | 6 ++++++
 Cargo.toml   | 2 +-
 2 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index ac297f20..45c48063 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,12 @@ documented here.
 This project adheres to [Semantic Versioning](https://semver.org/).
 
 
+## [0.31.4] (13 Nov. 2022)
+
+### Added
+- Add a `convert-glam022` feature to enable conversion between `nalgebra` and `glam v0.22`.
+
+
 ## [0.31.3] (30 Oct. 2022)
 
 ### Added
diff --git a/Cargo.toml b/Cargo.toml
index bcfa07d2..985a8918 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name    = "nalgebra"
-version = "0.31.3"
+version = "0.31.4"
 authors = [ "Sébastien Crozet <developer@crozet.re>" ]
 
 description = "General-purpose linear algebra library with transformations and statically-sized or dynamically-sized matrices."

From e245e1148a07cffc2e4752d6679fd5b8495338eb Mon Sep 17 00:00:00 2001
From: Andreas Longva <andreas.b.longva@gmail.com>
Date: Mon, 14 Nov 2022 09:26:45 +0100
Subject: [PATCH 046/119] 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<T, Const<R>, Const<C>, ViewStorage<'a, T, Const<R>, Const<C>, Const<1>, Const<R>>>;
 
 /// 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<T, Dynamic, Dynamic, ViewStorage<'a, T, Dynamic, Dynamic, RStride, CStride>>;
 
 /// 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<T, U1, U1, ViewStorage<'a, T, U1, U1, RStride, CStride>>;
 /// 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<T, U2, U2, ViewStorage<'a, T, U2, U2, RStride, CStride>>;
 /// 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<T, U3, U3, ViewStorage<'a, T, U3, U3, RStride, CStride>>;
 /// 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<T, U4, U4, ViewStorage<'a, T, U4, U4, RStride, CStride>>;
 /// 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<T, U5, U5, ViewStorage<'a, T, U5, U5, RStride, CStride>>;
 /// 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<T, U6, U6, ViewStorage<'a, T, U6, U6, RStride, CStride>>;
 
 /// 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<T, U1, U2, ViewStorage<'a, T, U1, U2, RStride, CStride>>;
 /// 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<T, U1, U3, ViewStorage<'a, T, U1, U3, RStride, CStride>>;
 /// 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<T, U1, U4, ViewStorage<'a, T, U1, U4, RStride, CStride>>;
 /// 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<T, U1, U5, ViewStorage<'a, T, U1, U5, RStride, CStride>>;
 /// 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<T, U1, U6, ViewStorage<'a, T, U1, U6, RStride, CStride>>;
 
 /// 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<T, U2, U1, ViewStorage<'a, T, U2, U1, RStride, CStride>>;
 /// 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<T, U2, U3, ViewStorage<'a, T, U2, U3, RStride, CStride>>;
 /// 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<T, U2, U4, ViewStorage<'a, T, U2, U4, RStride, CStride>>;
 /// 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<T, U2, U5, ViewStorage<'a, T, U2, U5, RStride, CStride>>;
 /// 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<T, U2, U6, ViewStorage<'a, T, U2, U6, RStride, CStride>>;
 
 /// 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<T, U3, U1, ViewStorage<'a, T, U3, U1, RStride, CStride>>;
 /// 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<T, U3, U2, ViewStorage<'a, T, U3, U2, RStride, CStride>>;
 /// 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<T, U3, U4, ViewStorage<'a, T, U3, U4, RStride, CStride>>;
 /// 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<T, U3, U5, ViewStorage<'a, T, U3, U5, RStride, CStride>>;
 /// 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<T, U3, U6, ViewStorage<'a, T, U3, U6, RStride, CStride>>;
 
 /// 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<T, U4, U1, ViewStorage<'a, T, U4, U1, RStride, CStride>>;
 /// 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<T, U4, U2, ViewStorage<'a, T, U4, U2, RStride, CStride>>;
 /// 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<T, U4, U3, ViewStorage<'a, T, U4, U3, RStride, CStride>>;
 /// 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<T, U4, U5, ViewStorage<'a, T, U4, U5, RStride, CStride>>;
 /// 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<T, U4, U6, ViewStorage<'a, T, U4, U6, RStride, CStride>>;
 
 /// 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<T, U5, U1, ViewStorage<'a, T, U5, U1, RStride, CStride>>;
 /// 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<T, U5, U2, ViewStorage<'a, T, U5, U2, RStride, CStride>>;
 /// 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<T, U5, U3, ViewStorage<'a, T, U5, U3, RStride, CStride>>;
 /// 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<T, U5, U4, ViewStorage<'a, T, U5, U4, RStride, CStride>>;
 /// 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<T, U5, U6, ViewStorage<'a, T, U5, U6, RStride, CStride>>;
 
 /// 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<T, U6, U1, ViewStorage<'a, T, U6, U1, RStride, CStride>>;
 /// 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<T, U6, U2, ViewStorage<'a, T, U6, U2, RStride, CStride>>;
 /// 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<T, U6, U3, ViewStorage<'a, T, U6, U3, RStride, CStride>>;
 /// 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<T, U6, U4, ViewStorage<'a, T, U6, U4, RStride, CStride>>;
 /// 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<T, U6, U5, ViewStorage<'a, T, U6, U5, RStride, CStride>>;
 
 /// 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<T, U1, Dynamic, ViewStorage<'a, T, U1, Dynamic, RStride, CStride>>;
 /// 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<T, U2, Dynamic, ViewStorage<'a, T, U2, Dynamic, RStride, CStride>>;
 /// 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<T, U3, Dynamic, ViewStorage<'a, T, U3, Dynamic, RStride, CStride>>;
 /// 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<T, U4, Dynamic, ViewStorage<'a, T, U4, Dynamic, RStride, CStride>>;
 /// 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<T, U5, Dynamic, ViewStorage<'a, T, U5, Dynamic, RStride, CStride>>;
 /// 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<T, U6, Dynamic, ViewStorage<'a, T, U6, Dynamic, RStride, CStride>>;
 
 /// 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<T, Dynamic, U1, ViewStorage<'a, T, Dynamic, U1, RStride, CStride>>;
 /// 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<T, Dynamic, U2, ViewStorage<'a, T, Dynamic, U2, RStride, CStride>>;
 /// 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<T, Dynamic, U3, ViewStorage<'a, T, Dynamic, U3, RStride, CStride>>;
 /// 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<T, Dynamic, U4, ViewStorage<'a, T, Dynamic, U4, RStride, CStride>>;
 /// 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<T, Dynamic, U5, ViewStorage<'a, T, Dynamic, U5, RStride, CStride>>;
 /// 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<T, Dynamic, U6, ViewStorage<'a, T, Dynamic, U6, RStride, CStride>>;
 
 /// 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<T, D, U1, ViewStorage<'a, T, D, U1, RStride, CStride>>;
 
 /// 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<T, Const<D>, Const<1>, ViewStorage<'a, T, Const<D>, Const<1>, Const<1>, Const<D>>>;
 
 /// A column vector slice dynamic numbers of rows and columns.
+#[deprecated = deprecation_note!(DVectorView)]
 pub type DVectorSlice<'a, T, RStride = U1, CStride = Dynamic> =
     Matrix<T, Dynamic, U1, ViewStorage<'a, T, Dynamic, U1, RStride, CStride>>;
 
 /// 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<T, U1, U1, ViewStorage<'a, T, U1, U1, RStride, CStride>>;
 /// 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<T, U2, U1, ViewStorage<'a, T, U2, U1, RStride, CStride>>;
 /// 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<T, U3, U1, ViewStorage<'a, T, U3, U1, RStride, CStride>>;
 /// 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<T, U4, U1, ViewStorage<'a, T, U4, U1, RStride, CStride>>;
 /// 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<T, U5, U1, ViewStorage<'a, T, U5, U1, RStride, CStride>>;
 /// 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<T, U6, U1, ViewStorage<'a, T, U6, U1, RStride, CStride>>;
 
@@ -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<T, Const<R>, Const<C>, ViewStorageMut<'a, T, Const<R>, Const<C>, Const<1>, Const<R>>>;
 
 /// 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<T, Dynamic, Dynamic, ViewStorageMut<'a, T, Dynamic, Dynamic, RStride, CStride>>;
 
 /// 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<T, U1, U1, ViewStorageMut<'a, T, U1, U1, RStride, CStride>>;
 /// 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<T, U2, U2, ViewStorageMut<'a, T, U2, U2, RStride, CStride>>;
 /// 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<T, U3, U3, ViewStorageMut<'a, T, U3, U3, RStride, CStride>>;
 /// 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<T, U4, U4, ViewStorageMut<'a, T, U4, U4, RStride, CStride>>;
 /// 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<T, U5, U5, ViewStorageMut<'a, T, U5, U5, RStride, CStride>>;
 /// 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<T, U6, U6, ViewStorageMut<'a, T, U6, U6, RStride, CStride>>;
 
 /// 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<T, U1, U2, ViewStorageMut<'a, T, U1, U2, RStride, CStride>>;
 /// 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<T, U1, U3, ViewStorageMut<'a, T, U1, U3, RStride, CStride>>;
 /// 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<T, U1, U4, ViewStorageMut<'a, T, U1, U4, RStride, CStride>>;
 /// 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<T, U1, U5, ViewStorageMut<'a, T, U1, U5, RStride, CStride>>;
 /// 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<T, U1, U6, ViewStorageMut<'a, T, U1, U6, RStride, CStride>>;
 
 /// 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<T, U2, U1, ViewStorageMut<'a, T, U2, U1, RStride, CStride>>;
 /// 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<T, U2, U3, ViewStorageMut<'a, T, U2, U3, RStride, CStride>>;
 /// 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<T, U2, U4, ViewStorageMut<'a, T, U2, U4, RStride, CStride>>;
 /// 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<T, U2, U5, ViewStorageMut<'a, T, U2, U5, RStride, CStride>>;
 /// 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<T, U2, U6, ViewStorageMut<'a, T, U2, U6, RStride, CStride>>;
 
 /// 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<T, U3, U1, ViewStorageMut<'a, T, U3, U1, RStride, CStride>>;
 /// 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<T, U3, U2, ViewStorageMut<'a, T, U3, U2, RStride, CStride>>;
 /// 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<T, U3, U4, ViewStorageMut<'a, T, U3, U4, RStride, CStride>>;
 /// 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<T, U3, U5, ViewStorageMut<'a, T, U3, U5, RStride, CStride>>;
 /// 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<T, U3, U6, ViewStorageMut<'a, T, U3, U6, RStride, CStride>>;
 
 /// 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<T, U4, U1, ViewStorageMut<'a, T, U4, U1, RStride, CStride>>;
 /// 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<T, U4, U2, ViewStorageMut<'a, T, U4, U2, RStride, CStride>>;
 /// 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<T, U4, U3, ViewStorageMut<'a, T, U4, U3, RStride, CStride>>;
 /// 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<T, U4, U5, ViewStorageMut<'a, T, U4, U5, RStride, CStride>>;
 /// 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<T, U4, U6, ViewStorageMut<'a, T, U4, U6, RStride, CStride>>;
 
 /// 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<T, U5, U1, ViewStorageMut<'a, T, U5, U1, RStride, CStride>>;
 /// 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<T, U5, U2, ViewStorageMut<'a, T, U5, U2, RStride, CStride>>;
 /// 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<T, U5, U3, ViewStorageMut<'a, T, U5, U3, RStride, CStride>>;
 /// 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<T, U5, U4, ViewStorageMut<'a, T, U5, U4, RStride, CStride>>;
 /// 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<T, U5, U6, ViewStorageMut<'a, T, U5, U6, RStride, CStride>>;
 
 /// 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<T, U6, U1, ViewStorageMut<'a, T, U6, U1, RStride, CStride>>;
 /// 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<T, U6, U2, ViewStorageMut<'a, T, U6, U2, RStride, CStride>>;
 /// 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<T, U6, U3, ViewStorageMut<'a, T, U6, U3, RStride, CStride>>;
 /// 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<T, U6, U4, ViewStorageMut<'a, T, U6, U4, RStride, CStride>>;
 /// 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<T, U6, U5, ViewStorageMut<'a, T, U6, U5, RStride, CStride>>;
 
 /// 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<T, U1, Dynamic, ViewStorageMut<'a, T, U1, Dynamic, RStride, CStride>>;
 /// 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<T, U2, Dynamic, ViewStorageMut<'a, T, U2, Dynamic, RStride, CStride>>;
 /// 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<T, U3, Dynamic, ViewStorageMut<'a, T, U3, Dynamic, RStride, CStride>>;
 /// 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<T, U4, Dynamic, ViewStorageMut<'a, T, U4, Dynamic, RStride, CStride>>;
 /// 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<T, U5, Dynamic, ViewStorageMut<'a, T, U5, Dynamic, RStride, CStride>>;
 /// 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<T, U6, Dynamic, ViewStorageMut<'a, T, U6, Dynamic, RStride, CStride>>;
 
 /// 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<T, Dynamic, U1, ViewStorageMut<'a, T, Dynamic, U1, RStride, CStride>>;
 /// 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<T, Dynamic, U2, ViewStorageMut<'a, T, Dynamic, U2, RStride, CStride>>;
 /// 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<T, Dynamic, U3, ViewStorageMut<'a, T, Dynamic, U3, RStride, CStride>>;
 /// 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<T, Dynamic, U4, ViewStorageMut<'a, T, Dynamic, U4, RStride, CStride>>;
 /// 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<T, Dynamic, U5, ViewStorageMut<'a, T, Dynamic, U5, RStride, CStride>>;
 /// 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<T, Dynamic, U6, ViewStorageMut<'a, T, Dynamic, U6, RStride, CStride>>;
 
 /// 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<T, D, U1, ViewStorageMut<'a, T, D, U1, RStride, CStride>>;
 
 /// 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<T, Const<D>, Const<1>, ViewStorageMut<'a, T, Const<D>, Const<1>, Const<1>, Const<D>>>;
 
 /// 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<T, Dynamic, U1, ViewStorageMut<'a, T, Dynamic, U1, RStride, CStride>>;
 
 /// 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<T, U1, U1, ViewStorageMut<'a, T, U1, U1, RStride, CStride>>;
 /// 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<T, U2, U1, ViewStorageMut<'a, T, U2, U1, RStride, CStride>>;
 /// 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<T, U3, U1, ViewStorageMut<'a, T, U3, U1, RStride, CStride>>;
 /// 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<T, U4, U1, ViewStorageMut<'a, T, U4, U1, RStride, CStride>>;
 /// 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<T, U5, U1, ViewStorageMut<'a, T, U5, U1, RStride, CStride>>;
 /// 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<T, U6, U1, ViewStorageMut<'a, T, U6, U1, RStride, CStride>>;

From 7d5097b0b2b98e0a17867ed28086dcb3c927cb6a Mon Sep 17 00:00:00 2001
From: Andreas Longva <andreas.b.longva@gmail.com>
Date: Mon, 14 Nov 2022 09:33:08 +0100
Subject: [PATCH 047/119] 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<T, D3, SC>,
         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<T, R2, C2, SB>,
         x: &Vector<T, D3, SC>,
         beta: T,
-        dot: impl Fn(&VectorSlice<'_, T, R2, SB::RStride, SB::CStride>, &Vector<T, D3, SC>) -> T,
+        dot: impl Fn(&VectorView<'_, T, R2, SB::RStride, SB::CStride>, &Vector<T, D3, SC>) -> T,
     ) where
         T: One,
         SB: Storage<T, R2, C2>,
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<T: Scalar, const D: usize> From<SVector<T, D>> for [T; D] {
 }
 
 impl<'a, T: Scalar, RStride: Dim, CStride: Dim, const D: usize>
-    From<VectorSlice<'a, T, Const<D>, RStride, CStride>> for [T; D]
+    From<VectorView<'a, T, Const<D>, RStride, CStride>> for [T; D]
 {
     #[inline]
-    fn from(vec: VectorSlice<'a, T, Const<D>, RStride, CStride>) -> Self {
+    fn from(vec: VectorView<'a, T, Const<D>, RStride, CStride>) -> Self {
         vec.into_owned().into()
     }
 }
 
 impl<'a, T: Scalar, RStride: Dim, CStride: Dim, const D: usize>
-    From<VectorSliceMut<'a, T, Const<D>, RStride, CStride>> for [T; D]
+    From<VectorViewMut<'a, T, Const<D>, RStride, CStride>> for [T; D]
 {
     #[inline]
-    fn from(vec: VectorSliceMut<'a, T, Const<D>, RStride, CStride>) -> Self {
+    fn from(vec: VectorViewMut<'a, T, Const<D>, RStride, CStride>) -> Self {
         vec.into_owned().into()
     }
 }
@@ -515,28 +515,28 @@ impl<'a, T: Scalar + Copy, R: Dim, C: Dim, S: RawStorageMut<T, R, C> + 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<DVectorSlice<'a, T>> for &'a [T] {
-    fn from(vec: DVectorSlice<'a, T>) -> &'a [T] {
+impl<'a, T: Scalar> From<DVectorView<'a, T>> 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<DVectorSliceMut<'a, T>> for &'a mut [T] {
-    fn from(vec: DVectorSliceMut<'a, T>) -> &'a mut [T] {
+impl<'a, T: Scalar> From<DVectorViewMut<'a, T>> 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<T, R2, C2, SB>,
         out: &mut Matrix<Status::Value, R3, C3, SC>,
         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<T>,
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<T: Scalar, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S> {
     #[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<T, C>
     where
         DefaultAllocator: Allocator<T, U1, C>,
@@ -41,7 +41,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S> {
     #[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<T, C>
     where
         DefaultAllocator: Allocator<T, C>,
@@ -67,7 +67,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S> {
     pub fn compress_columns(
         &self,
         init: OVector<T, R>,
-        f: impl Fn(&mut OVector<T, R>, VectorSlice<'_, T, R, S::RStride, S::CStride>),
+        f: impl Fn(&mut OVector<T, R>, VectorView<'_, T, R, S::RStride, S::CStride>),
     ) -> OVector<T, R>
     where
         DefaultAllocator: Allocator<T, R>,
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<T: ComplexField, D: Dim, S: Storage<T, D, D>> SquareMatrix<T, D, S> {
     /// Computes the solution of the linear system `self . x = b` where `x` is the unknown and only
@@ -376,8 +376,8 @@ impl<T: ComplexField, D: Dim, S: Storage<T, D, D>> SquareMatrix<T, D, S> {
         b: &mut Vector<T, R2, S2>,
         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<T: ComplexField, D: Dim, S: Storage<T, D, D>> SquareMatrix<T, D, S> {
         b: &mut Vector<T, R2, S2>,
         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<T: SimdComplexField, D: Dim, S: Storage<T, D, D>> SquareMatrix<T, D, S> {
         b: &mut Vector<T, R2, S2>,
         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<T, R2, U1>,
@@ -760,8 +760,8 @@ impl<T: SimdComplexField, D: Dim, S: Storage<T, D, D>> SquareMatrix<T, D, S> {
         b: &mut Vector<T, R2, S2>,
         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<T, R2, U1>,

From f792b5f5684f85c4eabacd5be6292361a69c4d5f Mon Sep 17 00:00:00 2001
From: Andreas Longva <andreas.b.longva@gmail.com>
Date: Mon, 14 Nov 2022 09:37:21 +0100
Subject: [PATCH 048/119] 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<T, R, C, ViewStorageMut<'a, T, R, C, RStride, CStride>>;
 
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 <andreas.b.longva@gmail.com>
Date: Mon, 14 Nov 2022 09:41:03 +0100
Subject: [PATCH 049/119] 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<T, D, D, ViewStorageMut<'a, T, D, D, RStride, CStride>>;
 

From a68d9b5dedf84101b4ad4f0d6f10a3ef6c4f26e8 Mon Sep 17 00:00:00 2001
From: Andreas Longva <andreas.b.longva@gmail.com>
Date: Mon, 14 Nov 2022 09:42:59 +0100
Subject: [PATCH 050/119] 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 <andreas.b.longva@gmail.com>
Date: Mon, 14 Nov 2022 10:56:13 +0100
Subject: [PATCH 051/119] 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<T, Const<R>, Const<C>, ViewStorage<'a, T, Const<R>, Const<C>, Const<1>, Const<R>>>;
 
 /// 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<T, Dynamic, Dynamic, ViewStorage<'a, T, Dynamic, Dynamic, RStride, CStride>>;
 
 /// 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<T, U1, U1, ViewStorage<'a, T, U1, U1, RStride, CStride>>;
 /// 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<T, U2, U2, ViewStorage<'a, T, U2, U2, RStride, CStride>>;
 /// 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<T, U3, U3, ViewStorage<'a, T, U3, U3, RStride, CStride>>;
 /// 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<T, U4, U4, ViewStorage<'a, T, U4, U4, RStride, CStride>>;
 /// 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<T, U5, U5, ViewStorage<'a, T, U5, U5, RStride, CStride>>;
 /// 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<T, U6, U6, ViewStorage<'a, T, U6, U6, RStride, CStride>>;
 
 /// 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<T, U1, U2, ViewStorage<'a, T, U1, U2, RStride, CStride>>;
 /// 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<T, U1, U3, ViewStorage<'a, T, U1, U3, RStride, CStride>>;
 /// 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<T, U1, U4, ViewStorage<'a, T, U1, U4, RStride, CStride>>;
 /// 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<T, U1, U5, ViewStorage<'a, T, U1, U5, RStride, CStride>>;
 /// 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<T, U1, U6, ViewStorage<'a, T, U1, U6, RStride, CStride>>;
 
 /// 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<T, U2, U1, ViewStorage<'a, T, U2, U1, RStride, CStride>>;
 /// 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<T, U2, U3, ViewStorage<'a, T, U2, U3, RStride, CStride>>;
 /// 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<T, U2, U4, ViewStorage<'a, T, U2, U4, RStride, CStride>>;
 /// 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<T, U2, U5, ViewStorage<'a, T, U2, U5, RStride, CStride>>;
 /// 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<T, U2, U6, ViewStorage<'a, T, U2, U6, RStride, CStride>>;
 
 /// 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<T, U3, U1, ViewStorage<'a, T, U3, U1, RStride, CStride>>;
 /// 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<T, U3, U2, ViewStorage<'a, T, U3, U2, RStride, CStride>>;
 /// 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<T, U3, U4, ViewStorage<'a, T, U3, U4, RStride, CStride>>;
 /// 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<T, U3, U5, ViewStorage<'a, T, U3, U5, RStride, CStride>>;
 /// 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<T, U3, U6, ViewStorage<'a, T, U3, U6, RStride, CStride>>;
 
 /// 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<T, U4, U1, ViewStorage<'a, T, U4, U1, RStride, CStride>>;
 /// 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<T, U4, U2, ViewStorage<'a, T, U4, U2, RStride, CStride>>;
 /// 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<T, U4, U3, ViewStorage<'a, T, U4, U3, RStride, CStride>>;
 /// 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<T, U4, U5, ViewStorage<'a, T, U4, U5, RStride, CStride>>;
 /// 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<T, U4, U6, ViewStorage<'a, T, U4, U6, RStride, CStride>>;
 
 /// 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<T, U5, U1, ViewStorage<'a, T, U5, U1, RStride, CStride>>;
 /// 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<T, U5, U2, ViewStorage<'a, T, U5, U2, RStride, CStride>>;
 /// 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<T, U5, U3, ViewStorage<'a, T, U5, U3, RStride, CStride>>;
 /// 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<T, U5, U4, ViewStorage<'a, T, U5, U4, RStride, CStride>>;
 /// 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<T, U5, U6, ViewStorage<'a, T, U5, U6, RStride, CStride>>;
 
 /// 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<T, U6, U1, ViewStorage<'a, T, U6, U1, RStride, CStride>>;
 /// 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<T, U6, U2, ViewStorage<'a, T, U6, U2, RStride, CStride>>;
 /// 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<T, U6, U3, ViewStorage<'a, T, U6, U3, RStride, CStride>>;
 /// 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<T, U6, U4, ViewStorage<'a, T, U6, U4, RStride, CStride>>;
 /// 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<T, U6, U5, ViewStorage<'a, T, U6, U5, RStride, CStride>>;
 
 /// 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<T, U1, Dynamic, ViewStorage<'a, T, U1, Dynamic, RStride, CStride>>;
 /// 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<T, U2, Dynamic, ViewStorage<'a, T, U2, Dynamic, RStride, CStride>>;
 /// 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<T, U3, Dynamic, ViewStorage<'a, T, U3, Dynamic, RStride, CStride>>;
 /// 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<T, U4, Dynamic, ViewStorage<'a, T, U4, Dynamic, RStride, CStride>>;
 /// 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<T, U5, Dynamic, ViewStorage<'a, T, U5, Dynamic, RStride, CStride>>;
 /// 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<T, U6, Dynamic, ViewStorage<'a, T, U6, Dynamic, RStride, CStride>>;
 
 /// 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<T, Dynamic, U1, ViewStorage<'a, T, Dynamic, U1, RStride, CStride>>;
 /// 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<T, Dynamic, U2, ViewStorage<'a, T, Dynamic, U2, RStride, CStride>>;
 /// 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<T, Dynamic, U3, ViewStorage<'a, T, Dynamic, U3, RStride, CStride>>;
 /// 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<T, Dynamic, U4, ViewStorage<'a, T, Dynamic, U4, RStride, CStride>>;
 /// 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<T, Dynamic, U5, ViewStorage<'a, T, Dynamic, U5, RStride, CStride>>;
 /// 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<T, Dynamic, U6, ViewStorage<'a, T, Dynamic, U6, RStride, CStride>>;
 
 /// 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<T, D, U1, ViewStorage<'a, T, D, U1, RStride, CStride>>;
 
 /// 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<T, Const<D>, Const<1>, ViewStorage<'a, T, Const<D>, Const<1>, Const<1>, Const<D>>>;
 
 /// 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<T, Dynamic, U1, ViewStorage<'a, T, Dynamic, U1, RStride, CStride>>;
 
 /// 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<T, U1, U1, ViewStorage<'a, T, U1, U1, RStride, CStride>>;
 /// 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<T, U2, U1, ViewStorage<'a, T, U2, U1, RStride, CStride>>;
 /// 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<T, U3, U1, ViewStorage<'a, T, U3, U1, RStride, CStride>>;
 /// 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<T, U4, U1, ViewStorage<'a, T, U4, U1, RStride, CStride>>;
 /// 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<T, U5, U1, ViewStorage<'a, T, U5, U1, RStride, CStride>>;
 /// 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<T, U6, U1, ViewStorage<'a, T, U6, U1, RStride, CStride>>;
 
@@ -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<T, Const<R>, Const<C>, ViewStorageMut<'a, T, Const<R>, Const<C>, Const<1>, Const<R>>>;
 
 /// 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<T, Dynamic, Dynamic, ViewStorageMut<'a, T, Dynamic, Dynamic, RStride, CStride>>;
 
 /// 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<T, U1, U1, ViewStorageMut<'a, T, U1, U1, RStride, CStride>>;
 /// 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<T, U2, U2, ViewStorageMut<'a, T, U2, U2, RStride, CStride>>;
 /// 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<T, U3, U3, ViewStorageMut<'a, T, U3, U3, RStride, CStride>>;
 /// 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<T, U4, U4, ViewStorageMut<'a, T, U4, U4, RStride, CStride>>;
 /// 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<T, U5, U5, ViewStorageMut<'a, T, U5, U5, RStride, CStride>>;
 /// 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<T, U6, U6, ViewStorageMut<'a, T, U6, U6, RStride, CStride>>;
 
 /// 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<T, U1, U2, ViewStorageMut<'a, T, U1, U2, RStride, CStride>>;
 /// 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<T, U1, U3, ViewStorageMut<'a, T, U1, U3, RStride, CStride>>;
 /// 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<T, U1, U4, ViewStorageMut<'a, T, U1, U4, RStride, CStride>>;
 /// 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<T, U1, U5, ViewStorageMut<'a, T, U1, U5, RStride, CStride>>;
 /// 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<T, U1, U6, ViewStorageMut<'a, T, U1, U6, RStride, CStride>>;
 
 /// 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<T, U2, U1, ViewStorageMut<'a, T, U2, U1, RStride, CStride>>;
 /// 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<T, U2, U3, ViewStorageMut<'a, T, U2, U3, RStride, CStride>>;
 /// 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<T, U2, U4, ViewStorageMut<'a, T, U2, U4, RStride, CStride>>;
 /// 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<T, U2, U5, ViewStorageMut<'a, T, U2, U5, RStride, CStride>>;
 /// 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<T, U2, U6, ViewStorageMut<'a, T, U2, U6, RStride, CStride>>;
 
 /// 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<T, U3, U1, ViewStorageMut<'a, T, U3, U1, RStride, CStride>>;
 /// 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<T, U3, U2, ViewStorageMut<'a, T, U3, U2, RStride, CStride>>;
 /// 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<T, U3, U4, ViewStorageMut<'a, T, U3, U4, RStride, CStride>>;
 /// 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<T, U3, U5, ViewStorageMut<'a, T, U3, U5, RStride, CStride>>;
 /// 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<T, U3, U6, ViewStorageMut<'a, T, U3, U6, RStride, CStride>>;
 
 /// 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<T, U4, U1, ViewStorageMut<'a, T, U4, U1, RStride, CStride>>;
 /// 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<T, U4, U2, ViewStorageMut<'a, T, U4, U2, RStride, CStride>>;
 /// 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<T, U4, U3, ViewStorageMut<'a, T, U4, U3, RStride, CStride>>;
 /// 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<T, U4, U5, ViewStorageMut<'a, T, U4, U5, RStride, CStride>>;
 /// 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<T, U4, U6, ViewStorageMut<'a, T, U4, U6, RStride, CStride>>;
 
 /// 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<T, U5, U1, ViewStorageMut<'a, T, U5, U1, RStride, CStride>>;
 /// 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<T, U5, U2, ViewStorageMut<'a, T, U5, U2, RStride, CStride>>;
 /// 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<T, U5, U3, ViewStorageMut<'a, T, U5, U3, RStride, CStride>>;
 /// 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<T, U5, U4, ViewStorageMut<'a, T, U5, U4, RStride, CStride>>;
 /// 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<T, U5, U6, ViewStorageMut<'a, T, U5, U6, RStride, CStride>>;
 
 /// 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<T, U6, U1, ViewStorageMut<'a, T, U6, U1, RStride, CStride>>;
 /// 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<T, U6, U2, ViewStorageMut<'a, T, U6, U2, RStride, CStride>>;
 /// 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<T, U6, U3, ViewStorageMut<'a, T, U6, U3, RStride, CStride>>;
 /// 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<T, U6, U4, ViewStorageMut<'a, T, U6, U4, RStride, CStride>>;
 /// 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<T, U6, U5, ViewStorageMut<'a, T, U6, U5, RStride, CStride>>;
 
 /// 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<T, U1, Dynamic, ViewStorageMut<'a, T, U1, Dynamic, RStride, CStride>>;
 /// 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<T, U2, Dynamic, ViewStorageMut<'a, T, U2, Dynamic, RStride, CStride>>;
 /// 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<T, U3, Dynamic, ViewStorageMut<'a, T, U3, Dynamic, RStride, CStride>>;
 /// 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<T, U4, Dynamic, ViewStorageMut<'a, T, U4, Dynamic, RStride, CStride>>;
 /// 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<T, U5, Dynamic, ViewStorageMut<'a, T, U5, Dynamic, RStride, CStride>>;
 /// 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<T, U6, Dynamic, ViewStorageMut<'a, T, U6, Dynamic, RStride, CStride>>;
 
 /// 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<T, Dynamic, U1, ViewStorageMut<'a, T, Dynamic, U1, RStride, CStride>>;
 /// 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<T, Dynamic, U2, ViewStorageMut<'a, T, Dynamic, U2, RStride, CStride>>;
 /// 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<T, Dynamic, U3, ViewStorageMut<'a, T, Dynamic, U3, RStride, CStride>>;
 /// 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<T, Dynamic, U4, ViewStorageMut<'a, T, Dynamic, U4, RStride, CStride>>;
 /// 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<T, Dynamic, U5, ViewStorageMut<'a, T, Dynamic, U5, RStride, CStride>>;
 /// 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<T, Dynamic, U6, ViewStorageMut<'a, T, Dynamic, U6, RStride, CStride>>;
 
 /// 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<T, D, U1, ViewStorageMut<'a, T, D, U1, RStride, CStride>>;
 
 /// 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<T, Const<D>, Const<1>, ViewStorageMut<'a, T, Const<D>, Const<1>, Const<1>, Const<D>>>;
 
 /// 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<T, Dynamic, U1, ViewStorageMut<'a, T, Dynamic, U1, RStride, CStride>>;
 
 /// 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<T, U1, U1, ViewStorageMut<'a, T, U1, U1, RStride, CStride>>;
 /// 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<T, U2, U1, ViewStorageMut<'a, T, U2, U1, RStride, CStride>>;
 /// 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<T, U3, U1, ViewStorageMut<'a, T, U3, U1, RStride, CStride>>;
 /// 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<T, U4, U1, ViewStorageMut<'a, T, U4, U1, RStride, CStride>>;
 /// 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<T, U5, U1, ViewStorageMut<'a, T, U5, U1, RStride, CStride>>;
 /// 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<T, U6, U1, ViewStorageMut<'a, T, U6, U1, RStride, CStride>>;
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 <andreas.b.longva@gmail.com>
Date: Mon, 14 Nov 2022 14:02:36 +0100
Subject: [PATCH 052/119] 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<T, R, C>>:
     }
 }
 
-/// # 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<T, R1, C1, R2, C2> =
 /// - [Elementwise mapping and folding <span style="float:right;">`map`, `fold`, `zip_map`…</span>](#elementwise-mapping-and-folding)
 /// - [Folding or columns and rows <span style="float:right;">`compress_rows`, `compress_columns`…</span>](#folding-on-columns-and-rows)
 ///
-/// #### Vector and matrix slicing
-/// - [Creating matrix slices from `&[T]` <span style="float:right;">`from_slice`, `from_slice_with_strides`…</span>](#creating-matrix-slices-from-t)
-/// - [Creating mutable matrix slices from `&mut [T]` <span style="float:right;">`from_slice_mut`, `from_slice_with_strides_mut`…</span>](#creating-mutable-matrix-slices-from-mut-t)
-/// - [Slicing based on index and length <span style="float:right;">`row`, `columns`, `slice`…</span>](#slicing-based-on-index-and-length)
-/// - [Mutable slicing based on index and length <span style="float:right;">`row_mut`, `columns_mut`, `slice_mut`…</span>](#mutable-slicing-based-on-index-and-length)
-/// - [Slicing based on ranges <span style="float:right;">`rows_range`, `columns_range`…</span>](#slicing-based-on-ranges)
-/// - [Mutable slicing based on ranges <span style="float:right;">`rows_range_mut`, `columns_range_mut`…</span>](#mutable-slicing-based-on-ranges)
+/// #### Vector and matrix views
+/// - [Creating matrix views from `&[T]` <span style="float:right;">`from_slice`, `from_slice_with_strides`…</span>](#creating-matrix-views-from-t)
+/// - [Creating mutable matrix views from `&mut [T]` <span style="float:right;">`from_slice_mut`, `from_slice_with_strides_mut`…</span>](#creating-mutable-matrix-views-from-mut-t)
+/// - [Views based on index and length <span style="float:right;">`row`, `columns`, `view`…</span>](#views-based-on-index-and-length)
+/// - [Mutable views based on index and length <span style="float:right;">`row_mut`, `columns_mut`, `view_mut`…</span>](#mutable-views-based-on-index-and-length)
+/// - [Views based on ranges <span style="float:right;">`rows_range`, `columns_range`…</span>](#views-based-on-ranges)
+/// - [Mutable views based on ranges <span style="float:right;">`rows_range_mut`, `columns_range_mut`…</span>](#mutable-views-based-on-ranges)
 ///
 /// #### In-place modification of a single matrix or vector
 /// - [In-place filling <span style="float:right;">`fill`, `fill_diagonal`, `fill_with_identity`…</span>](#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<T, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S> {
     }
 }
 
-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<const RSLICE: usize>($me: $Me, first_row: usize)
-            -> $MatrixView<'_, T, Const<RSLICE>, C, S::RStride, S::CStride> {
+        pub fn $fixed_rows<const RVIEW: usize>($me: $Me, first_row: usize)
+            -> $MatrixView<'_, T, Const<RVIEW>, C, S::RStride, S::CStride> {
 
-            $me.$rows_generic(first_row, Const::<RSLICE>)
+            $me.$rows_generic(first_row, Const::<RVIEW>)
         }
 
         /// Extracts from this matrix a compile-time number of rows regularly skipping `step`
         /// rows.
         #[inline]
-        pub fn $fixed_rows_with_step<const RSLICE: usize>($me: $Me, first_row: usize, step: usize)
-            -> $MatrixView<'_, T, Const<RSLICE>, C, Dynamic, S::CStride> {
+        pub fn $fixed_rows_with_step<const RVIEW: usize>($me: $Me, first_row: usize, step: usize)
+            -> $MatrixView<'_, T, Const<RVIEW>, C, Dynamic, S::CStride> {
 
-            $me.$rows_generic_with_step(first_row, Const::<RSLICE>, step)
+            $me.$rows_generic_with_step(first_row, Const::<RVIEW>, 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<RSlice: Dim>($me: $Me, row_start: usize, nrows: RSlice)
-            -> $MatrixView<'_, T, RSlice, C, S::RStride, S::CStride> {
+        pub fn $rows_generic<RView: Dim>($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<RSlice>($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<RView>($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<const CSLICE: usize>($me: $Me, first_col: usize)
-            -> $MatrixView<'_, T, R, Const<CSLICE>, S::RStride, S::CStride> {
+        pub fn $fixed_columns<const CVIEW: usize>($me: $Me, first_col: usize)
+            -> $MatrixView<'_, T, R, Const<CVIEW>, S::RStride, S::CStride> {
 
-            $me.$columns_generic(first_col, Const::<CSLICE>)
+            $me.$columns_generic(first_col, Const::<CVIEW>)
         }
 
         /// Extracts from this matrix a compile-time number of columns regularly skipping
         /// `step` columns.
         #[inline]
-        pub fn $fixed_columns_with_step<const CSLICE: usize>($me: $Me, first_col: usize, step: usize)
-            -> $MatrixView<'_, T, R, Const<CSLICE>, S::RStride, Dynamic> {
+        pub fn $fixed_columns_with_step<const CVIEW: usize>($me: $Me, first_col: usize, step: usize)
+            -> $MatrixView<'_, T, R, Const<CVIEW>, S::RStride, Dynamic> {
 
-            $me.$columns_generic_with_step(first_col, Const::<CSLICE>, step)
+            $me.$columns_generic_with_step(first_col, Const::<CVIEW>, 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<CSlice: Dim>($me: $Me, first_col: usize, ncols: CSlice)
-            -> $MatrixView<'_, T, R, CSlice, S::RStride, S::CStride> {
+        pub fn $columns_generic<CView: Dim>($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<CSlice: Dim>($me: $Me, first_col: usize, ncols: CSlice, step: usize)
-            -> $MatrixView<'_, T, R, CSlice, S::RStride, Dynamic> {
+        pub fn $columns_generic_with_step<CView: Dim>($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<const RSLICE: usize, const CSLICE: usize>($me: $Me, irow: usize, icol: usize)
-            -> $MatrixView<'_, T, Const<RSLICE>, Const<CSLICE>, S::RStride, S::CStride> {
+        #[deprecated = slice_deprecation_note!($fixed_view)]
+        pub fn $fixed_slice<const RVIEW: usize, const CVIEW: usize>($me: $Me, irow: usize, icol: usize)
+            -> $MatrixView<'_, T, Const<RVIEW>, Const<CVIEW>, S::RStride, S::CStride> {
+            $me.$fixed_view(irow, icol)
+        }
 
-            $me.assert_slice_index((irow, icol), (RSLICE, CSLICE), (0, 0));
-            let shape = (Const::<RSLICE>, Const::<CSLICE>);
+        /// 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<const RVIEW: usize, const CVIEW: usize>($me: $Me, irow: usize, icol: usize)
+            -> $MatrixView<'_, T, Const<RVIEW>, Const<CVIEW>, S::RStride, S::CStride> {
+
+            $me.assert_slice_index((irow, icol), (RVIEW, CVIEW), (0, 0));
+            let shape = (Const::<RVIEW>, Const::<CVIEW>);
 
             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<const RSLICE: usize, const CSLICE: usize>($me: $Me, start: (usize, usize), steps: (usize, usize))
-            -> $MatrixView<'_, T, Const<RSLICE>, Const<CSLICE>, Dynamic, Dynamic> {
-            let shape = (Const::<RSLICE>, Const::<CSLICE>);
-            $me.$generic_slice_with_steps(start, shape, steps)
+        #[deprecated = slice_deprecation_note!($fixed_view_with_steps)]
+        pub fn $fixed_slice_with_steps<const RVIEW: usize, const CVIEW: usize>($me: $Me, start: (usize, usize), steps: (usize, usize))
+            -> $MatrixView<'_, T, Const<RVIEW>, Const<CVIEW>, 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<const RVIEW: usize, const CVIEW: usize>($me: $Me, start: (usize, usize), steps: (usize, usize))
+            -> $MatrixView<'_, T, Const<RVIEW>, Const<CVIEW>, Dynamic, Dynamic> {
+            let shape = (Const::<RVIEW>, Const::<CVIEW>);
+            $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<RSlice, CSlice>($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<RView, CView>($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<RView, CView>($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<RSlice, CSlice>($me: $Me,
+        #[deprecated = slice_deprecation_note!($generic_view_with_steps)]
+        pub fn $generic_slice_with_steps<RView, CView>($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<RView, CView>($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<T, R, C, ViewStorageMut<'a, T, R, C, RStride, CStride>>;
 
-/// # Slicing based on index and length
+/// # Views based on index and length
 impl<T, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S> {
-    matrix_slice_impl!(
+    matrix_view_impl!(
      self: &Self, MatrixView, ViewStorage, RawStorage.get_address_unchecked(), &self.data;
      row,
      row_part,
@@ -708,19 +769,19 @@ impl<T, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S> {
      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<T, R: Dim, C: Dim, S: RawStorageMut<T, R, C>> Matrix<T, R, C, S> {
-    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<T, R: Dim, C: Dim, S: RawStorageMut<T, R, C>> Matrix<T, R, C, S> {
      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<T, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S> {
     /// by the range `cols`.
     #[inline]
     #[must_use]
+    #[deprecated = slice_deprecation_note!(view_range)]
     pub fn slice_range<RowRange, ColRange>(
         &self,
         rows: RowRange,
@@ -905,24 +967,44 @@ impl<T, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S> {
         )
     }
 
-    /// 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<RowRange, ColRange>(
+        &self,
+        rows: RowRange,
+        cols: ColRange,
+    ) -> MatrixView<'_, T, RowRange::Size, ColRange::Size, S::RStride, S::CStride>
+        where
+            RowRange: SliceRange<R>,
+            ColRange: SliceRange<C>,
+    {
+        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<RowRange: SliceRange<R>>(
         &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<ColRange: SliceRange<C>>(
         &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<T, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S> {
 impl<T, R: Dim, C: Dim, S: RawStorageMut<T, R, C>> Matrix<T, R, C, S> {
     /// 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<RowRange, ColRange>(
         &mut self,
         rows: RowRange,
@@ -939,30 +1022,44 @@ impl<T, R: Dim, C: Dim, S: RawStorageMut<T, R, C>> Matrix<T, R, C, S> {
     where
         RowRange: SliceRange<R>,
         ColRange: SliceRange<C>,
+    {
+        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<RowRange, ColRange>(
+        &mut self,
+        rows: RowRange,
+        cols: ColRange,
+    ) -> MatrixViewMut<'_, T, RowRange::Size, ColRange::Size, S::RStride, S::CStride>
+        where
+            RowRange: SliceRange<R>,
+            ColRange: SliceRange<C>,
     {
         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<RowRange: SliceRange<R>>(
         &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<ColRange: SliceRange<C>>(
         &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 <andreas.b.longva@gmail.com>
Date: Mon, 14 Nov 2022 14:14:42 +0100
Subject: [PATCH 053/119] 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<T, DimNameDiff<D, U1>>,
     {
         let mut res = Self::identity();
-        res.generic_slice_mut(
+        res.generic_view_mut(
             (0, D::dim() - 1),
             (DimNameDiff::<D, U1>::name(), Const::<1>),
         )
@@ -382,19 +382,19 @@ impl<T: Scalar + Zero + One + ClosedMul + ClosedAdd, D: DimName, S: Storage<T, D
         DefaultAllocator: Allocator<T, DimNameDiff<D, U1>>,
     {
         let scale = self
-            .generic_slice(
+            .generic_view(
                 (D::dim() - 1, 0),
                 (Const::<1>, DimNameDiff::<D, U1>::name()),
             )
             .tr_dot(shift);
-        let post_translation = self.generic_slice(
+        let post_translation = self.generic_view(
             (0, 0),
             (DimNameDiff::<D, U1>::name(), DimNameDiff::<D, U1>::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::<D, U1>::name(), Const::<1>),
         );
@@ -415,11 +415,11 @@ where
         &self,
         v: &OVector<T, DimNameDiff<D, U1>>,
     ) -> OVector<T, DimNameDiff<D, U1>> {
-        let transform = self.generic_slice(
+        let transform = self.generic_view(
             (0, 0),
             (DimNameDiff::<D, U1>::name(), DimNameDiff::<D, U1>::name()),
         );
-        let normalizer = self.generic_slice(
+        let normalizer = self.generic_view(
             (D::dim() - 1, 0),
             (Const::<1>, DimNameDiff::<D, U1>::name()),
         );
@@ -437,9 +437,9 @@ impl<T: RealField, S: Storage<T, Const<3>, Const<3>>> SquareMatrix<T, Const<3>,
     /// Transforms the given point, assuming the matrix `self` uses homogeneous coordinates.
     #[inline]
     pub fn transform_point(&self, pt: &Point<T, 2>) -> Point<T, 2> {
-        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<T: RealField, S: Storage<T, Const<4>, Const<4>>> SquareMatrix<T, Const<4>,
     /// Transforms the given point, assuming the matrix `self` uses homogeneous coordinates.
     #[inline]
     pub fn transform_point(&self, pt: &Point<T, 3>) -> Point<T, 3> {
-        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<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
             }
 
             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<T, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S> {
     /// ```
     /// # use nalgebra::DMatrix;
     /// let mat = DMatrix::<f32>::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<T: Scalar + Zero + One, D: DimAdd<U1> + IsNotStaticOne, S: RawStorage<T, D,
         );
         let dim = DimSum::<D, U1>::from_usize(self.nrows() + 1);
         let mut res = OMatrix::identity_generic(dim, dim);
-        res.generic_slice_mut::<D, D>((0, 0), self.shape_generic())
+        res.generic_view_mut::<D, D>((0, 0), self.shape_generic())
             .copy_from(self);
         res
     }
@@ -1661,7 +1661,7 @@ impl<T: Scalar + Zero, D: DimAdd<U1>, S: RawStorage<T, D>> Vector<T, D, S> {
     {
         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<T: Scalar, D: DimAdd<U1>, S: RawStorage<T, D>> Vector<T, D, S> {
         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<T, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S> {
         ColRange: SliceRange<C>,
     {
         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<T: SimdRealField, R, const D: usize> Isometry<T, R, D> {
         DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
     {
         let mut res: OMatrix<T, _, _> = crate::convert_ref(&self.rotation);
-        res.fixed_slice_mut::<D, 1>(0, D)
+        res.fixed_view_mut::<D, 1>(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<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>) -> bool {
-        let rot = m.fixed_slice::<D, D>(0, 0);
-        let bottom = m.fixed_slice::<1, D>(D, 0);
+        let rot = m.fixed_view::<D, D>(0, 0);
+        let bottom = m.fixed_view::<1, D>(D, 0);
 
         // Scalar types agree.
         m.iter().all(|e| SupersetOf::<T1>::is_in_subset(e)) &&
@@ -168,7 +168,7 @@ where
     fn from_superset_unchecked(
         m: &OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
     ) -> Self {
-        let t = m.fixed_slice::<D, 1>(0, D).into_owned();
+        let t = m.fixed_view::<D, 1>(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::<D, U1>::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<T, DimNameSum<D, U1>>,
     {
         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<T2, DimNameSum<D, U1>>) -> 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<T: Scalar, const D: usize> Rotation<T, D> {
         // adding the additional traits `DimAdd` and `IsNotStaticOne`. Maybe
         // these things will get nicer once specialization lands in Rust.
         let mut res = OMatrix::<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>::identity();
-        res.fixed_slice_mut::<D, D>(0, 0).copy_from(&self.matrix);
+        res.fixed_view_mut::<D, D>(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<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>) -> bool {
-        let rot = m.fixed_slice::<D, D>(0, 0);
-        let bottom = m.fixed_slice::<1, D>(D, 0);
+        let rot = m.fixed_view::<D, D>(0, 0);
+        let bottom = m.fixed_view::<1, D>(D, 0);
 
         // Scalar types agree.
         m.iter().all(|e| SupersetOf::<T1>::is_in_subset(e)) &&
@@ -226,7 +226,7 @@ where
     fn from_superset_unchecked(
         m: &OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
     ) -> Self {
-        let r = m.fixed_slice::<D, D>(0, 0);
+        let r = m.fixed_view::<D, D>(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<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
     ) -> Self {
-        let v = m.fixed_slice::<D, D>(0, 0).diagonal();
+        let v = m.fixed_view::<D, D>(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<T: SimdRealField, R, const D: usize> Similarity<T, R, D> {
     {
         let mut res = self.isometry.to_homogeneous();
 
-        for e in res.fixed_slice_mut::<D, D>(0, 0).iter_mut() {
+        for e in res.fixed_view_mut::<D, D>(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<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>) -> bool {
-        let mut rot = m.fixed_slice::<D, D>(0, 0).clone_owned();
+        let mut rot = m.fixed_view::<D, D>(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::<T1>::is_in_subset(e)) &&
             // The normalized block part is a rotation.
@@ -145,22 +145,22 @@ where
         m: &OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
     ) -> Self {
         let mut mm = m.clone_owned();
-        let na = mm.fixed_slice_mut::<D, 1>(0, 0).normalize_mut();
-        let nb = mm.fixed_slice_mut::<D, 1>(0, 1).normalize_mut();
-        let nc = mm.fixed_slice_mut::<D, 1>(0, 2).normalize_mut();
+        let na = mm.fixed_view_mut::<D, 1>(0, 0).normalize_mut();
+        let nb = mm.fixed_view_mut::<D, 1>(0, 1).normalize_mut();
+        let nc = mm.fixed_view_mut::<D, 1>(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::<D, D>(0, 0).determinant() < T2::zero() {
-            mm.fixed_slice_mut::<D, 1>(0, 0).neg_mut();
-            mm.fixed_slice_mut::<D, 1>(0, 1).neg_mut();
-            mm.fixed_slice_mut::<D, 1>(0, 2).neg_mut();
+        if mm.fixed_view::<D, D>(0, 0).determinant() < T2::zero() {
+            mm.fixed_view_mut::<D, 1>(0, 0).neg_mut();
+            mm.fixed_view_mut::<D, 1>(0, 1).neg_mut();
+            mm.fixed_view_mut::<D, 1>(0, 2).neg_mut();
             scale = -scale;
         }
 
-        let t = m.fixed_slice::<D, 1>(0, D).into_owned();
+        let t = m.fixed_view::<D, 1>(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::<D, D>(0, 0);
+        let transform = self.matrix().fixed_view::<D, D>(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::<D, D>(0, 0);
-        let translation = self.matrix().fixed_slice::<D, 1>(0, D);
+        let transform   = self.matrix().fixed_view::<D, D>(0, 0);
+        let translation = self.matrix().fixed_view::<D, 1>(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<T: Scalar, const D: usize> Translation<T, D> {
         DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
     {
         let mut res = OMatrix::<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>::identity();
-        res.fixed_slice_mut::<D, 1>(0, D).copy_from(&self.vector);
+        res.fixed_view_mut::<D, 1>(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<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>) -> bool {
-        let id = m.generic_slice((0, 0), (DimNameSum::<Const<D>, U1>::name(), Const::<D>));
+        let id = m.generic_view((0, 0), (DimNameSum::<Const<D>, U1>::name(), Const::<D>));
 
         // Scalar types agree.
         m.iter().all(|e| SupersetOf::<T1>::is_in_subset(e)) &&
@@ -173,7 +173,7 @@ where
     fn from_superset_unchecked(
         m: &OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
     ) -> Self {
-        let t = m.fixed_slice::<D, 1>(0, D);
+        let t = m.fixed_view::<D, 1>(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<Dm, Sm, Rx, Sx>(
         chol: &mut Matrix<T, Dm, Dm, Sm>,
         x: &mut Vector<T, Rx, Sx>,
@@ -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::<T::RealField>() {
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<T, R, C>,
 {
-    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<T, R: Dim, C: Dim, S>(
     S: StorageMut<T, R, C>,
 {
     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<T: ComplexField, D: Dim, S: Storage<T, D, D>> SquareMatrix<T, D, S> {
             }
 
             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<T: ComplexField, D: Dim, S: Storage<T, D, D>> SquareMatrix<T, D, S> {
             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<T: ComplexField, D: Dim, S: Storage<T, D, D>> SquareMatrix<T, D, S> {
             }
 
             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<T: ComplexField, D: Dim, S: Storage<T, D, D>> SquareMatrix<T, D, S> {
         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<T: ComplexField, D: Dim, S: Storage<T, D, D>> SquareMatrix<T, D, S> {
         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<T: SimdComplexField, D: Dim, S: Storage<T, D, D>> SquareMatrix<T, D, S> {
             }
 
             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<T: SimdComplexField, D: Dim, S: Storage<T, D, D>> SquareMatrix<T, D, S> {
             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<T: SimdComplexField, D: Dim, S: Storage<T, D, D>> SquareMatrix<T, D, S> {
             }
 
             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<T: SimdComplexField, D: Dim, S: Storage<T, D, D>> SquareMatrix<T, D, S> {
         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<T: SimdComplexField, D: Dim, S: Storage<T, D, D>> SquareMatrix<T, D, S> {
         ShapeConstraint: SameNumberOfRows<R2, D>,
     {
         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 <andreas.b.longva@gmail.com>
Date: Mon, 14 Nov 2022 14:40:53 +0100
Subject: [PATCH 054/119] 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<R>, Const<C>, RStride, CStride>) -> Self {
-        matrix_slice.into_owned()
+    fn from(matrix_view: MatrixView<'a, T, Const<R>, Const<C>, 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<R>, Const<C>, RStride, CStride>) -> Self {
-        matrix_slice.into_owned()
+    fn from(matrix_view: MatrixViewMut<'a, T, Const<R>, Const<C>, 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<T, R, C, S>>
-    for MatrixView<'a, T, RSlice, CSlice, RStride, CStride>
+impl<'a, T, R, C, RView, CView, RStride, CStride, S> From<&'a Matrix<T, R, C, S>>
+    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<T, R, C>,
-    ShapeConstraint: DimEq<R, RSlice>
-        + DimEq<C, CSlice>
+    ShapeConstraint: DimEq<R, RView>
+        + DimEq<C, CView>
         + DimEq<RStride, S::RStride>
         + DimEq<CStride, S::CStride>,
 {
     fn from(m: &'a Matrix<T, R, C, S>) -> 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<T, R, C, S>>
-    for MatrixView<'a, T, RSlice, CSlice, RStride, CStride>
+impl<'a, T, R, C, RView, CView, RStride, CStride, S> From<&'a mut Matrix<T, R, C, S>>
+    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<T, R, C>,
-    ShapeConstraint: DimEq<R, RSlice>
-        + DimEq<C, CSlice>
+    ShapeConstraint: DimEq<R, RView>
+        + DimEq<C, CView>
         + DimEq<RStride, S::RStride>
         + DimEq<CStride, S::CStride>,
 {
     fn from(m: &'a mut Matrix<T, R, C, S>) -> 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<T, R, C, S>>
-    for MatrixViewMut<'a, T, RSlice, CSlice, RStride, CStride>
+impl<'a, T, R, C, RView, CView, RStride, CStride, S> From<&'a mut Matrix<T, R, C, S>>
+    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<T, R, C>,
-    ShapeConstraint: DimEq<R, RSlice>
-        + DimEq<C, CSlice>
+    ShapeConstraint: DimEq<R, RView>
+        + DimEq<C, CView>
         + DimEq<RStride, S::RStride>
         + DimEq<CStride, S::CStride>,
 {
     fn from(m: &'a mut Matrix<T, R, C, S>) -> 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<T, R: Dim, C: Dim = U1>: 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<T, R: Dim, C: Dim = U1>: RawStorage<T, R, C> {
 /// contains `MaybeUninit<T>` 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<T, R: Dim, C: Dim = U1>: RawStorage<T, R, C> {
     /// The matrix mutable data pointer.

From 0c402318ec16f67a3ebfb4387b93db9c27921d54 Mon Sep 17 00:00:00 2001
From: Andreas Longva <andreas.b.longva@gmail.com>
Date: Mon, 14 Nov 2022 14:42:23 +0100
Subject: [PATCH 055/119] 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<T, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S> {
     #[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<const RVIEW: usize, const CVIEW: usize>($me: $Me, irow: usize, icol: usize)
             -> $MatrixView<'_, T, Const<RVIEW>, Const<CVIEW>, 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::<RVIEW>, Const::<CVIEW>);
 
             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 <andreas.b.longva@gmail.com>
Date: Mon, 14 Nov 2022 14:47:43 +0100
Subject: [PATCH 056/119] 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<Range1: SliceRange<R>, Range2: SliceRange<R>>($me: $Me, r1: Range1, r2: Range2)
+        pub fn $rows_range_pair<Range1: DimRange<R>, Range2: DimRange<R>>($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<Range1: SliceRange<C>, Range2: SliceRange<C>>($me: $Me, r1: Range1, r2: Range2)
+        pub fn $columns_range_pair<Range1: DimRange<C>, Range2: DimRange<C>>($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<T, R: Dim, C: Dim, S: RawStorageMut<T, R, C>> Matrix<T, R, C, S> {
 /// * 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<D: Dim> {
+pub trait DimRange<D: Dim> {
     /// Type of the range size. May be a type-level integer.
     type Size: Dim;
 
@@ -829,7 +829,16 @@ pub trait SliceRange<D: Dim> {
     fn size(&self, shape: D) -> Self::Size;
 }
 
-impl<D: Dim> SliceRange<D> 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<D: Dim>: DimRange<D> {}
+
+#[allow(deprecated)]
+impl<R: DimRange<D>, D: Dim> SliceRange<D> for R {}
+
+impl<D: Dim> DimRange<D> for usize {
     type Size = U1;
 
     #[inline(always)]
@@ -848,7 +857,7 @@ impl<D: Dim> SliceRange<D> for usize {
     }
 }
 
-impl<D: Dim> SliceRange<D> for Range<usize> {
+impl<D: Dim> DimRange<D> for Range<usize> {
     type Size = Dynamic;
 
     #[inline(always)]
@@ -867,7 +876,7 @@ impl<D: Dim> SliceRange<D> for Range<usize> {
     }
 }
 
-impl<D: Dim> SliceRange<D> for RangeFrom<usize> {
+impl<D: Dim> DimRange<D> for RangeFrom<usize> {
     type Size = Dynamic;
 
     #[inline(always)]
@@ -886,7 +895,7 @@ impl<D: Dim> SliceRange<D> for RangeFrom<usize> {
     }
 }
 
-impl<D: Dim> SliceRange<D> for RangeTo<usize> {
+impl<D: Dim> DimRange<D> for RangeTo<usize> {
     type Size = Dynamic;
 
     #[inline(always)]
@@ -905,7 +914,7 @@ impl<D: Dim> SliceRange<D> for RangeTo<usize> {
     }
 }
 
-impl<D: Dim> SliceRange<D> for RangeFull {
+impl<D: Dim> DimRange<D> for RangeFull {
     type Size = D;
 
     #[inline(always)]
@@ -924,7 +933,7 @@ impl<D: Dim> SliceRange<D> for RangeFull {
     }
 }
 
-impl<D: Dim> SliceRange<D> for RangeInclusive<usize> {
+impl<D: Dim> DimRange<D> for RangeInclusive<usize> {
     type Size = Dynamic;
 
     #[inline(always)]
@@ -957,8 +966,8 @@ impl<T, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S> {
         cols: ColRange,
     ) -> MatrixView<'_, T, RowRange::Size, ColRange::Size, S::RStride, S::CStride>
     where
-        RowRange: SliceRange<R>,
-        ColRange: SliceRange<C>,
+        RowRange: DimRange<R>,
+        ColRange: DimRange<C>,
     {
         let (nrows, ncols) = self.shape_generic();
         self.generic_view(
@@ -977,8 +986,8 @@ impl<T, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S> {
         cols: ColRange,
     ) -> MatrixView<'_, T, RowRange::Size, ColRange::Size, S::RStride, S::CStride>
         where
-            RowRange: SliceRange<R>,
-            ColRange: SliceRange<C>,
+            RowRange: DimRange<R>,
+            ColRange: DimRange<C>,
     {
         let (nrows, ncols) = self.shape_generic();
         self.generic_view(
@@ -990,7 +999,7 @@ impl<T, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S> {
     /// View containing all the rows indexed by the range `rows`.
     #[inline]
     #[must_use]
-    pub fn rows_range<RowRange: SliceRange<R>>(
+    pub fn rows_range<RowRange: DimRange<R>>(
         &self,
         rows: RowRange,
     ) -> MatrixView<'_, T, RowRange::Size, C, S::RStride, S::CStride> {
@@ -1000,7 +1009,7 @@ impl<T, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S> {
     /// View containing all the columns indexed by the range `rows`.
     #[inline]
     #[must_use]
-    pub fn columns_range<ColRange: SliceRange<C>>(
+    pub fn columns_range<ColRange: DimRange<C>>(
         &self,
         cols: ColRange,
     ) -> MatrixView<'_, T, R, ColRange::Size, S::RStride, S::CStride> {
@@ -1020,8 +1029,8 @@ impl<T, R: Dim, C: Dim, S: RawStorageMut<T, R, C>> Matrix<T, R, C, S> {
         cols: ColRange,
     ) -> MatrixViewMut<'_, T, RowRange::Size, ColRange::Size, S::RStride, S::CStride>
     where
-        RowRange: SliceRange<R>,
-        ColRange: SliceRange<C>,
+        RowRange: DimRange<R>,
+        ColRange: DimRange<C>,
     {
         self.view_range_mut(rows, cols)
     }
@@ -1034,8 +1043,8 @@ impl<T, R: Dim, C: Dim, S: RawStorageMut<T, R, C>> Matrix<T, R, C, S> {
         cols: ColRange,
     ) -> MatrixViewMut<'_, T, RowRange::Size, ColRange::Size, S::RStride, S::CStride>
         where
-            RowRange: SliceRange<R>,
-            ColRange: SliceRange<C>,
+            RowRange: DimRange<R>,
+            ColRange: DimRange<C>,
     {
         let (nrows, ncols) = self.shape_generic();
         self.generic_view_mut(
@@ -1046,7 +1055,7 @@ impl<T, R: Dim, C: Dim, S: RawStorageMut<T, R, C>> Matrix<T, R, C, S> {
 
     /// Mutable view containing all the rows indexed by the range `rows`.
     #[inline]
-    pub fn rows_range_mut<RowRange: SliceRange<R>>(
+    pub fn rows_range_mut<RowRange: DimRange<R>>(
         &mut self,
         rows: RowRange,
     ) -> MatrixViewMut<'_, T, RowRange::Size, C, S::RStride, S::CStride> {
@@ -1055,7 +1064,7 @@ impl<T, R: Dim, C: Dim, S: RawStorageMut<T, R, C>> Matrix<T, R, C, S> {
 
     /// Mutable view containing all the columns indexed by the range `cols`.
     #[inline]
-    pub fn columns_range_mut<ColRange: SliceRange<C>>(
+    pub fn columns_range_mut<ColRange: DimRange<C>>(
         &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 <andreas.b.longva@gmail.com>
Date: Mon, 14 Nov 2022 15:16:23 +0100
Subject: [PATCH 057/119] 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::<u8, Const<1024>, 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::<f32>::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::<f32>::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 <andreas.b.longva@gmail.com>
Date: Mon, 14 Nov 2022 15:18:28 +0100
Subject: [PATCH 058/119] 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<T: RealNumber>(x: &TMat3<T>) -> Qua<T> {
 
 /// Converts a rotation matrix in homogeneous coordinates to a quaternion.
 pub fn to_quat<T: RealNumber>(x: &TMat4<T>) -> Qua<T> {
-    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<T: Number>(m: &TMat3<T>, normal: &TVec2<T>) -> TMat3<T> {
     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<T: Number>(m: &TMat4<T>, normal: &TVec3<T>) -> TMat4<T> {
     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<T: RealNumber>(m: &TMat3<T>, normal: &TVec2<T>) -> TMat3<T> {
     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<T: RealNumber>(m: &TMat4<T>, normal: &TVec3<T>) -> TMat4<T> {
     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 <andreas.b.longva@gmail.com>
Date: Mon, 14 Nov 2022 15:21:20 +0100
Subject: [PATCH 059/119] 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 <andreas.b.longva@gmail.com>
Date: Mon, 14 Nov 2022 15:26:48 +0100
Subject: [PATCH 060/119] 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<T: RealField> CscCholesky<T> {
     ///
     /// Panics if `B` is not square.
     #[must_use = "Did you mean to use solve_mut()?"]
-    pub fn solve<'a>(&'a self, b: impl Into<DMatrixSlice<'a, T>>) -> DMatrix<T> {
+    pub fn solve<'a>(&'a self, b: impl Into<DMatrixView<'a, T>>) -> DMatrix<T> {
         let b = b.into();
         let mut output = b.clone_owned();
         self.solve_mut(&mut output);
@@ -278,7 +278,7 @@ impl<T: RealField> CscCholesky<T> {
     /// # Panics
     ///
     /// Panics if `b` is not square.
-    pub fn solve_mut<'a>(&'a self, b: impl Into<DMatrixSliceMut<'a, T>>) {
+    pub fn solve_mut<'a>(&'a self, b: impl Into<DMatrixViewMut<'a, T>>) {
         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<T>(
     beta: T,
-    mut c: DMatrixSliceMut<'_, T>,
+    mut c: DMatrixViewMut<'_, T>,
     alpha: T,
     a: Op<&CsMatrix<T>>,
-    b: Op<DMatrixSlice<'_, T>>,
+    b: Op<DMatrixView<'_, T>>,
 ) 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<DMatrixSliceMut<'a, T>>,
+    c: impl Into<DMatrixViewMut<'a, T>>,
     alpha: T,
     a: Op<&CscMatrix<T>>,
-    b: Op<impl Into<DMatrixSlice<'a, T>>>,
+    b: Op<impl Into<DMatrixView<'a, T>>>,
 ) where
     T: Scalar + ClosedAdd + ClosedMul + Zero + One,
 {
@@ -29,10 +29,10 @@ pub fn spmm_csc_dense<'a, T>(
 
 fn spmm_csc_dense_<T>(
     beta: T,
-    c: DMatrixSliceMut<'_, T>,
+    c: DMatrixViewMut<'_, T>,
     alpha: T,
     a: Op<&CscMatrix<T>>,
-    b: Op<DMatrixSlice<'_, T>>,
+    b: Op<DMatrixView<'_, T>>,
 ) 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<T>>,
-    b: impl Into<DMatrixSliceMut<'a, T>>,
+    b: impl Into<DMatrixViewMut<'a, T>>,
 ) -> 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<T: RealField>(
     l: &CscMatrix<T>,
-    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<T: RealField>(
     l: &CscMatrix<T>,
-    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<DMatrixSliceMut<'a, T>>,
+    c: impl Into<DMatrixViewMut<'a, T>>,
     alpha: T,
     a: Op<&CsrMatrix<T>>,
-    b: Op<impl Into<DMatrixSlice<'a, T>>>,
+    b: Op<impl Into<DMatrixView<'a, T>>>,
 ) where
     T: Scalar + ClosedAdd + ClosedMul + Zero + One,
 {
@@ -24,10 +24,10 @@ pub fn spmm_csr_dense<'a, T>(
 
 fn spmm_csr_dense_<T>(
     beta: T,
-    c: DMatrixSliceMut<'_, T>,
+    c: DMatrixViewMut<'_, T>,
     alpha: T,
     a: Op<&CsrMatrix<T>>,
-    b: Op<DMatrixSlice<'_, T>>,
+    b: Op<DMatrixView<'_, T>>,
 ) 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::<i32, 2, 2>::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::<Vec<_>>(),
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<Value = CscMatrix<f64>>
 /// Helper function to help us call dense GEMM with our `Op` type
 fn dense_gemm<'a>(
     beta: i32,
-    c: impl Into<DMatrixSliceMut<'a, i32>>,
+    c: impl Into<DMatrixViewMut<'a, i32>>,
     alpha: i32,
-    a: Op<impl Into<DMatrixSlice<'a, i32>>>,
-    b: Op<impl Into<DMatrixSlice<'a, i32>>>,
+    a: Op<impl Into<DMatrixView<'a, i32>>>,
+    b: Op<impl Into<DMatrixView<'a, i32>>>,
 ) {
     let mut c = c.into();
     let a = a.convert();

From 31e687bd76b22430ed3f18e6af761e4a551fa78e Mon Sep 17 00:00:00 2001
From: Andreas Longva <andreas.b.longva@gmail.com>
Date: Mon, 14 Nov 2022 16:41:01 +0100
Subject: [PATCH 061/119] 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<T, R, C, S>>
     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<T, R, C, S>>
     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<T, R, C, S>>
     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<T, R, C, S> Matrix<T, R, C, S>
+where
+    R: Dim,
+    C: Dim,
+    S: RawStorage<T, R, C>,
+{
+    /// 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<f64>) {}
+    ///
+    /// let matrix = nalgebra::Matrix3::zeros();
+    /// consume_view(matrix.as_view());
+    ///
+    /// let dynamic_view: DMatrixSlice<f64> = matrix.as_view();
+    /// let static_view_from_dyn: SMatrixView<f64, 3, 3> = dynamic_view.as_view();
+    /// ```
+    pub fn as_view<RView, CView, RViewStride, CViewStride>(&self) -> MatrixView<'_, T, RView, CView, RViewStride, CViewStride>
+    where
+        RView: Dim,
+        CView: Dim,
+        RViewStride: Dim,
+        CViewStride: Dim,
+        ShapeConstraint: DimEq<R, RView> + DimEq<C, CView> + DimEq<RViewStride, S::RStride> + DimEq<CViewStride, S::CStride>
+    {
+        // Defer to (&matrix).into()
+        self.into()
+    }
+}
+
+impl<T, R, C, S> Matrix<T, R, C, S>
+where
+    R: Dim,
+    C: Dim,
+    S: RawStorageMut<T, R, C>,
+{
+    /// 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<f64>) {}
+    ///
+    /// let mut matrix = nalgebra::Matrix3::zeros();
+    /// consume_view(matrix.as_view_mut());
+    ///
+    /// let mut dynamic_view: DMatrixViewMut<f64> = matrix.as_view_mut();
+    /// let static_view_from_dyn: SMatrixViewMut<f64, 3, 3> = dynamic_view.as_view_mut();
+    /// ```
+    pub fn as_view_mut<RView, CView, RViewStride, CViewStride>(&mut self) -> MatrixViewMut<'_, T, RView, CView, RViewStride, CViewStride>
+        where
+            RView: Dim,
+            CView: Dim,
+            RViewStride: Dim,
+            CViewStride: Dim,
+            ShapeConstraint: DimEq<R, RView> + DimEq<C, CView> + DimEq<RViewStride, S::RStride> + DimEq<CViewStride, S::CStride>
+    {
+        // Defer to (&mut matrix).into()
+        self.into()
+    }
+}

From 55c3a9c76408178411dbd71d3431f57b75cf589f Mon Sep 17 00:00:00 2001
From: Andreas Longva <andreas.b.longva@gmail.com>
Date: Mon, 14 Nov 2022 16:43:47 +0100
Subject: [PATCH 062/119] 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<T, R, C>,
-    ShapeConstraint: DimEq<R, RView>
-        + DimEq<C, CView>
-        + DimEq<RStride, S::RStride>
-        + DimEq<CStride, S::CStride>,
+    ShapeConstraint:
+        DimEq<R, RView> + DimEq<C, CView> + DimEq<RStride, S::RStride> + DimEq<CStride, S::CStride>,
 {
     fn from(m: &'a Matrix<T, R, C, S>) -> Self {
         let (row, col) = m.shape_generic();
@@ -416,10 +414,8 @@ where
     RStride: Dim,
     CStride: Dim,
     S: RawStorage<T, R, C>,
-    ShapeConstraint: DimEq<R, RView>
-        + DimEq<C, CView>
-        + DimEq<RStride, S::RStride>
-        + DimEq<CStride, S::CStride>,
+    ShapeConstraint:
+        DimEq<R, RView> + DimEq<C, CView> + DimEq<RStride, S::RStride> + DimEq<CStride, S::CStride>,
 {
     fn from(m: &'a mut Matrix<T, R, C, S>) -> Self {
         let (row, col) = m.shape_generic();
@@ -452,10 +448,8 @@ where
     RStride: Dim,
     CStride: Dim,
     S: RawStorageMut<T, R, C>,
-    ShapeConstraint: DimEq<R, RView>
-        + DimEq<C, CView>
-        + DimEq<RStride, S::RStride>
-        + DimEq<CStride, S::CStride>,
+    ShapeConstraint:
+        DimEq<R, RView> + DimEq<C, CView> + DimEq<RStride, S::RStride> + DimEq<CStride, S::CStride>,
 {
     fn from(m: &'a mut Matrix<T, R, C, S>) -> 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<T, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S> {
         rows: RowRange,
         cols: ColRange,
     ) -> MatrixView<'_, T, RowRange::Size, ColRange::Size, S::RStride, S::CStride>
-        where
-            RowRange: DimRange<R>,
-            ColRange: DimRange<C>,
+    where
+        RowRange: DimRange<R>,
+        ColRange: DimRange<C>,
     {
         let (nrows, ncols) = self.shape_generic();
         self.generic_view(
@@ -1043,9 +1043,9 @@ impl<T, R: Dim, C: Dim, S: RawStorageMut<T, R, C>> Matrix<T, R, C, S> {
         rows: RowRange,
         cols: ColRange,
     ) -> MatrixViewMut<'_, T, RowRange::Size, ColRange::Size, S::RStride, S::CStride>
-        where
-            RowRange: DimRange<R>,
-            ColRange: DimRange<C>,
+    where
+        RowRange: DimRange<R>,
+        ColRange: DimRange<C>,
     {
         let (nrows, ncols) = self.shape_generic();
         self.generic_view_mut(
@@ -1122,13 +1122,18 @@ where
     /// let dynamic_view: DMatrixSlice<f64> = matrix.as_view();
     /// let static_view_from_dyn: SMatrixView<f64, 3, 3> = dynamic_view.as_view();
     /// ```
-    pub fn as_view<RView, CView, RViewStride, CViewStride>(&self) -> MatrixView<'_, T, RView, CView, RViewStride, CViewStride>
+    pub fn as_view<RView, CView, RViewStride, CViewStride>(
+        &self,
+    ) -> MatrixView<'_, T, RView, CView, RViewStride, CViewStride>
     where
         RView: Dim,
         CView: Dim,
         RViewStride: Dim,
         CViewStride: Dim,
-        ShapeConstraint: DimEq<R, RView> + DimEq<C, CView> + DimEq<RViewStride, S::RStride> + DimEq<CViewStride, S::CStride>
+        ShapeConstraint: DimEq<R, RView>
+            + DimEq<C, CView>
+            + DimEq<RViewStride, S::RStride>
+            + DimEq<CViewStride, S::CStride>,
     {
         // Defer to (&matrix).into()
         self.into()
@@ -1164,13 +1169,18 @@ where
     /// let mut dynamic_view: DMatrixViewMut<f64> = matrix.as_view_mut();
     /// let static_view_from_dyn: SMatrixViewMut<f64, 3, 3> = dynamic_view.as_view_mut();
     /// ```
-    pub fn as_view_mut<RView, CView, RViewStride, CViewStride>(&mut self) -> MatrixViewMut<'_, T, RView, CView, RViewStride, CViewStride>
-        where
-            RView: Dim,
-            CView: Dim,
-            RViewStride: Dim,
-            CViewStride: Dim,
-            ShapeConstraint: DimEq<R, RView> + DimEq<C, CView> + DimEq<RViewStride, S::RStride> + DimEq<CViewStride, S::CStride>
+    pub fn as_view_mut<RView, CView, RViewStride, CViewStride>(
+        &mut self,
+    ) -> MatrixViewMut<'_, T, RView, CView, RViewStride, CViewStride>
+    where
+        RView: Dim,
+        CView: Dim,
+        RViewStride: Dim,
+        CViewStride: Dim,
+        ShapeConstraint: DimEq<R, RView>
+            + DimEq<C, CView>
+            + DimEq<RViewStride, S::RStride>
+            + DimEq<CViewStride, S::CStride>,
     {
         // 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 <andreas.b.longva@gmail.com>
Date: Mon, 14 Nov 2022 16:59:54 +0100
Subject: [PATCH 063/119] 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")]

From a4fdea927d7ddc5f84d8ce8f00aad91020730c16 Mon Sep 17 00:00:00 2001
From: "Ryan B. Harvey" <ryan.b.harvey@gmail.com>
Date: Mon, 12 Dec 2022 04:21:23 +0000
Subject: [PATCH 064/119] Add simple cargo doc step to CI

---
 .github/workflows/nalgebra-ci-build.yml | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/nalgebra-ci-build.yml b/.github/workflows/nalgebra-ci-build.yml
index d1a6c923..8b96d264 100644
--- a/.github/workflows/nalgebra-ci-build.yml
+++ b/.github/workflows/nalgebra-ci-build.yml
@@ -136,4 +136,10 @@ jobs:
       - run: cargo build --no-default-features --features cuda
       - run: cargo build --no-default-features --features cuda --target=nvptx64-nvidia-cuda
         env: 
-          CUDA_ARCH: "350"
\ No newline at end of file
+          CUDA_ARCH: "350"
+  docs:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - name: Generate documentation
+      run: cargo doc

From b2da4609cf58d8ae8dcab10562ea8a0e1821a88f Mon Sep 17 00:00:00 2001
From: Liam <6039896+Spodeian@users.noreply.github.com>
Date: Wed, 21 Dec 2022 18:51:02 +1100
Subject: [PATCH 065/119] Update isometry.rs

Fix formatting of documentation so that "A 3D isometry is composed of:" is on its own line.
---
 src/geometry/isometry.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/geometry/isometry.rs b/src/geometry/isometry.rs
index 67660800..ff7c7502 100755
--- a/src/geometry/isometry.rs
+++ b/src/geometry/isometry.rs
@@ -21,6 +21,7 @@ use crate::geometry::{AbstractRotation, Point, Translation};
 /// A 2D isometry is composed of:
 /// - A translation part of type [`Translation2`](crate::Translation2)
 /// - A rotation part which can either be a [`UnitComplex`](crate::UnitComplex) or a [`Rotation2`](crate::Rotation2).
+/// 
 /// A 3D isometry is composed of:
 /// - A translation part of type [`Translation3`](crate::Translation3)
 /// - A rotation part which can either be a [`UnitQuaternion`](crate::UnitQuaternion) or a [`Rotation3`](crate::Rotation3).

From e959f2eb9cec6bd771eebf74cee425c0edc934cb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=A9bastien=20Crozet?= <developer@crozet.re>
Date: Fri, 13 Jan 2023 09:58:41 +0100
Subject: [PATCH 066/119] Fix CheckBytes derives + drop Complex rkyv support
 for now

---
 Cargo.toml                      |  8 +---
 src/base/array_storage.rs       |  5 +--
 src/base/dimension.rs           |  8 ++--
 src/base/matrix.rs              |  9 ++---
 src/base/mod.rs                 |  3 ++
 src/base/rkyv_wrappers.rs       | 72 +++++++++++++++++++++++++++++++++
 src/base/unit.rs                |  5 +--
 src/geometry/dual_quaternion.rs |  5 +--
 src/geometry/orthographic.rs    |  5 +--
 src/geometry/perspective.rs     |  5 +--
 src/geometry/quaternion.rs      | 11 ++---
 src/geometry/rotation.rs        |  5 +--
 src/geometry/scale.rs           |  5 +--
 src/geometry/translation.rs     |  5 +--
 tests/core/rkyv.rs              | 11 +++--
 15 files changed, 100 insertions(+), 62 deletions(-)
 create mode 100644 src/base/rkyv_wrappers.rs

diff --git a/Cargo.toml b/Cargo.toml
index b657e6a2..9d0b1a7c 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -54,8 +54,8 @@ convert-glam022 = [ "glam022" ]
 ## `serde-serialize`.
 serde-serialize-no-std = [ "serde", "num-complex/serde" ]
 serde-serialize        = [ "serde-serialize-no-std", "serde/std" ]
-rkyv-serialize-no-std  = [ "rkyv", "rkyv_wrappers", "num-complex/rkyv" ]
-rkyv-serialize         = [ "rkyv-serialize-no-std", "rkyv/std", "rkyv/validation", "bytecheck", "num-complex/bytecheck" ]
+rkyv-serialize-no-std  = [ "rkyv/size_32" ]
+rkyv-serialize         = [ "rkyv-serialize-no-std", "rkyv/std", "rkyv/validation", "bytecheck" ]
 
 # Randomness
 ## To use rand in a #[no-std] environment, enable the
@@ -83,7 +83,6 @@ rand_distr     = { version = "0.4", default-features = false, optional = true }
 matrixmultiply = { version = "0.3", optional = true }
 serde          = { version = "1.0", default-features = false, features = [ "derive" ], optional = true }
 rkyv           = { version = "0.7", default-features = false, optional = true }
-rkyv_wrappers  = { git = "https://github.com/rkyv/rkyv_contrib", optional = true }
 bytecheck      = { version = "~0.6.1", optional = true }
 mint           = { version = "0.5", optional = true }
 quickcheck     = { version = "1", optional = true }
@@ -138,6 +137,3 @@ lto = true
 [package.metadata.docs.rs]
 # Enable all the features when building the docs on docs.rs
 all-features = true
-
-[patch.crates-io]
-num-complex = { git = "https://github.com/zyansheep/num-complex" }
\ No newline at end of file
diff --git a/src/base/array_storage.rs b/src/base/array_storage.rs
index 94ed8bb0..5c165399 100644
--- a/src/base/array_storage.rs
+++ b/src/base/array_storage.rs
@@ -38,10 +38,7 @@ use std::mem;
     ")
     )
 )]
-#[cfg_attr(
-    feature = "rkyv-serialize",
-    archive_attr(derive(bytecheck::CheckBytes))
-)]
+#[cfg_attr(feature = "rkyv-serialize", derive(bytecheck::CheckBytes))]
 #[cfg_attr(feature = "cuda", derive(cust_core::DeviceCopy))]
 pub struct ArrayStorage<T, const R: usize, const C: usize>(pub [[T; R]; C]);
 
diff --git a/src/base/dimension.rs b/src/base/dimension.rs
index 06697618..3d1de1ff 100644
--- a/src/base/dimension.rs
+++ b/src/base/dimension.rs
@@ -208,12 +208,10 @@ dim_ops!(
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 #[cfg_attr(
     feature = "rkyv-serialize-no-std",
-    derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
-)]
-#[cfg_attr(
-    feature = "rkyv-serialize",
-    archive_attr(derive(bytecheck::CheckBytes))
+    derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize),
+    archive(as = "Self")
 )]
+#[cfg_attr(feature = "rkyv-serialize", derive(bytecheck::CheckBytes))]
 #[cfg_attr(feature = "cuda", derive(cust_core::DeviceCopy))]
 pub struct Const<const R: usize>;
 
diff --git a/src/base/matrix.rs b/src/base/matrix.rs
index 8f664dd4..700e2f02 100644
--- a/src/base/matrix.rs
+++ b/src/base/matrix.rs
@@ -12,9 +12,9 @@ use std::mem;
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[cfg(feature = "rkyv-serialize-no-std")]
-use rkyv::{with::With, Archive, Archived};
+use super::rkyv_wrappers::CustomPhantom;
 #[cfg(feature = "rkyv-serialize-no-std")]
-use rkyv_wrappers::custom_phantom::CustomPhantom;
+use rkyv::{with::With, Archive, Archived};
 
 use simba::scalar::{ClosedAdd, ClosedMul, ClosedSub, Field, SupersetOf};
 use simba::simd::SimdPartialOrd;
@@ -167,10 +167,7 @@ pub type MatrixCross<T, R1, C1, R2, C2> =
     ")
     )
 )]
-#[cfg_attr(
-    feature = "rkyv-serialize",
-    archive_attr(derive(bytecheck::CheckBytes))
-)]
+#[cfg_attr(feature = "rkyv-serialize", derive(bytecheck::CheckBytes))]
 #[cfg_attr(feature = "cuda", derive(cust_core::DeviceCopy))]
 pub struct Matrix<T, R, C, S> {
     /// The data storage that contains all the matrix components. Disappointed?
diff --git a/src/base/mod.rs b/src/base/mod.rs
index dfe7cc8d..4cbcff93 100644
--- a/src/base/mod.rs
+++ b/src/base/mod.rs
@@ -42,6 +42,9 @@ mod min_max;
 /// Mechanisms for working with values that may not be initialized.
 pub mod uninit;
 
+#[cfg(feature = "rkyv-serialize-no-std")]
+mod rkyv_wrappers;
+
 pub use self::matrix::*;
 pub use self::norm::*;
 pub use self::scalar::*;
diff --git a/src/base/rkyv_wrappers.rs b/src/base/rkyv_wrappers.rs
new file mode 100644
index 00000000..b11c618a
--- /dev/null
+++ b/src/base/rkyv_wrappers.rs
@@ -0,0 +1,72 @@
+//! Wrapper that allows changing the generic type of a PhantomData<T>
+//!
+//! Copied from https://github.com/rkyv/rkyv_contrib (MIT-Apache2 licences) which isn’t published yet.
+
+use rkyv::{
+    with::{ArchiveWith, DeserializeWith, SerializeWith},
+    Fallible,
+};
+use std::marker::PhantomData;
+
+/// A wrapper that allows for changing the generic type of a PhantomData<T>.
+///
+/// Example:
+///
+/// ```rust
+/// use std::marker::PhantomData;
+/// use rkyv::{
+///     Archive, Serialize, Deserialize, Infallible, vec::ArchivedVec, Archived, with::With,
+/// };
+/// use rkyv_wrappers::custom_phantom::CustomPhantom;
+/// #[derive(Archive, Serialize, Deserialize, Debug, PartialEq, Eq, Default)]
+/// #[archive(as = "StructWithPhantom<T::Archived>", bound(archive = "
+/// 	T: Archive,
+/// 	With<PhantomData<T>, CustomPhantom<Archived<T>>>: Archive<Archived = PhantomData<Archived<T>>>
+/// "))]
+/// struct StructWithPhantom<T> {
+/// 	pub num: i32,
+///     #[with(CustomPhantom<T::Archived>)]
+///     pub phantom: PhantomData<T>,
+/// }
+/// let value = StructWithPhantom::<Vec<i32>>::default();
+/// let bytes = rkyv::to_bytes::<_, 1024>(&value).unwrap();
+/// let archived: &StructWithPhantom<ArchivedVec<i32>> = unsafe { rkyv::archived_root::<StructWithPhantom<Vec<i32>>>(&bytes) };
+///
+/// let deserialized: StructWithPhantom<Vec<i32>> = archived.deserialize(&mut Infallible).unwrap();
+/// assert_eq!(deserialized, value);
+/// ```
+pub struct CustomPhantom<NT: ?Sized> {
+    _data: PhantomData<*const NT>,
+}
+
+impl<OT: ?Sized, NT: ?Sized> ArchiveWith<PhantomData<OT>> for CustomPhantom<NT> {
+    type Archived = PhantomData<NT>;
+    type Resolver = ();
+
+    #[inline]
+    unsafe fn resolve_with(
+        _: &PhantomData<OT>,
+        _: usize,
+        _: Self::Resolver,
+        _: *mut Self::Archived,
+    ) {
+    }
+}
+
+impl<OT: ?Sized, NT: ?Sized, S: Fallible + ?Sized> SerializeWith<PhantomData<OT>, S>
+    for CustomPhantom<NT>
+{
+    #[inline]
+    fn serialize_with(_: &PhantomData<OT>, _: &mut S) -> Result<Self::Resolver, S::Error> {
+        Ok(())
+    }
+}
+
+impl<OT: ?Sized, NT: ?Sized, D: Fallible + ?Sized>
+    DeserializeWith<PhantomData<NT>, PhantomData<OT>, D> for CustomPhantom<NT>
+{
+    #[inline]
+    fn deserialize_with(_: &PhantomData<NT>, _: &mut D) -> Result<PhantomData<OT>, D::Error> {
+        Ok(PhantomData)
+    }
+}
diff --git a/src/base/unit.rs b/src/base/unit.rs
index 3d6f677f..2fc51107 100644
--- a/src/base/unit.rs
+++ b/src/base/unit.rs
@@ -31,10 +31,7 @@ use crate::{Dim, Matrix, OMatrix, RealField, Scalar, SimdComplexField, SimdRealF
     ")
     )
 )]
-#[cfg_attr(
-    feature = "rkyv-serialize",
-    archive_attr(derive(bytecheck::CheckBytes))
-)]
+#[cfg_attr(feature = "rkyv-serialize", derive(bytecheck::CheckBytes))]
 // #[cfg_attr(feature = "cuda", derive(cust_core::DeviceCopy))]
 pub struct Unit<T> {
     pub(crate) value: T,
diff --git a/src/geometry/dual_quaternion.rs b/src/geometry/dual_quaternion.rs
index 828f7116..bae04f46 100644
--- a/src/geometry/dual_quaternion.rs
+++ b/src/geometry/dual_quaternion.rs
@@ -51,10 +51,7 @@ use simba::scalar::{ClosedNeg, RealField};
     ")
     )
 )]
-#[cfg_attr(
-    feature = "rkyv-serialize",
-    archive_attr(derive(bytecheck::CheckBytes))
-)]
+#[cfg_attr(feature = "rkyv-serialize", derive(bytecheck::CheckBytes))]
 #[cfg_attr(feature = "cuda", derive(cust_core::DeviceCopy))]
 pub struct DualQuaternion<T> {
     /// The real component of the quaternion
diff --git a/src/geometry/orthographic.rs b/src/geometry/orthographic.rs
index 0368ee6f..06d0b471 100644
--- a/src/geometry/orthographic.rs
+++ b/src/geometry/orthographic.rs
@@ -30,10 +30,7 @@ use crate::geometry::{Point3, Projective3};
     ")
     )
 )]
-#[cfg_attr(
-    feature = "rkyv-serialize",
-    archive_attr(derive(bytecheck::CheckBytes))
-)]
+#[cfg_attr(feature = "rkyv-serialize", derive(bytecheck::CheckBytes))]
 #[cfg_attr(feature = "cuda", derive(cust_core::DeviceCopy))]
 #[derive(Copy, Clone)]
 pub struct Orthographic3<T> {
diff --git a/src/geometry/perspective.rs b/src/geometry/perspective.rs
index 91e97efe..a5fc19a8 100644
--- a/src/geometry/perspective.rs
+++ b/src/geometry/perspective.rs
@@ -31,10 +31,7 @@ use crate::geometry::{Point3, Projective3};
     ")
     )
 )]
-#[cfg_attr(
-    feature = "rkyv-serialize",
-    archive_attr(derive(bytecheck::CheckBytes))
-)]
+#[cfg_attr(feature = "rkyv-serialize", derive(bytecheck::CheckBytes))]
 #[cfg_attr(feature = "cuda", derive(cust_core::DeviceCopy))]
 #[derive(Copy, Clone)]
 pub struct Perspective3<T> {
diff --git a/src/geometry/quaternion.rs b/src/geometry/quaternion.rs
index 9dfc3ec3..1b251b29 100755
--- a/src/geometry/quaternion.rs
+++ b/src/geometry/quaternion.rs
@@ -29,15 +29,12 @@ use crate::geometry::{Point3, Rotation};
     archive(
         as = "Quaternion<T::Archived>",
         bound(archive = "
-        T: rkyv::Archive,
-        Vector4<T>: rkyv::Archive<Archived = Vector4<T::Archived>>
-    ")
+            T: rkyv::Archive,
+            Vector4<T>: rkyv::Archive<Archived = Vector4<T::Archived>>
+        ")
     )
 )]
-#[cfg_attr(
-    feature = "rkyv-serialize",
-    archive_attr(derive(bytecheck::CheckBytes))
-)]
+#[cfg_attr(feature = "rkyv-serialize", derive(bytecheck::CheckBytes))]
 #[cfg_attr(feature = "cuda", derive(cust_core::DeviceCopy))]
 pub struct Quaternion<T> {
     /// This quaternion as a 4D vector of coordinates in the `[ x, y, z, w ]` storage order.
diff --git a/src/geometry/rotation.rs b/src/geometry/rotation.rs
index 2774cb14..5eceec21 100755
--- a/src/geometry/rotation.rs
+++ b/src/geometry/rotation.rs
@@ -60,10 +60,7 @@ use crate::geometry::Point;
     ")
     )
 )]
-#[cfg_attr(
-    feature = "rkyv-serialize",
-    archive_attr(derive(bytecheck::CheckBytes))
-)]
+#[cfg_attr(feature = "rkyv-serialize", derive(bytecheck::CheckBytes))]
 #[cfg_attr(feature = "cuda", derive(cust_core::DeviceCopy))]
 #[derive(Copy, Clone)]
 pub struct Rotation<T, const D: usize> {
diff --git a/src/geometry/scale.rs b/src/geometry/scale.rs
index 93b2258f..36a68066 100755
--- a/src/geometry/scale.rs
+++ b/src/geometry/scale.rs
@@ -28,10 +28,7 @@ use crate::geometry::Point;
     ")
     )
 )]
-#[cfg_attr(
-    feature = "rkyv-serialize",
-    archive_attr(derive(bytecheck::CheckBytes))
-)]
+#[cfg_attr(feature = "rkyv-serialize", derive(bytecheck::CheckBytes))]
 #[cfg_attr(feature = "cuda", derive(cust_core::DeviceCopy))]
 #[derive(Copy, Clone)]
 pub struct Scale<T, const D: usize> {
diff --git a/src/geometry/translation.rs b/src/geometry/translation.rs
index d44e891b..39fae3b6 100755
--- a/src/geometry/translation.rs
+++ b/src/geometry/translation.rs
@@ -28,10 +28,7 @@ use crate::geometry::Point;
     ")
     )
 )]
-#[cfg_attr(
-    feature = "rkyv-serialize",
-    archive_attr(derive(bytecheck::CheckBytes))
-)]
+#[cfg_attr(feature = "rkyv-serialize", derive(bytecheck::CheckBytes))]
 #[cfg_attr(feature = "cuda", derive(cust_core::DeviceCopy))]
 #[derive(Copy, Clone)]
 pub struct Translation<T, const D: usize> {
diff --git a/tests/core/rkyv.rs b/tests/core/rkyv.rs
index 678e06d1..ffe9ed30 100644
--- a/tests/core/rkyv.rs
+++ b/tests/core/rkyv.rs
@@ -1,12 +1,11 @@
 #![cfg(feature = "rkyv-serialize")]
 
 use na::{
-    DMatrix, Isometry2, Isometry3, IsometryMatrix2, IsometryMatrix3, Matrix2x3, Matrix3x4, Point2,
-    Point3, Quaternion, Rotation2, Rotation3, Similarity2, Similarity3, SimilarityMatrix2,
-    SimilarityMatrix3, Translation2, Translation3, Unit, Vector2,
+    Isometry3, IsometryMatrix2, IsometryMatrix3, Matrix3x4, Point2, Point3, Quaternion, Rotation2,
+    Rotation3, Similarity3, SimilarityMatrix2, SimilarityMatrix3, Translation2, Translation3,
 };
 use rand;
-use rkyv::{Archive, Deserialize, Infallible, Serialize};
+use rkyv::{Deserialize, Infallible};
 
 macro_rules! test_rkyv_same_type(
     ($($test: ident, $ty: ident);* $(;)*) => {$(
@@ -52,9 +51,9 @@ test_rkyv_same_type!(
     rkyv_same_type_point2,             Point2;
     rkyv_same_type_translation2,       Translation2;
     rkyv_same_type_rotation2,          Rotation2;
-    rkyv_same_type_isometry2,          Isometry2;
+    // rkyv_same_type_isometry2,          Isometry2;
     rkyv_same_type_isometry_matrix2,   IsometryMatrix2;
-    rkyv_same_type_similarity2,        Similarity2;
+    // rkyv_same_type_similarity2,        Similarity2;
     rkyv_same_type_similarity_matrix2, SimilarityMatrix2;
 );
 

From e24acba5f952f47cb8eec86b6a8233c56cd4be5d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=A9bastien=20Crozet?= <developer@crozet.re>
Date: Fri, 13 Jan 2023 10:05:52 +0100
Subject: [PATCH 067/119] cargo fmt

---
 src/geometry/isometry.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/geometry/isometry.rs b/src/geometry/isometry.rs
index 04f7fca8..e3f44075 100755
--- a/src/geometry/isometry.rs
+++ b/src/geometry/isometry.rs
@@ -21,7 +21,7 @@ use crate::geometry::{AbstractRotation, Point, Translation};
 /// A 2D isometry is composed of:
 /// - A translation part of type [`Translation2`](crate::Translation2)
 /// - A rotation part which can either be a [`UnitComplex`](crate::UnitComplex) or a [`Rotation2`](crate::Rotation2).
-/// 
+///
 /// A 3D isometry is composed of:
 /// - A translation part of type [`Translation3`](crate::Translation3)
 /// - A rotation part which can either be a [`UnitQuaternion`](crate::UnitQuaternion) or a [`Rotation3`](crate::Rotation3).

From 7cacb2bf4a77db2e523e1752b99fecce696a6b2b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=A9bastien=20Crozet?= <developer@crozet.re>
Date: Fri, 13 Jan 2023 10:06:49 +0100
Subject: [PATCH 068/119] Fix CI for Cuda

---
 .github/workflows/nalgebra-ci-build.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/nalgebra-ci-build.yml b/.github/workflows/nalgebra-ci-build.yml
index 8b96d264..d4f061d8 100644
--- a/.github/workflows/nalgebra-ci-build.yml
+++ b/.github/workflows/nalgebra-ci-build.yml
@@ -125,7 +125,7 @@ jobs:
     steps:
       - uses: Jimver/cuda-toolkit@v0.2.4
         with:
-          cuda: '11.2.2'
+          cuda: '11.5.0'
       - name: Install nightly-2021-12-04
         uses: actions-rs/toolchain@v1
         with:

From ed573d054cccb5a893b9a7ef0b09386d71141f50 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=A9bastien=20Crozet?= <developer@crozet.re>
Date: Fri, 13 Jan 2023 10:10:53 +0100
Subject: [PATCH 069/119] Fix tests

---
 src/base/rkyv_wrappers.rs | 26 --------------------------
 1 file changed, 26 deletions(-)

diff --git a/src/base/rkyv_wrappers.rs b/src/base/rkyv_wrappers.rs
index b11c618a..ce178674 100644
--- a/src/base/rkyv_wrappers.rs
+++ b/src/base/rkyv_wrappers.rs
@@ -9,32 +9,6 @@ use rkyv::{
 use std::marker::PhantomData;
 
 /// A wrapper that allows for changing the generic type of a PhantomData<T>.
-///
-/// Example:
-///
-/// ```rust
-/// use std::marker::PhantomData;
-/// use rkyv::{
-///     Archive, Serialize, Deserialize, Infallible, vec::ArchivedVec, Archived, with::With,
-/// };
-/// use rkyv_wrappers::custom_phantom::CustomPhantom;
-/// #[derive(Archive, Serialize, Deserialize, Debug, PartialEq, Eq, Default)]
-/// #[archive(as = "StructWithPhantom<T::Archived>", bound(archive = "
-/// 	T: Archive,
-/// 	With<PhantomData<T>, CustomPhantom<Archived<T>>>: Archive<Archived = PhantomData<Archived<T>>>
-/// "))]
-/// struct StructWithPhantom<T> {
-/// 	pub num: i32,
-///     #[with(CustomPhantom<T::Archived>)]
-///     pub phantom: PhantomData<T>,
-/// }
-/// let value = StructWithPhantom::<Vec<i32>>::default();
-/// let bytes = rkyv::to_bytes::<_, 1024>(&value).unwrap();
-/// let archived: &StructWithPhantom<ArchivedVec<i32>> = unsafe { rkyv::archived_root::<StructWithPhantom<Vec<i32>>>(&bytes) };
-///
-/// let deserialized: StructWithPhantom<Vec<i32>> = archived.deserialize(&mut Infallible).unwrap();
-/// assert_eq!(deserialized, value);
-/// ```
 pub struct CustomPhantom<NT: ?Sized> {
     _data: PhantomData<*const NT>,
 }

From 924795be45d9478b42e39ca90442ec77fb0708ad Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=A9bastien=20Crozet?= <developer@crozet.re>
Date: Fri, 13 Jan 2023 10:12:47 +0100
Subject: [PATCH 070/119] CI: use the newer version of Jimver/cuda-toolkit

---
 .github/workflows/nalgebra-ci-build.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/nalgebra-ci-build.yml b/.github/workflows/nalgebra-ci-build.yml
index d4f061d8..9e500084 100644
--- a/.github/workflows/nalgebra-ci-build.yml
+++ b/.github/workflows/nalgebra-ci-build.yml
@@ -50,7 +50,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       # Needed because the --all-features build which enables cuda support.
-      - uses: Jimver/cuda-toolkit@v0.2.4
+      - uses: Jimver/cuda-toolkit@v0.2.8
       - uses: actions/checkout@v2
       - run: cargo build --all-features;
       - run: cargo build -p nalgebra-glm --all-features;
@@ -123,7 +123,7 @@ jobs:
   build-cuda:
     runs-on: ubuntu-latest
     steps:
-      - uses: Jimver/cuda-toolkit@v0.2.4
+      - uses: Jimver/cuda-toolkit@v0.2.8
         with:
           cuda: '11.5.0'
       - name: Install nightly-2021-12-04

From 00f1f11ca5c1603117b22e6f890d7485302a3127 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=A9bastien=20Crozet?= <developer@crozet.re>
Date: Fri, 13 Jan 2023 10:28:22 +0100
Subject: [PATCH 071/119] Deny unused_qualifications

---
 src/lib.rs | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index d12e991f..93f05ff5 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -88,12 +88,7 @@ an optimized set of tools for computer graphics and physics. Those features incl
     future_incompatible,
     missing_copy_implementations
 )]
-#![cfg_attr(feature = "rkyv-serialize-no-std", allow(unused_results))] // TODO: deny this once bytecheck stops generating warnings.
-#![cfg_attr(
-    not(feature = "rkyv-serialize-no-std"),
-    deny(unused_results),
-    deny(unused_qualifications)
-)] // TODO: deny this globally
+#![cfg_attr(not(feature = "rkyv-serialize-no-std"), deny(unused_results))] // TODO: deny this globally once bytecheck stops generating unused results.
 #![doc(
     html_favicon_url = "https://nalgebra.org/img/favicon.ico",
     html_root_url = "https://docs.rs/nalgebra/0.25.0"

From 598cb4fa8d9010dd95aa274e7764a178f13697c8 Mon Sep 17 00:00:00 2001
From: Hennadii Chernyshchyk <genaloner@gmail.com>
Date: Wed, 11 Jan 2023 15:16:16 +0200
Subject: [PATCH 072/119] Add ln_determinant to Cholesky

---
 src/linalg/cholesky.rs | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/src/linalg/cholesky.rs b/src/linalg/cholesky.rs
index f61a4e63..830cf2f1 100644
--- a/src/linalg/cholesky.rs
+++ b/src/linalg/cholesky.rs
@@ -2,6 +2,7 @@
 use serde::{Deserialize, Serialize};
 
 use num::One;
+use num::Zero;
 use simba::scalar::ComplexField;
 use simba::simd::SimdComplexField;
 
@@ -41,6 +42,7 @@ where
 impl<T: SimdComplexField, D: Dim> Cholesky<T, D>
 where
     DefaultAllocator: Allocator<T, D, D>,
+    T::SimdRealField: Zero,
 {
     /// Computes the Cholesky decomposition of `matrix` without checking that the matrix is definite-positive.
     ///
@@ -161,6 +163,27 @@ where
         }
         prod_diag.simd_modulus_squared()
     }
+
+    /// Computes the natural logarithm of determinant of the decomposed matrix.
+    ///
+    /// This method is more robust than `.determinant()` to very small or very
+    /// large determinants since it returns the natural logarithm of the
+    /// determinant rather than the determinant itself.
+    #[must_use]
+    pub fn ln_determinant(&self) -> T::SimdRealField {
+        let dim = self.chol.nrows();
+        let mut sum_diag = T::SimdRealField::zero();
+        for i in 0..dim {
+            sum_diag += unsafe {
+                self.chol
+                    .get_unchecked((i, i))
+                    .clone()
+                    .simd_modulus_squared()
+                    .simd_ln()
+            };
+        }
+        sum_diag
+    }
 }
 
 impl<T: ComplexField, D: Dim> Cholesky<T, D>

From dc1b291ece4acf1744b43fa9f242698ed4427ef5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=A9bastien=20Crozet?= <developer@crozet.re>
Date: Sat, 14 Jan 2023 11:47:17 +0100
Subject: [PATCH 073/119] Merge pull request #1179 from
 timethy/euler-angles-patch

Fix typo in `euler_angles()`, and cache cosine computation.
---
 src/geometry/rotation_specialization.rs | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/src/geometry/rotation_specialization.rs b/src/geometry/rotation_specialization.rs
index bba92512..1ea5cd92 100644
--- a/src/geometry/rotation_specialization.rs
+++ b/src/geometry/rotation_specialization.rs
@@ -956,13 +956,15 @@ impl<T: SimdRealField> Rotation3<T> {
     {
         // Implementation informed by "Computing Euler angles from a rotation matrix", by Gregory G. Slabaugh
         //  https://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.371.6578
+        //  where roll, pitch, yaw angles are referred to as ψ, θ, ϕ,
         if self[(2, 0)].clone().abs() < T::one() {
-            let yaw = -self[(2, 0)].clone().asin();
-            let roll = (self[(2, 1)].clone() / yaw.clone().cos())
-                .atan2(self[(2, 2)].clone() / yaw.clone().cos());
-            let pitch = (self[(1, 0)].clone() / yaw.clone().cos())
-                .atan2(self[(0, 0)].clone() / yaw.clone().cos());
-            (roll, yaw, pitch)
+            let pitch = -self[(2, 0)].clone().asin();
+            let theta_cos = pitch.clone().cos();
+            let roll = (self[(2, 1)].clone() / theta_cos.clone())
+                .atan2(self[(2, 2)].clone() / theta_cos.clone());
+            let yaw =
+                (self[(1, 0)].clone() / theta_cos.clone()).atan2(self[(0, 0)].clone() / theta_cos);
+            (roll, pitch, yaw)
         } else if self[(2, 0)].clone() <= -T::one() {
             (
                 self[(0, 1)].clone().atan2(self[(0, 2)].clone()),

From 3d31f322517a0092398559a05dd7f978b1bad77b Mon Sep 17 00:00:00 2001
From: Maxim Zhiburt <zhiburt@gmail.com>
Date: Tue, 19 Jul 2022 15:19:36 +0300
Subject: [PATCH 074/119] update try_inverse doc comment

---
 src/linalg/inverse.rs | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/src/linalg/inverse.rs b/src/linalg/inverse.rs
index f07be14a..ad6f96b4 100644
--- a/src/linalg/inverse.rs
+++ b/src/linalg/inverse.rs
@@ -9,6 +9,10 @@ use crate::linalg::lu;
 
 impl<T: ComplexField, D: Dim, S: Storage<T, D, D>> SquareMatrix<T, D, S> {
     /// Attempts to invert this matrix.
+    /// 
+    /// # Panics
+    /// 
+    /// It's unable to invert a non-square matrix so it panics in such case.
     #[inline]
     #[must_use = "Did you mean to use try_inverse_mut()?"]
     pub fn try_inverse(self) -> Option<OMatrix<T, D, D>>
@@ -27,6 +31,10 @@ impl<T: ComplexField, D: Dim, S: Storage<T, D, D>> SquareMatrix<T, D, S> {
 impl<T: ComplexField, D: Dim, S: StorageMut<T, D, D>> SquareMatrix<T, D, S> {
     /// Attempts to invert this matrix in-place. Returns `false` and leaves `self` untouched if
     /// inversion fails.
+    /// 
+    /// # Panics
+    /// 
+    /// It's unable to invert a non-square matrix so it panics in such case.
     #[inline]
     pub fn try_inverse_mut(&mut self) -> bool
     where

From 5ed215932caeba51fed15af1e4e7daa425a00092 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=A9bastien=20Crozet?= <developer@crozet.re>
Date: Sat, 14 Jan 2023 12:02:37 +0100
Subject: [PATCH 075/119] Slightly change comment wording.

---
 src/linalg/inverse.rs | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/linalg/inverse.rs b/src/linalg/inverse.rs
index ad6f96b4..91d45587 100644
--- a/src/linalg/inverse.rs
+++ b/src/linalg/inverse.rs
@@ -8,11 +8,11 @@ use crate::base::{DefaultAllocator, OMatrix, SquareMatrix};
 use crate::linalg::lu;
 
 impl<T: ComplexField, D: Dim, S: Storage<T, D, D>> SquareMatrix<T, D, S> {
-    /// Attempts to invert this matrix.
-    /// 
+    /// Attempts to invert this square matrix.
+    ///
     /// # Panics
-    /// 
-    /// It's unable to invert a non-square matrix so it panics in such case.
+    ///
+    /// Panics if `self` isn’t a square matrix.
     #[inline]
     #[must_use = "Did you mean to use try_inverse_mut()?"]
     pub fn try_inverse(self) -> Option<OMatrix<T, D, D>>
@@ -29,12 +29,12 @@ impl<T: ComplexField, D: Dim, S: Storage<T, D, D>> SquareMatrix<T, D, S> {
 }
 
 impl<T: ComplexField, D: Dim, S: StorageMut<T, D, D>> SquareMatrix<T, D, S> {
-    /// Attempts to invert this matrix in-place. Returns `false` and leaves `self` untouched if
+    /// Attempts to invert this square matrix in-place. Returns `false` and leaves `self` untouched if
     /// inversion fails.
-    /// 
+    ///
     /// # Panics
-    /// 
-    /// It's unable to invert a non-square matrix so it panics in such case.
+    ///
+    /// Panics if `self` isn’t a square matrix.
     #[inline]
     pub fn try_inverse_mut(&mut self) -> bool
     where

From f333bb4ba5d1375978ca1bd84000dc1a81418c99 Mon Sep 17 00:00:00 2001
From: Hennadii Chernyshchyk <genaloner@gmail.com>
Date: Sat, 14 Jan 2023 13:03:09 +0200
Subject: [PATCH 076/119] Update src/linalg/cholesky.rs
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Sébastien Crozet <sebastien@crozet.re>
---
 src/linalg/cholesky.rs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/linalg/cholesky.rs b/src/linalg/cholesky.rs
index 830cf2f1..eda64134 100644
--- a/src/linalg/cholesky.rs
+++ b/src/linalg/cholesky.rs
@@ -1,8 +1,7 @@
 #[cfg(feature = "serde-serialize-no-std")]
 use serde::{Deserialize, Serialize};
 
-use num::One;
-use num::Zero;
+use num::{One, Zero};
 use simba::scalar::ComplexField;
 use simba::simd::SimdComplexField;
 

From 0fcd9dd70210a54ce923365d47d3ad3ad1d00914 Mon Sep 17 00:00:00 2001
From: geo-ant <54497890+geo-ant@users.noreply.github.com>
Date: Tue, 18 Oct 2022 09:03:52 +0200
Subject: [PATCH 077/119] revert some things and add poc for mut and immut
 iterators

---
 Cargo.toml           |   2 +-
 src/base/iter.rs     | 165 +++++++++++++++++++++++++++++++++++-------
 src/base/par_iter.rs | 169 +++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 307 insertions(+), 29 deletions(-)
 create mode 100644 src/base/par_iter.rs

diff --git a/Cargo.toml b/Cargo.toml
index 9d0b1a7c..48262dce 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -101,7 +101,7 @@ glam020        = { package = "glam", version = "0.20", optional = true }
 glam021        = { package = "glam", version = "0.21", optional = true }
 glam022        = { package = "glam", version = "0.22", optional = true }
 cust_core      = { version = "0.1", optional = true }
-
+rayon = "1.5" # TODO make this feature gated
 
 [dev-dependencies]
 serde_json = "1.0"
diff --git a/src/base/iter.rs b/src/base/iter.rs
index 991c24dc..cb587589 100644
--- a/src/base/iter.rs
+++ b/src/base/iter.rs
@@ -1,12 +1,17 @@
 //! Matrix iterators.
 
+use core::fmt::Debug;
+use core::ops::Range;
 use std::iter::FusedIterator;
 use std::marker::PhantomData;
 use std::mem;
 
+use rayon::iter::plumbing::Producer;
+
 use crate::base::dimension::{Dim, U1};
 use crate::base::storage::{RawStorage, RawStorageMut};
 use crate::base::{Matrix, MatrixView, MatrixViewMut, Scalar};
+use crate::{DMatrix, DimMax};
 
 macro_rules! iterator {
     (struct $Name:ident for $Storage:ident.$ptr: ident -> $Ptr:ty, $Ref:ty, $SRef: ty) => {
@@ -288,7 +293,6 @@ impl<'a, T: Scalar, R: Dim, C: Dim, S: 'a + RawStorageMut<T, R, C>> ExactSizeIte
 }
 
 /*
- *
  * Column iterators.
  *
  */
@@ -296,12 +300,25 @@ impl<'a, T: Scalar, R: Dim, C: Dim, S: 'a + RawStorageMut<T, R, C>> ExactSizeIte
 /// An iterator through the columns of a matrix.
 pub struct ColumnIter<'a, T, R: Dim, C: Dim, S: RawStorage<T, R, C>> {
     mat: &'a Matrix<T, R, C, S>,
-    curr: usize,
+    range: Range<usize>,
 }
 
 impl<'a, T, R: Dim, C: Dim, S: 'a + RawStorage<T, R, C>> ColumnIter<'a, T, R, C, S> {
+    /// a new column iterator covering all columns of the matrix
     pub(crate) fn new(mat: &'a Matrix<T, R, C, S>) -> Self {
-        ColumnIter { mat, curr: 0 }
+        ColumnIter {
+            mat,
+            range: 0..mat.ncols(),
+        }
+    }
+    /// a new column iterator covering column indices [begin,end)
+    /// where begin is included in the range but index end is not
+    /// begin must lie in [0,ncols] and end must lie in [0,ncols].
+    pub(crate) fn with_range(mat: &'a Matrix<T, R, C, S>, range: Range<usize>) -> Self {
+        debug_assert!(range.end <= mat.ncols());
+        debug_assert!(range.start < mat.ncols());
+        debug_assert!(range.start <= range.end);
+        Self { mat, range }
     }
 }
 
@@ -310,9 +327,10 @@ impl<'a, T, R: Dim, C: Dim, S: 'a + RawStorage<T, R, C>> Iterator for ColumnIter
 
     #[inline]
     fn next(&mut self) -> Option<Self::Item> {
-        if self.curr < self.mat.ncols() {
-            let res = self.mat.column(self.curr);
-            self.curr += 1;
+        debug_assert!(self.range.start <= self.range.end);
+        if self.range.start < self.range.end {
+            let res = self.mat.column(self.range.start);
+            self.range.start += 1;
             Some(res)
         } else {
             None
@@ -321,15 +339,29 @@ impl<'a, T, R: Dim, C: Dim, S: 'a + RawStorage<T, R, C>> Iterator for ColumnIter
 
     #[inline]
     fn size_hint(&self) -> (usize, Option<usize>) {
-        (
-            self.mat.ncols() - self.curr,
-            Some(self.mat.ncols() - self.curr),
-        )
+        let hint = self.range.len();
+        (hint, Some(hint))
     }
 
     #[inline]
     fn count(self) -> usize {
-        self.mat.ncols() - self.curr
+        self.range.len()
+    }
+}
+
+impl<'a, T, R: Dim, C: Dim, S: 'a + RawStorage<T, R, C>> DoubleEndedIterator
+    for ColumnIter<'a, T, R, C, S>
+{
+    fn next_back(&mut self) -> Option<Self::Item> {
+        debug_assert!(self.range.start <= self.range.end);
+        if !self.range.is_empty() {
+            self.range.end -= 1;
+            debug_assert!(self.range.end < self.mat.ncols());
+            debug_assert!(self.range.end >= self.range.start);
+            Some(self.mat.column(self.range.end))
+        } else {
+            None
+        }
     }
 }
 
@@ -338,29 +370,53 @@ impl<'a, T: Scalar, R: Dim, C: Dim, S: 'a + RawStorage<T, R, C>> ExactSizeIterat
 {
     #[inline]
     fn len(&self) -> usize {
-        self.mat.ncols() - self.curr
+        self.range.end - self.range.start
+    }
+}
+
+impl<'a, T, R: Dim, Cols: Dim, S: RawStorage<T, R, Cols>> Producer for ColumnIter<'a, T, R, Cols, S>
+where
+    T: Send + Sync + Debug + PartialEq + Clone + 'static,
+    S: Sync,
+{
+    type Item = MatrixSlice<'a, T, R, U1, S::RStride, S::CStride>;
+    type IntoIter = ColumnIter<'a, T, R, Cols, S>;
+
+    fn split_at(self, index: usize) -> (Self, Self) {
+        // the index is relative to the size of this current iterator
+        // it will always start at zero
+        let left = Self {
+            mat: self.mat,
+            range: self.range.start..(self.range.start + index),
+        };
+
+        let right = Self {
+            mat: self.mat,
+            range: (self.range.start + index)..self.range.end,
+        };
+        (left, right)
+    }
+
+    fn into_iter(self) -> Self::IntoIter {
+        self
     }
 }
 
 /// An iterator through the mutable columns of a matrix.
 #[derive(Debug)]
 pub struct ColumnIterMut<'a, T, R: Dim, C: Dim, S: RawStorageMut<T, R, C>> {
-    mat: *mut Matrix<T, R, C, S>,
-    curr: usize,
-    phantom: PhantomData<&'a mut Matrix<T, R, C, S>>,
+    mat: &'a mut Matrix<T, R, C, S>,
+    range: Range<usize>,
 }
 
 impl<'a, T, R: Dim, C: Dim, S: 'a + RawStorageMut<T, R, C>> ColumnIterMut<'a, T, R, C, S> {
     pub(crate) fn new(mat: &'a mut Matrix<T, R, C, S>) -> Self {
-        ColumnIterMut {
-            mat,
-            curr: 0,
-            phantom: PhantomData,
-        }
+        let range = 0..mat.ncols();
+        ColumnIterMut { mat, range }
     }
 
     fn ncols(&self) -> usize {
-        unsafe { (*self.mat).ncols() }
+        self.mat.ncols()
     }
 }
 
@@ -370,10 +426,11 @@ impl<'a, T, R: Dim, C: Dim, S: 'a + RawStorageMut<T, R, C>> Iterator
     type Item = MatrixViewMut<'a, T, R, U1, S::RStride, S::CStride>;
 
     #[inline]
-    fn next(&mut self) -> Option<Self::Item> {
-        if self.curr < self.ncols() {
-            let res = unsafe { (*self.mat).column_mut(self.curr) };
-            self.curr += 1;
+    fn next(&'_ mut self) -> Option<Self::Item> {
+        if self.range.start < self.ncols() {
+            let pmat: *mut _ = self.mat;
+            let res = unsafe { (*pmat).column_mut(self.range.start) };
+            self.range.start += 1;
             Some(res)
         } else {
             None
@@ -382,12 +439,13 @@ impl<'a, T, R: Dim, C: Dim, S: 'a + RawStorageMut<T, R, C>> Iterator
 
     #[inline]
     fn size_hint(&self) -> (usize, Option<usize>) {
-        (self.ncols() - self.curr, Some(self.ncols() - self.curr))
+        let hint = self.range.len();
+        (hint, Some(hint))
     }
 
     #[inline]
     fn count(self) -> usize {
-        self.ncols() - self.curr
+        self.range.len()
     }
 }
 
@@ -396,6 +454,57 @@ impl<'a, T: Scalar, R: Dim, C: Dim, S: 'a + RawStorageMut<T, R, C>> ExactSizeIte
 {
     #[inline]
     fn len(&self) -> usize {
-        self.ncols() - self.curr
+        self.range.len()
     }
 }
+
+impl<'a, T: Scalar, R: Dim, C: Dim, S: 'a + RawStorageMut<T, R, C>> DoubleEndedIterator
+    for ColumnIterMut<'a, T, R, C, S>
+{
+    fn next_back(&mut self) -> Option<Self::Item> {
+        debug_assert!(self.range.start <= self.range.end);
+        if !self.range.is_empty() {
+            self.range.end -= 1;
+            debug_assert!(self.range.end < unsafe { (*self.mat).ncols() });
+            debug_assert!(self.range.end >= self.range.start);
+            let pmat: *mut _ = self.mat;
+            Some(unsafe { (*pmat).column_mut(self.range.end) })
+        } else {
+            None
+        }
+    }
+}
+
+impl<'a, T: Scalar, R: Dim, C: Dim, S: 'a + RawStorageMut<T, R, C>> Producer for ColumnIterMut<'a,T,R,C,S> 
+where T  : Send + Sync + Debug + PartialEq + Clone,
+      S: Send + Sync {
+    type Item = MatrixSliceMut<'a, T, R, U1, S::RStride, S::CStride>;
+    type IntoIter = ColumnIterMut<'a,T,R,C,S>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self 
+    }
+
+    fn split_at(self, index: usize) -> (Self, Self) {
+        // the index is relative to the size of this current iterator
+        // it will always start at zero
+        let pmat : * mut _ = self.mat; 
+
+        let left = Self {
+            mat: unsafe {&mut *pmat},
+            range: self.range.start..(self.range.start + index),
+        };
+
+        let right = Self {
+            mat: self.mat,
+            range: (self.range.start + index)..self.range.end,
+        };
+        (left, right)
+    }
+}
+
+fn test_send<T: Send>(_: T) {}
+
+fn something(mut matrix: DMatrix<f32>) {
+    test_send(matrix.column_iter_mut());
+}
diff --git a/src/base/par_iter.rs b/src/base/par_iter.rs
new file mode 100644
index 00000000..cdc602b5
--- /dev/null
+++ b/src/base/par_iter.rs
@@ -0,0 +1,169 @@
+//! this module implements parallelators to make matrices work with
+//! the rayon crate seamlessly
+
+use core::{
+    fmt::Debug,
+    iter::{Skip, Take},
+    marker::PhantomData,
+    ops::Range,
+};
+use std::os::unix::prelude::AsRawFd;
+
+use rayon::{
+    iter::plumbing::{bridge, Producer},
+    prelude::*,
+};
+
+use crate::{
+    iter::{ColumnIter, ColumnIterMut}, Const, DMatrix, Dim, Dynamic, Matrix, MatrixSlice, MatrixSliceMut,
+    RawStorage, RawStorageMut, U1, SliceStorageMut,
+};
+
+use super::conversion;
+
+/// a rayon parallel iterator over the columns of a matrix
+pub struct ParColumnIter<'a, T, R: Dim, Cols: Dim, S: RawStorage<T, R, Cols>> {
+    mat: &'a Matrix<T, R, Cols, S>,
+}
+
+impl<'a, T, R: Dim, Cols: Dim, S: RawStorage<T, R, Cols>> ParColumnIter<'a, T, R, Cols, S> {
+    fn new(matrix: &'a Matrix<T, R, Cols, S>) -> Self {
+        Self { mat: matrix }
+    }
+}
+
+impl<'a, T, R: Dim, Cols: Dim, S: RawStorage<T, R, Cols>> ParallelIterator
+    for ParColumnIter<'a, T, R, Cols, S>
+where
+    T: Sync + Send + Clone + Debug + PartialEq + 'static,
+    S: Sync,
+{
+    type Item = MatrixSlice<'a, T, R, U1, S::RStride, S::CStride>;
+
+    fn drive_unindexed<Consumer>(self, consumer: Consumer) -> Consumer::Result
+    where
+        Consumer: rayon::iter::plumbing::UnindexedConsumer<Self::Item>,
+    {
+        bridge(self, consumer)
+    }
+
+    fn opt_len(&self) -> Option<usize> {
+        Some(self.mat.ncols())
+    }
+}
+
+impl<'a, T, R: Dim, Cols: Dim, S: RawStorage<T, R, Cols>> IndexedParallelIterator
+    for ParColumnIter<'a, T, R, Cols, S>
+where
+    T: Send + Sync + Clone + Debug + PartialEq + 'static,
+    S: Sync,
+{
+    fn len(&self) -> usize {
+        self.mat.ncols()
+    }
+
+    fn drive<C: rayon::iter::plumbing::Consumer<Self::Item>>(self, consumer: C) -> C::Result {
+        bridge(self, consumer)
+    }
+
+    fn with_producer<CB: rayon::iter::plumbing::ProducerCallback<Self::Item>>(
+        self,
+        callback: CB,
+    ) -> CB::Output {
+        let producer = ColumnIter::new(self.mat);
+        callback.callback(producer)
+    }
+}
+
+impl<'a, T, R: Dim, Cols: Dim, S: RawStorage<T, R, Cols>> Matrix<T, R, Cols, S>
+where
+    T: Send + Sync + Clone + Debug + PartialEq + 'static,
+    S: Sync,
+{
+    fn par_column_iter(&self) -> ParColumnIter<'_, T, R, Cols, S> {
+        ParColumnIter::new(self)
+    }
+}
+
+/// TODO
+pub struct ParColumnIterMut<'a,T,R:Dim ,Cols:Dim, S:RawStorage<T,R,Cols>+RawStorageMut<T,R,Cols>> {
+    mat : &'a mut Matrix<T,R,Cols,S>,
+}
+
+impl<'a,T,R,Cols,S> ParColumnIterMut<'a,T,R,Cols,S> 
+where R: Dim, Cols : Dim, S:RawStorage<T,R,Cols> + RawStorageMut<T,R,Cols> {
+    /// TODO
+    pub fn new(mat : &'a mut Matrix<T,R,Cols,S>) -> Self {
+        Self {
+            mat,
+        }
+    }
+}
+
+impl<'a,T,R,Cols,S> ParallelIterator for ParColumnIterMut<'a,T,R,Cols,S> 
+where R: Dim, Cols : Dim, S:RawStorage<T,R,Cols> + RawStorageMut<T,R,Cols>, 
+T : Send + Sync + Debug + PartialEq + Clone + 'static, 
+S : Send + Sync {
+    type Item = MatrixSliceMut<'a, T, R, U1, S::RStride, S::CStride>;
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+        where
+            C: rayon::iter::plumbing::UnindexedConsumer<Self::Item> {
+                bridge(self,consumer)
+    }
+
+    fn opt_len(&self) -> Option<usize> {
+        Some(self.mat.ncols())
+    }
+}
+
+
+impl<'a,T,R,Cols,S> IndexedParallelIterator for ParColumnIterMut<'a,T,R,Cols,S> 
+where R: Dim, Cols : Dim, S:RawStorage<T,R,Cols> + RawStorageMut<T,R,Cols>, 
+T : Send + Sync + Debug + PartialEq + Clone + 'static, 
+S : Send + Sync {
+    fn drive<C: rayon::iter::plumbing::Consumer<Self::Item>>(self, consumer: C) -> C::Result {
+        bridge(self,consumer)
+    }
+
+    fn len(&self) -> usize {
+        self.mat.ncols()
+    }
+
+    fn with_producer<CB: rayon::iter::plumbing::ProducerCallback<Self::Item>>(self, callback: CB) -> CB::Output {
+        let producer = ColumnIterMut::new(self.mat);
+        callback.callback(producer)
+    }
+}
+
+impl<'a, T, R: Dim, Cols: Dim, S: RawStorage<T, R, Cols> + RawStorageMut<T,R,Cols>> Matrix<T, R, Cols, S>
+where
+    T: Send + Sync + Clone + Debug + PartialEq + 'static,
+    S: Sync,
+{
+    fn par_column_iter_mut(&mut self) -> ParColumnIterMut<'_, T, R, Cols, S> {
+        ParColumnIterMut::new(self)
+    }
+}
+
+
+#[test]
+fn parallel_iterator() {
+    let matrix = DMatrix::<f32>::zeros(3, 4);
+    let res: Vec<_> = matrix.par_column_iter().map(|col| col.len()).collect();
+    assert_eq!(res, vec![3, 3, 3, 3]);
+}
+
+#[test]
+fn test_mut_parallel_iter() {
+    let mut matrix = DMatrix::<f32>::zeros(4, 3);
+    matrix.par_column_iter_mut().enumerate().for_each(|(idx,mut col)| col[idx]=1f32);
+    let identity = DMatrix::<f32>::identity(4, 3);
+    assert_eq!(matrix,identity);
+}
+
+
+fn try_some_stuff() {
+    let mut mat = DMatrix::<f32>::zeros(3, 4);
+    let _left = mat.columns_mut(0, 1);
+    let _right = mat.columns_mut(1, 3);
+}

From f850ed535e67f29edcea36ad7685a13860df345f Mon Sep 17 00:00:00 2001
From: geo-ant <54497890+geo-ant@users.noreply.github.com>
Date: Wed, 19 Oct 2022 09:51:46 +0200
Subject: [PATCH 078/119] add tests and start cleanup

---
 src/base/mod.rs      |  2 +
 src/base/par_iter.rs | 12 ++----
 tests/core/matrix.rs | 89 ++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 95 insertions(+), 8 deletions(-)

diff --git a/src/base/mod.rs b/src/base/mod.rs
index 4cbcff93..b828d0a1 100644
--- a/src/base/mod.rs
+++ b/src/base/mod.rs
@@ -42,6 +42,8 @@ mod min_max;
 /// Mechanisms for working with values that may not be initialized.
 pub mod uninit;
 
+pub mod par_iter;
+
 #[cfg(feature = "rkyv-serialize-no-std")]
 mod rkyv_wrappers;
 
diff --git a/src/base/par_iter.rs b/src/base/par_iter.rs
index cdc602b5..abe48bb2 100644
--- a/src/base/par_iter.rs
+++ b/src/base/par_iter.rs
@@ -80,7 +80,8 @@ where
     T: Send + Sync + Clone + Debug + PartialEq + 'static,
     S: Sync,
 {
-    fn par_column_iter(&self) -> ParColumnIter<'_, T, R, Cols, S> {
+    /// TODO
+    pub fn par_column_iter(&self) -> ParColumnIter<'_, T, R, Cols, S> {
         ParColumnIter::new(self)
     }
 }
@@ -140,18 +141,13 @@ where
     T: Send + Sync + Clone + Debug + PartialEq + 'static,
     S: Sync,
 {
-    fn par_column_iter_mut(&mut self) -> ParColumnIterMut<'_, T, R, Cols, S> {
+    /// TODO
+    pub fn par_column_iter_mut(&mut self) -> ParColumnIterMut<'_, T, R, Cols, S> {
         ParColumnIterMut::new(self)
     }
 }
 
 
-#[test]
-fn parallel_iterator() {
-    let matrix = DMatrix::<f32>::zeros(3, 4);
-    let res: Vec<_> = matrix.par_column_iter().map(|col| col.len()).collect();
-    assert_eq!(res, vec![3, 3, 3, 3]);
-}
 
 #[test]
 fn test_mut_parallel_iter() {
diff --git a/tests/core/matrix.rs b/tests/core/matrix.rs
index 219845d4..aa515e49 100644
--- a/tests/core/matrix.rs
+++ b/tests/core/matrix.rs
@@ -1136,3 +1136,92 @@ fn omatrix_to_string() {
         (svec.to_string(), smatr.to_string())
     );
 }
+
+#[test]
+fn column_iteration() {
+    // dynamic matrix
+    let dmat = nalgebra::dmatrix![
+        13,14,15;
+        23,24,25;
+        33,34,35;
+        ];
+    // not using enumerate on purpose
+    let mut idx = 0;
+    for col in dmat.column_iter() {
+        assert_eq!(dmat.column(idx),col);
+        idx += 1;
+    }
+    // statically sized matrix
+    let smat: nalgebra::SMatrix<f64, 2, 2> = nalgebra::matrix![1.0, 2.0; 3.0, 4.0];
+    let mut idx = 0;
+    for col in smat.column_iter() {
+        assert_eq!(smat.column(idx),col);
+        idx += 1;
+    }
+}
+
+#[test]
+fn column_iteration_double_ended() {
+    let dmat = nalgebra::dmatrix![
+        13,14,15,16,17;
+        23,24,25,26,27;
+        33,34,35,36,37;
+        ];
+    let mut col_iter = dmat.column_iter();
+    assert_eq!(col_iter.next(),Some(dmat.column(0)));
+    assert_eq!(col_iter.next(),Some(dmat.column(1)));
+    assert_eq!(col_iter.next_back(),Some(dmat.column(4)));
+    assert_eq!(col_iter.next_back(),Some(dmat.column(3)));
+    assert_eq!(col_iter.next(),Some(dmat.column(2)));
+    assert_eq!(col_iter.next_back(),None);
+    assert_eq!(col_iter.next(),None);
+}
+
+#[test]
+fn parallel_column_iteration() {
+    use rayon::prelude::*;
+    use nalgebra::{dmatrix,dvector};
+    let dmat = dmatrix![
+        13.,14.;
+        23.,24.;
+        33.,34.;
+        ];
+    let cloned = dmat.clone();
+    // test that correct columns are iterated over
+    dmat.par_column_iter().enumerate().for_each(|(idx,col)| {
+        assert_eq!(col,cloned.column(idx)); 
+    });
+    // test that a more complex expression produces the same
+    // result as the serial equivalent
+    let par_result :f64 = dmat.par_column_iter().map(|col| col.norm()).sum();
+    let ser_result = dmat.column_iter().map(|col| col.norm()).sum();
+    assert_eq!(par_result,ser_result);
+}
+
+#[test]
+fn column_iteration_mut() {
+    todo!();
+}
+
+#[test]
+fn colum_iteration_mut_double_ended() {
+    let dmat = nalgebra::dmatrix![
+        13,14,15,16,17;
+        23,24,25,26,27;
+        33,34,35,36,37;
+        ];
+    let cloned = dmat.clone();
+    let mut col_iter = dmat.column_iter();
+    assert_eq!(col_iter.next(),Some(cloned.column(0)));
+    assert_eq!(col_iter.next(),Some(cloned.column(1)));
+    assert_eq!(col_iter.next_back(),Some(cloned.column(4)));
+    assert_eq!(col_iter.next_back(),Some(cloned.column(3)));
+    assert_eq!(col_iter.next(),Some(cloned.column(2)));
+    assert_eq!(col_iter.next_back(),None);
+    assert_eq!(col_iter.next(),None);
+}
+
+#[test]
+fn parallel_column_iteration_mut() {
+    todo!()
+}

From 7ac536be07b8ef7c44ed096574cf382d5d070700 Mon Sep 17 00:00:00 2001
From: geo-ant <54497890+geo-ant@users.noreply.github.com>
Date: Thu, 20 Oct 2022 19:07:22 +0200
Subject: [PATCH 079/119] cleanups and add tests

---
 src/base/iter.rs     | 23 +++++++---------
 src/base/par_iter.rs | 29 +++------------------
 tests/core/matrix.rs | 62 ++++++++++++++++++++++++++++++--------------
 3 files changed, 56 insertions(+), 58 deletions(-)

diff --git a/src/base/iter.rs b/src/base/iter.rs
index cb587589..f4b34f63 100644
--- a/src/base/iter.rs
+++ b/src/base/iter.rs
@@ -475,23 +475,26 @@ impl<'a, T: Scalar, R: Dim, C: Dim, S: 'a + RawStorageMut<T, R, C>> DoubleEndedI
     }
 }
 
-impl<'a, T: Scalar, R: Dim, C: Dim, S: 'a + RawStorageMut<T, R, C>> Producer for ColumnIterMut<'a,T,R,C,S> 
-where T  : Send + Sync + Debug + PartialEq + Clone,
-      S: Send + Sync {
+impl<'a, T: Scalar, R: Dim, C: Dim, S: 'a + RawStorageMut<T, R, C>> Producer
+    for ColumnIterMut<'a, T, R, C, S>
+where
+    T: Send + Sync + Debug + PartialEq + Clone,
+    S: Send + Sync,
+{
     type Item = MatrixSliceMut<'a, T, R, U1, S::RStride, S::CStride>;
-    type IntoIter = ColumnIterMut<'a,T,R,C,S>;
+    type IntoIter = ColumnIterMut<'a, T, R, C, S>;
 
     fn into_iter(self) -> Self::IntoIter {
-        self 
+        self
     }
 
     fn split_at(self, index: usize) -> (Self, Self) {
         // the index is relative to the size of this current iterator
         // it will always start at zero
-        let pmat : * mut _ = self.mat; 
+        let pmat: *mut _ = self.mat;
 
         let left = Self {
-            mat: unsafe {&mut *pmat},
+            mat: unsafe { &mut *pmat },
             range: self.range.start..(self.range.start + index),
         };
 
@@ -502,9 +505,3 @@ where T  : Send + Sync + Debug + PartialEq + Clone,
         (left, right)
     }
 }
-
-fn test_send<T: Send>(_: T) {}
-
-fn something(mut matrix: DMatrix<f32>) {
-    test_send(matrix.column_iter_mut());
-}
diff --git a/src/base/par_iter.rs b/src/base/par_iter.rs
index abe48bb2..b53e1f49 100644
--- a/src/base/par_iter.rs
+++ b/src/base/par_iter.rs
@@ -3,24 +3,18 @@
 
 use core::{
     fmt::Debug,
-    iter::{Skip, Take},
-    marker::PhantomData,
-    ops::Range,
 };
-use std::os::unix::prelude::AsRawFd;
 
 use rayon::{
-    iter::plumbing::{bridge, Producer},
+    iter::plumbing::{bridge},
     prelude::*,
 };
 
 use crate::{
-    iter::{ColumnIter, ColumnIterMut}, Const, DMatrix, Dim, Dynamic, Matrix, MatrixSlice, MatrixSliceMut,
-    RawStorage, RawStorageMut, U1, SliceStorageMut,
+    iter::{ColumnIter, ColumnIterMut},  DMatrix, Dim,  Matrix, MatrixSlice, MatrixSliceMut,
+    RawStorage, RawStorageMut, U1,
 };
 
-use super::conversion;
-
 /// a rayon parallel iterator over the columns of a matrix
 pub struct ParColumnIter<'a, T, R: Dim, Cols: Dim, S: RawStorage<T, R, Cols>> {
     mat: &'a Matrix<T, R, Cols, S>,
@@ -146,20 +140,3 @@ where
         ParColumnIterMut::new(self)
     }
 }
-
-
-
-#[test]
-fn test_mut_parallel_iter() {
-    let mut matrix = DMatrix::<f32>::zeros(4, 3);
-    matrix.par_column_iter_mut().enumerate().for_each(|(idx,mut col)| col[idx]=1f32);
-    let identity = DMatrix::<f32>::identity(4, 3);
-    assert_eq!(matrix,identity);
-}
-
-
-fn try_some_stuff() {
-    let mut mat = DMatrix::<f32>::zeros(3, 4);
-    let _left = mat.columns_mut(0, 1);
-    let _right = mat.columns_mut(1, 3);
-}
diff --git a/tests/core/matrix.rs b/tests/core/matrix.rs
index aa515e49..a4ad5057 100644
--- a/tests/core/matrix.rs
+++ b/tests/core/matrix.rs
@@ -1145,19 +1145,41 @@ fn column_iteration() {
         23,24,25;
         33,34,35;
         ];
-    // not using enumerate on purpose
-    let mut idx = 0;
-    for col in dmat.column_iter() {
-        assert_eq!(dmat.column(idx),col);
-        idx += 1;
-    }
+    let mut col_iter = dmat.column_iter();
+    assert_eq!(col_iter.next(),Some(dmat.column(0)));
+    assert_eq!(col_iter.next(),Some(dmat.column(1)));
+    assert_eq!(col_iter.next(),Some(dmat.column(2)));
+    assert_eq!(col_iter.next(),None);
+
     // statically sized matrix
     let smat: nalgebra::SMatrix<f64, 2, 2> = nalgebra::matrix![1.0, 2.0; 3.0, 4.0];
-    let mut idx = 0;
-    for col in smat.column_iter() {
-        assert_eq!(smat.column(idx),col);
-        idx += 1;
-    }
+    let mut col_iter = smat.column_iter();
+    assert_eq!(col_iter.next(),Some(smat.column(0)));
+    assert_eq!(col_iter.next(),Some(smat.column(1)));
+    assert_eq!(col_iter.next(),None);
+}
+
+#[test]
+fn column_iteration_mut() {
+    let mut dmat = nalgebra::dmatrix![
+        13,14,15;
+        23,24,25;
+        33,34,35;
+        ];
+    let mut cloned = dmat.clone();
+    let mut col_iter = dmat.column_iter_mut();
+    assert_eq!(col_iter.next(),Some(cloned.column_mut(0)));
+    assert_eq!(col_iter.next(),Some(cloned.column_mut(1)));
+    assert_eq!(col_iter.next(),Some(cloned.column_mut(2)));
+    assert_eq!(col_iter.next(),None);
+
+    // statically sized matrix
+    let mut smat: nalgebra::SMatrix<f64, 2, 2> = nalgebra::matrix![1.0, 2.0; 3.0, 4.0];
+    let mut cloned = smat.clone();
+    let mut col_iter = smat.column_iter_mut();
+    assert_eq!(col_iter.next(),Some(cloned.column_mut(0)));
+    assert_eq!(col_iter.next(),Some(cloned.column_mut(1)));
+    assert_eq!(col_iter.next(),None);
 }
 
 #[test]
@@ -1181,7 +1203,7 @@ fn column_iteration_double_ended() {
 fn parallel_column_iteration() {
     use rayon::prelude::*;
     use nalgebra::{dmatrix,dvector};
-    let dmat = dmatrix![
+    let dmat : DMatrix<f64> = dmatrix![
         13.,14.;
         23.,24.;
         33.,34.;
@@ -1193,15 +1215,11 @@ fn parallel_column_iteration() {
     });
     // test that a more complex expression produces the same
     // result as the serial equivalent
-    let par_result :f64 = dmat.par_column_iter().map(|col| col.norm()).sum();
-    let ser_result = dmat.column_iter().map(|col| col.norm()).sum();
+    let par_result : f64 = dmat.par_column_iter().map(|col| col.norm()).sum();
+    let ser_result : f64= dmat.column_iter().map(|col| col.norm()).sum();
     assert_eq!(par_result,ser_result);
 }
 
-#[test]
-fn column_iteration_mut() {
-    todo!();
-}
 
 #[test]
 fn colum_iteration_mut_double_ended() {
@@ -1223,5 +1241,11 @@ fn colum_iteration_mut_double_ended() {
 
 #[test]
 fn parallel_column_iteration_mut() {
-    todo!()
+    use rayon::prelude::*;
+    let mut first = DMatrix::<f32>::zeros(400,300);
+    let mut second = DMatrix::<f32>::zeros(400,300);
+    first.column_iter_mut().enumerate().for_each(|(idx,mut col)|col[idx]=1.);
+    second.par_column_iter_mut().enumerate().for_each(|(idx,mut col)| col[idx]=1.);
+    assert_eq!(first,second);
+    assert_eq!(second,DMatrix::identity(400,300));
 }

From daade1cf5e83cc956ef64b6e8e762cc5260f2705 Mon Sep 17 00:00:00 2001
From: geo-ant <54497890+geo-ant@users.noreply.github.com>
Date: Fri, 21 Oct 2022 08:44:35 +0200
Subject: [PATCH 080/119] add documentation

---
 src/base/iter.rs     | 15 +++------------
 src/base/par_iter.rs | 21 +++++++++------------
 2 files changed, 12 insertions(+), 24 deletions(-)

diff --git a/src/base/iter.rs b/src/base/iter.rs
index f4b34f63..eb3312c0 100644
--- a/src/base/iter.rs
+++ b/src/base/iter.rs
@@ -311,15 +311,6 @@ impl<'a, T, R: Dim, C: Dim, S: 'a + RawStorage<T, R, C>> ColumnIter<'a, T, R, C,
             range: 0..mat.ncols(),
         }
     }
-    /// a new column iterator covering column indices [begin,end)
-    /// where begin is included in the range but index end is not
-    /// begin must lie in [0,ncols] and end must lie in [0,ncols].
-    pub(crate) fn with_range(mat: &'a Matrix<T, R, C, S>, range: Range<usize>) -> Self {
-        debug_assert!(range.end <= mat.ncols());
-        debug_assert!(range.start < mat.ncols());
-        debug_assert!(range.start <= range.end);
-        Self { mat, range }
-    }
 }
 
 impl<'a, T, R: Dim, C: Dim, S: 'a + RawStorage<T, R, C>> Iterator for ColumnIter<'a, T, R, C, S> {
@@ -384,7 +375,7 @@ where
 
     fn split_at(self, index: usize) -> (Self, Self) {
         // the index is relative to the size of this current iterator
-        // it will always start at zero
+        // it will always start at zero so it serves as an offset
         let left = Self {
             mat: self.mat,
             range: self.range.start..(self.range.start + index),
@@ -465,7 +456,7 @@ impl<'a, T: Scalar, R: Dim, C: Dim, S: 'a + RawStorageMut<T, R, C>> DoubleEndedI
         debug_assert!(self.range.start <= self.range.end);
         if !self.range.is_empty() {
             self.range.end -= 1;
-            debug_assert!(self.range.end < unsafe { (*self.mat).ncols() });
+            debug_assert!(self.range.end < self.mat.ncols());
             debug_assert!(self.range.end >= self.range.start);
             let pmat: *mut _ = self.mat;
             Some(unsafe { (*pmat).column_mut(self.range.end) })
@@ -490,7 +481,7 @@ where
 
     fn split_at(self, index: usize) -> (Self, Self) {
         // the index is relative to the size of this current iterator
-        // it will always start at zero
+        // it will always start at zero so it serves as an offset
         let pmat: *mut _ = self.mat;
 
         let left = Self {
diff --git a/src/base/par_iter.rs b/src/base/par_iter.rs
index b53e1f49..3854e678 100644
--- a/src/base/par_iter.rs
+++ b/src/base/par_iter.rs
@@ -1,26 +1,23 @@
 //! this module implements parallelators to make matrices work with
 //! the rayon crate seamlessly
 
-use core::{
-    fmt::Debug,
-};
-
+use core::fmt::Debug;
 use rayon::{
     iter::plumbing::{bridge},
     prelude::*,
 };
-
 use crate::{
-    iter::{ColumnIter, ColumnIterMut},  DMatrix, Dim,  Matrix, MatrixSlice, MatrixSliceMut,
+    iter::{ColumnIter, ColumnIterMut}, Dim,  Matrix, MatrixSlice, MatrixSliceMut,
     RawStorage, RawStorageMut, U1,
 };
 
-/// a rayon parallel iterator over the columns of a matrix
+/// A rayon parallel iterator over the colums of a matrix
 pub struct ParColumnIter<'a, T, R: Dim, Cols: Dim, S: RawStorage<T, R, Cols>> {
     mat: &'a Matrix<T, R, Cols, S>,
 }
 
 impl<'a, T, R: Dim, Cols: Dim, S: RawStorage<T, R, Cols>> ParColumnIter<'a, T, R, Cols, S> {
+    /// create a new parallel iterator for the given matrix
     fn new(matrix: &'a Matrix<T, R, Cols, S>) -> Self {
         Self { mat: matrix }
     }
@@ -74,21 +71,21 @@ where
     T: Send + Sync + Clone + Debug + PartialEq + 'static,
     S: Sync,
 {
-    /// TODO
+    /// Iterate through the columns of the matrix in parallel using rayon.
     pub fn par_column_iter(&self) -> ParColumnIter<'_, T, R, Cols, S> {
         ParColumnIter::new(self)
     }
 }
 
-/// TODO
+/// A rayon parallel iterator through the mutable columns of a matrix
 pub struct ParColumnIterMut<'a,T,R:Dim ,Cols:Dim, S:RawStorage<T,R,Cols>+RawStorageMut<T,R,Cols>> {
     mat : &'a mut Matrix<T,R,Cols,S>,
 }
 
 impl<'a,T,R,Cols,S> ParColumnIterMut<'a,T,R,Cols,S> 
 where R: Dim, Cols : Dim, S:RawStorage<T,R,Cols> + RawStorageMut<T,R,Cols> {
-    /// TODO
-    pub fn new(mat : &'a mut Matrix<T,R,Cols,S>) -> Self {
+    /// create a new parallel iterator for the given matrix
+    fn new(mat : &'a mut Matrix<T,R,Cols,S>) -> Self {
         Self {
             mat,
         }
@@ -135,7 +132,7 @@ where
     T: Send + Sync + Clone + Debug + PartialEq + 'static,
     S: Sync,
 {
-    /// TODO
+    /// Mutably iterate through the columns of this matrix in parallel using rayon
     pub fn par_column_iter_mut(&mut self) -> ParColumnIterMut<'_, T, R, Cols, S> {
         ParColumnIterMut::new(self)
     }

From a4e28a136e7fd76f0dacea17f755f91d285b1e06 Mon Sep 17 00:00:00 2001
From: geo-ant <54497890+geo-ant@users.noreply.github.com>
Date: Fri, 21 Oct 2022 08:51:41 +0200
Subject: [PATCH 081/119] apply fmt

---
 src/base/par_iter.rs |  77 ++++++++++++++++----------
 tests/core/matrix.rs | 129 ++++++++++++++++++++++---------------------
 2 files changed, 114 insertions(+), 92 deletions(-)

diff --git a/src/base/par_iter.rs b/src/base/par_iter.rs
index 3854e678..3109e1ac 100644
--- a/src/base/par_iter.rs
+++ b/src/base/par_iter.rs
@@ -1,15 +1,12 @@
 //! this module implements parallelators to make matrices work with
 //! the rayon crate seamlessly
 
-use core::fmt::Debug;
-use rayon::{
-    iter::plumbing::{bridge},
-    prelude::*,
-};
 use crate::{
-    iter::{ColumnIter, ColumnIterMut}, Dim,  Matrix, MatrixSlice, MatrixSliceMut,
-    RawStorage, RawStorageMut, U1,
+    iter::{ColumnIter, ColumnIterMut},
+    Dim, Matrix, MatrixSlice, MatrixSliceMut, RawStorage, RawStorageMut, U1,
 };
+use core::fmt::Debug;
+use rayon::{iter::plumbing::bridge, prelude::*};
 
 /// A rayon parallel iterator over the colums of a matrix
 pub struct ParColumnIter<'a, T, R: Dim, Cols: Dim, S: RawStorage<T, R, Cols>> {
@@ -78,29 +75,42 @@ where
 }
 
 /// A rayon parallel iterator through the mutable columns of a matrix
-pub struct ParColumnIterMut<'a,T,R:Dim ,Cols:Dim, S:RawStorage<T,R,Cols>+RawStorageMut<T,R,Cols>> {
-    mat : &'a mut Matrix<T,R,Cols,S>,
+pub struct ParColumnIterMut<
+    'a,
+    T,
+    R: Dim,
+    Cols: Dim,
+    S: RawStorage<T, R, Cols> + RawStorageMut<T, R, Cols>,
+> {
+    mat: &'a mut Matrix<T, R, Cols, S>,
 }
 
-impl<'a,T,R,Cols,S> ParColumnIterMut<'a,T,R,Cols,S> 
-where R: Dim, Cols : Dim, S:RawStorage<T,R,Cols> + RawStorageMut<T,R,Cols> {
+impl<'a, T, R, Cols, S> ParColumnIterMut<'a, T, R, Cols, S>
+where
+    R: Dim,
+    Cols: Dim,
+    S: RawStorage<T, R, Cols> + RawStorageMut<T, R, Cols>,
+{
     /// create a new parallel iterator for the given matrix
-    fn new(mat : &'a mut Matrix<T,R,Cols,S>) -> Self {
-        Self {
-            mat,
-        }
+    fn new(mat: &'a mut Matrix<T, R, Cols, S>) -> Self {
+        Self { mat }
     }
 }
 
-impl<'a,T,R,Cols,S> ParallelIterator for ParColumnIterMut<'a,T,R,Cols,S> 
-where R: Dim, Cols : Dim, S:RawStorage<T,R,Cols> + RawStorageMut<T,R,Cols>, 
-T : Send + Sync + Debug + PartialEq + Clone + 'static, 
-S : Send + Sync {
+impl<'a, T, R, Cols, S> ParallelIterator for ParColumnIterMut<'a, T, R, Cols, S>
+where
+    R: Dim,
+    Cols: Dim,
+    S: RawStorage<T, R, Cols> + RawStorageMut<T, R, Cols>,
+    T: Send + Sync + Debug + PartialEq + Clone + 'static,
+    S: Send + Sync,
+{
     type Item = MatrixSliceMut<'a, T, R, U1, S::RStride, S::CStride>;
     fn drive_unindexed<C>(self, consumer: C) -> C::Result
-        where
-            C: rayon::iter::plumbing::UnindexedConsumer<Self::Item> {
-                bridge(self,consumer)
+    where
+        C: rayon::iter::plumbing::UnindexedConsumer<Self::Item>,
+    {
+        bridge(self, consumer)
     }
 
     fn opt_len(&self) -> Option<usize> {
@@ -108,26 +118,33 @@ S : Send + Sync {
     }
 }
 
-
-impl<'a,T,R,Cols,S> IndexedParallelIterator for ParColumnIterMut<'a,T,R,Cols,S> 
-where R: Dim, Cols : Dim, S:RawStorage<T,R,Cols> + RawStorageMut<T,R,Cols>, 
-T : Send + Sync + Debug + PartialEq + Clone + 'static, 
-S : Send + Sync {
+impl<'a, T, R, Cols, S> IndexedParallelIterator for ParColumnIterMut<'a, T, R, Cols, S>
+where
+    R: Dim,
+    Cols: Dim,
+    S: RawStorage<T, R, Cols> + RawStorageMut<T, R, Cols>,
+    T: Send + Sync + Debug + PartialEq + Clone + 'static,
+    S: Send + Sync,
+{
     fn drive<C: rayon::iter::plumbing::Consumer<Self::Item>>(self, consumer: C) -> C::Result {
-        bridge(self,consumer)
+        bridge(self, consumer)
     }
 
     fn len(&self) -> usize {
         self.mat.ncols()
     }
 
-    fn with_producer<CB: rayon::iter::plumbing::ProducerCallback<Self::Item>>(self, callback: CB) -> CB::Output {
+    fn with_producer<CB: rayon::iter::plumbing::ProducerCallback<Self::Item>>(
+        self,
+        callback: CB,
+    ) -> CB::Output {
         let producer = ColumnIterMut::new(self.mat);
         callback.callback(producer)
     }
 }
 
-impl<'a, T, R: Dim, Cols: Dim, S: RawStorage<T, R, Cols> + RawStorageMut<T,R,Cols>> Matrix<T, R, Cols, S>
+impl<'a, T, R: Dim, Cols: Dim, S: RawStorage<T, R, Cols> + RawStorageMut<T, R, Cols>>
+    Matrix<T, R, Cols, S>
 where
     T: Send + Sync + Clone + Debug + PartialEq + 'static,
     S: Sync,
diff --git a/tests/core/matrix.rs b/tests/core/matrix.rs
index a4ad5057..5021df8b 100644
--- a/tests/core/matrix.rs
+++ b/tests/core/matrix.rs
@@ -1141,111 +1141,116 @@ fn omatrix_to_string() {
 fn column_iteration() {
     // dynamic matrix
     let dmat = nalgebra::dmatrix![
-        13,14,15;
-        23,24,25;
-        33,34,35;
-        ];
+    13,14,15;
+    23,24,25;
+    33,34,35;
+    ];
     let mut col_iter = dmat.column_iter();
-    assert_eq!(col_iter.next(),Some(dmat.column(0)));
-    assert_eq!(col_iter.next(),Some(dmat.column(1)));
-    assert_eq!(col_iter.next(),Some(dmat.column(2)));
-    assert_eq!(col_iter.next(),None);
+    assert_eq!(col_iter.next(), Some(dmat.column(0)));
+    assert_eq!(col_iter.next(), Some(dmat.column(1)));
+    assert_eq!(col_iter.next(), Some(dmat.column(2)));
+    assert_eq!(col_iter.next(), None);
 
     // statically sized matrix
     let smat: nalgebra::SMatrix<f64, 2, 2> = nalgebra::matrix![1.0, 2.0; 3.0, 4.0];
     let mut col_iter = smat.column_iter();
-    assert_eq!(col_iter.next(),Some(smat.column(0)));
-    assert_eq!(col_iter.next(),Some(smat.column(1)));
-    assert_eq!(col_iter.next(),None);
+    assert_eq!(col_iter.next(), Some(smat.column(0)));
+    assert_eq!(col_iter.next(), Some(smat.column(1)));
+    assert_eq!(col_iter.next(), None);
 }
 
 #[test]
 fn column_iteration_mut() {
     let mut dmat = nalgebra::dmatrix![
-        13,14,15;
-        23,24,25;
-        33,34,35;
-        ];
+    13,14,15;
+    23,24,25;
+    33,34,35;
+    ];
     let mut cloned = dmat.clone();
     let mut col_iter = dmat.column_iter_mut();
-    assert_eq!(col_iter.next(),Some(cloned.column_mut(0)));
-    assert_eq!(col_iter.next(),Some(cloned.column_mut(1)));
-    assert_eq!(col_iter.next(),Some(cloned.column_mut(2)));
-    assert_eq!(col_iter.next(),None);
+    assert_eq!(col_iter.next(), Some(cloned.column_mut(0)));
+    assert_eq!(col_iter.next(), Some(cloned.column_mut(1)));
+    assert_eq!(col_iter.next(), Some(cloned.column_mut(2)));
+    assert_eq!(col_iter.next(), None);
 
     // statically sized matrix
     let mut smat: nalgebra::SMatrix<f64, 2, 2> = nalgebra::matrix![1.0, 2.0; 3.0, 4.0];
     let mut cloned = smat.clone();
     let mut col_iter = smat.column_iter_mut();
-    assert_eq!(col_iter.next(),Some(cloned.column_mut(0)));
-    assert_eq!(col_iter.next(),Some(cloned.column_mut(1)));
-    assert_eq!(col_iter.next(),None);
+    assert_eq!(col_iter.next(), Some(cloned.column_mut(0)));
+    assert_eq!(col_iter.next(), Some(cloned.column_mut(1)));
+    assert_eq!(col_iter.next(), None);
 }
 
 #[test]
 fn column_iteration_double_ended() {
     let dmat = nalgebra::dmatrix![
-        13,14,15,16,17;
-        23,24,25,26,27;
-        33,34,35,36,37;
-        ];
+    13,14,15,16,17;
+    23,24,25,26,27;
+    33,34,35,36,37;
+    ];
     let mut col_iter = dmat.column_iter();
-    assert_eq!(col_iter.next(),Some(dmat.column(0)));
-    assert_eq!(col_iter.next(),Some(dmat.column(1)));
-    assert_eq!(col_iter.next_back(),Some(dmat.column(4)));
-    assert_eq!(col_iter.next_back(),Some(dmat.column(3)));
-    assert_eq!(col_iter.next(),Some(dmat.column(2)));
-    assert_eq!(col_iter.next_back(),None);
-    assert_eq!(col_iter.next(),None);
+    assert_eq!(col_iter.next(), Some(dmat.column(0)));
+    assert_eq!(col_iter.next(), Some(dmat.column(1)));
+    assert_eq!(col_iter.next_back(), Some(dmat.column(4)));
+    assert_eq!(col_iter.next_back(), Some(dmat.column(3)));
+    assert_eq!(col_iter.next(), Some(dmat.column(2)));
+    assert_eq!(col_iter.next_back(), None);
+    assert_eq!(col_iter.next(), None);
 }
 
 #[test]
 fn parallel_column_iteration() {
+    use nalgebra::dmatrix;
     use rayon::prelude::*;
-    use nalgebra::{dmatrix,dvector};
-    let dmat : DMatrix<f64> = dmatrix![
-        13.,14.;
-        23.,24.;
-        33.,34.;
-        ];
+    let dmat: DMatrix<f64> = dmatrix![
+    13.,14.;
+    23.,24.;
+    33.,34.;
+    ];
     let cloned = dmat.clone();
     // test that correct columns are iterated over
-    dmat.par_column_iter().enumerate().for_each(|(idx,col)| {
-        assert_eq!(col,cloned.column(idx)); 
+    dmat.par_column_iter().enumerate().for_each(|(idx, col)| {
+        assert_eq!(col, cloned.column(idx));
     });
     // test that a more complex expression produces the same
     // result as the serial equivalent
-    let par_result : f64 = dmat.par_column_iter().map(|col| col.norm()).sum();
-    let ser_result : f64= dmat.column_iter().map(|col| col.norm()).sum();
-    assert_eq!(par_result,ser_result);
+    let par_result: f64 = dmat.par_column_iter().map(|col| col.norm()).sum();
+    let ser_result: f64 = dmat.column_iter().map(|col| col.norm()).sum();
+    assert_eq!(par_result, ser_result);
 }
 
-
 #[test]
 fn colum_iteration_mut_double_ended() {
     let dmat = nalgebra::dmatrix![
-        13,14,15,16,17;
-        23,24,25,26,27;
-        33,34,35,36,37;
-        ];
+    13,14,15,16,17;
+    23,24,25,26,27;
+    33,34,35,36,37;
+    ];
     let cloned = dmat.clone();
     let mut col_iter = dmat.column_iter();
-    assert_eq!(col_iter.next(),Some(cloned.column(0)));
-    assert_eq!(col_iter.next(),Some(cloned.column(1)));
-    assert_eq!(col_iter.next_back(),Some(cloned.column(4)));
-    assert_eq!(col_iter.next_back(),Some(cloned.column(3)));
-    assert_eq!(col_iter.next(),Some(cloned.column(2)));
-    assert_eq!(col_iter.next_back(),None);
-    assert_eq!(col_iter.next(),None);
+    assert_eq!(col_iter.next(), Some(cloned.column(0)));
+    assert_eq!(col_iter.next(), Some(cloned.column(1)));
+    assert_eq!(col_iter.next_back(), Some(cloned.column(4)));
+    assert_eq!(col_iter.next_back(), Some(cloned.column(3)));
+    assert_eq!(col_iter.next(), Some(cloned.column(2)));
+    assert_eq!(col_iter.next_back(), None);
+    assert_eq!(col_iter.next(), None);
 }
 
 #[test]
 fn parallel_column_iteration_mut() {
     use rayon::prelude::*;
-    let mut first = DMatrix::<f32>::zeros(400,300);
-    let mut second = DMatrix::<f32>::zeros(400,300);
-    first.column_iter_mut().enumerate().for_each(|(idx,mut col)|col[idx]=1.);
-    second.par_column_iter_mut().enumerate().for_each(|(idx,mut col)| col[idx]=1.);
-    assert_eq!(first,second);
-    assert_eq!(second,DMatrix::identity(400,300));
+    let mut first = DMatrix::<f32>::zeros(400, 300);
+    let mut second = DMatrix::<f32>::zeros(400, 300);
+    first
+        .column_iter_mut()
+        .enumerate()
+        .for_each(|(idx, mut col)| col[idx] = 1.);
+    second
+        .par_column_iter_mut()
+        .enumerate()
+        .for_each(|(idx, mut col)| col[idx] = 1.);
+    assert_eq!(first, second);
+    assert_eq!(second, DMatrix::identity(400, 300));
 }

From 42ab3f69037c8f9165adf8ba5b7a67f6beb648a2 Mon Sep 17 00:00:00 2001
From: geo-ant <54497890+geo-ant@users.noreply.github.com>
Date: Fri, 21 Oct 2022 09:02:28 +0200
Subject: [PATCH 082/119] fix clippy lints in my code

---
 src/base/par_iter.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/base/par_iter.rs b/src/base/par_iter.rs
index 3109e1ac..9beccee9 100644
--- a/src/base/par_iter.rs
+++ b/src/base/par_iter.rs
@@ -63,7 +63,7 @@ where
     }
 }
 
-impl<'a, T, R: Dim, Cols: Dim, S: RawStorage<T, R, Cols>> Matrix<T, R, Cols, S>
+impl<T, R: Dim, Cols: Dim, S: RawStorage<T, R, Cols>> Matrix<T, R, Cols, S>
 where
     T: Send + Sync + Clone + Debug + PartialEq + 'static,
     S: Sync,
@@ -143,7 +143,7 @@ where
     }
 }
 
-impl<'a, T, R: Dim, Cols: Dim, S: RawStorage<T, R, Cols> + RawStorageMut<T, R, Cols>>
+impl<T, R: Dim, Cols: Dim, S: RawStorage<T, R, Cols> + RawStorageMut<T, R, Cols>>
     Matrix<T, R, Cols, S>
 where
     T: Send + Sync + Clone + Debug + PartialEq + 'static,

From f6461d38623aa8cb1643b796054f00f07212d56f Mon Sep 17 00:00:00 2001
From: Geo <54497890+geo-ant@users.noreply.github.com>
Date: Sun, 23 Oct 2022 13:40:03 +0200
Subject: [PATCH 083/119] make mut iterator pointer based

Change the ColumnIterMut back to the original impl and manually implement Send
---
 src/base/iter.rs | 53 +++++++++++++++++++++++++-----------------------
 1 file changed, 28 insertions(+), 25 deletions(-)

diff --git a/src/base/iter.rs b/src/base/iter.rs
index eb3312c0..cbd2bbf6 100644
--- a/src/base/iter.rs
+++ b/src/base/iter.rs
@@ -226,7 +226,7 @@ impl<'a, T, R: Dim, C: Dim, S: 'a + RawStorage<T, R, C>> Iterator for RowIter<'a
 }
 
 impl<'a, T: Scalar, R: Dim, C: Dim, S: 'a + RawStorage<T, R, C>> ExactSizeIterator
-    for RowIter<'a, T, R, C, S>
+for RowIter<'a, T, R, C, S>
 {
     #[inline]
     fn len(&self) -> usize {
@@ -257,7 +257,7 @@ impl<'a, T, R: Dim, C: Dim, S: 'a + RawStorageMut<T, R, C>> RowIterMut<'a, T, R,
 }
 
 impl<'a, T, R: Dim, C: Dim, S: 'a + RawStorageMut<T, R, C>> Iterator
-    for RowIterMut<'a, T, R, C, S>
+for RowIterMut<'a, T, R, C, S>
 {
     type Item = MatrixViewMut<'a, T, U1, C, S::RStride, S::CStride>;
 
@@ -284,7 +284,7 @@ impl<'a, T, R: Dim, C: Dim, S: 'a + RawStorageMut<T, R, C>> Iterator
 }
 
 impl<'a, T: Scalar, R: Dim, C: Dim, S: 'a + RawStorageMut<T, R, C>> ExactSizeIterator
-    for RowIterMut<'a, T, R, C, S>
+for RowIterMut<'a, T, R, C, S>
 {
     #[inline]
     fn len(&self) -> usize {
@@ -341,7 +341,7 @@ impl<'a, T, R: Dim, C: Dim, S: 'a + RawStorage<T, R, C>> Iterator for ColumnIter
 }
 
 impl<'a, T, R: Dim, C: Dim, S: 'a + RawStorage<T, R, C>> DoubleEndedIterator
-    for ColumnIter<'a, T, R, C, S>
+for ColumnIter<'a, T, R, C, S>
 {
     fn next_back(&mut self) -> Option<Self::Item> {
         debug_assert!(self.range.start <= self.range.end);
@@ -357,7 +357,7 @@ impl<'a, T, R: Dim, C: Dim, S: 'a + RawStorage<T, R, C>> DoubleEndedIterator
 }
 
 impl<'a, T: Scalar, R: Dim, C: Dim, S: 'a + RawStorage<T, R, C>> ExactSizeIterator
-    for ColumnIter<'a, T, R, C, S>
+for ColumnIter<'a, T, R, C, S>
 {
     #[inline]
     fn len(&self) -> usize {
@@ -366,9 +366,9 @@ impl<'a, T: Scalar, R: Dim, C: Dim, S: 'a + RawStorage<T, R, C>> ExactSizeIterat
 }
 
 impl<'a, T, R: Dim, Cols: Dim, S: RawStorage<T, R, Cols>> Producer for ColumnIter<'a, T, R, Cols, S>
-where
-    T: Send + Sync + Debug + PartialEq + Clone + 'static,
-    S: Sync,
+    where
+        T: Send + Sync + Debug + PartialEq + Clone + 'static,
+        S: Sync,
 {
     type Item = MatrixSlice<'a, T, R, U1, S::RStride, S::CStride>;
     type IntoIter = ColumnIter<'a, T, R, Cols, S>;
@@ -396,31 +396,31 @@ where
 /// An iterator through the mutable columns of a matrix.
 #[derive(Debug)]
 pub struct ColumnIterMut<'a, T, R: Dim, C: Dim, S: RawStorageMut<T, R, C>> {
-    mat: &'a mut Matrix<T, R, C, S>,
+    mat: *mut Matrix<T, R, C, S>,
+    phantom: PhantomData<&'a mut Matrix<T, R, C, S>>,
     range: Range<usize>,
 }
 
 impl<'a, T, R: Dim, C: Dim, S: 'a + RawStorageMut<T, R, C>> ColumnIterMut<'a, T, R, C, S> {
     pub(crate) fn new(mat: &'a mut Matrix<T, R, C, S>) -> Self {
         let range = 0..mat.ncols();
-        ColumnIterMut { mat, range }
+        ColumnIterMut { mat, range, phantom: Default::default() }
     }
 
     fn ncols(&self) -> usize {
-        self.mat.ncols()
+        unsafe { (*self.mat).ncols() }
     }
 }
 
 impl<'a, T, R: Dim, C: Dim, S: 'a + RawStorageMut<T, R, C>> Iterator
-    for ColumnIterMut<'a, T, R, C, S>
+for ColumnIterMut<'a, T, R, C, S>
 {
     type Item = MatrixViewMut<'a, T, R, U1, S::RStride, S::CStride>;
 
     #[inline]
     fn next(&'_ mut self) -> Option<Self::Item> {
         if self.range.start < self.ncols() {
-            let pmat: *mut _ = self.mat;
-            let res = unsafe { (*pmat).column_mut(self.range.start) };
+            let res = unsafe { (*self.mat).column_mut(self.range.start) };
             self.range.start += 1;
             Some(res)
         } else {
@@ -441,7 +441,7 @@ impl<'a, T, R: Dim, C: Dim, S: 'a + RawStorageMut<T, R, C>> Iterator
 }
 
 impl<'a, T: Scalar, R: Dim, C: Dim, S: 'a + RawStorageMut<T, R, C>> ExactSizeIterator
-    for ColumnIterMut<'a, T, R, C, S>
+for ColumnIterMut<'a, T, R, C, S>
 {
     #[inline]
     fn len(&self) -> usize {
@@ -450,16 +450,15 @@ impl<'a, T: Scalar, R: Dim, C: Dim, S: 'a + RawStorageMut<T, R, C>> ExactSizeIte
 }
 
 impl<'a, T: Scalar, R: Dim, C: Dim, S: 'a + RawStorageMut<T, R, C>> DoubleEndedIterator
-    for ColumnIterMut<'a, T, R, C, S>
+for ColumnIterMut<'a, T, R, C, S>
 {
     fn next_back(&mut self) -> Option<Self::Item> {
         debug_assert!(self.range.start <= self.range.end);
         if !self.range.is_empty() {
             self.range.end -= 1;
-            debug_assert!(self.range.end < self.mat.ncols());
+            debug_assert!(self.range.end < self.ncols());
             debug_assert!(self.range.end >= self.range.start);
-            let pmat: *mut _ = self.mat;
-            Some(unsafe { (*pmat).column_mut(self.range.end) })
+            Some(unsafe { (*self.mat).column_mut(self.range.end) })
         } else {
             None
         }
@@ -467,10 +466,10 @@ impl<'a, T: Scalar, R: Dim, C: Dim, S: 'a + RawStorageMut<T, R, C>> DoubleEndedI
 }
 
 impl<'a, T: Scalar, R: Dim, C: Dim, S: 'a + RawStorageMut<T, R, C>> Producer
-    for ColumnIterMut<'a, T, R, C, S>
-where
-    T: Send + Sync + Debug + PartialEq + Clone,
-    S: Send + Sync,
+for ColumnIterMut<'a, T, R, C, S>
+    where
+        T: Send + Sync + Debug + PartialEq + Clone,
+        S: Send + Sync,
 {
     type Item = MatrixSliceMut<'a, T, R, U1, S::RStride, S::CStride>;
     type IntoIter = ColumnIterMut<'a, T, R, C, S>;
@@ -482,17 +481,21 @@ where
     fn split_at(self, index: usize) -> (Self, Self) {
         // the index is relative to the size of this current iterator
         // it will always start at zero so it serves as an offset
-        let pmat: *mut _ = self.mat;
 
         let left = Self {
-            mat: unsafe { &mut *pmat },
+            mat: self.mat,
             range: self.range.start..(self.range.start + index),
+            phantom: Default::default(),
         };
 
         let right = Self {
             mat: self.mat,
             range: (self.range.start + index)..self.range.end,
+            phantom: Default::default(),
         };
         (left, right)
     }
 }
+
+unsafe impl<'a, T: Scalar, R: Dim, C: Dim, S: 'a + RawStorageMut<T, R, C>> Send
+for ColumnIterMut<'a, T, R, C, S> {}
\ No newline at end of file

From 8638b796ac990e9d8ba83830c6e34e5cf460af37 Mon Sep 17 00:00:00 2001
From: geo-ant <54497890+geo-ant@users.noreply.github.com>
Date: Mon, 24 Oct 2022 08:08:20 +0200
Subject: [PATCH 084/119] fix fmt

---
 src/base/iter.rs | 40 +++++++++++++++++++++++-----------------
 1 file changed, 23 insertions(+), 17 deletions(-)

diff --git a/src/base/iter.rs b/src/base/iter.rs
index cbd2bbf6..925fefbb 100644
--- a/src/base/iter.rs
+++ b/src/base/iter.rs
@@ -226,7 +226,7 @@ impl<'a, T, R: Dim, C: Dim, S: 'a + RawStorage<T, R, C>> Iterator for RowIter<'a
 }
 
 impl<'a, T: Scalar, R: Dim, C: Dim, S: 'a + RawStorage<T, R, C>> ExactSizeIterator
-for RowIter<'a, T, R, C, S>
+    for RowIter<'a, T, R, C, S>
 {
     #[inline]
     fn len(&self) -> usize {
@@ -257,7 +257,7 @@ impl<'a, T, R: Dim, C: Dim, S: 'a + RawStorageMut<T, R, C>> RowIterMut<'a, T, R,
 }
 
 impl<'a, T, R: Dim, C: Dim, S: 'a + RawStorageMut<T, R, C>> Iterator
-for RowIterMut<'a, T, R, C, S>
+    for RowIterMut<'a, T, R, C, S>
 {
     type Item = MatrixViewMut<'a, T, U1, C, S::RStride, S::CStride>;
 
@@ -284,7 +284,7 @@ for RowIterMut<'a, T, R, C, S>
 }
 
 impl<'a, T: Scalar, R: Dim, C: Dim, S: 'a + RawStorageMut<T, R, C>> ExactSizeIterator
-for RowIterMut<'a, T, R, C, S>
+    for RowIterMut<'a, T, R, C, S>
 {
     #[inline]
     fn len(&self) -> usize {
@@ -341,7 +341,7 @@ impl<'a, T, R: Dim, C: Dim, S: 'a + RawStorage<T, R, C>> Iterator for ColumnIter
 }
 
 impl<'a, T, R: Dim, C: Dim, S: 'a + RawStorage<T, R, C>> DoubleEndedIterator
-for ColumnIter<'a, T, R, C, S>
+    for ColumnIter<'a, T, R, C, S>
 {
     fn next_back(&mut self) -> Option<Self::Item> {
         debug_assert!(self.range.start <= self.range.end);
@@ -357,7 +357,7 @@ for ColumnIter<'a, T, R, C, S>
 }
 
 impl<'a, T: Scalar, R: Dim, C: Dim, S: 'a + RawStorage<T, R, C>> ExactSizeIterator
-for ColumnIter<'a, T, R, C, S>
+    for ColumnIter<'a, T, R, C, S>
 {
     #[inline]
     fn len(&self) -> usize {
@@ -366,9 +366,9 @@ for ColumnIter<'a, T, R, C, S>
 }
 
 impl<'a, T, R: Dim, Cols: Dim, S: RawStorage<T, R, Cols>> Producer for ColumnIter<'a, T, R, Cols, S>
-    where
-        T: Send + Sync + Debug + PartialEq + Clone + 'static,
-        S: Sync,
+where
+    T: Send + Sync + Debug + PartialEq + Clone + 'static,
+    S: Sync,
 {
     type Item = MatrixSlice<'a, T, R, U1, S::RStride, S::CStride>;
     type IntoIter = ColumnIter<'a, T, R, Cols, S>;
@@ -404,7 +404,11 @@ pub struct ColumnIterMut<'a, T, R: Dim, C: Dim, S: RawStorageMut<T, R, C>> {
 impl<'a, T, R: Dim, C: Dim, S: 'a + RawStorageMut<T, R, C>> ColumnIterMut<'a, T, R, C, S> {
     pub(crate) fn new(mat: &'a mut Matrix<T, R, C, S>) -> Self {
         let range = 0..mat.ncols();
-        ColumnIterMut { mat, range, phantom: Default::default() }
+        ColumnIterMut {
+            mat,
+            range,
+            phantom: Default::default(),
+        }
     }
 
     fn ncols(&self) -> usize {
@@ -413,7 +417,7 @@ impl<'a, T, R: Dim, C: Dim, S: 'a + RawStorageMut<T, R, C>> ColumnIterMut<'a, T,
 }
 
 impl<'a, T, R: Dim, C: Dim, S: 'a + RawStorageMut<T, R, C>> Iterator
-for ColumnIterMut<'a, T, R, C, S>
+    for ColumnIterMut<'a, T, R, C, S>
 {
     type Item = MatrixViewMut<'a, T, R, U1, S::RStride, S::CStride>;
 
@@ -441,7 +445,7 @@ for ColumnIterMut<'a, T, R, C, S>
 }
 
 impl<'a, T: Scalar, R: Dim, C: Dim, S: 'a + RawStorageMut<T, R, C>> ExactSizeIterator
-for ColumnIterMut<'a, T, R, C, S>
+    for ColumnIterMut<'a, T, R, C, S>
 {
     #[inline]
     fn len(&self) -> usize {
@@ -450,7 +454,7 @@ for ColumnIterMut<'a, T, R, C, S>
 }
 
 impl<'a, T: Scalar, R: Dim, C: Dim, S: 'a + RawStorageMut<T, R, C>> DoubleEndedIterator
-for ColumnIterMut<'a, T, R, C, S>
+    for ColumnIterMut<'a, T, R, C, S>
 {
     fn next_back(&mut self) -> Option<Self::Item> {
         debug_assert!(self.range.start <= self.range.end);
@@ -466,10 +470,10 @@ for ColumnIterMut<'a, T, R, C, S>
 }
 
 impl<'a, T: Scalar, R: Dim, C: Dim, S: 'a + RawStorageMut<T, R, C>> Producer
-for ColumnIterMut<'a, T, R, C, S>
-    where
-        T: Send + Sync + Debug + PartialEq + Clone,
-        S: Send + Sync,
+    for ColumnIterMut<'a, T, R, C, S>
+where
+    T: Send + Sync + Debug + PartialEq + Clone,
+    S: Send + Sync,
 {
     type Item = MatrixSliceMut<'a, T, R, U1, S::RStride, S::CStride>;
     type IntoIter = ColumnIterMut<'a, T, R, C, S>;
@@ -498,4 +502,6 @@ for ColumnIterMut<'a, T, R, C, S>
 }
 
 unsafe impl<'a, T: Scalar, R: Dim, C: Dim, S: 'a + RawStorageMut<T, R, C>> Send
-for ColumnIterMut<'a, T, R, C, S> {}
\ No newline at end of file
+    for ColumnIterMut<'a, T, R, C, S>
+{
+}

From 85e7551c817f2c923bf0c902117283689ad66b05 Mon Sep 17 00:00:00 2001
From: geo-ant <54497890+geo-ant@users.noreply.github.com>
Date: Mon, 24 Oct 2022 08:39:03 +0200
Subject: [PATCH 085/119] feature gate functionality

---
 .github/workflows/nalgebra-ci-build.yml |   2 +-
 Cargo.toml                              |   3 +-
 src/base/iter.rs                        | 125 +++++++++++++-----------
 src/base/mod.rs                         |   1 +
 tests/core/matrix.rs                    |   3 +
 tests/lib.rs                            |   4 +
 6 files changed, 77 insertions(+), 61 deletions(-)

diff --git a/.github/workflows/nalgebra-ci-build.yml b/.github/workflows/nalgebra-ci-build.yml
index 9e500084..d7027127 100644
--- a/.github/workflows/nalgebra-ci-build.yml
+++ b/.github/workflows/nalgebra-ci-build.yml
@@ -61,7 +61,7 @@ jobs:
     steps:
       - uses: actions/checkout@v2
       - name: test
-        run: cargo test --features arbitrary,rand,serde-serialize,sparse,debug,io,compare,libm,proptest-support,slow-tests,rkyv-safe-deser;
+        run: cargo test --features arbitrary,rand,serde-serialize,sparse,debug,io,compare,libm,proptest-support,slow-tests,rkyv-safe-deser,rayon;
   test-nalgebra-glm:
     runs-on: ubuntu-latest
     steps:
diff --git a/Cargo.toml b/Cargo.toml
index 48262dce..b8f25b5d 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -33,6 +33,7 @@ libm    = [ "simba/libm" ]
 libm-force = [ "simba/libm_force" ]
 macros = [ "nalgebra-macros" ]
 cuda   = [ "cust_core", "simba/cuda" ]
+rayon  = [ "dep:rayon" ]
 
 # Conversion
 convert-mint = [ "mint" ]
@@ -101,7 +102,7 @@ glam020        = { package = "glam", version = "0.20", optional = true }
 glam021        = { package = "glam", version = "0.21", optional = true }
 glam022        = { package = "glam", version = "0.22", optional = true }
 cust_core      = { version = "0.1", optional = true }
-rayon = "1.5" # TODO make this feature gated
+rayon          = { version = "1.5", optional = true }
 
 [dev-dependencies]
 serde_json = "1.0"
diff --git a/src/base/iter.rs b/src/base/iter.rs
index 925fefbb..0ecd057c 100644
--- a/src/base/iter.rs
+++ b/src/base/iter.rs
@@ -6,8 +6,6 @@ use std::iter::FusedIterator;
 use std::marker::PhantomData;
 use std::mem;
 
-use rayon::iter::plumbing::Producer;
-
 use crate::base::dimension::{Dim, U1};
 use crate::base::storage::{RawStorage, RawStorageMut};
 use crate::base::{Matrix, MatrixView, MatrixViewMut, Scalar};
@@ -365,34 +363,6 @@ impl<'a, T: Scalar, R: Dim, C: Dim, S: 'a + RawStorage<T, R, C>> ExactSizeIterat
     }
 }
 
-impl<'a, T, R: Dim, Cols: Dim, S: RawStorage<T, R, Cols>> Producer for ColumnIter<'a, T, R, Cols, S>
-where
-    T: Send + Sync + Debug + PartialEq + Clone + 'static,
-    S: Sync,
-{
-    type Item = MatrixSlice<'a, T, R, U1, S::RStride, S::CStride>;
-    type IntoIter = ColumnIter<'a, T, R, Cols, S>;
-
-    fn split_at(self, index: usize) -> (Self, Self) {
-        // the index is relative to the size of this current iterator
-        // it will always start at zero so it serves as an offset
-        let left = Self {
-            mat: self.mat,
-            range: self.range.start..(self.range.start + index),
-        };
-
-        let right = Self {
-            mat: self.mat,
-            range: (self.range.start + index)..self.range.end,
-        };
-        (left, right)
-    }
-
-    fn into_iter(self) -> Self::IntoIter {
-        self
-    }
-}
-
 /// An iterator through the mutable columns of a matrix.
 #[derive(Debug)]
 pub struct ColumnIterMut<'a, T, R: Dim, C: Dim, S: RawStorageMut<T, R, C>> {
@@ -469,39 +439,76 @@ impl<'a, T: Scalar, R: Dim, C: Dim, S: 'a + RawStorageMut<T, R, C>> DoubleEndedI
     }
 }
 
-impl<'a, T: Scalar, R: Dim, C: Dim, S: 'a + RawStorageMut<T, R, C>> Producer
-    for ColumnIterMut<'a, T, R, C, S>
-where
-    T: Send + Sync + Debug + PartialEq + Clone,
-    S: Send + Sync,
-{
-    type Item = MatrixSliceMut<'a, T, R, U1, S::RStride, S::CStride>;
-    type IntoIter = ColumnIterMut<'a, T, R, C, S>;
+/// implementations for parallel iteration with rayon
+#[cfg(feature = "rayon")]
+mod parallel {
+    use super::*;
+    use rayon::iter::plumbing::Producer;
 
-    fn into_iter(self) -> Self::IntoIter {
-        self
+    impl<'a, T, R: Dim, Cols: Dim, S: RawStorage<T, R, Cols>> Producer for ColumnIter<'a, T, R, Cols, S>
+    where
+        T: Send + Sync + Debug + PartialEq + Clone + 'static,
+        S: Sync,
+    {
+        type Item = MatrixSlice<'a, T, R, U1, S::RStride, S::CStride>;
+        type IntoIter = ColumnIter<'a, T, R, Cols, S>;
+
+        fn split_at(self, index: usize) -> (Self, Self) {
+            // the index is relative to the size of this current iterator
+            // it will always start at zero so it serves as an offset
+            let left = Self {
+                mat: self.mat,
+                range: self.range.start..(self.range.start + index),
+            };
+
+            let right = Self {
+                mat: self.mat,
+                range: (self.range.start + index)..self.range.end,
+            };
+            (left, right)
+        }
+
+        fn into_iter(self) -> Self::IntoIter {
+            self
+        }
     }
 
-    fn split_at(self, index: usize) -> (Self, Self) {
-        // the index is relative to the size of this current iterator
-        // it will always start at zero so it serves as an offset
+    impl<'a, T: Scalar, R: Dim, C: Dim, S: 'a + RawStorageMut<T, R, C>> Producer
+        for ColumnIterMut<'a, T, R, C, S>
+    where
+        T: Send + Sync + Debug + PartialEq + Clone,
+        S: Send + Sync,
+    {
+        type Item = MatrixSliceMut<'a, T, R, U1, S::RStride, S::CStride>;
+        type IntoIter = ColumnIterMut<'a, T, R, C, S>;
 
-        let left = Self {
-            mat: self.mat,
-            range: self.range.start..(self.range.start + index),
-            phantom: Default::default(),
-        };
+        fn into_iter(self) -> Self::IntoIter {
+            self
+        }
 
-        let right = Self {
-            mat: self.mat,
-            range: (self.range.start + index)..self.range.end,
-            phantom: Default::default(),
-        };
-        (left, right)
+        fn split_at(self, index: usize) -> (Self, Self) {
+            // the index is relative to the size of this current iterator
+            // it will always start at zero so it serves as an offset
+
+            let left = Self {
+                mat: self.mat,
+                range: self.range.start..(self.range.start + index),
+                phantom: Default::default(),
+            };
+
+            let right = Self {
+                mat: self.mat,
+                range: (self.range.start + index)..self.range.end,
+                phantom: Default::default(),
+            };
+            (left, right)
+        }
+    }
+
+    /// this implementation is safe because we are enforcing exclusive access
+    /// to the columns through the active range of the iterator
+    unsafe impl<'a, T: Scalar, R: Dim, C: Dim, S: 'a + RawStorageMut<T, R, C>> Send
+        for ColumnIterMut<'a, T, R, C, S>
+    {
     }
 }
-
-unsafe impl<'a, T: Scalar, R: Dim, C: Dim, S: 'a + RawStorageMut<T, R, C>> Send
-    for ColumnIterMut<'a, T, R, C, S>
-{
-}
diff --git a/src/base/mod.rs b/src/base/mod.rs
index b828d0a1..0f09cc33 100644
--- a/src/base/mod.rs
+++ b/src/base/mod.rs
@@ -42,6 +42,7 @@ mod min_max;
 /// Mechanisms for working with values that may not be initialized.
 pub mod uninit;
 
+#[cfg(feature = "rayon")]
 pub mod par_iter;
 
 #[cfg(feature = "rkyv-serialize-no-std")]
diff --git a/tests/core/matrix.rs b/tests/core/matrix.rs
index 5021df8b..150eb678 100644
--- a/tests/core/matrix.rs
+++ b/tests/core/matrix.rs
@@ -1200,6 +1200,7 @@ fn column_iteration_double_ended() {
 }
 
 #[test]
+#[cfg(feature = "rayon")]
 fn parallel_column_iteration() {
     use nalgebra::dmatrix;
     use rayon::prelude::*;
@@ -1221,6 +1222,7 @@ fn parallel_column_iteration() {
 }
 
 #[test]
+#[cfg(feature = "rayon")]
 fn colum_iteration_mut_double_ended() {
     let dmat = nalgebra::dmatrix![
     13,14,15,16,17;
@@ -1239,6 +1241,7 @@ fn colum_iteration_mut_double_ended() {
 }
 
 #[test]
+#[cfg(feature = "rayon")]
 fn parallel_column_iteration_mut() {
     use rayon::prelude::*;
     let mut first = DMatrix::<f32>::zeros(400, 300);
diff --git a/tests/lib.rs b/tests/lib.rs
index 546aa8a7..fb13b3ae 100644
--- a/tests/lib.rs
+++ b/tests/lib.rs
@@ -9,6 +9,10 @@ compile_error!(
      Example: `cargo test --features debug,compare,rand,macros`"
 );
 
+// make sure to test the parallel iterators for all builds that do not require no_std
+#[cfg(all(feature = "std", not(feature = "rayon")))]
+compile_error!("Please additionally enable the `rayon` feature to compile and run the tests");
+
 #[cfg(all(feature = "debug", feature = "compare", feature = "rand"))]
 #[macro_use]
 extern crate approx;

From 6591f2819a56af4bb9fd130c22133c887a39f2a5 Mon Sep 17 00:00:00 2001
From: geo-ant <54497890+geo-ant@users.noreply.github.com>
Date: Mon, 24 Oct 2022 08:46:25 +0200
Subject: [PATCH 086/119] make rayon feature imply std

---
 Cargo.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Cargo.toml b/Cargo.toml
index b8f25b5d..7e7df5b4 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -33,7 +33,7 @@ libm    = [ "simba/libm" ]
 libm-force = [ "simba/libm_force" ]
 macros = [ "nalgebra-macros" ]
 cuda   = [ "cust_core", "simba/cuda" ]
-rayon  = [ "dep:rayon" ]
+rayon  = [ "std", "dep:rayon" ]
 
 # Conversion
 convert-mint = [ "mint" ]

From 701d260fa687698ac56fd625973ef2005eb8a5cd Mon Sep 17 00:00:00 2001
From: geo-ant <54497890+geo-ant@users.noreply.github.com>
Date: Tue, 25 Oct 2022 08:47:57 +0200
Subject: [PATCH 087/119] rayon parallel feature w/o nightly features on old
 compilers

---
 .github/workflows/nalgebra-ci-build.yml | 2 +-
 Cargo.toml                              | 2 +-
 tests/lib.rs                            | 4 ++--
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/nalgebra-ci-build.yml b/.github/workflows/nalgebra-ci-build.yml
index d7027127..467a3090 100644
--- a/.github/workflows/nalgebra-ci-build.yml
+++ b/.github/workflows/nalgebra-ci-build.yml
@@ -61,7 +61,7 @@ jobs:
     steps:
       - uses: actions/checkout@v2
       - name: test
-        run: cargo test --features arbitrary,rand,serde-serialize,sparse,debug,io,compare,libm,proptest-support,slow-tests,rkyv-safe-deser,rayon;
+        run: cargo test --features arbitrary,rand,serde-serialize,sparse,debug,io,compare,libm,proptest-support,slow-tests,rkyv-safe-deser,rayon-par;
   test-nalgebra-glm:
     runs-on: ubuntu-latest
     steps:
diff --git a/Cargo.toml b/Cargo.toml
index 7e7df5b4..ff3407fe 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -33,7 +33,7 @@ libm    = [ "simba/libm" ]
 libm-force = [ "simba/libm_force" ]
 macros = [ "nalgebra-macros" ]
 cuda   = [ "cust_core", "simba/cuda" ]
-rayon  = [ "std", "dep:rayon" ]
+rayon-par  = [ "std", "rayon" ]
 
 # Conversion
 convert-mint = [ "mint" ]
diff --git a/tests/lib.rs b/tests/lib.rs
index fb13b3ae..49384d8a 100644
--- a/tests/lib.rs
+++ b/tests/lib.rs
@@ -10,8 +10,8 @@ compile_error!(
 );
 
 // make sure to test the parallel iterators for all builds that do not require no_std
-#[cfg(all(feature = "std", not(feature = "rayon")))]
-compile_error!("Please additionally enable the `rayon` feature to compile and run the tests");
+#[cfg(all(feature = "std", not(feature = "rayon-par")))]
+compile_error!("Please additionally enable the `rayon-par` feature to compile and run the tests");
 
 #[cfg(all(feature = "debug", feature = "compare", feature = "rand"))]
 #[macro_use]

From e40687d8e6ddba17a3ea95cea66a1ec4ef819c91 Mon Sep 17 00:00:00 2001
From: geo-ant <54497890+geo-ant@users.noreply.github.com>
Date: Sat, 12 Nov 2022 17:37:18 +0100
Subject: [PATCH 088/119] replace confusing trait bounds with Scalar

---
 src/base/iter.rs     |  6 +++---
 src/base/par_iter.rs | 16 +++++++---------
 2 files changed, 10 insertions(+), 12 deletions(-)

diff --git a/src/base/iter.rs b/src/base/iter.rs
index 0ecd057c..b3f66d81 100644
--- a/src/base/iter.rs
+++ b/src/base/iter.rs
@@ -447,7 +447,7 @@ mod parallel {
 
     impl<'a, T, R: Dim, Cols: Dim, S: RawStorage<T, R, Cols>> Producer for ColumnIter<'a, T, R, Cols, S>
     where
-        T: Send + Sync + Debug + PartialEq + Clone + 'static,
+        T: Send + Sync +  Scalar,
         S: Sync,
     {
         type Item = MatrixSlice<'a, T, R, U1, S::RStride, S::CStride>;
@@ -473,10 +473,10 @@ mod parallel {
         }
     }
 
-    impl<'a, T: Scalar, R: Dim, C: Dim, S: 'a + RawStorageMut<T, R, C>> Producer
+    impl<'a, T, R: Dim, C: Dim, S: 'a + RawStorageMut<T, R, C>> Producer
         for ColumnIterMut<'a, T, R, C, S>
     where
-        T: Send + Sync + Debug + PartialEq + Clone,
+        T: Send + Sync + Scalar,
         S: Send + Sync,
     {
         type Item = MatrixSliceMut<'a, T, R, U1, S::RStride, S::CStride>;
diff --git a/src/base/par_iter.rs b/src/base/par_iter.rs
index 9beccee9..589f7b81 100644
--- a/src/base/par_iter.rs
+++ b/src/base/par_iter.rs
@@ -3,9 +3,7 @@
 
 use crate::{
     iter::{ColumnIter, ColumnIterMut},
-    Dim, Matrix, MatrixSlice, MatrixSliceMut, RawStorage, RawStorageMut, U1,
-};
-use core::fmt::Debug;
+    Dim, Matrix, MatrixSlice, MatrixSliceMut, RawStorage, RawStorageMut, U1, Scalar,};
 use rayon::{iter::plumbing::bridge, prelude::*};
 
 /// A rayon parallel iterator over the colums of a matrix
@@ -23,7 +21,7 @@ impl<'a, T, R: Dim, Cols: Dim, S: RawStorage<T, R, Cols>> ParColumnIter<'a, T, R
 impl<'a, T, R: Dim, Cols: Dim, S: RawStorage<T, R, Cols>> ParallelIterator
     for ParColumnIter<'a, T, R, Cols, S>
 where
-    T: Sync + Send + Clone + Debug + PartialEq + 'static,
+    T: Sync + Send + Scalar,
     S: Sync,
 {
     type Item = MatrixSlice<'a, T, R, U1, S::RStride, S::CStride>;
@@ -43,7 +41,7 @@ where
 impl<'a, T, R: Dim, Cols: Dim, S: RawStorage<T, R, Cols>> IndexedParallelIterator
     for ParColumnIter<'a, T, R, Cols, S>
 where
-    T: Send + Sync + Clone + Debug + PartialEq + 'static,
+    T: Send + Sync + Scalar,
     S: Sync,
 {
     fn len(&self) -> usize {
@@ -65,7 +63,7 @@ where
 
 impl<T, R: Dim, Cols: Dim, S: RawStorage<T, R, Cols>> Matrix<T, R, Cols, S>
 where
-    T: Send + Sync + Clone + Debug + PartialEq + 'static,
+    T: Send + Sync + Scalar,
     S: Sync,
 {
     /// Iterate through the columns of the matrix in parallel using rayon.
@@ -102,7 +100,7 @@ where
     R: Dim,
     Cols: Dim,
     S: RawStorage<T, R, Cols> + RawStorageMut<T, R, Cols>,
-    T: Send + Sync + Debug + PartialEq + Clone + 'static,
+    T: Send + Sync + Scalar,
     S: Send + Sync,
 {
     type Item = MatrixSliceMut<'a, T, R, U1, S::RStride, S::CStride>;
@@ -123,7 +121,7 @@ where
     R: Dim,
     Cols: Dim,
     S: RawStorage<T, R, Cols> + RawStorageMut<T, R, Cols>,
-    T: Send + Sync + Debug + PartialEq + Clone + 'static,
+    T: Send + Sync + Scalar,
     S: Send + Sync,
 {
     fn drive<C: rayon::iter::plumbing::Consumer<Self::Item>>(self, consumer: C) -> C::Result {
@@ -146,7 +144,7 @@ where
 impl<T, R: Dim, Cols: Dim, S: RawStorage<T, R, Cols> + RawStorageMut<T, R, Cols>>
     Matrix<T, R, Cols, S>
 where
-    T: Send + Sync + Clone + Debug + PartialEq + 'static,
+    T: Send + Sync + Scalar,
     S: Sync,
 {
     /// Mutably iterate through the columns of this matrix in parallel using rayon

From e9a5705e1afdcde2e2734e05184faa9159c5617d Mon Sep 17 00:00:00 2001
From: geo-ant <54497890+geo-ant@users.noreply.github.com>
Date: Sat, 12 Nov 2022 17:54:01 +0100
Subject: [PATCH 089/119] address review

---
 Cargo.toml           | 2 +-
 src/base/iter.rs     | 2 +-
 src/base/par_iter.rs | 6 +++---
 tests/core/matrix.rs | 2 +-
 tests/lib.rs         | 4 ++--
 5 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index ff3407fe..7e7df5b4 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -33,7 +33,7 @@ libm    = [ "simba/libm" ]
 libm-force = [ "simba/libm_force" ]
 macros = [ "nalgebra-macros" ]
 cuda   = [ "cust_core", "simba/cuda" ]
-rayon-par  = [ "std", "rayon" ]
+rayon  = [ "std", "dep:rayon" ]
 
 # Conversion
 convert-mint = [ "mint" ]
diff --git a/src/base/iter.rs b/src/base/iter.rs
index b3f66d81..4e1dc21a 100644
--- a/src/base/iter.rs
+++ b/src/base/iter.rs
@@ -447,7 +447,7 @@ mod parallel {
 
     impl<'a, T, R: Dim, Cols: Dim, S: RawStorage<T, R, Cols>> Producer for ColumnIter<'a, T, R, Cols, S>
     where
-        T: Send + Sync +  Scalar,
+        T: Send + Sync + Scalar,
         S: Sync,
     {
         type Item = MatrixSlice<'a, T, R, U1, S::RStride, S::CStride>;
diff --git a/src/base/par_iter.rs b/src/base/par_iter.rs
index 589f7b81..8aaad348 100644
--- a/src/base/par_iter.rs
+++ b/src/base/par_iter.rs
@@ -1,9 +1,9 @@
-//! this module implements parallelators to make matrices work with
-//! the rayon crate seamlessly
+//! Parallel iterators for matrices compatible with rayon.
 
 use crate::{
     iter::{ColumnIter, ColumnIterMut},
-    Dim, Matrix, MatrixSlice, MatrixSliceMut, RawStorage, RawStorageMut, U1, Scalar,};
+    Dim, Matrix, MatrixSlice, MatrixSliceMut, RawStorage, RawStorageMut, Scalar, U1,
+};
 use rayon::{iter::plumbing::bridge, prelude::*};
 
 /// A rayon parallel iterator over the colums of a matrix
diff --git a/tests/core/matrix.rs b/tests/core/matrix.rs
index 150eb678..12f5308e 100644
--- a/tests/core/matrix.rs
+++ b/tests/core/matrix.rs
@@ -1223,7 +1223,7 @@ fn parallel_column_iteration() {
 
 #[test]
 #[cfg(feature = "rayon")]
-fn colum_iteration_mut_double_ended() {
+fn column_iteration_mut_double_ended() {
     let dmat = nalgebra::dmatrix![
     13,14,15,16,17;
     23,24,25,26,27;
diff --git a/tests/lib.rs b/tests/lib.rs
index 49384d8a..fb13b3ae 100644
--- a/tests/lib.rs
+++ b/tests/lib.rs
@@ -10,8 +10,8 @@ compile_error!(
 );
 
 // make sure to test the parallel iterators for all builds that do not require no_std
-#[cfg(all(feature = "std", not(feature = "rayon-par")))]
-compile_error!("Please additionally enable the `rayon-par` feature to compile and run the tests");
+#[cfg(all(feature = "std", not(feature = "rayon")))]
+compile_error!("Please additionally enable the `rayon` feature to compile and run the tests");
 
 #[cfg(all(feature = "debug", feature = "compare", feature = "rand"))]
 #[macro_use]

From 324e686fe6befecf39e9dec0cb9a8cc52286c4ee Mon Sep 17 00:00:00 2001
From: geo-ant <54497890+geo-ant@users.noreply.github.com>
Date: Sat, 12 Nov 2022 17:57:27 +0100
Subject: [PATCH 090/119] update workflow for new feature name

---
 .github/workflows/nalgebra-ci-build.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/nalgebra-ci-build.yml b/.github/workflows/nalgebra-ci-build.yml
index 467a3090..d7027127 100644
--- a/.github/workflows/nalgebra-ci-build.yml
+++ b/.github/workflows/nalgebra-ci-build.yml
@@ -61,7 +61,7 @@ jobs:
     steps:
       - uses: actions/checkout@v2
       - name: test
-        run: cargo test --features arbitrary,rand,serde-serialize,sparse,debug,io,compare,libm,proptest-support,slow-tests,rkyv-safe-deser,rayon-par;
+        run: cargo test --features arbitrary,rand,serde-serialize,sparse,debug,io,compare,libm,proptest-support,slow-tests,rkyv-safe-deser,rayon;
   test-nalgebra-glm:
     runs-on: ubuntu-latest
     steps:

From 83c2e27d6d05e69777406852775d5411d8c5d1b3 Mon Sep 17 00:00:00 2001
From: geo-ant <54497890+geo-ant@users.noreply.github.com>
Date: Sat, 12 Nov 2022 19:01:28 +0100
Subject: [PATCH 091/119] start expanding docs(not done)

---
 src/base/par_iter.rs | 15 ++++++++++++++-
 1 file changed, 14 insertions(+), 1 deletion(-)

diff --git a/src/base/par_iter.rs b/src/base/par_iter.rs
index 8aaad348..93796b6a 100644
--- a/src/base/par_iter.rs
+++ b/src/base/par_iter.rs
@@ -6,7 +6,12 @@ use crate::{
 };
 use rayon::{iter::plumbing::bridge, prelude::*};
 
-/// A rayon parallel iterator over the colums of a matrix
+/// A rayon parallel iterator over the colums of a matrix. It is created
+/// using the [`par_column_iter`] method of [`Matrix`].
+///
+/// [`par_column_iter`]: crate::Matrix::par_column_iter
+/// [`Matrix`]: crate::Matrix
+#[cfg_attr(doc_cfg, doc(cfg(feature = "rayon")))]
 pub struct ParColumnIter<'a, T, R: Dim, Cols: Dim, S: RawStorage<T, R, Cols>> {
     mat: &'a Matrix<T, R, Cols, S>,
 }
@@ -18,6 +23,7 @@ impl<'a, T, R: Dim, Cols: Dim, S: RawStorage<T, R, Cols>> ParColumnIter<'a, T, R
     }
 }
 
+#[cfg_attr(doc_cfg, doc(cfg(feature = "rayon")))]
 impl<'a, T, R: Dim, Cols: Dim, S: RawStorage<T, R, Cols>> ParallelIterator
     for ParColumnIter<'a, T, R, Cols, S>
 where
@@ -38,6 +44,7 @@ where
     }
 }
 
+#[cfg_attr(doc_cfg, doc(cfg(feature = "rayon")))]
 impl<'a, T, R: Dim, Cols: Dim, S: RawStorage<T, R, Cols>> IndexedParallelIterator
     for ParColumnIter<'a, T, R, Cols, S>
 where
@@ -61,6 +68,7 @@ where
     }
 }
 
+#[cfg_attr(doc_cfg, doc(cfg(feature = "rayon")))]
 impl<T, R: Dim, Cols: Dim, S: RawStorage<T, R, Cols>> Matrix<T, R, Cols, S>
 where
     T: Send + Sync + Scalar,
@@ -72,6 +80,7 @@ where
     }
 }
 
+#[cfg_attr(doc_cfg, doc(cfg(feature = "rayon")))]
 /// A rayon parallel iterator through the mutable columns of a matrix
 pub struct ParColumnIterMut<
     'a,
@@ -83,6 +92,7 @@ pub struct ParColumnIterMut<
     mat: &'a mut Matrix<T, R, Cols, S>,
 }
 
+#[cfg_attr(doc_cfg, doc(cfg(feature = "rayon")))]
 impl<'a, T, R, Cols, S> ParColumnIterMut<'a, T, R, Cols, S>
 where
     R: Dim,
@@ -95,6 +105,7 @@ where
     }
 }
 
+#[cfg_attr(doc_cfg, doc(cfg(feature = "rayon")))]
 impl<'a, T, R, Cols, S> ParallelIterator for ParColumnIterMut<'a, T, R, Cols, S>
 where
     R: Dim,
@@ -116,6 +127,7 @@ where
     }
 }
 
+#[cfg_attr(doc_cfg, doc(cfg(feature = "rayon")))]
 impl<'a, T, R, Cols, S> IndexedParallelIterator for ParColumnIterMut<'a, T, R, Cols, S>
 where
     R: Dim,
@@ -141,6 +153,7 @@ where
     }
 }
 
+#[cfg_attr(doc_cfg, doc(cfg(feature = "rayon")))]
 impl<T, R: Dim, Cols: Dim, S: RawStorage<T, R, Cols> + RawStorageMut<T, R, Cols>>
     Matrix<T, R, Cols, S>
 where

From 97861c8a5e006dbc62572f8e9cc0aa94440a66ea Mon Sep 17 00:00:00 2001
From: geo-ant <54497890+geo-ant@users.noreply.github.com>
Date: Sun, 13 Nov 2022 14:54:26 +0100
Subject: [PATCH 092/119] add examples in par_column_iter method

---
 Cargo.toml           |  2 ++
 src/base/par_iter.rs | 30 ++++++++++++++++++++++++++++++
 2 files changed, 32 insertions(+)

diff --git a/Cargo.toml b/Cargo.toml
index 7e7df5b4..96356547 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -138,3 +138,5 @@ lto = true
 [package.metadata.docs.rs]
 # Enable all the features when building the docs on docs.rs
 all-features = true
+# define the configuration attribute `docsrs`
+rustdoc-args = ["--cfg", "docsrs"]
diff --git a/src/base/par_iter.rs b/src/base/par_iter.rs
index 93796b6a..a551c0a7 100644
--- a/src/base/par_iter.rs
+++ b/src/base/par_iter.rs
@@ -1,5 +1,9 @@
 //! Parallel iterators for matrices compatible with rayon.
 
+//only enables the `doc_cfg` feature when
+// the `docsrs` configuration attribute is defined
+#![cfg_attr(docsrs, feature(doc_cfg))]
+
 use crate::{
     iter::{ColumnIter, ColumnIterMut},
     Dim, Matrix, MatrixSlice, MatrixSliceMut, RawStorage, RawStorageMut, Scalar, U1,
@@ -75,6 +79,32 @@ where
     S: Sync,
 {
     /// Iterate through the columns of the matrix in parallel using rayon.
+    /// This iterates over *immutable* references ot the columns of the matrix,
+    /// if *mutable* access to the columns is required, use [`par_column_iter_mut`]
+    /// instead.
+    /// 
+    /// **Example**
+    /// Using parallel column iterators to calculate the sum of the maximum
+    /// elements in each column:
+    /// ```
+    /// use nalgebra::{dmatrix,DMatrix};
+    /// use rayon::prelude::*;
+    ///
+    /// let matrix : DMatrix<f64> = 
+    ///         nalgebra::dmatrix![1.,0.,5.;
+    ///                            2.,4.,1.;
+    ///                            3.,2.,2.;];
+    /// let sum_of_max :f64 = 
+    ///         matrix
+    ///         .par_column_iter()
+    ///         .map(|col|col.max())
+    ///         .sum();
+    ///
+    /// assert_eq!(sum_of_max,3.+4.+5.);
+    ///                             
+    /// ```
+    ///
+    /// [`par_column_iter_mut`]: crate::Matrix::par_column_iter_mut
     pub fn par_column_iter(&self) -> ParColumnIter<'_, T, R, Cols, S> {
         ParColumnIter::new(self)
     }

From 8d1f684e45d76ce97b44db940cbb7b1d2d1019ca Mon Sep 17 00:00:00 2001
From: geo-ant <54497890+geo-ant@users.noreply.github.com>
Date: Sun, 13 Nov 2022 17:01:15 +0100
Subject: [PATCH 093/119] change feature name to par-iter and add doc example
 to par_column_iter_mut

---
 Cargo.toml           |  2 +-
 src/base/iter.rs     |  2 +-
 src/base/matrix.rs   |  2 +-
 src/base/mod.rs      |  3 ++-
 src/base/par_iter.rs | 44 +++++++++++++++++++++++++++++++++-----------
 tests/core/matrix.rs |  6 +++---
 tests/lib.rs         |  4 ++--
 7 files changed, 43 insertions(+), 20 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 96356547..cee3130c 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -33,7 +33,7 @@ libm    = [ "simba/libm" ]
 libm-force = [ "simba/libm_force" ]
 macros = [ "nalgebra-macros" ]
 cuda   = [ "cust_core", "simba/cuda" ]
-rayon  = [ "std", "dep:rayon" ]
+par-iter  = [ "std", "rayon" ]
 
 # Conversion
 convert-mint = [ "mint" ]
diff --git a/src/base/iter.rs b/src/base/iter.rs
index 4e1dc21a..220eadd8 100644
--- a/src/base/iter.rs
+++ b/src/base/iter.rs
@@ -440,7 +440,7 @@ impl<'a, T: Scalar, R: Dim, C: Dim, S: 'a + RawStorageMut<T, R, C>> DoubleEndedI
 }
 
 /// implementations for parallel iteration with rayon
-#[cfg(feature = "rayon")]
+#[cfg(feature = "par-iter")]
 mod parallel {
     use super::*;
     use rayon::iter::plumbing::Producer;
diff --git a/src/base/matrix.rs b/src/base/matrix.rs
index 700e2f02..2d166d2a 100644
--- a/src/base/matrix.rs
+++ b/src/base/matrix.rs
@@ -100,7 +100,7 @@ pub type MatrixCross<T, R1, C1, R2, C2> =
 /// - [Find the min and max components (vector-specific methods) <span style="float:right;">`argmin`, `argmax`, `icamin`, `icamax`…</span>](#find-the-min-and-max-components-vector-specific-methods)
 ///
 /// #### Iteration, map, and fold
-/// - [Iteration on components, rows, and columns <span style="float:right;">`iter`, `column_iter`…</span>](#iteration-on-components-rows-and-columns)
+/// - [Iteration on components, rows, and columns <span style="float:right;">`iter`, `column_iter`, `par_column_iter`…</span>](#iteration-on-components-rows-and-columns)
 /// - [Elementwise mapping and folding <span style="float:right;">`map`, `fold`, `zip_map`…</span>](#elementwise-mapping-and-folding)
 /// - [Folding or columns and rows <span style="float:right;">`compress_rows`, `compress_columns`…</span>](#folding-on-columns-and-rows)
 ///
diff --git a/src/base/mod.rs b/src/base/mod.rs
index 0f09cc33..f22a53bf 100644
--- a/src/base/mod.rs
+++ b/src/base/mod.rs
@@ -42,7 +42,8 @@ mod min_max;
 /// Mechanisms for working with values that may not be initialized.
 pub mod uninit;
 
-#[cfg(feature = "rayon")]
+
+#[cfg(feature = "par-iter")]
 pub mod par_iter;
 
 #[cfg(feature = "rkyv-serialize-no-std")]
diff --git a/src/base/par_iter.rs b/src/base/par_iter.rs
index a551c0a7..1b106e6e 100644
--- a/src/base/par_iter.rs
+++ b/src/base/par_iter.rs
@@ -15,7 +15,7 @@ use rayon::{iter::plumbing::bridge, prelude::*};
 ///
 /// [`par_column_iter`]: crate::Matrix::par_column_iter
 /// [`Matrix`]: crate::Matrix
-#[cfg_attr(doc_cfg, doc(cfg(feature = "rayon")))]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "par-iter")))]
 pub struct ParColumnIter<'a, T, R: Dim, Cols: Dim, S: RawStorage<T, R, Cols>> {
     mat: &'a Matrix<T, R, Cols, S>,
 }
@@ -27,7 +27,7 @@ impl<'a, T, R: Dim, Cols: Dim, S: RawStorage<T, R, Cols>> ParColumnIter<'a, T, R
     }
 }
 
-#[cfg_attr(doc_cfg, doc(cfg(feature = "rayon")))]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "par-iter")))]
 impl<'a, T, R: Dim, Cols: Dim, S: RawStorage<T, R, Cols>> ParallelIterator
     for ParColumnIter<'a, T, R, Cols, S>
 where
@@ -48,7 +48,7 @@ where
     }
 }
 
-#[cfg_attr(doc_cfg, doc(cfg(feature = "rayon")))]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "par-iter")))]
 impl<'a, T, R: Dim, Cols: Dim, S: RawStorage<T, R, Cols>> IndexedParallelIterator
     for ParColumnIter<'a, T, R, Cols, S>
 where
@@ -72,7 +72,7 @@ where
     }
 }
 
-#[cfg_attr(doc_cfg, doc(cfg(feature = "rayon")))]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "par-iter")))]
 impl<T, R: Dim, Cols: Dim, S: RawStorage<T, R, Cols>> Matrix<T, R, Cols, S>
 where
     T: Send + Sync + Scalar,
@@ -83,7 +83,7 @@ where
     /// if *mutable* access to the columns is required, use [`par_column_iter_mut`]
     /// instead.
     /// 
-    /// **Example**
+    /// # Example
     /// Using parallel column iterators to calculate the sum of the maximum
     /// elements in each column:
     /// ```
@@ -110,7 +110,7 @@ where
     }
 }
 
-#[cfg_attr(doc_cfg, doc(cfg(feature = "rayon")))]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "par-iter")))]
 /// A rayon parallel iterator through the mutable columns of a matrix
 pub struct ParColumnIterMut<
     'a,
@@ -122,7 +122,7 @@ pub struct ParColumnIterMut<
     mat: &'a mut Matrix<T, R, Cols, S>,
 }
 
-#[cfg_attr(doc_cfg, doc(cfg(feature = "rayon")))]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "par-iter")))]
 impl<'a, T, R, Cols, S> ParColumnIterMut<'a, T, R, Cols, S>
 where
     R: Dim,
@@ -135,7 +135,7 @@ where
     }
 }
 
-#[cfg_attr(doc_cfg, doc(cfg(feature = "rayon")))]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "par-iter")))]
 impl<'a, T, R, Cols, S> ParallelIterator for ParColumnIterMut<'a, T, R, Cols, S>
 where
     R: Dim,
@@ -157,7 +157,7 @@ where
     }
 }
 
-#[cfg_attr(doc_cfg, doc(cfg(feature = "rayon")))]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "par-iter")))]
 impl<'a, T, R, Cols, S> IndexedParallelIterator for ParColumnIterMut<'a, T, R, Cols, S>
 where
     R: Dim,
@@ -183,14 +183,36 @@ where
     }
 }
 
-#[cfg_attr(doc_cfg, doc(cfg(feature = "rayon")))]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "par-iter")))]
 impl<T, R: Dim, Cols: Dim, S: RawStorage<T, R, Cols> + RawStorageMut<T, R, Cols>>
     Matrix<T, R, Cols, S>
 where
     T: Send + Sync + Scalar,
     S: Sync,
 {
-    /// Mutably iterate through the columns of this matrix in parallel using rayon
+    /// Mutably iterate through the columns of this matrix in parallel using rayon.
+    /// Allows mutable access to the columns in parallel using mutable references.
+    /// If mutable access to the columns is not required rather use [`par_column_iter`]
+    /// instead.
+    /// 
+    /// # Example 
+    /// Normalize each column of a matrix with respect to its own maximum value.
+    /// 
+    /// ```
+    /// use nalgebra::{dmatrix,DMatrix};
+    /// use rayon::prelude::*;
+    ///
+    /// let mut matrix : DMatrix<f64> =
+    ///                     dmatrix![2.,4.,6.;
+    ///                             1.,2.,3.];
+    /// matrix.par_column_iter_mut().for_each(|mut col| col /= col.max());
+    ///
+    /// assert_eq!(matrix,
+    ///             dmatrix![1. ,1. , 1.;
+    ///                      0.5,0.5,0.5]);
+    /// ```
+    ///
+    /// [`par_column_iter`]: crate::Matrix::par_column_iter
     pub fn par_column_iter_mut(&mut self) -> ParColumnIterMut<'_, T, R, Cols, S> {
         ParColumnIterMut::new(self)
     }
diff --git a/tests/core/matrix.rs b/tests/core/matrix.rs
index 12f5308e..603897af 100644
--- a/tests/core/matrix.rs
+++ b/tests/core/matrix.rs
@@ -1200,7 +1200,7 @@ fn column_iteration_double_ended() {
 }
 
 #[test]
-#[cfg(feature = "rayon")]
+#[cfg(feature = "par-iter")]
 fn parallel_column_iteration() {
     use nalgebra::dmatrix;
     use rayon::prelude::*;
@@ -1222,7 +1222,7 @@ fn parallel_column_iteration() {
 }
 
 #[test]
-#[cfg(feature = "rayon")]
+#[cfg(feature = "par-iter")]
 fn column_iteration_mut_double_ended() {
     let dmat = nalgebra::dmatrix![
     13,14,15,16,17;
@@ -1241,7 +1241,7 @@ fn column_iteration_mut_double_ended() {
 }
 
 #[test]
-#[cfg(feature = "rayon")]
+#[cfg(feature = "par-iter")]
 fn parallel_column_iteration_mut() {
     use rayon::prelude::*;
     let mut first = DMatrix::<f32>::zeros(400, 300);
diff --git a/tests/lib.rs b/tests/lib.rs
index fb13b3ae..6e4238e5 100644
--- a/tests/lib.rs
+++ b/tests/lib.rs
@@ -10,8 +10,8 @@ compile_error!(
 );
 
 // make sure to test the parallel iterators for all builds that do not require no_std
-#[cfg(all(feature = "std", not(feature = "rayon")))]
-compile_error!("Please additionally enable the `rayon` feature to compile and run the tests");
+#[cfg(all(feature = "std", not(feature = "par-iter")))]
+compile_error!("Please additionally enable the `par-iter` feature to compile and run the tests");
 
 #[cfg(all(feature = "debug", feature = "compare", feature = "rand"))]
 #[macro_use]

From e1305d3d8e626d0d112a30cebbf6aaf17eaa8238 Mon Sep 17 00:00:00 2001
From: geo-ant <54497890+geo-ant@users.noreply.github.com>
Date: Sun, 13 Nov 2022 17:01:31 +0100
Subject: [PATCH 094/119] fmt

---
 src/base/mod.rs      |  1 -
 src/base/par_iter.rs | 12 ++++++------
 2 files changed, 6 insertions(+), 7 deletions(-)

diff --git a/src/base/mod.rs b/src/base/mod.rs
index f22a53bf..73fe18c3 100644
--- a/src/base/mod.rs
+++ b/src/base/mod.rs
@@ -42,7 +42,6 @@ mod min_max;
 /// Mechanisms for working with values that may not be initialized.
 pub mod uninit;
 
-
 #[cfg(feature = "par-iter")]
 pub mod par_iter;
 
diff --git a/src/base/par_iter.rs b/src/base/par_iter.rs
index 1b106e6e..6e1eb53a 100644
--- a/src/base/par_iter.rs
+++ b/src/base/par_iter.rs
@@ -82,7 +82,7 @@ where
     /// This iterates over *immutable* references ot the columns of the matrix,
     /// if *mutable* access to the columns is required, use [`par_column_iter_mut`]
     /// instead.
-    /// 
+    ///
     /// # Example
     /// Using parallel column iterators to calculate the sum of the maximum
     /// elements in each column:
@@ -90,11 +90,11 @@ where
     /// use nalgebra::{dmatrix,DMatrix};
     /// use rayon::prelude::*;
     ///
-    /// let matrix : DMatrix<f64> = 
+    /// let matrix : DMatrix<f64> =
     ///         nalgebra::dmatrix![1.,0.,5.;
     ///                            2.,4.,1.;
     ///                            3.,2.,2.;];
-    /// let sum_of_max :f64 = 
+    /// let sum_of_max :f64 =
     ///         matrix
     ///         .par_column_iter()
     ///         .map(|col|col.max())
@@ -194,10 +194,10 @@ where
     /// Allows mutable access to the columns in parallel using mutable references.
     /// If mutable access to the columns is not required rather use [`par_column_iter`]
     /// instead.
-    /// 
-    /// # Example 
+    ///
+    /// # Example
     /// Normalize each column of a matrix with respect to its own maximum value.
-    /// 
+    ///
     /// ```
     /// use nalgebra::{dmatrix,DMatrix};
     /// use rayon::prelude::*;

From 85a58ca9391ba3da073ccce58fc473d344798aa5 Mon Sep 17 00:00:00 2001
From: geo-ant <54497890+geo-ant@users.noreply.github.com>
Date: Sun, 13 Nov 2022 17:02:19 +0100
Subject: [PATCH 095/119] update CI workflow

---
 .github/workflows/nalgebra-ci-build.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/nalgebra-ci-build.yml b/.github/workflows/nalgebra-ci-build.yml
index d7027127..665bd008 100644
--- a/.github/workflows/nalgebra-ci-build.yml
+++ b/.github/workflows/nalgebra-ci-build.yml
@@ -61,7 +61,7 @@ jobs:
     steps:
       - uses: actions/checkout@v2
       - name: test
-        run: cargo test --features arbitrary,rand,serde-serialize,sparse,debug,io,compare,libm,proptest-support,slow-tests,rkyv-safe-deser,rayon;
+        run: cargo test --features arbitrary,rand,serde-serialize,sparse,debug,io,compare,libm,proptest-support,slow-tests,rkyv-safe-deser,par-iter;
   test-nalgebra-glm:
     runs-on: ubuntu-latest
     steps:

From 6fce1067760d576380872161da0fbf3c4f9ff84d Mon Sep 17 00:00:00 2001
From: geo-ant <54497890+geo-ant@users.noreply.github.com>
Date: Sun, 13 Nov 2022 17:10:57 +0100
Subject: [PATCH 096/119] restructure code for better docs

---
 src/base/par_iter.rs | 75 +++++++++++++++++++++-----------------------
 1 file changed, 35 insertions(+), 40 deletions(-)

diff --git a/src/base/par_iter.rs b/src/base/par_iter.rs
index 6e1eb53a..6ea3e468 100644
--- a/src/base/par_iter.rs
+++ b/src/base/par_iter.rs
@@ -72,44 +72,6 @@ where
     }
 }
 
-#[cfg_attr(doc_cfg, doc(cfg(feature = "par-iter")))]
-impl<T, R: Dim, Cols: Dim, S: RawStorage<T, R, Cols>> Matrix<T, R, Cols, S>
-where
-    T: Send + Sync + Scalar,
-    S: Sync,
-{
-    /// Iterate through the columns of the matrix in parallel using rayon.
-    /// This iterates over *immutable* references ot the columns of the matrix,
-    /// if *mutable* access to the columns is required, use [`par_column_iter_mut`]
-    /// instead.
-    ///
-    /// # Example
-    /// Using parallel column iterators to calculate the sum of the maximum
-    /// elements in each column:
-    /// ```
-    /// use nalgebra::{dmatrix,DMatrix};
-    /// use rayon::prelude::*;
-    ///
-    /// let matrix : DMatrix<f64> =
-    ///         nalgebra::dmatrix![1.,0.,5.;
-    ///                            2.,4.,1.;
-    ///                            3.,2.,2.;];
-    /// let sum_of_max :f64 =
-    ///         matrix
-    ///         .par_column_iter()
-    ///         .map(|col|col.max())
-    ///         .sum();
-    ///
-    /// assert_eq!(sum_of_max,3.+4.+5.);
-    ///                             
-    /// ```
-    ///
-    /// [`par_column_iter_mut`]: crate::Matrix::par_column_iter_mut
-    pub fn par_column_iter(&self) -> ParColumnIter<'_, T, R, Cols, S> {
-        ParColumnIter::new(self)
-    }
-}
-
 #[cfg_attr(doc_cfg, doc(cfg(feature = "par-iter")))]
 /// A rayon parallel iterator through the mutable columns of a matrix
 pub struct ParColumnIterMut<
@@ -184,12 +146,44 @@ where
 }
 
 #[cfg_attr(doc_cfg, doc(cfg(feature = "par-iter")))]
-impl<T, R: Dim, Cols: Dim, S: RawStorage<T, R, Cols> + RawStorageMut<T, R, Cols>>
+/// # Parallel iterators using `rayon`
+/// *Only availabe if compiled with the feature `par-iter`*
+impl<T, R: Dim, Cols: Dim, S: RawStorage<T, R, Cols>>
     Matrix<T, R, Cols, S>
 where
     T: Send + Sync + Scalar,
     S: Sync,
 {
+    /// Iterate through the columns of the matrix in parallel using rayon.
+    /// This iterates over *immutable* references ot the columns of the matrix,
+    /// if *mutable* access to the columns is required, use [`par_column_iter_mut`]
+    /// instead.
+    ///
+    /// # Example
+    /// Using parallel column iterators to calculate the sum of the maximum
+    /// elements in each column:
+    /// ```
+    /// use nalgebra::{dmatrix,DMatrix};
+    /// use rayon::prelude::*;
+    ///
+    /// let matrix : DMatrix<f64> =
+    ///         nalgebra::dmatrix![1.,0.,5.;
+    ///                            2.,4.,1.;
+    ///                            3.,2.,2.;];
+    /// let sum_of_max :f64 =
+    ///         matrix
+    ///         .par_column_iter()
+    ///         .map(|col|col.max())
+    ///         .sum();
+    ///
+    /// assert_eq!(sum_of_max,3.+4.+5.);
+    ///                             
+    /// ```
+    ///
+    /// [`par_column_iter_mut`]: crate::Matrix::par_column_iter_mut
+    pub fn par_column_iter(&self) -> ParColumnIter<'_, T, R, Cols, S> {
+        ParColumnIter::new(self)
+    }
     /// Mutably iterate through the columns of this matrix in parallel using rayon.
     /// Allows mutable access to the columns in parallel using mutable references.
     /// If mutable access to the columns is not required rather use [`par_column_iter`]
@@ -213,7 +207,8 @@ where
     /// ```
     ///
     /// [`par_column_iter`]: crate::Matrix::par_column_iter
-    pub fn par_column_iter_mut(&mut self) -> ParColumnIterMut<'_, T, R, Cols, S> {
+    pub fn par_column_iter_mut(&mut self) -> ParColumnIterMut<'_, T, R, Cols, S> 
+    where S: RawStorageMut<T, R, Cols>{
         ParColumnIterMut::new(self)
     }
 }

From ae5bca75f7a840cfc2fcc2930b37f2654cd31cde Mon Sep 17 00:00:00 2001
From: geo-ant <54497890+geo-ant@users.noreply.github.com>
Date: Sun, 13 Nov 2022 17:15:15 +0100
Subject: [PATCH 097/119] advertize the feature on the matrix front doc page

---
 src/base/matrix.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/base/matrix.rs b/src/base/matrix.rs
index 2d166d2a..f0fa8d81 100644
--- a/src/base/matrix.rs
+++ b/src/base/matrix.rs
@@ -100,7 +100,8 @@ pub type MatrixCross<T, R1, C1, R2, C2> =
 /// - [Find the min and max components (vector-specific methods) <span style="float:right;">`argmin`, `argmax`, `icamin`, `icamax`…</span>](#find-the-min-and-max-components-vector-specific-methods)
 ///
 /// #### Iteration, map, and fold
-/// - [Iteration on components, rows, and columns <span style="float:right;">`iter`, `column_iter`, `par_column_iter`…</span>](#iteration-on-components-rows-and-columns)
+/// - [Iteration on components, rows, and columns <span style="float:right;">`iter`, `column_iter`…</span>](#iteration-on-components-rows-and-columns)
+/// - [Parallel iterators using rayon <span style="float:right;">`par_column_iter`, `par_column_iter_mut`…</span>](#parallel-iterators-using-rayon)
 /// - [Elementwise mapping and folding <span style="float:right;">`map`, `fold`, `zip_map`…</span>](#elementwise-mapping-and-folding)
 /// - [Folding or columns and rows <span style="float:right;">`compress_rows`, `compress_columns`…</span>](#folding-on-columns-and-rows)
 ///

From 66dfaf824adec8784e0213ca99829452dd54bec5 Mon Sep 17 00:00:00 2001
From: geo-ant <54497890+geo-ant@users.noreply.github.com>
Date: Sun, 13 Nov 2022 17:18:02 +0100
Subject: [PATCH 098/119] formatting

---
 src/base/par_iter.rs | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/src/base/par_iter.rs b/src/base/par_iter.rs
index 6ea3e468..a0ba5ebb 100644
--- a/src/base/par_iter.rs
+++ b/src/base/par_iter.rs
@@ -148,8 +148,7 @@ where
 #[cfg_attr(doc_cfg, doc(cfg(feature = "par-iter")))]
 /// # Parallel iterators using `rayon`
 /// *Only availabe if compiled with the feature `par-iter`*
-impl<T, R: Dim, Cols: Dim, S: RawStorage<T, R, Cols>>
-    Matrix<T, R, Cols, S>
+impl<T, R: Dim, Cols: Dim, S: RawStorage<T, R, Cols>> Matrix<T, R, Cols, S>
 where
     T: Send + Sync + Scalar,
     S: Sync,
@@ -207,8 +206,10 @@ where
     /// ```
     ///
     /// [`par_column_iter`]: crate::Matrix::par_column_iter
-    pub fn par_column_iter_mut(&mut self) -> ParColumnIterMut<'_, T, R, Cols, S> 
-    where S: RawStorageMut<T, R, Cols>{
+    pub fn par_column_iter_mut(&mut self) -> ParColumnIterMut<'_, T, R, Cols, S>
+    where
+        S: RawStorageMut<T, R, Cols>,
+    {
         ParColumnIterMut::new(self)
     }
 }

From 296320bb74be806a797b3e3a0f01f189c2361957 Mon Sep 17 00:00:00 2001
From: geo-ant <54497890+geo-ant@users.noreply.github.com>
Date: Sun, 13 Nov 2022 17:20:21 +0100
Subject: [PATCH 099/119] indicate feature gating

---
 src/base/par_iter.rs | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/src/base/par_iter.rs b/src/base/par_iter.rs
index a0ba5ebb..19700c92 100644
--- a/src/base/par_iter.rs
+++ b/src/base/par_iter.rs
@@ -1,6 +1,6 @@
 //! Parallel iterators for matrices compatible with rayon.
 
-//only enables the `doc_cfg` feature when
+// only enables the `doc_cfg` feature when
 // the `docsrs` configuration attribute is defined
 #![cfg_attr(docsrs, feature(doc_cfg))]
 
@@ -12,7 +12,8 @@ use rayon::{iter::plumbing::bridge, prelude::*};
 
 /// A rayon parallel iterator over the colums of a matrix. It is created
 /// using the [`par_column_iter`] method of [`Matrix`].
-///
+/// 
+/// *only availabe if compiled with the feature `par-iter`*
 /// [`par_column_iter`]: crate::Matrix::par_column_iter
 /// [`Matrix`]: crate::Matrix
 #[cfg_attr(doc_cfg, doc(cfg(feature = "par-iter")))]
@@ -49,6 +50,7 @@ where
 }
 
 #[cfg_attr(doc_cfg, doc(cfg(feature = "par-iter")))]
+/// *only availabe if compiled with the feature `par-iter`*
 impl<'a, T, R: Dim, Cols: Dim, S: RawStorage<T, R, Cols>> IndexedParallelIterator
     for ParColumnIter<'a, T, R, Cols, S>
 where
@@ -74,6 +76,7 @@ where
 
 #[cfg_attr(doc_cfg, doc(cfg(feature = "par-iter")))]
 /// A rayon parallel iterator through the mutable columns of a matrix
+/// *only availabe if compiled with the feature `par-iter`*
 pub struct ParColumnIterMut<
     'a,
     T,
@@ -85,6 +88,7 @@ pub struct ParColumnIterMut<
 }
 
 #[cfg_attr(doc_cfg, doc(cfg(feature = "par-iter")))]
+/// *only availabe if compiled with the feature `par-iter`*
 impl<'a, T, R, Cols, S> ParColumnIterMut<'a, T, R, Cols, S>
 where
     R: Dim,
@@ -98,6 +102,7 @@ where
 }
 
 #[cfg_attr(doc_cfg, doc(cfg(feature = "par-iter")))]
+/// *only availabe if compiled with the feature `par-iter`*
 impl<'a, T, R, Cols, S> ParallelIterator for ParColumnIterMut<'a, T, R, Cols, S>
 where
     R: Dim,
@@ -120,6 +125,7 @@ where
 }
 
 #[cfg_attr(doc_cfg, doc(cfg(feature = "par-iter")))]
+/// *only availabe if compiled with the feature `par-iter`*
 impl<'a, T, R, Cols, S> IndexedParallelIterator for ParColumnIterMut<'a, T, R, Cols, S>
 where
     R: Dim,

From 9cc7cc121f0c03c525c08fe171cd6de8f09ee2c8 Mon Sep 17 00:00:00 2001
From: geo-ant <54497890+geo-ant@users.noreply.github.com>
Date: Sun, 13 Nov 2022 17:23:43 +0100
Subject: [PATCH 100/119] mention feature gating

---
 src/base/iter.rs | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/src/base/iter.rs b/src/base/iter.rs
index 220eadd8..8f34dbc9 100644
--- a/src/base/iter.rs
+++ b/src/base/iter.rs
@@ -1,5 +1,9 @@
 //! Matrix iterators.
 
+// only enables the `doc_cfg` feature when
+// the `docsrs` configuration attribute is defined
+#![cfg_attr(docsrs, feature(doc_cfg))]
+
 use core::fmt::Debug;
 use core::ops::Range;
 use std::iter::FusedIterator;
@@ -445,6 +449,8 @@ mod parallel {
     use super::*;
     use rayon::iter::plumbing::Producer;
 
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "par-iter")))]
+    /// *only available if compiled with the feature `par-iter`*
     impl<'a, T, R: Dim, Cols: Dim, S: RawStorage<T, R, Cols>> Producer for ColumnIter<'a, T, R, Cols, S>
     where
         T: Send + Sync + Scalar,
@@ -473,6 +479,8 @@ mod parallel {
         }
     }
 
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "par-iter")))]
+    /// *only available if compiled with the feature `par-iter`*
     impl<'a, T, R: Dim, C: Dim, S: 'a + RawStorageMut<T, R, C>> Producer
         for ColumnIterMut<'a, T, R, C, S>
     where

From 93f2c6c125a58f80199999c54722ae93e6d502ad Mon Sep 17 00:00:00 2001
From: geo-ant <54497890+geo-ant@users.noreply.github.com>
Date: Thu, 24 Nov 2022 08:29:30 +0100
Subject: [PATCH 101/119] fix format

---
 src/base/par_iter.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/base/par_iter.rs b/src/base/par_iter.rs
index 19700c92..7d943e40 100644
--- a/src/base/par_iter.rs
+++ b/src/base/par_iter.rs
@@ -12,7 +12,7 @@ use rayon::{iter::plumbing::bridge, prelude::*};
 
 /// A rayon parallel iterator over the colums of a matrix. It is created
 /// using the [`par_column_iter`] method of [`Matrix`].
-/// 
+///
 /// *only availabe if compiled with the feature `par-iter`*
 /// [`par_column_iter`]: crate::Matrix::par_column_iter
 /// [`Matrix`]: crate::Matrix

From 7b9b123301da855b0776338e0c0d8c18cfa0e761 Mon Sep 17 00:00:00 2001
From: geo-ant <54497890+geo-ant@users.noreply.github.com>
Date: Sun, 27 Nov 2022 15:37:17 +0100
Subject: [PATCH 102/119] add test, find bug, add another test

---
 src/base/iter.rs     |  3 ++-
 tests/core/matrix.rs | 27 +++++++++++++++++++++++++++
 2 files changed, 29 insertions(+), 1 deletion(-)

diff --git a/src/base/iter.rs b/src/base/iter.rs
index 8f34dbc9..90a1607f 100644
--- a/src/base/iter.rs
+++ b/src/base/iter.rs
@@ -397,7 +397,8 @@ impl<'a, T, R: Dim, C: Dim, S: 'a + RawStorageMut<T, R, C>> Iterator
 
     #[inline]
     fn next(&'_ mut self) -> Option<Self::Item> {
-        if self.range.start < self.ncols() {
+        debug_assert!(self.range.start <= self.range.end);
+        if self.range.start < self.range.end {
             let res = unsafe { (*self.mat).column_mut(self.range.start) };
             self.range.start += 1;
             Some(res)
diff --git a/tests/core/matrix.rs b/tests/core/matrix.rs
index 603897af..29da1188 100644
--- a/tests/core/matrix.rs
+++ b/tests/core/matrix.rs
@@ -1199,6 +1199,24 @@ fn column_iteration_double_ended() {
     assert_eq!(col_iter.next(), None);
 }
 
+#[test]
+fn column_iterator_double_ended_mut() {
+    let mut dmat = nalgebra::dmatrix![
+    13,14,15,16,17;
+    23,24,25,26,27;
+    33,34,35,36,37;
+    ];
+    let mut cloned = dmat.clone();
+    let mut col_iter_mut = dmat.column_iter_mut();
+    assert_eq!(col_iter_mut.next(), Some(cloned.column_mut(0)));
+    assert_eq!(col_iter_mut.next(), Some(cloned.column_mut(1)));
+    assert_eq!(col_iter_mut.next_back(), Some(cloned.column_mut(4)));
+    assert_eq!(col_iter_mut.next_back(), Some(cloned.column_mut(3)));
+    assert_eq!(col_iter_mut.next(), Some(cloned.column_mut(2)));
+    assert_eq!(col_iter_mut.next_back(), None);
+    assert_eq!(col_iter_mut.next(), None);
+}
+
 #[test]
 #[cfg(feature = "par-iter")]
 fn parallel_column_iteration() {
@@ -1219,6 +1237,15 @@ fn parallel_column_iteration() {
     let par_result: f64 = dmat.par_column_iter().map(|col| col.norm()).sum();
     let ser_result: f64 = dmat.column_iter().map(|col| col.norm()).sum();
     assert_eq!(par_result, ser_result);
+    
+    // repeat this test using mutable iterators
+    let mut dmat = dmat;
+    dmat.par_column_iter_mut().enumerate().for_each(|(idx, col)| {
+        assert_eq!(col, cloned.column(idx));
+    });
+
+    let par_mut_result: f64 = dmat.par_column_iter_mut().map(|col| col.norm()).sum();
+    assert_eq!(par_mut_result,ser_result);
 }
 
 #[test]

From 61abece7af1cd02fabd40258e3347d54a80ab29c Mon Sep 17 00:00:00 2001
From: geo-ant <54497890+geo-ant@users.noreply.github.com>
Date: Sun, 27 Nov 2022 16:51:25 +0100
Subject: [PATCH 103/119] create separate newtype for producer trait

---
 src/base/iter.rs     | 88 +++-----------------------------------------
 src/base/par_iter.rs | 86 ++++++++++++++++++++++++++++++++++++++++++-
 2 files changed, 89 insertions(+), 85 deletions(-)

diff --git a/src/base/iter.rs b/src/base/iter.rs
index 90a1607f..fc6bd664 100644
--- a/src/base/iter.rs
+++ b/src/base/iter.rs
@@ -301,8 +301,8 @@ impl<'a, T: Scalar, R: Dim, C: Dim, S: 'a + RawStorageMut<T, R, C>> ExactSizeIte
 #[derive(Clone, Debug)]
 /// An iterator through the columns of a matrix.
 pub struct ColumnIter<'a, T, R: Dim, C: Dim, S: RawStorage<T, R, C>> {
-    mat: &'a Matrix<T, R, C, S>,
-    range: Range<usize>,
+    pub(crate) mat: &'a Matrix<T, R, C, S>,
+    pub(crate) range: Range<usize>,
 }
 
 impl<'a, T, R: Dim, C: Dim, S: 'a + RawStorage<T, R, C>> ColumnIter<'a, T, R, C, S> {
@@ -370,9 +370,9 @@ impl<'a, T: Scalar, R: Dim, C: Dim, S: 'a + RawStorage<T, R, C>> ExactSizeIterat
 /// An iterator through the mutable columns of a matrix.
 #[derive(Debug)]
 pub struct ColumnIterMut<'a, T, R: Dim, C: Dim, S: RawStorageMut<T, R, C>> {
-    mat: *mut Matrix<T, R, C, S>,
-    phantom: PhantomData<&'a mut Matrix<T, R, C, S>>,
-    range: Range<usize>,
+    pub(crate) mat: *mut Matrix<T, R, C, S>,
+    pub(crate) range: Range<usize>,
+    pub(crate) phantom: PhantomData<&'a mut Matrix<T, R, C, S>>,
 }
 
 impl<'a, T, R: Dim, C: Dim, S: 'a + RawStorageMut<T, R, C>> ColumnIterMut<'a, T, R, C, S> {
@@ -443,81 +443,3 @@ impl<'a, T: Scalar, R: Dim, C: Dim, S: 'a + RawStorageMut<T, R, C>> DoubleEndedI
         }
     }
 }
-
-/// implementations for parallel iteration with rayon
-#[cfg(feature = "par-iter")]
-mod parallel {
-    use super::*;
-    use rayon::iter::plumbing::Producer;
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "par-iter")))]
-    /// *only available if compiled with the feature `par-iter`*
-    impl<'a, T, R: Dim, Cols: Dim, S: RawStorage<T, R, Cols>> Producer for ColumnIter<'a, T, R, Cols, S>
-    where
-        T: Send + Sync + Scalar,
-        S: Sync,
-    {
-        type Item = MatrixSlice<'a, T, R, U1, S::RStride, S::CStride>;
-        type IntoIter = ColumnIter<'a, T, R, Cols, S>;
-
-        fn split_at(self, index: usize) -> (Self, Self) {
-            // the index is relative to the size of this current iterator
-            // it will always start at zero so it serves as an offset
-            let left = Self {
-                mat: self.mat,
-                range: self.range.start..(self.range.start + index),
-            };
-
-            let right = Self {
-                mat: self.mat,
-                range: (self.range.start + index)..self.range.end,
-            };
-            (left, right)
-        }
-
-        fn into_iter(self) -> Self::IntoIter {
-            self
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "par-iter")))]
-    /// *only available if compiled with the feature `par-iter`*
-    impl<'a, T, R: Dim, C: Dim, S: 'a + RawStorageMut<T, R, C>> Producer
-        for ColumnIterMut<'a, T, R, C, S>
-    where
-        T: Send + Sync + Scalar,
-        S: Send + Sync,
-    {
-        type Item = MatrixSliceMut<'a, T, R, U1, S::RStride, S::CStride>;
-        type IntoIter = ColumnIterMut<'a, T, R, C, S>;
-
-        fn into_iter(self) -> Self::IntoIter {
-            self
-        }
-
-        fn split_at(self, index: usize) -> (Self, Self) {
-            // the index is relative to the size of this current iterator
-            // it will always start at zero so it serves as an offset
-
-            let left = Self {
-                mat: self.mat,
-                range: self.range.start..(self.range.start + index),
-                phantom: Default::default(),
-            };
-
-            let right = Self {
-                mat: self.mat,
-                range: (self.range.start + index)..self.range.end,
-                phantom: Default::default(),
-            };
-            (left, right)
-        }
-    }
-
-    /// this implementation is safe because we are enforcing exclusive access
-    /// to the columns through the active range of the iterator
-    unsafe impl<'a, T: Scalar, R: Dim, C: Dim, S: 'a + RawStorageMut<T, R, C>> Send
-        for ColumnIterMut<'a, T, R, C, S>
-    {
-    }
-}
diff --git a/src/base/par_iter.rs b/src/base/par_iter.rs
index 7d943e40..46e3c607 100644
--- a/src/base/par_iter.rs
+++ b/src/base/par_iter.rs
@@ -9,6 +9,7 @@ use crate::{
     Dim, Matrix, MatrixSlice, MatrixSliceMut, RawStorage, RawStorageMut, Scalar, U1,
 };
 use rayon::{iter::plumbing::bridge, prelude::*};
+use rayon::iter::plumbing::Producer;
 
 /// A rayon parallel iterator over the colums of a matrix. It is created
 /// using the [`par_column_iter`] method of [`Matrix`].
@@ -69,7 +70,7 @@ where
         self,
         callback: CB,
     ) -> CB::Output {
-        let producer = ColumnIter::new(self.mat);
+        let producer = ColumnProducer(ColumnIter::new(self.mat));
         callback.callback(producer)
     }
 }
@@ -146,7 +147,7 @@ where
         self,
         callback: CB,
     ) -> CB::Output {
-        let producer = ColumnIterMut::new(self.mat);
+        let producer = ColumnProducerMut(ColumnIterMut::new(self.mat));
         callback.callback(producer)
     }
 }
@@ -219,3 +220,84 @@ where
         ParColumnIterMut::new(self)
     }
 }
+
+/// a private helper newtype that wraps the `ColumnIter` and implements
+/// the rayon `Producer` trait. It's just here so we don't have to make the
+/// rayon trait part of the public interface of the `ColumnIter`
+struct ColumnProducer<'a,T,R:Dim,C:Dim,S:RawStorage<T,R,C>>(ColumnIter<'a,T,R,C,S>); 
+
+#[cfg_attr(doc_cfg, doc(cfg(feature = "par-iter")))]
+/// *only available if compiled with the feature `par-iter`*
+impl<'a, T, R: Dim, Cols: Dim, S: RawStorage<T, R, Cols>> Producer for ColumnProducer<'a, T, R, Cols, S>
+where
+T: Send + Sync + Scalar,
+S: Sync,
+{
+    type Item = MatrixSlice<'a, T, R, U1, S::RStride, S::CStride>;
+    type IntoIter = ColumnIter<'a, T, R, Cols, S>;
+    
+    #[inline]
+    fn split_at(self, index: usize) -> (Self, Self) {
+        // the index is relative to the size of this current iterator
+        // it will always start at zero so it serves as an offset
+        let left_iter = ColumnIter {
+            mat: self.0.mat,
+            range: self.0.range.start..(self.0.range.start + index),
+        };
+
+        let right_iter = ColumnIter {
+            mat: self.0.mat,
+            range: (self.0.range.start + index)..self.0.range.end,
+        };
+        (Self(left_iter), Self(right_iter))
+    }
+
+    #[inline]   
+    fn into_iter(self) -> Self::IntoIter {
+        self.0
+    }
+}
+
+/// See `ColumnProducer`. A private wrapper newtype that keeps the Producer
+/// implementation private
+struct ColumnProducerMut<'a, T, R: Dim, C: Dim, S: RawStorageMut<T, R, C>>(ColumnIterMut<'a,T,R,C,S>);
+
+impl<'a, T, R: Dim, C: Dim, S: 'a + RawStorageMut<T, R, C>> Producer
+for ColumnProducerMut<'a, T, R, C, S>
+where
+T: Send + Sync + Scalar,
+S: Send + Sync,
+{
+    type Item = MatrixSliceMut<'a, T, R, U1, S::RStride, S::CStride>;
+    type IntoIter = ColumnIterMut<'a, T, R, C, S>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.0
+    }
+
+    fn split_at(self, index: usize) -> (Self, Self) {
+        // the index is relative to the size of this current iterator
+        // it will always start at zero so it serves as an offset
+
+        let left_iter = ColumnIterMut {
+            mat: self.0.mat,
+            range: self.0.range.start..(self.0.range.start + index),
+            phantom: Default::default(),
+        };
+
+        let right_iter = ColumnIterMut {
+            mat: self.0.mat,
+            range: (self.0.range.start + index)..self.0.range.end,
+            phantom: Default::default(),
+        };
+        (Self(left_iter), Self(right_iter))
+    }
+}
+
+
+/// this implementation is safe because we are enforcing exclusive access
+/// to the columns through the active range of the iterator
+unsafe impl<'a, T: Scalar, R: Dim, C: Dim, S: 'a + RawStorageMut<T, R, C>> Send
+for ColumnIterMut<'a, T, R, C, S>
+{
+}

From 50e25c57f7c82745cba061a95cbbbb527a1dc4e8 Mon Sep 17 00:00:00 2001
From: geo-ant <54497890+geo-ant@users.noreply.github.com>
Date: Sun, 27 Nov 2022 16:51:45 +0100
Subject: [PATCH 104/119] fmt

---
 src/base/par_iter.rs | 28 +++++++++++++++-------------
 tests/core/matrix.rs | 12 +++++++-----
 2 files changed, 22 insertions(+), 18 deletions(-)

diff --git a/src/base/par_iter.rs b/src/base/par_iter.rs
index 46e3c607..c50ba53f 100644
--- a/src/base/par_iter.rs
+++ b/src/base/par_iter.rs
@@ -8,8 +8,8 @@ use crate::{
     iter::{ColumnIter, ColumnIterMut},
     Dim, Matrix, MatrixSlice, MatrixSliceMut, RawStorage, RawStorageMut, Scalar, U1,
 };
-use rayon::{iter::plumbing::bridge, prelude::*};
 use rayon::iter::plumbing::Producer;
+use rayon::{iter::plumbing::bridge, prelude::*};
 
 /// A rayon parallel iterator over the colums of a matrix. It is created
 /// using the [`par_column_iter`] method of [`Matrix`].
@@ -224,18 +224,19 @@ where
 /// a private helper newtype that wraps the `ColumnIter` and implements
 /// the rayon `Producer` trait. It's just here so we don't have to make the
 /// rayon trait part of the public interface of the `ColumnIter`
-struct ColumnProducer<'a,T,R:Dim,C:Dim,S:RawStorage<T,R,C>>(ColumnIter<'a,T,R,C,S>); 
+struct ColumnProducer<'a, T, R: Dim, C: Dim, S: RawStorage<T, R, C>>(ColumnIter<'a, T, R, C, S>);
 
 #[cfg_attr(doc_cfg, doc(cfg(feature = "par-iter")))]
 /// *only available if compiled with the feature `par-iter`*
-impl<'a, T, R: Dim, Cols: Dim, S: RawStorage<T, R, Cols>> Producer for ColumnProducer<'a, T, R, Cols, S>
+impl<'a, T, R: Dim, Cols: Dim, S: RawStorage<T, R, Cols>> Producer
+    for ColumnProducer<'a, T, R, Cols, S>
 where
-T: Send + Sync + Scalar,
-S: Sync,
+    T: Send + Sync + Scalar,
+    S: Sync,
 {
     type Item = MatrixSlice<'a, T, R, U1, S::RStride, S::CStride>;
     type IntoIter = ColumnIter<'a, T, R, Cols, S>;
-    
+
     #[inline]
     fn split_at(self, index: usize) -> (Self, Self) {
         // the index is relative to the size of this current iterator
@@ -252,7 +253,7 @@ S: Sync,
         (Self(left_iter), Self(right_iter))
     }
 
-    #[inline]   
+    #[inline]
     fn into_iter(self) -> Self::IntoIter {
         self.0
     }
@@ -260,13 +261,15 @@ S: Sync,
 
 /// See `ColumnProducer`. A private wrapper newtype that keeps the Producer
 /// implementation private
-struct ColumnProducerMut<'a, T, R: Dim, C: Dim, S: RawStorageMut<T, R, C>>(ColumnIterMut<'a,T,R,C,S>);
+struct ColumnProducerMut<'a, T, R: Dim, C: Dim, S: RawStorageMut<T, R, C>>(
+    ColumnIterMut<'a, T, R, C, S>,
+);
 
 impl<'a, T, R: Dim, C: Dim, S: 'a + RawStorageMut<T, R, C>> Producer
-for ColumnProducerMut<'a, T, R, C, S>
+    for ColumnProducerMut<'a, T, R, C, S>
 where
-T: Send + Sync + Scalar,
-S: Send + Sync,
+    T: Send + Sync + Scalar,
+    S: Send + Sync,
 {
     type Item = MatrixSliceMut<'a, T, R, U1, S::RStride, S::CStride>;
     type IntoIter = ColumnIterMut<'a, T, R, C, S>;
@@ -294,10 +297,9 @@ S: Send + Sync,
     }
 }
 
-
 /// this implementation is safe because we are enforcing exclusive access
 /// to the columns through the active range of the iterator
 unsafe impl<'a, T: Scalar, R: Dim, C: Dim, S: 'a + RawStorageMut<T, R, C>> Send
-for ColumnIterMut<'a, T, R, C, S>
+    for ColumnIterMut<'a, T, R, C, S>
 {
 }
diff --git a/tests/core/matrix.rs b/tests/core/matrix.rs
index 29da1188..41972347 100644
--- a/tests/core/matrix.rs
+++ b/tests/core/matrix.rs
@@ -1237,15 +1237,17 @@ fn parallel_column_iteration() {
     let par_result: f64 = dmat.par_column_iter().map(|col| col.norm()).sum();
     let ser_result: f64 = dmat.column_iter().map(|col| col.norm()).sum();
     assert_eq!(par_result, ser_result);
-    
+
     // repeat this test using mutable iterators
     let mut dmat = dmat;
-    dmat.par_column_iter_mut().enumerate().for_each(|(idx, col)| {
-        assert_eq!(col, cloned.column(idx));
-    });
+    dmat.par_column_iter_mut()
+        .enumerate()
+        .for_each(|(idx, col)| {
+            assert_eq!(col, cloned.column(idx));
+        });
 
     let par_mut_result: f64 = dmat.par_column_iter_mut().map(|col| col.norm()).sum();
-    assert_eq!(par_mut_result,ser_result);
+    assert_eq!(par_mut_result, ser_result);
 }
 
 #[test]

From 997c707be9a75f6fd5c25ee1a4f3d853951f395e Mon Sep 17 00:00:00 2001
From: geo-ant <54497890+geo-ant@users.noreply.github.com>
Date: Sun, 27 Nov 2022 17:05:46 +0100
Subject: [PATCH 105/119] upgrade rayon dependency

---
 Cargo.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Cargo.toml b/Cargo.toml
index cee3130c..e7c6ba1e 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -102,7 +102,7 @@ glam020        = { package = "glam", version = "0.20", optional = true }
 glam021        = { package = "glam", version = "0.21", optional = true }
 glam022        = { package = "glam", version = "0.22", optional = true }
 cust_core      = { version = "0.1", optional = true }
-rayon          = { version = "1.5", optional = true }
+rayon          = { version = "1.6", optional = true }
 
 [dev-dependencies]
 serde_json = "1.0"

From 5e26b8e121d201e13a7e8969567e16c84cf39b4a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=A9bastien=20Crozet?= <developer@crozet.re>
Date: Sat, 14 Jan 2023 12:19:36 +0100
Subject: [PATCH 106/119] Remove unused import

---
 src/base/iter.rs     |  1 -
 src/base/par_iter.rs | 10 +++++-----
 2 files changed, 5 insertions(+), 6 deletions(-)

diff --git a/src/base/iter.rs b/src/base/iter.rs
index fc6bd664..4b9536ed 100644
--- a/src/base/iter.rs
+++ b/src/base/iter.rs
@@ -13,7 +13,6 @@ use std::mem;
 use crate::base::dimension::{Dim, U1};
 use crate::base::storage::{RawStorage, RawStorageMut};
 use crate::base::{Matrix, MatrixView, MatrixViewMut, Scalar};
-use crate::{DMatrix, DimMax};
 
 macro_rules! iterator {
     (struct $Name:ident for $Storage:ident.$ptr: ident -> $Ptr:ty, $Ref:ty, $SRef: ty) => {
diff --git a/src/base/par_iter.rs b/src/base/par_iter.rs
index c50ba53f..2a8ca268 100644
--- a/src/base/par_iter.rs
+++ b/src/base/par_iter.rs
@@ -6,7 +6,7 @@
 
 use crate::{
     iter::{ColumnIter, ColumnIterMut},
-    Dim, Matrix, MatrixSlice, MatrixSliceMut, RawStorage, RawStorageMut, Scalar, U1,
+    Dim, Matrix, MatrixView, MatrixViewMut, RawStorage, RawStorageMut, Scalar, U1,
 };
 use rayon::iter::plumbing::Producer;
 use rayon::{iter::plumbing::bridge, prelude::*};
@@ -36,7 +36,7 @@ where
     T: Sync + Send + Scalar,
     S: Sync,
 {
-    type Item = MatrixSlice<'a, T, R, U1, S::RStride, S::CStride>;
+    type Item = MatrixView<'a, T, R, U1, S::RStride, S::CStride>;
 
     fn drive_unindexed<Consumer>(self, consumer: Consumer) -> Consumer::Result
     where
@@ -112,7 +112,7 @@ where
     T: Send + Sync + Scalar,
     S: Send + Sync,
 {
-    type Item = MatrixSliceMut<'a, T, R, U1, S::RStride, S::CStride>;
+    type Item = MatrixViewMut<'a, T, R, U1, S::RStride, S::CStride>;
     fn drive_unindexed<C>(self, consumer: C) -> C::Result
     where
         C: rayon::iter::plumbing::UnindexedConsumer<Self::Item>,
@@ -234,7 +234,7 @@ where
     T: Send + Sync + Scalar,
     S: Sync,
 {
-    type Item = MatrixSlice<'a, T, R, U1, S::RStride, S::CStride>;
+    type Item = MatrixView<'a, T, R, U1, S::RStride, S::CStride>;
     type IntoIter = ColumnIter<'a, T, R, Cols, S>;
 
     #[inline]
@@ -271,7 +271,7 @@ where
     T: Send + Sync + Scalar,
     S: Send + Sync,
 {
-    type Item = MatrixSliceMut<'a, T, R, U1, S::RStride, S::CStride>;
+    type Item = MatrixViewMut<'a, T, R, U1, S::RStride, S::CStride>;
     type IntoIter = ColumnIterMut<'a, T, R, C, S>;
 
     fn into_iter(self) -> Self::IntoIter {

From ff88fad23cf92fe6ca56516deccc5c1784971773 Mon Sep 17 00:00:00 2001
From: Hennadii Chernyshchyk <genaloner@gmail.com>
Date: Sat, 14 Jan 2023 13:24:04 +0200
Subject: [PATCH 107/119] Remove redundant `T::SimdRealField: Zero`

---
 src/linalg/cholesky.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/linalg/cholesky.rs b/src/linalg/cholesky.rs
index eda64134..2ff22914 100644
--- a/src/linalg/cholesky.rs
+++ b/src/linalg/cholesky.rs
@@ -41,7 +41,6 @@ where
 impl<T: SimdComplexField, D: Dim> Cholesky<T, D>
 where
     DefaultAllocator: Allocator<T, D, D>,
-    T::SimdRealField: Zero,
 {
     /// Computes the Cholesky decomposition of `matrix` without checking that the matrix is definite-positive.
     ///

From 1f4ded0c504941603c3a2243c1c06c192a5993c8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=A9bastien=20Crozet?= <developer@crozet.re>
Date: Sat, 14 Jan 2023 15:30:00 +0100
Subject: [PATCH 108/119] =?UTF-8?q?Don=E2=80=99t=20make=20the=20ColumnIter?=
 =?UTF-8?q?[Mut]=20fields=20pub(crate)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/base/iter.rs     | 46 ++++++++++++++++++++++++++++----
 src/base/par_iter.rs | 62 ++++++++++++++++----------------------------
 tests/lib.rs         |  4 ---
 3 files changed, 63 insertions(+), 49 deletions(-)

diff --git a/src/base/iter.rs b/src/base/iter.rs
index 4b9536ed..f213f096 100644
--- a/src/base/iter.rs
+++ b/src/base/iter.rs
@@ -300,8 +300,8 @@ impl<'a, T: Scalar, R: Dim, C: Dim, S: 'a + RawStorageMut<T, R, C>> ExactSizeIte
 #[derive(Clone, Debug)]
 /// An iterator through the columns of a matrix.
 pub struct ColumnIter<'a, T, R: Dim, C: Dim, S: RawStorage<T, R, C>> {
-    pub(crate) mat: &'a Matrix<T, R, C, S>,
-    pub(crate) range: Range<usize>,
+    mat: &'a Matrix<T, R, C, S>,
+    range: Range<usize>,
 }
 
 impl<'a, T, R: Dim, C: Dim, S: 'a + RawStorage<T, R, C>> ColumnIter<'a, T, R, C, S> {
@@ -312,6 +312,22 @@ impl<'a, T, R: Dim, C: Dim, S: 'a + RawStorage<T, R, C>> ColumnIter<'a, T, R, C,
             range: 0..mat.ncols(),
         }
     }
+
+    pub(crate) fn split_at(self, index: usize) -> (Self, Self) {
+        // SAFETY: it’s OK even if index > self.range.len() because
+        //         the iterations will yield None in this case.
+        let left_iter = ColumnIter {
+            mat: self.mat,
+            range: self.range.start..(self.range.start + index),
+        };
+
+        let right_iter = ColumnIter {
+            mat: self.mat,
+            range: (self.range.start + index)..self.range.end,
+        };
+
+        (left_iter, right_iter)
+    }
 }
 
 impl<'a, T, R: Dim, C: Dim, S: 'a + RawStorage<T, R, C>> Iterator for ColumnIter<'a, T, R, C, S> {
@@ -369,9 +385,9 @@ impl<'a, T: Scalar, R: Dim, C: Dim, S: 'a + RawStorage<T, R, C>> ExactSizeIterat
 /// An iterator through the mutable columns of a matrix.
 #[derive(Debug)]
 pub struct ColumnIterMut<'a, T, R: Dim, C: Dim, S: RawStorageMut<T, R, C>> {
-    pub(crate) mat: *mut Matrix<T, R, C, S>,
-    pub(crate) range: Range<usize>,
-    pub(crate) phantom: PhantomData<&'a mut Matrix<T, R, C, S>>,
+    mat: *mut Matrix<T, R, C, S>,
+    range: Range<usize>,
+    phantom: PhantomData<&'a mut Matrix<T, R, C, S>>,
 }
 
 impl<'a, T, R: Dim, C: Dim, S: 'a + RawStorageMut<T, R, C>> ColumnIterMut<'a, T, R, C, S> {
@@ -384,6 +400,26 @@ impl<'a, T, R: Dim, C: Dim, S: 'a + RawStorageMut<T, R, C>> ColumnIterMut<'a, T,
         }
     }
 
+    pub(crate) fn split_at(self, index: usize) -> (Self, Self) {
+        // SAFETY: it’s OK even if index > self.range.len() because
+        //         the iterations will yield None in this case.
+        assert!(index <= self.range.len());
+
+        let left_iter = ColumnIterMut {
+            mat: self.mat,
+            range: self.range.start..(self.range.start + index),
+            phantom: Default::default(),
+        };
+
+        let right_iter = ColumnIterMut {
+            mat: self.mat,
+            range: (self.range.start + index)..self.range.end,
+            phantom: Default::default(),
+        };
+
+        (left_iter, right_iter)
+    }
+
     fn ncols(&self) -> usize {
         unsafe { (*self.mat).ncols() }
     }
diff --git a/src/base/par_iter.rs b/src/base/par_iter.rs
index 2a8ca268..820c408a 100644
--- a/src/base/par_iter.rs
+++ b/src/base/par_iter.rs
@@ -14,7 +14,7 @@ use rayon::{iter::plumbing::bridge, prelude::*};
 /// A rayon parallel iterator over the colums of a matrix. It is created
 /// using the [`par_column_iter`] method of [`Matrix`].
 ///
-/// *only availabe if compiled with the feature `par-iter`*
+/// *Only available if compiled with the feature `par-iter`.*
 /// [`par_column_iter`]: crate::Matrix::par_column_iter
 /// [`Matrix`]: crate::Matrix
 #[cfg_attr(doc_cfg, doc(cfg(feature = "par-iter")))]
@@ -23,7 +23,7 @@ pub struct ParColumnIter<'a, T, R: Dim, Cols: Dim, S: RawStorage<T, R, Cols>> {
 }
 
 impl<'a, T, R: Dim, Cols: Dim, S: RawStorage<T, R, Cols>> ParColumnIter<'a, T, R, Cols, S> {
-    /// create a new parallel iterator for the given matrix
+    /// Create a new parallel iterator for the given matrix.
     fn new(matrix: &'a Matrix<T, R, Cols, S>) -> Self {
         Self { mat: matrix }
     }
@@ -51,7 +51,7 @@ where
 }
 
 #[cfg_attr(doc_cfg, doc(cfg(feature = "par-iter")))]
-/// *only availabe if compiled with the feature `par-iter`*
+/// *Only available if compiled with the feature `par-iter`.*
 impl<'a, T, R: Dim, Cols: Dim, S: RawStorage<T, R, Cols>> IndexedParallelIterator
     for ParColumnIter<'a, T, R, Cols, S>
 where
@@ -76,8 +76,8 @@ where
 }
 
 #[cfg_attr(doc_cfg, doc(cfg(feature = "par-iter")))]
-/// A rayon parallel iterator through the mutable columns of a matrix
-/// *only availabe if compiled with the feature `par-iter`*
+/// A rayon parallel iterator through the mutable columns of a matrix.
+/// *Only available if compiled with the feature `par-iter`.*
 pub struct ParColumnIterMut<
     'a,
     T,
@@ -96,14 +96,14 @@ where
     Cols: Dim,
     S: RawStorage<T, R, Cols> + RawStorageMut<T, R, Cols>,
 {
-    /// create a new parallel iterator for the given matrix
+    /// create a new parallel iterator for the given matrix.
     fn new(mat: &'a mut Matrix<T, R, Cols, S>) -> Self {
         Self { mat }
     }
 }
 
 #[cfg_attr(doc_cfg, doc(cfg(feature = "par-iter")))]
-/// *only availabe if compiled with the feature `par-iter`*
+/// *Only available if compiled with the feature `par-iter`*
 impl<'a, T, R, Cols, S> ParallelIterator for ParColumnIterMut<'a, T, R, Cols, S>
 where
     R: Dim,
@@ -126,7 +126,7 @@ where
 }
 
 #[cfg_attr(doc_cfg, doc(cfg(feature = "par-iter")))]
-/// *only availabe if compiled with the feature `par-iter`*
+/// *Only available if compiled with the feature `par-iter`*
 impl<'a, T, R, Cols, S> IndexedParallelIterator for ParColumnIterMut<'a, T, R, Cols, S>
 where
     R: Dim,
@@ -154,7 +154,7 @@ where
 
 #[cfg_attr(doc_cfg, doc(cfg(feature = "par-iter")))]
 /// # Parallel iterators using `rayon`
-/// *Only availabe if compiled with the feature `par-iter`*
+/// *Only available if compiled with the feature `par-iter`*
 impl<T, R: Dim, Cols: Dim, S: RawStorage<T, R, Cols>> Matrix<T, R, Cols, S>
 where
     T: Send + Sync + Scalar,
@@ -190,6 +190,7 @@ where
     pub fn par_column_iter(&self) -> ParColumnIter<'_, T, R, Cols, S> {
         ParColumnIter::new(self)
     }
+
     /// Mutably iterate through the columns of this matrix in parallel using rayon.
     /// Allows mutable access to the columns in parallel using mutable references.
     /// If mutable access to the columns is not required rather use [`par_column_iter`]
@@ -221,9 +222,9 @@ where
     }
 }
 
-/// a private helper newtype that wraps the `ColumnIter` and implements
+/// A private helper newtype that wraps the `ColumnIter` and implements
 /// the rayon `Producer` trait. It's just here so we don't have to make the
-/// rayon trait part of the public interface of the `ColumnIter`
+/// rayon trait part of the public interface of the `ColumnIter`.
 struct ColumnProducer<'a, T, R: Dim, C: Dim, S: RawStorage<T, R, C>>(ColumnIter<'a, T, R, C, S>);
 
 #[cfg_attr(doc_cfg, doc(cfg(feature = "par-iter")))]
@@ -238,24 +239,16 @@ where
     type IntoIter = ColumnIter<'a, T, R, Cols, S>;
 
     #[inline]
-    fn split_at(self, index: usize) -> (Self, Self) {
-        // the index is relative to the size of this current iterator
-        // it will always start at zero so it serves as an offset
-        let left_iter = ColumnIter {
-            mat: self.0.mat,
-            range: self.0.range.start..(self.0.range.start + index),
-        };
-
-        let right_iter = ColumnIter {
-            mat: self.0.mat,
-            range: (self.0.range.start + index)..self.0.range.end,
-        };
-        (Self(left_iter), Self(right_iter))
+    fn into_iter(self) -> Self::IntoIter {
+        self.0
     }
 
     #[inline]
-    fn into_iter(self) -> Self::IntoIter {
-        self.0
+    fn split_at(self, index: usize) -> (Self, Self) {
+        // The index is relative to the size of this current iterator.
+        // It will always start at zero so it serves as an offset.
+        let (left_iter, right_iter) = self.0.split_at(index);
+        (Self(left_iter), Self(right_iter))
     }
 }
 
@@ -279,20 +272,9 @@ where
     }
 
     fn split_at(self, index: usize) -> (Self, Self) {
-        // the index is relative to the size of this current iterator
-        // it will always start at zero so it serves as an offset
-
-        let left_iter = ColumnIterMut {
-            mat: self.0.mat,
-            range: self.0.range.start..(self.0.range.start + index),
-            phantom: Default::default(),
-        };
-
-        let right_iter = ColumnIterMut {
-            mat: self.0.mat,
-            range: (self.0.range.start + index)..self.0.range.end,
-            phantom: Default::default(),
-        };
+        // The index is relative to the size of this current iterator
+        // it will always start at zero so it serves as an offset.
+        let (left_iter, right_iter) = self.0.split_at(index);
         (Self(left_iter), Self(right_iter))
     }
 }
diff --git a/tests/lib.rs b/tests/lib.rs
index 6e4238e5..546aa8a7 100644
--- a/tests/lib.rs
+++ b/tests/lib.rs
@@ -9,10 +9,6 @@ compile_error!(
      Example: `cargo test --features debug,compare,rand,macros`"
 );
 
-// make sure to test the parallel iterators for all builds that do not require no_std
-#[cfg(all(feature = "std", not(feature = "par-iter")))]
-compile_error!("Please additionally enable the `par-iter` feature to compile and run the tests");
-
 #[cfg(all(feature = "debug", feature = "compare", feature = "rand"))]
 #[macro_use]
 extern crate approx;

From d54c56fd4320f9e459435ec1ea24db6c0736ada2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=A9bastien=20Crozet?= <developer@crozet.re>
Date: Sat, 14 Jan 2023 15:37:12 +0100
Subject: [PATCH 109/119] Fix potential unsoundness in ColumnIter::split_at

---
 src/base/iter.rs | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/src/base/iter.rs b/src/base/iter.rs
index f213f096..0e4aa8d4 100644
--- a/src/base/iter.rs
+++ b/src/base/iter.rs
@@ -314,16 +314,17 @@ impl<'a, T, R: Dim, C: Dim, S: 'a + RawStorage<T, R, C>> ColumnIter<'a, T, R, C,
     }
 
     pub(crate) fn split_at(self, index: usize) -> (Self, Self) {
-        // SAFETY: it’s OK even if index > self.range.len() because
-        //         the iterations will yield None in this case.
+        // SAFETY: this makes sur the generated ranges are valid.
+        let split_pos = (self.range.start + index).min(self.range.end);
+
         let left_iter = ColumnIter {
             mat: self.mat,
-            range: self.range.start..(self.range.start + index),
+            range: self.range.start..split_pos,
         };
 
         let right_iter = ColumnIter {
             mat: self.mat,
-            range: (self.range.start + index)..self.range.end,
+            range: split_pos..self.range.end,
         };
 
         (left_iter, right_iter)
@@ -401,19 +402,18 @@ impl<'a, T, R: Dim, C: Dim, S: 'a + RawStorageMut<T, R, C>> ColumnIterMut<'a, T,
     }
 
     pub(crate) fn split_at(self, index: usize) -> (Self, Self) {
-        // SAFETY: it’s OK even if index > self.range.len() because
-        //         the iterations will yield None in this case.
-        assert!(index <= self.range.len());
+        // SAFETY: this makes sur the generated ranges are valid.
+        let split_pos = (self.range.start + index).min(self.range.end);
 
         let left_iter = ColumnIterMut {
             mat: self.mat,
-            range: self.range.start..(self.range.start + index),
+            range: self.range.start..split_pos,
             phantom: Default::default(),
         };
 
         let right_iter = ColumnIterMut {
             mat: self.mat,
-            range: (self.range.start + index)..self.range.end,
+            range: split_pos..self.range.end,
             phantom: Default::default(),
         };
 

From 82b496074068f25b59ecc8098bb42eab13bc9a8c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=A9bastien=20Crozet?= <developer@crozet.re>
Date: Sat, 14 Jan 2023 15:48:42 +0100
Subject: [PATCH 110/119] Better coding-style in the doc-tests.

---
 src/base/par_iter.rs | 34 ++++++++++++++++------------------
 1 file changed, 16 insertions(+), 18 deletions(-)

diff --git a/src/base/par_iter.rs b/src/base/par_iter.rs
index 820c408a..0f1202c9 100644
--- a/src/base/par_iter.rs
+++ b/src/base/par_iter.rs
@@ -169,20 +169,19 @@ where
     /// Using parallel column iterators to calculate the sum of the maximum
     /// elements in each column:
     /// ```
-    /// use nalgebra::{dmatrix,DMatrix};
+    /// use nalgebra::{dmatrix, DMatrix};
     /// use rayon::prelude::*;
     ///
-    /// let matrix : DMatrix<f64> =
-    ///         nalgebra::dmatrix![1.,0.,5.;
-    ///                            2.,4.,1.;
-    ///                            3.,2.,2.;];
-    /// let sum_of_max :f64 =
-    ///         matrix
-    ///         .par_column_iter()
-    ///         .map(|col|col.max())
-    ///         .sum();
+    /// let matrix : DMatrix<f64> = dmatrix![1.0, 0.0, 5.0;
+    ///     2.0, 4.0, 1.0;
+    ///     3.0, 2.0, 2.0;
+    /// ];
+    /// let sum_of_max :f64 = matrix
+    ///     .par_column_iter()
+    ///     .map(|col| col.max())
+    ///     .sum();
     ///
-    /// assert_eq!(sum_of_max,3.+4.+5.);
+    /// assert_eq!(sum_of_max,3.0 + 4.0 + 5.0);
     ///                             
     /// ```
     ///
@@ -200,17 +199,16 @@ where
     /// Normalize each column of a matrix with respect to its own maximum value.
     ///
     /// ```
-    /// use nalgebra::{dmatrix,DMatrix};
+    /// use nalgebra::{dmatrix, DMatrix};
     /// use rayon::prelude::*;
     ///
-    /// let mut matrix : DMatrix<f64> =
-    ///                     dmatrix![2.,4.,6.;
-    ///                             1.,2.,3.];
+    /// let mut matrix : DMatrix<f64> = dmatrix![
+    ///     2.0, 4.0, 6.0;
+    ///     1.0, 2.0, 3.0;
+    /// ];
     /// matrix.par_column_iter_mut().for_each(|mut col| col /= col.max());
     ///
-    /// assert_eq!(matrix,
-    ///             dmatrix![1. ,1. , 1.;
-    ///                      0.5,0.5,0.5]);
+    /// assert_eq!(matrix, dmatrix![1.0, 1.0, 1.0; 0.5, 0.5, 0.5]);
     /// ```
     ///
     /// [`par_column_iter`]: crate::Matrix::par_column_iter

From 3a8c1bf81e56e37421f7f17cfeb5c48d69fe316c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=A9bastien=20Crozet?= <developer@crozet.re>
Date: Sat, 14 Jan 2023 15:59:11 +0100
Subject: [PATCH 111/119] Use rayon as the feature name instead of par-iter

---
 .github/workflows/nalgebra-ci-build.yml |  2 +-
 Cargo.toml                              |  2 +-
 src/base/mod.rs                         |  2 +-
 src/base/par_iter.rs                    | 34 ++++++++++++-------------
 tests/core/matrix.rs                    |  6 ++---
 5 files changed, 23 insertions(+), 23 deletions(-)

diff --git a/.github/workflows/nalgebra-ci-build.yml b/.github/workflows/nalgebra-ci-build.yml
index 665bd008..d7027127 100644
--- a/.github/workflows/nalgebra-ci-build.yml
+++ b/.github/workflows/nalgebra-ci-build.yml
@@ -61,7 +61,7 @@ jobs:
     steps:
       - uses: actions/checkout@v2
       - name: test
-        run: cargo test --features arbitrary,rand,serde-serialize,sparse,debug,io,compare,libm,proptest-support,slow-tests,rkyv-safe-deser,par-iter;
+        run: cargo test --features arbitrary,rand,serde-serialize,sparse,debug,io,compare,libm,proptest-support,slow-tests,rkyv-safe-deser,rayon;
   test-nalgebra-glm:
     runs-on: ubuntu-latest
     steps:
diff --git a/Cargo.toml b/Cargo.toml
index e7c6ba1e..82528ed4 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -33,7 +33,7 @@ libm    = [ "simba/libm" ]
 libm-force = [ "simba/libm_force" ]
 macros = [ "nalgebra-macros" ]
 cuda   = [ "cust_core", "simba/cuda" ]
-par-iter  = [ "std", "rayon" ]
+
 
 # Conversion
 convert-mint = [ "mint" ]
diff --git a/src/base/mod.rs b/src/base/mod.rs
index 73fe18c3..0f09cc33 100644
--- a/src/base/mod.rs
+++ b/src/base/mod.rs
@@ -42,7 +42,7 @@ mod min_max;
 /// Mechanisms for working with values that may not be initialized.
 pub mod uninit;
 
-#[cfg(feature = "par-iter")]
+#[cfg(feature = "rayon")]
 pub mod par_iter;
 
 #[cfg(feature = "rkyv-serialize-no-std")]
diff --git a/src/base/par_iter.rs b/src/base/par_iter.rs
index 0f1202c9..af5e1cb7 100644
--- a/src/base/par_iter.rs
+++ b/src/base/par_iter.rs
@@ -14,10 +14,10 @@ use rayon::{iter::plumbing::bridge, prelude::*};
 /// A rayon parallel iterator over the colums of a matrix. It is created
 /// using the [`par_column_iter`] method of [`Matrix`].
 ///
-/// *Only available if compiled with the feature `par-iter`.*
+/// *Only available if compiled with the feature `rayon`.*
 /// [`par_column_iter`]: crate::Matrix::par_column_iter
 /// [`Matrix`]: crate::Matrix
-#[cfg_attr(doc_cfg, doc(cfg(feature = "par-iter")))]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "rayon")))]
 pub struct ParColumnIter<'a, T, R: Dim, Cols: Dim, S: RawStorage<T, R, Cols>> {
     mat: &'a Matrix<T, R, Cols, S>,
 }
@@ -29,7 +29,7 @@ impl<'a, T, R: Dim, Cols: Dim, S: RawStorage<T, R, Cols>> ParColumnIter<'a, T, R
     }
 }
 
-#[cfg_attr(doc_cfg, doc(cfg(feature = "par-iter")))]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "rayon")))]
 impl<'a, T, R: Dim, Cols: Dim, S: RawStorage<T, R, Cols>> ParallelIterator
     for ParColumnIter<'a, T, R, Cols, S>
 where
@@ -50,8 +50,8 @@ where
     }
 }
 
-#[cfg_attr(doc_cfg, doc(cfg(feature = "par-iter")))]
-/// *Only available if compiled with the feature `par-iter`.*
+#[cfg_attr(doc_cfg, doc(cfg(feature = "rayon")))]
+/// *Only available if compiled with the feature `rayon`.*
 impl<'a, T, R: Dim, Cols: Dim, S: RawStorage<T, R, Cols>> IndexedParallelIterator
     for ParColumnIter<'a, T, R, Cols, S>
 where
@@ -75,9 +75,9 @@ where
     }
 }
 
-#[cfg_attr(doc_cfg, doc(cfg(feature = "par-iter")))]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "rayon")))]
 /// A rayon parallel iterator through the mutable columns of a matrix.
-/// *Only available if compiled with the feature `par-iter`.*
+/// *Only available if compiled with the feature `rayon`.*
 pub struct ParColumnIterMut<
     'a,
     T,
@@ -88,8 +88,8 @@ pub struct ParColumnIterMut<
     mat: &'a mut Matrix<T, R, Cols, S>,
 }
 
-#[cfg_attr(doc_cfg, doc(cfg(feature = "par-iter")))]
-/// *only availabe if compiled with the feature `par-iter`*
+#[cfg_attr(doc_cfg, doc(cfg(feature = "rayon")))]
+/// *only availabe if compiled with the feature `rayon`*
 impl<'a, T, R, Cols, S> ParColumnIterMut<'a, T, R, Cols, S>
 where
     R: Dim,
@@ -102,8 +102,8 @@ where
     }
 }
 
-#[cfg_attr(doc_cfg, doc(cfg(feature = "par-iter")))]
-/// *Only available if compiled with the feature `par-iter`*
+#[cfg_attr(doc_cfg, doc(cfg(feature = "rayon")))]
+/// *Only available if compiled with the feature `rayon`*
 impl<'a, T, R, Cols, S> ParallelIterator for ParColumnIterMut<'a, T, R, Cols, S>
 where
     R: Dim,
@@ -125,8 +125,8 @@ where
     }
 }
 
-#[cfg_attr(doc_cfg, doc(cfg(feature = "par-iter")))]
-/// *Only available if compiled with the feature `par-iter`*
+#[cfg_attr(doc_cfg, doc(cfg(feature = "rayon")))]
+/// *Only available if compiled with the feature `rayon`*
 impl<'a, T, R, Cols, S> IndexedParallelIterator for ParColumnIterMut<'a, T, R, Cols, S>
 where
     R: Dim,
@@ -152,9 +152,9 @@ where
     }
 }
 
-#[cfg_attr(doc_cfg, doc(cfg(feature = "par-iter")))]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "rayon")))]
 /// # Parallel iterators using `rayon`
-/// *Only available if compiled with the feature `par-iter`*
+/// *Only available if compiled with the feature `rayon`*
 impl<T, R: Dim, Cols: Dim, S: RawStorage<T, R, Cols>> Matrix<T, R, Cols, S>
 where
     T: Send + Sync + Scalar,
@@ -225,8 +225,8 @@ where
 /// rayon trait part of the public interface of the `ColumnIter`.
 struct ColumnProducer<'a, T, R: Dim, C: Dim, S: RawStorage<T, R, C>>(ColumnIter<'a, T, R, C, S>);
 
-#[cfg_attr(doc_cfg, doc(cfg(feature = "par-iter")))]
-/// *only available if compiled with the feature `par-iter`*
+#[cfg_attr(doc_cfg, doc(cfg(feature = "rayon")))]
+/// *only available if compiled with the feature `rayon`*
 impl<'a, T, R: Dim, Cols: Dim, S: RawStorage<T, R, Cols>> Producer
     for ColumnProducer<'a, T, R, Cols, S>
 where
diff --git a/tests/core/matrix.rs b/tests/core/matrix.rs
index 41972347..27926a27 100644
--- a/tests/core/matrix.rs
+++ b/tests/core/matrix.rs
@@ -1218,7 +1218,7 @@ fn column_iterator_double_ended_mut() {
 }
 
 #[test]
-#[cfg(feature = "par-iter")]
+#[cfg(feature = "rayon")]
 fn parallel_column_iteration() {
     use nalgebra::dmatrix;
     use rayon::prelude::*;
@@ -1251,7 +1251,7 @@ fn parallel_column_iteration() {
 }
 
 #[test]
-#[cfg(feature = "par-iter")]
+#[cfg(feature = "rayon")]
 fn column_iteration_mut_double_ended() {
     let dmat = nalgebra::dmatrix![
     13,14,15,16,17;
@@ -1270,7 +1270,7 @@ fn column_iteration_mut_double_ended() {
 }
 
 #[test]
-#[cfg(feature = "par-iter")]
+#[cfg(feature = "rayon")]
 fn parallel_column_iteration_mut() {
     use rayon::prelude::*;
     let mut first = DMatrix::<f32>::zeros(400, 300);

From 19c99634c385ddbcee2ddbb3722b5fa4987fd1d8 Mon Sep 17 00:00:00 2001
From: Andreas Longva <andreas.b.longva@gmail.com>
Date: Thu, 24 Nov 2022 09:19:25 +0100
Subject: [PATCH 112/119] Add U0, U1, ... dimension constants

This allows us to simply write U4 in place of U4::name() or Const::<4>,
like we used to be able to before const generics.
---
 src/base/dimension.rs | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/src/base/dimension.rs b/src/base/dimension.rs
index 3d1de1ff..fef44645 100644
--- a/src/base/dimension.rs
+++ b/src/base/dimension.rs
@@ -310,6 +310,11 @@ macro_rules! from_to_typenum (
         }
 
         impl IsNotStaticOne for $D { }
+
+        /// The constant dimension
+        #[doc = stringify!($VAL)]
+        /// .
+        pub const $D: $D = Const::<$VAL>;
     )*}
 );
 
@@ -323,3 +328,7 @@ from_to_typenum!(
     U111, 111; U112, 112; U113, 113; U114, 114; U115, 115; U116, 116; U117, 117; U118, 118; U119, 119; U120, 120; U121, 121; U122, 122; U123, 123; U124, 124; U125, 125; U126, 126;
     U127, 127
 );
+
+/// The constant dimension 1.
+// Note: We add U1 separately since it's not covered by the from_to_typenum! macro.
+pub const U1: U1 = Const::<1>;

From 4221c44a2b74759dc67ce397807ad73c8e6998ba Mon Sep 17 00:00:00 2001
From: Andreas Longva <andreas.b.longva@gmail.com>
Date: Thu, 24 Nov 2022 13:16:59 +0100
Subject: [PATCH 113/119] Rename Dynamic -> Dyn

Provide a type alias to avoid breaking code. Make Dyn a
tuple struct so that we can use the succinct syntax
Dyn(n) instead of Dyn::new(n).
---
 src/base/dimension.rs | 23 ++++++++++++-----------
 1 file changed, 12 insertions(+), 11 deletions(-)

diff --git a/src/base/dimension.rs b/src/base/dimension.rs
index fef44645..cf290af5 100644
--- a/src/base/dimension.rs
+++ b/src/base/dimension.rs
@@ -22,15 +22,16 @@ use serde::{Deserialize, Deserializer, Serialize, Serializer};
     archive_attr(derive(bytecheck::CheckBytes))
 )]
 #[cfg_attr(feature = "cuda", derive(cust_core::DeviceCopy))]
-pub struct Dynamic {
-    value: usize,
-}
+pub struct Dyn(pub usize);
+
+// TODO: Deprecate?
+pub type Dynamic = Dyn;
 
 impl Dynamic {
     /// A dynamic size equal to `value`.
     #[inline]
     pub const fn new(value: usize) -> Self {
-        Self { value }
+        Self(value)
     }
 }
 
@@ -40,7 +41,7 @@ impl Serialize for Dynamic {
     where
         S: Serializer,
     {
-        self.value.serialize(serializer)
+        self.0.serialize(serializer)
     }
 }
 
@@ -50,7 +51,7 @@ impl<'de> Deserialize<'de> for Dynamic {
     where
         D: Deserializer<'de>,
     {
-        usize::deserialize(deserializer).map(|x| Dynamic { value: x })
+        usize::deserialize(deserializer).map(|x| Dynamic(x))
     }
 }
 
@@ -96,7 +97,7 @@ unsafe impl Dim for Dynamic {
 
     #[inline]
     fn value(&self) -> usize {
-        self.value
+        self.0
     }
 }
 
@@ -105,7 +106,7 @@ impl Add<usize> for Dynamic {
 
     #[inline]
     fn add(self, rhs: usize) -> Self {
-        Self::new(self.value + rhs)
+        Self::new(self.0 + rhs)
     }
 }
 
@@ -114,7 +115,7 @@ impl Sub<usize> for Dynamic {
 
     #[inline]
     fn sub(self, rhs: usize) -> Self {
-        Self::new(self.value - rhs)
+        Self::new(self.0 - rhs)
     }
 }
 
@@ -157,7 +158,7 @@ macro_rules! dim_ops(
 
             #[inline]
             fn $op(self, other: D) -> Dynamic {
-                Dynamic::new($op_path(self.value, other.value()))
+                Dynamic::new($op_path(self.value(), other.value()))
             }
         }
 
@@ -167,7 +168,7 @@ macro_rules! dim_ops(
 
             #[inline]
             fn $op(self, other: Dynamic) -> Dynamic {
-                Dynamic::new($op_path(self.value(), other.value))
+                Dynamic::new($op_path(self.value(), other.value()))
             }
         }
 

From afabf4bad2cba368f7dcf28ca34fd8bffa75d8a3 Mon Sep 17 00:00:00 2001
From: Andreas Longva <andreas.b.longva@gmail.com>
Date: Thu, 24 Nov 2022 14:14:49 +0100
Subject: [PATCH 114/119] ReshapableStorage for slices + tests for owned
 reshape

In the process of implementing ReshapbleStorage for SliceStorage(Mut),
I discovered that there appears to be no tests for the existing
reshape_generic functionality on owned matrices.
---
 src/base/matrix_view.rs | 45 +++++++++++++++++++++++
 tests/core/mod.rs       |  1 +
 tests/core/reshape.rs   | 80 +++++++++++++++++++++++++++++++++++++++++
 3 files changed, 126 insertions(+)
 create mode 100644 tests/core/reshape.rs

diff --git a/src/base/matrix_view.rs b/src/base/matrix_view.rs
index c3dbd215..7257629b 100644
--- a/src/base/matrix_view.rs
+++ b/src/base/matrix_view.rs
@@ -9,6 +9,7 @@ use crate::base::iter::MatrixIter;
 use crate::base::storage::{IsContiguous, Owned, RawStorage, RawStorageMut, Storage};
 use crate::base::{Matrix, Scalar};
 use crate::constraint::{DimEq, ShapeConstraint};
+use crate::ReshapableStorage;
 
 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)) => {
@@ -1186,3 +1187,47 @@ where
         self.into()
     }
 }
+
+// TODO: Arbitrary strides?
+impl<'a, T, R1, C1, R2, C2> ReshapableStorage<T, R1, C1, R2, C2>
+    for ViewStorage<'a, T, R1, C1, U1, R1>
+where
+    T: Scalar,
+    R1: Dim,
+    C1: Dim,
+    R2: Dim,
+    C2: Dim,
+{
+    type Output = ViewStorage<'a, T, R2, C2, U1, R2>;
+
+    fn reshape_generic(self, nrows: R2, ncols: C2) -> Self::Output {
+        let (r1, c1) = self.shape();
+        assert_eq!(nrows.value() * ncols.value(), r1.value() * c1.value());
+        let ptr = self.ptr();
+        let new_shape = (nrows, ncols);
+        let strides = (U1::name(), nrows);
+        unsafe { ViewStorage::from_raw_parts(ptr, new_shape, strides) }
+    }
+}
+
+// TODO: Arbitrary strides?
+impl<'a, T, R1, C1, R2, C2> ReshapableStorage<T, R1, C1, R2, C2>
+    for ViewStorageMut<'a, T, R1, C1, U1, R1>
+where
+    T: Scalar,
+    R1: Dim,
+    C1: Dim,
+    R2: Dim,
+    C2: Dim,
+{
+    type Output = ViewStorageMut<'a, T, R2, C2, U1, R2>;
+
+    fn reshape_generic(mut self, nrows: R2, ncols: C2) -> Self::Output {
+        let (r1, c1) = self.shape();
+        assert_eq!(nrows.value() * ncols.value(), r1.value() * c1.value());
+        let ptr = self.ptr_mut();
+        let new_shape = (nrows, ncols);
+        let strides = (U1::name(), nrows);
+        unsafe { ViewStorageMut::from_raw_parts(ptr, new_shape, strides) }
+    }
+}
diff --git a/tests/core/mod.rs b/tests/core/mod.rs
index 667f10a7..0f7ee85b 100644
--- a/tests/core/mod.rs
+++ b/tests/core/mod.rs
@@ -7,6 +7,7 @@ mod matrix;
 mod matrix_view;
 #[cfg(feature = "mint")]
 mod mint;
+mod reshape;
 #[cfg(feature = "rkyv-serialize-no-std")]
 mod rkyv;
 mod serde;
diff --git a/tests/core/reshape.rs b/tests/core/reshape.rs
new file mode 100644
index 00000000..b0d4a8a2
--- /dev/null
+++ b/tests/core/reshape.rs
@@ -0,0 +1,80 @@
+use na::{
+    Const, DMatrix, DMatrixSlice, DMatrixSliceMut, Dyn, Dynamic, Matrix, MatrixSlice,
+    MatrixSliceMut, SMatrix, SMatrixSlice, SMatrixSliceMut, VecStorage, U3, U4,
+};
+use nalgebra_macros::matrix;
+use simba::scalar::SupersetOf;
+
+const MATRIX: SMatrix<i32, 4, 3> = matrix![
+     1,  2,  3;
+     4,  5,  6;
+     7,  8,  9;
+    10, 11, 12
+];
+
+const RESHAPED_MATRIX: SMatrix<i32, 3, 4> = matrix![
+    1, 10,  8,  6;
+    4,  2, 11,  9;
+    7,  5,  3, 12
+];
+
+// Helper alias for making it easier to specify dynamically allocated matrices with
+// different dimension types (unlike DMatrix)
+type GenericDMatrix<T, R, C> = Matrix<T, R, C, VecStorage<T, R, C>>;
+
+#[test]
+fn reshape_owned() {
+    macro_rules! test_reshape {
+        ($in_matrix:ty => $out_matrix:ty, $rows:expr, $cols:expr) => {{
+            // This is a pretty weird way to convert, but Matrix implements SubsetOf
+            let matrix: $in_matrix = MATRIX.to_subset().unwrap();
+            let reshaped: $out_matrix = matrix.reshape_generic($rows, $cols);
+            assert_eq!(reshaped, RESHAPED_MATRIX);
+        }};
+    }
+
+    test_reshape!(SMatrix<_, 4, 3> => SMatrix<_, 3, 4>, U3, U4);
+    test_reshape!(GenericDMatrix<_, U4, Dyn> => GenericDMatrix<_, Dyn, Dyn>, Dyn(3), Dyn(4));
+    test_reshape!(GenericDMatrix<_, U4, Dyn> => GenericDMatrix<_, U3, Dyn>, U3, Dyn(4));
+    test_reshape!(GenericDMatrix<_, U4, Dyn> => GenericDMatrix<_, Dyn, U4>, Dyn(3), U4);
+    test_reshape!(DMatrix<_> => DMatrix<_>, Dyn(3), Dyn(4));
+}
+
+#[test]
+fn reshape_slice() {
+    macro_rules! test_reshape {
+        ($in_slice:ty => $out_slice:ty, $rows:expr, $cols:expr) => {
+            // We test both that types check out by being explicit about types
+            // and the actual contents of the matrix
+            {
+                // By constructing the slice from a mutable reference we can obtain *either*
+                // an immutable slice or a mutable slice, which simplifies the testing of both
+                // types of mutability
+                let mut source_matrix = MATRIX.clone();
+                let slice: $in_slice = Matrix::from(&mut source_matrix);
+                let reshaped: $out_slice = slice.reshape_generic($rows, $cols);
+                assert_eq!(reshaped, RESHAPED_MATRIX);
+            }
+        };
+    }
+
+    // Static "source slice"
+    test_reshape!(SMatrixSlice<_, 4, 3> => SMatrixSlice<_, 3, 4>, U3, U4);
+    test_reshape!(SMatrixSlice<_, 4, 3> => DMatrixSlice<_>, Dynamic::new(3), Dynamic::new(4));
+    test_reshape!(SMatrixSlice<_, 4, 3> => MatrixSlice<_, Const<3>, Dynamic>, U3, Dynamic::new(4));
+    test_reshape!(SMatrixSlice<_, 4, 3> => MatrixSlice<_, Dynamic, Const<4>>, Dynamic::new(3), U4);
+    test_reshape!(SMatrixSliceMut<_, 4, 3> => SMatrixSliceMut<_, 3, 4>, U3, U4);
+    test_reshape!(SMatrixSliceMut<_, 4, 3> => DMatrixSliceMut<_>, Dynamic::new(3), Dynamic::new(4));
+    test_reshape!(SMatrixSliceMut<_, 4, 3> => MatrixSliceMut<_, Const<3>, Dynamic>, U3, Dynamic::new(4));
+    test_reshape!(SMatrixSliceMut<_, 4, 3> => MatrixSliceMut<_, Dynamic, Const<4>>, Dynamic::new(3), U4);
+
+    // Dynamic "source slice"
+    test_reshape!(DMatrixSlice<_> => SMatrixSlice<_, 3, 4>, U3, U4);
+    test_reshape!(DMatrixSlice<_> => DMatrixSlice<_>, Dynamic::new(3), Dynamic::new(4));
+    test_reshape!(DMatrixSlice<_> => MatrixSlice<_, Const<3>, Dynamic>, U3, Dynamic::new(4));
+    test_reshape!(DMatrixSlice<_> => MatrixSlice<_, Dynamic, Const<4>>, Dynamic::new(3), U4);
+    test_reshape!(DMatrixSliceMut<_> => SMatrixSliceMut<_, 3, 4>, U3, U4);
+    test_reshape!(DMatrixSliceMut<_> => DMatrixSliceMut<_>, Dynamic::new(3), Dynamic::new(4));
+    test_reshape!(DMatrixSliceMut<_> => MatrixSliceMut<_, Const<3>, Dynamic>, U3, Dynamic::new(4));
+    test_reshape!(DMatrixSliceMut<_> => MatrixSliceMut<_, Dynamic, Const<4>>, Dynamic::new(3), U4);
+}

From c506bd577a3a995fbd9df3a61179b37a4ff4dc6c Mon Sep 17 00:00:00 2001
From: Andreas Longva <andreas.b.longva@gmail.com>
Date: Thu, 24 Nov 2022 16:18:13 +0100
Subject: [PATCH 115/119] Fix broken compilation for serde-serialize

---
 src/base/dimension.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/base/dimension.rs b/src/base/dimension.rs
index cf290af5..71472783 100644
--- a/src/base/dimension.rs
+++ b/src/base/dimension.rs
@@ -51,7 +51,7 @@ impl<'de> Deserialize<'de> for Dynamic {
     where
         D: Deserializer<'de>,
     {
-        usize::deserialize(deserializer).map(|x| Dynamic(x))
+        usize::deserialize(deserializer).map(|x| Dynamic::new(x))
     }
 }
 

From 3508280929462432c3cdf8ff4329e5e6093bc15b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=A9bastien=20Crozet?= <developer@crozet.re>
Date: Sat, 14 Jan 2023 16:13:21 +0100
Subject: [PATCH 116/119] Rename Slice to View in reshape tests

---
 tests/core/reshape.rs | 36 ++++++++++++++++++------------------
 1 file changed, 18 insertions(+), 18 deletions(-)

diff --git a/tests/core/reshape.rs b/tests/core/reshape.rs
index b0d4a8a2..42afa9bf 100644
--- a/tests/core/reshape.rs
+++ b/tests/core/reshape.rs
@@ -1,6 +1,6 @@
 use na::{
-    Const, DMatrix, DMatrixSlice, DMatrixSliceMut, Dyn, Dynamic, Matrix, MatrixSlice,
-    MatrixSliceMut, SMatrix, SMatrixSlice, SMatrixSliceMut, VecStorage, U3, U4,
+    Const, DMatrix, DMatrixView, DMatrixViewMut, Dyn, Dynamic, Matrix, MatrixView, MatrixViewMut,
+    SMatrix, SMatrixView, SMatrixViewMut, VecStorage, U3, U4,
 };
 use nalgebra_macros::matrix;
 use simba::scalar::SupersetOf;
@@ -59,22 +59,22 @@ fn reshape_slice() {
     }
 
     // Static "source slice"
-    test_reshape!(SMatrixSlice<_, 4, 3> => SMatrixSlice<_, 3, 4>, U3, U4);
-    test_reshape!(SMatrixSlice<_, 4, 3> => DMatrixSlice<_>, Dynamic::new(3), Dynamic::new(4));
-    test_reshape!(SMatrixSlice<_, 4, 3> => MatrixSlice<_, Const<3>, Dynamic>, U3, Dynamic::new(4));
-    test_reshape!(SMatrixSlice<_, 4, 3> => MatrixSlice<_, Dynamic, Const<4>>, Dynamic::new(3), U4);
-    test_reshape!(SMatrixSliceMut<_, 4, 3> => SMatrixSliceMut<_, 3, 4>, U3, U4);
-    test_reshape!(SMatrixSliceMut<_, 4, 3> => DMatrixSliceMut<_>, Dynamic::new(3), Dynamic::new(4));
-    test_reshape!(SMatrixSliceMut<_, 4, 3> => MatrixSliceMut<_, Const<3>, Dynamic>, U3, Dynamic::new(4));
-    test_reshape!(SMatrixSliceMut<_, 4, 3> => MatrixSliceMut<_, Dynamic, Const<4>>, Dynamic::new(3), U4);
+    test_reshape!(SMatrixView<_, 4, 3> => SMatrixView<_, 3, 4>, U3, U4);
+    test_reshape!(SMatrixView<_, 4, 3> => DMatrixView<_>, Dynamic::new(3), Dynamic::new(4));
+    test_reshape!(SMatrixView<_, 4, 3> => MatrixView<_, Const<3>, Dynamic>, U3, Dynamic::new(4));
+    test_reshape!(SMatrixView<_, 4, 3> => MatrixView<_, Dynamic, Const<4>>, Dynamic::new(3), U4);
+    test_reshape!(SMatrixViewMut<_, 4, 3> => SMatrixViewMut<_, 3, 4>, U3, U4);
+    test_reshape!(SMatrixViewMut<_, 4, 3> => DMatrixViewMut<_>, Dynamic::new(3), Dynamic::new(4));
+    test_reshape!(SMatrixViewMut<_, 4, 3> => MatrixViewMut<_, Const<3>, Dynamic>, U3, Dynamic::new(4));
+    test_reshape!(SMatrixViewMut<_, 4, 3> => MatrixViewMut<_, Dynamic, Const<4>>, Dynamic::new(3), U4);
 
     // Dynamic "source slice"
-    test_reshape!(DMatrixSlice<_> => SMatrixSlice<_, 3, 4>, U3, U4);
-    test_reshape!(DMatrixSlice<_> => DMatrixSlice<_>, Dynamic::new(3), Dynamic::new(4));
-    test_reshape!(DMatrixSlice<_> => MatrixSlice<_, Const<3>, Dynamic>, U3, Dynamic::new(4));
-    test_reshape!(DMatrixSlice<_> => MatrixSlice<_, Dynamic, Const<4>>, Dynamic::new(3), U4);
-    test_reshape!(DMatrixSliceMut<_> => SMatrixSliceMut<_, 3, 4>, U3, U4);
-    test_reshape!(DMatrixSliceMut<_> => DMatrixSliceMut<_>, Dynamic::new(3), Dynamic::new(4));
-    test_reshape!(DMatrixSliceMut<_> => MatrixSliceMut<_, Const<3>, Dynamic>, U3, Dynamic::new(4));
-    test_reshape!(DMatrixSliceMut<_> => MatrixSliceMut<_, Dynamic, Const<4>>, Dynamic::new(3), U4);
+    test_reshape!(DMatrixView<_> => SMatrixView<_, 3, 4>, U3, U4);
+    test_reshape!(DMatrixView<_> => DMatrixView<_>, Dynamic::new(3), Dynamic::new(4));
+    test_reshape!(DMatrixView<_> => MatrixView<_, Const<3>, Dynamic>, U3, Dynamic::new(4));
+    test_reshape!(DMatrixView<_> => MatrixView<_, Dynamic, Const<4>>, Dynamic::new(3), U4);
+    test_reshape!(DMatrixViewMut<_> => SMatrixViewMut<_, 3, 4>, U3, U4);
+    test_reshape!(DMatrixViewMut<_> => DMatrixViewMut<_>, Dynamic::new(3), Dynamic::new(4));
+    test_reshape!(DMatrixViewMut<_> => MatrixViewMut<_, Const<3>, Dynamic>, U3, Dynamic::new(4));
+    test_reshape!(DMatrixViewMut<_> => MatrixViewMut<_, Dynamic, Const<4>>, Dynamic::new(3), U4);
 }

From 711ac67da9e9adb28feeb544de9dfd063a14431a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=A9bastien=20Crozet?= <developer@crozet.re>
Date: Sat, 14 Jan 2023 16:22:27 +0100
Subject: [PATCH 117/119] Deplecate Dynamic and Dynamic::new

---
 examples/reshaping.rs                   |   6 +-
 nalgebra-macros/src/lib.rs              |   6 +-
 nalgebra-sparse/src/ops/impl_std_ops.rs |  22 ++---
 src/base/alias.rs                       |  32 +++----
 src/base/alias_slice.rs                 |  90 +++++++++----------
 src/base/alias_view.rs                  |  90 +++++++++----------
 src/base/allocator.rs                   |   2 +-
 src/base/blas.rs                        |   4 +-
 src/base/blas_uninit.rs                 |  16 ++--
 src/base/constraint.rs                  |  14 +--
 src/base/construction.rs                |  42 ++++-----
 src/base/construction_view.rs           |  54 ++++++------
 src/base/conversion.rs                  |  26 +++---
 src/base/default_allocator.rs           |  90 +++++++++----------
 src/base/dimension.rs                   |  55 ++++++------
 src/base/edition.rs                     | 110 ++++++++++++------------
 src/base/indexing.rs                    | 106 +++++++++++------------
 src/base/matrix.rs                      |  16 ++--
 src/base/matrix_view.rs                 |  84 +++++++++---------
 src/base/ops.rs                         |  14 +--
 src/base/vec_storage.rs                 |  82 +++++++++---------
 src/debug/random_orthogonal.rs          |   4 +-
 src/debug/random_sdp.rs                 |   4 +-
 src/linalg/bidiagonal.rs                |   2 +-
 src/linalg/eigen.rs                     |   6 +-
 src/linalg/permutation_sequence.rs      |   8 +-
 src/linalg/schur.rs                     |  30 +++----
 src/proptest/mod.rs                     |  36 ++++----
 src/sparse/cs_matrix.rs                 |  16 ++--
 src/sparse/cs_matrix_conversion.rs      |   4 +-
 tests/core/edition.rs                   |  10 +--
 tests/core/reshape.rs                   |  28 +++---
 tests/linalg/cholesky.rs                |  14 +--
 tests/linalg/convolution.rs             |   6 +-
 tests/linalg/full_piv_lu.rs             |   8 +-
 tests/proptest/mod.rs                   |  16 ++--
 36 files changed, 570 insertions(+), 583 deletions(-)

diff --git a/examples/reshaping.rs b/examples/reshaping.rs
index b2178e79..78f7bcd5 100644
--- a/examples/reshaping.rs
+++ b/examples/reshaping.rs
@@ -2,7 +2,7 @@
 
 extern crate nalgebra as na;
 
-use na::{DMatrix, Dynamic, Matrix2x3, Matrix3x2, Const};
+use na::{DMatrix, Dyn, Matrix2x3, Matrix3x2, Const};
 
 fn main() {
     // Matrices can be reshaped in-place without moving or copying values.
@@ -46,9 +46,9 @@ fn main() {
         ],
     );
 
-    let dm3 = dm1.reshape_generic(Dynamic::new(6), Dynamic::new(2));
+    let dm3 = dm1.reshape_generic(Dyn(6), Dyn(2));
     assert_eq!(dm3, dm2);
 
     // Invalid reshapings of dynamic matrices will panic at run-time.
-    //let dm4 = dm3.reshape_generic(Dynamic::new(6), Dynamic::new(6));
+    //let dm4 = dm3.reshape_generic(Dyn(6), Dyn(6));
 }
diff --git a/nalgebra-macros/src/lib.rs b/nalgebra-macros/src/lib.rs
index 0d7889ae..e12139d2 100644
--- a/nalgebra-macros/src/lib.rs
+++ b/nalgebra-macros/src/lib.rs
@@ -191,8 +191,8 @@ pub fn dmatrix(stream: TokenStream) -> TokenStream {
     let output = quote! {
         nalgebra::DMatrix::<_>
             ::from_vec_storage(nalgebra::VecStorage::new(
-                nalgebra::Dynamic::new(#row_dim),
-                nalgebra::Dynamic::new(#col_dim),
+                nalgebra::Dyn(#row_dim),
+                nalgebra::Dyn(#col_dim),
                 vec!#array_tokens))
     };
 
@@ -285,7 +285,7 @@ pub fn dvector(stream: TokenStream) -> TokenStream {
     let output = quote! {
         nalgebra::DVector::<_>
             ::from_vec_storage(nalgebra::VecStorage::new(
-                nalgebra::Dynamic::new(#len),
+                nalgebra::Dyn(#len),
                 nalgebra::Const::<1>,
                 vec!#array_tokens))
     };
diff --git a/nalgebra-sparse/src/ops/impl_std_ops.rs b/nalgebra-sparse/src/ops/impl_std_ops.rs
index 91b6574f..7363c9d9 100644
--- a/nalgebra-sparse/src/ops/impl_std_ops.rs
+++ b/nalgebra-sparse/src/ops/impl_std_ops.rs
@@ -10,7 +10,7 @@ use nalgebra::allocator::Allocator;
 use nalgebra::base::storage::RawStorage;
 use nalgebra::constraint::{DimEq, ShapeConstraint};
 use nalgebra::{
-    ClosedAdd, ClosedDiv, ClosedMul, ClosedSub, DefaultAllocator, Dim, Dynamic, Matrix, OMatrix,
+    ClosedAdd, ClosedDiv, ClosedMul, ClosedSub, DefaultAllocator, Dim, Dyn, Matrix, OMatrix,
     Scalar, U1,
 };
 use num_traits::{One, Zero};
@@ -273,8 +273,8 @@ macro_rules! impl_spmm_cs_dense {
         // Implement ref-ref
         impl_spmm_cs_dense!(&'a $matrix_type_name<T>, &'a Matrix<T, R, C, S>, $spmm_fn, |lhs, rhs| {
             let (_, ncols) = rhs.shape_generic();
-            let nrows = Dynamic::new(lhs.nrows());
-            let mut result = OMatrix::<T, Dynamic, C>::zeros_generic(nrows, ncols);
+            let nrows = Dyn(lhs.nrows());
+            let mut result = OMatrix::<T, Dyn, C>::zeros_generic(nrows, ncols);
             $spmm_fn(T::zero(), &mut result, T::one(), Op::NoOp(lhs), Op::NoOp(rhs));
             result
         });
@@ -302,21 +302,21 @@ macro_rules! impl_spmm_cs_dense {
             R: Dim,
             C: Dim,
             S: RawStorage<T, R, C>,
-            DefaultAllocator: Allocator<T, Dynamic, C>,
+            DefaultAllocator: Allocator<T, Dyn, C>,
             // TODO: Is it possible to simplify these bounds?
             ShapeConstraint:
-                // Bounds so that we can turn OMatrix<T, Dynamic, C> into a DMatrixSliceMut
-                  DimEq<U1, <<DefaultAllocator as Allocator<T, Dynamic, C>>::Buffer as RawStorage<T, Dynamic, C>>::RStride>
-                + DimEq<C, Dynamic>
-                + DimEq<Dynamic, <<DefaultAllocator as Allocator<T, Dynamic, C>>::Buffer as RawStorage<T, Dynamic, C>>::CStride>
+                // Bounds so that we can turn OMatrix<T, Dyn, C> into a DMatrixSliceMut
+                  DimEq<U1, <<DefaultAllocator as Allocator<T, Dyn, C>>::Buffer as RawStorage<T, Dyn, C>>::RStride>
+                + DimEq<C, Dyn>
+                + DimEq<Dyn, <<DefaultAllocator as Allocator<T, Dyn, C>>::Buffer as RawStorage<T, Dyn, C>>::CStride>
                 // Bounds so that we can turn &Matrix<T, R, C, S> into a DMatrixSlice
                 + DimEq<U1, S::RStride>
-                + DimEq<R, Dynamic>
-                + DimEq<Dynamic, S::CStride>
+                + DimEq<R, Dyn>
+                + DimEq<Dyn, S::CStride>
         {
             // We need the column dimension to be generic, so that if RHS is a vector, then
             // we also get a vector (and not a matrix)
-            type Output = OMatrix<T, Dynamic, C>;
+            type Output = OMatrix<T, Dyn, C>;
 
             fn mul(self, rhs: $dense_matrix_type) -> Self::Output {
                 let $lhs = self;
diff --git a/src/base/alias.rs b/src/base/alias.rs
index 68829d9a..e3ac40b0 100644
--- a/src/base/alias.rs
+++ b/src/base/alias.rs
@@ -1,5 +1,5 @@
 #[cfg(any(feature = "alloc", feature = "std"))]
-use crate::base::dimension::Dynamic;
+use crate::base::dimension::Dyn;
 use crate::base::dimension::{U1, U2, U3, U4, U5, U6};
 use crate::base::storage::Owned;
 #[cfg(any(feature = "std", feature = "alloc"))]
@@ -48,69 +48,69 @@ pub type SMatrix<T, const R: usize, const C: usize> =
 ///
 /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
 #[cfg(any(feature = "std", feature = "alloc"))]
-pub type DMatrix<T> = Matrix<T, Dynamic, Dynamic, VecStorage<T, Dynamic, Dynamic>>;
+pub type DMatrix<T> = Matrix<T, Dyn, Dyn, VecStorage<T, Dyn, Dyn>>;
 
 /// A heap-allocated, column-major, matrix with a dynamic number of rows and 1 columns.
 ///
 /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
 #[cfg(any(feature = "std", feature = "alloc"))]
-pub type MatrixXx1<T> = Matrix<T, Dynamic, U1, VecStorage<T, Dynamic, U1>>;
+pub type MatrixXx1<T> = Matrix<T, Dyn, U1, VecStorage<T, Dyn, U1>>;
 /// A heap-allocated, column-major, matrix with a dynamic number of rows and 2 columns.
 ///
 /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
 #[cfg(any(feature = "std", feature = "alloc"))]
-pub type MatrixXx2<T> = Matrix<T, Dynamic, U2, VecStorage<T, Dynamic, U2>>;
+pub type MatrixXx2<T> = Matrix<T, Dyn, U2, VecStorage<T, Dyn, U2>>;
 /// A heap-allocated, column-major, matrix with a dynamic number of rows and 3 columns.
 ///
 /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
 #[cfg(any(feature = "std", feature = "alloc"))]
-pub type MatrixXx3<T> = Matrix<T, Dynamic, U3, VecStorage<T, Dynamic, U3>>;
+pub type MatrixXx3<T> = Matrix<T, Dyn, U3, VecStorage<T, Dyn, U3>>;
 /// A heap-allocated, column-major, matrix with a dynamic number of rows and 4 columns.
 ///
 /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
 #[cfg(any(feature = "std", feature = "alloc"))]
-pub type MatrixXx4<T> = Matrix<T, Dynamic, U4, VecStorage<T, Dynamic, U4>>;
+pub type MatrixXx4<T> = Matrix<T, Dyn, U4, VecStorage<T, Dyn, U4>>;
 /// A heap-allocated, column-major, matrix with a dynamic number of rows and 5 columns.
 ///
 /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
 #[cfg(any(feature = "std", feature = "alloc"))]
-pub type MatrixXx5<T> = Matrix<T, Dynamic, U5, VecStorage<T, Dynamic, U5>>;
+pub type MatrixXx5<T> = Matrix<T, Dyn, U5, VecStorage<T, Dyn, U5>>;
 /// A heap-allocated, column-major, matrix with a dynamic number of rows and 6 columns.
 ///
 /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
 #[cfg(any(feature = "std", feature = "alloc"))]
-pub type MatrixXx6<T> = Matrix<T, Dynamic, U6, VecStorage<T, Dynamic, U6>>;
+pub type MatrixXx6<T> = Matrix<T, Dyn, U6, VecStorage<T, Dyn, U6>>;
 
 /// A heap-allocated, row-major, matrix with 1 rows and a dynamic number of columns.
 ///
 /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
 #[cfg(any(feature = "std", feature = "alloc"))]
-pub type Matrix1xX<T> = Matrix<T, U1, Dynamic, VecStorage<T, U1, Dynamic>>;
+pub type Matrix1xX<T> = Matrix<T, U1, Dyn, VecStorage<T, U1, Dyn>>;
 /// A heap-allocated, row-major, matrix with 2 rows and a dynamic number of columns.
 ///
 /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
 #[cfg(any(feature = "std", feature = "alloc"))]
-pub type Matrix2xX<T> = Matrix<T, U2, Dynamic, VecStorage<T, U2, Dynamic>>;
+pub type Matrix2xX<T> = Matrix<T, U2, Dyn, VecStorage<T, U2, Dyn>>;
 /// A heap-allocated, row-major, matrix with 3 rows and a dynamic number of columns.
 ///
 /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
 #[cfg(any(feature = "std", feature = "alloc"))]
-pub type Matrix3xX<T> = Matrix<T, U3, Dynamic, VecStorage<T, U3, Dynamic>>;
+pub type Matrix3xX<T> = Matrix<T, U3, Dyn, VecStorage<T, U3, Dyn>>;
 /// A heap-allocated, row-major, matrix with 4 rows and a dynamic number of columns.
 ///
 /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
 #[cfg(any(feature = "std", feature = "alloc"))]
-pub type Matrix4xX<T> = Matrix<T, U4, Dynamic, VecStorage<T, U4, Dynamic>>;
+pub type Matrix4xX<T> = Matrix<T, U4, Dyn, VecStorage<T, U4, Dyn>>;
 /// A heap-allocated, row-major, matrix with 5 rows and a dynamic number of columns.
 ///
 /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
 #[cfg(any(feature = "std", feature = "alloc"))]
-pub type Matrix5xX<T> = Matrix<T, U5, Dynamic, VecStorage<T, U5, Dynamic>>;
+pub type Matrix5xX<T> = Matrix<T, U5, Dyn, VecStorage<T, U5, Dyn>>;
 /// A heap-allocated, row-major, matrix with 6 rows and a dynamic number of columns.
 ///
 /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
 #[cfg(any(feature = "std", feature = "alloc"))]
-pub type Matrix6xX<T> = Matrix<T, U6, Dynamic, VecStorage<T, U6, Dynamic>>;
+pub type Matrix6xX<T> = Matrix<T, U6, Dyn, VecStorage<T, U6, Dyn>>;
 
 /// A stack-allocated, column-major, 1x1 square matrix.
 ///
@@ -276,7 +276,7 @@ pub type Matrix6x5<T> = Matrix<T, U6, U5, ArrayStorage<T, 6, 5>>;
  */
 /// A dynamically sized column vector.
 #[cfg(any(feature = "std", feature = "alloc"))]
-pub type DVector<T> = Matrix<T, Dynamic, U1, VecStorage<T, Dynamic, U1>>;
+pub type DVector<T> = Matrix<T, Dyn, U1, VecStorage<T, Dyn, U1>>;
 
 /// An owned D-dimensional column vector.
 pub type OVector<T, D> = Matrix<T, D, U1, Owned<T, D, U1>>;
@@ -316,7 +316,7 @@ pub type Vector6<T> = Matrix<T, U6, U1, ArrayStorage<T, 6, 1>>;
  */
 /// A dynamically sized row vector.
 #[cfg(any(feature = "std", feature = "alloc"))]
-pub type RowDVector<T> = Matrix<T, U1, Dynamic, VecStorage<T, U1, Dynamic>>;
+pub type RowDVector<T> = Matrix<T, U1, Dyn, VecStorage<T, U1, Dyn>>;
 
 /// An owned D-dimensional row vector.
 pub type RowOVector<T, D> = Matrix<T, U1, D, Owned<T, U1, D>>;
diff --git a/src/base/alias_slice.rs b/src/base/alias_slice.rs
index d3f8879a..9c1a9a87 100644
--- a/src/base/alias_slice.rs
+++ b/src/base/alias_slice.rs
@@ -1,4 +1,4 @@
-use crate::base::dimension::{Dynamic, U1, U2, U3, U4, U5, U6};
+use crate::base::dimension::{Dyn, U1, U2, U3, U4, U5, U6};
 use crate::base::matrix_view::{ViewStorage, ViewStorageMut};
 use crate::base::{Const, Matrix};
 use crate::slice_deprecation_note;
@@ -22,8 +22,8 @@ pub type SMatrixSlice<'a, T, const R: usize, const C: usize> =
 ///
 /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
 #[deprecated = slice_deprecation_note!(DMatrixView)]
-pub type DMatrixSlice<'a, T, RStride = U1, CStride = Dynamic> =
-    Matrix<T, Dynamic, Dynamic, ViewStorage<'a, T, Dynamic, Dynamic, RStride, CStride>>;
+pub type DMatrixSlice<'a, T, RStride = U1, CStride = Dyn> =
+    Matrix<T, Dyn, Dyn, ViewStorage<'a, T, Dyn, Dyn, RStride, CStride>>;
 
 /// A column-major 1x1 matrix slice.
 ///
@@ -251,52 +251,52 @@ pub type MatrixSlice6x5<'a, T, RStride = U1, CStride = U6> =
 /// A column-major matrix slice with 1 row and a number of columns chosen at runtime.
 #[deprecated = slice_deprecation_note!(MatrixView1xX)]
 pub type MatrixSlice1xX<'a, T, RStride = U1, CStride = U1> =
-    Matrix<T, U1, Dynamic, ViewStorage<'a, T, U1, Dynamic, RStride, CStride>>;
+    Matrix<T, U1, Dyn, ViewStorage<'a, T, U1, Dyn, RStride, CStride>>;
 /// A column-major matrix slice with 2 rows and a number of columns chosen at runtime.
 #[deprecated = slice_deprecation_note!(MatrixView2xX)]
 pub type MatrixSlice2xX<'a, T, RStride = U1, CStride = U2> =
-    Matrix<T, U2, Dynamic, ViewStorage<'a, T, U2, Dynamic, RStride, CStride>>;
+    Matrix<T, U2, Dyn, ViewStorage<'a, T, U2, Dyn, RStride, CStride>>;
 /// A column-major matrix slice with 3 rows and a number of columns chosen at runtime.
 #[deprecated = slice_deprecation_note!(MatrixView3xX)]
 pub type MatrixSlice3xX<'a, T, RStride = U1, CStride = U3> =
-    Matrix<T, U3, Dynamic, ViewStorage<'a, T, U3, Dynamic, RStride, CStride>>;
+    Matrix<T, U3, Dyn, ViewStorage<'a, T, U3, Dyn, RStride, CStride>>;
 /// A column-major matrix slice with 4 rows and a number of columns chosen at runtime.
 #[deprecated = slice_deprecation_note!(MatrixView4xX)]
 pub type MatrixSlice4xX<'a, T, RStride = U1, CStride = U4> =
-    Matrix<T, U4, Dynamic, ViewStorage<'a, T, U4, Dynamic, RStride, CStride>>;
+    Matrix<T, U4, Dyn, ViewStorage<'a, T, U4, Dyn, RStride, CStride>>;
 /// A column-major matrix slice with 5 rows and a number of columns chosen at runtime.
 #[deprecated = slice_deprecation_note!(MatrixView5xX)]
 pub type MatrixSlice5xX<'a, T, RStride = U1, CStride = U5> =
-    Matrix<T, U5, Dynamic, ViewStorage<'a, T, U5, Dynamic, RStride, CStride>>;
+    Matrix<T, U5, Dyn, ViewStorage<'a, T, U5, Dyn, RStride, CStride>>;
 /// A column-major matrix slice with 6 rows and a number of columns chosen at runtime.
 #[deprecated = slice_deprecation_note!(MatrixView6xX)]
 pub type MatrixSlice6xX<'a, T, RStride = U1, CStride = U6> =
-    Matrix<T, U6, Dynamic, ViewStorage<'a, T, U6, Dynamic, RStride, CStride>>;
+    Matrix<T, U6, Dyn, ViewStorage<'a, T, U6, Dyn, RStride, CStride>>;
 
 /// A column-major matrix slice with a number of rows chosen at runtime and 1 column.
 #[deprecated = slice_deprecation_note!(MatrixViewXx1)]
-pub type MatrixSliceXx1<'a, T, RStride = U1, CStride = Dynamic> =
-    Matrix<T, Dynamic, U1, ViewStorage<'a, T, Dynamic, U1, RStride, CStride>>;
+pub type MatrixSliceXx1<'a, T, RStride = U1, CStride = Dyn> =
+    Matrix<T, Dyn, U1, ViewStorage<'a, T, Dyn, U1, RStride, CStride>>;
 /// A column-major matrix slice with a number of rows chosen at runtime and 2 columns.
 #[deprecated = slice_deprecation_note!(MatrixViewXx2)]
-pub type MatrixSliceXx2<'a, T, RStride = U1, CStride = Dynamic> =
-    Matrix<T, Dynamic, U2, ViewStorage<'a, T, Dynamic, U2, RStride, CStride>>;
+pub type MatrixSliceXx2<'a, T, RStride = U1, CStride = Dyn> =
+    Matrix<T, Dyn, U2, ViewStorage<'a, T, Dyn, U2, RStride, CStride>>;
 /// A column-major matrix slice with a number of rows chosen at runtime and 3 columns.
 #[deprecated = slice_deprecation_note!(MatrixViewXx3)]
-pub type MatrixSliceXx3<'a, T, RStride = U1, CStride = Dynamic> =
-    Matrix<T, Dynamic, U3, ViewStorage<'a, T, Dynamic, U3, RStride, CStride>>;
+pub type MatrixSliceXx3<'a, T, RStride = U1, CStride = Dyn> =
+    Matrix<T, Dyn, U3, ViewStorage<'a, T, Dyn, U3, RStride, CStride>>;
 /// A column-major matrix slice with a number of rows chosen at runtime and 4 columns.
 #[deprecated = slice_deprecation_note!(MatrixViewXx4)]
-pub type MatrixSliceXx4<'a, T, RStride = U1, CStride = Dynamic> =
-    Matrix<T, Dynamic, U4, ViewStorage<'a, T, Dynamic, U4, RStride, CStride>>;
+pub type MatrixSliceXx4<'a, T, RStride = U1, CStride = Dyn> =
+    Matrix<T, Dyn, U4, ViewStorage<'a, T, Dyn, U4, RStride, CStride>>;
 /// A column-major matrix slice with a number of rows chosen at runtime and 5 columns.
 #[deprecated = slice_deprecation_note!(MatrixViewXx5)]
-pub type MatrixSliceXx5<'a, T, RStride = U1, CStride = Dynamic> =
-    Matrix<T, Dynamic, U5, ViewStorage<'a, T, Dynamic, U5, RStride, CStride>>;
+pub type MatrixSliceXx5<'a, T, RStride = U1, CStride = Dyn> =
+    Matrix<T, Dyn, U5, ViewStorage<'a, T, Dyn, U5, RStride, CStride>>;
 /// A column-major matrix slice with a number of rows chosen at runtime and 6 columns.
 #[deprecated = slice_deprecation_note!(MatrixViewXx6)]
-pub type MatrixSliceXx6<'a, T, RStride = U1, CStride = Dynamic> =
-    Matrix<T, Dynamic, U6, ViewStorage<'a, T, Dynamic, U6, RStride, CStride>>;
+pub type MatrixSliceXx6<'a, T, RStride = U1, CStride = Dyn> =
+    Matrix<T, Dyn, U6, ViewStorage<'a, T, Dyn, U6, RStride, CStride>>;
 
 /// A column vector slice with dimensions known at compile-time.
 ///
@@ -314,8 +314,8 @@ pub type SVectorSlice<'a, T, const D: usize> =
 
 /// A column vector slice dynamic numbers of rows and columns.
 #[deprecated = slice_deprecation_note!(DVectorView)]
-pub type DVectorSlice<'a, T, RStride = U1, CStride = Dynamic> =
-    Matrix<T, Dynamic, U1, ViewStorage<'a, T, Dynamic, U1, RStride, CStride>>;
+pub type DVectorSlice<'a, T, RStride = U1, CStride = Dyn> =
+    Matrix<T, Dyn, U1, ViewStorage<'a, T, Dyn, U1, RStride, CStride>>;
 
 /// A 1D column vector slice.
 ///
@@ -386,8 +386,8 @@ pub type SMatrixSliceMut<'a, T, const R: usize, const C: usize> =
 ///
 /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
 #[deprecated = slice_deprecation_note!(DMatrixViewMut)]
-pub type DMatrixSliceMut<'a, T, RStride = U1, CStride = Dynamic> =
-    Matrix<T, Dynamic, Dynamic, ViewStorageMut<'a, T, Dynamic, Dynamic, RStride, CStride>>;
+pub type DMatrixSliceMut<'a, T, RStride = U1, CStride = Dyn> =
+    Matrix<T, Dyn, Dyn, ViewStorageMut<'a, T, Dyn, Dyn, RStride, CStride>>;
 
 /// A column-major 1x1 matrix slice.
 ///
@@ -615,52 +615,52 @@ pub type MatrixSliceMut6x5<'a, T, RStride = U1, CStride = U6> =
 /// A column-major matrix slice with 1 row and a number of columns chosen at runtime.
 #[deprecated = slice_deprecation_note!(MatrixViewMut1xX)]
 pub type MatrixSliceMut1xX<'a, T, RStride = U1, CStride = U1> =
-    Matrix<T, U1, Dynamic, ViewStorageMut<'a, T, U1, Dynamic, RStride, CStride>>;
+    Matrix<T, U1, Dyn, ViewStorageMut<'a, T, U1, Dyn, RStride, CStride>>;
 /// A column-major matrix slice with 2 rows and a number of columns chosen at runtime.
 #[deprecated = slice_deprecation_note!(MatrixViewMut2xX)]
 pub type MatrixSliceMut2xX<'a, T, RStride = U1, CStride = U2> =
-    Matrix<T, U2, Dynamic, ViewStorageMut<'a, T, U2, Dynamic, RStride, CStride>>;
+    Matrix<T, U2, Dyn, ViewStorageMut<'a, T, U2, Dyn, RStride, CStride>>;
 /// A column-major matrix slice with 3 rows and a number of columns chosen at runtime.
 #[deprecated = slice_deprecation_note!(MatrixViewMut3xX)]
 pub type MatrixSliceMut3xX<'a, T, RStride = U1, CStride = U3> =
-    Matrix<T, U3, Dynamic, ViewStorageMut<'a, T, U3, Dynamic, RStride, CStride>>;
+    Matrix<T, U3, Dyn, ViewStorageMut<'a, T, U3, Dyn, RStride, CStride>>;
 /// A column-major matrix slice with 4 rows and a number of columns chosen at runtime.
 #[deprecated = slice_deprecation_note!(MatrixViewMut4xX)]
 pub type MatrixSliceMut4xX<'a, T, RStride = U1, CStride = U4> =
-    Matrix<T, U4, Dynamic, ViewStorageMut<'a, T, U4, Dynamic, RStride, CStride>>;
+    Matrix<T, U4, Dyn, ViewStorageMut<'a, T, U4, Dyn, RStride, CStride>>;
 /// A column-major matrix slice with 5 rows and a number of columns chosen at runtime.
 #[deprecated = slice_deprecation_note!(MatrixViewMut5xX)]
 pub type MatrixSliceMut5xX<'a, T, RStride = U1, CStride = U5> =
-    Matrix<T, U5, Dynamic, ViewStorageMut<'a, T, U5, Dynamic, RStride, CStride>>;
+    Matrix<T, U5, Dyn, ViewStorageMut<'a, T, U5, Dyn, RStride, CStride>>;
 /// A column-major matrix slice with 6 rows and a number of columns chosen at runtime.
 #[deprecated = slice_deprecation_note!(MatrixViewMut6xX)]
 pub type MatrixSliceMut6xX<'a, T, RStride = U1, CStride = U6> =
-    Matrix<T, U6, Dynamic, ViewStorageMut<'a, T, U6, Dynamic, RStride, CStride>>;
+    Matrix<T, U6, Dyn, ViewStorageMut<'a, T, U6, Dyn, RStride, CStride>>;
 
 /// A column-major matrix slice with a number of rows chosen at runtime and 1 column.
 #[deprecated = slice_deprecation_note!(MatrixViewMutXx1)]
-pub type MatrixSliceMutXx1<'a, T, RStride = U1, CStride = Dynamic> =
-    Matrix<T, Dynamic, U1, ViewStorageMut<'a, T, Dynamic, U1, RStride, CStride>>;
+pub type MatrixSliceMutXx1<'a, T, RStride = U1, CStride = Dyn> =
+    Matrix<T, Dyn, U1, ViewStorageMut<'a, T, Dyn, U1, RStride, CStride>>;
 /// A column-major matrix slice with a number of rows chosen at runtime and 2 columns.
 #[deprecated = slice_deprecation_note!(MatrixViewMutXx2)]
-pub type MatrixSliceMutXx2<'a, T, RStride = U1, CStride = Dynamic> =
-    Matrix<T, Dynamic, U2, ViewStorageMut<'a, T, Dynamic, U2, RStride, CStride>>;
+pub type MatrixSliceMutXx2<'a, T, RStride = U1, CStride = Dyn> =
+    Matrix<T, Dyn, U2, ViewStorageMut<'a, T, Dyn, U2, RStride, CStride>>;
 /// A column-major matrix slice with a number of rows chosen at runtime and 3 columns.
 #[deprecated = slice_deprecation_note!(MatrixViewMutXx3)]
-pub type MatrixSliceMutXx3<'a, T, RStride = U1, CStride = Dynamic> =
-    Matrix<T, Dynamic, U3, ViewStorageMut<'a, T, Dynamic, U3, RStride, CStride>>;
+pub type MatrixSliceMutXx3<'a, T, RStride = U1, CStride = Dyn> =
+    Matrix<T, Dyn, U3, ViewStorageMut<'a, T, Dyn, U3, RStride, CStride>>;
 /// A column-major matrix slice with a number of rows chosen at runtime and 4 columns.
 #[deprecated = slice_deprecation_note!(MatrixViewMutXx4)]
-pub type MatrixSliceMutXx4<'a, T, RStride = U1, CStride = Dynamic> =
-    Matrix<T, Dynamic, U4, ViewStorageMut<'a, T, Dynamic, U4, RStride, CStride>>;
+pub type MatrixSliceMutXx4<'a, T, RStride = U1, CStride = Dyn> =
+    Matrix<T, Dyn, U4, ViewStorageMut<'a, T, Dyn, U4, RStride, CStride>>;
 /// A column-major matrix slice with a number of rows chosen at runtime and 5 columns.
 #[deprecated = slice_deprecation_note!(MatrixViewMutXx5)]
-pub type MatrixSliceMutXx5<'a, T, RStride = U1, CStride = Dynamic> =
-    Matrix<T, Dynamic, U5, ViewStorageMut<'a, T, Dynamic, U5, RStride, CStride>>;
+pub type MatrixSliceMutXx5<'a, T, RStride = U1, CStride = Dyn> =
+    Matrix<T, Dyn, U5, ViewStorageMut<'a, T, Dyn, U5, RStride, CStride>>;
 /// A column-major matrix slice with a number of rows chosen at runtime and 6 columns.
 #[deprecated = slice_deprecation_note!(MatrixViewMutXx6)]
-pub type MatrixSliceMutXx6<'a, T, RStride = U1, CStride = Dynamic> =
-    Matrix<T, Dynamic, U6, ViewStorageMut<'a, T, Dynamic, U6, RStride, CStride>>;
+pub type MatrixSliceMutXx6<'a, T, RStride = U1, CStride = Dyn> =
+    Matrix<T, Dyn, U6, ViewStorageMut<'a, T, Dyn, U6, RStride, CStride>>;
 
 /// A column vector slice with dimensions known at compile-time.
 ///
@@ -680,8 +680,8 @@ pub type SVectorSliceMut<'a, T, const D: usize> =
 ///
 /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
 #[deprecated = slice_deprecation_note!(DVectorViewMut)]
-pub type DVectorSliceMut<'a, T, RStride = U1, CStride = Dynamic> =
-    Matrix<T, Dynamic, U1, ViewStorageMut<'a, T, Dynamic, U1, RStride, CStride>>;
+pub type DVectorSliceMut<'a, T, RStride = U1, CStride = Dyn> =
+    Matrix<T, Dyn, U1, ViewStorageMut<'a, T, Dyn, U1, RStride, CStride>>;
 
 /// A 1D column vector slice.
 ///
diff --git a/src/base/alias_view.rs b/src/base/alias_view.rs
index 1bbee3f8..26da6f47 100644
--- a/src/base/alias_view.rs
+++ b/src/base/alias_view.rs
@@ -1,4 +1,4 @@
-use crate::base::dimension::{Dynamic, U1, U2, U3, U4, U5, U6};
+use crate::base::dimension::{Dyn, U1, U2, U3, U4, U5, U6};
 use crate::base::matrix_view::{ViewStorage, ViewStorageMut};
 use crate::base::{Const, Matrix};
 
@@ -19,8 +19,8 @@ pub type SMatrixView<'a, T, const R: usize, const C: usize> =
 /// 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<T, Dynamic, Dynamic, ViewStorage<'a, T, Dynamic, Dynamic, RStride, CStride>>;
+pub type DMatrixView<'a, T, RStride = U1, CStride = Dyn> =
+    Matrix<T, Dyn, Dyn, ViewStorage<'a, T, Dyn, Dyn, RStride, CStride>>;
 
 /// A column-major 1x1 matrix view.
 ///
@@ -211,41 +211,41 @@ pub type MatrixView6x5<'a, T, RStride = U1, CStride = U6> =
 
 /// 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<T, U1, Dynamic, ViewStorage<'a, T, U1, Dynamic, RStride, CStride>>;
+    Matrix<T, U1, Dyn, ViewStorage<'a, T, U1, Dyn, RStride, CStride>>;
 /// 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<T, U2, Dynamic, ViewStorage<'a, T, U2, Dynamic, RStride, CStride>>;
+    Matrix<T, U2, Dyn, ViewStorage<'a, T, U2, Dyn, RStride, CStride>>;
 /// 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<T, U3, Dynamic, ViewStorage<'a, T, U3, Dynamic, RStride, CStride>>;
+    Matrix<T, U3, Dyn, ViewStorage<'a, T, U3, Dyn, RStride, CStride>>;
 /// 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<T, U4, Dynamic, ViewStorage<'a, T, U4, Dynamic, RStride, CStride>>;
+    Matrix<T, U4, Dyn, ViewStorage<'a, T, U4, Dyn, RStride, CStride>>;
 /// 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<T, U5, Dynamic, ViewStorage<'a, T, U5, Dynamic, RStride, CStride>>;
+    Matrix<T, U5, Dyn, ViewStorage<'a, T, U5, Dyn, RStride, CStride>>;
 /// 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<T, U6, Dynamic, ViewStorage<'a, T, U6, Dynamic, RStride, CStride>>;
+    Matrix<T, U6, Dyn, ViewStorage<'a, T, U6, Dyn, RStride, CStride>>;
 
 /// 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<T, Dynamic, U1, ViewStorage<'a, T, Dynamic, U1, RStride, CStride>>;
+pub type MatrixViewXx1<'a, T, RStride = U1, CStride = Dyn> =
+    Matrix<T, Dyn, U1, ViewStorage<'a, T, Dyn, U1, RStride, CStride>>;
 /// 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<T, Dynamic, U2, ViewStorage<'a, T, Dynamic, U2, RStride, CStride>>;
+pub type MatrixViewXx2<'a, T, RStride = U1, CStride = Dyn> =
+    Matrix<T, Dyn, U2, ViewStorage<'a, T, Dyn, U2, RStride, CStride>>;
 /// 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<T, Dynamic, U3, ViewStorage<'a, T, Dynamic, U3, RStride, CStride>>;
+pub type MatrixViewXx3<'a, T, RStride = U1, CStride = Dyn> =
+    Matrix<T, Dyn, U3, ViewStorage<'a, T, Dyn, U3, RStride, CStride>>;
 /// 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<T, Dynamic, U4, ViewStorage<'a, T, Dynamic, U4, RStride, CStride>>;
+pub type MatrixViewXx4<'a, T, RStride = U1, CStride = Dyn> =
+    Matrix<T, Dyn, U4, ViewStorage<'a, T, Dyn, U4, RStride, CStride>>;
 /// 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<T, Dynamic, U5, ViewStorage<'a, T, Dynamic, U5, RStride, CStride>>;
+pub type MatrixViewXx5<'a, T, RStride = U1, CStride = Dyn> =
+    Matrix<T, Dyn, U5, ViewStorage<'a, T, Dyn, U5, RStride, CStride>>;
 /// 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<T, Dynamic, U6, ViewStorage<'a, T, Dynamic, U6, RStride, CStride>>;
+pub type MatrixViewXx6<'a, T, RStride = U1, CStride = Dyn> =
+    Matrix<T, Dyn, U6, ViewStorage<'a, T, Dyn, U6, RStride, CStride>>;
 
 /// A column vector view with dimensions known at compile-time.
 ///
@@ -260,8 +260,8 @@ pub type SVectorView<'a, T, const D: usize> =
     Matrix<T, Const<D>, Const<1>, ViewStorage<'a, T, Const<D>, Const<1>, Const<1>, Const<D>>>;
 
 /// A column vector view dynamic numbers of rows and columns.
-pub type DVectorView<'a, T, RStride = U1, CStride = Dynamic> =
-    Matrix<T, Dynamic, U1, ViewStorage<'a, T, Dynamic, U1, RStride, CStride>>;
+pub type DVectorView<'a, T, RStride = U1, CStride = Dyn> =
+    Matrix<T, Dyn, U1, ViewStorage<'a, T, Dyn, U1, RStride, CStride>>;
 
 /// A 1D column vector view.
 ///
@@ -311,8 +311,8 @@ pub type SMatrixViewMut<'a, T, const R: usize, const C: usize> =
 /// 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<T, Dynamic, Dynamic, ViewStorageMut<'a, T, Dynamic, Dynamic, RStride, CStride>>;
+pub type DMatrixViewMut<'a, T, RStride = U1, CStride = Dyn> =
+    Matrix<T, Dyn, Dyn, ViewStorageMut<'a, T, Dyn, Dyn, RStride, CStride>>;
 
 /// A column-major 1x1 matrix view.
 ///
@@ -503,41 +503,41 @@ pub type MatrixViewMut6x5<'a, T, RStride = U1, CStride = U6> =
 
 /// 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<T, U1, Dynamic, ViewStorageMut<'a, T, U1, Dynamic, RStride, CStride>>;
+    Matrix<T, U1, Dyn, ViewStorageMut<'a, T, U1, Dyn, RStride, CStride>>;
 /// 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<T, U2, Dynamic, ViewStorageMut<'a, T, U2, Dynamic, RStride, CStride>>;
+    Matrix<T, U2, Dyn, ViewStorageMut<'a, T, U2, Dyn, RStride, CStride>>;
 /// 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<T, U3, Dynamic, ViewStorageMut<'a, T, U3, Dynamic, RStride, CStride>>;
+    Matrix<T, U3, Dyn, ViewStorageMut<'a, T, U3, Dyn, RStride, CStride>>;
 /// 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<T, U4, Dynamic, ViewStorageMut<'a, T, U4, Dynamic, RStride, CStride>>;
+    Matrix<T, U4, Dyn, ViewStorageMut<'a, T, U4, Dyn, RStride, CStride>>;
 /// 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<T, U5, Dynamic, ViewStorageMut<'a, T, U5, Dynamic, RStride, CStride>>;
+    Matrix<T, U5, Dyn, ViewStorageMut<'a, T, U5, Dyn, RStride, CStride>>;
 /// 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<T, U6, Dynamic, ViewStorageMut<'a, T, U6, Dynamic, RStride, CStride>>;
+    Matrix<T, U6, Dyn, ViewStorageMut<'a, T, U6, Dyn, RStride, CStride>>;
 
 /// 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<T, Dynamic, U1, ViewStorageMut<'a, T, Dynamic, U1, RStride, CStride>>;
+pub type MatrixViewMutXx1<'a, T, RStride = U1, CStride = Dyn> =
+    Matrix<T, Dyn, U1, ViewStorageMut<'a, T, Dyn, U1, RStride, CStride>>;
 /// 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<T, Dynamic, U2, ViewStorageMut<'a, T, Dynamic, U2, RStride, CStride>>;
+pub type MatrixViewMutXx2<'a, T, RStride = U1, CStride = Dyn> =
+    Matrix<T, Dyn, U2, ViewStorageMut<'a, T, Dyn, U2, RStride, CStride>>;
 /// 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<T, Dynamic, U3, ViewStorageMut<'a, T, Dynamic, U3, RStride, CStride>>;
+pub type MatrixViewMutXx3<'a, T, RStride = U1, CStride = Dyn> =
+    Matrix<T, Dyn, U3, ViewStorageMut<'a, T, Dyn, U3, RStride, CStride>>;
 /// 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<T, Dynamic, U4, ViewStorageMut<'a, T, Dynamic, U4, RStride, CStride>>;
+pub type MatrixViewMutXx4<'a, T, RStride = U1, CStride = Dyn> =
+    Matrix<T, Dyn, U4, ViewStorageMut<'a, T, Dyn, U4, RStride, CStride>>;
 /// 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<T, Dynamic, U5, ViewStorageMut<'a, T, Dynamic, U5, RStride, CStride>>;
+pub type MatrixViewMutXx5<'a, T, RStride = U1, CStride = Dyn> =
+    Matrix<T, Dyn, U5, ViewStorageMut<'a, T, Dyn, U5, RStride, CStride>>;
 /// 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<T, Dynamic, U6, ViewStorageMut<'a, T, Dynamic, U6, RStride, CStride>>;
+pub type MatrixViewMutXx6<'a, T, RStride = U1, CStride = Dyn> =
+    Matrix<T, Dyn, U6, ViewStorageMut<'a, T, Dyn, U6, RStride, CStride>>;
 
 /// A column vector view with dimensions known at compile-time.
 ///
@@ -554,8 +554,8 @@ pub type SVectorViewMut<'a, T, const D: usize> =
 /// 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<T, Dynamic, U1, ViewStorageMut<'a, T, Dynamic, U1, RStride, CStride>>;
+pub type DVectorViewMut<'a, T, RStride = U1, CStride = Dyn> =
+    Matrix<T, Dyn, U1, ViewStorageMut<'a, T, Dyn, U1, RStride, CStride>>;
 
 /// A 1D column vector view.
 ///
diff --git a/src/base/allocator.rs b/src/base/allocator.rs
index bb227d3b..6458b8cb 100644
--- a/src/base/allocator.rs
+++ b/src/base/allocator.rs
@@ -15,7 +15,7 @@ use std::mem::MaybeUninit;
 ///
 /// An allocator is said to be:
 ///   − static:  if `R` and `C` both implement `DimName`.
-///   − dynamic: if either one (or both) of `R` or `C` is equal to `Dynamic`.
+///   − dynamic: if either one (or both) of `R` or `C` is equal to `Dyn`.
 ///
 /// Every allocator must be both static and dynamic. Though not all implementations may share the
 /// same `Buffer` type.
diff --git a/src/base/blas.rs b/src/base/blas.rs
index 9d9dd2bd..e5741568 100644
--- a/src/base/blas.rs
+++ b/src/base/blas.rs
@@ -7,7 +7,7 @@ use crate::base::blas_uninit::{axcpy_uninit, gemm_uninit, gemv_uninit};
 use crate::base::constraint::{
     AreMultipliable, DimEq, SameNumberOfColumns, SameNumberOfRows, ShapeConstraint,
 };
-use crate::base::dimension::{Const, Dim, Dynamic, U1, U2, U3, U4};
+use crate::base::dimension::{Const, Dim, Dyn, U1, U2, U3, U4};
 use crate::base::storage::{Storage, StorageMut};
 use crate::base::uninit::Init;
 use crate::base::{
@@ -890,7 +890,7 @@ where
 
         for j in 0..dim1 {
             let val = unsafe { conjugate(y.vget_unchecked(j).clone()) };
-            let subdim = Dynamic::new(dim1 - j);
+            let subdim = Dyn(dim1 - j);
             // TODO: avoid bound checks.
             self.generic_view_mut((j, j), (subdim, Const::<1>)).axpy(
                 alpha.clone() * val,
diff --git a/src/base/blas_uninit.rs b/src/base/blas_uninit.rs
index 7e449d7d..3fcfa6e1 100644
--- a/src/base/blas_uninit.rs
+++ b/src/base/blas_uninit.rs
@@ -18,7 +18,7 @@ use std::mem;
 use crate::base::constraint::{
     AreMultipliable, DimEq, SameNumberOfColumns, SameNumberOfRows, ShapeConstraint,
 };
-use crate::base::dimension::{Dim, Dynamic, U1};
+use crate::base::dimension::{Dim, Dyn, U1};
 use crate::base::storage::{RawStorage, RawStorageMut};
 use crate::base::uninit::InitStatus;
 use crate::base::{Matrix, Scalar, Vector};
@@ -209,16 +209,16 @@ pub unsafe fn gemm_uninit<
 
     #[cfg(feature = "std")]
     {
-        // We assume large matrices will be Dynamic but small matrices static.
+        // We assume large matrices will be Dyn but small matrices static.
         // We could use matrixmultiply for large statically-sized matrices but the performance
         // threshold to activate it would be different from SMALL_DIM because our code optimizes
         // better for statically-sized matrices.
-        if R1::is::<Dynamic>()
-            || C1::is::<Dynamic>()
-            || R2::is::<Dynamic>()
-            || C2::is::<Dynamic>()
-            || R3::is::<Dynamic>()
-            || C3::is::<Dynamic>()
+        if R1::is::<Dyn>()
+            || C1::is::<Dyn>()
+            || R2::is::<Dyn>()
+            || C2::is::<Dyn>()
+            || R3::is::<Dyn>()
+            || C3::is::<Dyn>()
         {
             // matrixmultiply can be used only if the std feature is available.
             let nrows1 = y.nrows();
diff --git a/src/base/constraint.rs b/src/base/constraint.rs
index b8febd03..5aecc279 100644
--- a/src/base/constraint.rs
+++ b/src/base/constraint.rs
@@ -1,6 +1,6 @@
 //! Compatibility constraints between matrix shapes, e.g., for addition or multiplication.
 
-use crate::base::dimension::{Dim, DimName, Dynamic};
+use crate::base::dimension::{Dim, DimName, Dyn};
 
 /// A type used in `where` clauses for enforcing constraints.
 #[derive(Copy, Clone, Debug)]
@@ -25,11 +25,11 @@ impl<D: Dim> DimEq<D, D> for ShapeConstraint {
     type Representative = D;
 }
 
-impl<D: DimName> DimEq<D, Dynamic> for ShapeConstraint {
+impl<D: DimName> DimEq<D, Dyn> for ShapeConstraint {
     type Representative = D;
 }
 
-impl<D: DimName> DimEq<Dynamic, D> for ShapeConstraint {
+impl<D: DimName> DimEq<Dyn, D> for ShapeConstraint {
     type Representative = D;
 }
 
@@ -47,11 +47,11 @@ macro_rules! equality_trait_decl(
             type Representative = D;
         }
 
-        impl<D: DimName> $Trait<D, Dynamic> for ShapeConstraint {
+        impl<D: DimName> $Trait<D, Dyn> for ShapeConstraint {
             type Representative = D;
         }
 
-        impl<D: DimName> $Trait<Dynamic, D> for ShapeConstraint {
+        impl<D: DimName> $Trait<Dyn, D> for ShapeConstraint {
             type Representative = D;
         }
     )*}
@@ -82,10 +82,10 @@ impl<D: Dim> SameDimension<D, D> for ShapeConstraint {
     type Representative = D;
 }
 
-impl<D: DimName> SameDimension<D, Dynamic> for ShapeConstraint {
+impl<D: DimName> SameDimension<D, Dyn> for ShapeConstraint {
     type Representative = D;
 }
 
-impl<D: DimName> SameDimension<Dynamic, D> for ShapeConstraint {
+impl<D: DimName> SameDimension<Dyn, D> for ShapeConstraint {
     type Representative = D;
 }
diff --git a/src/base/construction.rs b/src/base/construction.rs
index 009d8c76..aabe75d8 100644
--- a/src/base/construction.rs
+++ b/src/base/construction.rs
@@ -19,7 +19,7 @@ use typenum::{self, Cmp, Greater};
 use simba::scalar::{ClosedAdd, ClosedMul};
 
 use crate::base::allocator::Allocator;
-use crate::base::dimension::{Dim, DimName, Dynamic, ToTypenum};
+use crate::base::dimension::{Dim, DimName, Dyn, ToTypenum};
 use crate::base::storage::RawStorage;
 use crate::base::{
     ArrayStorage, Const, DefaultAllocator, Matrix, OMatrix, OVector, Scalar, Unit, Vector,
@@ -317,12 +317,12 @@ where
     ///
     /// # Example
     /// ```
-    /// # use nalgebra::{Dynamic, DMatrix, Matrix, Const};
+    /// # use nalgebra::{Dyn, DMatrix, Matrix, Const};
     ///
     /// let vec = vec![0, 1, 2, 3, 4, 5];
     /// let vec_ptr = vec.as_ptr();
     ///
-    /// let matrix = Matrix::from_vec_generic(Dynamic::new(vec.len()), Const::<1>, vec);
+    /// let matrix = Matrix::from_vec_generic(Dyn(vec.len()), Const::<1>, vec);
     /// let matrix_storage_ptr = matrix.data.as_vec().as_ptr();
     ///
     /// // `matrix` is backed by exactly the same `Vec` as it was constructed from.
@@ -656,35 +656,35 @@ where
 }
 
 /// # Constructors of matrices with a dynamic number of columns
-impl<T: Scalar, R: DimName> OMatrix<T, R, Dynamic>
+impl<T: Scalar, R: DimName> OMatrix<T, R, Dyn>
 where
-    DefaultAllocator: Allocator<T, R, Dynamic>,
+    DefaultAllocator: Allocator<T, R, Dyn>,
 {
-    impl_constructors!(R, Dynamic;
+    impl_constructors!(R, Dyn;
                    => R: DimName;
-                   R::name(), Dynamic::new(ncols);
+                   R::name(), Dyn(ncols);
                    ncols);
 }
 
 /// # Constructors of dynamic vectors and matrices with a dynamic number of rows
-impl<T: Scalar, C: DimName> OMatrix<T, Dynamic, C>
+impl<T: Scalar, C: DimName> OMatrix<T, Dyn, C>
 where
-    DefaultAllocator: Allocator<T, Dynamic, C>,
+    DefaultAllocator: Allocator<T, Dyn, C>,
 {
-    impl_constructors!(Dynamic, C;
+    impl_constructors!(Dyn, C;
                    => C: DimName;
-                   Dynamic::new(nrows), C::name();
+                   Dyn(nrows), C::name();
                    nrows);
 }
 
 /// # Constructors of fully dynamic matrices
-impl<T: Scalar> OMatrix<T, Dynamic, Dynamic>
+impl<T: Scalar> OMatrix<T, Dyn, Dyn>
 where
-    DefaultAllocator: Allocator<T, Dynamic, Dynamic>,
+    DefaultAllocator: Allocator<T, Dyn, Dyn>,
 {
-    impl_constructors!(Dynamic, Dynamic;
+    impl_constructors!(Dyn, Dyn;
                    ;
-                   Dynamic::new(nrows), Dynamic::new(ncols);
+                   Dyn(nrows), Dyn(ncols);
                    nrows, ncols);
 }
 
@@ -790,19 +790,19 @@ impl_constructors_from_data!(data; R, C;                  // Arguments for Matri
 R::name(), C::name();         // Arguments for `_generic` constructors.
 ); // Arguments for non-generic constructors.
 
-impl_constructors_from_data!(data; R, Dynamic;
+impl_constructors_from_data!(data; R, Dyn;
 => R: DimName;
-R::name(), Dynamic::new(data.len() / R::dim());
+R::name(), Dyn(data.len() / R::dim());
 );
 
-impl_constructors_from_data!(data; Dynamic, C;
+impl_constructors_from_data!(data; Dyn, C;
 => C: DimName;
-Dynamic::new(data.len() / C::dim()), C::name();
+Dyn(data.len() / C::dim()), C::name();
 );
 
-impl_constructors_from_data!(data; Dynamic, Dynamic;
+impl_constructors_from_data!(data; Dyn, Dyn;
                             ;
-                            Dynamic::new(nrows), Dynamic::new(ncols);
+                            Dyn(nrows), Dyn(ncols);
                             nrows, ncols);
 
 /*
diff --git a/src/base/construction_view.rs b/src/base/construction_view.rs
index 910b2873..8584f5b2 100644
--- a/src/base/construction_view.rs
+++ b/src/base/construction_view.rs
@@ -1,4 +1,4 @@
-use crate::base::dimension::{Const, Dim, DimName, Dynamic};
+use crate::base::dimension::{Const, Dim, DimName, Dyn};
 use crate::base::matrix_view::{ViewStorage, ViewStorageMut};
 use crate::base::{MatrixView, MatrixViewMut, Scalar};
 
@@ -12,7 +12,7 @@ impl<'a, T: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim>
     ///
     /// # Safety
     /// This method is unsafe because the input data array is not checked to contain enough elements.
-    /// The generic types `R`, `C`, `RStride`, `CStride` can either be type-level integers or integers wrapped with `Dynamic::new()`.
+    /// The generic types `R`, `C`, `RStride`, `CStride` can either be type-level integers or integers wrapped with `Dyn()`.
     #[inline]
     pub unsafe fn from_slice_with_strides_generic_unchecked(
         data: &'a [T],
@@ -33,7 +33,7 @@ impl<'a, T: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim>
     /// 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()`.
+    /// The generic types `R`, `C`, `RStride`, `CStride` can either be type-level integers or integers wrapped with `Dyn()`.
     #[inline]
     pub fn from_slice_with_strides_generic(
         data: &'a [T],
@@ -62,7 +62,7 @@ impl<'a, T: Scalar, R: Dim, C: Dim> MatrixView<'a, T, R, C> {
     ///
     /// # Safety
     /// This method is unsafe because the input data array is not checked to contain enough elements.
-    /// The generic types `R` and `C` can either be type-level integers or integers wrapped with `Dynamic::new()`.
+    /// The generic types `R` and `C` can either be type-level integers or integers wrapped with `Dyn()`.
     #[inline]
     pub unsafe fn from_slice_generic_unchecked(
         data: &'a [T],
@@ -78,7 +78,7 @@ impl<'a, T: Scalar, R: Dim, C: Dim> MatrixView<'a, T, R, C> {
     /// 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()`.
+    /// The generic types `R` and `C` can either be type-level integers or integers wrapped with `Dyn()`.
     #[inline]
     pub fn from_slice_generic(data: &'a [T], nrows: R, ncols: C) -> Self {
         Self::from_slice_with_strides_generic(data, nrows, ncols, Const::<1>, nrows)
@@ -103,19 +103,19 @@ macro_rules! impl_constructors(
             }
         }
 
-        impl<'a, T: Scalar, $($DimIdent: $DimBound, )*> MatrixView<'a, T, $($Dims,)* Dynamic, Dynamic> {
+        impl<'a, T: Scalar, $($DimIdent: $DimBound, )*> MatrixView<'a, T, $($Dims,)* Dyn, Dyn> {
             /// Creates a new matrix view with the specified strides from the given data array.
             ///
             /// Panics if `data` does not contain enough elements.
             #[inline]
             pub fn from_slice_with_strides(data: &'a [T], $($args: usize,)* rstride: usize, cstride: usize) -> Self {
-                Self::from_slice_with_strides_generic(data, $($gargs,)* Dynamic::new(rstride), Dynamic::new(cstride))
+                Self::from_slice_with_strides_generic(data, $($gargs,)* Dyn(rstride), Dyn(cstride))
             }
 
             /// 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))
+                Self::from_slice_with_strides_generic_unchecked(data, start, $($gargs,)* Dyn(rstride), Dyn(cstride))
             }
         }
     }
@@ -127,19 +127,19 @@ impl_constructors!(R, C;                         // Arguments for Matrix<T, ...,
 R::name(), C::name();         // Arguments for `_generic` constructors.
 ); // Arguments for non-generic constructors.
 
-impl_constructors!(R, Dynamic;
+impl_constructors!(R, Dyn;
                    => R: DimName;
-                   R::name(), Dynamic::new(ncols);
+                   R::name(), Dyn(ncols);
                    ncols);
 
-impl_constructors!(Dynamic, C;
+impl_constructors!(Dyn, C;
                    => C: DimName;
-                   Dynamic::new(nrows), C::name();
+                   Dyn(nrows), C::name();
                    nrows);
 
-impl_constructors!(Dynamic, Dynamic;
+impl_constructors!(Dyn, Dyn;
                    ;
-                   Dynamic::new(nrows), Dynamic::new(ncols);
+                   Dyn(nrows), Dyn(ncols);
                    nrows, ncols);
 
 /// # Creating mutable matrix views from `&mut [T]`
@@ -150,7 +150,7 @@ impl<'a, T: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim>
     ///
     /// # Safety
     /// This method is unsafe because the input data array is not checked to contain enough elements.
-    /// The generic types `R`, `C`, `RStride`, `CStride` can either be type-level integers or integers wrapped with `Dynamic::new()`.
+    /// The generic types `R`, `C`, `RStride`, `CStride` can either be type-level integers or integers wrapped with `Dyn()`.
     #[inline]
     pub unsafe fn from_slice_with_strides_generic_unchecked(
         data: &'a mut [T],
@@ -171,7 +171,7 @@ impl<'a, T: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim>
     /// 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()`.
+    /// The generic types `R`, `C`, `RStride`, `CStride` can either be type-level integers or integers wrapped with `Dyn()`.
     #[inline]
     pub fn from_slice_with_strides_generic(
         data: &'a mut [T],
@@ -222,7 +222,7 @@ impl<'a, T: Scalar, R: Dim, C: Dim> MatrixViewMut<'a, T, R, C> {
     ///
     /// # Safety
     /// This method is unsafe because the input data array is not checked to contain enough elements.
-    /// The generic types `R` and `C` can either be type-level integers or integers wrapped with `Dynamic::new()`.
+    /// The generic types `R` and `C` can either be type-level integers or integers wrapped with `Dyn()`.
     #[inline]
     pub unsafe fn from_slice_generic_unchecked(
         data: &'a mut [T],
@@ -238,7 +238,7 @@ impl<'a, T: Scalar, R: Dim, C: Dim> MatrixViewMut<'a, T, R, C> {
     /// 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()`.
+    /// The generic types `R` and `C` can either be type-level integers or integers wrapped with `Dyn()`.
     #[inline]
     pub fn from_slice_generic(data: &'a mut [T], nrows: R, ncols: C) -> Self {
         Self::from_slice_with_strides_generic(data, nrows, ncols, Const::<1>, nrows)
@@ -263,21 +263,21 @@ macro_rules! impl_constructors_mut(
             }
         }
 
-        impl<'a, T: Scalar, $($DimIdent: $DimBound, )*> MatrixViewMut<'a, T, $($Dims,)* Dynamic, Dynamic> {
+        impl<'a, T: Scalar, $($DimIdent: $DimBound, )*> MatrixViewMut<'a, T, $($Dims,)* Dyn, Dyn> {
             /// Creates a new mutable matrix view with the specified strides from the given data array.
             ///
             /// Panics if `data` does not contain enough elements.
             #[inline]
             pub fn from_slice_with_strides_mut(data: &'a mut [T], $($args: usize,)* rstride: usize, cstride: usize) -> Self {
                 Self::from_slice_with_strides_generic(
-                    data, $($gargs,)* Dynamic::new(rstride), Dynamic::new(cstride))
+                    data, $($gargs,)* Dyn(rstride), Dyn(cstride))
             }
 
             /// 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(
-                    data, start, $($gargs,)* Dynamic::new(rstride), Dynamic::new(cstride))
+                    data, start, $($gargs,)* Dyn(rstride), Dyn(cstride))
             }
         }
     }
@@ -289,17 +289,17 @@ impl_constructors_mut!(R, C;                         // Arguments for Matrix<T,
 R::name(), C::name();         // Arguments for `_generic` constructors.
 ); // Arguments for non-generic constructors.
 
-impl_constructors_mut!(R, Dynamic;
+impl_constructors_mut!(R, Dyn;
                        => R: DimName;
-                       R::name(), Dynamic::new(ncols);
+                       R::name(), Dyn(ncols);
                        ncols);
 
-impl_constructors_mut!(Dynamic, C;
+impl_constructors_mut!(Dyn, C;
                        => C: DimName;
-                       Dynamic::new(nrows), C::name();
+                       Dyn(nrows), C::name();
                        nrows);
 
-impl_constructors_mut!(Dynamic, Dynamic;
+impl_constructors_mut!(Dyn, Dyn;
                        ;
-                       Dynamic::new(nrows), Dynamic::new(ncols);
+                       Dyn(nrows), Dyn(ncols);
                        nrows, ncols);
diff --git a/src/base/conversion.rs b/src/base/conversion.rs
index 02f72a43..22774287 100644
--- a/src/base/conversion.rs
+++ b/src/base/conversion.rs
@@ -9,7 +9,7 @@ use simba::simd::{PrimitiveSimdValue, SimdValue};
 use crate::base::allocator::{Allocator, SameShapeAllocator};
 use crate::base::constraint::{SameNumberOfColumns, SameNumberOfRows, ShapeConstraint};
 #[cfg(any(feature = "std", feature = "alloc"))]
-use crate::base::dimension::Dynamic;
+use crate::base::dimension::Dyn;
 use crate::base::dimension::{
     Const, Dim, DimName, U1, U10, U11, U12, U13, U14, U15, U16, U2, U3, U4, U5, U6, U7, U8, U9,
 };
@@ -302,29 +302,29 @@ where
 }
 
 #[cfg(any(feature = "std", feature = "alloc"))]
-impl<'a, T, C, RStride, CStride> From<MatrixView<'a, T, Dynamic, C, RStride, CStride>>
-    for Matrix<T, Dynamic, C, VecStorage<T, Dynamic, C>>
+impl<'a, T, C, RStride, CStride> From<MatrixView<'a, T, Dyn, C, RStride, CStride>>
+    for Matrix<T, Dyn, C, VecStorage<T, Dyn, C>>
 where
     T: Scalar,
     C: Dim,
     RStride: Dim,
     CStride: Dim,
 {
-    fn from(matrix_view: MatrixView<'a, T, Dynamic, C, RStride, CStride>) -> Self {
+    fn from(matrix_view: MatrixView<'a, T, Dyn, C, RStride, CStride>) -> Self {
         matrix_view.into_owned()
     }
 }
 
 #[cfg(any(feature = "std", feature = "alloc"))]
-impl<'a, T, R, RStride, CStride> From<MatrixView<'a, T, R, Dynamic, RStride, CStride>>
-    for Matrix<T, R, Dynamic, VecStorage<T, R, Dynamic>>
+impl<'a, T, R, RStride, CStride> From<MatrixView<'a, T, R, Dyn, RStride, CStride>>
+    for Matrix<T, R, Dyn, VecStorage<T, R, Dyn>>
 where
     T: Scalar,
     R: DimName,
     RStride: Dim,
     CStride: Dim,
 {
-    fn from(matrix_view: MatrixView<'a, T, R, Dynamic, RStride, CStride>) -> Self {
+    fn from(matrix_view: MatrixView<'a, T, R, Dyn, RStride, CStride>) -> Self {
         matrix_view.into_owned()
     }
 }
@@ -343,29 +343,29 @@ where
 }
 
 #[cfg(any(feature = "std", feature = "alloc"))]
-impl<'a, T, C, RStride, CStride> From<MatrixViewMut<'a, T, Dynamic, C, RStride, CStride>>
-    for Matrix<T, Dynamic, C, VecStorage<T, Dynamic, C>>
+impl<'a, T, C, RStride, CStride> From<MatrixViewMut<'a, T, Dyn, C, RStride, CStride>>
+    for Matrix<T, Dyn, C, VecStorage<T, Dyn, C>>
 where
     T: Scalar,
     C: Dim,
     RStride: Dim,
     CStride: Dim,
 {
-    fn from(matrix_view: MatrixViewMut<'a, T, Dynamic, C, RStride, CStride>) -> Self {
+    fn from(matrix_view: MatrixViewMut<'a, T, Dyn, C, RStride, CStride>) -> Self {
         matrix_view.into_owned()
     }
 }
 
 #[cfg(any(feature = "std", feature = "alloc"))]
-impl<'a, T, R, RStride, CStride> From<MatrixViewMut<'a, T, R, Dynamic, RStride, CStride>>
-    for Matrix<T, R, Dynamic, VecStorage<T, R, Dynamic>>
+impl<'a, T, R, RStride, CStride> From<MatrixViewMut<'a, T, R, Dyn, RStride, CStride>>
+    for Matrix<T, R, Dyn, VecStorage<T, R, Dyn>>
 where
     T: Scalar,
     R: DimName,
     RStride: Dim,
     CStride: Dim,
 {
-    fn from(matrix_view: MatrixViewMut<'a, T, R, Dynamic, RStride, CStride>) -> Self {
+    fn from(matrix_view: MatrixViewMut<'a, T, R, Dyn, RStride, CStride>) -> Self {
         matrix_view.into_owned()
     }
 }
diff --git a/src/base/default_allocator.rs b/src/base/default_allocator.rs
index 6aaadfc7..ff645d62 100644
--- a/src/base/default_allocator.rs
+++ b/src/base/default_allocator.rs
@@ -13,7 +13,7 @@ use super::Const;
 use crate::base::allocator::{Allocator, Reallocator};
 use crate::base::array_storage::ArrayStorage;
 #[cfg(any(feature = "alloc", feature = "std"))]
-use crate::base::dimension::Dynamic;
+use crate::base::dimension::Dyn;
 use crate::base::dimension::{Dim, DimName};
 use crate::base::storage::{RawStorage, RawStorageMut};
 #[cfg(any(feature = "std", feature = "alloc"))]
@@ -82,15 +82,15 @@ impl<T: Scalar, const R: usize, const C: usize> Allocator<T, Const<R>, Const<C>>
     }
 }
 
-// Dynamic - Static
-// Dynamic - Dynamic
+// Dyn - Static
+// Dyn - Dyn
 #[cfg(any(feature = "std", feature = "alloc"))]
-impl<T: Scalar, C: Dim> Allocator<T, Dynamic, C> for DefaultAllocator {
-    type Buffer = VecStorage<T, Dynamic, C>;
-    type BufferUninit = VecStorage<MaybeUninit<T>, Dynamic, C>;
+impl<T: Scalar, C: Dim> Allocator<T, Dyn, C> for DefaultAllocator {
+    type Buffer = VecStorage<T, Dyn, C>;
+    type BufferUninit = VecStorage<MaybeUninit<T>, Dyn, C>;
 
     #[inline]
-    fn allocate_uninit(nrows: Dynamic, ncols: C) -> VecStorage<MaybeUninit<T>, Dynamic, C> {
+    fn allocate_uninit(nrows: Dyn, ncols: C) -> VecStorage<MaybeUninit<T>, Dyn, C> {
         let mut data = Vec::new();
         let length = nrows.value() * ncols.value();
         data.reserve_exact(length);
@@ -99,9 +99,7 @@ impl<T: Scalar, C: Dim> Allocator<T, Dynamic, C> for DefaultAllocator {
     }
 
     #[inline]
-    unsafe fn assume_init(
-        uninit: VecStorage<MaybeUninit<T>, Dynamic, C>,
-    ) -> VecStorage<T, Dynamic, C> {
+    unsafe fn assume_init(uninit: VecStorage<MaybeUninit<T>, Dyn, C>) -> VecStorage<T, Dyn, C> {
         // Avoids a double-drop.
         let (nrows, ncols) = uninit.shape();
         let vec: Vec<_> = uninit.into();
@@ -117,7 +115,7 @@ impl<T: Scalar, C: Dim> Allocator<T, Dynamic, C> for DefaultAllocator {
 
     #[inline]
     fn allocate_from_iterator<I: IntoIterator<Item = T>>(
-        nrows: Dynamic,
+        nrows: Dyn,
         ncols: C,
         iter: I,
     ) -> Self::Buffer {
@@ -130,14 +128,14 @@ impl<T: Scalar, C: Dim> Allocator<T, Dynamic, C> for DefaultAllocator {
     }
 }
 
-// Static - Dynamic
+// Static - Dyn
 #[cfg(any(feature = "std", feature = "alloc"))]
-impl<T: Scalar, R: DimName> Allocator<T, R, Dynamic> for DefaultAllocator {
-    type Buffer = VecStorage<T, R, Dynamic>;
-    type BufferUninit = VecStorage<MaybeUninit<T>, R, Dynamic>;
+impl<T: Scalar, R: DimName> Allocator<T, R, Dyn> for DefaultAllocator {
+    type Buffer = VecStorage<T, R, Dyn>;
+    type BufferUninit = VecStorage<MaybeUninit<T>, R, Dyn>;
 
     #[inline]
-    fn allocate_uninit(nrows: R, ncols: Dynamic) -> VecStorage<MaybeUninit<T>, R, Dynamic> {
+    fn allocate_uninit(nrows: R, ncols: Dyn) -> VecStorage<MaybeUninit<T>, R, Dyn> {
         let mut data = Vec::new();
         let length = nrows.value() * ncols.value();
         data.reserve_exact(length);
@@ -147,9 +145,7 @@ impl<T: Scalar, R: DimName> Allocator<T, R, Dynamic> for DefaultAllocator {
     }
 
     #[inline]
-    unsafe fn assume_init(
-        uninit: VecStorage<MaybeUninit<T>, R, Dynamic>,
-    ) -> VecStorage<T, R, Dynamic> {
+    unsafe fn assume_init(uninit: VecStorage<MaybeUninit<T>, R, Dyn>) -> VecStorage<T, R, Dyn> {
         // Avoids a double-drop.
         let (nrows, ncols) = uninit.shape();
         let vec: Vec<_> = uninit.into();
@@ -166,7 +162,7 @@ impl<T: Scalar, R: DimName> Allocator<T, R, Dynamic> for DefaultAllocator {
     #[inline]
     fn allocate_from_iterator<I: IntoIterator<Item = T>>(
         nrows: R,
-        ncols: Dynamic,
+        ncols: Dyn,
         iter: I,
     ) -> Self::Buffer {
         let it = iter.into_iter();
@@ -215,20 +211,20 @@ where
     }
 }
 
-// Static × Static -> Dynamic × Any
+// Static × Static -> Dyn × Any
 #[cfg(any(feature = "std", feature = "alloc"))]
 impl<T: Scalar, CTo, const RFROM: usize, const CFROM: usize>
-    Reallocator<T, Const<RFROM>, Const<CFROM>, Dynamic, CTo> for DefaultAllocator
+    Reallocator<T, Const<RFROM>, Const<CFROM>, Dyn, CTo> for DefaultAllocator
 where
     CTo: Dim,
 {
     #[inline]
     unsafe fn reallocate_copy(
-        rto: Dynamic,
+        rto: Dyn,
         cto: CTo,
         buf: ArrayStorage<T, RFROM, CFROM>,
-    ) -> VecStorage<MaybeUninit<T>, Dynamic, CTo> {
-        let mut res = <Self as Allocator<T, Dynamic, CTo>>::allocate_uninit(rto, cto);
+    ) -> VecStorage<MaybeUninit<T>, Dyn, CTo> {
+        let mut res = <Self as Allocator<T, Dyn, CTo>>::allocate_uninit(rto, cto);
 
         let (rfrom, cfrom) = buf.shape();
 
@@ -246,20 +242,20 @@ where
     }
 }
 
-// Static × Static -> Static × Dynamic
+// Static × Static -> Static × Dyn
 #[cfg(any(feature = "std", feature = "alloc"))]
 impl<T: Scalar, RTo, const RFROM: usize, const CFROM: usize>
-    Reallocator<T, Const<RFROM>, Const<CFROM>, RTo, Dynamic> for DefaultAllocator
+    Reallocator<T, Const<RFROM>, Const<CFROM>, RTo, Dyn> for DefaultAllocator
 where
     RTo: DimName,
 {
     #[inline]
     unsafe fn reallocate_copy(
         rto: RTo,
-        cto: Dynamic,
+        cto: Dyn,
         buf: ArrayStorage<T, RFROM, CFROM>,
-    ) -> VecStorage<MaybeUninit<T>, RTo, Dynamic> {
-        let mut res = <Self as Allocator<T, RTo, Dynamic>>::allocate_uninit(rto, cto);
+    ) -> VecStorage<MaybeUninit<T>, RTo, Dyn> {
+        let mut res = <Self as Allocator<T, RTo, Dyn>>::allocate_uninit(rto, cto);
 
         let (rfrom, cfrom) = buf.shape();
 
@@ -279,60 +275,58 @@ where
 
 // All conversion from a dynamic buffer to a dynamic buffer.
 #[cfg(any(feature = "std", feature = "alloc"))]
-impl<T: Scalar, CFrom: Dim, CTo: Dim> Reallocator<T, Dynamic, CFrom, Dynamic, CTo>
-    for DefaultAllocator
-{
+impl<T: Scalar, CFrom: Dim, CTo: Dim> Reallocator<T, Dyn, CFrom, Dyn, CTo> for DefaultAllocator {
     #[inline]
     unsafe fn reallocate_copy(
-        rto: Dynamic,
+        rto: Dyn,
         cto: CTo,
-        buf: VecStorage<T, Dynamic, CFrom>,
-    ) -> VecStorage<MaybeUninit<T>, Dynamic, CTo> {
+        buf: VecStorage<T, Dyn, CFrom>,
+    ) -> VecStorage<MaybeUninit<T>, Dyn, CTo> {
         let new_buf = buf.resize(rto.value() * cto.value());
         VecStorage::new(rto, cto, new_buf)
     }
 }
 
 #[cfg(any(feature = "std", feature = "alloc"))]
-impl<T: Scalar, CFrom: Dim, RTo: DimName> Reallocator<T, Dynamic, CFrom, RTo, Dynamic>
+impl<T: Scalar, CFrom: Dim, RTo: DimName> Reallocator<T, Dyn, CFrom, RTo, Dyn>
     for DefaultAllocator
 {
     #[inline]
     unsafe fn reallocate_copy(
         rto: RTo,
-        cto: Dynamic,
-        buf: VecStorage<T, Dynamic, CFrom>,
-    ) -> VecStorage<MaybeUninit<T>, RTo, Dynamic> {
+        cto: Dyn,
+        buf: VecStorage<T, Dyn, CFrom>,
+    ) -> VecStorage<MaybeUninit<T>, RTo, Dyn> {
         let new_buf = buf.resize(rto.value() * cto.value());
         VecStorage::new(rto, cto, new_buf)
     }
 }
 
 #[cfg(any(feature = "std", feature = "alloc"))]
-impl<T: Scalar, RFrom: DimName, CTo: Dim> Reallocator<T, RFrom, Dynamic, Dynamic, CTo>
+impl<T: Scalar, RFrom: DimName, CTo: Dim> Reallocator<T, RFrom, Dyn, Dyn, CTo>
     for DefaultAllocator
 {
     #[inline]
     unsafe fn reallocate_copy(
-        rto: Dynamic,
+        rto: Dyn,
         cto: CTo,
-        buf: VecStorage<T, RFrom, Dynamic>,
-    ) -> VecStorage<MaybeUninit<T>, Dynamic, CTo> {
+        buf: VecStorage<T, RFrom, Dyn>,
+    ) -> VecStorage<MaybeUninit<T>, Dyn, CTo> {
         let new_buf = buf.resize(rto.value() * cto.value());
         VecStorage::new(rto, cto, new_buf)
     }
 }
 
 #[cfg(any(feature = "std", feature = "alloc"))]
-impl<T: Scalar, RFrom: DimName, RTo: DimName> Reallocator<T, RFrom, Dynamic, RTo, Dynamic>
+impl<T: Scalar, RFrom: DimName, RTo: DimName> Reallocator<T, RFrom, Dyn, RTo, Dyn>
     for DefaultAllocator
 {
     #[inline]
     unsafe fn reallocate_copy(
         rto: RTo,
-        cto: Dynamic,
-        buf: VecStorage<T, RFrom, Dynamic>,
-    ) -> VecStorage<MaybeUninit<T>, RTo, Dynamic> {
+        cto: Dyn,
+        buf: VecStorage<T, RFrom, Dyn>,
+    ) -> VecStorage<MaybeUninit<T>, RTo, Dyn> {
         let new_buf = buf.resize(rto.value() * cto.value());
         VecStorage::new(rto, cto, new_buf)
     }
diff --git a/src/base/dimension.rs b/src/base/dimension.rs
index 71472783..97616129 100644
--- a/src/base/dimension.rs
+++ b/src/base/dimension.rs
@@ -24,19 +24,20 @@ use serde::{Deserialize, Deserializer, Serialize, Serializer};
 #[cfg_attr(feature = "cuda", derive(cust_core::DeviceCopy))]
 pub struct Dyn(pub usize);
 
-// TODO: Deprecate?
+#[deprecated(note = "use Dyn instead.")]
 pub type Dynamic = Dyn;
 
-impl Dynamic {
+impl Dyn {
     /// A dynamic size equal to `value`.
     #[inline]
+    #[deprecated(note = "use Dyn(value) instead.")]
     pub const fn new(value: usize) -> Self {
         Self(value)
     }
 }
 
 #[cfg(feature = "serde-serialize-no-std")]
-impl Serialize for Dynamic {
+impl Serialize for Dyn {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
@@ -46,25 +47,25 @@ impl Serialize for Dynamic {
 }
 
 #[cfg(feature = "serde-serialize-no-std")]
-impl<'de> Deserialize<'de> for Dynamic {
+impl<'de> Deserialize<'de> for Dyn {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
         D: Deserializer<'de>,
     {
-        usize::deserialize(deserializer).map(|x| Dynamic::new(x))
+        usize::deserialize(deserializer).map(|x| Dyn(x))
     }
 }
 
-/// Trait implemented by `Dynamic`.
+/// Trait implemented by `Dyn`.
 pub trait IsDynamic {}
-/// Trait implemented by `Dynamic` and type-level integers different from `U1`.
+/// Trait implemented by `Dyn` and type-level integers different from `U1`.
 pub trait IsNotStaticOne {}
 
-impl IsDynamic for Dynamic {}
-impl IsNotStaticOne for Dynamic {}
+impl IsDynamic for Dyn {}
+impl IsNotStaticOne for Dyn {}
 
 /// Trait implemented by any type that can be used as a dimension. This includes type-level
-/// integers and `Dynamic` (for dimensions not known at compile-time).
+/// integers and `Dyn` (for dimensions not known at compile-time).
 pub unsafe trait Dim: Any + Debug + Copy + PartialEq + Send + Sync {
     #[inline(always)]
     fn is<D: Dim>() -> bool {
@@ -72,7 +73,7 @@ pub unsafe trait Dim: Any + Debug + Copy + PartialEq + Send + Sync {
     }
 
     /// Gets the compile-time value of `Self`. Returns `None` if it is not known, i.e., if `Self =
-    /// Dynamic`.
+    /// Dyn`.
     fn try_to_usize() -> Option<usize>;
 
     /// Gets the run-time value of `self`. For type-level integers, this is the same as
@@ -84,7 +85,7 @@ pub unsafe trait Dim: Any + Debug + Copy + PartialEq + Send + Sync {
     fn from_usize(dim: usize) -> Self;
 }
 
-unsafe impl Dim for Dynamic {
+unsafe impl Dim for Dyn {
     #[inline]
     fn try_to_usize() -> Option<usize> {
         None
@@ -92,7 +93,7 @@ unsafe impl Dim for Dynamic {
 
     #[inline]
     fn from_usize(dim: usize) -> Self {
-        Self::new(dim)
+        Self(dim)
     }
 
     #[inline]
@@ -101,21 +102,21 @@ unsafe impl Dim for Dynamic {
     }
 }
 
-impl Add<usize> for Dynamic {
-    type Output = Dynamic;
+impl Add<usize> for Dyn {
+    type Output = Dyn;
 
     #[inline]
     fn add(self, rhs: usize) -> Self {
-        Self::new(self.0 + rhs)
+        Self(self.0 + rhs)
     }
 }
 
-impl Sub<usize> for Dynamic {
-    type Output = Dynamic;
+impl Sub<usize> for Dyn {
+    type Output = Dyn;
 
     #[inline]
     fn sub(self, rhs: usize) -> Self {
-        Self::new(self.0 - rhs)
+        Self(self.0 - rhs)
     }
 }
 
@@ -153,22 +154,22 @@ macro_rules! dim_ops(
             }
         }
 
-        impl<D: Dim> $DimOp<D> for Dynamic {
-            type Output = Dynamic;
+        impl<D: Dim> $DimOp<D> for Dyn {
+            type Output = Dyn;
 
             #[inline]
-            fn $op(self, other: D) -> Dynamic {
-                Dynamic::new($op_path(self.value(), other.value()))
+            fn $op(self, other: D) -> Dyn {
+                Dyn($op_path(self.value(), other.value()))
             }
         }
 
         // TODO: use Const<T> instead of D: DimName?
-        impl<D: DimName> $DimOp<Dynamic> for D {
-            type Output = Dynamic;
+        impl<D: DimName> $DimOp<Dyn> for D {
+            type Output = Dyn;
 
             #[inline]
-            fn $op(self, other: Dynamic) -> Dynamic {
-                Dynamic::new($op_path(self.value(), other.value()))
+            fn $op(self, other: Dyn) -> Dyn {
+                Dyn($op_path(self.value(), other.value()))
             }
         }
 
diff --git a/src/base/edition.rs b/src/base/edition.rs
index 104bd7fb..e482fa24 100644
--- a/src/base/edition.rs
+++ b/src/base/edition.rs
@@ -7,7 +7,7 @@ use std::ptr;
 use crate::base::allocator::{Allocator, Reallocator};
 use crate::base::constraint::{DimEq, SameNumberOfColumns, SameNumberOfRows, ShapeConstraint};
 #[cfg(any(feature = "std", feature = "alloc"))]
-use crate::base::dimension::Dynamic;
+use crate::base::dimension::Dyn;
 use crate::base::dimension::{Const, Dim, DimAdd, DimDiff, DimMin, DimMinimum, DimSub, DimSum, U1};
 use crate::base::storage::{RawStorage, RawStorageMut, ReshapableStorage};
 use crate::base::{DefaultAllocator, Matrix, OMatrix, RowVector, Scalar, Vector};
@@ -48,15 +48,15 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
     /// Creates a new matrix by extracting the given set of rows from `self`.
     #[cfg(any(feature = "std", feature = "alloc"))]
     #[must_use]
-    pub fn select_rows<'a, I>(&self, irows: I) -> OMatrix<T, Dynamic, C>
+    pub fn select_rows<'a, I>(&self, irows: I) -> OMatrix<T, Dyn, C>
     where
         I: IntoIterator<Item = &'a usize>,
         I::IntoIter: ExactSizeIterator + Clone,
-        DefaultAllocator: Allocator<T, Dynamic, C>,
+        DefaultAllocator: Allocator<T, Dyn, C>,
     {
         let irows = irows.into_iter();
         let ncols = self.shape_generic().1;
-        let mut res = Matrix::uninit(Dynamic::new(irows.len()), ncols);
+        let mut res = Matrix::uninit(Dyn(irows.len()), ncols);
 
         // First, check that all the indices from irows are valid.
         // This will allow us to use unchecked access in the inner loop.
@@ -85,15 +85,15 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
     /// Creates a new matrix by extracting the given set of columns from `self`.
     #[cfg(any(feature = "std", feature = "alloc"))]
     #[must_use]
-    pub fn select_columns<'a, I>(&self, icols: I) -> OMatrix<T, R, Dynamic>
+    pub fn select_columns<'a, I>(&self, icols: I) -> OMatrix<T, R, Dyn>
     where
         I: IntoIterator<Item = &'a usize>,
         I::IntoIter: ExactSizeIterator,
-        DefaultAllocator: Allocator<T, R, Dynamic>,
+        DefaultAllocator: Allocator<T, R, Dyn>,
     {
         let icols = icols.into_iter();
         let nrows = self.shape_generic().0;
-        let mut res = Matrix::uninit(nrows, Dynamic::new(icols.len()));
+        let mut res = Matrix::uninit(nrows, Dyn(icols.len()));
 
         for (destination, source) in icols.enumerate() {
             // NOTE: this is basically a copy_frow but wrapping the values insnide of MaybeUninit.
@@ -359,10 +359,10 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
 
     /// Removes all columns in `indices`   
     #[cfg(any(feature = "std", feature = "alloc"))]
-    pub fn remove_columns_at(self, indices: &[usize]) -> OMatrix<T, R, Dynamic>
+    pub fn remove_columns_at(self, indices: &[usize]) -> OMatrix<T, R, Dyn>
     where
-        C: DimSub<Dynamic, Output = Dynamic>,
-        DefaultAllocator: Reallocator<T, R, C, R, Dynamic>,
+        C: DimSub<Dyn, Output = Dyn>,
+        DefaultAllocator: Reallocator<T, R, C, R, Dyn>,
     {
         let mut m = self.into_owned();
         let (nrows, ncols) = m.shape_generic();
@@ -400,7 +400,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
         unsafe {
             let new_data = DefaultAllocator::reallocate_copy(
                 nrows,
-                ncols.sub(Dynamic::from_usize(offset)),
+                ncols.sub(Dyn::from_usize(offset)),
                 m.data,
             );
 
@@ -410,10 +410,10 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
 
     /// Removes all rows in `indices`   
     #[cfg(any(feature = "std", feature = "alloc"))]
-    pub fn remove_rows_at(self, indices: &[usize]) -> OMatrix<T, Dynamic, C>
+    pub fn remove_rows_at(self, indices: &[usize]) -> OMatrix<T, Dyn, C>
     where
-        R: DimSub<Dynamic, Output = Dynamic>,
-        DefaultAllocator: Reallocator<T, R, C, Dynamic, C>,
+        R: DimSub<Dyn, Output = Dyn>,
+        DefaultAllocator: Reallocator<T, R, C, Dyn, C>,
     {
         let mut m = self.into_owned();
         let (nrows, ncols) = m.shape_generic();
@@ -448,7 +448,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
         //         be assumed to be initialized.
         unsafe {
             let new_data = DefaultAllocator::reallocate_copy(
-                nrows.sub(Dynamic::from_usize(offset / ncols.value())),
+                nrows.sub(Dyn::from_usize(offset / ncols.value())),
                 ncols,
                 m.data,
             );
@@ -474,12 +474,12 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
     /// Removes `n` consecutive columns from this matrix, starting with the `i`-th (included).
     #[inline]
     #[cfg(any(feature = "std", feature = "alloc"))]
-    pub fn remove_columns(self, i: usize, n: usize) -> OMatrix<T, R, Dynamic>
+    pub fn remove_columns(self, i: usize, n: usize) -> OMatrix<T, R, Dyn>
     where
-        C: DimSub<Dynamic, Output = Dynamic>,
-        DefaultAllocator: Reallocator<T, R, C, R, Dynamic>,
+        C: DimSub<Dyn, Output = Dyn>,
+        DefaultAllocator: Reallocator<T, R, C, R, Dyn>,
     {
-        self.remove_columns_generic(i, Dynamic::new(n))
+        self.remove_columns_generic(i, Dyn(n))
     }
 
     /// Removes `nremove.value()` columns from this matrix, starting with the `i`-th (included).
@@ -569,12 +569,12 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
     /// Removes `n` consecutive rows from this matrix, starting with the `i`-th (included).
     #[inline]
     #[cfg(any(feature = "std", feature = "alloc"))]
-    pub fn remove_rows(self, i: usize, n: usize) -> OMatrix<T, Dynamic, C>
+    pub fn remove_rows(self, i: usize, n: usize) -> OMatrix<T, Dyn, C>
     where
-        R: DimSub<Dynamic, Output = Dynamic>,
-        DefaultAllocator: Reallocator<T, R, C, Dynamic, C>,
+        R: DimSub<Dyn, Output = Dyn>,
+        DefaultAllocator: Reallocator<T, R, C, Dyn, C>,
     {
-        self.remove_rows_generic(i, Dynamic::new(n))
+        self.remove_rows_generic(i, Dyn(n))
     }
 
     /// Removes `nremove.value()` rows from this matrix, starting with the `i`-th (included).
@@ -659,12 +659,12 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
     /// Inserts `n` columns filled with `val` starting at the `i-th` position.
     #[inline]
     #[cfg(any(feature = "std", feature = "alloc"))]
-    pub fn insert_columns(self, i: usize, n: usize, val: T) -> OMatrix<T, R, Dynamic>
+    pub fn insert_columns(self, i: usize, n: usize, val: T) -> OMatrix<T, R, Dyn>
     where
-        C: DimAdd<Dynamic, Output = Dynamic>,
-        DefaultAllocator: Reallocator<T, R, C, R, Dynamic>,
+        C: DimAdd<Dyn, Output = Dyn>,
+        DefaultAllocator: Reallocator<T, R, C, R, Dyn>,
     {
-        let mut res = unsafe { self.insert_columns_generic_uninitialized(i, Dynamic::new(n)) };
+        let mut res = unsafe { self.insert_columns_generic_uninitialized(i, Dyn(n)) };
         res.columns_mut(i, n)
             .fill_with(|| MaybeUninit::new(val.clone()));
 
@@ -752,12 +752,12 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
     /// Inserts `n` rows filled with `val` starting at the `i-th` position.
     #[inline]
     #[cfg(any(feature = "std", feature = "alloc"))]
-    pub fn insert_rows(self, i: usize, n: usize, val: T) -> OMatrix<T, Dynamic, C>
+    pub fn insert_rows(self, i: usize, n: usize, val: T) -> OMatrix<T, Dyn, C>
     where
-        R: DimAdd<Dynamic, Output = Dynamic>,
-        DefaultAllocator: Reallocator<T, R, C, Dynamic, C>,
+        R: DimAdd<Dyn, Output = Dyn>,
+        DefaultAllocator: Reallocator<T, R, C, Dyn, C>,
     {
-        let mut res = unsafe { self.insert_rows_generic_uninitialized(i, Dynamic::new(n)) };
+        let mut res = unsafe { self.insert_rows_generic_uninitialized(i, Dyn(n)) };
         res.rows_mut(i, n)
             .fill_with(|| MaybeUninit::new(val.clone()));
 
@@ -815,11 +815,11 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
     /// The values are copied such that `self[(i, j)] == result[(i, j)]`. If the result has more
     /// rows and/or columns than `self`, then the extra rows or columns are filled with `val`.
     #[cfg(any(feature = "std", feature = "alloc"))]
-    pub fn resize(self, new_nrows: usize, new_ncols: usize, val: T) -> OMatrix<T, Dynamic, Dynamic>
+    pub fn resize(self, new_nrows: usize, new_ncols: usize, val: T) -> OMatrix<T, Dyn, Dyn>
     where
-        DefaultAllocator: Reallocator<T, R, C, Dynamic, Dynamic>,
+        DefaultAllocator: Reallocator<T, R, C, Dyn, Dyn>,
     {
-        self.resize_generic(Dynamic::new(new_nrows), Dynamic::new(new_ncols), val)
+        self.resize_generic(Dyn(new_nrows), Dyn(new_ncols), val)
     }
 
     /// Resizes this matrix vertically, i.e., so that it contains `new_nrows` rows while keeping the same number of columns.
@@ -827,12 +827,12 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
     /// The values are copied such that `self[(i, j)] == result[(i, j)]`. If the result has more
     /// rows than `self`, then the extra rows are filled with `val`.
     #[cfg(any(feature = "std", feature = "alloc"))]
-    pub fn resize_vertically(self, new_nrows: usize, val: T) -> OMatrix<T, Dynamic, C>
+    pub fn resize_vertically(self, new_nrows: usize, val: T) -> OMatrix<T, Dyn, C>
     where
-        DefaultAllocator: Reallocator<T, R, C, Dynamic, C>,
+        DefaultAllocator: Reallocator<T, R, C, Dyn, C>,
     {
         let ncols = self.shape_generic().1;
-        self.resize_generic(Dynamic::new(new_nrows), ncols, val)
+        self.resize_generic(Dyn(new_nrows), ncols, val)
     }
 
     /// Resizes this matrix horizontally, i.e., so that it contains `new_ncolumns` columns while keeping the same number of columns.
@@ -840,12 +840,12 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
     /// The values are copied such that `self[(i, j)] == result[(i, j)]`. If the result has more
     /// columns than `self`, then the extra columns are filled with `val`.
     #[cfg(any(feature = "std", feature = "alloc"))]
-    pub fn resize_horizontally(self, new_ncols: usize, val: T) -> OMatrix<T, R, Dynamic>
+    pub fn resize_horizontally(self, new_ncols: usize, val: T) -> OMatrix<T, R, Dyn>
     where
-        DefaultAllocator: Reallocator<T, R, C, R, Dynamic>,
+        DefaultAllocator: Reallocator<T, R, C, R, Dyn>,
     {
         let nrows = self.shape_generic().0;
-        self.resize_generic(nrows, Dynamic::new(new_ncols), val)
+        self.resize_generic(nrows, Dyn(new_ncols), val)
     }
 
     /// Resizes this matrix so that it contains `R2::value()` rows and `C2::value()` columns.
@@ -962,7 +962,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
     /// # Examples
     ///
     /// ```
-    /// # use nalgebra::{Matrix3x2, Matrix2x3, DMatrix, Const, Dynamic};
+    /// # use nalgebra::{Matrix3x2, Matrix2x3, DMatrix, Const, Dyn};
     ///
     /// let m1 = Matrix2x3::new(
     ///     1.1, 1.2, 1.3,
@@ -998,7 +998,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
     ///         0.0, 0.0,
     ///     ],
     /// );
-    /// let reshaped = dm1.reshape_generic(Dynamic::new(6), Dynamic::new(2));
+    /// let reshaped = dm1.reshape_generic(Dyn(6), Dyn(2));
     /// assert_eq!(reshaped, dm2);
     /// ```
     pub fn reshape_generic<R2, C2>(
@@ -1018,7 +1018,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
 
 /// # In-place resizing
 #[cfg(any(feature = "std", feature = "alloc"))]
-impl<T: Scalar> OMatrix<T, Dynamic, Dynamic> {
+impl<T: Scalar> OMatrix<T, Dyn, Dyn> {
     /// Resizes this matrix in-place.
     ///
     /// The values are copied such that `self[(i, j)] == result[(i, j)]`. If the result has more
@@ -1027,7 +1027,7 @@ impl<T: Scalar> OMatrix<T, Dynamic, Dynamic> {
     /// Defined only for owned fully-dynamic matrices, i.e., `DMatrix`.
     pub fn resize_mut(&mut self, new_nrows: usize, new_ncols: usize, val: T)
     where
-        DefaultAllocator: Reallocator<T, Dynamic, Dynamic, Dynamic, Dynamic>,
+        DefaultAllocator: Reallocator<T, Dyn, Dyn, Dyn, Dyn>,
     {
         // TODO: avoid the clone.
         *self = self.clone().resize(new_nrows, new_ncols, val);
@@ -1035,9 +1035,9 @@ impl<T: Scalar> OMatrix<T, Dynamic, Dynamic> {
 }
 
 #[cfg(any(feature = "std", feature = "alloc"))]
-impl<T: Scalar, C: Dim> OMatrix<T, Dynamic, C>
+impl<T: Scalar, C: Dim> OMatrix<T, Dyn, C>
 where
-    DefaultAllocator: Allocator<T, Dynamic, C>,
+    DefaultAllocator: Allocator<T, Dyn, C>,
 {
     /// Changes the number of rows of this matrix in-place.
     ///
@@ -1048,7 +1048,7 @@ where
     #[cfg(any(feature = "std", feature = "alloc"))]
     pub fn resize_vertically_mut(&mut self, new_nrows: usize, val: T)
     where
-        DefaultAllocator: Reallocator<T, Dynamic, C, Dynamic, C>,
+        DefaultAllocator: Reallocator<T, Dyn, C, Dyn, C>,
     {
         // TODO: avoid the clone.
         *self = self.clone().resize_vertically(new_nrows, val);
@@ -1056,9 +1056,9 @@ where
 }
 
 #[cfg(any(feature = "std", feature = "alloc"))]
-impl<T: Scalar, R: Dim> OMatrix<T, R, Dynamic>
+impl<T: Scalar, R: Dim> OMatrix<T, R, Dyn>
 where
-    DefaultAllocator: Allocator<T, R, Dynamic>,
+    DefaultAllocator: Allocator<T, R, Dyn>,
 {
     /// Changes the number of column of this matrix in-place.
     ///
@@ -1069,7 +1069,7 @@ where
     #[cfg(any(feature = "std", feature = "alloc"))]
     pub fn resize_horizontally_mut(&mut self, new_ncols: usize, val: T)
     where
-        DefaultAllocator: Reallocator<T, R, Dynamic, R, Dynamic>,
+        DefaultAllocator: Reallocator<T, R, Dyn, R, Dyn>,
     {
         // TODO: avoid the clone.
         *self = self.clone().resize_horizontally(new_ncols, val);
@@ -1167,7 +1167,7 @@ unsafe fn extend_rows<T>(data: &mut [T], nrows: usize, ncols: usize, i: usize, n
 /// Extend the number of columns of the `Matrix` with elements from
 /// a given iterator.
 #[cfg(any(feature = "std", feature = "alloc"))]
-impl<T, R, S> Extend<T> for Matrix<T, R, Dynamic, S>
+impl<T, R, S> Extend<T> for Matrix<T, R, Dyn, S>
 where
     T: Scalar,
     R: Dim,
@@ -1178,7 +1178,7 @@ where
     ///
     /// # Example
     /// ```
-    /// # use nalgebra::{DMatrix, Dynamic, Matrix, OMatrix, Matrix3};
+    /// # use nalgebra::{DMatrix, Dyn, Matrix, OMatrix, Matrix3};
     ///
     /// let data = vec![0, 1, 2,      // column 1
     ///                 3, 4, 5];     // column 2
@@ -1198,7 +1198,7 @@ where
     /// `Matrix`.
     ///
     /// ```should_panic
-    /// # use nalgebra::{DMatrix, Dynamic, OMatrix};
+    /// # use nalgebra::{DMatrix, Dyn, OMatrix};
     /// let data = vec![0, 1, 2,  // column 1
     ///                 3, 4, 5]; // column 2
     ///
@@ -1215,7 +1215,7 @@ where
 /// Extend the number of rows of the `Vector` with elements from
 /// a given iterator.
 #[cfg(any(feature = "std", feature = "alloc"))]
-impl<T, S> Extend<T> for Matrix<T, Dynamic, U1, S>
+impl<T, S> Extend<T> for Matrix<T, Dyn, U1, S>
 where
     T: Scalar,
     S: Extend<T>,
@@ -1236,7 +1236,7 @@ where
 }
 
 #[cfg(any(feature = "std", feature = "alloc"))]
-impl<T, R, S, RV, SV> Extend<Vector<T, RV, SV>> for Matrix<T, R, Dynamic, S>
+impl<T, R, S, RV, SV> Extend<Vector<T, RV, SV>> for Matrix<T, R, Dyn, S>
 where
     T: Scalar,
     R: Dim,
diff --git a/src/base/indexing.rs b/src/base/indexing.rs
index ceefe91e..48dd8fad 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, MatrixView, MatrixViewMut, Scalar, U1,
+    Const, Dim, DimDiff, DimName, DimSub, Dyn, Matrix, MatrixView, MatrixViewMut, Scalar, U1,
 };
 
 use std::ops;
@@ -49,7 +49,7 @@ fn dimrange_usize() {
 }
 
 impl<D: Dim> DimRange<D> for ops::Range<usize> {
-    type Length = Dynamic;
+    type Length = Dyn;
 
     #[inline(always)]
     fn lower(&self, _: D) -> usize {
@@ -58,7 +58,7 @@ impl<D: Dim> DimRange<D> for ops::Range<usize> {
 
     #[inline(always)]
     fn length(&self, _: D) -> Self::Length {
-        Dynamic::new(self.end.saturating_sub(self.start))
+        Dyn(self.end.saturating_sub(self.start))
     }
 
     #[inline(always)]
@@ -74,24 +74,24 @@ fn dimrange_range_usize() {
     assert!(DimRange::contained_by(&(0..1), Const::<1>));
     assert!(DimRange::contained_by(
         &((usize::MAX - 1)..usize::MAX),
-        Dynamic::new(usize::MAX)
+        Dyn(usize::MAX)
     ));
     assert_eq!(
-        DimRange::length(&((usize::MAX - 1)..usize::MAX), Dynamic::new(usize::MAX)),
-        Dynamic::new(1)
+        DimRange::length(&((usize::MAX - 1)..usize::MAX), Dyn(usize::MAX)),
+        Dyn(1)
     );
     assert_eq!(
-        DimRange::length(&(usize::MAX..(usize::MAX - 1)), Dynamic::new(usize::MAX)),
-        Dynamic::new(0)
+        DimRange::length(&(usize::MAX..(usize::MAX - 1)), Dyn(usize::MAX)),
+        Dyn(0)
     );
     assert_eq!(
-        DimRange::length(&(usize::MAX..usize::MAX), Dynamic::new(usize::MAX)),
-        Dynamic::new(0)
+        DimRange::length(&(usize::MAX..usize::MAX), Dyn(usize::MAX)),
+        Dyn(0)
     );
 }
 
 impl<D: Dim> DimRange<D> for ops::RangeFrom<usize> {
-    type Length = Dynamic;
+    type Length = Dyn;
 
     #[inline(always)]
     fn lower(&self, _: D) -> usize {
@@ -116,16 +116,13 @@ fn dimrange_rangefrom_usize() {
     assert!(DimRange::contained_by(&(0..), Const::<1>));
     assert!(DimRange::contained_by(
         &((usize::MAX - 1)..),
-        Dynamic::new(usize::MAX)
+        Dyn(usize::MAX)
     ));
     assert_eq!(
-        DimRange::length(&((usize::MAX - 1)..), Dynamic::new(usize::MAX)),
-        Dynamic::new(1)
-    );
-    assert_eq!(
-        DimRange::length(&(usize::MAX..), Dynamic::new(usize::MAX)),
-        Dynamic::new(0)
+        DimRange::length(&((usize::MAX - 1)..), Dyn(usize::MAX)),
+        Dyn(1)
     );
+    assert_eq!(DimRange::length(&(usize::MAX..), Dyn(usize::MAX)), Dyn(0));
 }
 
 impl<D: Dim, T: Dim> DimRange<D> for ops::RangeFrom<T>
@@ -181,7 +178,7 @@ fn dimrange_rangefull() {
 }
 
 impl<D: Dim> DimRange<D> for ops::RangeInclusive<usize> {
-    type Length = Dynamic;
+    type Length = Dyn;
 
     #[inline(always)]
     fn lower(&self, _: D) -> usize {
@@ -190,7 +187,7 @@ impl<D: Dim> DimRange<D> for ops::RangeInclusive<usize> {
 
     #[inline(always)]
     fn length(&self, _: D) -> Self::Length {
-        Dynamic::new(if self.end() < self.start() {
+        Dyn(if self.end() < self.start() {
             0
         } else {
             self.end().wrapping_sub(self.start().wrapping_sub(1))
@@ -209,33 +206,33 @@ fn dimrange_rangeinclusive_usize() {
     assert!(DimRange::contained_by(&(0..=0), Const::<1>));
     assert!(!DimRange::contained_by(
         &(usize::MAX..=usize::MAX),
-        Dynamic::new(usize::MAX)
+        Dyn(usize::MAX)
     ));
     assert!(!DimRange::contained_by(
         &((usize::MAX - 1)..=usize::MAX),
-        Dynamic::new(usize::MAX)
+        Dyn(usize::MAX)
     ));
     assert!(DimRange::contained_by(
         &((usize::MAX - 1)..=(usize::MAX - 1)),
-        Dynamic::new(usize::MAX)
+        Dyn(usize::MAX)
     ));
-    assert_eq!(DimRange::length(&(0..=0), Const::<1>), Dynamic::new(1));
+    assert_eq!(DimRange::length(&(0..=0), Const::<1>), Dyn(1));
     assert_eq!(
-        DimRange::length(&((usize::MAX - 1)..=usize::MAX), Dynamic::new(usize::MAX)),
-        Dynamic::new(2)
+        DimRange::length(&((usize::MAX - 1)..=usize::MAX), Dyn(usize::MAX)),
+        Dyn(2)
     );
     assert_eq!(
-        DimRange::length(&(usize::MAX..=(usize::MAX - 1)), Dynamic::new(usize::MAX)),
-        Dynamic::new(0)
+        DimRange::length(&(usize::MAX..=(usize::MAX - 1)), Dyn(usize::MAX)),
+        Dyn(0)
     );
     assert_eq!(
-        DimRange::length(&(usize::MAX..=usize::MAX), Dynamic::new(usize::MAX)),
-        Dynamic::new(1)
+        DimRange::length(&(usize::MAX..=usize::MAX), Dyn(usize::MAX)),
+        Dyn(1)
     );
 }
 
 impl<D: Dim> DimRange<D> for ops::RangeTo<usize> {
-    type Length = Dynamic;
+    type Length = Dyn;
 
     #[inline(always)]
     fn lower(&self, _: D) -> usize {
@@ -244,7 +241,7 @@ impl<D: Dim> DimRange<D> for ops::RangeTo<usize> {
 
     #[inline(always)]
     fn length(&self, _: D) -> Self::Length {
-        Dynamic::new(self.end)
+        Dyn(self.end)
     }
 
     #[inline(always)]
@@ -260,20 +257,20 @@ fn dimrange_rangeto_usize() {
     assert!(DimRange::contained_by(&(..0), Const::<1>));
     assert!(DimRange::contained_by(
         &(..(usize::MAX - 1)),
-        Dynamic::new(usize::MAX)
+        Dyn(usize::MAX)
     ));
     assert_eq!(
-        DimRange::length(&(..(usize::MAX - 1)), Dynamic::new(usize::MAX)),
-        Dynamic::new(usize::MAX - 1)
+        DimRange::length(&(..(usize::MAX - 1)), Dyn(usize::MAX)),
+        Dyn(usize::MAX - 1)
     );
     assert_eq!(
-        DimRange::length(&(..usize::MAX), Dynamic::new(usize::MAX)),
-        Dynamic::new(usize::MAX)
+        DimRange::length(&(..usize::MAX), Dyn(usize::MAX)),
+        Dyn(usize::MAX)
     );
 }
 
 impl<D: Dim> DimRange<D> for ops::RangeToInclusive<usize> {
-    type Length = Dynamic;
+    type Length = Dyn;
 
     #[inline(always)]
     fn lower(&self, _: D) -> usize {
@@ -282,7 +279,7 @@ impl<D: Dim> DimRange<D> for ops::RangeToInclusive<usize> {
 
     #[inline(always)]
     fn length(&self, _: D) -> Self::Length {
-        Dynamic::new(self.end + 1)
+        Dyn(self.end + 1)
     }
 
     #[inline(always)]
@@ -296,17 +293,14 @@ fn dimrange_rangetoinclusive_usize() {
     assert!(!DimRange::contained_by(&(..=0), Const::<0>));
     assert!(!DimRange::contained_by(&(..=1), Const::<0>));
     assert!(DimRange::contained_by(&(..=0), Const::<1>));
-    assert!(!DimRange::contained_by(
-        &(..=(usize::MAX)),
-        Dynamic::new(usize::MAX)
-    ));
+    assert!(!DimRange::contained_by(&(..=(usize::MAX)), Dyn(usize::MAX)));
     assert!(DimRange::contained_by(
         &(..=(usize::MAX - 1)),
-        Dynamic::new(usize::MAX)
+        Dyn(usize::MAX)
     ));
     assert_eq!(
-        DimRange::length(&(..=(usize::MAX - 1)), Dynamic::new(usize::MAX)),
-        Dynamic::new(usize::MAX)
+        DimRange::length(&(..=(usize::MAX - 1)), Dyn(usize::MAX)),
+        Dyn(usize::MAX)
     );
 }
 
@@ -742,12 +736,12 @@ macro_rules! impl_index_pairs {
 impl_index_pairs! {
     index R with {
         [<> usize                         =>  U1],
-        [<> ops::Range<usize>             =>  Dynamic],
-        [<> ops::RangeFrom<usize>         =>  Dynamic],
+        [<> ops::Range<usize>             =>  Dyn],
+        [<> ops::RangeFrom<usize>         =>  Dyn],
         [<> ops::RangeFull                =>  R],
-        [<> ops::RangeInclusive<usize>    =>  Dynamic],
-        [<> ops::RangeTo<usize>           =>  Dynamic],
-        [<> ops::RangeToInclusive<usize>  =>  Dynamic],
+        [<> ops::RangeInclusive<usize>    =>  Dyn],
+        [<> ops::RangeTo<usize>           =>  Dyn],
+        [<> ops::RangeToInclusive<usize>  =>  Dyn],
 
         [<I: Dim> ops::RangeFrom<I>
           =>  DimDiff<R, I>
@@ -755,12 +749,12 @@ impl_index_pairs! {
     }
     index C with {
         [<> usize                         =>  U1],
-        [<> ops::Range<usize>             =>  Dynamic],
-        [<> ops::RangeFrom<usize>         =>  Dynamic],
+        [<> ops::Range<usize>             =>  Dyn],
+        [<> ops::RangeFrom<usize>         =>  Dyn],
         [<> ops::RangeFull                =>  C],
-        [<> ops::RangeInclusive<usize>    =>  Dynamic],
-        [<> ops::RangeTo<usize>           =>  Dynamic],
-        [<> ops::RangeToInclusive<usize>  =>  Dynamic],
+        [<> ops::RangeInclusive<usize>    =>  Dyn],
+        [<> ops::RangeTo<usize>           =>  Dyn],
+        [<> ops::RangeToInclusive<usize>  =>  Dyn],
 
         [<J: DimName> ops::RangeFrom<J>
           =>  DimDiff<C, J>
diff --git a/src/base/matrix.rs b/src/base/matrix.rs
index f0fa8d81..d4875944 100644
--- a/src/base/matrix.rs
+++ b/src/base/matrix.rs
@@ -32,7 +32,7 @@ use crate::{ArrayStorage, SMatrix, SimdComplexField, Storage, UninitMatrix};
 use crate::storage::IsContiguous;
 use crate::uninit::{Init, InitStatus, Uninit};
 #[cfg(any(feature = "std", feature = "alloc"))]
-use crate::{DMatrix, DVector, Dynamic, RowDVector, VecStorage};
+use crate::{DMatrix, DVector, Dyn, RowDVector, VecStorage};
 use std::mem::MaybeUninit;
 
 /// A square matrix.
@@ -146,13 +146,13 @@ pub type MatrixCross<T, R1, C1, R2, C2> =
 /// - type-level unsigned integer constants (e.g. `U1024`, `U10000`) from the `typenum::` crate.
 /// Using those, you will not get error messages as nice as for numbers smaller than 128 defined on
 /// the `nalgebra::` module.
-/// - the special value `Dynamic` from the `nalgebra::` root module. This indicates that the
+/// - the special value `Dyn` from the `nalgebra::` root module. This indicates that the
 /// specified dimension is not known at compile-time. Note that this will generally imply that the
 /// matrix data storage `S` performs a dynamic allocation and contains extra metadata for the
 /// matrix shape.
 ///
-/// Note that mixing `Dynamic` with type-level unsigned integers is allowed. Actually, a
-/// dynamically-sized column vector should be represented as a `Matrix<T, Dynamic, U1, S>` (given
+/// Note that mixing `Dyn` with type-level unsigned integers is allowed. Actually, a
+/// dynamically-sized column vector should be represented as a `Matrix<T, Dyn, U1, S>` (given
 /// some concrete types for `T` and a compatible data storage type `S`).
 #[repr(C)]
 #[derive(Clone, Copy)]
@@ -341,7 +341,7 @@ impl<T> DMatrix<T> {
     ///
     /// This method exists primarily as a workaround for the fact that `from_data` can not
     /// work in `const fn` contexts.
-    pub const fn from_vec_storage(storage: VecStorage<T, Dynamic, Dynamic>) -> Self {
+    pub const fn from_vec_storage(storage: VecStorage<T, Dyn, Dyn>) -> Self {
         // This is sound because the dimensions of the matrix and the storage are guaranteed
         // to be the same
         unsafe { Self::from_data_statically_unchecked(storage) }
@@ -356,7 +356,7 @@ impl<T> DVector<T> {
     ///
     /// This method exists primarily as a workaround for the fact that `from_data` can not
     /// work in `const fn` contexts.
-    pub const fn from_vec_storage(storage: VecStorage<T, Dynamic, U1>) -> Self {
+    pub const fn from_vec_storage(storage: VecStorage<T, Dyn, U1>) -> Self {
         // This is sound because the dimensions of the matrix and the storage are guaranteed
         // to be the same
         unsafe { Self::from_data_statically_unchecked(storage) }
@@ -371,7 +371,7 @@ impl<T> RowDVector<T> {
     ///
     /// This method exists primarily as a workaround for the fact that `from_data` can not
     /// work in `const fn` contexts.
-    pub const fn from_vec_storage(storage: VecStorage<T, U1, Dynamic>) -> Self {
+    pub const fn from_vec_storage(storage: VecStorage<T, U1, Dyn>) -> Self {
         // This is sound because the dimensions of the matrix and the storage are guaranteed
         // to be the same
         unsafe { Self::from_data_statically_unchecked(storage) }
@@ -417,7 +417,7 @@ impl<T, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S> {
         (nrows.value(), ncols.value())
     }
 
-    /// The shape of this matrix wrapped into their representative types (`Const` or `Dynamic`).
+    /// The shape of this matrix wrapped into their representative types (`Const` or `Dyn`).
     #[inline]
     #[must_use]
     pub fn shape_generic(&self) -> (R, C) {
diff --git a/src/base/matrix_view.rs b/src/base/matrix_view.rs
index 7257629b..fa6f8f00 100644
--- a/src/base/matrix_view.rs
+++ b/src/base/matrix_view.rs
@@ -4,7 +4,7 @@ use std::slice;
 
 use crate::base::allocator::Allocator;
 use crate::base::default_allocator::DefaultAllocator;
-use crate::base::dimension::{Const, Dim, DimName, Dynamic, IsNotStaticOne, U1};
+use crate::base::dimension::{Const, Dim, DimName, Dyn, IsNotStaticOne, U1};
 use crate::base::iter::MatrixIter;
 use crate::base::storage::{IsContiguous, Owned, RawStorage, RawStorageMut, Storage};
 use crate::base::{Matrix, Scalar};
@@ -60,8 +60,8 @@ macro_rules! view_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> {
+        // Dyn 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, Dyn, Dyn> {
             /// Create a new matrix view without bounds checking.
             #[inline]
             pub unsafe fn new_unchecked<RStor, CStor, S>(storage: $SRef, start: (usize, usize), shape: (R, C))
@@ -180,7 +180,7 @@ macro_rules! storage_impl(
             #[inline]
             fn is_contiguous(&self) -> bool {
                 // Common cases that can be deduced at compile-time even if one of the dimensions
-                // is Dynamic.
+                // is Dyn.
                 if (RStride::is::<U1>() && C::is::<U1>()) || // Column vector.
                    (CStride::is::<U1>() && R::is::<U1>()) {  // Row vector.
                     true
@@ -325,24 +325,24 @@ 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_view((i, 0), (Const::<1>, Dynamic::new(n)))
+        pub fn $row_part($me: $Me, i: usize, n: usize) -> $MatrixView<'_, T, U1, Dyn, S::RStride, S::CStride> {
+            $me.$generic_view((i, 0), (Const::<1>, Dyn(n)))
         }
 
         /// Extracts from this matrix a set of consecutive rows.
         #[inline]
         pub fn $rows($me: $Me, first_row: usize, nrows: usize)
-            -> $MatrixView<'_, T, Dynamic, C, S::RStride, S::CStride> {
+            -> $MatrixView<'_, T, Dyn, C, S::RStride, S::CStride> {
 
-            $me.$rows_generic(first_row, Dynamic::new(nrows))
+            $me.$rows_generic(first_row, Dyn(nrows))
         }
 
         /// 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)
-            -> $MatrixView<'_, T, Dynamic, C, Dynamic, S::CStride> {
+            -> $MatrixView<'_, T, Dyn, C, Dyn, S::CStride> {
 
-            $me.$rows_generic_with_step(first_row, Dynamic::new(nrows), step)
+            $me.$rows_generic_with_step(first_row, Dyn(nrows), step)
         }
 
         /// Extracts a compile-time number of consecutive rows from this matrix.
@@ -357,7 +357,7 @@ macro_rules! matrix_view_impl (
         /// rows.
         #[inline]
         pub fn $fixed_rows_with_step<const RVIEW: usize>($me: $Me, first_row: usize, step: usize)
-            -> $MatrixView<'_, T, Const<RVIEW>, C, Dynamic, S::CStride> {
+            -> $MatrixView<'_, T, Const<RVIEW>, C, Dyn, S::CStride> {
 
             $me.$rows_generic_with_step(first_row, Const::<RVIEW>, step)
         }
@@ -383,14 +383,14 @@ macro_rules! matrix_view_impl (
         /// argument may or may not be values known at compile-time.
         #[inline]
         pub fn $rows_generic_with_step<RView>($me: $Me, row_start: usize, nrows: RView, step: usize)
-            -> $MatrixView<'_, T, RView, C, Dynamic, S::CStride>
+            -> $MatrixView<'_, T, RView, C, Dyn, S::CStride>
             where RView: Dim {
 
             let my_shape   = $me.shape_generic();
             let my_strides = $me.data.strides();
             $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 strides = (Dyn((step + 1) * my_strides.0.value()), my_strides.1);
             let shape   = (nrows, my_shape.1);
 
             unsafe {
@@ -412,25 +412,25 @@ macro_rules! matrix_view_impl (
 
         /// 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_view((0, i), (Dynamic::new(n), Const::<1>))
+        pub fn $column_part($me: $Me, i: usize, n: usize) -> $MatrixView<'_, T, Dyn, U1, S::RStride, S::CStride> {
+            $me.$generic_view((0, i), (Dyn(n), Const::<1>))
         }
 
         /// Extracts from this matrix a set of consecutive columns.
         #[inline]
         pub fn $columns($me: $Me, first_col: usize, ncols: usize)
-            -> $MatrixView<'_, T, R, Dynamic, S::RStride, S::CStride> {
+            -> $MatrixView<'_, T, R, Dyn, S::RStride, S::CStride> {
 
-            $me.$columns_generic(first_col, Dynamic::new(ncols))
+            $me.$columns_generic(first_col, Dyn(ncols))
         }
 
         /// Extracts from this matrix a set of consecutive columns regularly skipping `step`
         /// columns.
         #[inline]
         pub fn $columns_with_step($me: $Me, first_col: usize, ncols: usize, step: usize)
-            -> $MatrixView<'_, T, R, Dynamic, S::RStride, Dynamic> {
+            -> $MatrixView<'_, T, R, Dyn, S::RStride, Dyn> {
 
-            $me.$columns_generic_with_step(first_col, Dynamic::new(ncols), step)
+            $me.$columns_generic_with_step(first_col, Dyn(ncols), step)
         }
 
         /// Extracts a compile-time number of consecutive columns from this matrix.
@@ -445,7 +445,7 @@ macro_rules! matrix_view_impl (
         /// `step` columns.
         #[inline]
         pub fn $fixed_columns_with_step<const CVIEW: usize>($me: $Me, first_col: usize, step: usize)
-            -> $MatrixView<'_, T, R, Const<CVIEW>, S::RStride, Dynamic> {
+            -> $MatrixView<'_, T, R, Const<CVIEW>, S::RStride, Dyn> {
 
             $me.$columns_generic_with_step(first_col, Const::<CVIEW>, step)
         }
@@ -471,14 +471,14 @@ macro_rules! matrix_view_impl (
         /// or may not be values known at compile-time.
         #[inline]
         pub fn $columns_generic_with_step<CView: Dim>($me: $Me, first_col: usize, ncols: CView, step: usize)
-            -> $MatrixView<'_, T, R, CView, S::RStride, Dynamic> {
+            -> $MatrixView<'_, T, R, CView, S::RStride, Dyn> {
 
             let my_shape   = $me.shape_generic();
             let my_strides = $me.data.strides();
 
             $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 strides = (my_strides.0, Dyn((step + 1) * my_strides.1.value()));
             let shape   = (my_shape.0, ncols);
 
             unsafe {
@@ -497,7 +497,7 @@ macro_rules! matrix_view_impl (
         #[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> {
+            -> $MatrixView<'_, T, Dyn, Dyn, S::RStride, S::CStride> {
             $me.$view(start, shape)
         }
 
@@ -505,10 +505,10 @@ macro_rules! matrix_view_impl (
         /// consecutive elements.
         #[inline]
         pub fn $view($me: $Me, start: (usize, usize), shape: (usize, usize))
-            -> $MatrixView<'_, T, Dynamic, Dynamic, S::RStride, S::CStride> {
+            -> $MatrixView<'_, T, Dyn, Dyn, S::RStride, S::CStride> {
 
             $me.assert_view_index(start, shape, (0, 0));
-            let shape = (Dynamic::new(shape.0), Dynamic::new(shape.1));
+            let shape = (Dyn(shape.0), Dyn(shape.1));
 
             unsafe {
                 let data = $ViewStorage::new_unchecked($data, start, shape);
@@ -523,7 +523,7 @@ macro_rules! matrix_view_impl (
         #[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> {
+            -> $MatrixView<'_, T, Dyn, Dyn, Dyn, Dyn> {
             $me.$view_with_steps(start, shape, steps)
         }
 
@@ -533,8 +533,8 @@ macro_rules! matrix_view_impl (
         /// 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));
+            -> $MatrixView<'_, T, Dyn, Dyn, Dyn, Dyn> {
+            let shape = (Dyn(shape.0), Dyn(shape.1));
             $me.$generic_view_with_steps(start, shape, steps)
         }
 
@@ -569,7 +569,7 @@ macro_rules! matrix_view_impl (
         #[inline]
         #[deprecated = slice_deprecation_note!($fixed_view_with_steps)]
         pub fn $fixed_slice_with_steps<const RVIEW: usize, const CVIEW: usize>($me: $Me, start: (usize, usize), steps: (usize, usize))
-            -> $MatrixView<'_, T, Const<RVIEW>, Const<CVIEW>, Dynamic, Dynamic> {
+            -> $MatrixView<'_, T, Const<RVIEW>, Const<CVIEW>, Dyn, Dyn> {
             $me.$fixed_view_with_steps(start, steps)
         }
 
@@ -579,7 +579,7 @@ macro_rules! matrix_view_impl (
         /// the original matrix.
         #[inline]
         pub fn $fixed_view_with_steps<const RVIEW: usize, const CVIEW: usize>($me: $Me, start: (usize, usize), steps: (usize, usize))
-            -> $MatrixView<'_, T, Const<RVIEW>, Const<CVIEW>, Dynamic, Dynamic> {
+            -> $MatrixView<'_, T, Const<RVIEW>, Const<CVIEW>, Dyn, Dyn> {
             let shape = (Const::<RVIEW>, Const::<CVIEW>);
             $me.$generic_view_with_steps(start, shape, steps)
         }
@@ -616,7 +616,7 @@ macro_rules! matrix_view_impl (
                                                          start: (usize, usize),
                                                          shape: (RView, CView),
                                                          steps: (usize, usize))
-            -> $MatrixView<'_, T, RView, CView, Dynamic, Dynamic>
+            -> $MatrixView<'_, T, RView, CView, Dyn, Dyn>
             where RView: Dim,
                   CView: Dim {
             $me.$generic_view_with_steps(start, shape, steps)
@@ -628,15 +628,15 @@ macro_rules! matrix_view_impl (
                                                          start: (usize, usize),
                                                          shape: (RView, CView),
                                                          steps: (usize, usize))
-            -> $MatrixView<'_, T, RView, CView, Dynamic, Dynamic>
+            -> $MatrixView<'_, T, RView, CView, Dyn, Dyn>
             where RView: Dim,
                   CView: Dim {
 
             $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()),
-                              Dynamic::new((steps.1 + 1) * my_strides.1.value()));
+            let strides    = (Dyn((steps.0 + 1) * my_strides.0.value()),
+                              Dyn((steps.1 + 1) * my_strides.1.value()));
 
             unsafe {
                 let data = $ViewStorage::new_with_strides_unchecked($data, start, shape, strides);
@@ -860,7 +860,7 @@ impl<D: Dim> DimRange<D> for usize {
 }
 
 impl<D: Dim> DimRange<D> for Range<usize> {
-    type Size = Dynamic;
+    type Size = Dyn;
 
     #[inline(always)]
     fn begin(&self, _: D) -> usize {
@@ -874,12 +874,12 @@ impl<D: Dim> DimRange<D> for Range<usize> {
 
     #[inline(always)]
     fn size(&self, _: D) -> Self::Size {
-        Dynamic::new(self.end - self.start)
+        Dyn(self.end - self.start)
     }
 }
 
 impl<D: Dim> DimRange<D> for RangeFrom<usize> {
-    type Size = Dynamic;
+    type Size = Dyn;
 
     #[inline(always)]
     fn begin(&self, _: D) -> usize {
@@ -893,12 +893,12 @@ impl<D: Dim> DimRange<D> for RangeFrom<usize> {
 
     #[inline(always)]
     fn size(&self, dim: D) -> Self::Size {
-        Dynamic::new(dim.value() - self.start)
+        Dyn(dim.value() - self.start)
     }
 }
 
 impl<D: Dim> DimRange<D> for RangeTo<usize> {
-    type Size = Dynamic;
+    type Size = Dyn;
 
     #[inline(always)]
     fn begin(&self, _: D) -> usize {
@@ -912,7 +912,7 @@ impl<D: Dim> DimRange<D> for RangeTo<usize> {
 
     #[inline(always)]
     fn size(&self, _: D) -> Self::Size {
-        Dynamic::new(self.end)
+        Dyn(self.end)
     }
 }
 
@@ -936,7 +936,7 @@ impl<D: Dim> DimRange<D> for RangeFull {
 }
 
 impl<D: Dim> DimRange<D> for RangeInclusive<usize> {
-    type Size = Dynamic;
+    type Size = Dyn;
 
     #[inline(always)]
     fn begin(&self, _: D) -> usize {
@@ -950,7 +950,7 @@ impl<D: Dim> DimRange<D> for RangeInclusive<usize> {
 
     #[inline(always)]
     fn size(&self, _: D) -> Self::Size {
-        Dynamic::new(*self.end() + 1 - *self.start())
+        Dyn(*self.end() + 1 - *self.start())
     }
 }
 
diff --git a/src/base/ops.rs b/src/base/ops.rs
index 60ed5e26..d5cf3a51 100644
--- a/src/base/ops.rs
+++ b/src/base/ops.rs
@@ -11,7 +11,7 @@ use crate::base::blas_uninit::gemm_uninit;
 use crate::base::constraint::{
     AreMultipliable, DimEq, SameNumberOfColumns, SameNumberOfRows, ShapeConstraint,
 };
-use crate::base::dimension::{Dim, DimMul, DimName, DimProd, Dynamic};
+use crate::base::dimension::{Dim, DimMul, DimName, DimProd, Dyn};
 use crate::base::storage::{Storage, StorageMut};
 use crate::base::uninit::Uninit;
 use crate::base::{DefaultAllocator, Matrix, MatrixSum, OMatrix, Scalar, VectorView};
@@ -374,10 +374,10 @@ where
     }
 }
 
-impl<T, C: Dim> iter::Sum for OMatrix<T, Dynamic, C>
+impl<T, C: Dim> iter::Sum for OMatrix<T, Dyn, C>
 where
     T: Scalar + ClosedAdd + Zero,
-    DefaultAllocator: Allocator<T, Dynamic, C>,
+    DefaultAllocator: Allocator<T, Dyn, C>,
 {
     /// # Example
     /// ```
@@ -395,7 +395,7 @@ where
     /// # use nalgebra::DMatrix;
     /// iter::empty::<DMatrix<f64>>().sum::<DMatrix<f64>>(); // panics!
     /// ```
-    fn sum<I: Iterator<Item = OMatrix<T, Dynamic, C>>>(mut iter: I) -> OMatrix<T, Dynamic, C> {
+    fn sum<I: Iterator<Item = OMatrix<T, Dyn, C>>>(mut iter: I) -> OMatrix<T, Dyn, C> {
         if let Some(first) = iter.next() {
             iter.fold(first, |acc, x| acc + x)
         } else {
@@ -414,10 +414,10 @@ where
     }
 }
 
-impl<'a, T, C: Dim> iter::Sum<&'a OMatrix<T, Dynamic, C>> for OMatrix<T, Dynamic, C>
+impl<'a, T, C: Dim> iter::Sum<&'a OMatrix<T, Dyn, C>> for OMatrix<T, Dyn, C>
 where
     T: Scalar + ClosedAdd + Zero,
-    DefaultAllocator: Allocator<T, Dynamic, C>,
+    DefaultAllocator: Allocator<T, Dyn, C>,
 {
     /// # Example
     /// ```
@@ -435,7 +435,7 @@ where
     /// # use nalgebra::DMatrix;
     /// iter::empty::<&DMatrix<f64>>().sum::<DMatrix<f64>>(); // panics!
     /// ```
-    fn sum<I: Iterator<Item = &'a OMatrix<T, Dynamic, C>>>(mut iter: I) -> OMatrix<T, Dynamic, C> {
+    fn sum<I: Iterator<Item = &'a OMatrix<T, Dyn, C>>>(mut iter: I) -> OMatrix<T, Dyn, C> {
         if let Some(first) = iter.next() {
             iter.fold(first.clone(), |acc, x| acc + x)
         } else {
diff --git a/src/base/vec_storage.rs b/src/base/vec_storage.rs
index 414354cd..4614598b 100644
--- a/src/base/vec_storage.rs
+++ b/src/base/vec_storage.rs
@@ -4,7 +4,7 @@ use alloc::vec::Vec;
 use crate::base::allocator::Allocator;
 use crate::base::constraint::{SameNumberOfRows, ShapeConstraint};
 use crate::base::default_allocator::DefaultAllocator;
-use crate::base::dimension::{Dim, DimName, Dynamic, U1};
+use crate::base::dimension::{Dim, DimName, Dyn, U1};
 use crate::base::storage::{IsContiguous, Owned, RawStorage, RawStorageMut, ReshapableStorage};
 use crate::base::{Scalar, Vector};
 
@@ -188,13 +188,13 @@ impl<T, R: Dim, C: Dim> From<VecStorage<T, R, C>> for Vec<T> {
 
 /*
  *
- * Dynamic − Static
- * Dynamic − Dynamic
+ * Dyn − Static
+ * Dyn − Dyn
  *
  */
-unsafe impl<T, C: Dim> RawStorage<T, Dynamic, C> for VecStorage<T, Dynamic, C> {
+unsafe impl<T, C: Dim> RawStorage<T, Dyn, C> for VecStorage<T, Dyn, C> {
     type RStride = U1;
-    type CStride = Dynamic;
+    type CStride = Dyn;
 
     #[inline]
     fn ptr(&self) -> *const T {
@@ -202,7 +202,7 @@ unsafe impl<T, C: Dim> RawStorage<T, Dynamic, C> for VecStorage<T, Dynamic, C> {
     }
 
     #[inline]
-    fn shape(&self) -> (Dynamic, C) {
+    fn shape(&self) -> (Dyn, C) {
         (self.nrows, self.ncols)
     }
 
@@ -222,28 +222,28 @@ unsafe impl<T, C: Dim> RawStorage<T, Dynamic, C> for VecStorage<T, Dynamic, C> {
     }
 }
 
-unsafe impl<T: Scalar, C: Dim> Storage<T, Dynamic, C> for VecStorage<T, Dynamic, C>
+unsafe impl<T: Scalar, C: Dim> Storage<T, Dyn, C> for VecStorage<T, Dyn, C>
 where
-    DefaultAllocator: Allocator<T, Dynamic, C, Buffer = Self>,
+    DefaultAllocator: Allocator<T, Dyn, C, Buffer = Self>,
 {
     #[inline]
-    fn into_owned(self) -> Owned<T, Dynamic, C>
+    fn into_owned(self) -> Owned<T, Dyn, C>
     where
-        DefaultAllocator: Allocator<T, Dynamic, C>,
+        DefaultAllocator: Allocator<T, Dyn, C>,
     {
         self
     }
 
     #[inline]
-    fn clone_owned(&self) -> Owned<T, Dynamic, C>
+    fn clone_owned(&self) -> Owned<T, Dyn, C>
     where
-        DefaultAllocator: Allocator<T, Dynamic, C>,
+        DefaultAllocator: Allocator<T, Dyn, C>,
     {
         self.clone()
     }
 }
 
-unsafe impl<T, R: DimName> RawStorage<T, R, Dynamic> for VecStorage<T, R, Dynamic> {
+unsafe impl<T, R: DimName> RawStorage<T, R, Dyn> for VecStorage<T, R, Dyn> {
     type RStride = U1;
     type CStride = R;
 
@@ -253,7 +253,7 @@ unsafe impl<T, R: DimName> RawStorage<T, R, Dynamic> for VecStorage<T, R, Dynami
     }
 
     #[inline]
-    fn shape(&self) -> (R, Dynamic) {
+    fn shape(&self) -> (R, Dyn) {
         (self.nrows, self.ncols)
     }
 
@@ -273,22 +273,22 @@ unsafe impl<T, R: DimName> RawStorage<T, R, Dynamic> for VecStorage<T, R, Dynami
     }
 }
 
-unsafe impl<T: Scalar, R: DimName> Storage<T, R, Dynamic> for VecStorage<T, R, Dynamic>
+unsafe impl<T: Scalar, R: DimName> Storage<T, R, Dyn> for VecStorage<T, R, Dyn>
 where
-    DefaultAllocator: Allocator<T, R, Dynamic, Buffer = Self>,
+    DefaultAllocator: Allocator<T, R, Dyn, Buffer = Self>,
 {
     #[inline]
-    fn into_owned(self) -> Owned<T, R, Dynamic>
+    fn into_owned(self) -> Owned<T, R, Dyn>
     where
-        DefaultAllocator: Allocator<T, R, Dynamic>,
+        DefaultAllocator: Allocator<T, R, Dyn>,
     {
         self
     }
 
     #[inline]
-    fn clone_owned(&self) -> Owned<T, R, Dynamic>
+    fn clone_owned(&self) -> Owned<T, R, Dyn>
     where
-        DefaultAllocator: Allocator<T, R, Dynamic>,
+        DefaultAllocator: Allocator<T, R, Dyn>,
     {
         self.clone()
     }
@@ -299,7 +299,7 @@ where
  * RawStorageMut, ContiguousStorage.
  *
  */
-unsafe impl<T, C: Dim> RawStorageMut<T, Dynamic, C> for VecStorage<T, Dynamic, C> {
+unsafe impl<T, C: Dim> RawStorageMut<T, Dyn, C> for VecStorage<T, Dyn, C> {
     #[inline]
     fn ptr_mut(&mut self) -> *mut T {
         self.data.as_mut_ptr()
@@ -313,15 +313,15 @@ unsafe impl<T, C: Dim> RawStorageMut<T, Dynamic, C> for VecStorage<T, Dynamic, C
 
 unsafe impl<T, R: Dim, C: Dim> IsContiguous for VecStorage<T, R, C> {}
 
-impl<T, C1, C2> ReshapableStorage<T, Dynamic, C1, Dynamic, C2> for VecStorage<T, Dynamic, C1>
+impl<T, C1, C2> ReshapableStorage<T, Dyn, C1, Dyn, C2> for VecStorage<T, Dyn, C1>
 where
     T: Scalar,
     C1: Dim,
     C2: Dim,
 {
-    type Output = VecStorage<T, Dynamic, C2>;
+    type Output = VecStorage<T, Dyn, C2>;
 
-    fn reshape_generic(self, nrows: Dynamic, ncols: C2) -> Self::Output {
+    fn reshape_generic(self, nrows: Dyn, ncols: C2) -> Self::Output {
         assert_eq!(nrows.value() * ncols.value(), self.data.len());
         VecStorage {
             data: self.data,
@@ -331,15 +331,15 @@ where
     }
 }
 
-impl<T, C1, R2> ReshapableStorage<T, Dynamic, C1, R2, Dynamic> for VecStorage<T, Dynamic, C1>
+impl<T, C1, R2> ReshapableStorage<T, Dyn, C1, R2, Dyn> for VecStorage<T, Dyn, C1>
 where
     T: Scalar,
     C1: Dim,
     R2: DimName,
 {
-    type Output = VecStorage<T, R2, Dynamic>;
+    type Output = VecStorage<T, R2, Dyn>;
 
-    fn reshape_generic(self, nrows: R2, ncols: Dynamic) -> Self::Output {
+    fn reshape_generic(self, nrows: R2, ncols: Dyn) -> Self::Output {
         assert_eq!(nrows.value() * ncols.value(), self.data.len());
         VecStorage {
             data: self.data,
@@ -349,7 +349,7 @@ where
     }
 }
 
-unsafe impl<T, R: DimName> RawStorageMut<T, R, Dynamic> for VecStorage<T, R, Dynamic> {
+unsafe impl<T, R: DimName> RawStorageMut<T, R, Dyn> for VecStorage<T, R, Dyn> {
     #[inline]
     fn ptr_mut(&mut self) -> *mut T {
         self.data.as_mut_ptr()
@@ -361,15 +361,15 @@ unsafe impl<T, R: DimName> RawStorageMut<T, R, Dynamic> for VecStorage<T, R, Dyn
     }
 }
 
-impl<T, R1, C2> ReshapableStorage<T, R1, Dynamic, Dynamic, C2> for VecStorage<T, R1, Dynamic>
+impl<T, R1, C2> ReshapableStorage<T, R1, Dyn, Dyn, C2> for VecStorage<T, R1, Dyn>
 where
     T: Scalar,
     R1: DimName,
     C2: Dim,
 {
-    type Output = VecStorage<T, Dynamic, C2>;
+    type Output = VecStorage<T, Dyn, C2>;
 
-    fn reshape_generic(self, nrows: Dynamic, ncols: C2) -> Self::Output {
+    fn reshape_generic(self, nrows: Dyn, ncols: C2) -> Self::Output {
         assert_eq!(nrows.value() * ncols.value(), self.data.len());
         VecStorage {
             data: self.data,
@@ -379,15 +379,15 @@ where
     }
 }
 
-impl<T, R1, R2> ReshapableStorage<T, R1, Dynamic, R2, Dynamic> for VecStorage<T, R1, Dynamic>
+impl<T, R1, R2> ReshapableStorage<T, R1, Dyn, R2, Dyn> for VecStorage<T, R1, Dyn>
 where
     T: Scalar,
     R1: DimName,
     R2: DimName,
 {
-    type Output = VecStorage<T, R2, Dynamic>;
+    type Output = VecStorage<T, R2, Dyn>;
 
-    fn reshape_generic(self, nrows: R2, ncols: Dynamic) -> Self::Output {
+    fn reshape_generic(self, nrows: R2, ncols: Dyn) -> Self::Output {
         assert_eq!(nrows.value() * ncols.value(), self.data.len());
         VecStorage {
             data: self.data,
@@ -397,7 +397,7 @@ where
     }
 }
 
-impl<T, R: Dim> Extend<T> for VecStorage<T, R, Dynamic> {
+impl<T, R: Dim> Extend<T> for VecStorage<T, R, Dyn> {
     /// Extends the number of columns of the `VecStorage` with elements
     /// from the given iterator.
     ///
@@ -407,13 +407,13 @@ impl<T, R: Dim> Extend<T> for VecStorage<T, R, Dynamic> {
     /// `VecStorage`.
     fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) {
         self.data.extend(iter);
-        self.ncols = Dynamic::new(self.data.len() / self.nrows.value());
+        self.ncols = Dyn(self.data.len() / self.nrows.value());
         assert!(self.data.len() % self.nrows.value() == 0,
           "The number of elements produced by the given iterator was not a multiple of the number of rows.");
     }
 }
 
-impl<'a, T: 'a + Copy, R: Dim> Extend<&'a T> for VecStorage<T, R, Dynamic> {
+impl<'a, T: 'a + Copy, R: Dim> Extend<&'a T> for VecStorage<T, R, Dyn> {
     /// Extends the number of columns of the `VecStorage` with elements
     /// from the given iterator.
     ///
@@ -426,7 +426,7 @@ impl<'a, T: 'a + Copy, R: Dim> Extend<&'a T> for VecStorage<T, R, Dynamic> {
     }
 }
 
-impl<T, R, RV, SV> Extend<Vector<T, RV, SV>> for VecStorage<T, R, Dynamic>
+impl<T, R, RV, SV> Extend<Vector<T, RV, SV>> for VecStorage<T, R, Dyn>
 where
     T: Scalar,
     R: Dim,
@@ -450,15 +450,15 @@ where
             assert_eq!(nrows, vector.shape().0);
             self.data.extend(vector.iter().cloned());
         }
-        self.ncols = Dynamic::new(self.data.len() / nrows);
+        self.ncols = Dyn(self.data.len() / nrows);
     }
 }
 
-impl<T> Extend<T> for VecStorage<T, Dynamic, U1> {
+impl<T> Extend<T> for VecStorage<T, Dyn, U1> {
     /// Extends the number of rows of the `VecStorage` with elements
     /// from the given iterator.
     fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) {
         self.data.extend(iter);
-        self.nrows = Dynamic::new(self.data.len());
+        self.nrows = Dyn(self.data.len());
     }
 }
diff --git a/src/debug/random_orthogonal.rs b/src/debug/random_orthogonal.rs
index c9684238..18924fb2 100644
--- a/src/debug/random_orthogonal.rs
+++ b/src/debug/random_orthogonal.rs
@@ -4,7 +4,7 @@ use crate::base::storage::Owned;
 use quickcheck::{Arbitrary, Gen};
 
 use crate::base::allocator::Allocator;
-use crate::base::dimension::{Dim, Dynamic};
+use crate::base::dimension::{Dim, Dyn};
 use crate::base::Scalar;
 use crate::base::{DefaultAllocator, OMatrix};
 use crate::linalg::givens::GivensRotation;
@@ -12,7 +12,7 @@ use simba::scalar::ComplexField;
 
 /// A random orthogonal matrix.
 #[derive(Clone, Debug)]
-pub struct RandomOrthogonal<T: Scalar, D: Dim = Dynamic>
+pub struct RandomOrthogonal<T: Scalar, D: Dim = Dyn>
 where
     DefaultAllocator: Allocator<T, D, D>,
 {
diff --git a/src/debug/random_sdp.rs b/src/debug/random_sdp.rs
index a915f2fc..278071a8 100644
--- a/src/debug/random_sdp.rs
+++ b/src/debug/random_sdp.rs
@@ -4,7 +4,7 @@ use crate::base::storage::Owned;
 use quickcheck::{Arbitrary, Gen};
 
 use crate::base::allocator::Allocator;
-use crate::base::dimension::{Dim, Dynamic};
+use crate::base::dimension::{Dim, Dyn};
 use crate::base::Scalar;
 use crate::base::{DefaultAllocator, OMatrix};
 use simba::scalar::ComplexField;
@@ -13,7 +13,7 @@ use crate::debug::RandomOrthogonal;
 
 /// A random, well-conditioned, symmetric definite-positive matrix.
 #[derive(Clone, Debug)]
-pub struct RandomSDP<T: Scalar, D: Dim = Dynamic>
+pub struct RandomSDP<T: Scalar, D: Dim = Dyn>
 where
     DefaultAllocator: Allocator<T, D, D>,
 {
diff --git a/src/linalg/bidiagonal.rs b/src/linalg/bidiagonal.rs
index 56591ab1..3036e9f1 100644
--- a/src/linalg/bidiagonal.rs
+++ b/src/linalg/bidiagonal.rs
@@ -304,7 +304,7 @@ where
     }
 }
 
-// impl<T: ComplexField, D: DimMin<D, Output = D> + DimSub<Dynamic>> Bidiagonal<T, D, D>
+// impl<T: ComplexField, D: DimMin<D, Output = D> + DimSub<Dyn>> Bidiagonal<T, D, D>
 //     where DefaultAllocator: Allocator<T, D, D> +
 //                             Allocator<T, D> {
 //     /// Solves the linear system `self * x = b`, where `x` is the unknown to be determined.
diff --git a/src/linalg/eigen.rs b/src/linalg/eigen.rs
index 37b5ddea..a1f6172e 100644
--- a/src/linalg/eigen.rs
+++ b/src/linalg/eigen.rs
@@ -8,7 +8,7 @@ use std::fmt::Display;
 use std::ops::MulAssign;
 
 use crate::allocator::Allocator;
-use crate::base::dimension::{Dim, DimDiff, DimSub, Dynamic, U1, U2, U3};
+use crate::base::dimension::{Dim, DimDiff, DimSub, Dyn, U1, U2, U3};
 use crate::base::storage::Storage;
 use crate::base::{
     DefaultAllocator, Hessenberg, OMatrix, OVector, SquareMatrix, Unit, Vector2, Vector3,
@@ -52,8 +52,8 @@ where
 
 impl<T: ComplexField, D: Dim> Eigen<T, D>
 where
-    D: DimSub<U1>,                                   // For Hessenberg.
-    ShapeConstraint: DimEq<Dynamic, DimDiff<D, U1>>, // For Hessenberg.
+    D: DimSub<U1>,                               // For Hessenberg.
+    ShapeConstraint: DimEq<Dyn, DimDiff<D, U1>>, // For Hessenberg.
     DefaultAllocator: Allocator<T, D, DimDiff<D, U1>>
         + Allocator<T, DimDiff<D, U1>>
         + Allocator<T, D, D>
diff --git a/src/linalg/permutation_sequence.rs b/src/linalg/permutation_sequence.rs
index f4521988..9e4eb37b 100644
--- a/src/linalg/permutation_sequence.rs
+++ b/src/linalg/permutation_sequence.rs
@@ -7,7 +7,7 @@ use simba::scalar::ClosedNeg;
 use crate::allocator::Allocator;
 use crate::base::{DefaultAllocator, Matrix, OVector, Scalar};
 #[cfg(any(feature = "std", feature = "alloc"))]
-use crate::dimension::Dynamic;
+use crate::dimension::Dyn;
 use crate::dimension::{Const, Dim, DimName};
 use crate::storage::StorageMut;
 
@@ -51,14 +51,14 @@ where
 }
 
 #[cfg(any(feature = "std", feature = "alloc"))]
-impl PermutationSequence<Dynamic>
+impl PermutationSequence<Dyn>
 where
-    DefaultAllocator: Allocator<(usize, usize), Dynamic>,
+    DefaultAllocator: Allocator<(usize, usize), Dyn>,
 {
     /// Creates a new dynamically-allocated sequence of `n` identity permutations.
     #[inline]
     pub fn identity(n: usize) -> Self {
-        Self::identity_generic(Dynamic::new(n))
+        Self::identity_generic(Dyn(n))
     }
 }
 
diff --git a/src/linalg/schur.rs b/src/linalg/schur.rs
index 06d8426b..3f734723 100644
--- a/src/linalg/schur.rs
+++ b/src/linalg/schur.rs
@@ -8,7 +8,7 @@ use simba::scalar::{ComplexField, RealField};
 use std::cmp;
 
 use crate::allocator::Allocator;
-use crate::base::dimension::{Const, Dim, DimDiff, DimSub, Dynamic, U1, U2};
+use crate::base::dimension::{Const, Dim, DimDiff, DimSub, Dyn, U1, U2};
 use crate::base::storage::Storage;
 use crate::base::{DefaultAllocator, OMatrix, OVector, SquareMatrix, Unit, Vector2, Vector3};
 
@@ -174,12 +174,11 @@ where
                         {
                             let krows = cmp::min(k + 4, end + 1);
                             let mut work = work.rows_mut(0, krows);
-                            refl.reflect(&mut t.generic_view_mut(
-                                (k, k),
-                                (Const::<3>, Dynamic::new(dim.value() - k)),
-                            ));
+                            refl.reflect(
+                                &mut t.generic_view_mut((k, k), (Const::<3>, Dyn(dim.value() - k))),
+                            );
                             refl.reflect_rows(
-                                &mut t.generic_view_mut((0, k), (Dynamic::new(krows), Const::<3>)),
+                                &mut t.generic_view_mut((0, k), (Dyn(krows), Const::<3>)),
                                 &mut work,
                             );
                         }
@@ -212,13 +211,10 @@ 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)),
-                            ),
+                            &mut t.generic_view_mut((m, m), (Const::<2>, Dyn(dim.value() - m))),
                         );
                         refl.reflect_rows(
-                            &mut t.generic_view_mut((0, m), (Dynamic::new(end + 1), Const::<2>)),
+                            &mut t.generic_view_mut((0, m), (Dyn(end + 1), Const::<2>)),
                             &mut work,
                         );
                     }
@@ -231,12 +227,14 @@ where
                 // Decouple the 2x2 block if it has real eigenvalues.
                 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_view_mut(
-                        (start, start),
-                        (Const::<2>, Dynamic::new(dim.value() - start)),
-                    ));
+                    inv_rot.rotate(
+                        &mut t.generic_view_mut(
+                            (start, start),
+                            (Const::<2>, Dyn(dim.value() - start)),
+                        ),
+                    );
                     rot.rotate_rows(
-                        &mut t.generic_view_mut((0, start), (Dynamic::new(end + 1), Const::<2>)),
+                        &mut t.generic_view_mut((0, start), (Dyn(end + 1), Const::<2>)),
                     );
                     t[(end, start)] = T::zero();
 
diff --git a/src/proptest/mod.rs b/src/proptest/mod.rs
index a7cbe549..6cb31521 100644
--- a/src/proptest/mod.rs
+++ b/src/proptest/mod.rs
@@ -53,11 +53,11 @@
 //! with [matrix](fn.matrix.html) as follows:
 //!
 //! ```
-//! use nalgebra::{Dynamic, OMatrix, Const};
+//! use nalgebra::{Dyn, OMatrix, Const};
 //! use nalgebra::proptest::matrix;
 //! use proptest::prelude::*;
 //!
-//! type MyMatrix = OMatrix<i32, Const::<3>, Dynamic>;
+//! type MyMatrix = OMatrix<i32, Const::<3>, Dyn>;
 //!
 //! /// Returns a strategy for pairs of matrices with `U3` rows and the same number of
 //! /// columns.
@@ -93,7 +93,7 @@
 //! If you don't care about the dimensions of matrices, you can write tests like these:
 //!
 //! ```
-//! use nalgebra::{DMatrix, DVector, Dynamic, Matrix3, OMatrix, Vector3, U3};
+//! use nalgebra::{DMatrix, DVector, Dyn, Matrix3, OMatrix, Vector3, U3};
 //! use proptest::prelude::*;
 //!
 //! proptest! {
@@ -108,7 +108,7 @@
 //!     # /*
 //!     #[test]
 //!     # */
-//!     fn test_static_and_mixed(matrix: Matrix3<i32>, matrix2: OMatrix<i32, U3, Dynamic>) {
+//!     fn test_static_and_mixed(matrix: Matrix3<i32>, matrix2: OMatrix<i32, U3, Dyn>) {
 //!         // Test some property involving these matrices
 //!     }
 //!
@@ -141,7 +141,7 @@
 //! PROPTEST_MAX_SHRINK_ITERS=100000 cargo test my_failing_test
 //! ```
 use crate::allocator::Allocator;
-use crate::{Const, DefaultAllocator, Dim, DimName, Dynamic, OMatrix, Scalar, U1};
+use crate::{Const, DefaultAllocator, Dim, DimName, Dyn, OMatrix, Scalar, U1};
 use proptest::arbitrary::Arbitrary;
 use proptest::collection::vec;
 use proptest::strategy::{BoxedStrategy, Just, NewTree, Strategy, ValueTree};
@@ -167,9 +167,9 @@ pub struct MatrixParameters<NParameters, R, C> {
 /// of matrices with `proptest`. In most cases, you do not need to concern yourself with
 /// `DimRange` directly, as it supports conversion from other types such as `U3` or inclusive
 /// ranges such as `5 ..= 6`. The latter example corresponds to dimensions from (inclusive)
-/// `Dynamic::new(5)` to `Dynamic::new(6)` (inclusive).
+/// `Dyn(5)` to `Dyn(6)` (inclusive).
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub struct DimRange<D = Dynamic>(RangeInclusive<D>);
+pub struct DimRange<D = Dyn>(RangeInclusive<D>);
 
 impl<D: Dim> DimRange<D> {
     /// The lower bound for dimensions generated.
@@ -195,9 +195,9 @@ impl<D: Dim> From<RangeInclusive<D>> for DimRange<D> {
     }
 }
 
-impl From<RangeInclusive<usize>> for DimRange<Dynamic> {
+impl From<RangeInclusive<usize>> for DimRange<Dyn> {
     fn from(range: RangeInclusive<usize>) -> Self {
-        DimRange::from(Dynamic::new(*range.start())..=Dynamic::new(*range.end()))
+        DimRange::from(Dyn(*range.start())..=Dyn(*range.end()))
     }
 }
 
@@ -208,14 +208,14 @@ impl<D: Dim> DimRange<D> {
     }
 }
 
-impl From<usize> for DimRange<Dynamic> {
+impl From<usize> for DimRange<Dyn> {
     fn from(dim: usize) -> Self {
-        DimRange::from(Dynamic::new(dim))
+        DimRange::from(Dyn(dim))
     }
 }
 
-/// The default range used for Dynamic dimensions when generating arbitrary matrices.
-fn dynamic_dim_range() -> DimRange<Dynamic> {
+/// The default range used for Dyn dimensions when generating arbitrary matrices.
+fn dynamic_dim_range() -> DimRange<Dyn> {
     DimRange::from(0..=6)
 }
 
@@ -225,7 +225,7 @@ fn dynamic_dim_range() -> DimRange<Dynamic> {
 /// ## Examples
 /// ```
 /// use nalgebra::proptest::matrix;
-/// use nalgebra::{OMatrix, Const, Dynamic};
+/// use nalgebra::{OMatrix, Const, Dyn};
 /// use proptest::prelude::*;
 ///
 /// proptest! {
@@ -234,7 +234,7 @@ fn dynamic_dim_range() -> DimRange<Dynamic> {
 ///     # */
 ///     fn my_test(a in matrix(0 .. 5i32, Const::<3>, 0 ..= 5)) {
 ///         // Let's make sure we've got the correct type first
-///         let a: OMatrix<_, Const::<3>, Dynamic> = a;
+///         let a: OMatrix<_, Const::<3>, Dyn> = a;
 ///         prop_assert!(a.nrows() == 3);
 ///         prop_assert!(a.ncols() <= 5);
 ///         prop_assert!(a.iter().all(|x_ij| *x_ij >= 0 && *x_ij < 5));
@@ -347,7 +347,7 @@ where
     }
 }
 
-impl<NParameters, R> Default for MatrixParameters<NParameters, R, Dynamic>
+impl<NParameters, R> Default for MatrixParameters<NParameters, R, Dyn>
 where
     NParameters: Default,
     R: DimName,
@@ -361,7 +361,7 @@ where
     }
 }
 
-impl<NParameters, C> Default for MatrixParameters<NParameters, Dynamic, C>
+impl<NParameters, C> Default for MatrixParameters<NParameters, Dyn, C>
 where
     NParameters: Default,
     C: DimName,
@@ -375,7 +375,7 @@ where
     }
 }
 
-impl<NParameters> Default for MatrixParameters<NParameters, Dynamic, Dynamic>
+impl<NParameters> Default for MatrixParameters<NParameters, Dyn, Dyn>
 where
     NParameters: Default,
 {
diff --git a/src/sparse/cs_matrix.rs b/src/sparse/cs_matrix.rs
index 14f8d41e..5b63e537 100644
--- a/src/sparse/cs_matrix.rs
+++ b/src/sparse/cs_matrix.rs
@@ -7,7 +7,7 @@ use std::slice;
 
 use crate::allocator::Allocator;
 use crate::sparse::cs_utils;
-use crate::{Const, DefaultAllocator, Dim, Dynamic, Matrix, OVector, Scalar, Vector, U1};
+use crate::{Const, DefaultAllocator, Dim, Dyn, Matrix, OVector, Scalar, Vector, U1};
 
 pub struct ColumnEntries<'a, T> {
     curr: usize,
@@ -236,16 +236,16 @@ impl<T: Scalar, R: Dim, C: Dim> CsStorageMut<T, R, C> for CsVecStorage<T, R, C>
 pub struct CsSliceStorage<'a, T: Scalar, R: Dim, C: DimAdd<U1>> {
     shape: (R, C),
     p: VectorSlice<usize, DimSum<C, U1>>,
-    i: VectorSlice<usize, Dynamic>,
-    vals: VectorSlice<T, Dynamic>,
+    i: VectorSlice<usize, Dyn>,
+    vals: VectorSlice<T, Dyn>,
 }*/
 
 /// A compressed sparse column matrix.
 #[derive(Clone, Debug, PartialEq)]
 pub struct CsMatrix<
     T: Scalar,
-    R: Dim = Dynamic,
-    C: Dim = Dynamic,
+    R: Dim = Dyn,
+    C: Dim = Dyn,
     S: CsStorage<T, R, C> = CsVecStorage<T, R, C>,
 > {
     pub(crate) data: S,
@@ -253,7 +253,7 @@ pub struct CsMatrix<
 }
 
 /// A column compressed sparse vector.
-pub type CsVector<T, R = Dynamic, S = CsVecStorage<T, R, U1>> = CsMatrix<T, R, U1, S>;
+pub type CsVector<T, R = Dyn, S = CsVecStorage<T, R, U1>> = CsMatrix<T, R, U1, S>;
 
 impl<T: Scalar, R: Dim, C: Dim> CsMatrix<T, R, C>
 where
@@ -342,8 +342,8 @@ impl<T: Scalar + Zero + ClosedAdd> CsMatrix<T> {
         vals: Vec<T>,
     ) -> Self
     {
-        let nrows = Dynamic::new(nrows);
-        let ncols = Dynamic::new(ncols);
+        let nrows = Dyn(nrows);
+        let ncols = Dyn(ncols);
         let p = DVector::from_data(VecStorage::new(ncols, U1, p));
         Self::from_parts_generic(nrows, ncols, p, i, vals)
     }
diff --git a/src/sparse/cs_matrix_conversion.rs b/src/sparse/cs_matrix_conversion.rs
index e7ff8c36..4154f452 100644
--- a/src/sparse/cs_matrix_conversion.rs
+++ b/src/sparse/cs_matrix_conversion.rs
@@ -5,7 +5,7 @@ use crate::allocator::Allocator;
 use crate::sparse::cs_utils;
 use crate::sparse::{CsMatrix, CsStorage};
 use crate::storage::Storage;
-use crate::{DefaultAllocator, Dim, Dynamic, Matrix, OMatrix, Scalar};
+use crate::{DefaultAllocator, Dim, Dyn, Matrix, OMatrix, Scalar};
 
 impl<'a, T: Scalar + Zero + ClosedAdd> CsMatrix<T> {
     /// Creates a column-compressed sparse matrix from a sparse matrix in triplet form.
@@ -16,7 +16,7 @@ impl<'a, T: Scalar + Zero + ClosedAdd> CsMatrix<T> {
         icols: &[usize],
         vals: &[T],
     ) -> Self {
-        Self::from_triplet_generic(Dynamic::new(nrows), Dynamic::new(ncols), irows, icols, vals)
+        Self::from_triplet_generic(Dyn(nrows), Dyn(ncols), irows, icols, vals)
     }
 }
 
diff --git a/tests/core/edition.rs b/tests/core/edition.rs
index bd882652..f5a51874 100644
--- a/tests/core/edition.rs
+++ b/tests/core/edition.rs
@@ -2,7 +2,7 @@ use na::{
     DMatrix, Matrix, Matrix3, Matrix3x4, Matrix3x5, Matrix4, Matrix4x3, Matrix4x5, Matrix5,
     Matrix5x3, Matrix5x4,
 };
-use na::{Dynamic, U3, U5};
+use na::{Dyn, U3, U5};
 
 #[test]
 #[rustfmt::skip]
@@ -257,7 +257,7 @@ fn remove_columns() {
     assert_eq!(m.remove_fixed_columns::<2>(2), expected_b3);
 
     // The following is just to verify that the return type dimensions is correctly inferred.
-    let computed: Matrix<_, U3, Dynamic, _> = m.remove_columns(3, 2);
+    let computed: Matrix<_, U3, Dyn, _> = m.remove_columns(3, 2);
     assert!(computed.eq(&expected_b2));
 
     /*
@@ -391,7 +391,7 @@ fn remove_rows() {
     assert_eq!(m.remove_fixed_rows::<2>(2), expected3);
 
     // The following is just to verify that the return type dimensions is correctly inferred.
-    let computed: Matrix<_, Dynamic, U3, _> = m.remove_rows(3, 2);
+    let computed: Matrix<_, Dyn, U3, _> = m.remove_rows(3, 2);
     assert!(computed.eq(&expected2));
 }
 
@@ -508,7 +508,7 @@ fn insert_columns() {
     assert_eq!(m.insert_fixed_columns::<2>(2, 0), expected3);
 
     // The following is just to verify that the return type dimensions is correctly inferred.
-    let computed: Matrix<_, U5, Dynamic, _> = m.insert_columns(3, 2, 0);
+    let computed: Matrix<_, U5, Dyn, _> = m.insert_columns(3, 2, 0);
     assert!(computed.eq(&expected2));
 }
 
@@ -581,7 +581,7 @@ fn insert_rows() {
     assert_eq!(m.insert_fixed_rows::<2>(2, 0), expected3);
 
     // The following is just to verify that the return type dimensions is correctly inferred.
-    let computed: Matrix<_, Dynamic, U5, _> = m.insert_rows(3, 2, 0);
+    let computed: Matrix<_, Dyn, U5, _> = m.insert_rows(3, 2, 0);
     assert!(computed.eq(&expected2));
 }
 
diff --git a/tests/core/reshape.rs b/tests/core/reshape.rs
index 42afa9bf..0ad24bc6 100644
--- a/tests/core/reshape.rs
+++ b/tests/core/reshape.rs
@@ -1,5 +1,5 @@
 use na::{
-    Const, DMatrix, DMatrixView, DMatrixViewMut, Dyn, Dynamic, Matrix, MatrixView, MatrixViewMut,
+    Const, DMatrix, DMatrixView, DMatrixViewMut, Dyn, Dyn, Matrix, MatrixView, MatrixViewMut,
     SMatrix, SMatrixView, SMatrixViewMut, VecStorage, U3, U4,
 };
 use nalgebra_macros::matrix;
@@ -60,21 +60,21 @@ fn reshape_slice() {
 
     // Static "source slice"
     test_reshape!(SMatrixView<_, 4, 3> => SMatrixView<_, 3, 4>, U3, U4);
-    test_reshape!(SMatrixView<_, 4, 3> => DMatrixView<_>, Dynamic::new(3), Dynamic::new(4));
-    test_reshape!(SMatrixView<_, 4, 3> => MatrixView<_, Const<3>, Dynamic>, U3, Dynamic::new(4));
-    test_reshape!(SMatrixView<_, 4, 3> => MatrixView<_, Dynamic, Const<4>>, Dynamic::new(3), U4);
+    test_reshape!(SMatrixView<_, 4, 3> => DMatrixView<_>, Dyn(3), Dyn(4));
+    test_reshape!(SMatrixView<_, 4, 3> => MatrixView<_, Const<3>, Dyn>, U3, Dyn(4));
+    test_reshape!(SMatrixView<_, 4, 3> => MatrixView<_, Dyn, Const<4>>, Dyn(3), U4);
     test_reshape!(SMatrixViewMut<_, 4, 3> => SMatrixViewMut<_, 3, 4>, U3, U4);
-    test_reshape!(SMatrixViewMut<_, 4, 3> => DMatrixViewMut<_>, Dynamic::new(3), Dynamic::new(4));
-    test_reshape!(SMatrixViewMut<_, 4, 3> => MatrixViewMut<_, Const<3>, Dynamic>, U3, Dynamic::new(4));
-    test_reshape!(SMatrixViewMut<_, 4, 3> => MatrixViewMut<_, Dynamic, Const<4>>, Dynamic::new(3), U4);
+    test_reshape!(SMatrixViewMut<_, 4, 3> => DMatrixViewMut<_>, Dyn(3), Dyn(4));
+    test_reshape!(SMatrixViewMut<_, 4, 3> => MatrixViewMut<_, Const<3>, Dyn>, U3, Dyn(4));
+    test_reshape!(SMatrixViewMut<_, 4, 3> => MatrixViewMut<_, Dyn, Const<4>>, Dyn(3), U4);
 
-    // Dynamic "source slice"
+    // Dyn "source slice"
     test_reshape!(DMatrixView<_> => SMatrixView<_, 3, 4>, U3, U4);
-    test_reshape!(DMatrixView<_> => DMatrixView<_>, Dynamic::new(3), Dynamic::new(4));
-    test_reshape!(DMatrixView<_> => MatrixView<_, Const<3>, Dynamic>, U3, Dynamic::new(4));
-    test_reshape!(DMatrixView<_> => MatrixView<_, Dynamic, Const<4>>, Dynamic::new(3), U4);
+    test_reshape!(DMatrixView<_> => DMatrixView<_>, Dyn(3), Dyn(4));
+    test_reshape!(DMatrixView<_> => MatrixView<_, Const<3>, Dyn>, U3, Dyn(4));
+    test_reshape!(DMatrixView<_> => MatrixView<_, Dyn, Const<4>>, Dyn(3), U4);
     test_reshape!(DMatrixViewMut<_> => SMatrixViewMut<_, 3, 4>, U3, U4);
-    test_reshape!(DMatrixViewMut<_> => DMatrixViewMut<_>, Dynamic::new(3), Dynamic::new(4));
-    test_reshape!(DMatrixViewMut<_> => MatrixViewMut<_, Const<3>, Dynamic>, U3, Dynamic::new(4));
-    test_reshape!(DMatrixViewMut<_> => MatrixViewMut<_, Dynamic, Const<4>>, Dynamic::new(3), U4);
+    test_reshape!(DMatrixViewMut<_> => DMatrixViewMut<_>, Dyn(3), Dyn(4));
+    test_reshape!(DMatrixViewMut<_> => MatrixViewMut<_, Const<3>, Dyn>, U3, Dyn(4));
+    test_reshape!(DMatrixViewMut<_> => MatrixViewMut<_, Dyn, Const<4>>, Dyn(3), U4);
 }
diff --git a/tests/linalg/cholesky.rs b/tests/linalg/cholesky.rs
index 891e54ca..a73fa947 100644
--- a/tests/linalg/cholesky.rs
+++ b/tests/linalg/cholesky.rs
@@ -15,7 +15,7 @@ macro_rules! gen_tests(
     ($module: ident, $scalar: ty) => {
         mod $module {
             use na::debug::RandomSDP;
-            use na::dimension::{Const, Dynamic};
+            use na::dimension::{Const, Dyn};
             use na::{DMatrix, DVector, Matrix4x3, Vector4};
             use rand::random;
             use simba::scalar::ComplexField;
@@ -28,7 +28,7 @@ macro_rules! gen_tests(
             proptest! {
                 #[test]
                 fn cholesky(n in PROPTEST_MATRIX_DIM) {
-                    let m = RandomSDP::new(Dynamic::new(n), || random::<$scalar>().0).unwrap();
+                    let m = RandomSDP::new(Dyn(n), || random::<$scalar>().0).unwrap();
                     let l = m.clone().cholesky().unwrap().unpack();
                     prop_assert!(relative_eq!(m, &l * l.adjoint(), epsilon = 1.0e-7));
                 }
@@ -44,7 +44,7 @@ macro_rules! gen_tests(
 
                 #[test]
                 fn cholesky_solve(n in PROPTEST_MATRIX_DIM, nb in PROPTEST_MATRIX_DIM) {
-                    let m = RandomSDP::new(Dynamic::new(n), || random::<$scalar>().0).unwrap();
+                    let m = RandomSDP::new(Dyn(n), || random::<$scalar>().0).unwrap();
 
                     let chol = m.clone().cholesky().unwrap();
                     let b1 = DVector::<$scalar>::new_random(n).map(|e| e.0);
@@ -73,7 +73,7 @@ macro_rules! gen_tests(
 
                 #[test]
                 fn cholesky_inverse(n in PROPTEST_MATRIX_DIM) {
-                    let m = RandomSDP::new(Dynamic::new(n), || random::<$scalar>().0).unwrap();
+                    let m = RandomSDP::new(Dyn(n), || random::<$scalar>().0).unwrap();
                     let m1 = m.clone().cholesky().unwrap().inverse();
                     let id1 = &m  * &m1;
                     let id2 = &m1 * &m;
@@ -93,7 +93,7 @@ macro_rules! gen_tests(
 
                 #[test]
                 fn cholesky_determinant(n in PROPTEST_MATRIX_DIM) {
-                    let m = RandomSDP::new(Dynamic::new(n), || random::<$scalar>().0).unwrap();
+                    let m = RandomSDP::new(Dyn(n), || random::<$scalar>().0).unwrap();
                     let lu_det = m.clone().lu().determinant();
                     assert_relative_eq!(lu_det.imaginary(), 0., epsilon = 1.0e-7);
                     let chol_det = m.cholesky().unwrap().determinant();
@@ -137,7 +137,7 @@ macro_rules! gen_tests(
                 fn cholesky_insert_column(n in PROPTEST_MATRIX_DIM) {
                     let n = n.max(1).min(10);
                     let j = random::<usize>() % n;
-                    let m_updated = RandomSDP::new(Dynamic::new(n), || random::<$scalar>().0).unwrap();
+                    let m_updated = RandomSDP::new(Dyn(n), || random::<$scalar>().0).unwrap();
 
                     // build m and col from m_updated
                     let col = m_updated.column(j);
@@ -154,7 +154,7 @@ macro_rules! gen_tests(
                 fn cholesky_remove_column(n in PROPTEST_MATRIX_DIM) {
                     let n = n.max(1).min(10);
                     let j = random::<usize>() % n;
-                    let m = RandomSDP::new(Dynamic::new(n), || random::<$scalar>().0).unwrap();
+                    let m = RandomSDP::new(Dyn(n), || random::<$scalar>().0).unwrap();
 
                     // remove column from cholesky decomposition and rebuild m
                     let chol = m.clone().cholesky().unwrap().remove_column(j);
diff --git a/tests/linalg/convolution.rs b/tests/linalg/convolution.rs
index b2e151d3..eba8b84d 100644
--- a/tests/linalg/convolution.rs
+++ b/tests/linalg/convolution.rs
@@ -16,7 +16,7 @@ fn convolve_same_check() {
 
     assert!(relative_eq!(actual_s, expected_s, epsilon = 1.0e-7));
 
-    // Dynamic Tests
+    // Dyn Tests
     let actual_d = DVector::from_vec(vec![1.0, 4.0, 7.0, 10.0]);
     let expected_d = DVector::from_vec(vec![1.0, 2.0, 3.0, 4.0])
         .convolve_same(DVector::from_vec(vec![1.0, 2.0]));
@@ -54,7 +54,7 @@ fn convolve_full_check() {
 
     assert!(relative_eq!(actual_s, expected_s, epsilon = 1.0e-7));
 
-    // Dynamic Tests
+    // Dyn Tests
     let actual_d = DVector::from_vec(vec![1.0, 4.0, 7.0, 10.0, 8.0]);
     let expected_d = DVector::from_vec(vec![1.0, 2.0, 3.0, 4.0])
         .convolve_full(DVector::from_vec(vec![1.0, 2.0]));
@@ -90,7 +90,7 @@ fn convolve_valid_check() {
 
     assert!(relative_eq!(actual_s, expected_s, epsilon = 1.0e-7));
 
-    // Dynamic Tests
+    // Dyn Tests
     let actual_d = DVector::from_vec(vec![4.0, 7.0, 10.0]);
     let expected_d = DVector::from_vec(vec![1.0, 2.0, 3.0, 4.0])
         .convolve_valid(DVector::from_vec(vec![1.0, 2.0]));
diff --git a/tests/linalg/full_piv_lu.rs b/tests/linalg/full_piv_lu.rs
index 7ac95b0f..24e3bb48 100644
--- a/tests/linalg/full_piv_lu.rs
+++ b/tests/linalg/full_piv_lu.rs
@@ -253,7 +253,7 @@ fn remove_columns() {
     assert_eq!(m.remove_fixed_columns::<U2>(2), expected3);
 
     // The following is just to verify that the return type dimensions is correctly inferred.
-    let computed: Matrix<_, U3, Dynamic, _> = m.remove_columns(3, 2);
+    let computed: Matrix<_, U3, Dyn, _> = m.remove_columns(3, 2);
     assert!(computed.eq(&expected2));
 }
 
@@ -309,7 +309,7 @@ fn remove_rows() {
     assert_eq!(m.remove_fixed_rows::<U2>(2), expected3);
 
     // The following is just to verify that the return type dimensions is correctly inferred.
-    let computed: Matrix<_, Dynamic, U3, _> = m.remove_rows(3, 2);
+    let computed: Matrix<_, Dyn, U3, _> = m.remove_rows(3, 2);
     assert!(computed.eq(&expected2));
 }
 
@@ -374,7 +374,7 @@ fn insert_columns() {
     assert_eq!(m.insert_fixed_columns::<U2>(2, 0), expected3);
 
     // The following is just to verify that the return type dimensions is correctly inferred.
-    let computed: Matrix<_, U5, Dynamic, _> = m.insert_columns(3, 2, 0);
+    let computed: Matrix<_, U5, Dyn, _> = m.insert_columns(3, 2, 0);
     assert!(computed.eq(&expected2));
 }
 
@@ -434,7 +434,7 @@ fn insert_rows() {
     assert_eq!(m.insert_fixed_rows::<2>(2, 0), expected3);
 
     // The following is just to verify that the return type dimensions is correctly inferred.
-    let computed: Matrix<_, Dynamic, U5, _> = m.insert_rows(3, 2, 0);
+    let computed: Matrix<_, Dyn, U5, _> = m.insert_rows(3, 2, 0);
     assert!(computed.eq(&expected2));
 }
 
diff --git a/tests/proptest/mod.rs b/tests/proptest/mod.rs
index ec2e2c7b..cedfae84 100644
--- a/tests/proptest/mod.rs
+++ b/tests/proptest/mod.rs
@@ -101,11 +101,11 @@ pub fn dvector() -> impl Strategy<Value = DVector<f64>> {
 
 pub fn dmatrix_<ScalarStrategy>(
     scalar_strategy: ScalarStrategy,
-) -> impl Strategy<Value = OMatrix<ScalarStrategy::Value, Dynamic, Dynamic>>
+) -> impl Strategy<Value = OMatrix<ScalarStrategy::Value, Dyn, Dyn>>
 where
     ScalarStrategy: Strategy + Clone + 'static,
     ScalarStrategy::Value: Scalar,
-    DefaultAllocator: Allocator<ScalarStrategy::Value, Dynamic, Dynamic>,
+    DefaultAllocator: Allocator<ScalarStrategy::Value, Dyn, Dyn>,
 {
     matrix(scalar_strategy, PROPTEST_MATRIX_DIM, PROPTEST_MATRIX_DIM)
 }
@@ -114,7 +114,7 @@ where
 // where
 //     RangeInclusive<T>: Strategy<Value = T>,
 //     T: Scalar + PartialEq + Copy,
-//     DefaultAllocator: Allocator<T, Dynamic>,
+//     DefaultAllocator: Allocator<T, Dyn>,
 // {
 //     vector(range, PROPTEST_MATRIX_DIM)
 // }
@@ -213,9 +213,9 @@ fn test_matrix_output_types() {
     // Test that the dimension types are correct for the given inputs
     let _: MatrixStrategy<_, U3, U4> = matrix(-5..5, Const::<3>, Const::<4>);
     let _: MatrixStrategy<_, U3, U3> = matrix(-5..5, Const::<3>, Const::<3>);
-    let _: MatrixStrategy<_, U3, Dynamic> = matrix(-5..5, Const::<3>, 1..=5);
-    let _: MatrixStrategy<_, Dynamic, U3> = matrix(-5..5, 1..=5, Const::<3>);
-    let _: MatrixStrategy<_, Dynamic, Dynamic> = matrix(-5..5, 1..=5, 1..=5);
+    let _: MatrixStrategy<_, U3, Dyn> = matrix(-5..5, Const::<3>, 1..=5);
+    let _: MatrixStrategy<_, Dyn, U3> = matrix(-5..5, 1..=5, Const::<3>);
+    let _: MatrixStrategy<_, Dyn, Dyn> = matrix(-5..5, 1..=5, 1..=5);
 }
 
 // Below we have some tests to ensure that specific instances of OMatrix are usable
@@ -225,10 +225,10 @@ proptest! {
     fn ensure_arbitrary_test_compiles_matrix3(_: Matrix3<i32>) {}
 
     #[test]
-    fn ensure_arbitrary_test_compiles_matrixmn_u3_dynamic(_: OMatrix<i32, U3, Dynamic>) {}
+    fn ensure_arbitrary_test_compiles_matrixmn_u3_dynamic(_: OMatrix<i32, U3, Dyn>) {}
 
     #[test]
-    fn ensure_arbitrary_test_compiles_matrixmn_dynamic_u3(_: OMatrix<i32, Dynamic, U3>) {}
+    fn ensure_arbitrary_test_compiles_matrixmn_dynamic_u3(_: OMatrix<i32, Dyn, U3>) {}
 
     #[test]
     fn ensure_arbitrary_test_compiles_dmatrix(_: DMatrix<i32>) {}

From bcfc20caba12e70ca6db02ee5d53590c86be884e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=A9bastien=20Crozet?= <developer@crozet.re>
Date: Sat, 14 Jan 2023 16:26:26 +0100
Subject: [PATCH 118/119] Fix duplicate import

---
 tests/core/reshape.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/core/reshape.rs b/tests/core/reshape.rs
index 0ad24bc6..3873667f 100644
--- a/tests/core/reshape.rs
+++ b/tests/core/reshape.rs
@@ -1,6 +1,6 @@
 use na::{
-    Const, DMatrix, DMatrixView, DMatrixViewMut, Dyn, Dyn, Matrix, MatrixView, MatrixViewMut,
-    SMatrix, SMatrixView, SMatrixViewMut, VecStorage, U3, U4,
+    Const, DMatrix, DMatrixView, DMatrixViewMut, Dyn, Matrix, MatrixView, MatrixViewMut, SMatrix,
+    SMatrixView, SMatrixViewMut, VecStorage, U3, U4,
 };
 use nalgebra_macros::matrix;
 use simba::scalar::SupersetOf;

From 8aa34a952fabbb022ab719df702fe8714e258f3a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=A9bastien=20Crozet?= <developer@crozet.re>
Date: Sat, 14 Jan 2023 17:04:22 +0100
Subject: [PATCH 119/119] Release v0.32.0

---
 CHANGELOG.md               | 22 ++++++++++++++++++++++
 Cargo.toml                 |  6 +++---
 examples/cargo/Cargo.toml  |  2 +-
 nalgebra-glm/Cargo.toml    |  6 +++---
 nalgebra-lapack/Cargo.toml |  8 ++++----
 nalgebra-macros/Cargo.toml |  2 +-
 nalgebra-sparse/Cargo.toml |  6 +++---
 7 files changed, 37 insertions(+), 15 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 45c48063..71846f87 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,28 @@ documented here.
 
 This project adheres to [Semantic Versioning](https://semver.org/).
 
+## [0.32.0] (14 Jan. 2023)
+
+### Modified
+- Renamed all `MatrixSlice` types to `MatrixView`. In general all occurrences of the world `Slice` or `slice` have been
+  replaced by `View` or `view`.
+- Deprecated all the types involving `Slice` in its name, in favor of the word `View`.
+- Make it so that most `nalgebra` objects archive as themselves (when using `rkyv` for serialization).
+- Renamed `Dynamic` to `Dyn` and make `Dyn` a tuple struct.
+
+### Added
+- Add `Cholesky::ln_determinant` to compute the natural logarithm of the determinant of a matrix decomposed 
+  with Cholesky. This can be more numerically stable than computing the determinant itself when very small and/or
+  large values are involved.
+- Added new methods `Matrix::as_view` and `Matrix::as_view_mut`, which are very useful when working with view-based APIs.
+- Added parallel column iterator using `rayon`: `Matrix::par_column_iter` and `Matrix::par_column_iter_mut`. The `rayon`
+  feature must be enabled to access these methods.
+- Implement `ReshapableStorage` for matrix slices (only for unit strides at the moment).
+- Add `U0, U1, …` constants alongside the `U0, U1, …` types. This lets us write `U4` instead of `U4::name()` or
+  `Const::<4>` when we need const dimensions.
+
+### Fixed
+- Fixed the implementation of `Rotation3::euler_angles` to return the angles in the documented order (roll, pitch, yaw).
 
 ## [0.31.4] (13 Nov. 2022)
 
diff --git a/Cargo.toml b/Cargo.toml
index 82528ed4..03217548 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name    = "nalgebra"
-version = "0.31.4"
+version = "0.32.0"
 authors = [ "Sébastien Crozet <developer@crozet.re>" ]
 
 description = "General-purpose linear algebra library with transformations and statically-sized or dynamically-sized matrices."
@@ -78,7 +78,7 @@ num-traits     = { version = "0.2", default-features = false }
 num-complex    = { version = "0.4", default-features = false }
 num-rational   = { version = "0.4", default-features = false }
 approx         = { version = "0.5", default-features = false }
-simba          = { version = "0.7", default-features = false }
+simba          = { version = "0.8", default-features = false }
 alga           = { version = "0.9", default-features = false, optional = true }
 rand_distr     = { version = "0.4", default-features = false, optional = true }
 matrixmultiply = { version = "0.3", optional = true }
@@ -108,7 +108,7 @@ rayon          = { version = "1.6", optional = true }
 serde_json = "1.0"
 rand_xorshift = "0.3"
 rand_isaac = "0.3"
-criterion = { version = "0.3", features = ["html_reports"] }
+criterion = { version = "0.4", features = ["html_reports"] }
 
 # For matrix comparison macro
 matrixcompare = "0.3.0"
diff --git a/examples/cargo/Cargo.toml b/examples/cargo/Cargo.toml
index 63e70aab..2e9d4f23 100644
--- a/examples/cargo/Cargo.toml
+++ b/examples/cargo/Cargo.toml
@@ -4,7 +4,7 @@ version = "0.0.0"
 authors = [ "You" ]
 
 [dependencies]
-nalgebra = "0.31.0"
+nalgebra = "0.32.0"
 
 [[bin]]
 name = "example"
diff --git a/nalgebra-glm/Cargo.toml b/nalgebra-glm/Cargo.toml
index e700af37..3f9c4dd9 100644
--- a/nalgebra-glm/Cargo.toml
+++ b/nalgebra-glm/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "nalgebra-glm"
-version = "0.17.0"
+version = "0.18.0"
 authors = ["sebcrozet <developer@crozet.re>"]
 
 description = "A computer-graphics oriented API for nalgebra, inspired by the C++ GLM library."
@@ -35,5 +35,5 @@ convert-glam018 = [ "nalgebra/glam018" ]
 [dependencies]
 num-traits = { version = "0.2", default-features = false }
 approx = { version = "0.5", default-features = false }
-simba = { version = "0.7", default-features = false }
-nalgebra = { path =  "..", version = "0.31", default-features = false }
+simba = { version = "0.8", default-features = false }
+nalgebra = { path =  "..", version = "0.32", default-features = false }
diff --git a/nalgebra-lapack/Cargo.toml b/nalgebra-lapack/Cargo.toml
index af86224a..7eb7265b 100644
--- a/nalgebra-lapack/Cargo.toml
+++ b/nalgebra-lapack/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name    = "nalgebra-lapack"
-version = "0.23.0"
+version = "0.24.0"
 authors = [ "Sébastien Crozet <developer@crozet.re>", "Andrew Straw <strawman@astraw.com>" ]
 
 description   = "Matrix decompositions using nalgebra matrices and Lapack bindings."
@@ -29,17 +29,17 @@ accelerate = ["lapack-src/accelerate"]
 intel-mkl  = ["lapack-src/intel-mkl"]
 
 [dependencies]
-nalgebra      = { version = "0.31", path = ".." }
+nalgebra      = { version = "0.32", path = ".." }
 num-traits    = "0.2"
 num-complex   = { version = "0.4", default-features = false }
-simba         = "0.7"
+simba         = "0.8"
 serde         = { version = "1.0", features = [ "derive" ], optional = true }
 lapack        = { version = "0.19", default-features = false }
 lapack-src    = { version = "0.8", default-features = false }
 # clippy = "*"
 
 [dev-dependencies]
-nalgebra   = { version = "0.31", features = [ "arbitrary", "rand" ], path = ".." }
+nalgebra   = { version = "0.32", features = [ "arbitrary", "rand" ], path = ".." }
 proptest   = { version = "1", default-features = false, features = ["std"] }
 quickcheck = "1"
 approx     = "0.5"
diff --git a/nalgebra-macros/Cargo.toml b/nalgebra-macros/Cargo.toml
index 6e35f9e9..041e36a7 100644
--- a/nalgebra-macros/Cargo.toml
+++ b/nalgebra-macros/Cargo.toml
@@ -21,5 +21,5 @@ quote = "1.0"
 proc-macro2 = "1.0"
 
 [dev-dependencies]
-nalgebra = { version = "0.31.0", path = ".." }
+nalgebra = { version = "0.32.0", path = ".." }
 trybuild = "1.0.42"
diff --git a/nalgebra-sparse/Cargo.toml b/nalgebra-sparse/Cargo.toml
index fc95ddad..3a1bd20d 100644
--- a/nalgebra-sparse/Cargo.toml
+++ b/nalgebra-sparse/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "nalgebra-sparse"
-version = "0.8.0"
+version = "0.9.0"
 authors = [ "Andreas Longva", "Sébastien Crozet <developer@crozet.re>" ]
 edition = "2018"
 description = "Sparse matrix computation based on nalgebra."
@@ -24,7 +24,7 @@ io      = [ "pest", "pest_derive" ]
 slow-tests = []
 
 [dependencies]
-nalgebra = { version="0.31", path = "../" }
+nalgebra = { version="0.32", path = "../" }
 num-traits = { version = "0.2", default-features = false }
 proptest = { version = "1.0", optional = true }
 matrixcompare-core = { version = "0.1.0", optional = true }
@@ -35,7 +35,7 @@ serde = { version = "1.0", default-features = false, features = [ "derive" ], op
 [dev-dependencies]
 itertools = "0.10"
 matrixcompare = { version = "0.3.0", features = [ "proptest-support" ] }
-nalgebra = { version="0.31", path = "../", features = ["compare"] }
+nalgebra = { version="0.32", path = "../", features = ["compare"] }
 tempfile = "3.3"
 serde_json = "1.0"