diff --git a/Cargo.toml b/Cargo.toml
index a67c5839..15bf01fb 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -36,7 +36,7 @@ no_unsound_assume_init = [ ]
 # Conversion
 convert-mint = [ "mint" ]
 convert-glam = [ "glam" ]
-convert-glam-unchecked = [ "convert-glam" ] # Unable edgy conversions like Mat4 -> Isometry3
+convert-glam-unchecked = [ "convert-glam" ] # Enable edgy conversions like Mat4 -> Isometry3
 convert-bytemuck = [ "bytemuck" ]
 
 # Serialization
@@ -54,7 +54,6 @@ slow-tests       = []
 
 [dependencies]
 typenum        = "1.12"
-generic-array  = "0.14"
 rand-package   = { package = "rand", version = "0.8", optional = true, default-features = false }
 num-traits     = { version = "0.2", default-features = false }
 num-complex    = { version = "0.3", default-features = false }
diff --git a/README.md b/README.md
index 08350907..bed6183d 100644
--- a/README.md
+++ b/README.md
@@ -30,10 +30,10 @@
 
 -----
 
-## Gold sponsors
+## Platinum sponsors
 Rapier is supported by:
 <p>
   <a href="https://embark-studios.com">
-    <img src="https://www.embark.dev/img/logo_black.png" width="301px">
+    <img src="https://www.embark.dev/img/logo_black.png" width="401px">
   </a>
 </p>
diff --git a/benches/common/macros.rs b/benches/common/macros.rs
index 43bcf59d..3f775958 100644
--- a/benches/common/macros.rs
+++ b/benches/common/macros.rs
@@ -60,7 +60,7 @@ macro_rules! bench_unop_na(
                 i = (i + 1) & (LEN - 1);
 
                 unsafe {
-                    test::black_box(na::$unop(elems.get_unchecked(i)))
+                    std::hint::black_box(na::$unop(elems.get_unchecked(i)))
                 }
             }));
         }
@@ -82,7 +82,7 @@ macro_rules! bench_unop(
                 i = (i + 1) & (LEN - 1);
 
                 unsafe {
-                    test::black_box(elems.get_unchecked_mut(i).$unop())
+                    std::hint::black_box(elems.get_unchecked_mut(i).$unop())
                 }
             }));
         }
@@ -105,7 +105,7 @@ macro_rules! bench_construction(
 
                 unsafe {
                     let res = $constructor($(*$args.get_unchecked(i),)*);
-                    test::black_box(res)
+                    std::hint::black_box(res)
                 }
             }));
         }
diff --git a/benches/core/matrix.rs b/benches/core/matrix.rs
index 7f4432e3..df4a5a5b 100644
--- a/benches/core/matrix.rs
+++ b/benches/core/matrix.rs
@@ -1,4 +1,4 @@
-use na::{DMatrix, DVector, Matrix2, Matrix3, Matrix4, MatrixN, Vector2, Vector3, Vector4, U10};
+use na::{DMatrix, DVector, Matrix2, Matrix3, Matrix4, OMatrix, Vector2, Vector3, Vector4, U10};
 use rand::Rng;
 use rand_isaac::IsaacRng;
 use std::ops::{Add, Div, Mul, Sub};
@@ -116,8 +116,8 @@ fn mat10_mul_mat10(bench: &mut criterion::Criterion) {
 }
 
 fn mat10_mul_mat10_static(bench: &mut criterion::Criterion) {
-    let a = MatrixN::<f64, U10>::new_random();
-    let b = MatrixN::<f64, U10>::new_random();
+    let a = OMatrix::<f64, U10, U10>::new_random();
+    let b = OMatrix::<f64, U10, U10>::new_random();
 
     bench.bench_function("mat10_mul_mat10_static", move |bh| bh.iter(|| &a * &b));
 }
@@ -198,7 +198,7 @@ fn mat_mul_mat(bench: &mut criterion::Criterion) {
 
     bench.bench_function("mat_mul_mat", move |bh| {
         bh.iter(|| {
-            test::black_box(a.mul_to(&b, &mut ab));
+            std::hint::black_box(a.mul_to(&b, &mut ab));
         })
     });
 }
diff --git a/benches/core/vector.rs b/benches/core/vector.rs
index 2806d034..66025bc5 100644
--- a/benches/core/vector.rs
+++ b/benches/core/vector.rs
@@ -1,8 +1,7 @@
-use na::{DVector, Vector2, Vector3, Vector4, VectorN};
+use na::{DVector, SVector, Vector2, Vector3, Vector4};
 use rand::Rng;
 use rand_isaac::IsaacRng;
 use std::ops::{Add, Div, Mul, Sub};
-use typenum::U10000;
 
 #[path = "../common/macros.rs"]
 mod macros;
@@ -45,8 +44,8 @@ bench_unop!(vec2_normalize, Vector2<f32>, normalize);
 bench_unop!(vec3_normalize, Vector3<f32>, normalize);
 bench_unop!(vec4_normalize, Vector4<f32>, normalize);
 
-bench_binop_ref!(vec10000_dot_f64, VectorN<f64, U10000>, VectorN<f64, U10000>, dot);
-bench_binop_ref!(vec10000_dot_f32, VectorN<f32, U10000>, VectorN<f32, U10000>, dot);
+bench_binop_ref!(vec10000_dot_f64, SVector<f64, 10000>, SVector<f64, 10000>, dot);
+bench_binop_ref!(vec10000_dot_f32, SVector<f32, 10000>, SVector<f32, 10000>, dot);
 
 fn vec10000_axpy_f64(bh: &mut criterion::Criterion) {
     use rand::SeedableRng;
@@ -82,8 +81,8 @@ fn vec10000_axpy_f64_slice(bh: &mut criterion::Criterion) {
 
     bh.bench_function("vec10000_axpy_f64_slice", move |bh| {
         bh.iter(|| {
-            let mut a = a.fixed_rows_mut::<U10000>(0);
-            let b = b.fixed_rows::<U10000>(0);
+            let mut a = a.fixed_rows_mut::<10000>(0);
+            let b = b.fixed_rows::<10000>(0);
 
             a.axpy(n, &b, 1.0)
         })
@@ -93,11 +92,11 @@ fn vec10000_axpy_f64_slice(bh: &mut criterion::Criterion) {
 fn vec10000_axpy_f64_static(bh: &mut criterion::Criterion) {
     use rand::SeedableRng;
     let mut rng = IsaacRng::seed_from_u64(0);
-    let mut a = VectorN::<f64, U10000>::new_random();
-    let b = VectorN::<f64, U10000>::new_random();
+    let mut a = SVector::<f64, 10000>::new_random();
+    let b = SVector::<f64, 10000>::new_random();
     let n = rng.gen::<f64>();
 
-    // NOTE: for some reasons, it is much faster if the arument are boxed (Box::new(VectorN...)).
+    // NOTE: for some reasons, it is much faster if the arument are boxed (Box::new(OVector...)).
     bh.bench_function("vec10000_axpy_f64_static", move |bh| {
         bh.iter(|| a.axpy(n, &b, 1.0))
     });
diff --git a/benches/lib.rs b/benches/lib.rs
index e4215a12..a77cc743 100644
--- a/benches/lib.rs
+++ b/benches/lib.rs
@@ -2,10 +2,7 @@
 #![allow(unused_macros)]
 
 extern crate nalgebra as na;
-extern crate rand;
-extern crate rand_isaac;
-extern crate test;
-extern crate typenum;
+extern crate rand_package as rand;
 
 #[macro_use]
 extern crate criterion;
diff --git a/benches/linalg/bidiagonal.rs b/benches/linalg/bidiagonal.rs
index ad875264..fe96c772 100644
--- a/benches/linalg/bidiagonal.rs
+++ b/benches/linalg/bidiagonal.rs
@@ -7,35 +7,35 @@ mod macros;
 fn bidiagonalize_100x100(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(100, 100);
     bh.bench_function("bidiagonalize_100x100", move |bh| {
-        bh.iter(|| test::black_box(Bidiagonal::new(m.clone())))
+        bh.iter(|| std::hint::black_box(Bidiagonal::new(m.clone())))
     });
 }
 
 fn bidiagonalize_100x500(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(100, 500);
     bh.bench_function("bidiagonalize_100x500", move |bh| {
-        bh.iter(|| test::black_box(Bidiagonal::new(m.clone())))
+        bh.iter(|| std::hint::black_box(Bidiagonal::new(m.clone())))
     });
 }
 
 fn bidiagonalize_4x4(bh: &mut criterion::Criterion) {
     let m = Matrix4::<f64>::new_random();
     bh.bench_function("bidiagonalize_4x4", move |bh| {
-        bh.iter(|| test::black_box(Bidiagonal::new(m.clone())))
+        bh.iter(|| std::hint::black_box(Bidiagonal::new(m.clone())))
     });
 }
 
 fn bidiagonalize_500x100(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(500, 100);
     bh.bench_function("bidiagonalize_500x100", move |bh| {
-        bh.iter(|| test::black_box(Bidiagonal::new(m.clone())))
+        bh.iter(|| std::hint::black_box(Bidiagonal::new(m.clone())))
     });
 }
 
 fn bidiagonalize_500x500(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(500, 500);
     bh.bench_function("bidiagonalize_500x500", move |bh| {
-        bh.iter(|| test::black_box(Bidiagonal::new(m.clone())))
+        bh.iter(|| std::hint::black_box(Bidiagonal::new(m.clone())))
     });
 }
 
diff --git a/benches/linalg/cholesky.rs b/benches/linalg/cholesky.rs
index a03888f5..09c80642 100644
--- a/benches/linalg/cholesky.rs
+++ b/benches/linalg/cholesky.rs
@@ -5,7 +5,7 @@ fn cholesky_100x100(bh: &mut criterion::Criterion) {
     let m = &m * m.transpose();
 
     bh.bench_function("cholesky_100x100", move |bh| {
-        bh.iter(|| test::black_box(Cholesky::new(m.clone())))
+        bh.iter(|| std::hint::black_box(Cholesky::new(m.clone())))
     });
 }
 
@@ -14,7 +14,7 @@ fn cholesky_500x500(bh: &mut criterion::Criterion) {
     let m = &m * m.transpose();
 
     bh.bench_function("cholesky_500x500", move |bh| {
-        bh.iter(|| test::black_box(Cholesky::new(m.clone())))
+        bh.iter(|| std::hint::black_box(Cholesky::new(m.clone())))
     });
 }
 
diff --git a/benches/linalg/full_piv_lu.rs b/benches/linalg/full_piv_lu.rs
index dfd176da..748b6b05 100644
--- a/benches/linalg/full_piv_lu.rs
+++ b/benches/linalg/full_piv_lu.rs
@@ -4,21 +4,21 @@ use na::{DMatrix, DVector, FullPivLU};
 fn full_piv_lu_decompose_10x10(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(10, 10);
     bh.bench_function("full_piv_lu_decompose_10x10", move |bh| {
-        bh.iter(|| test::black_box(FullPivLU::new(m.clone())))
+        bh.iter(|| std::hint::black_box(FullPivLU::new(m.clone())))
     });
 }
 
 fn full_piv_lu_decompose_100x100(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(100, 100);
     bh.bench_function("full_piv_lu_decompose_100x100", move |bh| {
-        bh.iter(|| test::black_box(FullPivLU::new(m.clone())))
+        bh.iter(|| std::hint::black_box(FullPivLU::new(m.clone())))
     });
 }
 
 fn full_piv_lu_decompose_500x500(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(500, 500);
     bh.bench_function("full_piv_lu_decompose_500x500", move |bh| {
-        bh.iter(|| test::black_box(FullPivLU::new(m.clone())))
+        bh.iter(|| std::hint::black_box(FullPivLU::new(m.clone())))
     });
 }
 
@@ -63,7 +63,7 @@ fn full_piv_lu_inverse_10x10(bh: &mut criterion::Criterion) {
     let lu = FullPivLU::new(m.clone());
 
     bh.bench_function("full_piv_lu_inverse_10x10", move |bh| {
-        bh.iter(|| test::black_box(lu.try_inverse()))
+        bh.iter(|| std::hint::black_box(lu.try_inverse()))
     });
 }
 
@@ -72,7 +72,7 @@ fn full_piv_lu_inverse_100x100(bh: &mut criterion::Criterion) {
     let lu = FullPivLU::new(m.clone());
 
     bh.bench_function("full_piv_lu_inverse_100x100", move |bh| {
-        bh.iter(|| test::black_box(lu.try_inverse()))
+        bh.iter(|| std::hint::black_box(lu.try_inverse()))
     });
 }
 
@@ -81,7 +81,7 @@ fn full_piv_lu_inverse_500x500(bh: &mut criterion::Criterion) {
     let lu = FullPivLU::new(m.clone());
 
     bh.bench_function("full_piv_lu_inverse_500x500", move |bh| {
-        bh.iter(|| test::black_box(lu.try_inverse()))
+        bh.iter(|| std::hint::black_box(lu.try_inverse()))
     });
 }
 
@@ -90,7 +90,7 @@ fn full_piv_lu_determinant_10x10(bh: &mut criterion::Criterion) {
     let lu = FullPivLU::new(m.clone());
 
     bh.bench_function("full_piv_lu_determinant_10x10", move |bh| {
-        bh.iter(|| test::black_box(lu.determinant()))
+        bh.iter(|| std::hint::black_box(lu.determinant()))
     });
 }
 
@@ -99,7 +99,7 @@ fn full_piv_lu_determinant_100x100(bh: &mut criterion::Criterion) {
     let lu = FullPivLU::new(m.clone());
 
     bh.bench_function("full_piv_lu_determinant_100x100", move |bh| {
-        bh.iter(|| test::black_box(lu.determinant()))
+        bh.iter(|| std::hint::black_box(lu.determinant()))
     });
 }
 
@@ -108,7 +108,7 @@ fn full_piv_lu_determinant_500x500(bh: &mut criterion::Criterion) {
     let lu = FullPivLU::new(m.clone());
 
     bh.bench_function("full_piv_lu_determinant_500x500", move |bh| {
-        bh.iter(|| test::black_box(lu.determinant()))
+        bh.iter(|| std::hint::black_box(lu.determinant()))
     });
 }
 
diff --git a/benches/linalg/hessenberg.rs b/benches/linalg/hessenberg.rs
index a989616c..a2aabb80 100644
--- a/benches/linalg/hessenberg.rs
+++ b/benches/linalg/hessenberg.rs
@@ -7,28 +7,28 @@ mod macros;
 fn hessenberg_decompose_4x4(bh: &mut criterion::Criterion) {
     let m = Matrix4::<f64>::new_random();
     bh.bench_function("hessenberg_decompose_4x4", move |bh| {
-        bh.iter(|| test::black_box(Hessenberg::new(m.clone())))
+        bh.iter(|| std::hint::black_box(Hessenberg::new(m.clone())))
     });
 }
 
 fn hessenberg_decompose_100x100(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(100, 100);
     bh.bench_function("hessenberg_decompose_100x100", move |bh| {
-        bh.iter(|| test::black_box(Hessenberg::new(m.clone())))
+        bh.iter(|| std::hint::black_box(Hessenberg::new(m.clone())))
     });
 }
 
 fn hessenberg_decompose_200x200(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(200, 200);
     bh.bench_function("hessenberg_decompose_200x200", move |bh| {
-        bh.iter(|| test::black_box(Hessenberg::new(m.clone())))
+        bh.iter(|| std::hint::black_box(Hessenberg::new(m.clone())))
     });
 }
 
 fn hessenberg_decompose_500x500(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(500, 500);
     bh.bench_function("hessenberg_decompose_500x500", move |bh| {
-        bh.iter(|| test::black_box(Hessenberg::new(m.clone())))
+        bh.iter(|| std::hint::black_box(Hessenberg::new(m.clone())))
     });
 }
 
diff --git a/benches/linalg/lu.rs b/benches/linalg/lu.rs
index c42cd499..2b2ab972 100644
--- a/benches/linalg/lu.rs
+++ b/benches/linalg/lu.rs
@@ -4,21 +4,21 @@ use na::{DMatrix, DVector, LU};
 fn lu_decompose_10x10(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(10, 10);
     bh.bench_function("lu_decompose_10x10", move |bh| {
-        bh.iter(|| test::black_box(LU::new(m.clone())))
+        bh.iter(|| std::hint::black_box(LU::new(m.clone())))
     });
 }
 
 fn lu_decompose_100x100(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(100, 100);
     bh.bench_function("lu_decompose_100x100", move |bh| {
-        bh.iter(|| test::black_box(LU::new(m.clone())))
+        bh.iter(|| std::hint::black_box(LU::new(m.clone())))
     });
 }
 
 fn lu_decompose_500x500(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(500, 500);
     bh.bench_function("lu_decompose_500x500", move |bh| {
-        bh.iter(|| test::black_box(LU::new(m.clone())))
+        bh.iter(|| std::hint::black_box(LU::new(m.clone())))
     });
 }
 
@@ -63,7 +63,7 @@ fn lu_inverse_10x10(bh: &mut criterion::Criterion) {
     let lu = LU::new(m.clone());
 
     bh.bench_function("lu_inverse_10x10", move |bh| {
-        bh.iter(|| test::black_box(lu.try_inverse()))
+        bh.iter(|| std::hint::black_box(lu.try_inverse()))
     });
 }
 
@@ -72,7 +72,7 @@ fn lu_inverse_100x100(bh: &mut criterion::Criterion) {
     let lu = LU::new(m.clone());
 
     bh.bench_function("lu_inverse_100x100", move |bh| {
-        bh.iter(|| test::black_box(lu.try_inverse()))
+        bh.iter(|| std::hint::black_box(lu.try_inverse()))
     });
 }
 
@@ -81,7 +81,7 @@ fn lu_inverse_500x500(bh: &mut criterion::Criterion) {
     let lu = LU::new(m.clone());
 
     bh.bench_function("lu_inverse_500x500", move |bh| {
-        bh.iter(|| test::black_box(lu.try_inverse()))
+        bh.iter(|| std::hint::black_box(lu.try_inverse()))
     });
 }
 
@@ -90,7 +90,7 @@ fn lu_determinant_10x10(bh: &mut criterion::Criterion) {
     let lu = LU::new(m.clone());
 
     bh.bench_function("lu_determinant_10x10", move |bh| {
-        bh.iter(|| test::black_box(lu.determinant()))
+        bh.iter(|| std::hint::black_box(lu.determinant()))
     });
 }
 
@@ -99,7 +99,7 @@ fn lu_determinant_100x100(bh: &mut criterion::Criterion) {
     let lu = LU::new(m.clone());
 
     bh.bench_function("lu_determinant_100x100", move |bh| {
-        bh.iter(|| test::black_box(lu.determinant()))
+        bh.iter(|| std::hint::black_box(lu.determinant()))
     });
 }
 
@@ -107,7 +107,9 @@ fn lu_determinant_500x500(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(500, 500);
     let lu = LU::new(m.clone());
 
-    bh.bench_function("", move |bh| bh.iter(|| test::black_box(lu.determinant())));
+    bh.bench_function("", move |bh| {
+        bh.iter(|| std::hint::black_box(lu.determinant()))
+    });
 }
 
 criterion_group!(
diff --git a/benches/linalg/qr.rs b/benches/linalg/qr.rs
index d896f978..0c62b9ea 100644
--- a/benches/linalg/qr.rs
+++ b/benches/linalg/qr.rs
@@ -7,35 +7,35 @@ mod macros;
 fn qr_decompose_100x100(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(100, 100);
     bh.bench_function("qr_decompose_100x100", move |bh| {
-        bh.iter(|| test::black_box(QR::new(m.clone())))
+        bh.iter(|| std::hint::black_box(QR::new(m.clone())))
     });
 }
 
 fn qr_decompose_100x500(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(100, 500);
     bh.bench_function("qr_decompose_100x500", move |bh| {
-        bh.iter(|| test::black_box(QR::new(m.clone())))
+        bh.iter(|| std::hint::black_box(QR::new(m.clone())))
     });
 }
 
 fn qr_decompose_4x4(bh: &mut criterion::Criterion) {
     let m = Matrix4::<f64>::new_random();
     bh.bench_function("qr_decompose_4x4", move |bh| {
-        bh.iter(|| test::black_box(QR::new(m.clone())))
+        bh.iter(|| std::hint::black_box(QR::new(m.clone())))
     });
 }
 
 fn qr_decompose_500x100(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(500, 100);
     bh.bench_function("qr_decompose_500x100", move |bh| {
-        bh.iter(|| test::black_box(QR::new(m.clone())))
+        bh.iter(|| std::hint::black_box(QR::new(m.clone())))
     });
 }
 
 fn qr_decompose_500x500(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(500, 500);
     bh.bench_function("qr_decompose_500x500", move |bh| {
-        bh.iter(|| test::black_box(QR::new(m.clone())))
+        bh.iter(|| std::hint::black_box(QR::new(m.clone())))
     });
 }
 
@@ -121,7 +121,7 @@ fn qr_inverse_10x10(bh: &mut criterion::Criterion) {
     let qr = QR::new(m.clone());
 
     bh.bench_function("qr_inverse_10x10", move |bh| {
-        bh.iter(|| test::black_box(qr.try_inverse()))
+        bh.iter(|| std::hint::black_box(qr.try_inverse()))
     });
 }
 
@@ -130,7 +130,7 @@ fn qr_inverse_100x100(bh: &mut criterion::Criterion) {
     let qr = QR::new(m.clone());
 
     bh.bench_function("qr_inverse_100x100", move |bh| {
-        bh.iter(|| test::black_box(qr.try_inverse()))
+        bh.iter(|| std::hint::black_box(qr.try_inverse()))
     });
 }
 
@@ -139,7 +139,7 @@ fn qr_inverse_500x500(bh: &mut criterion::Criterion) {
     let qr = QR::new(m.clone());
 
     bh.bench_function("qr_inverse_500x500", move |bh| {
-        bh.iter(|| test::black_box(qr.try_inverse()))
+        bh.iter(|| std::hint::black_box(qr.try_inverse()))
     });
 }
 
diff --git a/benches/linalg/schur.rs b/benches/linalg/schur.rs
index e4193a25..2014f145 100644
--- a/benches/linalg/schur.rs
+++ b/benches/linalg/schur.rs
@@ -3,56 +3,56 @@ use na::{Matrix4, Schur};
 fn schur_decompose_4x4(bh: &mut criterion::Criterion) {
     let m = Matrix4::<f64>::new_random();
     bh.bench_function("schur_decompose_4x4", move |bh| {
-        bh.iter(|| test::black_box(Schur::new(m.clone())))
+        bh.iter(|| std::hint::black_box(Schur::new(m.clone())))
     });
 }
 
 fn schur_decompose_10x10(bh: &mut criterion::Criterion) {
     let m = crate::reproductible_dmatrix(10, 10);
     bh.bench_function("schur_decompose_10x10", move |bh| {
-        bh.iter(|| test::black_box(Schur::new(m.clone())))
+        bh.iter(|| std::hint::black_box(Schur::new(m.clone())))
     });
 }
 
 fn schur_decompose_100x100(bh: &mut criterion::Criterion) {
     let m = crate::reproductible_dmatrix(100, 100);
     bh.bench_function("schur_decompose_100x100", move |bh| {
-        bh.iter(|| test::black_box(Schur::new(m.clone())))
+        bh.iter(|| std::hint::black_box(Schur::new(m.clone())))
     });
 }
 
 fn schur_decompose_200x200(bh: &mut criterion::Criterion) {
     let m = crate::reproductible_dmatrix(200, 200);
     bh.bench_function("schur_decompose_200x200", move |bh| {
-        bh.iter(|| test::black_box(Schur::new(m.clone())))
+        bh.iter(|| std::hint::black_box(Schur::new(m.clone())))
     });
 }
 
 fn eigenvalues_4x4(bh: &mut criterion::Criterion) {
     let m = Matrix4::<f64>::new_random();
     bh.bench_function("eigenvalues_4x4", move |bh| {
-        bh.iter(|| test::black_box(m.complex_eigenvalues()))
+        bh.iter(|| std::hint::black_box(m.complex_eigenvalues()))
     });
 }
 
 fn eigenvalues_10x10(bh: &mut criterion::Criterion) {
     let m = crate::reproductible_dmatrix(10, 10);
     bh.bench_function("eigenvalues_10x10", move |bh| {
-        bh.iter(|| test::black_box(m.complex_eigenvalues()))
+        bh.iter(|| std::hint::black_box(m.complex_eigenvalues()))
     });
 }
 
 fn eigenvalues_100x100(bh: &mut criterion::Criterion) {
     let m = crate::reproductible_dmatrix(100, 100);
     bh.bench_function("eigenvalues_100x100", move |bh| {
-        bh.iter(|| test::black_box(m.complex_eigenvalues()))
+        bh.iter(|| std::hint::black_box(m.complex_eigenvalues()))
     });
 }
 
 fn eigenvalues_200x200(bh: &mut criterion::Criterion) {
     let m = crate::reproductible_dmatrix(200, 200);
     bh.bench_function("eigenvalues_200x200", move |bh| {
-        bh.iter(|| test::black_box(m.complex_eigenvalues()))
+        bh.iter(|| std::hint::black_box(m.complex_eigenvalues()))
     });
 }
 
diff --git a/benches/linalg/svd.rs b/benches/linalg/svd.rs
index aec18fd8..b84f60d6 100644
--- a/benches/linalg/svd.rs
+++ b/benches/linalg/svd.rs
@@ -3,112 +3,112 @@ use na::{Matrix4, SVD};
 fn svd_decompose_4x4(bh: &mut criterion::Criterion) {
     let m = Matrix4::<f64>::new_random();
     bh.bench_function("svd_decompose_4x4", move |bh| {
-        bh.iter(|| test::black_box(SVD::new(m.clone(), true, true)))
+        bh.iter(|| std::hint::black_box(SVD::new(m.clone(), true, true)))
     });
 }
 
 fn svd_decompose_10x10(bh: &mut criterion::Criterion) {
     let m = crate::reproductible_dmatrix(10, 10);
     bh.bench_function("svd_decompose_10x10", move |bh| {
-        bh.iter(|| test::black_box(SVD::new(m.clone(), true, true)))
+        bh.iter(|| std::hint::black_box(SVD::new(m.clone(), true, true)))
     });
 }
 
 fn svd_decompose_100x100(bh: &mut criterion::Criterion) {
     let m = crate::reproductible_dmatrix(100, 100);
     bh.bench_function("svd_decompose_100x100", move |bh| {
-        bh.iter(|| test::black_box(SVD::new(m.clone(), true, true)))
+        bh.iter(|| std::hint::black_box(SVD::new(m.clone(), true, true)))
     });
 }
 
 fn svd_decompose_200x200(bh: &mut criterion::Criterion) {
     let m = crate::reproductible_dmatrix(200, 200);
     bh.bench_function("svd_decompose_200x200", move |bh| {
-        bh.iter(|| test::black_box(SVD::new(m.clone(), true, true)))
+        bh.iter(|| std::hint::black_box(SVD::new(m.clone(), true, true)))
     });
 }
 
 fn rank_4x4(bh: &mut criterion::Criterion) {
     let m = Matrix4::<f64>::new_random();
     bh.bench_function("rank_4x4", move |bh| {
-        bh.iter(|| test::black_box(m.rank(1.0e-10)))
+        bh.iter(|| std::hint::black_box(m.rank(1.0e-10)))
     });
 }
 
 fn rank_10x10(bh: &mut criterion::Criterion) {
     let m = crate::reproductible_dmatrix(10, 10);
     bh.bench_function("rank_10x10", move |bh| {
-        bh.iter(|| test::black_box(m.rank(1.0e-10)))
+        bh.iter(|| std::hint::black_box(m.rank(1.0e-10)))
     });
 }
 
 fn rank_100x100(bh: &mut criterion::Criterion) {
     let m = crate::reproductible_dmatrix(100, 100);
     bh.bench_function("rank_100x100", move |bh| {
-        bh.iter(|| test::black_box(m.rank(1.0e-10)))
+        bh.iter(|| std::hint::black_box(m.rank(1.0e-10)))
     });
 }
 
 fn rank_200x200(bh: &mut criterion::Criterion) {
     let m = crate::reproductible_dmatrix(200, 200);
     bh.bench_function("rank_200x200", move |bh| {
-        bh.iter(|| test::black_box(m.rank(1.0e-10)))
+        bh.iter(|| std::hint::black_box(m.rank(1.0e-10)))
     });
 }
 
 fn singular_values_4x4(bh: &mut criterion::Criterion) {
     let m = Matrix4::<f64>::new_random();
     bh.bench_function("singular_values_4x4", move |bh| {
-        bh.iter(|| test::black_box(m.singular_values()))
+        bh.iter(|| std::hint::black_box(m.singular_values()))
     });
 }
 
 fn singular_values_10x10(bh: &mut criterion::Criterion) {
     let m = crate::reproductible_dmatrix(10, 10);
     bh.bench_function("singular_values_10x10", move |bh| {
-        bh.iter(|| test::black_box(m.singular_values()))
+        bh.iter(|| std::hint::black_box(m.singular_values()))
     });
 }
 
 fn singular_values_100x100(bh: &mut criterion::Criterion) {
     let m = crate::reproductible_dmatrix(100, 100);
     bh.bench_function("singular_values_100x100", move |bh| {
-        bh.iter(|| test::black_box(m.singular_values()))
+        bh.iter(|| std::hint::black_box(m.singular_values()))
     });
 }
 
 fn singular_values_200x200(bh: &mut criterion::Criterion) {
     let m = crate::reproductible_dmatrix(200, 200);
     bh.bench_function("singular_values_200x200", move |bh| {
-        bh.iter(|| test::black_box(m.singular_values()))
+        bh.iter(|| std::hint::black_box(m.singular_values()))
     });
 }
 
 fn pseudo_inverse_4x4(bh: &mut criterion::Criterion) {
     let m = Matrix4::<f64>::new_random();
     bh.bench_function("pseudo_inverse_4x4", move |bh| {
-        bh.iter(|| test::black_box(m.clone().pseudo_inverse(1.0e-10)))
+        bh.iter(|| std::hint::black_box(m.clone().pseudo_inverse(1.0e-10)))
     });
 }
 
 fn pseudo_inverse_10x10(bh: &mut criterion::Criterion) {
     let m = crate::reproductible_dmatrix(10, 10);
     bh.bench_function("pseudo_inverse_10x10", move |bh| {
-        bh.iter(|| test::black_box(m.clone().pseudo_inverse(1.0e-10)))
+        bh.iter(|| std::hint::black_box(m.clone().pseudo_inverse(1.0e-10)))
     });
 }
 
 fn pseudo_inverse_100x100(bh: &mut criterion::Criterion) {
     let m = crate::reproductible_dmatrix(100, 100);
     bh.bench_function("pseudo_inverse_100x100", move |bh| {
-        bh.iter(|| test::black_box(m.clone().pseudo_inverse(1.0e-10)))
+        bh.iter(|| std::hint::black_box(m.clone().pseudo_inverse(1.0e-10)))
     });
 }
 
 fn pseudo_inverse_200x200(bh: &mut criterion::Criterion) {
     let m = crate::reproductible_dmatrix(200, 200);
     bh.bench_function("pseudo_inverse_200x200", move |bh| {
-        bh.iter(|| test::black_box(m.clone().pseudo_inverse(1.0e-10)))
+        bh.iter(|| std::hint::black_box(m.clone().pseudo_inverse(1.0e-10)))
     });
 }
 
diff --git a/benches/linalg/symmetric_eigen.rs b/benches/linalg/symmetric_eigen.rs
index 3b52ba5c..07ecc2a2 100644
--- a/benches/linalg/symmetric_eigen.rs
+++ b/benches/linalg/symmetric_eigen.rs
@@ -3,28 +3,28 @@ use na::{Matrix4, SymmetricEigen};
 fn symmetric_eigen_decompose_4x4(bh: &mut criterion::Criterion) {
     let m = Matrix4::<f64>::new_random();
     bh.bench_function("symmetric_eigen_decompose_4x4", move |bh| {
-        bh.iter(|| test::black_box(SymmetricEigen::new(m.clone())))
+        bh.iter(|| std::hint::black_box(SymmetricEigen::new(m.clone())))
     });
 }
 
 fn symmetric_eigen_decompose_10x10(bh: &mut criterion::Criterion) {
     let m = crate::reproductible_dmatrix(10, 10);
     bh.bench_function("symmetric_eigen_decompose_10x10", move |bh| {
-        bh.iter(|| test::black_box(SymmetricEigen::new(m.clone())))
+        bh.iter(|| std::hint::black_box(SymmetricEigen::new(m.clone())))
     });
 }
 
 fn symmetric_eigen_decompose_100x100(bh: &mut criterion::Criterion) {
     let m = crate::reproductible_dmatrix(100, 100);
     bh.bench_function("symmetric_eigen_decompose_100x100", move |bh| {
-        bh.iter(|| test::black_box(SymmetricEigen::new(m.clone())))
+        bh.iter(|| std::hint::black_box(SymmetricEigen::new(m.clone())))
     });
 }
 
 fn symmetric_eigen_decompose_200x200(bh: &mut criterion::Criterion) {
     let m = crate::reproductible_dmatrix(200, 200);
     bh.bench_function("symmetric_eigen_decompose_200x200", move |bh| {
-        bh.iter(|| test::black_box(SymmetricEigen::new(m.clone())))
+        bh.iter(|| std::hint::black_box(SymmetricEigen::new(m.clone())))
     });
 }
 
diff --git a/examples/dimensional_genericity.rs b/examples/dimensional_genericity.rs
index 00c40f14..1fdd5a5f 100644
--- a/examples/dimensional_genericity.rs
+++ b/examples/dimensional_genericity.rs
@@ -2,26 +2,26 @@ extern crate nalgebra as na;
 
 use na::allocator::Allocator;
 use na::dimension::Dim;
-use na::{DefaultAllocator, RealField, Unit, Vector2, Vector3, VectorN};
+use na::{DefaultAllocator, OVector, RealField, Unit, Vector2, Vector3};
 
 /// Reflects a vector wrt. the hyperplane with normal `plane_normal`.
-fn reflect_wrt_hyperplane_with_dimensional_genericity<N: RealField, D: Dim>(
-    plane_normal: &Unit<VectorN<N, D>>,
-    vector: &VectorN<N, D>,
-) -> VectorN<N, D>
+fn reflect_wrt_hyperplane_with_dimensional_genericity<T: RealField, D: Dim>(
+    plane_normal: &Unit<OVector<T, D>>,
+    vector: &OVector<T, D>,
+) -> OVector<T, D>
 where
-    N: RealField,
+    T: RealField,
     D: Dim,
-    DefaultAllocator: Allocator<N, D>,
+    DefaultAllocator: Allocator<T, D>,
 {
     let n = plane_normal.as_ref(); // Get the underlying V.
     vector - n * (n.dot(vector) * na::convert(2.0))
 }
 
 /// Reflects a 2D vector wrt. the 2D line with normal `plane_normal`.
-fn reflect_wrt_hyperplane2<N>(plane_normal: &Unit<Vector2<N>>, vector: &Vector2<N>) -> Vector2<N>
+fn reflect_wrt_hyperplane2<T>(plane_normal: &Unit<Vector2<T>>, vector: &Vector2<T>) -> Vector2<T>
 where
-    N: RealField,
+    T: RealField,
 {
     let n = plane_normal.as_ref(); // Get the underlying Vector2
     vector - n * (n.dot(vector) * na::convert(2.0))
@@ -29,9 +29,9 @@ where
 
 /// Reflects a 3D vector wrt. the 3D plane with normal `plane_normal`.
 /// /!\ This is an exact replicate of `reflect_wrt_hyperplane2, but for 3D.
-fn reflect_wrt_hyperplane3<N>(plane_normal: &Unit<Vector3<N>>, vector: &Vector3<N>) -> Vector3<N>
+fn reflect_wrt_hyperplane3<T>(plane_normal: &Unit<Vector3<T>>, vector: &Vector3<T>) -> Vector3<T>
 where
-    N: RealField,
+    T: RealField,
 {
     let n = plane_normal.as_ref(); // Get the underlying Vector3
     vector - n * (n.dot(vector) * na::convert(2.0))
diff --git a/examples/matrixcompare.rs b/examples/matrixcompare.rs
index 713be25f..293739de 100644
--- a/examples/matrixcompare.rs
+++ b/examples/matrixcompare.rs
@@ -2,20 +2,20 @@ extern crate nalgebra as na;
 
 use matrixcompare::comparators::{AbsoluteElementwiseComparator, ExactElementwiseComparator};
 use matrixcompare::compare_matrices;
-use na::{MatrixMN, U3, U4};
+use na::{OMatrix, U3, U4};
 
 fn compare_integers_fail() {
     println!("Comparing two integer matrices.");
 
     #[rustfmt::skip]
-    let a = MatrixMN::<_, U3, U4>::from_row_slice(&[
+    let a = OMatrix::<_, U3, U4>::from_row_slice(&[
         0, 1,  2,  3,
         4, 5,  6,  7,
         8, 9, -2, 11
     ]);
 
     #[rustfmt::skip]
-    let b = MatrixMN::<_, U3, U4>::from_row_slice(&[
+    let b = OMatrix::<_, U3, U4>::from_row_slice(&[
         0, 1,  2,  3,
         4, 5,  6,  7,
         8, 9, 10, 11
@@ -29,14 +29,14 @@ fn compare_integers_fail() {
 fn compare_different_size() {
     println!("Comparing matrices of different size.");
     #[rustfmt::skip]
-    let a = MatrixMN::<_, U3, U3>::from_row_slice(&[
+    let a = OMatrix::<_, U3, U3>::from_row_slice(&[
         0, 1,  2,
         4, 5,  6,
         8, 9, 10,
     ]);
 
     #[rustfmt::skip]
-    let b = MatrixMN::<_, U3, U4>::from_row_slice(&[
+    let b = OMatrix::<_, U3, U4>::from_row_slice(&[
         0, 1,  2,  3,
         4, 5,  6,  7,
         8, 9, 10, 11
@@ -51,14 +51,14 @@ fn compare_f64_abs_tol_fail() {
     println!("Comparing two f64 matrices.");
 
     #[rustfmt::skip]
-    let a = MatrixMN::<f64, U3, U3>::from_row_slice(&[
+    let a = OMatrix::<f64, U3, U3>::from_row_slice(&[
         0.0, 1.0,  2.0 + 1e-10,
         4.0, 5.0,  6.0,
         8.0, 9.0, 10.0,
     ]);
 
     #[rustfmt::skip]
-    let b = MatrixMN::<_, U3, U3>::from_row_slice(&[
+    let b = OMatrix::<_, U3, U3>::from_row_slice(&[
         0.0, 1.0,  2.0,
         4.0, 5.0,  6.0,
         8.0, 9.0, 10.0
diff --git a/examples/reshaping.rs b/examples/reshaping.rs
index 60cb9bdd..b2178e79 100644
--- a/examples/reshaping.rs
+++ b/examples/reshaping.rs
@@ -2,7 +2,7 @@
 
 extern crate nalgebra as na;
 
-use na::{DMatrix, Dynamic, Matrix2x3, Matrix3x2, U2, U3};
+use na::{DMatrix, Dynamic, Matrix2x3, Matrix3x2, Const};
 
 fn main() {
     // Matrices can be reshaped in-place without moving or copying values.
@@ -16,7 +16,7 @@ fn main() {
         1.2, 2.3
     );
 
-    let m3 = m1.reshape_generic(U3, U2);
+    let m3 = m1.reshape_generic(Const::<3>, Const::<2>);
     assert_eq!(m3, m2);
 
     // Note that, for statically sized matrices, invalid reshapes will not compile:
diff --git a/examples/scalar_genericity.rs b/examples/scalar_genericity.rs
index 403f9ec2..58559ec6 100644
--- a/examples/scalar_genericity.rs
+++ b/examples/scalar_genericity.rs
@@ -3,15 +3,15 @@ extern crate nalgebra as na;
 use na::{Scalar, Vector3};
 use simba::scalar::RealField;
 
-fn print_vector<N: Scalar>(m: &Vector3<N>) {
+fn print_vector<T: Scalar>(m: &Vector3<T>) {
     println!("{:?}", m)
 }
 
-fn print_norm<N: RealField>(v: &Vector3<N>) {
+fn print_norm<T: RealField>(v: &Vector3<T>) {
     // NOTE: alternatively, nalgebra already defines `v.norm()`.
     let norm = v.dot(v).sqrt();
 
-    // The RealField bound implies that N is Display so we can
+    // The RealField bound implies that T is Display so we can
     // use "{}" instead of "{:?}" for the format string.
     println!("{}", norm)
 }
diff --git a/nalgebra-glm/src/aliases.rs b/nalgebra-glm/src/aliases.rs
index 206a8abe..0bf7b639 100644
--- a/nalgebra-glm/src/aliases.rs
+++ b/nalgebra-glm/src/aliases.rs
@@ -1,9 +1,9 @@
 use na::{
     Matrix2, Matrix2x3, Matrix2x4, Matrix3, Matrix3x2, Matrix3x4, Matrix4, Matrix4x2, Matrix4x3,
-    MatrixMN, Quaternion, VectorN, U1, U2, U3, U4,
+    Quaternion, SMatrix, SVector,
 };
 
-/// A matrix with components of type `N`. It has `R` rows, and `C` columns.
+/// A matrix with components of type `T`. It has `R` rows, and `C` columns.
 ///
 /// In this library, vectors, represented as [`TVec`](type.TVec.html) and
 /// friends, are also matrices. Operations that operate on a matrix will
@@ -24,8 +24,8 @@ use na::{
 /// * [`TMat4x3`](type.TMat4x3.html)
 /// * [`TMat4x4`](type.TMat4x4.html)
 /// * [`TVec`](type.TVec.html)
-pub type TMat<N, R, C> = MatrixMN<N, R, C>;
-/// A column vector with components of type `N`. It has `D` rows (and one column).
+pub type TMat<T, const R: usize, const C: usize> = SMatrix<T, R, C>;
+/// A column vector with components of type `T`. It has `D` rows (and one column).
 ///
 /// In this library, vectors are represented as a single column matrix, so
 /// operations on [`TMat`](type.TMat.html) are also valid on vectors.
@@ -37,11 +37,11 @@ pub type TMat<N, R, C> = MatrixMN<N, R, C>;
 /// * [`TVec2`](type.TVec2.html)
 /// * [`TVec3`](type.TVec3.html)
 /// * [`TVec4`](type.TVec4.html)
-pub type TVec<N, R> = VectorN<N, R>;
-/// A quaternion with components of type `N`.
-pub type Qua<N> = Quaternion<N>;
+pub type TVec<T, const R: usize> = SVector<T, R>;
+/// A quaternion with components of type `T`.
+pub type Qua<T> = Quaternion<T>;
 
-/// A 1D vector with components of type `N`.
+/// A 1D vector with components of type `T`.
 ///
 /// # See also:
 ///
@@ -69,8 +69,8 @@ pub type Qua<N> = Quaternion<N>;
 /// * [`U64Vec1`](type.U64Vec1.html)
 /// * [`U8Vec1`](type.U8Vec1.html)
 /// * [`Vec1`](type.Vec1.html)
-pub type TVec1<N> = TVec<N, U1>;
-/// A 2D vector with components of type `N`.
+pub type TVec1<T> = TVec<T, 1>;
+/// A 2D vector with components of type `T`.
 ///
 /// # See also:
 ///
@@ -99,8 +99,8 @@ pub type TVec1<N> = TVec<N, U1>;
 /// * [`U64Vec2`](type.U64Vec2.html)
 /// * [`U8Vec2`](type.U8Vec2.html)
 /// * [`Vec2`](type.Vec2.html)
-pub type TVec2<N> = TVec<N, U2>;
-/// A 3D vector with components of type `N`.
+pub type TVec2<T> = TVec<T, 2>;
+/// A 3D vector with components of type `T`.
 ///
 /// # See also:
 ///
@@ -129,8 +129,8 @@ pub type TVec2<N> = TVec<N, U2>;
 /// * [`U64Vec3`](type.U64Vec3.html)
 /// * [`U8Vec3`](type.U8Vec3.html)
 /// * [`Vec3`](type.Vec3.html)
-pub type TVec3<N> = TVec<N, U3>;
-/// A 4D vector with components of type `N`.
+pub type TVec3<T> = TVec<T, 3>;
+/// A 4D vector with components of type `T`.
 ///
 /// # See also:
 ///
@@ -158,7 +158,7 @@ pub type TVec3<N> = TVec<N, U3>;
 /// * [`U64Vec4`](type.U64Vec4.html)
 /// * [`U8Vec4`](type.U8Vec4.html)
 /// * [`Vec4`](type.Vec4.html)
-pub type TVec4<N> = TVec<N, U4>;
+pub type TVec4<T> = TVec<T, 4>;
 /// A 1D vector with boolean components.
 pub type BVec1 = TVec1<bool>;
 /// A 2D vector with boolean components.
@@ -268,31 +268,31 @@ pub type I8Vec3 = TVec3<i8>;
 /// A 4D vector with `i8` components.
 pub type I8Vec4 = TVec4<i8>;
 
-/// A 2x2 matrix with components of type `N`.
-pub type TMat2<N> = Matrix2<N>;
-/// A 2x2 matrix with components of type `N`.
-pub type TMat2x2<N> = Matrix2<N>;
-/// A 2x3 matrix with components of type `N`.
-pub type TMat2x3<N> = Matrix2x3<N>;
-/// A 2x4 matrix with components of type `N`.
-pub type TMat2x4<N> = Matrix2x4<N>;
-/// A 3x3 matrix with components of type `N`.
-pub type TMat3<N> = Matrix3<N>;
-/// A 3x2 matrix with components of type `N`.
-pub type TMat3x2<N> = Matrix3x2<N>;
-/// A 3x3 matrix with components of type `N`.
-pub type TMat3x3<N> = Matrix3<N>;
-/// A 3x4 matrix with components of type `N`.
-pub type TMat3x4<N> = Matrix3x4<N>;
-/// A 4x4 matrix with components of type `N`.
-pub type TMat4<N> = Matrix4<N>;
-/// A 4x2 matrix with components of type `N`.
-pub type TMat4x2<N> = Matrix4x2<N>;
-/// A 4x3 matrix with components of type `N`.
-pub type TMat4x3<N> = Matrix4x3<N>;
-/// A 4x4 matrix with components of type `N`.
-pub type TMat4x4<N> = Matrix4<N>;
-/// A 2x2 matrix with components of type `N`.
+/// A 2x2 matrix with components of type `T`.
+pub type TMat2<T> = Matrix2<T>;
+/// A 2x2 matrix with components of type `T`.
+pub type TMat2x2<T> = Matrix2<T>;
+/// A 2x3 matrix with components of type `T`.
+pub type TMat2x3<T> = Matrix2x3<T>;
+/// A 2x4 matrix with components of type `T`.
+pub type TMat2x4<T> = Matrix2x4<T>;
+/// A 3x3 matrix with components of type `T`.
+pub type TMat3<T> = Matrix3<T>;
+/// A 3x2 matrix with components of type `T`.
+pub type TMat3x2<T> = Matrix3x2<T>;
+/// A 3x3 matrix with components of type `T`.
+pub type TMat3x3<T> = Matrix3<T>;
+/// A 3x4 matrix with components of type `T`.
+pub type TMat3x4<T> = Matrix3x4<T>;
+/// A 4x4 matrix with components of type `T`.
+pub type TMat4<T> = Matrix4<T>;
+/// A 4x2 matrix with components of type `T`.
+pub type TMat4x2<T> = Matrix4x2<T>;
+/// A 4x3 matrix with components of type `T`.
+pub type TMat4x3<T> = Matrix4x3<T>;
+/// A 4x4 matrix with components of type `T`.
+pub type TMat4x4<T> = Matrix4<T>;
+/// A 2x2 matrix with components of type `T`.
 pub type DMat2 = Matrix2<f64>;
 /// A 2x2 matrix with `f64` components.
 pub type DMat2x2 = Matrix2<f64>;
diff --git a/nalgebra-glm/src/common.rs b/nalgebra-glm/src/common.rs
index 2df38714..1efa80a3 100644
--- a/nalgebra-glm/src/common.rs
+++ b/nalgebra-glm/src/common.rs
@@ -1,9 +1,9 @@
 use core::mem;
-use na::{self, DefaultAllocator, RealField};
+use na::{self, RealField};
 use num::FromPrimitive;
 
 use crate::aliases::{TMat, TVec};
-use crate::traits::{Alloc, Dimension, Number};
+use crate::traits::Number;
 
 /// For each matrix or vector component `x` if `x >= 0`; otherwise, it returns `-x`.
 ///
@@ -21,10 +21,7 @@ use crate::traits::{Alloc, Dimension, Number};
 /// # See also:
 ///
 /// * [`sign`](fn.sign.html)
-pub fn abs<N: Number, R: Dimension, C: Dimension>(x: &TMat<N, R, C>) -> TMat<N, R, C>
-where
-    DefaultAllocator: Alloc<N, R, C>,
-{
+pub fn abs<T: Number, const R: usize, const C: usize>(x: &TMat<T, R, C>) -> TMat<T, R, C> {
     x.abs()
 }
 
@@ -45,10 +42,7 @@ where
 /// * [`fract`](fn.fract.html)
 /// * [`round`](fn.round.html)
 /// * [`trunc`](fn.trunc.html)
-pub fn ceil<N: RealField, D: Dimension>(x: &TVec<N, D>) -> TVec<N, D>
-where
-    DefaultAllocator: Alloc<N, D>,
-{
+pub fn ceil<T: RealField, const D: usize>(x: &TVec<T, D>) -> TVec<T, D> {
     x.map(|x| x.ceil())
 }
 
@@ -73,7 +67,7 @@ where
 ///
 /// * [`clamp`](fn.clamp.html)
 /// * [`clamp_vec`](fn.clamp_vec.html)
-pub fn clamp_scalar<N: Number>(x: N, min_val: N, max_val: N) -> N {
+pub fn clamp_scalar<T: Number>(x: T, min_val: T, max_val: T) -> T {
     na::clamp(x, min_val, max_val)
 }
 
@@ -97,10 +91,7 @@ pub fn clamp_scalar<N: Number>(x: N, min_val: N, max_val: N) -> N {
 ///
 /// * [`clamp_scalar`](fn.clamp_scalar.html)
 /// * [`clamp_vec`](fn.clamp_vec.html)
-pub fn clamp<N: Number, D: Dimension>(x: &TVec<N, D>, min_val: N, max_val: N) -> TVec<N, D>
-where
-    DefaultAllocator: Alloc<N, D>,
-{
+pub fn clamp<T: Number, const D: usize>(x: &TVec<T, D>, min_val: T, max_val: T) -> TVec<T, D> {
     x.map(|x| na::clamp(x, min_val, max_val))
 }
 
@@ -131,14 +122,11 @@ where
 ///
 /// * [`clamp_scalar`](fn.clamp_scalar.html)
 /// * [`clamp`](fn.clamp.html)
-pub fn clamp_vec<N: Number, D: Dimension>(
-    x: &TVec<N, D>,
-    min_val: &TVec<N, D>,
-    max_val: &TVec<N, D>,
-) -> TVec<N, D>
-where
-    DefaultAllocator: Alloc<N, D>,
-{
+pub fn clamp_vec<T: Number, const D: usize>(
+    x: &TVec<T, D>,
+    min_val: &TVec<T, D>,
+    max_val: &TVec<T, D>,
+) -> TVec<T, D> {
     x.zip_zip_map(min_val, max_val, |a, min, max| na::clamp(a, min, max))
 }
 
@@ -172,10 +160,7 @@ pub fn float_bits_to_int(v: f32) -> i32 {
 /// * [`int_bits_to_float_vec`](fn.int_bits_to_float_vec.html)
 /// * [`uint_bits_to_float`](fn.uint_bits_to_float.html)
 /// * [`uint_bits_to_float_scalar`](fn.uint_bits_to_float_scalar.html)
-pub fn float_bits_to_int_vec<D: Dimension>(v: &TVec<f32, D>) -> TVec<i32, D>
-where
-    DefaultAllocator: Alloc<f32, D>,
-{
+pub fn float_bits_to_int_vec<const D: usize>(v: &TVec<f32, D>) -> TVec<i32, D> {
     v.map(float_bits_to_int)
 }
 
@@ -209,10 +194,7 @@ pub fn float_bits_to_uint(v: f32) -> u32 {
 /// * [`int_bits_to_float_vec`](fn.int_bits_to_float_vec.html)
 /// * [`uint_bits_to_float`](fn.uint_bits_to_float.html)
 /// * [`uint_bits_to_float_scalar`](fn.uint_bits_to_float_scalar.html)
-pub fn float_bits_to_uint_vec<D: Dimension>(v: &TVec<f32, D>) -> TVec<u32, D>
-where
-    DefaultAllocator: Alloc<f32, D>,
-{
+pub fn float_bits_to_uint_vec<const D: usize>(v: &TVec<f32, D>) -> TVec<u32, D> {
     v.map(float_bits_to_uint)
 }
 
@@ -232,15 +214,12 @@ where
 /// * [`fract`](fn.fract.html)
 /// * [`round`](fn.round.html)
 /// * [`trunc`](fn.trunc.html)
-pub fn floor<N: RealField, D: Dimension>(x: &TVec<N, D>) -> TVec<N, D>
-where
-    DefaultAllocator: Alloc<N, D>,
-{
+pub fn floor<T: RealField, const D: usize>(x: &TVec<T, D>) -> TVec<T, D> {
     x.map(|x| x.floor())
 }
 
 //// TODO: should be implemented for TVec/TMat?
-//pub fn fma<N: Number>(a: N, b: N, c: N) -> N {
+//pub fn fma<T: Number>(a: T, b: T, c: T) -> T {
 //    // TODO: use an actual FMA
 //    a * b + c
 //}
@@ -261,16 +240,13 @@ where
 /// * [`floor`](fn.floor.html)
 /// * [`round`](fn.round.html)
 /// * [`trunc`](fn.trunc.html)
-pub fn fract<N: RealField, D: Dimension>(x: &TVec<N, D>) -> TVec<N, D>
-where
-    DefaultAllocator: Alloc<N, D>,
-{
+pub fn fract<T: RealField, const D: usize>(x: &TVec<T, D>) -> TVec<T, D> {
     x.map(|x| x.fract())
 }
 
 //// TODO: should be implemented for TVec/TMat?
 ///// Returns the (significant, exponent) of this float number.
-//pub fn frexp<N: RealField>(x: N, exp: N) -> (N, N) {
+//pub fn frexp<T: RealField>(x: T, exp: T) -> (T, T) {
 //    // TODO: is there a better approach?
 //    let e = x.log2().ceil();
 //    (x * (-e).exp2(), e)
@@ -306,27 +282,22 @@ pub fn int_bits_to_float(v: i32) -> f32 {
 /// * [`int_bits_to_float`](fn.int_bits_to_float.html)
 /// * [`uint_bits_to_float`](fn.uint_bits_to_float.html)
 /// * [`uint_bits_to_float_scalar`](fn.uint_bits_to_float_scalar.html)
-pub fn int_bits_to_float_vec<D: Dimension>(v: &TVec<i32, D>) -> TVec<f32, D>
-where
-    DefaultAllocator: Alloc<f32, D>,
-{
+pub fn int_bits_to_float_vec<const D: usize>(v: &TVec<i32, D>) -> TVec<f32, D> {
     v.map(int_bits_to_float)
 }
 
-//pub fn isinf<N: Scalar, D: Dimension>(x: &TVec<N, D>) -> TVec<bool, D>
-//    where DefaultAllocator: Alloc<N, D> {
+//pub fn isinf<T: Scalar, const D: usize>(x: &TVec<T, D>) -> TVec<bool, D> {
 //        unimplemented!()
 //
 //}
 //
-//pub fn isnan<N: Scalar, D: Dimension>(x: &TVec<N, D>) -> TVec<bool, D>
-//    where DefaultAllocator: Alloc<N, D> {
+//pub fn isnan<T: Scalar, const D: usize>(x: &TVec<T, D>) -> TVec<bool, D> {
 //        unimplemented!()
 //
 //}
 
 ///// Returns the (significant, exponent) of this float number.
-//pub fn ldexp<N: RealField>(x: N, exp: N) -> N {
+//pub fn ldexp<T: RealField>(x: T, exp: T) -> T {
 //    // TODO: is there a better approach?
 //    x * (exp).exp2()
 //}
@@ -346,8 +317,8 @@ where
 ///
 /// * [`mix`](fn.mix.html)
 /// * [`mix_vec`](fn.mix_vec.html)
-pub fn mix_scalar<N: Number>(x: N, y: N, a: N) -> N {
-    x * (N::one() - a) + y * a
+pub fn mix_scalar<T: Number>(x: T, y: T, a: T) -> T {
+    x * (T::one() - a) + y * a
 }
 
 /// Returns `x * (1.0 - a) + y * a`, i.e., the linear blend of the vectors x and y using the scalar value a.
@@ -367,11 +338,8 @@ pub fn mix_scalar<N: Number>(x: N, y: N, a: N) -> N {
 ///
 /// * [`mix_scalar`](fn.mix_scalar.html)
 /// * [`mix_vec`](fn.mix_vec.html)
-pub fn mix<N: Number, D: Dimension>(x: &TVec<N, D>, y: &TVec<N, D>, a: N) -> TVec<N, D>
-where
-    DefaultAllocator: Alloc<N, D>,
-{
-    x * (N::one() - a) + y * a
+pub fn mix<T: Number, const D: usize>(x: &TVec<T, D>, y: &TVec<T, D>, a: T) -> TVec<T, D> {
+    x * (T::one() - a) + y * a
 }
 
 /// Returns `x * (1.0 - a) + y * a`, i.e., the component-wise linear blend of `x` and `y` using the components of
@@ -393,15 +361,12 @@ where
 ///
 /// * [`mix_scalar`](fn.mix_scalar.html)
 /// * [`mix`](fn.mix.html)
-pub fn mix_vec<N: Number, D: Dimension>(
-    x: &TVec<N, D>,
-    y: &TVec<N, D>,
-    a: &TVec<N, D>,
-) -> TVec<N, D>
-where
-    DefaultAllocator: Alloc<N, D>,
-{
-    x.component_mul(&(TVec::<N, D>::repeat(N::one()) - a)) + y.component_mul(&a)
+pub fn mix_vec<T: Number, const D: usize>(
+    x: &TVec<T, D>,
+    y: &TVec<T, D>,
+    a: &TVec<T, D>,
+) -> TVec<T, D> {
+    x.component_mul(&(TVec::<T, D>::repeat(T::one()) - a)) + y.component_mul(&a)
 }
 
 /// Returns `x * (1.0 - a) + y * a`, i.e., the linear blend of the scalars x and y using the scalar value a.
@@ -420,7 +385,7 @@ where
 ///
 /// * [`lerp`](fn.lerp.html)
 /// * [`lerp_vec`](fn.lerp_vec.html)
-pub fn lerp_scalar<N: Number>(x: N, y: N, a: N) -> N {
+pub fn lerp_scalar<T: Number>(x: T, y: T, a: T) -> T {
     mix_scalar(x, y, a)
 }
 
@@ -442,10 +407,7 @@ pub fn lerp_scalar<N: Number>(x: N, y: N, a: N) -> N {
 ///
 /// * [`lerp_scalar`](fn.lerp_scalar.html)
 /// * [`lerp_vec`](fn.lerp_vec.html)
-pub fn lerp<N: Number, D: Dimension>(x: &TVec<N, D>, y: &TVec<N, D>, a: N) -> TVec<N, D>
-where
-    DefaultAllocator: Alloc<N, D>,
-{
+pub fn lerp<T: Number, const D: usize>(x: &TVec<T, D>, y: &TVec<T, D>, a: T) -> TVec<T, D> {
     mix(x, y, a)
 }
 
@@ -469,14 +431,11 @@ where
 ///
 /// * [`lerp_scalar`](fn.lerp_scalar.html)
 /// * [`lerp`](fn.lerp.html)
-pub fn lerp_vec<N: Number, D: Dimension>(
-    x: &TVec<N, D>,
-    y: &TVec<N, D>,
-    a: &TVec<N, D>,
-) -> TVec<N, D>
-where
-    DefaultAllocator: Alloc<N, D>,
-{
+pub fn lerp_vec<T: Number, const D: usize>(
+    x: &TVec<T, D>,
+    y: &TVec<T, D>,
+    a: &TVec<T, D>,
+) -> TVec<T, D> {
     mix_vec(x, y, a)
 }
 
@@ -487,10 +446,7 @@ where
 /// # See also:
 ///
 /// * [`modf`](fn.modf.html)
-pub fn modf_vec<N: Number, D: Dimension>(x: &TVec<N, D>, y: &TVec<N, D>) -> TVec<N, D>
-where
-    DefaultAllocator: Alloc<N, D>,
-{
+pub fn modf_vec<T: Number, const D: usize>(x: &TVec<T, D>, y: &TVec<T, D>) -> TVec<T, D> {
     x.zip_map(y, |x, y| x % y)
 }
 
@@ -499,7 +455,7 @@ where
 /// # See also:
 ///
 /// * [`modf_vec`](fn.modf_vec.html)
-pub fn modf<N: Number>(x: N, i: N) -> N {
+pub fn modf<T: Number>(x: T, i: T) -> T {
     x % i
 }
 
@@ -521,15 +477,11 @@ pub fn modf<N: Number>(x: N, i: N) -> N {
 /// * [`floor`](fn.floor.html)
 /// * [`fract`](fn.fract.html)
 /// * [`trunc`](fn.trunc.html)
-pub fn round<N: RealField, D: Dimension>(x: &TVec<N, D>) -> TVec<N, D>
-where
-    DefaultAllocator: Alloc<N, D>,
-{
+pub fn round<T: RealField, const D: usize>(x: &TVec<T, D>) -> TVec<T, D> {
     x.map(|x| x.round())
 }
 
-//pub fn roundEven<N: Scalar, D: Dimension>(x: &TVec<N, D>) -> TVec<N, D>
-//    where DefaultAllocator: Alloc<N, D> {
+//pub fn roundEven<T: Scalar, const D: usize>(x: &TVec<T, D>) -> TVec<T, D> {
 //        unimplemented!()
 //}
 
@@ -547,46 +499,37 @@ where
 ///
 /// * [`abs`](fn.abs.html)
 ///
-pub fn sign<N: Number, D: Dimension>(x: &TVec<N, D>) -> TVec<N, D>
-where
-    DefaultAllocator: Alloc<N, D>,
-{
-    x.map(|x| if x.is_zero() { N::zero() } else { x.signum() })
+pub fn sign<T: Number, const D: usize>(x: &TVec<T, D>) -> TVec<T, D> {
+    x.map(|x| if x.is_zero() { T::zero() } else { x.signum() })
 }
 
 /// Returns 0.0 if `x <= edge0` and `1.0 if x >= edge1` and performs smooth Hermite interpolation between 0 and 1 when `edge0 < x < edge1`.
 ///
 /// This is useful in cases where you would want a threshold function with a smooth transition.
 /// This is equivalent to: `let result = clamp((x - edge0) / (edge1 - edge0), 0, 1); return t * t * (3 - 2 * t);` Results are undefined if `edge0 >= edge1`.
-pub fn smoothstep<N: Number>(edge0: N, edge1: N, x: N) -> N {
-    let _3: N = FromPrimitive::from_f64(3.0).unwrap();
-    let _2: N = FromPrimitive::from_f64(2.0).unwrap();
-    let t = na::clamp((x - edge0) / (edge1 - edge0), N::zero(), N::one());
+pub fn smoothstep<T: Number>(edge0: T, edge1: T, x: T) -> T {
+    let _3: T = FromPrimitive::from_f64(3.0).unwrap();
+    let _2: T = FromPrimitive::from_f64(2.0).unwrap();
+    let t = na::clamp((x - edge0) / (edge1 - edge0), T::zero(), T::one());
     t * t * (_3 - t * _2)
 }
 
 /// Returns 0.0 if `x < edge`, otherwise it returns 1.0.
-pub fn step_scalar<N: Number>(edge: N, x: N) -> N {
+pub fn step_scalar<T: Number>(edge: T, x: T) -> T {
     if edge > x {
-        N::zero()
+        T::zero()
     } else {
-        N::one()
+        T::one()
     }
 }
 
 /// Returns 0.0 if `x[i] < edge`, otherwise it returns 1.0.
-pub fn step<N: Number, D: Dimension>(edge: N, x: &TVec<N, D>) -> TVec<N, D>
-where
-    DefaultAllocator: Alloc<N, D>,
-{
+pub fn step<T: Number, const D: usize>(edge: T, x: &TVec<T, D>) -> TVec<T, D> {
     x.map(|x| step_scalar(edge, x))
 }
 
 /// Returns 0.0 if `x[i] < edge[i]`, otherwise it returns 1.0.
-pub fn step_vec<N: Number, D: Dimension>(edge: &TVec<N, D>, x: &TVec<N, D>) -> TVec<N, D>
-where
-    DefaultAllocator: Alloc<N, D>,
-{
+pub fn step_vec<T: Number, const D: usize>(edge: &TVec<T, D>, x: &TVec<T, D>) -> TVec<T, D> {
     edge.zip_map(x, step_scalar)
 }
 
@@ -606,10 +549,7 @@ where
 /// * [`floor`](fn.floor.html)
 /// * [`fract`](fn.fract.html)
 /// * [`round`](fn.round.html)
-pub fn trunc<N: RealField, D: Dimension>(x: &TVec<N, D>) -> TVec<N, D>
-where
-    DefaultAllocator: Alloc<N, D>,
-{
+pub fn trunc<T: RealField, const D: usize>(x: &TVec<T, D>) -> TVec<T, D> {
     x.map(|x| x.trunc())
 }
 
@@ -643,9 +583,6 @@ pub fn uint_bits_to_float_scalar(v: u32) -> f32 {
 /// * [`int_bits_to_float`](fn.int_bits_to_float.html)
 /// * [`int_bits_to_float_vec`](fn.int_bits_to_float_vec.html)
 /// * [`uint_bits_to_float_scalar`](fn.uint_bits_to_float_scalar.html)
-pub fn uint_bits_to_float<D: Dimension>(v: &TVec<u32, D>) -> TVec<f32, D>
-where
-    DefaultAllocator: Alloc<f32, D>,
-{
+pub fn uint_bits_to_float<const D: usize>(v: &TVec<u32, D>) -> TVec<f32, D> {
     v.map(uint_bits_to_float_scalar)
 }
diff --git a/nalgebra-glm/src/constructors.rs b/nalgebra-glm/src/constructors.rs
index 175626a1..c6641c6e 100644
--- a/nalgebra-glm/src/constructors.rs
+++ b/nalgebra-glm/src/constructors.rs
@@ -2,7 +2,7 @@ use crate::aliases::{
     Qua, TMat, TMat2, TMat2x3, TMat2x4, TMat3, TMat3x2, TMat3x4, TMat4, TMat4x2, TMat4x3, TVec1,
     TVec2, TVec3, TVec4,
 };
-use na::{RealField, Scalar, U2, U3, U4};
+use na::{RealField, Scalar};
 
 /// Creates a new 1D vector.
 ///
@@ -14,30 +14,30 @@ use na::{RealField, Scalar, U2, U3, U4};
 /// # use nalgebra_glm as glm;
 /// let v = glm::vec1(true);
 /// ```
-pub fn vec1<N: Scalar>(x: N) -> TVec1<N> {
+pub fn vec1<T: Scalar>(x: T) -> TVec1<T> {
     TVec1::new(x)
 }
 
 /// Creates a new 2D vector.
-pub fn vec2<N: Scalar>(x: N, y: N) -> TVec2<N> {
+pub fn vec2<T: Scalar>(x: T, y: T) -> TVec2<T> {
     TVec2::new(x, y)
 }
 
 /// Creates a new 3D vector.
-pub fn vec3<N: Scalar>(x: N, y: N, z: N) -> TVec3<N> {
+pub fn vec3<T: Scalar>(x: T, y: T, z: T) -> TVec3<T> {
     TVec3::new(x, y, z)
 }
 
 /// Creates a new 4D vector.
-pub fn vec4<N: Scalar>(x: N, y: N, z: N, w: N) -> TVec4<N> {
+pub fn vec4<T: Scalar>(x: T, y: T, z: T, w: T) -> TVec4<T> {
     TVec4::new(x, y, z, w)
 }
 
 /// Create a new 2x2 matrix.
 #[rustfmt::skip]
-pub fn mat2<N: Scalar>(m11: N, m12: N,
-                       m21: N, m22: N) -> TMat2<N> {
-    TMat::<N, U2, U2>::new(
+pub fn mat2<T: Scalar>(m11: T, m12: T,
+                       m21: T, m22: T) -> TMat2<T> {
+    TMat::<T, 2, 2>::new(
         m11, m12,
         m21, m22,
     )
@@ -45,9 +45,9 @@ pub fn mat2<N: Scalar>(m11: N, m12: N,
 
 /// Create a new 2x2 matrix.
 #[rustfmt::skip]
-pub fn mat2x2<N: Scalar>(m11: N, m12: N,
-                         m21: N, m22: N) -> TMat2<N> {
-    TMat::<N, U2, U2>::new(
+pub fn mat2x2<T: Scalar>(m11: T, m12: T,
+                         m21: T, m22: T) -> TMat2<T> {
+    TMat::<T, 2, 2>::new(
         m11, m12,
         m21, m22,
     )
@@ -55,9 +55,9 @@ pub fn mat2x2<N: Scalar>(m11: N, m12: N,
 
 /// Create a new 2x3 matrix.
 #[rustfmt::skip]
-pub fn mat2x3<N: Scalar>(m11: N, m12: N, m13: N,
-                         m21: N, m22: N, m23: N) -> TMat2x3<N> {
-    TMat::<N, U2, U3>::new(
+pub fn mat2x3<T: Scalar>(m11: T, m12: T, m13: T,
+                         m21: T, m22: T, m23: T) -> TMat2x3<T> {
+    TMat::<T, 2, 3>::new(
         m11, m12, m13,
         m21, m22, m23,
     )
@@ -65,9 +65,9 @@ pub fn mat2x3<N: Scalar>(m11: N, m12: N, m13: N,
 
 /// Create a new 2x4 matrix.
 #[rustfmt::skip]
-pub fn mat2x4<N: Scalar>(m11: N, m12: N, m13: N, m14: N,
-                         m21: N, m22: N, m23: N, m24: N) -> TMat2x4<N> {
-    TMat::<N, U2, U4>::new(
+pub fn mat2x4<T: Scalar>(m11: T, m12: T, m13: T, m14: T,
+                         m21: T, m22: T, m23: T, m24: T) -> TMat2x4<T> {
+    TMat::<T, 2, 4>::new(
         m11, m12, m13, m14,
         m21, m22, m23, m24,
     )
@@ -75,10 +75,10 @@ pub fn mat2x4<N: Scalar>(m11: N, m12: N, m13: N, m14: N,
 
 /// Create a new 3x3 matrix.
 #[rustfmt::skip]
-pub fn mat3<N: Scalar>(m11: N, m12: N, m13: N,
-                       m21: N, m22: N, m23: N,
-                       m31: N, m32: N, m33: N) -> TMat3<N> {
-    TMat::<N, U3, U3>::new(
+pub fn mat3<T: Scalar>(m11: T, m12: T, m13: T,
+                       m21: T, m22: T, m23: T,
+                       m31: T, m32: T, m33: T) -> TMat3<T> {
+    TMat::<T, 3, 3>::new(
         m11, m12, m13,
         m21, m22, m23,
         m31, m32, m33,
@@ -87,10 +87,10 @@ pub fn mat3<N: Scalar>(m11: N, m12: N, m13: N,
 
 /// Create a new 3x2 matrix.
 #[rustfmt::skip]
-pub fn mat3x2<N: Scalar>(m11: N, m12: N,
-                         m21: N, m22: N,
-                         m31: N, m32: N) -> TMat3x2<N> {
-    TMat::<N, U3, U2>::new(
+pub fn mat3x2<T: Scalar>(m11: T, m12: T,
+                         m21: T, m22: T,
+                         m31: T, m32: T) -> TMat3x2<T> {
+    TMat::<T, 3, 2>::new(
         m11, m12,
         m21, m22,
         m31, m32,
@@ -99,10 +99,10 @@ pub fn mat3x2<N: Scalar>(m11: N, m12: N,
 
 /// Create a new 3x3 matrix.
 #[rustfmt::skip]
-pub fn mat3x3<N: Scalar>(m11: N, m12: N, m13: N,
-                         m21: N, m22: N, m23: N,
-                         m31: N, m32: N, m33: N) -> TMat3<N> {
-    TMat::<N, U3, U3>::new(
+pub fn mat3x3<T: Scalar>(m11: T, m12: T, m13: T,
+                         m21: T, m22: T, m23: T,
+                         m31: T, m32: T, m33: T) -> TMat3<T> {
+    TMat::<T, 3, 3>::new(
         m11, m12, m13,
         m31, m32, m33,
         m21, m22, m23,
@@ -111,10 +111,10 @@ pub fn mat3x3<N: Scalar>(m11: N, m12: N, m13: N,
 
 /// Create a new 3x4 matrix.
 #[rustfmt::skip]
-pub fn mat3x4<N: Scalar>(m11: N, m12: N, m13: N, m14: N,
-                         m21: N, m22: N, m23: N, m24: N,
-                         m31: N, m32: N, m33: N, m34: N) -> TMat3x4<N> {
-    TMat::<N, U3, U4>::new(
+pub fn mat3x4<T: Scalar>(m11: T, m12: T, m13: T, m14: T,
+                         m21: T, m22: T, m23: T, m24: T,
+                         m31: T, m32: T, m33: T, m34: T) -> TMat3x4<T> {
+    TMat::<T, 3, 4>::new(
         m11, m12, m13, m14,
         m21, m22, m23, m24,
         m31, m32, m33, m34,
@@ -123,11 +123,11 @@ pub fn mat3x4<N: Scalar>(m11: N, m12: N, m13: N, m14: N,
 
 /// Create a new 4x2 matrix.
 #[rustfmt::skip]
-pub fn mat4x2<N: Scalar>(m11: N, m12: N,
-                         m21: N, m22: N,
-                         m31: N, m32: N,
-                         m41: N, m42: N) -> TMat4x2<N> {
-    TMat::<N, U4, U2>::new(
+pub fn mat4x2<T: Scalar>(m11: T, m12: T,
+                         m21: T, m22: T,
+                         m31: T, m32: T,
+                         m41: T, m42: T) -> TMat4x2<T> {
+    TMat::<T, 4, 2>::new(
         m11, m12,
         m21, m22,
         m31, m32,
@@ -137,11 +137,11 @@ pub fn mat4x2<N: Scalar>(m11: N, m12: N,
 
 /// Create a new 4x3 matrix.
 #[rustfmt::skip]
-pub fn mat4x3<N: Scalar>(m11: N, m12: N, m13: N,
-                         m21: N, m22: N, m23: N,
-                         m31: N, m32: N, m33: N,
-                         m41: N, m42: N, m43: N) -> TMat4x3<N> {
-    TMat::<N, U4, U3>::new(
+pub fn mat4x3<T: Scalar>(m11: T, m12: T, m13: T,
+                         m21: T, m22: T, m23: T,
+                         m31: T, m32: T, m33: T,
+                         m41: T, m42: T, m43: T) -> TMat4x3<T> {
+    TMat::<T, 4, 3>::new(
         m11, m12, m13,
         m21, m22, m23,
         m31, m32, m33,
@@ -151,11 +151,11 @@ pub fn mat4x3<N: Scalar>(m11: N, m12: N, m13: N,
 
 /// Create a new 4x4 matrix.
 #[rustfmt::skip]
-pub fn mat4x4<N: Scalar>(m11: N, m12: N, m13: N, m14: N,
-                         m21: N, m22: N, m23: N, m24: N,
-                         m31: N, m32: N, m33: N, m34: N,
-                         m41: N, m42: N, m43: N, m44: N) -> TMat4<N> {
-    TMat::<N, U4, U4>::new(
+pub fn mat4x4<T: Scalar>(m11: T, m12: T, m13: T, m14: T,
+                         m21: T, m22: T, m23: T, m24: T,
+                         m31: T, m32: T, m33: T, m34: T,
+                         m41: T, m42: T, m43: T, m44: T) -> TMat4<T> {
+    TMat::<T, 4, 4>::new(
         m11, m12, m13, m14,
         m21, m22, m23, m24,
         m31, m32, m33, m34,
@@ -165,11 +165,11 @@ pub fn mat4x4<N: Scalar>(m11: N, m12: N, m13: N, m14: N,
 
 /// Create a new 4x4 matrix.
 #[rustfmt::skip]
-pub fn mat4<N: Scalar>(m11: N, m12: N, m13: N, m14: N,
-                       m21: N, m22: N, m23: N, m24: N,
-                       m31: N, m32: N, m33: N, m34: N,
-                       m41: N, m42: N, m43: N, m44: N) -> TMat4<N> {
-    TMat::<N, U4, U4>::new(
+pub fn mat4<T: Scalar>(m11: T, m12: T, m13: T, m14: T,
+                       m21: T, m22: T, m23: T, m24: T,
+                       m31: T, m32: T, m33: T, m34: T,
+                       m41: T, m42: T, m43: T, m44: T) -> TMat4<T> {
+    TMat::<T, 4, 4>::new(
         m11, m12, m13, m14,
         m21, m22, m23, m24,
         m31, m32, m33, m34,
@@ -178,6 +178,6 @@ pub fn mat4<N: Scalar>(m11: N, m12: N, m13: N, m14: N,
 }
 
 /// Creates a new quaternion.
-pub fn quat<N: RealField>(x: N, y: N, z: N, w: N) -> Qua<N> {
+pub fn quat<T: RealField>(x: T, y: T, z: T, w: T) -> Qua<T> {
     Qua::new(w, x, y, z)
 }
diff --git a/nalgebra-glm/src/exponential.rs b/nalgebra-glm/src/exponential.rs
index 5830704a..54502123 100644
--- a/nalgebra-glm/src/exponential.rs
+++ b/nalgebra-glm/src/exponential.rs
@@ -1,16 +1,12 @@
 use crate::aliases::TVec;
-use crate::traits::{Alloc, Dimension};
-use na::{DefaultAllocator, RealField};
+use na::RealField;
 
 /// Component-wise exponential.
 ///
 /// # See also:
 ///
 /// * [`exp2`](fn.exp2.html)
-pub fn exp<N: RealField, D: Dimension>(v: &TVec<N, D>) -> TVec<N, D>
-where
-    DefaultAllocator: Alloc<N, D>,
-{
+pub fn exp<T: RealField, const D: usize>(v: &TVec<T, D>) -> TVec<T, D> {
     v.map(|x| x.exp())
 }
 
@@ -19,10 +15,7 @@ where
 /// # See also:
 ///
 /// * [`exp`](fn.exp.html)
-pub fn exp2<N: RealField, D: Dimension>(v: &TVec<N, D>) -> TVec<N, D>
-where
-    DefaultAllocator: Alloc<N, D>,
-{
+pub fn exp2<T: RealField, const D: usize>(v: &TVec<T, D>) -> TVec<T, D> {
     v.map(|x| x.exp2())
 }
 
@@ -31,11 +24,8 @@ where
 /// # See also:
 ///
 /// * [`sqrt`](fn.sqrt.html)
-pub fn inversesqrt<N: RealField, D: Dimension>(v: &TVec<N, D>) -> TVec<N, D>
-where
-    DefaultAllocator: Alloc<N, D>,
-{
-    v.map(|x| N::one() / x.sqrt())
+pub fn inversesqrt<T: RealField, const D: usize>(v: &TVec<T, D>) -> TVec<T, D> {
+    v.map(|x| T::one() / x.sqrt())
 }
 
 /// Component-wise logarithm.
@@ -43,10 +33,7 @@ where
 /// # See also:
 ///
 /// * [`log2`](fn.log2.html)
-pub fn log<N: RealField, D: Dimension>(v: &TVec<N, D>) -> TVec<N, D>
-where
-    DefaultAllocator: Alloc<N, D>,
-{
+pub fn log<T: RealField, const D: usize>(v: &TVec<T, D>) -> TVec<T, D> {
     v.map(|x| x.ln())
 }
 
@@ -55,18 +42,12 @@ where
 /// # See also:
 ///
 /// * [`log`](fn.log.html)
-pub fn log2<N: RealField, D: Dimension>(v: &TVec<N, D>) -> TVec<N, D>
-where
-    DefaultAllocator: Alloc<N, D>,
-{
+pub fn log2<T: RealField, const D: usize>(v: &TVec<T, D>) -> TVec<T, D> {
     v.map(|x| x.log2())
 }
 
 /// Component-wise power.
-pub fn pow<N: RealField, D: Dimension>(base: &TVec<N, D>, exponent: &TVec<N, D>) -> TVec<N, D>
-where
-    DefaultAllocator: Alloc<N, D>,
-{
+pub fn pow<T: RealField, const D: usize>(base: &TVec<T, D>, exponent: &TVec<T, D>) -> TVec<T, D> {
     base.zip_map(exponent, |b, e| b.powf(e))
 }
 
@@ -78,9 +59,6 @@ where
 /// * [`exp2`](fn.exp2.html)
 /// * [`inversesqrt`](fn.inversesqrt.html)
 /// * [`pow`](fn.pow.html)
-pub fn sqrt<N: RealField, D: Dimension>(v: &TVec<N, D>) -> TVec<N, D>
-where
-    DefaultAllocator: Alloc<N, D>,
-{
+pub fn sqrt<T: RealField, const D: usize>(v: &TVec<T, D>) -> TVec<T, D> {
     v.map(|x| x.sqrt())
 }
diff --git a/nalgebra-glm/src/ext/matrix_clip_space.rs b/nalgebra-glm/src/ext/matrix_clip_space.rs
index 5ee725ae..bb268a54 100644
--- a/nalgebra-glm/src/ext/matrix_clip_space.rs
+++ b/nalgebra-glm/src/ext/matrix_clip_space.rs
@@ -1,51 +1,51 @@
 use crate::aliases::TMat4;
 use na::RealField;
 
-//pub fn frustum<N: RealField>(left: N, right: N, bottom: N, top: N, near: N, far: N) -> TMat4<N> {
+//pub fn frustum<T: RealField>(left: T, right: T, bottom: T, top: T, near: T, far: T) -> TMat4<T> {
 //    unimplemented!()
 //}
 
-//pub fn frustum_lh<N: RealField>(left: N, right: N, bottom: N, top: N, near: N, far: N) -> TMat4<N> {
+//pub fn frustum_lh<T: RealField>(left: T, right: T, bottom: T, top: T, near: T, far: T) -> TMat4<T> {
 //    unimplemented!()
 //}
 //
-//pub fn frustum_lr_no<N: RealField>(left: N, right: N, bottom: N, top: N, near: N, far: N) -> TMat4<N> {
+//pub fn frustum_lr_no<T: RealField>(left: T, right: T, bottom: T, top: T, near: T, far: T) -> TMat4<T> {
 //    unimplemented!()
 //}
 //
-//pub fn frustum_lh_zo<N: RealField>(left: N, right: N, bottom: N, top: N, near: N, far: N) -> TMat4<N> {
+//pub fn frustum_lh_zo<T: RealField>(left: T, right: T, bottom: T, top: T, near: T, far: T) -> TMat4<T> {
 //    unimplemented!()
 //}
 //
-//pub fn frustum_no<N: RealField>(left: N, right: N, bottom: N, top: N, near: N, far: N) -> TMat4<N> {
+//pub fn frustum_no<T: RealField>(left: T, right: T, bottom: T, top: T, near: T, far: T) -> TMat4<T> {
 //    unimplemented!()
 //}
 //
-//pub fn frustum_rh<N: RealField>(left: N, right: N, bottom: N, top: N, near: N, far: N) -> TMat4<N> {
+//pub fn frustum_rh<T: RealField>(left: T, right: T, bottom: T, top: T, near: T, far: T) -> TMat4<T> {
 //    unimplemented!()
 //}
 //
-//pub fn frustum_rh_no<N: RealField>(left: N, right: N, bottom: N, top: N, near: N, far: N) -> TMat4<N> {
+//pub fn frustum_rh_no<T: RealField>(left: T, right: T, bottom: T, top: T, near: T, far: T) -> TMat4<T> {
 //    unimplemented!()
 //}
 //
-//pub fn frustum_rh_zo<N: RealField>(left: N, right: N, bottom: N, top: N, near: N, far: N) -> TMat4<N> {
+//pub fn frustum_rh_zo<T: RealField>(left: T, right: T, bottom: T, top: T, near: T, far: T) -> TMat4<T> {
 //    unimplemented!()
 //}
 //
-//pub fn frustum_zo<N: RealField>(left: N, right: N, bottom: N, top: N, near: N, far: N) -> TMat4<N> {
+//pub fn frustum_zo<T: RealField>(left: T, right: T, bottom: T, top: T, near: T, far: T) -> TMat4<T> {
 //    unimplemented!()
 //}
 
-//pub fn infinite_perspective<N: RealField>(fovy: N, aspect: N, near: N) -> TMat4<N> {
+//pub fn infinite_perspective<T: RealField>(fovy: T, aspect: T, near: T) -> TMat4<T> {
 //    unimplemented!()
 //}
 //
-//pub fn infinite_perspective_lh<N: RealField>(fovy: N, aspect: N, near: N) -> TMat4<N> {
+//pub fn infinite_perspective_lh<T: RealField>(fovy: T, aspect: T, near: T) -> TMat4<T> {
 //    unimplemented!()
 //}
 //
-//pub fn infinite_ortho<N: RealField>(left: N, right: N, bottom: N, top: N) -> TMat4<N> {
+//pub fn infinite_ortho<T: RealField>(left: T, right: T, bottom: T, top: T) -> TMat4<T> {
 //    unimplemented!()
 //}
 
@@ -60,7 +60,7 @@ use na::RealField;
 /// * `znear` - Distance from the viewer to the near clipping plane
 /// * `zfar` - Distance from the viewer to the far clipping plane
 ///
-pub fn ortho<N: RealField>(left: N, right: N, bottom: N, top: N, znear: N, zfar: N) -> TMat4<N> {
+pub fn ortho<T: RealField>(left: T, right: T, bottom: T, top: T, znear: T, zfar: T) -> TMat4<T> {
     ortho_rh_no(left, right, bottom, top, znear, zfar)
 }
 
@@ -75,7 +75,7 @@ pub fn ortho<N: RealField>(left: N, right: N, bottom: N, top: N, znear: N, zfar:
 /// * `znear` - Distance from the viewer to the near clipping plane
 /// * `zfar` - Distance from the viewer to the far clipping plane
 ///
-pub fn ortho_lh<N: RealField>(left: N, right: N, bottom: N, top: N, znear: N, zfar: N) -> TMat4<N> {
+pub fn ortho_lh<T: RealField>(left: T, right: T, bottom: T, top: T, znear: T, zfar: T) -> TMat4<T> {
     ortho_lh_no(left, right, bottom, top, znear, zfar)
 }
 
@@ -90,16 +90,16 @@ pub fn ortho_lh<N: RealField>(left: N, right: N, bottom: N, top: N, znear: N, zf
 /// * `znear` - Distance from the viewer to the near clipping plane
 /// * `zfar` - Distance from the viewer to the far clipping plane
 ///
-pub fn ortho_lh_no<N: RealField>(
-    left: N,
-    right: N,
-    bottom: N,
-    top: N,
-    znear: N,
-    zfar: N,
-) -> TMat4<N> {
-    let two: N = crate::convert(2.0);
-    let mut mat: TMat4<N> = TMat4::<N>::identity();
+pub fn ortho_lh_no<T: RealField>(
+    left: T,
+    right: T,
+    bottom: T,
+    top: T,
+    znear: T,
+    zfar: T,
+) -> TMat4<T> {
+    let two: T = crate::convert(2.0);
+    let mut mat: TMat4<T> = TMat4::<T>::identity();
 
     mat[(0, 0)] = two / (right - left);
     mat[(0, 3)] = -(right + left) / (right - left);
@@ -122,17 +122,17 @@ pub fn ortho_lh_no<N: RealField>(
 /// * `znear` - Distance from the viewer to the near clipping plane
 /// * `zfar` - Distance from the viewer to the far clipping plane
 ///
-pub fn ortho_lh_zo<N: RealField>(
-    left: N,
-    right: N,
-    bottom: N,
-    top: N,
-    znear: N,
-    zfar: N,
-) -> TMat4<N> {
-    let one: N = N::one();
-    let two: N = crate::convert(2.0);
-    let mut mat: TMat4<N> = TMat4::<N>::identity();
+pub fn ortho_lh_zo<T: RealField>(
+    left: T,
+    right: T,
+    bottom: T,
+    top: T,
+    znear: T,
+    zfar: T,
+) -> TMat4<T> {
+    let one: T = T::one();
+    let two: T = crate::convert(2.0);
+    let mut mat: TMat4<T> = TMat4::<T>::identity();
 
     mat[(0, 0)] = two / (right - left);
     mat[(0, 3)] = -(right + left) / (right - left);
@@ -155,7 +155,7 @@ pub fn ortho_lh_zo<N: RealField>(
 /// * `znear` - Distance from the viewer to the near clipping plane
 /// * `zfar` - Distance from the viewer to the far clipping plane
 ///
-pub fn ortho_no<N: RealField>(left: N, right: N, bottom: N, top: N, znear: N, zfar: N) -> TMat4<N> {
+pub fn ortho_no<T: RealField>(left: T, right: T, bottom: T, top: T, znear: T, zfar: T) -> TMat4<T> {
     ortho_rh_no(left, right, bottom, top, znear, zfar)
 }
 
@@ -170,7 +170,7 @@ pub fn ortho_no<N: RealField>(left: N, right: N, bottom: N, top: N, znear: N, zf
 /// * `znear` - Distance from the viewer to the near clipping plane
 /// * `zfar` - Distance from the viewer to the far clipping plane
 ///
-pub fn ortho_rh<N: RealField>(left: N, right: N, bottom: N, top: N, znear: N, zfar: N) -> TMat4<N> {
+pub fn ortho_rh<T: RealField>(left: T, right: T, bottom: T, top: T, znear: T, zfar: T) -> TMat4<T> {
     ortho_rh_no(left, right, bottom, top, znear, zfar)
 }
 
@@ -185,16 +185,16 @@ pub fn ortho_rh<N: RealField>(left: N, right: N, bottom: N, top: N, znear: N, zf
 /// * `znear` - Distance from the viewer to the near clipping plane
 /// * `zfar` - Distance from the viewer to the far clipping plane
 ///
-pub fn ortho_rh_no<N: RealField>(
-    left: N,
-    right: N,
-    bottom: N,
-    top: N,
-    znear: N,
-    zfar: N,
-) -> TMat4<N> {
-    let two: N = crate::convert(2.0);
-    let mut mat: TMat4<N> = TMat4::<N>::identity();
+pub fn ortho_rh_no<T: RealField>(
+    left: T,
+    right: T,
+    bottom: T,
+    top: T,
+    znear: T,
+    zfar: T,
+) -> TMat4<T> {
+    let two: T = crate::convert(2.0);
+    let mut mat: TMat4<T> = TMat4::<T>::identity();
 
     mat[(0, 0)] = two / (right - left);
     mat[(0, 3)] = -(right + left) / (right - left);
@@ -217,17 +217,17 @@ pub fn ortho_rh_no<N: RealField>(
 /// * `znear` - Distance from the viewer to the near clipping plane
 /// * `zfar` - Distance from the viewer to the far clipping plane
 ///
-pub fn ortho_rh_zo<N: RealField>(
-    left: N,
-    right: N,
-    bottom: N,
-    top: N,
-    znear: N,
-    zfar: N,
-) -> TMat4<N> {
-    let one: N = N::one();
-    let two: N = crate::convert(2.0);
-    let mut mat: TMat4<N> = TMat4::<N>::identity();
+pub fn ortho_rh_zo<T: RealField>(
+    left: T,
+    right: T,
+    bottom: T,
+    top: T,
+    znear: T,
+    zfar: T,
+) -> TMat4<T> {
+    let one: T = T::one();
+    let two: T = crate::convert(2.0);
+    let mut mat: TMat4<T> = TMat4::<T>::identity();
 
     mat[(0, 0)] = two / (right - left);
     mat[(0, 3)] = -(right + left) / (right - left);
@@ -250,7 +250,7 @@ pub fn ortho_rh_zo<N: RealField>(
 /// * `znear` - Distance from the viewer to the near clipping plane
 /// * `zfar` - Distance from the viewer to the far clipping plane
 ///
-pub fn ortho_zo<N: RealField>(left: N, right: N, bottom: N, top: N, znear: N, zfar: N) -> TMat4<N> {
+pub fn ortho_zo<T: RealField>(left: T, right: T, bottom: T, top: T, znear: T, zfar: T) -> TMat4<T> {
     ortho_rh_zo(left, right, bottom, top, znear, zfar)
 }
 
@@ -264,7 +264,7 @@ pub fn ortho_zo<N: RealField>(left: N, right: N, bottom: N, top: N, znear: N, zf
 /// * `near` - Distance from the viewer to the near clipping plane
 /// * `far` - Distance from the viewer to the far clipping plane
 ///
-pub fn perspective_fov<N: RealField>(fov: N, width: N, height: N, near: N, far: N) -> TMat4<N> {
+pub fn perspective_fov<T: RealField>(fov: T, width: T, height: T, near: T, far: T) -> TMat4<T> {
     perspective_fov_rh_no(fov, width, height, near, far)
 }
 
@@ -278,7 +278,7 @@ pub fn perspective_fov<N: RealField>(fov: N, width: N, height: N, near: N, far:
 /// * `near` - Distance from the viewer to the near clipping plane
 /// * `far` - Distance from the viewer to the far clipping plane
 ///
-pub fn perspective_fov_lh<N: RealField>(fov: N, width: N, height: N, near: N, far: N) -> TMat4<N> {
+pub fn perspective_fov_lh<T: RealField>(fov: T, width: T, height: T, near: T, far: T) -> TMat4<T> {
     perspective_fov_lh_no(fov, width, height, near, far)
 }
 
@@ -292,16 +292,16 @@ pub fn perspective_fov_lh<N: RealField>(fov: N, width: N, height: N, near: N, fa
 /// * `near` - Distance from the viewer to the near clipping plane
 /// * `far` - Distance from the viewer to the far clipping plane
 ///
-pub fn perspective_fov_lh_no<N: RealField>(
-    fov: N,
-    width: N,
-    height: N,
-    near: N,
-    far: N,
-) -> TMat4<N> {
-    assert!(width > N::zero(), "The width must be greater than zero");
-    assert!(height > N::zero(), "The height must be greater than zero.");
-    assert!(fov > N::zero(), "The fov must be greater than zero");
+pub fn perspective_fov_lh_no<T: RealField>(
+    fov: T,
+    width: T,
+    height: T,
+    near: T,
+    far: T,
+) -> TMat4<T> {
+    assert!(width > T::zero(), "The width must be greater than zero");
+    assert!(height > T::zero(), "The height must be greater than zero.");
+    assert!(fov > T::zero(), "The fov must be greater than zero");
 
     let mut mat = TMat4::zeros();
 
@@ -313,7 +313,7 @@ pub fn perspective_fov_lh_no<N: RealField>(
     mat[(1, 1)] = h;
     mat[(2, 2)] = (far + near) / (far - near);
     mat[(2, 3)] = -(far * near * crate::convert(2.0)) / (far - near);
-    mat[(3, 2)] = N::one();
+    mat[(3, 2)] = T::one();
 
     mat
 }
@@ -328,16 +328,16 @@ pub fn perspective_fov_lh_no<N: RealField>(
 /// * `near` - Distance from the viewer to the near clipping plane
 /// * `far` - Distance from the viewer to the far clipping plane
 ///
-pub fn perspective_fov_lh_zo<N: RealField>(
-    fov: N,
-    width: N,
-    height: N,
-    near: N,
-    far: N,
-) -> TMat4<N> {
-    assert!(width > N::zero(), "The width must be greater than zero");
-    assert!(height > N::zero(), "The height must be greater than zero.");
-    assert!(fov > N::zero(), "The fov must be greater than zero");
+pub fn perspective_fov_lh_zo<T: RealField>(
+    fov: T,
+    width: T,
+    height: T,
+    near: T,
+    far: T,
+) -> TMat4<T> {
+    assert!(width > T::zero(), "The width must be greater than zero");
+    assert!(height > T::zero(), "The height must be greater than zero.");
+    assert!(fov > T::zero(), "The fov must be greater than zero");
 
     let mut mat = TMat4::zeros();
 
@@ -349,7 +349,7 @@ pub fn perspective_fov_lh_zo<N: RealField>(
     mat[(1, 1)] = h;
     mat[(2, 2)] = far / (far - near);
     mat[(2, 3)] = -(far * near) / (far - near);
-    mat[(3, 2)] = N::one();
+    mat[(3, 2)] = T::one();
 
     mat
 }
@@ -364,7 +364,7 @@ pub fn perspective_fov_lh_zo<N: RealField>(
 /// * `near` - Distance from the viewer to the near clipping plane
 /// * `far` - Distance from the viewer to the far clipping plane
 ///
-pub fn perspective_fov_no<N: RealField>(fov: N, width: N, height: N, near: N, far: N) -> TMat4<N> {
+pub fn perspective_fov_no<T: RealField>(fov: T, width: T, height: T, near: T, far: T) -> TMat4<T> {
     perspective_fov_rh_no(fov, width, height, near, far)
 }
 
@@ -378,7 +378,7 @@ pub fn perspective_fov_no<N: RealField>(fov: N, width: N, height: N, near: N, fa
 /// * `near` - Distance from the viewer to the near clipping plane
 /// * `far` - Distance from the viewer to the far clipping plane
 ///
-pub fn perspective_fov_rh<N: RealField>(fov: N, width: N, height: N, near: N, far: N) -> TMat4<N> {
+pub fn perspective_fov_rh<T: RealField>(fov: T, width: T, height: T, near: T, far: T) -> TMat4<T> {
     perspective_fov_rh_no(fov, width, height, near, far)
 }
 
@@ -392,16 +392,16 @@ pub fn perspective_fov_rh<N: RealField>(fov: N, width: N, height: N, near: N, fa
 /// * `near` - Distance from the viewer to the near clipping plane
 /// * `far` - Distance from the viewer to the far clipping plane
 ///
-pub fn perspective_fov_rh_no<N: RealField>(
-    fov: N,
-    width: N,
-    height: N,
-    near: N,
-    far: N,
-) -> TMat4<N> {
-    assert!(width > N::zero(), "The width must be greater than zero");
-    assert!(height > N::zero(), "The height must be greater than zero.");
-    assert!(fov > N::zero(), "The fov must be greater than zero");
+pub fn perspective_fov_rh_no<T: RealField>(
+    fov: T,
+    width: T,
+    height: T,
+    near: T,
+    far: T,
+) -> TMat4<T> {
+    assert!(width > T::zero(), "The width must be greater than zero");
+    assert!(height > T::zero(), "The height must be greater than zero.");
+    assert!(fov > T::zero(), "The fov must be greater than zero");
 
     let mut mat = TMat4::zeros();
 
@@ -413,7 +413,7 @@ pub fn perspective_fov_rh_no<N: RealField>(
     mat[(1, 1)] = h;
     mat[(2, 2)] = -(far + near) / (far - near);
     mat[(2, 3)] = -(far * near * crate::convert(2.0)) / (far - near);
-    mat[(3, 2)] = -N::one();
+    mat[(3, 2)] = -T::one();
 
     mat
 }
@@ -428,16 +428,16 @@ pub fn perspective_fov_rh_no<N: RealField>(
 /// * `near` - Distance from the viewer to the near clipping plane
 /// * `far` - Distance from the viewer to the far clipping plane
 ///
-pub fn perspective_fov_rh_zo<N: RealField>(
-    fov: N,
-    width: N,
-    height: N,
-    near: N,
-    far: N,
-) -> TMat4<N> {
-    assert!(width > N::zero(), "The width must be greater than zero");
-    assert!(height > N::zero(), "The height must be greater than zero.");
-    assert!(fov > N::zero(), "The fov must be greater than zero");
+pub fn perspective_fov_rh_zo<T: RealField>(
+    fov: T,
+    width: T,
+    height: T,
+    near: T,
+    far: T,
+) -> TMat4<T> {
+    assert!(width > T::zero(), "The width must be greater than zero");
+    assert!(height > T::zero(), "The height must be greater than zero.");
+    assert!(fov > T::zero(), "The fov must be greater than zero");
 
     let mut mat = TMat4::zeros();
 
@@ -449,7 +449,7 @@ pub fn perspective_fov_rh_zo<N: RealField>(
     mat[(1, 1)] = h;
     mat[(2, 2)] = far / (near - far);
     mat[(2, 3)] = -(far * near) / (far - near);
-    mat[(3, 2)] = -N::one();
+    mat[(3, 2)] = -T::one();
 
     mat
 }
@@ -464,7 +464,7 @@ pub fn perspective_fov_rh_zo<N: RealField>(
 /// * `near` - Distance from the viewer to the near clipping plane
 /// * `far` - Distance from the viewer to the far clipping plane
 ///
-pub fn perspective_fov_zo<N: RealField>(fov: N, width: N, height: N, near: N, far: N) -> TMat4<N> {
+pub fn perspective_fov_zo<T: RealField>(fov: T, width: T, height: T, near: T, far: T) -> TMat4<T> {
     perspective_fov_rh_zo(fov, width, height, near, far)
 }
 
@@ -479,7 +479,7 @@ pub fn perspective_fov_zo<N: RealField>(fov: N, width: N, height: N, near: N, fa
 ///
 /// # Important note
 /// The `aspect` and `fovy` argument are interchanged compared to the original GLM API.
-pub fn perspective<N: RealField>(aspect: N, fovy: N, near: N, far: N) -> TMat4<N> {
+pub fn perspective<T: RealField>(aspect: T, fovy: T, near: T, far: T) -> TMat4<T> {
     // TODO: Breaking change - revert back to proper glm conventions?
     //
     //       Prior to changes to support configuring the behaviour of this function it was simply
@@ -508,7 +508,7 @@ pub fn perspective<N: RealField>(aspect: N, fovy: N, near: N, far: N) -> TMat4<N
 ///
 /// # Important note
 /// The `aspect` and `fovy` argument are interchanged compared to the original GLM API.
-pub fn perspective_lh<N: RealField>(aspect: N, fovy: N, near: N, far: N) -> TMat4<N> {
+pub fn perspective_lh<T: RealField>(aspect: T, fovy: T, near: T, far: T) -> TMat4<T> {
     perspective_lh_no(aspect, fovy, near, far)
 }
 
@@ -523,19 +523,19 @@ pub fn perspective_lh<N: RealField>(aspect: N, fovy: N, near: N, far: N) -> TMat
 ///
 /// # Important note
 /// The `aspect` and `fovy` argument are interchanged compared to the original GLM API.
-pub fn perspective_lh_no<N: RealField>(aspect: N, fovy: N, near: N, far: N) -> TMat4<N> {
+pub fn perspective_lh_no<T: RealField>(aspect: T, fovy: T, near: T, far: T) -> TMat4<T> {
     assert!(
-        !relative_eq!(far - near, N::zero()),
+        !relative_eq!(far - near, T::zero()),
         "The near-plane and far-plane must not be superimposed."
     );
     assert!(
-        !relative_eq!(aspect, N::zero()),
+        !relative_eq!(aspect, T::zero()),
         "The aspect ratio must not be zero."
     );
 
-    let one = N::one();
-    let two: N = crate::convert(2.0);
-    let mut mat: TMat4<N> = TMat4::zeros();
+    let one = T::one();
+    let two: T = crate::convert(2.0);
+    let mut mat: TMat4<T> = TMat4::zeros();
 
     let tan_half_fovy = (fovy / two).tan();
 
@@ -559,19 +559,19 @@ pub fn perspective_lh_no<N: RealField>(aspect: N, fovy: N, near: N, far: N) -> T
 ///
 /// # Important note
 /// The `aspect` and `fovy` argument are interchanged compared to the original GLM API.
-pub fn perspective_lh_zo<N: RealField>(aspect: N, fovy: N, near: N, far: N) -> TMat4<N> {
+pub fn perspective_lh_zo<T: RealField>(aspect: T, fovy: T, near: T, far: T) -> TMat4<T> {
     assert!(
-        !relative_eq!(far - near, N::zero()),
+        !relative_eq!(far - near, T::zero()),
         "The near-plane and far-plane must not be superimposed."
     );
     assert!(
-        !relative_eq!(aspect, N::zero()),
+        !relative_eq!(aspect, T::zero()),
         "The aspect ratio must not be zero."
     );
 
-    let one = N::one();
-    let two: N = crate::convert(2.0);
-    let mut mat: TMat4<N> = TMat4::zeros();
+    let one = T::one();
+    let two: T = crate::convert(2.0);
+    let mut mat: TMat4<T> = TMat4::zeros();
 
     let tan_half_fovy = (fovy / two).tan();
 
@@ -595,7 +595,7 @@ pub fn perspective_lh_zo<N: RealField>(aspect: N, fovy: N, near: N, far: N) -> T
 ///
 /// # Important note
 /// The `aspect` and `fovy` argument are interchanged compared to the original GLM API.
-pub fn perspective_no<N: RealField>(aspect: N, fovy: N, near: N, far: N) -> TMat4<N> {
+pub fn perspective_no<T: RealField>(aspect: T, fovy: T, near: T, far: T) -> TMat4<T> {
     perspective_rh_no(aspect, fovy, near, far)
 }
 
@@ -610,7 +610,7 @@ pub fn perspective_no<N: RealField>(aspect: N, fovy: N, near: N, far: N) -> TMat
 ///
 /// # Important note
 /// The `aspect` and `fovy` argument are interchanged compared to the original GLM API.
-pub fn perspective_rh<N: RealField>(aspect: N, fovy: N, near: N, far: N) -> TMat4<N> {
+pub fn perspective_rh<T: RealField>(aspect: T, fovy: T, near: T, far: T) -> TMat4<T> {
     perspective_rh_no(aspect, fovy, near, far)
 }
 
@@ -625,19 +625,19 @@ pub fn perspective_rh<N: RealField>(aspect: N, fovy: N, near: N, far: N) -> TMat
 ///
 /// # Important note
 /// The `aspect` and `fovy` argument are interchanged compared to the original GLM API.
-pub fn perspective_rh_no<N: RealField>(aspect: N, fovy: N, near: N, far: N) -> TMat4<N> {
+pub fn perspective_rh_no<T: RealField>(aspect: T, fovy: T, near: T, far: T) -> TMat4<T> {
     assert!(
-        !relative_eq!(far - near, N::zero()),
+        !relative_eq!(far - near, T::zero()),
         "The near-plane and far-plane must not be superimposed."
     );
     assert!(
-        !relative_eq!(aspect, N::zero()),
+        !relative_eq!(aspect, T::zero()),
         "The aspect ratio must not be zero."
     );
 
-    let negone = -N::one();
-    let one = N::one();
-    let two: N = crate::convert(2.0);
+    let negone = -T::one();
+    let one = T::one();
+    let two: T = crate::convert(2.0);
     let mut mat = TMat4::zeros();
 
     let tan_half_fovy = (fovy / two).tan();
@@ -662,18 +662,18 @@ pub fn perspective_rh_no<N: RealField>(aspect: N, fovy: N, near: N, far: N) -> T
 ///
 /// # Important note
 /// The `aspect` and `fovy` argument are interchanged compared to the original GLM API.
-pub fn perspective_rh_zo<N: RealField>(aspect: N, fovy: N, near: N, far: N) -> TMat4<N> {
+pub fn perspective_rh_zo<T: RealField>(aspect: T, fovy: T, near: T, far: T) -> TMat4<T> {
     assert!(
-        !relative_eq!(far - near, N::zero()),
+        !relative_eq!(far - near, T::zero()),
         "The near-plane and far-plane must not be superimposed."
     );
     assert!(
-        !relative_eq!(aspect, N::zero()),
+        !relative_eq!(aspect, T::zero()),
         "The aspect ratio must not be zero."
     );
 
-    let negone = -N::one();
-    let one = N::one();
+    let negone = -T::one();
+    let one = T::one();
     let two = crate::convert(2.0);
     let mut mat = TMat4::zeros();
 
@@ -699,7 +699,7 @@ pub fn perspective_rh_zo<N: RealField>(aspect: N, fovy: N, near: N, far: N) -> T
 ///
 /// # Important note
 /// The `aspect` and `fovy` argument are interchanged compared to the original GLM API.
-pub fn perspective_zo<N: RealField>(aspect: N, fovy: N, near: N, far: N) -> TMat4<N> {
+pub fn perspective_zo<T: RealField>(aspect: T, fovy: T, near: T, far: T) -> TMat4<T> {
     perspective_rh_zo(aspect, fovy, near, far)
 }
 
@@ -713,15 +713,15 @@ pub fn perspective_zo<N: RealField>(aspect: N, fovy: N, near: N, far: N) -> TMat
 ///
 /// # Important note
 /// The `aspect` and `fovy` argument are interchanged compared to the original GLM API.
-pub fn infinite_perspective_rh_no<N: RealField>(aspect: N, fovy: N, near: N) -> TMat4<N> {
-    let f = N::one() / (fovy * na::convert(0.5)).tan();
+pub fn infinite_perspective_rh_no<T: RealField>(aspect: T, fovy: T, near: T) -> TMat4<T> {
+    let f = T::one() / (fovy * na::convert(0.5)).tan();
     let mut mat = TMat4::zeros();
 
     mat[(0, 0)] = f / aspect;
     mat[(1, 1)] = f;
-    mat[(2, 2)] = -N::one();
+    mat[(2, 2)] = -T::one();
     mat[(2, 3)] = -near * na::convert(2.0);
-    mat[(3, 2)] = -N::one();
+    mat[(3, 2)] = -T::one();
 
     mat
 }
@@ -738,15 +738,15 @@ pub fn infinite_perspective_rh_no<N: RealField>(aspect: N, fovy: N, near: N) ->
 /// The `aspect` and `fovy` argument are interchanged compared to the original GLM API.
 ///
 // https://discourse.nphysics.org/t/reversed-z-and-infinite-zfar-in-projections/341/2
-pub fn infinite_perspective_rh_zo<N: RealField>(aspect: N, fovy: N, near: N) -> TMat4<N> {
-    let f = N::one() / (fovy * na::convert(0.5)).tan();
+pub fn infinite_perspective_rh_zo<T: RealField>(aspect: T, fovy: T, near: T) -> TMat4<T> {
+    let f = T::one() / (fovy * na::convert(0.5)).tan();
     let mut mat = TMat4::zeros();
 
     mat[(0, 0)] = f / aspect;
     mat[(1, 1)] = f;
-    mat[(2, 2)] = -N::one();
+    mat[(2, 2)] = -T::one();
     mat[(2, 3)] = -near;
-    mat[(3, 2)] = -N::one();
+    mat[(3, 2)] = -T::one();
 
     mat
 }
@@ -763,8 +763,8 @@ pub fn infinite_perspective_rh_zo<N: RealField>(aspect: N, fovy: N, near: N) ->
 /// # Important note
 /// The `aspect` and `fovy` argument are interchanged compared to the original GLM API.
 // NOTE: The variants `_no` of reversed perspective are not useful.
-pub fn reversed_perspective_rh_zo<N: RealField>(aspect: N, fovy: N, near: N, far: N) -> TMat4<N> {
-    let one = N::one();
+pub fn reversed_perspective_rh_zo<T: RealField>(aspect: T, fovy: T, near: T, far: T) -> TMat4<T> {
+    let one = T::one();
     let two = crate::convert(2.0);
     let mut mat = TMat4::zeros();
 
@@ -791,22 +791,22 @@ pub fn reversed_perspective_rh_zo<N: RealField>(aspect: N, fovy: N, near: N, far
 /// The `aspect` and `fovy` argument are interchanged compared to the original GLM API.
 // Credit: https://discourse.nphysics.org/t/reversed-z-and-infinite-zfar-in-projections/341/2
 // NOTE: The variants `_no` of reversed perspective are not useful.
-pub fn reversed_infinite_perspective_rh_zo<N: RealField>(aspect: N, fovy: N, near: N) -> TMat4<N> {
-    let f = N::one() / (fovy * na::convert(0.5)).tan();
+pub fn reversed_infinite_perspective_rh_zo<T: RealField>(aspect: T, fovy: T, near: T) -> TMat4<T> {
+    let f = T::one() / (fovy * na::convert(0.5)).tan();
     let mut mat = TMat4::zeros();
 
     mat[(0, 0)] = f / aspect;
     mat[(1, 1)] = f;
     mat[(2, 3)] = near;
-    mat[(3, 2)] = -N::one();
+    mat[(3, 2)] = -T::one();
 
     mat
 }
 
-//pub fn tweaked_infinite_perspective<N: RealField>(fovy: N, aspect: N, near: N) -> TMat4<N> {
+//pub fn tweaked_infinite_perspective<T: RealField>(fovy: T, aspect: T, near: T) -> TMat4<T> {
 //    unimplemented!()
 //}
 //
-//pub fn tweaked_infinite_perspective_ep<N: RealField>(fovy: N, aspect: N, near: N, ep: N) -> TMat4<N> {
+//pub fn tweaked_infinite_perspective_ep<T: RealField>(fovy: T, aspect: T, near: T, ep: T) -> TMat4<T> {
 //    unimplemented!()
 //}
diff --git a/nalgebra-glm/src/ext/matrix_projection.rs b/nalgebra-glm/src/ext/matrix_projection.rs
index 93c8d664..b9d8f045 100644
--- a/nalgebra-glm/src/ext/matrix_projection.rs
+++ b/nalgebra-glm/src/ext/matrix_projection.rs
@@ -1,4 +1,4 @@
-use na::{self, RealField, U3};
+use na::{self, RealField};
 
 use crate::aliases::{TMat4, TVec2, TVec3, TVec4};
 
@@ -9,22 +9,22 @@ use crate::aliases::{TMat4, TVec2, TVec3, TVec4};
 /// * `center` - Specify the center of a picking region in window coordinates.
 /// * `delta` - Specify the width and height, respectively, of the picking region in window coordinates.
 /// * `viewport` - Rendering viewport.
-pub fn pick_matrix<N: RealField>(
-    center: &TVec2<N>,
-    delta: &TVec2<N>,
-    viewport: &TVec4<N>,
-) -> TMat4<N> {
+pub fn pick_matrix<T: RealField>(
+    center: &TVec2<T>,
+    delta: &TVec2<T>,
+    viewport: &TVec4<T>,
+) -> TMat4<T> {
     let shift = TVec3::new(
         (viewport.z - (center.x - viewport.x) * na::convert(2.0)) / delta.x,
         (viewport.w - (center.y - viewport.y) * na::convert(2.0)) / delta.y,
-        N::zero(),
+        T::zero(),
     );
 
     let result = TMat4::new_translation(&shift);
     result.prepend_nonuniform_scaling(&TVec3::new(
         viewport.z / delta.x,
         viewport.w / delta.y,
-        N::one(),
+        T::one(),
     ))
 }
 
@@ -45,12 +45,12 @@ pub fn pick_matrix<N: RealField>(
 /// * [`unproject`](fn.unproject.html)
 /// * [`unproject_no`](fn.unproject_no.html)
 /// * [`unproject_zo`](fn.unproject_zo.html)
-pub fn project<N: RealField>(
-    obj: &TVec3<N>,
-    model: &TMat4<N>,
-    proj: &TMat4<N>,
-    viewport: TVec4<N>,
-) -> TVec3<N> {
+pub fn project<T: RealField>(
+    obj: &TVec3<T>,
+    model: &TMat4<T>,
+    proj: &TMat4<T>,
+    viewport: TVec4<T>,
+) -> TVec3<T> {
     project_no(obj, model, proj, viewport)
 }
 
@@ -72,12 +72,12 @@ pub fn project<N: RealField>(
 /// * [`unproject`](fn.unproject.html)
 /// * [`unproject_no`](fn.unproject_no.html)
 /// * [`unproject_zo`](fn.unproject_zo.html)
-pub fn project_no<N: RealField>(
-    obj: &TVec3<N>,
-    model: &TMat4<N>,
-    proj: &TMat4<N>,
-    viewport: TVec4<N>,
-) -> TVec3<N> {
+pub fn project_no<T: RealField>(
+    obj: &TVec3<T>,
+    model: &TMat4<T>,
+    proj: &TMat4<T>,
+    viewport: TVec4<T>,
+) -> TVec3<T> {
     let proj = project_zo(obj, model, proj, viewport);
     TVec3::new(proj.x, proj.y, proj.z * na::convert(0.5) + na::convert(0.5))
 }
@@ -100,18 +100,18 @@ pub fn project_no<N: RealField>(
 /// * [`unproject`](fn.unproject.html)
 /// * [`unproject_no`](fn.unproject_no.html)
 /// * [`unproject_zo`](fn.unproject_zo.html)
-pub fn project_zo<N: RealField>(
-    obj: &TVec3<N>,
-    model: &TMat4<N>,
-    proj: &TMat4<N>,
-    viewport: TVec4<N>,
-) -> TVec3<N> {
-    let normalized = proj * model * TVec4::new(obj.x, obj.y, obj.z, N::one());
-    let scale = N::one() / normalized.w;
+pub fn project_zo<T: RealField>(
+    obj: &TVec3<T>,
+    model: &TMat4<T>,
+    proj: &TMat4<T>,
+    viewport: TVec4<T>,
+) -> TVec3<T> {
+    let normalized = proj * model * TVec4::new(obj.x, obj.y, obj.z, T::one());
+    let scale = T::one() / normalized.w;
 
     TVec3::new(
-        viewport.x + (viewport.z * (normalized.x * scale + N::one()) * na::convert(0.5)),
-        viewport.y + (viewport.w * (normalized.y * scale + N::one()) * na::convert(0.5)),
+        viewport.x + (viewport.z * (normalized.x * scale + T::one()) * na::convert(0.5)),
+        viewport.y + (viewport.w * (normalized.y * scale + T::one()) * na::convert(0.5)),
         normalized.z * scale,
     )
 }
@@ -133,12 +133,12 @@ pub fn project_zo<N: RealField>(
 /// * [`project_zo`](fn.project_zo.html)
 /// * [`unproject_no`](fn.unproject_no.html)
 /// * [`unproject_zo`](fn.unproject_zo.html)
-pub fn unproject<N: RealField>(
-    win: &TVec3<N>,
-    model: &TMat4<N>,
-    proj: &TMat4<N>,
-    viewport: TVec4<N>,
-) -> TVec3<N> {
+pub fn unproject<T: RealField>(
+    win: &TVec3<T>,
+    model: &TMat4<T>,
+    proj: &TMat4<T>,
+    viewport: TVec4<T>,
+) -> TVec3<T> {
     unproject_no(win, model, proj, viewport)
 }
 
@@ -160,23 +160,23 @@ pub fn unproject<N: RealField>(
 /// * [`project_zo`](fn.project_zo.html)
 /// * [`unproject`](fn.unproject.html)
 /// * [`unproject_zo`](fn.unproject_zo.html)
-pub fn unproject_no<N: RealField>(
-    win: &TVec3<N>,
-    model: &TMat4<N>,
-    proj: &TMat4<N>,
-    viewport: TVec4<N>,
-) -> TVec3<N> {
-    let _2: N = na::convert(2.0);
+pub fn unproject_no<T: RealField>(
+    win: &TVec3<T>,
+    model: &TMat4<T>,
+    proj: &TMat4<T>,
+    viewport: TVec4<T>,
+) -> TVec3<T> {
+    let _2: T = na::convert(2.0);
     let transform = (proj * model).try_inverse().unwrap_or_else(TMat4::zeros);
     let pt = TVec4::new(
-        _2 * (win.x - viewport.x) / viewport.z - N::one(),
-        _2 * (win.y - viewport.y) / viewport.w - N::one(),
-        _2 * win.z - N::one(),
-        N::one(),
+        _2 * (win.x - viewport.x) / viewport.z - T::one(),
+        _2 * (win.y - viewport.y) / viewport.w - T::one(),
+        _2 * win.z - T::one(),
+        T::one(),
     );
 
     let result = transform * pt;
-    result.fixed_rows::<U3>(0) / result.w
+    result.fixed_rows::<3>(0) / result.w
 }
 
 /// Map the specified window coordinates (win.x, win.y, win.z) into object coordinates.
@@ -197,21 +197,21 @@ pub fn unproject_no<N: RealField>(
 /// * [`project_zo`](fn.project_zo.html)
 /// * [`unproject`](fn.unproject.html)
 /// * [`unproject_no`](fn.unproject_no.html)
-pub fn unproject_zo<N: RealField>(
-    win: &TVec3<N>,
-    model: &TMat4<N>,
-    proj: &TMat4<N>,
-    viewport: TVec4<N>,
-) -> TVec3<N> {
-    let _2: N = na::convert(2.0);
+pub fn unproject_zo<T: RealField>(
+    win: &TVec3<T>,
+    model: &TMat4<T>,
+    proj: &TMat4<T>,
+    viewport: TVec4<T>,
+) -> TVec3<T> {
+    let _2: T = na::convert(2.0);
     let transform = (proj * model).try_inverse().unwrap_or_else(TMat4::zeros);
     let pt = TVec4::new(
-        _2 * (win.x - viewport.x) / viewport.z - N::one(),
-        _2 * (win.y - viewport.y) / viewport.w - N::one(),
+        _2 * (win.x - viewport.x) / viewport.z - T::one(),
+        _2 * (win.y - viewport.y) / viewport.w - T::one(),
         win.z,
-        N::one(),
+        T::one(),
     );
 
     let result = transform * pt;
-    result.fixed_rows::<U3>(0) / result.w
+    result.fixed_rows::<3>(0) / result.w
 }
diff --git a/nalgebra-glm/src/ext/matrix_relationnal.rs b/nalgebra-glm/src/ext/matrix_relationnal.rs
index 7866e72a..e8d1e2fd 100644
--- a/nalgebra-glm/src/ext/matrix_relationnal.rs
+++ b/nalgebra-glm/src/ext/matrix_relationnal.rs
@@ -1,21 +1,16 @@
-use na::DefaultAllocator;
-
 use crate::aliases::{TMat, TVec};
-use crate::traits::{Alloc, Dimension, Number};
+use crate::traits::Number;
 
 /// Perform a component-wise equal-to comparison of two matrices.
 ///
 /// Return a boolean vector which components value is True if this expression is satisfied per column of the matrices.
-pub fn equal_columns<N: Number, R: Dimension, C: Dimension>(
-    x: &TMat<N, R, C>,
-    y: &TMat<N, R, C>,
-) -> TVec<bool, C>
-where
-    DefaultAllocator: Alloc<N, R, C>,
-{
+pub fn equal_columns<T: Number, const R: usize, const C: usize>(
+    x: &TMat<T, R, C>,
+    y: &TMat<T, R, C>,
+) -> TVec<bool, C> {
     let mut res = TVec::<_, C>::repeat(false);
 
-    for i in 0..C::dim() {
+    for i in 0..C {
         res[i] = x.column(i) == y.column(i)
     }
 
@@ -25,31 +20,25 @@ where
 /// Returns the component-wise comparison of `|x - y| < epsilon`.
 ///
 /// True if this expression is satisfied.
-pub fn equal_columns_eps<N: Number, R: Dimension, C: Dimension>(
-    x: &TMat<N, R, C>,
-    y: &TMat<N, R, C>,
-    epsilon: N,
-) -> TVec<bool, C>
-where
-    DefaultAllocator: Alloc<N, R, C>,
-{
+pub fn equal_columns_eps<T: Number, const R: usize, const C: usize>(
+    x: &TMat<T, R, C>,
+    y: &TMat<T, R, C>,
+    epsilon: T,
+) -> TVec<bool, C> {
     equal_columns_eps_vec(x, y, &TVec::<_, C>::repeat(epsilon))
 }
 
 /// Returns the component-wise comparison on each matrix column `|x - y| < epsilon`.
 ///
 /// True if this expression is satisfied.
-pub fn equal_columns_eps_vec<N: Number, R: Dimension, C: Dimension>(
-    x: &TMat<N, R, C>,
-    y: &TMat<N, R, C>,
-    epsilon: &TVec<N, C>,
-) -> TVec<bool, C>
-where
-    DefaultAllocator: Alloc<N, R, C>,
-{
+pub fn equal_columns_eps_vec<T: Number, const R: usize, const C: usize>(
+    x: &TMat<T, R, C>,
+    y: &TMat<T, R, C>,
+    epsilon: &TVec<T, C>,
+) -> TVec<bool, C> {
     let mut res = TVec::<_, C>::repeat(false);
 
-    for i in 0..C::dim() {
+    for i in 0..C {
         res[i] = (x.column(i) - y.column(i)).abs() < TVec::<_, R>::repeat(epsilon[i])
     }
 
@@ -59,16 +48,13 @@ where
 /// Perform a component-wise not-equal-to comparison of two matrices.
 ///
 /// Return a boolean vector which components value is True if this expression is satisfied per column of the matrices.
-pub fn not_equal_columns<N: Number, R: Dimension, C: Dimension>(
-    x: &TMat<N, R, C>,
-    y: &TMat<N, R, C>,
-) -> TVec<bool, C>
-where
-    DefaultAllocator: Alloc<N, R, C>,
-{
+pub fn not_equal_columns<T: Number, const R: usize, const C: usize>(
+    x: &TMat<T, R, C>,
+    y: &TMat<T, R, C>,
+) -> TVec<bool, C> {
     let mut res = TVec::<_, C>::repeat(false);
 
-    for i in 0..C::dim() {
+    for i in 0..C {
         res[i] = x.column(i) != y.column(i)
     }
 
@@ -78,31 +64,25 @@ where
 /// Returns the component-wise comparison of `|x - y| < epsilon`.
 ///
 /// True if this expression is not satisfied.
-pub fn not_equal_columns_eps<N: Number, R: Dimension, C: Dimension>(
-    x: &TMat<N, R, C>,
-    y: &TMat<N, R, C>,
-    epsilon: N,
-) -> TVec<bool, C>
-where
-    DefaultAllocator: Alloc<N, R, C>,
-{
+pub fn not_equal_columns_eps<T: Number, const R: usize, const C: usize>(
+    x: &TMat<T, R, C>,
+    y: &TMat<T, R, C>,
+    epsilon: T,
+) -> TVec<bool, C> {
     not_equal_columns_eps_vec(x, y, &TVec::<_, C>::repeat(epsilon))
 }
 
 /// Returns the component-wise comparison of `|x - y| >= epsilon`.
 ///
 /// True if this expression is not satisfied.
-pub fn not_equal_columns_eps_vec<N: Number, R: Dimension, C: Dimension>(
-    x: &TMat<N, R, C>,
-    y: &TMat<N, R, C>,
-    epsilon: &TVec<N, C>,
-) -> TVec<bool, C>
-where
-    DefaultAllocator: Alloc<N, R, C>,
-{
+pub fn not_equal_columns_eps_vec<T: Number, const R: usize, const C: usize>(
+    x: &TMat<T, R, C>,
+    y: &TMat<T, R, C>,
+    epsilon: &TVec<T, C>,
+) -> TVec<bool, C> {
     let mut res = TVec::<_, C>::repeat(false);
 
-    for i in 0..C::dim() {
+    for i in 0..C {
         res[i] = (x.column(i) - y.column(i)).abs() >= TVec::<_, R>::repeat(epsilon[i])
     }
 
diff --git a/nalgebra-glm/src/ext/matrix_transform.rs b/nalgebra-glm/src/ext/matrix_transform.rs
index df0696a4..821b585a 100644
--- a/nalgebra-glm/src/ext/matrix_transform.rs
+++ b/nalgebra-glm/src/ext/matrix_transform.rs
@@ -1,14 +1,11 @@
-use na::{DefaultAllocator, Point3, RealField, Rotation3, Unit};
+use na::{Point3, RealField, Rotation3, Unit};
 
 use crate::aliases::{TMat, TMat4, TVec, TVec3};
-use crate::traits::{Alloc, Dimension, Number};
+use crate::traits::Number;
 
 /// The identity matrix.
-pub fn identity<N: Number, D: Dimension>() -> TMat<N, D, D>
-where
-    DefaultAllocator: Alloc<N, D, D>,
-{
-    TMat::<N, D, D>::identity()
+pub fn identity<T: Number, const D: usize>() -> TMat<T, D, D> {
+    TMat::<T, D, D>::identity()
 }
 
 /// Build a look at view matrix based on the right handedness.
@@ -23,7 +20,7 @@ where
 ///
 /// * [`look_at_lh`](fn.look_at_lh.html)
 /// * [`look_at_rh`](fn.look_at_rh.html)
-pub fn look_at<N: RealField>(eye: &TVec3<N>, center: &TVec3<N>, up: &TVec3<N>) -> TMat4<N> {
+pub fn look_at<T: RealField>(eye: &TVec3<T>, center: &TVec3<T>, up: &TVec3<T>) -> TMat4<T> {
     look_at_rh(eye, center, up)
 }
 
@@ -39,7 +36,7 @@ pub fn look_at<N: RealField>(eye: &TVec3<N>, center: &TVec3<N>, up: &TVec3<N>) -
 ///
 /// * [`look_at`](fn.look_at.html)
 /// * [`look_at_rh`](fn.look_at_rh.html)
-pub fn look_at_lh<N: RealField>(eye: &TVec3<N>, center: &TVec3<N>, up: &TVec3<N>) -> TMat4<N> {
+pub fn look_at_lh<T: RealField>(eye: &TVec3<T>, center: &TVec3<T>, up: &TVec3<T>) -> TMat4<T> {
     TMat::look_at_lh(&Point3::from(*eye), &Point3::from(*center), up)
 }
 
@@ -55,7 +52,7 @@ pub fn look_at_lh<N: RealField>(eye: &TVec3<N>, center: &TVec3<N>, up: &TVec3<N>
 ///
 /// * [`look_at`](fn.look_at.html)
 /// * [`look_at_lh`](fn.look_at_lh.html)
-pub fn look_at_rh<N: RealField>(eye: &TVec3<N>, center: &TVec3<N>, up: &TVec3<N>) -> TMat4<N> {
+pub fn look_at_rh<T: RealField>(eye: &TVec3<T>, center: &TVec3<T>, up: &TVec3<T>) -> TMat4<T> {
     TMat::look_at_rh(&Point3::from(*eye), &Point3::from(*center), up)
 }
 
@@ -74,7 +71,7 @@ pub fn look_at_rh<N: RealField>(eye: &TVec3<N>, center: &TVec3<N>, up: &TVec3<N>
 /// * [`rotate_z`](fn.rotate_z.html)
 /// * [`scale`](fn.scale.html)
 /// * [`translate`](fn.translate.html)
-pub fn rotate<N: RealField>(m: &TMat4<N>, angle: N, axis: &TVec3<N>) -> TMat4<N> {
+pub fn rotate<T: RealField>(m: &TMat4<T>, angle: T, axis: &TVec3<T>) -> TMat4<T> {
     m * Rotation3::from_axis_angle(&Unit::new_normalize(*axis), angle).to_homogeneous()
 }
 
@@ -92,7 +89,7 @@ pub fn rotate<N: RealField>(m: &TMat4<N>, angle: N, axis: &TVec3<N>) -> TMat4<N>
 /// * [`rotate_z`](fn.rotate_z.html)
 /// * [`scale`](fn.scale.html)
 /// * [`translate`](fn.translate.html)
-pub fn rotate_x<N: RealField>(m: &TMat4<N>, angle: N) -> TMat4<N> {
+pub fn rotate_x<T: RealField>(m: &TMat4<T>, angle: T) -> TMat4<T> {
     rotate(m, angle, &TVec::x())
 }
 
@@ -110,7 +107,7 @@ pub fn rotate_x<N: RealField>(m: &TMat4<N>, angle: N) -> TMat4<N> {
 /// * [`rotate_z`](fn.rotate_z.html)
 /// * [`scale`](fn.scale.html)
 /// * [`translate`](fn.translate.html)
-pub fn rotate_y<N: RealField>(m: &TMat4<N>, angle: N) -> TMat4<N> {
+pub fn rotate_y<T: RealField>(m: &TMat4<T>, angle: T) -> TMat4<T> {
     rotate(m, angle, &TVec::y())
 }
 
@@ -128,7 +125,7 @@ pub fn rotate_y<N: RealField>(m: &TMat4<N>, angle: N) -> TMat4<N> {
 /// * [`rotate_y`](fn.rotate_y.html)
 /// * [`scale`](fn.scale.html)
 /// * [`translate`](fn.translate.html)
-pub fn rotate_z<N: RealField>(m: &TMat4<N>, angle: N) -> TMat4<N> {
+pub fn rotate_z<T: RealField>(m: &TMat4<T>, angle: T) -> TMat4<T> {
     rotate(m, angle, &TVec::z())
 }
 
@@ -146,7 +143,7 @@ pub fn rotate_z<N: RealField>(m: &TMat4<N>, angle: N) -> TMat4<N> {
 /// * [`rotate_y`](fn.rotate_y.html)
 /// * [`rotate_z`](fn.rotate_z.html)
 /// * [`translate`](fn.translate.html)
-pub fn scale<N: Number>(m: &TMat4<N>, v: &TVec3<N>) -> TMat4<N> {
+pub fn scale<T: Number>(m: &TMat4<T>, v: &TVec3<T>) -> TMat4<T> {
     m.prepend_nonuniform_scaling(v)
 }
 
@@ -164,6 +161,6 @@ pub fn scale<N: Number>(m: &TMat4<N>, v: &TVec3<N>) -> TMat4<N> {
 /// * [`rotate_y`](fn.rotate_y.html)
 /// * [`rotate_z`](fn.rotate_z.html)
 /// * [`scale`](fn.scale.html)
-pub fn translate<N: Number>(m: &TMat4<N>, v: &TVec3<N>) -> TMat4<N> {
+pub fn translate<T: Number>(m: &TMat4<T>, v: &TVec3<T>) -> TMat4<T> {
     m.prepend_translation(v)
 }
diff --git a/nalgebra-glm/src/ext/quaternion_common.rs b/nalgebra-glm/src/ext/quaternion_common.rs
index 072b57e2..fd3dbc2b 100644
--- a/nalgebra-glm/src/ext/quaternion_common.rs
+++ b/nalgebra-glm/src/ext/quaternion_common.rs
@@ -3,34 +3,34 @@ use na::{self, RealField, Unit};
 use crate::aliases::Qua;
 
 /// The conjugate of `q`.
-pub fn quat_conjugate<N: RealField>(q: &Qua<N>) -> Qua<N> {
+pub fn quat_conjugate<T: RealField>(q: &Qua<T>) -> Qua<T> {
     q.conjugate()
 }
 
 /// The inverse of `q`.
-pub fn quat_inverse<N: RealField>(q: &Qua<N>) -> Qua<N> {
+pub fn quat_inverse<T: RealField>(q: &Qua<T>) -> Qua<T> {
     q.try_inverse().unwrap_or_else(na::zero)
 }
 
-//pub fn quat_isinf<N: RealField>(x: &Qua<N>) -> TVec<bool, U4> {
+//pub fn quat_isinf<T: RealField>(x: &Qua<T>) -> TVec<bool, U4> {
 //    x.coords.map(|e| e.is_inf())
 //}
 
-//pub fn quat_isnan<N: RealField>(x: &Qua<N>) -> TVec<bool, U4> {
+//pub fn quat_isnan<T: RealField>(x: &Qua<T>) -> TVec<bool, U4> {
 //    x.coords.map(|e| e.is_nan())
 //}
 
 /// Interpolate linearly between `x` and `y`.
-pub fn quat_lerp<N: RealField>(x: &Qua<N>, y: &Qua<N>, a: N) -> Qua<N> {
+pub fn quat_lerp<T: RealField>(x: &Qua<T>, y: &Qua<T>, a: T) -> Qua<T> {
     x.lerp(y, a)
 }
 
-//pub fn quat_mix<N: RealField>(x: &Qua<N>, y: &Qua<N>, a: N) -> Qua<N> {
-//    x * (N::one() - a) + y * a
+//pub fn quat_mix<T: RealField>(x: &Qua<T>, y: &Qua<T>, a: T) -> Qua<T> {
+//    x * (T::one() - a) + y * a
 //}
 
 /// Interpolate spherically between `x` and `y`.
-pub fn quat_slerp<N: RealField>(x: &Qua<N>, y: &Qua<N>, a: N) -> Qua<N> {
+pub fn quat_slerp<T: RealField>(x: &Qua<T>, y: &Qua<T>, a: T) -> Qua<T> {
     Unit::new_normalize(*x)
         .slerp(&Unit::new_normalize(*y), a)
         .into_inner()
diff --git a/nalgebra-glm/src/ext/quaternion_geometric.rs b/nalgebra-glm/src/ext/quaternion_geometric.rs
index 24d9310d..7930a8da 100644
--- a/nalgebra-glm/src/ext/quaternion_geometric.rs
+++ b/nalgebra-glm/src/ext/quaternion_geometric.rs
@@ -3,26 +3,26 @@ use na::RealField;
 use crate::aliases::Qua;
 
 /// Multiplies two quaternions.
-pub fn quat_cross<N: RealField>(q1: &Qua<N>, q2: &Qua<N>) -> Qua<N> {
+pub fn quat_cross<T: RealField>(q1: &Qua<T>, q2: &Qua<T>) -> Qua<T> {
     q1 * q2
 }
 
 /// The scalar product of two quaternions.
-pub fn quat_dot<N: RealField>(x: &Qua<N>, y: &Qua<N>) -> N {
+pub fn quat_dot<T: RealField>(x: &Qua<T>, y: &Qua<T>) -> T {
     x.dot(y)
 }
 
 /// The magnitude of the quaternion `q`.
-pub fn quat_length<N: RealField>(q: &Qua<N>) -> N {
+pub fn quat_length<T: RealField>(q: &Qua<T>) -> T {
     q.norm()
 }
 
 /// The magnitude of the quaternion `q`.
-pub fn quat_magnitude<N: RealField>(q: &Qua<N>) -> N {
+pub fn quat_magnitude<T: RealField>(q: &Qua<T>) -> T {
     q.norm()
 }
 
 /// Normalizes the quaternion `q`.
-pub fn quat_normalize<N: RealField>(q: &Qua<N>) -> Qua<N> {
+pub fn quat_normalize<T: RealField>(q: &Qua<T>) -> Qua<T> {
     q.normalize()
 }
diff --git a/nalgebra-glm/src/ext/quaternion_relational.rs b/nalgebra-glm/src/ext/quaternion_relational.rs
index bd24edbe..282a3614 100644
--- a/nalgebra-glm/src/ext/quaternion_relational.rs
+++ b/nalgebra-glm/src/ext/quaternion_relational.rs
@@ -1,23 +1,23 @@
-use na::{RealField, U4};
+use na::RealField;
 
 use crate::aliases::{Qua, TVec};
 
 /// Component-wise equality comparison between two quaternions.
-pub fn quat_equal<N: RealField>(x: &Qua<N>, y: &Qua<N>) -> TVec<bool, U4> {
+pub fn quat_equal<T: RealField>(x: &Qua<T>, y: &Qua<T>) -> TVec<bool, 4> {
     crate::equal(&x.coords, &y.coords)
 }
 
 /// Component-wise approximate equality comparison between two quaternions.
-pub fn quat_equal_eps<N: RealField>(x: &Qua<N>, y: &Qua<N>, epsilon: N) -> TVec<bool, U4> {
+pub fn quat_equal_eps<T: RealField>(x: &Qua<T>, y: &Qua<T>, epsilon: T) -> TVec<bool, 4> {
     crate::equal_eps(&x.coords, &y.coords, epsilon)
 }
 
 /// Component-wise non-equality comparison between two quaternions.
-pub fn quat_not_equal<N: RealField>(x: &Qua<N>, y: &Qua<N>) -> TVec<bool, U4> {
+pub fn quat_not_equal<T: RealField>(x: &Qua<T>, y: &Qua<T>) -> TVec<bool, 4> {
     crate::not_equal(&x.coords, &y.coords)
 }
 
 /// Component-wise approximate non-equality comparison between two quaternions.
-pub fn quat_not_equal_eps<N: RealField>(x: &Qua<N>, y: &Qua<N>, epsilon: N) -> TVec<bool, U4> {
+pub fn quat_not_equal_eps<T: RealField>(x: &Qua<T>, y: &Qua<T>, epsilon: T) -> TVec<bool, 4> {
     crate::not_equal_eps(&x.coords, &y.coords, epsilon)
 }
diff --git a/nalgebra-glm/src/ext/quaternion_transform.rs b/nalgebra-glm/src/ext/quaternion_transform.rs
index 1e4e9771..34689cb4 100644
--- a/nalgebra-glm/src/ext/quaternion_transform.rs
+++ b/nalgebra-glm/src/ext/quaternion_transform.rs
@@ -3,25 +3,25 @@ use na::{RealField, Unit, UnitQuaternion};
 use crate::aliases::{Qua, TVec3};
 
 /// Computes the quaternion exponential.
-pub fn quat_exp<N: RealField>(q: &Qua<N>) -> Qua<N> {
+pub fn quat_exp<T: RealField>(q: &Qua<T>) -> Qua<T> {
     q.exp()
 }
 
 /// Computes the quaternion logarithm.
-pub fn quat_log<N: RealField>(q: &Qua<N>) -> Qua<N> {
+pub fn quat_log<T: RealField>(q: &Qua<T>) -> Qua<T> {
     q.ln()
 }
 
 /// Raises the quaternion `q` to the power `y`.
-pub fn quat_pow<N: RealField>(q: &Qua<N>, y: N) -> Qua<N> {
+pub fn quat_pow<T: RealField>(q: &Qua<T>, y: T) -> Qua<T> {
     q.powf(y)
 }
 
 /// Builds a quaternion from an axis and an angle, and right-multiply it to the quaternion `q`.
-pub fn quat_rotate<N: RealField>(q: &Qua<N>, angle: N, axis: &TVec3<N>) -> Qua<N> {
+pub fn quat_rotate<T: RealField>(q: &Qua<T>, angle: T, axis: &TVec3<T>) -> Qua<T> {
     q * UnitQuaternion::from_axis_angle(&Unit::new_normalize(*axis), angle).into_inner()
 }
 
-//pub fn quat_sqrt<N: RealField>(q: &Qua<N>) -> Qua<N> {
+//pub fn quat_sqrt<T: RealField>(q: &Qua<T>) -> Qua<T> {
 //    unimplemented!()
 //}
diff --git a/nalgebra-glm/src/ext/quaternion_trigonometric.rs b/nalgebra-glm/src/ext/quaternion_trigonometric.rs
index a711e69a..fdd21250 100644
--- a/nalgebra-glm/src/ext/quaternion_trigonometric.rs
+++ b/nalgebra-glm/src/ext/quaternion_trigonometric.rs
@@ -3,17 +3,17 @@ use na::{RealField, Unit, UnitQuaternion};
 use crate::aliases::{Qua, TVec3};
 
 /// The rotation angle of this quaternion assumed to be normalized.
-pub fn quat_angle<N: RealField>(x: &Qua<N>) -> N {
+pub fn quat_angle<T: RealField>(x: &Qua<T>) -> T {
     UnitQuaternion::from_quaternion(*x).angle()
 }
 
 /// Creates a quaternion from an axis and an angle.
-pub fn quat_angle_axis<N: RealField>(angle: N, axis: &TVec3<N>) -> Qua<N> {
+pub fn quat_angle_axis<T: RealField>(angle: T, axis: &TVec3<T>) -> Qua<T> {
     UnitQuaternion::from_axis_angle(&Unit::new_normalize(*axis), angle).into_inner()
 }
 
 /// The rotation axis of a quaternion assumed to be normalized.
-pub fn quat_axis<N: RealField>(x: &Qua<N>) -> TVec3<N> {
+pub fn quat_axis<T: RealField>(x: &Qua<T>) -> TVec3<T> {
     if let Some(a) = UnitQuaternion::from_quaternion(*x).axis() {
         a.into_inner()
     } else {
diff --git a/nalgebra-glm/src/ext/scalar_common.rs b/nalgebra-glm/src/ext/scalar_common.rs
index b3bd9c13..696b97e4 100644
--- a/nalgebra-glm/src/ext/scalar_common.rs
+++ b/nalgebra-glm/src/ext/scalar_common.rs
@@ -15,7 +15,7 @@ use crate::traits::Number;
 /// * [`max4_scalar`](fn.max4_scalar.html)
 /// * [`min3_scalar`](fn.min3_scalar.html)
 /// * [`min4_scalar`](fn.min4_scalar.html)
-pub fn max2_scalar<N: Number>(a: N, b: N) -> N {
+pub fn max2_scalar<T: Number>(a: T, b: T) -> T {
     if a >= b {
         a
     } else {
@@ -38,7 +38,7 @@ pub fn max2_scalar<N: Number>(a: N, b: N) -> N {
 /// * [`max4_scalar`](fn.max4_scalar.html)
 /// * [`min3_scalar`](fn.min3_scalar.html)
 /// * [`min4_scalar`](fn.min4_scalar.html)
-pub fn min2_scalar<N: Number>(a: N, b: N) -> N {
+pub fn min2_scalar<T: Number>(a: T, b: T) -> T {
     if a <= b {
         a
     } else {
@@ -61,7 +61,7 @@ pub fn min2_scalar<N: Number>(a: N, b: N) -> N {
 /// * [`max4_scalar`](fn.max4_scalar.html)
 /// * [`min3_scalar`](fn.min3_scalar.html)
 /// * [`min4_scalar`](fn.min4_scalar.html)
-pub fn max3_scalar<N: Number>(a: N, b: N, c: N) -> N {
+pub fn max3_scalar<T: Number>(a: T, b: T, c: T) -> T {
     max2_scalar(max2_scalar(a, b), c)
 }
 
@@ -80,7 +80,7 @@ pub fn max3_scalar<N: Number>(a: N, b: N, c: N) -> N {
 /// * [`max3_scalar`](fn.max3_scalar.html)
 /// * [`min3_scalar`](fn.min3_scalar.html)
 /// * [`min4_scalar`](fn.min4_scalar.html)
-pub fn max4_scalar<N: Number>(a: N, b: N, c: N, d: N) -> N {
+pub fn max4_scalar<T: Number>(a: T, b: T, c: T, d: T) -> T {
     max2_scalar(max2_scalar(a, b), max2_scalar(c, d))
 }
 
@@ -99,7 +99,7 @@ pub fn max4_scalar<N: Number>(a: N, b: N, c: N, d: N) -> N {
 /// * [`max3_scalar`](fn.max3_scalar.html)
 /// * [`max4_scalar`](fn.max4_scalar.html)
 /// * [`min4_scalar`](fn.min4_scalar.html)
-pub fn min3_scalar<N: Number>(a: N, b: N, c: N) -> N {
+pub fn min3_scalar<T: Number>(a: T, b: T, c: T) -> T {
     min2_scalar(min2_scalar(a, b), c)
 }
 
@@ -118,6 +118,6 @@ pub fn min3_scalar<N: Number>(a: N, b: N, c: N) -> N {
 /// * [`max3_scalar`](fn.max3_scalar.html)
 /// * [`max4_scalar`](fn.max4_scalar.html)
 /// * [`min3_scalar`](fn.min3_scalar.html)
-pub fn min4_scalar<N: Number>(a: N, b: N, c: N, d: N) -> N {
+pub fn min4_scalar<T: Number>(a: T, b: T, c: T, d: T) -> T {
     min2_scalar(min2_scalar(a, b), min2_scalar(c, d))
 }
diff --git a/nalgebra-glm/src/ext/scalar_constants.rs b/nalgebra-glm/src/ext/scalar_constants.rs
index e0741465..89d6f969 100644
--- a/nalgebra-glm/src/ext/scalar_constants.rs
+++ b/nalgebra-glm/src/ext/scalar_constants.rs
@@ -2,8 +2,8 @@ use approx::AbsDiffEq;
 use na::RealField;
 
 /// Default epsilon value used for approximate comparison.
-pub fn epsilon<N: AbsDiffEq<Epsilon = N>>() -> N {
-    N::default_epsilon()
+pub fn epsilon<T: AbsDiffEq<Epsilon = T>>() -> T {
+    T::default_epsilon()
 }
 
 /// The value of PI.
@@ -22,6 +22,6 @@ pub fn epsilon<N: AbsDiffEq<Epsilon = N>>() -> N {
 /// * [`two_over_pi`](fn.two_over_pi.html)
 /// * [`two_over_root_pi`](fn.two_over_root_pi.html)
 /// * [`two_pi`](fn.two_pi.html)
-pub fn pi<N: RealField>() -> N {
-    N::pi()
+pub fn pi<T: RealField>() -> T {
+    T::pi()
 }
diff --git a/nalgebra-glm/src/ext/vector_common.rs b/nalgebra-glm/src/ext/vector_common.rs
index ff892f1e..4e1f7446 100644
--- a/nalgebra-glm/src/ext/vector_common.rs
+++ b/nalgebra-glm/src/ext/vector_common.rs
@@ -1,7 +1,5 @@
-use na::{self, DefaultAllocator};
-
 use crate::aliases::TVec;
-use crate::traits::{Alloc, Dimension, Number};
+use crate::traits::Number;
 
 /// Component-wise maximum between a vector and a scalar.
 ///
@@ -16,10 +14,7 @@ use crate::traits::{Alloc, Dimension, Number};
 /// * [`min2`](fn.min2.html)
 /// * [`min3`](fn.min3.html)
 /// * [`min4`](fn.min4.html)
-pub fn max<N: Number, D: Dimension>(a: &TVec<N, D>, b: N) -> TVec<N, D>
-where
-    DefaultAllocator: Alloc<N, D>,
-{
+pub fn max<T: Number, const D: usize>(a: &TVec<T, D>, b: T) -> TVec<T, D> {
     a.map(|a| crate::max2_scalar(a, b))
 }
 
@@ -36,10 +31,7 @@ where
 /// * [`min2`](fn.min2.html)
 /// * [`min3`](fn.min3.html)
 /// * [`min4`](fn.min4.html)
-pub fn max2<N: Number, D: Dimension>(a: &TVec<N, D>, b: &TVec<N, D>) -> TVec<N, D>
-where
-    DefaultAllocator: Alloc<N, D>,
-{
+pub fn max2<T: Number, const D: usize>(a: &TVec<T, D>, b: &TVec<T, D>) -> TVec<T, D> {
     a.zip_map(b, |a, b| crate::max2_scalar(a, b))
 }
 
@@ -56,10 +48,11 @@ where
 /// * [`min2`](fn.min2.html)
 /// * [`min3`](fn.min3.html)
 /// * [`min4`](fn.min4.html)
-pub fn max3<N: Number, D: Dimension>(a: &TVec<N, D>, b: &TVec<N, D>, c: &TVec<N, D>) -> TVec<N, D>
-where
-    DefaultAllocator: Alloc<N, D>,
-{
+pub fn max3<T: Number, const D: usize>(
+    a: &TVec<T, D>,
+    b: &TVec<T, D>,
+    c: &TVec<T, D>,
+) -> TVec<T, D> {
     max2(&max2(a, b), c)
 }
 
@@ -76,15 +69,12 @@ where
 /// * [`min2`](fn.min2.html)
 /// * [`min3`](fn.min3.html)
 /// * [`min4`](fn.min4.html)
-pub fn max4<N: Number, D: Dimension>(
-    a: &TVec<N, D>,
-    b: &TVec<N, D>,
-    c: &TVec<N, D>,
-    d: &TVec<N, D>,
-) -> TVec<N, D>
-where
-    DefaultAllocator: Alloc<N, D>,
-{
+pub fn max4<T: Number, const D: usize>(
+    a: &TVec<T, D>,
+    b: &TVec<T, D>,
+    c: &TVec<T, D>,
+    d: &TVec<T, D>,
+) -> TVec<T, D> {
     max2(&max2(a, b), &max2(c, d))
 }
 
@@ -101,10 +91,7 @@ where
 /// * [`min2`](fn.min2.html)
 /// * [`min3`](fn.min3.html)
 /// * [`min4`](fn.min4.html)
-pub fn min<N: Number, D: Dimension>(x: &TVec<N, D>, y: N) -> TVec<N, D>
-where
-    DefaultAllocator: Alloc<N, D>,
-{
+pub fn min<T: Number, const D: usize>(x: &TVec<T, D>, y: T) -> TVec<T, D> {
     x.map(|x| crate::min2_scalar(x, y))
 }
 
@@ -121,10 +108,7 @@ where
 /// * [`min`](fn.min.html)
 /// * [`min3`](fn.min3.html)
 /// * [`min4`](fn.min4.html)
-pub fn min2<N: Number, D: Dimension>(x: &TVec<N, D>, y: &TVec<N, D>) -> TVec<N, D>
-where
-    DefaultAllocator: Alloc<N, D>,
-{
+pub fn min2<T: Number, const D: usize>(x: &TVec<T, D>, y: &TVec<T, D>) -> TVec<T, D> {
     x.zip_map(y, |a, b| crate::min2_scalar(a, b))
 }
 
@@ -141,10 +125,11 @@ where
 /// * [`min`](fn.min.html)
 /// * [`min2`](fn.min2.html)
 /// * [`min4`](fn.min4.html)
-pub fn min3<N: Number, D: Dimension>(a: &TVec<N, D>, b: &TVec<N, D>, c: &TVec<N, D>) -> TVec<N, D>
-where
-    DefaultAllocator: Alloc<N, D>,
-{
+pub fn min3<T: Number, const D: usize>(
+    a: &TVec<T, D>,
+    b: &TVec<T, D>,
+    c: &TVec<T, D>,
+) -> TVec<T, D> {
     min2(&min2(a, b), c)
 }
 
@@ -161,14 +146,11 @@ where
 /// * [`min`](fn.min.html)
 /// * [`min2`](fn.min2.html)
 /// * [`min3`](fn.min3.html)
-pub fn min4<N: Number, D: Dimension>(
-    a: &TVec<N, D>,
-    b: &TVec<N, D>,
-    c: &TVec<N, D>,
-    d: &TVec<N, D>,
-) -> TVec<N, D>
-where
-    DefaultAllocator: Alloc<N, D>,
-{
+pub fn min4<T: Number, const D: usize>(
+    a: &TVec<T, D>,
+    b: &TVec<T, D>,
+    c: &TVec<T, D>,
+    d: &TVec<T, D>,
+) -> TVec<T, D> {
     min2(&min2(a, b), &min2(c, d))
 }
diff --git a/nalgebra-glm/src/ext/vector_relational.rs b/nalgebra-glm/src/ext/vector_relational.rs
index a5071336..baefe1bd 100644
--- a/nalgebra-glm/src/ext/vector_relational.rs
+++ b/nalgebra-glm/src/ext/vector_relational.rs
@@ -1,7 +1,5 @@
-use na::DefaultAllocator;
-
 use crate::aliases::TVec;
-use crate::traits::{Alloc, Dimension, Number};
+use crate::traits::Number;
 
 /// Component-wise approximate equality of two vectors, using a scalar epsilon.
 ///
@@ -10,14 +8,11 @@ use crate::traits::{Alloc, Dimension, Number};
 /// * [`equal_eps_vec`](fn.equal_eps_vec.html)
 /// * [`not_equal_eps`](fn.not_equal_eps.html)
 /// * [`not_equal_eps_vec`](fn.not_equal_eps_vec.html)
-pub fn equal_eps<N: Number, D: Dimension>(
-    x: &TVec<N, D>,
-    y: &TVec<N, D>,
-    epsilon: N,
-) -> TVec<bool, D>
-where
-    DefaultAllocator: Alloc<N, D>,
-{
+pub fn equal_eps<T: Number, const D: usize>(
+    x: &TVec<T, D>,
+    y: &TVec<T, D>,
+    epsilon: T,
+) -> TVec<bool, D> {
     x.zip_map(y, |x, y| abs_diff_eq!(x, y, epsilon = epsilon))
 }
 
@@ -28,14 +23,11 @@ where
 /// * [`equal_eps`](fn.equal_eps.html)
 /// * [`not_equal_eps`](fn.not_equal_eps.html)
 /// * [`not_equal_eps_vec`](fn.not_equal_eps_vec.html)
-pub fn equal_eps_vec<N: Number, D: Dimension>(
-    x: &TVec<N, D>,
-    y: &TVec<N, D>,
-    epsilon: &TVec<N, D>,
-) -> TVec<bool, D>
-where
-    DefaultAllocator: Alloc<N, D>,
-{
+pub fn equal_eps_vec<T: Number, const D: usize>(
+    x: &TVec<T, D>,
+    y: &TVec<T, D>,
+    epsilon: &TVec<T, D>,
+) -> TVec<bool, D> {
     x.zip_zip_map(y, epsilon, |x, y, eps| abs_diff_eq!(x, y, epsilon = eps))
 }
 
@@ -46,14 +38,11 @@ where
 /// * [`equal_eps`](fn.equal_eps.html)
 /// * [`equal_eps_vec`](fn.equal_eps_vec.html)
 /// * [`not_equal_eps_vec`](fn.not_equal_eps_vec.html)
-pub fn not_equal_eps<N: Number, D: Dimension>(
-    x: &TVec<N, D>,
-    y: &TVec<N, D>,
-    epsilon: N,
-) -> TVec<bool, D>
-where
-    DefaultAllocator: Alloc<N, D>,
-{
+pub fn not_equal_eps<T: Number, const D: usize>(
+    x: &TVec<T, D>,
+    y: &TVec<T, D>,
+    epsilon: T,
+) -> TVec<bool, D> {
     x.zip_map(y, |x, y| abs_diff_ne!(x, y, epsilon = epsilon))
 }
 
@@ -64,13 +53,10 @@ where
 /// * [`equal_eps`](fn.equal_eps.html)
 /// * [`equal_eps_vec`](fn.equal_eps_vec.html)
 /// * [`not_equal_eps`](fn.not_equal_eps.html)
-pub fn not_equal_eps_vec<N: Number, D: Dimension>(
-    x: &TVec<N, D>,
-    y: &TVec<N, D>,
-    epsilon: &TVec<N, D>,
-) -> TVec<bool, D>
-where
-    DefaultAllocator: Alloc<N, D>,
-{
+pub fn not_equal_eps_vec<T: Number, const D: usize>(
+    x: &TVec<T, D>,
+    y: &TVec<T, D>,
+    epsilon: &TVec<T, D>,
+) -> TVec<bool, D> {
     x.zip_zip_map(y, epsilon, |x, y, eps| abs_diff_ne!(x, y, epsilon = eps))
 }
diff --git a/nalgebra-glm/src/geometric.rs b/nalgebra-glm/src/geometric.rs
index a4b0b988..3942756d 100644
--- a/nalgebra-glm/src/geometric.rs
+++ b/nalgebra-glm/src/geometric.rs
@@ -1,10 +1,10 @@
-use na::{DefaultAllocator, RealField};
+use na::RealField;
 
 use crate::aliases::{TVec, TVec3};
-use crate::traits::{Alloc, Dimension, Number};
+use crate::traits::Number;
 
 /// The cross product of two vectors.
-pub fn cross<N: Number>(x: &TVec3<N>, y: &TVec3<N>) -> TVec3<N> {
+pub fn cross<T: Number>(x: &TVec3<T>, y: &TVec3<T>) -> TVec3<T> {
     x.cross(y)
 }
 
@@ -13,31 +13,22 @@ pub fn cross<N: Number>(x: &TVec3<N>, y: &TVec3<N>) -> TVec3<N> {
 /// # See also:
 ///
 /// * [`distance2`](fn.distance2.html)
-pub fn distance<N: RealField, D: Dimension>(p0: &TVec<N, D>, p1: &TVec<N, D>) -> N
-where
-    DefaultAllocator: Alloc<N, D>,
-{
+pub fn distance<T: RealField, const D: usize>(p0: &TVec<T, D>, p1: &TVec<T, D>) -> T {
     (p1 - p0).norm()
 }
 
 /// The dot product of two vectors.
-pub fn dot<N: Number, D: Dimension>(x: &TVec<N, D>, y: &TVec<N, D>) -> N
-where
-    DefaultAllocator: Alloc<N, D>,
-{
+pub fn dot<T: Number, const D: usize>(x: &TVec<T, D>, y: &TVec<T, D>) -> T {
     x.dot(y)
 }
 
 /// If `dot(nref, i) < 0.0`, return `n`, otherwise, return `-n`.
-pub fn faceforward<N: Number, D: Dimension>(
-    n: &TVec<N, D>,
-    i: &TVec<N, D>,
-    nref: &TVec<N, D>,
-) -> TVec<N, D>
-where
-    DefaultAllocator: Alloc<N, D>,
-{
-    if nref.dot(i) < N::zero() {
+pub fn faceforward<T: Number, const D: usize>(
+    n: &TVec<T, D>,
+    i: &TVec<T, D>,
+    nref: &TVec<T, D>,
+) -> TVec<T, D> {
+    if nref.dot(i) < T::zero() {
         n.clone()
     } else {
         -n.clone()
@@ -53,10 +44,7 @@ where
 /// * [`length2`](fn.length2.html)
 /// * [`magnitude`](fn.magnitude.html)
 /// * [`magnitude2`](fn.magnitude2.html)
-pub fn length<N: RealField, D: Dimension>(x: &TVec<N, D>) -> N
-where
-    DefaultAllocator: Alloc<N, D>,
-{
+pub fn length<T: RealField, const D: usize>(x: &TVec<T, D>) -> T {
     x.norm()
 }
 
@@ -69,39 +57,31 @@ where
 /// * [`length`](fn.length.html)
 /// * [`magnitude2`](fn.magnitude2.html)
 /// * [`nalgebra::norm`](../nalgebra/fn.norm.html)
-pub fn magnitude<N: RealField, D: Dimension>(x: &TVec<N, D>) -> N
-where
-    DefaultAllocator: Alloc<N, D>,
-{
+pub fn magnitude<T: RealField, const D: usize>(x: &TVec<T, D>) -> T {
     x.norm()
 }
 
 /// Normalizes a vector.
-pub fn normalize<N: RealField, D: Dimension>(x: &TVec<N, D>) -> TVec<N, D>
-where
-    DefaultAllocator: Alloc<N, D>,
-{
+pub fn normalize<T: RealField, const D: usize>(x: &TVec<T, D>) -> TVec<T, D> {
     x.normalize()
 }
 
 /// For the incident vector `i` and surface orientation `n`, returns the reflection direction : `result = i - 2.0 * dot(n, i) * n`.
-pub fn reflect_vec<N: Number, D: Dimension>(i: &TVec<N, D>, n: &TVec<N, D>) -> TVec<N, D>
-where
-    DefaultAllocator: Alloc<N, D>,
-{
-    let _2 = N::one() + N::one();
+pub fn reflect_vec<T: Number, const D: usize>(i: &TVec<T, D>, n: &TVec<T, D>) -> TVec<T, D> {
+    let _2 = T::one() + T::one();
     i - n * (n.dot(i) * _2)
 }
 
 /// For the incident vector `i` and surface normal `n`, and the ratio of indices of refraction `eta`, return the refraction vector.
-pub fn refract_vec<N: RealField, D: Dimension>(i: &TVec<N, D>, n: &TVec<N, D>, eta: N) -> TVec<N, D>
-where
-    DefaultAllocator: Alloc<N, D>,
-{
+pub fn refract_vec<T: RealField, const D: usize>(
+    i: &TVec<T, D>,
+    n: &TVec<T, D>,
+    eta: T,
+) -> TVec<T, D> {
     let ni = n.dot(i);
-    let k = N::one() - eta * eta * (N::one() - ni * ni);
+    let k = T::one() - eta * eta * (T::one() - ni * ni);
 
-    if k < N::zero() {
+    if k < T::zero() {
         TVec::<_, D>::zeros()
     } else {
         i * eta - n * (eta * dot(n, i) + k.sqrt())
diff --git a/nalgebra-glm/src/gtc/bitfield.rs b/nalgebra-glm/src/gtc/bitfield.rs
index bdf18552..b37f0591 100644
--- a/nalgebra-glm/src/gtc/bitfield.rs
+++ b/nalgebra-glm/src/gtc/bitfield.rs
@@ -1,6 +1,5 @@
-use na::{Scalar, DefaultAllocator};
+use na::{DefaultAllocator, Scalar};
 
-use crate::traits::{Alloc, Dimension};
 use crate::aliases::*;
 
 pub fn bitfieldDeinterleave(x: u16) -> U8Vec2 {
@@ -19,8 +18,11 @@ pub fn bitfieldFillOne<IU>(Value: IU, FirstBit: i32, BitCount: i32) -> IU {
     unimplemented!()
 }
 
-pub fn bitfieldFillOne2<N: Scalar, D: Dimension>(Value: &TVec<N, D>, FirstBit: i32, BitCount: i32) -> TVec<N, D>
-    where DefaultAllocator: Alloc<N, D> {
+pub fn bitfieldFillOne2<T: Scalar, const D: usize>(
+    Value: &TVec<T, D>,
+    FirstBit: i32,
+    BitCount: i32,
+) -> TVec<T, D> {
     unimplemented!()
 }
 
@@ -28,8 +30,11 @@ pub fn bitfieldFillZero<IU>(Value: IU, FirstBit: i32, BitCount: i32) -> IU {
     unimplemented!()
 }
 
-pub fn bitfieldFillZero2<N: Scalar, D: Dimension>(Value: &TVec<N, D>, FirstBit: i32, BitCount: i32) -> TVec<N, D>
-    where DefaultAllocator: Alloc<N, D> {
+pub fn bitfieldFillZero2<T: Scalar, const D: usize>(
+    Value: &TVec<T, D>,
+    FirstBit: i32,
+    BitCount: i32,
+) -> TVec<T, D> {
     unimplemented!()
 }
 
@@ -113,8 +118,7 @@ pub fn bitfieldRotateLeft<IU>(In: IU, Shift: i32) -> IU {
     unimplemented!()
 }
 
-pub fn bitfieldRotateLeft2<N: Scalar, D: Dimension>(In: &TVec<N, D>, Shift: i32) -> TVec<N, D>
-    where DefaultAllocator: Alloc<N, D> {
+pub fn bitfieldRotateLeft2<T: Scalar, const D: usize>(In: &TVec<T, D>, Shift: i32) -> TVec<T, D> {
     unimplemented!()
 }
 
@@ -122,8 +126,7 @@ pub fn bitfieldRotateRight<IU>(In: IU, Shift: i32) -> IU {
     unimplemented!()
 }
 
-pub fn bitfieldRotateRight2<N: Scalar, D: Dimension>(In: &TVec<N, D>, Shift: i32) -> TVec<N, D>
-    where DefaultAllocator: Alloc<N, D> {
+pub fn bitfieldRotateRight2<T: Scalar, const D: usize>(In: &TVec<T, D>, Shift: i32) -> TVec<T, D> {
     unimplemented!()
 }
 
@@ -131,7 +134,6 @@ pub fn mask<IU>(Bits: IU) -> IU {
     unimplemented!()
 }
 
-pub fn mask2<N: Scalar, D: Dimension>(v: &TVec<N, D>) -> TVec<N, D>
-    where DefaultAllocator: Alloc<N, D> {
+pub fn mask2<T: Scalar, const D: usize>(v: &TVec<T, D>) -> TVec<T, D> {
     unimplemented!()
 }
diff --git a/nalgebra-glm/src/gtc/constants.rs b/nalgebra-glm/src/gtc/constants.rs
index 81375ee3..545d6b17 100644
--- a/nalgebra-glm/src/gtc/constants.rs
+++ b/nalgebra-glm/src/gtc/constants.rs
@@ -3,13 +3,13 @@ use na::{self, RealField};
 /// The Euler constant.
 ///
 /// This is a shorthand alias for [`euler`](fn.euler.html).
-pub fn e<N: RealField>() -> N {
-    N::e()
+pub fn e<T: RealField>() -> T {
+    T::e()
 }
 
 /// The Euler constant.
-pub fn euler<N: RealField>() -> N {
-    N::e()
+pub fn euler<T: RealField>() -> T {
+    T::e()
 }
 
 /// Returns `4 / pi`.
@@ -28,13 +28,13 @@ pub fn euler<N: RealField>() -> N {
 /// * [`two_over_pi`](fn.two_over_pi.html)
 /// * [`two_over_root_pi`](fn.two_over_root_pi.html)
 /// * [`two_pi`](fn.two_pi.html)
-pub fn four_over_pi<N: RealField>() -> N {
-    na::convert::<_, N>(4.0) / N::pi()
+pub fn four_over_pi<T: RealField>() -> T {
+    na::convert::<_, T>(4.0) / T::pi()
 }
 
 /// Returns the golden ratio.
-pub fn golden_ratio<N: RealField>() -> N {
-    (N::one() + root_five()) / na::convert(2.0)
+pub fn golden_ratio<T: RealField>() -> T {
+    (T::one() + root_five()) / na::convert(2.0)
 }
 
 /// Returns `pi / 2`.
@@ -53,8 +53,8 @@ pub fn golden_ratio<N: RealField>() -> N {
 /// * [`two_over_pi`](fn.two_over_pi.html)
 /// * [`two_over_root_pi`](fn.two_over_root_pi.html)
 /// * [`two_pi`](fn.two_pi.html)
-pub fn half_pi<N: RealField>() -> N {
-    N::frac_pi_2()
+pub fn half_pi<T: RealField>() -> T {
+    T::frac_pi_2()
 }
 
 /// Returns `ln(ln(2))`.
@@ -63,8 +63,8 @@ pub fn half_pi<N: RealField>() -> N {
 ///
 /// * [`ln_ten`](fn.ln_ten.html)
 /// * [`ln_two`](fn.ln_two.html)
-pub fn ln_ln_two<N: RealField>() -> N {
-    N::ln_2().ln()
+pub fn ln_ln_two<T: RealField>() -> T {
+    T::ln_2().ln()
 }
 
 /// Returns `ln(10)`.
@@ -73,8 +73,8 @@ pub fn ln_ln_two<N: RealField>() -> N {
 ///
 /// * [`ln_ln_two`](fn.ln_ln_two.html)
 /// * [`ln_two`](fn.ln_two.html)
-pub fn ln_ten<N: RealField>() -> N {
-    N::ln_10()
+pub fn ln_ten<T: RealField>() -> T {
+    T::ln_10()
 }
 
 /// Returns `ln(2)`.
@@ -83,8 +83,8 @@ pub fn ln_ten<N: RealField>() -> N {
 ///
 /// * [`ln_ln_two`](fn.ln_ln_two.html)
 /// * [`ln_ten`](fn.ln_ten.html)
-pub fn ln_two<N: RealField>() -> N {
-    N::ln_2()
+pub fn ln_two<T: RealField>() -> T {
+    T::ln_2()
 }
 
 /// Returns `1`.
@@ -106,13 +106,13 @@ pub use na::one;
 /// * [`two_over_pi`](fn.two_over_pi.html)
 /// * [`two_over_root_pi`](fn.two_over_root_pi.html)
 /// * [`two_pi`](fn.two_pi.html)
-pub fn one_over_pi<N: RealField>() -> N {
-    N::frac_1_pi()
+pub fn one_over_pi<T: RealField>() -> T {
+    T::frac_1_pi()
 }
 
 /// Returns `1 / sqrt(2)`.
-pub fn one_over_root_two<N: RealField>() -> N {
-    N::one() / root_two()
+pub fn one_over_root_two<T: RealField>() -> T {
+    T::one() / root_two()
 }
 
 /// Returns `1 / (2pi)`.
@@ -131,8 +131,8 @@ pub fn one_over_root_two<N: RealField>() -> N {
 /// * [`two_over_pi`](fn.two_over_pi.html)
 /// * [`two_over_root_pi`](fn.two_over_root_pi.html)
 /// * [`two_pi`](fn.two_pi.html)
-pub fn one_over_two_pi<N: RealField>() -> N {
-    N::frac_1_pi() * na::convert(0.5)
+pub fn one_over_two_pi<T: RealField>() -> T {
+    T::frac_1_pi() * na::convert(0.5)
 }
 
 /// Returns `pi / 4`.
@@ -151,8 +151,8 @@ pub fn one_over_two_pi<N: RealField>() -> N {
 /// * [`two_over_pi`](fn.two_over_pi.html)
 /// * [`two_over_root_pi`](fn.two_over_root_pi.html)
 /// * [`two_pi`](fn.two_pi.html)
-pub fn quarter_pi<N: RealField>() -> N {
-    N::frac_pi_4()
+pub fn quarter_pi<T: RealField>() -> T {
+    T::frac_pi_4()
 }
 
 /// Returns `sqrt(5)`.
@@ -161,8 +161,8 @@ pub fn quarter_pi<N: RealField>() -> N {
 ///
 /// * [`root_three`](fn.root_three.html)
 /// * [`root_two`](fn.root_two.html)
-pub fn root_five<N: RealField>() -> N {
-    na::convert::<_, N>(5.0).sqrt()
+pub fn root_five<T: RealField>() -> T {
+    na::convert::<_, T>(5.0).sqrt()
 }
 
 /// Returns `sqrt(pi / 2)`.
@@ -181,13 +181,13 @@ pub fn root_five<N: RealField>() -> N {
 /// * [`two_over_pi`](fn.two_over_pi.html)
 /// * [`two_over_root_pi`](fn.two_over_root_pi.html)
 /// * [`two_pi`](fn.two_pi.html)
-pub fn root_half_pi<N: RealField>() -> N {
-    (N::pi() / na::convert(2.0)).sqrt()
+pub fn root_half_pi<T: RealField>() -> T {
+    (T::pi() / na::convert(2.0)).sqrt()
 }
 
 /// Returns `sqrt(ln(4))`.
-pub fn root_ln_four<N: RealField>() -> N {
-    na::convert::<_, N>(4.0).ln().sqrt()
+pub fn root_ln_four<T: RealField>() -> T {
+    na::convert::<_, T>(4.0).ln().sqrt()
 }
 
 /// Returns the square root of pi.
@@ -206,8 +206,8 @@ pub fn root_ln_four<N: RealField>() -> N {
 /// * [`two_over_pi`](fn.two_over_pi.html)
 /// * [`two_over_root_pi`](fn.two_over_root_pi.html)
 /// * [`two_pi`](fn.two_pi.html)
-pub fn root_pi<N: RealField>() -> N {
-    N::pi().sqrt()
+pub fn root_pi<T: RealField>() -> T {
+    T::pi().sqrt()
 }
 
 /// Returns the square root of 3.
@@ -216,8 +216,8 @@ pub fn root_pi<N: RealField>() -> N {
 ///
 /// * [`root_five`](fn.root_five.html)
 /// * [`root_two`](fn.root_two.html)
-pub fn root_three<N: RealField>() -> N {
-    na::convert::<_, N>(3.0).sqrt()
+pub fn root_three<T: RealField>() -> T {
+    na::convert::<_, T>(3.0).sqrt()
 }
 
 /// Returns the square root of 2.
@@ -226,9 +226,9 @@ pub fn root_three<N: RealField>() -> N {
 ///
 /// * [`root_five`](fn.root_five.html)
 /// * [`root_three`](fn.root_three.html)
-pub fn root_two<N: RealField>() -> N {
+pub fn root_two<T: RealField>() -> T {
     // TODO: there should be a crate::sqrt_2() on the RealField trait.
-    na::convert::<_, N>(2.0).sqrt()
+    na::convert::<_, T>(2.0).sqrt()
 }
 
 /// Returns the square root of 2pi.
@@ -247,8 +247,8 @@ pub fn root_two<N: RealField>() -> N {
 /// * [`two_over_pi`](fn.two_over_pi.html)
 /// * [`two_over_root_pi`](fn.two_over_root_pi.html)
 /// * [`two_pi`](fn.two_pi.html)
-pub fn root_two_pi<N: RealField>() -> N {
-    N::two_pi().sqrt()
+pub fn root_two_pi<T: RealField>() -> T {
+    T::two_pi().sqrt()
 }
 
 /// Returns `1 / 3`.
@@ -256,7 +256,7 @@ pub fn root_two_pi<N: RealField>() -> N {
 /// # See also:
 ///
 /// * [`two_thirds`](fn.two_thirds.html)
-pub fn third<N: RealField>() -> N {
+pub fn third<T: RealField>() -> T {
     na::convert(1.0 / 3.0)
 }
 
@@ -276,8 +276,8 @@ pub fn third<N: RealField>() -> N {
 /// * [`two_over_pi`](fn.two_over_pi.html)
 /// * [`two_over_root_pi`](fn.two_over_root_pi.html)
 /// * [`two_pi`](fn.two_pi.html)
-pub fn three_over_two_pi<N: RealField>() -> N {
-    na::convert::<_, N>(3.0) / N::two_pi()
+pub fn three_over_two_pi<T: RealField>() -> T {
+    na::convert::<_, T>(3.0) / T::two_pi()
 }
 
 /// Returns `2 / pi`.
@@ -295,8 +295,8 @@ pub fn three_over_two_pi<N: RealField>() -> N {
 /// * [`three_over_two_pi`](fn.three_over_two_pi.html)
 /// * [`two_over_root_pi`](fn.two_over_root_pi.html)
 /// * [`two_pi`](fn.two_pi.html)
-pub fn two_over_pi<N: RealField>() -> N {
-    N::frac_2_pi()
+pub fn two_over_pi<T: RealField>() -> T {
+    T::frac_2_pi()
 }
 
 /// Returns `2 / sqrt(pi)`.
@@ -315,8 +315,8 @@ pub fn two_over_pi<N: RealField>() -> N {
 /// * [`three_over_two_pi`](fn.three_over_two_pi.html)
 /// * [`two_over_pi`](fn.two_over_pi.html)
 /// * [`two_pi`](fn.two_pi.html)
-pub fn two_over_root_pi<N: RealField>() -> N {
-    N::frac_2_sqrt_pi()
+pub fn two_over_root_pi<T: RealField>() -> T {
+    T::frac_2_sqrt_pi()
 }
 
 /// Returns `2pi`.
@@ -335,8 +335,8 @@ pub fn two_over_root_pi<N: RealField>() -> N {
 /// * [`three_over_two_pi`](fn.three_over_two_pi.html)
 /// * [`two_over_pi`](fn.two_over_pi.html)
 /// * [`two_over_root_pi`](fn.two_over_root_pi.html)
-pub fn two_pi<N: RealField>() -> N {
-    N::two_pi()
+pub fn two_pi<T: RealField>() -> T {
+    T::two_pi()
 }
 
 /// Returns `2 / 3`.
@@ -344,7 +344,7 @@ pub fn two_pi<N: RealField>() -> N {
 /// # See also:
 ///
 /// * [`third`](fn.third.html)
-pub fn two_thirds<N: RealField>() -> N {
+pub fn two_thirds<T: RealField>() -> T {
     na::convert(2.0 / 3.0)
 }
 
diff --git a/nalgebra-glm/src/gtc/epsilon.rs b/nalgebra-glm/src/gtc/epsilon.rs
index 81ac2e6c..fae29981 100644
--- a/nalgebra-glm/src/gtc/epsilon.rs
+++ b/nalgebra-glm/src/gtc/epsilon.rs
@@ -8,24 +8,24 @@ use crate::traits::{Alloc, Number, Dimension};
 use crate::aliases::TVec;
 
 /// Component-wise approximate equality beween two vectors.
-pub fn epsilon_equal<N: Number, D: Dimension>(x: &TVec<N, D>, y: &TVec<N, D>, epsilon: N) -> TVec<bool, D>
-    where DefaultAllocator: Alloc<N, D> {
+pub fn epsilon_equal<T: Number, const D: usize>(x: &TVec<T, D>, y: &TVec<T, D>, epsilon: T) -> TVec<bool, D>
+    where DefaultAllocator: Alloc<T, D> {
     x.zip_map(y, |x, y| abs_diff_eq!(x, y, epsilon = epsilon))
 }
 
 /// Component-wise approximate equality beween two scalars.
-pub fn epsilon_equal2<N: AbsDiffEq<Epsilon = N>>(x: N, y: N, epsilon: N) -> bool {
+pub fn epsilon_equal2<T: AbsDiffEq<Epsilon = T>>(x: T, y: T, epsilon: T) -> bool {
     abs_diff_eq!(x, y, epsilon = epsilon)
 }
 
 /// Component-wise approximate non-equality beween two vectors.
-pub fn epsilon_not_equal<N: Number, D: Dimension>(x: &TVec<N, D>, y: &TVec<N, D>, epsilon: N) -> TVec<bool, D>
-    where DefaultAllocator: Alloc<N, D> {
+pub fn epsilon_not_equal<T: Number, const D: usize>(x: &TVec<T, D>, y: &TVec<T, D>, epsilon: T) -> TVec<bool, D>
+    where DefaultAllocator: Alloc<T, D> {
     x.zip_map(y, |x, y| abs_diff_ne!(x, y, epsilon = epsilon))
 }
 
 /// Component-wise approximate non-equality beween two scalars.
-pub fn epsilon_not_equal2<N: AbsDiffEq<Epsilon = N>>(x: N, y: N, epsilon: N) -> bool {
+pub fn epsilon_not_equal2<T: AbsDiffEq<Epsilon = T>>(x: T, y: T, epsilon: T) -> bool {
     abs_diff_ne!(x, y, epsilon = epsilon)
 }
 */
diff --git a/nalgebra-glm/src/gtc/integer.rs b/nalgebra-glm/src/gtc/integer.rs
index a972a4ab..cf1225ea 100644
--- a/nalgebra-glm/src/gtc/integer.rs
+++ b/nalgebra-glm/src/gtc/integer.rs
@@ -1,10 +1,9 @@
-//use na::{Scalar, DefaultAllocator};
+//use na::Scalar;
+//
 //
-//use crate::traits::{Alloc, Dimension};
 //use crate::aliases::TVec;
 
-//pub fn iround<N: Scalar, D: Dimension>(x: &TVec<N, D>) -> TVec<i32, D>
-//    where DefaultAllocator: Alloc<N, D> {
+//pub fn iround<T: Scalar, const D: usize>(x: &TVec<T, D>) -> TVec<i32, D> {
 //    x.map(|x| x.round())
 //}
 //
@@ -12,7 +11,6 @@
 //    unimplemented!()
 //}
 //
-//pub fn uround<N: Scalar, D: Dimension>(x: &TVec<N, D>) -> TVec<u32, D>
-//    where DefaultAllocator: Alloc<N, D> {
+//pub fn uround<T: Scalar, const D: usize>(x: &TVec<T, D>) -> TVec<u32, D>  {
 //    unimplemented!()
 //}
diff --git a/nalgebra-glm/src/gtc/matrix_access.rs b/nalgebra-glm/src/gtc/matrix_access.rs
index 2713b8be..798c3b14 100644
--- a/nalgebra-glm/src/gtc/matrix_access.rs
+++ b/nalgebra-glm/src/gtc/matrix_access.rs
@@ -1,7 +1,6 @@
-use na::{DefaultAllocator, Scalar};
+use na::Scalar;
 
 use crate::aliases::{TMat, TVec};
-use crate::traits::{Alloc, Dimension};
 
 /// The `index`-th column of the matrix `m`.
 ///
@@ -10,10 +9,10 @@ use crate::traits::{Alloc, Dimension};
 /// * [`row`](fn.row.html)
 /// * [`set_column`](fn.set_column.html)
 /// * [`set_row`](fn.set_row.html)
-pub fn column<N: Scalar, R: Dimension, C: Dimension>(m: &TMat<N, R, C>, index: usize) -> TVec<N, R>
-where
-    DefaultAllocator: Alloc<N, R, C>,
-{
+pub fn column<T: Scalar, const R: usize, const C: usize>(
+    m: &TMat<T, R, C>,
+    index: usize,
+) -> TVec<T, R> {
     m.column(index).into_owned()
 }
 
@@ -24,14 +23,11 @@ where
 /// * [`column`](fn.column.html)
 /// * [`row`](fn.row.html)
 /// * [`set_row`](fn.set_row.html)
-pub fn set_column<N: Scalar, R: Dimension, C: Dimension>(
-    m: &TMat<N, R, C>,
+pub fn set_column<T: Scalar, const R: usize, const C: usize>(
+    m: &TMat<T, R, C>,
     index: usize,
-    x: &TVec<N, R>,
-) -> TMat<N, R, C>
-where
-    DefaultAllocator: Alloc<N, R, C>,
-{
+    x: &TVec<T, R>,
+) -> TMat<T, R, C> {
     let mut res = m.clone();
     res.set_column(index, x);
     res
@@ -44,10 +40,10 @@ where
 /// * [`column`](fn.column.html)
 /// * [`set_column`](fn.set_column.html)
 /// * [`set_row`](fn.set_row.html)
-pub fn row<N: Scalar, R: Dimension, C: Dimension>(m: &TMat<N, R, C>, index: usize) -> TVec<N, C>
-where
-    DefaultAllocator: Alloc<N, R, C>,
-{
+pub fn row<T: Scalar, const R: usize, const C: usize>(
+    m: &TMat<T, R, C>,
+    index: usize,
+) -> TVec<T, C> {
     m.row(index).into_owned().transpose()
 }
 
@@ -58,14 +54,11 @@ where
 /// * [`column`](fn.column.html)
 /// * [`row`](fn.row.html)
 /// * [`set_column`](fn.set_column.html)
-pub fn set_row<N: Scalar, R: Dimension, C: Dimension>(
-    m: &TMat<N, R, C>,
+pub fn set_row<T: Scalar, const R: usize, const C: usize>(
+    m: &TMat<T, R, C>,
     index: usize,
-    x: &TVec<N, C>,
-) -> TMat<N, R, C>
-where
-    DefaultAllocator: Alloc<N, R, C>,
-{
+    x: &TVec<T, C>,
+) -> TMat<T, R, C> {
     let mut res = m.clone();
     res.set_row(index, &x.transpose());
     res
diff --git a/nalgebra-glm/src/gtc/matrix_inverse.rs b/nalgebra-glm/src/gtc/matrix_inverse.rs
index c71a11f9..c0df4486 100644
--- a/nalgebra-glm/src/gtc/matrix_inverse.rs
+++ b/nalgebra-glm/src/gtc/matrix_inverse.rs
@@ -1,22 +1,15 @@
-use na::{DefaultAllocator, RealField};
+use na::RealField;
 
 use crate::aliases::TMat;
-use crate::traits::{Alloc, Dimension};
 
 /// Fast matrix inverse for affine matrix.
-pub fn affine_inverse<N: RealField, D: Dimension>(m: TMat<N, D, D>) -> TMat<N, D, D>
-where
-    DefaultAllocator: Alloc<N, D, D>,
-{
+pub fn affine_inverse<T: RealField, const D: usize>(m: TMat<T, D, D>) -> TMat<T, D, D> {
     // TODO: this should be optimized.
     m.try_inverse().unwrap_or_else(TMat::<_, D, D>::zeros)
 }
 
 /// Compute the transpose of the inverse of a matrix.
-pub fn inverse_transpose<N: RealField, D: Dimension>(m: TMat<N, D, D>) -> TMat<N, D, D>
-where
-    DefaultAllocator: Alloc<N, D, D>,
-{
+pub fn inverse_transpose<T: RealField, const D: usize>(m: TMat<T, D, D>) -> TMat<T, D, D> {
     m.try_inverse()
         .unwrap_or_else(TMat::<_, D, D>::zeros)
         .transpose()
diff --git a/nalgebra-glm/src/gtc/packing.rs b/nalgebra-glm/src/gtc/packing.rs
index ea5acac4..9635bdf9 100644
--- a/nalgebra-glm/src/gtc/packing.rs
+++ b/nalgebra-glm/src/gtc/packing.rs
@@ -1,9 +1,7 @@
-use na::{Scalar, RealField, DefaultAllocator, U3, U4};
+use na::{DefaultAllocator, RealField, Scalar, U3, U4};
 
-use crate::traits::{Alloc, Dimension};
 use crate::aliases::*;
 
-
 pub fn packF2x11_1x10(v: &Vec3) -> i32 {
     unimplemented!()
 }
@@ -12,8 +10,10 @@ pub fn packF3x9_E1x5(v: &Vec3) -> i32 {
     unimplemented!()
 }
 
-pub fn packHalf<D: Dimension>(v: &TVec<f32, D>) -> TVec<u16, D>
-    where DefaultAllocator: Alloc<u16, D> {
+pub fn packHalf<const D: usize>(v: &TVec<f32, D>) -> TVec<u16, D>
+where
+    DefaultAllocator: Alloc<u16, D>,
+{
     unimplemented!()
 }
 
@@ -49,12 +49,14 @@ pub fn packInt4x8(v: &I8Vec4) -> i32 {
     unimplemented!()
 }
 
-pub fn packRGBM<N: Scalar>(rgb: &TVec3<N>) -> TVec4<N> {
+pub fn packRGBM<T: Scalar>(rgb: &TVec3<T>) -> TVec4<T> {
     unimplemented!()
 }
 
-pub fn packSnorm<I: Scalar, N: RealField, D: Dimension>(v: TVec<N, D>) -> TVec<I, D>
-    where DefaultAllocator: Alloc<N, D> + Alloc<I, D> {
+pub fn packSnorm<I: Scalar, T: RealField, const D: usize>(v: TVec<T, D>) -> TVec<I, D>
+where
+    DefaultAllocator: Alloc<T, D> + Alloc<I, D>,
+{
     unimplemented!()
 }
 
@@ -102,8 +104,10 @@ pub fn packUint4x8(v: &U8Vec4) -> i32 {
     unimplemented!()
 }
 
-pub fn packUnorm<UI: Scalar, N: RealField, D: Dimension>(v: &TVec<N, D>) -> TVec<UI, D>
-    where DefaultAllocator: Alloc<N, D> + Alloc<UI, D> {
+pub fn packUnorm<UI: Scalar, T: RealField, const D: usize>(v: &TVec<T, D>) -> TVec<UI, D>
+where
+    DefaultAllocator: Alloc<T, D> + Alloc<UI, D>,
+{
     unimplemented!()
 }
 
@@ -155,8 +159,7 @@ pub fn unpackF3x9_E1x5(p: i32) -> Vec3 {
     unimplemented!()
 }
 
-pub fn unpackHalf<N: Scalar, D: Dimension>(p: TVec<i16, D>) -> TVec<N, D>
-    where DefaultAllocator: Alloc<N, D> {
+pub fn unpackHalf<T: Scalar, const D: usize>(p: TVec<i16, D>) -> TVec<T, D> {
     unimplemented!()
 }
 
@@ -192,12 +195,14 @@ pub fn unpackInt4x8(p: i32) -> I8Vec4 {
     unimplemented!()
 }
 
-pub fn unpackRGBM<N: Scalar>(rgbm: &TVec4<N>) -> TVec3<N> {
+pub fn unpackRGBM<T: Scalar>(rgbm: &TVec4<T>) -> TVec3<T> {
     unimplemented!()
 }
 
-pub fn unpackSnorm<I: Scalar, N: RealField, D: Dimension>(v: &TVec<I, D>) -> TVec<N, D>
-    where DefaultAllocator: Alloc<N, D> + Alloc<I, D> {
+pub fn unpackSnorm<I: Scalar, T: RealField, const D: usize>(v: &TVec<I, D>) -> TVec<T, D>
+where
+    DefaultAllocator: Alloc<T, D> + Alloc<I, D>,
+{
     unimplemented!()
 }
 
@@ -245,8 +250,10 @@ pub fn unpackUint4x8(p: i32) -> U8Vec4 {
     unimplemented!()
 }
 
-pub fn unpackUnorm<UI: Scalar, N: RealField, D: Dimension>(v: &TVec<UI, D>) -> TVec<N, D>
-    where DefaultAllocator: Alloc<N, D> + Alloc<UI, D> {
+pub fn unpackUnorm<UI: Scalar, T: RealField, const D: usize>(v: &TVec<UI, D>) -> TVec<T, D>
+where
+    DefaultAllocator: Alloc<T, D> + Alloc<UI, D>,
+{
     unimplemented!()
 }
 
diff --git a/nalgebra-glm/src/gtc/quaternion.rs b/nalgebra-glm/src/gtc/quaternion.rs
index 63a42511..6d483fe5 100644
--- a/nalgebra-glm/src/gtc/quaternion.rs
+++ b/nalgebra-glm/src/gtc/quaternion.rs
@@ -1,36 +1,36 @@
-use na::{RealField, UnitQuaternion, U4};
+use na::{RealField, UnitQuaternion};
 
 use crate::aliases::{Qua, TMat4, TVec, TVec3};
 
 /// Euler angles of the quaternion `q` as (pitch, yaw, roll).
-pub fn quat_euler_angles<N: RealField>(x: &Qua<N>) -> TVec3<N> {
+pub fn quat_euler_angles<T: RealField>(x: &Qua<T>) -> TVec3<T> {
     let q = UnitQuaternion::new_unchecked(*x);
     let a = q.euler_angles();
     TVec3::new(a.2, a.1, a.0)
 }
 
 /// Component-wise `>` comparison between two quaternions.
-pub fn quat_greater_than<N: RealField>(x: &Qua<N>, y: &Qua<N>) -> TVec<bool, U4> {
+pub fn quat_greater_than<T: RealField>(x: &Qua<T>, y: &Qua<T>) -> TVec<bool, 4> {
     crate::greater_than(&x.coords, &y.coords)
 }
 
 /// Component-wise `>=` comparison between two quaternions.
-pub fn quat_greater_than_equal<N: RealField>(x: &Qua<N>, y: &Qua<N>) -> TVec<bool, U4> {
+pub fn quat_greater_than_equal<T: RealField>(x: &Qua<T>, y: &Qua<T>) -> TVec<bool, 4> {
     crate::greater_than_equal(&x.coords, &y.coords)
 }
 
 /// Component-wise `<` comparison between two quaternions.
-pub fn quat_less_than<N: RealField>(x: &Qua<N>, y: &Qua<N>) -> TVec<bool, U4> {
+pub fn quat_less_than<T: RealField>(x: &Qua<T>, y: &Qua<T>) -> TVec<bool, 4> {
     crate::less_than(&x.coords, &y.coords)
 }
 
 /// Component-wise `<=` comparison between two quaternions.
-pub fn quat_less_than_equal<N: RealField>(x: &Qua<N>, y: &Qua<N>) -> TVec<bool, U4> {
+pub fn quat_less_than_equal<T: RealField>(x: &Qua<T>, y: &Qua<T>) -> TVec<bool, 4> {
     crate::less_than_equal(&x.coords, &y.coords)
 }
 
 /// Convert a quaternion to a rotation matrix in homogeneous coordinates.
-pub fn quat_cast<N: RealField>(x: &Qua<N>) -> TMat4<N> {
+pub fn quat_cast<T: RealField>(x: &Qua<T>) -> TMat4<T> {
     crate::quat_to_mat4(x)
 }
 
@@ -41,34 +41,34 @@ pub fn quat_cast<N: RealField>(x: &Qua<N>) -> TMat4<N> {
 /// * `direction` - Direction vector point at where to look
 /// * `up` - Object up vector
 ///
-pub fn quat_look_at<N: RealField>(direction: &TVec3<N>, up: &TVec3<N>) -> Qua<N> {
+pub fn quat_look_at<T: RealField>(direction: &TVec3<T>, up: &TVec3<T>) -> Qua<T> {
     quat_look_at_rh(direction, up)
 }
 
 /// Computes a left-handed look-at quaternion (equivalent to a left-handed look-at matrix).
-pub fn quat_look_at_lh<N: RealField>(direction: &TVec3<N>, up: &TVec3<N>) -> Qua<N> {
+pub fn quat_look_at_lh<T: RealField>(direction: &TVec3<T>, up: &TVec3<T>) -> Qua<T> {
     UnitQuaternion::look_at_lh(direction, up).into_inner()
 }
 
 /// Computes a right-handed look-at quaternion (equivalent to a right-handed look-at matrix).
-pub fn quat_look_at_rh<N: RealField>(direction: &TVec3<N>, up: &TVec3<N>) -> Qua<N> {
+pub fn quat_look_at_rh<T: RealField>(direction: &TVec3<T>, up: &TVec3<T>) -> Qua<T> {
     UnitQuaternion::look_at_rh(direction, up).into_inner()
 }
 
 /// The "roll" Euler angle of the quaternion `x` assumed to be normalized.
-pub fn quat_roll<N: RealField>(x: &Qua<N>) -> N {
+pub fn quat_roll<T: RealField>(x: &Qua<T>) -> T {
     // TODO: optimize this.
     quat_euler_angles(x).z
 }
 
 /// The "yaw" Euler angle of the quaternion `x` assumed to be normalized.
-pub fn quat_yaw<N: RealField>(x: &Qua<N>) -> N {
+pub fn quat_yaw<T: RealField>(x: &Qua<T>) -> T {
     // TODO: optimize this.
     quat_euler_angles(x).y
 }
 
 /// The "pitch" Euler angle of the quaternion `x` assumed to be normalized.
-pub fn quat_pitch<N: RealField>(x: &Qua<N>) -> N {
+pub fn quat_pitch<T: RealField>(x: &Qua<T>) -> T {
     // TODO: optimize this.
     quat_euler_angles(x).x
 }
diff --git a/nalgebra-glm/src/gtc/round.rs b/nalgebra-glm/src/gtc/round.rs
index 5ad95780..5cf75936 100644
--- a/nalgebra-glm/src/gtc/round.rs
+++ b/nalgebra-glm/src/gtc/round.rs
@@ -1,15 +1,16 @@
-use na::{Scalar, RealField, U3, DefaultAllocator};
+use na::{DefaultAllocator, RealField, Scalar, U3};
 
-use crate::traits::{Number, Alloc, Dimension};
 use crate::aliases::TVec;
-
+use crate::traits::{Alloc, Dimension, Number};
 
 pub fn ceilMultiple<T>(v: T, Multiple: T) -> T {
     unimplemented!()
 }
 
-pub fn ceilMultiple2<N: Scalar, D: Dimension>(v: &TVec<N, D>, Multiple: &TVec<N, D>) -> TVec<N, D>
-    where DefaultAllocator: Alloc<N, D> {
+pub fn ceilMultiple2<T: Scalar, const D: usize>(v: &TVec<T, D>, Multiple: &TVec<T, D>) -> TVec<T, D>
+where
+    DefaultAllocator: Alloc<T, D>,
+{
     unimplemented!()
 }
 
@@ -17,8 +18,10 @@ pub fn ceilPowerOfTwo<IU>(v: IU) -> IU {
     unimplemented!()
 }
 
-pub fn ceilPowerOfTwo2<N: Scalar, D: Dimension>(v: &TVec<N, D>) -> TVec<N, D>
-    where DefaultAllocator: Alloc<N, D> {
+pub fn ceilPowerOfTwo2<T: Scalar, const D: usize>(v: &TVec<T, D>) -> TVec<T, D>
+where
+    DefaultAllocator: Alloc<T, D>,
+{
     unimplemented!()
 }
 
@@ -26,8 +29,13 @@ pub fn floorMultiple<T>(v: T, Multiple: T) -> T {
     unimplemented!()
 }
 
-pub fn floorMultiple2<N: Scalar, D: Dimension>(v: &TVec<N, D>, Multiple: &TVec<N, D>) -> TVec<N, D>
-    where DefaultAllocator: Alloc<N, D> {
+pub fn floorMultiple2<T: Scalar, const D: usize>(
+    v: &TVec<T, D>,
+    Multiple: &TVec<T, D>,
+) -> TVec<T, D>
+where
+    DefaultAllocator: Alloc<T, D>,
+{
     unimplemented!()
 }
 
@@ -35,8 +43,10 @@ pub fn floorPowerOfTwo<IU>(v: IU) -> IU {
     unimplemented!()
 }
 
-pub fn floorPowerOfTwo2<N: Scalar, D: Dimension>(v: &TVec<N, D>) -> TVec<N, D>
-    where DefaultAllocator: Alloc<N, D> {
+pub fn floorPowerOfTwo2<T: Scalar, const D: usize>(v: &TVec<T, D>) -> TVec<T, D>
+where
+    DefaultAllocator: Alloc<T, D>,
+{
     unimplemented!()
 }
 
@@ -44,13 +54,20 @@ pub fn isMultiple<IU>(v: IU, Multiple: IU) -> bool {
     unimplemented!()
 }
 
-pub fn isMultiple2<N: Scalar, D: Dimension>(v: &TVec<N, D>,Multiple: N) -> TVec<bool, D>
-    where DefaultAllocator: Alloc<N, D> {
+pub fn isMultiple2<T: Scalar, const D: usize>(v: &TVec<T, D>, Multiple: T) -> TVec<bool, D>
+where
+    DefaultAllocator: Alloc<T, D>,
+{
     unimplemented!()
 }
 
-pub fn isMultiple3<N: Scalar, D: Dimension>(v: &TVec<N, D>, Multiple: &TVec<N, D>) -> TVec<bool, D>
-    where DefaultAllocator: Alloc<N, D> {
+pub fn isMultiple3<T: Scalar, const D: usize>(
+    v: &TVec<T, D>,
+    Multiple: &TVec<T, D>,
+) -> TVec<bool, D>
+where
+    DefaultAllocator: Alloc<T, D>,
+{
     unimplemented!()
 }
 
@@ -58,8 +75,10 @@ pub fn isPowerOfTwo2<IU>(v: IU) -> bool {
     unimplemented!()
 }
 
-pub fn isPowerOfTwo<N: Scalar, D: Dimension>(v: &TVec<N, D>) -> TVec<bool, D>
-    where DefaultAllocator: Alloc<N, D> {
+pub fn isPowerOfTwo<T: Scalar, const D: usize>(v: &TVec<T, D>) -> TVec<bool, D>
+where
+    DefaultAllocator: Alloc<T, D>,
+{
     unimplemented!()
 }
 
@@ -67,8 +86,13 @@ pub fn roundMultiple<T>(v: T, Multiple: T) -> T {
     unimplemented!()
 }
 
-pub fn roundMultiple2<N: Scalar, D: Dimension>(v: &TVec<N, D>, Multiple: &TVec<N, D>) -> TVec<N, D>
-    where DefaultAllocator: Alloc<N, D> {
+pub fn roundMultiple2<T: Scalar, const D: usize>(
+    v: &TVec<T, D>,
+    Multiple: &TVec<T, D>,
+) -> TVec<T, D>
+where
+    DefaultAllocator: Alloc<T, D>,
+{
     unimplemented!()
 }
 
@@ -76,7 +100,9 @@ pub fn roundPowerOfTwo<IU>(v: IU) -> IU {
     unimplemented!()
 }
 
-pub fn roundPowerOfTwo2<N: Scalar, D: Dimension>(v: &TVec<N, D>) -> TVec<N, D>
-    where DefaultAllocator: Alloc<N, D> {
+pub fn roundPowerOfTwo2<T: Scalar, const D: usize>(v: &TVec<T, D>) -> TVec<T, D>
+where
+    DefaultAllocator: Alloc<T, D>,
+{
     unimplemented!()
 }
diff --git a/nalgebra-glm/src/gtc/type_ptr.rs b/nalgebra-glm/src/gtc/type_ptr.rs
index f8c6698b..bdd72585 100644
--- a/nalgebra-glm/src/gtc/type_ptr.rs
+++ b/nalgebra-glm/src/gtc/type_ptr.rs
@@ -1,81 +1,81 @@
-use na::{DefaultAllocator, Quaternion, RealField, Scalar};
+use na::{Quaternion, RealField, Scalar};
 
 use crate::aliases::{
     Qua, TMat, TMat2, TMat2x3, TMat2x4, TMat3, TMat3x2, TMat3x4, TMat4, TMat4x2, TMat4x3, TVec1,
     TVec2, TVec3, TVec4,
 };
-use crate::traits::{Alloc, Dimension, Number};
+use crate::traits::Number;
 
 /// Creates a 2x2 matrix from a slice arranged in column-major order.
-pub fn make_mat2<N: Scalar>(ptr: &[N]) -> TMat2<N> {
+pub fn make_mat2<T: Scalar>(ptr: &[T]) -> TMat2<T> {
     TMat2::from_column_slice(ptr)
 }
 
 /// Creates a 2x2 matrix from a slice arranged in column-major order.
-pub fn make_mat2x2<N: Scalar>(ptr: &[N]) -> TMat2<N> {
+pub fn make_mat2x2<T: Scalar>(ptr: &[T]) -> TMat2<T> {
     TMat2::from_column_slice(ptr)
 }
 
 /// Creates a 2x3 matrix from a slice arranged in column-major order.
-pub fn make_mat2x3<N: Scalar>(ptr: &[N]) -> TMat2x3<N> {
+pub fn make_mat2x3<T: Scalar>(ptr: &[T]) -> TMat2x3<T> {
     TMat2x3::from_column_slice(ptr)
 }
 
 /// Creates a 2x4 matrix from a slice arranged in column-major order.
-pub fn make_mat2x4<N: Scalar>(ptr: &[N]) -> TMat2x4<N> {
+pub fn make_mat2x4<T: Scalar>(ptr: &[T]) -> TMat2x4<T> {
     TMat2x4::from_column_slice(ptr)
 }
 
 /// Creates a 3 matrix from a slice arranged in column-major order.
-pub fn make_mat3<N: Scalar>(ptr: &[N]) -> TMat3<N> {
+pub fn make_mat3<T: Scalar>(ptr: &[T]) -> TMat3<T> {
     TMat3::from_column_slice(ptr)
 }
 
 /// Creates a 3x2 matrix from a slice arranged in column-major order.
-pub fn make_mat3x2<N: Scalar>(ptr: &[N]) -> TMat3x2<N> {
+pub fn make_mat3x2<T: Scalar>(ptr: &[T]) -> TMat3x2<T> {
     TMat3x2::from_column_slice(ptr)
 }
 
 /// Creates a 3x3 matrix from a slice arranged in column-major order.
-pub fn make_mat3x3<N: Scalar>(ptr: &[N]) -> TMat3<N> {
+pub fn make_mat3x3<T: Scalar>(ptr: &[T]) -> TMat3<T> {
     TMat3::from_column_slice(ptr)
 }
 
 /// Creates a 3x4 matrix from a slice arranged in column-major order.
-pub fn make_mat3x4<N: Scalar>(ptr: &[N]) -> TMat3x4<N> {
+pub fn make_mat3x4<T: Scalar>(ptr: &[T]) -> TMat3x4<T> {
     TMat3x4::from_column_slice(ptr)
 }
 
 /// Creates a 4x4 matrix from a slice arranged in column-major order.
-pub fn make_mat4<N: Scalar>(ptr: &[N]) -> TMat4<N> {
+pub fn make_mat4<T: Scalar>(ptr: &[T]) -> TMat4<T> {
     TMat4::from_column_slice(ptr)
 }
 
 /// Creates a 4x2 matrix from a slice arranged in column-major order.
-pub fn make_mat4x2<N: Scalar>(ptr: &[N]) -> TMat4x2<N> {
+pub fn make_mat4x2<T: Scalar>(ptr: &[T]) -> TMat4x2<T> {
     TMat4x2::from_column_slice(ptr)
 }
 
 /// Creates a 4x3 matrix from a slice arranged in column-major order.
-pub fn make_mat4x3<N: Scalar>(ptr: &[N]) -> TMat4x3<N> {
+pub fn make_mat4x3<T: Scalar>(ptr: &[T]) -> TMat4x3<T> {
     TMat4x3::from_column_slice(ptr)
 }
 
 /// Creates a 4x4 matrix from a slice arranged in column-major order.
-pub fn make_mat4x4<N: Scalar>(ptr: &[N]) -> TMat4<N> {
+pub fn make_mat4x4<T: Scalar>(ptr: &[T]) -> TMat4<T> {
     TMat4::from_column_slice(ptr)
 }
 
 /// Converts a 2x2 matrix to a 3x3 matrix.
-pub fn mat2_to_mat3<N: Number>(m: &TMat2<N>) -> TMat3<N> {
-    let _0 = N::zero();
-    let _1 = N::one();
+pub fn mat2_to_mat3<T: Number>(m: &TMat2<T>) -> TMat3<T> {
+    let _0 = T::zero();
+    let _1 = T::one();
 
     TMat3::new(m.m11, m.m12, _0, m.m21, m.m22, _0, _0, _0, _1)
 }
 
 /// Converts a 3x3 matrix to a 2x2 matrix.
-pub fn mat3_to_mat2<N: Scalar>(m: &TMat3<N>) -> TMat2<N> {
+pub fn mat3_to_mat2<T: Scalar>(m: &TMat3<T>) -> TMat2<T> {
     TMat2::new(
         m.m11.inlined_clone(),
         m.m12.inlined_clone(),
@@ -85,9 +85,9 @@ pub fn mat3_to_mat2<N: Scalar>(m: &TMat3<N>) -> TMat2<N> {
 }
 
 /// Converts a 3x3 matrix to a 4x4 matrix.
-pub fn mat3_to_mat4<N: Number>(m: &TMat3<N>) -> TMat4<N> {
-    let _0 = N::zero();
-    let _1 = N::one();
+pub fn mat3_to_mat4<T: Number>(m: &TMat3<T>) -> TMat4<T> {
+    let _0 = T::zero();
+    let _1 = T::one();
 
     TMat4::new(
         m.m11, m.m12, m.m13, _0, m.m21, m.m22, m.m23, _0, m.m31, m.m32, m.m33, _0, _0, _0, _0, _1,
@@ -95,7 +95,7 @@ pub fn mat3_to_mat4<N: Number>(m: &TMat3<N>) -> TMat4<N> {
 }
 
 /// Converts a 4x4 matrix to a 3x3 matrix.
-pub fn mat4_to_mat3<N: Scalar>(m: &TMat4<N>) -> TMat3<N> {
+pub fn mat4_to_mat3<T: Scalar>(m: &TMat4<T>) -> TMat3<T> {
     TMat3::new(
         m.m11.inlined_clone(),
         m.m12.inlined_clone(),
@@ -110,9 +110,9 @@ pub fn mat4_to_mat3<N: Scalar>(m: &TMat4<N>) -> TMat3<N> {
 }
 
 /// Converts a 2x2 matrix to a 4x4 matrix.
-pub fn mat2_to_mat4<N: Number>(m: &TMat2<N>) -> TMat4<N> {
-    let _0 = N::zero();
-    let _1 = N::one();
+pub fn mat2_to_mat4<T: Number>(m: &TMat2<T>) -> TMat4<T> {
+    let _0 = T::zero();
+    let _1 = T::one();
 
     TMat4::new(
         m.m11, m.m12, _0, _0, m.m21, m.m22, _0, _0, _0, _0, _1, _0, _0, _0, _0, _1,
@@ -120,7 +120,7 @@ pub fn mat2_to_mat4<N: Number>(m: &TMat2<N>) -> TMat4<N> {
 }
 
 /// Converts a 4x4 matrix to a 2x2 matrix.
-pub fn mat4_to_mat2<N: Scalar>(m: &TMat4<N>) -> TMat2<N> {
+pub fn mat4_to_mat2<T: Scalar>(m: &TMat4<T>) -> TMat2<T> {
     TMat2::new(
         m.m11.inlined_clone(),
         m.m12.inlined_clone(),
@@ -130,7 +130,7 @@ pub fn mat4_to_mat2<N: Scalar>(m: &TMat4<N>) -> TMat2<N> {
 }
 
 /// Creates a quaternion from a slice arranged as `[x, y, z, w]`.
-pub fn make_quat<N: RealField>(ptr: &[N]) -> Qua<N> {
+pub fn make_quat<T: RealField>(ptr: &[T]) -> Qua<T> {
     Quaternion::from(TVec4::from_column_slice(ptr))
 }
 
@@ -141,7 +141,7 @@ pub fn make_quat<N: RealField>(ptr: &[N]) -> Qua<N> {
 /// * [`make_vec2`](fn.make_vec2.html)
 /// * [`make_vec3`](fn.make_vec3.html)
 /// * [`make_vec4`](fn.make_vec4.html)
-pub fn make_vec1<N: Scalar>(v: &TVec1<N>) -> TVec1<N> {
+pub fn make_vec1<T: Scalar>(v: &TVec1<T>) -> TVec1<T> {
     v.clone()
 }
 
@@ -155,7 +155,7 @@ pub fn make_vec1<N: Scalar>(v: &TVec1<N>) -> TVec1<N> {
 /// * [`vec1_to_vec2`](fn.vec1_to_vec2.html)
 /// * [`vec1_to_vec3`](fn.vec1_to_vec3.html)
 /// * [`vec1_to_vec4`](fn.vec1_to_vec4.html)
-pub fn vec2_to_vec1<N: Scalar>(v: &TVec2<N>) -> TVec1<N> {
+pub fn vec2_to_vec1<T: Scalar>(v: &TVec2<T>) -> TVec1<T> {
     TVec1::new(v.x.inlined_clone())
 }
 
@@ -169,7 +169,7 @@ pub fn vec2_to_vec1<N: Scalar>(v: &TVec2<N>) -> TVec1<N> {
 /// * [`vec1_to_vec2`](fn.vec1_to_vec2.html)
 /// * [`vec1_to_vec3`](fn.vec1_to_vec3.html)
 /// * [`vec1_to_vec4`](fn.vec1_to_vec4.html)
-pub fn vec3_to_vec1<N: Scalar>(v: &TVec3<N>) -> TVec1<N> {
+pub fn vec3_to_vec1<T: Scalar>(v: &TVec3<T>) -> TVec1<T> {
     TVec1::new(v.x.inlined_clone())
 }
 
@@ -183,7 +183,7 @@ pub fn vec3_to_vec1<N: Scalar>(v: &TVec3<N>) -> TVec1<N> {
 /// * [`vec1_to_vec2`](fn.vec1_to_vec2.html)
 /// * [`vec1_to_vec3`](fn.vec1_to_vec3.html)
 /// * [`vec1_to_vec4`](fn.vec1_to_vec4.html)
-pub fn vec4_to_vec1<N: Scalar>(v: &TVec4<N>) -> TVec1<N> {
+pub fn vec4_to_vec1<T: Scalar>(v: &TVec4<T>) -> TVec1<T> {
     TVec1::new(v.x.inlined_clone())
 }
 
@@ -199,8 +199,8 @@ pub fn vec4_to_vec1<N: Scalar>(v: &TVec4<N>) -> TVec1<N> {
 /// * [`vec2_to_vec2`](fn.vec2_to_vec2.html)
 /// * [`vec2_to_vec3`](fn.vec2_to_vec3.html)
 /// * [`vec2_to_vec4`](fn.vec2_to_vec4.html)
-pub fn vec1_to_vec2<N: Number>(v: &TVec1<N>) -> TVec2<N> {
-    TVec2::new(v.x.inlined_clone(), N::zero())
+pub fn vec1_to_vec2<T: Number>(v: &TVec1<T>) -> TVec2<T> {
+    TVec2::new(v.x.inlined_clone(), T::zero())
 }
 
 /// Creates a 2D vector from another vector.
@@ -214,7 +214,7 @@ pub fn vec1_to_vec2<N: Number>(v: &TVec1<N>) -> TVec2<N> {
 /// * [`vec2_to_vec2`](fn.vec2_to_vec2.html)
 /// * [`vec2_to_vec3`](fn.vec2_to_vec3.html)
 /// * [`vec2_to_vec4`](fn.vec2_to_vec4.html)
-pub fn vec2_to_vec2<N: Scalar>(v: &TVec2<N>) -> TVec2<N> {
+pub fn vec2_to_vec2<T: Scalar>(v: &TVec2<T>) -> TVec2<T> {
     v.clone()
 }
 
@@ -228,7 +228,7 @@ pub fn vec2_to_vec2<N: Scalar>(v: &TVec2<N>) -> TVec2<N> {
 /// * [`vec2_to_vec2`](fn.vec2_to_vec2.html)
 /// * [`vec2_to_vec3`](fn.vec2_to_vec3.html)
 /// * [`vec2_to_vec4`](fn.vec2_to_vec4.html)
-pub fn vec3_to_vec2<N: Scalar>(v: &TVec3<N>) -> TVec2<N> {
+pub fn vec3_to_vec2<T: Scalar>(v: &TVec3<T>) -> TVec2<T> {
     TVec2::new(v.x.inlined_clone(), v.y.inlined_clone())
 }
 
@@ -242,7 +242,7 @@ pub fn vec3_to_vec2<N: Scalar>(v: &TVec3<N>) -> TVec2<N> {
 /// * [`vec2_to_vec2`](fn.vec2_to_vec2.html)
 /// * [`vec2_to_vec3`](fn.vec2_to_vec3.html)
 /// * [`vec2_to_vec4`](fn.vec2_to_vec4.html)
-pub fn vec4_to_vec2<N: Scalar>(v: &TVec4<N>) -> TVec2<N> {
+pub fn vec4_to_vec2<T: Scalar>(v: &TVec4<T>) -> TVec2<T> {
     TVec2::new(v.x.inlined_clone(), v.y.inlined_clone())
 }
 
@@ -253,7 +253,7 @@ pub fn vec4_to_vec2<N: Scalar>(v: &TVec4<N>) -> TVec2<N> {
 /// * [`make_vec1`](fn.make_vec1.html)
 /// * [`make_vec3`](fn.make_vec3.html)
 /// * [`make_vec4`](fn.make_vec4.html)
-pub fn make_vec2<N: Scalar>(ptr: &[N]) -> TVec2<N> {
+pub fn make_vec2<T: Scalar>(ptr: &[T]) -> TVec2<T> {
     TVec2::from_column_slice(ptr)
 }
 
@@ -268,8 +268,8 @@ pub fn make_vec2<N: Scalar>(ptr: &[N]) -> TVec2<N> {
 /// * [`vec4_to_vec3`](fn.vec4_to_vec3.html)
 /// * [`vec1_to_vec2`](fn.vec1_to_vec2.html)
 /// * [`vec1_to_vec4`](fn.vec1_to_vec4.html)
-pub fn vec1_to_vec3<N: Number>(v: &TVec1<N>) -> TVec3<N> {
-    TVec3::new(v.x.inlined_clone(), N::zero(), N::zero())
+pub fn vec1_to_vec3<T: Number>(v: &TVec1<T>) -> TVec3<T> {
+    TVec3::new(v.x.inlined_clone(), T::zero(), T::zero())
 }
 
 /// Creates a 3D vector from another vector.
@@ -284,8 +284,8 @@ pub fn vec1_to_vec3<N: Number>(v: &TVec1<N>) -> TVec3<N> {
 /// * [`vec3_to_vec1`](fn.vec3_to_vec1.html)
 /// * [`vec3_to_vec2`](fn.vec3_to_vec2.html)
 /// * [`vec3_to_vec4`](fn.vec3_to_vec4.html)
-pub fn vec2_to_vec3<N: Number>(v: &TVec2<N>) -> TVec3<N> {
-    TVec3::new(v.x.inlined_clone(), v.y.inlined_clone(), N::zero())
+pub fn vec2_to_vec3<T: Number>(v: &TVec2<T>) -> TVec3<T> {
+    TVec3::new(v.x.inlined_clone(), v.y.inlined_clone(), T::zero())
 }
 
 /// Creates a 3D vector from another vector.
@@ -298,7 +298,7 @@ pub fn vec2_to_vec3<N: Number>(v: &TVec2<N>) -> TVec3<N> {
 /// * [`vec3_to_vec1`](fn.vec3_to_vec1.html)
 /// * [`vec3_to_vec2`](fn.vec3_to_vec2.html)
 /// * [`vec3_to_vec4`](fn.vec3_to_vec4.html)
-pub fn vec3_to_vec3<N: Scalar>(v: &TVec3<N>) -> TVec3<N> {
+pub fn vec3_to_vec3<T: Scalar>(v: &TVec3<T>) -> TVec3<T> {
     v.clone()
 }
 
@@ -312,7 +312,7 @@ pub fn vec3_to_vec3<N: Scalar>(v: &TVec3<N>) -> TVec3<N> {
 /// * [`vec3_to_vec1`](fn.vec3_to_vec1.html)
 /// * [`vec3_to_vec2`](fn.vec3_to_vec2.html)
 /// * [`vec3_to_vec4`](fn.vec3_to_vec4.html)
-pub fn vec4_to_vec3<N: Scalar>(v: &TVec4<N>) -> TVec3<N> {
+pub fn vec4_to_vec3<T: Scalar>(v: &TVec4<T>) -> TVec3<T> {
     TVec3::new(
         v.x.inlined_clone(),
         v.y.inlined_clone(),
@@ -327,7 +327,7 @@ pub fn vec4_to_vec3<N: Scalar>(v: &TVec4<N>) -> TVec3<N> {
 /// * [`make_vec1`](fn.make_vec1.html)
 /// * [`make_vec2`](fn.make_vec2.html)
 /// * [`make_vec4`](fn.make_vec4.html)
-pub fn make_vec3<N: Scalar>(ptr: &[N]) -> TVec3<N> {
+pub fn make_vec3<T: Scalar>(ptr: &[T]) -> TVec3<T> {
     TVec3::from_column_slice(ptr)
 }
 
@@ -343,8 +343,8 @@ pub fn make_vec3<N: Scalar>(ptr: &[N]) -> TVec3<N> {
 /// * [`vec1_to_vec2`](fn.vec1_to_vec2.html)
 /// * [`vec1_to_vec3`](fn.vec1_to_vec3.html)
 /// * [`vec1_to_vec4`](fn.vec1_to_vec4.html)
-pub fn vec1_to_vec4<N: Number>(v: &TVec1<N>) -> TVec4<N> {
-    TVec4::new(v.x, N::zero(), N::zero(), N::zero())
+pub fn vec1_to_vec4<T: Number>(v: &TVec1<T>) -> TVec4<T> {
+    TVec4::new(v.x, T::zero(), T::zero(), T::zero())
 }
 
 /// Creates a 4D vector from another vector.
@@ -359,8 +359,8 @@ pub fn vec1_to_vec4<N: Number>(v: &TVec1<N>) -> TVec4<N> {
 /// * [`vec2_to_vec1`](fn.vec2_to_vec1.html)
 /// * [`vec2_to_vec2`](fn.vec2_to_vec2.html)
 /// * [`vec2_to_vec3`](fn.vec2_to_vec3.html)
-pub fn vec2_to_vec4<N: Number>(v: &TVec2<N>) -> TVec4<N> {
-    TVec4::new(v.x, v.y, N::zero(), N::zero())
+pub fn vec2_to_vec4<T: Number>(v: &TVec2<T>) -> TVec4<T> {
+    TVec4::new(v.x, v.y, T::zero(), T::zero())
 }
 
 /// Creates a 4D vector from another vector.
@@ -375,8 +375,8 @@ pub fn vec2_to_vec4<N: Number>(v: &TVec2<N>) -> TVec4<N> {
 /// * [`vec3_to_vec1`](fn.vec3_to_vec1.html)
 /// * [`vec3_to_vec2`](fn.vec3_to_vec2.html)
 /// * [`vec3_to_vec3`](fn.vec3_to_vec3.html)
-pub fn vec3_to_vec4<N: Number>(v: &TVec3<N>) -> TVec4<N> {
-    TVec4::new(v.x, v.y, v.z, N::zero())
+pub fn vec3_to_vec4<T: Number>(v: &TVec3<T>) -> TVec4<T> {
+    TVec4::new(v.x, v.y, v.z, T::zero())
 }
 
 /// Creates a 4D vector from another vector.
@@ -389,7 +389,7 @@ pub fn vec3_to_vec4<N: Number>(v: &TVec3<N>) -> TVec4<N> {
 /// * [`vec4_to_vec1`](fn.vec4_to_vec1.html)
 /// * [`vec4_to_vec2`](fn.vec4_to_vec2.html)
 /// * [`vec4_to_vec3`](fn.vec4_to_vec3.html)
-pub fn vec4_to_vec4<N: Scalar>(v: &TVec4<N>) -> TVec4<N> {
+pub fn vec4_to_vec4<T: Scalar>(v: &TVec4<T>) -> TVec4<T> {
     v.clone()
 }
 
@@ -400,22 +400,16 @@ pub fn vec4_to_vec4<N: Scalar>(v: &TVec4<N>) -> TVec4<N> {
 /// * [`make_vec1`](fn.make_vec1.html)
 /// * [`make_vec2`](fn.make_vec2.html)
 /// * [`make_vec3`](fn.make_vec3.html)
-pub fn make_vec4<N: Scalar>(ptr: &[N]) -> TVec4<N> {
+pub fn make_vec4<T: Scalar>(ptr: &[T]) -> TVec4<T> {
     TVec4::from_column_slice(ptr)
 }
 
 /// Converts a matrix or vector to a slice arranged in column-major order.
-pub fn value_ptr<N: Scalar, R: Dimension, C: Dimension>(x: &TMat<N, R, C>) -> &[N]
-where
-    DefaultAllocator: Alloc<N, R, C>,
-{
+pub fn value_ptr<T: Scalar, const R: usize, const C: usize>(x: &TMat<T, R, C>) -> &[T] {
     x.as_slice()
 }
 
 /// Converts a matrix or vector to a mutable slice arranged in column-major order.
-pub fn value_ptr_mut<N: Scalar, R: Dimension, C: Dimension>(x: &mut TMat<N, R, C>) -> &mut [N]
-where
-    DefaultAllocator: Alloc<N, R, C>,
-{
+pub fn value_ptr_mut<T: Scalar, const R: usize, const C: usize>(x: &mut TMat<T, R, C>) -> &mut [T] {
     x.as_mut_slice()
 }
diff --git a/nalgebra-glm/src/gtc/ulp.rs b/nalgebra-glm/src/gtc/ulp.rs
index 8258d0df..4ab93826 100644
--- a/nalgebra-glm/src/gtc/ulp.rs
+++ b/nalgebra-glm/src/gtc/ulp.rs
@@ -2,12 +2,11 @@ use na::{Scalar, U2};
 
 use crate::aliases::TVec;
 
-
 pub fn float_distance<T>(x: T, y: T) -> u64 {
     unimplemented!()
 }
 
-pub fn float_distance2<N: Scalar>(x: &TVec2<N>, y: &TVec2<N>) -> TVec<u64, U2> {
+pub fn float_distance2<T: Scalar>(x: &TVec2<T>, y: &TVec2<T>) -> TVec<u64, U2> {
     unimplemented!()
 }
 
diff --git a/nalgebra-glm/src/gtx/component_wise.rs b/nalgebra-glm/src/gtx/component_wise.rs
index cfb851f4..85d0dd71 100644
--- a/nalgebra-glm/src/gtx/component_wise.rs
+++ b/nalgebra-glm/src/gtx/component_wise.rs
@@ -1,7 +1,5 @@
-use na::{self, DefaultAllocator};
-
 use crate::aliases::TMat;
-use crate::traits::{Alloc, Dimension, Number};
+use crate::traits::Number;
 
 /// The sum of every component of the given matrix or vector.
 ///
@@ -21,11 +19,8 @@ use crate::traits::{Alloc, Dimension, Number};
 /// * [`comp_max`](fn.comp_max.html)
 /// * [`comp_min`](fn.comp_min.html)
 /// * [`comp_mul`](fn.comp_mul.html)
-pub fn comp_add<N: Number, R: Dimension, C: Dimension>(m: &TMat<N, R, C>) -> N
-where
-    DefaultAllocator: Alloc<N, R, C>,
-{
-    m.iter().fold(N::zero(), |x, y| x + *y)
+pub fn comp_add<T: Number, const R: usize, const C: usize>(m: &TMat<T, R, C>) -> T {
+    m.iter().fold(T::zero(), |x, y| x + *y)
 }
 
 /// The maximum of every component of the given matrix or vector.
@@ -50,12 +45,9 @@ where
 /// * [`max2`](fn.max2.html)
 /// * [`max3`](fn.max3.html)
 /// * [`max4`](fn.max4.html)
-pub fn comp_max<N: Number, R: Dimension, C: Dimension>(m: &TMat<N, R, C>) -> N
-where
-    DefaultAllocator: Alloc<N, R, C>,
-{
+pub fn comp_max<T: Number, const R: usize, const C: usize>(m: &TMat<T, R, C>) -> T {
     m.iter()
-        .fold(N::min_value(), |x, y| crate::max2_scalar(x, *y))
+        .fold(T::min_value(), |x, y| crate::max2_scalar(x, *y))
 }
 
 /// The minimum of every component of the given matrix or vector.
@@ -80,12 +72,9 @@ where
 /// * [`min2`](fn.min2.html)
 /// * [`min3`](fn.min3.html)
 /// * [`min4`](fn.min4.html)
-pub fn comp_min<N: Number, R: Dimension, C: Dimension>(m: &TMat<N, R, C>) -> N
-where
-    DefaultAllocator: Alloc<N, R, C>,
-{
+pub fn comp_min<T: Number, const R: usize, const C: usize>(m: &TMat<T, R, C>) -> T {
     m.iter()
-        .fold(N::max_value(), |x, y| crate::min2_scalar(x, *y))
+        .fold(T::max_value(), |x, y| crate::min2_scalar(x, *y))
 }
 
 /// The product of every component of the given matrix or vector.
@@ -106,11 +95,8 @@ where
 /// * [`comp_add`](fn.comp_add.html)
 /// * [`comp_max`](fn.comp_max.html)
 /// * [`comp_min`](fn.comp_min.html)
-pub fn comp_mul<N: Number, R: Dimension, C: Dimension>(m: &TMat<N, R, C>) -> N
-where
-    DefaultAllocator: Alloc<N, R, C>,
-{
-    m.iter().fold(N::one(), |x, y| x * *y)
+pub fn comp_mul<T: Number, const R: usize, const C: usize>(m: &TMat<T, R, C>) -> T {
+    m.iter().fold(T::one(), |x, y| x * *y)
 }
 
 //pub fn vec< L, floatType, Q > compNormalize (vec< L, T, Q > const &v)
diff --git a/nalgebra-glm/src/gtx/euler_angles.rs b/nalgebra-glm/src/gtx/euler_angles.rs
index c9d16738..4dc9f9d1 100644
--- a/nalgebra-glm/src/gtx/euler_angles.rs
+++ b/nalgebra-glm/src/gtx/euler_angles.rs
@@ -1,163 +1,163 @@
 use na::{RealField, U3, U4};
 
-use crate::aliases::{TVec, TMat};
+use crate::aliases::{TMat, TVec};
 
-pub fn derivedEulerAngleX<N: RealField>(angleX: N, angularVelocityX: N) -> TMat4<N> {
+pub fn derivedEulerAngleX<T: RealField>(angleX: T, angularVelocityX: T) -> TMat4<T> {
     unimplemented!()
 }
 
-pub fn derivedEulerAngleY<N: RealField>(angleY: N, angularVelocityY: N) -> TMat4<N> {
+pub fn derivedEulerAngleY<T: RealField>(angleY: T, angularVelocityY: T) -> TMat4<T> {
     unimplemented!()
 }
 
-pub fn derivedEulerAngleZ<N: RealField>(angleZ: N, angularVelocityZ: N) -> TMat4<N> {
+pub fn derivedEulerAngleZ<T: RealField>(angleZ: T, angularVelocityZ: T) -> TMat4<T> {
     unimplemented!()
 }
 
-pub fn eulerAngleX<N: RealField>(angleX: N) -> TMat4<N> {
+pub fn eulerAngleX<T: RealField>(angleX: T) -> TMat4<T> {
     unimplemented!()
 }
 
-pub fn eulerAngleXY<N: RealField>(angleX: N, angleY: N) -> TMat4<N> {
+pub fn eulerAngleXY<T: RealField>(angleX: T, angleY: T) -> TMat4<T> {
     unimplemented!()
 }
 
-pub fn eulerAngleXYX<N: RealField>(t1: N, t2: N, t3: N) -> TMat4<N> {
+pub fn eulerAngleXYX<T: RealField>(t1: T, t2: T, t3: T) -> TMat4<T> {
     unimplemented!()
 }
 
-pub fn eulerAngleXYZ<N: RealField>(t1: N, t2: N, t3: N) -> TMat4<N> {
+pub fn eulerAngleXYZ<T: RealField>(t1: T, t2: T, t3: T) -> TMat4<T> {
     unimplemented!()
 }
 
-pub fn eulerAngleXZ<N: RealField>(angleX: N, angleZ: N) -> TMat4<N> {
+pub fn eulerAngleXZ<T: RealField>(angleX: T, angleZ: T) -> TMat4<T> {
     unimplemented!()
 }
 
-pub fn eulerAngleXZX<N: RealField>(t1: N, t2: N, t3: N) -> TMat4<N> {
+pub fn eulerAngleXZX<T: RealField>(t1: T, t2: T, t3: T) -> TMat4<T> {
     unimplemented!()
 }
 
-pub fn eulerAngleXZY<N: RealField>(t1: N, t2: N, t3: N) -> TMat4<N> {
+pub fn eulerAngleXZY<T: RealField>(t1: T, t2: T, t3: T) -> TMat4<T> {
     unimplemented!()
 }
 
-pub fn eulerAngleY<N: RealField>(angleY: N) -> TMat4<N> {
+pub fn eulerAngleY<T: RealField>(angleY: T) -> TMat4<T> {
     unimplemented!()
 }
 
-pub fn eulerAngleYX<N: RealField>(angleY: N, angleX: N) -> TMat4<N> {
+pub fn eulerAngleYX<T: RealField>(angleY: T, angleX: T) -> TMat4<T> {
     unimplemented!()
 }
 
-pub fn eulerAngleYXY<N: RealField>(t1: N, t2: N, t3: N) -> TMat4<N> {
+pub fn eulerAngleYXY<T: RealField>(t1: T, t2: T, t3: T) -> TMat4<T> {
     unimplemented!()
 }
 
-pub fn eulerAngleYXZ<N: RealField>(yaw: N, pitch: N, roll: N) -> TMat4<N> {
+pub fn eulerAngleYXZ<T: RealField>(yaw: T, pitch: T, roll: T) -> TMat4<T> {
     unimplemented!()
 }
 
-pub fn eulerAngleYZ<N: RealField>(angleY: N, angleZ: N) -> TMat4<N> {
+pub fn eulerAngleYZ<T: RealField>(angleY: T, angleZ: T) -> TMat4<T> {
     unimplemented!()
 }
 
-pub fn eulerAngleYZX<N: RealField>(t1: N, t2: N, t3: N) -> TMat4<N> {
+pub fn eulerAngleYZX<T: RealField>(t1: T, t2: T, t3: T) -> TMat4<T> {
     unimplemented!()
 }
 
-pub fn eulerAngleYZY<N: RealField>(t1: N, t2: N, t3: N) -> TMat4<N> {
+pub fn eulerAngleYZY<T: RealField>(t1: T, t2: T, t3: T) -> TMat4<T> {
     unimplemented!()
 }
 
-pub fn eulerAngleZ<N: RealField>(angleZ: N) -> TMat4<N> {
+pub fn eulerAngleZ<T: RealField>(angleZ: T) -> TMat4<T> {
     unimplemented!()
 }
 
-pub fn eulerAngleZX<N: RealField>(angle: N, angleX: N) -> TMat4<N> {
+pub fn eulerAngleZX<T: RealField>(angle: T, angleX: T) -> TMat4<T> {
     unimplemented!()
 }
 
-pub fn eulerAngleZXY<N: RealField>(t1: N, t2: N, t3: N) -> TMat4<N> {
+pub fn eulerAngleZXY<T: RealField>(t1: T, t2: T, t3: T) -> TMat4<T> {
     unimplemented!()
 }
 
-pub fn eulerAngleZXZ<N: RealField>(t1: N, t2: N, t3: N) -> TMat4<N> {
+pub fn eulerAngleZXZ<T: RealField>(t1: T, t2: T, t3: T) -> TMat4<T> {
     unimplemented!()
 }
 
-pub fn eulerAngleZY<N: RealField>(angleZ: N, angleY: N) -> TMat4<N> {
+pub fn eulerAngleZY<T: RealField>(angleZ: T, angleY: T) -> TMat4<T> {
     unimplemented!()
 }
 
-pub fn eulerAngleZYX<N: RealField>(t1: N, t2: N, t3: N) -> TMat4<N> {
+pub fn eulerAngleZYX<T: RealField>(t1: T, t2: T, t3: T) -> TMat4<T> {
     unimplemented!()
 }
 
-pub fn eulerAngleZYZ<N: RealField>(t1: N, t2: N, t3: N) -> TMat4<N> {
+pub fn eulerAngleZYZ<T: RealField>(t1: T, t2: T, t3: T) -> TMat4<T> {
     unimplemented!()
 }
 
-pub fn extractEulerAngleXYX<N: RealField>(M: &TMat4<N>) -> (N, N, N) {
+pub fn extractEulerAngleXYX<T: RealField>(M: &TMat4<T>) -> (T, T, T) {
     unimplemented!()
 }
 
-pub fn extractEulerAngleXYZ<N: RealField>(M: &TMat4<N>) -> (N, N, N) {
+pub fn extractEulerAngleXYZ<T: RealField>(M: &TMat4<T>) -> (T, T, T) {
     unimplemented!()
 }
 
-pub fn extractEulerAngleXZX<N: RealField>(M: &TMat4<N>) -> (N, N, N) {
+pub fn extractEulerAngleXZX<T: RealField>(M: &TMat4<T>) -> (T, T, T) {
     unimplemented!()
 }
 
-pub fn extractEulerAngleXZY<N: RealField>(M: &TMat4<N>) -> (N, N, N) {
+pub fn extractEulerAngleXZY<T: RealField>(M: &TMat4<T>) -> (T, T, T) {
     unimplemented!()
 }
 
-pub fn extractEulerAngleYXY<N: RealField>(M: &TMat4<N>) -> (N, N, N) {
+pub fn extractEulerAngleYXY<T: RealField>(M: &TMat4<T>) -> (T, T, T) {
     unimplemented!()
 }
 
-pub fn extractEulerAngleYXZ<N: RealField>(M: &TMat4<N>) -> (N, N, N) {
+pub fn extractEulerAngleYXZ<T: RealField>(M: &TMat4<T>) -> (T, T, T) {
     unimplemented!()
 }
 
-pub fn extractEulerAngleYZX<N: RealField>(M: &TMat4<N>) -> (N, N, N) {
+pub fn extractEulerAngleYZX<T: RealField>(M: &TMat4<T>) -> (T, T, T) {
     unimplemented!()
 }
 
-pub fn extractEulerAngleYZY<N: RealField>(M: &TMat4<N>) -> (N, N, N) {
+pub fn extractEulerAngleYZY<T: RealField>(M: &TMat4<T>) -> (T, T, T) {
     unimplemented!()
 }
 
-pub fn extractEulerAngleZXY<N: RealField>(M: &TMat4<N>) -> (N, N, N) {
+pub fn extractEulerAngleZXY<T: RealField>(M: &TMat4<T>) -> (T, T, T) {
     unimplemented!()
 }
 
-pub fn extractEulerAngleZXZ<N: RealField>(M: &TMat4<N>) -> (N, N, N) {
+pub fn extractEulerAngleZXZ<T: RealField>(M: &TMat4<T>) -> (T, T, T) {
     unimplemented!()
 }
 
-pub fn extractEulerAngleZYX<N: RealField>(M: &TMat4<N>) -> (N, N, N) {
+pub fn extractEulerAngleZYX<T: RealField>(M: &TMat4<T>) -> (T, T, T) {
     unimplemented!()
 }
 
-pub fn extractEulerAngleZYZ<N: RealField>(M: &TMat4<N>) -> (N, N, N) {
+pub fn extractEulerAngleZYZ<T: RealField>(M: &TMat4<T>) -> (T, T, T) {
     unimplemented!()
 }
 
-pub fn orientate2<N: RealField>(angle: N) -> TMat3x3<N> {
+pub fn orientate2<T: RealField>(angle: T) -> TMat3x3<T> {
     unimplemented!()
 }
 
-pub fn orientate3<N: RealField>(angles: TVec3<N>) -> TMat3x3<N> {
+pub fn orientate3<T: RealField>(angles: TVec3<T>) -> TMat3x3<T> {
     unimplemented!()
 }
 
-pub fn orientate4<N: RealField>(angles: TVec3<N>) -> TMat4<N> {
+pub fn orientate4<T: RealField>(angles: TVec3<T>) -> TMat4<T> {
     unimplemented!()
 }
 
-pub fn yawPitchRoll<N: RealField>(yaw: N, pitch: N, roll: N) -> TMat4<N> {
+pub fn yawPitchRoll<T: RealField>(yaw: T, pitch: T, roll: T) -> TMat4<T> {
     unimplemented!()
 }
diff --git a/nalgebra-glm/src/gtx/exterior_product.rs b/nalgebra-glm/src/gtx/exterior_product.rs
index a95c557b..15e9f998 100644
--- a/nalgebra-glm/src/gtx/exterior_product.rs
+++ b/nalgebra-glm/src/gtx/exterior_product.rs
@@ -2,6 +2,6 @@ use crate::aliases::TVec2;
 use crate::traits::Number;
 
 /// The 2D perpendicular product between two vectors.
-pub fn cross2d<N: Number>(v: &TVec2<N>, u: &TVec2<N>) -> N {
+pub fn cross2d<T: Number>(v: &TVec2<T>, u: &TVec2<T>) -> T {
     v.perp(u)
 }
diff --git a/nalgebra-glm/src/gtx/handed_coordinate_space.rs b/nalgebra-glm/src/gtx/handed_coordinate_space.rs
index 22d25056..1063db5e 100644
--- a/nalgebra-glm/src/gtx/handed_coordinate_space.rs
+++ b/nalgebra-glm/src/gtx/handed_coordinate_space.rs
@@ -6,8 +6,8 @@ use crate::traits::Number;
 /// # See also:
 ///
 /// * [`right_handed`](fn.right_handed.html)
-pub fn left_handed<N: Number>(a: &TVec3<N>, b: &TVec3<N>, c: &TVec3<N>) -> bool {
-    a.cross(b).dot(c) < N::zero()
+pub fn left_handed<T: Number>(a: &TVec3<T>, b: &TVec3<T>, c: &TVec3<T>) -> bool {
+    a.cross(b).dot(c) < T::zero()
 }
 
 /// Returns `true` if `{a, b, c}` forms a right-handed trihedron.
@@ -15,6 +15,6 @@ pub fn left_handed<N: Number>(a: &TVec3<N>, b: &TVec3<N>, c: &TVec3<N>) -> bool
 /// # See also:
 ///
 /// * [`left_handed`](fn.left_handed.html)
-pub fn right_handed<N: Number>(a: &TVec3<N>, b: &TVec3<N>, c: &TVec3<N>) -> bool {
-    a.cross(b).dot(c) > N::zero()
+pub fn right_handed<T: Number>(a: &TVec3<T>, b: &TVec3<T>, c: &TVec3<T>) -> bool {
+    a.cross(b).dot(c) > T::zero()
 }
diff --git a/nalgebra-glm/src/gtx/matrix_cross_product.rs b/nalgebra-glm/src/gtx/matrix_cross_product.rs
index 40aa03e8..83ac881e 100644
--- a/nalgebra-glm/src/gtx/matrix_cross_product.rs
+++ b/nalgebra-glm/src/gtx/matrix_cross_product.rs
@@ -7,7 +7,7 @@ use crate::aliases::{TMat3, TMat4, TVec3};
 /// # See also:
 ///
 /// * [`matrix_cross`](fn.matrix_cross.html)
-pub fn matrix_cross3<N: RealField>(x: &TVec3<N>) -> TMat3<N> {
+pub fn matrix_cross3<T: RealField>(x: &TVec3<T>) -> TMat3<T> {
     x.cross_matrix()
 }
 
@@ -16,6 +16,6 @@ pub fn matrix_cross3<N: RealField>(x: &TVec3<N>) -> TMat3<N> {
 /// # See also:
 ///
 /// * [`matrix_cross3`](fn.matrix_cross3.html)
-pub fn matrix_cross<N: RealField>(x: &TVec3<N>) -> TMat4<N> {
+pub fn matrix_cross<T: RealField>(x: &TVec3<T>) -> TMat4<T> {
     crate::mat3_to_mat4(&x.cross_matrix())
 }
diff --git a/nalgebra-glm/src/gtx/matrix_operation.rs b/nalgebra-glm/src/gtx/matrix_operation.rs
index cc051273..a46a9a5c 100644
--- a/nalgebra-glm/src/gtx/matrix_operation.rs
+++ b/nalgebra-glm/src/gtx/matrix_operation.rs
@@ -15,7 +15,7 @@ use crate::traits::Number;
 /// * [`diagonal4x2`](fn.diagonal4x2.html)
 /// * [`diagonal4x3`](fn.diagonal4x3.html)
 /// * [`diagonal4x4`](fn.diagonal4x4.html)
-pub fn diagonal2x2<N: Number>(v: &TVec2<N>) -> TMat2<N> {
+pub fn diagonal2x2<T: Number>(v: &TVec2<T>) -> TMat2<T> {
     TMat2::from_diagonal(v)
 }
 
@@ -31,7 +31,7 @@ pub fn diagonal2x2<N: Number>(v: &TVec2<N>) -> TMat2<N> {
 /// * [`diagonal4x2`](fn.diagonal4x2.html)
 /// * [`diagonal4x3`](fn.diagonal4x3.html)
 /// * [`diagonal4x4`](fn.diagonal4x4.html)
-pub fn diagonal2x3<N: Number>(v: &TVec2<N>) -> TMat2x3<N> {
+pub fn diagonal2x3<T: Number>(v: &TVec2<T>) -> TMat2x3<T> {
     TMat2x3::from_partial_diagonal(v.as_slice())
 }
 
@@ -47,7 +47,7 @@ pub fn diagonal2x3<N: Number>(v: &TVec2<N>) -> TMat2x3<N> {
 /// * [`diagonal4x2`](fn.diagonal4x2.html)
 /// * [`diagonal4x3`](fn.diagonal4x3.html)
 /// * [`diagonal4x4`](fn.diagonal4x4.html)
-pub fn diagonal2x4<N: Number>(v: &TVec2<N>) -> TMat2x4<N> {
+pub fn diagonal2x4<T: Number>(v: &TVec2<T>) -> TMat2x4<T> {
     TMat2x4::from_partial_diagonal(v.as_slice())
 }
 
@@ -63,7 +63,7 @@ pub fn diagonal2x4<N: Number>(v: &TVec2<N>) -> TMat2x4<N> {
 /// * [`diagonal4x2`](fn.diagonal4x2.html)
 /// * [`diagonal4x3`](fn.diagonal4x3.html)
 /// * [`diagonal4x4`](fn.diagonal4x4.html)
-pub fn diagonal3x2<N: Number>(v: &TVec2<N>) -> TMat3x2<N> {
+pub fn diagonal3x2<T: Number>(v: &TVec2<T>) -> TMat3x2<T> {
     TMat3x2::from_partial_diagonal(v.as_slice())
 }
 
@@ -79,7 +79,7 @@ pub fn diagonal3x2<N: Number>(v: &TVec2<N>) -> TMat3x2<N> {
 /// * [`diagonal4x2`](fn.diagonal4x2.html)
 /// * [`diagonal4x3`](fn.diagonal4x3.html)
 /// * [`diagonal4x4`](fn.diagonal4x4.html)
-pub fn diagonal3x3<N: Number>(v: &TVec3<N>) -> TMat3<N> {
+pub fn diagonal3x3<T: Number>(v: &TVec3<T>) -> TMat3<T> {
     TMat3::from_diagonal(v)
 }
 
@@ -95,7 +95,7 @@ pub fn diagonal3x3<N: Number>(v: &TVec3<N>) -> TMat3<N> {
 /// * [`diagonal4x2`](fn.diagonal4x2.html)
 /// * [`diagonal4x3`](fn.diagonal4x3.html)
 /// * [`diagonal4x4`](fn.diagonal4x4.html)
-pub fn diagonal3x4<N: Number>(v: &TVec3<N>) -> TMat3x4<N> {
+pub fn diagonal3x4<T: Number>(v: &TVec3<T>) -> TMat3x4<T> {
     TMat3x4::from_partial_diagonal(v.as_slice())
 }
 
@@ -111,7 +111,7 @@ pub fn diagonal3x4<N: Number>(v: &TVec3<N>) -> TMat3x4<N> {
 /// * [`diagonal3x4`](fn.diagonal3x4.html)
 /// * [`diagonal4x3`](fn.diagonal4x3.html)
 /// * [`diagonal4x4`](fn.diagonal4x4.html)
-pub fn diagonal4x2<N: Number>(v: &TVec2<N>) -> TMat4x2<N> {
+pub fn diagonal4x2<T: Number>(v: &TVec2<T>) -> TMat4x2<T> {
     TMat4x2::from_partial_diagonal(v.as_slice())
 }
 
@@ -127,7 +127,7 @@ pub fn diagonal4x2<N: Number>(v: &TVec2<N>) -> TMat4x2<N> {
 /// * [`diagonal3x4`](fn.diagonal3x4.html)
 /// * [`diagonal4x2`](fn.diagonal4x2.html)
 /// * [`diagonal4x4`](fn.diagonal4x4.html)
-pub fn diagonal4x3<N: Number>(v: &TVec3<N>) -> TMat4x3<N> {
+pub fn diagonal4x3<T: Number>(v: &TVec3<T>) -> TMat4x3<T> {
     TMat4x3::from_partial_diagonal(v.as_slice())
 }
 
@@ -143,6 +143,6 @@ pub fn diagonal4x3<N: Number>(v: &TVec3<N>) -> TMat4x3<N> {
 /// * [`diagonal3x4`](fn.diagonal3x4.html)
 /// * [`diagonal4x2`](fn.diagonal4x2.html)
 /// * [`diagonal4x3`](fn.diagonal4x3.html)
-pub fn diagonal4x4<N: Number>(v: &TVec4<N>) -> TMat4<N> {
+pub fn diagonal4x4<T: Number>(v: &TVec4<T>) -> TMat4<T> {
     TMat4::from_diagonal(v)
 }
diff --git a/nalgebra-glm/src/gtx/norm.rs b/nalgebra-glm/src/gtx/norm.rs
index f6fabe97..8da6ab13 100644
--- a/nalgebra-glm/src/gtx/norm.rs
+++ b/nalgebra-glm/src/gtx/norm.rs
@@ -1,17 +1,13 @@
-use na::{DefaultAllocator, RealField};
+use na::RealField;
 
 use crate::aliases::TVec;
-use crate::traits::{Alloc, Dimension};
 
 /// The squared distance between two points.
 ///
 /// # See also:
 ///
 /// * [`distance`](fn.distance.html)
-pub fn distance2<N: RealField, D: Dimension>(p0: &TVec<N, D>, p1: &TVec<N, D>) -> N
-where
-    DefaultAllocator: Alloc<N, D>,
-{
+pub fn distance2<T: RealField, const D: usize>(p0: &TVec<T, D>, p1: &TVec<T, D>) -> T {
     (p1 - p0).norm_squared()
 }
 
@@ -22,10 +18,7 @@ where
 /// * [`l1_norm`](fn.l1_norm.html)
 /// * [`l2_distance`](fn.l2_distance.html)
 /// * [`l2_norm`](fn.l2_norm.html)
-pub fn l1_distance<N: RealField, D: Dimension>(x: &TVec<N, D>, y: &TVec<N, D>) -> N
-where
-    DefaultAllocator: Alloc<N, D>,
-{
+pub fn l1_distance<T: RealField, const D: usize>(x: &TVec<T, D>, y: &TVec<T, D>) -> T {
     l1_norm(&(y - x))
 }
 
@@ -39,10 +32,7 @@ where
 /// * [`l1_distance`](fn.l1_distance.html)
 /// * [`l2_distance`](fn.l2_distance.html)
 /// * [`l2_norm`](fn.l2_norm.html)
-pub fn l1_norm<N: RealField, D: Dimension>(v: &TVec<N, D>) -> N
-where
-    DefaultAllocator: Alloc<N, D>,
-{
+pub fn l1_norm<T: RealField, const D: usize>(v: &TVec<T, D>) -> T {
     crate::comp_add(&v.abs())
 }
 
@@ -60,10 +50,7 @@ where
 /// * [`length2`](fn.length2.html)
 /// * [`magnitude`](fn.magnitude.html)
 /// * [`magnitude2`](fn.magnitude2.html)
-pub fn l2_distance<N: RealField, D: Dimension>(x: &TVec<N, D>, y: &TVec<N, D>) -> N
-where
-    DefaultAllocator: Alloc<N, D>,
-{
+pub fn l2_distance<T: RealField, const D: usize>(x: &TVec<T, D>, y: &TVec<T, D>) -> T {
     l2_norm(&(y - x))
 }
 
@@ -83,10 +70,7 @@ where
 /// * [`length2`](fn.length2.html)
 /// * [`magnitude`](fn.magnitude.html)
 /// * [`magnitude2`](fn.magnitude2.html)
-pub fn l2_norm<N: RealField, D: Dimension>(x: &TVec<N, D>) -> N
-where
-    DefaultAllocator: Alloc<N, D>,
-{
+pub fn l2_norm<T: RealField, const D: usize>(x: &TVec<T, D>) -> T {
     x.norm()
 }
 
@@ -101,10 +85,7 @@ where
 /// * [`length`](fn.length.html)
 /// * [`magnitude`](fn.magnitude.html)
 /// * [`magnitude2`](fn.magnitude2.html)
-pub fn length2<N: RealField, D: Dimension>(x: &TVec<N, D>) -> N
-where
-    DefaultAllocator: Alloc<N, D>,
-{
+pub fn length2<T: RealField, const D: usize>(x: &TVec<T, D>) -> T {
     x.norm_squared()
 }
 
@@ -119,19 +100,14 @@ where
 /// * [`length2`](fn.length2.html)
 /// * [`magnitude`](fn.magnitude.html)
 /// * [`nalgebra::norm_squared`](../nalgebra/fn.norm_squared.html)
-pub fn magnitude2<N: RealField, D: Dimension>(x: &TVec<N, D>) -> N
-where
-    DefaultAllocator: Alloc<N, D>,
-{
+pub fn magnitude2<T: RealField, const D: usize>(x: &TVec<T, D>) -> T {
     x.norm_squared()
 }
 
-//pub fn lxNorm<N: RealField, D: Dimension>(x: &TVec<N, D>, y: &TVec<N, D>, unsigned int Depth) -> N
-//    where DefaultAllocator: Alloc<N, D> {
+//pub fn lxNorm<T: RealField, const D: usize>(x: &TVec<T, D>, y: &TVec<T, D>, unsigned int Depth) -> T {
 //    unimplemented!()
 //}
 //
-//pub fn lxNorm<N: RealField, D: Dimension>(x: &TVec<N, D>, unsigned int Depth) -> N
-//    where DefaultAllocator: Alloc<N, D> {
+//pub fn lxNorm<T: RealField, const D: usize>(x: &TVec<T, D>, unsigned int Depth) -> T  {
 //    unimplemented!()
 //}
diff --git a/nalgebra-glm/src/gtx/normal.rs b/nalgebra-glm/src/gtx/normal.rs
index d9f48034..0686b787 100644
--- a/nalgebra-glm/src/gtx/normal.rs
+++ b/nalgebra-glm/src/gtx/normal.rs
@@ -5,6 +5,6 @@ use crate::aliases::TVec3;
 /// The normal vector of the given triangle.
 ///
 /// The normal is computed as the normalized vector `cross(p2 - p1, p3 - p1)`.
-pub fn triangle_normal<N: RealField>(p1: &TVec3<N>, p2: &TVec3<N>, p3: &TVec3<N>) -> TVec3<N> {
+pub fn triangle_normal<T: RealField>(p1: &TVec3<T>, p2: &TVec3<T>, p3: &TVec3<T>) -> TVec3<T> {
     (p2 - p1).cross(&(p3 - p1)).normalize()
 }
diff --git a/nalgebra-glm/src/gtx/normalize_dot.rs b/nalgebra-glm/src/gtx/normalize_dot.rs
index 23e6a73f..7305ee2b 100644
--- a/nalgebra-glm/src/gtx/normalize_dot.rs
+++ b/nalgebra-glm/src/gtx/normalize_dot.rs
@@ -1,7 +1,6 @@
-use na::{DefaultAllocator, RealField};
+use na::RealField;
 
 use crate::aliases::TVec;
-use crate::traits::{Alloc, Dimension};
 
 /// The dot product of the normalized version of `x` and `y`.
 ///
@@ -10,10 +9,7 @@ use crate::traits::{Alloc, Dimension};
 /// # See also:
 ///
 /// * [`normalize_dot`](fn.normalize_dot.html`)
-pub fn fast_normalize_dot<N: RealField, D: Dimension>(x: &TVec<N, D>, y: &TVec<N, D>) -> N
-where
-    DefaultAllocator: Alloc<N, D>,
-{
+pub fn fast_normalize_dot<T: RealField, const D: usize>(x: &TVec<T, D>, y: &TVec<T, D>) -> T {
     // XXX: improve those.
     x.normalize().dot(&y.normalize())
 }
@@ -23,10 +19,7 @@ where
 /// # See also:
 ///
 /// * [`fast_normalize_dot`](fn.fast_normalize_dot.html`)
-pub fn normalize_dot<N: RealField, D: Dimension>(x: &TVec<N, D>, y: &TVec<N, D>) -> N
-where
-    DefaultAllocator: Alloc<N, D>,
-{
+pub fn normalize_dot<T: RealField, const D: usize>(x: &TVec<T, D>, y: &TVec<T, D>) -> T {
     // XXX: improve those.
     x.normalize().dot(&y.normalize())
 }
diff --git a/nalgebra-glm/src/gtx/quaternion.rs b/nalgebra-glm/src/gtx/quaternion.rs
index a90760d4..3f256e64 100644
--- a/nalgebra-glm/src/gtx/quaternion.rs
+++ b/nalgebra-glm/src/gtx/quaternion.rs
@@ -1,97 +1,97 @@
-use na::{RealField, Rotation3, Unit, UnitQuaternion, U3};
+use na::{RealField, Rotation3, Unit, UnitQuaternion};
 
 use crate::aliases::{Qua, TMat3, TMat4, TVec3, TVec4};
 
 /// Rotate the vector `v` by the quaternion `q` assumed to be normalized.
-pub fn quat_cross_vec<N: RealField>(q: &Qua<N>, v: &TVec3<N>) -> TVec3<N> {
+pub fn quat_cross_vec<T: RealField>(q: &Qua<T>, v: &TVec3<T>) -> TVec3<T> {
     UnitQuaternion::new_unchecked(*q) * v
 }
 
 /// Rotate the vector `v` by the inverse of the quaternion `q` assumed to be normalized.
-pub fn quat_inv_cross_vec<N: RealField>(v: &TVec3<N>, q: &Qua<N>) -> TVec3<N> {
+pub fn quat_inv_cross_vec<T: RealField>(v: &TVec3<T>, q: &Qua<T>) -> TVec3<T> {
     UnitQuaternion::new_unchecked(*q).inverse() * v
 }
 
 /// The quaternion `w` component.
-pub fn quat_extract_real_component<N: RealField>(q: &Qua<N>) -> N {
+pub fn quat_extract_real_component<T: RealField>(q: &Qua<T>) -> T {
     q.w
 }
 
 /// Normalized linear interpolation between two quaternions.
-pub fn quat_fast_mix<N: RealField>(x: &Qua<N>, y: &Qua<N>, a: N) -> Qua<N> {
+pub fn quat_fast_mix<T: RealField>(x: &Qua<T>, y: &Qua<T>, a: T) -> Qua<T> {
     Unit::new_unchecked(*x)
         .nlerp(&Unit::new_unchecked(*y), a)
         .into_inner()
 }
 
-//pub fn quat_intermediate<N: RealField>(prev: &Qua<N>, curr: &Qua<N>, next: &Qua<N>) -> Qua<N> {
+//pub fn quat_intermediate<T: RealField>(prev: &Qua<T>, curr: &Qua<T>, next: &Qua<T>) -> Qua<T> {
 //    unimplemented!()
 //}
 
 /// The squared magnitude of a quaternion `q`.
-pub fn quat_length2<N: RealField>(q: &Qua<N>) -> N {
+pub fn quat_length2<T: RealField>(q: &Qua<T>) -> T {
     q.norm_squared()
 }
 
 /// The squared magnitude of a quaternion `q`.
-pub fn quat_magnitude2<N: RealField>(q: &Qua<N>) -> N {
+pub fn quat_magnitude2<T: RealField>(q: &Qua<T>) -> T {
     q.norm_squared()
 }
 
 /// The quaternion representing the identity rotation.
-pub fn quat_identity<N: RealField>() -> Qua<N> {
+pub fn quat_identity<T: RealField>() -> Qua<T> {
     UnitQuaternion::identity().into_inner()
 }
 
 /// Rotates a vector by a quaternion assumed to be normalized.
-pub fn quat_rotate_vec3<N: RealField>(q: &Qua<N>, v: &TVec3<N>) -> TVec3<N> {
+pub fn quat_rotate_vec3<T: RealField>(q: &Qua<T>, v: &TVec3<T>) -> TVec3<T> {
     UnitQuaternion::new_unchecked(*q) * v
 }
 
 /// Rotates a vector in homogeneous coordinates by a quaternion assumed to be normalized.
-pub fn quat_rotate_vec<N: RealField>(q: &Qua<N>, v: &TVec4<N>) -> TVec4<N> {
-    let rotated = Unit::new_unchecked(*q) * v.fixed_rows::<U3>(0);
+pub fn quat_rotate_vec<T: RealField>(q: &Qua<T>, v: &TVec4<T>) -> TVec4<T> {
+    let rotated = Unit::new_unchecked(*q) * v.fixed_rows::<3>(0);
     TVec4::new(rotated.x, rotated.y, rotated.z, v.w)
 }
 
 /// The rotation required to align `orig` to `dest`.
-pub fn quat_rotation<N: RealField>(orig: &TVec3<N>, dest: &TVec3<N>) -> Qua<N> {
+pub fn quat_rotation<T: RealField>(orig: &TVec3<T>, dest: &TVec3<T>) -> Qua<T> {
     UnitQuaternion::rotation_between(orig, dest)
         .unwrap_or_else(UnitQuaternion::identity)
         .into_inner()
 }
 
 /// The spherical linear interpolation between two quaternions.
-pub fn quat_short_mix<N: RealField>(x: &Qua<N>, y: &Qua<N>, a: N) -> Qua<N> {
+pub fn quat_short_mix<T: RealField>(x: &Qua<T>, y: &Qua<T>, a: T) -> Qua<T> {
     Unit::new_normalize(*x)
         .slerp(&Unit::new_normalize(*y), a)
         .into_inner()
 }
 
-//pub fn quat_squad<N: RealField>(q1: &Qua<N>, q2: &Qua<N>, s1: &Qua<N>, s2: &Qua<N>, h: N) -> Qua<N> {
+//pub fn quat_squad<T: RealField>(q1: &Qua<T>, q2: &Qua<T>, s1: &Qua<T>, s2: &Qua<T>, h: T) -> Qua<T> {
 //    unimplemented!()
 //}
 
 /// Converts a quaternion to a rotation matrix.
-pub fn quat_to_mat3<N: RealField>(x: &Qua<N>) -> TMat3<N> {
+pub fn quat_to_mat3<T: RealField>(x: &Qua<T>) -> TMat3<T> {
     UnitQuaternion::new_unchecked(*x)
         .to_rotation_matrix()
         .into_inner()
 }
 
 /// Converts a quaternion to a rotation matrix in homogenous coordinates.
-pub fn quat_to_mat4<N: RealField>(x: &Qua<N>) -> TMat4<N> {
+pub fn quat_to_mat4<T: RealField>(x: &Qua<T>) -> TMat4<T> {
     UnitQuaternion::new_unchecked(*x).to_homogeneous()
 }
 
 /// Converts a rotation matrix to a quaternion.
-pub fn mat3_to_quat<N: RealField>(x: &TMat3<N>) -> Qua<N> {
+pub fn mat3_to_quat<T: RealField>(x: &TMat3<T>) -> Qua<T> {
     let r = Rotation3::from_matrix_unchecked(*x);
     UnitQuaternion::from_rotation_matrix(&r).into_inner()
 }
 
 /// Converts a rotation matrix in homogeneous coordinates to a quaternion.
-pub fn to_quat<N: RealField>(x: &TMat4<N>) -> Qua<N> {
-    let rot = x.fixed_slice::<U3, U3>(0, 0).into_owned();
+pub fn to_quat<T: RealField>(x: &TMat4<T>) -> Qua<T> {
+    let rot = x.fixed_slice::<3, 3>(0, 0).into_owned();
     mat3_to_quat(&rot)
 }
diff --git a/nalgebra-glm/src/gtx/rotate_normalized_axis.rs b/nalgebra-glm/src/gtx/rotate_normalized_axis.rs
index 1672b978..e403864c 100644
--- a/nalgebra-glm/src/gtx/rotate_normalized_axis.rs
+++ b/nalgebra-glm/src/gtx/rotate_normalized_axis.rs
@@ -9,7 +9,7 @@ use crate::aliases::{Qua, TMat4, TVec3};
 /// * `m` - Input matrix multiplied by this rotation matrix.
 /// * `angle` - Rotation angle expressed in radians.
 /// * `axis` - Rotation axis, must be normalized.
-pub fn rotate_normalized_axis<N: RealField>(m: &TMat4<N>, angle: N, axis: &TVec3<N>) -> TMat4<N> {
+pub fn rotate_normalized_axis<T: RealField>(m: &TMat4<T>, angle: T, axis: &TVec3<T>) -> TMat4<T> {
     m * Rotation3::from_axis_angle(&Unit::new_unchecked(*axis), angle).to_homogeneous()
 }
 
@@ -20,6 +20,6 @@ pub fn rotate_normalized_axis<N: RealField>(m: &TMat4<N>, angle: N, axis: &TVec3
 /// * `q` - Source orientation.
 /// * `angle` - Angle expressed in radians.
 /// * `axis` - Normalized axis of the rotation, must be normalized.
-pub fn quat_rotate_normalized_axis<N: RealField>(q: &Qua<N>, angle: N, axis: &TVec3<N>) -> Qua<N> {
+pub fn quat_rotate_normalized_axis<T: RealField>(q: &Qua<T>, angle: T, axis: &TVec3<T>) -> Qua<T> {
     q * UnitQuaternion::from_axis_angle(&Unit::new_unchecked(*axis), angle).into_inner()
 }
diff --git a/nalgebra-glm/src/gtx/rotate_vector.rs b/nalgebra-glm/src/gtx/rotate_vector.rs
index 30abc767..30101c30 100644
--- a/nalgebra-glm/src/gtx/rotate_vector.rs
+++ b/nalgebra-glm/src/gtx/rotate_vector.rs
@@ -3,7 +3,7 @@ use na::{RealField, Rotation3, Unit, UnitComplex};
 use crate::aliases::{TMat4, TVec2, TVec3, TVec4};
 
 /// Build the rotation matrix needed to align `normal` and `up`.
-pub fn orientation<N: RealField>(normal: &TVec3<N>, up: &TVec3<N>) -> TMat4<N> {
+pub fn orientation<T: RealField>(normal: &TVec3<T>, up: &TVec3<T>) -> TMat4<T> {
     if let Some(r) = Rotation3::rotation_between(normal, up) {
         r.to_homogeneous()
     } else {
@@ -12,52 +12,52 @@ pub fn orientation<N: RealField>(normal: &TVec3<N>, up: &TVec3<N>) -> TMat4<N> {
 }
 
 /// Rotate a two dimensional vector.
-pub fn rotate_vec2<N: RealField>(v: &TVec2<N>, angle: N) -> TVec2<N> {
+pub fn rotate_vec2<T: RealField>(v: &TVec2<T>, angle: T) -> TVec2<T> {
     UnitComplex::new(angle) * v
 }
 
 /// Rotate a three dimensional vector around an axis.
-pub fn rotate_vec3<N: RealField>(v: &TVec3<N>, angle: N, normal: &TVec3<N>) -> TVec3<N> {
+pub fn rotate_vec3<T: RealField>(v: &TVec3<T>, angle: T, normal: &TVec3<T>) -> TVec3<T> {
     Rotation3::from_axis_angle(&Unit::new_normalize(*normal), angle) * v
 }
 
 /// Rotate a thee dimensional vector in homogeneous coordinates around an axis.
-pub fn rotate_vec4<N: RealField>(v: &TVec4<N>, angle: N, normal: &TVec3<N>) -> TVec4<N> {
+pub fn rotate_vec4<T: RealField>(v: &TVec4<T>, angle: T, normal: &TVec3<T>) -> TVec4<T> {
     Rotation3::from_axis_angle(&Unit::new_normalize(*normal), angle).to_homogeneous() * v
 }
 
 /// Rotate a three dimensional vector around the `X` axis.
-pub fn rotate_x_vec3<N: RealField>(v: &TVec3<N>, angle: N) -> TVec3<N> {
+pub fn rotate_x_vec3<T: RealField>(v: &TVec3<T>, angle: T) -> TVec3<T> {
     Rotation3::from_axis_angle(&TVec3::x_axis(), angle) * v
 }
 
 /// Rotate a three dimensional vector in homogeneous coordinates around the `X` axis.
-pub fn rotate_x_vec4<N: RealField>(v: &TVec4<N>, angle: N) -> TVec4<N> {
+pub fn rotate_x_vec4<T: RealField>(v: &TVec4<T>, angle: T) -> TVec4<T> {
     Rotation3::from_axis_angle(&TVec3::x_axis(), angle).to_homogeneous() * v
 }
 
 /// Rotate a three dimensional vector around the `Y` axis.
-pub fn rotate_y_vec3<N: RealField>(v: &TVec3<N>, angle: N) -> TVec3<N> {
+pub fn rotate_y_vec3<T: RealField>(v: &TVec3<T>, angle: T) -> TVec3<T> {
     Rotation3::from_axis_angle(&TVec3::y_axis(), angle) * v
 }
 
 /// Rotate a three dimensional vector in homogeneous coordinates around the `Y` axis.
-pub fn rotate_y_vec4<N: RealField>(v: &TVec4<N>, angle: N) -> TVec4<N> {
+pub fn rotate_y_vec4<T: RealField>(v: &TVec4<T>, angle: T) -> TVec4<T> {
     Rotation3::from_axis_angle(&TVec3::y_axis(), angle).to_homogeneous() * v
 }
 
 /// Rotate a three dimensional vector around the `Z` axis.
-pub fn rotate_z_vec3<N: RealField>(v: &TVec3<N>, angle: N) -> TVec3<N> {
+pub fn rotate_z_vec3<T: RealField>(v: &TVec3<T>, angle: T) -> TVec3<T> {
     Rotation3::from_axis_angle(&TVec3::z_axis(), angle) * v
 }
 
 /// Rotate a three dimensional vector in homogeneous coordinates around the `Z` axis.
-pub fn rotate_z_vec4<N: RealField>(v: &TVec4<N>, angle: N) -> TVec4<N> {
+pub fn rotate_z_vec4<T: RealField>(v: &TVec4<T>, angle: T) -> TVec4<T> {
     Rotation3::from_axis_angle(&TVec3::z_axis(), angle).to_homogeneous() * v
 }
 
 /// Computes a spherical linear interpolation between the vectors `x` and `y` assumed to be normalized.
-pub fn slerp<N: RealField>(x: &TVec3<N>, y: &TVec3<N>, a: N) -> TVec3<N> {
+pub fn slerp<T: RealField>(x: &TVec3<T>, y: &TVec3<T>, a: T) -> TVec3<T> {
     Unit::new_unchecked(*x)
         .slerp(&Unit::new_unchecked(*y), a)
         .into_inner()
diff --git a/nalgebra-glm/src/gtx/transform.rs b/nalgebra-glm/src/gtx/transform.rs
index 17a853c1..b1f14952 100644
--- a/nalgebra-glm/src/gtx/transform.rs
+++ b/nalgebra-glm/src/gtx/transform.rs
@@ -12,7 +12,7 @@ use crate::traits::Number;
 /// * [`rotation2d`](fn.rotation2d.html)
 /// * [`scaling2d`](fn.scaling2d.html)
 /// * [`translation2d`](fn.translation2d.html)
-pub fn rotation<N: RealField>(angle: N, v: &TVec3<N>) -> TMat4<N> {
+pub fn rotation<T: RealField>(angle: T, v: &TVec3<T>) -> TMat4<T> {
     Rotation3::from_axis_angle(&Unit::new_normalize(*v), angle).to_homogeneous()
 }
 
@@ -25,7 +25,7 @@ pub fn rotation<N: RealField>(angle: N, v: &TVec3<N>) -> TMat4<N> {
 /// * [`rotation2d`](fn.rotation2d.html)
 /// * [`scaling2d`](fn.scaling2d.html)
 /// * [`translation2d`](fn.translation2d.html)
-pub fn scaling<N: Number>(v: &TVec3<N>) -> TMat4<N> {
+pub fn scaling<T: Number>(v: &TVec3<T>) -> TMat4<T> {
     TMat4::new_nonuniform_scaling(v)
 }
 
@@ -38,7 +38,7 @@ pub fn scaling<N: Number>(v: &TVec3<N>) -> TMat4<N> {
 /// * [`rotation2d`](fn.rotation2d.html)
 /// * [`scaling2d`](fn.scaling2d.html)
 /// * [`translation2d`](fn.translation2d.html)
-pub fn translation<N: Number>(v: &TVec3<N>) -> TMat4<N> {
+pub fn translation<T: Number>(v: &TVec3<T>) -> TMat4<T> {
     TMat4::new_translation(v)
 }
 
@@ -51,7 +51,7 @@ pub fn translation<N: Number>(v: &TVec3<N>) -> TMat4<N> {
 /// * [`translation`](fn.translation.html)
 /// * [`scaling2d`](fn.scaling2d.html)
 /// * [`translation2d`](fn.translation2d.html)
-pub fn rotation2d<N: RealField>(angle: N) -> TMat3<N> {
+pub fn rotation2d<T: RealField>(angle: T) -> TMat3<T> {
     Rotation2::new(angle).to_homogeneous()
 }
 
@@ -64,7 +64,7 @@ pub fn rotation2d<N: RealField>(angle: N) -> TMat3<N> {
 /// * [`translation`](fn.translation.html)
 /// * [`rotation2d`](fn.rotation2d.html)
 /// * [`translation2d`](fn.translation2d.html)
-pub fn scaling2d<N: Number>(v: &TVec2<N>) -> TMat3<N> {
+pub fn scaling2d<T: Number>(v: &TVec2<T>) -> TMat3<T> {
     TMat3::new_nonuniform_scaling(v)
 }
 
@@ -77,6 +77,6 @@ pub fn scaling2d<N: Number>(v: &TVec2<N>) -> TMat3<N> {
 /// * [`translation`](fn.translation.html)
 /// * [`rotation2d`](fn.rotation2d.html)
 /// * [`scaling2d`](fn.scaling2d.html)
-pub fn translation2d<N: Number>(v: &TVec2<N>) -> TMat3<N> {
+pub fn translation2d<T: Number>(v: &TVec2<T>) -> TMat3<T> {
     TMat3::new_translation(v)
 }
diff --git a/nalgebra-glm/src/gtx/transform2.rs b/nalgebra-glm/src/gtx/transform2.rs
index eaa74acb..9fcf95c7 100644
--- a/nalgebra-glm/src/gtx/transform2.rs
+++ b/nalgebra-glm/src/gtx/transform2.rs
@@ -1,14 +1,12 @@
-use na::{U2, U3};
-
 use crate::aliases::{TMat3, TMat4, TVec2, TVec3};
 use crate::traits::Number;
 
 /// Build planar projection matrix along normal axis and right-multiply it to `m`.
-pub fn proj2d<N: Number>(m: &TMat3<N>, normal: &TVec2<N>) -> TMat3<N> {
+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::<U2, U2>(0, 0);
+        let mut part = res.fixed_slice_mut::<2, 2>(0, 0);
         part -= normal * normal.transpose();
     }
 
@@ -16,11 +14,11 @@ pub fn proj2d<N: Number>(m: &TMat3<N>, normal: &TVec2<N>) -> TMat3<N> {
 }
 
 /// Build planar projection matrix along normal axis, and right-multiply it to `m`.
-pub fn proj<N: Number>(m: &TMat4<N>, normal: &TVec3<N>) -> TMat4<N> {
+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::<U3, U3>(0, 0);
+        let mut part = res.fixed_slice_mut::<3, 3>(0, 0);
         part -= normal * normal.transpose();
     }
 
@@ -28,33 +26,33 @@ pub fn proj<N: Number>(m: &TMat4<N>, normal: &TVec3<N>) -> TMat4<N> {
 }
 
 /// Builds a reflection matrix and right-multiply it to `m`.
-pub fn reflect2d<N: Number>(m: &TMat3<N>, normal: &TVec2<N>) -> TMat3<N> {
+pub fn reflect2d<T: Number>(m: &TMat3<T>, normal: &TVec2<T>) -> TMat3<T> {
     let mut res = TMat3::identity();
 
     {
-        let mut part = res.fixed_slice_mut::<U2, U2>(0, 0);
-        part -= (normal * N::from_f64(2.0).unwrap()) * normal.transpose();
+        let mut part = res.fixed_slice_mut::<2, 2>(0, 0);
+        part -= (normal * T::from_f64(2.0).unwrap()) * normal.transpose();
     }
 
     m * res
 }
 
 /// Builds a reflection matrix, and right-multiply it to `m`.
-pub fn reflect<N: Number>(m: &TMat4<N>, normal: &TVec3<N>) -> TMat4<N> {
+pub fn reflect<T: Number>(m: &TMat4<T>, normal: &TVec3<T>) -> TMat4<T> {
     let mut res = TMat4::identity();
 
     {
-        let mut part = res.fixed_slice_mut::<U3, U3>(0, 0);
-        part -= (normal * N::from_f64(2.0).unwrap()) * normal.transpose();
+        let mut part = res.fixed_slice_mut::<3, 3>(0, 0);
+        part -= (normal * T::from_f64(2.0).unwrap()) * normal.transpose();
     }
 
     m * res
 }
 
 /// Builds a scale-bias matrix.
-pub fn scale_bias_matrix<N: Number>(scale: N, bias: N) -> TMat4<N> {
-    let _0 = N::zero();
-    let _1 = N::one();
+pub fn scale_bias_matrix<T: Number>(scale: T, bias: T) -> TMat4<T> {
+    let _0 = T::zero();
+    let _1 = T::one();
 
     TMat4::new(
         scale, _0, _0, bias, _0, scale, _0, bias, _0, _0, scale, bias, _0, _0, _0, _1,
@@ -62,50 +60,50 @@ pub fn scale_bias_matrix<N: Number>(scale: N, bias: N) -> TMat4<N> {
 }
 
 /// Builds a scale-bias matrix, and right-multiply it to `m`.
-pub fn scale_bias<N: Number>(m: &TMat4<N>, scale: N, bias: N) -> TMat4<N> {
+pub fn scale_bias<T: Number>(m: &TMat4<T>, scale: T, bias: T) -> TMat4<T> {
     m * scale_bias_matrix(scale, bias)
 }
 
 /// Transforms a matrix with a shearing on X axis.
-pub fn shear2d_x<N: Number>(m: &TMat3<N>, y: N) -> TMat3<N> {
-    let _0 = N::zero();
-    let _1 = N::one();
+pub fn shear2d_x<T: Number>(m: &TMat3<T>, y: T) -> TMat3<T> {
+    let _0 = T::zero();
+    let _1 = T::one();
 
     let shear = TMat3::new(_1, y, _0, _0, _1, _0, _0, _0, _1);
     m * shear
 }
 
 /// Transforms a matrix with a shearing on Y axis.
-pub fn shear_x<N: Number>(m: &TMat4<N>, y: N, z: N) -> TMat4<N> {
-    let _0 = N::zero();
-    let _1 = N::one();
+pub fn shear_x<T: Number>(m: &TMat4<T>, y: T, z: T) -> TMat4<T> {
+    let _0 = T::zero();
+    let _1 = T::one();
     let shear = TMat4::new(_1, _0, _0, _0, y, _1, _0, _0, z, _0, _1, _0, _0, _0, _0, _1);
 
     m * shear
 }
 
 /// Transforms a matrix with a shearing on Y axis.
-pub fn shear2d_y<N: Number>(m: &TMat3<N>, x: N) -> TMat3<N> {
-    let _0 = N::zero();
-    let _1 = N::one();
+pub fn shear2d_y<T: Number>(m: &TMat3<T>, x: T) -> TMat3<T> {
+    let _0 = T::zero();
+    let _1 = T::one();
 
     let shear = TMat3::new(_1, _0, _0, x, _1, _0, _0, _0, _1);
     m * shear
 }
 
 /// Transforms a matrix with a shearing on Y axis.
-pub fn shear_y<N: Number>(m: &TMat4<N>, x: N, z: N) -> TMat4<N> {
-    let _0 = N::zero();
-    let _1 = N::one();
+pub fn shear_y<T: Number>(m: &TMat4<T>, x: T, z: T) -> TMat4<T> {
+    let _0 = T::zero();
+    let _1 = T::one();
     let shear = TMat4::new(_1, x, _0, _0, _0, _1, _0, _0, _0, z, _1, _0, _0, _0, _0, _1);
 
     m * shear
 }
 
 /// Transforms a matrix with a shearing on Z axis.
-pub fn shear_z<N: Number>(m: &TMat4<N>, x: N, y: N) -> TMat4<N> {
-    let _0 = N::zero();
-    let _1 = N::one();
+pub fn shear_z<T: Number>(m: &TMat4<T>, x: T, y: T) -> TMat4<T> {
+    let _0 = T::zero();
+    let _1 = T::one();
     let shear = TMat4::new(_1, _0, x, _0, _0, _1, y, _0, _0, _0, _1, _0, _0, _0, _0, _1);
 
     m * shear
diff --git a/nalgebra-glm/src/gtx/transform2d.rs b/nalgebra-glm/src/gtx/transform2d.rs
index 0c7deb18..c320628e 100644
--- a/nalgebra-glm/src/gtx/transform2d.rs
+++ b/nalgebra-glm/src/gtx/transform2d.rs
@@ -12,7 +12,7 @@ use crate::traits::Number;
 /// * [`scaling2d`](fn.scaling2d.html)
 /// * [`translate2d`](fn.translate2d.html)
 /// * [`translation2d`](fn.translation2d.html)
-pub fn rotate2d<N: RealField>(m: &TMat3<N>, angle: N) -> TMat3<N> {
+pub fn rotate2d<T: RealField>(m: &TMat3<T>, angle: T) -> TMat3<T> {
     m * UnitComplex::new(angle).to_homogeneous()
 }
 
@@ -25,7 +25,7 @@ pub fn rotate2d<N: RealField>(m: &TMat3<N>, angle: N) -> TMat3<N> {
 /// * [`scaling2d`](fn.scaling2d.html)
 /// * [`translate2d`](fn.translate2d.html)
 /// * [`translation2d`](fn.translation2d.html)
-pub fn scale2d<N: Number>(m: &TMat3<N>, v: &TVec2<N>) -> TMat3<N> {
+pub fn scale2d<T: Number>(m: &TMat3<T>, v: &TVec2<T>) -> TMat3<T> {
     m.prepend_nonuniform_scaling(v)
 }
 
@@ -38,6 +38,6 @@ pub fn scale2d<N: Number>(m: &TMat3<N>, v: &TVec2<N>) -> TMat3<N> {
 /// * [`scale2d`](fn.scale2d.html)
 /// * [`scaling2d`](fn.scaling2d.html)
 /// * [`translation2d`](fn.translation2d.html)
-pub fn translate2d<N: Number>(m: &TMat3<N>, v: &TVec2<N>) -> TMat3<N> {
+pub fn translate2d<T: Number>(m: &TMat3<T>, v: &TVec2<T>) -> TMat3<T> {
     m.prepend_translation(v)
 }
diff --git a/nalgebra-glm/src/gtx/vector_angle.rs b/nalgebra-glm/src/gtx/vector_angle.rs
index e71abafb..5b61932f 100644
--- a/nalgebra-glm/src/gtx/vector_angle.rs
+++ b/nalgebra-glm/src/gtx/vector_angle.rs
@@ -1,20 +1,16 @@
-use na::{DefaultAllocator, RealField};
+use na::RealField;
 
 use crate::aliases::TVec;
-use crate::traits::{Alloc, Dimension};
 
 /// The angle between two vectors.
-pub fn angle<N: RealField, D: Dimension>(x: &TVec<N, D>, y: &TVec<N, D>) -> N
-where
-    DefaultAllocator: Alloc<N, D>,
-{
+pub fn angle<T: RealField, const D: usize>(x: &TVec<T, D>, y: &TVec<T, D>) -> T {
     x.angle(y)
 }
 
-//pub fn oriented_angle<N: RealField>(x: &TVec2<N>, y: &TVec2<N>) -> N {
+//pub fn oriented_angle<T: RealField>(x: &TVec2<T>, y: &TVec2<T>) -> T {
 //    unimplemented!()
 //}
 //
-//pub fn oriented_angle_ref<N: RealField>(x: &TVec3<N>, y: &TVec3<N>, refv: &TVec3<N>) -> N {
+//pub fn oriented_angle_ref<T: RealField>(x: &TVec3<T>, y: &TVec3<T>, refv: &TVec3<T>) -> T {
 //    unimplemented!()
 //}
diff --git a/nalgebra-glm/src/gtx/vector_query.rs b/nalgebra-glm/src/gtx/vector_query.rs
index 687d9530..1e739e24 100644
--- a/nalgebra-glm/src/gtx/vector_query.rs
+++ b/nalgebra-glm/src/gtx/vector_query.rs
@@ -1,14 +1,14 @@
-use na::{DefaultAllocator, RealField};
+use na::RealField;
 
 use crate::aliases::{TVec, TVec2, TVec3};
-use crate::traits::{Alloc, Dimension, Number};
+use crate::traits::Number;
 
 /// Returns `true` if two vectors are collinear (up to an epsilon).
 ///
 /// # See also:
 ///
 /// * [`are_collinear2d`](fn.are_collinear2d.html)
-pub fn are_collinear<N: Number>(v0: &TVec3<N>, v1: &TVec3<N>, epsilon: N) -> bool {
+pub fn are_collinear<T: Number>(v0: &TVec3<T>, v1: &TVec3<T>, epsilon: T) -> bool {
     is_null(&v0.cross(v1), epsilon)
 }
 
@@ -17,43 +17,34 @@ pub fn are_collinear<N: Number>(v0: &TVec3<N>, v1: &TVec3<N>, epsilon: N) -> boo
 /// # See also:
 ///
 /// * [`are_collinear`](fn.are_collinear.html)
-pub fn are_collinear2d<N: Number>(v0: &TVec2<N>, v1: &TVec2<N>, epsilon: N) -> bool {
-    abs_diff_eq!(v0.perp(v1), N::zero(), epsilon = epsilon)
+pub fn are_collinear2d<T: Number>(v0: &TVec2<T>, v1: &TVec2<T>, epsilon: T) -> bool {
+    abs_diff_eq!(v0.perp(v1), T::zero(), epsilon = epsilon)
 }
 
 /// Returns `true` if two vectors are orthogonal (up to an epsilon).
-pub fn are_orthogonal<N: Number, D: Dimension>(v0: &TVec<N, D>, v1: &TVec<N, D>, epsilon: N) -> bool
-where
-    DefaultAllocator: Alloc<N, D>,
-{
-    abs_diff_eq!(v0.dot(v1), N::zero(), epsilon = epsilon)
+pub fn are_orthogonal<T: Number, const D: usize>(
+    v0: &TVec<T, D>,
+    v1: &TVec<T, D>,
+    epsilon: T,
+) -> bool {
+    abs_diff_eq!(v0.dot(v1), T::zero(), epsilon = epsilon)
 }
 
-//pub fn are_orthonormal<N: Number, D: Dimension>(v0: &TVec<N, D>, v1: &TVec<N, D>, epsilon: N) -> bool
-//    where DefaultAllocator: Alloc<N, D> {
+//pub fn are_orthonormal<T: Number, const D: usize>(v0: &TVec<T, D>, v1: &TVec<T, D>, epsilon: T) -> bool {
 //    unimplemented!()
 //}
 
 /// Returns `true` if all the components of `v` are zero (up to an epsilon).
-pub fn is_comp_null<N: Number, D: Dimension>(v: &TVec<N, D>, epsilon: N) -> TVec<bool, D>
-where
-    DefaultAllocator: Alloc<N, D>,
-{
-    v.map(|x| abs_diff_eq!(x, N::zero(), epsilon = epsilon))
+pub fn is_comp_null<T: Number, const D: usize>(v: &TVec<T, D>, epsilon: T) -> TVec<bool, D> {
+    v.map(|x| abs_diff_eq!(x, T::zero(), epsilon = epsilon))
 }
 
 /// Returns `true` if `v` has a magnitude of 1 (up to an epsilon).
-pub fn is_normalized<N: RealField, D: Dimension>(v: &TVec<N, D>, epsilon: N) -> bool
-where
-    DefaultAllocator: Alloc<N, D>,
-{
-    abs_diff_eq!(v.norm_squared(), N::one(), epsilon = epsilon * epsilon)
+pub fn is_normalized<T: RealField, const D: usize>(v: &TVec<T, D>, epsilon: T) -> bool {
+    abs_diff_eq!(v.norm_squared(), T::one(), epsilon = epsilon * epsilon)
 }
 
 /// Returns `true` if `v` is zero (up to an epsilon).
-pub fn is_null<N: Number, D: Dimension>(v: &TVec<N, D>, epsilon: N) -> bool
-where
-    DefaultAllocator: Alloc<N, D>,
-{
-    abs_diff_eq!(*v, TVec::<N, D>::zeros(), epsilon = epsilon)
+pub fn is_null<T: Number, const D: usize>(v: &TVec<T, D>, epsilon: T) -> bool {
+    abs_diff_eq!(*v, TVec::<T, D>::zeros(), epsilon = epsilon)
 }
diff --git a/nalgebra-glm/src/integer.rs b/nalgebra-glm/src/integer.rs
index 198d737a..93aa4847 100644
--- a/nalgebra-glm/src/integer.rs
+++ b/nalgebra-glm/src/integer.rs
@@ -1,29 +1,46 @@
-use na::{Scalar, RealField, U3, DefaultAllocator};
+use na::{DefaultAllocator, RealField, Scalar, U3};
 
-use crate::traits::{Number, Alloc, Dimension};
 use crate::aliases::TVec;
+use crate::traits::{Alloc, Dimension, Number};
 
 pub fn bitCount<T>(v: T) -> i32 {
     unimplemented!()
 }
 
-pub fn bitCount2<N: Scalar, D: Dimension>(v: &TVec<N, D>) -> TVec<i32, D>
-    where DefaultAllocator: Alloc<N, D> {
+pub fn bitCount2<T: Scalar, const D: usize>(v: &TVec<T, D>) -> TVec<i32, D>
+where
+    DefaultAllocator: Alloc<T, D>,
+{
     unimplemented!()
 }
 
-pub fn bitfieldExtract<N: Scalar, D: Dimension>(Value: &TVec<N, D>, Offset: i32, Bits: i32) -> TVec<N, D>
-    where DefaultAllocator: Alloc<N, D> {
+pub fn bitfieldExtract<T: Scalar, const D: usize>(
+    Value: &TVec<T, D>,
+    Offset: i32,
+    Bits: i32,
+) -> TVec<T, D>
+where
+    DefaultAllocator: Alloc<T, D>,
+{
     unimplemented!()
 }
 
-pub fn bitfieldInsert<N: Scalar, D: Dimension>(Base: &TVec<N, D>, Insert: &TVec<N, D>, Offset: i32, Bits: i32) -> TVec<N, D>
-    where DefaultAllocator: Alloc<N, D> {
+pub fn bitfieldInsert<T: Scalar, const D: usize>(
+    Base: &TVec<T, D>,
+    Insert: &TVec<T, D>,
+    Offset: i32,
+    Bits: i32,
+) -> TVec<T, D>
+where
+    DefaultAllocator: Alloc<T, D>,
+{
     unimplemented!()
 }
 
-pub fn bitfieldReverse<N: Scalar, D: Dimension>(v: &TVec<N, D>) -> TVec<N, D>
-    where DefaultAllocator: Alloc<N, D> {
+pub fn bitfieldReverse<T: Scalar, const D: usize>(v: &TVec<T, D>) -> TVec<T, D>
+where
+    DefaultAllocator: Alloc<T, D>,
+{
     unimplemented!()
 }
 
@@ -31,8 +48,10 @@ pub fn findLSB<IU>(x: IU) -> u32 {
     unimplemented!()
 }
 
-pub fn findLSB2<N: Scalar, D: Dimension>(v: &TVec<N, D>) -> TVec<i32, D>
-    where DefaultAllocator: Alloc<N, D> {
+pub fn findLSB2<T: Scalar, const D: usize>(v: &TVec<T, D>) -> TVec<i32, D>
+where
+    DefaultAllocator: Alloc<T, D>,
+{
     unimplemented!()
 }
 
@@ -40,27 +59,53 @@ pub fn findMSB<IU>(x: IU) -> i32 {
     unimplemented!()
 }
 
-pub fn findMSB2<N: Scalar, D: Dimension>(v: &TVec<N, D>) -> TVec<i32, D>
-    where DefaultAllocator: Alloc<N, D> {
+pub fn findMSB2<T: Scalar, const D: usize>(v: &TVec<T, D>) -> TVec<i32, D>
+where
+    DefaultAllocator: Alloc<T, D>,
+{
     unimplemented!()
 }
 
-pub fn imulExtended<N: Scalar, D: Dimension>(x: &TVec<i32, D>, y: &TVec<i32, D>, msb: &TVec<i32, D>, lsb: &TVec<i32, D>)
-    where DefaultAllocator: Alloc<N, D> {
+pub fn imulExtended<T: Scalar, const D: usize>(
+    x: &TVec<i32, D>,
+    y: &TVec<i32, D>,
+    msb: &TVec<i32, D>,
+    lsb: &TVec<i32, D>,
+) where
+    DefaultAllocator: Alloc<T, D>,
+{
     unimplemented!()
 }
 
-pub fn uaddCarry<N: Scalar, D: Dimension>(x: &TVec<u32, D>, y: &TVec<u32, D>, carry: &TVec<u32, D>) -> TVec<u32, D>
-    where DefaultAllocator: Alloc<N, D> {
+pub fn uaddCarry<T: Scalar, const D: usize>(
+    x: &TVec<u32, D>,
+    y: &TVec<u32, D>,
+    carry: &TVec<u32, D>,
+) -> TVec<u32, D>
+where
+    DefaultAllocator: Alloc<T, D>,
+{
     unimplemented!()
 }
 
-pub fn umulExtended<N: Scalar, D: Dimension>(x: &TVec<u32, D>, y: &TVec<u32, D>, msb: &TVec<u32, D>, lsb: &TVec<u32, D>)
-    where DefaultAllocator: Alloc<N, D> {
-unimplemented!()
-}
-
-pub fn usubBorrow<N: Scalar, D: Dimension>(x: &TVec<u32, D>, y: &TVec<u32, D>, borrow: &TVec<u32, D>) -> TVec<u32, D>
-    where DefaultAllocator: Alloc<N, D> {
+pub fn umulExtended<T: Scalar, const D: usize>(
+    x: &TVec<u32, D>,
+    y: &TVec<u32, D>,
+    msb: &TVec<u32, D>,
+    lsb: &TVec<u32, D>,
+) where
+    DefaultAllocator: Alloc<T, D>,
+{
+    unimplemented!()
+}
+
+pub fn usubBorrow<T: Scalar, const D: usize>(
+    x: &TVec<u32, D>,
+    y: &TVec<u32, D>,
+    borrow: &TVec<u32, D>,
+) -> TVec<u32, D>
+where
+    DefaultAllocator: Alloc<T, D>,
+{
     unimplemented!()
 }
diff --git a/nalgebra-glm/src/lib.rs b/nalgebra-glm/src/lib.rs
index e9c64160..df578a80 100644
--- a/nalgebra-glm/src/lib.rs
+++ b/nalgebra-glm/src/lib.rs
@@ -54,7 +54,7 @@
    ### Vector and matrix construction
    Vectors, matrices, and quaternions can be constructed using several approaches:
    * Using functions with the same name as their type in lower-case. For example [`glm::vec3(x, y, z)`](fn.vec3.html) will create a 3D vector.
-   * Using the `::new` constructor. For example [`Vec3::new(x, y, z)`](../nalgebra/base/type.MatrixMN.html#method.new-27) will create a 3D vector.
+   * Using the `::new` constructor. For example [`Vec3::new(x, y, z)`](../nalgebra/base/type.OMatrix.html#method.new-27) will create a 3D vector.
    * Using the functions prefixed by `make_` to build a vector a matrix from a slice. For example [`glm::make_vec3(&[x, y, z])`](fn.make_vec3.html) will create a 3D vector.
    Keep in mind that constructing a matrix using this type of functions require its components to be arranged in column-major order on the slice.
    * Using a geometric construction function. For example [`glm::rotation(angle, axis)`](fn.rotation.html) will build a 4x4 homogeneous rotation matrix from an angle (in radians) and an axis.
@@ -119,7 +119,7 @@ extern crate approx;
 extern crate nalgebra as na;
 
 pub use crate::aliases::*;
-pub use crate::traits::{Alloc, Dimension, Number};
+pub use crate::traits::Number;
 pub use common::{
     abs, ceil, clamp, clamp_scalar, clamp_vec, float_bits_to_int, float_bits_to_int_vec,
     float_bits_to_uint, float_bits_to_uint_vec, floor, fract, int_bits_to_float,
diff --git a/nalgebra-glm/src/matrix.rs b/nalgebra-glm/src/matrix.rs
index ea887cf2..23485247 100644
--- a/nalgebra-glm/src/matrix.rs
+++ b/nalgebra-glm/src/matrix.rs
@@ -1,52 +1,40 @@
-use na::{DefaultAllocator, RealField, Scalar};
+use na::{Const, DimMin, RealField, Scalar};
 
 use crate::aliases::{TMat, TVec};
-use crate::traits::{Alloc, Dimension, Number};
+use crate::traits::Number;
 
 /// The determinant of the matrix `m`.
-pub fn determinant<N: RealField, D: Dimension>(m: &TMat<N, D, D>) -> N
+pub fn determinant<T: RealField, const D: usize>(m: &TMat<T, D, D>) -> T
 where
-    DefaultAllocator: Alloc<N, D, D>,
+    Const<D>: DimMin<Const<D>, Output = Const<D>>,
 {
     m.determinant()
 }
 
 /// The inverse of the matrix `m`.
-pub fn inverse<N: RealField, D: Dimension>(m: &TMat<N, D, D>) -> TMat<N, D, D>
-where
-    DefaultAllocator: Alloc<N, D, D>,
-{
+pub fn inverse<T: RealField, const D: usize>(m: &TMat<T, D, D>) -> TMat<T, D, D> {
     m.clone()
         .try_inverse()
-        .unwrap_or_else(TMat::<N, D, D>::zeros)
+        .unwrap_or_else(TMat::<T, D, D>::zeros)
 }
 
 /// Component-wise multiplication of two matrices.
-pub fn matrix_comp_mult<N: Number, R: Dimension, C: Dimension>(
-    x: &TMat<N, R, C>,
-    y: &TMat<N, R, C>,
-) -> TMat<N, R, C>
-where
-    DefaultAllocator: Alloc<N, R, C>,
-{
+pub fn matrix_comp_mult<T: Number, const R: usize, const C: usize>(
+    x: &TMat<T, R, C>,
+    y: &TMat<T, R, C>,
+) -> TMat<T, R, C> {
     x.component_mul(y)
 }
 
 /// Treats the first parameter `c` as a column vector and the second parameter `r` as a row vector and does a linear algebraic matrix multiply `c * r`.
-pub fn outer_product<N: Number, R: Dimension, C: Dimension>(
-    c: &TVec<N, R>,
-    r: &TVec<N, C>,
-) -> TMat<N, R, C>
-where
-    DefaultAllocator: Alloc<N, R, C>,
-{
+pub fn outer_product<T: Number, const R: usize, const C: usize>(
+    c: &TVec<T, R>,
+    r: &TVec<T, C>,
+) -> TMat<T, R, C> {
     c * r.transpose()
 }
 
 /// The transpose of the matrix `m`.
-pub fn transpose<N: Scalar, R: Dimension, C: Dimension>(x: &TMat<N, R, C>) -> TMat<N, C, R>
-where
-    DefaultAllocator: Alloc<N, R, C>,
-{
+pub fn transpose<T: Scalar, const R: usize, const C: usize>(x: &TMat<T, R, C>) -> TMat<T, C, R> {
     x.transpose()
 }
diff --git a/nalgebra-glm/src/packing.rs b/nalgebra-glm/src/packing.rs
index 3273fb26..35352e94 100644
--- a/nalgebra-glm/src/packing.rs
+++ b/nalgebra-glm/src/packing.rs
@@ -1,52 +1,51 @@
 use na::Scalar;
 
-use crate::aliases::{Vec2, Vec4, UVec2};
+use crate::aliases::{UVec2, Vec2, Vec4};
 
-
-pub fn packDouble2x32<N: Scalar>(v: &UVec2) -> f64 {
+pub fn packDouble2x32<T: Scalar>(v: &UVec2) -> f64 {
     unimplemented!()
 }
 
-pub fn packHalf2x16<N: Scalar>(v: &Vec2) -> u32 {
+pub fn packHalf2x16<T: Scalar>(v: &Vec2) -> u32 {
     unimplemented!()
 }
 
-pub fn packSnorm2x16<N: Scalar>(v: &Vec2) -> u32 {
+pub fn packSnorm2x16<T: Scalar>(v: &Vec2) -> u32 {
     unimplemented!()
 }
 
-pub fn packSnorm4x8<N: Scalar>(v: &Vec4) -> u32 {
+pub fn packSnorm4x8<T: Scalar>(v: &Vec4) -> u32 {
     unimplemented!()
 }
 
-pub fn packUnorm2x16<N: Scalar>(v: &Vec2) -> u32 {
+pub fn packUnorm2x16<T: Scalar>(v: &Vec2) -> u32 {
     unimplemented!()
 }
 
-pub fn packUnorm4x8<N: Scalar>(v: &Vec4) -> u32 {
+pub fn packUnorm4x8<T: Scalar>(v: &Vec4) -> u32 {
     unimplemented!()
 }
 
-pub fn unpackDouble2x32<N: Scalar>(v: f64) -> UVec2 {
+pub fn unpackDouble2x32<T: Scalar>(v: f64) -> UVec2 {
     unimplemented!()
 }
 
-pub fn unpackHalf2x16<N: Scalar>(v: u32) -> Vec2 {
+pub fn unpackHalf2x16<T: Scalar>(v: u32) -> Vec2 {
     unimplemented!()
 }
 
-pub fn unpackSnorm2x16<N: Scalar>(p: u32) -> Vec2 {
+pub fn unpackSnorm2x16<T: Scalar>(p: u32) -> Vec2 {
     unimplemented!()
 }
 
-pub fn unpackSnorm4x8<N: Scalar>(p: u32) -> Vec4 {
+pub fn unpackSnorm4x8<T: Scalar>(p: u32) -> Vec4 {
     unimplemented!()
 }
 
-pub fn unpackUnorm2x16<N: Scalar>(p: u32) -> Vec2 {
+pub fn unpackUnorm2x16<T: Scalar>(p: u32) -> Vec2 {
     unimplemented!()
 }
 
-pub fn unpackUnorm4x8<N: Scalar>(p: u32) -> Vec4 {
+pub fn unpackUnorm4x8<T: Scalar>(p: u32) -> Vec4 {
     unimplemented!()
 }
diff --git a/nalgebra-glm/src/traits.rs b/nalgebra-glm/src/traits.rs
index 24d41083..04d192c9 100644
--- a/nalgebra-glm/src/traits.rs
+++ b/nalgebra-glm/src/traits.rs
@@ -1,15 +1,10 @@
 use approx::AbsDiffEq;
 use num::{Bounded, FromPrimitive, Signed};
 
-use na::allocator::Allocator;
-use na::{DimMin, DimName, Scalar, U1};
+use na::Scalar;
 use simba::scalar::{ClosedAdd, ClosedMul, ClosedSub};
 use std::cmp::PartialOrd;
 
-/// A type-level number representing a vector, matrix row, or matrix column, dimension.
-pub trait Dimension: DimName + DimMin<Self, Output = Self> {}
-impl<D: DimName + DimMin<D, Output = Self>> Dimension for D {}
-
 /// A number that can either be an integer or a float.
 pub trait Number:
     Scalar
@@ -39,64 +34,3 @@ impl<
     > Number for T
 {
 }
-
-#[doc(hidden)]
-pub trait Alloc<N: Scalar, R: Dimension, C: Dimension = U1>:
-    Allocator<N, R>
-    + Allocator<N, C>
-    + Allocator<N, U1, R>
-    + Allocator<N, U1, C>
-    + Allocator<N, R, C>
-    + Allocator<N, C, R>
-    + Allocator<N, R, R>
-    + Allocator<N, C, C>
-    + Allocator<bool, R>
-    + Allocator<bool, C>
-    + Allocator<f32, R>
-    + Allocator<f32, C>
-    + Allocator<u32, R>
-    + Allocator<u32, C>
-    + Allocator<i32, R>
-    + Allocator<i32, C>
-    + Allocator<f64, R>
-    + Allocator<f64, C>
-    + Allocator<u64, R>
-    + Allocator<u64, C>
-    + Allocator<i64, R>
-    + Allocator<i64, C>
-    + Allocator<i16, R>
-    + Allocator<i16, C>
-    + Allocator<(usize, usize), R>
-    + Allocator<(usize, usize), C>
-{
-}
-
-impl<N: Scalar, R: Dimension, C: Dimension, T> Alloc<N, R, C> for T where
-    T: Allocator<N, R>
-        + Allocator<N, C>
-        + Allocator<N, U1, R>
-        + Allocator<N, U1, C>
-        + Allocator<N, R, C>
-        + Allocator<N, C, R>
-        + Allocator<N, R, R>
-        + Allocator<N, C, C>
-        + Allocator<bool, R>
-        + Allocator<bool, C>
-        + Allocator<f32, R>
-        + Allocator<f32, C>
-        + Allocator<u32, R>
-        + Allocator<u32, C>
-        + Allocator<i32, R>
-        + Allocator<i32, C>
-        + Allocator<f64, R>
-        + Allocator<f64, C>
-        + Allocator<u64, R>
-        + Allocator<u64, C>
-        + Allocator<i64, R>
-        + Allocator<i64, C>
-        + Allocator<i16, R>
-        + Allocator<i16, C>
-        + Allocator<(usize, usize), R>
-        + Allocator<(usize, usize), C>
-{
-}
diff --git a/nalgebra-glm/src/trigonometric.rs b/nalgebra-glm/src/trigonometric.rs
index adf1a211..257218d3 100644
--- a/nalgebra-glm/src/trigonometric.rs
+++ b/nalgebra-glm/src/trigonometric.rs
@@ -1,124 +1,78 @@
-use na::{self, DefaultAllocator, RealField};
+use na::{self, RealField};
 
 use crate::aliases::TVec;
-use crate::traits::{Alloc, Dimension};
 
 /// Component-wise arc-cosinus.
-pub fn acos<N: RealField, D: Dimension>(x: &TVec<N, D>) -> TVec<N, D>
-where
-    DefaultAllocator: Alloc<N, D>,
-{
+pub fn acos<T: RealField, const D: usize>(x: &TVec<T, D>) -> TVec<T, D> {
     x.map(|e| e.acos())
 }
 
 /// Component-wise hyperbolic arc-cosinus.
-pub fn acosh<N: RealField, D: Dimension>(x: &TVec<N, D>) -> TVec<N, D>
-where
-    DefaultAllocator: Alloc<N, D>,
-{
+pub fn acosh<T: RealField, const D: usize>(x: &TVec<T, D>) -> TVec<T, D> {
     x.map(|e| e.acosh())
 }
 
 /// Component-wise arc-sinus.
-pub fn asin<N: RealField, D: Dimension>(x: &TVec<N, D>) -> TVec<N, D>
-where
-    DefaultAllocator: Alloc<N, D>,
-{
+pub fn asin<T: RealField, const D: usize>(x: &TVec<T, D>) -> TVec<T, D> {
     x.map(|e| e.asin())
 }
 
 /// Component-wise hyperbolic arc-sinus.
-pub fn asinh<N: RealField, D: Dimension>(x: &TVec<N, D>) -> TVec<N, D>
-where
-    DefaultAllocator: Alloc<N, D>,
-{
+pub fn asinh<T: RealField, const D: usize>(x: &TVec<T, D>) -> TVec<T, D> {
     x.map(|e| e.asinh())
 }
 
 /// Component-wise arc-tangent of `y / x`.
-pub fn atan2<N: RealField, D: Dimension>(y: &TVec<N, D>, x: &TVec<N, D>) -> TVec<N, D>
-where
-    DefaultAllocator: Alloc<N, D>,
-{
+pub fn atan2<T: RealField, const D: usize>(y: &TVec<T, D>, x: &TVec<T, D>) -> TVec<T, D> {
     y.zip_map(x, |y, x| y.atan2(x))
 }
 
 /// Component-wise arc-tangent.
-pub fn atan<N: RealField, D: Dimension>(y_over_x: &TVec<N, D>) -> TVec<N, D>
-where
-    DefaultAllocator: Alloc<N, D>,
-{
+pub fn atan<T: RealField, const D: usize>(y_over_x: &TVec<T, D>) -> TVec<T, D> {
     y_over_x.map(|e| e.atan())
 }
 
 /// Component-wise hyperbolic arc-tangent.
-pub fn atanh<N: RealField, D: Dimension>(x: &TVec<N, D>) -> TVec<N, D>
-where
-    DefaultAllocator: Alloc<N, D>,
-{
+pub fn atanh<T: RealField, const D: usize>(x: &TVec<T, D>) -> TVec<T, D> {
     x.map(|e| e.atanh())
 }
 
 /// Component-wise cosinus.
-pub fn cos<N: RealField, D: Dimension>(angle: &TVec<N, D>) -> TVec<N, D>
-where
-    DefaultAllocator: Alloc<N, D>,
-{
+pub fn cos<T: RealField, const D: usize>(angle: &TVec<T, D>) -> TVec<T, D> {
     angle.map(|e| e.cos())
 }
 
 /// Component-wise hyperbolic cosinus.
-pub fn cosh<N: RealField, D: Dimension>(angle: &TVec<N, D>) -> TVec<N, D>
-where
-    DefaultAllocator: Alloc<N, D>,
-{
+pub fn cosh<T: RealField, const D: usize>(angle: &TVec<T, D>) -> TVec<T, D> {
     angle.map(|e| e.cosh())
 }
 
 /// Component-wise conversion from radians to degrees.
-pub fn degrees<N: RealField, D: Dimension>(radians: &TVec<N, D>) -> TVec<N, D>
-where
-    DefaultAllocator: Alloc<N, D>,
-{
-    radians.map(|e| e * na::convert(180.0) / N::pi())
+pub fn degrees<T: RealField, const D: usize>(radians: &TVec<T, D>) -> TVec<T, D> {
+    radians.map(|e| e * na::convert(180.0) / T::pi())
 }
 
 /// Component-wise conversion fro degrees to radians.
-pub fn radians<N: RealField, D: Dimension>(degrees: &TVec<N, D>) -> TVec<N, D>
-where
-    DefaultAllocator: Alloc<N, D>,
-{
-    degrees.map(|e| e * N::pi() / na::convert(180.0))
+pub fn radians<T: RealField, const D: usize>(degrees: &TVec<T, D>) -> TVec<T, D> {
+    degrees.map(|e| e * T::pi() / na::convert(180.0))
 }
 
 /// Component-wise sinus.
-pub fn sin<N: RealField, D: Dimension>(angle: &TVec<N, D>) -> TVec<N, D>
-where
-    DefaultAllocator: Alloc<N, D>,
-{
+pub fn sin<T: RealField, const D: usize>(angle: &TVec<T, D>) -> TVec<T, D> {
     angle.map(|e| e.sin())
 }
 
 /// Component-wise hyperbolic sinus.
-pub fn sinh<N: RealField, D: Dimension>(angle: &TVec<N, D>) -> TVec<N, D>
-where
-    DefaultAllocator: Alloc<N, D>,
-{
+pub fn sinh<T: RealField, const D: usize>(angle: &TVec<T, D>) -> TVec<T, D> {
     angle.map(|e| e.sinh())
 }
 
 /// Component-wise tangent.
-pub fn tan<N: RealField, D: Dimension>(angle: &TVec<N, D>) -> TVec<N, D>
-where
-    DefaultAllocator: Alloc<N, D>,
-{
+pub fn tan<T: RealField, const D: usize>(angle: &TVec<T, D>) -> TVec<T, D> {
     angle.map(|e| e.tan())
 }
 
 /// Component-wise hyperbolic tangent.
-pub fn tanh<N: RealField, D: Dimension>(angle: &TVec<N, D>) -> TVec<N, D>
-where
-    DefaultAllocator: Alloc<N, D>,
-{
+pub fn tanh<T: RealField, const D: usize>(angle: &TVec<T, D>) -> TVec<T, D> {
     angle.map(|e| e.tanh())
 }
diff --git a/nalgebra-glm/src/vector_relational.rs b/nalgebra-glm/src/vector_relational.rs
index be17d247..b8b3fbd7 100644
--- a/nalgebra-glm/src/vector_relational.rs
+++ b/nalgebra-glm/src/vector_relational.rs
@@ -1,7 +1,5 @@
-use na::DefaultAllocator;
-
 use crate::aliases::TVec;
-use crate::traits::{Alloc, Dimension, Number};
+use crate::traits::Number;
 
 /// Checks that all the vector components are `true`.
 ///
@@ -20,10 +18,7 @@ use crate::traits::{Alloc, Dimension, Number};
 ///
 /// * [`any`](fn.any.html)
 /// * [`not`](fn.not.html)
-pub fn all<D: Dimension>(v: &TVec<bool, D>) -> bool
-where
-    DefaultAllocator: Alloc<bool, D>,
-{
+pub fn all<const D: usize>(v: &TVec<bool, D>) -> bool {
     v.iter().all(|x| *x)
 }
 
@@ -47,10 +42,7 @@ where
 ///
 /// * [`all`](fn.all.html)
 /// * [`not`](fn.not.html)
-pub fn any<D: Dimension>(v: &TVec<bool, D>) -> bool
-where
-    DefaultAllocator: Alloc<bool, D>,
-{
+pub fn any<const D: usize>(v: &TVec<bool, D>) -> bool {
     v.iter().any(|x| *x)
 }
 
@@ -73,10 +65,7 @@ where
 /// * [`less_than_equal`](fn.less_than_equal.html)
 /// * [`not`](fn.not.html)
 /// * [`not_equal`](fn.not_equal.html)
-pub fn equal<N: Number, D: Dimension>(x: &TVec<N, D>, y: &TVec<N, D>) -> TVec<bool, D>
-where
-    DefaultAllocator: Alloc<N, D>,
-{
+pub fn equal<T: Number, const D: usize>(x: &TVec<T, D>, y: &TVec<T, D>) -> TVec<bool, D> {
     x.zip_map(y, |x, y| x == y)
 }
 
@@ -99,10 +88,7 @@ where
 /// * [`less_than_equal`](fn.less_than_equal.html)
 /// * [`not`](fn.not.html)
 /// * [`not_equal`](fn.not_equal.html)
-pub fn greater_than<N: Number, D: Dimension>(x: &TVec<N, D>, y: &TVec<N, D>) -> TVec<bool, D>
-where
-    DefaultAllocator: Alloc<N, D>,
-{
+pub fn greater_than<T: Number, const D: usize>(x: &TVec<T, D>, y: &TVec<T, D>) -> TVec<bool, D> {
     x.zip_map(y, |x, y| x > y)
 }
 
@@ -125,10 +111,10 @@ where
 /// * [`less_than_equal`](fn.less_than_equal.html)
 /// * [`not`](fn.not.html)
 /// * [`not_equal`](fn.not_equal.html)
-pub fn greater_than_equal<N: Number, D: Dimension>(x: &TVec<N, D>, y: &TVec<N, D>) -> TVec<bool, D>
-where
-    DefaultAllocator: Alloc<N, D>,
-{
+pub fn greater_than_equal<T: Number, const D: usize>(
+    x: &TVec<T, D>,
+    y: &TVec<T, D>,
+) -> TVec<bool, D> {
     x.zip_map(y, |x, y| x >= y)
 }
 
@@ -151,10 +137,7 @@ where
 /// * [`less_than_equal`](fn.less_than_equal.html)
 /// * [`not`](fn.not.html)
 /// * [`not_equal`](fn.not_equal.html)
-pub fn less_than<N: Number, D: Dimension>(x: &TVec<N, D>, y: &TVec<N, D>) -> TVec<bool, D>
-where
-    DefaultAllocator: Alloc<N, D>,
-{
+pub fn less_than<T: Number, const D: usize>(x: &TVec<T, D>, y: &TVec<T, D>) -> TVec<bool, D> {
     x.zip_map(y, |x, y| x < y)
 }
 
@@ -177,10 +160,7 @@ where
 /// * [`less_than`](fn.less_than.html)
 /// * [`not`](fn.not.html)
 /// * [`not_equal`](fn.not_equal.html)
-pub fn less_than_equal<N: Number, D: Dimension>(x: &TVec<N, D>, y: &TVec<N, D>) -> TVec<bool, D>
-where
-    DefaultAllocator: Alloc<N, D>,
-{
+pub fn less_than_equal<T: Number, const D: usize>(x: &TVec<T, D>, y: &TVec<T, D>) -> TVec<bool, D> {
     x.zip_map(y, |x, y| x <= y)
 }
 
@@ -204,10 +184,7 @@ where
 /// * [`less_than`](fn.less_than.html)
 /// * [`less_than_equal`](fn.less_than_equal.html)
 /// * [`not_equal`](fn.not_equal.html)
-pub fn not<D: Dimension>(v: &TVec<bool, D>) -> TVec<bool, D>
-where
-    DefaultAllocator: Alloc<bool, D>,
-{
+pub fn not<const D: usize>(v: &TVec<bool, D>) -> TVec<bool, D> {
     v.map(|x| !x)
 }
 
@@ -230,9 +207,6 @@ where
 /// * [`less_than`](fn.less_than.html)
 /// * [`less_than_equal`](fn.less_than_equal.html)
 /// * [`not`](fn.not.html)
-pub fn not_equal<N: Number, D: Dimension>(x: &TVec<N, D>, y: &TVec<N, D>) -> TVec<bool, D>
-where
-    DefaultAllocator: Alloc<N, D>,
-{
+pub fn not_equal<T: Number, const D: usize>(x: &TVec<T, D>, y: &TVec<T, D>) -> TVec<bool, D> {
     x.zip_map(y, |x, y| x != y)
 }
diff --git a/nalgebra-lapack/Cargo.toml b/nalgebra-lapack/Cargo.toml
index c2de1b96..3da66478 100644
--- a/nalgebra-lapack/Cargo.toml
+++ b/nalgebra-lapack/Cargo.toml
@@ -40,8 +40,8 @@ lapack-src    = { version = "0.6", default-features = false }
 # clippy = "*"
 
 [dev-dependencies]
-nalgebra   = { version = "0.25", features = [ "arbitrary" ], path = ".." }
-proptest = { version = "1", default-features = false, features = ["std"] }
+nalgebra   = { version = "0.25", features = [ "arbitrary", "rand" ], path = ".." }
+proptest   = { version = "1", default-features = false, features = ["std"] }
 quickcheck = "1"
 approx     = "0.4"
 rand       = "0.8"
diff --git a/nalgebra-lapack/benches/linalg/hessenberg.rs b/nalgebra-lapack/benches/linalg/hessenberg.rs
index d62c221c..6a1de81e 100644
--- a/nalgebra-lapack/benches/linalg/hessenberg.rs
+++ b/nalgebra-lapack/benches/linalg/hessenberg.rs
@@ -5,17 +5,17 @@ use test::{self, Bencher};
 #[bench]
 fn hessenberg_decompose_100x100(bh: &mut Bencher) {
     let m = DMatrix::<f64>::new_random(100, 100);
-    bh.iter(|| test::black_box(Hessenberg::new(m.clone())))
+    bh.iter(|| std::hint::black_box(Hessenberg::new(m.clone())))
 }
 
 #[bench]
 fn hessenberg_decompose_4x4(bh: &mut Bencher) {
     let m = Matrix4::<f64>::new_random();
-    bh.iter(|| test::black_box(Hessenberg::new(m.clone())))
+    bh.iter(|| std::hint::black_box(Hessenberg::new(m.clone())))
 }
 
 #[bench]
 fn hessenberg_decompose_500x500(bh: &mut Bencher) {
     let m = DMatrix::<f64>::new_random(500, 500);
-    bh.iter(|| test::black_box(Hessenberg::new(m.clone())))
+    bh.iter(|| std::hint::black_box(Hessenberg::new(m.clone())))
 }
diff --git a/nalgebra-lapack/benches/linalg/lu.rs b/nalgebra-lapack/benches/linalg/lu.rs
index 4afd9003..4f33c757 100644
--- a/nalgebra-lapack/benches/linalg/lu.rs
+++ b/nalgebra-lapack/benches/linalg/lu.rs
@@ -5,29 +5,29 @@ use test::{self, Bencher};
 #[bench]
 fn lu_decompose_100x100(bh: &mut Bencher) {
     let m = DMatrix::<f64>::new_random(100, 100);
-    bh.iter(|| test::black_box(LU::new(m.clone())))
+    bh.iter(|| std::hint::black_box(LU::new(m.clone())))
 }
 
 #[bench]
 fn lu_decompose_100x500(bh: &mut Bencher) {
     let m = DMatrix::<f64>::new_random(100, 500);
-    bh.iter(|| test::black_box(LU::new(m.clone())))
+    bh.iter(|| std::hint::black_box(LU::new(m.clone())))
 }
 
 #[bench]
 fn lu_decompose_4x4(bh: &mut Bencher) {
     let m = Matrix4::<f64>::new_random();
-    bh.iter(|| test::black_box(LU::new(m.clone())))
+    bh.iter(|| std::hint::black_box(LU::new(m.clone())))
 }
 
 #[bench]
 fn lu_decompose_500x100(bh: &mut Bencher) {
     let m = DMatrix::<f64>::new_random(500, 100);
-    bh.iter(|| test::black_box(LU::new(m.clone())))
+    bh.iter(|| std::hint::black_box(LU::new(m.clone())))
 }
 
 #[bench]
 fn lu_decompose_500x500(bh: &mut Bencher) {
     let m = DMatrix::<f64>::new_random(500, 500);
-    bh.iter(|| test::black_box(LU::new(m.clone())))
+    bh.iter(|| std::hint::black_box(LU::new(m.clone())))
 }
diff --git a/nalgebra-lapack/benches/linalg/qr.rs b/nalgebra-lapack/benches/linalg/qr.rs
index c473e6f5..6e74fc52 100644
--- a/nalgebra-lapack/benches/linalg/qr.rs
+++ b/nalgebra-lapack/benches/linalg/qr.rs
@@ -5,29 +5,29 @@ use test::{self, Bencher};
 #[bench]
 fn qr_decompose_100x100(bh: &mut Bencher) {
     let m = DMatrix::<f64>::new_random(100, 100);
-    bh.iter(|| test::black_box(QR::new(m.clone())))
+    bh.iter(|| std::hint::black_box(QR::new(m.clone())))
 }
 
 #[bench]
 fn qr_decompose_100x500(bh: &mut Bencher) {
     let m = DMatrix::<f64>::new_random(100, 500);
-    bh.iter(|| test::black_box(QR::new(m.clone())))
+    bh.iter(|| std::hint::black_box(QR::new(m.clone())))
 }
 
 #[bench]
 fn qr_decompose_4x4(bh: &mut Bencher) {
     let m = Matrix4::<f64>::new_random();
-    bh.iter(|| test::black_box(QR::new(m.clone())))
+    bh.iter(|| std::hint::black_box(QR::new(m.clone())))
 }
 
 #[bench]
 fn qr_decompose_500x100(bh: &mut Bencher) {
     let m = DMatrix::<f64>::new_random(500, 100);
-    bh.iter(|| test::black_box(QR::new(m.clone())))
+    bh.iter(|| std::hint::black_box(QR::new(m.clone())))
 }
 
 #[bench]
 fn qr_decompose_500x500(bh: &mut Bencher) {
     let m = DMatrix::<f64>::new_random(500, 500);
-    bh.iter(|| test::black_box(QR::new(m.clone())))
+    bh.iter(|| std::hint::black_box(QR::new(m.clone())))
 }
diff --git a/nalgebra-lapack/src/cholesky.rs b/nalgebra-lapack/src/cholesky.rs
index 93bf2443..fbbf6fd4 100644
--- a/nalgebra-lapack/src/cholesky.rs
+++ b/nalgebra-lapack/src/cholesky.rs
@@ -7,7 +7,7 @@ use num_complex::Complex;
 use na::allocator::Allocator;
 use na::dimension::Dim;
 use na::storage::Storage;
-use na::{DefaultAllocator, Matrix, MatrixMN, MatrixN, Scalar};
+use na::{DefaultAllocator, Matrix, OMatrix, Scalar};
 
 use lapack;
 
@@ -15,39 +15,39 @@ use lapack;
 #[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
 #[cfg_attr(
     feature = "serde-serialize",
-    serde(bound(serialize = "DefaultAllocator: Allocator<N, D>,
-         MatrixN<N, D>: Serialize"))
+    serde(bound(serialize = "DefaultAllocator: Allocator<T, D>,
+         OMatrix<T, D, D>: Serialize"))
 )]
 #[cfg_attr(
     feature = "serde-serialize",
-    serde(bound(deserialize = "DefaultAllocator: Allocator<N, D>,
-         MatrixN<N, D>: Deserialize<'de>"))
+    serde(bound(deserialize = "DefaultAllocator: Allocator<T, D>,
+         OMatrix<T, D, D>: Deserialize<'de>"))
 )]
 #[derive(Clone, Debug)]
-pub struct Cholesky<N: Scalar, D: Dim>
+pub struct Cholesky<T: Scalar, D: Dim>
 where
-    DefaultAllocator: Allocator<N, D, D>,
+    DefaultAllocator: Allocator<T, D, D>,
 {
-    l: MatrixN<N, D>,
+    l: OMatrix<T, D, D>,
 }
 
-impl<N: Scalar + Copy, D: Dim> Copy for Cholesky<N, D>
+impl<T: Scalar + Copy, D: Dim> Copy for Cholesky<T, D>
 where
-    DefaultAllocator: Allocator<N, D, D>,
-    MatrixN<N, D>: Copy,
+    DefaultAllocator: Allocator<T, D, D>,
+    OMatrix<T, D, D>: Copy,
 {
 }
 
-impl<N: CholeskyScalar + Zero, D: Dim> Cholesky<N, D>
+impl<T: CholeskyScalar + Zero, D: Dim> Cholesky<T, D>
 where
-    DefaultAllocator: Allocator<N, D, D>,
+    DefaultAllocator: Allocator<T, D, D>,
 {
     /// Computes the cholesky decomposition of the given symmetric-definite-positive square
     /// matrix.
     ///
     /// Only the lower-triangular part of the input matrix is considered.
     #[inline]
-    pub fn new(mut m: MatrixN<N, D>) -> Option<Self> {
+    pub fn new(mut m: OMatrix<T, D, D>) -> Option<Self> {
         // TODO: check symmetry as well?
         assert!(
             m.is_square(),
@@ -58,14 +58,14 @@ where
         let dim = m.nrows() as i32;
         let mut info = 0;
 
-        N::xpotrf(uplo, dim, m.as_mut_slice(), dim, &mut info);
+        T::xpotrf(uplo, dim, m.as_mut_slice(), dim, &mut info);
         lapack_check!(info);
 
         Some(Self { l: m })
     }
 
     /// Retrieves the lower-triangular factor of the cholesky decomposition.
-    pub fn unpack(mut self) -> MatrixN<N, D> {
+    pub fn unpack(mut self) -> OMatrix<T, D, D> {
         self.l.fill_upper_triangle(Zero::zero(), 1);
         self.l
     }
@@ -75,12 +75,12 @@ where
     ///
     /// This is an allocation-less version of `self.l()`. The values of the strict upper-triangular
     /// part are garbage and should be ignored by further computations.
-    pub fn unpack_dirty(self) -> MatrixN<N, D> {
+    pub fn unpack_dirty(self) -> OMatrix<T, D, D> {
         self.l
     }
 
     /// Retrieves the lower-triangular factor of the cholesky decomposition.
-    pub fn l(&self) -> MatrixN<N, D> {
+    pub fn l(&self) -> OMatrix<T, D, D> {
         let mut res = self.l.clone();
         res.fill_upper_triangle(Zero::zero(), 1);
         res
@@ -91,7 +91,7 @@ where
     ///
     /// This is an allocation-less version of `self.l()`. The values of the strict upper-triangular
     /// part are garbage and should be ignored by further computations.
-    pub fn l_dirty(&self) -> &MatrixN<N, D> {
+    pub fn l_dirty(&self) -> &OMatrix<T, D, D> {
         &self.l
     }
 
@@ -99,11 +99,11 @@ where
     /// unknown to be determined.
     pub fn solve<R2: Dim, C2: Dim, S2>(
         &self,
-        b: &Matrix<N, R2, C2, S2>,
-    ) -> Option<MatrixMN<N, R2, C2>>
+        b: &Matrix<T, R2, C2, S2>,
+    ) -> Option<OMatrix<T, R2, C2>>
     where
-        S2: Storage<N, R2, C2>,
-        DefaultAllocator: Allocator<N, R2, C2>,
+        S2: Storage<T, R2, C2>,
+        DefaultAllocator: Allocator<T, R2, C2>,
     {
         let mut res = b.clone_owned();
         if self.solve_mut(&mut res) {
@@ -115,9 +115,9 @@ where
 
     /// Solves in-place the symmetric-definite-positive linear system `self * x = b`, where `x` is
     /// the unknown to be determined.
-    pub fn solve_mut<R2: Dim, C2: Dim>(&self, b: &mut MatrixMN<N, R2, C2>) -> bool
+    pub fn solve_mut<R2: Dim, C2: Dim>(&self, b: &mut OMatrix<T, R2, C2>) -> bool
     where
-        DefaultAllocator: Allocator<N, R2, C2>,
+        DefaultAllocator: Allocator<T, R2, C2>,
     {
         let dim = self.l.nrows();
 
@@ -131,7 +131,7 @@ where
         let ldb = dim as i32;
         let mut info = 0;
 
-        N::xpotrs(
+        T::xpotrs(
             b'L',
             dim as i32,
             nrhs,
@@ -145,11 +145,11 @@ where
     }
 
     /// Computes the inverse of the decomposed matrix.
-    pub fn inverse(mut self) -> Option<MatrixN<N, D>> {
+    pub fn inverse(mut self) -> Option<OMatrix<T, D, D>> {
         let dim = self.l.nrows();
         let mut info = 0;
 
-        N::xpotri(
+        T::xpotri(
             b'L',
             dim as i32,
             self.l.as_mut_slice(),
diff --git a/nalgebra-lapack/src/eigen.rs b/nalgebra-lapack/src/eigen.rs
index 1aae842c..cbe1555a 100644
--- a/nalgebra-lapack/src/eigen.rs
+++ b/nalgebra-lapack/src/eigen.rs
@@ -8,9 +8,9 @@ use simba::scalar::RealField;
 
 use crate::ComplexHelper;
 use na::allocator::Allocator;
-use na::dimension::{Dim, U1};
+use na::dimension::{Const, Dim};
 use na::storage::Storage;
-use na::{DefaultAllocator, Matrix, MatrixN, Scalar, VectorN};
+use na::{DefaultAllocator, Matrix, OMatrix, OVector, Scalar};
 
 use lapack;
 
@@ -19,74 +19,74 @@ use lapack;
 #[cfg_attr(
     feature = "serde-serialize",
     serde(
-        bound(serialize = "DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>,
-         VectorN<N, D>: Serialize,
-         MatrixN<N, D>: Serialize")
+        bound(serialize = "DefaultAllocator: Allocator<T, D, D> + Allocator<T, D>,
+         OVector<T, D>: Serialize,
+         OMatrix<T, D, D>: Serialize")
     )
 )]
 #[cfg_attr(
     feature = "serde-serialize",
     serde(
-        bound(deserialize = "DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>,
-         VectorN<N, D>: Serialize,
-         MatrixN<N, D>: Deserialize<'de>")
+        bound(deserialize = "DefaultAllocator: Allocator<T, D, D> + Allocator<T, D>,
+         OVector<T, D>: Serialize,
+         OMatrix<T, D, D>: Deserialize<'de>")
     )
 )]
 #[derive(Clone, Debug)]
-pub struct Eigen<N: Scalar, D: Dim>
+pub struct Eigen<T: Scalar, D: Dim>
 where
-    DefaultAllocator: Allocator<N, D> + Allocator<N, D, D>,
+    DefaultAllocator: Allocator<T, D> + Allocator<T, D, D>,
 {
     /// The eigenvalues of the decomposed matrix.
-    pub eigenvalues: VectorN<N, D>,
+    pub eigenvalues: OVector<T, D>,
     /// The (right) eigenvectors of the decomposed matrix.
-    pub eigenvectors: Option<MatrixN<N, D>>,
+    pub eigenvectors: Option<OMatrix<T, D, D>>,
     /// The left eigenvectors of the decomposed matrix.
-    pub left_eigenvectors: Option<MatrixN<N, D>>,
+    pub left_eigenvectors: Option<OMatrix<T, D, D>>,
 }
 
-impl<N: Scalar + Copy, D: Dim> Copy for Eigen<N, D>
+impl<T: Scalar + Copy, D: Dim> Copy for Eigen<T, D>
 where
-    DefaultAllocator: Allocator<N, D> + Allocator<N, D, D>,
-    VectorN<N, D>: Copy,
-    MatrixN<N, D>: Copy,
+    DefaultAllocator: Allocator<T, D> + Allocator<T, D, D>,
+    OVector<T, D>: Copy,
+    OMatrix<T, D, D>: Copy,
 {
 }
 
-impl<N: EigenScalar + RealField, D: Dim> Eigen<N, D>
+impl<T: EigenScalar + RealField, D: Dim> Eigen<T, D>
 where
-    DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>,
+    DefaultAllocator: Allocator<T, D, D> + Allocator<T, D>,
 {
     /// Computes the eigenvalues and eigenvectors of the square matrix `m`.
     ///
     /// If `eigenvectors` is `false` then, the eigenvectors are not computed explicitly.
     pub fn new(
-        mut m: MatrixN<N, D>,
+        mut m: OMatrix<T, D, D>,
         left_eigenvectors: bool,
         eigenvectors: bool,
-    ) -> Option<Eigen<N, D>> {
+    ) -> Option<Eigen<T, 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 ljob = if left_eigenvectors { b'V' } else { b'T' };
+        let rjob = if eigenvectors { b'V' } else { b'T' };
 
         let (nrows, ncols) = m.data.shape();
         let n = nrows.value();
 
         let lda = n as i32;
 
-        let mut wr = unsafe { Matrix::new_uninitialized_generic(nrows, U1).assume_init() };
+        let mut wr = unsafe { Matrix::new_uninitialized_generic(nrows, Const::<1>).assume_init() };
         // TODO: Tap into the workspace.
-        let mut wi = unsafe { Matrix::new_uninitialized_generic(nrows, U1).assume_init() };
+        let mut wi = unsafe { Matrix::new_uninitialized_generic(nrows, Const::<1>).assume_init() };
 
         let mut info = 0;
-        let mut placeholder1 = [N::zero()];
-        let mut placeholder2 = [N::zero()];
+        let mut placeholder1 = [T::zero()];
+        let mut placeholder2 = [T::zero()];
 
-        let lwork = N::xgeev_work_size(
+        let lwork = T::xgeev_work_size(
             ljob,
             rjob,
             n as i32,
@@ -112,7 +112,7 @@ where
                 let mut vr =
                     unsafe { Matrix::new_uninitialized_generic(nrows, ncols).assume_init() };
 
-                N::xgeev(
+                T::xgeev(
                     ljob,
                     rjob,
                     n as i32,
@@ -142,7 +142,7 @@ where
                 let mut vl =
                     unsafe { Matrix::new_uninitialized_generic(nrows, ncols).assume_init() };
 
-                N::xgeev(
+                T::xgeev(
                     ljob,
                     rjob,
                     n as i32,
@@ -172,7 +172,7 @@ where
                 let mut vr =
                     unsafe { Matrix::new_uninitialized_generic(nrows, ncols).assume_init() };
 
-                N::xgeev(
+                T::xgeev(
                     ljob,
                     rjob,
                     n as i32,
@@ -199,7 +199,7 @@ where
                 }
             }
             (false, false) => {
-                N::xgeev(
+                T::xgeev(
                     ljob,
                     rjob,
                     n as i32,
@@ -233,9 +233,9 @@ where
     /// The complex eigenvalues of the given matrix.
     ///
     /// Panics if the eigenvalue computation does not converge.
-    pub fn complex_eigenvalues(mut m: MatrixN<N, D>) -> VectorN<Complex<N>, D>
+    pub fn complex_eigenvalues(mut m: OMatrix<T, D, D>) -> OVector<Complex<T>, D>
     where
-        DefaultAllocator: Allocator<Complex<N>, D>,
+        DefaultAllocator: Allocator<Complex<T>, D>,
     {
         assert!(
             m.is_square(),
@@ -247,16 +247,16 @@ where
 
         let lda = n as i32;
 
-        let mut wr = unsafe { Matrix::new_uninitialized_generic(nrows, U1).assume_init() };
-        let mut wi = unsafe { Matrix::new_uninitialized_generic(nrows, U1).assume_init() };
+        let mut wr = unsafe { Matrix::new_uninitialized_generic(nrows, Const::<1>).assume_init() };
+        let mut wi = unsafe { Matrix::new_uninitialized_generic(nrows, Const::<1>).assume_init() };
 
         let mut info = 0;
-        let mut placeholder1 = [N::zero()];
-        let mut placeholder2 = [N::zero()];
+        let mut placeholder1 = [T::zero()];
+        let mut placeholder2 = [T::zero()];
 
-        let lwork = N::xgeev_work_size(
-            b'N',
-            b'N',
+        let lwork = T::xgeev_work_size(
+            b'T',
+            b'T',
             n as i32,
             m.as_mut_slice(),
             lda,
@@ -273,9 +273,9 @@ where
 
         let mut work = unsafe { crate::uninitialized_vec(lwork as usize) };
 
-        N::xgeev(
-            b'N',
-            b'N',
+        T::xgeev(
+            b'T',
+            b'T',
             n as i32,
             m.as_mut_slice(),
             lda,
@@ -291,7 +291,7 @@ where
         );
         lapack_panic!(info);
 
-        let mut res = unsafe { Matrix::new_uninitialized_generic(nrows, U1).assume_init() };
+        let mut res = unsafe { Matrix::new_uninitialized_generic(nrows, Const::<1>).assume_init() };
 
         for i in 0..res.len() {
             res[i] = Complex::new(wr[i], wi[i]);
@@ -302,8 +302,8 @@ where
 
     /// The determinant of the decomposed matrix.
     #[inline]
-    pub fn determinant(&self) -> N {
-        let mut det = N::one();
+    pub fn determinant(&self) -> T {
+        let mut det = T::one();
         for e in self.eigenvalues.iter() {
             det *= *e;
         }
diff --git a/nalgebra-lapack/src/hessenberg.rs b/nalgebra-lapack/src/hessenberg.rs
index ed456ecb..b025a8bf 100644
--- a/nalgebra-lapack/src/hessenberg.rs
+++ b/nalgebra-lapack/src/hessenberg.rs
@@ -3,9 +3,9 @@ use num_complex::Complex;
 
 use crate::ComplexHelper;
 use na::allocator::Allocator;
-use na::dimension::{DimDiff, DimSub, U1};
+use na::dimension::{Const, DimDiff, DimSub, U1};
 use na::storage::Storage;
-use na::{DefaultAllocator, Matrix, MatrixN, Scalar, VectorN};
+use na::{DefaultAllocator, Matrix, OMatrix, OVector, Scalar};
 
 use lapack;
 
@@ -13,41 +13,41 @@ use lapack;
 #[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
 #[cfg_attr(
     feature = "serde-serialize",
-    serde(bound(serialize = "DefaultAllocator: Allocator<N, D, D> +
-                           Allocator<N, DimDiff<D, U1>>,
-         MatrixN<N, D>: Serialize,
-         VectorN<N, DimDiff<D, U1>>: Serialize"))
+    serde(bound(serialize = "DefaultAllocator: Allocator<T, D, D> +
+                           Allocator<T, DimDiff<D, U1>>,
+         OMatrix<T, D, D>: Serialize,
+         OVector<T, DimDiff<D, U1>>: Serialize"))
 )]
 #[cfg_attr(
     feature = "serde-serialize",
-    serde(bound(deserialize = "DefaultAllocator: Allocator<N, D, D> +
-                           Allocator<N, DimDiff<D, U1>>,
-         MatrixN<N, D>: Deserialize<'de>,
-         VectorN<N, DimDiff<D, U1>>: Deserialize<'de>"))
+    serde(bound(deserialize = "DefaultAllocator: Allocator<T, D, D> +
+                           Allocator<T, DimDiff<D, U1>>,
+         OMatrix<T, D, D>: Deserialize<'de>,
+         OVector<T, DimDiff<D, U1>>: Deserialize<'de>"))
 )]
 #[derive(Clone, Debug)]
-pub struct Hessenberg<N: Scalar, D: DimSub<U1>>
+pub struct Hessenberg<T: Scalar, D: DimSub<U1>>
 where
-    DefaultAllocator: Allocator<N, D, D> + Allocator<N, DimDiff<D, U1>>,
+    DefaultAllocator: Allocator<T, D, D> + Allocator<T, DimDiff<D, U1>>,
 {
-    h: MatrixN<N, D>,
-    tau: VectorN<N, DimDiff<D, U1>>,
+    h: OMatrix<T, D, D>,
+    tau: OVector<T, DimDiff<D, U1>>,
 }
 
-impl<N: Scalar + Copy, D: DimSub<U1>> Copy for Hessenberg<N, D>
+impl<T: Scalar + Copy, D: DimSub<U1>> Copy for Hessenberg<T, D>
 where
-    DefaultAllocator: Allocator<N, D, D> + Allocator<N, DimDiff<D, U1>>,
-    MatrixN<N, D>: Copy,
-    VectorN<N, DimDiff<D, U1>>: Copy,
+    DefaultAllocator: Allocator<T, D, D> + Allocator<T, DimDiff<D, U1>>,
+    OMatrix<T, D, D>: Copy,
+    OVector<T, DimDiff<D, U1>>: Copy,
 {
 }
 
-impl<N: HessenbergScalar + Zero, D: DimSub<U1>> Hessenberg<N, D>
+impl<T: HessenbergScalar + Zero, D: DimSub<U1>> Hessenberg<T, D>
 where
-    DefaultAllocator: Allocator<N, D, D> + Allocator<N, DimDiff<D, U1>>,
+    DefaultAllocator: Allocator<T, D, D> + Allocator<T, DimDiff<D, U1>>,
 {
     /// Computes the hessenberg decomposition of the matrix `m`.
-    pub fn new(mut m: MatrixN<N, D>) -> Self {
+    pub fn new(mut m: OMatrix<T, D, D>) -> Self {
         let nrows = m.data.shape().0;
         let n = nrows.value() as i32;
 
@@ -60,16 +60,18 @@ where
             "Unable to compute the hessenberg decomposition of an empty matrix."
         );
 
-        let mut tau = unsafe { Matrix::new_uninitialized_generic(nrows.sub(U1), U1).assume_init() };
+        let mut tau = unsafe {
+            Matrix::new_uninitialized_generic(nrows.sub(Const::<1>), Const::<1>).assume_init()
+        };
 
         let mut info = 0;
         let lwork =
-            N::xgehrd_work_size(n, 1, n, m.as_mut_slice(), n, tau.as_mut_slice(), &mut info);
+            T::xgehrd_work_size(n, 1, n, m.as_mut_slice(), n, tau.as_mut_slice(), &mut info);
         let mut work = unsafe { crate::uninitialized_vec(lwork as usize) };
 
         lapack_panic!(info);
 
-        N::xgehrd(
+        T::xgehrd(
             n,
             1,
             n,
@@ -87,36 +89,36 @@ where
 
     /// Computes the hessenberg matrix of this decomposition.
     #[inline]
-    pub fn h(&self) -> MatrixN<N, D> {
+    pub fn h(&self) -> OMatrix<T, D, D> {
         let mut h = self.h.clone_owned();
-        h.fill_lower_triangle(N::zero(), 2);
+        h.fill_lower_triangle(T::zero(), 2);
 
         h
     }
 }
 
-impl<N: HessenbergReal + Zero, D: DimSub<U1>> Hessenberg<N, D>
+impl<T: HessenbergReal + Zero, D: DimSub<U1>> Hessenberg<T, D>
 where
-    DefaultAllocator: Allocator<N, D, D> + Allocator<N, DimDiff<D, U1>>,
+    DefaultAllocator: Allocator<T, D, D> + Allocator<T, DimDiff<D, U1>>,
 {
     /// Computes the matrices `(Q, H)` of this decomposition.
     #[inline]
-    pub fn unpack(self) -> (MatrixN<N, D>, MatrixN<N, D>) {
+    pub fn unpack(self) -> (OMatrix<T, D, D>, OMatrix<T, D, D>) {
         (self.q(), self.h())
     }
 
     /// Computes the unitary matrix `Q` of this decomposition.
     #[inline]
-    pub fn q(&self) -> MatrixN<N, D> {
+    pub fn q(&self) -> OMatrix<T, D, D> {
         let n = self.h.nrows() as i32;
         let mut q = self.h.clone_owned();
         let mut info = 0;
 
         let lwork =
-            N::xorghr_work_size(n, 1, n, q.as_mut_slice(), n, self.tau.as_slice(), &mut info);
-        let mut work = vec![N::zero(); lwork as usize];
+            T::xorghr_work_size(n, 1, n, q.as_mut_slice(), n, self.tau.as_slice(), &mut info);
+        let mut work = vec![T::zero(); lwork as usize];
 
-        N::xorghr(
+        T::xorghr(
             n,
             1,
             n,
diff --git a/nalgebra-lapack/src/lu.rs b/nalgebra-lapack/src/lu.rs
index 17245fb9..5ca5f143 100644
--- a/nalgebra-lapack/src/lu.rs
+++ b/nalgebra-lapack/src/lu.rs
@@ -3,9 +3,9 @@ use num_complex::Complex;
 
 use crate::ComplexHelper;
 use na::allocator::Allocator;
-use na::dimension::{Dim, DimMin, DimMinimum, U1};
+use na::dimension::{Const, Dim, DimMin, DimMinimum};
 use na::storage::Storage;
-use na::{DefaultAllocator, Matrix, MatrixMN, MatrixN, Scalar, VectorN};
+use na::{DefaultAllocator, Matrix, OMatrix, OVector, Scalar};
 
 use lapack;
 
@@ -20,57 +20,57 @@ use lapack;
 #[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
 #[cfg_attr(
     feature = "serde-serialize",
-    serde(bound(serialize = "DefaultAllocator: Allocator<N, R, C> +
+    serde(bound(serialize = "DefaultAllocator: Allocator<T, R, C> +
                            Allocator<i32, DimMinimum<R, C>>,
-         MatrixMN<N, R, C>: Serialize,
+         OMatrix<T, R, C>: Serialize,
          PermutationSequence<DimMinimum<R, C>>: Serialize"))
 )]
 #[cfg_attr(
     feature = "serde-serialize",
-    serde(bound(deserialize = "DefaultAllocator: Allocator<N, R, C> +
+    serde(bound(deserialize = "DefaultAllocator: Allocator<T, R, C> +
                            Allocator<i32, DimMinimum<R, C>>,
-         MatrixMN<N, R, C>: Deserialize<'de>,
+         OMatrix<T, R, C>: Deserialize<'de>,
          PermutationSequence<DimMinimum<R, C>>: Deserialize<'de>"))
 )]
 #[derive(Clone, Debug)]
-pub struct LU<N: Scalar, R: DimMin<C>, C: Dim>
+pub struct LU<T: Scalar, R: DimMin<C>, C: Dim>
 where
-    DefaultAllocator: Allocator<i32, DimMinimum<R, C>> + Allocator<N, R, C>,
+    DefaultAllocator: Allocator<i32, DimMinimum<R, C>> + Allocator<T, R, C>,
 {
-    lu: MatrixMN<N, R, C>,
-    p: VectorN<i32, DimMinimum<R, C>>,
+    lu: OMatrix<T, R, C>,
+    p: OVector<i32, DimMinimum<R, C>>,
 }
 
-impl<N: Scalar + Copy, R: DimMin<C>, C: Dim> Copy for LU<N, R, C>
+impl<T: Scalar + Copy, R: DimMin<C>, C: Dim> Copy for LU<T, R, C>
 where
-    DefaultAllocator: Allocator<N, R, C> + Allocator<i32, DimMinimum<R, C>>,
-    MatrixMN<N, R, C>: Copy,
-    VectorN<i32, DimMinimum<R, C>>: Copy,
+    DefaultAllocator: Allocator<T, R, C> + Allocator<i32, DimMinimum<R, C>>,
+    OMatrix<T, R, C>: Copy,
+    OVector<i32, DimMinimum<R, C>>: Copy,
 {
 }
 
-impl<N: LUScalar, R: Dim, C: Dim> LU<N, R, C>
+impl<T: LUScalar, R: Dim, C: Dim> LU<T, R, C>
 where
-    N: Zero + One,
+    T: Zero + One,
     R: DimMin<C>,
-    DefaultAllocator: Allocator<N, R, C>
-        + Allocator<N, R, R>
-        + Allocator<N, R, DimMinimum<R, C>>
-        + Allocator<N, DimMinimum<R, C>, C>
+    DefaultAllocator: Allocator<T, R, C>
+        + Allocator<T, R, R>
+        + Allocator<T, R, DimMinimum<R, C>>
+        + Allocator<T, DimMinimum<R, C>, C>
         + Allocator<i32, DimMinimum<R, C>>,
 {
     /// Computes the LU decomposition with partial (row) pivoting of `matrix`.
-    pub fn new(mut m: MatrixMN<N, R, C>) -> Self {
+    pub fn new(mut m: OMatrix<T, R, C>) -> Self {
         let (nrows, ncols) = m.data.shape();
         let min_nrows_ncols = nrows.min(ncols);
         let nrows = nrows.value() as i32;
         let ncols = ncols.value() as i32;
 
-        let mut ipiv: VectorN<i32, _> = Matrix::zeros_generic(min_nrows_ncols, U1);
+        let mut ipiv: OVector<i32, _> = Matrix::zeros_generic(min_nrows_ncols, Const::<1>);
 
         let mut info = 0;
 
-        N::xgetrf(
+        T::xgetrf(
             nrows,
             ncols,
             m.as_mut_slice(),
@@ -85,7 +85,7 @@ where
 
     /// Gets the lower-triangular matrix part of the decomposition.
     #[inline]
-    pub fn l(&self) -> MatrixMN<N, R, DimMinimum<R, C>> {
+    pub fn l(&self) -> OMatrix<T, R, DimMinimum<R, C>> {
         let (nrows, ncols) = self.lu.data.shape();
         let mut res = self.lu.columns_generic(0, nrows.min(ncols)).into_owned();
 
@@ -97,7 +97,7 @@ where
 
     /// Gets the upper-triangular matrix part of the decomposition.
     #[inline]
-    pub fn u(&self) -> MatrixMN<N, DimMinimum<R, C>, C> {
+    pub fn u(&self) -> OMatrix<T, DimMinimum<R, C>, C> {
         let (nrows, ncols) = self.lu.data.shape();
         let mut res = self.lu.rows_generic(0, nrows.min(ncols)).into_owned();
 
@@ -111,7 +111,7 @@ where
     /// Computing the permutation matrix explicitly is costly and usually not necessary.
     /// To permute rows of a matrix or vector, use the method `self.permute(...)` instead.
     #[inline]
-    pub fn p(&self) -> MatrixN<N, R> {
+    pub fn p(&self) -> OMatrix<T, R, R> {
         let (dim, _) = self.lu.data.shape();
         let mut id = Matrix::identity_generic(dim, dim);
         self.permute(&mut id);
@@ -124,19 +124,19 @@ where
 
     /// Gets the LAPACK permutation indices.
     #[inline]
-    pub fn permutation_indices(&self) -> &VectorN<i32, DimMinimum<R, C>> {
+    pub fn permutation_indices(&self) -> &OVector<i32, DimMinimum<R, C>> {
         &self.p
     }
 
     /// Applies the permutation matrix to a given matrix or vector in-place.
     #[inline]
-    pub fn permute<C2: Dim>(&self, rhs: &mut MatrixMN<N, R, C2>)
+    pub fn permute<C2: Dim>(&self, rhs: &mut OMatrix<T, R, C2>)
     where
-        DefaultAllocator: Allocator<N, R, C2>,
+        DefaultAllocator: Allocator<T, R, C2>,
     {
         let (nrows, ncols) = rhs.shape();
 
-        N::xlaswp(
+        T::xlaswp(
             ncols as i32,
             rhs.as_mut_slice(),
             nrows as i32,
@@ -147,9 +147,9 @@ where
         );
     }
 
-    fn generic_solve_mut<R2: Dim, C2: Dim>(&self, trans: u8, b: &mut MatrixMN<N, R2, C2>) -> bool
+    fn generic_solve_mut<R2: Dim, C2: Dim>(&self, trans: u8, b: &mut OMatrix<T, R2, C2>) -> bool
     where
-        DefaultAllocator: Allocator<N, R2, C2> + Allocator<i32, R2>,
+        DefaultAllocator: Allocator<T, R2, C2> + Allocator<i32, R2>,
     {
         let dim = self.lu.nrows();
 
@@ -167,7 +167,7 @@ where
         let ldb = dim as i32;
         let mut info = 0;
 
-        N::xgetrs(
+        T::xgetrs(
             trans,
             dim as i32,
             nrhs,
@@ -184,14 +184,14 @@ where
     /// Solves the linear system `self * x = b`, where `x` is the unknown to be determined.
     pub fn solve<R2: Dim, C2: Dim, S2>(
         &self,
-        b: &Matrix<N, R2, C2, S2>,
-    ) -> Option<MatrixMN<N, R2, C2>>
+        b: &Matrix<T, R2, C2, S2>,
+    ) -> Option<OMatrix<T, R2, C2>>
     where
-        S2: Storage<N, R2, C2>,
-        DefaultAllocator: Allocator<N, R2, C2> + Allocator<i32, R2>,
+        S2: Storage<T, R2, C2>,
+        DefaultAllocator: Allocator<T, R2, C2> + Allocator<i32, R2>,
     {
         let mut res = b.clone_owned();
-        if self.generic_solve_mut(b'N', &mut res) {
+        if self.generic_solve_mut(b'T', &mut res) {
             Some(res)
         } else {
             None
@@ -202,11 +202,11 @@ where
     /// determined.
     pub fn solve_transpose<R2: Dim, C2: Dim, S2>(
         &self,
-        b: &Matrix<N, R2, C2, S2>,
-    ) -> Option<MatrixMN<N, R2, C2>>
+        b: &Matrix<T, R2, C2, S2>,
+    ) -> Option<OMatrix<T, R2, C2>>
     where
-        S2: Storage<N, R2, C2>,
-        DefaultAllocator: Allocator<N, R2, C2> + Allocator<i32, R2>,
+        S2: Storage<T, R2, C2>,
+        DefaultAllocator: Allocator<T, R2, C2> + Allocator<i32, R2>,
     {
         let mut res = b.clone_owned();
         if self.generic_solve_mut(b'T', &mut res) {
@@ -220,11 +220,11 @@ where
     /// be determined.
     pub fn solve_conjugate_transpose<R2: Dim, C2: Dim, S2>(
         &self,
-        b: &Matrix<N, R2, C2, S2>,
-    ) -> Option<MatrixMN<N, R2, C2>>
+        b: &Matrix<T, R2, C2, S2>,
+    ) -> Option<OMatrix<T, R2, C2>>
     where
-        S2: Storage<N, R2, C2>,
-        DefaultAllocator: Allocator<N, R2, C2> + Allocator<i32, R2>,
+        S2: Storage<T, R2, C2>,
+        DefaultAllocator: Allocator<T, R2, C2> + Allocator<i32, R2>,
     {
         let mut res = b.clone_owned();
         if self.generic_solve_mut(b'T', &mut res) {
@@ -237,20 +237,20 @@ where
     /// Solves in-place the linear system `self * x = b`, where `x` is the unknown to be determined.
     ///
     /// Returns `false` if no solution was found (the decomposed matrix is singular).
-    pub fn solve_mut<R2: Dim, C2: Dim>(&self, b: &mut MatrixMN<N, R2, C2>) -> bool
+    pub fn solve_mut<R2: Dim, C2: Dim>(&self, b: &mut OMatrix<T, R2, C2>) -> bool
     where
-        DefaultAllocator: Allocator<N, R2, C2> + Allocator<i32, R2>,
+        DefaultAllocator: Allocator<T, R2, C2> + Allocator<i32, R2>,
     {
-        self.generic_solve_mut(b'N', b)
+        self.generic_solve_mut(b'T', b)
     }
 
     /// Solves in-place the linear system `self.transpose() * x = b`, where `x` is the unknown to be
     /// determined.
     ///
     /// Returns `false` if no solution was found (the decomposed matrix is singular).
-    pub fn solve_transpose_mut<R2: Dim, C2: Dim>(&self, b: &mut MatrixMN<N, R2, C2>) -> bool
+    pub fn solve_transpose_mut<R2: Dim, C2: Dim>(&self, b: &mut OMatrix<T, R2, C2>) -> bool
     where
-        DefaultAllocator: Allocator<N, R2, C2> + Allocator<i32, R2>,
+        DefaultAllocator: Allocator<T, R2, C2> + Allocator<i32, R2>,
     {
         self.generic_solve_mut(b'T', b)
     }
@@ -259,25 +259,25 @@ where
     /// be determined.
     ///
     /// Returns `false` if no solution was found (the decomposed matrix is singular).
-    pub fn solve_adjoint_mut<R2: Dim, C2: Dim>(&self, b: &mut MatrixMN<N, R2, C2>) -> bool
+    pub fn solve_adjoint_mut<R2: Dim, C2: Dim>(&self, b: &mut OMatrix<T, R2, C2>) -> bool
     where
-        DefaultAllocator: Allocator<N, R2, C2> + Allocator<i32, R2>,
+        DefaultAllocator: Allocator<T, R2, C2> + Allocator<i32, R2>,
     {
         self.generic_solve_mut(b'T', b)
     }
 }
 
-impl<N: LUScalar, D: Dim> LU<N, D, D>
+impl<T: LUScalar, D: Dim> LU<T, D, D>
 where
-    N: Zero + One,
+    T: Zero + One,
     D: DimMin<D, Output = D>,
-    DefaultAllocator: Allocator<N, D, D> + Allocator<i32, D>,
+    DefaultAllocator: Allocator<T, D, D> + Allocator<i32, D>,
 {
     /// Computes the inverse of the decomposed matrix.
-    pub fn inverse(mut self) -> Option<MatrixN<N, D>> {
+    pub fn inverse(mut self) -> Option<OMatrix<T, D, D>> {
         let dim = self.lu.nrows() as i32;
         let mut info = 0;
-        let lwork = N::xgetri_work_size(
+        let lwork = T::xgetri_work_size(
             dim,
             self.lu.as_mut_slice(),
             dim,
@@ -288,7 +288,7 @@ where
 
         let mut work = unsafe { crate::uninitialized_vec(lwork as usize) };
 
-        N::xgetri(
+        T::xgetri(
             dim,
             self.lu.as_mut_slice(),
             dim,
diff --git a/nalgebra-lapack/src/qr.rs b/nalgebra-lapack/src/qr.rs
index c9216135..b58c3f35 100644
--- a/nalgebra-lapack/src/qr.rs
+++ b/nalgebra-lapack/src/qr.rs
@@ -6,9 +6,9 @@ use num_complex::Complex;
 
 use crate::ComplexHelper;
 use na::allocator::Allocator;
-use na::dimension::{Dim, DimMin, DimMinimum, U1};
+use na::dimension::{Const, Dim, DimMin, DimMinimum};
 use na::storage::Storage;
-use na::{DefaultAllocator, Matrix, MatrixMN, Scalar, VectorN};
+use na::{DefaultAllocator, Matrix, OMatrix, OVector, Scalar};
 
 use lapack;
 
@@ -16,55 +16,56 @@ use lapack;
 #[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
 #[cfg_attr(
     feature = "serde-serialize",
-    serde(bound(serialize = "DefaultAllocator: Allocator<N, R, C> +
-                           Allocator<N, DimMinimum<R, C>>,
-         MatrixMN<N, R, C>: Serialize,
-         VectorN<N, DimMinimum<R, C>>: Serialize"))
+    serde(bound(serialize = "DefaultAllocator: Allocator<T, R, C> +
+                           Allocator<T, DimMinimum<R, C>>,
+         OMatrix<T, R, C>: Serialize,
+         OVector<T, DimMinimum<R, C>>: Serialize"))
 )]
 #[cfg_attr(
     feature = "serde-serialize",
-    serde(bound(deserialize = "DefaultAllocator: Allocator<N, R, C> +
-                           Allocator<N, DimMinimum<R, C>>,
-         MatrixMN<N, R, C>: Deserialize<'de>,
-         VectorN<N, DimMinimum<R, C>>: Deserialize<'de>"))
+    serde(bound(deserialize = "DefaultAllocator: Allocator<T, R, C> +
+                           Allocator<T, DimMinimum<R, C>>,
+         OMatrix<T, R, C>: Deserialize<'de>,
+         OVector<T, DimMinimum<R, C>>: Deserialize<'de>"))
 )]
 #[derive(Clone, Debug)]
-pub struct QR<N: Scalar, R: DimMin<C>, C: Dim>
+pub struct QR<T: Scalar, R: DimMin<C>, C: Dim>
 where
-    DefaultAllocator: Allocator<N, R, C> + Allocator<N, DimMinimum<R, C>>,
+    DefaultAllocator: Allocator<T, R, C> + Allocator<T, DimMinimum<R, C>>,
 {
-    qr: MatrixMN<N, R, C>,
-    tau: VectorN<N, DimMinimum<R, C>>,
+    qr: OMatrix<T, R, C>,
+    tau: OVector<T, DimMinimum<R, C>>,
 }
 
-impl<N: Scalar + Copy, R: DimMin<C>, C: Dim> Copy for QR<N, R, C>
+impl<T: Scalar + Copy, R: DimMin<C>, C: Dim> Copy for QR<T, R, C>
 where
-    DefaultAllocator: Allocator<N, R, C> + Allocator<N, DimMinimum<R, C>>,
-    MatrixMN<N, R, C>: Copy,
-    VectorN<N, DimMinimum<R, C>>: Copy,
+    DefaultAllocator: Allocator<T, R, C> + Allocator<T, DimMinimum<R, C>>,
+    OMatrix<T, R, C>: Copy,
+    OVector<T, DimMinimum<R, C>>: Copy,
 {
 }
 
-impl<N: QRScalar + Zero, R: DimMin<C>, C: Dim> QR<N, R, C>
+impl<T: QRScalar + Zero, R: DimMin<C>, C: Dim> QR<T, R, C>
 where
-    DefaultAllocator: Allocator<N, R, C>
-        + Allocator<N, R, DimMinimum<R, C>>
-        + Allocator<N, DimMinimum<R, C>, C>
-        + Allocator<N, DimMinimum<R, C>>,
+    DefaultAllocator: Allocator<T, R, C>
+        + Allocator<T, R, DimMinimum<R, C>>
+        + Allocator<T, DimMinimum<R, C>, C>
+        + Allocator<T, DimMinimum<R, C>>,
 {
     /// Computes the QR decomposition of the matrix `m`.
-    pub fn new(mut m: MatrixMN<N, R, C>) -> Self {
+    pub fn new(mut m: OMatrix<T, R, C>) -> Self {
         let (nrows, ncols) = m.data.shape();
 
         let mut info = 0;
-        let mut tau =
-            unsafe { Matrix::new_uninitialized_generic(nrows.min(ncols), U1).assume_init() };
+        let mut tau = unsafe {
+            Matrix::new_uninitialized_generic(nrows.min(ncols), Const::<1>).assume_init()
+        };
 
         if nrows.value() == 0 || ncols.value() == 0 {
             return Self { qr: m, tau: tau };
         }
 
-        let lwork = N::xgeqrf_work_size(
+        let lwork = T::xgeqrf_work_size(
             nrows.value() as i32,
             ncols.value() as i32,
             m.as_mut_slice(),
@@ -75,7 +76,7 @@ where
 
         let mut work = unsafe { crate::uninitialized_vec(lwork as usize) };
 
-        N::xgeqrf(
+        T::xgeqrf(
             nrows.value() as i32,
             ncols.value() as i32,
             m.as_mut_slice(),
@@ -91,37 +92,37 @@ where
 
     /// Retrieves the upper trapezoidal submatrix `R` of this decomposition.
     #[inline]
-    pub fn r(&self) -> MatrixMN<N, DimMinimum<R, C>, C> {
+    pub fn r(&self) -> OMatrix<T, DimMinimum<R, C>, C> {
         let (nrows, ncols) = self.qr.data.shape();
         self.qr.rows_generic(0, nrows.min(ncols)).upper_triangle()
     }
 }
 
-impl<N: QRReal + Zero, R: DimMin<C>, C: Dim> QR<N, R, C>
+impl<T: QRReal + Zero, R: DimMin<C>, C: Dim> QR<T, R, C>
 where
-    DefaultAllocator: Allocator<N, R, C>
-        + Allocator<N, R, DimMinimum<R, C>>
-        + Allocator<N, DimMinimum<R, C>, C>
-        + Allocator<N, DimMinimum<R, C>>,
+    DefaultAllocator: Allocator<T, R, C>
+        + Allocator<T, R, DimMinimum<R, C>>
+        + Allocator<T, DimMinimum<R, C>, C>
+        + Allocator<T, DimMinimum<R, C>>,
 {
     /// Retrieves the matrices `(Q, R)` of this decompositions.
     pub fn unpack(
         self,
     ) -> (
-        MatrixMN<N, R, DimMinimum<R, C>>,
-        MatrixMN<N, DimMinimum<R, C>, C>,
+        OMatrix<T, R, DimMinimum<R, C>>,
+        OMatrix<T, DimMinimum<R, C>, C>,
     ) {
         (self.q(), self.r())
     }
 
     /// Computes the orthogonal matrix `Q` of this decomposition.
     #[inline]
-    pub fn q(&self) -> MatrixMN<N, R, DimMinimum<R, C>> {
+    pub fn q(&self) -> OMatrix<T, R, DimMinimum<R, C>> {
         let (nrows, ncols) = self.qr.data.shape();
         let min_nrows_ncols = nrows.min(ncols);
 
         if min_nrows_ncols.value() == 0 {
-            return MatrixMN::from_element_generic(nrows, min_nrows_ncols, N::zero());
+            return OMatrix::from_element_generic(nrows, min_nrows_ncols, T::zero());
         }
 
         let mut q = self
@@ -132,7 +133,7 @@ where
         let mut info = 0;
         let nrows = nrows.value() as i32;
 
-        let lwork = N::xorgqr_work_size(
+        let lwork = T::xorgqr_work_size(
             nrows,
             min_nrows_ncols.value() as i32,
             self.tau.len() as i32,
@@ -142,9 +143,9 @@ where
             &mut info,
         );
 
-        let mut work = vec![N::zero(); lwork as usize];
+        let mut work = vec![T::zero(); lwork as usize];
 
-        N::xorgqr(
+        T::xorgqr(
             nrows,
             min_nrows_ncols.value() as i32,
             self.tau.len() as i32,
diff --git a/nalgebra-lapack/src/schur.rs b/nalgebra-lapack/src/schur.rs
index 0480f73f..a850f01d 100644
--- a/nalgebra-lapack/src/schur.rs
+++ b/nalgebra-lapack/src/schur.rs
@@ -8,9 +8,9 @@ use simba::scalar::RealField;
 
 use crate::ComplexHelper;
 use na::allocator::Allocator;
-use na::dimension::{Dim, U1};
+use na::dimension::{Const, Dim};
 use na::storage::Storage;
-use na::{DefaultAllocator, Matrix, MatrixN, Scalar, VectorN};
+use na::{DefaultAllocator, Matrix, OMatrix, OVector, Scalar};
 
 use lapack;
 
@@ -19,53 +19,53 @@ use lapack;
 #[cfg_attr(
     feature = "serde-serialize",
     serde(
-        bound(serialize = "DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>,
-         VectorN<N, D>: Serialize,
-         MatrixN<N, D>: Serialize")
+        bound(serialize = "DefaultAllocator: Allocator<T, D, D> + Allocator<T, D>,
+         OVector<T, D>: Serialize,
+         OMatrix<T, D, D>: Serialize")
     )
 )]
 #[cfg_attr(
     feature = "serde-serialize",
     serde(
-        bound(deserialize = "DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>,
-         VectorN<N, D>: Serialize,
-         MatrixN<N, D>: Deserialize<'de>")
+        bound(deserialize = "DefaultAllocator: Allocator<T, D, D> + Allocator<T, D>,
+         OVector<T, D>: Serialize,
+         OMatrix<T, D, D>: Deserialize<'de>")
     )
 )]
 #[derive(Clone, Debug)]
-pub struct Schur<N: Scalar, D: Dim>
+pub struct Schur<T: Scalar, D: Dim>
 where
-    DefaultAllocator: Allocator<N, D> + Allocator<N, D, D>,
+    DefaultAllocator: Allocator<T, D> + Allocator<T, D, D>,
 {
-    re: VectorN<N, D>,
-    im: VectorN<N, D>,
-    t: MatrixN<N, D>,
-    q: MatrixN<N, D>,
+    re: OVector<T, D>,
+    im: OVector<T, D>,
+    t: OMatrix<T, D, D>,
+    q: OMatrix<T, D, D>,
 }
 
-impl<N: Scalar + Copy, D: Dim> Copy for Schur<N, D>
+impl<T: Scalar + Copy, D: Dim> Copy for Schur<T, D>
 where
-    DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>,
-    MatrixN<N, D>: Copy,
-    VectorN<N, D>: Copy,
+    DefaultAllocator: Allocator<T, D, D> + Allocator<T, D>,
+    OMatrix<T, D, D>: Copy,
+    OVector<T, D>: Copy,
 {
 }
 
-impl<N: SchurScalar + RealField, D: Dim> Schur<N, D>
+impl<T: SchurScalar + RealField, D: Dim> Schur<T, D>
 where
-    DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>,
+    DefaultAllocator: Allocator<T, D, D> + Allocator<T, D>,
 {
     /// Computes the eigenvalues and real Schur form of the matrix `m`.
     ///
     /// Panics if the method did not converge.
-    pub fn new(m: MatrixN<N, D>) -> Self {
+    pub fn new(m: OMatrix<T, D, D>) -> Self {
         Self::try_new(m).expect("Schur decomposition: convergence failed.")
     }
 
     /// Computes the eigenvalues and real Schur form of the matrix `m`.
     ///
     /// Returns `None` if the method did not converge.
-    pub fn try_new(mut m: MatrixN<N, D>) -> Option<Self> {
+    pub fn try_new(mut m: OMatrix<T, D, D>) -> Option<Self> {
         assert!(
             m.is_square(),
             "Unable to compute the eigenvalue decomposition of a non-square matrix."
@@ -78,16 +78,16 @@ where
 
         let mut info = 0;
 
-        let mut wr = unsafe { Matrix::new_uninitialized_generic(nrows, U1).assume_init() };
-        let mut wi = unsafe { Matrix::new_uninitialized_generic(nrows, U1).assume_init() };
+        let mut wr = unsafe { Matrix::new_uninitialized_generic(nrows, Const::<1>).assume_init() };
+        let mut wi = unsafe { Matrix::new_uninitialized_generic(nrows, Const::<1>).assume_init() };
         let mut q = unsafe { Matrix::new_uninitialized_generic(nrows, ncols).assume_init() };
         // Placeholders:
         let mut bwork = [0i32];
         let mut unused = 0;
 
-        let lwork = N::xgees_work_size(
+        let lwork = T::xgees_work_size(
             b'V',
-            b'N',
+            b'T',
             n as i32,
             m.as_mut_slice(),
             lda,
@@ -103,9 +103,9 @@ where
 
         let mut work = unsafe { crate::uninitialized_vec(lwork as usize) };
 
-        N::xgees(
+        T::xgees(
             b'V',
-            b'N',
+            b'T',
             n as i32,
             m.as_mut_slice(),
             lda,
@@ -131,14 +131,14 @@ where
 
     /// Retrieves the unitary matrix `Q` and the upper-quasitriangular matrix `T` such that the
     /// decomposed matrix equals `Q * T * Q.transpose()`.
-    pub fn unpack(self) -> (MatrixN<N, D>, MatrixN<N, D>) {
+    pub fn unpack(self) -> (OMatrix<T, D, D>, OMatrix<T, D, D>) {
         (self.q, self.t)
     }
 
     /// Computes the real eigenvalues of the decomposed matrix.
     ///
     /// Return `None` if some eigenvalues are complex.
-    pub fn eigenvalues(&self) -> Option<VectorN<N, D>> {
+    pub fn eigenvalues(&self) -> Option<OVector<T, D>> {
         if self.im.iter().all(|e| e.is_zero()) {
             Some(self.re.clone())
         } else {
@@ -147,12 +147,13 @@ where
     }
 
     /// Computes the complex eigenvalues of the decomposed matrix.
-    pub fn complex_eigenvalues(&self) -> VectorN<Complex<N>, D>
+    pub fn complex_eigenvalues(&self) -> OVector<Complex<T>, D>
     where
-        DefaultAllocator: Allocator<Complex<N>, D>,
+        DefaultAllocator: Allocator<Complex<T>, D>,
     {
-        let mut out =
-            unsafe { VectorN::new_uninitialized_generic(self.t.data.shape().0, U1).assume_init() };
+        let mut out = unsafe {
+            OVector::new_uninitialized_generic(self.t.data.shape().0, Const::<1>).assume_init()
+        };
 
         for i in 0..out.len() {
             out[i] = Complex::new(self.re[i], self.im[i])
diff --git a/nalgebra-lapack/src/svd.rs b/nalgebra-lapack/src/svd.rs
index 70c7fd18..f6b907b6 100644
--- a/nalgebra-lapack/src/svd.rs
+++ b/nalgebra-lapack/src/svd.rs
@@ -5,9 +5,9 @@ use num::Signed;
 use std::cmp;
 
 use na::allocator::Allocator;
-use na::dimension::{Dim, DimMin, DimMinimum, U1};
+use na::dimension::{Const, Dim, DimMin, DimMinimum, U1};
 use na::storage::Storage;
-use na::{DefaultAllocator, Matrix, MatrixMN, MatrixN, Scalar, VectorN};
+use na::{DefaultAllocator, Matrix, OMatrix, OVector, Scalar};
 
 use lapack;
 
@@ -15,41 +15,41 @@ use lapack;
 #[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
 #[cfg_attr(
     feature = "serde-serialize",
-    serde(bound(serialize = "DefaultAllocator: Allocator<N, DimMinimum<R, C>> +
-                           Allocator<N, R, R> +
-                           Allocator<N, C, C>,
-         MatrixN<N, R>: Serialize,
-         MatrixN<N, C>: Serialize,
-         VectorN<N, DimMinimum<R, C>>: Serialize"))
+    serde(bound(serialize = "DefaultAllocator: Allocator<T, DimMinimum<R, C>> +
+                           Allocator<T, R, R> +
+                           Allocator<T, C, C>,
+         OMatrix<T, R>: Serialize,
+         OMatrix<T, C>: Serialize,
+         OVector<T, DimMinimum<R, C>>: Serialize"))
 )]
 #[cfg_attr(
     feature = "serde-serialize",
-    serde(bound(serialize = "DefaultAllocator: Allocator<N, DimMinimum<R, C>> +
-                           Allocator<N, R, R> +
-                           Allocator<N, C, C>,
-         MatrixN<N, R>: Deserialize<'de>,
-         MatrixN<N, C>: Deserialize<'de>,
-         VectorN<N, DimMinimum<R, C>>: Deserialize<'de>"))
+    serde(bound(serialize = "DefaultAllocator: Allocator<T, DimMinimum<R, C>> +
+                           Allocator<T, R, R> +
+                           Allocator<T, C, C>,
+         OMatrix<T, R>: Deserialize<'de>,
+         OMatrix<T, C>: Deserialize<'de>,
+         OVector<T, DimMinimum<R, C>>: Deserialize<'de>"))
 )]
 #[derive(Clone, Debug)]
-pub struct SVD<N: Scalar, R: DimMin<C>, C: Dim>
+pub struct SVD<T: Scalar, R: DimMin<C>, C: Dim>
 where
-    DefaultAllocator: Allocator<N, R, R> + Allocator<N, DimMinimum<R, C>> + Allocator<N, C, C>,
+    DefaultAllocator: Allocator<T, R, R> + Allocator<T, DimMinimum<R, C>> + Allocator<T, C, C>,
 {
     /// The left-singular vectors `U` of this SVD.
-    pub u: MatrixN<N, R>, // TODO: should be MatrixMN<N, R, DimMinimum<R, C>>
+    pub u: OMatrix<T, R, R>, // TODO: should be OMatrix<T, R, DimMinimum<R, C>>
     /// The right-singular vectors `V^t` of this SVD.
-    pub vt: MatrixN<N, C>, // TODO: should be MatrixMN<N, DimMinimum<R, C>, C>
+    pub vt: OMatrix<T, C, C>, // TODO: should be OMatrix<T, DimMinimum<R, C>, C>
     /// The singular values of this SVD.
-    pub singular_values: VectorN<N, DimMinimum<R, C>>,
+    pub singular_values: OVector<T, DimMinimum<R, C>>,
 }
 
-impl<N: Scalar + Copy, R: DimMin<C>, C: Dim> Copy for SVD<N, R, C>
+impl<T: Scalar + Copy, R: DimMin<C>, C: Dim> Copy for SVD<T, R, C>
 where
-    DefaultAllocator: Allocator<N, C, C> + Allocator<N, R, R> + Allocator<N, DimMinimum<R, C>>,
-    MatrixMN<N, R, R>: Copy,
-    MatrixMN<N, C, C>: Copy,
-    VectorN<N, DimMinimum<R, C>>: Copy,
+    DefaultAllocator: Allocator<T, C, C> + Allocator<T, R, R> + Allocator<T, DimMinimum<R, C>>,
+    OMatrix<T, R, R>: Copy,
+    OMatrix<T, C, C>: Copy,
+    OVector<T, DimMinimum<R, C>>: Copy,
 {
 }
 
@@ -63,19 +63,19 @@ where
         + Allocator<Self, C, C>,
 {
     /// Computes the SVD decomposition of `m`.
-    fn compute(m: MatrixMN<Self, R, C>) -> Option<SVD<Self, R, C>>;
+    fn compute(m: OMatrix<Self, R, C>) -> Option<SVD<Self, R, C>>;
 }
 
-impl<N: SVDScalar<R, C>, R: DimMin<C>, C: Dim> SVD<N, R, C>
+impl<T: SVDScalar<R, C>, R: DimMin<C>, C: Dim> SVD<T, R, C>
 where
-    DefaultAllocator: Allocator<N, R, R>
-        + Allocator<N, R, C>
-        + Allocator<N, DimMinimum<R, C>>
-        + Allocator<N, C, C>,
+    DefaultAllocator: Allocator<T, R, R>
+        + Allocator<T, R, C>
+        + Allocator<T, DimMinimum<R, C>>
+        + Allocator<T, C, C>,
 {
     /// Computes the Singular Value Decomposition of `matrix`.
-    pub fn new(m: MatrixMN<N, R, C>) -> Option<Self> {
-        N::compute(m)
+    pub fn new(m: OMatrix<T, R, C>) -> Option<Self> {
+        T::compute(m)
     }
 }
 
@@ -88,7 +88,7 @@ macro_rules! svd_impl(
                                         Allocator<$t, C, C> +
                                         Allocator<$t, DimMinimum<R, C>> {
 
-            fn compute(mut m: MatrixMN<$t, R, C>) -> Option<SVD<$t, R, C>> {
+            fn compute(mut m: OMatrix<$t, R, C>) -> Option<SVD<$t, R, C>> {
                 let (nrows, ncols) = m.data.shape();
 
                 if nrows.value() == 0 || ncols.value() == 0 {
@@ -100,7 +100,7 @@ macro_rules! svd_impl(
                 let lda = nrows.value() as i32;
 
                 let mut u  = unsafe { Matrix::new_uninitialized_generic(nrows, nrows).assume_init() };
-                let mut s  = unsafe { Matrix::new_uninitialized_generic(nrows.min(ncols), U1).assume_init() };
+                let mut s  = unsafe { Matrix::new_uninitialized_generic(nrows.min(ncols), Const::<1>).assume_init() };
                 let mut vt = unsafe { Matrix::new_uninitialized_generic(ncols, ncols).assume_init() };
 
                 let ldu  = nrows.value();
@@ -150,12 +150,12 @@ macro_rules! svd_impl(
             /// Useful if some components (e.g. some singular values) of this decomposition have
             /// been manually changed by the user.
             #[inline]
-            pub fn recompose(self) -> MatrixMN<$t, R, C> {
+            pub fn recompose(self) -> OMatrix<$t, R, C> {
                 let nrows           = self.u.data.shape().0;
                 let ncols           = self.vt.data.shape().1;
                 let min_nrows_ncols = nrows.min(ncols);
 
-                let mut res: MatrixMN<_, R, C> = Matrix::zeros_generic(nrows, ncols);
+                let mut res: OMatrix<_, R, C> = Matrix::zeros_generic(nrows, ncols);
 
                 {
                     let mut sres = res.generic_slice_mut((0, 0), (min_nrows_ncols, ncols));
@@ -175,12 +175,12 @@ macro_rules! svd_impl(
             ///
             /// All singular value below epsilon will be set to zero instead of being inverted.
             #[inline]
-            pub fn pseudo_inverse(&self, epsilon: $t) -> MatrixMN<$t, C, R> {
+            pub fn pseudo_inverse(&self, epsilon: $t) -> OMatrix<$t, C, R> {
                 let nrows           = self.u.data.shape().0;
                 let ncols           = self.vt.data.shape().1;
                 let min_nrows_ncols = nrows.min(ncols);
 
-                let mut res: MatrixMN<_, C, R> = Matrix::zeros_generic(ncols, nrows);
+                let mut res: OMatrix<_, C, R> = Matrix::zeros_generic(ncols, nrows);
 
                 {
                     let mut sres = res.generic_slice_mut((0, 0), (min_nrows_ncols, nrows));
@@ -230,9 +230,9 @@ macro_rules! svd_complex_impl(
     ($name: ident, $t: ty, $lapack_func: path) => (
         impl SVDScalar for Complex<$t> {
             fn compute<R: Dim, C: Dim, S>(mut m: Matrix<$t, R, C, S>) -> Option<SVD<$t, R, C, S::Alloc>>
-            Option<(MatrixN<Complex<$t>, R, S::Alloc>,
-                    VectorN<$t, DimMinimum<R, C>, S::Alloc>,
-                    MatrixN<Complex<$t>, C, S::Alloc>)>
+            Option<(OMatrix<Complex<$t>, R, S::Alloc>,
+                    OVector<$t, DimMinimum<R, C>, S::Alloc>,
+                    OMatrix<Complex<$t>, C, S::Alloc>)>
             where R: DimMin<C>,
                   S: ContiguousStorage<Complex<$t>, R, C>,
                   S::Alloc: OwnedAllocator<Complex<$t>, R, C, S> +
diff --git a/nalgebra-lapack/src/symmetric_eigen.rs b/nalgebra-lapack/src/symmetric_eigen.rs
index c255058d..0cd6bfc1 100644
--- a/nalgebra-lapack/src/symmetric_eigen.rs
+++ b/nalgebra-lapack/src/symmetric_eigen.rs
@@ -8,9 +8,9 @@ use simba::scalar::RealField;
 
 use crate::ComplexHelper;
 use na::allocator::Allocator;
-use na::dimension::{Dim, U1};
+use na::dimension::{Const, Dim};
 use na::storage::Storage;
-use na::{DefaultAllocator, Matrix, MatrixN, Scalar, VectorN};
+use na::{DefaultAllocator, Matrix, OMatrix, OVector, Scalar};
 
 use lapack;
 
@@ -18,47 +18,47 @@ use lapack;
 #[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
 #[cfg_attr(
     feature = "serde-serialize",
-    serde(bound(serialize = "DefaultAllocator: Allocator<N, D, D> +
-                           Allocator<N, D>,
-         VectorN<N, D>: Serialize,
-         MatrixN<N, D>: Serialize"))
+    serde(bound(serialize = "DefaultAllocator: Allocator<T, D, D> +
+                           Allocator<T, D>,
+         OVector<T, D>: Serialize,
+         OMatrix<T, D, D>: Serialize"))
 )]
 #[cfg_attr(
     feature = "serde-serialize",
-    serde(bound(deserialize = "DefaultAllocator: Allocator<N, D, D> +
-                           Allocator<N, D>,
-         VectorN<N, D>: Deserialize<'de>,
-         MatrixN<N, D>: Deserialize<'de>"))
+    serde(bound(deserialize = "DefaultAllocator: Allocator<T, D, D> +
+                           Allocator<T, D>,
+         OVector<T, D>: Deserialize<'de>,
+         OMatrix<T, D, D>: Deserialize<'de>"))
 )]
 #[derive(Clone, Debug)]
-pub struct SymmetricEigen<N: Scalar, D: Dim>
+pub struct SymmetricEigen<T: Scalar, D: Dim>
 where
-    DefaultAllocator: Allocator<N, D> + Allocator<N, D, D>,
+    DefaultAllocator: Allocator<T, D> + Allocator<T, D, D>,
 {
     /// The eigenvectors of the decomposed matrix.
-    pub eigenvectors: MatrixN<N, D>,
+    pub eigenvectors: OMatrix<T, D, D>,
 
     /// The unsorted eigenvalues of the decomposed matrix.
-    pub eigenvalues: VectorN<N, D>,
+    pub eigenvalues: OVector<T, D>,
 }
 
-impl<N: Scalar + Copy, D: Dim> Copy for SymmetricEigen<N, D>
+impl<T: Scalar + Copy, D: Dim> Copy for SymmetricEigen<T, D>
 where
-    DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>,
-    MatrixN<N, D>: Copy,
-    VectorN<N, D>: Copy,
+    DefaultAllocator: Allocator<T, D, D> + Allocator<T, D>,
+    OMatrix<T, D, D>: Copy,
+    OVector<T, D>: Copy,
 {
 }
 
-impl<N: SymmetricEigenScalar + RealField, D: Dim> SymmetricEigen<N, D>
+impl<T: SymmetricEigenScalar + RealField, D: Dim> SymmetricEigen<T, D>
 where
-    DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>,
+    DefaultAllocator: Allocator<T, D, D> + Allocator<T, D>,
 {
     /// Computes the eigenvalues and eigenvectors of the symmetric matrix `m`.
     ///
     /// Only the lower-triangular part of `m` is read. If `eigenvectors` is `false` then, the
     /// eigenvectors are not computed explicitly. Panics if the method did not converge.
-    pub fn new(m: MatrixN<N, D>) -> Self {
+    pub fn new(m: OMatrix<T, D, D>) -> Self {
         let (vals, vecs) =
             Self::do_decompose(m, true).expect("SymmetricEigen: convergence failure.");
         Self {
@@ -71,7 +71,7 @@ where
     ///
     /// Only the lower-triangular part of `m` is read. If `eigenvectors` is `false` then, the
     /// eigenvectors are not computed explicitly. Returns `None` if the method did not converge.
-    pub fn try_new(m: MatrixN<N, D>) -> Option<Self> {
+    pub fn try_new(m: OMatrix<T, D, D>) -> Option<Self> {
         Self::do_decompose(m, true).map(|(vals, vecs)| SymmetricEigen {
             eigenvalues: vals,
             eigenvectors: vecs.unwrap(),
@@ -79,30 +79,31 @@ where
     }
 
     fn do_decompose(
-        mut m: MatrixN<N, D>,
+        mut m: OMatrix<T, D, D>,
         eigenvectors: bool,
-    ) -> Option<(VectorN<N, D>, Option<MatrixN<N, D>>)> {
+    ) -> Option<(OVector<T, D>, Option<OMatrix<T, D, D>>)> {
         assert!(
             m.is_square(),
             "Unable to compute the eigenvalue decomposition of a non-square matrix."
         );
 
-        let jobz = if eigenvectors { b'V' } else { b'N' };
+        let jobz = if eigenvectors { b'V' } else { b'T' };
 
         let nrows = m.data.shape().0;
         let n = nrows.value();
 
         let lda = n as i32;
 
-        let mut values = unsafe { Matrix::new_uninitialized_generic(nrows, U1).assume_init() };
+        let mut values =
+            unsafe { Matrix::new_uninitialized_generic(nrows, Const::<1>).assume_init() };
         let mut info = 0;
 
-        let lwork = N::xsyev_work_size(jobz, b'L', n as i32, m.as_mut_slice(), lda, &mut info);
+        let lwork = T::xsyev_work_size(jobz, b'L', n as i32, m.as_mut_slice(), lda, &mut info);
         lapack_check!(info);
 
         let mut work = unsafe { crate::uninitialized_vec(lwork as usize) };
 
-        N::xsyev(
+        T::xsyev(
             jobz,
             b'L',
             n as i32,
@@ -122,7 +123,7 @@ where
     /// Computes only the eigenvalues of the input matrix.
     ///
     /// Panics if the method does not converge.
-    pub fn eigenvalues(m: MatrixN<N, D>) -> VectorN<N, D> {
+    pub fn eigenvalues(m: OMatrix<T, D, D>) -> OVector<T, D> {
         Self::do_decompose(m, false)
             .expect("SymmetricEigen eigenvalues: convergence failure.")
             .0
@@ -131,14 +132,14 @@ where
     /// Computes only the eigenvalues of the input matrix.
     ///
     /// Returns `None` if the method does not converge.
-    pub fn try_eigenvalues(m: MatrixN<N, D>) -> Option<VectorN<N, D>> {
+    pub fn try_eigenvalues(m: OMatrix<T, D, D>) -> Option<OVector<T, D>> {
         Self::do_decompose(m, false).map(|res| res.0)
     }
 
     /// The determinant of the decomposed matrix.
     #[inline]
-    pub fn determinant(&self) -> N {
-        let mut det = N::one();
+    pub fn determinant(&self) -> T {
+        let mut det = T::one();
         for e in self.eigenvalues.iter() {
             det *= *e;
         }
@@ -149,7 +150,7 @@ where
     /// Rebuild the original matrix.
     ///
     /// This is useful if some of the eigenvalues have been manually modified.
-    pub fn recompose(&self) -> MatrixN<N, D> {
+    pub fn recompose(&self) -> OMatrix<T, D, D> {
         let mut u_t = self.eigenvectors.clone();
         for i in 0..self.eigenvalues.len() {
             let val = self.eigenvalues[i];
diff --git a/nalgebra-sparse/src/ops/impl_std_ops.rs b/nalgebra-sparse/src/ops/impl_std_ops.rs
index 75645bed..590bd934 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::Storage;
 use nalgebra::constraint::{DimEq, ShapeConstraint};
 use nalgebra::{
-    ClosedAdd, ClosedDiv, ClosedMul, ClosedSub, DefaultAllocator, Dim, Dynamic, Matrix, MatrixMN,
+    ClosedAdd, ClosedDiv, ClosedMul, ClosedSub, DefaultAllocator, Dim, Dynamic, Matrix, OMatrix,
     Scalar, U1,
 };
 use num_traits::{One, Zero};
@@ -274,7 +274,7 @@ macro_rules! impl_spmm_cs_dense {
         impl_spmm_cs_dense!(&'a $matrix_type_name<T>, &'a Matrix<T, R, C, S>, $spmm_fn, |lhs, rhs| {
             let (_, ncols) = rhs.data.shape();
             let nrows = Dynamic::new(lhs.nrows());
-            let mut result = MatrixMN::<T, Dynamic, C>::zeros_generic(nrows, ncols);
+            let mut result = OMatrix::<T, Dynamic, C>::zeros_generic(nrows, ncols);
             $spmm_fn(T::zero(), &mut result, T::one(), Op::NoOp(lhs), Op::NoOp(rhs));
             result
         });
@@ -305,7 +305,7 @@ macro_rules! impl_spmm_cs_dense {
             DefaultAllocator: Allocator<T, Dynamic, C>,
             // TODO: Is it possible to simplify these bounds?
             ShapeConstraint:
-                // Bounds so that we can turn MatrixMN<T, Dynamic, C> into a DMatrixSliceMut
+                // Bounds so that we can turn OMatrix<T, Dynamic, C> into a DMatrixSliceMut
                   DimEq<U1, <<DefaultAllocator as Allocator<T, Dynamic, C>>::Buffer as Storage<T, Dynamic, C>>::RStride>
                 + DimEq<C, Dynamic>
                 + DimEq<Dynamic, <<DefaultAllocator as Allocator<T, Dynamic, C>>::Buffer as Storage<T, Dynamic, C>>::CStride>
@@ -316,7 +316,7 @@ macro_rules! impl_spmm_cs_dense {
         {
             // 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 = MatrixMN<T, Dynamic, C>;
+            type Output = OMatrix<T, Dynamic, 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 42cd37a6..6bc04813 100644
--- a/src/base/alias.rs
+++ b/src/base/alias.rs
@@ -4,8 +4,7 @@ use crate::base::dimension::{U1, U2, U3, U4, U5, U6};
 use crate::base::storage::Owned;
 #[cfg(any(feature = "std", feature = "alloc"))]
 use crate::base::vec_storage::VecStorage;
-use crate::base::Matrix;
-use crate::base::Unit;
+use crate::base::{ArrayStorage, Const, Matrix, Unit};
 
 /*
  *
@@ -14,244 +13,254 @@ use crate::base::Unit;
  *
  *
  */
-/// A statically sized column-major matrix with `R` rows and `C` columns.
+
+/// An owned matrix column-major matrix 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(note = "This matrix name contains a typo. Use MatrixMN instead.")]
-pub type MatrixNM<N, R, C> = Matrix<N, R, C, Owned<N, R, C>>;
+pub type OMatrix<T, R, C> = Matrix<T, R, C, Owned<T, R, C>>;
+
+/// An owned matrix column-major matrix 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(
+    note = "use SMatrix for a statically-sized matrix using integer dimensions, or OMatrix for an owned matrix using types as dimensions."
+)]
+pub type MatrixMN<T, R, C> = Matrix<T, R, C, Owned<T, R, C>>;
+
+/// An owned matrix column-major matrix with `D` columns.
+///
+/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
+#[deprecated(note = "use OMatrix<T, D, D> or SMatrix<T, D, D> instead.")]
+pub type MatrixN<T, D> = Matrix<T, D, D, Owned<T, D, D>>;
 
 /// A statically sized column-major matrix 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.**
-pub type MatrixMN<N, R, C> = Matrix<N, R, C, Owned<N, R, C>>;
-
-/// A statically sized column-major square matrix 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 MatrixN<N, D> = Matrix<N, D, D, Owned<N, D, D>>;
+pub type SMatrix<T, const R: usize, const C: usize> =
+    Matrix<T, Const<R>, Const<C>, ArrayStorage<T, R, C>>;
 
 /// A dynamically sized column-major matrix.
 ///
 /// **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<N> = Matrix<N, Dynamic, Dynamic, Owned<N, Dynamic, Dynamic>>;
+pub type DMatrix<T> = Matrix<T, Dynamic, Dynamic, VecStorage<T, Dynamic, Dynamic>>;
 
 /// 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<N> = Matrix<N, Dynamic, U1, Owned<N, Dynamic, U1>>;
+pub type MatrixXx1<T> = Matrix<T, Dynamic, U1, VecStorage<T, Dynamic, 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<N> = Matrix<N, Dynamic, U2, Owned<N, Dynamic, U2>>;
+pub type MatrixXx2<T> = Matrix<T, Dynamic, U2, VecStorage<T, Dynamic, 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<N> = Matrix<N, Dynamic, U3, Owned<N, Dynamic, U3>>;
+pub type MatrixXx3<T> = Matrix<T, Dynamic, U3, VecStorage<T, Dynamic, 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<N> = Matrix<N, Dynamic, U4, Owned<N, Dynamic, U4>>;
+pub type MatrixXx4<T> = Matrix<T, Dynamic, U4, VecStorage<T, Dynamic, 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<N> = Matrix<N, Dynamic, U5, Owned<N, Dynamic, U5>>;
+pub type MatrixXx5<T> = Matrix<T, Dynamic, U5, VecStorage<T, Dynamic, 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<N> = Matrix<N, Dynamic, U6, Owned<N, Dynamic, U6>>;
+pub type MatrixXx6<T> = Matrix<T, Dynamic, U6, VecStorage<T, Dynamic, 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<N> = Matrix<N, U1, Dynamic, Owned<N, U1, Dynamic>>;
+pub type Matrix1xX<T> = Matrix<T, U1, Dynamic, VecStorage<T, U1, Dynamic>>;
 /// 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<N> = Matrix<N, U2, Dynamic, Owned<N, U2, Dynamic>>;
+pub type Matrix2xX<T> = Matrix<T, U2, Dynamic, VecStorage<T, U2, Dynamic>>;
 /// 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<N> = Matrix<N, U3, Dynamic, Owned<N, U3, Dynamic>>;
+pub type Matrix3xX<T> = Matrix<T, U3, Dynamic, VecStorage<T, U3, Dynamic>>;
 /// 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<N> = Matrix<N, U4, Dynamic, Owned<N, U4, Dynamic>>;
+pub type Matrix4xX<T> = Matrix<T, U4, Dynamic, VecStorage<T, U4, Dynamic>>;
 /// 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<N> = Matrix<N, U5, Dynamic, Owned<N, U5, Dynamic>>;
+pub type Matrix5xX<T> = Matrix<T, U5, Dynamic, VecStorage<T, U5, Dynamic>>;
 /// 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<N> = Matrix<N, U6, Dynamic, Owned<N, U6, Dynamic>>;
+pub type Matrix6xX<T> = Matrix<T, U6, Dynamic, VecStorage<T, U6, Dynamic>>;
 
 /// A stack-allocated, column-major, 1x1 square matrix.
 ///
 /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
-pub type Matrix1<N> = Matrix<N, U1, U1, Owned<N, U1, U1>>;
+pub type Matrix1<T> = Matrix<T, U1, U1, ArrayStorage<T, 1, 1>>;
 /// A stack-allocated, column-major, 2x2 square matrix.
 ///
 /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
-pub type Matrix2<N> = Matrix<N, U2, U2, Owned<N, U2, U2>>;
+pub type Matrix2<T> = Matrix<T, U2, U2, ArrayStorage<T, 2, 2>>;
 /// A stack-allocated, column-major, 3x3 square matrix.
 ///
 /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
-pub type Matrix3<N> = Matrix<N, U3, U3, Owned<N, U3, U3>>;
+pub type Matrix3<T> = Matrix<T, U3, U3, ArrayStorage<T, 3, 3>>;
 /// A stack-allocated, column-major, 4x4 square matrix.
 ///
 /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
-pub type Matrix4<N> = Matrix<N, U4, U4, Owned<N, U4, U4>>;
+pub type Matrix4<T> = Matrix<T, U4, U4, ArrayStorage<T, 4, 4>>;
 /// A stack-allocated, column-major, 5x5 square matrix.
 ///
 /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
-pub type Matrix5<N> = Matrix<N, U5, U5, Owned<N, U5, U5>>;
+pub type Matrix5<T> = Matrix<T, U5, U5, ArrayStorage<T, 5, 5>>;
 /// A stack-allocated, column-major, 6x6 square matrix.
 ///
 /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
-pub type Matrix6<N> = Matrix<N, U6, U6, Owned<N, U6, U6>>;
+pub type Matrix6<T> = Matrix<T, U6, U6, ArrayStorage<T, 6, 6>>;
 
 /// A stack-allocated, column-major, 1x2 matrix.
 ///
 /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
-pub type Matrix1x2<N> = Matrix<N, U1, U2, Owned<N, U1, U2>>;
+pub type Matrix1x2<T> = Matrix<T, U1, U2, ArrayStorage<T, 1, 2>>;
 /// A stack-allocated, column-major, 1x3 matrix.
 ///
 /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
-pub type Matrix1x3<N> = Matrix<N, U1, U3, Owned<N, U1, U3>>;
+pub type Matrix1x3<T> = Matrix<T, U1, U3, ArrayStorage<T, 1, 3>>;
 /// A stack-allocated, column-major, 1x4 matrix.
 ///
 /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
-pub type Matrix1x4<N> = Matrix<N, U1, U4, Owned<N, U1, U4>>;
+pub type Matrix1x4<T> = Matrix<T, U1, U4, ArrayStorage<T, 1, 4>>;
 /// A stack-allocated, column-major, 1x5 matrix.
 ///
 /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
-pub type Matrix1x5<N> = Matrix<N, U1, U5, Owned<N, U1, U5>>;
+pub type Matrix1x5<T> = Matrix<T, U1, U5, ArrayStorage<T, 1, 5>>;
 /// A stack-allocated, column-major, 1x6 matrix.
 ///
 /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
-pub type Matrix1x6<N> = Matrix<N, U1, U6, Owned<N, U1, U6>>;
+pub type Matrix1x6<T> = Matrix<T, U1, U6, ArrayStorage<T, 1, 6>>;
 
 /// A stack-allocated, column-major, 2x3 matrix.
 ///
 /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
-pub type Matrix2x3<N> = Matrix<N, U2, U3, Owned<N, U2, U3>>;
+pub type Matrix2x3<T> = Matrix<T, U2, U3, ArrayStorage<T, 2, 3>>;
 /// A stack-allocated, column-major, 2x4 matrix.
 ///
 /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
-pub type Matrix2x4<N> = Matrix<N, U2, U4, Owned<N, U2, U4>>;
+pub type Matrix2x4<T> = Matrix<T, U2, U4, ArrayStorage<T, 2, 4>>;
 /// A stack-allocated, column-major, 2x5 matrix.
 ///
 /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
-pub type Matrix2x5<N> = Matrix<N, U2, U5, Owned<N, U2, U5>>;
+pub type Matrix2x5<T> = Matrix<T, U2, U5, ArrayStorage<T, 2, 5>>;
 /// A stack-allocated, column-major, 2x6 matrix.
 ///
 /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
-pub type Matrix2x6<N> = Matrix<N, U2, U6, Owned<N, U2, U6>>;
+pub type Matrix2x6<T> = Matrix<T, U2, U6, ArrayStorage<T, 2, 6>>;
 
 /// A stack-allocated, column-major, 3x4 matrix.
 ///
 /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
-pub type Matrix3x4<N> = Matrix<N, U3, U4, Owned<N, U3, U4>>;
+pub type Matrix3x4<T> = Matrix<T, U3, U4, ArrayStorage<T, 3, 4>>;
 /// A stack-allocated, column-major, 3x5 matrix.
 ///
 /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
-pub type Matrix3x5<N> = Matrix<N, U3, U5, Owned<N, U3, U5>>;
+pub type Matrix3x5<T> = Matrix<T, U3, U5, ArrayStorage<T, 3, 5>>;
 /// A stack-allocated, column-major, 3x6 matrix.
 ///
 /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
-pub type Matrix3x6<N> = Matrix<N, U3, U6, Owned<N, U3, U6>>;
+pub type Matrix3x6<T> = Matrix<T, U3, U6, ArrayStorage<T, 3, 6>>;
 
 /// A stack-allocated, column-major, 4x5 matrix.
 ///
 /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
-pub type Matrix4x5<N> = Matrix<N, U4, U5, Owned<N, U4, U5>>;
+pub type Matrix4x5<T> = Matrix<T, U4, U5, ArrayStorage<T, 4, 5>>;
 /// A stack-allocated, column-major, 4x6 matrix.
 ///
 /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
-pub type Matrix4x6<N> = Matrix<N, U4, U6, Owned<N, U4, U6>>;
+pub type Matrix4x6<T> = Matrix<T, U4, U6, ArrayStorage<T, 4, 6>>;
 
 /// A stack-allocated, column-major, 5x6 matrix.
 ///
 /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
-pub type Matrix5x6<N> = Matrix<N, U5, U6, Owned<N, U5, U6>>;
+pub type Matrix5x6<T> = Matrix<T, U5, U6, ArrayStorage<T, 5, 6>>;
 
 /// A stack-allocated, column-major, 2x1 matrix.
 ///
 /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
-pub type Matrix2x1<N> = Matrix<N, U2, U1, Owned<N, U2, U1>>;
+pub type Matrix2x1<T> = Matrix<T, U2, U1, ArrayStorage<T, 2, 1>>;
 /// A stack-allocated, column-major, 3x1 matrix.
 ///
 /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
-pub type Matrix3x1<N> = Matrix<N, U3, U1, Owned<N, U3, U1>>;
+pub type Matrix3x1<T> = Matrix<T, U3, U1, ArrayStorage<T, 3, 1>>;
 /// A stack-allocated, column-major, 4x1 matrix.
 ///
 /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
-pub type Matrix4x1<N> = Matrix<N, U4, U1, Owned<N, U4, U1>>;
+pub type Matrix4x1<T> = Matrix<T, U4, U1, ArrayStorage<T, 4, 1>>;
 /// A stack-allocated, column-major, 5x1 matrix.
 ///
 /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
-pub type Matrix5x1<N> = Matrix<N, U5, U1, Owned<N, U5, U1>>;
+pub type Matrix5x1<T> = Matrix<T, U5, U1, ArrayStorage<T, 5, 1>>;
 /// A stack-allocated, column-major, 6x1 matrix.
 ///
 /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
-pub type Matrix6x1<N> = Matrix<N, U6, U1, Owned<N, U6, U1>>;
+pub type Matrix6x1<T> = Matrix<T, U6, U1, ArrayStorage<T, 6, 1>>;
 
 /// A stack-allocated, column-major, 3x2 matrix.
 ///
 /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
-pub type Matrix3x2<N> = Matrix<N, U3, U2, Owned<N, U3, U2>>;
+pub type Matrix3x2<T> = Matrix<T, U3, U2, ArrayStorage<T, 3, 2>>;
 /// A stack-allocated, column-major, 4x2 matrix.
 ///
 /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
-pub type Matrix4x2<N> = Matrix<N, U4, U2, Owned<N, U4, U2>>;
+pub type Matrix4x2<T> = Matrix<T, U4, U2, ArrayStorage<T, 4, 2>>;
 /// A stack-allocated, column-major, 5x2 matrix.
 ///
 /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
-pub type Matrix5x2<N> = Matrix<N, U5, U2, Owned<N, U5, U2>>;
+pub type Matrix5x2<T> = Matrix<T, U5, U2, ArrayStorage<T, 5, 2>>;
 /// A stack-allocated, column-major, 6x2 matrix.
 ///
 /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
-pub type Matrix6x2<N> = Matrix<N, U6, U2, Owned<N, U6, U2>>;
+pub type Matrix6x2<T> = Matrix<T, U6, U2, ArrayStorage<T, 6, 2>>;
 
 /// A stack-allocated, column-major, 4x3 matrix.
 ///
 /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
-pub type Matrix4x3<N> = Matrix<N, U4, U3, Owned<N, U4, U3>>;
+pub type Matrix4x3<T> = Matrix<T, U4, U3, ArrayStorage<T, 4, 3>>;
 /// A stack-allocated, column-major, 5x3 matrix.
 ///
 /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
-pub type Matrix5x3<N> = Matrix<N, U5, U3, Owned<N, U5, U3>>;
+pub type Matrix5x3<T> = Matrix<T, U5, U3, ArrayStorage<T, 5, 3>>;
 /// A stack-allocated, column-major, 6x3 matrix.
 ///
 /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
-pub type Matrix6x3<N> = Matrix<N, U6, U3, Owned<N, U6, U3>>;
+pub type Matrix6x3<T> = Matrix<T, U6, U3, ArrayStorage<T, 6, 3>>;
 
 /// A stack-allocated, column-major, 5x4 matrix.
 ///
 /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
-pub type Matrix5x4<N> = Matrix<N, U5, U4, Owned<N, U5, U4>>;
+pub type Matrix5x4<T> = Matrix<T, U5, U4, ArrayStorage<T, 5, 4>>;
 /// A stack-allocated, column-major, 6x4 matrix.
 ///
 /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
-pub type Matrix6x4<N> = Matrix<N, U6, U4, Owned<N, U6, U4>>;
+pub type Matrix6x4<T> = Matrix<T, U6, U4, ArrayStorage<T, 6, 4>>;
 
 /// A stack-allocated, column-major, 6x5 matrix.
 ///
 /// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
-pub type Matrix6x5<N> = Matrix<N, U6, U5, Owned<N, U6, U5>>;
+pub type Matrix6x5<T> = Matrix<T, U6, U5, ArrayStorage<T, 6, 5>>;
 
 /*
  *
@@ -262,23 +271,33 @@ pub type Matrix6x5<N> = Matrix<N, U6, U5, Owned<N, U6, U5>>;
  */
 /// A dynamically sized column vector.
 #[cfg(any(feature = "std", feature = "alloc"))]
-pub type DVector<N> = Matrix<N, Dynamic, U1, VecStorage<N, Dynamic, U1>>;
+pub type DVector<T> = Matrix<T, Dynamic, U1, VecStorage<T, Dynamic, U1>>;
 
+/// An owned D-dimensional column vector.
+pub type OVector<T, D> = Matrix<T, D, U1, Owned<T, D, U1>>;
 /// A statically sized D-dimensional column vector.
-pub type VectorN<N, D> = Matrix<N, D, U1, Owned<N, D, U1>>;
+pub type SVector<T, const D: usize> = Matrix<T, Const<D>, U1, ArrayStorage<T, D, 1>>; // Owned<T, Const<D>, U1>>;
+
+/// An owned matrix column-major matrix 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(
+    note = "use SVector for a statically-sized matrix using integer dimensions, or OVector for an owned matrix using types as dimensions."
+)]
+pub type VectorN<T, D> = Matrix<T, D, U1, Owned<T, D, U1>>;
 
 /// A stack-allocated, 1-dimensional column vector.
-pub type Vector1<N> = Matrix<N, U1, U1, Owned<N, U1, U1>>;
+pub type Vector1<T> = Matrix<T, U1, U1, ArrayStorage<T, 1, 1>>;
 /// A stack-allocated, 2-dimensional column vector.
-pub type Vector2<N> = Matrix<N, U2, U1, Owned<N, U2, U1>>;
+pub type Vector2<T> = Matrix<T, U2, U1, ArrayStorage<T, 2, 1>>;
 /// A stack-allocated, 3-dimensional column vector.
-pub type Vector3<N> = Matrix<N, U3, U1, Owned<N, U3, U1>>;
+pub type Vector3<T> = Matrix<T, U3, U1, ArrayStorage<T, 3, 1>>;
 /// A stack-allocated, 4-dimensional column vector.
-pub type Vector4<N> = Matrix<N, U4, U1, Owned<N, U4, U1>>;
+pub type Vector4<T> = Matrix<T, U4, U1, ArrayStorage<T, 4, 1>>;
 /// A stack-allocated, 5-dimensional column vector.
-pub type Vector5<N> = Matrix<N, U5, U1, Owned<N, U5, U1>>;
+pub type Vector5<T> = Matrix<T, U5, U1, ArrayStorage<T, 5, 1>>;
 /// A stack-allocated, 6-dimensional column vector.
-pub type Vector6<N> = Matrix<N, U6, U1, Owned<N, U6, U1>>;
+pub type Vector6<T> = Matrix<T, U6, U1, ArrayStorage<T, 6, 1>>;
 
 /*
  *
@@ -289,23 +308,26 @@ pub type Vector6<N> = Matrix<N, U6, U1, Owned<N, U6, U1>>;
  */
 /// A dynamically sized row vector.
 #[cfg(any(feature = "std", feature = "alloc"))]
-pub type RowDVector<N> = Matrix<N, U1, Dynamic, VecStorage<N, U1, Dynamic>>;
+pub type RowDVector<T> = Matrix<T, U1, Dynamic, VecStorage<T, U1, Dynamic>>;
+
+/// An owned D-dimensional row vector.
+pub type RowOVector<T, D> = Matrix<T, U1, D, Owned<T, U1, D>>;
 
 /// A statically sized D-dimensional row vector.
-pub type RowVectorN<N, D> = Matrix<N, U1, D, Owned<N, U1, D>>;
+pub type RowSVector<T, const D: usize> = Matrix<T, U1, Const<D>, ArrayStorage<T, 1, D>>;
 
 /// A stack-allocated, 1-dimensional row vector.
-pub type RowVector1<N> = Matrix<N, U1, U1, Owned<N, U1, U1>>;
+pub type RowVector1<T> = Matrix<T, U1, U1, ArrayStorage<T, 1, 1>>;
 /// A stack-allocated, 2-dimensional row vector.
-pub type RowVector2<N> = Matrix<N, U1, U2, Owned<N, U1, U2>>;
+pub type RowVector2<T> = Matrix<T, U1, U2, ArrayStorage<T, 1, 2>>;
 /// A stack-allocated, 3-dimensional row vector.
-pub type RowVector3<N> = Matrix<N, U1, U3, Owned<N, U1, U3>>;
+pub type RowVector3<T> = Matrix<T, U1, U3, ArrayStorage<T, 1, 3>>;
 /// A stack-allocated, 4-dimensional row vector.
-pub type RowVector4<N> = Matrix<N, U1, U4, Owned<N, U1, U4>>;
+pub type RowVector4<T> = Matrix<T, U1, U4, ArrayStorage<T, 1, 4>>;
 /// A stack-allocated, 5-dimensional row vector.
-pub type RowVector5<N> = Matrix<N, U1, U5, Owned<N, U1, U5>>;
+pub type RowVector5<T> = Matrix<T, U1, U5, ArrayStorage<T, 1, 5>>;
 /// A stack-allocated, 6-dimensional row vector.
-pub type RowVector6<N> = Matrix<N, U1, U6, Owned<N, U1, U6>>;
+pub type RowVector6<T> = Matrix<T, U1, U6, ArrayStorage<T, 1, 6>>;
 
 /*
  *
@@ -315,14 +337,14 @@ pub type RowVector6<N> = Matrix<N, U1, U6, Owned<N, U1, U6>>;
  *
  */
 /// A stack-allocated, 1-dimensional unit vector.
-pub type UnitVector1<N> = Unit<Matrix<N, U1, U1, Owned<N, U1, U1>>>;
+pub type UnitVector1<T> = Unit<Matrix<T, U1, U1, ArrayStorage<T, 1, 1>>>;
 /// A stack-allocated, 2-dimensional unit vector.
-pub type UnitVector2<N> = Unit<Matrix<N, U2, U1, Owned<N, U2, U1>>>;
+pub type UnitVector2<T> = Unit<Matrix<T, U2, U1, ArrayStorage<T, 2, 1>>>;
 /// A stack-allocated, 3-dimensional unit vector.
-pub type UnitVector3<N> = Unit<Matrix<N, U3, U1, Owned<N, U3, U1>>>;
+pub type UnitVector3<T> = Unit<Matrix<T, U3, U1, ArrayStorage<T, 3, 1>>>;
 /// A stack-allocated, 4-dimensional unit vector.
-pub type UnitVector4<N> = Unit<Matrix<N, U4, U1, Owned<N, U4, U1>>>;
+pub type UnitVector4<T> = Unit<Matrix<T, U4, U1, ArrayStorage<T, 4, 1>>>;
 /// A stack-allocated, 5-dimensional unit vector.
-pub type UnitVector5<N> = Unit<Matrix<N, U5, U1, Owned<N, U5, U1>>>;
+pub type UnitVector5<T> = Unit<Matrix<T, U5, U1, ArrayStorage<T, 5, 1>>>;
 /// A stack-allocated, 6-dimensional unit vector.
-pub type UnitVector6<N> = Unit<Matrix<N, U6, U1, Owned<N, U6, U1>>>;
+pub type UnitVector6<T> = Unit<Matrix<T, U6, U1, ArrayStorage<T, 6, 1>>>;
diff --git a/src/base/alias_slice.rs b/src/base/alias_slice.rs
index d919fef9..929d2f03 100644
--- a/src/base/alias_slice.rs
+++ b/src/base/alias_slice.rs
@@ -1,6 +1,6 @@
 use crate::base::dimension::{Dynamic, U1, U2, U3, U4, U5, U6};
 use crate::base::matrix_slice::{SliceStorage, SliceStorageMut};
-use crate::base::Matrix;
+use crate::base::{Const, Matrix};
 
 /*
  *
@@ -9,287 +9,290 @@ use crate::base::Matrix;
  *
  *
  */
-/// A column-major matrix slice with `R` rows and `C` columns.
+// NOTE: we can't provide defaults for the strides because it's not supported yet by min_const_generics.
+/// 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 MatrixSliceMN<'a, N, R, C, RStride = U1, CStride = R> =
-    Matrix<N, R, C, SliceStorage<'a, N, 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 MatrixSliceN<'a, N, D, RStride = U1, CStride = D> =
-    Matrix<N, D, D, SliceStorage<'a, N, D, D, RStride, CStride>>;
+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>>>;
 
 /// 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, N, RStride = U1, CStride = Dynamic> =
-    Matrix<N, Dynamic, Dynamic, SliceStorage<'a, N, Dynamic, Dynamic, RStride, CStride>>;
+pub type DMatrixSlice<'a, T, RStride = U1, CStride = Dynamic> =
+    Matrix<T, Dynamic, Dynamic, SliceStorage<'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, N, RStride = U1, CStride = U1> =
-    Matrix<N, U1, U1, SliceStorage<'a, N, U1, U1, RStride, CStride>>;
+pub type MatrixSlice1<'a, T, RStride = U1, CStride = U1> =
+    Matrix<T, U1, U1, SliceStorage<'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, N, RStride = U1, CStride = U2> =
-    Matrix<N, U2, U2, SliceStorage<'a, N, U2, U2, RStride, CStride>>;
+pub type MatrixSlice2<'a, T, RStride = U1, CStride = U2> =
+    Matrix<T, U2, U2, SliceStorage<'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, N, RStride = U1, CStride = U3> =
-    Matrix<N, U3, U3, SliceStorage<'a, N, U3, U3, RStride, CStride>>;
+pub type MatrixSlice3<'a, T, RStride = U1, CStride = U3> =
+    Matrix<T, U3, U3, SliceStorage<'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, N, RStride = U1, CStride = U4> =
-    Matrix<N, U4, U4, SliceStorage<'a, N, U4, U4, RStride, CStride>>;
+pub type MatrixSlice4<'a, T, RStride = U1, CStride = U4> =
+    Matrix<T, U4, U4, SliceStorage<'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, N, RStride = U1, CStride = U5> =
-    Matrix<N, U5, U5, SliceStorage<'a, N, U5, U5, RStride, CStride>>;
+pub type MatrixSlice5<'a, T, RStride = U1, CStride = U5> =
+    Matrix<T, U5, U5, SliceStorage<'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, N, RStride = U1, CStride = U6> =
-    Matrix<N, U6, U6, SliceStorage<'a, N, U6, U6, RStride, CStride>>;
+pub type MatrixSlice6<'a, T, RStride = U1, CStride = U6> =
+    Matrix<T, U6, U6, SliceStorage<'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, N, RStride = U1, CStride = U1> =
-    Matrix<N, U1, U2, SliceStorage<'a, N, U1, U2, RStride, CStride>>;
+pub type MatrixSlice1x2<'a, T, RStride = U1, CStride = U1> =
+    Matrix<T, U1, U2, SliceStorage<'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, N, RStride = U1, CStride = U1> =
-    Matrix<N, U1, U3, SliceStorage<'a, N, U1, U3, RStride, CStride>>;
+pub type MatrixSlice1x3<'a, T, RStride = U1, CStride = U1> =
+    Matrix<T, U1, U3, SliceStorage<'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, N, RStride = U1, CStride = U1> =
-    Matrix<N, U1, U4, SliceStorage<'a, N, U1, U4, RStride, CStride>>;
+pub type MatrixSlice1x4<'a, T, RStride = U1, CStride = U1> =
+    Matrix<T, U1, U4, SliceStorage<'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, N, RStride = U1, CStride = U1> =
-    Matrix<N, U1, U5, SliceStorage<'a, N, U1, U5, RStride, CStride>>;
+pub type MatrixSlice1x5<'a, T, RStride = U1, CStride = U1> =
+    Matrix<T, U1, U5, SliceStorage<'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, N, RStride = U1, CStride = U1> =
-    Matrix<N, U1, U6, SliceStorage<'a, N, U1, U6, RStride, CStride>>;
+pub type MatrixSlice1x6<'a, T, RStride = U1, CStride = U1> =
+    Matrix<T, U1, U6, SliceStorage<'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, N, RStride = U1, CStride = U2> =
-    Matrix<N, U2, U1, SliceStorage<'a, N, U2, U1, RStride, CStride>>;
+pub type MatrixSlice2x1<'a, T, RStride = U1, CStride = U2> =
+    Matrix<T, U2, U1, SliceStorage<'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, N, RStride = U1, CStride = U2> =
-    Matrix<N, U2, U3, SliceStorage<'a, N, U2, U3, RStride, CStride>>;
+pub type MatrixSlice2x3<'a, T, RStride = U1, CStride = U2> =
+    Matrix<T, U2, U3, SliceStorage<'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, N, RStride = U1, CStride = U2> =
-    Matrix<N, U2, U4, SliceStorage<'a, N, U2, U4, RStride, CStride>>;
+pub type MatrixSlice2x4<'a, T, RStride = U1, CStride = U2> =
+    Matrix<T, U2, U4, SliceStorage<'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, N, RStride = U1, CStride = U2> =
-    Matrix<N, U2, U5, SliceStorage<'a, N, U2, U5, RStride, CStride>>;
+pub type MatrixSlice2x5<'a, T, RStride = U1, CStride = U2> =
+    Matrix<T, U2, U5, SliceStorage<'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, N, RStride = U1, CStride = U2> =
-    Matrix<N, U2, U6, SliceStorage<'a, N, U2, U6, RStride, CStride>>;
+pub type MatrixSlice2x6<'a, T, RStride = U1, CStride = U2> =
+    Matrix<T, U2, U6, SliceStorage<'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, N, RStride = U1, CStride = U3> =
-    Matrix<N, U3, U1, SliceStorage<'a, N, U3, U1, RStride, CStride>>;
+pub type MatrixSlice3x1<'a, T, RStride = U1, CStride = U3> =
+    Matrix<T, U3, U1, SliceStorage<'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, N, RStride = U1, CStride = U3> =
-    Matrix<N, U3, U2, SliceStorage<'a, N, U3, U2, RStride, CStride>>;
+pub type MatrixSlice3x2<'a, T, RStride = U1, CStride = U3> =
+    Matrix<T, U3, U2, SliceStorage<'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, N, RStride = U1, CStride = U3> =
-    Matrix<N, U3, U4, SliceStorage<'a, N, U3, U4, RStride, CStride>>;
+pub type MatrixSlice3x4<'a, T, RStride = U1, CStride = U3> =
+    Matrix<T, U3, U4, SliceStorage<'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, N, RStride = U1, CStride = U3> =
-    Matrix<N, U3, U5, SliceStorage<'a, N, U3, U5, RStride, CStride>>;
+pub type MatrixSlice3x5<'a, T, RStride = U1, CStride = U3> =
+    Matrix<T, U3, U5, SliceStorage<'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, N, RStride = U1, CStride = U3> =
-    Matrix<N, U3, U6, SliceStorage<'a, N, U3, U6, RStride, CStride>>;
+pub type MatrixSlice3x6<'a, T, RStride = U1, CStride = U3> =
+    Matrix<T, U3, U6, SliceStorage<'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, N, RStride = U1, CStride = U4> =
-    Matrix<N, U4, U1, SliceStorage<'a, N, U4, U1, RStride, CStride>>;
+pub type MatrixSlice4x1<'a, T, RStride = U1, CStride = U4> =
+    Matrix<T, U4, U1, SliceStorage<'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, N, RStride = U1, CStride = U4> =
-    Matrix<N, U4, U2, SliceStorage<'a, N, U4, U2, RStride, CStride>>;
+pub type MatrixSlice4x2<'a, T, RStride = U1, CStride = U4> =
+    Matrix<T, U4, U2, SliceStorage<'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, N, RStride = U1, CStride = U4> =
-    Matrix<N, U4, U3, SliceStorage<'a, N, U4, U3, RStride, CStride>>;
+pub type MatrixSlice4x3<'a, T, RStride = U1, CStride = U4> =
+    Matrix<T, U4, U3, SliceStorage<'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, N, RStride = U1, CStride = U4> =
-    Matrix<N, U4, U5, SliceStorage<'a, N, U4, U5, RStride, CStride>>;
+pub type MatrixSlice4x5<'a, T, RStride = U1, CStride = U4> =
+    Matrix<T, U4, U5, SliceStorage<'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, N, RStride = U1, CStride = U4> =
-    Matrix<N, U4, U6, SliceStorage<'a, N, U4, U6, RStride, CStride>>;
+pub type MatrixSlice4x6<'a, T, RStride = U1, CStride = U4> =
+    Matrix<T, U4, U6, SliceStorage<'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, N, RStride = U1, CStride = U5> =
-    Matrix<N, U5, U1, SliceStorage<'a, N, U5, U1, RStride, CStride>>;
+pub type MatrixSlice5x1<'a, T, RStride = U1, CStride = U5> =
+    Matrix<T, U5, U1, SliceStorage<'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, N, RStride = U1, CStride = U5> =
-    Matrix<N, U5, U2, SliceStorage<'a, N, U5, U2, RStride, CStride>>;
+pub type MatrixSlice5x2<'a, T, RStride = U1, CStride = U5> =
+    Matrix<T, U5, U2, SliceStorage<'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, N, RStride = U1, CStride = U5> =
-    Matrix<N, U5, U3, SliceStorage<'a, N, U5, U3, RStride, CStride>>;
+pub type MatrixSlice5x3<'a, T, RStride = U1, CStride = U5> =
+    Matrix<T, U5, U3, SliceStorage<'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, N, RStride = U1, CStride = U5> =
-    Matrix<N, U5, U4, SliceStorage<'a, N, U5, U4, RStride, CStride>>;
+pub type MatrixSlice5x4<'a, T, RStride = U1, CStride = U5> =
+    Matrix<T, U5, U4, SliceStorage<'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, N, RStride = U1, CStride = U5> =
-    Matrix<N, U5, U6, SliceStorage<'a, N, U5, U6, RStride, CStride>>;
+pub type MatrixSlice5x6<'a, T, RStride = U1, CStride = U5> =
+    Matrix<T, U5, U6, SliceStorage<'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, N, RStride = U1, CStride = U6> =
-    Matrix<N, U6, U1, SliceStorage<'a, N, U6, U1, RStride, CStride>>;
+pub type MatrixSlice6x1<'a, T, RStride = U1, CStride = U6> =
+    Matrix<T, U6, U1, SliceStorage<'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, N, RStride = U1, CStride = U6> =
-    Matrix<N, U6, U2, SliceStorage<'a, N, U6, U2, RStride, CStride>>;
+pub type MatrixSlice6x2<'a, T, RStride = U1, CStride = U6> =
+    Matrix<T, U6, U2, SliceStorage<'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, N, RStride = U1, CStride = U6> =
-    Matrix<N, U6, U3, SliceStorage<'a, N, U6, U3, RStride, CStride>>;
+pub type MatrixSlice6x3<'a, T, RStride = U1, CStride = U6> =
+    Matrix<T, U6, U3, SliceStorage<'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, N, RStride = U1, CStride = U6> =
-    Matrix<N, U6, U4, SliceStorage<'a, N, U6, U4, RStride, CStride>>;
+pub type MatrixSlice6x4<'a, T, RStride = U1, CStride = U6> =
+    Matrix<T, U6, U4, SliceStorage<'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, N, RStride = U1, CStride = U6> =
-    Matrix<N, U6, U5, SliceStorage<'a, N, U6, U5, RStride, CStride>>;
+pub type MatrixSlice6x5<'a, T, RStride = U1, CStride = U6> =
+    Matrix<T, U6, U5, SliceStorage<'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, N, RStride = U1, CStride = U1> =
-    Matrix<N, U1, Dynamic, SliceStorage<'a, N, U1, Dynamic, RStride, CStride>>;
+pub type MatrixSlice1xX<'a, T, RStride = U1, CStride = U1> =
+    Matrix<T, U1, Dynamic, SliceStorage<'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, N, RStride = U1, CStride = U2> =
-    Matrix<N, U2, Dynamic, SliceStorage<'a, N, U2, Dynamic, RStride, CStride>>;
+pub type MatrixSlice2xX<'a, T, RStride = U1, CStride = U2> =
+    Matrix<T, U2, Dynamic, SliceStorage<'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, N, RStride = U1, CStride = U3> =
-    Matrix<N, U3, Dynamic, SliceStorage<'a, N, U3, Dynamic, RStride, CStride>>;
+pub type MatrixSlice3xX<'a, T, RStride = U1, CStride = U3> =
+    Matrix<T, U3, Dynamic, SliceStorage<'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, N, RStride = U1, CStride = U4> =
-    Matrix<N, U4, Dynamic, SliceStorage<'a, N, U4, Dynamic, RStride, CStride>>;
+pub type MatrixSlice4xX<'a, T, RStride = U1, CStride = U4> =
+    Matrix<T, U4, Dynamic, SliceStorage<'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, N, RStride = U1, CStride = U5> =
-    Matrix<N, U5, Dynamic, SliceStorage<'a, N, U5, Dynamic, RStride, CStride>>;
+pub type MatrixSlice5xX<'a, T, RStride = U1, CStride = U5> =
+    Matrix<T, U5, Dynamic, SliceStorage<'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, N, RStride = U1, CStride = U6> =
-    Matrix<N, U6, Dynamic, SliceStorage<'a, N, U6, Dynamic, RStride, CStride>>;
+pub type MatrixSlice6xX<'a, T, RStride = U1, CStride = U6> =
+    Matrix<T, U6, Dynamic, SliceStorage<'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, N, RStride = U1, CStride = Dynamic> =
-    Matrix<N, Dynamic, U1, SliceStorage<'a, N, Dynamic, U1, RStride, CStride>>;
+pub type MatrixSliceXx1<'a, T, RStride = U1, CStride = Dynamic> =
+    Matrix<T, Dynamic, U1, SliceStorage<'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, N, RStride = U1, CStride = Dynamic> =
-    Matrix<N, Dynamic, U2, SliceStorage<'a, N, Dynamic, U2, RStride, CStride>>;
+pub type MatrixSliceXx2<'a, T, RStride = U1, CStride = Dynamic> =
+    Matrix<T, Dynamic, U2, SliceStorage<'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, N, RStride = U1, CStride = Dynamic> =
-    Matrix<N, Dynamic, U3, SliceStorage<'a, N, Dynamic, U3, RStride, CStride>>;
+pub type MatrixSliceXx3<'a, T, RStride = U1, CStride = Dynamic> =
+    Matrix<T, Dynamic, U3, SliceStorage<'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, N, RStride = U1, CStride = Dynamic> =
-    Matrix<N, Dynamic, U4, SliceStorage<'a, N, Dynamic, U4, RStride, CStride>>;
+pub type MatrixSliceXx4<'a, T, RStride = U1, CStride = Dynamic> =
+    Matrix<T, Dynamic, U4, SliceStorage<'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, N, RStride = U1, CStride = Dynamic> =
-    Matrix<N, Dynamic, U5, SliceStorage<'a, N, Dynamic, U5, RStride, CStride>>;
+pub type MatrixSliceXx5<'a, T, RStride = U1, CStride = Dynamic> =
+    Matrix<T, Dynamic, U5, SliceStorage<'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, N, RStride = U1, CStride = Dynamic> =
-    Matrix<N, Dynamic, U6, SliceStorage<'a, N, Dynamic, U6, RStride, CStride>>;
+pub type MatrixSliceXx6<'a, T, RStride = U1, CStride = Dynamic> =
+    Matrix<T, Dynamic, U6, SliceStorage<'a, T, Dynamic, U6, RStride, CStride>>;
 
-/// A column vector slice with `D` rows.
-pub type VectorSliceN<'a, N, D, RStride = U1, CStride = D> =
-    Matrix<N, D, U1, SliceStorage<'a, N, 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 VectorSlice<'a, T, D, RStride = U1, CStride = D> =
+    Matrix<T, D, U1, SliceStorage<'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>>>;
 
 /// A column vector slice dynamic numbers of rows and columns.
-pub type DVectorSlice<'a, N, RStride = U1, CStride = Dynamic> =
-    Matrix<N, Dynamic, U1, SliceStorage<'a, N, Dynamic, U1, RStride, CStride>>;
+pub type DVectorSlice<'a, T, RStride = U1, CStride = Dynamic> =
+    Matrix<T, Dynamic, U1, SliceStorage<'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, N, RStride = U1, CStride = U1> =
-    Matrix<N, U1, U1, SliceStorage<'a, N, U1, U1, RStride, CStride>>;
+pub type VectorSlice1<'a, T, RStride = U1, CStride = U1> =
+    Matrix<T, U1, U1, SliceStorage<'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, N, RStride = U1, CStride = U2> =
-    Matrix<N, U2, U1, SliceStorage<'a, N, U2, U1, RStride, CStride>>;
+pub type VectorSlice2<'a, T, RStride = U1, CStride = U2> =
+    Matrix<T, U2, U1, SliceStorage<'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, N, RStride = U1, CStride = U3> =
-    Matrix<N, U3, U1, SliceStorage<'a, N, U3, U1, RStride, CStride>>;
+pub type VectorSlice3<'a, T, RStride = U1, CStride = U3> =
+    Matrix<T, U3, U1, SliceStorage<'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, N, RStride = U1, CStride = U4> =
-    Matrix<N, U4, U1, SliceStorage<'a, N, U4, U1, RStride, CStride>>;
+pub type VectorSlice4<'a, T, RStride = U1, CStride = U4> =
+    Matrix<T, U4, U1, SliceStorage<'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, N, RStride = U1, CStride = U5> =
-    Matrix<N, U5, U1, SliceStorage<'a, N, U5, U1, RStride, CStride>>;
+pub type VectorSlice5<'a, T, RStride = U1, CStride = U5> =
+    Matrix<T, U5, U1, SliceStorage<'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, N, RStride = U1, CStride = U6> =
-    Matrix<N, U6, U1, SliceStorage<'a, N, U6, U1, RStride, CStride>>;
+pub type VectorSlice6<'a, T, RStride = U1, CStride = U6> =
+    Matrix<T, U6, U1, SliceStorage<'a, T, U6, U1, RStride, CStride>>;
 
 /*
  *
@@ -301,281 +304,297 @@ pub type VectorSlice6<'a, N, 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.**
-pub type MatrixSliceMutMN<'a, N, R, C, RStride = U1, CStride = R> =
-    Matrix<N, R, C, SliceStorageMut<'a, N, R, C, RStride, CStride>>;
+pub type MatrixSliceMutMN<'a, T, R, C, RStride = U1, CStride = R> =
+    Matrix<T, R, C, SliceStorageMut<'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, N, D, RStride = U1, CStride = D> =
-    Matrix<N, D, D, SliceStorageMut<'a, N, D, D, RStride, CStride>>;
+pub type MatrixSliceMutN<'a, T, D, RStride = U1, CStride = D> =
+    Matrix<T, D, D, SliceStorageMut<'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>>>;
 
 /// 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, N, RStride = U1, CStride = Dynamic> =
-    Matrix<N, Dynamic, Dynamic, SliceStorageMut<'a, N, Dynamic, Dynamic, RStride, CStride>>;
+pub type DMatrixSliceMut<'a, T, RStride = U1, CStride = Dynamic> =
+    Matrix<T, Dynamic, Dynamic, SliceStorageMut<'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, N, RStride = U1, CStride = U1> =
-    Matrix<N, U1, U1, SliceStorageMut<'a, N, U1, U1, RStride, CStride>>;
+pub type MatrixSliceMut1<'a, T, RStride = U1, CStride = U1> =
+    Matrix<T, U1, U1, SliceStorageMut<'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, N, RStride = U1, CStride = U2> =
-    Matrix<N, U2, U2, SliceStorageMut<'a, N, U2, U2, RStride, CStride>>;
+pub type MatrixSliceMut2<'a, T, RStride = U1, CStride = U2> =
+    Matrix<T, U2, U2, SliceStorageMut<'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, N, RStride = U1, CStride = U3> =
-    Matrix<N, U3, U3, SliceStorageMut<'a, N, U3, U3, RStride, CStride>>;
+pub type MatrixSliceMut3<'a, T, RStride = U1, CStride = U3> =
+    Matrix<T, U3, U3, SliceStorageMut<'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, N, RStride = U1, CStride = U4> =
-    Matrix<N, U4, U4, SliceStorageMut<'a, N, U4, U4, RStride, CStride>>;
+pub type MatrixSliceMut4<'a, T, RStride = U1, CStride = U4> =
+    Matrix<T, U4, U4, SliceStorageMut<'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, N, RStride = U1, CStride = U5> =
-    Matrix<N, U5, U5, SliceStorageMut<'a, N, U5, U5, RStride, CStride>>;
+pub type MatrixSliceMut5<'a, T, RStride = U1, CStride = U5> =
+    Matrix<T, U5, U5, SliceStorageMut<'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, N, RStride = U1, CStride = U6> =
-    Matrix<N, U6, U6, SliceStorageMut<'a, N, U6, U6, RStride, CStride>>;
+pub type MatrixSliceMut6<'a, T, RStride = U1, CStride = U6> =
+    Matrix<T, U6, U6, SliceStorageMut<'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, N, RStride = U1, CStride = U1> =
-    Matrix<N, U1, U2, SliceStorageMut<'a, N, U1, U2, RStride, CStride>>;
+pub type MatrixSliceMut1x2<'a, T, RStride = U1, CStride = U1> =
+    Matrix<T, U1, U2, SliceStorageMut<'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, N, RStride = U1, CStride = U1> =
-    Matrix<N, U1, U3, SliceStorageMut<'a, N, U1, U3, RStride, CStride>>;
+pub type MatrixSliceMut1x3<'a, T, RStride = U1, CStride = U1> =
+    Matrix<T, U1, U3, SliceStorageMut<'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, N, RStride = U1, CStride = U1> =
-    Matrix<N, U1, U4, SliceStorageMut<'a, N, U1, U4, RStride, CStride>>;
+pub type MatrixSliceMut1x4<'a, T, RStride = U1, CStride = U1> =
+    Matrix<T, U1, U4, SliceStorageMut<'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, N, RStride = U1, CStride = U1> =
-    Matrix<N, U1, U5, SliceStorageMut<'a, N, U1, U5, RStride, CStride>>;
+pub type MatrixSliceMut1x5<'a, T, RStride = U1, CStride = U1> =
+    Matrix<T, U1, U5, SliceStorageMut<'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, N, RStride = U1, CStride = U1> =
-    Matrix<N, U1, U6, SliceStorageMut<'a, N, U1, U6, RStride, CStride>>;
+pub type MatrixSliceMut1x6<'a, T, RStride = U1, CStride = U1> =
+    Matrix<T, U1, U6, SliceStorageMut<'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, N, RStride = U1, CStride = U2> =
-    Matrix<N, U2, U1, SliceStorageMut<'a, N, U2, U1, RStride, CStride>>;
+pub type MatrixSliceMut2x1<'a, T, RStride = U1, CStride = U2> =
+    Matrix<T, U2, U1, SliceStorageMut<'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, N, RStride = U1, CStride = U2> =
-    Matrix<N, U2, U3, SliceStorageMut<'a, N, U2, U3, RStride, CStride>>;
+pub type MatrixSliceMut2x3<'a, T, RStride = U1, CStride = U2> =
+    Matrix<T, U2, U3, SliceStorageMut<'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, N, RStride = U1, CStride = U2> =
-    Matrix<N, U2, U4, SliceStorageMut<'a, N, U2, U4, RStride, CStride>>;
+pub type MatrixSliceMut2x4<'a, T, RStride = U1, CStride = U2> =
+    Matrix<T, U2, U4, SliceStorageMut<'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, N, RStride = U1, CStride = U2> =
-    Matrix<N, U2, U5, SliceStorageMut<'a, N, U2, U5, RStride, CStride>>;
+pub type MatrixSliceMut2x5<'a, T, RStride = U1, CStride = U2> =
+    Matrix<T, U2, U5, SliceStorageMut<'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, N, RStride = U1, CStride = U2> =
-    Matrix<N, U2, U6, SliceStorageMut<'a, N, U2, U6, RStride, CStride>>;
+pub type MatrixSliceMut2x6<'a, T, RStride = U1, CStride = U2> =
+    Matrix<T, U2, U6, SliceStorageMut<'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, N, RStride = U1, CStride = U3> =
-    Matrix<N, U3, U1, SliceStorageMut<'a, N, U3, U1, RStride, CStride>>;
+pub type MatrixSliceMut3x1<'a, T, RStride = U1, CStride = U3> =
+    Matrix<T, U3, U1, SliceStorageMut<'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, N, RStride = U1, CStride = U3> =
-    Matrix<N, U3, U2, SliceStorageMut<'a, N, U3, U2, RStride, CStride>>;
+pub type MatrixSliceMut3x2<'a, T, RStride = U1, CStride = U3> =
+    Matrix<T, U3, U2, SliceStorageMut<'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, N, RStride = U1, CStride = U3> =
-    Matrix<N, U3, U4, SliceStorageMut<'a, N, U3, U4, RStride, CStride>>;
+pub type MatrixSliceMut3x4<'a, T, RStride = U1, CStride = U3> =
+    Matrix<T, U3, U4, SliceStorageMut<'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, N, RStride = U1, CStride = U3> =
-    Matrix<N, U3, U5, SliceStorageMut<'a, N, U3, U5, RStride, CStride>>;
+pub type MatrixSliceMut3x5<'a, T, RStride = U1, CStride = U3> =
+    Matrix<T, U3, U5, SliceStorageMut<'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, N, RStride = U1, CStride = U3> =
-    Matrix<N, U3, U6, SliceStorageMut<'a, N, U3, U6, RStride, CStride>>;
+pub type MatrixSliceMut3x6<'a, T, RStride = U1, CStride = U3> =
+    Matrix<T, U3, U6, SliceStorageMut<'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, N, RStride = U1, CStride = U4> =
-    Matrix<N, U4, U1, SliceStorageMut<'a, N, U4, U1, RStride, CStride>>;
+pub type MatrixSliceMut4x1<'a, T, RStride = U1, CStride = U4> =
+    Matrix<T, U4, U1, SliceStorageMut<'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, N, RStride = U1, CStride = U4> =
-    Matrix<N, U4, U2, SliceStorageMut<'a, N, U4, U2, RStride, CStride>>;
+pub type MatrixSliceMut4x2<'a, T, RStride = U1, CStride = U4> =
+    Matrix<T, U4, U2, SliceStorageMut<'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, N, RStride = U1, CStride = U4> =
-    Matrix<N, U4, U3, SliceStorageMut<'a, N, U4, U3, RStride, CStride>>;
+pub type MatrixSliceMut4x3<'a, T, RStride = U1, CStride = U4> =
+    Matrix<T, U4, U3, SliceStorageMut<'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, N, RStride = U1, CStride = U4> =
-    Matrix<N, U4, U5, SliceStorageMut<'a, N, U4, U5, RStride, CStride>>;
+pub type MatrixSliceMut4x5<'a, T, RStride = U1, CStride = U4> =
+    Matrix<T, U4, U5, SliceStorageMut<'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, N, RStride = U1, CStride = U4> =
-    Matrix<N, U4, U6, SliceStorageMut<'a, N, U4, U6, RStride, CStride>>;
+pub type MatrixSliceMut4x6<'a, T, RStride = U1, CStride = U4> =
+    Matrix<T, U4, U6, SliceStorageMut<'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, N, RStride = U1, CStride = U5> =
-    Matrix<N, U5, U1, SliceStorageMut<'a, N, U5, U1, RStride, CStride>>;
+pub type MatrixSliceMut5x1<'a, T, RStride = U1, CStride = U5> =
+    Matrix<T, U5, U1, SliceStorageMut<'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, N, RStride = U1, CStride = U5> =
-    Matrix<N, U5, U2, SliceStorageMut<'a, N, U5, U2, RStride, CStride>>;
+pub type MatrixSliceMut5x2<'a, T, RStride = U1, CStride = U5> =
+    Matrix<T, U5, U2, SliceStorageMut<'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, N, RStride = U1, CStride = U5> =
-    Matrix<N, U5, U3, SliceStorageMut<'a, N, U5, U3, RStride, CStride>>;
+pub type MatrixSliceMut5x3<'a, T, RStride = U1, CStride = U5> =
+    Matrix<T, U5, U3, SliceStorageMut<'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, N, RStride = U1, CStride = U5> =
-    Matrix<N, U5, U4, SliceStorageMut<'a, N, U5, U4, RStride, CStride>>;
+pub type MatrixSliceMut5x4<'a, T, RStride = U1, CStride = U5> =
+    Matrix<T, U5, U4, SliceStorageMut<'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, N, RStride = U1, CStride = U5> =
-    Matrix<N, U5, U6, SliceStorageMut<'a, N, U5, U6, RStride, CStride>>;
+pub type MatrixSliceMut5x6<'a, T, RStride = U1, CStride = U5> =
+    Matrix<T, U5, U6, SliceStorageMut<'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, N, RStride = U1, CStride = U6> =
-    Matrix<N, U6, U1, SliceStorageMut<'a, N, U6, U1, RStride, CStride>>;
+pub type MatrixSliceMut6x1<'a, T, RStride = U1, CStride = U6> =
+    Matrix<T, U6, U1, SliceStorageMut<'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, N, RStride = U1, CStride = U6> =
-    Matrix<N, U6, U2, SliceStorageMut<'a, N, U6, U2, RStride, CStride>>;
+pub type MatrixSliceMut6x2<'a, T, RStride = U1, CStride = U6> =
+    Matrix<T, U6, U2, SliceStorageMut<'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, N, RStride = U1, CStride = U6> =
-    Matrix<N, U6, U3, SliceStorageMut<'a, N, U6, U3, RStride, CStride>>;
+pub type MatrixSliceMut6x3<'a, T, RStride = U1, CStride = U6> =
+    Matrix<T, U6, U3, SliceStorageMut<'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, N, RStride = U1, CStride = U6> =
-    Matrix<N, U6, U4, SliceStorageMut<'a, N, U6, U4, RStride, CStride>>;
+pub type MatrixSliceMut6x4<'a, T, RStride = U1, CStride = U6> =
+    Matrix<T, U6, U4, SliceStorageMut<'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, N, RStride = U1, CStride = U6> =
-    Matrix<N, U6, U5, SliceStorageMut<'a, N, U6, U5, RStride, CStride>>;
+pub type MatrixSliceMut6x5<'a, T, RStride = U1, CStride = U6> =
+    Matrix<T, U6, U5, SliceStorageMut<'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, N, RStride = U1, CStride = U1> =
-    Matrix<N, U1, Dynamic, SliceStorageMut<'a, N, U1, Dynamic, RStride, CStride>>;
+pub type MatrixSliceMut1xX<'a, T, RStride = U1, CStride = U1> =
+    Matrix<T, U1, Dynamic, SliceStorageMut<'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, N, RStride = U1, CStride = U2> =
-    Matrix<N, U2, Dynamic, SliceStorageMut<'a, N, U2, Dynamic, RStride, CStride>>;
+pub type MatrixSliceMut2xX<'a, T, RStride = U1, CStride = U2> =
+    Matrix<T, U2, Dynamic, SliceStorageMut<'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, N, RStride = U1, CStride = U3> =
-    Matrix<N, U3, Dynamic, SliceStorageMut<'a, N, U3, Dynamic, RStride, CStride>>;
+pub type MatrixSliceMut3xX<'a, T, RStride = U1, CStride = U3> =
+    Matrix<T, U3, Dynamic, SliceStorageMut<'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, N, RStride = U1, CStride = U4> =
-    Matrix<N, U4, Dynamic, SliceStorageMut<'a, N, U4, Dynamic, RStride, CStride>>;
+pub type MatrixSliceMut4xX<'a, T, RStride = U1, CStride = U4> =
+    Matrix<T, U4, Dynamic, SliceStorageMut<'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, N, RStride = U1, CStride = U5> =
-    Matrix<N, U5, Dynamic, SliceStorageMut<'a, N, U5, Dynamic, RStride, CStride>>;
+pub type MatrixSliceMut5xX<'a, T, RStride = U1, CStride = U5> =
+    Matrix<T, U5, Dynamic, SliceStorageMut<'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, N, RStride = U1, CStride = U6> =
-    Matrix<N, U6, Dynamic, SliceStorageMut<'a, N, U6, Dynamic, RStride, CStride>>;
+pub type MatrixSliceMut6xX<'a, T, RStride = U1, CStride = U6> =
+    Matrix<T, U6, Dynamic, SliceStorageMut<'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, N, RStride = U1, CStride = Dynamic> =
-    Matrix<N, Dynamic, U1, SliceStorageMut<'a, N, Dynamic, U1, RStride, CStride>>;
+pub type MatrixSliceMutXx1<'a, T, RStride = U1, CStride = Dynamic> =
+    Matrix<T, Dynamic, U1, SliceStorageMut<'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, N, RStride = U1, CStride = Dynamic> =
-    Matrix<N, Dynamic, U2, SliceStorageMut<'a, N, Dynamic, U2, RStride, CStride>>;
+pub type MatrixSliceMutXx2<'a, T, RStride = U1, CStride = Dynamic> =
+    Matrix<T, Dynamic, U2, SliceStorageMut<'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, N, RStride = U1, CStride = Dynamic> =
-    Matrix<N, Dynamic, U3, SliceStorageMut<'a, N, Dynamic, U3, RStride, CStride>>;
+pub type MatrixSliceMutXx3<'a, T, RStride = U1, CStride = Dynamic> =
+    Matrix<T, Dynamic, U3, SliceStorageMut<'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, N, RStride = U1, CStride = Dynamic> =
-    Matrix<N, Dynamic, U4, SliceStorageMut<'a, N, Dynamic, U4, RStride, CStride>>;
+pub type MatrixSliceMutXx4<'a, T, RStride = U1, CStride = Dynamic> =
+    Matrix<T, Dynamic, U4, SliceStorageMut<'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, N, RStride = U1, CStride = Dynamic> =
-    Matrix<N, Dynamic, U5, SliceStorageMut<'a, N, Dynamic, U5, RStride, CStride>>;
+pub type MatrixSliceMutXx5<'a, T, RStride = U1, CStride = Dynamic> =
+    Matrix<T, Dynamic, U5, SliceStorageMut<'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, N, RStride = U1, CStride = Dynamic> =
-    Matrix<N, Dynamic, U6, SliceStorageMut<'a, N, Dynamic, U6, RStride, CStride>>;
+pub type MatrixSliceMutXx6<'a, T, RStride = U1, CStride = Dynamic> =
+    Matrix<T, Dynamic, U6, SliceStorageMut<'a, T, Dynamic, U6, RStride, CStride>>;
 
-/// A column vector slice with `D` rows.
-pub type VectorSliceMutN<'a, N, D, RStride = U1, CStride = D> =
-    Matrix<N, D, U1, SliceStorageMut<'a, N, 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 VectorSliceMut<'a, T, D, RStride = U1, CStride = D> =
+    Matrix<T, D, U1, SliceStorageMut<'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>>>;
 
 /// A column vector slice dynamic numbers of rows and columns.
-pub type DVectorSliceMut<'a, N, RStride = U1, CStride = Dynamic> =
-    Matrix<N, Dynamic, U1, SliceStorageMut<'a, N, Dynamic, U1, RStride, CStride>>;
+///
+/// **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>>;
 
 /// 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, N, RStride = U1, CStride = U1> =
-    Matrix<N, U1, U1, SliceStorageMut<'a, N, U1, U1, RStride, CStride>>;
+pub type VectorSliceMut1<'a, T, RStride = U1, CStride = U1> =
+    Matrix<T, U1, U1, SliceStorageMut<'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, N, RStride = U1, CStride = U2> =
-    Matrix<N, U2, U1, SliceStorageMut<'a, N, U2, U1, RStride, CStride>>;
+pub type VectorSliceMut2<'a, T, RStride = U1, CStride = U2> =
+    Matrix<T, U2, U1, SliceStorageMut<'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, N, RStride = U1, CStride = U3> =
-    Matrix<N, U3, U1, SliceStorageMut<'a, N, U3, U1, RStride, CStride>>;
+pub type VectorSliceMut3<'a, T, RStride = U1, CStride = U3> =
+    Matrix<T, U3, U1, SliceStorageMut<'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, N, RStride = U1, CStride = U4> =
-    Matrix<N, U4, U1, SliceStorageMut<'a, N, U4, U1, RStride, CStride>>;
+pub type VectorSliceMut4<'a, T, RStride = U1, CStride = U4> =
+    Matrix<T, U4, U1, SliceStorageMut<'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, N, RStride = U1, CStride = U5> =
-    Matrix<N, U5, U1, SliceStorageMut<'a, N, U5, U1, RStride, CStride>>;
+pub type VectorSliceMut5<'a, T, RStride = U1, CStride = U5> =
+    Matrix<T, U5, U1, SliceStorageMut<'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, N, RStride = U1, CStride = U6> =
-    Matrix<N, U6, U1, SliceStorageMut<'a, N, U6, U1, RStride, CStride>>;
+pub type VectorSliceMut6<'a, T, RStride = U1, CStride = U6> =
+    Matrix<T, U6, U1, SliceStorageMut<'a, T, U6, U1, RStride, CStride>>;
diff --git a/src/base/allocator.rs b/src/base/allocator.rs
index 3632cf5d..062ffbc2 100644
--- a/src/base/allocator.rs
+++ b/src/base/allocator.rs
@@ -9,7 +9,7 @@ use crate::base::storage::ContiguousStorageMut;
 use crate::base::{DefaultAllocator, Scalar};
 
 /// A matrix allocator of a memory buffer that may contain `R::to_usize() * C::to_usize()`
-/// elements of type `N`.
+/// elements of type `T`.
 ///
 /// An allocator is said to be:
 ///   − static:  if `R` and `C` both implement `DimName`.
@@ -17,15 +17,15 @@ use crate::base::{DefaultAllocator, Scalar};
 ///
 /// Every allocator must be both static and dynamic. Though not all implementations may share the
 /// same `Buffer` type.
-pub trait Allocator<N: Scalar, R: Dim, C: Dim = U1>: Any + Sized {
+pub trait Allocator<T: Scalar, R: Dim, C: Dim = U1>: Any + Sized {
     /// The type of buffer this allocator can instanciate.
-    type Buffer: ContiguousStorageMut<N, R, C> + Clone;
+    type Buffer: ContiguousStorageMut<T, R, C> + Clone;
 
     /// Allocates a buffer with the given number of rows and columns without initializing its content.
     unsafe fn allocate_uninitialized(nrows: R, ncols: C) -> mem::MaybeUninit<Self::Buffer>;
 
     /// Allocates a buffer initialized with the content of the given iterator.
-    fn allocate_from_iterator<I: IntoIterator<Item = N>>(
+    fn allocate_from_iterator<I: IntoIterator<Item = T>>(
         nrows: R,
         ncols: C,
         iter: I,
@@ -34,8 +34,8 @@ pub trait Allocator<N: Scalar, R: Dim, C: Dim = U1>: Any + Sized {
 
 /// A matrix reallocator. Changes the size of the memory buffer that initially contains (RFrom ×
 /// CFrom) elements to a smaller or larger size (RTo, CTo).
-pub trait Reallocator<N: Scalar, RFrom: Dim, CFrom: Dim, RTo: Dim, CTo: Dim>:
-    Allocator<N, RFrom, CFrom> + Allocator<N, RTo, CTo>
+pub trait Reallocator<T: Scalar, RFrom: Dim, CFrom: Dim, RTo: Dim, CTo: Dim>:
+    Allocator<T, RFrom, CFrom> + Allocator<T, RTo, CTo>
 {
     /// Reallocates a buffer of shape `(RTo, CTo)`, possibly reusing a previously allocated buffer
     /// `buf`. Data stored by `buf` are linearly copied to the output:
@@ -47,8 +47,8 @@ pub trait Reallocator<N: Scalar, RFrom: Dim, CFrom: Dim, RTo: Dim, CTo: Dim>:
     unsafe fn reallocate_copy(
         nrows: RTo,
         ncols: CTo,
-        buf: <Self as Allocator<N, RFrom, CFrom>>::Buffer,
-    ) -> <Self as Allocator<N, RTo, CTo>>::Buffer;
+        buf: <Self as Allocator<T, RFrom, CFrom>>::Buffer,
+    ) -> <Self as Allocator<T, RTo, CTo>>::Buffer;
 }
 
 /// The number of rows of the result of a componentwise operation on two matrices.
@@ -59,48 +59,48 @@ pub type SameShapeC<C1, C2> = <ShapeConstraint as SameNumberOfColumns<C1, C2>>::
 
 // TODO: Bad name.
 /// Restricts the given number of rows and columns to be respectively the same.
-pub trait SameShapeAllocator<N, R1, C1, R2, C2>:
-    Allocator<N, R1, C1> + Allocator<N, SameShapeR<R1, R2>, SameShapeC<C1, C2>>
+pub trait SameShapeAllocator<T, R1, C1, R2, C2>:
+    Allocator<T, R1, C1> + Allocator<T, SameShapeR<R1, R2>, SameShapeC<C1, C2>>
 where
     R1: Dim,
     R2: Dim,
     C1: Dim,
     C2: Dim,
-    N: Scalar,
+    T: Scalar,
     ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
 {
 }
 
-impl<N, R1, R2, C1, C2> SameShapeAllocator<N, R1, C1, R2, C2> for DefaultAllocator
+impl<T, R1, R2, C1, C2> SameShapeAllocator<T, R1, C1, R2, C2> for DefaultAllocator
 where
     R1: Dim,
     R2: Dim,
     C1: Dim,
     C2: Dim,
-    N: Scalar,
-    DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, SameShapeR<R1, R2>, SameShapeC<C1, C2>>,
+    T: Scalar,
+    DefaultAllocator: Allocator<T, R1, C1> + Allocator<T, SameShapeR<R1, R2>, SameShapeC<C1, C2>>,
     ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
 {
 }
 
 // XXX: Bad name.
 /// Restricts the given number of rows to be equal.
-pub trait SameShapeVectorAllocator<N, R1, R2>:
-    Allocator<N, R1> + Allocator<N, SameShapeR<R1, R2>> + SameShapeAllocator<N, R1, U1, R2, U1>
+pub trait SameShapeVectorAllocator<T, R1, R2>:
+    Allocator<T, R1> + Allocator<T, SameShapeR<R1, R2>> + SameShapeAllocator<T, R1, U1, R2, U1>
 where
     R1: Dim,
     R2: Dim,
-    N: Scalar,
+    T: Scalar,
     ShapeConstraint: SameNumberOfRows<R1, R2>,
 {
 }
 
-impl<N, R1, R2> SameShapeVectorAllocator<N, R1, R2> for DefaultAllocator
+impl<T, R1, R2> SameShapeVectorAllocator<T, R1, R2> for DefaultAllocator
 where
     R1: Dim,
     R2: Dim,
-    N: Scalar,
-    DefaultAllocator: Allocator<N, R1, U1> + Allocator<N, SameShapeR<R1, R2>>,
+    T: Scalar,
+    DefaultAllocator: Allocator<T, R1, U1> + Allocator<T, SameShapeR<R1, R2>>,
     ShapeConstraint: SameNumberOfRows<R1, R2>,
 {
 }
diff --git a/src/base/array_storage.rs b/src/base/array_storage.rs
index e067cb49..67384a39 100644
--- a/src/base/array_storage.rs
+++ b/src/base/array_storage.rs
@@ -1,8 +1,8 @@
 use std::fmt::{self, Debug, Formatter};
-use std::hash::{Hash, Hasher};
+// use std::hash::{Hash, Hasher};
 #[cfg(feature = "abomonation-serialize")]
 use std::io::{Result as IOResult, Write};
-use std::ops::{Deref, DerefMut, Mul};
+use std::ops::Mul;
 
 #[cfg(feature = "serde-serialize")]
 use serde::de::{Error, SeqAccess, Visitor};
@@ -18,12 +18,9 @@ use std::mem;
 #[cfg(feature = "abomonation-serialize")]
 use abomonation::Abomonation;
 
-use generic_array::{ArrayLength, GenericArray};
-use typenum::Prod;
-
 use crate::base::allocator::Allocator;
 use crate::base::default_allocator::DefaultAllocator;
-use crate::base::dimension::{DimName, U1};
+use crate::base::dimension::{Const, ToTypenum};
 use crate::base::storage::{
     ContiguousStorage, ContiguousStorageMut, Owned, ReshapableStorage, Storage, StorageMut,
 };
@@ -36,166 +33,49 @@ use crate::base::Scalar;
  */
 /// A array-based statically sized matrix data storage.
 #[repr(C)]
-pub struct ArrayStorage<N, R, C>
-where
-    R: DimName,
-    C: DimName,
-    R::Value: Mul<C::Value>,
-    Prod<R::Value, C::Value>: ArrayLength<N>,
-{
-    data: GenericArray<N, Prod<R::Value, C::Value>>,
-}
+#[derive(Copy, Clone, PartialEq, Eq, Hash)]
+pub struct ArrayStorage<T, const R: usize, const C: usize>(pub [[T; R]; C]);
 
-#[deprecated(note = "renamed to `ArrayStorage`")]
-/// Renamed to [ArrayStorage].
-pub type MatrixArray<N, R, C> = ArrayStorage<N, R, C>;
-
-impl<N, R, C> Default for ArrayStorage<N, R, C>
+// TODO: remove this once the stdlib implements Default for arrays.
+impl<T: Default, const R: usize, const C: usize> Default for ArrayStorage<T, R, C>
 where
-    R: DimName,
-    C: DimName,
-    R::Value: Mul<C::Value>,
-    Prod<R::Value, C::Value>: ArrayLength<N>,
-    N: Default,
+    [[T; R]; C]: Default,
 {
+    #[inline]
     fn default() -> Self {
-        ArrayStorage {
-            data: Default::default(),
-        }
+        Self(Default::default())
     }
 }
 
-impl<N, R, C> Hash for ArrayStorage<N, R, C>
-where
-    N: Hash,
-    R: DimName,
-    C: DimName,
-    R::Value: Mul<C::Value>,
-    Prod<R::Value, C::Value>: ArrayLength<N>,
-{
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        self.data[..].hash(state)
-    }
-}
-
-impl<N, R, C> Deref for ArrayStorage<N, R, C>
-where
-    R: DimName,
-    C: DimName,
-    R::Value: Mul<C::Value>,
-    Prod<R::Value, C::Value>: ArrayLength<N>,
-{
-    type Target = GenericArray<N, Prod<R::Value, C::Value>>;
-
-    #[inline]
-    fn deref(&self) -> &Self::Target {
-        &self.data
-    }
-}
-
-impl<N, R, C> DerefMut for ArrayStorage<N, R, C>
-where
-    R: DimName,
-    C: DimName,
-    R::Value: Mul<C::Value>,
-    Prod<R::Value, C::Value>: ArrayLength<N>,
-{
-    #[inline]
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.data
-    }
-}
-
-impl<N, R, C> Debug for ArrayStorage<N, R, C>
-where
-    N: Debug,
-    R: DimName,
-    C: DimName,
-    R::Value: Mul<C::Value>,
-    Prod<R::Value, C::Value>: ArrayLength<N>,
-{
+impl<T: Debug, const R: usize, const C: usize> Debug for ArrayStorage<T, R, C> {
     #[inline]
     fn fmt(&self, fmt: &mut Formatter) -> fmt::Result {
-        self.data.fmt(fmt)
+        self.0.fmt(fmt)
     }
 }
 
-impl<N, R, C> Copy for ArrayStorage<N, R, C>
+unsafe impl<T, const R: usize, const C: usize> Storage<T, Const<R>, Const<C>>
+    for ArrayStorage<T, R, C>
 where
-    N: Copy,
-    R: DimName,
-    C: DimName,
-    R::Value: Mul<C::Value>,
-    Prod<R::Value, C::Value>: ArrayLength<N>,
-    GenericArray<N, Prod<R::Value, C::Value>>: Copy,
+    T: Scalar,
+    DefaultAllocator: Allocator<T, Const<R>, Const<C>, Buffer = Self>,
 {
-}
-
-impl<N, R, C> Clone for ArrayStorage<N, R, C>
-where
-    N: Clone,
-    R: DimName,
-    C: DimName,
-    R::Value: Mul<C::Value>,
-    Prod<R::Value, C::Value>: ArrayLength<N>,
-{
-    #[inline]
-    fn clone(&self) -> Self {
-        ArrayStorage {
-            data: self.data.clone(),
-        }
-    }
-}
-
-impl<N, R, C> Eq for ArrayStorage<N, R, C>
-where
-    N: Eq,
-    R: DimName,
-    C: DimName,
-    R::Value: Mul<C::Value>,
-    Prod<R::Value, C::Value>: ArrayLength<N>,
-{
-}
-
-impl<N, R, C> PartialEq for ArrayStorage<N, R, C>
-where
-    N: PartialEq,
-    R: DimName,
-    C: DimName,
-    R::Value: Mul<C::Value>,
-    Prod<R::Value, C::Value>: ArrayLength<N>,
-{
-    #[inline]
-    fn eq(&self, right: &Self) -> bool {
-        self.data == right.data
-    }
-}
-
-unsafe impl<N, R, C> Storage<N, R, C> for ArrayStorage<N, R, C>
-where
-    N: Scalar,
-    R: DimName,
-    C: DimName,
-    R::Value: Mul<C::Value>,
-    Prod<R::Value, C::Value>: ArrayLength<N>,
-    DefaultAllocator: Allocator<N, R, C, Buffer = Self>,
-{
-    type RStride = U1;
-    type CStride = R;
+    type RStride = Const<1>;
+    type CStride = Const<R>;
 
     #[inline]
-    fn ptr(&self) -> *const N {
-        self[..].as_ptr()
+    fn ptr(&self) -> *const T {
+        self.0.as_ptr() as *const T
     }
 
     #[inline]
-    fn shape(&self) -> (R, C) {
-        (R::name(), C::name())
+    fn shape(&self) -> (Const<R>, Const<C>) {
+        (Const, Const)
     }
 
     #[inline]
     fn strides(&self) -> (Self::RStride, Self::CStride) {
-        (Self::RStride::name(), Self::CStride::name())
+        (Const, Const)
     }
 
     #[inline]
@@ -204,112 +84,107 @@ where
     }
 
     #[inline]
-    fn into_owned(self) -> Owned<N, R, C>
+    fn into_owned(self) -> Owned<T, Const<R>, Const<C>>
     where
-        DefaultAllocator: Allocator<N, R, C>,
+        DefaultAllocator: Allocator<T, Const<R>, Const<C>>,
     {
         self
     }
 
     #[inline]
-    fn clone_owned(&self) -> Owned<N, R, C>
+    fn clone_owned(&self) -> Owned<T, Const<R>, Const<C>>
     where
-        DefaultAllocator: Allocator<N, R, C>,
+        DefaultAllocator: Allocator<T, Const<R>, Const<C>>,
     {
-        let it = self.iter().cloned();
-
+        let it = self.as_slice().iter().cloned();
         DefaultAllocator::allocate_from_iterator(self.shape().0, self.shape().1, it)
     }
 
     #[inline]
-    fn as_slice(&self) -> &[N] {
-        &self[..]
+    fn as_slice(&self) -> &[T] {
+        unsafe { std::slice::from_raw_parts(self.ptr(), R * C) }
     }
 }
 
-unsafe impl<N, R, C> StorageMut<N, R, C> for ArrayStorage<N, R, C>
+unsafe impl<T, const R: usize, const C: usize> StorageMut<T, Const<R>, Const<C>>
+    for ArrayStorage<T, R, C>
 where
-    N: Scalar,
-    R: DimName,
-    C: DimName,
-    R::Value: Mul<C::Value>,
-    Prod<R::Value, C::Value>: ArrayLength<N>,
-    DefaultAllocator: Allocator<N, R, C, Buffer = Self>,
+    T: Scalar,
+    DefaultAllocator: Allocator<T, Const<R>, Const<C>, Buffer = Self>,
 {
     #[inline]
-    fn ptr_mut(&mut self) -> *mut N {
-        self[..].as_mut_ptr()
+    fn ptr_mut(&mut self) -> *mut T {
+        self.0.as_mut_ptr() as *mut T
     }
 
     #[inline]
-    fn as_mut_slice(&mut self) -> &mut [N] {
-        &mut self[..]
+    fn as_mut_slice(&mut self) -> &mut [T] {
+        unsafe { std::slice::from_raw_parts_mut(self.ptr_mut(), R * C) }
     }
 }
 
-unsafe impl<N, R, C> ContiguousStorage<N, R, C> for ArrayStorage<N, R, C>
+unsafe impl<T, const R: usize, const C: usize> ContiguousStorage<T, Const<R>, Const<C>>
+    for ArrayStorage<T, R, C>
 where
-    N: Scalar,
-    R: DimName,
-    C: DimName,
-    R::Value: Mul<C::Value>,
-    Prod<R::Value, C::Value>: ArrayLength<N>,
-    DefaultAllocator: Allocator<N, R, C, Buffer = Self>,
+    T: Scalar,
+    DefaultAllocator: Allocator<T, Const<R>, Const<C>, Buffer = Self>,
 {
 }
 
-unsafe impl<N, R, C> ContiguousStorageMut<N, R, C> for ArrayStorage<N, R, C>
+unsafe impl<T, const R: usize, const C: usize> ContiguousStorageMut<T, Const<R>, Const<C>>
+    for ArrayStorage<T, R, C>
 where
-    N: Scalar,
-    R: DimName,
-    C: DimName,
-    R::Value: Mul<C::Value>,
-    Prod<R::Value, C::Value>: ArrayLength<N>,
-    DefaultAllocator: Allocator<N, R, C, Buffer = Self>,
+    T: Scalar,
+    DefaultAllocator: Allocator<T, Const<R>, Const<C>, Buffer = Self>,
 {
 }
 
-impl<N, R1, C1, R2, C2> ReshapableStorage<N, R1, C1, R2, C2> for ArrayStorage<N, R1, C1>
+impl<T, const R1: usize, const C1: usize, const R2: usize, const C2: usize>
+    ReshapableStorage<T, Const<R1>, Const<C1>, Const<R2>, Const<C2>> for ArrayStorage<T, R1, C1>
 where
-    N: Scalar,
-    R1: DimName,
-    C1: DimName,
-    R1::Value: Mul<C1::Value>,
-    Prod<R1::Value, C1::Value>: ArrayLength<N>,
-    R2: DimName,
-    C2: DimName,
-    R2::Value: Mul<C2::Value, Output = Prod<R1::Value, C1::Value>>,
-    Prod<R2::Value, C2::Value>: ArrayLength<N>,
+    T: Scalar,
+    Const<R1>: ToTypenum,
+    Const<C1>: ToTypenum,
+    Const<R2>: ToTypenum,
+    Const<C2>: ToTypenum,
+    <Const<R1> as ToTypenum>::Typenum: Mul<<Const<C1> as ToTypenum>::Typenum>,
+    <Const<R2> as ToTypenum>::Typenum: Mul<
+        <Const<C2> as ToTypenum>::Typenum,
+        Output = typenum::Prod<
+            <Const<R1> as ToTypenum>::Typenum,
+            <Const<C1> as ToTypenum>::Typenum,
+        >,
+    >,
 {
-    type Output = ArrayStorage<N, R2, C2>;
+    type Output = ArrayStorage<T, R2, C2>;
 
-    fn reshape_generic(self, _: R2, _: C2) -> Self::Output {
-        ArrayStorage { data: self.data }
+    fn reshape_generic(self, _: Const<R2>, _: Const<C2>) -> Self::Output {
+        unsafe {
+            let data: [[T; R2]; C2] = std::mem::transmute_copy(&self.0);
+            std::mem::forget(self.0);
+            ArrayStorage(data)
+        }
     }
 }
 
 /*
  *
- * Allocation-less serde impls.
+ * Serialization.
  *
  */
-// XXX: open an issue for GenericArray so that it implements serde traits?
+// XXX: open an issue for serde so that it allows the serialization/deserialization of all arrays?
 #[cfg(feature = "serde-serialize")]
-impl<N, R, C> Serialize for ArrayStorage<N, R, C>
+impl<T, const R: usize, const C: usize> Serialize for ArrayStorage<T, R, C>
 where
-    N: Scalar + Serialize,
-    R: DimName,
-    C: DimName,
-    R::Value: Mul<C::Value>,
-    Prod<R::Value, C::Value>: ArrayLength<N>,
+    T: Scalar + Serialize,
 {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
     {
-        let mut serializer = serializer.serialize_seq(Some(R::dim() * C::dim()))?;
+        let mut serializer = serializer.serialize_seq(Some(R * C))?;
 
-        for e in self.iter() {
+        for e in self.as_slice().iter() {
             serializer.serialize_element(e)?;
         }
 
@@ -318,13 +193,9 @@ where
 }
 
 #[cfg(feature = "serde-serialize")]
-impl<'a, N, R, C> Deserialize<'a> for ArrayStorage<N, R, C>
+impl<'a, T, const R: usize, const C: usize> Deserialize<'a> for ArrayStorage<T, R, C>
 where
-    N: Scalar + Deserialize<'a>,
-    R: DimName,
-    C: DimName,
-    R::Value: Mul<C::Value>,
-    Prod<R::Value, C::Value>: ArrayLength<N>,
+    T: Scalar + Deserialize<'a>,
 {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
@@ -336,18 +207,14 @@ where
 
 #[cfg(feature = "serde-serialize")]
 /// A visitor that produces a matrix array.
-struct ArrayStorageVisitor<N, R, C> {
-    marker: PhantomData<(N, R, C)>,
+struct ArrayStorageVisitor<T, const R: usize, const C: usize> {
+    marker: PhantomData<T>,
 }
 
 #[cfg(feature = "serde-serialize")]
-impl<N, R, C> ArrayStorageVisitor<N, R, C>
+impl<T, const R: usize, const C: usize> ArrayStorageVisitor<T, R, C>
 where
-    N: Scalar,
-    R: DimName,
-    C: DimName,
-    R::Value: Mul<C::Value>,
-    Prod<R::Value, C::Value>: ArrayLength<N>,
+    T: Scalar,
 {
     /// Construct a new sequence visitor.
     pub fn new() -> Self {
@@ -358,22 +225,18 @@ where
 }
 
 #[cfg(feature = "serde-serialize")]
-impl<'a, N, R, C> Visitor<'a> for ArrayStorageVisitor<N, R, C>
+impl<'a, T, const R: usize, const C: usize> Visitor<'a> for ArrayStorageVisitor<T, R, C>
 where
-    N: Scalar + Deserialize<'a>,
-    R: DimName,
-    C: DimName,
-    R::Value: Mul<C::Value>,
-    Prod<R::Value, C::Value>: ArrayLength<N>,
+    T: Scalar + Deserialize<'a>,
 {
-    type Value = ArrayStorage<N, R, C>;
+    type Value = ArrayStorage<T, R, C>;
 
     fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
         formatter.write_str("a matrix array")
     }
 
     #[inline]
-    fn visit_seq<V>(self, mut visitor: V) -> Result<ArrayStorage<N, R, C>, V::Error>
+    fn visit_seq<V>(self, mut visitor: V) -> Result<ArrayStorage<T, R, C>, V::Error>
     where
         V: SeqAccess<'a>,
     {
@@ -381,12 +244,13 @@ where
         let mut curr = 0;
 
         while let Some(value) = visitor.next_element()? {
-            *out.get_mut(curr)
+            *out.as_mut_slice()
+                .get_mut(curr)
                 .ok_or_else(|| V::Error::invalid_length(curr, &self))? = value;
             curr += 1;
         }
 
-        if curr == R::dim() * C::dim() {
+        if curr == R * C {
             Ok(out)
         } else {
             Err(V::Error::invalid_length(curr, &self))
@@ -395,36 +259,24 @@ where
 }
 
 #[cfg(feature = "bytemuck")]
-unsafe impl<N: Scalar + bytemuck::Zeroable, R: DimName, C: DimName> bytemuck::Zeroable
-    for ArrayStorage<N, R, C>
-where
-    R::Value: Mul<C::Value>,
-    Prod<R::Value, C::Value>: ArrayLength<N>,
-    Self: Copy,
+unsafe impl<T: Scalar + Copy + bytemuck::Zeroable, const R: usize, const C: usize>
+    bytemuck::Zeroable for ArrayStorage<T, R, C>
 {
 }
 
 #[cfg(feature = "bytemuck")]
-unsafe impl<N: Scalar + bytemuck::Pod, R: DimName, C: DimName> bytemuck::Pod
-    for ArrayStorage<N, R, C>
-where
-    R::Value: Mul<C::Value>,
-    Prod<R::Value, C::Value>: ArrayLength<N>,
-    Self: Copy,
+unsafe impl<T: Scalar + Copy + bytemuck::Pod, const R: usize, const C: usize> bytemuck::Pod
+    for ArrayStorage<T, R, C>
 {
 }
 
 #[cfg(feature = "abomonation-serialize")]
-impl<N, R, C> Abomonation for ArrayStorage<N, R, C>
+impl<T, const R: usize, const C: usize> Abomonation for ArrayStorage<T, R, C>
 where
-    R: DimName,
-    C: DimName,
-    R::Value: Mul<C::Value>,
-    Prod<R::Value, C::Value>: ArrayLength<N>,
-    N: Abomonation,
+    T: Scalar + Abomonation,
 {
     unsafe fn entomb<W: Write>(&self, writer: &mut W) -> IOResult<()> {
-        for element in self.data.as_slice() {
+        for element in self.as_slice() {
             element.entomb(writer)?;
         }
 
@@ -432,7 +284,7 @@ where
     }
 
     unsafe fn exhume<'a, 'b>(&'a mut self, mut bytes: &'b mut [u8]) -> Option<&'b mut [u8]> {
-        for element in self.data.as_mut_slice() {
+        for element in self.as_mut_slice() {
             let temp = bytes;
             bytes = if let Some(remainder) = element.exhume(temp) {
                 remainder
@@ -444,9 +296,6 @@ where
     }
 
     fn extent(&self) -> usize {
-        self.data
-            .as_slice()
-            .iter()
-            .fold(0, |acc, e| acc + e.extent())
+        self.as_slice().iter().fold(0, |acc, e| acc + e.extent())
     }
 }
diff --git a/src/base/blas.rs b/src/base/blas.rs
index 92a43a38..05705f17 100644
--- a/src/base/blas.rs
+++ b/src/base/blas.rs
@@ -10,25 +10,25 @@ use crate::base::allocator::Allocator;
 use crate::base::constraint::{
     AreMultipliable, DimEq, SameNumberOfColumns, SameNumberOfRows, ShapeConstraint,
 };
-use crate::base::dimension::{Dim, Dynamic, U1, U2, U3, U4};
+use crate::base::dimension::{Const, Dim, Dynamic, U1, U2, U3, U4};
 use crate::base::storage::{Storage, StorageMut};
 use crate::base::{
-    DVectorSlice, DefaultAllocator, Matrix, Scalar, SquareMatrix, Vector, VectorSliceN,
+    DVectorSlice, DefaultAllocator, Matrix, Scalar, SquareMatrix, Vector, VectorSlice,
 };
 
 /// # Dot/scalar product
-impl<N, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S>
+impl<T, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S>
 where
-    N: Scalar + Zero + ClosedAdd + ClosedMul,
+    T: Scalar + Zero + ClosedAdd + ClosedMul,
 {
     #[inline(always)]
     fn dotx<R2: Dim, C2: Dim, SB>(
         &self,
-        rhs: &Matrix<N, R2, C2, SB>,
-        conjugate: impl Fn(N) -> N,
-    ) -> N
+        rhs: &Matrix<T, R2, C2, SB>,
+        conjugate: impl Fn(T) -> T,
+    ) -> T
     where
-        SB: Storage<N, R2, C2>,
+        SB: Storage<T, R2, C2>,
         ShapeConstraint: DimEq<R, R2> + DimEq<C, C2>,
     {
         assert!(
@@ -92,7 +92,7 @@ where
         //
         // And this comment from bluss:
         // https://users.rust-lang.org/t/how-to-zip-two-slices-efficiently/2048/12
-        let mut res = N::zero();
+        let mut res = T::zero();
 
         // We have to define them outside of the loop (and not inside at first assignment)
         // otherwise vectorization won't kick in for some reason.
@@ -108,14 +108,14 @@ where
         for j in 0..self.ncols() {
             let mut i = 0;
 
-            acc0 = N::zero();
-            acc1 = N::zero();
-            acc2 = N::zero();
-            acc3 = N::zero();
-            acc4 = N::zero();
-            acc5 = N::zero();
-            acc6 = N::zero();
-            acc7 = N::zero();
+            acc0 = T::zero();
+            acc1 = T::zero();
+            acc2 = T::zero();
+            acc3 = T::zero();
+            acc4 = T::zero();
+            acc5 = T::zero();
+            acc6 = T::zero();
+            acc7 = T::zero();
 
             while self.nrows() - i >= 8 {
                 acc0 += unsafe {
@@ -193,9 +193,9 @@ where
     /// ```
     ///
     #[inline]
-    pub fn dot<R2: Dim, C2: Dim, SB>(&self, rhs: &Matrix<N, R2, C2, SB>) -> N
+    pub fn dot<R2: Dim, C2: Dim, SB>(&self, rhs: &Matrix<T, R2, C2, SB>) -> T
     where
-        SB: Storage<N, R2, C2>,
+        SB: Storage<T, R2, C2>,
         ShapeConstraint: DimEq<R, R2> + DimEq<C, C2>,
     {
         self.dotx(rhs, |e| e)
@@ -221,13 +221,13 @@ where
     /// assert_ne!(vec1.dotc(&vec2), vec1.dot(&vec2));
     /// ```
     #[inline]
-    pub fn dotc<R2: Dim, C2: Dim, SB>(&self, rhs: &Matrix<N, R2, C2, SB>) -> N
+    pub fn dotc<R2: Dim, C2: Dim, SB>(&self, rhs: &Matrix<T, R2, C2, SB>) -> T
     where
-        N: SimdComplexField,
-        SB: Storage<N, R2, C2>,
+        T: SimdComplexField,
+        SB: Storage<T, R2, C2>,
         ShapeConstraint: DimEq<R, R2> + DimEq<C, C2>,
     {
-        self.dotx(rhs, N::simd_conjugate)
+        self.dotx(rhs, T::simd_conjugate)
     }
 
     /// The dot product between the transpose of `self` and `rhs`.
@@ -248,9 +248,9 @@ where
     /// assert_eq!(mat1.tr_dot(&mat2), 9.1);
     /// ```
     #[inline]
-    pub fn tr_dot<R2: Dim, C2: Dim, SB>(&self, rhs: &Matrix<N, R2, C2, SB>) -> N
+    pub fn tr_dot<R2: Dim, C2: Dim, SB>(&self, rhs: &Matrix<T, R2, C2, SB>) -> T
     where
-        SB: Storage<N, R2, C2>,
+        SB: Storage<T, R2, C2>,
         ShapeConstraint: DimEq<C, R2> + DimEq<R, C2>,
     {
         let (nrows, ncols) = self.shape();
@@ -260,7 +260,7 @@ where
             "Transposed dot product dimension mismatch."
         );
 
-        let mut res = N::zero();
+        let mut res = T::zero();
 
         for j in 0..self.nrows() {
             for i in 0..self.ncols() {
@@ -275,17 +275,17 @@ where
     }
 }
 
-fn array_axcpy<N>(
-    y: &mut [N],
-    a: N,
-    x: &[N],
-    c: N,
-    beta: N,
+fn array_axcpy<T>(
+    y: &mut [T],
+    a: T,
+    x: &[T],
+    c: T,
+    beta: T,
     stride1: usize,
     stride2: usize,
     len: usize,
 ) where
-    N: Scalar + Zero + ClosedAdd + ClosedMul,
+    T: Scalar + Zero + ClosedAdd + ClosedMul,
 {
     for i in 0..len {
         unsafe {
@@ -298,9 +298,9 @@ fn array_axcpy<N>(
     }
 }
 
-fn array_axc<N>(y: &mut [N], a: N, x: &[N], c: N, stride1: usize, stride2: usize, len: usize)
+fn array_axc<T>(y: &mut [T], a: T, x: &[T], c: T, stride1: usize, stride2: usize, len: usize)
 where
-    N: Scalar + Zero + ClosedAdd + ClosedMul,
+    T: Scalar + Zero + ClosedAdd + ClosedMul,
 {
     for i in 0..len {
         unsafe {
@@ -312,10 +312,10 @@ where
 }
 
 /// # BLAS functions
-impl<N, D: Dim, S> Vector<N, D, S>
+impl<T, D: Dim, S> Vector<T, D, S>
 where
-    N: Scalar + Zero + ClosedAdd + ClosedMul,
-    S: StorageMut<N, D>,
+    T: Scalar + Zero + ClosedAdd + ClosedMul,
+    S: StorageMut<T, D>,
 {
     /// Computes `self = a * x * c + b * self`.
     ///
@@ -331,9 +331,9 @@ where
     /// assert_eq!(vec1, Vector3::new(6.0, 12.0, 18.0));
     /// ```
     #[inline]
-    pub fn axcpy<D2: Dim, SB>(&mut self, a: N, x: &Vector<N, D2, SB>, c: N, b: N)
+    pub fn axcpy<D2: Dim, SB>(&mut self, a: T, x: &Vector<T, D2, SB>, c: T, b: T)
     where
-        SB: Storage<N, D2>,
+        SB: Storage<T, D2>,
         ShapeConstraint: DimEq<D, D2>,
     {
         assert_eq!(self.nrows(), x.nrows(), "Axcpy: mismatched vector shapes.");
@@ -365,14 +365,14 @@ where
     /// assert_eq!(vec1, Vector3::new(6.0, 12.0, 18.0));
     /// ```
     #[inline]
-    pub fn axpy<D2: Dim, SB>(&mut self, a: N, x: &Vector<N, D2, SB>, b: N)
+    pub fn axpy<D2: Dim, SB>(&mut self, a: T, x: &Vector<T, D2, SB>, b: T)
     where
-        N: One,
-        SB: Storage<N, D2>,
+        T: One,
+        SB: Storage<T, D2>,
         ShapeConstraint: DimEq<D, D2>,
     {
         assert_eq!(self.nrows(), x.nrows(), "Axpy: mismatched vector shapes.");
-        self.axcpy(a, x, N::one(), b)
+        self.axcpy(a, x, T::one(), b)
     }
 
     /// Computes `self = alpha * a * x + beta * self`, where `a` is a matrix, `x` a vector, and
@@ -394,14 +394,14 @@ where
     #[inline]
     pub fn gemv<R2: Dim, C2: Dim, D3: Dim, SB, SC>(
         &mut self,
-        alpha: N,
-        a: &Matrix<N, R2, C2, SB>,
-        x: &Vector<N, D3, SC>,
-        beta: N,
+        alpha: T,
+        a: &Matrix<T, R2, C2, SB>,
+        x: &Vector<T, D3, SC>,
+        beta: T,
     ) where
-        N: One,
-        SB: Storage<N, R2, C2>,
-        SC: Storage<N, D3>,
+        T: One,
+        SB: Storage<T, R2, C2>,
+        SC: Storage<T, D3>,
         ShapeConstraint: DimEq<D, R2> + AreMultipliable<R2, C2, D3, U1>,
     {
         let dim1 = self.nrows();
@@ -418,7 +418,7 @@ where
             // because we documented the guaranty that `self` is
             // never read if `beta` is zero.
             if beta.is_zero() {
-                self.fill(N::zero());
+                self.fill(T::zero());
             } else {
                 *self *= beta;
             }
@@ -434,25 +434,25 @@ where
             let col2 = a.column(j);
             let val = unsafe { x.vget_unchecked(j).inlined_clone() };
 
-            self.axcpy(alpha.inlined_clone(), &col2, val, N::one());
+            self.axcpy(alpha.inlined_clone(), &col2, val, T::one());
         }
     }
 
     #[inline(always)]
     fn xxgemv<D2: Dim, D3: Dim, SB, SC>(
         &mut self,
-        alpha: N,
-        a: &SquareMatrix<N, D2, SB>,
-        x: &Vector<N, D3, SC>,
-        beta: N,
+        alpha: T,
+        a: &SquareMatrix<T, D2, SB>,
+        x: &Vector<T, D3, SC>,
+        beta: T,
         dot: impl Fn(
-            &DVectorSlice<N, SB::RStride, SB::CStride>,
-            &DVectorSlice<N, SC::RStride, SC::CStride>,
-        ) -> N,
+            &DVectorSlice<T, SB::RStride, SB::CStride>,
+            &DVectorSlice<T, SC::RStride, SC::CStride>,
+        ) -> T,
     ) where
-        N: One,
-        SB: Storage<N, D2, D2>,
-        SC: Storage<N, D3>,
+        T: One,
+        SB: Storage<T, D2, D2>,
+        SC: Storage<T, D3>,
         ShapeConstraint: DimEq<D, D2> + AreMultipliable<D2, D2, D3, U1>,
     {
         let dim1 = self.nrows();
@@ -490,7 +490,7 @@ where
             self.rows_range_mut(j + 1..).axpy(
                 alpha.inlined_clone() * val,
                 &col2.rows_range(j + 1..),
-                N::one(),
+                T::one(),
             );
         }
     }
@@ -501,14 +501,14 @@ where
     #[deprecated(note = "This is renamed `sygemv` to match the original BLAS terminology.")]
     pub fn gemv_symm<D2: Dim, D3: Dim, SB, SC>(
         &mut self,
-        alpha: N,
-        a: &SquareMatrix<N, D2, SB>,
-        x: &Vector<N, D3, SC>,
-        beta: N,
+        alpha: T,
+        a: &SquareMatrix<T, D2, SB>,
+        x: &Vector<T, D3, SC>,
+        beta: T,
     ) where
-        N: One,
-        SB: Storage<N, D2, D2>,
-        SC: Storage<N, D3>,
+        T: One,
+        SB: Storage<T, D2, D2>,
+        SC: Storage<T, D3>,
         ShapeConstraint: DimEq<D, D2> + AreMultipliable<D2, D2, D3, U1>,
     {
         self.sygemv(alpha, a, x, beta)
@@ -545,14 +545,14 @@ where
     #[inline]
     pub fn sygemv<D2: Dim, D3: Dim, SB, SC>(
         &mut self,
-        alpha: N,
-        a: &SquareMatrix<N, D2, SB>,
-        x: &Vector<N, D3, SC>,
-        beta: N,
+        alpha: T,
+        a: &SquareMatrix<T, D2, SB>,
+        x: &Vector<T, D3, SC>,
+        beta: T,
     ) where
-        N: One,
-        SB: Storage<N, D2, D2>,
-        SC: Storage<N, D3>,
+        T: One,
+        SB: Storage<T, D2, D2>,
+        SC: Storage<T, D3>,
         ShapeConstraint: DimEq<D, D2> + AreMultipliable<D2, D2, D3, U1>,
     {
         self.xxgemv(alpha, a, x, beta, |a, b| a.dot(b))
@@ -590,14 +590,14 @@ where
     #[inline]
     pub fn hegemv<D2: Dim, D3: Dim, SB, SC>(
         &mut self,
-        alpha: N,
-        a: &SquareMatrix<N, D2, SB>,
-        x: &Vector<N, D3, SC>,
-        beta: N,
+        alpha: T,
+        a: &SquareMatrix<T, D2, SB>,
+        x: &Vector<T, D3, SC>,
+        beta: T,
     ) where
-        N: SimdComplexField,
-        SB: Storage<N, D2, D2>,
-        SC: Storage<N, D3>,
+        T: SimdComplexField,
+        SB: Storage<T, D2, D2>,
+        SC: Storage<T, D3>,
         ShapeConstraint: DimEq<D, D2> + AreMultipliable<D2, D2, D3, U1>,
     {
         self.xxgemv(alpha, a, x, beta, |a, b| a.dotc(b))
@@ -606,15 +606,15 @@ where
     #[inline(always)]
     fn gemv_xx<R2: Dim, C2: Dim, D3: Dim, SB, SC>(
         &mut self,
-        alpha: N,
-        a: &Matrix<N, R2, C2, SB>,
-        x: &Vector<N, D3, SC>,
-        beta: N,
-        dot: impl Fn(&VectorSliceN<N, R2, SB::RStride, SB::CStride>, &Vector<N, D3, SC>) -> N,
+        alpha: T,
+        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,
     ) where
-        N: One,
-        SB: Storage<N, R2, C2>,
-        SC: Storage<N, D3>,
+        T: One,
+        SB: Storage<T, R2, C2>,
+        SC: Storage<T, D3>,
         ShapeConstraint: DimEq<D, C2> + AreMultipliable<C2, R2, D3, U1>,
     {
         let dim1 = self.nrows();
@@ -665,14 +665,14 @@ where
     #[inline]
     pub fn gemv_tr<R2: Dim, C2: Dim, D3: Dim, SB, SC>(
         &mut self,
-        alpha: N,
-        a: &Matrix<N, R2, C2, SB>,
-        x: &Vector<N, D3, SC>,
-        beta: N,
+        alpha: T,
+        a: &Matrix<T, R2, C2, SB>,
+        x: &Vector<T, D3, SC>,
+        beta: T,
     ) where
-        N: One,
-        SB: Storage<N, R2, C2>,
-        SC: Storage<N, D3>,
+        T: One,
+        SB: Storage<T, R2, C2>,
+        SC: Storage<T, D3>,
         ShapeConstraint: DimEq<D, C2> + AreMultipliable<C2, R2, D3, U1>,
     {
         self.gemv_xx(alpha, a, x, beta, |a, b| a.dot(b))
@@ -700,36 +700,36 @@ where
     #[inline]
     pub fn gemv_ad<R2: Dim, C2: Dim, D3: Dim, SB, SC>(
         &mut self,
-        alpha: N,
-        a: &Matrix<N, R2, C2, SB>,
-        x: &Vector<N, D3, SC>,
-        beta: N,
+        alpha: T,
+        a: &Matrix<T, R2, C2, SB>,
+        x: &Vector<T, D3, SC>,
+        beta: T,
     ) where
-        N: SimdComplexField,
-        SB: Storage<N, R2, C2>,
-        SC: Storage<N, D3>,
+        T: SimdComplexField,
+        SB: Storage<T, R2, C2>,
+        SC: Storage<T, D3>,
         ShapeConstraint: DimEq<D, C2> + AreMultipliable<C2, R2, D3, U1>,
     {
         self.gemv_xx(alpha, a, x, beta, |a, b| a.dotc(b))
     }
 }
 
-impl<N, R1: Dim, C1: Dim, S: StorageMut<N, R1, C1>> Matrix<N, R1, C1, S>
+impl<T, R1: Dim, C1: Dim, S: StorageMut<T, R1, C1>> Matrix<T, R1, C1, S>
 where
-    N: Scalar + Zero + ClosedAdd + ClosedMul,
+    T: Scalar + Zero + ClosedAdd + ClosedMul,
 {
     #[inline(always)]
     fn gerx<D2: Dim, D3: Dim, SB, SC>(
         &mut self,
-        alpha: N,
-        x: &Vector<N, D2, SB>,
-        y: &Vector<N, D3, SC>,
-        beta: N,
-        conjugate: impl Fn(N) -> N,
+        alpha: T,
+        x: &Vector<T, D2, SB>,
+        y: &Vector<T, D3, SC>,
+        beta: T,
+        conjugate: impl Fn(T) -> T,
     ) where
-        N: One,
-        SB: Storage<N, D2>,
-        SC: Storage<N, D3>,
+        T: One,
+        SB: Storage<T, D2>,
+        SC: Storage<T, D3>,
         ShapeConstraint: DimEq<R1, D2> + DimEq<C1, D3>,
     {
         let (nrows1, ncols1) = self.shape();
@@ -768,14 +768,14 @@ where
     #[inline]
     pub fn ger<D2: Dim, D3: Dim, SB, SC>(
         &mut self,
-        alpha: N,
-        x: &Vector<N, D2, SB>,
-        y: &Vector<N, D3, SC>,
-        beta: N,
+        alpha: T,
+        x: &Vector<T, D2, SB>,
+        y: &Vector<T, D3, SC>,
+        beta: T,
     ) where
-        N: One,
-        SB: Storage<N, D2>,
-        SC: Storage<N, D3>,
+        T: One,
+        SB: Storage<T, D2>,
+        SC: Storage<T, D3>,
         ShapeConstraint: DimEq<R1, D2> + DimEq<C1, D3>,
     {
         self.gerx(alpha, x, y, beta, |e| e)
@@ -801,14 +801,14 @@ where
     #[inline]
     pub fn gerc<D2: Dim, D3: Dim, SB, SC>(
         &mut self,
-        alpha: N,
-        x: &Vector<N, D2, SB>,
-        y: &Vector<N, D3, SC>,
-        beta: N,
+        alpha: T,
+        x: &Vector<T, D2, SB>,
+        y: &Vector<T, D3, SC>,
+        beta: T,
     ) where
-        N: SimdComplexField,
-        SB: Storage<N, D2>,
-        SC: Storage<N, D3>,
+        T: SimdComplexField,
+        SB: Storage<T, D2>,
+        SC: Storage<T, D3>,
         ShapeConstraint: DimEq<R1, D2> + DimEq<C1, D3>,
     {
         self.gerx(alpha, x, y, beta, SimdComplexField::simd_conjugate)
@@ -838,14 +838,14 @@ where
     #[inline]
     pub fn gemm<R2: Dim, C2: Dim, R3: Dim, C3: Dim, SB, SC>(
         &mut self,
-        alpha: N,
-        a: &Matrix<N, R2, C2, SB>,
-        b: &Matrix<N, R3, C3, SC>,
-        beta: N,
+        alpha: T,
+        a: &Matrix<T, R2, C2, SB>,
+        b: &Matrix<T, R3, C3, SC>,
+        beta: T,
     ) where
-        N: One,
-        SB: Storage<N, R2, C2>,
-        SC: Storage<N, R3, C3>,
+        T: One,
+        SB: Storage<T, R2, C2>,
+        SC: Storage<T, R3, C3>,
         ShapeConstraint: SameNumberOfRows<R1, R2>
             + SameNumberOfColumns<C1, C3>
             + AreMultipliable<R2, C2, R3, C3>,
@@ -897,14 +897,14 @@ where
                         // because we documented the guaranty that `self` is
                         // never read if `beta` is zero.
                         if beta.is_zero() {
-                            self.fill(N::zero());
+                            self.fill(T::zero());
                         } else {
                             *self *= beta;
                         }
                         return;
                     }
 
-                    if N::is::<f32>() {
+                    if T::is::<f32>() {
                         let (rsa, csa) = a.strides();
                         let (rsb, csb) = b.strides();
                         let (rsc, csc) = self.strides();
@@ -928,7 +928,7 @@ where
                             );
                         }
                         return;
-                    } else if N::is::<f64>() {
+                    } else if T::is::<f64>() {
                         let (rsa, csa) = a.strides();
                         let (rsb, csb) = b.strides();
                         let (rsc, csc) = self.strides();
@@ -993,14 +993,14 @@ where
     #[inline]
     pub fn gemm_tr<R2: Dim, C2: Dim, R3: Dim, C3: Dim, SB, SC>(
         &mut self,
-        alpha: N,
-        a: &Matrix<N, R2, C2, SB>,
-        b: &Matrix<N, R3, C3, SC>,
-        beta: N,
+        alpha: T,
+        a: &Matrix<T, R2, C2, SB>,
+        b: &Matrix<T, R3, C3, SC>,
+        beta: T,
     ) where
-        N: One,
-        SB: Storage<N, R2, C2>,
-        SC: Storage<N, R3, C3>,
+        T: One,
+        SB: Storage<T, R2, C2>,
+        SC: Storage<T, R3, C3>,
         ShapeConstraint: SameNumberOfRows<R1, C2>
             + SameNumberOfColumns<C1, C3>
             + AreMultipliable<C2, R2, R3, C3>,
@@ -1055,14 +1055,14 @@ where
     #[inline]
     pub fn gemm_ad<R2: Dim, C2: Dim, R3: Dim, C3: Dim, SB, SC>(
         &mut self,
-        alpha: N,
-        a: &Matrix<N, R2, C2, SB>,
-        b: &Matrix<N, R3, C3, SC>,
-        beta: N,
+        alpha: T,
+        a: &Matrix<T, R2, C2, SB>,
+        b: &Matrix<T, R3, C3, SC>,
+        beta: T,
     ) where
-        N: SimdComplexField,
-        SB: Storage<N, R2, C2>,
-        SC: Storage<N, R3, C3>,
+        T: SimdComplexField,
+        SB: Storage<T, R2, C2>,
+        SC: Storage<T, R3, C3>,
         ShapeConstraint: SameNumberOfRows<R1, C2>
             + SameNumberOfColumns<C1, C3>
             + AreMultipliable<C2, R2, R3, C3>,
@@ -1088,22 +1088,22 @@ where
     }
 }
 
-impl<N, R1: Dim, C1: Dim, S: StorageMut<N, R1, C1>> Matrix<N, R1, C1, S>
+impl<T, R1: Dim, C1: Dim, S: StorageMut<T, R1, C1>> Matrix<T, R1, C1, S>
 where
-    N: Scalar + Zero + ClosedAdd + ClosedMul,
+    T: Scalar + Zero + ClosedAdd + ClosedMul,
 {
     #[inline(always)]
     fn xxgerx<D2: Dim, D3: Dim, SB, SC>(
         &mut self,
-        alpha: N,
-        x: &Vector<N, D2, SB>,
-        y: &Vector<N, D3, SC>,
-        beta: N,
-        conjugate: impl Fn(N) -> N,
+        alpha: T,
+        x: &Vector<T, D2, SB>,
+        y: &Vector<T, D3, SC>,
+        beta: T,
+        conjugate: impl Fn(T) -> T,
     ) where
-        N: One,
-        SB: Storage<N, D2>,
-        SC: Storage<N, D3>,
+        T: One,
+        SB: Storage<T, D2>,
+        SC: Storage<T, D3>,
         ShapeConstraint: DimEq<R1, D2> + DimEq<C1, D3>,
     {
         let dim1 = self.nrows();
@@ -1120,7 +1120,7 @@ where
             let val = unsafe { conjugate(y.vget_unchecked(j).inlined_clone()) };
             let subdim = Dynamic::new(dim1 - j);
             // TODO: avoid bound checks.
-            self.generic_slice_mut((j, j), (subdim, U1)).axpy(
+            self.generic_slice_mut((j, j), (subdim, Const::<1>)).axpy(
                 alpha.inlined_clone() * val,
                 &x.rows_range(j..),
                 beta.inlined_clone(),
@@ -1151,14 +1151,14 @@ where
     #[deprecated(note = "This is renamed `syger` to match the original BLAS terminology.")]
     pub fn ger_symm<D2: Dim, D3: Dim, SB, SC>(
         &mut self,
-        alpha: N,
-        x: &Vector<N, D2, SB>,
-        y: &Vector<N, D3, SC>,
-        beta: N,
+        alpha: T,
+        x: &Vector<T, D2, SB>,
+        y: &Vector<T, D3, SC>,
+        beta: T,
     ) where
-        N: One,
-        SB: Storage<N, D2>,
-        SC: Storage<N, D3>,
+        T: One,
+        SB: Storage<T, D2>,
+        SC: Storage<T, D3>,
         ShapeConstraint: DimEq<R1, D2> + DimEq<C1, D3>,
     {
         self.syger(alpha, x, y, beta)
@@ -1187,14 +1187,14 @@ where
     #[inline]
     pub fn syger<D2: Dim, D3: Dim, SB, SC>(
         &mut self,
-        alpha: N,
-        x: &Vector<N, D2, SB>,
-        y: &Vector<N, D3, SC>,
-        beta: N,
+        alpha: T,
+        x: &Vector<T, D2, SB>,
+        y: &Vector<T, D3, SC>,
+        beta: T,
     ) where
-        N: One,
-        SB: Storage<N, D2>,
-        SC: Storage<N, D3>,
+        T: One,
+        SB: Storage<T, D2>,
+        SC: Storage<T, D3>,
         ShapeConstraint: DimEq<R1, D2> + DimEq<C1, D3>,
     {
         self.xxgerx(alpha, x, y, beta, |e| e)
@@ -1222,23 +1222,23 @@ where
     #[inline]
     pub fn hegerc<D2: Dim, D3: Dim, SB, SC>(
         &mut self,
-        alpha: N,
-        x: &Vector<N, D2, SB>,
-        y: &Vector<N, D3, SC>,
-        beta: N,
+        alpha: T,
+        x: &Vector<T, D2, SB>,
+        y: &Vector<T, D3, SC>,
+        beta: T,
     ) where
-        N: SimdComplexField,
-        SB: Storage<N, D2>,
-        SC: Storage<N, D3>,
+        T: SimdComplexField,
+        SB: Storage<T, D2>,
+        SC: Storage<T, D3>,
         ShapeConstraint: DimEq<R1, D2> + DimEq<C1, D3>,
     {
         self.xxgerx(alpha, x, y, beta, SimdComplexField::simd_conjugate)
     }
 }
 
-impl<N, D1: Dim, S: StorageMut<N, D1, D1>> SquareMatrix<N, D1, S>
+impl<T, D1: Dim, S: StorageMut<T, D1, D1>> SquareMatrix<T, D1, S>
 where
-    N: Scalar + Zero + One + ClosedAdd + ClosedMul,
+    T: Scalar + Zero + One + ClosedAdd + ClosedMul,
 {
     /// Computes the quadratic form `self = alpha * lhs * mid * lhs.transpose() + beta * self`.
     ///
@@ -1268,27 +1268,27 @@ where
     /// assert_relative_eq!(mat, expected);
     pub fn quadform_tr_with_workspace<D2, S2, R3, C3, S3, D4, S4>(
         &mut self,
-        work: &mut Vector<N, D2, S2>,
-        alpha: N,
-        lhs: &Matrix<N, R3, C3, S3>,
-        mid: &SquareMatrix<N, D4, S4>,
-        beta: N,
+        work: &mut Vector<T, D2, S2>,
+        alpha: T,
+        lhs: &Matrix<T, R3, C3, S3>,
+        mid: &SquareMatrix<T, D4, S4>,
+        beta: T,
     ) where
         D2: Dim,
         R3: Dim,
         C3: Dim,
         D4: Dim,
-        S2: StorageMut<N, D2>,
-        S3: Storage<N, R3, C3>,
-        S4: Storage<N, D4, D4>,
+        S2: StorageMut<T, D2>,
+        S3: Storage<T, R3, C3>,
+        S4: Storage<T, D4, D4>,
         ShapeConstraint: DimEq<D1, D2> + DimEq<D1, R3> + DimEq<D2, R3> + DimEq<C3, D4>,
     {
-        work.gemv(N::one(), lhs, &mid.column(0), N::zero());
+        work.gemv(T::one(), lhs, &mid.column(0), T::zero());
         self.ger(alpha.inlined_clone(), work, &lhs.column(0), beta);
 
         for j in 1..mid.ncols() {
-            work.gemv(N::one(), lhs, &mid.column(j), N::zero());
-            self.ger(alpha.inlined_clone(), work, &lhs.column(j), N::one());
+            work.gemv(T::one(), lhs, &mid.column(j), T::zero());
+            self.ger(alpha.inlined_clone(), work, &lhs.column(j), T::one());
         }
     }
 
@@ -1315,21 +1315,22 @@ where
     /// assert_relative_eq!(mat, expected);
     pub fn quadform_tr<R3, C3, S3, D4, S4>(
         &mut self,
-        alpha: N,
-        lhs: &Matrix<N, R3, C3, S3>,
-        mid: &SquareMatrix<N, D4, S4>,
-        beta: N,
+        alpha: T,
+        lhs: &Matrix<T, R3, C3, S3>,
+        mid: &SquareMatrix<T, D4, S4>,
+        beta: T,
     ) where
         R3: Dim,
         C3: Dim,
         D4: Dim,
-        S3: Storage<N, R3, C3>,
-        S4: Storage<N, D4, D4>,
+        S3: Storage<T, R3, C3>,
+        S4: Storage<T, D4, D4>,
         ShapeConstraint: DimEq<D1, D1> + DimEq<D1, R3> + DimEq<C3, D4>,
-        DefaultAllocator: Allocator<N, D1>,
+        DefaultAllocator: Allocator<T, D1>,
     {
-        let mut work =
-            unsafe { crate::unimplemented_or_uninitialized_generic!(self.data.shape().0, U1) };
+        let mut work = unsafe {
+            crate::unimplemented_or_uninitialized_generic!(self.data.shape().0, Const::<1>)
+        };
         self.quadform_tr_with_workspace(&mut work, alpha, lhs, mid, beta)
     }
 
@@ -1360,28 +1361,28 @@ where
     /// assert_relative_eq!(mat, expected);
     pub fn quadform_with_workspace<D2, S2, D3, S3, R4, C4, S4>(
         &mut self,
-        work: &mut Vector<N, D2, S2>,
-        alpha: N,
-        mid: &SquareMatrix<N, D3, S3>,
-        rhs: &Matrix<N, R4, C4, S4>,
-        beta: N,
+        work: &mut Vector<T, D2, S2>,
+        alpha: T,
+        mid: &SquareMatrix<T, D3, S3>,
+        rhs: &Matrix<T, R4, C4, S4>,
+        beta: T,
     ) where
         D2: Dim,
         D3: Dim,
         R4: Dim,
         C4: Dim,
-        S2: StorageMut<N, D2>,
-        S3: Storage<N, D3, D3>,
-        S4: Storage<N, R4, C4>,
+        S2: StorageMut<T, D2>,
+        S3: Storage<T, D3, D3>,
+        S4: Storage<T, R4, C4>,
         ShapeConstraint:
             DimEq<D3, R4> + DimEq<D1, C4> + DimEq<D2, D3> + AreMultipliable<C4, R4, D2, U1>,
     {
-        work.gemv(N::one(), mid, &rhs.column(0), N::zero());
+        work.gemv(T::one(), mid, &rhs.column(0), T::zero());
         self.column_mut(0)
             .gemv_tr(alpha.inlined_clone(), &rhs, work, beta.inlined_clone());
 
         for j in 1..rhs.ncols() {
-            work.gemv(N::one(), mid, &rhs.column(j), N::zero());
+            work.gemv(T::one(), mid, &rhs.column(j), T::zero());
             self.column_mut(j)
                 .gemv_tr(alpha.inlined_clone(), &rhs, work, beta.inlined_clone());
         }
@@ -1409,21 +1410,22 @@ where
     /// assert_relative_eq!(mat, expected);
     pub fn quadform<D2, S2, R3, C3, S3>(
         &mut self,
-        alpha: N,
-        mid: &SquareMatrix<N, D2, S2>,
-        rhs: &Matrix<N, R3, C3, S3>,
-        beta: N,
+        alpha: T,
+        mid: &SquareMatrix<T, D2, S2>,
+        rhs: &Matrix<T, R3, C3, S3>,
+        beta: T,
     ) where
         D2: Dim,
         R3: Dim,
         C3: Dim,
-        S2: Storage<N, D2, D2>,
-        S3: Storage<N, R3, C3>,
+        S2: Storage<T, D2, D2>,
+        S3: Storage<T, R3, C3>,
         ShapeConstraint: DimEq<D2, R3> + DimEq<D1, C3> + AreMultipliable<C3, R3, D2, U1>,
-        DefaultAllocator: Allocator<N, D2>,
+        DefaultAllocator: Allocator<T, D2>,
     {
-        let mut work =
-            unsafe { crate::unimplemented_or_uninitialized_generic!(mid.data.shape().0, U1) };
+        let mut work = unsafe {
+            crate::unimplemented_or_uninitialized_generic!(mid.data.shape().0, Const::<1>)
+        };
         self.quadform_with_workspace(&mut work, alpha, mid, rhs, beta)
     }
 }
diff --git a/src/base/cg.rs b/src/base/cg.rs
index f63cca64..2b62524b 100644
--- a/src/base/cg.rs
+++ b/src/base/cg.rs
@@ -11,8 +11,8 @@ use crate::base::allocator::Allocator;
 use crate::base::dimension::{DimName, DimNameDiff, DimNameSub, U1};
 use crate::base::storage::{Storage, StorageMut};
 use crate::base::{
-    DefaultAllocator, Matrix3, Matrix4, MatrixN, Scalar, SquareMatrix, Unit, Vector, Vector2,
-    Vector3, VectorN,
+    Const, DefaultAllocator, Matrix3, Matrix4, OMatrix, OVector, Scalar, SquareMatrix, Unit,
+    Vector, Vector2, Vector3,
 };
 use crate::geometry::{
     Isometry, IsometryMatrix3, Orthographic3, Perspective3, Point, Point2, Point3, Rotation2,
@@ -22,26 +22,26 @@ use crate::geometry::{
 use simba::scalar::{ClosedAdd, ClosedMul, RealField};
 
 /// # Translation and scaling in any dimension
-impl<N, D: DimName> MatrixN<N, D>
+impl<T, D: DimName> OMatrix<T, D, D>
 where
-    N: Scalar + Zero + One,
-    DefaultAllocator: Allocator<N, D, D>,
+    T: Scalar + Zero + One,
+    DefaultAllocator: Allocator<T, D, D>,
 {
     /// Creates a new homogeneous matrix that applies the same scaling factor on each dimension.
     #[inline]
-    pub fn new_scaling(scaling: N) -> Self {
+    pub fn new_scaling(scaling: T) -> Self {
         let mut res = Self::from_diagonal_element(scaling);
-        res[(D::dim() - 1, D::dim() - 1)] = N::one();
+        res[(D::dim() - 1, D::dim() - 1)] = T::one();
 
         res
     }
 
     /// Creates a new homogeneous matrix that applies a distinct scaling factor for each dimension.
     #[inline]
-    pub fn new_nonuniform_scaling<SB>(scaling: &Vector<N, DimNameDiff<D, U1>, SB>) -> Self
+    pub fn new_nonuniform_scaling<SB>(scaling: &Vector<T, DimNameDiff<D, U1>, SB>) -> Self
     where
         D: DimNameSub<U1>,
-        SB: Storage<N, DimNameDiff<D, U1>>,
+        SB: Storage<T, DimNameDiff<D, U1>>,
     {
         let mut res = Self::identity();
         for i in 0..scaling.len() {
@@ -53,24 +53,27 @@ where
 
     /// Creates a new homogeneous matrix that applies a pure translation.
     #[inline]
-    pub fn new_translation<SB>(translation: &Vector<N, DimNameDiff<D, U1>, SB>) -> Self
+    pub fn new_translation<SB>(translation: &Vector<T, DimNameDiff<D, U1>, SB>) -> Self
     where
         D: DimNameSub<U1>,
-        SB: Storage<N, DimNameDiff<D, U1>>,
+        SB: Storage<T, DimNameDiff<D, U1>>,
     {
         let mut res = Self::identity();
-        res.fixed_slice_mut::<DimNameDiff<D, U1>, U1>(0, D::dim() - 1)
-            .copy_from(translation);
+        res.generic_slice_mut(
+            (0, D::dim() - 1),
+            (DimNameDiff::<D, U1>::name(), Const::<1>),
+        )
+        .copy_from(translation);
 
         res
     }
 }
 
 /// # 2D transformations as a Matrix3
-impl<N: RealField> Matrix3<N> {
+impl<T: RealField> Matrix3<T> {
     /// Builds a 2 dimensional homogeneous rotation matrix from an angle in radian.
     #[inline]
-    pub fn new_rotation(angle: N) -> Self {
+    pub fn new_rotation(angle: T) -> Self {
         Rotation2::new(angle).to_homogeneous()
     }
 
@@ -78,9 +81,9 @@ impl<N: RealField> Matrix3<N> {
     ///
     /// Can be used to implement "zoom_to" functionality.
     #[inline]
-    pub fn new_nonuniform_scaling_wrt_point(scaling: &Vector2<N>, pt: &Point2<N>) -> Self {
-        let zero = N::zero();
-        let one = N::one();
+    pub fn new_nonuniform_scaling_wrt_point(scaling: &Vector2<T>, pt: &Point2<T>) -> Self {
+        let zero = T::zero();
+        let one = T::one();
         Matrix3::new(
             scaling.x,
             zero,
@@ -96,12 +99,12 @@ impl<N: RealField> Matrix3<N> {
 }
 
 /// # 3D transformations as a Matrix4
-impl<N: RealField> Matrix4<N> {
+impl<T: RealField> Matrix4<T> {
     /// Builds a 3D homogeneous rotation matrix from an axis and an angle (multiplied together).
     ///
     /// Returns the identity matrix if the given argument is zero.
     #[inline]
-    pub fn new_rotation(axisangle: Vector3<N>) -> Self {
+    pub fn new_rotation(axisangle: Vector3<T>) -> Self {
         Rotation3::new(axisangle).to_homogeneous()
     }
 
@@ -109,7 +112,7 @@ impl<N: RealField> Matrix4<N> {
     ///
     /// Returns the identity matrix if the given argument is zero.
     #[inline]
-    pub fn new_rotation_wrt_point(axisangle: Vector3<N>, pt: Point3<N>) -> Self {
+    pub fn new_rotation_wrt_point(axisangle: Vector3<T>, pt: Point3<T>) -> Self {
         let rot = Rotation3::from_scaled_axis(axisangle);
         Isometry::rotation_wrt_point(rot, pt).to_homogeneous()
     }
@@ -118,9 +121,9 @@ impl<N: RealField> Matrix4<N> {
     ///
     /// Can be used to implement "zoom_to" functionality.
     #[inline]
-    pub fn new_nonuniform_scaling_wrt_point(scaling: &Vector3<N>, pt: &Point3<N>) -> Self {
-        let zero = N::zero();
-        let one = N::one();
+    pub fn new_nonuniform_scaling_wrt_point(scaling: &Vector3<T>, pt: &Point3<T>) -> Self {
+        let zero = T::zero();
+        let one = T::one();
         Matrix4::new(
             scaling.x,
             zero,
@@ -146,31 +149,31 @@ impl<N: RealField> Matrix4<N> {
     /// Returns the identity matrix if the given argument is zero.
     /// This is identical to `Self::new_rotation`.
     #[inline]
-    pub fn from_scaled_axis(axisangle: Vector3<N>) -> Self {
+    pub fn from_scaled_axis(axisangle: Vector3<T>) -> Self {
         Rotation3::from_scaled_axis(axisangle).to_homogeneous()
     }
 
     /// Creates a new rotation from Euler angles.
     ///
     /// The primitive rotations are applied in order: 1 roll − 2 pitch − 3 yaw.
-    pub fn from_euler_angles(roll: N, pitch: N, yaw: N) -> Self {
+    pub fn from_euler_angles(roll: T, pitch: T, yaw: T) -> Self {
         Rotation3::from_euler_angles(roll, pitch, yaw).to_homogeneous()
     }
 
     /// Builds a 3D homogeneous rotation matrix from an axis and a rotation angle.
-    pub fn from_axis_angle(axis: &Unit<Vector3<N>>, angle: N) -> Self {
+    pub fn from_axis_angle(axis: &Unit<Vector3<T>>, angle: T) -> Self {
         Rotation3::from_axis_angle(axis, angle).to_homogeneous()
     }
 
     /// Creates a new homogeneous matrix for an orthographic projection.
     #[inline]
-    pub fn new_orthographic(left: N, right: N, bottom: N, top: N, znear: N, zfar: N) -> Self {
+    pub fn new_orthographic(left: T, right: T, bottom: T, top: T, znear: T, zfar: T) -> Self {
         Orthographic3::new(left, right, bottom, top, znear, zfar).into_inner()
     }
 
     /// Creates a new homogeneous matrix for a perspective projection.
     #[inline]
-    pub fn new_perspective(aspect: N, fovy: N, znear: N, zfar: N) -> Self {
+    pub fn new_perspective(aspect: T, fovy: T, znear: T, zfar: T) -> Self {
         Perspective3::new(aspect, fovy, znear, zfar).into_inner()
     }
 
@@ -180,40 +183,40 @@ impl<N: RealField> Matrix4<N> {
     /// It maps the view direction `target - eye` to the positive `z` axis and the origin to the
     /// `eye`.
     #[inline]
-    pub fn face_towards(eye: &Point3<N>, target: &Point3<N>, up: &Vector3<N>) -> Self {
+    pub fn face_towards(eye: &Point3<T>, target: &Point3<T>, up: &Vector3<T>) -> Self {
         IsometryMatrix3::face_towards(eye, target, up).to_homogeneous()
     }
 
     /// Deprecated: Use [Matrix4::face_towards] instead.
     #[deprecated(note = "renamed to `face_towards`")]
-    pub fn new_observer_frame(eye: &Point3<N>, target: &Point3<N>, up: &Vector3<N>) -> Self {
+    pub fn new_observer_frame(eye: &Point3<T>, target: &Point3<T>, up: &Vector3<T>) -> Self {
         Matrix4::face_towards(eye, target, up)
     }
 
     /// Builds a right-handed look-at view matrix.
     #[inline]
-    pub fn look_at_rh(eye: &Point3<N>, target: &Point3<N>, up: &Vector3<N>) -> Self {
+    pub fn look_at_rh(eye: &Point3<T>, target: &Point3<T>, up: &Vector3<T>) -> Self {
         IsometryMatrix3::look_at_rh(eye, target, up).to_homogeneous()
     }
 
     /// Builds a left-handed look-at view matrix.
     #[inline]
-    pub fn look_at_lh(eye: &Point3<N>, target: &Point3<N>, up: &Vector3<N>) -> Self {
+    pub fn look_at_lh(eye: &Point3<T>, target: &Point3<T>, up: &Vector3<T>) -> Self {
         IsometryMatrix3::look_at_lh(eye, target, up).to_homogeneous()
     }
 }
 
 /// # Append/prepend translation and scaling
-impl<N: Scalar + Zero + One + ClosedMul + ClosedAdd, D: DimName, S: Storage<N, D, D>>
-    SquareMatrix<N, D, S>
+impl<T: Scalar + Zero + One + ClosedMul + ClosedAdd, D: DimName, S: Storage<T, D, D>>
+    SquareMatrix<T, D, S>
 {
     /// Computes the transformation equal to `self` followed by an uniform scaling factor.
     #[inline]
     #[must_use = "Did you mean to use append_scaling_mut()?"]
-    pub fn append_scaling(&self, scaling: N) -> MatrixN<N, D>
+    pub fn append_scaling(&self, scaling: T) -> OMatrix<T, D, D>
     where
         D: DimNameSub<U1>,
-        DefaultAllocator: Allocator<N, D, D>,
+        DefaultAllocator: Allocator<T, D, D>,
     {
         let mut res = self.clone_owned();
         res.append_scaling_mut(scaling);
@@ -223,10 +226,10 @@ impl<N: Scalar + Zero + One + ClosedMul + ClosedAdd, D: DimName, S: Storage<N, D
     /// Computes the transformation equal to an uniform scaling factor followed by `self`.
     #[inline]
     #[must_use = "Did you mean to use prepend_scaling_mut()?"]
-    pub fn prepend_scaling(&self, scaling: N) -> MatrixN<N, D>
+    pub fn prepend_scaling(&self, scaling: T) -> OMatrix<T, D, D>
     where
         D: DimNameSub<U1>,
-        DefaultAllocator: Allocator<N, D, D>,
+        DefaultAllocator: Allocator<T, D, D>,
     {
         let mut res = self.clone_owned();
         res.prepend_scaling_mut(scaling);
@@ -238,12 +241,12 @@ impl<N: Scalar + Zero + One + ClosedMul + ClosedAdd, D: DimName, S: Storage<N, D
     #[must_use = "Did you mean to use append_nonuniform_scaling_mut()?"]
     pub fn append_nonuniform_scaling<SB>(
         &self,
-        scaling: &Vector<N, DimNameDiff<D, U1>, SB>,
-    ) -> MatrixN<N, D>
+        scaling: &Vector<T, DimNameDiff<D, U1>, SB>,
+    ) -> OMatrix<T, D, D>
     where
         D: DimNameSub<U1>,
-        SB: Storage<N, DimNameDiff<D, U1>>,
-        DefaultAllocator: Allocator<N, D, D>,
+        SB: Storage<T, DimNameDiff<D, U1>>,
+        DefaultAllocator: Allocator<T, D, D>,
     {
         let mut res = self.clone_owned();
         res.append_nonuniform_scaling_mut(scaling);
@@ -255,12 +258,12 @@ impl<N: Scalar + Zero + One + ClosedMul + ClosedAdd, D: DimName, S: Storage<N, D
     #[must_use = "Did you mean to use prepend_nonuniform_scaling_mut()?"]
     pub fn prepend_nonuniform_scaling<SB>(
         &self,
-        scaling: &Vector<N, DimNameDiff<D, U1>, SB>,
-    ) -> MatrixN<N, D>
+        scaling: &Vector<T, DimNameDiff<D, U1>, SB>,
+    ) -> OMatrix<T, D, D>
     where
         D: DimNameSub<U1>,
-        SB: Storage<N, DimNameDiff<D, U1>>,
-        DefaultAllocator: Allocator<N, D, D>,
+        SB: Storage<T, DimNameDiff<D, U1>>,
+        DefaultAllocator: Allocator<T, D, D>,
     {
         let mut res = self.clone_owned();
         res.prepend_nonuniform_scaling_mut(scaling);
@@ -270,11 +273,14 @@ impl<N: Scalar + Zero + One + ClosedMul + ClosedAdd, D: DimName, S: Storage<N, D
     /// Computes the transformation equal to `self` followed by a translation.
     #[inline]
     #[must_use = "Did you mean to use append_translation_mut()?"]
-    pub fn append_translation<SB>(&self, shift: &Vector<N, DimNameDiff<D, U1>, SB>) -> MatrixN<N, D>
+    pub fn append_translation<SB>(
+        &self,
+        shift: &Vector<T, DimNameDiff<D, U1>, SB>,
+    ) -> OMatrix<T, D, D>
     where
         D: DimNameSub<U1>,
-        SB: Storage<N, DimNameDiff<D, U1>>,
-        DefaultAllocator: Allocator<N, D, D>,
+        SB: Storage<T, DimNameDiff<D, U1>>,
+        DefaultAllocator: Allocator<T, D, D>,
     {
         let mut res = self.clone_owned();
         res.append_translation_mut(shift);
@@ -286,12 +292,12 @@ impl<N: Scalar + Zero + One + ClosedMul + ClosedAdd, D: DimName, S: Storage<N, D
     #[must_use = "Did you mean to use prepend_translation_mut()?"]
     pub fn prepend_translation<SB>(
         &self,
-        shift: &Vector<N, DimNameDiff<D, U1>, SB>,
-    ) -> MatrixN<N, D>
+        shift: &Vector<T, DimNameDiff<D, U1>, SB>,
+    ) -> OMatrix<T, D, D>
     where
         D: DimNameSub<U1>,
-        SB: Storage<N, DimNameDiff<D, U1>>,
-        DefaultAllocator: Allocator<N, D, D> + Allocator<N, DimNameDiff<D, U1>>,
+        SB: Storage<T, DimNameDiff<D, U1>>,
+        DefaultAllocator: Allocator<T, D, D> + Allocator<T, DimNameDiff<D, U1>>,
     {
         let mut res = self.clone_owned();
         res.prepend_translation_mut(shift);
@@ -300,36 +306,36 @@ impl<N: Scalar + Zero + One + ClosedMul + ClosedAdd, D: DimName, S: Storage<N, D
 
     /// Computes in-place the transformation equal to `self` followed by an uniform scaling factor.
     #[inline]
-    pub fn append_scaling_mut(&mut self, scaling: N)
+    pub fn append_scaling_mut(&mut self, scaling: T)
     where
-        S: StorageMut<N, D, D>,
+        S: StorageMut<T, D, D>,
         D: DimNameSub<U1>,
     {
-        let mut to_scale = self.fixed_rows_mut::<DimNameDiff<D, U1>>(0);
+        let mut to_scale = self.rows_generic_mut(0, DimNameDiff::<D, U1>::name());
         to_scale *= scaling;
     }
 
     /// Computes in-place the transformation equal to an uniform scaling factor followed by `self`.
     #[inline]
-    pub fn prepend_scaling_mut(&mut self, scaling: N)
+    pub fn prepend_scaling_mut(&mut self, scaling: T)
     where
-        S: StorageMut<N, D, D>,
+        S: StorageMut<T, D, D>,
         D: DimNameSub<U1>,
     {
-        let mut to_scale = self.fixed_columns_mut::<DimNameDiff<D, U1>>(0);
+        let mut to_scale = self.columns_generic_mut(0, DimNameDiff::<D, U1>::name());
         to_scale *= scaling;
     }
 
     /// Computes in-place the transformation equal to `self` followed by a non-uniform scaling factor.
     #[inline]
-    pub fn append_nonuniform_scaling_mut<SB>(&mut self, scaling: &Vector<N, DimNameDiff<D, U1>, SB>)
+    pub fn append_nonuniform_scaling_mut<SB>(&mut self, scaling: &Vector<T, DimNameDiff<D, U1>, SB>)
     where
-        S: StorageMut<N, D, D>,
+        S: StorageMut<T, D, D>,
         D: DimNameSub<U1>,
-        SB: Storage<N, DimNameDiff<D, U1>>,
+        SB: Storage<T, DimNameDiff<D, U1>>,
     {
         for i in 0..scaling.len() {
-            let mut to_scale = self.fixed_rows_mut::<U1>(i);
+            let mut to_scale = self.fixed_rows_mut::<1>(i);
             to_scale *= scaling[i].inlined_clone();
         }
     }
@@ -338,25 +344,25 @@ impl<N: Scalar + Zero + One + ClosedMul + ClosedAdd, D: DimName, S: Storage<N, D
     #[inline]
     pub fn prepend_nonuniform_scaling_mut<SB>(
         &mut self,
-        scaling: &Vector<N, DimNameDiff<D, U1>, SB>,
+        scaling: &Vector<T, DimNameDiff<D, U1>, SB>,
     ) where
-        S: StorageMut<N, D, D>,
+        S: StorageMut<T, D, D>,
         D: DimNameSub<U1>,
-        SB: Storage<N, DimNameDiff<D, U1>>,
+        SB: Storage<T, DimNameDiff<D, U1>>,
     {
         for i in 0..scaling.len() {
-            let mut to_scale = self.fixed_columns_mut::<U1>(i);
+            let mut to_scale = self.fixed_columns_mut::<1>(i);
             to_scale *= scaling[i].inlined_clone();
         }
     }
 
     /// Computes the transformation equal to `self` followed by a translation.
     #[inline]
-    pub fn append_translation_mut<SB>(&mut self, shift: &Vector<N, DimNameDiff<D, U1>, SB>)
+    pub fn append_translation_mut<SB>(&mut self, shift: &Vector<T, DimNameDiff<D, U1>, SB>)
     where
-        S: StorageMut<N, D, D>,
+        S: StorageMut<T, D, D>,
         D: DimNameSub<U1>,
-        SB: Storage<N, DimNameDiff<D, U1>>,
+        SB: Storage<T, DimNameDiff<D, U1>>,
     {
         for i in 0..D::dim() {
             for j in 0..D::dim() - 1 {
@@ -368,41 +374,55 @@ impl<N: Scalar + Zero + One + ClosedMul + ClosedAdd, D: DimName, S: Storage<N, D
 
     /// Computes the transformation equal to a translation followed by `self`.
     #[inline]
-    pub fn prepend_translation_mut<SB>(&mut self, shift: &Vector<N, DimNameDiff<D, U1>, SB>)
+    pub fn prepend_translation_mut<SB>(&mut self, shift: &Vector<T, DimNameDiff<D, U1>, SB>)
     where
         D: DimNameSub<U1>,
-        S: StorageMut<N, D, D>,
-        SB: Storage<N, DimNameDiff<D, U1>>,
-        DefaultAllocator: Allocator<N, DimNameDiff<D, U1>>,
+        S: StorageMut<T, D, D>,
+        SB: Storage<T, DimNameDiff<D, U1>>,
+        DefaultAllocator: Allocator<T, DimNameDiff<D, U1>>,
     {
         let scale = self
-            .fixed_slice::<U1, DimNameDiff<D, U1>>(D::dim() - 1, 0)
+            .generic_slice(
+                (D::dim() - 1, 0),
+                (Const::<1>, DimNameDiff::<D, U1>::name()),
+            )
             .tr_dot(&shift);
-        let post_translation =
-            self.fixed_slice::<DimNameDiff<D, U1>, DimNameDiff<D, U1>>(0, 0) * shift;
+        let post_translation = self.generic_slice(
+            (0, 0),
+            (DimNameDiff::<D, U1>::name(), DimNameDiff::<D, U1>::name()),
+        ) * shift;
 
         self[(D::dim() - 1, D::dim() - 1)] += scale;
 
-        let mut translation = self.fixed_slice_mut::<DimNameDiff<D, U1>, U1>(0, D::dim() - 1);
+        let mut translation = self.generic_slice_mut(
+            (0, D::dim() - 1),
+            (DimNameDiff::<D, U1>::name(), Const::<1>),
+        );
         translation += post_translation;
     }
 }
 
 /// # Transformation of vectors and points
-impl<N: RealField, D: DimNameSub<U1>, S: Storage<N, D, D>> SquareMatrix<N, D, S>
+impl<T: RealField, D: DimNameSub<U1>, S: Storage<T, D, D>> SquareMatrix<T, D, S>
 where
-    DefaultAllocator: Allocator<N, D, D>
-        + Allocator<N, DimNameDiff<D, U1>>
-        + Allocator<N, DimNameDiff<D, U1>, DimNameDiff<D, U1>>,
+    DefaultAllocator: Allocator<T, D, D>
+        + Allocator<T, DimNameDiff<D, U1>>
+        + Allocator<T, DimNameDiff<D, U1>, DimNameDiff<D, U1>>,
 {
     /// Transforms the given vector, assuming the matrix `self` uses homogeneous coordinates.
     #[inline]
     pub fn transform_vector(
         &self,
-        v: &VectorN<N, DimNameDiff<D, U1>>,
-    ) -> VectorN<N, DimNameDiff<D, U1>> {
-        let transform = self.fixed_slice::<DimNameDiff<D, U1>, DimNameDiff<D, U1>>(0, 0);
-        let normalizer = self.fixed_slice::<U1, DimNameDiff<D, U1>>(D::dim() - 1, 0);
+        v: &OVector<T, DimNameDiff<D, U1>>,
+    ) -> OVector<T, DimNameDiff<D, U1>> {
+        let transform = self.generic_slice(
+            (0, 0),
+            (DimNameDiff::<D, U1>::name(), DimNameDiff::<D, U1>::name()),
+        );
+        let normalizer = self.generic_slice(
+            (D::dim() - 1, 0),
+            (Const::<1>, DimNameDiff::<D, U1>::name()),
+        );
         let n = normalizer.tr_dot(&v);
 
         if !n.is_zero() {
@@ -411,18 +431,33 @@ where
 
         transform * v
     }
+}
 
+impl<T: RealField, S: Storage<T, Const<3>, Const<3>>> SquareMatrix<T, Const<3>, S> {
     /// Transforms the given point, assuming the matrix `self` uses homogeneous coordinates.
     #[inline]
-    pub fn transform_point(
-        &self,
-        pt: &Point<N, DimNameDiff<D, U1>>,
-    ) -> Point<N, DimNameDiff<D, U1>> {
-        let transform = self.fixed_slice::<DimNameDiff<D, U1>, DimNameDiff<D, U1>>(0, 0);
-        let translation = self.fixed_slice::<DimNameDiff<D, U1>, U1>(0, D::dim() - 1);
-        let normalizer = self.fixed_slice::<U1, DimNameDiff<D, U1>>(D::dim() - 1, 0);
-        let n = normalizer.tr_dot(&pt.coords)
-            + unsafe { *self.get_unchecked((D::dim() - 1, D::dim() - 1)) };
+    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 n = normalizer.tr_dot(&pt.coords) + unsafe { *self.get_unchecked((2, 2)) };
+
+        if !n.is_zero() {
+            (transform * pt + translation) / n
+        } else {
+            transform * pt + translation
+        }
+    }
+}
+
+impl<T: RealField, S: Storage<T, Const<4>, Const<4>>> SquareMatrix<T, Const<4>, S> {
+    /// 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 n = normalizer.tr_dot(&pt.coords) + unsafe { *self.get_unchecked((3, 3)) };
 
         if !n.is_zero() {
             (transform * pt + translation) / n
diff --git a/src/base/componentwise.rs b/src/base/componentwise.rs
index dcc4ece1..b7030f61 100644
--- a/src/base/componentwise.rs
+++ b/src/base/componentwise.rs
@@ -10,13 +10,13 @@ use crate::base::allocator::{Allocator, SameShapeAllocator};
 use crate::base::constraint::{SameNumberOfColumns, SameNumberOfRows, ShapeConstraint};
 use crate::base::dimension::Dim;
 use crate::base::storage::{Storage, StorageMut};
-use crate::base::{DefaultAllocator, Matrix, MatrixMN, MatrixSum, Scalar};
+use crate::base::{DefaultAllocator, Matrix, MatrixSum, OMatrix, Scalar};
 use crate::ClosedAdd;
 
 /// The type of the result of a matrix component-wise operation.
-pub type MatrixComponentOp<N, R1, C1, R2, C2> = MatrixSum<N, R1, C1, R2, C2>;
+pub type MatrixComponentOp<T, R1, C1, R2, C2> = MatrixSum<T, R1, C1, R2, C2>;
 
-impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
+impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
     /// Computes the component-wise absolute value.
     ///
     /// # Example
@@ -28,10 +28,10 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     /// assert_eq!(a.abs(), Matrix2::new(0.0, 1.0, 2.0, 3.0))
     /// ```
     #[inline]
-    pub fn abs(&self) -> MatrixMN<N, R, C>
+    pub fn abs(&self) -> OMatrix<T, R, C>
     where
-        N: Signed,
-        DefaultAllocator: Allocator<N, R, C>,
+        T: Signed,
+        DefaultAllocator: Allocator<T, R, C>,
     {
         let mut res = self.clone_owned();
 
@@ -49,11 +49,11 @@ macro_rules! component_binop_impl(
     ($($binop: ident, $binop_mut: ident, $binop_assign: ident, $cmpy: ident, $Trait: ident . $op: ident . $op_assign: ident, $desc:expr, $desc_cmpy:expr, $desc_mut:expr);* $(;)*) => {$(
         #[doc = $desc]
         #[inline]
-        pub fn $binop<R2, C2, SB>(&self, rhs: &Matrix<N, R2, C2, SB>) -> MatrixComponentOp<N, R1, C1, R2, C2>
-            where N: $Trait,
+        pub fn $binop<R2, C2, SB>(&self, rhs: &Matrix<T, R2, C2, SB>) -> MatrixComponentOp<T, R1, C1, R2, C2>
+            where T: $Trait,
                   R2: Dim, C2: Dim,
-                  SB: Storage<N, R2, C2>,
-                  DefaultAllocator: SameShapeAllocator<N, R1, C1, R2, C2>,
+                  SB: Storage<T, R2, C2>,
+                  DefaultAllocator: SameShapeAllocator<T, R1, C1, R2, C2>,
                   ShapeConstraint:  SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2> {
 
             assert_eq!(self.shape(), rhs.shape(), "Componentwise mul/div: mismatched matrix dimensions.");
@@ -73,13 +73,13 @@ macro_rules! component_binop_impl(
         // componentwise binop plus Y.
         #[doc = $desc_cmpy]
         #[inline]
-        pub fn $cmpy<R2, C2, SB, R3, C3, SC>(&mut self, alpha: N, a: &Matrix<N, R2, C2, SB>, b: &Matrix<N, R3, C3, SC>, beta: N)
-            where N: $Trait + Zero + Mul<N, Output = N> + Add<N, Output = N>,
+        pub fn $cmpy<R2, C2, SB, R3, C3, SC>(&mut self, alpha: T, a: &Matrix<T, R2, C2, SB>, b: &Matrix<T, R3, C3, SC>, beta: T)
+            where T: $Trait + Zero + Mul<T, Output = T> + Add<T, Output = T>,
                   R2: Dim, C2: Dim,
                   R3: Dim, C3: Dim,
-                  SA: StorageMut<N, R1, C1>,
-                  SB: Storage<N, R2, C2>,
-                  SC: Storage<N, R3, C3>,
+                  SA: StorageMut<T, R1, C1>,
+                  SB: Storage<T, R2, C2>,
+                  SC: Storage<T, R3, C3>,
                   ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2> +
                                    SameNumberOfRows<R1, R3> + SameNumberOfColumns<C1, C3> {
             assert_eq!(self.shape(), a.shape(), "Componentwise mul/div: mismatched matrix dimensions.");
@@ -109,12 +109,12 @@ macro_rules! component_binop_impl(
 
         #[doc = $desc_mut]
         #[inline]
-        pub fn $binop_assign<R2, C2, SB>(&mut self, rhs: &Matrix<N, R2, C2, SB>)
-            where N: $Trait,
+        pub fn $binop_assign<R2, C2, SB>(&mut self, rhs: &Matrix<T, R2, C2, SB>)
+            where T: $Trait,
                   R2: Dim,
                   C2: Dim,
-                  SA: StorageMut<N, R1, C1>,
-                  SB: Storage<N, R2, C2>,
+                  SA: StorageMut<T, R1, C1>,
+                  SB: Storage<T, R2, C2>,
                   ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2> {
 
             assert_eq!(self.shape(), rhs.shape(), "Componentwise mul/div: mismatched matrix dimensions.");
@@ -131,12 +131,12 @@ macro_rules! component_binop_impl(
         #[doc = $desc_mut]
         #[inline]
         #[deprecated(note = "This is renamed using the `_assign` suffix instead of the `_mut` suffix.")]
-        pub fn $binop_mut<R2, C2, SB>(&mut self, rhs: &Matrix<N, R2, C2, SB>)
-            where N: $Trait,
+        pub fn $binop_mut<R2, C2, SB>(&mut self, rhs: &Matrix<T, R2, C2, SB>)
+            where T: $Trait,
                   R2: Dim,
                   C2: Dim,
-                  SA: StorageMut<N, R1, C1>,
-                  SB: Storage<N, R2, C2>,
+                  SA: StorageMut<T, R1, C1>,
+                  SB: Storage<T, R2, C2>,
                   ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2> {
             self.$binop_assign(rhs)
         }
@@ -144,7 +144,7 @@ macro_rules! component_binop_impl(
 );
 
 /// # Componentwise operations
-impl<N: Scalar, R1: Dim, C1: Dim, SA: Storage<N, R1, C1>> Matrix<N, R1, C1, SA> {
+impl<T: Scalar, R1: Dim, C1: Dim, SA: Storage<T, R1, C1>> Matrix<T, R1, C1, SA> {
     component_binop_impl!(
         component_mul, component_mul_mut, component_mul_assign, cmpy, ClosedMul.mul.mul_assign,
         r"
@@ -241,30 +241,30 @@ impl<N: Scalar, R1: Dim, C1: Dim, SA: Storage<N, R1, C1>> Matrix<N, R1, C1, SA>
 
     /// Computes the infimum (aka. componentwise min) of two matrices/vectors.
     #[inline]
-    pub fn inf(&self, other: &Self) -> MatrixMN<N, R1, C1>
+    pub fn inf(&self, other: &Self) -> OMatrix<T, R1, C1>
     where
-        N: SimdPartialOrd,
-        DefaultAllocator: Allocator<N, R1, C1>,
+        T: SimdPartialOrd,
+        DefaultAllocator: Allocator<T, R1, C1>,
     {
         self.zip_map(other, |a, b| a.simd_min(b))
     }
 
     /// Computes the supremum (aka. componentwise max) of two matrices/vectors.
     #[inline]
-    pub fn sup(&self, other: &Self) -> MatrixMN<N, R1, C1>
+    pub fn sup(&self, other: &Self) -> OMatrix<T, R1, C1>
     where
-        N: SimdPartialOrd,
-        DefaultAllocator: Allocator<N, R1, C1>,
+        T: SimdPartialOrd,
+        DefaultAllocator: Allocator<T, R1, C1>,
     {
         self.zip_map(other, |a, b| a.simd_max(b))
     }
 
     /// Computes the (infimum, supremum) of two matrices/vectors.
     #[inline]
-    pub fn inf_sup(&self, other: &Self) -> (MatrixMN<N, R1, C1>, MatrixMN<N, R1, C1>)
+    pub fn inf_sup(&self, other: &Self) -> (OMatrix<T, R1, C1>, OMatrix<T, R1, C1>)
     where
-        N: SimdPartialOrd,
-        DefaultAllocator: Allocator<N, R1, C1>,
+        T: SimdPartialOrd,
+        DefaultAllocator: Allocator<T, R1, C1>,
     {
         // TODO: can this be optimized?
         (self.inf(other), self.sup(other))
@@ -273,10 +273,10 @@ impl<N: Scalar, R1: Dim, C1: Dim, SA: Storage<N, R1, C1>> Matrix<N, R1, C1, SA>
     /// Adds a scalar to `self`.
     #[inline]
     #[must_use = "Did you mean to use add_scalar_mut()?"]
-    pub fn add_scalar(&self, rhs: N) -> MatrixMN<N, R1, C1>
+    pub fn add_scalar(&self, rhs: T) -> OMatrix<T, R1, C1>
     where
-        N: ClosedAdd,
-        DefaultAllocator: Allocator<N, R1, C1>,
+        T: ClosedAdd,
+        DefaultAllocator: Allocator<T, R1, C1>,
     {
         let mut res = self.clone_owned();
         res.add_scalar_mut(rhs);
@@ -285,10 +285,10 @@ impl<N: Scalar, R1: Dim, C1: Dim, SA: Storage<N, R1, C1>> Matrix<N, R1, C1, SA>
 
     /// Adds a scalar to `self` in-place.
     #[inline]
-    pub fn add_scalar_mut(&mut self, rhs: N)
+    pub fn add_scalar_mut(&mut self, rhs: T)
     where
-        N: ClosedAdd,
-        SA: StorageMut<N, R1, C1>,
+        T: ClosedAdd,
+        SA: StorageMut<T, R1, C1>,
     {
         for e in self.iter_mut() {
             *e += rhs.inlined_clone()
diff --git a/src/base/construction.rs b/src/base/construction.rs
index 2fd0bb7f..e3e56b53 100644
--- a/src/base/construction.rs
+++ b/src/base/construction.rs
@@ -20,9 +20,11 @@ use typenum::{self, Cmp, Greater};
 use simba::scalar::{ClosedAdd, ClosedMul};
 
 use crate::base::allocator::Allocator;
-use crate::base::dimension::{Dim, DimName, Dynamic, U1, U2, U3, U4, U5, U6};
+use crate::base::dimension::{Dim, DimName, Dynamic, ToTypenum};
 use crate::base::storage::Storage;
-use crate::base::{DefaultAllocator, Matrix, MatrixMN, MatrixN, Scalar, Unit, Vector, VectorN};
+use crate::base::{
+    ArrayStorage, Const, DefaultAllocator, Matrix, OMatrix, OVector, Scalar, Unit, Vector,
+};
 
 /// When "no_unsound_assume_init" is enabled, expands to `unimplemented!()` instead of `new_uninitialized_generic().assume_init()`.
 /// Intended as a placeholder, each callsite should be refactored to use uninitialized memory soundly
@@ -31,7 +33,7 @@ macro_rules! unimplemented_or_uninitialized_generic {
     ($nrows:expr, $ncols:expr) => {{
         #[cfg(feature="no_unsound_assume_init")] {
             // Some of the call sites need the number of rows and columns from this to infer a type, so
-            // uninitialized memory is used to infer the type, as `N: Zero` isn't available at all callsites.
+            // uninitialized memory is used to infer the type, as `T: Zero` isn't available at all callsites.
             // This may technically still be UB even though the assume_init is dead code, but all callsites should be fixed before #556 is closed.
             let typeinference_helper = crate::base::Matrix::new_uninitialized_generic($nrows, $ncols);
             unimplemented!();
@@ -47,9 +49,9 @@ macro_rules! unimplemented_or_uninitialized_generic {
 /// the dimension as inputs.
 ///
 /// These functions should only be used when working on dimension-generic code.
-impl<N: Scalar, R: Dim, C: Dim> MatrixMN<N, R, C>
+impl<T: Scalar, R: Dim, C: Dim> OMatrix<T, R, C>
 where
-    DefaultAllocator: Allocator<N, R, C>,
+    DefaultAllocator: Allocator<T, R, C>,
 {
     /// Creates a new uninitialized matrix. If the matrix has a compile-time dimension, this panics
     /// if `nrows != R::to_usize()` or `ncols != C::to_usize()`.
@@ -60,7 +62,7 @@ where
 
     /// Creates a matrix with all its elements set to `elem`.
     #[inline]
-    pub fn from_element_generic(nrows: R, ncols: C, elem: N) -> Self {
+    pub fn from_element_generic(nrows: R, ncols: C, elem: T) -> Self {
         let len = nrows.value() * ncols.value();
         Self::from_iterator_generic(nrows, ncols, iter::repeat(elem).take(len))
     }
@@ -69,7 +71,7 @@ where
     ///
     /// Same as `from_element_generic`.
     #[inline]
-    pub fn repeat_generic(nrows: R, ncols: C, elem: N) -> Self {
+    pub fn repeat_generic(nrows: R, ncols: C, elem: T) -> Self {
         let len = nrows.value() * ncols.value();
         Self::from_iterator_generic(nrows, ncols, iter::repeat(elem).take(len))
     }
@@ -78,16 +80,16 @@ where
     #[inline]
     pub fn zeros_generic(nrows: R, ncols: C) -> Self
     where
-        N: Zero,
+        T: Zero,
     {
-        Self::from_element_generic(nrows, ncols, N::zero())
+        Self::from_element_generic(nrows, ncols, T::zero())
     }
 
     /// Creates a matrix with all its elements filled by an iterator.
     #[inline]
     pub fn from_iterator_generic<I>(nrows: R, ncols: C, iter: I) -> Self
     where
-        I: IntoIterator<Item = N>,
+        I: IntoIterator<Item = T>,
     {
         Self::from_data(DefaultAllocator::allocate_from_iterator(nrows, ncols, iter))
     }
@@ -98,7 +100,7 @@ where
     /// The order of elements in the slice must follow the usual mathematic writing, i.e.,
     /// row-by-row.
     #[inline]
-    pub fn from_row_slice_generic(nrows: R, ncols: C, slice: &[N]) -> Self {
+    pub fn from_row_slice_generic(nrows: R, ncols: C, slice: &[T]) -> Self {
         assert!(
             slice.len() == nrows.value() * ncols.value(),
             "Matrix init. error: the slice did not contain the right number of elements."
@@ -119,7 +121,7 @@ where
     /// Creates a matrix with its elements filled with the components provided by a slice. The
     /// components must have the same layout as the matrix data storage (i.e. column-major).
     #[inline]
-    pub fn from_column_slice_generic(nrows: R, ncols: C, slice: &[N]) -> Self {
+    pub fn from_column_slice_generic(nrows: R, ncols: C, slice: &[T]) -> Self {
         Self::from_iterator_generic(nrows, ncols, slice.iter().cloned())
     }
 
@@ -128,7 +130,7 @@ where
     #[inline]
     pub fn from_fn_generic<F>(nrows: R, ncols: C, mut f: F) -> Self
     where
-        F: FnMut(usize, usize) -> N,
+        F: FnMut(usize, usize) -> T,
     {
         let mut res: Self = unsafe { crate::unimplemented_or_uninitialized_generic!(nrows, ncols) };
 
@@ -148,9 +150,9 @@ where
     #[inline]
     pub fn identity_generic(nrows: R, ncols: C) -> Self
     where
-        N: Zero + One,
+        T: Zero + One,
     {
-        Self::from_diagonal_element_generic(nrows, ncols, N::one())
+        Self::from_diagonal_element_generic(nrows, ncols, T::one())
     }
 
     /// Creates a new matrix with its diagonal filled with copies of `elt`.
@@ -158,9 +160,9 @@ where
     /// If the matrix is not square, the largest square submatrix starting at index `(0, 0)` is set
     /// to the identity matrix. All other entries are set to zero.
     #[inline]
-    pub fn from_diagonal_element_generic(nrows: R, ncols: C, elt: N) -> Self
+    pub fn from_diagonal_element_generic(nrows: R, ncols: C, elt: T) -> Self
     where
-        N: Zero + One,
+        T: Zero + One,
     {
         let mut res = Self::zeros_generic(nrows, ncols);
 
@@ -176,9 +178,9 @@ where
     ///
     /// Panics if `elts.len()` is larger than the minimum among `nrows` and `ncols`.
     #[inline]
-    pub fn from_partial_diagonal_generic(nrows: R, ncols: C, elts: &[N]) -> Self
+    pub fn from_partial_diagonal_generic(nrows: R, ncols: C, elts: &[T]) -> Self
     where
-        N: Zero,
+        T: Zero,
     {
         let mut res = Self::zeros_generic(nrows, ncols);
         assert!(
@@ -210,9 +212,9 @@ where
     ///         m.m31 == 7.0 && m.m32 == 8.0 && m.m33 == 9.0);
     /// ```
     #[inline]
-    pub fn from_rows<SB>(rows: &[Matrix<N, U1, C, SB>]) -> Self
+    pub fn from_rows<SB>(rows: &[Matrix<T, Const<1>, C, SB>]) -> Self
     where
-        SB: Storage<N, U1, C>,
+        SB: Storage<T, Const<1>, C>,
     {
         assert!(!rows.is_empty(), "At least one row must be given.");
         let nrows = R::try_to_usize().unwrap_or_else(|| rows.len());
@@ -252,9 +254,9 @@ where
     ///         m.m31 == 3.0 && m.m32 == 6.0 && m.m33 == 9.0);
     /// ```
     #[inline]
-    pub fn from_columns<SB>(columns: &[Vector<N, R, SB>]) -> Self
+    pub fn from_columns<SB>(columns: &[Vector<T, R, SB>]) -> Self
     where
-        SB: Storage<N, R>,
+        SB: Storage<T, R>,
     {
         assert!(!columns.is_empty(), "At least one column must be given.");
         let ncols = C::try_to_usize().unwrap_or_else(|| columns.len());
@@ -282,7 +284,7 @@ where
     #[cfg(feature = "rand")]
     pub fn new_random_generic(nrows: R, ncols: C) -> Self
     where
-        Standard: Distribution<N>,
+        Standard: Distribution<T>,
     {
         let mut rng = rand::thread_rng();
         Self::from_fn_generic(nrows, ncols, |_, _| rng.gen())
@@ -291,7 +293,7 @@ where
     /// Creates a matrix filled with random values from the given distribution.
     #[inline]
     #[cfg(feature = "rand-no-std")]
-    pub fn from_distribution_generic<Distr: Distribution<N> + ?Sized, G: Rng + ?Sized>(
+    pub fn from_distribution_generic<Distr: Distribution<T> + ?Sized, G: Rng + ?Sized>(
         nrows: R,
         ncols: C,
         distribution: &Distr,
@@ -306,12 +308,12 @@ where
     ///
     /// # Example
     /// ```
-    /// # use nalgebra::{Dynamic, DMatrix, Matrix, U1};
+    /// # use nalgebra::{Dynamic, 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()), U1, vec);
+    /// let matrix = Matrix::from_vec_generic(Dynamic::new(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.
@@ -319,15 +321,15 @@ where
     /// ```
     #[inline]
     #[cfg(any(feature = "std", feature = "alloc"))]
-    pub fn from_vec_generic(nrows: R, ncols: C, data: Vec<N>) -> Self {
+    pub fn from_vec_generic(nrows: R, ncols: C, data: Vec<T>) -> Self {
         Self::from_iterator_generic(nrows, ncols, data)
     }
 }
 
-impl<N, D: Dim> MatrixN<N, D>
+impl<T, D: Dim> OMatrix<T, D, D>
 where
-    N: Scalar,
-    DefaultAllocator: Allocator<N, D, D>,
+    T: Scalar,
+    DefaultAllocator: Allocator<T, D, D>,
 {
     /// Creates a square matrix with its diagonal set to `diag` and all other entries set to 0.
     ///
@@ -348,9 +350,9 @@ where
     ///         dm[(2, 0)] == 0.0 && dm[(2, 1)] == 0.0 && dm[(2, 2)] == 3.0);
     /// ```
     #[inline]
-    pub fn from_diagonal<SB: Storage<N, D>>(diag: &Vector<N, D, SB>) -> Self
+    pub fn from_diagonal<SB: Storage<T, D>>(diag: &Vector<T, D, SB>) -> Self
     where
-        N: Zero,
+        T: Zero,
     {
         let (dim, _) = diag.data.shape();
         let mut res = Self::zeros_generic(dim, dim);
@@ -399,7 +401,7 @@ macro_rules! impl_constructors(
         ///         dm[(1, 0)] == 2.0 && dm[(1, 1)] == 2.0 && dm[(1, 2)] == 2.0);
         /// ```
         #[inline]
-        pub fn from_element($($args: usize,)* elem: N) -> Self {
+        pub fn from_element($($args: usize,)* elem: T) -> Self {
             Self::from_element_generic($($gargs, )* elem)
         }
 
@@ -426,7 +428,7 @@ macro_rules! impl_constructors(
         ///         dm[(1, 0)] == 2.0 && dm[(1, 1)] == 2.0 && dm[(1, 2)] == 2.0);
         /// ```
         #[inline]
-        pub fn repeat($($args: usize,)* elem: N) -> Self {
+        pub fn repeat($($args: usize,)* elem: T) -> Self {
             Self::repeat_generic($($gargs, )* elem)
         }
 
@@ -452,7 +454,7 @@ macro_rules! impl_constructors(
         /// ```
         #[inline]
         pub fn zeros($($args: usize),*) -> Self
-            where N: Zero {
+            where T: Zero {
             Self::zeros_generic($($gargs),*)
         }
 
@@ -481,7 +483,7 @@ macro_rules! impl_constructors(
         /// ```
         #[inline]
         pub fn from_iterator<I>($($args: usize,)* iter: I) -> Self
-            where I: IntoIterator<Item = N> {
+            where I: IntoIterator<Item = T> {
             Self::from_iterator_generic($($gargs, )* iter)
         }
 
@@ -509,7 +511,7 @@ macro_rules! impl_constructors(
         /// ```
         #[inline]
         pub fn from_fn<F>($($args: usize,)* f: F) -> Self
-            where F: FnMut(usize, usize) -> N {
+            where F: FnMut(usize, usize) -> T {
             Self::from_fn_generic($($gargs, )* f)
         }
 
@@ -533,7 +535,7 @@ macro_rules! impl_constructors(
         /// ```
         #[inline]
         pub fn identity($($args: usize,)*) -> Self
-            where N: Zero + One {
+            where T: Zero + One {
             Self::identity_generic($($gargs),* )
         }
 
@@ -555,8 +557,8 @@ macro_rules! impl_constructors(
         ///         dm[(1, 0)] == 0.0 && dm[(1, 1)] == 5.0 && dm[(1, 2)] == 0.0);
         /// ```
         #[inline]
-        pub fn from_diagonal_element($($args: usize,)* elt: N) -> Self
-            where N: Zero + One {
+        pub fn from_diagonal_element($($args: usize,)* elt: T) -> Self
+            where T: Zero + One {
             Self::from_diagonal_element_generic($($gargs, )* elt)
         }
 
@@ -582,15 +584,15 @@ macro_rules! impl_constructors(
         ///         dm[(2, 0)] == 0.0 && dm[(2, 1)] == 0.0 && dm[(2, 2)] == 0.0);
         /// ```
         #[inline]
-        pub fn from_partial_diagonal($($args: usize,)* elts: &[N]) -> Self
-            where N: Zero {
+        pub fn from_partial_diagonal($($args: usize,)* elts: &[T]) -> Self
+            where T: Zero {
             Self::from_partial_diagonal_generic($($gargs, )* elts)
         }
 
         /// Creates a matrix or vector filled with random values from the given distribution.
         #[inline]
         #[cfg(feature = "rand-no-std")]
-        pub fn from_distribution<Distr: Distribution<N> + ?Sized, G: Rng + ?Sized>(
+        pub fn from_distribution<Distr: Distribution<T> + ?Sized, G: Rng + ?Sized>(
             $($args: usize,)*
             distribution: &Distr,
             rng: &mut G,
@@ -602,28 +604,28 @@ macro_rules! impl_constructors(
         #[inline]
         #[cfg(feature = "rand")]
         pub fn new_random($($args: usize),*) -> Self
-            where Standard: Distribution<N> {
+            where Standard: Distribution<T> {
             Self::new_random_generic($($gargs),*)
         }
     }
 );
 
 /// # Constructors of statically-sized vectors or statically-sized matrices
-impl<N: Scalar, R: DimName, C: DimName> MatrixMN<N, R, C>
+impl<T: Scalar, R: DimName, C: DimName> OMatrix<T, R, C>
 where
-    DefaultAllocator: Allocator<N, R, C>,
+    DefaultAllocator: Allocator<T, R, C>,
 {
-    // TODO: this is not very pretty. We could find a better call syntax.
-    impl_constructors!(R, C;                         // Arguments for Matrix<N, ..., S>
-    => R: DimName, => C: DimName; // Type parameters for impl<N, ..., S>
+    // TODO: this is not very pretty. We could find a better call syntax.
+    impl_constructors!(R, C;                         // Arguments for Matrix<T, ..., S>
+    => R: DimName, => C: DimName; // Type parameters for impl<T, ..., S>
     R::name(), C::name();         // Arguments for `_generic` constructors.
     ); // Arguments for non-generic constructors.
 }
 
 /// # Constructors of matrices with a dynamic number of columns
-impl<N: Scalar, R: DimName> MatrixMN<N, R, Dynamic>
+impl<T: Scalar, R: DimName> OMatrix<T, R, Dynamic>
 where
-    DefaultAllocator: Allocator<N, R, Dynamic>,
+    DefaultAllocator: Allocator<T, R, Dynamic>,
 {
     impl_constructors!(R, Dynamic;
                    => R: DimName;
@@ -632,9 +634,9 @@ where
 }
 
 /// # Constructors of dynamic vectors and matrices with a dynamic number of rows
-impl<N: Scalar, C: DimName> MatrixMN<N, Dynamic, C>
+impl<T: Scalar, C: DimName> OMatrix<T, Dynamic, C>
 where
-    DefaultAllocator: Allocator<N, Dynamic, C>,
+    DefaultAllocator: Allocator<T, Dynamic, C>,
 {
     impl_constructors!(Dynamic, C;
                    => C: DimName;
@@ -643,9 +645,9 @@ where
 }
 
 /// # Constructors of fully dynamic matrices
-impl<N: Scalar> MatrixMN<N, Dynamic, Dynamic>
+impl<T: Scalar> OMatrix<T, Dynamic, Dynamic>
 where
-    DefaultAllocator: Allocator<N, Dynamic, Dynamic>,
+    DefaultAllocator: Allocator<T, Dynamic, Dynamic>,
 {
     impl_constructors!(Dynamic, Dynamic;
                    ;
@@ -661,8 +663,8 @@ where
  */
 macro_rules! impl_constructors_from_data(
     ($data: ident; $($Dims: ty),*; $(=> $DimIdent: ident: $DimBound: ident),*; $($gargs: expr),*; $($args: ident),*) => {
-        impl<N: Scalar, $($DimIdent: $DimBound, )*> MatrixMN<N $(, $Dims)*>
-        where DefaultAllocator: Allocator<N $(, $Dims)*> {
+        impl<T: Scalar, $($DimIdent: $DimBound, )*> OMatrix<T $(, $Dims)*>
+        where DefaultAllocator: Allocator<T $(, $Dims)*> {
             /// Creates a matrix with its elements filled with the components provided by a slice
             /// in row-major order.
             ///
@@ -689,7 +691,7 @@ macro_rules! impl_constructors_from_data(
             ///         dm[(1, 0)] == 3 && dm[(1, 1)] == 4 && dm[(1, 2)] == 5);
             /// ```
             #[inline]
-            pub fn from_row_slice($($args: usize,)* $data: &[N]) -> Self {
+            pub fn from_row_slice($($args: usize,)* $data: &[T]) -> Self {
                 Self::from_row_slice_generic($($gargs, )* $data)
             }
 
@@ -716,7 +718,7 @@ macro_rules! impl_constructors_from_data(
             ///         dm[(1, 0)] == 1 && dm[(1, 1)] == 3 && dm[(1, 2)] == 5);
             /// ```
             #[inline]
-            pub fn from_column_slice($($args: usize,)* $data: &[N]) -> Self {
+            pub fn from_column_slice($($args: usize,)* $data: &[T]) -> Self {
                 Self::from_column_slice_generic($($gargs, )* $data)
             }
 
@@ -742,7 +744,7 @@ macro_rules! impl_constructors_from_data(
             /// ```
             #[inline]
             #[cfg(any(feature = "std", feature = "alloc"))]
-            pub fn from_vec($($args: usize,)* $data: Vec<N>) -> Self {
+            pub fn from_vec($($args: usize,)* $data: Vec<T>) -> Self {
                 Self::from_vec_generic($($gargs, )* $data)
             }
         }
@@ -750,8 +752,8 @@ macro_rules! impl_constructors_from_data(
 );
 
 // TODO: this is not very pretty. We could find a better call syntax.
-impl_constructors_from_data!(data; R, C;                  // Arguments for Matrix<N, ..., S>
-=> R: DimName, => C: DimName; // Type parameters for impl<N, ..., S>
+impl_constructors_from_data!(data; R, C;                  // Arguments for Matrix<T, ..., S>
+=> R: DimName, => C: DimName; // Type parameters for impl<T, ..., S>
 R::name(), C::name();         // Arguments for `_generic` constructors.
 ); // Arguments for non-generic constructors.
 
@@ -775,14 +777,14 @@ impl_constructors_from_data!(data; Dynamic, Dynamic;
  * Zero, One, Rand traits.
  *
  */
-impl<N, R: DimName, C: DimName> Zero for MatrixMN<N, R, C>
+impl<T, R: DimName, C: DimName> Zero for OMatrix<T, R, C>
 where
-    N: Scalar + Zero + ClosedAdd,
-    DefaultAllocator: Allocator<N, R, C>,
+    T: Scalar + Zero + ClosedAdd,
+    DefaultAllocator: Allocator<T, R, C>,
 {
     #[inline]
     fn zero() -> Self {
-        Self::from_element(N::zero())
+        Self::from_element(T::zero())
     }
 
     #[inline]
@@ -791,10 +793,10 @@ where
     }
 }
 
-impl<N, D: DimName> One for MatrixN<N, D>
+impl<T, D: DimName> One for OMatrix<T, D, D>
 where
-    N: Scalar + Zero + One + ClosedMul + ClosedAdd,
-    DefaultAllocator: Allocator<N, D, D>,
+    T: Scalar + Zero + One + ClosedMul + ClosedAdd,
+    DefaultAllocator: Allocator<T, D, D>,
 {
     #[inline]
     fn one() -> Self {
@@ -802,45 +804,45 @@ where
     }
 }
 
-impl<N, R: DimName, C: DimName> Bounded for MatrixMN<N, R, C>
+impl<T, R: DimName, C: DimName> Bounded for OMatrix<T, R, C>
 where
-    N: Scalar + Bounded,
-    DefaultAllocator: Allocator<N, R, C>,
+    T: Scalar + Bounded,
+    DefaultAllocator: Allocator<T, R, C>,
 {
     #[inline]
     fn max_value() -> Self {
-        Self::from_element(N::max_value())
+        Self::from_element(T::max_value())
     }
 
     #[inline]
     fn min_value() -> Self {
-        Self::from_element(N::min_value())
+        Self::from_element(T::min_value())
     }
 }
 
 #[cfg(feature = "rand-no-std")]
-impl<N: Scalar, R: Dim, C: Dim> Distribution<MatrixMN<N, R, C>> for Standard
+impl<T: Scalar, R: Dim, C: Dim> Distribution<OMatrix<T, R, C>> for Standard
 where
-    DefaultAllocator: Allocator<N, R, C>,
-    Standard: Distribution<N>,
+    DefaultAllocator: Allocator<T, R, C>,
+    Standard: Distribution<T>,
 {
     #[inline]
-    fn sample<'a, G: Rng + ?Sized>(&self, rng: &'a mut G) -> MatrixMN<N, R, C> {
+    fn sample<'a, G: Rng + ?Sized>(&self, rng: &'a mut G) -> OMatrix<T, R, C> {
         let nrows = R::try_to_usize().unwrap_or_else(|| rng.gen_range(0..10));
         let ncols = C::try_to_usize().unwrap_or_else(|| rng.gen_range(0..10));
 
-        MatrixMN::from_fn_generic(R::from_usize(nrows), C::from_usize(ncols), |_, _| rng.gen())
+        OMatrix::from_fn_generic(R::from_usize(nrows), C::from_usize(ncols), |_, _| rng.gen())
     }
 }
 
 #[cfg(feature = "arbitrary")]
-impl<N, R, C> Arbitrary for MatrixMN<N, R, C>
+impl<T, R, C> Arbitrary for OMatrix<T, R, C>
 where
     R: Dim,
     C: Dim,
-    N: Scalar + Arbitrary + Send,
-    DefaultAllocator: Allocator<N, R, C>,
-    Owned<N, R, C>: Clone + Send,
+    T: Scalar + Arbitrary + Send,
+    DefaultAllocator: Allocator<T, R, C>,
+    Owned<T, R, C>: Clone + Send,
 {
     #[inline]
     fn arbitrary(g: &mut Gen) -> Self {
@@ -848,24 +850,24 @@ where
         let ncols = C::try_to_usize().unwrap_or(usize::arbitrary(g) % 10);
 
         Self::from_fn_generic(R::from_usize(nrows), C::from_usize(ncols), |_, _| {
-            N::arbitrary(g)
+            T::arbitrary(g)
         })
     }
 }
 
 // TODO(specialization): faster impls possible for D≤4 (see rand_distr::{UnitCircle, UnitSphere})
 #[cfg(feature = "rand")]
-impl<N: crate::RealField, D: DimName> Distribution<Unit<VectorN<N, D>>> for Standard
+impl<T: crate::RealField, D: DimName> Distribution<Unit<OVector<T, D>>> for Standard
 where
-    DefaultAllocator: Allocator<N, D>,
-    rand_distr::StandardNormal: Distribution<N>,
+    DefaultAllocator: Allocator<T, D>,
+    rand_distr::StandardNormal: Distribution<T>,
 {
     /// Generate a uniformly distributed random unit vector.
     #[inline]
-    fn sample<'a, G: Rng + ?Sized>(&self, rng: &'a mut G) -> Unit<VectorN<N, D>> {
-        Unit::new_normalize(VectorN::from_distribution_generic(
+    fn sample<'a, G: Rng + ?Sized>(&self, rng: &'a mut G) -> Unit<OVector<T, D>> {
+        Unit::new_normalize(OVector::from_distribution_generic(
             D::name(),
-            U1,
+            Const::<1>,
             &rand_distr::StandardNormal,
             rng,
         ))
@@ -877,22 +879,44 @@ where
  * Constructors for small matrices and vectors.
  *
  */
+
+macro_rules! transpose_array(
+    [$($a: ident),*;] => {
+        [$([$a]),*]
+    };
+    [$($a: ident),*; $($b: ident),*;] => {
+        [$([$a, $b]),*];
+    };
+    [$($a: ident),*; $($b: ident),*; $($c: ident),*;] => {
+        [$([$a, $b, $c]),*];
+    };
+    [$($a: ident),*; $($b: ident),*; $($c: ident),*; $($d: ident),*;] => {
+        [$([$a, $b, $c, $d]),*];
+    };
+    [$($a: ident),*; $($b: ident),*; $($c: ident),*; $($d: ident),*; $($e: ident),*;] => {
+        [$([$a, $b, $c, $d, $e]),*];
+    };
+    [$($a: ident),*; $($b: ident),*; $($c: ident),*; $($d: ident),*; $($e: ident),*; $($f: ident),*;] => {
+        [$([$a, $b, $c, $d, $e, $f]),*];
+    };
+);
+
 macro_rules! componentwise_constructors_impl(
-    ($($R: ty, $C: ty, $($args: ident:($irow: expr,$icol: expr)),*);* $(;)*) => {$(
-        impl<N> MatrixMN<N, $R, $C>
-            where N: Scalar,
-                  DefaultAllocator: Allocator<N, $R, $C> {
+    ($($R: expr, $C: expr, [$($($args: ident),*);*] $(;)*)*) => {$(
+        impl<T> Matrix<T, Const<$R>, Const<$C>, ArrayStorage<T, $R, $C>> {
             /// Initializes this matrix from its components.
             #[inline]
-            pub fn new($($args: N),*) -> Self {
+            pub const fn new($($($args: T),*),*) -> Self {
                 unsafe {
-                    #[cfg(feature="no_unsound_assume_init")]
-                    let mut res: Self = unimplemented!();
-                    #[cfg(not(feature="no_unsound_assume_init"))]
-                    let mut res = Self::new_uninitialized().assume_init();
-                    $( *res.get_unchecked_mut(($irow, $icol)) = $args; )*
-
-                    res
+                    Self::from_data_statically_unchecked(
+                        ArrayStorage(
+                            transpose_array![
+                                $(
+                                    $($args),*
+                                ;)*
+                            ]
+                        )
+                    )
                 }
             }
         }
@@ -903,145 +927,145 @@ componentwise_constructors_impl!(
     /*
      * Square matrices 1 .. 6.
      */
-    U2, U2, m11:(0,0), m12:(0,1),
-            m21:(1,0), m22:(1,1);
-    U3, U3, m11:(0,0), m12:(0,1), m13:(0,2),
-            m21:(1,0), m22:(1,1), m23:(1,2),
-            m31:(2,0), m32:(2,1), m33:(2,2);
-    U4, U4, m11:(0,0), m12:(0,1), m13:(0,2), m14:(0,3),
-            m21:(1,0), m22:(1,1), m23:(1,2), m24:(1,3),
-            m31:(2,0), m32:(2,1), m33:(2,2), m34:(2,3),
-            m41:(3,0), m42:(3,1), m43:(3,2), m44:(3,3);
-    U5, U5, m11:(0,0), m12:(0,1), m13:(0,2), m14:(0,3), m15:(0,4),
-            m21:(1,0), m22:(1,1), m23:(1,2), m24:(1,3), m25:(1,4),
-            m31:(2,0), m32:(2,1), m33:(2,2), m34:(2,3), m35:(2,4),
-            m41:(3,0), m42:(3,1), m43:(3,2), m44:(3,3), m45:(3,4),
-            m51:(4,0), m52:(4,1), m53:(4,2), m54:(4,3), m55:(4,4);
-    U6, U6, m11:(0,0), m12:(0,1), m13:(0,2), m14:(0,3), m15:(0,4), m16:(0,5),
-            m21:(1,0), m22:(1,1), m23:(1,2), m24:(1,3), m25:(1,4), m26:(1,5),
-            m31:(2,0), m32:(2,1), m33:(2,2), m34:(2,3), m35:(2,4), m36:(2,5),
-            m41:(3,0), m42:(3,1), m43:(3,2), m44:(3,3), m45:(3,4), m46:(3,5),
-            m51:(4,0), m52:(4,1), m53:(4,2), m54:(4,3), m55:(4,4), m56:(4,5),
-            m61:(5,0), m62:(5,1), m63:(5,2), m64:(5,3), m65:(5,4), m66:(5,5);
+    2, 2, [m11, m12;
+           m21, m22];
+    3, 3, [m11, m12, m13;
+          m21, m22, m23;
+          m31, m32, m33];
+    4, 4, [m11, m12, m13, m14;
+          m21, m22, m23, m24;
+          m31, m32, m33, m34;
+          m41, m42, m43, m44];
+    5, 5, [m11, m12, m13, m14, m15;
+          m21, m22, m23, m24, m25;
+          m31, m32, m33, m34, m35;
+          m41, m42, m43, m44, m45;
+          m51, m52, m53, m54, m55];
+    6, 6, [m11, m12, m13, m14, m15, m16;
+          m21, m22, m23, m24, m25, m26;
+          m31, m32, m33, m34, m35, m36;
+          m41, m42, m43, m44, m45, m46;
+          m51, m52, m53, m54, m55, m56;
+          m61, m62, m63, m64, m65, m66];
 
     /*
      * Rectangular matrices with 2 rows.
      */
-    U2, U3, m11:(0,0), m12:(0,1), m13:(0,2),
-            m21:(1,0), m22:(1,1), m23:(1,2);
-    U2, U4, m11:(0,0), m12:(0,1), m13:(0,2), m14:(0,3),
-            m21:(1,0), m22:(1,1), m23:(1,2), m24:(1,3);
-    U2, U5, m11:(0,0), m12:(0,1), m13:(0,2), m14:(0,3), m15:(0,4),
-            m21:(1,0), m22:(1,1), m23:(1,2), m24:(1,3), m25:(1,4);
-    U2, U6, m11:(0,0), m12:(0,1), m13:(0,2), m14:(0,3), m15:(0,4), m16:(0,5),
-            m21:(1,0), m22:(1,1), m23:(1,2), m24:(1,3), m25:(1,4), m26:(1,5);
+    2, 3, [m11, m12, m13;
+          m21, m22, m23];
+    2, 4, [m11, m12, m13, m14;
+          m21, m22, m23, m24];
+    2, 5, [m11, m12, m13, m14, m15;
+          m21, m22, m23, m24, m25];
+    2, 6, [m11, m12, m13, m14, m15, m16;
+          m21, m22, m23, m24, m25, m26];
 
     /*
      * Rectangular matrices with 3 rows.
      */
-    U3, U2, m11:(0,0), m12:(0,1),
-            m21:(1,0), m22:(1,1),
-            m31:(2,0), m32:(2,1);
-    U3, U4, m11:(0,0), m12:(0,1), m13:(0,2), m14:(0,3),
-            m21:(1,0), m22:(1,1), m23:(1,2), m24:(1,3),
-            m31:(2,0), m32:(2,1), m33:(2,2), m34:(2,3);
-    U3, U5, m11:(0,0), m12:(0,1), m13:(0,2), m14:(0,3), m15:(0,4),
-            m21:(1,0), m22:(1,1), m23:(1,2), m24:(1,3), m25:(1,4),
-            m31:(2,0), m32:(2,1), m33:(2,2), m34:(2,3), m35:(2,4);
-    U3, U6, m11:(0,0), m12:(0,1), m13:(0,2), m14:(0,3), m15:(0,4), m16:(0,5),
-            m21:(1,0), m22:(1,1), m23:(1,2), m24:(1,3), m25:(1,4), m26:(1,5),
-            m31:(2,0), m32:(2,1), m33:(2,2), m34:(2,3), m35:(2,4), m36:(2,5);
+    3, 2, [m11, m12;
+          m21, m22;
+          m31, m32];
+    3, 4, [m11, m12, m13, m14;
+          m21, m22, m23, m24;
+          m31, m32, m33, m34];
+    3, 5, [m11, m12, m13, m14, m15;
+          m21, m22, m23, m24, m25;
+          m31, m32, m33, m34, m35];
+    3, 6, [m11, m12, m13, m14, m15, m16;
+          m21, m22, m23, m24, m25, m26;
+          m31, m32, m33, m34, m35, m36];
 
     /*
      * Rectangular matrices with 4 rows.
      */
-    U4, U2, m11:(0,0), m12:(0,1),
-            m21:(1,0), m22:(1,1),
-            m31:(2,0), m32:(2,1),
-            m41:(3,0), m42:(3,1);
-    U4, U3, m11:(0,0), m12:(0,1), m13:(0,2),
-            m21:(1,0), m22:(1,1), m23:(1,2),
-            m31:(2,0), m32:(2,1), m33:(2,2),
-            m41:(3,0), m42:(3,1), m43:(3,2);
-    U4, U5, m11:(0,0), m12:(0,1), m13:(0,2), m14:(0,3), m15:(0,4),
-            m21:(1,0), m22:(1,1), m23:(1,2), m24:(1,3), m25:(1,4),
-            m31:(2,0), m32:(2,1), m33:(2,2), m34:(2,3), m35:(2,4),
-            m41:(3,0), m42:(3,1), m43:(3,2), m44:(3,3), m45:(3,4);
-    U4, U6, m11:(0,0), m12:(0,1), m13:(0,2), m14:(0,3), m15:(0,4), m16:(0,5),
-            m21:(1,0), m22:(1,1), m23:(1,2), m24:(1,3), m25:(1,4), m26:(1,5),
-            m31:(2,0), m32:(2,1), m33:(2,2), m34:(2,3), m35:(2,4), m36:(2,5),
-            m41:(3,0), m42:(3,1), m43:(3,2), m44:(3,3), m45:(3,4), m46:(3,5);
+    4, 2, [m11, m12;
+          m21, m22;
+          m31, m32;
+          m41, m42];
+    4, 3, [m11, m12, m13;
+          m21, m22, m23;
+          m31, m32, m33;
+          m41, m42, m43];
+    4, 5, [m11, m12, m13, m14, m15;
+          m21, m22, m23, m24, m25;
+          m31, m32, m33, m34, m35;
+          m41, m42, m43, m44, m45];
+    4, 6, [m11, m12, m13, m14, m15, m16;
+          m21, m22, m23, m24, m25, m26;
+          m31, m32, m33, m34, m35, m36;
+          m41, m42, m43, m44, m45, m46];
 
     /*
      * Rectangular matrices with 5 rows.
      */
-    U5, U2, m11:(0,0), m12:(0,1),
-            m21:(1,0), m22:(1,1),
-            m31:(2,0), m32:(2,1),
-            m41:(3,0), m42:(3,1),
-            m51:(4,0), m52:(4,1);
-    U5, U3, m11:(0,0), m12:(0,1), m13:(0,2),
-            m21:(1,0), m22:(1,1), m23:(1,2),
-            m31:(2,0), m32:(2,1), m33:(2,2),
-            m41:(3,0), m42:(3,1), m43:(3,2),
-            m51:(4,0), m52:(4,1), m53:(4,2);
-    U5, U4, m11:(0,0), m12:(0,1), m13:(0,2), m14:(0,3),
-            m21:(1,0), m22:(1,1), m23:(1,2), m24:(1,3),
-            m31:(2,0), m32:(2,1), m33:(2,2), m34:(2,3),
-            m41:(3,0), m42:(3,1), m43:(3,2), m44:(3,3),
-            m51:(4,0), m52:(4,1), m53:(4,2), m54:(4,3);
-    U5, U6, m11:(0,0), m12:(0,1), m13:(0,2), m14:(0,3), m15:(0,4), m16:(0,5),
-            m21:(1,0), m22:(1,1), m23:(1,2), m24:(1,3), m25:(1,4), m26:(1,5),
-            m31:(2,0), m32:(2,1), m33:(2,2), m34:(2,3), m35:(2,4), m36:(2,5),
-            m41:(3,0), m42:(3,1), m43:(3,2), m44:(3,3), m45:(3,4), m46:(3,5),
-            m51:(4,0), m52:(4,1), m53:(4,2), m54:(4,3), m55:(4,4), m56:(4,5);
+    5, 2, [m11, m12;
+          m21, m22;
+          m31, m32;
+          m41, m42;
+          m51, m52];
+    5, 3, [m11, m12, m13;
+          m21, m22, m23;
+          m31, m32, m33;
+          m41, m42, m43;
+          m51, m52, m53];
+    5, 4, [m11, m12, m13, m14;
+          m21, m22, m23, m24;
+          m31, m32, m33, m34;
+          m41, m42, m43, m44;
+          m51, m52, m53, m54];
+    5, 6, [m11, m12, m13, m14, m15, m16;
+          m21, m22, m23, m24, m25, m26;
+          m31, m32, m33, m34, m35, m36;
+          m41, m42, m43, m44, m45, m46;
+          m51, m52, m53, m54, m55, m56];
 
     /*
      * Rectangular matrices with 6 rows.
      */
-    U6, U2, m11:(0,0), m12:(0,1),
-            m21:(1,0), m22:(1,1),
-            m31:(2,0), m32:(2,1),
-            m41:(3,0), m42:(3,1),
-            m51:(4,0), m52:(4,1),
-            m61:(5,0), m62:(5,1);
-    U6, U3, m11:(0,0), m12:(0,1), m13:(0,2),
-            m21:(1,0), m22:(1,1), m23:(1,2),
-            m31:(2,0), m32:(2,1), m33:(2,2),
-            m41:(3,0), m42:(3,1), m43:(3,2),
-            m51:(4,0), m52:(4,1), m53:(4,2),
-            m61:(5,0), m62:(5,1), m63:(5,2);
-    U6, U4, m11:(0,0), m12:(0,1), m13:(0,2), m14:(0,3),
-            m21:(1,0), m22:(1,1), m23:(1,2), m24:(1,3),
-            m31:(2,0), m32:(2,1), m33:(2,2), m34:(2,3),
-            m41:(3,0), m42:(3,1), m43:(3,2), m44:(3,3),
-            m51:(4,0), m52:(4,1), m53:(4,2), m54:(4,3),
-            m61:(5,0), m62:(5,1), m63:(5,2), m64:(5,3);
-    U6, U5, m11:(0,0), m12:(0,1), m13:(0,2), m14:(0,3), m15:(0,4),
-            m21:(1,0), m22:(1,1), m23:(1,2), m24:(1,3), m25:(1,4),
-            m31:(2,0), m32:(2,1), m33:(2,2), m34:(2,3), m35:(2,4),
-            m41:(3,0), m42:(3,1), m43:(3,2), m44:(3,3), m45:(3,4),
-            m51:(4,0), m52:(4,1), m53:(4,2), m54:(4,3), m55:(4,4),
-            m61:(5,0), m62:(5,1), m63:(5,2), m64:(5,3), m65:(5,4);
+    6, 2, [m11, m12;
+          m21, m22;
+          m31, m32;
+          m41, m42;
+          m51, m52;
+          m61, m62];
+    6, 3, [m11, m12, m13;
+          m21, m22, m23;
+          m31, m32, m33;
+          m41, m42, m43;
+          m51, m52, m53;
+          m61, m62, m63];
+    6, 4, [m11, m12, m13, m14;
+          m21, m22, m23, m24;
+          m31, m32, m33, m34;
+          m41, m42, m43, m44;
+          m51, m52, m53, m54;
+          m61, m62, m63, m64];
+    6, 5, [m11, m12, m13, m14, m15;
+          m21, m22, m23, m24, m25;
+          m31, m32, m33, m34, m35;
+          m41, m42, m43, m44, m45;
+          m51, m52, m53, m54, m55;
+          m61, m62, m63, m64, m65];
 
     /*
      * Row vectors 1 .. 6.
      */
-    U1, U1, x:(0,0);
-    U1, U2, x:(0,0), y:(0,1);
-    U1, U3, x:(0,0), y:(0,1), z:(0,2);
-    U1, U4, x:(0,0), y:(0,1), z:(0,2), w:(0,3);
-    U1, U5, x:(0,0), y:(0,1), z:(0,2), w:(0,3), a:(0,4);
-    U1, U6, x:(0,0), y:(0,1), z:(0,2), w:(0,3), a:(0,4), b:(0,5);
+    1, 1, [x];
+    1, 2, [x, y];
+    1, 3, [x, y, z];
+    1, 4, [x, y, z, w];
+    1, 5, [x, y, z, w, a];
+    1, 6, [x, y, z, w, a, b];
 
     /*
      * Column vectors 1 .. 6.
      */
-    U2, U1, x:(0,0), y:(1,0);
-    U3, U1, x:(0,0), y:(1,0), z:(2,0);
-    U4, U1, x:(0,0), y:(1,0), z:(2,0), w:(3,0);
-    U5, U1, x:(0,0), y:(1,0), z:(2,0), w:(3,0), a:(4,0);
-    U6, U1, x:(0,0), y:(1,0), z:(2,0), w:(3,0), a:(4,0), b:(5,0);
+    2, 1, [x; y];
+    3, 1, [x; y; z];
+    4, 1, [x; y; z; w];
+    5, 1, [x; y; z; w; a];
+    6, 1, [x; y; z; w; a; b];
 );
 
 /*
@@ -1049,34 +1073,35 @@ componentwise_constructors_impl!(
  * Axis constructors.
  *
  */
-impl<N, R: DimName> VectorN<N, R>
+impl<T, R: DimName> OVector<T, R>
 where
-    N: Scalar + Zero + One,
-    DefaultAllocator: Allocator<N, R>,
+    R: ToTypenum,
+    T: Scalar + Zero + One,
+    DefaultAllocator: Allocator<T, R>,
 {
     /// The column vector with `val` as its i-th component.
     #[inline]
-    pub fn ith(i: usize, val: N) -> Self {
+    pub fn ith(i: usize, val: T) -> Self {
         let mut res = Self::zeros();
         res[i] = val;
         res
     }
 
-    /// The column unit vector with `N::one()` as its i-th component.
+    /// The column unit vector with `T::one()` as its i-th component.
     #[inline]
     pub fn ith_axis(i: usize) -> Unit<Self> {
-        Unit::new_unchecked(Self::ith(i, N::one()))
+        Unit::new_unchecked(Self::ith(i, T::one()))
     }
 
     /// The column vector with a 1 as its first component, and zero elsewhere.
     #[inline]
     pub fn x() -> Self
     where
-        R::Value: Cmp<typenum::U0, Output = Greater>,
+        R::Typenum: Cmp<typenum::U0, Output = Greater>,
     {
         let mut res = Self::zeros();
         unsafe {
-            *res.vget_unchecked_mut(0) = N::one();
+            *res.vget_unchecked_mut(0) = T::one();
         }
 
         res
@@ -1086,11 +1111,11 @@ where
     #[inline]
     pub fn y() -> Self
     where
-        R::Value: Cmp<typenum::U1, Output = Greater>,
+        R::Typenum: Cmp<typenum::U1, Output = Greater>,
     {
         let mut res = Self::zeros();
         unsafe {
-            *res.vget_unchecked_mut(1) = N::one();
+            *res.vget_unchecked_mut(1) = T::one();
         }
 
         res
@@ -1100,11 +1125,11 @@ where
     #[inline]
     pub fn z() -> Self
     where
-        R::Value: Cmp<typenum::U2, Output = Greater>,
+        R::Typenum: Cmp<typenum::U2, Output = Greater>,
     {
         let mut res = Self::zeros();
         unsafe {
-            *res.vget_unchecked_mut(2) = N::one();
+            *res.vget_unchecked_mut(2) = T::one();
         }
 
         res
@@ -1114,11 +1139,11 @@ where
     #[inline]
     pub fn w() -> Self
     where
-        R::Value: Cmp<typenum::U3, Output = Greater>,
+        R::Typenum: Cmp<typenum::U3, Output = Greater>,
     {
         let mut res = Self::zeros();
         unsafe {
-            *res.vget_unchecked_mut(3) = N::one();
+            *res.vget_unchecked_mut(3) = T::one();
         }
 
         res
@@ -1128,11 +1153,11 @@ where
     #[inline]
     pub fn a() -> Self
     where
-        R::Value: Cmp<typenum::U4, Output = Greater>,
+        R::Typenum: Cmp<typenum::U4, Output = Greater>,
     {
         let mut res = Self::zeros();
         unsafe {
-            *res.vget_unchecked_mut(4) = N::one();
+            *res.vget_unchecked_mut(4) = T::one();
         }
 
         res
@@ -1142,11 +1167,11 @@ where
     #[inline]
     pub fn b() -> Self
     where
-        R::Value: Cmp<typenum::U5, Output = Greater>,
+        R::Typenum: Cmp<typenum::U5, Output = Greater>,
     {
         let mut res = Self::zeros();
         unsafe {
-            *res.vget_unchecked_mut(5) = N::one();
+            *res.vget_unchecked_mut(5) = T::one();
         }
 
         res
@@ -1156,7 +1181,7 @@ where
     #[inline]
     pub fn x_axis() -> Unit<Self>
     where
-        R::Value: Cmp<typenum::U0, Output = Greater>,
+        R::Typenum: Cmp<typenum::U0, Output = Greater>,
     {
         Unit::new_unchecked(Self::x())
     }
@@ -1165,7 +1190,7 @@ where
     #[inline]
     pub fn y_axis() -> Unit<Self>
     where
-        R::Value: Cmp<typenum::U1, Output = Greater>,
+        R::Typenum: Cmp<typenum::U1, Output = Greater>,
     {
         Unit::new_unchecked(Self::y())
     }
@@ -1174,7 +1199,7 @@ where
     #[inline]
     pub fn z_axis() -> Unit<Self>
     where
-        R::Value: Cmp<typenum::U2, Output = Greater>,
+        R::Typenum: Cmp<typenum::U2, Output = Greater>,
     {
         Unit::new_unchecked(Self::z())
     }
@@ -1183,7 +1208,7 @@ where
     #[inline]
     pub fn w_axis() -> Unit<Self>
     where
-        R::Value: Cmp<typenum::U3, Output = Greater>,
+        R::Typenum: Cmp<typenum::U3, Output = Greater>,
     {
         Unit::new_unchecked(Self::w())
     }
@@ -1192,7 +1217,7 @@ where
     #[inline]
     pub fn a_axis() -> Unit<Self>
     where
-        R::Value: Cmp<typenum::U4, Output = Greater>,
+        R::Typenum: Cmp<typenum::U4, Output = Greater>,
     {
         Unit::new_unchecked(Self::a())
     }
@@ -1201,7 +1226,7 @@ where
     #[inline]
     pub fn b_axis() -> Unit<Self>
     where
-        R::Value: Cmp<typenum::U5, Output = Greater>,
+        R::Typenum: Cmp<typenum::U5, Output = Greater>,
     {
         Unit::new_unchecked(Self::b())
     }
diff --git a/src/base/construction_slice.rs b/src/base/construction_slice.rs
index 1b6d7b00..43f3692b 100644
--- a/src/base/construction_slice.rs
+++ b/src/base/construction_slice.rs
@@ -1,12 +1,12 @@
-use crate::base::dimension::{Dim, DimName, Dynamic, U1};
+use crate::base::dimension::{Const, Dim, DimName, Dynamic};
 use crate::base::matrix_slice::{SliceStorage, SliceStorageMut};
-use crate::base::{MatrixSliceMN, MatrixSliceMutMN, Scalar};
+use crate::base::{MatrixSlice, MatrixSliceMutMN, Scalar};
 
 use num_rational::Ratio;
 
 /// # Creating matrix slices from `&[T]`
-impl<'a, N: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim>
-    MatrixSliceMN<'a, N, R, C, RStride, CStride>
+impl<'a, T: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim>
+    MatrixSlice<'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.
     ///
@@ -14,7 +14,7 @@ impl<'a, N: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim>
     /// The generic types `R`, `C`, `RStride`, `CStride` can either be type-level integers or integers wrapped with `Dynamic::new()`.
     #[inline]
     pub unsafe fn from_slice_with_strides_generic_unchecked(
-        data: &'a [N],
+        data: &'a [T],
         start: usize,
         nrows: R,
         ncols: C,
@@ -35,7 +35,7 @@ impl<'a, N: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim>
     /// The generic types `R`, `C`, `RStride`, `CStride` can either be type-level integers or integers wrapped with `Dynamic::new()`.
     #[inline]
     pub fn from_slice_with_strides_generic(
-        data: &'a [N],
+        data: &'a [T],
         nrows: R,
         ncols: C,
         rstride: RStride,
@@ -56,19 +56,21 @@ impl<'a, N: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim>
     }
 }
 
-impl<'a, N: Scalar, R: Dim, C: Dim> MatrixSliceMN<'a, N, R, C> {
+impl<'a, T: Scalar, R: Dim, C: Dim> MatrixSlice<'a, T, R, C> {
     /// Creates, without bound-checking, a matrix slice from an array and with dimensions specified by generic types instances.
     ///
     /// 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()`.
     #[inline]
     pub unsafe fn from_slice_generic_unchecked(
-        data: &'a [N],
+        data: &'a [T],
         start: usize,
         nrows: R,
         ncols: C,
     ) -> Self {
-        Self::from_slice_with_strides_generic_unchecked(data, start, nrows, ncols, U1, nrows)
+        Self::from_slice_with_strides_generic_unchecked(
+            data, start, nrows, ncols, Const::<1>, nrows,
+        )
     }
 
     /// Creates a matrix slice from an array and with dimensions and strides specified by generic types instances.
@@ -76,41 +78,41 @@ impl<'a, N: Scalar, R: Dim, C: Dim> MatrixSliceMN<'a, N, R, C> {
     /// 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()`.
     #[inline]
-    pub fn from_slice_generic(data: &'a [N], nrows: R, ncols: C) -> Self {
-        Self::from_slice_with_strides_generic(data, nrows, ncols, U1, nrows)
+    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)
     }
 }
 
 macro_rules! impl_constructors(
     ($($Dims: ty),*; $(=> $DimIdent: ident: $DimBound: ident),*; $($gargs: expr),*; $($args: ident),*) => {
-        impl<'a, N: Scalar, $($DimIdent: $DimBound),*> MatrixSliceMN<'a, N, $($Dims),*> {
+        impl<'a, T: Scalar, $($DimIdent: $DimBound),*> MatrixSlice<'a, T, $($Dims),*> {
             /// Creates a new matrix slice from the given data array.
             ///
             /// Panics if `data` does not contain enough elements.
             #[inline]
-            pub fn from_slice(data: &'a [N], $($args: usize),*) -> Self {
+            pub fn from_slice(data: &'a [T], $($args: usize),*) -> Self {
                 Self::from_slice_generic(data, $($gargs),*)
             }
 
             /// Creates, without bound checking, a new matrix slice from the given data array.
             #[inline]
-            pub unsafe fn from_slice_unchecked(data: &'a [N], start: usize, $($args: usize),*) -> Self {
+            pub unsafe fn from_slice_unchecked(data: &'a [T], start: usize, $($args: usize),*) -> Self {
                 Self::from_slice_generic_unchecked(data, start, $($gargs),*)
             }
         }
 
-        impl<'a, N: Scalar, $($DimIdent: $DimBound, )*> MatrixSliceMN<'a, N, $($Dims,)* Dynamic, Dynamic> {
+        impl<'a, T: Scalar, $($DimIdent: $DimBound, )*> MatrixSlice<'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.
             #[inline]
-            pub fn from_slice_with_strides(data: &'a [N], $($args: usize,)* rstride: usize, cstride: usize) -> Self {
+            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))
             }
 
             /// Creates, without bound checking, a new matrix slice with the specified strides from the given data array.
             #[inline]
-            pub unsafe fn from_slice_with_strides_unchecked(data: &'a [N], start: usize, $($args: usize,)* rstride: usize, cstride: usize) -> Self {
+            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))
             }
         }
@@ -118,8 +120,8 @@ macro_rules! impl_constructors(
 );
 
 // TODO: this is not very pretty. We could find a better call syntax.
-impl_constructors!(R, C;                         // Arguments for Matrix<N, ..., S>
-=> R: DimName, => C: DimName; // Type parameters for impl<N, ..., S>
+impl_constructors!(R, C;                         // Arguments for Matrix<T, ..., S>
+=> R: DimName, => C: DimName; // Type parameters for impl<T, ..., S>
 R::name(), C::name();         // Arguments for `_generic` constructors.
 ); // Arguments for non-generic constructors.
 
@@ -139,8 +141,8 @@ impl_constructors!(Dynamic, Dynamic;
                    nrows, ncols);
 
 /// # Creating mutable matrix slices from `&mut [T]`
-impl<'a, N: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim>
-    MatrixSliceMutMN<'a, N, R, C, RStride, CStride>
+impl<'a, T: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim>
+    MatrixSliceMutMN<'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.
     ///
@@ -148,7 +150,7 @@ impl<'a, N: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim>
     /// The generic types `R`, `C`, `RStride`, `CStride` can either be type-level integers or integers wrapped with `Dynamic::new()`.
     #[inline]
     pub unsafe fn from_slice_with_strides_generic_unchecked(
-        data: &'a mut [N],
+        data: &'a mut [T],
         start: usize,
         nrows: R,
         ncols: C,
@@ -169,7 +171,7 @@ impl<'a, N: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim>
     /// The generic types `R`, `C`, `RStride`, `CStride` can either be type-level integers or integers wrapped with `Dynamic::new()`.
     #[inline]
     pub fn from_slice_with_strides_generic(
-        data: &'a mut [N],
+        data: &'a mut [T],
         nrows: R,
         ncols: C,
         rstride: RStride,
@@ -212,19 +214,21 @@ impl<'a, N: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim>
     }
 }
 
-impl<'a, N: Scalar, R: Dim, C: Dim> MatrixSliceMutMN<'a, N, R, C> {
+impl<'a, T: Scalar, R: Dim, C: Dim> MatrixSliceMutMN<'a, T, R, C> {
     /// Creates, without bound-checking, a mutable matrix slice from an array and with dimensions specified by generic types instances.
     ///
     /// 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()`.
     #[inline]
     pub unsafe fn from_slice_generic_unchecked(
-        data: &'a mut [N],
+        data: &'a mut [T],
         start: usize,
         nrows: R,
         ncols: C,
     ) -> Self {
-        Self::from_slice_with_strides_generic_unchecked(data, start, nrows, ncols, U1, nrows)
+        Self::from_slice_with_strides_generic_unchecked(
+            data, start, nrows, ncols, Const::<1>, nrows,
+        )
     }
 
     /// Creates a mutable matrix slice from an array and with dimensions and strides specified by generic types instances.
@@ -232,42 +236,42 @@ impl<'a, N: Scalar, R: Dim, C: Dim> MatrixSliceMutMN<'a, N, R, C> {
     /// 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()`.
     #[inline]
-    pub fn from_slice_generic(data: &'a mut [N], nrows: R, ncols: C) -> Self {
-        Self::from_slice_with_strides_generic(data, nrows, ncols, U1, nrows)
+    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)
     }
 }
 
 macro_rules! impl_constructors_mut(
     ($($Dims: ty),*; $(=> $DimIdent: ident: $DimBound: ident),*; $($gargs: expr),*; $($args: ident),*) => {
-        impl<'a, N: Scalar, $($DimIdent: $DimBound),*> MatrixSliceMutMN<'a, N, $($Dims),*> {
+        impl<'a, T: Scalar, $($DimIdent: $DimBound),*> MatrixSliceMutMN<'a, T, $($Dims),*> {
             /// Creates a new mutable matrix slice from the given data array.
             ///
             /// Panics if `data` does not contain enough elements.
             #[inline]
-            pub fn from_slice(data: &'a mut [N], $($args: usize),*) -> Self {
+            pub fn from_slice(data: &'a mut [T], $($args: usize),*) -> Self {
                 Self::from_slice_generic(data, $($gargs),*)
             }
 
             /// Creates, without bound checking, a new mutable matrix slice from the given data array.
             #[inline]
-            pub unsafe fn from_slice_unchecked(data: &'a mut [N], start: usize, $($args: usize),*) -> Self {
+            pub unsafe fn from_slice_unchecked(data: &'a mut [T], start: usize, $($args: usize),*) -> Self {
                 Self::from_slice_generic_unchecked(data, start, $($gargs),*)
             }
         }
 
-        impl<'a, N: Scalar, $($DimIdent: $DimBound, )*> MatrixSliceMutMN<'a, N, $($Dims,)* Dynamic, Dynamic> {
+        impl<'a, T: Scalar, $($DimIdent: $DimBound, )*> MatrixSliceMutMN<'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.
             #[inline]
-            pub fn from_slice_with_strides_mut(data: &'a mut [N], $($args: usize,)* rstride: usize, cstride: usize) -> Self {
+            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))
             }
 
             /// Creates, without bound checking, a new mutable matrix slice with the specified strides from the given data array.
             #[inline]
-            pub unsafe fn from_slice_with_strides_unchecked(data: &'a mut [N], start: usize, $($args: usize,)* rstride: usize, cstride: usize) -> Self {
+            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))
             }
@@ -276,8 +280,8 @@ macro_rules! impl_constructors_mut(
 );
 
 // TODO: this is not very pretty. We could find a better call syntax.
-impl_constructors_mut!(R, C;                         // Arguments for Matrix<N, ..., S>
-=> R: DimName, => C: DimName; // Type parameters for impl<N, ..., S>
+impl_constructors_mut!(R, C;                         // Arguments for Matrix<T, ..., S>
+=> R: DimName, => C: DimName; // Type parameters for impl<T, ..., S>
 R::name(), C::name();         // Arguments for `_generic` constructors.
 ); // Arguments for non-generic constructors.
 
diff --git a/src/base/conversion.rs b/src/base/conversion.rs
index 92d3be15..24a088a2 100644
--- a/src/base/conversion.rs
+++ b/src/base/conversion.rs
@@ -5,10 +5,6 @@ use std::convert::{AsMut, AsRef, From, Into};
 use std::mem;
 use std::ptr;
 
-use generic_array::ArrayLength;
-use std::ops::Mul;
-use typenum::Prod;
-
 use simba::simd::{PrimitiveSimdValue, SimdValue};
 
 use crate::base::allocator::{Allocator, SameShapeAllocator};
@@ -16,13 +12,13 @@ use crate::base::constraint::{SameNumberOfColumns, SameNumberOfRows, ShapeConstr
 #[cfg(any(feature = "std", feature = "alloc"))]
 use crate::base::dimension::Dynamic;
 use crate::base::dimension::{
-    Dim, DimName, U1, U10, U11, U12, U13, U14, U15, U16, U2, U3, U4, U5, U6, U7, U8, U9,
+    Const, Dim, DimName, U1, U10, U11, U12, U13, U14, U15, U16, U2, U3, U4, U5, U6, U7, U8, U9,
 };
 use crate::base::iter::{MatrixIter, MatrixIterMut};
 use crate::base::storage::{ContiguousStorage, ContiguousStorageMut, Storage, StorageMut};
 use crate::base::{
-    ArrayStorage, DVectorSlice, DVectorSliceMut, DefaultAllocator, Matrix, MatrixMN, MatrixSlice,
-    MatrixSliceMut, Scalar,
+    ArrayStorage, DVectorSlice, DVectorSliceMut, DefaultAllocator, Matrix, MatrixSlice,
+    MatrixSliceMut, OMatrix, Scalar,
 };
 #[cfg(any(feature = "std", feature = "alloc"))]
 use crate::base::{DVector, VecStorage};
@@ -30,30 +26,30 @@ use crate::base::{SliceStorage, SliceStorageMut};
 use crate::constraint::DimEq;
 
 // TODO: too bad this won't work allo slice conversions.
-impl<N1, N2, R1, C1, R2, C2> SubsetOf<MatrixMN<N2, R2, C2>> for MatrixMN<N1, R1, C1>
+impl<T1, T2, R1, C1, R2, C2> SubsetOf<OMatrix<T2, R2, C2>> for OMatrix<T1, R1, C1>
 where
     R1: Dim,
     C1: Dim,
     R2: Dim,
     C2: Dim,
-    N1: Scalar,
-    N2: Scalar + SupersetOf<N1>,
+    T1: Scalar,
+    T2: Scalar + SupersetOf<T1>,
     DefaultAllocator:
-        Allocator<N2, R2, C2> + Allocator<N1, R1, C1> + SameShapeAllocator<N1, R1, C1, R2, C2>,
+        Allocator<T2, R2, C2> + Allocator<T1, R1, C1> + SameShapeAllocator<T1, R1, C1, R2, C2>,
     ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
 {
     #[inline]
-    fn to_superset(&self) -> MatrixMN<N2, R2, C2> {
+    fn to_superset(&self) -> OMatrix<T2, R2, C2> {
         let (nrows, ncols) = self.shape();
         let nrows2 = R2::from_usize(nrows);
         let ncols2 = C2::from_usize(ncols);
 
-        let mut res: MatrixMN<N2, R2, C2> =
+        let mut res: OMatrix<T2, R2, C2> =
             unsafe { crate::unimplemented_or_uninitialized_generic!(nrows2, ncols2) };
         for i in 0..nrows {
             for j in 0..ncols {
                 unsafe {
-                    *res.get_unchecked_mut((i, j)) = N2::from_subset(self.get_unchecked((i, j)))
+                    *res.get_unchecked_mut((i, j)) = T2::from_subset(self.get_unchecked((i, j)))
                 }
             }
         }
@@ -62,12 +58,12 @@ where
     }
 
     #[inline]
-    fn is_in_subset(m: &MatrixMN<N2, R2, C2>) -> bool {
+    fn is_in_subset(m: &OMatrix<T2, R2, C2>) -> bool {
         m.iter().all(|e| e.is_in_subset())
     }
 
     #[inline]
-    fn from_superset_unchecked(m: &MatrixMN<N2, R2, C2>) -> Self {
+    fn from_superset_unchecked(m: &OMatrix<T2, R2, C2>) -> Self {
         let (nrows2, ncols2) = m.shape();
         let nrows = R1::from_usize(nrows2);
         let ncols = C1::from_usize(ncols2);
@@ -85,9 +81,9 @@ where
     }
 }
 
-impl<'a, N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> IntoIterator for &'a Matrix<N, R, C, S> {
-    type Item = &'a N;
-    type IntoIter = MatrixIter<'a, N, R, C, S>;
+impl<'a, T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> IntoIterator for &'a Matrix<T, R, C, S> {
+    type Item = &'a T;
+    type IntoIter = MatrixIter<'a, T, R, C, S>;
 
     #[inline]
     fn into_iter(self) -> Self::IntoIter {
@@ -95,11 +91,11 @@ impl<'a, N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> IntoIterator for &'a Ma
     }
 }
 
-impl<'a, N: Scalar, R: Dim, C: Dim, S: StorageMut<N, R, C>> IntoIterator
-    for &'a mut Matrix<N, R, C, S>
+impl<'a, T: Scalar, R: Dim, C: Dim, S: StorageMut<T, R, C>> IntoIterator
+    for &'a mut Matrix<T, R, C, S>
 {
-    type Item = &'a mut N;
-    type IntoIter = MatrixIterMut<'a, N, R, C, S>;
+    type Item = &'a mut T;
+    type IntoIter = MatrixIterMut<'a, T, R, C, S>;
 
     #[inline]
     fn into_iter(self) -> Self::IntoIter {
@@ -109,11 +105,11 @@ impl<'a, N: Scalar, R: Dim, C: Dim, S: StorageMut<N, R, C>> IntoIterator
 
 macro_rules! impl_from_into_asref_1D(
     ($(($NRows: ident, $NCols: ident) => $SZ: expr);* $(;)*) => {$(
-        impl<N> From<[N; $SZ]> for MatrixMN<N, $NRows, $NCols>
-        where N: Scalar,
-              DefaultAllocator: Allocator<N, $NRows, $NCols> {
+        impl<T> From<[T; $SZ]> for OMatrix<T, $NRows, $NCols>
+        where T: Scalar,
+              DefaultAllocator: Allocator<T, $NRows, $NCols> {
             #[inline]
-            fn from(arr: [N; $SZ]) -> Self {
+            fn from(arr: [T; $SZ]) -> Self {
                 unsafe {
                     let mut res = Self::new_uninitialized();
                     ptr::copy_nonoverlapping(&arr[0], (*res.as_mut_ptr()).data.ptr_mut(), $SZ);
@@ -123,35 +119,35 @@ macro_rules! impl_from_into_asref_1D(
             }
         }
 
-        impl<N, S> Into<[N; $SZ]> for Matrix<N, $NRows, $NCols, S>
-        where N: Scalar,
-              S: ContiguousStorage<N, $NRows, $NCols> {
+        impl<T, S> Into<[T; $SZ]> for Matrix<T, $NRows, $NCols, S>
+        where T: Scalar,
+              S: ContiguousStorage<T, $NRows, $NCols> {
             #[inline]
-            fn into(self) -> [N; $SZ] {
-                let mut res = mem::MaybeUninit::<[N; $SZ]>::uninit();
+            fn into(self) -> [T; $SZ] {
+                let mut res = mem::MaybeUninit::<[T; $SZ]>::uninit();
 
-                unsafe { ptr::copy_nonoverlapping(self.data.ptr(), res.as_mut_ptr() as *mut N, $SZ) };
+                unsafe { ptr::copy_nonoverlapping(self.data.ptr(), res.as_mut_ptr() as *mut T, $SZ) };
 
                 unsafe { res.assume_init() }
             }
         }
 
-        impl<N, S> AsRef<[N; $SZ]> for Matrix<N, $NRows, $NCols, S>
-        where N: Scalar,
-              S: ContiguousStorage<N, $NRows, $NCols> {
+        impl<T, S> AsRef<[T; $SZ]> for Matrix<T, $NRows, $NCols, S>
+        where T: Scalar,
+              S: ContiguousStorage<T, $NRows, $NCols> {
             #[inline]
-            fn as_ref(&self) -> &[N; $SZ] {
+            fn as_ref(&self) -> &[T; $SZ] {
                 unsafe {
                     mem::transmute(self.data.ptr())
                 }
             }
         }
 
-        impl<N, S> AsMut<[N; $SZ]> for Matrix<N, $NRows, $NCols, S>
-        where N: Scalar,
-              S: ContiguousStorageMut<N, $NRows, $NCols> {
+        impl<T, S> AsMut<[T; $SZ]> for Matrix<T, $NRows, $NCols, S>
+        where T: Scalar,
+              S: ContiguousStorageMut<T, $NRows, $NCols> {
             #[inline]
-            fn as_mut(&mut self) -> &mut [N; $SZ] {
+            fn as_mut(&mut self) -> &mut [T; $SZ] {
                 unsafe {
                     mem::transmute(self.data.ptr_mut())
                 }
@@ -177,10 +173,10 @@ impl_from_into_asref_1D!(
 
 macro_rules! impl_from_into_asref_2D(
     ($(($NRows: ty, $NCols: ty) => ($SZRows: expr, $SZCols: expr));* $(;)*) => {$(
-        impl<N: Scalar> From<[[N; $SZRows]; $SZCols]> for MatrixMN<N, $NRows, $NCols>
-        where DefaultAllocator: Allocator<N, $NRows, $NCols> {
+        impl<T: Scalar> From<[[T; $SZRows]; $SZCols]> for OMatrix<T, $NRows, $NCols>
+        where DefaultAllocator: Allocator<T, $NRows, $NCols> {
             #[inline]
-            fn from(arr: [[N; $SZRows]; $SZCols]) -> Self {
+            fn from(arr: [[T; $SZRows]; $SZCols]) -> Self {
                 unsafe {
                     let mut res = Self::new_uninitialized();
                     ptr::copy_nonoverlapping(&arr[0][0], (*res.as_mut_ptr()).data.ptr_mut(), $SZRows * $SZCols);
@@ -190,32 +186,32 @@ macro_rules! impl_from_into_asref_2D(
             }
         }
 
-        impl<N: Scalar, S> Into<[[N; $SZRows]; $SZCols]> for Matrix<N, $NRows, $NCols, S>
-        where S: ContiguousStorage<N, $NRows, $NCols> {
+        impl<T: Scalar, S> Into<[[T; $SZRows]; $SZCols]> for Matrix<T, $NRows, $NCols, S>
+        where S: ContiguousStorage<T, $NRows, $NCols> {
             #[inline]
-            fn into(self) -> [[N; $SZRows]; $SZCols] {
-                let mut res = mem::MaybeUninit::<[[N; $SZRows]; $SZCols]>::uninit();
+            fn into(self) -> [[T; $SZRows]; $SZCols] {
+                let mut res = mem::MaybeUninit::<[[T; $SZRows]; $SZCols]>::uninit();
 
-                unsafe { ptr::copy_nonoverlapping(self.data.ptr(), res.as_mut_ptr() as *mut N, $SZRows * $SZCols) };
+                unsafe { ptr::copy_nonoverlapping(self.data.ptr(), res.as_mut_ptr() as *mut T, $SZRows * $SZCols) };
 
                 unsafe { res.assume_init() }
             }
         }
 
-        impl<N: Scalar, S> AsRef<[[N; $SZRows]; $SZCols]> for Matrix<N, $NRows, $NCols, S>
-        where S: ContiguousStorage<N, $NRows, $NCols> {
+        impl<T: Scalar, S> AsRef<[[T; $SZRows]; $SZCols]> for Matrix<T, $NRows, $NCols, S>
+        where S: ContiguousStorage<T, $NRows, $NCols> {
             #[inline]
-            fn as_ref(&self) -> &[[N; $SZRows]; $SZCols] {
+            fn as_ref(&self) -> &[[T; $SZRows]; $SZCols] {
                 unsafe {
                     mem::transmute(self.data.ptr())
                 }
             }
         }
 
-        impl<N: Scalar, S> AsMut<[[N; $SZRows]; $SZCols]> for Matrix<N, $NRows, $NCols, S>
-        where S: ContiguousStorageMut<N, $NRows, $NCols> {
+        impl<T: Scalar, S> AsMut<[[T; $SZRows]; $SZCols]> for Matrix<T, $NRows, $NCols, S>
+        where S: ContiguousStorageMut<T, $NRows, $NCols> {
             #[inline]
-            fn as_mut(&mut self) -> &mut [[N; $SZRows]; $SZCols] {
+            fn as_mut(&mut self) -> &mut [[T; $SZRows]; $SZCols] {
                 unsafe {
                     mem::transmute(self.data.ptr_mut())
                 }
@@ -233,111 +229,105 @@ impl_from_into_asref_2D!(
     (U6, U2) => (6, 2); (U6, U3) => (6, 3); (U6, U4) => (6, 4); (U6, U5) => (6, 5); (U6, U6) => (6, 6);
 );
 
-impl<'a, N, R, C, RStride, CStride> From<MatrixSlice<'a, N, R, C, RStride, CStride>>
-    for Matrix<N, R, C, ArrayStorage<N, R, C>>
+impl<'a, T, RStride, CStride, const R: usize, const C: usize>
+    From<MatrixSlice<'a, T, Const<R>, Const<C>, RStride, CStride>>
+    for Matrix<T, Const<R>, Const<C>, ArrayStorage<T, R, C>>
 where
-    N: Scalar,
-    R: DimName,
-    C: DimName,
+    T: Scalar,
     RStride: Dim,
     CStride: Dim,
-    R::Value: Mul<C::Value>,
-    Prod<R::Value, C::Value>: ArrayLength<N>,
 {
-    fn from(matrix_slice: MatrixSlice<'a, N, R, C, RStride, CStride>) -> Self {
+    fn from(matrix_slice: MatrixSlice<'a, T, Const<R>, Const<C>, RStride, CStride>) -> Self {
         matrix_slice.into_owned()
     }
 }
 
 #[cfg(any(feature = "std", feature = "alloc"))]
-impl<'a, N, C, RStride, CStride> From<MatrixSlice<'a, N, Dynamic, C, RStride, CStride>>
-    for Matrix<N, Dynamic, C, VecStorage<N, Dynamic, C>>
+impl<'a, T, C, RStride, CStride> From<MatrixSlice<'a, T, Dynamic, C, RStride, CStride>>
+    for Matrix<T, Dynamic, C, VecStorage<T, Dynamic, C>>
 where
-    N: Scalar,
+    T: Scalar,
     C: Dim,
     RStride: Dim,
     CStride: Dim,
 {
-    fn from(matrix_slice: MatrixSlice<'a, N, Dynamic, C, RStride, CStride>) -> Self {
+    fn from(matrix_slice: MatrixSlice<'a, T, Dynamic, C, RStride, CStride>) -> Self {
         matrix_slice.into_owned()
     }
 }
 
 #[cfg(any(feature = "std", feature = "alloc"))]
-impl<'a, N, R, RStride, CStride> From<MatrixSlice<'a, N, R, Dynamic, RStride, CStride>>
-    for Matrix<N, R, Dynamic, VecStorage<N, R, Dynamic>>
+impl<'a, T, R, RStride, CStride> From<MatrixSlice<'a, T, R, Dynamic, RStride, CStride>>
+    for Matrix<T, R, Dynamic, VecStorage<T, R, Dynamic>>
 where
-    N: Scalar,
+    T: Scalar,
     R: DimName,
     RStride: Dim,
     CStride: Dim,
 {
-    fn from(matrix_slice: MatrixSlice<'a, N, R, Dynamic, RStride, CStride>) -> Self {
+    fn from(matrix_slice: MatrixSlice<'a, T, R, Dynamic, RStride, CStride>) -> Self {
         matrix_slice.into_owned()
     }
 }
 
-impl<'a, N, R, C, RStride, CStride> From<MatrixSliceMut<'a, N, R, C, RStride, CStride>>
-    for Matrix<N, R, C, ArrayStorage<N, R, C>>
+impl<'a, T, RStride, CStride, const R: usize, const C: usize>
+    From<MatrixSliceMut<'a, T, Const<R>, Const<C>, RStride, CStride>>
+    for Matrix<T, Const<R>, Const<C>, ArrayStorage<T, R, C>>
 where
-    N: Scalar,
-    R: DimName,
-    C: DimName,
+    T: Scalar,
     RStride: Dim,
     CStride: Dim,
-    R::Value: Mul<C::Value>,
-    Prod<R::Value, C::Value>: ArrayLength<N>,
 {
-    fn from(matrix_slice: MatrixSliceMut<'a, N, R, C, RStride, CStride>) -> Self {
+    fn from(matrix_slice: MatrixSliceMut<'a, T, Const<R>, Const<C>, RStride, CStride>) -> Self {
         matrix_slice.into_owned()
     }
 }
 
 #[cfg(any(feature = "std", feature = "alloc"))]
-impl<'a, N, C, RStride, CStride> From<MatrixSliceMut<'a, N, Dynamic, C, RStride, CStride>>
-    for Matrix<N, Dynamic, C, VecStorage<N, Dynamic, C>>
+impl<'a, T, C, RStride, CStride> From<MatrixSliceMut<'a, T, Dynamic, C, RStride, CStride>>
+    for Matrix<T, Dynamic, C, VecStorage<T, Dynamic, C>>
 where
-    N: Scalar,
+    T: Scalar,
     C: Dim,
     RStride: Dim,
     CStride: Dim,
 {
-    fn from(matrix_slice: MatrixSliceMut<'a, N, Dynamic, C, RStride, CStride>) -> Self {
+    fn from(matrix_slice: MatrixSliceMut<'a, T, Dynamic, C, RStride, CStride>) -> Self {
         matrix_slice.into_owned()
     }
 }
 
 #[cfg(any(feature = "std", feature = "alloc"))]
-impl<'a, N, R, RStride, CStride> From<MatrixSliceMut<'a, N, R, Dynamic, RStride, CStride>>
-    for Matrix<N, R, Dynamic, VecStorage<N, R, Dynamic>>
+impl<'a, T, R, RStride, CStride> From<MatrixSliceMut<'a, T, R, Dynamic, RStride, CStride>>
+    for Matrix<T, R, Dynamic, VecStorage<T, R, Dynamic>>
 where
-    N: Scalar,
+    T: Scalar,
     R: DimName,
     RStride: Dim,
     CStride: Dim,
 {
-    fn from(matrix_slice: MatrixSliceMut<'a, N, R, Dynamic, RStride, CStride>) -> Self {
+    fn from(matrix_slice: MatrixSliceMut<'a, T, R, Dynamic, RStride, CStride>) -> Self {
         matrix_slice.into_owned()
     }
 }
 
-impl<'a, N, R, C, RSlice, CSlice, RStride, CStride, S> From<&'a Matrix<N, R, C, S>>
-    for MatrixSlice<'a, N, RSlice, CSlice, RStride, CStride>
+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>
 where
-    N: Scalar,
+    T: Scalar,
     R: Dim,
     C: Dim,
     RSlice: Dim,
     CSlice: Dim,
     RStride: Dim,
     CStride: Dim,
-    S: Storage<N, R, C>,
+    S: Storage<T, R, C>,
     ShapeConstraint: DimEq<R, RSlice>
         + DimEq<C, CSlice>
         + DimEq<RStride, S::RStride>
         + DimEq<CStride, S::CStride>,
 {
-    fn from(m: &'a Matrix<N, R, C, S>) -> Self {
+    fn from(m: &'a Matrix<T, R, C, S>) -> Self {
         let (row, col) = m.data.shape();
         let row_slice = RSlice::from_usize(row.value());
         let col_slice = CSlice::from_usize(col.value());
@@ -358,23 +348,23 @@ where
     }
 }
 
-impl<'a, N, R, C, RSlice, CSlice, RStride, CStride, S> From<&'a mut Matrix<N, R, C, S>>
-    for MatrixSlice<'a, N, RSlice, CSlice, RStride, CStride>
+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>
 where
-    N: Scalar,
+    T: Scalar,
     R: Dim,
     C: Dim,
     RSlice: Dim,
     CSlice: Dim,
     RStride: Dim,
     CStride: Dim,
-    S: Storage<N, R, C>,
+    S: Storage<T, R, C>,
     ShapeConstraint: DimEq<R, RSlice>
         + DimEq<C, CSlice>
         + DimEq<RStride, S::RStride>
         + DimEq<CStride, S::CStride>,
 {
-    fn from(m: &'a mut Matrix<N, R, C, S>) -> Self {
+    fn from(m: &'a mut Matrix<T, R, C, S>) -> Self {
         let (row, col) = m.data.shape();
         let row_slice = RSlice::from_usize(row.value());
         let col_slice = CSlice::from_usize(col.value());
@@ -395,23 +385,23 @@ where
     }
 }
 
-impl<'a, N, R, C, RSlice, CSlice, RStride, CStride, S> From<&'a mut Matrix<N, R, C, S>>
-    for MatrixSliceMut<'a, N, RSlice, CSlice, RStride, CStride>
+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>
 where
-    N: Scalar,
+    T: Scalar,
     R: Dim,
     C: Dim,
     RSlice: Dim,
     CSlice: Dim,
     RStride: Dim,
     CStride: Dim,
-    S: StorageMut<N, R, C>,
+    S: StorageMut<T, R, C>,
     ShapeConstraint: DimEq<R, RSlice>
         + DimEq<C, CSlice>
         + DimEq<RStride, S::RStride>
         + DimEq<CStride, S::CStride>,
 {
-    fn from(m: &'a mut Matrix<N, R, C, S>) -> Self {
+    fn from(m: &'a mut Matrix<T, R, C, S>) -> Self {
         let (row, col) = m.data.shape();
         let row_slice = RSlice::from_usize(row.value());
         let col_slice = CSlice::from_usize(col.value());
@@ -433,54 +423,54 @@ where
 }
 
 #[cfg(any(feature = "std", feature = "alloc"))]
-impl<'a, N: Scalar> From<Vec<N>> for DVector<N> {
+impl<'a, T: Scalar> From<Vec<T>> for DVector<T> {
     #[inline]
-    fn from(vec: Vec<N>) -> Self {
+    fn from(vec: Vec<T>) -> Self {
         Self::from_vec(vec)
     }
 }
 
-impl<'a, N: Scalar + Copy, R: Dim, C: Dim, S: ContiguousStorage<N, R, C>> Into<&'a [N]>
-    for &'a Matrix<N, R, C, S>
+impl<'a, T: Scalar + Copy, R: Dim, C: Dim, S: ContiguousStorage<T, R, C>> Into<&'a [T]>
+    for &'a Matrix<T, R, C, S>
 {
     #[inline]
-    fn into(self) -> &'a [N] {
+    fn into(self) -> &'a [T] {
         self.as_slice()
     }
 }
 
-impl<'a, N: Scalar + Copy, R: Dim, C: Dim, S: ContiguousStorageMut<N, R, C>> Into<&'a mut [N]>
-    for &'a mut Matrix<N, R, C, S>
+impl<'a, T: Scalar + Copy, R: Dim, C: Dim, S: ContiguousStorageMut<T, R, C>> Into<&'a mut [T]>
+    for &'a mut Matrix<T, R, C, S>
 {
     #[inline]
-    fn into(self) -> &'a mut [N] {
+    fn into(self) -> &'a mut [T] {
         self.as_mut_slice()
     }
 }
 
-impl<'a, N: Scalar + Copy> From<&'a [N]> for DVectorSlice<'a, N> {
+impl<'a, T: Scalar + Copy> From<&'a [T]> for DVectorSlice<'a, T> {
     #[inline]
-    fn from(slice: &'a [N]) -> Self {
+    fn from(slice: &'a [T]) -> Self {
         Self::from_slice(slice, slice.len())
     }
 }
 
-impl<'a, N: Scalar + Copy> From<&'a mut [N]> for DVectorSliceMut<'a, N> {
+impl<'a, T: Scalar + Copy> From<&'a mut [T]> for DVectorSliceMut<'a, T> {
     #[inline]
-    fn from(slice: &'a mut [N]) -> Self {
+    fn from(slice: &'a mut [T]) -> Self {
         Self::from_slice(slice, slice.len())
     }
 }
 
-impl<N: Scalar + PrimitiveSimdValue, R: Dim, C: Dim> From<[MatrixMN<N::Element, R, C>; 2]>
-    for MatrixMN<N, R, C>
+impl<T: Scalar + PrimitiveSimdValue, R: Dim, C: Dim> From<[OMatrix<T::Element, R, C>; 2]>
+    for OMatrix<T, R, C>
 where
-    N: From<[<N as SimdValue>::Element; 2]>,
-    N::Element: Scalar + SimdValue,
-    DefaultAllocator: Allocator<N, R, C> + Allocator<N::Element, R, C>,
+    T: From<[<T as SimdValue>::Element; 2]>,
+    T::Element: Scalar + SimdValue,
+    DefaultAllocator: Allocator<T, R, C> + Allocator<T::Element, R, C>,
 {
     #[inline]
-    fn from(arr: [MatrixMN<N::Element, R, C>; 2]) -> Self {
+    fn from(arr: [OMatrix<T::Element, R, C>; 2]) -> Self {
         let (nrows, ncols) = arr[0].data.shape();
 
         Self::from_fn_generic(nrows, ncols, |i, j| {
@@ -493,15 +483,15 @@ where
     }
 }
 
-impl<N: Scalar + PrimitiveSimdValue, R: Dim, C: Dim> From<[MatrixMN<N::Element, R, C>; 4]>
-    for MatrixMN<N, R, C>
+impl<T: Scalar + PrimitiveSimdValue, R: Dim, C: Dim> From<[OMatrix<T::Element, R, C>; 4]>
+    for OMatrix<T, R, C>
 where
-    N: From<[<N as SimdValue>::Element; 4]>,
-    N::Element: Scalar + SimdValue,
-    DefaultAllocator: Allocator<N, R, C> + Allocator<N::Element, R, C>,
+    T: From<[<T as SimdValue>::Element; 4]>,
+    T::Element: Scalar + SimdValue,
+    DefaultAllocator: Allocator<T, R, C> + Allocator<T::Element, R, C>,
 {
     #[inline]
-    fn from(arr: [MatrixMN<N::Element, R, C>; 4]) -> Self {
+    fn from(arr: [OMatrix<T::Element, R, C>; 4]) -> Self {
         let (nrows, ncols) = arr[0].data.shape();
 
         Self::from_fn_generic(nrows, ncols, |i, j| {
@@ -516,15 +506,15 @@ where
     }
 }
 
-impl<N: Scalar + PrimitiveSimdValue, R: Dim, C: Dim> From<[MatrixMN<N::Element, R, C>; 8]>
-    for MatrixMN<N, R, C>
+impl<T: Scalar + PrimitiveSimdValue, R: Dim, C: Dim> From<[OMatrix<T::Element, R, C>; 8]>
+    for OMatrix<T, R, C>
 where
-    N: From<[<N as SimdValue>::Element; 8]>,
-    N::Element: Scalar + SimdValue,
-    DefaultAllocator: Allocator<N, R, C> + Allocator<N::Element, R, C>,
+    T: From<[<T as SimdValue>::Element; 8]>,
+    T::Element: Scalar + SimdValue,
+    DefaultAllocator: Allocator<T, R, C> + Allocator<T::Element, R, C>,
 {
     #[inline]
-    fn from(arr: [MatrixMN<N::Element, R, C>; 8]) -> Self {
+    fn from(arr: [OMatrix<T::Element, R, C>; 8]) -> Self {
         let (nrows, ncols) = arr[0].data.shape();
 
         Self::from_fn_generic(nrows, ncols, |i, j| {
@@ -543,14 +533,14 @@ where
     }
 }
 
-impl<N: Scalar + PrimitiveSimdValue, R: Dim, C: Dim> From<[MatrixMN<N::Element, R, C>; 16]>
-    for MatrixMN<N, R, C>
+impl<T: Scalar + PrimitiveSimdValue, R: Dim, C: Dim> From<[OMatrix<T::Element, R, C>; 16]>
+    for OMatrix<T, R, C>
 where
-    N: From<[<N as SimdValue>::Element; 16]>,
-    N::Element: Scalar + SimdValue,
-    DefaultAllocator: Allocator<N, R, C> + Allocator<N::Element, R, C>,
+    T: From<[<T as SimdValue>::Element; 16]>,
+    T::Element: Scalar + SimdValue,
+    DefaultAllocator: Allocator<T, R, C> + Allocator<T::Element, R, C>,
 {
-    fn from(arr: [MatrixMN<N::Element, R, C>; 16]) -> Self {
+    fn from(arr: [OMatrix<T::Element, R, C>; 16]) -> Self {
         let (nrows, ncols) = arr[0].data.shape();
 
         Self::from_fn_generic(nrows, ncols, |i, j| {
diff --git a/src/base/coordinates.rs b/src/base/coordinates.rs
index 832723e3..9cf6bd33 100644
--- a/src/base/coordinates.rs
+++ b/src/base/coordinates.rs
@@ -24,17 +24,17 @@ macro_rules! coords_impl(
         #[repr(C)]
         #[derive(Eq, PartialEq, Clone, Hash, Debug, Copy)]
         #[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
-        pub struct $T<N: Scalar> {
-            $(pub $comps: N),*
+        pub struct $T<T: Scalar> {
+            $(pub $comps: T),*
         }
     }
 );
 
 macro_rules! deref_impl(
     ($R: ty, $C: ty; $Target: ident) => {
-        impl<N: Scalar, S> Deref for Matrix<N, $R, $C, S>
-            where S: ContiguousStorage<N, $R, $C> {
-            type Target = $Target<N>;
+        impl<T: Scalar, S> Deref for Matrix<T, $R, $C, S>
+            where S: ContiguousStorage<T, $R, $C> {
+            type Target = $Target<T>;
 
             #[inline]
             fn deref(&self) -> &Self::Target {
@@ -42,8 +42,8 @@ macro_rules! deref_impl(
             }
         }
 
-        impl<N: Scalar, S> DerefMut for Matrix<N, $R, $C, S>
-            where S: ContiguousStorageMut<N, $R, $C> {
+        impl<T: Scalar, S> DerefMut for Matrix<T, $R, $C, S>
+            where S: ContiguousStorageMut<T, $R, $C> {
             #[inline]
             fn deref_mut(&mut self) -> &mut Self::Target {
                 unsafe { mem::transmute(self.data.ptr_mut()) }
diff --git a/src/base/default_allocator.rs b/src/base/default_allocator.rs
index 81ed1f53..a9f994fe 100644
--- a/src/base/default_allocator.rs
+++ b/src/base/default_allocator.rs
@@ -5,15 +5,12 @@
 
 use std::cmp;
 use std::mem;
-use std::ops::Mul;
 use std::ptr;
 
 #[cfg(all(feature = "alloc", not(feature = "std")))]
 use alloc::vec::Vec;
 
-use generic_array::ArrayLength;
-use typenum::Prod;
-
+use super::Const;
 use crate::base::allocator::{Allocator, Reallocator};
 use crate::base::array_storage::ArrayStorage;
 #[cfg(any(feature = "alloc", feature = "std"))]
@@ -34,25 +31,20 @@ use crate::base::Scalar;
 pub struct DefaultAllocator;
 
 // Static - Static
-impl<N, R, C> Allocator<N, R, C> for DefaultAllocator
-where
-    N: Scalar,
-    R: DimName,
-    C: DimName,
-    R::Value: Mul<C::Value>,
-    Prod<R::Value, C::Value>: ArrayLength<N>,
+impl<T: Scalar, const R: usize, const C: usize> Allocator<T, Const<R>, Const<C>>
+    for DefaultAllocator
 {
-    type Buffer = ArrayStorage<N, R, C>;
+    type Buffer = ArrayStorage<T, R, C>;
 
     #[inline]
-    unsafe fn allocate_uninitialized(_: R, _: C) -> mem::MaybeUninit<Self::Buffer> {
+    unsafe fn allocate_uninitialized(_: Const<R>, _: Const<C>) -> mem::MaybeUninit<Self::Buffer> {
         mem::MaybeUninit::<Self::Buffer>::uninit()
     }
 
     #[inline]
-    fn allocate_from_iterator<I: IntoIterator<Item = N>>(
-        nrows: R,
-        ncols: C,
+    fn allocate_from_iterator<I: IntoIterator<Item = T>>(
+        nrows: Const<R>,
+        ncols: Const<C>,
         iter: I,
     ) -> Self::Buffer {
         #[cfg(feature = "no_unsound_assume_init")]
@@ -61,7 +53,7 @@ where
         let mut res = unsafe { Self::allocate_uninitialized(nrows, ncols).assume_init() };
         let mut count = 0;
 
-        for (res, e) in res.iter_mut().zip(iter.into_iter()) {
+        for (res, e) in res.as_mut_slice().iter_mut().zip(iter.into_iter()) {
             *res = e;
             count += 1;
         }
@@ -78,8 +70,8 @@ where
 // Dynamic - Static
 // Dynamic - Dynamic
 #[cfg(any(feature = "std", feature = "alloc"))]
-impl<N: Scalar, C: Dim> Allocator<N, Dynamic, C> for DefaultAllocator {
-    type Buffer = VecStorage<N, Dynamic, C>;
+impl<T: Scalar, C: Dim> Allocator<T, Dynamic, C> for DefaultAllocator {
+    type Buffer = VecStorage<T, Dynamic, C>;
 
     #[inline]
     unsafe fn allocate_uninitialized(nrows: Dynamic, ncols: C) -> mem::MaybeUninit<Self::Buffer> {
@@ -92,13 +84,13 @@ impl<N: Scalar, C: Dim> Allocator<N, Dynamic, C> for DefaultAllocator {
     }
 
     #[inline]
-    fn allocate_from_iterator<I: IntoIterator<Item = N>>(
+    fn allocate_from_iterator<I: IntoIterator<Item = T>>(
         nrows: Dynamic,
         ncols: C,
         iter: I,
     ) -> Self::Buffer {
         let it = iter.into_iter();
-        let res: Vec<N> = it.collect();
+        let res: Vec<T> = it.collect();
         assert!(res.len() == nrows.value() * ncols.value(),
                 "Allocation from iterator error: the iterator did not yield the correct number of elements.");
 
@@ -108,8 +100,8 @@ impl<N: Scalar, C: Dim> Allocator<N, Dynamic, C> for DefaultAllocator {
 
 // Static - Dynamic
 #[cfg(any(feature = "std", feature = "alloc"))]
-impl<N: Scalar, R: DimName> Allocator<N, R, Dynamic> for DefaultAllocator {
-    type Buffer = VecStorage<N, R, Dynamic>;
+impl<T: Scalar, R: DimName> Allocator<T, R, Dynamic> for DefaultAllocator {
+    type Buffer = VecStorage<T, R, Dynamic>;
 
     #[inline]
     unsafe fn allocate_uninitialized(nrows: R, ncols: Dynamic) -> mem::MaybeUninit<Self::Buffer> {
@@ -122,13 +114,13 @@ impl<N: Scalar, R: DimName> Allocator<N, R, Dynamic> for DefaultAllocator {
     }
 
     #[inline]
-    fn allocate_from_iterator<I: IntoIterator<Item = N>>(
+    fn allocate_from_iterator<I: IntoIterator<Item = T>>(
         nrows: R,
         ncols: Dynamic,
         iter: I,
     ) -> Self::Buffer {
         let it = iter.into_iter();
-        let res: Vec<N> = it.collect();
+        let res: Vec<T> = it.collect();
         assert!(res.len() == nrows.value() * ncols.value(),
                 "Allocation from iterator error: the iterator did not yield the correct number of elements.");
 
@@ -142,27 +134,25 @@ impl<N: Scalar, R: DimName> Allocator<N, R, Dynamic> for DefaultAllocator {
  *
  */
 // Anything -> Static × Static
-impl<N: Scalar, RFrom, CFrom, RTo, CTo> Reallocator<N, RFrom, CFrom, RTo, CTo> for DefaultAllocator
+impl<T: Scalar, RFrom, CFrom, const RTO: usize, const CTO: usize>
+    Reallocator<T, RFrom, CFrom, Const<RTO>, Const<CTO>> for DefaultAllocator
 where
     RFrom: Dim,
     CFrom: Dim,
-    RTo: DimName,
-    CTo: DimName,
-    Self: Allocator<N, RFrom, CFrom>,
-    RTo::Value: Mul<CTo::Value>,
-    Prod<RTo::Value, CTo::Value>: ArrayLength<N>,
+    Self: Allocator<T, RFrom, CFrom>,
 {
     #[inline]
     unsafe fn reallocate_copy(
-        rto: RTo,
-        cto: CTo,
-        buf: <Self as Allocator<N, RFrom, CFrom>>::Buffer,
-    ) -> ArrayStorage<N, RTo, CTo> {
+        rto: Const<RTO>,
+        cto: Const<CTO>,
+        buf: <Self as Allocator<T, RFrom, CFrom>>::Buffer,
+    ) -> ArrayStorage<T, RTO, CTO> {
         #[cfg(feature = "no_unsound_assume_init")]
-        let mut res: ArrayStorage<N, RTo, CTo> = unimplemented!();
+        let mut res: ArrayStorage<T, RTO, CTO> = unimplemented!();
         #[cfg(not(feature = "no_unsound_assume_init"))]
         let mut res =
-            <Self as Allocator<N, RTo, CTo>>::allocate_uninitialized(rto, cto).assume_init();
+            <Self as Allocator<T, Const<RTO>, Const<CTO>>>::allocate_uninitialized(rto, cto)
+                .assume_init();
 
         let (rfrom, cfrom) = buf.shape();
 
@@ -176,25 +166,22 @@ where
 
 // Static × Static -> Dynamic × Any
 #[cfg(any(feature = "std", feature = "alloc"))]
-impl<N: Scalar, RFrom, CFrom, CTo> Reallocator<N, RFrom, CFrom, Dynamic, CTo> for DefaultAllocator
+impl<T: Scalar, CTo, const RFROM: usize, const CFROM: usize>
+    Reallocator<T, Const<RFROM>, Const<CFROM>, Dynamic, CTo> for DefaultAllocator
 where
-    RFrom: DimName,
-    CFrom: DimName,
     CTo: Dim,
-    RFrom::Value: Mul<CFrom::Value>,
-    Prod<RFrom::Value, CFrom::Value>: ArrayLength<N>,
 {
     #[inline]
     unsafe fn reallocate_copy(
         rto: Dynamic,
         cto: CTo,
-        buf: ArrayStorage<N, RFrom, CFrom>,
-    ) -> VecStorage<N, Dynamic, CTo> {
+        buf: ArrayStorage<T, RFROM, CFROM>,
+    ) -> VecStorage<T, Dynamic, CTo> {
         #[cfg(feature = "no_unsound_assume_init")]
-        let mut res: VecStorage<N, Dynamic, CTo> = unimplemented!();
+        let mut res: VecStorage<T, Dynamic, CTo> = unimplemented!();
         #[cfg(not(feature = "no_unsound_assume_init"))]
         let mut res =
-            <Self as Allocator<N, Dynamic, CTo>>::allocate_uninitialized(rto, cto).assume_init();
+            <Self as Allocator<T, Dynamic, CTo>>::allocate_uninitialized(rto, cto).assume_init();
 
         let (rfrom, cfrom) = buf.shape();
 
@@ -208,25 +195,22 @@ where
 
 // Static × Static -> Static × Dynamic
 #[cfg(any(feature = "std", feature = "alloc"))]
-impl<N: Scalar, RFrom, CFrom, RTo> Reallocator<N, RFrom, CFrom, RTo, Dynamic> for DefaultAllocator
+impl<T: Scalar, RTo, const RFROM: usize, const CFROM: usize>
+    Reallocator<T, Const<RFROM>, Const<CFROM>, RTo, Dynamic> for DefaultAllocator
 where
-    RFrom: DimName,
-    CFrom: DimName,
     RTo: DimName,
-    RFrom::Value: Mul<CFrom::Value>,
-    Prod<RFrom::Value, CFrom::Value>: ArrayLength<N>,
 {
     #[inline]
     unsafe fn reallocate_copy(
         rto: RTo,
         cto: Dynamic,
-        buf: ArrayStorage<N, RFrom, CFrom>,
-    ) -> VecStorage<N, RTo, Dynamic> {
+        buf: ArrayStorage<T, RFROM, CFROM>,
+    ) -> VecStorage<T, RTo, Dynamic> {
         #[cfg(feature = "no_unsound_assume_init")]
-        let mut res: VecStorage<N, RTo, Dynamic> = unimplemented!();
+        let mut res: VecStorage<T, RTo, Dynamic> = unimplemented!();
         #[cfg(not(feature = "no_unsound_assume_init"))]
         let mut res =
-            <Self as Allocator<N, RTo, Dynamic>>::allocate_uninitialized(rto, cto).assume_init();
+            <Self as Allocator<T, RTo, Dynamic>>::allocate_uninitialized(rto, cto).assume_init();
 
         let (rfrom, cfrom) = buf.shape();
 
@@ -240,60 +224,60 @@ where
 
 // All conversion from a dynamic buffer to a dynamic buffer.
 #[cfg(any(feature = "std", feature = "alloc"))]
-impl<N: Scalar, CFrom: Dim, CTo: Dim> Reallocator<N, Dynamic, CFrom, Dynamic, CTo>
+impl<T: Scalar, CFrom: Dim, CTo: Dim> Reallocator<T, Dynamic, CFrom, Dynamic, CTo>
     for DefaultAllocator
 {
     #[inline]
     unsafe fn reallocate_copy(
         rto: Dynamic,
         cto: CTo,
-        buf: VecStorage<N, Dynamic, CFrom>,
-    ) -> VecStorage<N, Dynamic, CTo> {
+        buf: VecStorage<T, Dynamic, CFrom>,
+    ) -> VecStorage<T, Dynamic, CTo> {
         let new_buf = buf.resize(rto.value() * cto.value());
         VecStorage::new(rto, cto, new_buf)
     }
 }
 
 #[cfg(any(feature = "std", feature = "alloc"))]
-impl<N: Scalar, CFrom: Dim, RTo: DimName> Reallocator<N, Dynamic, CFrom, RTo, Dynamic>
+impl<T: Scalar, CFrom: Dim, RTo: DimName> Reallocator<T, Dynamic, CFrom, RTo, Dynamic>
     for DefaultAllocator
 {
     #[inline]
     unsafe fn reallocate_copy(
         rto: RTo,
         cto: Dynamic,
-        buf: VecStorage<N, Dynamic, CFrom>,
-    ) -> VecStorage<N, RTo, Dynamic> {
+        buf: VecStorage<T, Dynamic, CFrom>,
+    ) -> VecStorage<T, RTo, Dynamic> {
         let new_buf = buf.resize(rto.value() * cto.value());
         VecStorage::new(rto, cto, new_buf)
     }
 }
 
 #[cfg(any(feature = "std", feature = "alloc"))]
-impl<N: Scalar, RFrom: DimName, CTo: Dim> Reallocator<N, RFrom, Dynamic, Dynamic, CTo>
+impl<T: Scalar, RFrom: DimName, CTo: Dim> Reallocator<T, RFrom, Dynamic, Dynamic, CTo>
     for DefaultAllocator
 {
     #[inline]
     unsafe fn reallocate_copy(
         rto: Dynamic,
         cto: CTo,
-        buf: VecStorage<N, RFrom, Dynamic>,
-    ) -> VecStorage<N, Dynamic, CTo> {
+        buf: VecStorage<T, RFrom, Dynamic>,
+    ) -> VecStorage<T, Dynamic, CTo> {
         let new_buf = buf.resize(rto.value() * cto.value());
         VecStorage::new(rto, cto, new_buf)
     }
 }
 
 #[cfg(any(feature = "std", feature = "alloc"))]
-impl<N: Scalar, RFrom: DimName, RTo: DimName> Reallocator<N, RFrom, Dynamic, RTo, Dynamic>
+impl<T: Scalar, RFrom: DimName, RTo: DimName> Reallocator<T, RFrom, Dynamic, RTo, Dynamic>
     for DefaultAllocator
 {
     #[inline]
     unsafe fn reallocate_copy(
         rto: RTo,
         cto: Dynamic,
-        buf: VecStorage<N, RFrom, Dynamic>,
-    ) -> VecStorage<N, RTo, Dynamic> {
+        buf: VecStorage<T, RFrom, Dynamic>,
+    ) -> VecStorage<T, RTo, Dynamic> {
         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 7eed2e32..90a5bdd9 100644
--- a/src/base/dimension.rs
+++ b/src/base/dimension.rs
@@ -6,9 +6,7 @@ use std::any::{Any, TypeId};
 use std::cmp;
 use std::fmt::Debug;
 use std::ops::{Add, Div, Mul, Sub};
-use typenum::{
-    self, Bit, Diff, Max, Maximum, Min, Minimum, Prod, Quot, Sum, UInt, UTerm, Unsigned, B1,
-};
+use typenum::{self, Diff, Max, Maximum, Min, Minimum, Prod, Quot, Sum, Unsigned};
 
 #[cfg(feature = "serde-serialize")]
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
@@ -130,13 +128,17 @@ macro_rules! dim_ops(
             fn $op(self, other: D) -> Self::Output;
         }
 
-        impl<D1: DimName, D2: DimName> $DimOp<D2> for D1
-            where D1::Value: $Op<D2::Value>,
-                  $ResOp<D1::Value, D2::Value>: NamedDim {
-            type Output = <$ResOp<D1::Value, D2::Value> as NamedDim>::Name;
+        impl<const A: usize, const B: usize> $DimOp<Const<B>> for Const<A>
+        where
+            Const<A>: ToTypenum,
+            Const<B>: ToTypenum,
+            <Const<A> as ToTypenum>::Typenum: $Op<<Const<B> as ToTypenum>::Typenum>,
+            $ResOp<<Const<A> as ToTypenum>::Typenum, <Const<B> as ToTypenum>::Typenum>: ToConst,
+        {
+            type Output =
+                <$ResOp<<Const<A> as ToTypenum>::Typenum, <Const<B> as ToTypenum>::Typenum> as ToConst>::Const;
 
-            #[inline]
-            fn $op(self, _: D2) -> Self::Output {
+            fn $op(self, _: Const<B>) -> Self::Output {
                 Self::Output::name()
             }
         }
@@ -150,6 +152,7 @@ macro_rules! dim_ops(
             }
         }
 
+        // TODO: use Const<T> instead of D: DimName?
         impl<D: DimName> $DimOp<Dynamic> for D {
             type Output = Dynamic;
 
@@ -167,13 +170,17 @@ macro_rules! dim_ops(
             fn $op(self, other: D) -> Self::Output;
         }
 
-        impl<D1: DimName, D2: DimName> $DimNameOp<D2> for D1
-            where D1::Value: $Op<D2::Value>,
-                  $ResOp<D1::Value, D2::Value>: NamedDim {
-            type Output = <$ResOp<D1::Value, D2::Value> as NamedDim>::Name;
+        impl<const A: usize, const B: usize> $DimNameOp<Const<B>> for Const<A>
+        where
+            Const<A>: ToTypenum,
+            Const<B>: ToTypenum,
+            <Const<A> as ToTypenum>::Typenum: $Op<<Const<B> as ToTypenum>::Typenum>,
+            $ResOp<<Const<A> as ToTypenum>::Typenum, <Const<B> as ToTypenum>::Typenum>: ToConst,
+        {
+            type Output =
+                <$ResOp<<Const<A> as ToTypenum>::Typenum, <Const<B> as ToTypenum>::Typenum> as ToConst>::Const;
 
-            #[inline]
-            fn $op(self, _: D2) -> Self::Output {
+            fn $op(self, _: Const<B>) -> Self::Output {
                 Self::Output::name()
             }
         }
@@ -189,105 +196,85 @@ dim_ops!(
     DimMax, DimNameMax, Max, max, cmp::max, DimMaximum, DimNameMaximum, Maximum;
 );
 
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+pub struct Const<const R: usize>;
+
 /// Trait implemented exclusively by type-level integers.
 pub trait DimName: Dim {
-    type Value: NamedDim<Name = Self>;
+    const USIZE: usize;
 
     /// The name of this dimension, i.e., the singleton `Self`.
     fn name() -> Self;
 
     // TODO: this is not a very idiomatic name.
     /// The value of this dimension.
-    #[inline]
-    fn dim() -> usize {
-        Self::Value::to_usize()
-    }
+    fn dim() -> usize;
 }
 
-pub trait NamedDim: Sized + Any + Unsigned {
-    type Name: DimName<Value = Self>;
+pub trait ToConst {
+    type Const: DimName;
 }
 
-/// A type level dimension with a value of `1`.
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
-pub struct U1;
+pub trait ToTypenum {
+    type Typenum: Unsigned;
+}
 
-impl Dim for U1 {
-    #[inline]
+impl<const T: usize> Dim for Const<T> {
     fn try_to_usize() -> Option<usize> {
-        Some(1)
+        Some(T)
     }
 
-    #[inline]
-    fn from_usize(dim: usize) -> Self {
-        assert!(dim == 1, "Mismatched dimension.");
-        U1
-    }
-
-    #[inline]
     fn value(&self) -> usize {
-        1
+        T
+    }
+
+    fn from_usize(dim: usize) -> Self {
+        assert_eq!(dim, T);
+        Self
     }
 }
 
-impl DimName for U1 {
-    type Value = typenum::U1;
+impl<const T: usize> DimName for Const<T> {
+    const USIZE: usize = T;
 
     #[inline]
     fn name() -> Self {
-        U1
+        Self
+    }
+
+    #[inline]
+    fn dim() -> usize {
+        T
     }
 }
 
-impl NamedDim for typenum::U1 {
-    type Name = U1;
+pub type U1 = Const<1>;
+
+impl ToTypenum for Const<{ typenum::U1::USIZE }> {
+    type Typenum = typenum::U1;
 }
 
-macro_rules! named_dimension (
+impl ToConst for typenum::U1 {
+    type Const = Const<{ typenum::U1::USIZE }>;
+}
+
+macro_rules! from_to_typenum (
     ($($D: ident),* $(,)*) => {$(
-        /// A type level dimension.
-        #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-        #[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
-        pub struct $D;
+        pub type $D = Const<{ typenum::$D::USIZE }>;
 
-        impl Dim for $D {
-            #[inline]
-            fn try_to_usize() -> Option<usize> {
-                Some(typenum::$D::to_usize())
-            }
-
-            #[inline]
-            fn from_usize(dim: usize) -> Self {
-                assert!(dim == typenum::$D::to_usize(), "Mismatched dimension.");
-                $D
-            }
-
-            #[inline]
-            fn value(&self) -> usize {
-                typenum::$D::to_usize()
-            }
+        impl ToTypenum for Const<{ typenum::$D::USIZE }> {
+            type Typenum = typenum::$D;
         }
 
-        impl DimName for $D {
-            type Value = typenum::$D;
-
-            #[inline]
-            fn name() -> Self {
-                $D
-            }
-        }
-
-        impl NamedDim for typenum::$D {
-            type Name = $D;
+        impl ToConst for typenum::$D {
+            type Const = Const<{ typenum::$D::USIZE }>;
         }
 
         impl IsNotStaticOne for $D { }
     )*}
 );
 
-// We give explicit names to all Unsigned in [0, 128[
-named_dimension!(
+from_to_typenum!(
     U0, /*U1,*/ U2, U3, U4, U5, U6, U7, U8, U9, U10, U11, U12, U13, U14, U15, U16, U17, U18,
     U19, U20, U21, U22, U23, U24, U25, U26, U27, U28, U29, U30, U31, U32, U33, U34, U35, U36, U37,
     U38, U39, U40, U41, U42, U43, U44, U45, U46, U47, U48, U49, U50, U51, U52, U53, U54, U55, U56,
@@ -297,117 +284,3 @@ named_dimension!(
     U111, U112, U113, U114, U115, U116, U117, U118, U119, U120, U121, U122, U123, U124, U125, U126,
     U127
 );
-
-// For values greater than U1023, just use the typenum binary representation directly.
-impl<
-        A: Bit + Any + Debug + Copy + PartialEq + Send + Sync,
-        B: Bit + Any + Debug + Copy + PartialEq + Send + Sync,
-        C: Bit + Any + Debug + Copy + PartialEq + Send + Sync,
-        D: Bit + Any + Debug + Copy + PartialEq + Send + Sync,
-        E: Bit + Any + Debug + Copy + PartialEq + Send + Sync,
-        F: Bit + Any + Debug + Copy + PartialEq + Send + Sync,
-        G: Bit + Any + Debug + Copy + PartialEq + Send + Sync,
-    > NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, A>, B>, C>, D>, E>, F>, G>
-{
-    type Name = Self;
-}
-
-impl<
-        A: Bit + Any + Debug + Copy + PartialEq + Send + Sync,
-        B: Bit + Any + Debug + Copy + PartialEq + Send + Sync,
-        C: Bit + Any + Debug + Copy + PartialEq + Send + Sync,
-        D: Bit + Any + Debug + Copy + PartialEq + Send + Sync,
-        E: Bit + Any + Debug + Copy + PartialEq + Send + Sync,
-        F: Bit + Any + Debug + Copy + PartialEq + Send + Sync,
-        G: Bit + Any + Debug + Copy + PartialEq + Send + Sync,
-    > Dim for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, A>, B>, C>, D>, E>, F>, G>
-{
-    #[inline]
-    fn try_to_usize() -> Option<usize> {
-        Some(Self::to_usize())
-    }
-
-    #[inline]
-    fn from_usize(dim: usize) -> Self {
-        assert!(dim == Self::to_usize(), "Mismatched dimension.");
-        Self::new()
-    }
-
-    #[inline]
-    fn value(&self) -> usize {
-        Self::to_usize()
-    }
-}
-
-impl<
-        A: Bit + Any + Debug + Copy + PartialEq + Send + Sync,
-        B: Bit + Any + Debug + Copy + PartialEq + Send + Sync,
-        C: Bit + Any + Debug + Copy + PartialEq + Send + Sync,
-        D: Bit + Any + Debug + Copy + PartialEq + Send + Sync,
-        E: Bit + Any + Debug + Copy + PartialEq + Send + Sync,
-        F: Bit + Any + Debug + Copy + PartialEq + Send + Sync,
-        G: Bit + Any + Debug + Copy + PartialEq + Send + Sync,
-    > DimName for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, A>, B>, C>, D>, E>, F>, G>
-{
-    type Value = Self;
-
-    #[inline]
-    fn name() -> Self {
-        Self::new()
-    }
-}
-
-impl<
-        A: Bit + Any + Debug + Copy + PartialEq + Send + Sync,
-        B: Bit + Any + Debug + Copy + PartialEq + Send + Sync,
-        C: Bit + Any + Debug + Copy + PartialEq + Send + Sync,
-        D: Bit + Any + Debug + Copy + PartialEq + Send + Sync,
-        E: Bit + Any + Debug + Copy + PartialEq + Send + Sync,
-        F: Bit + Any + Debug + Copy + PartialEq + Send + Sync,
-        G: Bit + Any + Debug + Copy + PartialEq + Send + Sync,
-    > IsNotStaticOne
-    for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, A>, B>, C>, D>, E>, F>, G>
-{
-}
-
-impl<U: Unsigned + DimName, B: Bit + Any + Debug + Copy + PartialEq + Send + Sync> NamedDim
-    for UInt<U, B>
-{
-    type Name = UInt<U, B>;
-}
-
-impl<U: Unsigned + DimName, B: Bit + Any + Debug + Copy + PartialEq + Send + Sync> Dim
-    for UInt<U, B>
-{
-    #[inline]
-    fn try_to_usize() -> Option<usize> {
-        Some(Self::to_usize())
-    }
-
-    #[inline]
-    fn from_usize(dim: usize) -> Self {
-        assert!(dim == Self::to_usize(), "Mismatched dimension.");
-        Self::new()
-    }
-
-    #[inline]
-    fn value(&self) -> usize {
-        Self::to_usize()
-    }
-}
-
-impl<U: Unsigned + DimName, B: Bit + Any + Debug + Copy + PartialEq + Send + Sync> DimName
-    for UInt<U, B>
-{
-    type Value = UInt<U, B>;
-
-    #[inline]
-    fn name() -> Self {
-        Self::new()
-    }
-}
-
-impl<U: Unsigned + DimName, B: Bit + Any + Debug + Copy + PartialEq + Send + Sync> IsNotStaticOne
-    for UInt<U, B>
-{
-}
diff --git a/src/base/edition.rs b/src/base/edition.rs
index 9d8606af..17c08c98 100644
--- a/src/base/edition.rs
+++ b/src/base/edition.rs
@@ -10,47 +10,43 @@ 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::{
-    Dim, DimAdd, DimDiff, DimMin, DimMinimum, DimName, DimSub, DimSum, U1,
-};
+use crate::base::dimension::{Const, Dim, DimAdd, DimDiff, DimMin, DimMinimum, DimSub, DimSum, U1};
 use crate::base::storage::{ReshapableStorage, Storage, StorageMut};
-#[cfg(any(feature = "std", feature = "alloc"))]
-use crate::base::DMatrix;
-use crate::base::{DefaultAllocator, Matrix, MatrixMN, RowVector, Scalar, Vector};
+use crate::base::{DefaultAllocator, Matrix, OMatrix, RowVector, Scalar, Vector};
 
 /// # Rows and columns extraction
-impl<N: Scalar + Zero, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
+impl<T: Scalar + Zero, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
     /// Extracts the upper triangular part of this matrix (including the diagonal).
     #[inline]
-    pub fn upper_triangle(&self) -> MatrixMN<N, R, C>
+    pub fn upper_triangle(&self) -> OMatrix<T, R, C>
     where
-        DefaultAllocator: Allocator<N, R, C>,
+        DefaultAllocator: Allocator<T, R, C>,
     {
         let mut res = self.clone_owned();
-        res.fill_lower_triangle(N::zero(), 1);
+        res.fill_lower_triangle(T::zero(), 1);
 
         res
     }
 
     /// Extracts the lower triangular part of this matrix (including the diagonal).
     #[inline]
-    pub fn lower_triangle(&self) -> MatrixMN<N, R, C>
+    pub fn lower_triangle(&self) -> OMatrix<T, R, C>
     where
-        DefaultAllocator: Allocator<N, R, C>,
+        DefaultAllocator: Allocator<T, R, C>,
     {
         let mut res = self.clone_owned();
-        res.fill_upper_triangle(N::zero(), 1);
+        res.fill_upper_triangle(T::zero(), 1);
 
         res
     }
 
     /// Creates a new matrix by extracting the given set of rows from `self`.
     #[cfg(any(feature = "std", feature = "alloc"))]
-    pub fn select_rows<'a, I>(&self, irows: I) -> MatrixMN<N, Dynamic, C>
+    pub fn select_rows<'a, I>(&self, irows: I) -> OMatrix<T, Dynamic, C>
     where
         I: IntoIterator<Item = &'a usize>,
         I::IntoIter: ExactSizeIterator + Clone,
-        DefaultAllocator: Allocator<N, Dynamic, C>,
+        DefaultAllocator: Allocator<T, Dynamic, C>,
     {
         let irows = irows.into_iter();
         let ncols = self.data.shape().1;
@@ -82,11 +78,11 @@ impl<N: Scalar + Zero, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
 
     /// Creates a new matrix by extracting the given set of columns from `self`.
     #[cfg(any(feature = "std", feature = "alloc"))]
-    pub fn select_columns<'a, I>(&self, icols: I) -> MatrixMN<N, R, Dynamic>
+    pub fn select_columns<'a, I>(&self, icols: I) -> OMatrix<T, R, Dynamic>
     where
         I: IntoIterator<Item = &'a usize>,
         I::IntoIter: ExactSizeIterator,
-        DefaultAllocator: Allocator<N, R, Dynamic>,
+        DefaultAllocator: Allocator<T, R, Dynamic>,
     {
         let icols = icols.into_iter();
         let nrows = self.data.shape().0;
@@ -103,13 +99,13 @@ impl<N: Scalar + Zero, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
 }
 
 /// # Set rows, columns, and diagonal
-impl<N: Scalar, R: Dim, C: Dim, S: StorageMut<N, R, C>> Matrix<N, R, C, S> {
+impl<T: Scalar, R: Dim, C: Dim, S: StorageMut<T, R, C>> Matrix<T, R, C, S> {
     /// Fills the diagonal of this matrix with the content of the given vector.
     #[inline]
-    pub fn set_diagonal<R2: Dim, S2>(&mut self, diag: &Vector<N, R2, S2>)
+    pub fn set_diagonal<R2: Dim, S2>(&mut self, diag: &Vector<T, R2, S2>)
     where
         R: DimMin<C>,
-        S2: Storage<N, R2>,
+        S2: Storage<T, R2>,
         ShapeConstraint: DimEq<DimMinimum<R, C>, R2>,
     {
         let (nrows, ncols) = self.shape();
@@ -127,7 +123,7 @@ impl<N: Scalar, R: Dim, C: Dim, S: StorageMut<N, R, C>> Matrix<N, R, C, S> {
     /// minimum of the number of rows and columns of `self`, and starting with the
     /// diagonal element at index (0, 0).
     #[inline]
-    pub fn set_partial_diagonal(&mut self, diag: impl Iterator<Item = N>) {
+    pub fn set_partial_diagonal(&mut self, diag: impl Iterator<Item = T>) {
         let (nrows, ncols) = self.shape();
         let min_nrows_ncols = cmp::min(nrows, ncols);
 
@@ -138,9 +134,9 @@ impl<N: Scalar, R: Dim, C: Dim, S: StorageMut<N, R, C>> Matrix<N, R, C, S> {
 
     /// Fills the selected row of this matrix with the content of the given vector.
     #[inline]
-    pub fn set_row<C2: Dim, S2>(&mut self, i: usize, row: &RowVector<N, C2, S2>)
+    pub fn set_row<C2: Dim, S2>(&mut self, i: usize, row: &RowVector<T, C2, S2>)
     where
-        S2: Storage<N, U1, C2>,
+        S2: Storage<T, U1, C2>,
         ShapeConstraint: SameNumberOfColumns<C, C2>,
     {
         self.row_mut(i).copy_from(row);
@@ -148,9 +144,9 @@ impl<N: Scalar, R: Dim, C: Dim, S: StorageMut<N, R, C>> Matrix<N, R, C, S> {
 
     /// Fills the selected column of this matrix with the content of the given vector.
     #[inline]
-    pub fn set_column<R2: Dim, S2>(&mut self, i: usize, column: &Vector<N, R2, S2>)
+    pub fn set_column<R2: Dim, S2>(&mut self, i: usize, column: &Vector<T, R2, S2>)
     where
-        S2: Storage<N, R2, U1>,
+        S2: Storage<T, R2, U1>,
         ShapeConstraint: SameNumberOfRows<R, R2>,
     {
         self.column_mut(i).copy_from(column);
@@ -158,10 +154,10 @@ impl<N: Scalar, R: Dim, C: Dim, S: StorageMut<N, R, C>> Matrix<N, R, C, S> {
 }
 
 /// # In-place filling
-impl<N: Scalar, R: Dim, C: Dim, S: StorageMut<N, R, C>> Matrix<N, R, C, S> {
+impl<T: Scalar, R: Dim, C: Dim, S: StorageMut<T, R, C>> Matrix<T, R, C, S> {
     /// Sets all the elements of this matrix to `val`.
     #[inline]
-    pub fn fill(&mut self, val: N) {
+    pub fn fill(&mut self, val: T) {
         for e in self.iter_mut() {
             *e = val.inlined_clone()
         }
@@ -171,15 +167,15 @@ impl<N: Scalar, R: Dim, C: Dim, S: StorageMut<N, R, C>> Matrix<N, R, C, S> {
     #[inline]
     pub fn fill_with_identity(&mut self)
     where
-        N: Zero + One,
+        T: Zero + One,
     {
-        self.fill(N::zero());
-        self.fill_diagonal(N::one());
+        self.fill(T::zero());
+        self.fill_diagonal(T::one());
     }
 
     /// Sets all the diagonal elements of this matrix to `val`.
     #[inline]
-    pub fn fill_diagonal(&mut self, val: N) {
+    pub fn fill_diagonal(&mut self, val: T) {
         let (nrows, ncols) = self.shape();
         let n = cmp::min(nrows, ncols);
 
@@ -190,7 +186,7 @@ impl<N: Scalar, R: Dim, C: Dim, S: StorageMut<N, R, C>> Matrix<N, R, C, S> {
 
     /// Sets all the elements of the selected row to `val`.
     #[inline]
-    pub fn fill_row(&mut self, i: usize, val: N) {
+    pub fn fill_row(&mut self, i: usize, val: T) {
         assert!(i < self.nrows(), "Row index out of bounds.");
         for j in 0..self.ncols() {
             unsafe { *self.get_unchecked_mut((i, j)) = val.inlined_clone() }
@@ -199,7 +195,7 @@ impl<N: Scalar, R: Dim, C: Dim, S: StorageMut<N, R, C>> Matrix<N, R, C, S> {
 
     /// Sets all the elements of the selected column to `val`.
     #[inline]
-    pub fn fill_column(&mut self, j: usize, val: N) {
+    pub fn fill_column(&mut self, j: usize, val: T) {
         assert!(j < self.ncols(), "Row index out of bounds.");
         for i in 0..self.nrows() {
             unsafe { *self.get_unchecked_mut((i, j)) = val.inlined_clone() }
@@ -214,7 +210,7 @@ impl<N: Scalar, R: Dim, C: Dim, S: StorageMut<N, R, C>> Matrix<N, R, C, S> {
     /// * If `shift > 1`, then the diagonal and the first `shift - 1` subdiagonals are left
     /// untouched.
     #[inline]
-    pub fn fill_lower_triangle(&mut self, val: N, shift: usize) {
+    pub fn fill_lower_triangle(&mut self, val: T, shift: usize) {
         for j in 0..self.ncols() {
             for i in (j + shift)..self.nrows() {
                 unsafe { *self.get_unchecked_mut((i, j)) = val.inlined_clone() }
@@ -230,7 +226,7 @@ impl<N: Scalar, R: Dim, C: Dim, S: StorageMut<N, R, C>> Matrix<N, R, C, S> {
     /// * If `shift > 1`, then the diagonal and the first `shift - 1` superdiagonals are left
     /// untouched.
     #[inline]
-    pub fn fill_upper_triangle(&mut self, val: N, shift: usize) {
+    pub fn fill_upper_triangle(&mut self, val: T, shift: usize) {
         for j in shift..self.ncols() {
             // TODO: is there a more efficient way to avoid the min ?
             // (necessary for rectangular matrices)
@@ -241,7 +237,7 @@ impl<N: Scalar, R: Dim, C: Dim, S: StorageMut<N, R, C>> Matrix<N, R, C, S> {
     }
 }
 
-impl<N: Scalar, D: Dim, S: StorageMut<N, D, D>> Matrix<N, D, D, S> {
+impl<T: Scalar, D: Dim, S: StorageMut<T, D, D>> Matrix<T, D, D, S> {
     /// Copies the upper-triangle of this matrix to its lower-triangular part.
     ///
     /// This makes the matrix symmetric. Panics if the matrix is not square.
@@ -275,7 +271,7 @@ impl<N: Scalar, D: Dim, S: StorageMut<N, D, D>> Matrix<N, D, D, S> {
 }
 
 /// # In-place swapping
-impl<N: Scalar, R: Dim, C: Dim, S: StorageMut<N, R, C>> Matrix<N, R, C, S> {
+impl<T: Scalar, R: Dim, C: Dim, S: StorageMut<T, R, C>> Matrix<T, R, C, S> {
     /// Swaps two rows in-place.
     #[inline]
     pub fn swap_rows(&mut self, irow1: usize, irow2: usize) {
@@ -311,7 +307,7 @@ impl<N: Scalar, R: Dim, C: Dim, S: StorageMut<N, R, C>> Matrix<N, R, C, S> {
  *
  */
 /// # Rows and columns removal
-impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
+impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
     /*
      *
      * Column removal.
@@ -319,20 +315,20 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
      */
     /// Removes the `i`-th column from this matrix.
     #[inline]
-    pub fn remove_column(self, i: usize) -> MatrixMN<N, R, DimDiff<C, U1>>
+    pub fn remove_column(self, i: usize) -> OMatrix<T, R, DimDiff<C, U1>>
     where
         C: DimSub<U1>,
-        DefaultAllocator: Reallocator<N, R, C, R, DimDiff<C, U1>>,
+        DefaultAllocator: Reallocator<T, R, C, R, DimDiff<C, U1>>,
     {
-        self.remove_fixed_columns::<U1>(i)
+        self.remove_fixed_columns::<1>(i)
     }
 
     /// Removes all columns in `indices`   
     #[cfg(any(feature = "std", feature = "alloc"))]
-    pub fn remove_columns_at(self, indices: &[usize]) -> MatrixMN<N, R, Dynamic>
+    pub fn remove_columns_at(self, indices: &[usize]) -> OMatrix<T, R, Dynamic>
     where
         C: DimSub<Dynamic, Output = Dynamic>,
-        DefaultAllocator: Reallocator<N, R, C, R, Dynamic>,
+        DefaultAllocator: Reallocator<T, R, C, R, Dynamic>,
     {
         let mut m = self.into_owned();
         let (nrows, ncols) = m.data.shape();
@@ -363,10 +359,10 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
 
     /// Removes all rows in `indices`   
     #[cfg(any(feature = "std", feature = "alloc"))]
-    pub fn remove_rows_at(self, indices: &[usize]) -> MatrixMN<N, Dynamic, C>
+    pub fn remove_rows_at(self, indices: &[usize]) -> OMatrix<T, Dynamic, C>
     where
         R: DimSub<Dynamic, Output = Dynamic>,
-        DefaultAllocator: Reallocator<N, R, C, Dynamic, C>,
+        DefaultAllocator: Reallocator<T, R, C, Dynamic, C>,
     {
         let mut m = self.into_owned();
         let (nrows, ncols) = m.data.shape();
@@ -398,22 +394,24 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     /// Removes `D::dim()` consecutive columns from this matrix, starting with the `i`-th
     /// (included).
     #[inline]
-    pub fn remove_fixed_columns<D>(self, i: usize) -> MatrixMN<N, R, DimDiff<C, D>>
+    pub fn remove_fixed_columns<const D: usize>(
+        self,
+        i: usize,
+    ) -> OMatrix<T, R, DimDiff<C, Const<D>>>
     where
-        D: DimName,
-        C: DimSub<D>,
-        DefaultAllocator: Reallocator<N, R, C, R, DimDiff<C, D>>,
+        C: DimSub<Const<D>>,
+        DefaultAllocator: Reallocator<T, R, C, R, DimDiff<C, Const<D>>>,
     {
-        self.remove_columns_generic(i, D::name())
+        self.remove_columns_generic(i, Const::<D>)
     }
 
     /// 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) -> MatrixMN<N, R, Dynamic>
+    pub fn remove_columns(self, i: usize, n: usize) -> OMatrix<T, R, Dynamic>
     where
         C: DimSub<Dynamic, Output = Dynamic>,
-        DefaultAllocator: Reallocator<N, R, C, R, Dynamic>,
+        DefaultAllocator: Reallocator<T, R, C, R, Dynamic>,
     {
         self.remove_columns_generic(i, Dynamic::new(n))
     }
@@ -423,11 +421,11 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     /// This is the generic implementation of `.remove_columns(...)` and
     /// `.remove_fixed_columns(...)` which have nicer API interfaces.
     #[inline]
-    pub fn remove_columns_generic<D>(self, i: usize, nremove: D) -> MatrixMN<N, R, DimDiff<C, D>>
+    pub fn remove_columns_generic<D>(self, i: usize, nremove: D) -> OMatrix<T, R, DimDiff<C, D>>
     where
         D: Dim,
         C: DimSub<D>,
-        DefaultAllocator: Reallocator<N, R, C, R, DimDiff<C, D>>,
+        DefaultAllocator: Reallocator<T, R, C, R, DimDiff<C, D>>,
     {
         let mut m = self.into_owned();
         let (nrows, ncols) = m.data.shape();
@@ -468,32 +466,31 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
      */
     /// Removes the `i`-th row from this matrix.
     #[inline]
-    pub fn remove_row(self, i: usize) -> MatrixMN<N, DimDiff<R, U1>, C>
+    pub fn remove_row(self, i: usize) -> OMatrix<T, DimDiff<R, U1>, C>
     where
         R: DimSub<U1>,
-        DefaultAllocator: Reallocator<N, R, C, DimDiff<R, U1>, C>,
+        DefaultAllocator: Reallocator<T, R, C, DimDiff<R, U1>, C>,
     {
-        self.remove_fixed_rows::<U1>(i)
+        self.remove_fixed_rows::<1>(i)
     }
 
     /// Removes `D::dim()` consecutive rows from this matrix, starting with the `i`-th (included).
     #[inline]
-    pub fn remove_fixed_rows<D>(self, i: usize) -> MatrixMN<N, DimDiff<R, D>, C>
+    pub fn remove_fixed_rows<const D: usize>(self, i: usize) -> OMatrix<T, DimDiff<R, Const<D>>, C>
     where
-        D: DimName,
-        R: DimSub<D>,
-        DefaultAllocator: Reallocator<N, R, C, DimDiff<R, D>, C>,
+        R: DimSub<Const<D>>,
+        DefaultAllocator: Reallocator<T, R, C, DimDiff<R, Const<D>>, C>,
     {
-        self.remove_rows_generic(i, D::name())
+        self.remove_rows_generic(i, Const::<D>)
     }
 
     /// 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) -> MatrixMN<N, Dynamic, C>
+    pub fn remove_rows(self, i: usize, n: usize) -> OMatrix<T, Dynamic, C>
     where
         R: DimSub<Dynamic, Output = Dynamic>,
-        DefaultAllocator: Reallocator<N, R, C, Dynamic, C>,
+        DefaultAllocator: Reallocator<T, R, C, Dynamic, C>,
     {
         self.remove_rows_generic(i, Dynamic::new(n))
     }
@@ -503,11 +500,11 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     /// This is the generic implementation of `.remove_rows(...)` and `.remove_fixed_rows(...)`
     /// which have nicer API interfaces.
     #[inline]
-    pub fn remove_rows_generic<D>(self, i: usize, nremove: D) -> MatrixMN<N, DimDiff<R, D>, C>
+    pub fn remove_rows_generic<D>(self, i: usize, nremove: D) -> OMatrix<T, DimDiff<R, D>, C>
     where
         D: Dim,
         R: DimSub<D>,
-        DefaultAllocator: Reallocator<N, R, C, DimDiff<R, D>, C>,
+        DefaultAllocator: Reallocator<T, R, C, DimDiff<R, D>, C>,
     {
         let mut m = self.into_owned();
         let (nrows, ncols) = m.data.shape();
@@ -539,7 +536,7 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
 }
 
 /// # Rows and columns insertion
-impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
+impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
     /*
      *
      * Columns insertion.
@@ -547,23 +544,26 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
      */
     /// Inserts a column filled with `val` at the `i-th` position.
     #[inline]
-    pub fn insert_column(self, i: usize, val: N) -> MatrixMN<N, R, DimSum<C, U1>>
+    pub fn insert_column(self, i: usize, val: T) -> OMatrix<T, R, DimSum<C, U1>>
     where
         C: DimAdd<U1>,
-        DefaultAllocator: Reallocator<N, R, C, R, DimSum<C, U1>>,
+        DefaultAllocator: Reallocator<T, R, C, R, DimSum<C, U1>>,
     {
-        self.insert_fixed_columns::<U1>(i, val)
+        self.insert_fixed_columns::<1>(i, val)
     }
 
-    /// Inserts `D::dim()` columns filled with `val` starting at the `i-th` position.
+    /// Inserts `D` columns filled with `val` starting at the `i-th` position.
     #[inline]
-    pub fn insert_fixed_columns<D>(self, i: usize, val: N) -> MatrixMN<N, R, DimSum<C, D>>
+    pub fn insert_fixed_columns<const D: usize>(
+        self,
+        i: usize,
+        val: T,
+    ) -> OMatrix<T, R, DimSum<C, Const<D>>>
     where
-        D: DimName,
-        C: DimAdd<D>,
-        DefaultAllocator: Reallocator<N, R, C, R, DimSum<C, D>>,
+        C: DimAdd<Const<D>>,
+        DefaultAllocator: Reallocator<T, R, C, R, DimSum<C, Const<D>>>,
     {
-        let mut res = unsafe { self.insert_columns_generic_uninitialized(i, D::name()) };
+        let mut res = unsafe { self.insert_columns_generic_uninitialized(i, Const::<D>) };
         res.fixed_columns_mut::<D>(i).fill(val);
         res
     }
@@ -571,10 +571,10 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, 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: N) -> MatrixMN<N, R, Dynamic>
+    pub fn insert_columns(self, i: usize, n: usize, val: T) -> OMatrix<T, R, Dynamic>
     where
         C: DimAdd<Dynamic, Output = Dynamic>,
-        DefaultAllocator: Reallocator<N, R, C, R, Dynamic>,
+        DefaultAllocator: Reallocator<T, R, C, R, Dynamic>,
     {
         let mut res = unsafe { self.insert_columns_generic_uninitialized(i, Dynamic::new(n)) };
         res.columns_mut(i, n).fill(val);
@@ -589,11 +589,11 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
         self,
         i: usize,
         ninsert: D,
-    ) -> MatrixMN<N, R, DimSum<C, D>>
+    ) -> OMatrix<T, R, DimSum<C, D>>
     where
         D: Dim,
         C: DimAdd<D>,
-        DefaultAllocator: Reallocator<N, R, C, R, DimSum<C, D>>,
+        DefaultAllocator: Reallocator<T, R, C, R, DimSum<C, D>>,
     {
         let m = self.into_owned();
         let (nrows, ncols) = m.data.shape();
@@ -625,23 +625,26 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
      */
     /// Inserts a row filled with `val` at the `i-th` position.
     #[inline]
-    pub fn insert_row(self, i: usize, val: N) -> MatrixMN<N, DimSum<R, U1>, C>
+    pub fn insert_row(self, i: usize, val: T) -> OMatrix<T, DimSum<R, U1>, C>
     where
         R: DimAdd<U1>,
-        DefaultAllocator: Reallocator<N, R, C, DimSum<R, U1>, C>,
+        DefaultAllocator: Reallocator<T, R, C, DimSum<R, U1>, C>,
     {
-        self.insert_fixed_rows::<U1>(i, val)
+        self.insert_fixed_rows::<1>(i, val)
     }
 
     /// Inserts `D::dim()` rows filled with `val` starting at the `i-th` position.
     #[inline]
-    pub fn insert_fixed_rows<D>(self, i: usize, val: N) -> MatrixMN<N, DimSum<R, D>, C>
+    pub fn insert_fixed_rows<const D: usize>(
+        self,
+        i: usize,
+        val: T,
+    ) -> OMatrix<T, DimSum<R, Const<D>>, C>
     where
-        D: DimName,
-        R: DimAdd<D>,
-        DefaultAllocator: Reallocator<N, R, C, DimSum<R, D>, C>,
+        R: DimAdd<Const<D>>,
+        DefaultAllocator: Reallocator<T, R, C, DimSum<R, Const<D>>, C>,
     {
-        let mut res = unsafe { self.insert_rows_generic_uninitialized(i, D::name()) };
+        let mut res = unsafe { self.insert_rows_generic_uninitialized(i, Const::<D>) };
         res.fixed_rows_mut::<D>(i).fill(val);
         res
     }
@@ -649,10 +652,10 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, 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: N) -> MatrixMN<N, Dynamic, C>
+    pub fn insert_rows(self, i: usize, n: usize, val: T) -> OMatrix<T, Dynamic, C>
     where
         R: DimAdd<Dynamic, Output = Dynamic>,
-        DefaultAllocator: Reallocator<N, R, C, Dynamic, C>,
+        DefaultAllocator: Reallocator<T, R, C, Dynamic, C>,
     {
         let mut res = unsafe { self.insert_rows_generic_uninitialized(i, Dynamic::new(n)) };
         res.rows_mut(i, n).fill(val);
@@ -669,11 +672,11 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
         self,
         i: usize,
         ninsert: D,
-    ) -> MatrixMN<N, DimSum<R, D>, C>
+    ) -> OMatrix<T, DimSum<R, D>, C>
     where
         D: Dim,
         R: DimAdd<D>,
-        DefaultAllocator: Reallocator<N, R, C, DimSum<R, D>, C>,
+        DefaultAllocator: Reallocator<T, R, C, DimSum<R, D>, C>,
     {
         let m = self.into_owned();
         let (nrows, ncols) = m.data.shape();
@@ -700,15 +703,15 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
 }
 
 /// # Resizing and reshaping
-impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
+impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
     /// Resizes this matrix so that it contains `new_nrows` rows and `new_ncols` columns.
     ///
     /// 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: N) -> DMatrix<N>
+    pub fn resize(self, new_nrows: usize, new_ncols: usize, val: T) -> OMatrix<T, Dynamic, Dynamic>
     where
-        DefaultAllocator: Reallocator<N, R, C, Dynamic, Dynamic>,
+        DefaultAllocator: Reallocator<T, R, C, Dynamic, Dynamic>,
     {
         self.resize_generic(Dynamic::new(new_nrows), Dynamic::new(new_ncols), val)
     }
@@ -718,9 +721,9 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, 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: N) -> MatrixMN<N, Dynamic, C>
+    pub fn resize_vertically(self, new_nrows: usize, val: T) -> OMatrix<T, Dynamic, C>
     where
-        DefaultAllocator: Reallocator<N, R, C, Dynamic, C>,
+        DefaultAllocator: Reallocator<T, R, C, Dynamic, C>,
     {
         let ncols = self.data.shape().1;
         self.resize_generic(Dynamic::new(new_nrows), ncols, val)
@@ -731,9 +734,9 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, 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: N) -> MatrixMN<N, R, Dynamic>
+    pub fn resize_horizontally(self, new_ncols: usize, val: T) -> OMatrix<T, R, Dynamic>
     where
-        DefaultAllocator: Reallocator<N, R, C, R, Dynamic>,
+        DefaultAllocator: Reallocator<T, R, C, R, Dynamic>,
     {
         let nrows = self.data.shape().0;
         self.resize_generic(nrows, Dynamic::new(new_ncols), val)
@@ -743,11 +746,14 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, 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`.
-    pub fn fixed_resize<R2: DimName, C2: DimName>(self, val: N) -> MatrixMN<N, R2, C2>
+    pub fn fixed_resize<const R2: usize, const C2: usize>(
+        self,
+        val: T,
+    ) -> OMatrix<T, Const<R2>, Const<C2>>
     where
-        DefaultAllocator: Reallocator<N, R, C, R2, C2>,
+        DefaultAllocator: Reallocator<T, R, C, Const<R2>, Const<C2>>,
     {
-        self.resize_generic(R2::name(), C2::name(), val)
+        self.resize_generic(Const::<R2>, Const::<C2>, val)
     }
 
     /// Resizes `self` such that it has dimensions `new_nrows × new_ncols`.
@@ -759,10 +765,10 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
         self,
         new_nrows: R2,
         new_ncols: C2,
-        val: N,
-    ) -> MatrixMN<N, R2, C2>
+        val: T,
+    ) -> OMatrix<T, R2, C2>
     where
-        DefaultAllocator: Reallocator<N, R, C, R2, C2>,
+        DefaultAllocator: Reallocator<T, R, C, R2, C2>,
     {
         let (nrows, ncols) = self.shape();
         let mut data = self.data.into_owned();
@@ -831,7 +837,7 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     /// # Examples
     ///
     /// ```
-    /// # use nalgebra::{Matrix3x2, Matrix2x3, DMatrix, U2, U3, Dynamic};
+    /// # use nalgebra::{Matrix3x2, Matrix2x3, DMatrix, Const, Dynamic};
     ///
     /// let m1 = Matrix2x3::new(
     ///     1.1, 1.2, 1.3,
@@ -842,7 +848,7 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     ///     2.1, 1.3,
     ///     1.2, 2.3
     /// );
-    /// let reshaped = m1.reshape_generic(U3, U2);
+    /// let reshaped = m1.reshape_generic(Const::<3>, Const::<2>);
     /// assert_eq!(reshaped, m2);
     ///
     /// let dm1 = DMatrix::from_row_slice(
@@ -874,11 +880,11 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
         self,
         new_nrows: R2,
         new_ncols: C2,
-    ) -> Matrix<N, R2, C2, S::Output>
+    ) -> Matrix<T, R2, C2, S::Output>
     where
         R2: Dim,
         C2: Dim,
-        S: ReshapableStorage<N, R, C, R2, C2>,
+        S: ReshapableStorage<T, R, C, R2, C2>,
     {
         let data = self.data.reshape_generic(new_nrows, new_ncols);
         Matrix::from_data(data)
@@ -887,16 +893,16 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
 
 /// # In-place resizing
 #[cfg(any(feature = "std", feature = "alloc"))]
-impl<N: Scalar> DMatrix<N> {
+impl<T: Scalar> OMatrix<T, Dynamic, Dynamic> {
     /// Resizes this matrix in-place.
     ///
     /// 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`.
     ///
     /// Defined only for owned fully-dynamic matrices, i.e., `DMatrix`.
-    pub fn resize_mut(&mut self, new_nrows: usize, new_ncols: usize, val: N)
+    pub fn resize_mut(&mut self, new_nrows: usize, new_ncols: usize, val: T)
     where
-        DefaultAllocator: Reallocator<N, Dynamic, Dynamic, Dynamic, Dynamic>,
+        DefaultAllocator: Reallocator<T, Dynamic, Dynamic, Dynamic, Dynamic>,
     {
         let placeholder = unsafe {
             crate::unimplemented_or_uninitialized_generic!(Dynamic::new(0), Dynamic::new(0))
@@ -908,9 +914,9 @@ impl<N: Scalar> DMatrix<N> {
 }
 
 #[cfg(any(feature = "std", feature = "alloc"))]
-impl<N: Scalar, C: Dim> MatrixMN<N, Dynamic, C>
+impl<T: Scalar, C: Dim> OMatrix<T, Dynamic, C>
 where
-    DefaultAllocator: Allocator<N, Dynamic, C>,
+    DefaultAllocator: Allocator<T, Dynamic, C>,
 {
     /// Changes the number of rows of this matrix in-place.
     ///
@@ -919,9 +925,9 @@ where
     ///
     /// Defined only for owned matrices with a dynamic number of rows (for example, `DVector`).
     #[cfg(any(feature = "std", feature = "alloc"))]
-    pub fn resize_vertically_mut(&mut self, new_nrows: usize, val: N)
+    pub fn resize_vertically_mut(&mut self, new_nrows: usize, val: T)
     where
-        DefaultAllocator: Reallocator<N, Dynamic, C, Dynamic, C>,
+        DefaultAllocator: Reallocator<T, Dynamic, C, Dynamic, C>,
     {
         let placeholder = unsafe {
             crate::unimplemented_or_uninitialized_generic!(Dynamic::new(0), self.data.shape().1)
@@ -933,9 +939,9 @@ where
 }
 
 #[cfg(any(feature = "std", feature = "alloc"))]
-impl<N: Scalar, R: Dim> MatrixMN<N, R, Dynamic>
+impl<T: Scalar, R: Dim> OMatrix<T, R, Dynamic>
 where
-    DefaultAllocator: Allocator<N, R, Dynamic>,
+    DefaultAllocator: Allocator<T, R, Dynamic>,
 {
     /// Changes the number of column of this matrix in-place.
     ///
@@ -944,9 +950,9 @@ where
     ///
     /// Defined only for owned matrices with a dynamic number of columns (for example, `DVector`).
     #[cfg(any(feature = "std", feature = "alloc"))]
-    pub fn resize_horizontally_mut(&mut self, new_ncols: usize, val: N)
+    pub fn resize_horizontally_mut(&mut self, new_ncols: usize, val: T)
     where
-        DefaultAllocator: Reallocator<N, R, Dynamic, R, Dynamic>,
+        DefaultAllocator: Reallocator<T, R, Dynamic, R, Dynamic>,
     {
         let placeholder = unsafe {
             crate::unimplemented_or_uninitialized_generic!(self.data.shape().0, Dynamic::new(0))
@@ -957,8 +963,8 @@ where
     }
 }
 
-unsafe fn compress_rows<N: Scalar>(
-    data: &mut [N],
+unsafe fn compress_rows<T: Scalar>(
+    data: &mut [T],
     nrows: usize,
     ncols: usize,
     i: usize,
@@ -996,8 +1002,8 @@ unsafe fn compress_rows<N: Scalar>(
 
 // Moves entries of a matrix buffer to make place for `ninsert` emty rows starting at the `i-th` row index.
 // The `data` buffer is assumed to contained at least `(nrows + ninsert) * ncols` elements.
-unsafe fn extend_rows<N: Scalar>(
-    data: &mut [N],
+unsafe fn extend_rows<T: Scalar>(
+    data: &mut [T],
     nrows: usize,
     ncols: usize,
     i: usize,
@@ -1032,18 +1038,18 @@ unsafe fn extend_rows<N: Scalar>(
 /// Extend the number of columns of the `Matrix` with elements from
 /// a given iterator.
 #[cfg(any(feature = "std", feature = "alloc"))]
-impl<N, R, S> Extend<N> for Matrix<N, R, Dynamic, S>
+impl<T, R, S> Extend<T> for Matrix<T, R, Dynamic, S>
 where
-    N: Scalar,
+    T: Scalar,
     R: Dim,
-    S: Extend<N>,
+    S: Extend<T>,
 {
     /// Extend the number of columns of the `Matrix` with elements
     /// from the given iterator.
     ///
     /// # Example
     /// ```
-    /// # use nalgebra::{DMatrix, Dynamic, Matrix, MatrixMN, Matrix3};
+    /// # use nalgebra::{DMatrix, Dynamic, Matrix, OMatrix, Matrix3};
     ///
     /// let data = vec![0, 1, 2,      // column 1
     ///                 3, 4, 5];     // column 2
@@ -1063,7 +1069,7 @@ where
     /// `Matrix`.
     ///
     /// ```should_panic
-    /// # use nalgebra::{DMatrix, Dynamic, MatrixMN};
+    /// # use nalgebra::{DMatrix, Dynamic, OMatrix};
     /// let data = vec![0, 1, 2,  // column 1
     ///                 3, 4, 5]; // column 2
     ///
@@ -1072,7 +1078,7 @@ where
     /// // The following panics because the vec length is not a multiple of 3.
     /// matrix.extend(vec![6, 7, 8, 9]);
     /// ```
-    fn extend<I: IntoIterator<Item = N>>(&mut self, iter: I) {
+    fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) {
         self.data.extend(iter);
     }
 }
@@ -1080,10 +1086,10 @@ where
 /// Extend the number of rows of the `Vector` with elements from
 /// a given iterator.
 #[cfg(any(feature = "std", feature = "alloc"))]
-impl<N, S> Extend<N> for Matrix<N, Dynamic, U1, S>
+impl<T, S> Extend<T> for Matrix<T, Dynamic, U1, S>
 where
-    N: Scalar,
-    S: Extend<N>,
+    T: Scalar,
+    S: Extend<T>,
 {
     /// Extend the number of rows of a `Vector` with elements
     /// from the given iterator.
@@ -1095,19 +1101,19 @@ where
     /// vector.extend(vec![3, 4, 5]);
     /// assert!(vector.eq(&DVector::from_vec(vec![0, 1, 2, 3, 4, 5])));
     /// ```
-    fn extend<I: IntoIterator<Item = N>>(&mut self, iter: I) {
+    fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) {
         self.data.extend(iter);
     }
 }
 
 #[cfg(any(feature = "std", feature = "alloc"))]
-impl<N, R, S, RV, SV> Extend<Vector<N, RV, SV>> for Matrix<N, R, Dynamic, S>
+impl<T, R, S, RV, SV> Extend<Vector<T, RV, SV>> for Matrix<T, R, Dynamic, S>
 where
-    N: Scalar,
+    T: Scalar,
     R: Dim,
-    S: Extend<Vector<N, RV, SV>>,
+    S: Extend<Vector<T, RV, SV>>,
     RV: Dim,
-    SV: Storage<N, RV>,
+    SV: Storage<T, RV>,
     ShapeConstraint: SameNumberOfRows<R, RV>,
 {
     /// Extends the number of columns of a `Matrix` with `Vector`s
@@ -1159,7 +1165,7 @@ where
     /// matrix.extend(
     ///   vec![Vector4::new(6, 7, 8, 9)]); // too few dimensions!
     /// ```
-    fn extend<I: IntoIterator<Item = Vector<N, RV, SV>>>(&mut self, iter: I) {
+    fn extend<I: IntoIterator<Item = Vector<T, RV, SV>>>(&mut self, iter: I) {
         self.data.extend(iter);
     }
 }
diff --git a/src/base/indexing.rs b/src/base/indexing.rs
index 998cfff8..17fd1f66 100644
--- a/src/base/indexing.rs
+++ b/src/base/indexing.rs
@@ -2,12 +2,12 @@
 
 use crate::base::storage::{Storage, StorageMut};
 use crate::base::{
-    Dim, DimDiff, DimName, DimSub, Dynamic, Matrix, MatrixSlice, MatrixSliceMut, Scalar, U1,
+    Const, Dim, DimDiff, DimName, DimSub, Dynamic, Matrix, MatrixSlice, MatrixSliceMut, Scalar, U1,
 };
 
 use std::ops;
 
-// N.B.: Not a public trait!
+// T.B.: Not a public trait!
 trait DimRange<D: Dim> {
     /// The number of elements indexed by this range.
     type Length: Dim;
@@ -32,7 +32,7 @@ impl<D: Dim> DimRange<D> for usize {
 
     #[inline(always)]
     fn length(&self, _: D) -> Self::Length {
-        U1
+        Const::<1>
     }
 
     #[inline(always)]
@@ -43,9 +43,8 @@ impl<D: Dim> DimRange<D> for usize {
 
 #[test]
 fn dimrange_usize() {
-    use crate::base::dimension::U0;
-    assert_eq!(DimRange::contained_by(&0, U0), false);
-    assert_eq!(DimRange::contained_by(&0, U1), true);
+    assert_eq!(DimRange::contained_by(&0, Const::<0>), false);
+    assert_eq!(DimRange::contained_by(&0, Const::<1>), true);
 }
 
 impl<D: Dim> DimRange<D> for ops::Range<usize> {
@@ -69,11 +68,10 @@ impl<D: Dim> DimRange<D> for ops::Range<usize> {
 
 #[test]
 fn dimrange_range_usize() {
-    use crate::base::dimension::U0;
     use std::usize::MAX;
-    assert_eq!(DimRange::contained_by(&(0..0), U0), false);
-    assert_eq!(DimRange::contained_by(&(0..1), U0), false);
-    assert_eq!(DimRange::contained_by(&(0..1), U1), true);
+    assert_eq!(DimRange::contained_by(&(0..0), Const::<0>), false);
+    assert_eq!(DimRange::contained_by(&(0..1), Const::<0>), false);
+    assert_eq!(DimRange::contained_by(&(0..1), Const::<1>), true);
     assert_eq!(
         DimRange::contained_by(&((MAX - 1)..MAX), Dynamic::new(MAX)),
         true
@@ -113,11 +111,10 @@ impl<D: Dim> DimRange<D> for ops::RangeFrom<usize> {
 
 #[test]
 fn dimrange_rangefrom_usize() {
-    use crate::base::dimension::U0;
     use std::usize::MAX;
-    assert_eq!(DimRange::contained_by(&(0..), U0), false);
-    assert_eq!(DimRange::contained_by(&(0..), U0), false);
-    assert_eq!(DimRange::contained_by(&(0..), U1), true);
+    assert_eq!(DimRange::contained_by(&(0..), Const::<0>), false);
+    assert_eq!(DimRange::contained_by(&(0..), Const::<0>), false);
+    assert_eq!(DimRange::contained_by(&(0..), Const::<1>), true);
     assert_eq!(
         DimRange::contained_by(&((MAX - 1)..), Dynamic::new(MAX)),
         true
@@ -156,8 +153,7 @@ where
 
 #[test]
 fn dimrange_rangefrom_dimname() {
-    use crate::base::dimension::{U4, U5};
-    assert_eq!(DimRange::length(&(U1..), U5), U4);
+    assert_eq!(DimRange::length(&(Const::<1>..), Const::<5>), Const::<4>);
 }
 
 impl<D: Dim> DimRange<D> for ops::RangeFull {
@@ -181,9 +177,8 @@ impl<D: Dim> DimRange<D> for ops::RangeFull {
 
 #[test]
 fn dimrange_rangefull() {
-    use crate::base::dimension::U0;
-    assert_eq!(DimRange::contained_by(&(..), U0), true);
-    assert_eq!(DimRange::length(&(..), U1), U1);
+    assert_eq!(DimRange::contained_by(&(..), Const::<0>), true);
+    assert_eq!(DimRange::length(&(..), Const::<1>), Const::<1>);
 }
 
 impl<D: Dim> DimRange<D> for ops::RangeInclusive<usize> {
@@ -211,10 +206,9 @@ impl<D: Dim> DimRange<D> for ops::RangeInclusive<usize> {
 
 #[test]
 fn dimrange_rangeinclusive_usize() {
-    use crate::base::dimension::U0;
     use std::usize::MAX;
-    assert_eq!(DimRange::contained_by(&(0..=0), U0), false);
-    assert_eq!(DimRange::contained_by(&(0..=0), U1), true);
+    assert_eq!(DimRange::contained_by(&(0..=0), Const::<0>), false);
+    assert_eq!(DimRange::contained_by(&(0..=0), Const::<1>), true);
     assert_eq!(
         DimRange::contained_by(&(MAX..=MAX), Dynamic::new(MAX)),
         false
@@ -227,7 +221,7 @@ fn dimrange_rangeinclusive_usize() {
         DimRange::contained_by(&((MAX - 1)..=(MAX - 1)), Dynamic::new(MAX)),
         true
     );
-    assert_eq!(DimRange::length(&(0..=0), U1), Dynamic::new(1));
+    assert_eq!(DimRange::length(&(0..=0), Const::<1>), Dynamic::new(1));
     assert_eq!(
         DimRange::length(&((MAX - 1)..=MAX), Dynamic::new(MAX)),
         Dynamic::new(2)
@@ -263,11 +257,10 @@ impl<D: Dim> DimRange<D> for ops::RangeTo<usize> {
 
 #[test]
 fn dimrange_rangeto_usize() {
-    use crate::base::dimension::U0;
     use std::usize::MAX;
-    assert_eq!(DimRange::contained_by(&(..0), U0), true);
-    assert_eq!(DimRange::contained_by(&(..1), U0), false);
-    assert_eq!(DimRange::contained_by(&(..0), U1), true);
+    assert_eq!(DimRange::contained_by(&(..0), Const::<0>), true);
+    assert_eq!(DimRange::contained_by(&(..1), Const::<0>), false);
+    assert_eq!(DimRange::contained_by(&(..0), Const::<1>), true);
     assert_eq!(
         DimRange::contained_by(&(..(MAX - 1)), Dynamic::new(MAX)),
         true
@@ -303,11 +296,10 @@ impl<D: Dim> DimRange<D> for ops::RangeToInclusive<usize> {
 
 #[test]
 fn dimrange_rangetoinclusive_usize() {
-    use crate::base::dimension::U0;
     use std::usize::MAX;
-    assert_eq!(DimRange::contained_by(&(..=0), U0), false);
-    assert_eq!(DimRange::contained_by(&(..=1), U0), false);
-    assert_eq!(DimRange::contained_by(&(..=0), U1), true);
+    assert_eq!(DimRange::contained_by(&(..=0), Const::<0>), false);
+    assert_eq!(DimRange::contained_by(&(..=1), Const::<0>), false);
+    assert_eq!(DimRange::contained_by(&(..=0), Const::<1>), true);
     assert_eq!(
         DimRange::contained_by(&(..=(MAX)), Dynamic::new(MAX)),
         false
@@ -323,19 +315,19 @@ fn dimrange_rangetoinclusive_usize() {
 }
 
 /// A helper trait used for indexing operations.
-pub trait MatrixIndex<'a, N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>>: Sized {
+pub trait MatrixIndex<'a, T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>>: Sized {
     /// The output type returned by methods.
     type Output: 'a;
 
     /// Produces true if the given matrix is contained by this index.
     #[doc(hidden)]
-    fn contained_by(&self, matrix: &Matrix<N, R, C, S>) -> bool;
+    fn contained_by(&self, matrix: &Matrix<T, R, C, S>) -> bool;
 
     /// Produces a shared view of the data at this location if in bounds,
     /// or `None`, otherwise.
     #[doc(hidden)]
     #[inline(always)]
-    fn get(self, matrix: &'a Matrix<N, R, C, S>) -> Option<Self::Output> {
+    fn get(self, matrix: &'a Matrix<T, R, C, S>) -> Option<Self::Output> {
         if self.contained_by(matrix) {
             Some(unsafe { self.get_unchecked(matrix) })
         } else {
@@ -346,20 +338,20 @@ pub trait MatrixIndex<'a, N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>>: Sized
     /// Produces a shared view of the data at this location if in bounds
     /// without any bounds checking.
     #[doc(hidden)]
-    unsafe fn get_unchecked(self, matrix: &'a Matrix<N, R, C, S>) -> Self::Output;
+    unsafe fn get_unchecked(self, matrix: &'a Matrix<T, R, C, S>) -> Self::Output;
 
     /// Produces a shared view to the data at this location, or panics
     /// if out of bounds.
     #[doc(hidden)]
     #[inline(always)]
-    fn index(self, matrix: &'a Matrix<N, R, C, S>) -> Self::Output {
+    fn index(self, matrix: &'a Matrix<T, R, C, S>) -> Self::Output {
         self.get(matrix).expect("Index out of bounds.")
     }
 }
 
 /// A helper trait used for indexing operations.
-pub trait MatrixIndexMut<'a, N: Scalar, R: Dim, C: Dim, S: StorageMut<N, R, C>>:
-    MatrixIndex<'a, N, R, C, S>
+pub trait MatrixIndexMut<'a, T: Scalar, R: Dim, C: Dim, S: StorageMut<T, R, C>>:
+    MatrixIndex<'a, T, R, C, S>
 {
     /// The output type returned by methods.
     type OutputMut: 'a;
@@ -367,13 +359,13 @@ pub trait MatrixIndexMut<'a, N: Scalar, R: Dim, C: Dim, S: StorageMut<N, R, C>>:
     /// Produces a mutable view of the data at this location, without
     /// performing any bounds checking.
     #[doc(hidden)]
-    unsafe fn get_unchecked_mut(self, matrix: &'a mut Matrix<N, R, C, S>) -> Self::OutputMut;
+    unsafe fn get_unchecked_mut(self, matrix: &'a mut Matrix<T, R, C, S>) -> Self::OutputMut;
 
     /// Produces a mutable view of the data at this location, if in
     /// bounds.
     #[doc(hidden)]
     #[inline(always)]
-    fn get_mut(self, matrix: &'a mut Matrix<N, R, C, S>) -> Option<Self::OutputMut> {
+    fn get_mut(self, matrix: &'a mut Matrix<T, R, C, S>) -> Option<Self::OutputMut> {
         if self.contained_by(matrix) {
             Some(unsafe { self.get_unchecked_mut(matrix) })
         } else {
@@ -385,7 +377,7 @@ pub trait MatrixIndexMut<'a, N: Scalar, R: Dim, C: Dim, S: StorageMut<N, R, C>>:
     /// if out of bounds.
     #[doc(hidden)]
     #[inline(always)]
-    fn index_mut(self, matrix: &'a mut Matrix<N, R, C, S>) -> Self::OutputMut {
+    fn index_mut(self, matrix: &'a mut Matrix<T, R, C, S>) -> Self::OutputMut {
         self.get_mut(matrix).expect("Index out of bounds.")
     }
 }
@@ -461,7 +453,7 @@ pub trait MatrixIndexMut<'a, N: Scalar, R: Dim, C: Dim, S: StorageMut<N, R, C>>:
 ///     .eq(&Matrix2x1::new(0,
 ///                         1)));
 ///
-/// assert!(matrix.index((U1.., 0))
+/// assert!(matrix.index((Const::<1>.., 0))
 ///     .eq(&Matrix2x1::new(1,
 ///                         2)));
 /// ```
@@ -489,13 +481,13 @@ pub trait MatrixIndexMut<'a, N: Scalar, R: Dim, C: Dim, S: StorageMut<N, R, C>>:
 ///                         4, 7,
 ///                         5, 8)));
 /// ```
-impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
+impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
     /// Produces a view of the data at the given index, or
     /// `None` if the index is out of bounds.
     #[inline]
     pub fn get<'a, I>(&'a self, index: I) -> Option<I::Output>
     where
-        I: MatrixIndex<'a, N, R, C, S>,
+        I: MatrixIndex<'a, T, R, C, S>,
     {
         index.get(self)
     }
@@ -505,8 +497,8 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     #[inline]
     pub fn get_mut<'a, I>(&'a mut self, index: I) -> Option<I::OutputMut>
     where
-        S: StorageMut<N, R, C>,
-        I: MatrixIndexMut<'a, N, R, C, S>,
+        S: StorageMut<T, R, C>,
+        I: MatrixIndexMut<'a, T, R, C, S>,
     {
         index.get_mut(self)
     }
@@ -516,7 +508,7 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     #[inline]
     pub fn index<'a, I>(&'a self, index: I) -> I::Output
     where
-        I: MatrixIndex<'a, N, R, C, S>,
+        I: MatrixIndex<'a, T, R, C, S>,
     {
         index.index(self)
     }
@@ -526,8 +518,8 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     #[inline]
     pub fn index_mut<'a, I>(&'a mut self, index: I) -> I::OutputMut
     where
-        S: StorageMut<N, R, C>,
-        I: MatrixIndexMut<'a, N, R, C, S>,
+        S: StorageMut<T, R, C>,
+        I: MatrixIndexMut<'a, T, R, C, S>,
     {
         index.index_mut(self)
     }
@@ -537,7 +529,7 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     #[inline]
     pub unsafe fn get_unchecked<'a, I>(&'a self, index: I) -> I::Output
     where
-        I: MatrixIndex<'a, N, R, C, S>,
+        I: MatrixIndex<'a, T, R, C, S>,
     {
         index.get_unchecked(self)
     }
@@ -547,8 +539,8 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     #[inline]
     pub unsafe fn get_unchecked_mut<'a, I>(&'a mut self, index: I) -> I::OutputMut
     where
-        S: StorageMut<N, R, C>,
-        I: MatrixIndexMut<'a, N, R, C, S>,
+        S: StorageMut<T, R, C>,
+        I: MatrixIndexMut<'a, T, R, C, S>,
     {
         index.get_unchecked_mut(self)
     }
@@ -556,42 +548,42 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
 
 // EXTRACT A SINGLE ELEMENT BY 1D LINEAR ADDRESS
 
-impl<'a, N, R, C, S> MatrixIndex<'a, N, R, C, S> for usize
+impl<'a, T, R, C, S> MatrixIndex<'a, T, R, C, S> for usize
 where
-    N: Scalar,
+    T: Scalar,
     R: Dim,
     C: Dim,
-    S: Storage<N, R, C>,
+    S: Storage<T, R, C>,
 {
-    type Output = &'a N;
+    type Output = &'a T;
 
     #[doc(hidden)]
     #[inline(always)]
-    fn contained_by(&self, matrix: &Matrix<N, R, C, S>) -> bool {
+    fn contained_by(&self, matrix: &Matrix<T, R, C, S>) -> bool {
         *self < matrix.len()
     }
 
     #[doc(hidden)]
     #[inline(always)]
-    unsafe fn get_unchecked(self, matrix: &'a Matrix<N, R, C, S>) -> Self::Output {
+    unsafe fn get_unchecked(self, matrix: &'a Matrix<T, R, C, S>) -> Self::Output {
         matrix.data.get_unchecked_linear(self)
     }
 }
 
-impl<'a, N, R, C, S> MatrixIndexMut<'a, N, R, C, S> for usize
+impl<'a, T, R, C, S> MatrixIndexMut<'a, T, R, C, S> for usize
 where
-    N: Scalar,
+    T: Scalar,
     R: Dim,
     C: Dim,
-    S: StorageMut<N, R, C>,
+    S: StorageMut<T, R, C>,
 {
-    type OutputMut = &'a mut N;
+    type OutputMut = &'a mut T;
 
     #[doc(hidden)]
     #[inline(always)]
-    unsafe fn get_unchecked_mut(self, matrix: &'a mut Matrix<N, R, C, S>) -> Self::OutputMut
+    unsafe fn get_unchecked_mut(self, matrix: &'a mut Matrix<T, R, C, S>) -> Self::OutputMut
     where
-        S: StorageMut<N, R, C>,
+        S: StorageMut<T, R, C>,
     {
         matrix.data.get_unchecked_linear_mut(self)
     }
@@ -599,18 +591,18 @@ where
 
 // EXTRACT A SINGLE ELEMENT BY 2D COORDINATES
 
-impl<'a, N, R, C, S> MatrixIndex<'a, N, R, C, S> for (usize, usize)
+impl<'a, T, R, C, S> MatrixIndex<'a, T, R, C, S> for (usize, usize)
 where
-    N: Scalar,
+    T: Scalar,
     R: Dim,
     C: Dim,
-    S: Storage<N, R, C>,
+    S: Storage<T, R, C>,
 {
-    type Output = &'a N;
+    type Output = &'a T;
 
     #[doc(hidden)]
     #[inline(always)]
-    fn contained_by(&self, matrix: &Matrix<N, R, C, S>) -> bool {
+    fn contained_by(&self, matrix: &Matrix<T, R, C, S>) -> bool {
         let (rows, cols) = self;
         let (nrows, ncols) = matrix.data.shape();
         DimRange::contained_by(rows, nrows) && DimRange::contained_by(cols, ncols)
@@ -618,26 +610,26 @@ where
 
     #[doc(hidden)]
     #[inline(always)]
-    unsafe fn get_unchecked(self, matrix: &'a Matrix<N, R, C, S>) -> Self::Output {
+    unsafe fn get_unchecked(self, matrix: &'a Matrix<T, R, C, S>) -> Self::Output {
         let (row, col) = self;
         matrix.data.get_unchecked(row, col)
     }
 }
 
-impl<'a, N, R, C, S> MatrixIndexMut<'a, N, R, C, S> for (usize, usize)
+impl<'a, T, R, C, S> MatrixIndexMut<'a, T, R, C, S> for (usize, usize)
 where
-    N: Scalar,
+    T: Scalar,
     R: Dim,
     C: Dim,
-    S: StorageMut<N, R, C>,
+    S: StorageMut<T, R, C>,
 {
-    type OutputMut = &'a mut N;
+    type OutputMut = &'a mut T;
 
     #[doc(hidden)]
     #[inline(always)]
-    unsafe fn get_unchecked_mut(self, matrix: &'a mut Matrix<N, R, C, S>) -> Self::OutputMut
+    unsafe fn get_unchecked_mut(self, matrix: &'a mut Matrix<T, R, C, S>) -> Self::OutputMut
     where
-        S: StorageMut<N, R, C>,
+        S: StorageMut<T, R, C>,
     {
         let (row, col) = self;
         matrix.data.get_unchecked_mut(row, col)
@@ -663,20 +655,20 @@ macro_rules! impl_index_pair {
         $(where $CConstraintType: ty: $CConstraintBound: ident $(<$($CConstraintBoundParams: ty $( = $CEqBound: ty )*),*>)* )*]
     ) =>
     {
-        impl<'a, N, $R, $C, S, $($RTyP : $RTyPB,)* $($CTyP : $CTyPB),*> MatrixIndex<'a, N, $R, $C, S> for ($RIdx, $CIdx)
+        impl<'a, T, $R, $C, S, $($RTyP : $RTyPB,)* $($CTyP : $CTyPB),*> MatrixIndex<'a, T, $R, $C, S> for ($RIdx, $CIdx)
         where
-            N: Scalar,
+            T: Scalar,
             $R: Dim,
             $C: Dim,
-            S: Storage<N, R, C>,
+            S: Storage<T, R, C>,
             $( $RConstraintType: $RConstraintBound $(<$( $RConstraintBoundParams $( = $REqBound )*),*>)* ,)*
             $( $CConstraintType: $CConstraintBound $(<$( $CConstraintBoundParams $( = $CEqBound )*),*>)* ),*
         {
-            type Output = MatrixSlice<'a, N, $ROut, $COut, S::RStride, S::CStride>;
+            type Output = MatrixSlice<'a, T, $ROut, $COut, S::RStride, S::CStride>;
 
             #[doc(hidden)]
             #[inline(always)]
-            fn contained_by(&self, matrix: &Matrix<N, $R, $C, S>) -> bool {
+            fn contained_by(&self, matrix: &Matrix<T, $R, $C, S>) -> bool {
                 let (rows, cols) = self;
                 let (nrows, ncols) = matrix.data.shape();
                 DimRange::contained_by(rows, nrows) && DimRange::contained_by(cols, ncols)
@@ -684,7 +676,7 @@ macro_rules! impl_index_pair {
 
             #[doc(hidden)]
             #[inline(always)]
-            unsafe fn get_unchecked(self, matrix: &'a Matrix<N, $R, $C, S>) -> Self::Output {
+            unsafe fn get_unchecked(self, matrix: &'a Matrix<T, $R, $C, S>) -> Self::Output {
                 use crate::base::SliceStorage;
 
                 let (rows, cols) = self;
@@ -699,20 +691,20 @@ macro_rules! impl_index_pair {
             }
         }
 
-        impl<'a, N, $R, $C, S, $($RTyP : $RTyPB,)* $($CTyP : $CTyPB),*> MatrixIndexMut<'a, N, $R, $C, S> for ($RIdx, $CIdx)
+        impl<'a, T, $R, $C, S, $($RTyP : $RTyPB,)* $($CTyP : $CTyPB),*> MatrixIndexMut<'a, T, $R, $C, S> for ($RIdx, $CIdx)
         where
-            N: Scalar,
+            T: Scalar,
             $R: Dim,
             $C: Dim,
-            S: StorageMut<N, R, C>,
+            S: StorageMut<T, R, C>,
             $( $RConstraintType: $RConstraintBound $(<$( $RConstraintBoundParams $( = $REqBound )*),*>)* ,)*
             $( $CConstraintType: $CConstraintBound $(<$( $CConstraintBoundParams $( = $CEqBound )*),*>)* ),*
         {
-            type OutputMut = MatrixSliceMut<'a, N, $ROut, $COut, S::RStride, S::CStride>;
+            type OutputMut = MatrixSliceMut<'a, T, $ROut, $COut, S::RStride, S::CStride>;
 
             #[doc(hidden)]
             #[inline(always)]
-            unsafe fn get_unchecked_mut(self, matrix: &'a mut Matrix<N, $R, $C, S>) -> Self::OutputMut {
+            unsafe fn get_unchecked_mut(self, matrix: &'a mut Matrix<T, $R, $C, S>) -> Self::OutputMut {
                 use crate::base::SliceStorageMut;
 
                 let (rows, cols) = self;
diff --git a/src/base/interpolation.rs b/src/base/interpolation.rs
index 1d74d203..c008743a 100644
--- a/src/base/interpolation.rs
+++ b/src/base/interpolation.rs
@@ -1,12 +1,12 @@
 use crate::storage::Storage;
 use crate::{
-    Allocator, DefaultAllocator, Dim, One, RealField, Scalar, Unit, Vector, VectorN, Zero,
+    Allocator, DefaultAllocator, Dim, OVector, One, RealField, Scalar, Unit, Vector, Zero,
 };
 use simba::scalar::{ClosedAdd, ClosedMul, ClosedSub};
 
 /// # Interpolation
-impl<N: Scalar + Zero + One + ClosedAdd + ClosedSub + ClosedMul, D: Dim, S: Storage<N, D>>
-    Vector<N, D, S>
+impl<T: Scalar + Zero + One + ClosedAdd + ClosedSub + ClosedMul, D: Dim, S: Storage<T, D>>
+    Vector<T, D, S>
 {
     /// Returns `self * (1.0 - t) + rhs * t`, i.e., the linear blend of the vectors x and y using the scalar value a.
     ///
@@ -20,12 +20,12 @@ impl<N: Scalar + Zero + One + ClosedAdd + ClosedSub + ClosedMul, D: Dim, S: Stor
     /// let y = Vector3::new(10.0, 20.0, 30.0);
     /// assert_eq!(x.lerp(&y, 0.1), Vector3::new(1.9, 3.8, 5.7));
     /// ```
-    pub fn lerp<S2: Storage<N, D>>(&self, rhs: &Vector<N, D, S2>, t: N) -> VectorN<N, D>
+    pub fn lerp<S2: Storage<T, D>>(&self, rhs: &Vector<T, D, S2>, t: T) -> OVector<T, D>
     where
-        DefaultAllocator: Allocator<N, D>,
+        DefaultAllocator: Allocator<T, D>,
     {
         let mut res = self.clone_owned();
-        res.axpy(t.inlined_clone(), rhs, N::one() - t);
+        res.axpy(t.inlined_clone(), rhs, T::one() - t);
         res
     }
 
@@ -45,10 +45,10 @@ impl<N: Scalar + Zero + One + ClosedAdd + ClosedSub + ClosedMul, D: Dim, S: Stor
     ///
     /// assert_eq!(v, v2.normalize());
     /// ```
-    pub fn slerp<S2: Storage<N, D>>(&self, rhs: &Vector<N, D, S2>, t: N) -> VectorN<N, D>
+    pub fn slerp<S2: Storage<T, D>>(&self, rhs: &Vector<T, D, S2>, t: T) -> OVector<T, D>
     where
-        N: RealField,
-        DefaultAllocator: Allocator<N, D>,
+        T: RealField,
+        DefaultAllocator: Allocator<T, D>,
     {
         let me = Unit::new_normalize(self.clone_owned());
         let rhs = Unit::new_normalize(rhs.clone_owned());
@@ -57,7 +57,7 @@ impl<N: Scalar + Zero + One + ClosedAdd + ClosedSub + ClosedMul, D: Dim, S: Stor
 }
 
 /// # Interpolation between two unit vectors
-impl<N: RealField, D: Dim, S: Storage<N, D>> Unit<Vector<N, D, S>> {
+impl<T: RealField, D: Dim, S: Storage<T, D>> Unit<Vector<T, D, S>> {
     /// Computes the spherical linear interpolation between two unit vectors.
     ///
     /// # Examples:
@@ -72,16 +72,16 @@ impl<N: RealField, D: Dim, S: Storage<N, D>> Unit<Vector<N, D, S>> {
     ///
     /// assert_eq!(v, v2);
     /// ```
-    pub fn slerp<S2: Storage<N, D>>(
+    pub fn slerp<S2: Storage<T, D>>(
         &self,
-        rhs: &Unit<Vector<N, D, S2>>,
-        t: N,
-    ) -> Unit<VectorN<N, D>>
+        rhs: &Unit<Vector<T, D, S2>>,
+        t: T,
+    ) -> Unit<OVector<T, D>>
     where
-        DefaultAllocator: Allocator<N, D>,
+        DefaultAllocator: Allocator<T, D>,
     {
         // TODO: the result is wrong when self and rhs are collinear with opposite direction.
-        self.try_slerp(rhs, t, N::default_epsilon())
+        self.try_slerp(rhs, t, T::default_epsilon())
             .unwrap_or_else(|| Unit::new_unchecked(self.clone_owned()))
     }
 
@@ -89,33 +89,33 @@ impl<N: RealField, D: Dim, S: Storage<N, D>> Unit<Vector<N, D, S>> {
     ///
     /// Returns `None` if the two vectors are almost collinear and with opposite direction
     /// (in this case, there is an infinity of possible results).
-    pub fn try_slerp<S2: Storage<N, D>>(
+    pub fn try_slerp<S2: Storage<T, D>>(
         &self,
-        rhs: &Unit<Vector<N, D, S2>>,
-        t: N,
-        epsilon: N,
-    ) -> Option<Unit<VectorN<N, D>>>
+        rhs: &Unit<Vector<T, D, S2>>,
+        t: T,
+        epsilon: T,
+    ) -> Option<Unit<OVector<T, D>>>
     where
-        DefaultAllocator: Allocator<N, D>,
+        DefaultAllocator: Allocator<T, D>,
     {
         let c_hang = self.dot(rhs);
 
         // self == other
-        if c_hang >= N::one() {
+        if c_hang >= T::one() {
             return Some(Unit::new_unchecked(self.clone_owned()));
         }
 
         let hang = c_hang.acos();
-        let s_hang = (N::one() - c_hang * c_hang).sqrt();
+        let s_hang = (T::one() - c_hang * c_hang).sqrt();
 
         // TODO: what if s_hang is 0.0 ? The result is not well-defined.
-        if relative_eq!(s_hang, N::zero(), epsilon = epsilon) {
+        if relative_eq!(s_hang, T::zero(), epsilon = epsilon) {
             None
         } else {
-            let ta = ((N::one() - t) * hang).sin() / s_hang;
+            let ta = ((T::one() - t) * hang).sin() / s_hang;
             let tb = (t * hang).sin() / s_hang;
             let mut res = self.scale(ta);
-            res.axpy(tb, &**rhs, N::one());
+            res.axpy(tb, &**rhs, T::one());
 
             Some(Unit::new_unchecked(res))
         }
diff --git a/src/base/iter.rs b/src/base/iter.rs
index f744cf02..1592299d 100644
--- a/src/base/iter.rs
+++ b/src/base/iter.rs
@@ -11,7 +11,7 @@ use crate::base::{Matrix, MatrixSlice, MatrixSliceMut, Scalar};
 macro_rules! iterator {
     (struct $Name:ident for $Storage:ident.$ptr: ident -> $Ptr:ty, $Ref:ty, $SRef: ty) => {
         /// An iterator through a dense matrix with arbitrary strides matrix.
-        pub struct $Name<'a, N: Scalar, R: Dim, C: Dim, S: 'a + $Storage<N, R, C>> {
+        pub struct $Name<'a, T: Scalar, R: Dim, C: Dim, S: 'a + $Storage<T, R, C>> {
             ptr: $Ptr,
             inner_ptr: $Ptr,
             inner_end: $Ptr,
@@ -22,9 +22,9 @@ macro_rules! iterator {
 
         // TODO: we need to specialize for the case where the matrix storage is owned (in which
         // case the iterator is trivial because it does not have any stride).
-        impl<'a, N: Scalar, R: Dim, C: Dim, S: 'a + $Storage<N, R, C>> $Name<'a, N, R, C, S> {
+        impl<'a, T: Scalar, R: Dim, C: Dim, S: 'a + $Storage<T, R, C>> $Name<'a, T, R, C, S> {
             /// Creates a new iterator for the given matrix storage.
-            pub fn new(storage: $SRef) -> $Name<'a, N, R, C, S> {
+            pub fn new(storage: $SRef) -> $Name<'a, T, R, C, S> {
                 let shape = storage.shape();
                 let strides = storage.strides();
                 let inner_offset = shape.0.value() * strides.0.value();
@@ -59,8 +59,8 @@ macro_rules! iterator {
             }
         }
 
-        impl<'a, N: Scalar, R: Dim, C: Dim, S: 'a + $Storage<N, R, C>> Iterator
-            for $Name<'a, N, R, C, S>
+        impl<'a, T: Scalar, R: Dim, C: Dim, S: 'a + $Storage<T, R, C>> Iterator
+            for $Name<'a, T, R, C, S>
         {
             type Item = $Ref;
 
@@ -112,8 +112,8 @@ macro_rules! iterator {
             }
         }
 
-        impl<'a, N: Scalar, R: Dim, C: Dim, S: 'a + $Storage<N, R, C>> DoubleEndedIterator
-            for $Name<'a, N, R, C, S>
+        impl<'a, T: Scalar, R: Dim, C: Dim, S: 'a + $Storage<T, R, C>> DoubleEndedIterator
+            for $Name<'a, T, R, C, S>
         {
             #[inline]
             fn next_back(&mut self) -> Option<$Ref> {
@@ -152,8 +152,8 @@ macro_rules! iterator {
             }
         }
 
-        impl<'a, N: Scalar, R: Dim, C: Dim, S: 'a + $Storage<N, R, C>> ExactSizeIterator
-            for $Name<'a, N, R, C, S>
+        impl<'a, T: Scalar, R: Dim, C: Dim, S: 'a + $Storage<T, R, C>> ExactSizeIterator
+            for $Name<'a, T, R, C, S>
         {
             #[inline]
             fn len(&self) -> usize {
@@ -161,15 +161,15 @@ macro_rules! iterator {
             }
         }
 
-        impl<'a, N: Scalar, R: Dim, C: Dim, S: 'a + $Storage<N, R, C>> FusedIterator
-            for $Name<'a, N, R, C, S>
+        impl<'a, T: Scalar, R: Dim, C: Dim, S: 'a + $Storage<T, R, C>> FusedIterator
+            for $Name<'a, T, R, C, S>
         {
         }
     };
 }
 
-iterator!(struct MatrixIter for Storage.ptr -> *const N, &'a N, &'a S);
-iterator!(struct MatrixIterMut for StorageMut.ptr_mut -> *mut N, &'a mut N, &'a mut S);
+iterator!(struct MatrixIter for Storage.ptr -> *const T, &'a T, &'a S);
+iterator!(struct MatrixIterMut for StorageMut.ptr_mut -> *mut T, &'a mut T, &'a mut S);
 
 /*
  *
@@ -178,19 +178,19 @@ iterator!(struct MatrixIterMut for StorageMut.ptr_mut -> *mut N, &'a mut N, &'a
  */
 #[derive(Clone)]
 /// An iterator through the rows of a matrix.
-pub struct RowIter<'a, N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> {
-    mat: &'a Matrix<N, R, C, S>,
+pub struct RowIter<'a, T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> {
+    mat: &'a Matrix<T, R, C, S>,
     curr: usize,
 }
 
-impl<'a, N: Scalar, R: Dim, C: Dim, S: 'a + Storage<N, R, C>> RowIter<'a, N, R, C, S> {
-    pub(crate) fn new(mat: &'a Matrix<N, R, C, S>) -> Self {
+impl<'a, T: Scalar, R: Dim, C: Dim, S: 'a + Storage<T, R, C>> RowIter<'a, T, R, C, S> {
+    pub(crate) fn new(mat: &'a Matrix<T, R, C, S>) -> Self {
         RowIter { mat, curr: 0 }
     }
 }
 
-impl<'a, N: Scalar, R: Dim, C: Dim, S: 'a + Storage<N, R, C>> Iterator for RowIter<'a, N, R, C, S> {
-    type Item = MatrixSlice<'a, N, U1, C, S::RStride, S::CStride>;
+impl<'a, T: Scalar, R: Dim, C: Dim, S: 'a + Storage<T, R, C>> Iterator for RowIter<'a, T, R, C, S> {
+    type Item = MatrixSlice<'a, T, U1, C, S::RStride, S::CStride>;
 
     #[inline]
     fn next(&mut self) -> Option<Self::Item> {
@@ -217,8 +217,8 @@ impl<'a, N: Scalar, R: Dim, C: Dim, S: 'a + Storage<N, R, C>> Iterator for RowIt
     }
 }
 
-impl<'a, N: Scalar, R: Dim, C: Dim, S: 'a + Storage<N, R, C>> ExactSizeIterator
-    for RowIter<'a, N, R, C, S>
+impl<'a, T: Scalar, R: Dim, C: Dim, S: 'a + Storage<T, R, C>> ExactSizeIterator
+    for RowIter<'a, T, R, C, S>
 {
     #[inline]
     fn len(&self) -> usize {
@@ -227,14 +227,14 @@ impl<'a, N: Scalar, R: Dim, C: Dim, S: 'a + Storage<N, R, C>> ExactSizeIterator
 }
 
 /// An iterator through the mutable rows of a matrix.
-pub struct RowIterMut<'a, N: Scalar, R: Dim, C: Dim, S: StorageMut<N, R, C>> {
-    mat: *mut Matrix<N, R, C, S>,
+pub struct RowIterMut<'a, T: Scalar, R: Dim, C: Dim, S: StorageMut<T, R, C>> {
+    mat: *mut Matrix<T, R, C, S>,
     curr: usize,
-    phantom: PhantomData<&'a mut Matrix<N, R, C, S>>,
+    phantom: PhantomData<&'a mut Matrix<T, R, C, S>>,
 }
 
-impl<'a, N: Scalar, R: Dim, C: Dim, S: 'a + StorageMut<N, R, C>> RowIterMut<'a, N, R, C, S> {
-    pub(crate) fn new(mat: &'a mut Matrix<N, R, C, S>) -> Self {
+impl<'a, T: Scalar, R: Dim, C: Dim, S: 'a + StorageMut<T, R, C>> RowIterMut<'a, T, R, C, S> {
+    pub(crate) fn new(mat: &'a mut Matrix<T, R, C, S>) -> Self {
         RowIterMut {
             mat,
             curr: 0,
@@ -247,10 +247,10 @@ impl<'a, N: Scalar, R: Dim, C: Dim, S: 'a + StorageMut<N, R, C>> RowIterMut<'a,
     }
 }
 
-impl<'a, N: Scalar, R: Dim, C: Dim, S: 'a + StorageMut<N, R, C>> Iterator
-    for RowIterMut<'a, N, R, C, S>
+impl<'a, T: Scalar, R: Dim, C: Dim, S: 'a + StorageMut<T, R, C>> Iterator
+    for RowIterMut<'a, T, R, C, S>
 {
-    type Item = MatrixSliceMut<'a, N, U1, C, S::RStride, S::CStride>;
+    type Item = MatrixSliceMut<'a, T, U1, C, S::RStride, S::CStride>;
 
     #[inline]
     fn next(&mut self) -> Option<Self::Item> {
@@ -274,8 +274,8 @@ impl<'a, N: Scalar, R: Dim, C: Dim, S: 'a + StorageMut<N, R, C>> Iterator
     }
 }
 
-impl<'a, N: Scalar, R: Dim, C: Dim, S: 'a + StorageMut<N, R, C>> ExactSizeIterator
-    for RowIterMut<'a, N, R, C, S>
+impl<'a, T: Scalar, R: Dim, C: Dim, S: 'a + StorageMut<T, R, C>> ExactSizeIterator
+    for RowIterMut<'a, T, R, C, S>
 {
     #[inline]
     fn len(&self) -> usize {
@@ -290,21 +290,21 @@ impl<'a, N: Scalar, R: Dim, C: Dim, S: 'a + StorageMut<N, R, C>> ExactSizeIterat
  */
 #[derive(Clone)]
 /// An iterator through the columns of a matrix.
-pub struct ColumnIter<'a, N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> {
-    mat: &'a Matrix<N, R, C, S>,
+pub struct ColumnIter<'a, T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> {
+    mat: &'a Matrix<T, R, C, S>,
     curr: usize,
 }
 
-impl<'a, N: Scalar, R: Dim, C: Dim, S: 'a + Storage<N, R, C>> ColumnIter<'a, N, R, C, S> {
-    pub(crate) fn new(mat: &'a Matrix<N, R, C, S>) -> Self {
+impl<'a, T: Scalar, R: Dim, C: Dim, S: 'a + Storage<T, R, C>> ColumnIter<'a, T, R, C, S> {
+    pub(crate) fn new(mat: &'a Matrix<T, R, C, S>) -> Self {
         ColumnIter { mat, curr: 0 }
     }
 }
 
-impl<'a, N: Scalar, R: Dim, C: Dim, S: 'a + Storage<N, R, C>> Iterator
-    for ColumnIter<'a, N, R, C, S>
+impl<'a, T: Scalar, R: Dim, C: Dim, S: 'a + Storage<T, R, C>> Iterator
+    for ColumnIter<'a, T, R, C, S>
 {
-    type Item = MatrixSlice<'a, N, R, U1, S::RStride, S::CStride>;
+    type Item = MatrixSlice<'a, T, R, U1, S::RStride, S::CStride>;
 
     #[inline]
     fn next(&mut self) -> Option<Self::Item> {
@@ -331,8 +331,8 @@ impl<'a, N: Scalar, R: Dim, C: Dim, S: 'a + Storage<N, R, C>> Iterator
     }
 }
 
-impl<'a, N: Scalar, R: Dim, C: Dim, S: 'a + Storage<N, R, C>> ExactSizeIterator
-    for ColumnIter<'a, N, R, C, S>
+impl<'a, T: Scalar, R: Dim, C: Dim, S: 'a + Storage<T, R, C>> ExactSizeIterator
+    for ColumnIter<'a, T, R, C, S>
 {
     #[inline]
     fn len(&self) -> usize {
@@ -341,14 +341,14 @@ impl<'a, N: Scalar, R: Dim, C: Dim, S: 'a + Storage<N, R, C>> ExactSizeIterator
 }
 
 /// An iterator through the mutable columns of a matrix.
-pub struct ColumnIterMut<'a, N: Scalar, R: Dim, C: Dim, S: StorageMut<N, R, C>> {
-    mat: *mut Matrix<N, R, C, S>,
+pub struct ColumnIterMut<'a, T: Scalar, R: Dim, C: Dim, S: StorageMut<T, R, C>> {
+    mat: *mut Matrix<T, R, C, S>,
     curr: usize,
-    phantom: PhantomData<&'a mut Matrix<N, R, C, S>>,
+    phantom: PhantomData<&'a mut Matrix<T, R, C, S>>,
 }
 
-impl<'a, N: Scalar, R: Dim, C: Dim, S: 'a + StorageMut<N, R, C>> ColumnIterMut<'a, N, R, C, S> {
-    pub(crate) fn new(mat: &'a mut Matrix<N, R, C, S>) -> Self {
+impl<'a, T: Scalar, R: Dim, C: Dim, S: 'a + StorageMut<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,
@@ -361,10 +361,10 @@ impl<'a, N: Scalar, R: Dim, C: Dim, S: 'a + StorageMut<N, R, C>> ColumnIterMut<'
     }
 }
 
-impl<'a, N: Scalar, R: Dim, C: Dim, S: 'a + StorageMut<N, R, C>> Iterator
-    for ColumnIterMut<'a, N, R, C, S>
+impl<'a, T: Scalar, R: Dim, C: Dim, S: 'a + StorageMut<T, R, C>> Iterator
+    for ColumnIterMut<'a, T, R, C, S>
 {
-    type Item = MatrixSliceMut<'a, N, R, U1, S::RStride, S::CStride>;
+    type Item = MatrixSliceMut<'a, T, R, U1, S::RStride, S::CStride>;
 
     #[inline]
     fn next(&mut self) -> Option<Self::Item> {
@@ -388,8 +388,8 @@ impl<'a, N: Scalar, R: Dim, C: Dim, S: 'a + StorageMut<N, R, C>> Iterator
     }
 }
 
-impl<'a, N: Scalar, R: Dim, C: Dim, S: 'a + StorageMut<N, R, C>> ExactSizeIterator
-    for ColumnIterMut<'a, N, R, C, S>
+impl<'a, T: Scalar, R: Dim, C: Dim, S: 'a + StorageMut<T, R, C>> ExactSizeIterator
+    for ColumnIterMut<'a, T, R, C, S>
 {
     #[inline]
     fn len(&self) -> usize {
diff --git a/src/base/matrix.rs b/src/base/matrix.rs
index ee426227..bfa2bb35 100644
--- a/src/base/matrix.rs
+++ b/src/base/matrix.rs
@@ -28,29 +28,29 @@ use crate::base::iter::{
 use crate::base::storage::{
     ContiguousStorage, ContiguousStorageMut, Owned, SameShapeStorage, Storage, StorageMut,
 };
-use crate::base::{DefaultAllocator, MatrixMN, MatrixN, Scalar, Unit, VectorN};
+use crate::base::{Const, DefaultAllocator, OMatrix, OVector, Scalar, Unit};
 use crate::SimdComplexField;
 
 /// A square matrix.
-pub type SquareMatrix<N, D, S> = Matrix<N, D, D, S>;
+pub type SquareMatrix<T, D, S> = Matrix<T, D, D, S>;
 
 /// A matrix with one column and `D` rows.
-pub type Vector<N, D, S> = Matrix<N, D, U1, S>;
+pub type Vector<T, D, S> = Matrix<T, D, U1, S>;
 
 /// A matrix with one row and `D` columns .
-pub type RowVector<N, D, S> = Matrix<N, U1, D, S>;
+pub type RowVector<T, D, S> = Matrix<T, U1, D, S>;
 
 /// The type of the result of a matrix sum.
-pub type MatrixSum<N, R1, C1, R2, C2> =
-    Matrix<N, SameShapeR<R1, R2>, SameShapeC<C1, C2>, SameShapeStorage<N, R1, C1, R2, C2>>;
+pub type MatrixSum<T, R1, C1, R2, C2> =
+    Matrix<T, SameShapeR<R1, R2>, SameShapeC<C1, C2>, SameShapeStorage<T, R1, C1, R2, C2>>;
 
 /// The type of the result of a matrix sum.
-pub type VectorSum<N, R1, R2> =
-    Matrix<N, SameShapeR<R1, R2>, U1, SameShapeStorage<N, R1, U1, R2, U1>>;
+pub type VectorSum<T, R1, R2> =
+    Matrix<T, SameShapeR<R1, R2>, U1, SameShapeStorage<T, R1, U1, R2, U1>>;
 
 /// The type of the result of a matrix cross product.
-pub type MatrixCross<N, R1, C1, R2, C2> =
-    Matrix<N, SameShapeR<R1, R2>, SameShapeC<C1, C2>, SameShapeStorage<N, R1, C1, R2, C2>>;
+pub type MatrixCross<T, R1, C1, R2, C2> =
+    Matrix<T, SameShapeR<R1, R2>, SameShapeC<C1, C2>, SameShapeStorage<T, R1, C1, R2, C2>>;
 
 /// The most generic column-major matrix (and vector) type.
 ///
@@ -128,7 +128,7 @@ pub type MatrixCross<N, R1, C1, R2, C2> =
 ///
 /// # Type parameters
 /// The generic `Matrix` type has four type parameters:
-/// - `N`: for the matrix components scalar type.
+/// - `T`: for the matrix components scalar type.
 /// - `R`: for the matrix number of rows.
 /// - `C`: for the matrix number of columns.
 /// - `S`: for the matrix data storage, i.e., the buffer that actually contains the matrix
@@ -146,11 +146,11 @@ pub type MatrixCross<N, R1, C1, R2, C2> =
 /// 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<N, Dynamic, U1, S>` (given
-/// some concrete types for `N` and a compatible data storage type `S`).
+/// dynamically-sized column vector should be represented as a `Matrix<T, Dynamic, U1, S>` (given
+/// some concrete types for `T` and a compatible data storage type `S`).
 #[repr(C)]
 #[derive(Clone, Copy)]
-pub struct Matrix<N: Scalar, R: Dim, C: Dim, S> {
+pub struct Matrix<T, R, C, S> {
     /// The data storage that contains all the matrix components. Disappointed?
     ///
     /// Well, if you came here to see how you can access the matrix components,
@@ -176,10 +176,20 @@ pub struct Matrix<N: Scalar, R: Dim, C: Dim, S> {
     /// starts at 0 as you would expect.
     pub data: S,
 
-    _phantoms: PhantomData<(N, R, C)>,
+    // NOTE: the fact that this field is private is important because
+    //       this prevents the user from constructing a matrix with
+    //       dimensions R, C that don't match the dimension of the
+    //       storage S. Instead they have to use the unsafe function
+    //       from_data_statically_unchecked.
+    //       Note that it would probably make sense to just have
+    //       the type `Matrix<S>`, and have `T, R, C` be associated-types
+    //       of the `Storage` trait. However, because we don't have
+    //       specialization, this is not bossible because these `T, R, C`
+    //       allows us to desambiguate a lot of configurations.
+    _phantoms: PhantomData<(T, R, C)>,
 }
 
-impl<N: Scalar, R: Dim, C: Dim, S: fmt::Debug> fmt::Debug for Matrix<N, R, C, S> {
+impl<T, R: Dim, C: Dim, S: fmt::Debug> fmt::Debug for Matrix<T, R, C, S> {
     fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> {
         formatter
             .debug_struct("Matrix")
@@ -188,9 +198,9 @@ impl<N: Scalar, R: Dim, C: Dim, S: fmt::Debug> fmt::Debug for Matrix<N, R, C, S>
     }
 }
 
-impl<N, R, C, S> Default for Matrix<N, R, C, S>
+impl<T, R, C, S> Default for Matrix<T, R, C, S>
 where
-    N: Scalar,
+    T: Scalar,
     R: Dim,
     C: Dim,
     S: Default,
@@ -204,25 +214,25 @@ where
 }
 
 #[cfg(feature = "serde-serialize")]
-impl<N, R, C, S> Serialize for Matrix<N, R, C, S>
+impl<T, R, C, S> Serialize for Matrix<T, R, C, S>
 where
-    N: Scalar,
+    T: Scalar,
     R: Dim,
     C: Dim,
     S: Serialize,
 {
-    fn serialize<T>(&self, serializer: T) -> Result<T::Ok, T::Error>
+    fn serialize<Ser>(&self, serializer: Ser) -> Result<Ser::Ok, Ser::Error>
     where
-        T: Serializer,
+        Ser: Serializer,
     {
         self.data.serialize(serializer)
     }
 }
 
 #[cfg(feature = "serde-serialize")]
-impl<'de, N, R, C, S> Deserialize<'de> for Matrix<N, R, C, S>
+impl<'de, T, R, C, S> Deserialize<'de> for Matrix<T, R, C, S>
 where
-    N: Scalar,
+    T: Scalar,
     R: Dim,
     C: Dim,
     S: Deserialize<'de>,
@@ -239,7 +249,7 @@ where
 }
 
 #[cfg(feature = "abomonation-serialize")]
-impl<N: Scalar, R: Dim, C: Dim, S: Abomonation> Abomonation for Matrix<N, R, C, S> {
+impl<T: Scalar, R: Dim, C: Dim, S: Abomonation> Abomonation for Matrix<T, R, C, S> {
     unsafe fn entomb<W: Write>(&self, writer: &mut W) -> IOResult<()> {
         self.data.entomb(writer)
     }
@@ -254,8 +264,8 @@ impl<N: Scalar, R: Dim, C: Dim, S: Abomonation> Abomonation for Matrix<N, R, C,
 }
 
 #[cfg(feature = "compare")]
-impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> matrixcompare_core::Matrix<N>
-    for Matrix<N, R, C, S>
+impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> matrixcompare_core::Matrix<T>
+    for Matrix<T, R, C, S>
 {
     fn rows(&self) -> usize {
         self.nrows()
@@ -265,41 +275,41 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> matrixcompare_core::Matrix<
         self.ncols()
     }
 
-    fn access(&self) -> matrixcompare_core::Access<N> {
+    fn access(&self) -> matrixcompare_core::Access<T> {
         matrixcompare_core::Access::Dense(self)
     }
 }
 
 #[cfg(feature = "compare")]
-impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> matrixcompare_core::DenseAccess<N>
-    for Matrix<N, R, C, S>
+impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> matrixcompare_core::DenseAccess<T>
+    for Matrix<T, R, C, S>
 {
-    fn fetch_single(&self, row: usize, col: usize) -> N {
+    fn fetch_single(&self, row: usize, col: usize) -> T {
         self.index((row, col)).clone()
     }
 }
 
 #[cfg(feature = "bytemuck")]
-unsafe impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> bytemuck::Zeroable
-    for Matrix<N, R, C, S>
+unsafe impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> bytemuck::Zeroable
+    for Matrix<T, R, C, S>
 where
     S: bytemuck::Zeroable,
 {
 }
 
 #[cfg(feature = "bytemuck")]
-unsafe impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> bytemuck::Pod for Matrix<N, R, C, S>
+unsafe impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> bytemuck::Pod for Matrix<T, R, C, S>
 where
     S: bytemuck::Pod,
     Self: Copy,
 {
 }
 
-impl<N: Scalar, R: Dim, C: Dim, S> Matrix<N, R, C, S> {
+impl<T, R, C, S> Matrix<T, R, C, S> {
     /// Creates a new matrix with the given data without statically checking that the matrix
     /// dimension matches the storage dimension.
-    #[inline]
-    pub unsafe fn from_data_statically_unchecked(data: S) -> Matrix<N, R, C, S> {
+    #[inline(always)]
+    pub const unsafe fn from_data_statically_unchecked(data: S) -> Matrix<T, R, C, S> {
         Matrix {
             data,
             _phantoms: PhantomData,
@@ -307,25 +317,25 @@ impl<N: Scalar, R: Dim, C: Dim, S> Matrix<N, R, C, S> {
     }
 }
 
-impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
+impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
     /// Creates a new matrix with the given data.
-    #[inline]
+    #[inline(always)]
     pub fn from_data(data: S) -> Self {
         unsafe { Self::from_data_statically_unchecked(data) }
     }
 
     /// Creates a new uninitialized matrix with the given uninitialized data
     pub unsafe fn from_uninitialized_data(data: mem::MaybeUninit<S>) -> mem::MaybeUninit<Self> {
-        let res: Matrix<N, R, C, mem::MaybeUninit<S>> = Matrix {
+        let res: Matrix<T, R, C, mem::MaybeUninit<S>> = Matrix {
             data,
             _phantoms: PhantomData,
         };
-        let res: mem::MaybeUninit<Matrix<N, R, C, mem::MaybeUninit<S>>> =
+        let res: mem::MaybeUninit<Matrix<T, R, C, mem::MaybeUninit<S>>> =
             mem::MaybeUninit::new(res);
         // safety: since we wrap the inner MaybeUninit in an outer MaybeUninit above, the fact that the `data` field is partially-uninitialized is still opaque.
-        // with s/transmute_copy/transmute/, rustc claims that `MaybeUninit<Matrix<N, R, C, MaybeUninit<S>>>` may be of a different size from `MaybeUninit<Matrix<N, R, C, S>>`
+        // with s/transmute_copy/transmute/, rustc claims that `MaybeUninit<Matrix<T, R, C, MaybeUninit<S>>>` may be of a different size from `MaybeUninit<Matrix<T, R, C, S>>`
         // but MaybeUninit's documentation says "MaybeUninit<T> is guaranteed to have the same size, alignment, and ABI as T", which implies those types should be the same size
-        let res: mem::MaybeUninit<Matrix<N, R, C, S>> = mem::transmute_copy(&res);
+        let res: mem::MaybeUninit<Matrix<T, R, C, S>> = mem::transmute_copy(&res);
         res
     }
 
@@ -426,7 +436,7 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     /// assert_eq!(unsafe { *ptr }, m[0]);
     /// ```
     #[inline]
-    pub fn as_ptr(&self) -> *const N {
+    pub fn as_ptr(&self) -> *const T {
         self.data.ptr()
     }
 
@@ -436,16 +446,16 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     #[inline]
     pub fn relative_eq<R2, C2, SB>(
         &self,
-        other: &Matrix<N, R2, C2, SB>,
-        eps: N::Epsilon,
-        max_relative: N::Epsilon,
+        other: &Matrix<T, R2, C2, SB>,
+        eps: T::Epsilon,
+        max_relative: T::Epsilon,
     ) -> bool
     where
-        N: RelativeEq,
+        T: RelativeEq,
         R2: Dim,
         C2: Dim,
-        SB: Storage<N, R2, C2>,
-        N::Epsilon: Copy,
+        SB: Storage<T, R2, C2>,
+        T::Epsilon: Copy,
         ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,
     {
         assert!(self.shape() == other.shape());
@@ -456,12 +466,12 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
 
     /// Tests whether `self` and `rhs` are exactly equal.
     #[inline]
-    pub fn eq<R2, C2, SB>(&self, other: &Matrix<N, R2, C2, SB>) -> bool
+    pub fn eq<R2, C2, SB>(&self, other: &Matrix<T, R2, C2, SB>) -> bool
     where
-        N: PartialEq,
+        T: PartialEq,
         R2: Dim,
         C2: Dim,
-        SB: Storage<N, R2, C2>,
+        SB: Storage<T, R2, C2>,
         ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,
     {
         assert!(self.shape() == other.shape());
@@ -470,9 +480,9 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
 
     /// Moves this matrix into one that owns its data.
     #[inline]
-    pub fn into_owned(self) -> MatrixMN<N, R, C>
+    pub fn into_owned(self) -> OMatrix<T, R, C>
     where
-        DefaultAllocator: Allocator<N, R, C>,
+        DefaultAllocator: Allocator<T, R, C>,
     {
         Matrix::from_data(self.data.into_owned())
     }
@@ -482,14 +492,14 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     /// Moves this matrix into one that owns its data. The actual type of the result depends on
     /// matrix storage combination rules for addition.
     #[inline]
-    pub fn into_owned_sum<R2, C2>(self) -> MatrixSum<N, R, C, R2, C2>
+    pub fn into_owned_sum<R2, C2>(self) -> MatrixSum<T, R, C, R2, C2>
     where
         R2: Dim,
         C2: Dim,
-        DefaultAllocator: SameShapeAllocator<N, R, C, R2, C2>,
+        DefaultAllocator: SameShapeAllocator<T, R, C, R2, C2>,
         ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,
     {
-        if TypeId::of::<SameShapeStorage<N, R, C, R2, C2>>() == TypeId::of::<Owned<N, R, C>>() {
+        if TypeId::of::<SameShapeStorage<T, R, C, R2, C2>>() == TypeId::of::<Owned<T, R, C>>() {
             // We can just return `self.into_owned()`.
 
             unsafe {
@@ -506,9 +516,9 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
 
     /// Clones this matrix to one that owns its data.
     #[inline]
-    pub fn clone_owned(&self) -> MatrixMN<N, R, C>
+    pub fn clone_owned(&self) -> OMatrix<T, R, C>
     where
-        DefaultAllocator: Allocator<N, R, C>,
+        DefaultAllocator: Allocator<T, R, C>,
     {
         Matrix::from_data(self.data.clone_owned())
     }
@@ -516,18 +526,18 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     /// Clones this matrix into one that owns its data. The actual type of the result depends on
     /// matrix storage combination rules for addition.
     #[inline]
-    pub fn clone_owned_sum<R2, C2>(&self) -> MatrixSum<N, R, C, R2, C2>
+    pub fn clone_owned_sum<R2, C2>(&self) -> MatrixSum<T, R, C, R2, C2>
     where
         R2: Dim,
         C2: Dim,
-        DefaultAllocator: SameShapeAllocator<N, R, C, R2, C2>,
+        DefaultAllocator: SameShapeAllocator<T, R, C, R2, C2>,
         ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,
     {
         let (nrows, ncols) = self.shape();
         let nrows: SameShapeR<R, R2> = Dim::from_usize(nrows);
         let ncols: SameShapeC<C, C2> = Dim::from_usize(ncols);
 
-        let mut res: MatrixSum<N, R, C, R2, C2> =
+        let mut res: MatrixSum<T, R, C, R2, C2> =
             unsafe { crate::unimplemented_or_uninitialized_generic!(nrows, ncols) };
 
         // TODO: use copy_from
@@ -544,11 +554,11 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
 
     /// Transposes `self` and store the result into `out`.
     #[inline]
-    pub fn transpose_to<R2, C2, SB>(&self, out: &mut Matrix<N, R2, C2, SB>)
+    pub fn transpose_to<R2, C2, SB>(&self, out: &mut Matrix<T, R2, C2, SB>)
     where
         R2: Dim,
         C2: Dim,
-        SB: StorageMut<N, R2, C2>,
+        SB: StorageMut<T, R2, C2>,
         ShapeConstraint: SameNumberOfRows<R, C2> + SameNumberOfColumns<C, R2>,
     {
         let (nrows, ncols) = self.shape();
@@ -570,9 +580,9 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     /// Transposes `self`.
     #[inline]
     #[must_use = "Did you mean to use transpose_mut()?"]
-    pub fn transpose(&self) -> MatrixMN<N, C, R>
+    pub fn transpose(&self) -> OMatrix<T, C, R>
     where
-        DefaultAllocator: Allocator<N, C, R>,
+        DefaultAllocator: Allocator<T, C, R>,
     {
         let (nrows, ncols) = self.data.shape();
 
@@ -586,16 +596,16 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
 }
 
 /// # Elementwise mapping and folding
-impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
+impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
     /// Returns a matrix containing the result of `f` applied to each of its entries.
     #[inline]
-    pub fn map<N2: Scalar, F: FnMut(N) -> N2>(&self, mut f: F) -> MatrixMN<N2, R, C>
+    pub fn map<T2: Scalar, F: FnMut(T) -> T2>(&self, mut f: F) -> OMatrix<T2, R, C>
     where
-        DefaultAllocator: Allocator<N2, R, C>,
+        DefaultAllocator: Allocator<T2, R, C>,
     {
         let (nrows, ncols) = self.data.shape();
 
-        let mut res: MatrixMN<N2, R, C> =
+        let mut res: OMatrix<T2, R, C> =
             unsafe { crate::unimplemented_or_uninitialized_generic!(nrows, ncols) };
 
         for j in 0..ncols.value() {
@@ -619,10 +629,10 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     /// let q2 = q.cast::<f32>();
     /// assert_eq!(q2, Vector3::new(1.0f32, 2.0, 3.0));
     /// ```
-    pub fn cast<N2: Scalar>(self) -> MatrixMN<N2, R, C>
+    pub fn cast<T2: Scalar>(self) -> OMatrix<T2, R, C>
     where
-        MatrixMN<N2, R, C>: SupersetOf<Self>,
-        DefaultAllocator: Allocator<N2, R, C>,
+        OMatrix<T2, R, C>: SupersetOf<Self>,
+        DefaultAllocator: Allocator<T2, R, C>,
     {
         crate::convert(self)
     }
@@ -635,11 +645,11 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     /// - If the matrix has has least one component, then `init_f` is called with the first component
     /// to compute the initial value. Folding then continues on all the remaining components of the matrix.
     #[inline]
-    pub fn fold_with<N2>(
+    pub fn fold_with<T2>(
         &self,
-        init_f: impl FnOnce(Option<&N>) -> N2,
-        f: impl FnMut(N2, &N) -> N2,
-    ) -> N2 {
+        init_f: impl FnOnce(Option<&T>) -> T2,
+        f: impl FnMut(T2, &T) -> T2,
+    ) -> T2 {
         let mut it = self.iter();
         let init = init_f(it.next());
         it.fold(init, f)
@@ -648,16 +658,16 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     /// Returns a matrix containing the result of `f` applied to each of its entries. Unlike `map`,
     /// `f` also gets passed the row and column index, i.e. `f(row, col, value)`.
     #[inline]
-    pub fn map_with_location<N2: Scalar, F: FnMut(usize, usize, N) -> N2>(
+    pub fn map_with_location<T2: Scalar, F: FnMut(usize, usize, T) -> T2>(
         &self,
         mut f: F,
-    ) -> MatrixMN<N2, R, C>
+    ) -> OMatrix<T2, R, C>
     where
-        DefaultAllocator: Allocator<N2, R, C>,
+        DefaultAllocator: Allocator<T2, R, C>,
     {
         let (nrows, ncols) = self.data.shape();
 
-        let mut res: MatrixMN<N2, R, C> =
+        let mut res: OMatrix<T2, R, C> =
             unsafe { crate::unimplemented_or_uninitialized_generic!(nrows, ncols) };
 
         for j in 0..ncols.value() {
@@ -675,17 +685,17 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     /// Returns a matrix containing the result of `f` applied to each entries of `self` and
     /// `rhs`.
     #[inline]
-    pub fn zip_map<N2, N3, S2, F>(&self, rhs: &Matrix<N2, R, C, S2>, mut f: F) -> MatrixMN<N3, R, C>
+    pub fn zip_map<T2, N3, S2, F>(&self, rhs: &Matrix<T2, R, C, S2>, mut f: F) -> OMatrix<N3, R, C>
     where
-        N2: Scalar,
+        T2: Scalar,
         N3: Scalar,
-        S2: Storage<N2, R, C>,
-        F: FnMut(N, N2) -> N3,
+        S2: Storage<T2, R, C>,
+        F: FnMut(T, T2) -> N3,
         DefaultAllocator: Allocator<N3, R, C>,
     {
         let (nrows, ncols) = self.data.shape();
 
-        let mut res: MatrixMN<N3, R, C> =
+        let mut res: OMatrix<N3, R, C> =
             unsafe { crate::unimplemented_or_uninitialized_generic!(nrows, ncols) };
 
         assert_eq!(
@@ -710,24 +720,24 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     /// Returns a matrix containing the result of `f` applied to each entries of `self` and
     /// `b`, and `c`.
     #[inline]
-    pub fn zip_zip_map<N2, N3, N4, S2, S3, F>(
+    pub fn zip_zip_map<T2, N3, N4, S2, S3, F>(
         &self,
-        b: &Matrix<N2, R, C, S2>,
+        b: &Matrix<T2, R, C, S2>,
         c: &Matrix<N3, R, C, S3>,
         mut f: F,
-    ) -> MatrixMN<N4, R, C>
+    ) -> OMatrix<N4, R, C>
     where
-        N2: Scalar,
+        T2: Scalar,
         N3: Scalar,
         N4: Scalar,
-        S2: Storage<N2, R, C>,
+        S2: Storage<T2, R, C>,
         S3: Storage<N3, R, C>,
-        F: FnMut(N, N2, N3) -> N4,
+        F: FnMut(T, T2, N3) -> N4,
         DefaultAllocator: Allocator<N4, R, C>,
     {
         let (nrows, ncols) = self.data.shape();
 
-        let mut res: MatrixMN<N4, R, C> =
+        let mut res: OMatrix<N4, R, C> =
             unsafe { crate::unimplemented_or_uninitialized_generic!(nrows, ncols) };
 
         assert_eq!(
@@ -757,7 +767,7 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
 
     /// Folds a function `f` on each entry of `self`.
     #[inline]
-    pub fn fold<Acc>(&self, init: Acc, mut f: impl FnMut(Acc, N) -> Acc) -> Acc {
+    pub fn fold<Acc>(&self, init: Acc, mut f: impl FnMut(Acc, T) -> Acc) -> Acc {
         let (nrows, ncols) = self.data.shape();
 
         let mut res = init;
@@ -776,17 +786,17 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
 
     /// Folds a function `f` on each pairs of entries from `self` and `rhs`.
     #[inline]
-    pub fn zip_fold<N2, R2, C2, S2, Acc>(
+    pub fn zip_fold<T2, R2, C2, S2, Acc>(
         &self,
-        rhs: &Matrix<N2, R2, C2, S2>,
+        rhs: &Matrix<T2, R2, C2, S2>,
         init: Acc,
-        mut f: impl FnMut(Acc, N, N2) -> Acc,
+        mut f: impl FnMut(Acc, T, T2) -> Acc,
     ) -> Acc
     where
-        N2: Scalar,
+        T2: Scalar,
         R2: Dim,
         C2: Dim,
-        S2: Storage<N2, R2, C2>,
+        S2: Storage<T2, R2, C2>,
         ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,
     {
         let (nrows, ncols) = self.data.shape();
@@ -814,9 +824,9 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
 
     /// Replaces each component of `self` by the result of a closure `f` applied on it.
     #[inline]
-    pub fn apply<F: FnMut(N) -> N>(&mut self, mut f: F)
+    pub fn apply<F: FnMut(T) -> T>(&mut self, mut f: F)
     where
-        S: StorageMut<N, R, C>,
+        S: StorageMut<T, R, C>,
     {
         let (nrows, ncols) = self.shape();
 
@@ -833,16 +843,16 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     /// Replaces each component of `self` by the result of a closure `f` applied on its components
     /// joined with the components from `rhs`.
     #[inline]
-    pub fn zip_apply<N2, R2, C2, S2>(
+    pub fn zip_apply<T2, R2, C2, S2>(
         &mut self,
-        rhs: &Matrix<N2, R2, C2, S2>,
-        mut f: impl FnMut(N, N2) -> N,
+        rhs: &Matrix<T2, R2, C2, S2>,
+        mut f: impl FnMut(T, T2) -> T,
     ) where
-        S: StorageMut<N, R, C>,
-        N2: Scalar,
+        S: StorageMut<T, R, C>,
+        T2: Scalar,
         R2: Dim,
         C2: Dim,
-        S2: Storage<N2, R2, C2>,
+        S2: Storage<T2, R2, C2>,
         ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,
     {
         let (nrows, ncols) = self.shape();
@@ -867,17 +877,17 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     /// Replaces each component of `self` by the result of a closure `f` applied on its components
     /// joined with the components from `b` and `c`.
     #[inline]
-    pub fn zip_zip_apply<N2, R2, C2, S2, N3, R3, C3, S3>(
+    pub fn zip_zip_apply<T2, R2, C2, S2, N3, R3, C3, S3>(
         &mut self,
-        b: &Matrix<N2, R2, C2, S2>,
+        b: &Matrix<T2, R2, C2, S2>,
         c: &Matrix<N3, R3, C3, S3>,
-        mut f: impl FnMut(N, N2, N3) -> N,
+        mut f: impl FnMut(T, T2, N3) -> T,
     ) where
-        S: StorageMut<N, R, C>,
-        N2: Scalar,
+        S: StorageMut<T, R, C>,
+        T2: Scalar,
         R2: Dim,
         C2: Dim,
-        S2: Storage<N2, R2, C2>,
+        S2: Storage<T2, R2, C2>,
         N3: Scalar,
         R3: Dim,
         C3: Dim,
@@ -912,7 +922,7 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
 }
 
 /// # Iteration on components, rows, and columns
-impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
+impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
     /// Iterates through this matrix coordinates in column-major order.
     ///
     /// # Examples:
@@ -930,7 +940,7 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     /// assert_eq!(*it.next().unwrap(), 23);
     /// assert!(it.next().is_none());
     #[inline]
-    pub fn iter(&self) -> MatrixIter<N, R, C, S> {
+    pub fn iter(&self) -> MatrixIter<T, R, C, S> {
         MatrixIter::new(&self.data)
     }
 
@@ -946,7 +956,7 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     /// }
     /// ```
     #[inline]
-    pub fn row_iter(&self) -> RowIter<N, R, C, S> {
+    pub fn row_iter(&self) -> RowIter<T, R, C, S> {
         RowIter::new(self)
     }
 
@@ -961,15 +971,15 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     /// }
     /// ```
     #[inline]
-    pub fn column_iter(&self) -> ColumnIter<N, R, C, S> {
+    pub fn column_iter(&self) -> ColumnIter<T, R, C, S> {
         ColumnIter::new(self)
     }
 
     /// Mutably iterates through this matrix coordinates.
     #[inline]
-    pub fn iter_mut(&mut self) -> MatrixIterMut<N, R, C, S>
+    pub fn iter_mut(&mut self) -> MatrixIterMut<T, R, C, S>
     where
-        S: StorageMut<N, R, C>,
+        S: StorageMut<T, R, C>,
     {
         MatrixIterMut::new(&mut self.data)
     }
@@ -990,9 +1000,9 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     /// assert_eq!(a, expected);
     /// ```
     #[inline]
-    pub fn row_iter_mut(&mut self) -> RowIterMut<N, R, C, S>
+    pub fn row_iter_mut(&mut self) -> RowIterMut<T, R, C, S>
     where
-        S: StorageMut<N, R, C>,
+        S: StorageMut<T, R, C>,
     {
         RowIterMut::new(self)
     }
@@ -1013,21 +1023,21 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     /// assert_eq!(a, expected);
     /// ```
     #[inline]
-    pub fn column_iter_mut(&mut self) -> ColumnIterMut<N, R, C, S>
+    pub fn column_iter_mut(&mut self) -> ColumnIterMut<T, R, C, S>
     where
-        S: StorageMut<N, R, C>,
+        S: StorageMut<T, R, C>,
     {
         ColumnIterMut::new(self)
     }
 }
 
-impl<N: Scalar, R: Dim, C: Dim, S: StorageMut<N, R, C>> Matrix<N, R, C, S> {
+impl<T: Scalar, R: Dim, C: Dim, S: StorageMut<T, R, C>> Matrix<T, R, C, S> {
     /// Returns a mutable pointer to the start of the matrix.
     ///
     /// If the matrix is not empty, this pointer is guaranteed to be aligned
     /// and non-null.
     #[inline]
-    pub fn as_mut_ptr(&mut self) -> *mut N {
+    pub fn as_mut_ptr(&mut self) -> *mut T {
         self.data.ptr_mut()
     }
 
@@ -1058,7 +1068,7 @@ impl<N: Scalar, R: Dim, C: Dim, S: StorageMut<N, R, C>> Matrix<N, R, C, S> {
     ///
     /// The components of the slice are assumed to be ordered in column-major order.
     #[inline]
-    pub fn copy_from_slice(&mut self, slice: &[N]) {
+    pub fn copy_from_slice(&mut self, slice: &[T]) {
         let (nrows, ncols) = self.shape();
 
         assert!(
@@ -1078,11 +1088,11 @@ impl<N: Scalar, R: Dim, C: Dim, S: StorageMut<N, R, C>> Matrix<N, R, C, S> {
 
     /// Fills this matrix with the content of another one. Both must have the same shape.
     #[inline]
-    pub fn copy_from<R2, C2, SB>(&mut self, other: &Matrix<N, R2, C2, SB>)
+    pub fn copy_from<R2, C2, SB>(&mut self, other: &Matrix<T, R2, C2, SB>)
     where
         R2: Dim,
         C2: Dim,
-        SB: Storage<N, R2, C2>,
+        SB: Storage<T, R2, C2>,
         ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,
     {
         assert!(
@@ -1101,11 +1111,11 @@ impl<N: Scalar, R: Dim, C: Dim, S: StorageMut<N, R, C>> Matrix<N, R, C, S> {
 
     /// Fills this matrix with the content of the transpose another one.
     #[inline]
-    pub fn tr_copy_from<R2, C2, SB>(&mut self, other: &Matrix<N, R2, C2, SB>)
+    pub fn tr_copy_from<R2, C2, SB>(&mut self, other: &Matrix<T, R2, C2, SB>)
     where
         R2: Dim,
         C2: Dim,
-        SB: Storage<N, R2, C2>,
+        SB: Storage<T, R2, C2>,
         ShapeConstraint: DimEq<R, C2> + SameNumberOfColumns<C, R2>,
     {
         let (nrows, ncols) = self.shape();
@@ -1126,49 +1136,49 @@ impl<N: Scalar, R: Dim, C: Dim, S: StorageMut<N, R, C>> Matrix<N, R, C, S> {
     // TODO: rename `apply` to `apply_mut` and `apply_into` to `apply`?
     /// Returns `self` with each of its components replaced by the result of a closure `f` applied on it.
     #[inline]
-    pub fn apply_into<F: FnMut(N) -> N>(mut self, f: F) -> Self {
+    pub fn apply_into<F: FnMut(T) -> T>(mut self, f: F) -> Self {
         self.apply(f);
         self
     }
 }
 
-impl<N: Scalar, D: Dim, S: Storage<N, D>> Vector<N, D, S> {
+impl<T: Scalar, D: Dim, S: Storage<T, D>> Vector<T, D, S> {
     /// Gets a reference to the i-th element of this column vector without bound checking.
     #[inline]
-    pub unsafe fn vget_unchecked(&self, i: usize) -> &N {
+    pub unsafe fn vget_unchecked(&self, i: usize) -> &T {
         debug_assert!(i < self.nrows(), "Vector index out of bounds.");
         let i = i * self.strides().0;
         self.data.get_unchecked_linear(i)
     }
 }
 
-impl<N: Scalar, D: Dim, S: StorageMut<N, D>> Vector<N, D, S> {
+impl<T: Scalar, D: Dim, S: StorageMut<T, D>> Vector<T, D, S> {
     /// Gets a mutable reference to the i-th element of this column vector without bound checking.
     #[inline]
-    pub unsafe fn vget_unchecked_mut(&mut self, i: usize) -> &mut N {
+    pub unsafe fn vget_unchecked_mut(&mut self, i: usize) -> &mut T {
         debug_assert!(i < self.nrows(), "Vector index out of bounds.");
         let i = i * self.strides().0;
         self.data.get_unchecked_linear_mut(i)
     }
 }
 
-impl<N: Scalar, R: Dim, C: Dim, S: ContiguousStorage<N, R, C>> Matrix<N, R, C, S> {
+impl<T: Scalar, R: Dim, C: Dim, S: ContiguousStorage<T, R, C>> Matrix<T, R, C, S> {
     /// Extracts a slice containing the entire matrix entries ordered column-by-columns.
     #[inline]
-    pub fn as_slice(&self) -> &[N] {
+    pub fn as_slice(&self) -> &[T] {
         self.data.as_slice()
     }
 }
 
-impl<N: Scalar, R: Dim, C: Dim, S: ContiguousStorageMut<N, R, C>> Matrix<N, R, C, S> {
+impl<T: Scalar, R: Dim, C: Dim, S: ContiguousStorageMut<T, R, C>> Matrix<T, R, C, S> {
     /// Extracts a mutable slice containing the entire matrix entries ordered column-by-columns.
     #[inline]
-    pub fn as_mut_slice(&mut self) -> &mut [N] {
+    pub fn as_mut_slice(&mut self) -> &mut [T] {
         self.data.as_mut_slice()
     }
 }
 
-impl<N: Scalar, D: Dim, S: StorageMut<N, D, D>> Matrix<N, D, D, S> {
+impl<T: Scalar, D: Dim, S: StorageMut<T, D, D>> Matrix<T, D, D, S> {
     /// Transposes the square matrix `self` in-place.
     pub fn transpose_mut(&mut self) {
         assert!(
@@ -1186,14 +1196,14 @@ impl<N: Scalar, D: Dim, S: StorageMut<N, D, D>> Matrix<N, D, D, S> {
     }
 }
 
-impl<N: SimdComplexField, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
+impl<T: SimdComplexField, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
     /// Takes the adjoint (aka. conjugate-transpose) of `self` and store the result into `out`.
     #[inline]
-    pub fn adjoint_to<R2, C2, SB>(&self, out: &mut Matrix<N, R2, C2, SB>)
+    pub fn adjoint_to<R2, C2, SB>(&self, out: &mut Matrix<T, R2, C2, SB>)
     where
         R2: Dim,
         C2: Dim,
-        SB: StorageMut<N, R2, C2>,
+        SB: StorageMut<T, R2, C2>,
         ShapeConstraint: SameNumberOfRows<R, C2> + SameNumberOfColumns<C, R2>,
     {
         let (nrows, ncols) = self.shape();
@@ -1215,14 +1225,14 @@ impl<N: SimdComplexField, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S
     /// The adjoint (aka. conjugate-transpose) of `self`.
     #[inline]
     #[must_use = "Did you mean to use adjoint_mut()?"]
-    pub fn adjoint(&self) -> MatrixMN<N, C, R>
+    pub fn adjoint(&self) -> OMatrix<T, C, R>
     where
-        DefaultAllocator: Allocator<N, C, R>,
+        DefaultAllocator: Allocator<T, C, R>,
     {
         let (nrows, ncols) = self.data.shape();
 
         unsafe {
-            let mut res: MatrixMN<_, C, R> =
+            let mut res: OMatrix<_, C, R> =
                 crate::unimplemented_or_uninitialized_generic!(ncols, nrows);
             self.adjoint_to(&mut res);
 
@@ -1233,11 +1243,11 @@ impl<N: SimdComplexField, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S
     /// Takes the conjugate and transposes `self` and store the result into `out`.
     #[deprecated(note = "Renamed `self.adjoint_to(out)`.")]
     #[inline]
-    pub fn conjugate_transpose_to<R2, C2, SB>(&self, out: &mut Matrix<N, R2, C2, SB>)
+    pub fn conjugate_transpose_to<R2, C2, SB>(&self, out: &mut Matrix<T, R2, C2, SB>)
     where
         R2: Dim,
         C2: Dim,
-        SB: StorageMut<N, R2, C2>,
+        SB: StorageMut<T, R2, C2>,
         ShapeConstraint: SameNumberOfRows<R, C2> + SameNumberOfColumns<C, R2>,
     {
         self.adjoint_to(out)
@@ -1246,9 +1256,9 @@ impl<N: SimdComplexField, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S
     /// The conjugate transposition of `self`.
     #[deprecated(note = "Renamed `self.adjoint()`.")]
     #[inline]
-    pub fn conjugate_transpose(&self) -> MatrixMN<N, C, R>
+    pub fn conjugate_transpose(&self) -> OMatrix<T, C, R>
     where
-        DefaultAllocator: Allocator<N, C, R>,
+        DefaultAllocator: Allocator<T, C, R>,
     {
         self.adjoint()
     }
@@ -1256,9 +1266,9 @@ impl<N: SimdComplexField, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S
     /// The conjugate of `self`.
     #[inline]
     #[must_use = "Did you mean to use conjugate_mut()?"]
-    pub fn conjugate(&self) -> MatrixMN<N, R, C>
+    pub fn conjugate(&self) -> OMatrix<T, R, C>
     where
-        DefaultAllocator: Allocator<N, R, C>,
+        DefaultAllocator: Allocator<T, R, C>,
     {
         self.map(|e| e.simd_conjugate())
     }
@@ -1266,9 +1276,9 @@ impl<N: SimdComplexField, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S
     /// Divides each component of the complex matrix `self` by the given real.
     #[inline]
     #[must_use = "Did you mean to use unscale_mut()?"]
-    pub fn unscale(&self, real: N::SimdRealField) -> MatrixMN<N, R, C>
+    pub fn unscale(&self, real: T::SimdRealField) -> OMatrix<T, R, C>
     where
-        DefaultAllocator: Allocator<N, R, C>,
+        DefaultAllocator: Allocator<T, R, C>,
     {
         self.map(|e| e.simd_unscale(real))
     }
@@ -1276,15 +1286,15 @@ impl<N: SimdComplexField, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S
     /// Multiplies each component of the complex matrix `self` by the given real.
     #[inline]
     #[must_use = "Did you mean to use scale_mut()?"]
-    pub fn scale(&self, real: N::SimdRealField) -> MatrixMN<N, R, C>
+    pub fn scale(&self, real: T::SimdRealField) -> OMatrix<T, R, C>
     where
-        DefaultAllocator: Allocator<N, R, C>,
+        DefaultAllocator: Allocator<T, R, C>,
     {
         self.map(|e| e.simd_scale(real))
     }
 }
 
-impl<N: SimdComplexField, R: Dim, C: Dim, S: StorageMut<N, R, C>> Matrix<N, R, C, S> {
+impl<T: SimdComplexField, R: Dim, C: Dim, S: StorageMut<T, R, C>> Matrix<T, R, C, S> {
     /// The conjugate of the complex matrix `self` computed in-place.
     #[inline]
     pub fn conjugate_mut(&mut self) {
@@ -1293,18 +1303,18 @@ impl<N: SimdComplexField, R: Dim, C: Dim, S: StorageMut<N, R, C>> Matrix<N, R, C
 
     /// Divides each component of the complex matrix `self` by the given real.
     #[inline]
-    pub fn unscale_mut(&mut self, real: N::SimdRealField) {
+    pub fn unscale_mut(&mut self, real: T::SimdRealField) {
         self.apply(|e| e.simd_unscale(real))
     }
 
     /// Multiplies each component of the complex matrix `self` by the given real.
     #[inline]
-    pub fn scale_mut(&mut self, real: N::SimdRealField) {
+    pub fn scale_mut(&mut self, real: T::SimdRealField) {
         self.apply(|e| e.simd_scale(real))
     }
 }
 
-impl<N: SimdComplexField, D: Dim, S: StorageMut<N, D, D>> Matrix<N, D, D, S> {
+impl<T: SimdComplexField, D: Dim, S: StorageMut<T, D, D>> Matrix<T, D, D, S> {
     /// Sets `self` to its adjoint.
     #[deprecated(note = "Renamed to `self.adjoint_mut()`.")]
     pub fn conjugate_transform_mut(&mut self) {
@@ -1323,8 +1333,8 @@ impl<N: SimdComplexField, D: Dim, S: StorageMut<N, D, D>> Matrix<N, D, D, S> {
         for i in 0..dim {
             for j in 0..i {
                 unsafe {
-                    let ref_ij = self.get_unchecked_mut((i, j)) as *mut N;
-                    let ref_ji = self.get_unchecked_mut((j, i)) as *mut N;
+                    let ref_ij = self.get_unchecked_mut((i, j)) as *mut T;
+                    let ref_ji = self.get_unchecked_mut((j, i)) as *mut T;
                     let conj_ij = (*ref_ij).simd_conjugate();
                     let conj_ji = (*ref_ji).simd_conjugate();
                     *ref_ij = conj_ji;
@@ -1340,12 +1350,12 @@ impl<N: SimdComplexField, D: Dim, S: StorageMut<N, D, D>> Matrix<N, D, D, S> {
     }
 }
 
-impl<N: Scalar, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
+impl<T: Scalar, D: Dim, S: Storage<T, D, D>> SquareMatrix<T, D, S> {
     /// The diagonal of this matrix.
     #[inline]
-    pub fn diagonal(&self) -> VectorN<N, D>
+    pub fn diagonal(&self) -> OVector<T, D>
     where
-        DefaultAllocator: Allocator<N, D>,
+        DefaultAllocator: Allocator<T, D>,
     {
         self.map_diagonal(|e| e)
     }
@@ -1354,9 +1364,9 @@ impl<N: Scalar, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
     ///
     /// This is a more efficient version of `self.diagonal().map(f)` since this
     /// allocates only once.
-    pub fn map_diagonal<N2: Scalar>(&self, mut f: impl FnMut(N) -> N2) -> VectorN<N2, D>
+    pub fn map_diagonal<T2: Scalar>(&self, mut f: impl FnMut(T) -> T2) -> OVector<T2, D>
     where
-        DefaultAllocator: Allocator<N2, D>,
+        DefaultAllocator: Allocator<T2, D>,
     {
         assert!(
             self.is_square(),
@@ -1364,8 +1374,8 @@ impl<N: Scalar, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
         );
 
         let dim = self.data.shape().0;
-        let mut res: VectorN<N2, D> =
-            unsafe { crate::unimplemented_or_uninitialized_generic!(dim, U1) };
+        let mut res: OVector<T2, D> =
+            unsafe { crate::unimplemented_or_uninitialized_generic!(dim, Const::<1>) };
 
         for i in 0..dim.value() {
             unsafe {
@@ -1378,9 +1388,9 @@ impl<N: Scalar, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
 
     /// Computes a trace of a square matrix, i.e., the sum of its diagonal elements.
     #[inline]
-    pub fn trace(&self) -> N
+    pub fn trace(&self) -> T
     where
-        N: Scalar + Zero + ClosedAdd,
+        T: Scalar + Zero + ClosedAdd,
     {
         assert!(
             self.is_square(),
@@ -1388,7 +1398,7 @@ impl<N: Scalar, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
         );
 
         let dim = self.data.shape().0;
-        let mut res = N::zero();
+        let mut res = T::zero();
 
         for i in 0..dim.value() {
             res += unsafe { self.get_unchecked((i, i)).inlined_clone() };
@@ -1398,12 +1408,12 @@ impl<N: Scalar, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
     }
 }
 
-impl<N: SimdComplexField, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
+impl<T: SimdComplexField, D: Dim, S: Storage<T, D, D>> SquareMatrix<T, D, S> {
     /// The symmetric part of `self`, i.e., `0.5 * (self + self.transpose())`.
     #[inline]
-    pub fn symmetric_part(&self) -> MatrixMN<N, D, D>
+    pub fn symmetric_part(&self) -> OMatrix<T, D, D>
     where
-        DefaultAllocator: Allocator<N, D, D>,
+        DefaultAllocator: Allocator<T, D, D>,
     {
         assert!(
             self.is_square(),
@@ -1411,15 +1421,15 @@ impl<N: SimdComplexField, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
         );
         let mut tr = self.transpose();
         tr += self;
-        tr *= crate::convert::<_, N>(0.5);
+        tr *= crate::convert::<_, T>(0.5);
         tr
     }
 
     /// The hermitian part of `self`, i.e., `0.5 * (self + self.adjoint())`.
     #[inline]
-    pub fn hermitian_part(&self) -> MatrixMN<N, D, D>
+    pub fn hermitian_part(&self) -> OMatrix<T, D, D>
     where
-        DefaultAllocator: Allocator<N, D, D>,
+        DefaultAllocator: Allocator<T, D, D>,
     {
         assert!(
             self.is_square(),
@@ -1428,72 +1438,72 @@ impl<N: SimdComplexField, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
 
         let mut tr = self.adjoint();
         tr += self;
-        tr *= crate::convert::<_, N>(0.5);
+        tr *= crate::convert::<_, T>(0.5);
         tr
     }
 }
 
-impl<N: Scalar + Zero + One, D: DimAdd<U1> + IsNotStaticOne, S: Storage<N, D, D>>
-    Matrix<N, D, D, S>
+impl<T: Scalar + Zero + One, D: DimAdd<U1> + IsNotStaticOne, S: Storage<T, D, D>>
+    Matrix<T, D, D, S>
 {
     /// Yields the homogeneous matrix for this matrix, i.e., appending an additional dimension and
     /// and setting the diagonal element to `1`.
     #[inline]
-    pub fn to_homogeneous(&self) -> MatrixN<N, DimSum<D, U1>>
+    pub fn to_homogeneous(&self) -> OMatrix<T, DimSum<D, U1>, DimSum<D, U1>>
     where
-        DefaultAllocator: Allocator<N, DimSum<D, U1>, DimSum<D, U1>>,
+        DefaultAllocator: Allocator<T, DimSum<D, U1>, DimSum<D, U1>>,
     {
         assert!(
             self.is_square(),
             "Only square matrices can currently be transformed to homogeneous coordinates."
         );
         let dim = DimSum::<D, U1>::from_usize(self.nrows() + 1);
-        let mut res = MatrixN::identity_generic(dim, dim);
+        let mut res = OMatrix::identity_generic(dim, dim);
         res.generic_slice_mut::<D, D>((0, 0), self.data.shape())
             .copy_from(&self);
         res
     }
 }
 
-impl<N: Scalar + Zero, D: DimAdd<U1>, S: Storage<N, D>> Vector<N, D, S> {
+impl<T: Scalar + Zero, D: DimAdd<U1>, S: Storage<T, D>> Vector<T, D, S> {
     /// Computes the coordinates in projective space of this vector, i.e., appends a `0` to its
     /// coordinates.
     #[inline]
-    pub fn to_homogeneous(&self) -> VectorN<N, DimSum<D, U1>>
+    pub fn to_homogeneous(&self) -> OVector<T, DimSum<D, U1>>
     where
-        DefaultAllocator: Allocator<N, DimSum<D, U1>>,
+        DefaultAllocator: Allocator<T, DimSum<D, U1>>,
     {
-        self.push(N::zero())
+        self.push(T::zero())
     }
 
     /// Constructs a vector from coordinates in projective space, i.e., removes a `0` at the end of
     /// `self`. Returns `None` if this last component is not zero.
     #[inline]
-    pub fn from_homogeneous<SB>(v: Vector<N, DimSum<D, U1>, SB>) -> Option<VectorN<N, D>>
+    pub fn from_homogeneous<SB>(v: Vector<T, DimSum<D, U1>, SB>) -> Option<OVector<T, D>>
     where
-        SB: Storage<N, DimSum<D, U1>>,
-        DefaultAllocator: Allocator<N, D>,
+        SB: Storage<T, DimSum<D, U1>>,
+        DefaultAllocator: Allocator<T, D>,
     {
         if v[v.len() - 1].is_zero() {
             let nrows = D::from_usize(v.len() - 1);
-            Some(v.generic_slice((0, 0), (nrows, U1)).into_owned())
+            Some(v.generic_slice((0, 0), (nrows, Const::<1>)).into_owned())
         } else {
             None
         }
     }
 }
 
-impl<N: Scalar + Zero, D: DimAdd<U1>, S: Storage<N, D>> Vector<N, D, S> {
+impl<T: Scalar + Zero, D: DimAdd<U1>, S: Storage<T, D>> Vector<T, D, S> {
     /// Constructs a new vector of higher dimension by appending `element` to the end of `self`.
     #[inline]
-    pub fn push(&self, element: N) -> VectorN<N, DimSum<D, U1>>
+    pub fn push(&self, element: T) -> OVector<T, DimSum<D, U1>>
     where
-        DefaultAllocator: Allocator<N, DimSum<D, U1>>,
+        DefaultAllocator: Allocator<T, DimSum<D, U1>>,
     {
         let len = self.len();
         let hnrows = DimSum::<D, U1>::from_usize(len + 1);
-        let mut res: VectorN<N, _> =
-            unsafe { crate::unimplemented_or_uninitialized_generic!(hnrows, U1) };
+        let mut res: OVector<T, _> =
+            unsafe { crate::unimplemented_or_uninitialized_generic!(hnrows, Const::<1>) };
         res.generic_slice_mut((0, 0), self.data.shape())
             .copy_from(self);
         res[(len, 0)] = element;
@@ -1502,17 +1512,17 @@ impl<N: Scalar + Zero, D: DimAdd<U1>, S: Storage<N, D>> Vector<N, D, S> {
     }
 }
 
-impl<N, R: Dim, C: Dim, S> AbsDiffEq for Matrix<N, R, C, S>
+impl<T, R: Dim, C: Dim, S> AbsDiffEq for Matrix<T, R, C, S>
 where
-    N: Scalar + AbsDiffEq,
-    S: Storage<N, R, C>,
-    N::Epsilon: Copy,
+    T: Scalar + AbsDiffEq,
+    S: Storage<T, R, C>,
+    T::Epsilon: Copy,
 {
-    type Epsilon = N::Epsilon;
+    type Epsilon = T::Epsilon;
 
     #[inline]
     fn default_epsilon() -> Self::Epsilon {
-        N::default_epsilon()
+        T::default_epsilon()
     }
 
     #[inline]
@@ -1523,15 +1533,15 @@ where
     }
 }
 
-impl<N, R: Dim, C: Dim, S> RelativeEq for Matrix<N, R, C, S>
+impl<T, R: Dim, C: Dim, S> RelativeEq for Matrix<T, R, C, S>
 where
-    N: Scalar + RelativeEq,
-    S: Storage<N, R, C>,
-    N::Epsilon: Copy,
+    T: Scalar + RelativeEq,
+    S: Storage<T, R, C>,
+    T::Epsilon: Copy,
 {
     #[inline]
     fn default_max_relative() -> Self::Epsilon {
-        N::default_max_relative()
+        T::default_max_relative()
     }
 
     #[inline]
@@ -1545,15 +1555,15 @@ where
     }
 }
 
-impl<N, R: Dim, C: Dim, S> UlpsEq for Matrix<N, R, C, S>
+impl<T, R: Dim, C: Dim, S> UlpsEq for Matrix<T, R, C, S>
 where
-    N: Scalar + UlpsEq,
-    S: Storage<N, R, C>,
-    N::Epsilon: Copy,
+    T: Scalar + UlpsEq,
+    S: Storage<T, R, C>,
+    T::Epsilon: Copy,
 {
     #[inline]
     fn default_max_ulps() -> u32 {
-        N::default_max_ulps()
+        T::default_max_ulps()
     }
 
     #[inline]
@@ -1565,10 +1575,10 @@ where
     }
 }
 
-impl<N, R: Dim, C: Dim, S> PartialOrd for Matrix<N, R, C, S>
+impl<T, R: Dim, C: Dim, S> PartialOrd for Matrix<T, R, C, S>
 where
-    N: Scalar + PartialOrd,
-    S: Storage<N, R, C>,
+    T: Scalar + PartialOrd,
+    S: Storage<T, R, C>,
 {
     #[inline]
     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
@@ -1657,40 +1667,40 @@ where
     }
 }
 
-impl<N, R: Dim, C: Dim, S> Eq for Matrix<N, R, C, S>
+impl<T, R: Dim, C: Dim, S> Eq for Matrix<T, R, C, S>
 where
-    N: Scalar + Eq,
-    S: Storage<N, R, C>,
+    T: Scalar + Eq,
+    S: Storage<T, R, C>,
 {
 }
 
-impl<N, R, R2, C, C2, S, S2> PartialEq<Matrix<N, R2, C2, S2>> for Matrix<N, R, C, S>
+impl<T, R, R2, C, C2, S, S2> PartialEq<Matrix<T, R2, C2, S2>> for Matrix<T, R, C, S>
 where
-    N: Scalar + PartialEq,
+    T: Scalar + PartialEq,
     C: Dim,
     C2: Dim,
     R: Dim,
     R2: Dim,
-    S: Storage<N, R, C>,
-    S2: Storage<N, R2, C2>,
+    S: Storage<T, R, C>,
+    S2: Storage<T, R2, C2>,
 {
     #[inline]
-    fn eq(&self, right: &Matrix<N, R2, C2, S2>) -> bool {
+    fn eq(&self, right: &Matrix<T, R2, C2, S2>) -> bool {
         self.shape() == right.shape() && self.iter().zip(right.iter()).all(|(l, r)| l == r)
     }
 }
 
 macro_rules! impl_fmt {
     ($trait: path, $fmt_str_without_precision: expr, $fmt_str_with_precision: expr) => {
-        impl<N, R: Dim, C: Dim, S> $trait for Matrix<N, R, C, S>
+        impl<T, R: Dim, C: Dim, S> $trait for Matrix<T, R, C, S>
         where
-            N: Scalar + $trait,
-            S: Storage<N, R, C>,
+            T: Scalar + $trait,
+            S: Storage<T, R, C>,
             DefaultAllocator: Allocator<usize, R, C>,
         {
             fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
                 #[cfg(feature = "std")]
-                fn val_width<N: Scalar + $trait>(val: &N, f: &mut fmt::Formatter) -> usize {
+                fn val_width<T: Scalar + $trait>(val: &T, f: &mut fmt::Formatter) -> usize {
                     match f.precision() {
                         Some(precision) => format!($fmt_str_with_precision, val, precision)
                             .chars()
@@ -1700,7 +1710,7 @@ macro_rules! impl_fmt {
                 }
 
                 #[cfg(not(feature = "std"))]
-                fn val_width<N: Scalar + $trait>(_: &N, _: &mut fmt::Formatter) -> usize {
+                fn val_width<T: Scalar + $trait>(_: &T, _: &mut fmt::Formatter) -> usize {
                     4
                 }
 
@@ -1711,7 +1721,7 @@ macro_rules! impl_fmt {
                 }
 
                 let mut max_length = 0;
-                let mut lengths: MatrixMN<usize, R, C> = Matrix::zeros_generic(nrows, ncols);
+                let mut lengths: OMatrix<usize, R, C> = Matrix::zeros_generic(nrows, ncols);
                 let (nrows, ncols) = self.shape();
 
                 for i in 0..nrows {
@@ -1783,16 +1793,16 @@ fn lower_exp() {
 }
 
 /// # Cross product
-impl<N: Scalar + ClosedAdd + ClosedSub + ClosedMul, R: Dim, C: Dim, S: Storage<N, R, C>>
-    Matrix<N, R, C, S>
+impl<T: Scalar + ClosedAdd + ClosedSub + ClosedMul, R: Dim, C: Dim, S: Storage<T, R, C>>
+    Matrix<T, R, C, S>
 {
     /// The perpendicular product between two 2D column vectors, i.e. `a.x * b.y - a.y * b.x`.
     #[inline]
-    pub fn perp<R2, C2, SB>(&self, b: &Matrix<N, R2, C2, SB>) -> N
+    pub fn perp<R2, C2, SB>(&self, b: &Matrix<T, R2, C2, SB>) -> T
     where
         R2: Dim,
         C2: Dim,
-        SB: Storage<N, R2, C2>,
+        SB: Storage<T, R2, C2>,
         ShapeConstraint: SameNumberOfRows<R, U2>
             + SameNumberOfColumns<C, U1>
             + SameNumberOfRows<R2, U2>
@@ -1817,12 +1827,12 @@ impl<N: Scalar + ClosedAdd + ClosedSub + ClosedMul, R: Dim, C: Dim, S: Storage<N
     /// Panics if the shape is not 3D vector. In the future, this will be implemented only for
     /// dynamically-sized matrices and statically-sized 3D matrices.
     #[inline]
-    pub fn cross<R2, C2, SB>(&self, b: &Matrix<N, R2, C2, SB>) -> MatrixCross<N, R, C, R2, C2>
+    pub fn cross<R2, C2, SB>(&self, b: &Matrix<T, R2, C2, SB>) -> MatrixCross<T, R, C, R2, C2>
     where
         R2: Dim,
         C2: Dim,
-        SB: Storage<N, R2, C2>,
-        DefaultAllocator: SameShapeAllocator<N, R, C, R2, C2>,
+        SB: Storage<T, R2, C2>,
+        DefaultAllocator: SameShapeAllocator<T, R, C, R2, C2>,
         ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,
     {
         let shape = self.shape();
@@ -1838,7 +1848,7 @@ impl<N: Scalar + ClosedAdd + ClosedSub + ClosedMul, R: Dim, C: Dim, S: Storage<N
                 // TODO: soooo ugly!
                 let nrows = SameShapeR::<R, R2>::from_usize(3);
                 let ncols = SameShapeC::<C, C2>::from_usize(1);
-                let mut res: MatrixCross<N, R, C, R2, C2> =
+                let mut res: MatrixCross<T, R, C, R2, C2> =
                     crate::unimplemented_or_uninitialized_generic!(nrows, ncols);
 
                 let ax = self.get_unchecked((0, 0));
@@ -1863,7 +1873,7 @@ impl<N: Scalar + ClosedAdd + ClosedSub + ClosedMul, R: Dim, C: Dim, S: Storage<N
                 // TODO: ugly!
                 let nrows = SameShapeR::<R, R2>::from_usize(1);
                 let ncols = SameShapeC::<C, C2>::from_usize(3);
-                let mut res: MatrixCross<N, R, C, R2, C2> =
+                let mut res: MatrixCross<T, R, C, R2, C2> =
                     crate::unimplemented_or_uninitialized_generic!(nrows, ncols);
 
                 let ax = self.get_unchecked((0, 0));
@@ -1887,33 +1897,30 @@ impl<N: Scalar + ClosedAdd + ClosedSub + ClosedMul, R: Dim, C: Dim, S: Storage<N
     }
 }
 
-impl<N: Scalar + Field, S: Storage<N, U3>> Vector<N, U3, S>
-where
-    DefaultAllocator: Allocator<N, U3>,
-{
+impl<T: Scalar + Field, S: Storage<T, U3>> Vector<T, U3, S> {
     /// Computes the matrix `M` such that for all vector `v` we have `M * v == self.cross(&v)`.
     #[inline]
-    pub fn cross_matrix(&self) -> MatrixN<N, U3> {
-        MatrixN::<N, U3>::new(
-            N::zero(),
+    pub fn cross_matrix(&self) -> OMatrix<T, U3, U3> {
+        OMatrix::<T, U3, U3>::new(
+            T::zero(),
             -self[2].inlined_clone(),
             self[1].inlined_clone(),
             self[2].inlined_clone(),
-            N::zero(),
+            T::zero(),
             -self[0].inlined_clone(),
             -self[1].inlined_clone(),
             self[0].inlined_clone(),
-            N::zero(),
+            T::zero(),
         )
     }
 }
 
-impl<N: SimdComplexField, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
+impl<T: SimdComplexField, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
     /// The smallest angle between two vectors.
     #[inline]
-    pub fn angle<R2: Dim, C2: Dim, SB>(&self, other: &Matrix<N, R2, C2, SB>) -> N::SimdRealField
+    pub fn angle<R2: Dim, C2: Dim, SB>(&self, other: &Matrix<T, R2, C2, SB>) -> T::SimdRealField
     where
-        SB: Storage<N, R2, C2>,
+        SB: Storage<T, R2, C2>,
         ShapeConstraint: DimEq<R, R2> + DimEq<C, C2>,
     {
         let prod = self.dotc(other);
@@ -1921,26 +1928,26 @@ impl<N: SimdComplexField, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S
         let n2 = other.norm();
 
         if n1.is_zero() || n2.is_zero() {
-            N::SimdRealField::zero()
+            T::SimdRealField::zero()
         } else {
             let cang = prod.simd_real() / (n1 * n2);
-            cang.simd_clamp(-N::SimdRealField::one(), N::SimdRealField::one())
+            cang.simd_clamp(-T::SimdRealField::one(), T::SimdRealField::one())
                 .simd_acos()
         }
     }
 }
 
-impl<N, R: Dim, C: Dim, S> AbsDiffEq for Unit<Matrix<N, R, C, S>>
+impl<T, R: Dim, C: Dim, S> AbsDiffEq for Unit<Matrix<T, R, C, S>>
 where
-    N: Scalar + AbsDiffEq,
-    S: Storage<N, R, C>,
-    N::Epsilon: Copy,
+    T: Scalar + AbsDiffEq,
+    S: Storage<T, R, C>,
+    T::Epsilon: Copy,
 {
-    type Epsilon = N::Epsilon;
+    type Epsilon = T::Epsilon;
 
     #[inline]
     fn default_epsilon() -> Self::Epsilon {
-        N::default_epsilon()
+        T::default_epsilon()
     }
 
     #[inline]
@@ -1949,15 +1956,15 @@ where
     }
 }
 
-impl<N, R: Dim, C: Dim, S> RelativeEq for Unit<Matrix<N, R, C, S>>
+impl<T, R: Dim, C: Dim, S> RelativeEq for Unit<Matrix<T, R, C, S>>
 where
-    N: Scalar + RelativeEq,
-    S: Storage<N, R, C>,
-    N::Epsilon: Copy,
+    T: Scalar + RelativeEq,
+    S: Storage<T, R, C>,
+    T::Epsilon: Copy,
 {
     #[inline]
     fn default_max_relative() -> Self::Epsilon {
-        N::default_max_relative()
+        T::default_max_relative()
     }
 
     #[inline]
@@ -1972,15 +1979,15 @@ where
     }
 }
 
-impl<N, R: Dim, C: Dim, S> UlpsEq for Unit<Matrix<N, R, C, S>>
+impl<T, R: Dim, C: Dim, S> UlpsEq for Unit<Matrix<T, R, C, S>>
 where
-    N: Scalar + UlpsEq,
-    S: Storage<N, R, C>,
-    N::Epsilon: Copy,
+    T: Scalar + UlpsEq,
+    S: Storage<T, R, C>,
+    T::Epsilon: Copy,
 {
     #[inline]
     fn default_max_ulps() -> u32 {
-        N::default_max_ulps()
+        T::default_max_ulps()
     }
 
     #[inline]
@@ -1989,12 +1996,12 @@ where
     }
 }
 
-impl<N, R, C, S> Hash for Matrix<N, R, C, S>
+impl<T, R, C, S> Hash for Matrix<T, R, C, S>
 where
-    N: Scalar + Hash,
+    T: Scalar + Hash,
     R: Dim,
     C: Dim,
-    S: Storage<N, R, C>,
+    S: Storage<T, R, C>,
 {
     fn hash<H: Hasher>(&self, state: &mut H) {
         let (nrows, ncols) = self.shape();
diff --git a/src/base/matrix_simba.rs b/src/base/matrix_simba.rs
index 09bc937f..e0333f45 100644
--- a/src/base/matrix_simba.rs
+++ b/src/base/matrix_simba.rs
@@ -2,32 +2,32 @@ use simba::simd::SimdValue;
 
 use crate::base::allocator::Allocator;
 use crate::base::dimension::Dim;
-use crate::base::{DefaultAllocator, MatrixMN, Scalar};
+use crate::base::{DefaultAllocator, OMatrix, Scalar};
 
 /*
  *
  * Simd structures.
  *
  */
-impl<N, R, C> SimdValue for MatrixMN<N, R, C>
+impl<T, R, C> SimdValue for OMatrix<T, R, C>
 where
-    N: Scalar + SimdValue,
+    T: Scalar + SimdValue,
     R: Dim,
     C: Dim,
-    N::Element: Scalar,
-    DefaultAllocator: Allocator<N, R, C> + Allocator<N::Element, R, C>,
+    T::Element: Scalar,
+    DefaultAllocator: Allocator<T, R, C> + Allocator<T::Element, R, C>,
 {
-    type Element = MatrixMN<N::Element, R, C>;
-    type SimdBool = N::SimdBool;
+    type Element = OMatrix<T::Element, R, C>;
+    type SimdBool = T::SimdBool;
 
     #[inline]
     fn lanes() -> usize {
-        N::lanes()
+        T::lanes()
     }
 
     #[inline]
     fn splat(val: Self::Element) -> Self {
-        val.map(N::splat)
+        val.map(T::splat)
     }
 
     #[inline]
diff --git a/src/base/matrix_slice.rs b/src/base/matrix_slice.rs
index ac1fbfd6..6b03c7b2 100644
--- a/src/base/matrix_slice.rs
+++ b/src/base/matrix_slice.rs
@@ -4,7 +4,7 @@ use std::slice;
 
 use crate::base::allocator::Allocator;
 use crate::base::default_allocator::DefaultAllocator;
-use crate::base::dimension::{Dim, DimName, Dynamic, IsNotStaticOne, U1};
+use crate::base::dimension::{Const, Dim, DimName, Dynamic, IsNotStaticOne, U1};
 use crate::base::iter::MatrixIter;
 use crate::base::storage::{ContiguousStorage, ContiguousStorageMut, Owned, Storage, StorageMut};
 use crate::base::{Matrix, Scalar};
@@ -13,22 +13,22 @@ macro_rules! slice_storage_impl(
     ($doc: expr; $Storage: ident as $SRef: ty; $T: ident.$get_addr: ident ($Ptr: ty as $Ref: ty)) => {
         #[doc = $doc]
         #[derive(Debug)]
-        pub struct $T<'a, N: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim> {
+        pub struct $T<'a, T: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim> {
             ptr:       $Ptr,
             shape:     (R, C),
             strides:   (RStride, CStride),
             _phantoms: PhantomData<$Ref>,
         }
 
-        unsafe impl<'a, N: Scalar + Send, R: Dim, C: Dim, RStride: Dim, CStride: Dim> Send
-            for $T<'a, N, R, C, RStride, CStride>
+        unsafe impl<'a, T: Scalar + Send, R: Dim, C: Dim, RStride: Dim, CStride: Dim> Send
+            for $T<'a, T, R, C, RStride, CStride>
         {}
 
-        unsafe impl<'a, N: Scalar + Sync, R: Dim, C: Dim, RStride: Dim, CStride: Dim> Sync
-            for $T<'a, N, R, C, RStride, CStride>
+        unsafe impl<'a, T: Scalar + Sync, R: Dim, C: Dim, RStride: Dim, CStride: Dim> Sync
+            for $T<'a, T, R, C, RStride, CStride>
         {}
 
-        impl<'a, N: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim> $T<'a, N, R, C, RStride, CStride> {
+        impl<'a, T: Scalar, 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.
             #[inline]
             pub unsafe fn from_raw_parts(ptr:     $Ptr,
@@ -48,14 +48,14 @@ macro_rules! slice_storage_impl(
         }
 
         // Dynamic is arbitrary. It's just to be able to call the constructors with `Slice::`
-        impl<'a, N: Scalar, R: Dim, C: Dim> $T<'a, N, R, C, Dynamic, Dynamic> {
+        impl<'a, T: Scalar, R: Dim, C: Dim> $T<'a, T, R, C, Dynamic, Dynamic> {
             /// Create a new matrix slice without bound checking.
             #[inline]
             pub unsafe fn new_unchecked<RStor, CStor, S>(storage: $SRef, start: (usize, usize), shape: (R, C))
-                -> $T<'a, N, R, C, S::RStride, S::CStride>
+                -> $T<'a, T, R, C, S::RStride, S::CStride>
                 where RStor: Dim,
                       CStor: Dim,
-                      S:     $Storage<N, RStor, CStor> {
+                      S:     $Storage<T, RStor, CStor> {
 
                 let strides = storage.strides();
                 $T::new_with_strides_unchecked(storage, start, shape, strides)
@@ -67,10 +67,10 @@ macro_rules! slice_storage_impl(
                                                                                         start:   (usize, usize),
                                                                                         shape:   (R, C),
                                                                                         strides: (RStride, CStride))
-                -> $T<'a, N, R, C, RStride, CStride>
+                -> $T<'a, T, R, C, RStride, CStride>
                 where RStor: Dim,
                       CStor: Dim,
-                      S: $Storage<N, RStor, CStor>,
+                      S: $Storage<T, RStor, CStor>,
                       RStride: Dim,
                       CStride: Dim {
 
@@ -82,20 +82,20 @@ macro_rules! slice_storage_impl(
 
 slice_storage_impl!("A matrix data storage for a matrix slice. Only contains an internal reference \
                      to another matrix data storage.";
-    Storage as &'a S; SliceStorage.get_address_unchecked(*const N as &'a N));
+    Storage as &'a S; SliceStorage.get_address_unchecked(*const T as &'a T));
 
 slice_storage_impl!("A mutable matrix data storage for mutable matrix slice. Only contains an \
                      internal mutable reference to another matrix data storage.";
-    StorageMut as &'a mut S; SliceStorageMut.get_address_unchecked_mut(*mut N as &'a mut N)
+    StorageMut as &'a mut S; SliceStorageMut.get_address_unchecked_mut(*mut T as &'a mut T)
 );
 
-impl<'a, N: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim> Copy
-    for SliceStorage<'a, N, R, C, RStride, CStride>
+impl<'a, T: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim> Copy
+    for SliceStorage<'a, T, R, C, RStride, CStride>
 {
 }
 
-impl<'a, N: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim> Clone
-    for SliceStorage<'a, N, 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>
 {
     #[inline]
     fn clone(&self) -> Self {
@@ -110,14 +110,14 @@ impl<'a, N: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim> Clone
 
 macro_rules! storage_impl(
     ($($T: ident),* $(,)*) => {$(
-        unsafe impl<'a, N: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim> Storage<N, R, C>
-            for $T<'a, N, R, C, RStride, CStride> {
+        unsafe impl<'a, T: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim> Storage<T, R, C>
+            for $T<'a, T, R, C, RStride, CStride> {
 
             type RStride = RStride;
             type CStride = CStride;
 
             #[inline]
-            fn ptr(&self) -> *const N {
+            fn ptr(&self) -> *const T {
                 self.ptr
             }
 
@@ -148,21 +148,21 @@ macro_rules! storage_impl(
             }
 
             #[inline]
-            fn into_owned(self) -> Owned<N, R, C>
-                where DefaultAllocator: Allocator<N, R, C> {
+            fn into_owned(self) -> Owned<T, R, C>
+                where DefaultAllocator: Allocator<T, R, C> {
                 self.clone_owned()
             }
 
             #[inline]
-            fn clone_owned(&self) -> Owned<N, R, C>
-                where DefaultAllocator: Allocator<N, R, C> {
+            fn clone_owned(&self) -> Owned<T, R, C>
+                where DefaultAllocator: Allocator<T, R, C> {
                 let (nrows, ncols) = self.shape();
                 let it = MatrixIter::new(self).cloned();
                 DefaultAllocator::allocate_from_iterator(nrows, ncols, it)
             }
 
             #[inline]
-            fn as_slice(&self) -> &[N] {
+            fn as_slice(&self) -> &[T] {
                 let (nrows, ncols) = self.shape();
                 if nrows.value() != 0 && ncols.value() != 0 {
                     let sz = self.linear_index(nrows.value() - 1, ncols.value() - 1);
@@ -178,16 +178,16 @@ macro_rules! storage_impl(
 
 storage_impl!(SliceStorage, SliceStorageMut);
 
-unsafe impl<'a, N: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim> StorageMut<N, R, C>
-    for SliceStorageMut<'a, N, R, C, RStride, CStride>
+unsafe impl<'a, T: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim> StorageMut<T, R, C>
+    for SliceStorageMut<'a, T, R, C, RStride, CStride>
 {
     #[inline]
-    fn ptr_mut(&mut self) -> *mut N {
+    fn ptr_mut(&mut self) -> *mut T {
         self.ptr
     }
 
     #[inline]
-    fn as_mut_slice(&mut self) -> &mut [N] {
+    fn as_mut_slice(&mut self) -> &mut [T] {
         let (nrows, ncols) = self.shape();
         if nrows.value() != 0 && ncols.value() != 0 {
             let sz = self.linear_index(nrows.value() - 1, ncols.value() - 1);
@@ -198,33 +198,33 @@ unsafe impl<'a, N: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim> StorageMu
     }
 }
 
-unsafe impl<'a, N: Scalar, R: Dim, CStride: Dim> ContiguousStorage<N, R, U1>
-    for SliceStorage<'a, N, R, U1, U1, CStride>
+unsafe impl<'a, T: Scalar, R: Dim, CStride: Dim> ContiguousStorage<T, R, U1>
+    for SliceStorage<'a, T, R, U1, U1, CStride>
 {
 }
-unsafe impl<'a, N: Scalar, R: Dim, CStride: Dim> ContiguousStorage<N, R, U1>
-    for SliceStorageMut<'a, N, R, U1, U1, CStride>
+unsafe impl<'a, T: Scalar, R: Dim, CStride: Dim> ContiguousStorage<T, R, U1>
+    for SliceStorageMut<'a, T, R, U1, U1, CStride>
 {
 }
-unsafe impl<'a, N: Scalar, R: Dim, CStride: Dim> ContiguousStorageMut<N, R, U1>
-    for SliceStorageMut<'a, N, R, U1, U1, CStride>
+unsafe impl<'a, T: Scalar, R: Dim, CStride: Dim> ContiguousStorageMut<T, R, U1>
+    for SliceStorageMut<'a, T, R, U1, U1, CStride>
 {
 }
 
-unsafe impl<'a, N: Scalar, R: DimName, C: Dim + IsNotStaticOne> ContiguousStorage<N, R, C>
-    for SliceStorage<'a, N, R, C, U1, R>
+unsafe impl<'a, T: Scalar, R: DimName, C: Dim + IsNotStaticOne> ContiguousStorage<T, R, C>
+    for SliceStorage<'a, T, R, C, U1, R>
 {
 }
-unsafe impl<'a, N: Scalar, R: DimName, C: Dim + IsNotStaticOne> ContiguousStorage<N, R, C>
-    for SliceStorageMut<'a, N, R, C, U1, R>
+unsafe impl<'a, T: Scalar, R: DimName, C: Dim + IsNotStaticOne> ContiguousStorage<T, R, C>
+    for SliceStorageMut<'a, T, R, C, U1, R>
 {
 }
-unsafe impl<'a, N: Scalar, R: DimName, C: Dim + IsNotStaticOne> ContiguousStorageMut<N, R, C>
-    for SliceStorageMut<'a, N, R, C, U1, R>
+unsafe impl<'a, T: Scalar, R: DimName, C: Dim + IsNotStaticOne> ContiguousStorageMut<T, R, C>
+    for SliceStorageMut<'a, T, R, C, U1, R>
 {
 }
 
-impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
+impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
     #[inline]
     fn assert_slice_index(
         &self,
@@ -281,20 +281,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<N, U1, C, S::RStride, S::CStride> {
-            $me.$fixed_rows::<U1>(i)
+        pub fn $row($me: $Me, i: usize) -> $MatrixSlice<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<N, U1, Dynamic, S::RStride, S::CStride> {
-            $me.$generic_slice((i, 0), (U1, Dynamic::new(n)))
+        pub fn $row_part($me: $Me, i: usize, n: usize) -> $MatrixSlice<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<N, Dynamic, C, S::RStride, S::CStride> {
+            -> $MatrixSlice<T, Dynamic, C, S::RStride, S::CStride> {
 
             $me.$rows_generic(first_row, Dynamic::new(nrows))
         }
@@ -302,33 +302,33 @@ 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<N, Dynamic, C, Dynamic, S::CStride> {
+            -> $MatrixSlice<T, Dynamic, C, Dynamic, S::CStride> {
 
             $me.$rows_generic_with_step(first_row, Dynamic::new(nrows), step)
         }
 
         /// Extracts a compile-time number of consecutive rows from this matrix.
         #[inline]
-        pub fn $fixed_rows<RSlice: DimName>($me: $Me, first_row: usize)
-            -> $MatrixSlice<N, RSlice, C, S::RStride, S::CStride> {
+        pub fn $fixed_rows<const RSLICE: usize>($me: $Me, first_row: usize)
+            -> $MatrixSlice<T, Const<RSLICE>, C, S::RStride, S::CStride> {
 
-            $me.$rows_generic(first_row, RSlice::name())
+            $me.$rows_generic(first_row, Const::<RSLICE>)
         }
 
         /// Extracts from this matrix a compile-time number of rows regularly skipping `step`
         /// rows.
         #[inline]
-        pub fn $fixed_rows_with_step<RSlice: DimName>($me: $Me, first_row: usize, step: usize)
-            -> $MatrixSlice<N, RSlice, C, Dynamic, S::CStride> {
+        pub fn $fixed_rows_with_step<const RSLICE: usize>($me: $Me, first_row: usize, step: usize)
+            -> $MatrixSlice<T, Const<RSLICE>, C, Dynamic, S::CStride> {
 
-            $me.$rows_generic_with_step(first_row, RSlice::name(), step)
+            $me.$rows_generic_with_step(first_row, Const::<RSLICE>, 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)
-            -> $MatrixSlice<N, RSlice, C, S::RStride, S::CStride> {
+            -> $MatrixSlice<T, RSlice, C, S::RStride, S::CStride> {
 
             let my_shape   = $me.data.shape();
             $me.assert_slice_index((row_start, 0), (nrows.value(), my_shape.1.value()), (0, 0));
@@ -345,7 +345,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<N, RSlice, C, Dynamic, S::CStride>
+            -> $MatrixSlice<T, RSlice, C, Dynamic, S::CStride>
             where RSlice: Dim {
 
             let my_shape   = $me.data.shape();
@@ -368,20 +368,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<N, R, U1, S::RStride, S::CStride> {
-            $me.$fixed_columns::<U1>(i)
+        pub fn $column($me: $Me, i: usize) -> $MatrixSlice<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<N, Dynamic, U1, S::RStride, S::CStride> {
-            $me.$generic_slice((0, i), (Dynamic::new(n), U1))
+        pub fn $column_part($me: $Me, i: usize, n: usize) -> $MatrixSlice<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<N, R, Dynamic, S::RStride, S::CStride> {
+            -> $MatrixSlice<T, R, Dynamic, S::RStride, S::CStride> {
 
             $me.$columns_generic(first_col, Dynamic::new(ncols))
         }
@@ -390,33 +390,33 @@ macro_rules! matrix_slice_impl(
         /// columns.
         #[inline]
         pub fn $columns_with_step($me: $Me, first_col: usize, ncols: usize, step: usize)
-            -> $MatrixSlice<N, R, Dynamic, S::RStride, Dynamic> {
+            -> $MatrixSlice<T, R, Dynamic, S::RStride, Dynamic> {
 
             $me.$columns_generic_with_step(first_col, Dynamic::new(ncols), step)
         }
 
         /// Extracts a compile-time number of consecutive columns from this matrix.
         #[inline]
-        pub fn $fixed_columns<CSlice: DimName>($me: $Me, first_col: usize)
-            -> $MatrixSlice<N, R, CSlice, S::RStride, S::CStride> {
+        pub fn $fixed_columns<const CSLICE: usize>($me: $Me, first_col: usize)
+            -> $MatrixSlice<T, R, Const<CSLICE>, S::RStride, S::CStride> {
 
-            $me.$columns_generic(first_col, CSlice::name())
+            $me.$columns_generic(first_col, Const::<CSLICE>)
         }
 
         /// Extracts from this matrix a compile-time number of columns regularly skipping
         /// `step` columns.
         #[inline]
-        pub fn $fixed_columns_with_step<CSlice: DimName>($me: $Me, first_col: usize, step: usize)
-            -> $MatrixSlice<N, R, CSlice, S::RStride, Dynamic> {
+        pub fn $fixed_columns_with_step<const CSLICE: usize>($me: $Me, first_col: usize, step: usize)
+            -> $MatrixSlice<T, R, Const<CSLICE>, S::RStride, Dynamic> {
 
-            $me.$columns_generic_with_step(first_col, CSlice::name(), step)
+            $me.$columns_generic_with_step(first_col, Const::<CSLICE>, 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)
-            -> $MatrixSlice<N, R, CSlice, S::RStride, S::CStride> {
+            -> $MatrixSlice<T, R, CSlice, S::RStride, S::CStride> {
 
             let my_shape = $me.data.shape();
             $me.assert_slice_index((0, first_col), (my_shape.0.value(), ncols.value()), (0, 0));
@@ -433,7 +433,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<N, R, CSlice, S::RStride, Dynamic> {
+            -> $MatrixSlice<T, R, CSlice, S::RStride, Dynamic> {
 
             let my_shape   = $me.data.shape();
             let my_strides = $me.data.strides();
@@ -458,7 +458,7 @@ macro_rules! matrix_slice_impl(
         /// consecutive elements.
         #[inline]
         pub fn $slice($me: $Me, start: (usize, usize), shape: (usize, usize))
-            -> $MatrixSlice<N, Dynamic, Dynamic, S::RStride, S::CStride> {
+            -> $MatrixSlice<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));
@@ -476,7 +476,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<N, Dynamic, Dynamic, Dynamic, Dynamic> {
+            -> $MatrixSlice<T, Dynamic, Dynamic, Dynamic, Dynamic> {
             let shape = (Dynamic::new(shape.0), Dynamic::new(shape.1));
 
             $me.$generic_slice_with_steps(start, shape, steps)
@@ -485,13 +485,11 @@ macro_rules! matrix_slice_impl(
         /// Slices this matrix starting at its component `(irow, icol)` and with `(R::dim(),
         /// CSlice::dim())` consecutive components.
         #[inline]
-        pub fn $fixed_slice<RSlice, CSlice>($me: $Me, irow: usize, icol: usize)
-            -> $MatrixSlice<N, RSlice, CSlice, S::RStride, S::CStride>
-            where RSlice: DimName,
-                  CSlice: DimName {
+        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> {
 
-            $me.assert_slice_index((irow, icol), (RSlice::dim(), CSlice::dim()), (0, 0));
-            let shape = (RSlice::name(), CSlice::name());
+            $me.assert_slice_index((irow, icol), (RSLICE, CSLICE), (0, 0));
+            let shape = (Const::<RSLICE>, Const::<CSLICE>);
 
             unsafe {
                 let data = $SliceStorage::new_unchecked($data, (irow, icol), shape);
@@ -500,22 +498,20 @@ macro_rules! matrix_slice_impl(
         }
 
         /// Slices this matrix starting at its component `(start.0, start.1)` and with
-        /// `(R::dim(), CSlice::dim())` components. Each row (resp. column) of the sliced
+        /// `(RSLICE, CSLICE)` 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<RSlice, CSlice>($me: $Me, start: (usize, usize), steps: (usize, usize))
-            -> $MatrixSlice<N, RSlice, CSlice, Dynamic, Dynamic>
-            where RSlice: DimName,
-                  CSlice: DimName {
-            let shape = (RSlice::name(), CSlice::name());
+        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> {
+            let shape = (Const::<RSLICE>, Const::<CSLICE>);
             $me.$generic_slice_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))
-            -> $MatrixSlice<N, RSlice, CSlice, S::RStride, S::CStride>
+            -> $MatrixSlice<T, RSlice, CSlice, S::RStride, S::CStride>
             where RSlice: Dim,
                   CSlice: Dim {
 
@@ -533,7 +529,7 @@ macro_rules! matrix_slice_impl(
                                                          start: (usize, usize),
                                                          shape: (RSlice, CSlice),
                                                          steps: (usize, usize))
-            -> $MatrixSlice<N, RSlice, CSlice, Dynamic, Dynamic>
+            -> $MatrixSlice<T, RSlice, CSlice, Dynamic, Dynamic>
             where RSlice: Dim,
                   CSlice: Dim {
 
@@ -559,8 +555,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<N, Range1::Size, C, S::RStride, S::CStride>,
-                $MatrixSlice<N, Range2::Size, C, S::RStride, S::CStride>) {
+            -> ($MatrixSlice<T, Range1::Size, C, S::RStride, S::CStride>,
+                $MatrixSlice<T, Range2::Size, C, S::RStride, S::CStride>) {
 
             let (nrows, ncols) = $me.data.shape();
             let strides        = $me.data.strides();
@@ -595,8 +591,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<N, R, Range1::Size, S::RStride, S::CStride>,
-                $MatrixSlice<N, R, Range2::Size, S::RStride, S::CStride>) {
+            -> ($MatrixSlice<T, R, Range1::Size, S::RStride, S::CStride>,
+                $MatrixSlice<T, R, Range2::Size, S::RStride, S::CStride>) {
 
             let (nrows, ncols) = $me.data.shape();
             let strides        = $me.data.strides();
@@ -629,14 +625,14 @@ macro_rules! matrix_slice_impl(
 );
 
 /// A matrix slice.
-pub type MatrixSlice<'a, N, R, C, RStride, CStride> =
-    Matrix<N, R, C, SliceStorage<'a, N, R, C, RStride, CStride>>;
+pub type MatrixSlice<'a, T, R, C, RStride = U1, CStride = R> =
+    Matrix<T, R, C, SliceStorage<'a, T, R, C, RStride, CStride>>;
 /// A mutable matrix slice.
-pub type MatrixSliceMut<'a, N, R, C, RStride, CStride> =
-    Matrix<N, R, C, SliceStorageMut<'a, N, R, C, RStride, CStride>>;
+pub type MatrixSliceMut<'a, T, R, C, RStride = U1, CStride = R> =
+    Matrix<T, R, C, SliceStorageMut<'a, T, R, C, RStride, CStride>>;
 
 /// # Slicing based on index and length
-impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
+impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
     matrix_slice_impl!(
      self: &Self, MatrixSlice, SliceStorage, Storage.get_address_unchecked(), &self.data;
      row,
@@ -666,7 +662,7 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
 }
 
 /// # Mutable slicing based on index and length
-impl<N: Scalar, R: Dim, C: Dim, S: StorageMut<N, R, C>> Matrix<N, R, C, S> {
+impl<T: Scalar, R: Dim, C: Dim, S: StorageMut<T, R, C>> Matrix<T, R, C, S> {
     matrix_slice_impl!(
      self: &mut Self, MatrixSliceMut, SliceStorageMut, StorageMut.get_address_unchecked_mut(), &mut self.data;
      row_mut,
@@ -730,7 +726,7 @@ impl<D: Dim> SliceRange<D> for usize {
 
     #[inline(always)]
     fn size(&self, _: D) -> Self::Size {
-        U1
+        Const::<1>
     }
 }
 
@@ -812,7 +808,7 @@ impl<D: Dim> SliceRange<D> for RangeFull {
 
 // TODO: see how much of this overlaps with the general indexing
 // methods from indexing.rs.
-impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
+impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
     /// Slices a sub-matrix containing the rows indexed by the range `rows` and the columns indexed
     /// by the range `cols`.
     #[inline]
@@ -820,7 +816,7 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
         &self,
         rows: RowRange,
         cols: ColRange,
-    ) -> MatrixSlice<N, RowRange::Size, ColRange::Size, S::RStride, S::CStride>
+    ) -> MatrixSlice<T, RowRange::Size, ColRange::Size, S::RStride, S::CStride>
     where
         RowRange: SliceRange<R>,
         ColRange: SliceRange<C>,
@@ -837,7 +833,7 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     pub fn rows_range<RowRange: SliceRange<R>>(
         &self,
         rows: RowRange,
-    ) -> MatrixSlice<N, RowRange::Size, C, S::RStride, S::CStride> {
+    ) -> MatrixSlice<T, RowRange::Size, C, S::RStride, S::CStride> {
         self.slice_range(rows, ..)
     }
 
@@ -846,21 +842,21 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     pub fn columns_range<ColRange: SliceRange<C>>(
         &self,
         cols: ColRange,
-    ) -> MatrixSlice<N, R, ColRange::Size, S::RStride, S::CStride> {
+    ) -> MatrixSlice<T, R, ColRange::Size, S::RStride, S::CStride> {
         self.slice_range(.., cols)
     }
 }
 
 // TODO: see how much of this overlaps with the general indexing
 // methods from indexing.rs.
-impl<N: Scalar, R: Dim, C: Dim, S: StorageMut<N, R, C>> Matrix<N, R, C, S> {
+impl<T: Scalar, R: Dim, C: Dim, S: StorageMut<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`.
     pub fn slice_range_mut<RowRange, ColRange>(
         &mut self,
         rows: RowRange,
         cols: ColRange,
-    ) -> MatrixSliceMut<N, RowRange::Size, ColRange::Size, S::RStride, S::CStride>
+    ) -> MatrixSliceMut<T, RowRange::Size, ColRange::Size, S::RStride, S::CStride>
     where
         RowRange: SliceRange<R>,
         ColRange: SliceRange<C>,
@@ -877,7 +873,7 @@ impl<N: Scalar, R: Dim, C: Dim, S: StorageMut<N, R, C>> Matrix<N, R, C, S> {
     pub fn rows_range_mut<RowRange: SliceRange<R>>(
         &mut self,
         rows: RowRange,
-    ) -> MatrixSliceMut<N, RowRange::Size, C, S::RStride, S::CStride> {
+    ) -> MatrixSliceMut<T, RowRange::Size, C, S::RStride, S::CStride> {
         self.slice_range_mut(rows, ..)
     }
 
@@ -886,21 +882,21 @@ impl<N: Scalar, R: Dim, C: Dim, S: StorageMut<N, R, C>> Matrix<N, R, C, S> {
     pub fn columns_range_mut<ColRange: SliceRange<C>>(
         &mut self,
         cols: ColRange,
-    ) -> MatrixSliceMut<N, R, ColRange::Size, S::RStride, S::CStride> {
+    ) -> MatrixSliceMut<T, R, ColRange::Size, S::RStride, S::CStride> {
         self.slice_range_mut(.., cols)
     }
 }
 
-impl<'a, N, R, C, RStride, CStride> From<MatrixSliceMut<'a, N, R, C, RStride, CStride>>
-    for MatrixSlice<'a, N, R, C, RStride, CStride>
+impl<'a, T, R, C, RStride, CStride> From<MatrixSliceMut<'a, T, R, C, RStride, CStride>>
+    for MatrixSlice<'a, T, R, C, RStride, CStride>
 where
-    N: Scalar,
+    T: Scalar,
     R: Dim,
     C: Dim,
     RStride: Dim,
     CStride: Dim,
 {
-    fn from(slice_mut: MatrixSliceMut<'a, N, R, C, RStride, CStride>) -> Self {
+    fn from(slice_mut: MatrixSliceMut<'a, T, R, C, RStride, CStride>) -> Self {
         let data = SliceStorage {
             ptr: slice_mut.data.ptr,
             shape: slice_mut.data.shape,
diff --git a/src/base/min_max.rs b/src/base/min_max.rs
index 0bddd4b0..d532d87a 100644
--- a/src/base/min_max.rs
+++ b/src/base/min_max.rs
@@ -4,7 +4,7 @@ use num::{Signed, Zero};
 use simba::simd::SimdSigned;
 
 /// # Find the min and max components
-impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
+impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
     /// Returns the absolute value of the component with the largest absolute value.
     /// # Example
     /// ```
@@ -13,12 +13,12 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     /// assert_eq!(Vector3::new(-1.0, -2.0, -3.0).amax(), 3.0);
     /// ```
     #[inline]
-    pub fn amax(&self) -> N
+    pub fn amax(&self) -> T
     where
-        N: Zero + SimdSigned + SimdPartialOrd,
+        T: Zero + SimdSigned + SimdPartialOrd,
     {
         self.fold_with(
-            |e| e.unwrap_or(&N::zero()).simd_abs(),
+            |e| e.unwrap_or(&T::zero()).simd_abs(),
             |a, b| a.simd_max(b.simd_abs()),
         )
     }
@@ -33,12 +33,12 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     ///     Complex::new(1.0, 3.0)).camax(), 5.0);
     /// ```
     #[inline]
-    pub fn camax(&self) -> N::SimdRealField
+    pub fn camax(&self) -> T::SimdRealField
     where
-        N: SimdComplexField,
+        T: SimdComplexField,
     {
         self.fold_with(
-            |e| e.unwrap_or(&N::zero()).simd_norm1(),
+            |e| e.unwrap_or(&T::zero()).simd_norm1(),
             |a, b| a.simd_max(b.simd_norm1()),
         )
     }
@@ -52,12 +52,12 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     /// assert_eq!(Vector3::new(5u32, 2, 3).max(), 5);
     /// ```
     #[inline]
-    pub fn max(&self) -> N
+    pub fn max(&self) -> T
     where
-        N: SimdPartialOrd + Zero,
+        T: SimdPartialOrd + Zero,
     {
         self.fold_with(
-            |e| e.map(|e| e.inlined_clone()).unwrap_or_else(N::zero),
+            |e| e.map(|e| e.inlined_clone()).unwrap_or_else(T::zero),
             |a, b| a.simd_max(b.inlined_clone()),
         )
     }
@@ -70,12 +70,12 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     /// assert_eq!(Vector3::new(10.0, 2.0, 30.0).amin(), 2.0);
     /// ```
     #[inline]
-    pub fn amin(&self) -> N
+    pub fn amin(&self) -> T
     where
-        N: Zero + SimdPartialOrd + SimdSigned,
+        T: Zero + SimdPartialOrd + SimdSigned,
     {
         self.fold_with(
-            |e| e.map(|e| e.simd_abs()).unwrap_or_else(N::zero),
+            |e| e.map(|e| e.simd_abs()).unwrap_or_else(T::zero),
             |a, b| a.simd_min(b.simd_abs()),
         )
     }
@@ -90,14 +90,14 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     ///     Complex::new(1.0, 3.0)).camin(), 3.0);
     /// ```
     #[inline]
-    pub fn camin(&self) -> N::SimdRealField
+    pub fn camin(&self) -> T::SimdRealField
     where
-        N: SimdComplexField,
+        T: SimdComplexField,
     {
         self.fold_with(
             |e| {
                 e.map(|e| e.simd_norm1())
-                    .unwrap_or_else(N::SimdRealField::zero)
+                    .unwrap_or_else(T::SimdRealField::zero)
             },
             |a, b| a.simd_min(b.simd_norm1()),
         )
@@ -112,12 +112,12 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     /// assert_eq!(Vector3::new(5u32, 2, 3).min(), 2);
     /// ```
     #[inline]
-    pub fn min(&self) -> N
+    pub fn min(&self) -> T
     where
-        N: SimdPartialOrd + Zero,
+        T: SimdPartialOrd + Zero,
     {
         self.fold_with(
-            |e| e.map(|e| e.inlined_clone()).unwrap_or_else(N::zero),
+            |e| e.map(|e| e.inlined_clone()).unwrap_or_else(T::zero),
             |a, b| a.simd_min(b.inlined_clone()),
         )
     }
@@ -138,7 +138,7 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     #[inline]
     pub fn icamax_full(&self) -> (usize, usize)
     where
-        N: ComplexField,
+        T: ComplexField,
     {
         assert!(!self.is_empty(), "The input matrix must not be empty.");
 
@@ -160,7 +160,7 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     }
 }
 
-impl<N: Scalar + PartialOrd + Signed, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
+impl<T: Scalar + PartialOrd + Signed, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
     /// Computes the index of the matrix component with the largest absolute value.
     ///
     /// # Examples:
@@ -195,7 +195,7 @@ impl<N: Scalar + PartialOrd + Signed, R: Dim, C: Dim, S: Storage<N, R, C>> Matri
 
 // TODO: find a way to avoid code duplication just for complex number support.
 /// # Find the min and max components (vector-specific methods)
-impl<N: Scalar, D: Dim, S: Storage<N, D>> Vector<N, D, S> {
+impl<T: Scalar, D: Dim, S: Storage<T, D>> Vector<T, D, S> {
     /// Computes the index of the vector component with the largest complex or real absolute value.
     ///
     /// # Examples:
@@ -211,7 +211,7 @@ impl<N: Scalar, D: Dim, S: Storage<N, D>> Vector<N, D, S> {
     #[inline]
     pub fn icamax(&self) -> usize
     where
-        N: ComplexField,
+        T: ComplexField,
     {
         assert!(!self.is_empty(), "The input vector must not be empty.");
 
@@ -240,9 +240,9 @@ impl<N: Scalar, D: Dim, S: Storage<N, D>> Vector<N, D, S> {
     /// assert_eq!(vec.argmax(), (2, 13));
     /// ```
     #[inline]
-    pub fn argmax(&self) -> (usize, N)
+    pub fn argmax(&self) -> (usize, T)
     where
-        N: PartialOrd,
+        T: PartialOrd,
     {
         assert!(!self.is_empty(), "The input vector must not be empty.");
 
@@ -273,7 +273,7 @@ impl<N: Scalar, D: Dim, S: Storage<N, D>> Vector<N, D, S> {
     #[inline]
     pub fn imax(&self) -> usize
     where
-        N: PartialOrd,
+        T: PartialOrd,
     {
         self.argmax().0
     }
@@ -290,7 +290,7 @@ impl<N: Scalar, D: Dim, S: Storage<N, D>> Vector<N, D, S> {
     #[inline]
     pub fn iamax(&self) -> usize
     where
-        N: PartialOrd + Signed,
+        T: PartialOrd + Signed,
     {
         assert!(!self.is_empty(), "The input vector must not be empty.");
 
@@ -319,9 +319,9 @@ impl<N: Scalar, D: Dim, S: Storage<N, D>> Vector<N, D, S> {
     /// assert_eq!(vec.argmin(), (1, -15));
     /// ```
     #[inline]
-    pub fn argmin(&self) -> (usize, N)
+    pub fn argmin(&self) -> (usize, T)
     where
-        N: PartialOrd,
+        T: PartialOrd,
     {
         assert!(!self.is_empty(), "The input vector must not be empty.");
 
@@ -352,7 +352,7 @@ impl<N: Scalar, D: Dim, S: Storage<N, D>> Vector<N, D, S> {
     #[inline]
     pub fn imin(&self) -> usize
     where
-        N: PartialOrd,
+        T: PartialOrd,
     {
         self.argmin().0
     }
@@ -369,7 +369,7 @@ impl<N: Scalar, D: Dim, S: Storage<N, D>> Vector<N, D, S> {
     #[inline]
     pub fn iamin(&self) -> usize
     where
-        N: PartialOrd + Signed,
+        T: PartialOrd + Signed,
     {
         assert!(!self.is_empty(), "The input vector must not be empty.");
 
diff --git a/src/base/norm.rs b/src/base/norm.rs
index 3f0508f2..251bf661 100644
--- a/src/base/norm.rs
+++ b/src/base/norm.rs
@@ -5,7 +5,7 @@ use num::Zero;
 use std::ops::Neg;
 
 use crate::allocator::Allocator;
-use crate::base::{DefaultAllocator, Dim, DimName, Matrix, MatrixMN, Normed, VectorN};
+use crate::base::{DefaultAllocator, Dim, DimName, Matrix, Normed, OMatrix, OVector};
 use crate::constraint::{SameNumberOfColumns, SameNumberOfRows, ShapeConstraint};
 use crate::storage::{Storage, StorageMut};
 use crate::{ComplexField, Scalar, SimdComplexField, Unit};
@@ -16,26 +16,26 @@ use simba::simd::{SimdOption, SimdPartialOrd, SimdValue};
 /// A trait for abstract matrix norms.
 ///
 /// This may be moved to the alga crate in the future.
-pub trait Norm<N: SimdComplexField> {
+pub trait Norm<T: SimdComplexField> {
     /// Apply this norm to the given matrix.
-    fn norm<R, C, S>(&self, m: &Matrix<N, R, C, S>) -> N::SimdRealField
+    fn norm<R, C, S>(&self, m: &Matrix<T, R, C, S>) -> T::SimdRealField
     where
         R: Dim,
         C: Dim,
-        S: Storage<N, R, C>;
+        S: Storage<T, R, C>;
     /// Use the metric induced by this norm to compute the metric distance between the two given matrices.
     fn metric_distance<R1, C1, S1, R2, C2, S2>(
         &self,
-        m1: &Matrix<N, R1, C1, S1>,
-        m2: &Matrix<N, R2, C2, S2>,
-    ) -> N::SimdRealField
+        m1: &Matrix<T, R1, C1, S1>,
+        m2: &Matrix<T, R2, C2, S2>,
+    ) -> T::SimdRealField
     where
         R1: Dim,
         C1: Dim,
-        S1: Storage<N, R1, C1>,
+        S1: Storage<T, R1, C1>,
         R2: Dim,
         C2: Dim,
-        S2: Storage<N, R2, C2>,
+        S2: Storage<T, R2, C2>,
         ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>;
 }
 
@@ -46,13 +46,13 @@ pub struct LpNorm(pub i32);
 /// L-infinite norm aka. Chebytchev norm aka. uniform norm aka. suppremum norm.
 pub struct UniformNorm;
 
-impl<N: SimdComplexField> Norm<N> for EuclideanNorm {
+impl<T: SimdComplexField> Norm<T> for EuclideanNorm {
     #[inline]
-    fn norm<R, C, S>(&self, m: &Matrix<N, R, C, S>) -> N::SimdRealField
+    fn norm<R, C, S>(&self, m: &Matrix<T, R, C, S>) -> T::SimdRealField
     where
         R: Dim,
         C: Dim,
-        S: Storage<N, R, C>,
+        S: Storage<T, R, C>,
     {
         m.norm_squared().simd_sqrt()
     }
@@ -60,19 +60,19 @@ impl<N: SimdComplexField> Norm<N> for EuclideanNorm {
     #[inline]
     fn metric_distance<R1, C1, S1, R2, C2, S2>(
         &self,
-        m1: &Matrix<N, R1, C1, S1>,
-        m2: &Matrix<N, R2, C2, S2>,
-    ) -> N::SimdRealField
+        m1: &Matrix<T, R1, C1, S1>,
+        m2: &Matrix<T, R2, C2, S2>,
+    ) -> T::SimdRealField
     where
         R1: Dim,
         C1: Dim,
-        S1: Storage<N, R1, C1>,
+        S1: Storage<T, R1, C1>,
         R2: Dim,
         C2: Dim,
-        S2: Storage<N, R2, C2>,
+        S2: Storage<T, R2, C2>,
         ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
     {
-        m1.zip_fold(m2, N::SimdRealField::zero(), |acc, a, b| {
+        m1.zip_fold(m2, T::SimdRealField::zero(), |acc, a, b| {
             let diff = a - b;
             acc + diff.simd_modulus_squared()
         })
@@ -80,15 +80,15 @@ impl<N: SimdComplexField> Norm<N> for EuclideanNorm {
     }
 }
 
-impl<N: SimdComplexField> Norm<N> for LpNorm {
+impl<T: SimdComplexField> Norm<T> for LpNorm {
     #[inline]
-    fn norm<R, C, S>(&self, m: &Matrix<N, R, C, S>) -> N::SimdRealField
+    fn norm<R, C, S>(&self, m: &Matrix<T, R, C, S>) -> T::SimdRealField
     where
         R: Dim,
         C: Dim,
-        S: Storage<N, R, C>,
+        S: Storage<T, R, C>,
     {
-        m.fold(N::SimdRealField::zero(), |a, b| {
+        m.fold(T::SimdRealField::zero(), |a, b| {
             a + b.simd_modulus().simd_powi(self.0)
         })
         .simd_powf(crate::convert(1.0 / (self.0 as f64)))
@@ -97,19 +97,19 @@ impl<N: SimdComplexField> Norm<N> for LpNorm {
     #[inline]
     fn metric_distance<R1, C1, S1, R2, C2, S2>(
         &self,
-        m1: &Matrix<N, R1, C1, S1>,
-        m2: &Matrix<N, R2, C2, S2>,
-    ) -> N::SimdRealField
+        m1: &Matrix<T, R1, C1, S1>,
+        m2: &Matrix<T, R2, C2, S2>,
+    ) -> T::SimdRealField
     where
         R1: Dim,
         C1: Dim,
-        S1: Storage<N, R1, C1>,
+        S1: Storage<T, R1, C1>,
         R2: Dim,
         C2: Dim,
-        S2: Storage<N, R2, C2>,
+        S2: Storage<T, R2, C2>,
         ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
     {
-        m1.zip_fold(m2, N::SimdRealField::zero(), |acc, a, b| {
+        m1.zip_fold(m2, T::SimdRealField::zero(), |acc, a, b| {
             let diff = a - b;
             acc + diff.simd_modulus().simd_powi(self.0)
         })
@@ -117,17 +117,17 @@ impl<N: SimdComplexField> Norm<N> for LpNorm {
     }
 }
 
-impl<N: SimdComplexField> Norm<N> for UniformNorm {
+impl<T: SimdComplexField> Norm<T> for UniformNorm {
     #[inline]
-    fn norm<R, C, S>(&self, m: &Matrix<N, R, C, S>) -> N::SimdRealField
+    fn norm<R, C, S>(&self, m: &Matrix<T, R, C, S>) -> T::SimdRealField
     where
         R: Dim,
         C: Dim,
-        S: Storage<N, R, C>,
+        S: Storage<T, R, C>,
     {
         // NOTE: we don't use `m.amax()` here because for the complex
         // numbers this will return the max norm1 instead of the modulus.
-        m.fold(N::SimdRealField::zero(), |acc, a| {
+        m.fold(T::SimdRealField::zero(), |acc, a| {
             acc.simd_max(a.simd_modulus())
         })
     }
@@ -135,19 +135,19 @@ impl<N: SimdComplexField> Norm<N> for UniformNorm {
     #[inline]
     fn metric_distance<R1, C1, S1, R2, C2, S2>(
         &self,
-        m1: &Matrix<N, R1, C1, S1>,
-        m2: &Matrix<N, R2, C2, S2>,
-    ) -> N::SimdRealField
+        m1: &Matrix<T, R1, C1, S1>,
+        m2: &Matrix<T, R2, C2, S2>,
+    ) -> T::SimdRealField
     where
         R1: Dim,
         C1: Dim,
-        S1: Storage<N, R1, C1>,
+        S1: Storage<T, R1, C1>,
         R2: Dim,
         C2: Dim,
-        S2: Storage<N, R2, C2>,
+        S2: Storage<T, R2, C2>,
         ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
     {
-        m1.zip_fold(m2, N::SimdRealField::zero(), |acc, a, b| {
+        m1.zip_fold(m2, T::SimdRealField::zero(), |acc, a, b| {
             let val = (a - b).simd_modulus();
             acc.simd_max(val)
         })
@@ -155,14 +155,14 @@ impl<N: SimdComplexField> Norm<N> for UniformNorm {
 }
 
 /// # Magnitude and norms
-impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
+impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
     /// The squared L2 norm of this vector.
     #[inline]
-    pub fn norm_squared(&self) -> N::SimdRealField
+    pub fn norm_squared(&self) -> T::SimdRealField
     where
-        N: SimdComplexField,
+        T: SimdComplexField,
     {
-        let mut res = N::SimdRealField::zero();
+        let mut res = T::SimdRealField::zero();
 
         for i in 0..self.ncols() {
             let col = self.column(i);
@@ -176,9 +176,9 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     ///
     /// Use `.apply_norm` to apply a custom norm.
     #[inline]
-    pub fn norm(&self) -> N::SimdRealField
+    pub fn norm(&self) -> T::SimdRealField
     where
-        N: SimdComplexField,
+        T: SimdComplexField,
     {
         self.norm_squared().simd_sqrt()
     }
@@ -187,12 +187,12 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     ///
     /// Use `.apply_metric_distance` to apply a custom norm.
     #[inline]
-    pub fn metric_distance<R2, C2, S2>(&self, rhs: &Matrix<N, R2, C2, S2>) -> N::SimdRealField
+    pub fn metric_distance<R2, C2, S2>(&self, rhs: &Matrix<T, R2, C2, S2>) -> T::SimdRealField
     where
-        N: SimdComplexField,
+        T: SimdComplexField,
         R2: Dim,
         C2: Dim,
-        S2: Storage<N, R2, C2>,
+        S2: Storage<T, R2, C2>,
         ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,
     {
         self.apply_metric_distance(rhs, &EuclideanNorm)
@@ -211,9 +211,9 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     /// assert_eq!(v.apply_norm(&EuclideanNorm), v.norm());
     /// ```
     #[inline]
-    pub fn apply_norm(&self, norm: &impl Norm<N>) -> N::SimdRealField
+    pub fn apply_norm(&self, norm: &impl Norm<T>) -> T::SimdRealField
     where
-        N: SimdComplexField,
+        T: SimdComplexField,
     {
         norm.norm(self)
     }
@@ -235,14 +235,14 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     #[inline]
     pub fn apply_metric_distance<R2, C2, S2>(
         &self,
-        rhs: &Matrix<N, R2, C2, S2>,
-        norm: &impl Norm<N>,
-    ) -> N::SimdRealField
+        rhs: &Matrix<T, R2, C2, S2>,
+        norm: &impl Norm<T>,
+    ) -> T::SimdRealField
     where
-        N: SimdComplexField,
+        T: SimdComplexField,
         R2: Dim,
         C2: Dim,
-        S2: Storage<N, R2, C2>,
+        S2: Storage<T, R2, C2>,
         ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,
     {
         norm.metric_distance(self, rhs)
@@ -254,9 +254,9 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     ///
     /// This function is simply implemented as a call to `norm()`
     #[inline]
-    pub fn magnitude(&self) -> N::SimdRealField
+    pub fn magnitude(&self) -> T::SimdRealField
     where
-        N: SimdComplexField,
+        T: SimdComplexField,
     {
         self.norm()
     }
@@ -267,19 +267,19 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     ///
     /// This function is simply implemented as a call to `norm_squared()`
     #[inline]
-    pub fn magnitude_squared(&self) -> N::SimdRealField
+    pub fn magnitude_squared(&self) -> T::SimdRealField
     where
-        N: SimdComplexField,
+        T: SimdComplexField,
     {
         self.norm_squared()
     }
 
     /// Sets the magnitude of this vector.
     #[inline]
-    pub fn set_magnitude(&mut self, magnitude: N::SimdRealField)
+    pub fn set_magnitude(&mut self, magnitude: T::SimdRealField)
     where
-        N: SimdComplexField,
-        S: StorageMut<N, R, C>,
+        T: SimdComplexField,
+        S: StorageMut<T, R, C>,
     {
         let n = self.norm();
         self.scale_mut(magnitude / n)
@@ -288,19 +288,19 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     /// Returns a normalized version of this matrix.
     #[inline]
     #[must_use = "Did you mean to use normalize_mut()?"]
-    pub fn normalize(&self) -> MatrixMN<N, R, C>
+    pub fn normalize(&self) -> OMatrix<T, R, C>
     where
-        N: SimdComplexField,
-        DefaultAllocator: Allocator<N, R, C>,
+        T: SimdComplexField,
+        DefaultAllocator: Allocator<T, R, C>,
     {
         self.unscale(self.norm())
     }
 
     /// The Lp norm of this matrix.
     #[inline]
-    pub fn lp_norm(&self, p: i32) -> N::SimdRealField
+    pub fn lp_norm(&self, p: i32) -> T::SimdRealField
     where
-        N: SimdComplexField,
+        T: SimdComplexField,
     {
         self.apply_norm(&LpNorm(p))
     }
@@ -310,11 +310,11 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     /// The components of this matrix can be SIMD types.
     #[inline]
     #[must_use = "Did you mean to use simd_try_normalize_mut()?"]
-    pub fn simd_try_normalize(&self, min_norm: N::SimdRealField) -> SimdOption<MatrixMN<N, R, C>>
+    pub fn simd_try_normalize(&self, min_norm: T::SimdRealField) -> SimdOption<OMatrix<T, R, C>>
     where
-        N: SimdComplexField,
-        N::Element: Scalar,
-        DefaultAllocator: Allocator<N, R, C> + Allocator<N::Element, R, C>,
+        T: SimdComplexField,
+        T::Element: Scalar,
+        DefaultAllocator: Allocator<T, R, C> + Allocator<T::Element, R, C>,
     {
         let n = self.norm();
         let le = n.simd_le(min_norm);
@@ -327,10 +327,10 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     /// If `self.magnitude()` is smaller than `min_magnitude`, it will be left unchanged.
     /// Otherwise this is equivalent to: `*self = self.normalize() * magnitude.
     #[inline]
-    pub fn try_set_magnitude(&mut self, magnitude: N::RealField, min_magnitude: N::RealField)
+    pub fn try_set_magnitude(&mut self, magnitude: T::RealField, min_magnitude: T::RealField)
     where
-        N: ComplexField,
-        S: StorageMut<N, R, C>,
+        T: ComplexField,
+        S: StorageMut<T, R, C>,
     {
         let n = self.norm();
 
@@ -341,10 +341,10 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
 
     /// Returns a new vector with the same magnitude as `self` clamped between `0.0` and `max`.
     #[inline]
-    pub fn cap_magnitude(&self, max: N::RealField) -> MatrixMN<N, R, C>
+    pub fn cap_magnitude(&self, max: T::RealField) -> OMatrix<T, R, C>
     where
-        N: ComplexField,
-        DefaultAllocator: Allocator<N, R, C>,
+        T: ComplexField,
+        DefaultAllocator: Allocator<T, R, C>,
     {
         let n = self.norm();
 
@@ -357,11 +357,11 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
 
     /// Returns a new vector with the same magnitude as `self` clamped between `0.0` and `max`.
     #[inline]
-    pub fn simd_cap_magnitude(&self, max: N::SimdRealField) -> MatrixMN<N, R, C>
+    pub fn simd_cap_magnitude(&self, max: T::SimdRealField) -> OMatrix<T, R, C>
     where
-        N: SimdComplexField,
-        N::Element: Scalar,
-        DefaultAllocator: Allocator<N, R, C> + Allocator<N::Element, R, C>,
+        T: SimdComplexField,
+        T::Element: Scalar,
+        DefaultAllocator: Allocator<T, R, C> + Allocator<T::Element, R, C>,
     {
         let n = self.norm();
         let scaled = self.scale(max / n);
@@ -374,10 +374,10 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     /// The components of this matrix cannot be SIMD types (see `simd_try_normalize`) instead.
     #[inline]
     #[must_use = "Did you mean to use try_normalize_mut()?"]
-    pub fn try_normalize(&self, min_norm: N::RealField) -> Option<MatrixMN<N, R, C>>
+    pub fn try_normalize(&self, min_norm: T::RealField) -> Option<OMatrix<T, R, C>>
     where
-        N: ComplexField,
-        DefaultAllocator: Allocator<N, R, C>,
+        T: ComplexField,
+        DefaultAllocator: Allocator<T, R, C>,
     {
         let n = self.norm();
 
@@ -390,14 +390,14 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
 }
 
 /// # In-place normalization
-impl<N: Scalar, R: Dim, C: Dim, S: StorageMut<N, R, C>> Matrix<N, R, C, S> {
+impl<T: Scalar, R: Dim, C: Dim, S: StorageMut<T, R, C>> Matrix<T, R, C, S> {
     /// Normalizes this matrix in-place and returns its norm.
     ///
     /// The components of the matrix cannot be SIMD types (see `simd_try_normalize_mut` instead).
     #[inline]
-    pub fn normalize_mut(&mut self) -> N::SimdRealField
+    pub fn normalize_mut(&mut self) -> T::SimdRealField
     where
-        N: SimdComplexField,
+        T: SimdComplexField,
     {
         let n = self.norm();
         self.unscale_mut(n);
@@ -412,12 +412,12 @@ impl<N: Scalar, R: Dim, C: Dim, S: StorageMut<N, R, C>> Matrix<N, R, C, S> {
     #[must_use = "Did you mean to use simd_try_normalize_mut()?"]
     pub fn simd_try_normalize_mut(
         &mut self,
-        min_norm: N::SimdRealField,
-    ) -> SimdOption<N::SimdRealField>
+        min_norm: T::SimdRealField,
+    ) -> SimdOption<T::SimdRealField>
     where
-        N: SimdComplexField,
-        N::Element: Scalar,
-        DefaultAllocator: Allocator<N, R, C> + Allocator<N::Element, R, C>,
+        T: SimdComplexField,
+        T::Element: Scalar,
+        DefaultAllocator: Allocator<T, R, C> + Allocator<T::Element, R, C>,
     {
         let n = self.norm();
         let le = n.simd_le(min_norm);
@@ -429,9 +429,9 @@ impl<N: Scalar, R: Dim, C: Dim, S: StorageMut<N, R, C>> Matrix<N, R, C, S> {
     ///
     /// If the normalization succeeded, returns the old norm of this matrix.
     #[inline]
-    pub fn try_normalize_mut(&mut self, min_norm: N::RealField) -> Option<N::RealField>
+    pub fn try_normalize_mut(&mut self, min_norm: T::RealField) -> Option<T::RealField>
     where
-        N: ComplexField,
+        T: ComplexField,
     {
         let n = self.norm();
 
@@ -444,19 +444,19 @@ impl<N: Scalar, R: Dim, C: Dim, S: StorageMut<N, R, C>> Matrix<N, R, C, S> {
     }
 }
 
-impl<N: SimdComplexField, R: Dim, C: Dim> Normed for MatrixMN<N, R, C>
+impl<T: SimdComplexField, R: Dim, C: Dim> Normed for OMatrix<T, R, C>
 where
-    DefaultAllocator: Allocator<N, R, C>,
+    DefaultAllocator: Allocator<T, R, C>,
 {
-    type Norm = N::SimdRealField;
+    type Norm = T::SimdRealField;
 
     #[inline]
-    fn norm(&self) -> N::SimdRealField {
+    fn norm(&self) -> T::SimdRealField {
         self.norm()
     }
 
     #[inline]
-    fn norm_squared(&self) -> N::SimdRealField {
+    fn norm_squared(&self) -> T::SimdRealField {
         self.norm_squared()
     }
 
@@ -471,11 +471,11 @@ where
     }
 }
 
-impl<N: Scalar + ClosedNeg, R: Dim, C: Dim> Neg for Unit<MatrixMN<N, R, C>>
+impl<T: Scalar + ClosedNeg, R: Dim, C: Dim> Neg for Unit<OMatrix<T, R, C>>
 where
-    DefaultAllocator: Allocator<N, R, C>,
+    DefaultAllocator: Allocator<T, R, C>,
 {
-    type Output = Unit<MatrixMN<N, R, C>>;
+    type Output = Unit<OMatrix<T, R, C>>;
 
     #[inline]
     fn neg(self) -> Self::Output {
@@ -488,9 +488,9 @@ where
 //   − use `x()` instead of `::canonical_basis_element`
 //   − use `::new(x, y, z)` instead of `::from_slice`
 /// # Basis and orthogonalization
-impl<N: ComplexField, D: DimName> VectorN<N, D>
+impl<T: ComplexField, D: DimName> OVector<T, D>
 where
-    DefaultAllocator: Allocator<N, D>,
+    DefaultAllocator: Allocator<T, D>,
 {
     /// The i-the canonical basis element.
     #[inline]
@@ -499,7 +499,7 @@ where
 
         let mut res = Self::zero();
         unsafe {
-            *res.data.get_unchecked_linear_mut(i) = N::one();
+            *res.data.get_unchecked_linear_mut(i) = T::one();
         }
 
         res
@@ -521,7 +521,7 @@ where
                 }
             }
 
-            if vs[i].try_normalize_mut(N::RealField::zero()).is_some() {
+            if vs[i].try_normalize_mut(T::RealField::zero()).is_some() {
                 // TODO: this will be efficient on dynamically-allocated vectors but for
                 // statically-allocated ones, `.clone_from` would be better.
                 vs.swap(nbasis_elements, i);
@@ -581,9 +581,9 @@ where
                     let mut a;
 
                     if v[0].norm1() > v[1].norm1() {
-                        a = Self::from_column_slice(&[v[2], N::zero(), -v[0]]);
+                        a = Self::from_column_slice(&[v[2], T::zero(), -v[0]]);
                     } else {
-                        a = Self::from_column_slice(&[N::zero(), -v[2], v[1]]);
+                        a = Self::from_column_slice(&[T::zero(), -v[2], v[1]]);
                     };
 
                     let _ = a.normalize_mut();
@@ -612,7 +612,7 @@ where
                             elt -= v * elt.dot(v)
                         }
 
-                        if let Some(subsp_elt) = elt.try_normalize(N::RealField::zero()) {
+                        if let Some(subsp_elt) = elt.try_normalize(T::RealField::zero()) {
                             if !f(&subsp_elt) {
                                 return;
                             };
diff --git a/src/base/ops.rs b/src/base/ops.rs
index 73f18a8c..8917efb1 100644
--- a/src/base/ops.rs
+++ b/src/base/ops.rs
@@ -12,7 +12,7 @@ use crate::base::constraint::{
 };
 use crate::base::dimension::{Dim, DimMul, DimName, DimProd, Dynamic};
 use crate::base::storage::{ContiguousStorageMut, Storage, StorageMut};
-use crate::base::{DefaultAllocator, Matrix, MatrixMN, MatrixN, MatrixSum, Scalar, VectorSliceN};
+use crate::base::{DefaultAllocator, Matrix, MatrixSum, OMatrix, Scalar, VectorSlice};
 use crate::SimdComplexField;
 
 /*
@@ -20,8 +20,8 @@ use crate::SimdComplexField;
  * Indexing.
  *
  */
-impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Index<usize> for Matrix<N, R, C, S> {
-    type Output = N;
+impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Index<usize> for Matrix<T, R, C, S> {
+    type Output = T;
 
     #[inline]
     fn index(&self, i: usize) -> &Self::Output {
@@ -30,12 +30,12 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Index<usize> for Matrix<N,
     }
 }
 
-impl<N, R: Dim, C: Dim, S> Index<(usize, usize)> for Matrix<N, R, C, S>
+impl<T, R: Dim, C: Dim, S> Index<(usize, usize)> for Matrix<T, R, C, S>
 where
-    N: Scalar,
-    S: Storage<N, R, C>,
+    T: Scalar,
+    S: Storage<T, R, C>,
 {
-    type Output = N;
+    type Output = T;
 
     #[inline]
     fn index(&self, ij: (usize, usize)) -> &Self::Output {
@@ -50,21 +50,21 @@ where
 }
 
 // Mutable versions.
-impl<N: Scalar, R: Dim, C: Dim, S: StorageMut<N, R, C>> IndexMut<usize> for Matrix<N, R, C, S> {
+impl<T: Scalar, R: Dim, C: Dim, S: StorageMut<T, R, C>> IndexMut<usize> for Matrix<T, R, C, S> {
     #[inline]
-    fn index_mut(&mut self, i: usize) -> &mut N {
+    fn index_mut(&mut self, i: usize) -> &mut T {
         let ij = self.vector_to_matrix_index(i);
         &mut self[ij]
     }
 }
 
-impl<N, R: Dim, C: Dim, S> IndexMut<(usize, usize)> for Matrix<N, R, C, S>
+impl<T, R: Dim, C: Dim, S> IndexMut<(usize, usize)> for Matrix<T, R, C, S>
 where
-    N: Scalar,
-    S: StorageMut<N, R, C>,
+    T: Scalar,
+    S: StorageMut<T, R, C>,
 {
     #[inline]
-    fn index_mut(&mut self, ij: (usize, usize)) -> &mut N {
+    fn index_mut(&mut self, ij: (usize, usize)) -> &mut T {
         let shape = self.shape();
         assert!(
             ij.0 < shape.0 && ij.1 < shape.1,
@@ -80,13 +80,13 @@ where
  * Neg
  *
  */
-impl<N, R: Dim, C: Dim, S> Neg for Matrix<N, R, C, S>
+impl<T, R: Dim, C: Dim, S> Neg for Matrix<T, R, C, S>
 where
-    N: Scalar + ClosedNeg,
-    S: Storage<N, R, C>,
-    DefaultAllocator: Allocator<N, R, C>,
+    T: Scalar + ClosedNeg,
+    S: Storage<T, R, C>,
+    DefaultAllocator: Allocator<T, R, C>,
 {
-    type Output = MatrixMN<N, R, C>;
+    type Output = OMatrix<T, R, C>;
 
     #[inline]
     fn neg(self) -> Self::Output {
@@ -96,13 +96,13 @@ where
     }
 }
 
-impl<'a, N, R: Dim, C: Dim, S> Neg for &'a Matrix<N, R, C, S>
+impl<'a, T, R: Dim, C: Dim, S> Neg for &'a Matrix<T, R, C, S>
 where
-    N: Scalar + ClosedNeg,
-    S: Storage<N, R, C>,
-    DefaultAllocator: Allocator<N, R, C>,
+    T: Scalar + ClosedNeg,
+    S: Storage<T, R, C>,
+    DefaultAllocator: Allocator<T, R, C>,
 {
-    type Output = MatrixMN<N, R, C>;
+    type Output = OMatrix<T, R, C>;
 
     #[inline]
     fn neg(self) -> Self::Output {
@@ -110,10 +110,10 @@ where
     }
 }
 
-impl<N, R: Dim, C: Dim, S> Matrix<N, R, C, S>
+impl<T, R: Dim, C: Dim, S> Matrix<T, R, C, S>
 where
-    N: Scalar + ClosedNeg,
-    S: StorageMut<N, R, C>,
+    T: Scalar + ClosedNeg,
+    S: StorageMut<T, R, C>,
 {
     /// Negates `self` in-place.
     #[inline]
@@ -136,8 +136,8 @@ macro_rules! componentwise_binop_impl(
      $method_assign_statically_unchecked_rhs: ident;
      $method_to: ident, $method_to_statically_unchecked: ident) => {
 
-        impl<N, R1: Dim, C1: Dim, SA: Storage<N, R1, C1>> Matrix<N, R1, C1, SA>
-            where N: Scalar + $bound {
+        impl<T, R1: Dim, C1: Dim, SA: Storage<T, R1, C1>> Matrix<T, R1, C1, SA>
+            where T: Scalar + $bound {
 
             /*
              *
@@ -149,10 +149,10 @@ macro_rules! componentwise_binop_impl(
             #[inline]
             fn $method_to_statically_unchecked<R2: Dim, C2: Dim, SB,
                                                R3: Dim, C3: Dim, SC>(&self,
-                                                                     rhs: &Matrix<N, R2, C2, SB>,
-                                                                     out: &mut Matrix<N, R3, C3, SC>)
-                where SB: Storage<N, R2, C2>,
-                      SC: StorageMut<N, R3, C3> {
+                                                                     rhs: &Matrix<T, R2, C2, SB>,
+                                                                     out: &mut Matrix<T, R3, C3, SC>)
+                where SB: Storage<T, R2, C2>,
+                      SC: StorageMut<T, R3, C3> {
                 assert_eq!(self.shape(), rhs.shape(), "Matrix addition/subtraction dimensions mismatch.");
                 assert_eq!(self.shape(), out.shape(), "Matrix addition/subtraction output dimensions mismatch.");
 
@@ -182,11 +182,11 @@ macro_rules! componentwise_binop_impl(
 
 
             #[inline]
-            fn $method_assign_statically_unchecked<R2, C2, SB>(&mut self, rhs: &Matrix<N, R2, C2, SB>)
+            fn $method_assign_statically_unchecked<R2, C2, SB>(&mut self, rhs: &Matrix<T, R2, C2, SB>)
                 where R2: Dim,
                       C2: Dim,
-                      SA: StorageMut<N, R1, C1>,
-                      SB: Storage<N, R2, C2> {
+                      SA: StorageMut<T, R1, C1>,
+                      SB: Storage<T, R2, C2> {
                 assert_eq!(self.shape(), rhs.shape(), "Matrix addition/subtraction dimensions mismatch.");
 
                 // This is the most common case and should be deduced at compile-time.
@@ -213,10 +213,10 @@ macro_rules! componentwise_binop_impl(
 
 
             #[inline]
-            fn $method_assign_statically_unchecked_rhs<R2, C2, SB>(&self, rhs: &mut Matrix<N, R2, C2, SB>)
+            fn $method_assign_statically_unchecked_rhs<R2, C2, SB>(&self, rhs: &mut Matrix<T, R2, C2, SB>)
                 where R2: Dim,
                       C2: Dim,
-                      SB: StorageMut<N, R2, C2> {
+                      SB: StorageMut<T, R2, C2> {
                 assert_eq!(self.shape(), rhs.shape(), "Matrix addition/subtraction dimensions mismatch.");
 
                 // This is the most common case and should be deduced at compile-time.
@@ -255,27 +255,27 @@ macro_rules! componentwise_binop_impl(
             #[inline]
             pub fn $method_to<R2: Dim, C2: Dim, SB,
                               R3: Dim, C3: Dim, SC>(&self,
-                                                    rhs: &Matrix<N, R2, C2, SB>,
-                                                    out: &mut Matrix<N, R3, C3, SC>)
-                where SB: Storage<N, R2, C2>,
-                      SC: StorageMut<N, R3, C3>,
+                                                    rhs: &Matrix<T, R2, C2, SB>,
+                                                    out: &mut Matrix<T, R3, C3, SC>)
+                where SB: Storage<T, R2, C2>,
+                      SC: StorageMut<T, R3, C3>,
                       ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2> +
                                        SameNumberOfRows<R1, R3> + SameNumberOfColumns<C1, C3> {
                 self.$method_to_statically_unchecked(rhs, out)
             }
         }
 
-        impl<'b, N, R1, C1, R2, C2, SA, SB> $Trait<&'b Matrix<N, R2, C2, SB>> for Matrix<N, R1, C1, SA>
+        impl<'b, T, R1, C1, R2, C2, SA, SB> $Trait<&'b Matrix<T, R2, C2, SB>> for Matrix<T, R1, C1, SA>
             where R1: Dim, C1: Dim, R2: Dim, C2: Dim,
-                  N: Scalar + $bound,
-                  SA: Storage<N, R1, C1>,
-                  SB: Storage<N, R2, C2>,
-                  DefaultAllocator: SameShapeAllocator<N, R1, C1, R2, C2>,
+                  T: Scalar + $bound,
+                  SA: Storage<T, R1, C1>,
+                  SB: Storage<T, R2, C2>,
+                  DefaultAllocator: SameShapeAllocator<T, R1, C1, R2, C2>,
                   ShapeConstraint:  SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2> {
-            type Output = MatrixSum<N, R1, C1, R2, C2>;
+            type Output = MatrixSum<T, R1, C1, R2, C2>;
 
             #[inline]
-            fn $method(self, rhs: &'b Matrix<N, R2, C2, SB>) -> Self::Output {
+            fn $method(self, rhs: &'b Matrix<T, R2, C2, SB>) -> Self::Output {
                 assert_eq!(self.shape(), rhs.shape(), "Matrix addition/subtraction dimensions mismatch.");
                 let mut res = self.into_owned_sum::<R2, C2>();
                 res.$method_assign_statically_unchecked(rhs);
@@ -283,17 +283,17 @@ macro_rules! componentwise_binop_impl(
             }
         }
 
-        impl<'a, N, R1, C1, R2, C2, SA, SB> $Trait<Matrix<N, R2, C2, SB>> for &'a Matrix<N, R1, C1, SA>
+        impl<'a, T, R1, C1, R2, C2, SA, SB> $Trait<Matrix<T, R2, C2, SB>> for &'a Matrix<T, R1, C1, SA>
             where R1: Dim, C1: Dim, R2: Dim, C2: Dim,
-                  N: Scalar + $bound,
-                  SA: Storage<N, R1, C1>,
-                  SB: Storage<N, R2, C2>,
-                  DefaultAllocator: SameShapeAllocator<N, R2, C2, R1, C1>,
+                  T: Scalar + $bound,
+                  SA: Storage<T, R1, C1>,
+                  SB: Storage<T, R2, C2>,
+                  DefaultAllocator: SameShapeAllocator<T, R2, C2, R1, C1>,
                   ShapeConstraint:  SameNumberOfRows<R2, R1> + SameNumberOfColumns<C2, C1> {
-            type Output = MatrixSum<N, R2, C2, R1, C1>;
+            type Output = MatrixSum<T, R2, C2, R1, C1>;
 
             #[inline]
-            fn $method(self, rhs: Matrix<N, R2, C2, SB>) -> Self::Output {
+            fn $method(self, rhs: Matrix<T, R2, C2, SB>) -> Self::Output {
                 let mut rhs = rhs.into_owned_sum::<R1, C1>();
                 assert_eq!(self.shape(), rhs.shape(), "Matrix addition/subtraction dimensions mismatch.");
                 self.$method_assign_statically_unchecked_rhs(&mut rhs);
@@ -301,32 +301,32 @@ macro_rules! componentwise_binop_impl(
             }
         }
 
-        impl<N, R1, C1, R2, C2, SA, SB> $Trait<Matrix<N, R2, C2, SB>> for Matrix<N, R1, C1, SA>
+        impl<T, R1, C1, R2, C2, SA, SB> $Trait<Matrix<T, R2, C2, SB>> for Matrix<T, R1, C1, SA>
             where R1: Dim, C1: Dim, R2: Dim, C2: Dim,
-                  N: Scalar + $bound,
-                  SA: Storage<N, R1, C1>,
-                  SB: Storage<N, R2, C2>,
-                  DefaultAllocator: SameShapeAllocator<N, R1, C1, R2, C2>,
+                  T: Scalar + $bound,
+                  SA: Storage<T, R1, C1>,
+                  SB: Storage<T, R2, C2>,
+                  DefaultAllocator: SameShapeAllocator<T, R1, C1, R2, C2>,
                   ShapeConstraint:  SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2> {
-            type Output = MatrixSum<N, R1, C1, R2, C2>;
+            type Output = MatrixSum<T, R1, C1, R2, C2>;
 
             #[inline]
-            fn $method(self, rhs: Matrix<N, R2, C2, SB>) -> Self::Output {
+            fn $method(self, rhs: Matrix<T, R2, C2, SB>) -> Self::Output {
                 self.$method(&rhs)
             }
         }
 
-        impl<'a, 'b, N, R1, C1, R2, C2, SA, SB> $Trait<&'b Matrix<N, R2, C2, SB>> for &'a Matrix<N, R1, C1, SA>
+        impl<'a, 'b, T, R1, C1, R2, C2, SA, SB> $Trait<&'b Matrix<T, R2, C2, SB>> for &'a Matrix<T, R1, C1, SA>
             where R1: Dim, C1: Dim, R2: Dim, C2: Dim,
-                  N: Scalar + $bound,
-                  SA: Storage<N, R1, C1>,
-                  SB: Storage<N, R2, C2>,
-                  DefaultAllocator: SameShapeAllocator<N, R1, C1, R2, C2>,
+                  T: Scalar + $bound,
+                  SA: Storage<T, R1, C1>,
+                  SB: Storage<T, R2, C2>,
+                  DefaultAllocator: SameShapeAllocator<T, R1, C1, R2, C2>,
                   ShapeConstraint:  SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2> {
-            type Output = MatrixSum<N, R1, C1, R2, C2>;
+            type Output = MatrixSum<T, R1, C1, R2, C2>;
 
             #[inline]
-            fn $method(self, rhs: &'b Matrix<N, R2, C2, SB>) -> Self::Output {
+            fn $method(self, rhs: &'b Matrix<T, R2, C2, SB>) -> Self::Output {
                 let mut res = unsafe {
                     let (nrows, ncols) = self.shape();
                     let nrows: SameShapeR<R1, R2> = Dim::from_usize(nrows);
@@ -339,28 +339,28 @@ macro_rules! componentwise_binop_impl(
             }
         }
 
-        impl<'b, N, R1, C1, R2, C2, SA, SB> $TraitAssign<&'b Matrix<N, R2, C2, SB>> for Matrix<N, R1, C1, SA>
+        impl<'b, T, R1, C1, R2, C2, SA, SB> $TraitAssign<&'b Matrix<T, R2, C2, SB>> for Matrix<T, R1, C1, SA>
             where R1: Dim, C1: Dim, R2: Dim, C2: Dim,
-                  N: Scalar + $bound,
-                  SA: StorageMut<N, R1, C1>,
-                  SB: Storage<N, R2, C2>,
+                  T: Scalar + $bound,
+                  SA: StorageMut<T, R1, C1>,
+                  SB: Storage<T, R2, C2>,
                   ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2> {
 
             #[inline]
-            fn $method_assign(&mut self, rhs: &'b Matrix<N, R2, C2, SB>) {
+            fn $method_assign(&mut self, rhs: &'b Matrix<T, R2, C2, SB>) {
                 self.$method_assign_statically_unchecked(rhs)
             }
         }
 
-        impl<N, R1, C1, R2, C2, SA, SB> $TraitAssign<Matrix<N, R2, C2, SB>> for Matrix<N, R1, C1, SA>
+        impl<T, R1, C1, R2, C2, SA, SB> $TraitAssign<Matrix<T, R2, C2, SB>> for Matrix<T, R1, C1, SA>
             where R1: Dim, C1: Dim, R2: Dim, C2: Dim,
-                  N: Scalar + $bound,
-                  SA: StorageMut<N, R1, C1>,
-                  SB: Storage<N, R2, C2>,
+                  T: Scalar + $bound,
+                  SA: StorageMut<T, R1, C1>,
+                  SB: Storage<T, R2, C2>,
                   ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2> {
 
             #[inline]
-            fn $method_assign(&mut self, rhs: Matrix<N, R2, C2, SB>) {
+            fn $method_assign(&mut self, rhs: Matrix<T, R2, C2, SB>) {
                 self.$method_assign(&rhs)
             }
         }
@@ -374,20 +374,20 @@ componentwise_binop_impl!(Sub, sub, ClosedSub;
                           SubAssign, sub_assign, sub_assign_statically_unchecked, sub_assign_statically_unchecked_mut;
                           sub_to, sub_to_statically_unchecked);
 
-impl<N, R: DimName, C: DimName> iter::Sum for MatrixMN<N, R, C>
+impl<T, R: DimName, C: DimName> iter::Sum for OMatrix<T, R, C>
 where
-    N: Scalar + ClosedAdd + Zero,
-    DefaultAllocator: Allocator<N, R, C>,
+    T: Scalar + ClosedAdd + Zero,
+    DefaultAllocator: Allocator<T, R, C>,
 {
-    fn sum<I: Iterator<Item = MatrixMN<N, R, C>>>(iter: I) -> MatrixMN<N, R, C> {
+    fn sum<I: Iterator<Item = OMatrix<T, R, C>>>(iter: I) -> OMatrix<T, R, C> {
         iter.fold(Matrix::zero(), |acc, x| acc + x)
     }
 }
 
-impl<N, C: Dim> iter::Sum for MatrixMN<N, Dynamic, C>
+impl<T, C: Dim> iter::Sum for OMatrix<T, Dynamic, C>
 where
-    N: Scalar + ClosedAdd + Zero,
-    DefaultAllocator: Allocator<N, Dynamic, C>,
+    T: Scalar + ClosedAdd + Zero,
+    DefaultAllocator: Allocator<T, Dynamic, C>,
 {
     /// # Example
     /// ```
@@ -405,7 +405,7 @@ where
     /// # use nalgebra::DMatrix;
     /// iter::empty::<DMatrix<f64>>().sum::<DMatrix<f64>>(); // panics!
     /// ```
-    fn sum<I: Iterator<Item = MatrixMN<N, Dynamic, C>>>(mut iter: I) -> MatrixMN<N, Dynamic, C> {
+    fn sum<I: Iterator<Item = OMatrix<T, Dynamic, C>>>(mut iter: I) -> OMatrix<T, Dynamic, C> {
         if let Some(first) = iter.next() {
             iter.fold(first, |acc, x| acc + x)
         } else {
@@ -414,20 +414,20 @@ where
     }
 }
 
-impl<'a, N, R: DimName, C: DimName> iter::Sum<&'a MatrixMN<N, R, C>> for MatrixMN<N, R, C>
+impl<'a, T, R: DimName, C: DimName> iter::Sum<&'a OMatrix<T, R, C>> for OMatrix<T, R, C>
 where
-    N: Scalar + ClosedAdd + Zero,
-    DefaultAllocator: Allocator<N, R, C>,
+    T: Scalar + ClosedAdd + Zero,
+    DefaultAllocator: Allocator<T, R, C>,
 {
-    fn sum<I: Iterator<Item = &'a MatrixMN<N, R, C>>>(iter: I) -> MatrixMN<N, R, C> {
+    fn sum<I: Iterator<Item = &'a OMatrix<T, R, C>>>(iter: I) -> OMatrix<T, R, C> {
         iter.fold(Matrix::zero(), |acc, x| acc + x)
     }
 }
 
-impl<'a, N, C: Dim> iter::Sum<&'a MatrixMN<N, Dynamic, C>> for MatrixMN<N, Dynamic, C>
+impl<'a, T, C: Dim> iter::Sum<&'a OMatrix<T, Dynamic, C>> for OMatrix<T, Dynamic, C>
 where
-    N: Scalar + ClosedAdd + Zero,
-    DefaultAllocator: Allocator<N, Dynamic, C>,
+    T: Scalar + ClosedAdd + Zero,
+    DefaultAllocator: Allocator<T, Dynamic, C>,
 {
     /// # Example
     /// ```
@@ -445,9 +445,7 @@ where
     /// # use nalgebra::DMatrix;
     /// iter::empty::<&DMatrix<f64>>().sum::<DMatrix<f64>>(); // panics!
     /// ```
-    fn sum<I: Iterator<Item = &'a MatrixMN<N, Dynamic, C>>>(
-        mut iter: I,
-    ) -> MatrixMN<N, Dynamic, C> {
+    fn sum<I: Iterator<Item = &'a OMatrix<T, Dynamic, C>>>(mut iter: I) -> OMatrix<T, Dynamic, C> {
         if let Some(first) = iter.next() {
             iter.fold(first.clone(), |acc, x| acc + x)
         } else {
@@ -467,14 +465,14 @@ where
 macro_rules! componentwise_scalarop_impl(
     ($Trait: ident, $method: ident, $bound: ident;
      $TraitAssign: ident, $method_assign: ident) => {
-        impl<N, R: Dim, C: Dim, S> $Trait<N> for Matrix<N, R, C, S>
-            where N: Scalar + $bound,
-                  S: Storage<N, R, C>,
-                  DefaultAllocator: Allocator<N, R, C> {
-            type Output = MatrixMN<N, R, C>;
+        impl<T, R: Dim, C: Dim, S> $Trait<T> for Matrix<T, R, C, S>
+            where T: Scalar + $bound,
+                  S: Storage<T, R, C>,
+                  DefaultAllocator: Allocator<T, R, C> {
+            type Output = OMatrix<T, R, C>;
 
             #[inline]
-            fn $method(self, rhs: N) -> Self::Output {
+            fn $method(self, rhs: T) -> Self::Output {
                 let mut res = self.into_owned();
 
                 // XXX: optimize our iterator!
@@ -491,23 +489,23 @@ macro_rules! componentwise_scalarop_impl(
             }
         }
 
-        impl<'a, N, R: Dim, C: Dim, S> $Trait<N> for &'a Matrix<N, R, C, S>
-            where N: Scalar + $bound,
-                  S: Storage<N, R, C>,
-                  DefaultAllocator: Allocator<N, R, C> {
-            type Output = MatrixMN<N, R, C>;
+        impl<'a, T, R: Dim, C: Dim, S> $Trait<T> for &'a Matrix<T, R, C, S>
+            where T: Scalar + $bound,
+                  S: Storage<T, R, C>,
+                  DefaultAllocator: Allocator<T, R, C> {
+            type Output = OMatrix<T, R, C>;
 
             #[inline]
-            fn $method(self, rhs: N) -> Self::Output {
+            fn $method(self, rhs: T) -> Self::Output {
                 self.clone_owned().$method(rhs)
             }
         }
 
-        impl<N, R: Dim, C: Dim, S> $TraitAssign<N> for Matrix<N, R, C, S>
-            where N: Scalar + $bound,
-                  S: StorageMut<N, R, C> {
+        impl<T, R: Dim, C: Dim, S> $TraitAssign<T> for Matrix<T, R, C, S>
+            where T: Scalar + $bound,
+                  S: StorageMut<T, R, C> {
             #[inline]
-            fn $method_assign(&mut self, rhs: N) {
+            fn $method_assign(&mut self, rhs: T) {
                 for j in 0 .. self.ncols() {
                     for i in 0 .. self.nrows() {
                         unsafe { self.get_unchecked_mut((i, j)).$method_assign(rhs.inlined_clone()) };
@@ -525,7 +523,7 @@ macro_rules! left_scalar_mul_impl(
     ($($T: ty),* $(,)*) => {$(
         impl<R: Dim, C: Dim, S: Storage<$T, R, C>> Mul<Matrix<$T, R, C, S>> for $T
             where DefaultAllocator: Allocator<$T, R, C> {
-            type Output = MatrixMN<$T, R, C>;
+            type Output = OMatrix<$T, R, C>;
 
             #[inline]
             fn mul(self, rhs: Matrix<$T, R, C, S>) -> Self::Output {
@@ -547,7 +545,7 @@ macro_rules! left_scalar_mul_impl(
 
         impl<'b, R: Dim, C: Dim, S: Storage<$T, R, C>> Mul<&'b Matrix<$T, R, C, S>> for $T
             where DefaultAllocator: Allocator<$T, R, C> {
-            type Output = MatrixMN<$T, R, C>;
+            type Output = OMatrix<$T, R, C>;
 
             #[inline]
             fn mul(self, rhs: &'b Matrix<$T, R, C, S>) -> Self::Output {
@@ -560,19 +558,19 @@ macro_rules! left_scalar_mul_impl(
 left_scalar_mul_impl!(u8, u16, u32, u64, usize, i8, i16, i32, i64, isize, f32, f64);
 
 // Matrix × Matrix
-impl<'a, 'b, N, R1: Dim, C1: Dim, R2: Dim, C2: Dim, SA, SB> Mul<&'b Matrix<N, R2, C2, SB>>
-    for &'a Matrix<N, R1, C1, SA>
+impl<'a, 'b, T, R1: Dim, C1: Dim, R2: Dim, C2: Dim, SA, SB> Mul<&'b Matrix<T, R2, C2, SB>>
+    for &'a Matrix<T, R1, C1, SA>
 where
-    N: Scalar + Zero + One + ClosedAdd + ClosedMul,
-    SA: Storage<N, R1, C1>,
-    SB: Storage<N, R2, C2>,
-    DefaultAllocator: Allocator<N, R1, C2>,
+    T: Scalar + Zero + One + ClosedAdd + ClosedMul,
+    SA: Storage<T, R1, C1>,
+    SB: Storage<T, R2, C2>,
+    DefaultAllocator: Allocator<T, R1, C2>,
     ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,
 {
-    type Output = MatrixMN<N, R1, C2>;
+    type Output = OMatrix<T, R1, C2>;
 
     #[inline]
-    fn mul(self, rhs: &'b Matrix<N, R2, C2, SB>) -> Self::Output {
+    fn mul(self, rhs: &'b Matrix<T, R2, C2, SB>) -> Self::Output {
         let mut res = unsafe {
             crate::unimplemented_or_uninitialized_generic!(self.data.shape().0, rhs.data.shape().1)
         };
@@ -581,53 +579,53 @@ where
     }
 }
 
-impl<'a, N, R1: Dim, C1: Dim, R2: Dim, C2: Dim, SA, SB> Mul<Matrix<N, R2, C2, SB>>
-    for &'a Matrix<N, R1, C1, SA>
+impl<'a, T, R1: Dim, C1: Dim, R2: Dim, C2: Dim, SA, SB> Mul<Matrix<T, R2, C2, SB>>
+    for &'a Matrix<T, R1, C1, SA>
 where
-    N: Scalar + Zero + One + ClosedAdd + ClosedMul,
-    SB: Storage<N, R2, C2>,
-    SA: Storage<N, R1, C1>,
-    DefaultAllocator: Allocator<N, R1, C2>,
+    T: Scalar + Zero + One + ClosedAdd + ClosedMul,
+    SB: Storage<T, R2, C2>,
+    SA: Storage<T, R1, C1>,
+    DefaultAllocator: Allocator<T, R1, C2>,
     ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,
 {
-    type Output = MatrixMN<N, R1, C2>;
+    type Output = OMatrix<T, R1, C2>;
 
     #[inline]
-    fn mul(self, rhs: Matrix<N, R2, C2, SB>) -> Self::Output {
+    fn mul(self, rhs: Matrix<T, R2, C2, SB>) -> Self::Output {
         self * &rhs
     }
 }
 
-impl<'b, N, R1: Dim, C1: Dim, R2: Dim, C2: Dim, SA, SB> Mul<&'b Matrix<N, R2, C2, SB>>
-    for Matrix<N, R1, C1, SA>
+impl<'b, T, R1: Dim, C1: Dim, R2: Dim, C2: Dim, SA, SB> Mul<&'b Matrix<T, R2, C2, SB>>
+    for Matrix<T, R1, C1, SA>
 where
-    N: Scalar + Zero + One + ClosedAdd + ClosedMul,
-    SB: Storage<N, R2, C2>,
-    SA: Storage<N, R1, C1>,
-    DefaultAllocator: Allocator<N, R1, C2>,
+    T: Scalar + Zero + One + ClosedAdd + ClosedMul,
+    SB: Storage<T, R2, C2>,
+    SA: Storage<T, R1, C1>,
+    DefaultAllocator: Allocator<T, R1, C2>,
     ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,
 {
-    type Output = MatrixMN<N, R1, C2>;
+    type Output = OMatrix<T, R1, C2>;
 
     #[inline]
-    fn mul(self, rhs: &'b Matrix<N, R2, C2, SB>) -> Self::Output {
+    fn mul(self, rhs: &'b Matrix<T, R2, C2, SB>) -> Self::Output {
         &self * rhs
     }
 }
 
-impl<N, R1: Dim, C1: Dim, R2: Dim, C2: Dim, SA, SB> Mul<Matrix<N, R2, C2, SB>>
-    for Matrix<N, R1, C1, SA>
+impl<T, R1: Dim, C1: Dim, R2: Dim, C2: Dim, SA, SB> Mul<Matrix<T, R2, C2, SB>>
+    for Matrix<T, R1, C1, SA>
 where
-    N: Scalar + Zero + One + ClosedAdd + ClosedMul,
-    SB: Storage<N, R2, C2>,
-    SA: Storage<N, R1, C1>,
-    DefaultAllocator: Allocator<N, R1, C2>,
+    T: Scalar + Zero + One + ClosedAdd + ClosedMul,
+    SB: Storage<T, R2, C2>,
+    SA: Storage<T, R1, C1>,
+    DefaultAllocator: Allocator<T, R1, C2>,
     ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,
 {
-    type Output = MatrixMN<N, R1, C2>;
+    type Output = OMatrix<T, R1, C2>;
 
     #[inline]
-    fn mul(self, rhs: Matrix<N, R2, C2, SB>) -> Self::Output {
+    fn mul(self, rhs: Matrix<T, R2, C2, SB>) -> Self::Output {
         &self * &rhs
     }
 }
@@ -635,53 +633,53 @@ where
 // TODO: this is too restrictive:
 //    − we can't use `a *= b` when `a` is a mutable slice.
 //    − we can't use `a *= b` when C2 is not equal to C1.
-impl<N, R1, C1, R2, SA, SB> MulAssign<Matrix<N, R2, C1, SB>> for Matrix<N, R1, C1, SA>
+impl<T, R1, C1, R2, SA, SB> MulAssign<Matrix<T, R2, C1, SB>> for Matrix<T, R1, C1, SA>
 where
     R1: Dim,
     C1: Dim,
     R2: Dim,
-    N: Scalar + Zero + One + ClosedAdd + ClosedMul,
-    SB: Storage<N, R2, C1>,
-    SA: ContiguousStorageMut<N, R1, C1> + Clone,
+    T: Scalar + Zero + One + ClosedAdd + ClosedMul,
+    SB: Storage<T, R2, C1>,
+    SA: ContiguousStorageMut<T, R1, C1> + Clone,
     ShapeConstraint: AreMultipliable<R1, C1, R2, C1>,
-    DefaultAllocator: Allocator<N, R1, C1, Buffer = SA>,
+    DefaultAllocator: Allocator<T, R1, C1, Buffer = SA>,
 {
     #[inline]
-    fn mul_assign(&mut self, rhs: Matrix<N, R2, C1, SB>) {
+    fn mul_assign(&mut self, rhs: Matrix<T, R2, C1, SB>) {
         *self = &*self * rhs
     }
 }
 
-impl<'b, N, R1, C1, R2, SA, SB> MulAssign<&'b Matrix<N, R2, C1, SB>> for Matrix<N, R1, C1, SA>
+impl<'b, T, R1, C1, R2, SA, SB> MulAssign<&'b Matrix<T, R2, C1, SB>> for Matrix<T, R1, C1, SA>
 where
     R1: Dim,
     C1: Dim,
     R2: Dim,
-    N: Scalar + Zero + One + ClosedAdd + ClosedMul,
-    SB: Storage<N, R2, C1>,
-    SA: ContiguousStorageMut<N, R1, C1> + Clone,
+    T: Scalar + Zero + One + ClosedAdd + ClosedMul,
+    SB: Storage<T, R2, C1>,
+    SA: ContiguousStorageMut<T, R1, C1> + Clone,
     ShapeConstraint: AreMultipliable<R1, C1, R2, C1>,
     // TODO: this is too restrictive. See comments for the non-ref version.
-    DefaultAllocator: Allocator<N, R1, C1, Buffer = SA>,
+    DefaultAllocator: Allocator<T, R1, C1, Buffer = SA>,
 {
     #[inline]
-    fn mul_assign(&mut self, rhs: &'b Matrix<N, R2, C1, SB>) {
+    fn mul_assign(&mut self, rhs: &'b Matrix<T, R2, C1, SB>) {
         *self = &*self * rhs
     }
 }
 
 /// # Special multiplications.
-impl<N, R1: Dim, C1: Dim, SA> Matrix<N, R1, C1, SA>
+impl<T, R1: Dim, C1: Dim, SA> Matrix<T, R1, C1, SA>
 where
-    N: Scalar + Zero + One + ClosedAdd + ClosedMul,
-    SA: Storage<N, R1, C1>,
+    T: Scalar + Zero + One + ClosedAdd + ClosedMul,
+    SA: Storage<T, R1, C1>,
 {
     /// Equivalent to `self.transpose() * rhs`.
     #[inline]
-    pub fn tr_mul<R2: Dim, C2: Dim, SB>(&self, rhs: &Matrix<N, R2, C2, SB>) -> MatrixMN<N, C1, C2>
+    pub fn tr_mul<R2: Dim, C2: Dim, SB>(&self, rhs: &Matrix<T, R2, C2, SB>) -> OMatrix<T, C1, C2>
     where
-        SB: Storage<N, R2, C2>,
-        DefaultAllocator: Allocator<N, C1, C2>,
+        SB: Storage<T, R2, C2>,
+        DefaultAllocator: Allocator<T, C1, C2>,
         ShapeConstraint: SameNumberOfRows<R1, R2>,
     {
         let mut res = unsafe {
@@ -694,11 +692,11 @@ where
 
     /// Equivalent to `self.adjoint() * rhs`.
     #[inline]
-    pub fn ad_mul<R2: Dim, C2: Dim, SB>(&self, rhs: &Matrix<N, R2, C2, SB>) -> MatrixMN<N, C1, C2>
+    pub fn ad_mul<R2: Dim, C2: Dim, SB>(&self, rhs: &Matrix<T, R2, C2, SB>) -> OMatrix<T, C1, C2>
     where
-        N: SimdComplexField,
-        SB: Storage<N, R2, C2>,
-        DefaultAllocator: Allocator<N, C1, C2>,
+        T: SimdComplexField,
+        SB: Storage<T, R2, C2>,
+        DefaultAllocator: Allocator<T, C1, C2>,
         ShapeConstraint: SameNumberOfRows<R1, R2>,
     {
         let mut res = unsafe {
@@ -712,15 +710,15 @@ where
     #[inline(always)]
     fn xx_mul_to<R2: Dim, C2: Dim, SB, R3: Dim, C3: Dim, SC>(
         &self,
-        rhs: &Matrix<N, R2, C2, SB>,
-        out: &mut Matrix<N, R3, C3, SC>,
+        rhs: &Matrix<T, R2, C2, SB>,
+        out: &mut Matrix<T, R3, C3, SC>,
         dot: impl Fn(
-            &VectorSliceN<N, R1, SA::RStride, SA::CStride>,
-            &VectorSliceN<N, R2, SB::RStride, SB::CStride>,
-        ) -> N,
+            &VectorSlice<T, R1, SA::RStride, SA::CStride>,
+            &VectorSlice<T, R2, SB::RStride, SB::CStride>,
+        ) -> T,
     ) where
-        SB: Storage<N, R2, C2>,
-        SC: StorageMut<N, R3, C3>,
+        SB: Storage<T, R2, C2>,
+        SC: StorageMut<T, R3, C3>,
         ShapeConstraint: SameNumberOfRows<R1, R2> + DimEq<C1, R3> + DimEq<C2, C3>,
     {
         let (nrows1, ncols1) = self.shape();
@@ -759,11 +757,11 @@ where
     #[inline]
     pub fn tr_mul_to<R2: Dim, C2: Dim, SB, R3: Dim, C3: Dim, SC>(
         &self,
-        rhs: &Matrix<N, R2, C2, SB>,
-        out: &mut Matrix<N, R3, C3, SC>,
+        rhs: &Matrix<T, R2, C2, SB>,
+        out: &mut Matrix<T, R3, C3, SC>,
     ) where
-        SB: Storage<N, R2, C2>,
-        SC: StorageMut<N, R3, C3>,
+        SB: Storage<T, R2, C2>,
+        SC: StorageMut<T, R3, C3>,
         ShapeConstraint: SameNumberOfRows<R1, R2> + DimEq<C1, R3> + DimEq<C2, C3>,
     {
         self.xx_mul_to(rhs, out, |a, b| a.dot(b))
@@ -774,12 +772,12 @@ where
     #[inline]
     pub fn ad_mul_to<R2: Dim, C2: Dim, SB, R3: Dim, C3: Dim, SC>(
         &self,
-        rhs: &Matrix<N, R2, C2, SB>,
-        out: &mut Matrix<N, R3, C3, SC>,
+        rhs: &Matrix<T, R2, C2, SB>,
+        out: &mut Matrix<T, R3, C3, SC>,
     ) where
-        N: SimdComplexField,
-        SB: Storage<N, R2, C2>,
-        SC: StorageMut<N, R3, C3>,
+        T: SimdComplexField,
+        SB: Storage<T, R2, C2>,
+        SC: StorageMut<T, R3, C3>,
         ShapeConstraint: SameNumberOfRows<R1, R2> + DimEq<C1, R3> + DimEq<C2, C3>,
     {
         self.xx_mul_to(rhs, out, |a, b| a.dotc(b))
@@ -789,30 +787,30 @@ where
     #[inline]
     pub fn mul_to<R2: Dim, C2: Dim, SB, R3: Dim, C3: Dim, SC>(
         &self,
-        rhs: &Matrix<N, R2, C2, SB>,
-        out: &mut Matrix<N, R3, C3, SC>,
+        rhs: &Matrix<T, R2, C2, SB>,
+        out: &mut Matrix<T, R3, C3, SC>,
     ) where
-        SB: Storage<N, R2, C2>,
-        SC: StorageMut<N, R3, C3>,
+        SB: Storage<T, R2, C2>,
+        SC: StorageMut<T, R3, C3>,
         ShapeConstraint: SameNumberOfRows<R3, R1>
             + SameNumberOfColumns<C3, C2>
             + AreMultipliable<R1, C1, R2, C2>,
     {
-        out.gemm(N::one(), self, rhs, N::zero());
+        out.gemm(T::one(), self, rhs, T::zero());
     }
 
     /// The kronecker product of two matrices (aka. tensor product of the corresponding linear
     /// maps).
     pub fn kronecker<R2: Dim, C2: Dim, SB>(
         &self,
-        rhs: &Matrix<N, R2, C2, SB>,
-    ) -> MatrixMN<N, DimProd<R1, R2>, DimProd<C1, C2>>
+        rhs: &Matrix<T, R2, C2, SB>,
+    ) -> OMatrix<T, DimProd<R1, R2>, DimProd<C1, C2>>
     where
-        N: ClosedMul,
+        T: ClosedMul,
         R1: DimMul<R2>,
         C1: DimMul<C2>,
-        SB: Storage<N, R2, C2>,
-        DefaultAllocator: Allocator<N, DimProd<R1, R2>, DimProd<C1, C2>>,
+        SB: Storage<T, R2, C2>,
+        DefaultAllocator: Allocator<T, DimProd<R1, R2>, DimProd<C1, C2>>,
     {
         let (nrows1, ncols1) = self.data.shape();
         let (nrows2, ncols2) = rhs.data.shape();
@@ -845,22 +843,22 @@ where
     }
 }
 
-impl<N, D: DimName> iter::Product for MatrixN<N, D>
+impl<T, D: DimName> iter::Product for OMatrix<T, D, D>
 where
-    N: Scalar + Zero + One + ClosedMul + ClosedAdd,
-    DefaultAllocator: Allocator<N, D, D>,
+    T: Scalar + Zero + One + ClosedMul + ClosedAdd,
+    DefaultAllocator: Allocator<T, D, D>,
 {
-    fn product<I: Iterator<Item = MatrixN<N, D>>>(iter: I) -> MatrixN<N, D> {
+    fn product<I: Iterator<Item = OMatrix<T, D, D>>>(iter: I) -> OMatrix<T, D, D> {
         iter.fold(Matrix::one(), |acc, x| acc * x)
     }
 }
 
-impl<'a, N, D: DimName> iter::Product<&'a MatrixN<N, D>> for MatrixN<N, D>
+impl<'a, T, D: DimName> iter::Product<&'a OMatrix<T, D, D>> for OMatrix<T, D, D>
 where
-    N: Scalar + Zero + One + ClosedMul + ClosedAdd,
-    DefaultAllocator: Allocator<N, D, D>,
+    T: Scalar + Zero + One + ClosedMul + ClosedAdd,
+    DefaultAllocator: Allocator<T, D, D>,
 {
-    fn product<I: Iterator<Item = &'a MatrixN<N, D>>>(iter: I) -> MatrixN<N, D> {
+    fn product<I: Iterator<Item = &'a OMatrix<T, D, D>>>(iter: I) -> OMatrix<T, D, D> {
         iter.fold(Matrix::one(), |acc, x| acc * x)
     }
 }
diff --git a/src/base/properties.rs b/src/base/properties.rs
index d1119afe..1cbff719 100644
--- a/src/base/properties.rs
+++ b/src/base/properties.rs
@@ -9,7 +9,7 @@ use crate::base::dimension::{Dim, DimMin};
 use crate::base::storage::Storage;
 use crate::base::{DefaultAllocator, Matrix, Scalar, SquareMatrix};
 
-impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
+impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
     /// The total number of elements of this matrix.
     ///
     /// # Examples:
@@ -52,10 +52,10 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     /// If the matrix is diagonal, this checks that diagonal elements (i.e. at coordinates `(i, i)`
     /// for i from `0` to `min(R, C)`) are equal one; and that all other elements are zero.
     #[inline]
-    pub fn is_identity(&self, eps: N::Epsilon) -> bool
+    pub fn is_identity(&self, eps: T::Epsilon) -> bool
     where
-        N: Zero + One + RelativeEq,
-        N::Epsilon: Copy,
+        T: Zero + One + RelativeEq,
+        T::Epsilon: Copy,
     {
         let (nrows, ncols) = self.shape();
         let d;
@@ -65,7 +65,7 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
 
             for i in d..nrows {
                 for j in 0..ncols {
-                    if !relative_eq!(self[(i, j)], N::zero(), epsilon = eps) {
+                    if !relative_eq!(self[(i, j)], T::zero(), epsilon = eps) {
                         return false;
                     }
                 }
@@ -76,7 +76,7 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
 
             for i in 0..nrows {
                 for j in d..ncols {
-                    if !relative_eq!(self[(i, j)], N::zero(), epsilon = eps) {
+                    if !relative_eq!(self[(i, j)], T::zero(), epsilon = eps) {
                         return false;
                     }
                 }
@@ -87,8 +87,8 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
         for i in 1..d {
             for j in 0..i {
                 // TODO: use unsafe indexing.
-                if !relative_eq!(self[(i, j)], N::zero(), epsilon = eps)
-                    || !relative_eq!(self[(j, i)], N::zero(), epsilon = eps)
+                if !relative_eq!(self[(i, j)], T::zero(), epsilon = eps)
+                    || !relative_eq!(self[(j, i)], T::zero(), epsilon = eps)
                 {
                     return false;
                 }
@@ -97,7 +97,7 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
 
         // Diagonal elements of the sub-square matrix.
         for i in 0..d {
-            if !relative_eq!(self[(i, i)], N::one(), epsilon = eps) {
+            if !relative_eq!(self[(i, i)], T::one(), epsilon = eps) {
                 return false;
             }
         }
@@ -106,35 +106,35 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     }
 }
 
-impl<N: ComplexField, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
+impl<T: ComplexField, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
     /// Checks that `Mᵀ × M = Id`.
     ///
     /// In this definition `Id` is approximately equal to the identity matrix with a relative error
     /// equal to `eps`.
     #[inline]
-    pub fn is_orthogonal(&self, eps: N::Epsilon) -> bool
+    pub fn is_orthogonal(&self, eps: T::Epsilon) -> bool
     where
-        N: Zero + One + ClosedAdd + ClosedMul + RelativeEq,
-        S: Storage<N, R, C>,
-        N::Epsilon: Copy,
-        DefaultAllocator: Allocator<N, R, C> + Allocator<N, C, C>,
+        T: Zero + One + ClosedAdd + ClosedMul + RelativeEq,
+        S: Storage<T, R, C>,
+        T::Epsilon: Copy,
+        DefaultAllocator: Allocator<T, R, C> + Allocator<T, C, C>,
     {
         (self.ad_mul(self)).is_identity(eps)
     }
 }
 
-impl<N: RealField, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S>
+impl<T: RealField, D: Dim, S: Storage<T, D, D>> SquareMatrix<T, D, S>
 where
-    DefaultAllocator: Allocator<N, D, D>,
+    DefaultAllocator: Allocator<T, D, D>,
 {
     /// Checks that this matrix is orthogonal and has a determinant equal to 1.
     #[inline]
-    pub fn is_special_orthogonal(&self, eps: N) -> bool
+    pub fn is_special_orthogonal(&self, eps: T) -> bool
     where
         D: DimMin<D, Output = D>,
         DefaultAllocator: Allocator<(usize, usize), D>,
     {
-        self.is_square() && self.is_orthogonal(eps) && self.determinant() > N::zero()
+        self.is_square() && self.is_orthogonal(eps) && self.determinant() > T::zero()
     }
 
     /// Returns `true` if this matrix is invertible.
diff --git a/src/base/scalar.rs b/src/base/scalar.rs
index a8008ddf..db9e458d 100644
--- a/src/base/scalar.rs
+++ b/src/base/scalar.rs
@@ -9,7 +9,7 @@ pub trait Scalar: Clone + PartialEq + Debug + Any {
     #[inline]
     /// Tests if `Self` the same as the type `T`
     ///
-    /// Typically used to test of `Self` is a f32 or a f64 with `N::is::<f32>()`.
+    /// Typically used to test of `Self` is a f32 or a f64 with `T::is::<f32>()`.
     fn is<T: Scalar>() -> bool {
         TypeId::of::<Self>() == TypeId::of::<T>()
     }
diff --git a/src/base/statistics.rs b/src/base/statistics.rs
index 811b508f..8f6c77ce 100644
--- a/src/base/statistics.rs
+++ b/src/base/statistics.rs
@@ -1,24 +1,24 @@
 use crate::allocator::Allocator;
 use crate::storage::Storage;
-use crate::{DefaultAllocator, Dim, Matrix, RowVectorN, Scalar, VectorN, VectorSliceN, U1};
+use crate::{Const, DefaultAllocator, Dim, Matrix, OVector, RowOVector, Scalar, VectorSlice, U1};
 use num::Zero;
 use simba::scalar::{ClosedAdd, Field, SupersetOf};
 
 /// # Folding on columns and rows
-impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
+impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
     /// Returns a row vector where each element is the result of the application of `f` on the
     /// corresponding column of the original matrix.
     #[inline]
     pub fn compress_rows(
         &self,
-        f: impl Fn(VectorSliceN<N, R, S::RStride, S::CStride>) -> N,
-    ) -> RowVectorN<N, C>
+        f: impl Fn(VectorSlice<T, R, S::RStride, S::CStride>) -> T,
+    ) -> RowOVector<T, C>
     where
-        DefaultAllocator: Allocator<N, U1, C>,
+        DefaultAllocator: Allocator<T, U1, C>,
     {
         let ncols = self.data.shape().1;
-        let mut res: RowVectorN<N, C> =
-            unsafe { crate::unimplemented_or_uninitialized_generic!(U1, ncols) };
+        let mut res: RowOVector<T, C> =
+            unsafe { crate::unimplemented_or_uninitialized_generic!(Const::<1>, ncols) };
 
         for i in 0..ncols.value() {
             // TODO: avoid bound checking of column.
@@ -37,14 +37,14 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     #[inline]
     pub fn compress_rows_tr(
         &self,
-        f: impl Fn(VectorSliceN<N, R, S::RStride, S::CStride>) -> N,
-    ) -> VectorN<N, C>
+        f: impl Fn(VectorSlice<T, R, S::RStride, S::CStride>) -> T,
+    ) -> OVector<T, C>
     where
-        DefaultAllocator: Allocator<N, C>,
+        DefaultAllocator: Allocator<T, C>,
     {
         let ncols = self.data.shape().1;
-        let mut res: VectorN<N, C> =
-            unsafe { crate::unimplemented_or_uninitialized_generic!(ncols, U1) };
+        let mut res: OVector<T, C> =
+            unsafe { crate::unimplemented_or_uninitialized_generic!(ncols, Const::<1>) };
 
         for i in 0..ncols.value() {
             // TODO: avoid bound checking of column.
@@ -60,11 +60,11 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     #[inline]
     pub fn compress_columns(
         &self,
-        init: VectorN<N, R>,
-        f: impl Fn(&mut VectorN<N, R>, VectorSliceN<N, R, S::RStride, S::CStride>),
-    ) -> VectorN<N, R>
+        init: OVector<T, R>,
+        f: impl Fn(&mut OVector<T, R>, VectorSlice<T, R, S::RStride, S::CStride>),
+    ) -> OVector<T, R>
     where
-        DefaultAllocator: Allocator<N, R>,
+        DefaultAllocator: Allocator<T, R>,
     {
         let mut res = init;
 
@@ -77,7 +77,7 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
 }
 
 /// # Common statistics operations
-impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
+impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
     /*
      *
      * Sum computation.
@@ -95,11 +95,11 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     /// assert_eq!(m.sum(), 21.0);
     /// ```
     #[inline]
-    pub fn sum(&self) -> N
+    pub fn sum(&self) -> T
     where
-        N: ClosedAdd + Zero,
+        T: ClosedAdd + Zero,
     {
-        self.iter().cloned().fold(N::zero(), |a, b| a + b)
+        self.iter().cloned().fold(T::zero(), |a, b| a + b)
     }
 
     /// The sum of all the rows of this matrix.
@@ -120,10 +120,10 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     /// assert_eq!(mint.row_sum(), RowVector2::new(9,12));
     /// ```
     #[inline]
-    pub fn row_sum(&self) -> RowVectorN<N, C>
+    pub fn row_sum(&self) -> RowOVector<T, C>
     where
-        N: ClosedAdd + Zero,
-        DefaultAllocator: Allocator<N, U1, C>,
+        T: ClosedAdd + Zero,
+        DefaultAllocator: Allocator<T, U1, C>,
     {
         self.compress_rows(|col| col.sum())
     }
@@ -144,10 +144,10 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     /// assert_eq!(mint.row_sum_tr(), Vector2::new(9,12));
     /// ```
     #[inline]
-    pub fn row_sum_tr(&self) -> VectorN<N, C>
+    pub fn row_sum_tr(&self) -> OVector<T, C>
     where
-        N: ClosedAdd + Zero,
-        DefaultAllocator: Allocator<N, C>,
+        T: ClosedAdd + Zero,
+        DefaultAllocator: Allocator<T, C>,
     {
         self.compress_rows_tr(|col| col.sum())
     }
@@ -168,13 +168,13 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     /// assert_eq!(mint.column_sum(), Vector3::new(3,7,11));
     /// ```
     #[inline]
-    pub fn column_sum(&self) -> VectorN<N, R>
+    pub fn column_sum(&self) -> OVector<T, R>
     where
-        N: ClosedAdd + Zero,
-        DefaultAllocator: Allocator<N, R>,
+        T: ClosedAdd + Zero,
+        DefaultAllocator: Allocator<T, R>,
     {
         let nrows = self.data.shape().0;
-        self.compress_columns(VectorN::zeros_generic(nrows, U1), |out, col| {
+        self.compress_columns(OVector::zeros_generic(nrows, Const::<1>), |out, col| {
             *out += col;
         })
     }
@@ -197,17 +197,17 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     /// assert_relative_eq!(m.variance(), 35.0 / 12.0, epsilon = 1.0e-8);
     /// ```
     #[inline]
-    pub fn variance(&self) -> N
+    pub fn variance(&self) -> T
     where
-        N: Field + SupersetOf<f64>,
+        T: Field + SupersetOf<f64>,
     {
         if self.is_empty() {
-            N::zero()
+            T::zero()
         } else {
-            let val = self.iter().cloned().fold((N::zero(), N::zero()), |a, b| {
+            let val = self.iter().cloned().fold((T::zero(), T::zero()), |a, b| {
                 (a.0 + b.inlined_clone() * b.inlined_clone(), a.1 + b)
             });
-            let denom = N::one() / crate::convert::<_, N>(self.len() as f64);
+            let denom = T::one() / crate::convert::<_, T>(self.len() as f64);
             let vd = val.1 * denom.inlined_clone();
             val.0 * denom - vd.inlined_clone() * vd
         }
@@ -226,10 +226,10 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     /// assert_eq!(m.row_variance(), RowVector3::new(2.25, 2.25, 2.25));
     /// ```
     #[inline]
-    pub fn row_variance(&self) -> RowVectorN<N, C>
+    pub fn row_variance(&self) -> RowOVector<T, C>
     where
-        N: Field + SupersetOf<f64>,
-        DefaultAllocator: Allocator<N, U1, C>,
+        T: Field + SupersetOf<f64>,
+        DefaultAllocator: Allocator<T, U1, C>,
     {
         self.compress_rows(|col| col.variance())
     }
@@ -246,10 +246,10 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     /// assert_eq!(m.row_variance_tr(), Vector3::new(2.25, 2.25, 2.25));
     /// ```
     #[inline]
-    pub fn row_variance_tr(&self) -> VectorN<N, C>
+    pub fn row_variance_tr(&self) -> OVector<T, C>
     where
-        N: Field + SupersetOf<f64>,
-        DefaultAllocator: Allocator<N, C>,
+        T: Field + SupersetOf<f64>,
+        DefaultAllocator: Allocator<T, C>,
     {
         self.compress_rows_tr(|col| col.variance())
     }
@@ -267,17 +267,17 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     /// assert_relative_eq!(m.column_variance(), Vector2::new(2.0 / 3.0, 2.0 / 3.0), epsilon = 1.0e-8);
     /// ```
     #[inline]
-    pub fn column_variance(&self) -> VectorN<N, R>
+    pub fn column_variance(&self) -> OVector<T, R>
     where
-        N: Field + SupersetOf<f64>,
-        DefaultAllocator: Allocator<N, R>,
+        T: Field + SupersetOf<f64>,
+        DefaultAllocator: Allocator<T, R>,
     {
         let (nrows, ncols) = self.data.shape();
 
         let mut mean = self.column_mean();
         mean.apply(|e| -(e.inlined_clone() * e));
 
-        let denom = N::one() / crate::convert::<_, N>(ncols.value() as f64);
+        let denom = T::one() / crate::convert::<_, T>(ncols.value() as f64);
         self.compress_columns(mean, |out, col| {
             for i in 0..nrows.value() {
                 unsafe {
@@ -306,12 +306,12 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     /// assert_eq!(m.mean(), 3.5);
     /// ```
     #[inline]
-    pub fn mean(&self) -> N
+    pub fn mean(&self) -> T
     where
-        N: Field + SupersetOf<f64>,
+        T: Field + SupersetOf<f64>,
     {
         if self.is_empty() {
-            N::zero()
+            T::zero()
         } else {
             self.sum() / crate::convert(self.len() as f64)
         }
@@ -331,10 +331,10 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     /// assert_eq!(m.row_mean(), RowVector3::new(2.5, 3.5, 4.5));
     /// ```
     #[inline]
-    pub fn row_mean(&self) -> RowVectorN<N, C>
+    pub fn row_mean(&self) -> RowOVector<T, C>
     where
-        N: Field + SupersetOf<f64>,
-        DefaultAllocator: Allocator<N, U1, C>,
+        T: Field + SupersetOf<f64>,
+        DefaultAllocator: Allocator<T, U1, C>,
     {
         self.compress_rows(|col| col.mean())
     }
@@ -351,10 +351,10 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     /// assert_eq!(m.row_mean_tr(), Vector3::new(2.5, 3.5, 4.5));
     /// ```
     #[inline]
-    pub fn row_mean_tr(&self) -> VectorN<N, C>
+    pub fn row_mean_tr(&self) -> OVector<T, C>
     where
-        N: Field + SupersetOf<f64>,
-        DefaultAllocator: Allocator<N, C>,
+        T: Field + SupersetOf<f64>,
+        DefaultAllocator: Allocator<T, C>,
     {
         self.compress_rows_tr(|col| col.mean())
     }
@@ -371,15 +371,15 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     /// assert_eq!(m.column_mean(), Vector2::new(2.0, 5.0));
     /// ```
     #[inline]
-    pub fn column_mean(&self) -> VectorN<N, R>
+    pub fn column_mean(&self) -> OVector<T, R>
     where
-        N: Field + SupersetOf<f64>,
-        DefaultAllocator: Allocator<N, R>,
+        T: Field + SupersetOf<f64>,
+        DefaultAllocator: Allocator<T, R>,
     {
         let (nrows, ncols) = self.data.shape();
-        let denom = N::one() / crate::convert::<_, N>(ncols.value() as f64);
-        self.compress_columns(VectorN::zeros_generic(nrows, U1), |out, col| {
-            out.axpy(denom.inlined_clone(), &col, N::one())
+        let denom = T::one() / crate::convert::<_, T>(ncols.value() as f64);
+        self.compress_columns(OVector::zeros_generic(nrows, Const::<1>), |out, col| {
+            out.axpy(denom.inlined_clone(), &col, T::one())
         })
     }
 }
diff --git a/src/base/storage.rs b/src/base/storage.rs
index 038884e3..0238b36c 100644
--- a/src/base/storage.rs
+++ b/src/base/storage.rs
@@ -12,20 +12,20 @@ use crate::base::Scalar;
  * Aliases for allocation results.
  */
 /// The data storage for the sum of two matrices with dimensions `(R1, C1)` and `(R2, C2)`.
-pub type SameShapeStorage<N, R1, C1, R2, C2> =
-    <DefaultAllocator as Allocator<N, SameShapeR<R1, R2>, SameShapeC<C1, C2>>>::Buffer;
+pub type SameShapeStorage<T, R1, C1, R2, C2> =
+    <DefaultAllocator as Allocator<T, SameShapeR<R1, R2>, SameShapeC<C1, C2>>>::Buffer;
 
 // TODO: better name than Owned ?
 /// The owned data storage that can be allocated from `S`.
-pub type Owned<N, R, C = U1> = <DefaultAllocator as Allocator<N, R, C>>::Buffer;
+pub type Owned<T, R, C = U1> = <DefaultAllocator as Allocator<T, R, C>>::Buffer;
 
 /// The row-stride of the owned data storage for a buffer of dimension `(R, C)`.
-pub type RStride<N, R, C = U1> =
-    <<DefaultAllocator as Allocator<N, R, C>>::Buffer as Storage<N, R, C>>::RStride;
+pub type RStride<T, R, C = U1> =
+    <<DefaultAllocator as Allocator<T, R, C>>::Buffer as Storage<T, R, C>>::RStride;
 
 /// The column-stride of the owned data storage for a buffer of dimension `(R, C)`.
-pub type CStride<N, R, C = U1> =
-    <<DefaultAllocator as Allocator<N, R, C>>::Buffer as Storage<N, R, C>>::CStride;
+pub type CStride<T, R, C = U1> =
+    <<DefaultAllocator as Allocator<T, R, C>>::Buffer as Storage<T, R, C>>::CStride;
 
 /// The trait shared by all matrix data storage.
 ///
@@ -36,7 +36,7 @@ pub type CStride<N, R, C = U1> =
 /// should **not** allow the user to modify the size of the underlying buffer with safe methods
 /// (for example the `VecStorage::data_mut` method is unsafe because the user could change the
 /// vector's size so that it no longer contains enough elements: this will lead to UB.
-pub unsafe trait Storage<N: Scalar, R: Dim, C: Dim = U1>: Debug + Sized {
+pub unsafe trait Storage<T: Scalar, R: Dim, C: Dim = U1>: Debug + Sized {
     /// The static stride of this storage's rows.
     type RStride: Dim;
 
@@ -44,7 +44,7 @@ pub unsafe trait Storage<N: Scalar, R: Dim, C: Dim = U1>: Debug + Sized {
     type CStride: Dim;
 
     /// The matrix data pointer.
-    fn ptr(&self) -> *const N;
+    fn ptr(&self) -> *const T;
 
     /// The dimension of the matrix at run-time. Arr length of zero indicates the additive identity
     /// element of any dimension. Must be equal to `Self::dimension()` if it is not `None`.
@@ -71,25 +71,25 @@ pub unsafe trait Storage<N: Scalar, R: Dim, C: Dim = U1>: Debug + Sized {
 
     /// Gets the address of the i-th matrix component without performing bound-checking.
     #[inline]
-    unsafe fn get_address_unchecked_linear(&self, i: usize) -> *const N {
+    unsafe fn get_address_unchecked_linear(&self, i: usize) -> *const T {
         self.ptr().wrapping_add(i)
     }
 
     /// Gets the address of the i-th matrix component without performing bound-checking.
     #[inline]
-    unsafe fn get_address_unchecked(&self, irow: usize, icol: usize) -> *const N {
+    unsafe fn get_address_unchecked(&self, irow: usize, icol: usize) -> *const T {
         self.get_address_unchecked_linear(self.linear_index(irow, icol))
     }
 
     /// Retrieves a reference to the i-th element without bound-checking.
     #[inline]
-    unsafe fn get_unchecked_linear(&self, i: usize) -> &N {
+    unsafe fn get_unchecked_linear(&self, i: usize) -> &T {
         &*self.get_address_unchecked_linear(i)
     }
 
     /// Retrieves a reference to the i-th element without bound-checking.
     #[inline]
-    unsafe fn get_unchecked(&self, irow: usize, icol: usize) -> &N {
+    unsafe fn get_unchecked(&self, irow: usize, icol: usize) -> &T {
         self.get_unchecked_linear(self.linear_index(irow, icol))
     }
 
@@ -99,17 +99,17 @@ pub unsafe trait Storage<N: Scalar, R: Dim, C: Dim = U1>: Debug + Sized {
     /// Retrieves the data buffer as a contiguous slice.
     ///
     /// The matrix components may not be stored in a contiguous way, depending on the strides.
-    fn as_slice(&self) -> &[N];
+    fn as_slice(&self) -> &[T];
 
     /// Builds a matrix data storage that does not contain any reference.
-    fn into_owned(self) -> Owned<N, R, C>
+    fn into_owned(self) -> Owned<T, R, C>
     where
-        DefaultAllocator: Allocator<N, R, C>;
+        DefaultAllocator: Allocator<T, R, C>;
 
     /// Clones this data storage to one that does not contain any reference.
-    fn clone_owned(&self) -> Owned<N, R, C>
+    fn clone_owned(&self) -> Owned<T, R, C>
     where
-        DefaultAllocator: Allocator<N, R, C>;
+        DefaultAllocator: Allocator<T, R, C>;
 }
 
 /// Trait implemented by matrix data storage that can provide a mutable access to its elements.
@@ -117,31 +117,31 @@ pub unsafe trait Storage<N: Scalar, R: Dim, C: Dim = U1>: Debug + Sized {
 /// 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
 /// contains only an internal reference to them).
-pub unsafe trait StorageMut<N: Scalar, R: Dim, C: Dim = U1>: Storage<N, R, C> {
+pub unsafe trait StorageMut<T: Scalar, R: Dim, C: Dim = U1>: Storage<T, R, C> {
     /// The matrix mutable data pointer.
-    fn ptr_mut(&mut self) -> *mut N;
+    fn ptr_mut(&mut self) -> *mut T;
 
     /// Gets the mutable address of the i-th matrix component without performing bound-checking.
     #[inline]
-    unsafe fn get_address_unchecked_linear_mut(&mut self, i: usize) -> *mut N {
+    unsafe fn get_address_unchecked_linear_mut(&mut self, i: usize) -> *mut T {
         self.ptr_mut().wrapping_add(i)
     }
 
     /// Gets the mutable address of the i-th matrix component without performing bound-checking.
     #[inline]
-    unsafe fn get_address_unchecked_mut(&mut self, irow: usize, icol: usize) -> *mut N {
+    unsafe fn get_address_unchecked_mut(&mut self, irow: usize, icol: usize) -> *mut T {
         let lid = self.linear_index(irow, icol);
         self.get_address_unchecked_linear_mut(lid)
     }
 
     /// Retrieves a mutable reference to the i-th element without bound-checking.
-    unsafe fn get_unchecked_linear_mut(&mut self, i: usize) -> &mut N {
+    unsafe fn get_unchecked_linear_mut(&mut self, i: usize) -> &mut T {
         &mut *self.get_address_unchecked_linear_mut(i)
     }
 
     /// Retrieves a mutable reference to the element at `(irow, icol)` without bound-checking.
     #[inline]
-    unsafe fn get_unchecked_mut(&mut self, irow: usize, icol: usize) -> &mut N {
+    unsafe fn get_unchecked_mut(&mut self, irow: usize, icol: usize) -> &mut T {
         &mut *self.get_address_unchecked_mut(irow, icol)
     }
 
@@ -166,7 +166,7 @@ pub unsafe trait StorageMut<N: Scalar, R: Dim, C: Dim = U1>: Storage<N, R, C> {
     /// Retrieves the mutable data buffer as a contiguous slice.
     ///
     /// Matrix components may not be contiguous, depending on its strides.
-    fn as_mut_slice(&mut self) -> &mut [N];
+    fn as_mut_slice(&mut self) -> &mut [T];
 }
 
 /// A matrix storage that is stored contiguously in memory.
@@ -174,8 +174,8 @@ pub unsafe trait StorageMut<N: Scalar, R: Dim, C: Dim = U1>: Storage<N, R, C> {
 /// The storage requirement means that for any value of `i` in `[0, nrows * ncols - 1]`, the value
 /// `.get_unchecked_linear` returns one of the matrix component. This trait is unsafe because
 /// failing to comply to this may cause Undefined Behaviors.
-pub unsafe trait ContiguousStorage<N: Scalar, R: Dim, C: Dim = U1>:
-    Storage<N, R, C>
+pub unsafe trait ContiguousStorage<T: Scalar, R: Dim, C: Dim = U1>:
+    Storage<T, R, C>
 {
 }
 
@@ -184,22 +184,22 @@ pub unsafe trait ContiguousStorage<N: Scalar, R: Dim, C: Dim = U1>:
 /// The storage requirement means that for any value of `i` in `[0, nrows * ncols - 1]`, the value
 /// `.get_unchecked_linear` returns one of the matrix component. This trait is unsafe because
 /// failing to comply to this may cause Undefined Behaviors.
-pub unsafe trait ContiguousStorageMut<N: Scalar, R: Dim, C: Dim = U1>:
-    ContiguousStorage<N, R, C> + StorageMut<N, R, C>
+pub unsafe trait ContiguousStorageMut<T: Scalar, R: Dim, C: Dim = U1>:
+    ContiguousStorage<T, R, C> + StorageMut<T, R, C>
 {
 }
 
 /// A matrix storage that can be reshaped in-place.
-pub trait ReshapableStorage<N, R1, C1, R2, C2>: Storage<N, R1, C1>
+pub trait ReshapableStorage<T, R1, C1, R2, C2>: Storage<T, R1, C1>
 where
-    N: Scalar,
+    T: Scalar,
     R1: Dim,
     C1: Dim,
     R2: Dim,
     C2: Dim,
 {
     /// The reshaped storage type.
-    type Output: Storage<N, R2, C2>;
+    type Output: Storage<T, R2, C2>;
 
     /// Reshapes the storage into the output storage type.
     fn reshape_generic(self, nrows: R2, ncols: C2) -> Self::Output;
diff --git a/src/base/swizzle.rs b/src/base/swizzle.rs
index b8578925..1e2f0e4c 100644
--- a/src/base/swizzle.rs
+++ b/src/base/swizzle.rs
@@ -1,4 +1,4 @@
-use crate::base::{DimName, Scalar, Vector, Vector2, Vector3};
+use crate::base::{DimName, Scalar, ToTypenum, Vector, Vector2, Vector3};
 use crate::storage::Storage;
 use typenum::{self, Cmp, Greater};
 
@@ -8,8 +8,8 @@ macro_rules! impl_swizzle {
             $(
                 /// Builds a new vector from components of `self`.
                 #[inline]
-                pub fn $name(&self) -> $Result<N>
-                where D::Value: Cmp<typenum::$BaseDim, Output=Greater> {
+                pub fn $name(&self) -> $Result<T>
+                where D::Typenum: Cmp<typenum::$BaseDim, Output=Greater> {
                     $Result::new($(self[$i].inlined_clone()),*)
                 }
             )*
@@ -18,7 +18,10 @@ macro_rules! impl_swizzle {
 }
 
 /// # Swizzling
-impl<N: Scalar, D: DimName, S: Storage<N, D>> Vector<N, D, S> {
+impl<T: Scalar, D, S: Storage<T, D>> Vector<T, D, S>
+where
+    D: DimName + ToTypenum,
+{
     impl_swizzle!(
         where U0: xx()  -> Vector2[0, 0],
                   xxx() -> Vector3[0, 0, 0];
diff --git a/src/base/unit.rs b/src/base/unit.rs
index 70e3a927..527f7503 100644
--- a/src/base/unit.rs
+++ b/src/base/unit.rs
@@ -12,7 +12,7 @@ use abomonation::Abomonation;
 use crate::allocator::Allocator;
 use crate::base::DefaultAllocator;
 use crate::storage::Storage;
-use crate::{Dim, Matrix, MatrixMN, RealField, Scalar, SimdComplexField, SimdRealField};
+use crate::{Dim, Matrix, OMatrix, RealField, Scalar, SimdComplexField, SimdRealField};
 
 /// A wrapper that ensures the underlying algebraic entity has a unit norm.
 ///
@@ -71,12 +71,12 @@ impl<T: Abomonation> Abomonation for Unit<T> {
     }
 }
 
-impl<N, R, C, S> PartialEq for Unit<Matrix<N, R, C, S>>
+impl<T, R, C, S> PartialEq for Unit<Matrix<T, R, C, S>>
 where
-    N: Scalar + PartialEq,
+    T: Scalar + PartialEq,
     R: Dim,
     C: Dim,
-    S: Storage<N, R, C>,
+    S: Storage<T, R, C>,
 {
     #[inline]
     fn eq(&self, rhs: &Self) -> bool {
@@ -84,12 +84,12 @@ where
     }
 }
 
-impl<N, R, C, S> Eq for Unit<Matrix<N, R, C, S>>
+impl<T, R, C, S> Eq for Unit<Matrix<T, R, C, S>>
 where
-    N: Scalar + Eq,
+    T: Scalar + Eq,
     R: Dim,
     C: Dim,
-    S: Storage<N, R, C>,
+    S: Storage<T, R, C>,
 {
 }
 
@@ -298,32 +298,32 @@ impl<T> Deref for Unit<T> {
 // NOTE: we can't use a generic implementation for `Unit<T>` because
 // num_complex::Complex does not implement `From[Complex<...>...]` (and can't
 // because of the orphan rules).
-impl<N: Scalar + simba::simd::PrimitiveSimdValue, R: Dim, C: Dim>
-    From<[Unit<MatrixMN<N::Element, R, C>>; 2]> for Unit<MatrixMN<N, R, C>>
+impl<T: Scalar + simba::simd::PrimitiveSimdValue, R: Dim, C: Dim>
+    From<[Unit<OMatrix<T::Element, R, C>>; 2]> for Unit<OMatrix<T, R, C>>
 where
-    N: From<[<N as simba::simd::SimdValue>::Element; 2]>,
-    N::Element: Scalar,
-    DefaultAllocator: Allocator<N, R, C> + Allocator<N::Element, R, C>,
+    T: From<[<T as simba::simd::SimdValue>::Element; 2]>,
+    T::Element: Scalar,
+    DefaultAllocator: Allocator<T, R, C> + Allocator<T::Element, R, C>,
 {
     #[inline]
-    fn from(arr: [Unit<MatrixMN<N::Element, R, C>>; 2]) -> Self {
-        Self::new_unchecked(MatrixMN::from([
+    fn from(arr: [Unit<OMatrix<T::Element, R, C>>; 2]) -> Self {
+        Self::new_unchecked(OMatrix::from([
             arr[0].clone().into_inner(),
             arr[1].clone().into_inner(),
         ]))
     }
 }
 
-impl<N: Scalar + simba::simd::PrimitiveSimdValue, R: Dim, C: Dim>
-    From<[Unit<MatrixMN<N::Element, R, C>>; 4]> for Unit<MatrixMN<N, R, C>>
+impl<T: Scalar + simba::simd::PrimitiveSimdValue, R: Dim, C: Dim>
+    From<[Unit<OMatrix<T::Element, R, C>>; 4]> for Unit<OMatrix<T, R, C>>
 where
-    N: From<[<N as simba::simd::SimdValue>::Element; 4]>,
-    N::Element: Scalar,
-    DefaultAllocator: Allocator<N, R, C> + Allocator<N::Element, R, C>,
+    T: From<[<T as simba::simd::SimdValue>::Element; 4]>,
+    T::Element: Scalar,
+    DefaultAllocator: Allocator<T, R, C> + Allocator<T::Element, R, C>,
 {
     #[inline]
-    fn from(arr: [Unit<MatrixMN<N::Element, R, C>>; 4]) -> Self {
-        Self::new_unchecked(MatrixMN::from([
+    fn from(arr: [Unit<OMatrix<T::Element, R, C>>; 4]) -> Self {
+        Self::new_unchecked(OMatrix::from([
             arr[0].clone().into_inner(),
             arr[1].clone().into_inner(),
             arr[2].clone().into_inner(),
@@ -332,16 +332,16 @@ where
     }
 }
 
-impl<N: Scalar + simba::simd::PrimitiveSimdValue, R: Dim, C: Dim>
-    From<[Unit<MatrixMN<N::Element, R, C>>; 8]> for Unit<MatrixMN<N, R, C>>
+impl<T: Scalar + simba::simd::PrimitiveSimdValue, R: Dim, C: Dim>
+    From<[Unit<OMatrix<T::Element, R, C>>; 8]> for Unit<OMatrix<T, R, C>>
 where
-    N: From<[<N as simba::simd::SimdValue>::Element; 8]>,
-    N::Element: Scalar,
-    DefaultAllocator: Allocator<N, R, C> + Allocator<N::Element, R, C>,
+    T: From<[<T as simba::simd::SimdValue>::Element; 8]>,
+    T::Element: Scalar,
+    DefaultAllocator: Allocator<T, R, C> + Allocator<T::Element, R, C>,
 {
     #[inline]
-    fn from(arr: [Unit<MatrixMN<N::Element, R, C>>; 8]) -> Self {
-        Self::new_unchecked(MatrixMN::from([
+    fn from(arr: [Unit<OMatrix<T::Element, R, C>>; 8]) -> Self {
+        Self::new_unchecked(OMatrix::from([
             arr[0].clone().into_inner(),
             arr[1].clone().into_inner(),
             arr[2].clone().into_inner(),
@@ -354,16 +354,16 @@ where
     }
 }
 
-impl<N: Scalar + simba::simd::PrimitiveSimdValue, R: Dim, C: Dim>
-    From<[Unit<MatrixMN<N::Element, R, C>>; 16]> for Unit<MatrixMN<N, R, C>>
+impl<T: Scalar + simba::simd::PrimitiveSimdValue, R: Dim, C: Dim>
+    From<[Unit<OMatrix<T::Element, R, C>>; 16]> for Unit<OMatrix<T, R, C>>
 where
-    N: From<[<N as simba::simd::SimdValue>::Element; 16]>,
-    N::Element: Scalar,
-    DefaultAllocator: Allocator<N, R, C> + Allocator<N::Element, R, C>,
+    T: From<[<T as simba::simd::SimdValue>::Element; 16]>,
+    T::Element: Scalar,
+    DefaultAllocator: Allocator<T, R, C> + Allocator<T::Element, R, C>,
 {
     #[inline]
-    fn from(arr: [Unit<MatrixMN<N::Element, R, C>>; 16]) -> Self {
-        Self::new_unchecked(MatrixMN::from([
+    fn from(arr: [Unit<OMatrix<T::Element, R, C>>; 16]) -> Self {
+        Self::new_unchecked(OMatrix::from([
             arr[0].clone().into_inner(),
             arr[1].clone().into_inner(),
             arr[2].clone().into_inner(),
diff --git a/src/base/vec_storage.rs b/src/base/vec_storage.rs
index 03f032e8..29da127d 100644
--- a/src/base/vec_storage.rs
+++ b/src/base/vec_storage.rs
@@ -25,20 +25,20 @@ use abomonation::Abomonation;
 #[repr(C)]
 #[derive(Eq, Debug, Clone, PartialEq)]
 #[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
-pub struct VecStorage<N, R: Dim, C: Dim> {
-    data: Vec<N>,
+pub struct VecStorage<T, R: Dim, C: Dim> {
+    data: Vec<T>,
     nrows: R,
     ncols: C,
 }
 
 #[deprecated(note = "renamed to `VecStorage`")]
 /// Renamed to [VecStorage].
-pub type MatrixVec<N, R, C> = VecStorage<N, R, C>;
+pub type MatrixVec<T, R, C> = VecStorage<T, R, C>;
 
-impl<N, R: Dim, C: Dim> VecStorage<N, R, C> {
+impl<T, R: Dim, C: Dim> VecStorage<T, R, C> {
     /// Creates a new dynamic matrix data storage from the given vector and shape.
     #[inline]
-    pub fn new(nrows: R, ncols: C, data: Vec<N>) -> Self {
+    pub fn new(nrows: R, ncols: C, data: Vec<T>) -> Self {
         assert!(
             nrows.value() * ncols.value() == data.len(),
             "Data storage buffer dimension mismatch."
@@ -48,7 +48,7 @@ impl<N, R: Dim, C: Dim> VecStorage<N, R, C> {
 
     /// The underlying data storage.
     #[inline]
-    pub fn as_vec(&self) -> &Vec<N> {
+    pub fn as_vec(&self) -> &Vec<T> {
         &self.data
     }
 
@@ -57,7 +57,7 @@ impl<N, R: Dim, C: Dim> VecStorage<N, R, C> {
     /// This is unsafe because this may cause UB if the size of the vector is changed
     /// by the user.
     #[inline]
-    pub unsafe fn as_vec_mut(&mut self) -> &mut Vec<N> {
+    pub unsafe fn as_vec_mut(&mut self) -> &mut Vec<T> {
         &mut self.data
     }
 
@@ -66,7 +66,7 @@ impl<N, R: Dim, C: Dim> VecStorage<N, R, C> {
     /// If `sz` is larger than the current size, additional elements are uninitialized.
     /// If `sz` is smaller than the current size, additional elements are truncated.
     #[inline]
-    pub unsafe fn resize(mut self, sz: usize) -> Vec<N> {
+    pub unsafe fn resize(mut self, sz: usize) -> Vec<T> {
         let len = self.len();
 
         if sz < len {
@@ -93,8 +93,8 @@ impl<N, R: Dim, C: Dim> VecStorage<N, R, C> {
     }
 }
 
-impl<N, R: Dim, C: Dim> Into<Vec<N>> for VecStorage<N, R, C> {
-    fn into(self) -> Vec<N> {
+impl<T, R: Dim, C: Dim> Into<Vec<T>> for VecStorage<T, R, C> {
+    fn into(self) -> Vec<T> {
         self.data
     }
 }
@@ -105,15 +105,15 @@ impl<N, R: Dim, C: Dim> Into<Vec<N>> for VecStorage<N, R, C> {
  * Dynamic − Dynamic
  *
  */
-unsafe impl<N: Scalar, C: Dim> Storage<N, Dynamic, C> for VecStorage<N, Dynamic, C>
+unsafe impl<T: Scalar, C: Dim> Storage<T, Dynamic, C> for VecStorage<T, Dynamic, C>
 where
-    DefaultAllocator: Allocator<N, Dynamic, C, Buffer = Self>,
+    DefaultAllocator: Allocator<T, Dynamic, C, Buffer = Self>,
 {
     type RStride = U1;
     type CStride = Dynamic;
 
     #[inline]
-    fn ptr(&self) -> *const N {
+    fn ptr(&self) -> *const T {
         self.data.as_ptr()
     }
 
@@ -133,36 +133,36 @@ where
     }
 
     #[inline]
-    fn into_owned(self) -> Owned<N, Dynamic, C>
+    fn into_owned(self) -> Owned<T, Dynamic, C>
     where
-        DefaultAllocator: Allocator<N, Dynamic, C>,
+        DefaultAllocator: Allocator<T, Dynamic, C>,
     {
         self
     }
 
     #[inline]
-    fn clone_owned(&self) -> Owned<N, Dynamic, C>
+    fn clone_owned(&self) -> Owned<T, Dynamic, C>
     where
-        DefaultAllocator: Allocator<N, Dynamic, C>,
+        DefaultAllocator: Allocator<T, Dynamic, C>,
     {
         self.clone()
     }
 
     #[inline]
-    fn as_slice(&self) -> &[N] {
+    fn as_slice(&self) -> &[T] {
         &self.data
     }
 }
 
-unsafe impl<N: Scalar, R: DimName> Storage<N, R, Dynamic> for VecStorage<N, R, Dynamic>
+unsafe impl<T: Scalar, R: DimName> Storage<T, R, Dynamic> for VecStorage<T, R, Dynamic>
 where
-    DefaultAllocator: Allocator<N, R, Dynamic, Buffer = Self>,
+    DefaultAllocator: Allocator<T, R, Dynamic, Buffer = Self>,
 {
     type RStride = U1;
     type CStride = R;
 
     #[inline]
-    fn ptr(&self) -> *const N {
+    fn ptr(&self) -> *const T {
         self.data.as_ptr()
     }
 
@@ -182,23 +182,23 @@ where
     }
 
     #[inline]
-    fn into_owned(self) -> Owned<N, R, Dynamic>
+    fn into_owned(self) -> Owned<T, R, Dynamic>
     where
-        DefaultAllocator: Allocator<N, R, Dynamic>,
+        DefaultAllocator: Allocator<T, R, Dynamic>,
     {
         self
     }
 
     #[inline]
-    fn clone_owned(&self) -> Owned<N, R, Dynamic>
+    fn clone_owned(&self) -> Owned<T, R, Dynamic>
     where
-        DefaultAllocator: Allocator<N, R, Dynamic>,
+        DefaultAllocator: Allocator<T, R, Dynamic>,
     {
         self.clone()
     }
 
     #[inline]
-    fn as_slice(&self) -> &[N] {
+    fn as_slice(&self) -> &[T] {
         &self.data
     }
 }
@@ -208,38 +208,38 @@ where
  * StorageMut, ContiguousStorage.
  *
  */
-unsafe impl<N: Scalar, C: Dim> StorageMut<N, Dynamic, C> for VecStorage<N, Dynamic, C>
+unsafe impl<T: Scalar, C: Dim> StorageMut<T, Dynamic, C> for VecStorage<T, Dynamic, C>
 where
-    DefaultAllocator: Allocator<N, Dynamic, C, Buffer = Self>,
+    DefaultAllocator: Allocator<T, Dynamic, C, Buffer = Self>,
 {
     #[inline]
-    fn ptr_mut(&mut self) -> *mut N {
+    fn ptr_mut(&mut self) -> *mut T {
         self.data.as_mut_ptr()
     }
 
     #[inline]
-    fn as_mut_slice(&mut self) -> &mut [N] {
+    fn as_mut_slice(&mut self) -> &mut [T] {
         &mut self.data[..]
     }
 }
 
-unsafe impl<N: Scalar, C: Dim> ContiguousStorage<N, Dynamic, C> for VecStorage<N, Dynamic, C> where
-    DefaultAllocator: Allocator<N, Dynamic, C, Buffer = Self>
+unsafe impl<T: Scalar, C: Dim> ContiguousStorage<T, Dynamic, C> for VecStorage<T, Dynamic, C> where
+    DefaultAllocator: Allocator<T, Dynamic, C, Buffer = Self>
 {
 }
 
-unsafe impl<N: Scalar, C: Dim> ContiguousStorageMut<N, Dynamic, C> for VecStorage<N, Dynamic, C> where
-    DefaultAllocator: Allocator<N, Dynamic, C, Buffer = Self>
+unsafe impl<T: Scalar, C: Dim> ContiguousStorageMut<T, Dynamic, C> for VecStorage<T, Dynamic, C> where
+    DefaultAllocator: Allocator<T, Dynamic, C, Buffer = Self>
 {
 }
 
-impl<N, C1, C2> ReshapableStorage<N, Dynamic, C1, Dynamic, C2> for VecStorage<N, Dynamic, C1>
+impl<T, C1, C2> ReshapableStorage<T, Dynamic, C1, Dynamic, C2> for VecStorage<T, Dynamic, C1>
 where
-    N: Scalar,
+    T: Scalar,
     C1: Dim,
     C2: Dim,
 {
-    type Output = VecStorage<N, Dynamic, C2>;
+    type Output = VecStorage<T, Dynamic, C2>;
 
     fn reshape_generic(self, nrows: Dynamic, ncols: C2) -> Self::Output {
         assert_eq!(nrows.value() * ncols.value(), self.data.len());
@@ -251,13 +251,13 @@ where
     }
 }
 
-impl<N, C1, R2> ReshapableStorage<N, Dynamic, C1, R2, Dynamic> for VecStorage<N, Dynamic, C1>
+impl<T, C1, R2> ReshapableStorage<T, Dynamic, C1, R2, Dynamic> for VecStorage<T, Dynamic, C1>
 where
-    N: Scalar,
+    T: Scalar,
     C1: Dim,
     R2: DimName,
 {
-    type Output = VecStorage<N, R2, Dynamic>;
+    type Output = VecStorage<T, R2, Dynamic>;
 
     fn reshape_generic(self, nrows: R2, ncols: Dynamic) -> Self::Output {
         assert_eq!(nrows.value() * ncols.value(), self.data.len());
@@ -269,28 +269,28 @@ where
     }
 }
 
-unsafe impl<N: Scalar, R: DimName> StorageMut<N, R, Dynamic> for VecStorage<N, R, Dynamic>
+unsafe impl<T: Scalar, R: DimName> StorageMut<T, R, Dynamic> for VecStorage<T, R, Dynamic>
 where
-    DefaultAllocator: Allocator<N, R, Dynamic, Buffer = Self>,
+    DefaultAllocator: Allocator<T, R, Dynamic, Buffer = Self>,
 {
     #[inline]
-    fn ptr_mut(&mut self) -> *mut N {
+    fn ptr_mut(&mut self) -> *mut T {
         self.data.as_mut_ptr()
     }
 
     #[inline]
-    fn as_mut_slice(&mut self) -> &mut [N] {
+    fn as_mut_slice(&mut self) -> &mut [T] {
         &mut self.data[..]
     }
 }
 
-impl<N, R1, C2> ReshapableStorage<N, R1, Dynamic, Dynamic, C2> for VecStorage<N, R1, Dynamic>
+impl<T, R1, C2> ReshapableStorage<T, R1, Dynamic, Dynamic, C2> for VecStorage<T, R1, Dynamic>
 where
-    N: Scalar,
+    T: Scalar,
     R1: DimName,
     C2: Dim,
 {
-    type Output = VecStorage<N, Dynamic, C2>;
+    type Output = VecStorage<T, Dynamic, C2>;
 
     fn reshape_generic(self, nrows: Dynamic, ncols: C2) -> Self::Output {
         assert_eq!(nrows.value() * ncols.value(), self.data.len());
@@ -302,13 +302,13 @@ where
     }
 }
 
-impl<N, R1, R2> ReshapableStorage<N, R1, Dynamic, R2, Dynamic> for VecStorage<N, R1, Dynamic>
+impl<T, R1, R2> ReshapableStorage<T, R1, Dynamic, R2, Dynamic> for VecStorage<T, R1, Dynamic>
 where
-    N: Scalar,
+    T: Scalar,
     R1: DimName,
     R2: DimName,
 {
-    type Output = VecStorage<N, R2, Dynamic>;
+    type Output = VecStorage<T, R2, Dynamic>;
 
     fn reshape_generic(self, nrows: R2, ncols: Dynamic) -> Self::Output {
         assert_eq!(nrows.value() * ncols.value(), self.data.len());
@@ -321,7 +321,7 @@ where
 }
 
 #[cfg(feature = "abomonation-serialize")]
-impl<N: Abomonation, R: Dim, C: Dim> Abomonation for VecStorage<N, R, C> {
+impl<T: Abomonation, R: Dim, C: Dim> Abomonation for VecStorage<T, R, C> {
     unsafe fn entomb<W: Write>(&self, writer: &mut W) -> IOResult<()> {
         self.data.entomb(writer)
     }
@@ -335,17 +335,17 @@ impl<N: Abomonation, R: Dim, C: Dim> Abomonation for VecStorage<N, R, C> {
     }
 }
 
-unsafe impl<N: Scalar, R: DimName> ContiguousStorage<N, R, Dynamic> for VecStorage<N, R, Dynamic> where
-    DefaultAllocator: Allocator<N, R, Dynamic, Buffer = Self>
+unsafe impl<T: Scalar, R: DimName> ContiguousStorage<T, R, Dynamic> for VecStorage<T, R, Dynamic> where
+    DefaultAllocator: Allocator<T, R, Dynamic, Buffer = Self>
 {
 }
 
-unsafe impl<N: Scalar, R: DimName> ContiguousStorageMut<N, R, Dynamic> for VecStorage<N, R, Dynamic> where
-    DefaultAllocator: Allocator<N, R, Dynamic, Buffer = Self>
+unsafe impl<T: Scalar, R: DimName> ContiguousStorageMut<T, R, Dynamic> for VecStorage<T, R, Dynamic> where
+    DefaultAllocator: Allocator<T, R, Dynamic, Buffer = Self>
 {
 }
 
-impl<N, R: Dim> Extend<N> for VecStorage<N, R, Dynamic> {
+impl<T, R: Dim> Extend<T> for VecStorage<T, R, Dynamic> {
     /// Extends the number of columns of the `VecStorage` with elements
     /// from the given iterator.
     ///
@@ -353,7 +353,7 @@ impl<N, R: Dim> Extend<N> for VecStorage<N, R, Dynamic> {
     /// This function panics if the number of elements yielded by the
     /// given iterator is not a multiple of the number of rows of the
     /// `VecStorage`.
-    fn extend<I: IntoIterator<Item = N>>(&mut self, iter: I) {
+    fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) {
         self.data.extend(iter);
         self.ncols = Dynamic::new(self.data.len() / self.nrows.value());
         assert!(self.data.len() % self.nrows.value() == 0,
@@ -361,7 +361,7 @@ impl<N, R: Dim> Extend<N> for VecStorage<N, R, Dynamic> {
     }
 }
 
-impl<'a, N: 'a + Copy, R: Dim> Extend<&'a N> for VecStorage<N, R, Dynamic> {
+impl<'a, T: 'a + Copy, R: Dim> Extend<&'a T> for VecStorage<T, R, Dynamic> {
     /// Extends the number of columns of the `VecStorage` with elements
     /// from the given iterator.
     ///
@@ -369,17 +369,17 @@ impl<'a, N: 'a + Copy, R: Dim> Extend<&'a N> for VecStorage<N, R, Dynamic> {
     /// This function panics if the number of elements yielded by the
     /// given iterator is not a multiple of the number of rows of the
     /// `VecStorage`.
-    fn extend<I: IntoIterator<Item = &'a N>>(&mut self, iter: I) {
+    fn extend<I: IntoIterator<Item = &'a T>>(&mut self, iter: I) {
         self.extend(iter.into_iter().copied())
     }
 }
 
-impl<N, R, RV, SV> Extend<Vector<N, RV, SV>> for VecStorage<N, R, Dynamic>
+impl<T, R, RV, SV> Extend<Vector<T, RV, SV>> for VecStorage<T, R, Dynamic>
 where
-    N: Scalar,
+    T: Scalar,
     R: Dim,
     RV: Dim,
-    SV: Storage<N, RV>,
+    SV: Storage<T, RV>,
     ShapeConstraint: SameNumberOfRows<R, RV>,
 {
     /// Extends the number of columns of the `VecStorage` with vectors
@@ -389,7 +389,7 @@ where
     /// This function panics if the number of rows of each `Vector`
     /// yielded by the iterator is not equal to the number of rows
     /// of this `VecStorage`.
-    fn extend<I: IntoIterator<Item = Vector<N, RV, SV>>>(&mut self, iter: I) {
+    fn extend<I: IntoIterator<Item = Vector<T, RV, SV>>>(&mut self, iter: I) {
         let nrows = self.nrows.value();
         let iter = iter.into_iter();
         let (lower, _upper) = iter.size_hint();
@@ -402,10 +402,10 @@ where
     }
 }
 
-impl<N> Extend<N> for VecStorage<N, Dynamic, U1> {
+impl<T> Extend<T> for VecStorage<T, Dynamic, U1> {
     /// Extends the number of rows of the `VecStorage` with elements
     /// from the given iterator.
-    fn extend<I: IntoIterator<Item = N>>(&mut self, iter: I) {
+    fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) {
         self.data.extend(iter);
         self.nrows = Dynamic::new(self.data.len());
     }
diff --git a/src/debug/random_orthogonal.rs b/src/debug/random_orthogonal.rs
index fc740dc2..c9684238 100644
--- a/src/debug/random_orthogonal.rs
+++ b/src/debug/random_orthogonal.rs
@@ -4,38 +4,38 @@ use crate::base::storage::Owned;
 use quickcheck::{Arbitrary, Gen};
 
 use crate::base::allocator::Allocator;
-use crate::base::dimension::{Dim, Dynamic, U2};
+use crate::base::dimension::{Dim, Dynamic};
 use crate::base::Scalar;
-use crate::base::{DefaultAllocator, MatrixN};
+use crate::base::{DefaultAllocator, OMatrix};
 use crate::linalg::givens::GivensRotation;
 use simba::scalar::ComplexField;
 
 /// A random orthogonal matrix.
 #[derive(Clone, Debug)]
-pub struct RandomOrthogonal<N: Scalar, D: Dim = Dynamic>
+pub struct RandomOrthogonal<T: Scalar, D: Dim = Dynamic>
 where
-    DefaultAllocator: Allocator<N, D, D>,
+    DefaultAllocator: Allocator<T, D, D>,
 {
-    m: MatrixN<N, D>,
+    m: OMatrix<T, D, D>,
 }
 
-impl<N: ComplexField, D: Dim> RandomOrthogonal<N, D>
+impl<T: ComplexField, D: Dim> RandomOrthogonal<T, D>
 where
-    DefaultAllocator: Allocator<N, D, D>,
+    DefaultAllocator: Allocator<T, D, D>,
 {
     /// Retrieve the generated matrix.
-    pub fn unwrap(self) -> MatrixN<N, D> {
+    pub fn unwrap(self) -> OMatrix<T, D, D> {
         self.m
     }
 
     /// Creates a new random orthogonal matrix from its dimension and a random reals generators.
-    pub fn new<Rand: FnMut() -> N>(dim: D, mut rand: Rand) -> Self {
-        let mut res = MatrixN::identity_generic(dim, dim);
+    pub fn new<Rand: FnMut() -> T>(dim: D, mut rand: Rand) -> Self {
+        let mut res = OMatrix::identity_generic(dim, dim);
 
         // Create an orthogonal matrix by composing random Givens rotations rotations.
         for i in 0..dim.value() - 1 {
             let rot = GivensRotation::new(rand(), rand()).0;
-            rot.rotate(&mut res.fixed_rows_mut::<U2>(i));
+            rot.rotate(&mut res.fixed_rows_mut::<2>(i));
         }
 
         RandomOrthogonal { m: res }
@@ -43,13 +43,13 @@ where
 }
 
 #[cfg(feature = "arbitrary")]
-impl<N: ComplexField + Arbitrary + Send, D: Dim> Arbitrary for RandomOrthogonal<N, D>
+impl<T: ComplexField + Arbitrary + Send, D: Dim> Arbitrary for RandomOrthogonal<T, D>
 where
-    DefaultAllocator: Allocator<N, D, D>,
-    Owned<N, D, D>: Clone + Send,
+    DefaultAllocator: Allocator<T, D, D>,
+    Owned<T, D, D>: Clone + Send,
 {
     fn arbitrary(g: &mut Gen) -> Self {
         let dim = D::try_to_usize().unwrap_or(1 + usize::arbitrary(g) % 50);
-        Self::new(D::from_usize(dim), || N::arbitrary(g))
+        Self::new(D::from_usize(dim), || T::arbitrary(g))
     }
 }
diff --git a/src/debug/random_sdp.rs b/src/debug/random_sdp.rs
index fa2ef118..a915f2fc 100644
--- a/src/debug/random_sdp.rs
+++ b/src/debug/random_sdp.rs
@@ -6,38 +6,38 @@ use quickcheck::{Arbitrary, Gen};
 use crate::base::allocator::Allocator;
 use crate::base::dimension::{Dim, Dynamic};
 use crate::base::Scalar;
-use crate::base::{DefaultAllocator, MatrixN};
+use crate::base::{DefaultAllocator, OMatrix};
 use simba::scalar::ComplexField;
 
 use crate::debug::RandomOrthogonal;
 
 /// A random, well-conditioned, symmetric definite-positive matrix.
 #[derive(Clone, Debug)]
-pub struct RandomSDP<N: Scalar, D: Dim = Dynamic>
+pub struct RandomSDP<T: Scalar, D: Dim = Dynamic>
 where
-    DefaultAllocator: Allocator<N, D, D>,
+    DefaultAllocator: Allocator<T, D, D>,
 {
-    m: MatrixN<N, D>,
+    m: OMatrix<T, D, D>,
 }
 
-impl<N: ComplexField, D: Dim> RandomSDP<N, D>
+impl<T: ComplexField, D: Dim> RandomSDP<T, D>
 where
-    DefaultAllocator: Allocator<N, D, D>,
+    DefaultAllocator: Allocator<T, D, D>,
 {
     /// Retrieve the generated matrix.
-    pub fn unwrap(self) -> MatrixN<N, D> {
+    pub fn unwrap(self) -> OMatrix<T, D, D> {
         self.m
     }
 
     /// Creates a new well conditioned symmetric definite-positive matrix from its dimension and a
     /// random reals generators.
-    pub fn new<Rand: FnMut() -> N>(dim: D, mut rand: Rand) -> Self {
+    pub fn new<Rand: FnMut() -> T>(dim: D, mut rand: Rand) -> Self {
         let mut m = RandomOrthogonal::new(dim, || rand()).unwrap();
         let mt = m.adjoint();
 
         for i in 0..dim.value() {
             let mut col = m.column_mut(i);
-            let eigenval = N::one() + N::from_real(rand().modulus());
+            let eigenval = T::one() + T::from_real(rand().modulus());
             col *= eigenval;
         }
 
@@ -46,13 +46,13 @@ where
 }
 
 #[cfg(feature = "arbitrary")]
-impl<N: ComplexField + Arbitrary + Send, D: Dim> Arbitrary for RandomSDP<N, D>
+impl<T: ComplexField + Arbitrary + Send, D: Dim> Arbitrary for RandomSDP<T, D>
 where
-    DefaultAllocator: Allocator<N, D, D>,
-    Owned<N, D, D>: Clone + Send,
+    DefaultAllocator: Allocator<T, D, D>,
+    Owned<T, D, D>: Clone + Send,
 {
     fn arbitrary(g: &mut Gen) -> Self {
         let dim = D::try_to_usize().unwrap_or(1 + usize::arbitrary(g) % 50);
-        Self::new(D::from_usize(dim), || N::arbitrary(g))
+        Self::new(D::from_usize(dim), || T::arbitrary(g))
     }
 }
diff --git a/src/geometry/abstract_rotation.rs b/src/geometry/abstract_rotation.rs
index 52471851..4bbabea2 100644
--- a/src/geometry/abstract_rotation.rs
+++ b/src/geometry/abstract_rotation.rs
@@ -1,11 +1,10 @@
-use crate::allocator::Allocator;
 use crate::geometry::{Rotation, UnitComplex, UnitQuaternion};
-use crate::{DefaultAllocator, DimName, Point, Scalar, SimdRealField, Unit, VectorN, U2, U3};
+use crate::{Const, OVector, Point, SVector, Scalar, SimdRealField, Unit};
 
 use simba::scalar::ClosedMul;
 
 /// Trait implemented by rotations that can be used inside of an `Isometry` or `Similarity`.
-pub trait AbstractRotation<N: Scalar, D: DimName>: PartialEq + ClosedMul + Clone {
+pub trait AbstractRotation<T: Scalar, const D: usize>: PartialEq + ClosedMul + Clone {
     /// The rotation identity.
     fn identity() -> Self;
     /// The rotation inverse.
@@ -13,34 +12,22 @@ pub trait AbstractRotation<N: Scalar, D: DimName>: PartialEq + ClosedMul + Clone
     /// Change `self` to its inverse.
     fn inverse_mut(&mut self);
     /// Apply the rotation to the given vector.
-    fn transform_vector(&self, v: &VectorN<N, D>) -> VectorN<N, D>
-    where
-        DefaultAllocator: Allocator<N, D>;
+    fn transform_vector(&self, v: &SVector<T, D>) -> SVector<T, D>;
     /// Apply the rotation to the given point.
-    fn transform_point(&self, p: &Point<N, D>) -> Point<N, D>
-    where
-        DefaultAllocator: Allocator<N, D>;
+    fn transform_point(&self, p: &Point<T, D>) -> Point<T, D>;
     /// Apply the inverse rotation to the given vector.
-    fn inverse_transform_vector(&self, v: &VectorN<N, D>) -> VectorN<N, D>
-    where
-        DefaultAllocator: Allocator<N, D>;
+    fn inverse_transform_vector(&self, v: &OVector<T, Const<D>>) -> OVector<T, Const<D>>;
     /// Apply the inverse rotation to the given unit vector.
-    fn inverse_transform_unit_vector(&self, v: &Unit<VectorN<N, D>>) -> Unit<VectorN<N, D>>
-    where
-        DefaultAllocator: Allocator<N, D>,
-    {
+    fn inverse_transform_unit_vector(&self, v: &Unit<SVector<T, D>>) -> Unit<SVector<T, D>> {
         Unit::new_unchecked(self.inverse_transform_vector(&**v))
     }
     /// Apply the inverse rotation to the given point.
-    fn inverse_transform_point(&self, p: &Point<N, D>) -> Point<N, D>
-    where
-        DefaultAllocator: Allocator<N, D>;
+    fn inverse_transform_point(&self, p: &Point<T, D>) -> Point<T, D>;
 }
 
-impl<N: SimdRealField, D: DimName> AbstractRotation<N, D> for Rotation<N, D>
+impl<T: SimdRealField, const D: usize> AbstractRotation<T, D> for Rotation<T, D>
 where
-    N::Element: SimdRealField,
-    DefaultAllocator: Allocator<N, D, D>,
+    T::Element: SimdRealField,
 {
     #[inline]
     fn identity() -> Self {
@@ -58,49 +45,34 @@ where
     }
 
     #[inline]
-    fn transform_vector(&self, v: &VectorN<N, D>) -> VectorN<N, D>
-    where
-        DefaultAllocator: Allocator<N, D>,
-    {
+    fn transform_vector(&self, v: &SVector<T, D>) -> SVector<T, D> {
         self * v
     }
 
     #[inline]
-    fn transform_point(&self, p: &Point<N, D>) -> Point<N, D>
-    where
-        DefaultAllocator: Allocator<N, D>,
-    {
+    fn transform_point(&self, p: &Point<T, D>) -> Point<T, D> {
         self * p
     }
 
     #[inline]
-    fn inverse_transform_vector(&self, v: &VectorN<N, D>) -> VectorN<N, D>
-    where
-        DefaultAllocator: Allocator<N, D>,
-    {
+    fn inverse_transform_vector(&self, v: &SVector<T, D>) -> SVector<T, D> {
         self.inverse_transform_vector(v)
     }
 
     #[inline]
-    fn inverse_transform_unit_vector(&self, v: &Unit<VectorN<N, D>>) -> Unit<VectorN<N, D>>
-    where
-        DefaultAllocator: Allocator<N, D>,
-    {
+    fn inverse_transform_unit_vector(&self, v: &Unit<SVector<T, D>>) -> Unit<SVector<T, D>> {
         self.inverse_transform_unit_vector(v)
     }
 
     #[inline]
-    fn inverse_transform_point(&self, p: &Point<N, D>) -> Point<N, D>
-    where
-        DefaultAllocator: Allocator<N, D>,
-    {
+    fn inverse_transform_point(&self, p: &Point<T, D>) -> Point<T, D> {
         self.inverse_transform_point(p)
     }
 }
 
-impl<N: SimdRealField> AbstractRotation<N, U3> for UnitQuaternion<N>
+impl<T: SimdRealField> AbstractRotation<T, 3> for UnitQuaternion<T>
 where
-    N::Element: SimdRealField,
+    T::Element: SimdRealField,
 {
     #[inline]
     fn identity() -> Self {
@@ -118,29 +90,29 @@ where
     }
 
     #[inline]
-    fn transform_vector(&self, v: &VectorN<N, U3>) -> VectorN<N, U3> {
+    fn transform_vector(&self, v: &SVector<T, 3>) -> SVector<T, 3> {
         self * v
     }
 
     #[inline]
-    fn transform_point(&self, p: &Point<N, U3>) -> Point<N, U3> {
+    fn transform_point(&self, p: &Point<T, 3>) -> Point<T, 3> {
         self * p
     }
 
     #[inline]
-    fn inverse_transform_vector(&self, v: &VectorN<N, U3>) -> VectorN<N, U3> {
+    fn inverse_transform_vector(&self, v: &SVector<T, 3>) -> SVector<T, 3> {
         self.inverse_transform_vector(v)
     }
 
     #[inline]
-    fn inverse_transform_point(&self, p: &Point<N, U3>) -> Point<N, U3> {
+    fn inverse_transform_point(&self, p: &Point<T, 3>) -> Point<T, 3> {
         self.inverse_transform_point(p)
     }
 }
 
-impl<N: SimdRealField> AbstractRotation<N, U2> for UnitComplex<N>
+impl<T: SimdRealField> AbstractRotation<T, 2> for UnitComplex<T>
 where
-    N::Element: SimdRealField,
+    T::Element: SimdRealField,
 {
     #[inline]
     fn identity() -> Self {
@@ -158,22 +130,22 @@ where
     }
 
     #[inline]
-    fn transform_vector(&self, v: &VectorN<N, U2>) -> VectorN<N, U2> {
+    fn transform_vector(&self, v: &SVector<T, 2>) -> SVector<T, 2> {
         self * v
     }
 
     #[inline]
-    fn transform_point(&self, p: &Point<N, U2>) -> Point<N, U2> {
+    fn transform_point(&self, p: &Point<T, 2>) -> Point<T, 2> {
         self * p
     }
 
     #[inline]
-    fn inverse_transform_vector(&self, v: &VectorN<N, U2>) -> VectorN<N, U2> {
+    fn inverse_transform_vector(&self, v: &SVector<T, 2>) -> SVector<T, 2> {
         self.inverse_transform_vector(v)
     }
 
     #[inline]
-    fn inverse_transform_point(&self, p: &Point<N, U2>) -> Point<N, U2> {
+    fn inverse_transform_point(&self, p: &Point<T, 2>) -> Point<T, 2> {
         self.inverse_transform_point(p)
     }
 }
diff --git a/src/geometry/dual_quaternion.rs b/src/geometry/dual_quaternion.rs
index b11e7364..471e08bf 100644
--- a/src/geometry/dual_quaternion.rs
+++ b/src/geometry/dual_quaternion.rs
@@ -1,6 +1,6 @@
 use crate::{
-    Isometry3, Matrix4, Normed, Point3, Quaternion, Scalar, SimdRealField, Translation3, Unit,
-    UnitQuaternion, Vector3, VectorN, Zero, U8,
+    Isometry3, Matrix4, Normed, OVector, Point3, Quaternion, Scalar, SimdRealField, Translation3,
+    Unit, UnitQuaternion, Vector3, Zero, U8,
 };
 use approx::{AbsDiffEq, RelativeEq, UlpsEq};
 #[cfg(feature = "serde-serialize")]
@@ -36,14 +36,14 @@ use simba::scalar::{ClosedNeg, RealField};
 ///  See https://github.com/dimforge/nalgebra/issues/487
 #[repr(C)]
 #[derive(Debug, Eq, PartialEq, Copy, Clone)]
-pub struct DualQuaternion<N: Scalar> {
+pub struct DualQuaternion<T: Scalar> {
     /// The real component of the quaternion
-    pub real: Quaternion<N>,
+    pub real: Quaternion<T>,
     /// The dual component of the quaternion
-    pub dual: Quaternion<N>,
+    pub dual: Quaternion<T>,
 }
 
-impl<N: Scalar + Zero> Default for DualQuaternion<N> {
+impl<T: Scalar + Zero> Default for DualQuaternion<T> {
     fn default() -> Self {
         Self {
             real: Quaternion::default(),
@@ -52,9 +52,9 @@ impl<N: Scalar + Zero> Default for DualQuaternion<N> {
     }
 }
 
-impl<N: SimdRealField> DualQuaternion<N>
+impl<T: SimdRealField> DualQuaternion<T>
 where
-    N::Element: SimdRealField,
+    T::Element: SimdRealField,
 {
     /// Normalizes this quaternion.
     ///
@@ -93,7 +93,7 @@ where
     /// relative_eq!(dq.real.norm(), 1.0);
     /// ```
     #[inline]
-    pub fn normalize_mut(&mut self) -> N {
+    pub fn normalize_mut(&mut self) -> T {
         let real_norm = self.real.norm();
         self.real /= real_norm;
         self.dual /= real_norm;
@@ -168,7 +168,7 @@ where
     #[must_use = "Did you mean to use try_inverse_mut()?"]
     pub fn try_inverse(&self) -> Option<Self>
     where
-        N: RealField,
+        T: RealField,
     {
         let mut res = *self;
         if res.try_inverse_mut() {
@@ -200,7 +200,7 @@ where
     #[inline]
     pub fn try_inverse_mut(&mut self) -> bool
     where
-        N: RealField,
+        T: RealField,
     {
         let inverted = self.real.try_inverse_mut();
         if inverted {
@@ -232,15 +232,15 @@ where
     /// ));
     /// ```
     #[inline]
-    pub fn lerp(&self, other: &Self, t: N) -> Self {
-        self * (N::one() - t) + other * t
+    pub fn lerp(&self, other: &Self, t: T) -> Self {
+        self * (T::one() - t) + other * t
     }
 }
 
 #[cfg(feature = "serde-serialize")]
-impl<N: SimdRealField> Serialize for DualQuaternion<N>
+impl<T: SimdRealField> Serialize for DualQuaternion<T>
 where
-    N: Serialize,
+    T: Serialize,
 {
     fn serialize<S>(&self, serializer: S) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
     where
@@ -251,17 +251,17 @@ where
 }
 
 #[cfg(feature = "serde-serialize")]
-impl<'a, N: SimdRealField> Deserialize<'a> for DualQuaternion<N>
+impl<'a, T: SimdRealField> Deserialize<'a> for DualQuaternion<T>
 where
-    N: Deserialize<'a>,
+    T: Deserialize<'a>,
 {
     fn deserialize<Des>(deserializer: Des) -> Result<Self, Des::Error>
     where
         Des: Deserializer<'a>,
     {
-        type Dq<N> = [N; 8];
+        type Dq<T> = [T; 8];
 
-        let dq: Dq<N> = Dq::<N>::deserialize(deserializer)?;
+        let dq: Dq<T> = Dq::<T>::deserialize(deserializer)?;
 
         Ok(Self {
             real: Quaternion::new(dq[3], dq[0], dq[1], dq[2]),
@@ -270,18 +270,18 @@ where
     }
 }
 
-impl<N: RealField> DualQuaternion<N> {
-    fn to_vector(&self) -> VectorN<N, U8> {
+impl<T: RealField> DualQuaternion<T> {
+    fn to_vector(&self) -> OVector<T, U8> {
         self.as_ref().clone().into()
     }
 }
 
-impl<N: RealField + AbsDiffEq<Epsilon = N>> AbsDiffEq for DualQuaternion<N> {
-    type Epsilon = N;
+impl<T: RealField + AbsDiffEq<Epsilon = T>> AbsDiffEq for DualQuaternion<T> {
+    type Epsilon = T;
 
     #[inline]
     fn default_epsilon() -> Self::Epsilon {
-        N::default_epsilon()
+        T::default_epsilon()
     }
 
     #[inline]
@@ -292,10 +292,10 @@ impl<N: RealField + AbsDiffEq<Epsilon = N>> AbsDiffEq for DualQuaternion<N> {
     }
 }
 
-impl<N: RealField + RelativeEq<Epsilon = N>> RelativeEq for DualQuaternion<N> {
+impl<T: RealField + RelativeEq<Epsilon = T>> RelativeEq for DualQuaternion<T> {
     #[inline]
     fn default_max_relative() -> Self::Epsilon {
-        N::default_max_relative()
+        T::default_max_relative()
     }
 
     #[inline]
@@ -311,10 +311,10 @@ impl<N: RealField + RelativeEq<Epsilon = N>> RelativeEq for DualQuaternion<N> {
     }
 }
 
-impl<N: RealField + UlpsEq<Epsilon = N>> UlpsEq for DualQuaternion<N> {
+impl<T: RealField + UlpsEq<Epsilon = T>> UlpsEq for DualQuaternion<T> {
     #[inline]
     fn default_max_ulps() -> u32 {
-        N::default_max_ulps()
+        T::default_max_ulps()
     }
 
     #[inline]
@@ -326,27 +326,27 @@ impl<N: RealField + UlpsEq<Epsilon = N>> UlpsEq for DualQuaternion<N> {
 }
 
 /// A unit quaternions. May be used to represent a rotation followed by a translation.
-pub type UnitDualQuaternion<N> = Unit<DualQuaternion<N>>;
+pub type UnitDualQuaternion<T> = Unit<DualQuaternion<T>>;
 
-impl<N: Scalar + ClosedNeg + PartialEq + SimdRealField> PartialEq for UnitDualQuaternion<N> {
+impl<T: Scalar + ClosedNeg + PartialEq + SimdRealField> PartialEq for UnitDualQuaternion<T> {
     #[inline]
     fn eq(&self, rhs: &Self) -> bool {
         self.as_ref().eq(rhs.as_ref())
     }
 }
 
-impl<N: Scalar + ClosedNeg + Eq + SimdRealField> Eq for UnitDualQuaternion<N> {}
+impl<T: Scalar + ClosedNeg + Eq + SimdRealField> Eq for UnitDualQuaternion<T> {}
 
-impl<N: SimdRealField> Normed for DualQuaternion<N> {
-    type Norm = N::SimdRealField;
+impl<T: SimdRealField> Normed for DualQuaternion<T> {
+    type Norm = T::SimdRealField;
 
     #[inline]
-    fn norm(&self) -> N::SimdRealField {
+    fn norm(&self) -> T::SimdRealField {
         self.real.norm()
     }
 
     #[inline]
-    fn norm_squared(&self) -> N::SimdRealField {
+    fn norm_squared(&self) -> T::SimdRealField {
         self.real.norm_squared()
     }
 
@@ -363,9 +363,9 @@ impl<N: SimdRealField> Normed for DualQuaternion<N> {
     }
 }
 
-impl<N: SimdRealField> UnitDualQuaternion<N>
+impl<T: SimdRealField> UnitDualQuaternion<T>
 where
-    N::Element: SimdRealField,
+    T::Element: SimdRealField,
 {
     /// The underlying dual quaternion.
     ///
@@ -381,7 +381,7 @@ where
     /// ));
     /// ```
     #[inline]
-    pub fn dual_quaternion(&self) -> &DualQuaternion<N> {
+    pub fn dual_quaternion(&self) -> &DualQuaternion<T> {
         self.as_ref()
     }
 
@@ -518,7 +518,7 @@ where
     /// );
     /// ```
     #[inline]
-    pub fn lerp(&self, other: &Self, t: N) -> DualQuaternion<N> {
+    pub fn lerp(&self, other: &Self, t: T) -> DualQuaternion<T> {
         self.as_ref().lerp(other.as_ref(), t)
     }
 
@@ -546,7 +546,7 @@ where
     /// ), epsilon = 1.0e-6);
     /// ```
     #[inline]
-    pub fn nlerp(&self, other: &Self, t: N) -> Self {
+    pub fn nlerp(&self, other: &Self, t: T) -> Self {
         let mut res = self.lerp(other, t);
         let _ = res.normalize_mut();
 
@@ -581,11 +581,11 @@ where
     /// );
     /// assert_relative_eq!(dq.translation().vector.y, 3.0, epsilon = 1.0e-6);
     #[inline]
-    pub fn sclerp(&self, other: &Self, t: N) -> Self
+    pub fn sclerp(&self, other: &Self, t: T) -> Self
     where
-        N: RealField,
+        T: RealField,
     {
-        self.try_sclerp(other, t, N::default_epsilon())
+        self.try_sclerp(other, t, T::default_epsilon())
             .expect("DualQuaternion sclerp: ambiguous configuration.")
     }
 
@@ -600,18 +600,18 @@ where
     /// * `epsilon`: the value below which the sinus of the angle separating both quaternion
     /// must be to return `None`.
     #[inline]
-    pub fn try_sclerp(&self, other: &Self, t: N, epsilon: N) -> Option<Self>
+    pub fn try_sclerp(&self, other: &Self, t: T, epsilon: T) -> Option<Self>
     where
-        N: RealField,
+        T: RealField,
     {
-        let two = N::one() + N::one();
-        let half = N::one() / two;
+        let two = T::one() + T::one();
+        let half = T::one() / two;
 
         // Invert one of the quaternions if we've got a longest-path
         // interpolation.
         let other = {
             let dot_product = self.as_ref().real.coords.dot(&other.as_ref().real.coords);
-            if dot_product < N::zero() {
+            if dot_product < T::zero() {
                 -other.clone()
             } else {
                 other.clone()
@@ -620,11 +620,11 @@ where
 
         let difference = self.as_ref().conjugate() * other.as_ref();
         let norm_squared = difference.real.vector().norm_squared();
-        if relative_eq!(norm_squared, N::zero(), epsilon = epsilon) {
+        if relative_eq!(norm_squared, T::zero(), epsilon = epsilon) {
             return None;
         }
 
-        let inverse_norm_squared = N::one() / norm_squared;
+        let inverse_norm_squared = T::one() / norm_squared;
         let inverse_norm = inverse_norm_squared.sqrt();
 
         let mut angle = two * difference.real.scalar().acos();
@@ -667,7 +667,7 @@ where
     /// );
     /// ```
     #[inline]
-    pub fn rotation(&self) -> UnitQuaternion<N> {
+    pub fn rotation(&self) -> UnitQuaternion<T> {
         Unit::new_unchecked(self.as_ref().real)
     }
 
@@ -686,8 +686,8 @@ where
     /// );
     /// ```
     #[inline]
-    pub fn translation(&self) -> Translation3<N> {
-        let two = N::one() + N::one();
+    pub fn translation(&self) -> Translation3<T> {
+        let two = T::one() + T::one();
         Translation3::from(
             ((self.as_ref().dual * self.as_ref().real.conjugate()) * two)
                 .vector()
@@ -712,7 +712,7 @@ where
     /// assert_relative_eq!(iso.translation.vector, translation, epsilon = 1.0e-6);
     /// ```
     #[inline]
-    pub fn to_isometry(&self) -> Isometry3<N> {
+    pub fn to_isometry(&self) -> Isometry3<T> {
         Isometry3::from_parts(self.translation(), self.rotation())
     }
 
@@ -735,7 +735,7 @@ where
     /// );
     /// ```
     #[inline]
-    pub fn transform_point(&self, pt: &Point3<N>) -> Point3<N> {
+    pub fn transform_point(&self, pt: &Point3<T>) -> Point3<T> {
         self * pt
     }
 
@@ -758,7 +758,7 @@ where
     /// );
     /// ```
     #[inline]
-    pub fn transform_vector(&self, v: &Vector3<N>) -> Vector3<N> {
+    pub fn transform_vector(&self, v: &Vector3<T>) -> Vector3<T> {
         self * v
     }
 
@@ -781,7 +781,7 @@ where
     /// );
     /// ```
     #[inline]
-    pub fn inverse_transform_point(&self, pt: &Point3<N>) -> Point3<N> {
+    pub fn inverse_transform_point(&self, pt: &Point3<T>) -> Point3<T> {
         self.inverse() * pt
     }
 
@@ -805,7 +805,7 @@ where
     /// );
     /// ```
     #[inline]
-    pub fn inverse_transform_vector(&self, v: &Vector3<N>) -> Vector3<N> {
+    pub fn inverse_transform_vector(&self, v: &Vector3<T>) -> Vector3<T> {
         self.inverse() * v
     }
 
@@ -830,14 +830,14 @@ where
     /// );
     /// ```
     #[inline]
-    pub fn inverse_transform_unit_vector(&self, v: &Unit<Vector3<N>>) -> Unit<Vector3<N>> {
+    pub fn inverse_transform_unit_vector(&self, v: &Unit<Vector3<T>>) -> Unit<Vector3<T>> {
         self.inverse() * v
     }
 }
 
-impl<N: SimdRealField + RealField> UnitDualQuaternion<N>
+impl<T: SimdRealField + RealField> UnitDualQuaternion<T>
 where
-    N::Element: SimdRealField,
+    T::Element: SimdRealField,
 {
     /// Converts this unit dual quaternion interpreted as an isometry
     /// into its equivalent homogeneous transformation matrix.
@@ -857,18 +857,18 @@ where
     /// assert_relative_eq!(dq.to_homogeneous(), expected, epsilon = 1.0e-6);
     /// ```
     #[inline]
-    pub fn to_homogeneous(&self) -> Matrix4<N> {
+    pub fn to_homogeneous(&self) -> Matrix4<T> {
         self.to_isometry().to_homogeneous()
     }
 }
 
-impl<N: RealField> Default for UnitDualQuaternion<N> {
+impl<T: RealField> Default for UnitDualQuaternion<T> {
     fn default() -> Self {
         Self::identity()
     }
 }
 
-impl<N: RealField + fmt::Display> fmt::Display for UnitDualQuaternion<N> {
+impl<T: RealField + fmt::Display> fmt::Display for UnitDualQuaternion<T> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         if let Some(axis) = self.rotation().axis() {
             let axis = axis.into_inner();
@@ -892,12 +892,12 @@ impl<N: RealField + fmt::Display> fmt::Display for UnitDualQuaternion<N> {
     }
 }
 
-impl<N: RealField + AbsDiffEq<Epsilon = N>> AbsDiffEq for UnitDualQuaternion<N> {
-    type Epsilon = N;
+impl<T: RealField + AbsDiffEq<Epsilon = T>> AbsDiffEq for UnitDualQuaternion<T> {
+    type Epsilon = T;
 
     #[inline]
     fn default_epsilon() -> Self::Epsilon {
-        N::default_epsilon()
+        T::default_epsilon()
     }
 
     #[inline]
@@ -906,10 +906,10 @@ impl<N: RealField + AbsDiffEq<Epsilon = N>> AbsDiffEq for UnitDualQuaternion<N>
     }
 }
 
-impl<N: RealField + RelativeEq<Epsilon = N>> RelativeEq for UnitDualQuaternion<N> {
+impl<T: RealField + RelativeEq<Epsilon = T>> RelativeEq for UnitDualQuaternion<T> {
     #[inline]
     fn default_max_relative() -> Self::Epsilon {
-        N::default_max_relative()
+        T::default_max_relative()
     }
 
     #[inline]
@@ -924,10 +924,10 @@ impl<N: RealField + RelativeEq<Epsilon = N>> RelativeEq for UnitDualQuaternion<N
     }
 }
 
-impl<N: RealField + UlpsEq<Epsilon = N>> UlpsEq for UnitDualQuaternion<N> {
+impl<T: RealField + UlpsEq<Epsilon = T>> UlpsEq for UnitDualQuaternion<T> {
     #[inline]
     fn default_max_ulps() -> u32 {
-        N::default_max_ulps()
+        T::default_max_ulps()
     }
 
     #[inline]
diff --git a/src/geometry/dual_quaternion_construction.rs b/src/geometry/dual_quaternion_construction.rs
index 047a9a2b..be274cf4 100644
--- a/src/geometry/dual_quaternion_construction.rs
+++ b/src/geometry/dual_quaternion_construction.rs
@@ -7,7 +7,7 @@ use num::{One, Zero};
 use quickcheck::{Arbitrary, Gen};
 use simba::scalar::SupersetOf;
 
-impl<N: Scalar> DualQuaternion<N> {
+impl<T: Scalar> DualQuaternion<T> {
     /// Creates a dual quaternion from its rotation and translation components.
     ///
     /// # Example
@@ -20,7 +20,7 @@ impl<N: Scalar> DualQuaternion<N> {
     /// assert_eq!(dq.real.w, 1.0);
     /// ```
     #[inline]
-    pub fn from_real_and_dual(real: Quaternion<N>, dual: Quaternion<N>) -> Self {
+    pub fn from_real_and_dual(real: Quaternion<T>, dual: Quaternion<T>) -> Self {
         Self { real, dual }
     }
 
@@ -43,11 +43,11 @@ impl<N: Scalar> DualQuaternion<N> {
     #[inline]
     pub fn identity() -> Self
     where
-        N: SimdRealField,
+        T: SimdRealField,
     {
         Self::from_real_and_dual(
-            Quaternion::from_real(N::one()),
-            Quaternion::from_real(N::zero()),
+            Quaternion::from_real(T::one()),
+            Quaternion::from_real(T::zero()),
         )
     }
 
@@ -68,9 +68,9 @@ impl<N: Scalar> DualQuaternion<N> {
     }
 }
 
-impl<N: SimdRealField> DualQuaternion<N>
+impl<T: SimdRealField> DualQuaternion<T>
 where
-    N::Element: SimdRealField,
+    T::Element: SimdRealField,
 {
     /// Creates a dual quaternion from only its real part, with no translation
     /// component.
@@ -85,7 +85,7 @@ where
     /// assert_eq!(dq.dual.w, 0.0);
     /// ```
     #[inline]
-    pub fn from_real(real: Quaternion<N>) -> Self {
+    pub fn from_real(real: Quaternion<T>) -> Self {
         Self {
             real,
             dual: Quaternion::zero(),
@@ -93,9 +93,9 @@ where
     }
 }
 
-impl<N: SimdRealField> One for DualQuaternion<N>
+impl<T: SimdRealField> One for DualQuaternion<T>
 where
-    N::Element: SimdRealField,
+    T::Element: SimdRealField,
 {
     #[inline]
     fn one() -> Self {
@@ -103,9 +103,9 @@ where
     }
 }
 
-impl<N: SimdRealField> Zero for DualQuaternion<N>
+impl<T: SimdRealField> Zero for DualQuaternion<T>
 where
-    N::Element: SimdRealField,
+    T::Element: SimdRealField,
 {
     #[inline]
     fn zero() -> Self {
@@ -119,10 +119,10 @@ where
 }
 
 #[cfg(feature = "arbitrary")]
-impl<N> Arbitrary for DualQuaternion<N>
+impl<T> Arbitrary for DualQuaternion<T>
 where
-    N: SimdRealField + Arbitrary + Send,
-    N::Element: SimdRealField,
+    T: SimdRealField + Arbitrary + Send,
+    T::Element: SimdRealField,
 {
     #[inline]
     fn arbitrary(rng: &mut Gen) -> Self {
@@ -130,7 +130,7 @@ where
     }
 }
 
-impl<N: SimdRealField> UnitDualQuaternion<N> {
+impl<T: SimdRealField> UnitDualQuaternion<T> {
     /// The unit dual quaternion multiplicative identity, which also represents
     /// the identity transformation as an isometry.
     ///
@@ -164,9 +164,9 @@ impl<N: SimdRealField> UnitDualQuaternion<N> {
     }
 }
 
-impl<N: SimdRealField> UnitDualQuaternion<N>
+impl<T: SimdRealField> UnitDualQuaternion<T>
 where
-    N::Element: SimdRealField,
+    T::Element: SimdRealField,
 {
     /// Return a dual quaternion representing the translation and orientation
     /// given by the provided rotation quaternion and translation vector.
@@ -183,11 +183,11 @@ where
     /// assert_relative_eq!(dq * point, Point3::new(1.0, 0.0, 2.0), epsilon = 1.0e-6);
     /// ```
     #[inline]
-    pub fn from_parts(translation: Translation3<N>, rotation: UnitQuaternion<N>) -> Self {
-        let half: N = crate::convert(0.5f64);
+    pub fn from_parts(translation: Translation3<T>, rotation: UnitQuaternion<T>) -> Self {
+        let half: T = crate::convert(0.5f64);
         UnitDualQuaternion::new_unchecked(DualQuaternion {
             real: rotation.clone().into_inner(),
-            dual: Quaternion::from_parts(N::zero(), translation.vector)
+            dual: Quaternion::from_parts(T::zero(), translation.vector)
                 * rotation.clone().into_inner()
                 * half,
         })
@@ -209,7 +209,7 @@ where
     /// assert_relative_eq!(dq * point, iso * point, epsilon = 1.0e-6);
     /// ```
     #[inline]
-    pub fn from_isometry(isometry: &Isometry3<N>) -> Self {
+    pub fn from_isometry(isometry: &Isometry3<T>) -> Self {
         UnitDualQuaternion::from_parts(isometry.translation, isometry.rotation)
     }
 
@@ -227,14 +227,14 @@ where
     /// assert_eq!(dq.as_ref().dual.norm(), 0.0);
     /// ```
     #[inline]
-    pub fn from_rotation(rotation: UnitQuaternion<N>) -> Self {
+    pub fn from_rotation(rotation: UnitQuaternion<T>) -> Self {
         Self::new_unchecked(DualQuaternion::from_real(rotation.into_inner()))
     }
 }
 
-impl<N: SimdRealField> One for UnitDualQuaternion<N>
+impl<T: SimdRealField> One for UnitDualQuaternion<T>
 where
-    N::Element: SimdRealField,
+    T::Element: SimdRealField,
 {
     #[inline]
     fn one() -> Self {
@@ -243,10 +243,10 @@ where
 }
 
 #[cfg(feature = "arbitrary")]
-impl<N> Arbitrary for UnitDualQuaternion<N>
+impl<T> Arbitrary for UnitDualQuaternion<T>
 where
-    N: SimdRealField + Arbitrary + Send,
-    N::Element: SimdRealField,
+    T: SimdRealField + Arbitrary + Send,
+    T::Element: SimdRealField,
 {
     #[inline]
     fn arbitrary(rng: &mut Gen) -> Self {
diff --git a/src/geometry/dual_quaternion_conversion.rs b/src/geometry/dual_quaternion_conversion.rs
index 20c6895a..94ef9e97 100644
--- a/src/geometry/dual_quaternion_conversion.rs
+++ b/src/geometry/dual_quaternion_conversion.rs
@@ -1,7 +1,6 @@
 use simba::scalar::{RealField, SubsetOf, SupersetOf};
 use simba::simd::SimdRealField;
 
-use crate::base::dimension::U3;
 use crate::base::{Matrix4, Vector4};
 use crate::geometry::{
     DualQuaternion, Isometry3, Similarity3, SuperTCategoryOf, TAffine, Transform, Translation3,
@@ -14,33 +13,33 @@ use crate::geometry::{
  *
  * DualQuaternion     -> DualQuaternion
  * UnitDualQuaternion -> UnitDualQuaternion
- * UnitDualQuaternion -> Isometry<U3>
- * UnitDualQuaternion -> Similarity<U3>
- * UnitDualQuaternion -> Transform<U3>
+ * UnitDualQuaternion -> Isometry<3>
+ * UnitDualQuaternion -> Similarity<3>
+ * UnitDualQuaternion -> Transform<3>
  * UnitDualQuaternion -> Matrix<U4> (homogeneous)
  *
  * NOTE:
  * UnitDualQuaternion -> DualQuaternion is already provided by: Unit<T> -> T
  */
 
-impl<N1, N2> SubsetOf<DualQuaternion<N2>> for DualQuaternion<N1>
+impl<T1, T2> SubsetOf<DualQuaternion<T2>> for DualQuaternion<T1>
 where
-    N1: SimdRealField,
-    N2: SimdRealField + SupersetOf<N1>,
+    T1: SimdRealField,
+    T2: SimdRealField + SupersetOf<T1>,
 {
     #[inline]
-    fn to_superset(&self) -> DualQuaternion<N2> {
+    fn to_superset(&self) -> DualQuaternion<T2> {
         DualQuaternion::from_real_and_dual(self.real.to_superset(), self.dual.to_superset())
     }
 
     #[inline]
-    fn is_in_subset(dq: &DualQuaternion<N2>) -> bool {
-        crate::is_convertible::<_, Vector4<N1>>(&dq.real.coords)
-            && crate::is_convertible::<_, Vector4<N1>>(&dq.dual.coords)
+    fn is_in_subset(dq: &DualQuaternion<T2>) -> bool {
+        crate::is_convertible::<_, Vector4<T1>>(&dq.real.coords)
+            && crate::is_convertible::<_, Vector4<T1>>(&dq.dual.coords)
     }
 
     #[inline]
-    fn from_superset_unchecked(dq: &DualQuaternion<N2>) -> Self {
+    fn from_superset_unchecked(dq: &DualQuaternion<T2>) -> Self {
         DualQuaternion::from_real_and_dual(
             dq.real.to_subset_unchecked(),
             dq.dual.to_subset_unchecked(),
@@ -48,141 +47,141 @@ where
     }
 }
 
-impl<N1, N2> SubsetOf<UnitDualQuaternion<N2>> for UnitDualQuaternion<N1>
+impl<T1, T2> SubsetOf<UnitDualQuaternion<T2>> for UnitDualQuaternion<T1>
 where
-    N1: SimdRealField,
-    N2: SimdRealField + SupersetOf<N1>,
+    T1: SimdRealField,
+    T2: SimdRealField + SupersetOf<T1>,
 {
     #[inline]
-    fn to_superset(&self) -> UnitDualQuaternion<N2> {
+    fn to_superset(&self) -> UnitDualQuaternion<T2> {
         UnitDualQuaternion::new_unchecked(self.as_ref().to_superset())
     }
 
     #[inline]
-    fn is_in_subset(dq: &UnitDualQuaternion<N2>) -> bool {
-        crate::is_convertible::<_, DualQuaternion<N1>>(dq.as_ref())
+    fn is_in_subset(dq: &UnitDualQuaternion<T2>) -> bool {
+        crate::is_convertible::<_, DualQuaternion<T1>>(dq.as_ref())
     }
 
     #[inline]
-    fn from_superset_unchecked(dq: &UnitDualQuaternion<N2>) -> Self {
+    fn from_superset_unchecked(dq: &UnitDualQuaternion<T2>) -> Self {
         Self::new_unchecked(crate::convert_ref_unchecked(dq.as_ref()))
     }
 }
 
-impl<N1, N2> SubsetOf<Isometry3<N2>> for UnitDualQuaternion<N1>
+impl<T1, T2> SubsetOf<Isometry3<T2>> for UnitDualQuaternion<T1>
 where
-    N1: RealField,
-    N2: RealField + SupersetOf<N1>,
+    T1: RealField,
+    T2: RealField + SupersetOf<T1>,
 {
     #[inline]
-    fn to_superset(&self) -> Isometry3<N2> {
-        let dq: UnitDualQuaternion<N2> = self.to_superset();
+    fn to_superset(&self) -> Isometry3<T2> {
+        let dq: UnitDualQuaternion<T2> = self.to_superset();
         let iso = dq.to_isometry();
         crate::convert_unchecked(iso)
     }
 
     #[inline]
-    fn is_in_subset(iso: &Isometry3<N2>) -> bool {
-        crate::is_convertible::<_, UnitQuaternion<N1>>(&iso.rotation)
-            && crate::is_convertible::<_, Translation3<N1>>(&iso.translation)
+    fn is_in_subset(iso: &Isometry3<T2>) -> bool {
+        crate::is_convertible::<_, UnitQuaternion<T1>>(&iso.rotation)
+            && crate::is_convertible::<_, Translation3<T1>>(&iso.translation)
     }
 
     #[inline]
-    fn from_superset_unchecked(iso: &Isometry3<N2>) -> Self {
-        let dq = UnitDualQuaternion::<N2>::from_isometry(iso);
+    fn from_superset_unchecked(iso: &Isometry3<T2>) -> Self {
+        let dq = UnitDualQuaternion::<T2>::from_isometry(iso);
         crate::convert_unchecked(dq)
     }
 }
 
-impl<N1, N2> SubsetOf<Similarity3<N2>> for UnitDualQuaternion<N1>
+impl<T1, T2> SubsetOf<Similarity3<T2>> for UnitDualQuaternion<T1>
 where
-    N1: RealField,
-    N2: RealField + SupersetOf<N1>,
+    T1: RealField,
+    T2: RealField + SupersetOf<T1>,
 {
     #[inline]
-    fn to_superset(&self) -> Similarity3<N2> {
-        Similarity3::from_isometry(crate::convert_ref(self), N2::one())
+    fn to_superset(&self) -> Similarity3<T2> {
+        Similarity3::from_isometry(crate::convert_ref(self), T2::one())
     }
 
     #[inline]
-    fn is_in_subset(sim: &Similarity3<N2>) -> bool {
-        sim.scaling() == N2::one()
+    fn is_in_subset(sim: &Similarity3<T2>) -> bool {
+        sim.scaling() == T2::one()
     }
 
     #[inline]
-    fn from_superset_unchecked(sim: &Similarity3<N2>) -> Self {
+    fn from_superset_unchecked(sim: &Similarity3<T2>) -> Self {
         crate::convert_ref_unchecked(&sim.isometry)
     }
 }
 
-impl<N1, N2, C> SubsetOf<Transform<N2, U3, C>> for UnitDualQuaternion<N1>
+impl<T1, T2, C> SubsetOf<Transform<T2, C, 3>> for UnitDualQuaternion<T1>
 where
-    N1: RealField,
-    N2: RealField + SupersetOf<N1>,
+    T1: RealField,
+    T2: RealField + SupersetOf<T1>,
     C: SuperTCategoryOf<TAffine>,
 {
     #[inline]
-    fn to_superset(&self) -> Transform<N2, U3, C> {
+    fn to_superset(&self) -> Transform<T2, C, 3> {
         Transform::from_matrix_unchecked(self.to_homogeneous().to_superset())
     }
 
     #[inline]
-    fn is_in_subset(t: &Transform<N2, U3, C>) -> bool {
+    fn is_in_subset(t: &Transform<T2, C, 3>) -> bool {
         <Self as SubsetOf<_>>::is_in_subset(t.matrix())
     }
 
     #[inline]
-    fn from_superset_unchecked(t: &Transform<N2, U3, C>) -> Self {
+    fn from_superset_unchecked(t: &Transform<T2, C, 3>) -> Self {
         Self::from_superset_unchecked(t.matrix())
     }
 }
 
-impl<N1: RealField, N2: RealField + SupersetOf<N1>> SubsetOf<Matrix4<N2>>
-    for UnitDualQuaternion<N1>
+impl<T1: RealField, T2: RealField + SupersetOf<T1>> SubsetOf<Matrix4<T2>>
+    for UnitDualQuaternion<T1>
 {
     #[inline]
-    fn to_superset(&self) -> Matrix4<N2> {
+    fn to_superset(&self) -> Matrix4<T2> {
         self.to_homogeneous().to_superset()
     }
 
     #[inline]
-    fn is_in_subset(m: &Matrix4<N2>) -> bool {
-        crate::is_convertible::<_, Isometry3<N1>>(m)
+    fn is_in_subset(m: &Matrix4<T2>) -> bool {
+        crate::is_convertible::<_, Isometry3<T1>>(m)
     }
 
     #[inline]
-    fn from_superset_unchecked(m: &Matrix4<N2>) -> Self {
-        let iso: Isometry3<N1> = crate::convert_ref_unchecked(m);
+    fn from_superset_unchecked(m: &Matrix4<T2>) -> Self {
+        let iso: Isometry3<T1> = crate::convert_ref_unchecked(m);
         Self::from_isometry(&iso)
     }
 }
 
-impl<N: SimdRealField + RealField> From<UnitDualQuaternion<N>> for Matrix4<N>
+impl<T: SimdRealField + RealField> From<UnitDualQuaternion<T>> for Matrix4<T>
 where
-    N::Element: SimdRealField,
+    T::Element: SimdRealField,
 {
     #[inline]
-    fn from(dq: UnitDualQuaternion<N>) -> Self {
+    fn from(dq: UnitDualQuaternion<T>) -> Self {
         dq.to_homogeneous()
     }
 }
 
-impl<N: SimdRealField> From<UnitDualQuaternion<N>> for Isometry3<N>
+impl<T: SimdRealField> From<UnitDualQuaternion<T>> for Isometry3<T>
 where
-    N::Element: SimdRealField,
+    T::Element: SimdRealField,
 {
     #[inline]
-    fn from(dq: UnitDualQuaternion<N>) -> Self {
+    fn from(dq: UnitDualQuaternion<T>) -> Self {
         dq.to_isometry()
     }
 }
 
-impl<N: SimdRealField> From<Isometry3<N>> for UnitDualQuaternion<N>
+impl<T: SimdRealField> From<Isometry3<T>> for UnitDualQuaternion<T>
 where
-    N::Element: SimdRealField,
+    T::Element: SimdRealField,
 {
     #[inline]
-    fn from(iso: Isometry3<N>) -> Self {
+    fn from(iso: Isometry3<T>) -> Self {
         Self::from_isometry(&iso)
     }
 }
diff --git a/src/geometry/dual_quaternion_ops.rs b/src/geometry/dual_quaternion_ops.rs
index 44d36b97..46bc22b5 100644
--- a/src/geometry/dual_quaternion_ops.rs
+++ b/src/geometry/dual_quaternion_ops.rs
@@ -46,31 +46,30 @@
 
 use crate::base::storage::Storage;
 use crate::{
-    Allocator, DefaultAllocator, DualQuaternion, Isometry3, Point, Point3, Quaternion,
-    SimdRealField, Translation3, Unit, UnitDualQuaternion, UnitQuaternion, Vector, Vector3, U1, U3,
-    U4,
+    DualQuaternion, Isometry3, Point, Point3, Quaternion, SimdRealField, Translation3, Unit,
+    UnitDualQuaternion, UnitQuaternion, Vector, Vector3, U3,
 };
 use std::mem;
 use std::ops::{
     Add, AddAssign, Div, DivAssign, Index, IndexMut, Mul, MulAssign, Neg, Sub, SubAssign,
 };
 
-impl<N: SimdRealField> AsRef<[N; 8]> for DualQuaternion<N> {
+impl<T: SimdRealField> AsRef<[T; 8]> for DualQuaternion<T> {
     #[inline]
-    fn as_ref(&self) -> &[N; 8] {
+    fn as_ref(&self) -> &[T; 8] {
         unsafe { mem::transmute(self) }
     }
 }
 
-impl<N: SimdRealField> AsMut<[N; 8]> for DualQuaternion<N> {
+impl<T: SimdRealField> AsMut<[T; 8]> for DualQuaternion<T> {
     #[inline]
-    fn as_mut(&mut self) -> &mut [N; 8] {
+    fn as_mut(&mut self) -> &mut [T; 8] {
         unsafe { mem::transmute(self) }
     }
 }
 
-impl<N: SimdRealField> Index<usize> for DualQuaternion<N> {
-    type Output = N;
+impl<T: SimdRealField> Index<usize> for DualQuaternion<T> {
+    type Output = T;
 
     #[inline]
     fn index(&self, i: usize) -> &Self::Output {
@@ -78,18 +77,18 @@ impl<N: SimdRealField> Index<usize> for DualQuaternion<N> {
     }
 }
 
-impl<N: SimdRealField> IndexMut<usize> for DualQuaternion<N> {
+impl<T: SimdRealField> IndexMut<usize> for DualQuaternion<T> {
     #[inline]
-    fn index_mut(&mut self, i: usize) -> &mut N {
+    fn index_mut(&mut self, i: usize) -> &mut T {
         &mut self.as_mut()[i]
     }
 }
 
-impl<N: SimdRealField> Neg for DualQuaternion<N>
+impl<T: SimdRealField> Neg for DualQuaternion<T>
 where
-    N::Element: SimdRealField,
+    T::Element: SimdRealField,
 {
-    type Output = DualQuaternion<N>;
+    type Output = DualQuaternion<T>;
 
     #[inline]
     fn neg(self) -> Self::Output {
@@ -97,11 +96,11 @@ where
     }
 }
 
-impl<'a, N: SimdRealField> Neg for &'a DualQuaternion<N>
+impl<'a, T: SimdRealField> Neg for &'a DualQuaternion<T>
 where
-    N::Element: SimdRealField,
+    T::Element: SimdRealField,
 {
-    type Output = DualQuaternion<N>;
+    type Output = DualQuaternion<T>;
 
     #[inline]
     fn neg(self) -> Self::Output {
@@ -109,11 +108,11 @@ where
     }
 }
 
-impl<N: SimdRealField> Neg for UnitDualQuaternion<N>
+impl<T: SimdRealField> Neg for UnitDualQuaternion<T>
 where
-    N::Element: SimdRealField,
+    T::Element: SimdRealField,
 {
-    type Output = UnitDualQuaternion<N>;
+    type Output = UnitDualQuaternion<T>;
 
     #[inline]
     fn neg(self) -> Self::Output {
@@ -121,11 +120,11 @@ where
     }
 }
 
-impl<'a, N: SimdRealField> Neg for &'a UnitDualQuaternion<N>
+impl<'a, T: SimdRealField> Neg for &'a UnitDualQuaternion<T>
 where
-    N::Element: SimdRealField,
+    T::Element: SimdRealField,
 {
-    type Output = UnitDualQuaternion<N>;
+    type Output = UnitDualQuaternion<T>;
 
     #[inline]
     fn neg(self) -> Self::Output {
@@ -139,10 +138,8 @@ macro_rules! dual_quaternion_op_impl(
      $(for $Storage: ident: $StoragesBound: ident $(<$($BoundParam: ty),*>)*),*;
      $lhs: ident: $Lhs: ty, $rhs: ident: $Rhs: ty, Output = $Result: ty $(=> $VDimA: ty, $VDimB: ty)*;
      $action: expr; $($lives: tt),*) => {
-        impl<$($lives ,)* N: SimdRealField $(, $Storage: $StoragesBound $(<$($BoundParam),*>)*)*> $Op<$Rhs> for $Lhs
-            where N::Element: SimdRealField,
-                  DefaultAllocator: Allocator<N, $LhsRDim, $LhsCDim> +
-                                    Allocator<N, $RhsRDim, $RhsCDim> {
+        impl<$($lives ,)* T: SimdRealField $(, $Storage: $StoragesBound $(<$($BoundParam),*>)*)*> $Op<$Rhs> for $Lhs
+            where T::Element: SimdRealField, {
             type Output = $Result;
 
             #[inline]
@@ -157,7 +154,7 @@ macro_rules! dual_quaternion_op_impl(
 dual_quaternion_op_impl!(
     Add, add;
     (U4, U1), (U4, U1);
-    self: &'a DualQuaternion<N>, rhs: &'b DualQuaternion<N>, Output = DualQuaternion<N>;
+    self: &'a DualQuaternion<T>, rhs: &'b DualQuaternion<T>, Output = DualQuaternion<T>;
     DualQuaternion::from_real_and_dual(
         &self.real + &rhs.real,
         &self.dual + &rhs.dual,
@@ -167,7 +164,7 @@ dual_quaternion_op_impl!(
 dual_quaternion_op_impl!(
     Add, add;
     (U4, U1), (U4, U1);
-    self: &'a DualQuaternion<N>, rhs: DualQuaternion<N>, Output = DualQuaternion<N>;
+    self: &'a DualQuaternion<T>, rhs: DualQuaternion<T>, Output = DualQuaternion<T>;
     DualQuaternion::from_real_and_dual(
         &self.real + rhs.real,
         &self.dual + rhs.dual,
@@ -177,7 +174,7 @@ dual_quaternion_op_impl!(
 dual_quaternion_op_impl!(
     Add, add;
     (U4, U1), (U4, U1);
-    self: DualQuaternion<N>, rhs: &'b DualQuaternion<N>, Output = DualQuaternion<N>;
+    self: DualQuaternion<T>, rhs: &'b DualQuaternion<T>, Output = DualQuaternion<T>;
     DualQuaternion::from_real_and_dual(
         self.real + &rhs.real,
         self.dual + &rhs.dual,
@@ -187,7 +184,7 @@ dual_quaternion_op_impl!(
 dual_quaternion_op_impl!(
     Add, add;
     (U4, U1), (U4, U1);
-    self: DualQuaternion<N>, rhs: DualQuaternion<N>, Output = DualQuaternion<N>;
+    self: DualQuaternion<T>, rhs: DualQuaternion<T>, Output = DualQuaternion<T>;
     DualQuaternion::from_real_and_dual(
         self.real + rhs.real,
         self.dual + rhs.dual,
@@ -197,7 +194,7 @@ dual_quaternion_op_impl!(
 dual_quaternion_op_impl!(
     Sub, sub;
     (U4, U1), (U4, U1);
-    self: &'a DualQuaternion<N>, rhs: &'b DualQuaternion<N>, Output = DualQuaternion<N>;
+    self: &'a DualQuaternion<T>, rhs: &'b DualQuaternion<T>, Output = DualQuaternion<T>;
     DualQuaternion::from_real_and_dual(
         &self.real - &rhs.real,
         &self.dual - &rhs.dual,
@@ -207,7 +204,7 @@ dual_quaternion_op_impl!(
 dual_quaternion_op_impl!(
     Sub, sub;
     (U4, U1), (U4, U1);
-    self: &'a DualQuaternion<N>, rhs: DualQuaternion<N>, Output = DualQuaternion<N>;
+    self: &'a DualQuaternion<T>, rhs: DualQuaternion<T>, Output = DualQuaternion<T>;
     DualQuaternion::from_real_and_dual(
         &self.real - rhs.real,
         &self.dual - rhs.dual,
@@ -217,7 +214,7 @@ dual_quaternion_op_impl!(
 dual_quaternion_op_impl!(
     Sub, sub;
     (U4, U1), (U4, U1);
-    self: DualQuaternion<N>, rhs: &'b DualQuaternion<N>, Output = DualQuaternion<N>;
+    self: DualQuaternion<T>, rhs: &'b DualQuaternion<T>, Output = DualQuaternion<T>;
     DualQuaternion::from_real_and_dual(
         self.real - &rhs.real,
         self.dual - &rhs.dual,
@@ -227,7 +224,7 @@ dual_quaternion_op_impl!(
 dual_quaternion_op_impl!(
     Sub, sub;
     (U4, U1), (U4, U1);
-    self: DualQuaternion<N>, rhs: DualQuaternion<N>, Output = DualQuaternion<N>;
+    self: DualQuaternion<T>, rhs: DualQuaternion<T>, Output = DualQuaternion<T>;
     DualQuaternion::from_real_and_dual(
         self.real - rhs.real,
         self.dual - rhs.dual,
@@ -237,7 +234,7 @@ dual_quaternion_op_impl!(
 dual_quaternion_op_impl!(
     Mul, mul;
     (U4, U1), (U4, U1);
-    self: &'a DualQuaternion<N>, rhs: &'b DualQuaternion<N>, Output = DualQuaternion<N>;
+    self: &'a DualQuaternion<T>, rhs: &'b DualQuaternion<T>, Output = DualQuaternion<T>;
     DualQuaternion::from_real_and_dual(
         &self.real * &rhs.real,
         &self.real * &rhs.dual + &self.dual * &rhs.real,
@@ -247,56 +244,56 @@ dual_quaternion_op_impl!(
 dual_quaternion_op_impl!(
     Mul, mul;
     (U4, U1), (U4, U1);
-    self: &'a DualQuaternion<N>, rhs: DualQuaternion<N>, Output = DualQuaternion<N>;
+    self: &'a DualQuaternion<T>, rhs: DualQuaternion<T>, Output = DualQuaternion<T>;
     self * &rhs;
     'a);
 
 dual_quaternion_op_impl!(
     Mul, mul;
     (U4, U1), (U4, U1);
-    self: DualQuaternion<N>, rhs: &'b DualQuaternion<N>, Output = DualQuaternion<N>;
+    self: DualQuaternion<T>, rhs: &'b DualQuaternion<T>, Output = DualQuaternion<T>;
     &self * rhs;
     'b);
 
 dual_quaternion_op_impl!(
     Mul, mul;
     (U4, U1), (U4, U1);
-    self: DualQuaternion<N>, rhs: DualQuaternion<N>, Output = DualQuaternion<N>;
+    self: DualQuaternion<T>, rhs: DualQuaternion<T>, Output = DualQuaternion<T>;
     &self * &rhs; );
 
 // DualQuaternion × UnitDualQuaternion
 dual_quaternion_op_impl!(
     Mul, mul;
     (U4, U1), (U4, U1);
-    self: &'a DualQuaternion<N>, rhs: &'b UnitDualQuaternion<N>, Output = DualQuaternion<N>;
+    self: &'a DualQuaternion<T>, rhs: &'b UnitDualQuaternion<T>, Output = DualQuaternion<T>;
     self * rhs.dual_quaternion();
     'a, 'b);
 
 dual_quaternion_op_impl!(
     Mul, mul;
     (U4, U1), (U4, U1);
-    self: &'a DualQuaternion<N>, rhs: UnitDualQuaternion<N>, Output = DualQuaternion<N>;
+    self: &'a DualQuaternion<T>, rhs: UnitDualQuaternion<T>, Output = DualQuaternion<T>;
     self * rhs.dual_quaternion();
     'a);
 
 dual_quaternion_op_impl!(
     Mul, mul;
     (U4, U1), (U4, U1);
-    self: DualQuaternion<N>, rhs: &'b UnitDualQuaternion<N>, Output = DualQuaternion<N>;
+    self: DualQuaternion<T>, rhs: &'b UnitDualQuaternion<T>, Output = DualQuaternion<T>;
     self * rhs.dual_quaternion();
     'b);
 
 dual_quaternion_op_impl!(
     Mul, mul;
     (U4, U1), (U4, U1);
-    self: DualQuaternion<N>, rhs: UnitDualQuaternion<N>, Output = DualQuaternion<N>;
+    self: DualQuaternion<T>, rhs: UnitDualQuaternion<T>, Output = DualQuaternion<T>;
     self * rhs.dual_quaternion(););
 
 // DualQuaternion ÷ UnitDualQuaternion
 dual_quaternion_op_impl!(
     Div, div;
     (U4, U1), (U4, U1);
-    self: &'a DualQuaternion<N>, rhs: &'b UnitDualQuaternion<N>, Output = DualQuaternion<N>;
+    self: &'a DualQuaternion<T>, rhs: &'b UnitDualQuaternion<T>, Output = DualQuaternion<T>;
     #[allow(clippy::suspicious_arithmetic_impl)]
     { self * rhs.inverse().dual_quaternion() };
     'a, 'b);
@@ -304,7 +301,7 @@ dual_quaternion_op_impl!(
 dual_quaternion_op_impl!(
     Div, div;
     (U4, U1), (U4, U1);
-    self: &'a DualQuaternion<N>, rhs: UnitDualQuaternion<N>, Output = DualQuaternion<N>;
+    self: &'a DualQuaternion<T>, rhs: UnitDualQuaternion<T>, Output = DualQuaternion<T>;
     #[allow(clippy::suspicious_arithmetic_impl)]
     { self * rhs.inverse().dual_quaternion() };
     'a);
@@ -312,7 +309,7 @@ dual_quaternion_op_impl!(
 dual_quaternion_op_impl!(
     Div, div;
     (U4, U1), (U4, U1);
-    self: DualQuaternion<N>, rhs: &'b UnitDualQuaternion<N>, Output = DualQuaternion<N>;
+    self: DualQuaternion<T>, rhs: &'b UnitDualQuaternion<T>, Output = DualQuaternion<T>;
     #[allow(clippy::suspicious_arithmetic_impl)]
     { self * rhs.inverse().dual_quaternion() };
     'b);
@@ -320,7 +317,7 @@ dual_quaternion_op_impl!(
 dual_quaternion_op_impl!(
     Div, div;
     (U4, U1), (U4, U1);
-    self: DualQuaternion<N>, rhs: UnitDualQuaternion<N>, Output = DualQuaternion<N>;
+    self: DualQuaternion<T>, rhs: UnitDualQuaternion<T>, Output = DualQuaternion<T>;
     #[allow(clippy::suspicious_arithmetic_impl)]
     { self * rhs.inverse().dual_quaternion() };);
 
@@ -328,199 +325,199 @@ dual_quaternion_op_impl!(
 dual_quaternion_op_impl!(
     Mul, mul;
     (U4, U1), (U4, U1);
-    self: &'a UnitDualQuaternion<N>, rhs: &'b UnitDualQuaternion<N>, Output = UnitDualQuaternion<N>;
+    self: &'a UnitDualQuaternion<T>, rhs: &'b UnitDualQuaternion<T>, Output = UnitDualQuaternion<T>;
     UnitDualQuaternion::new_unchecked(self.as_ref() * rhs.as_ref());
     'a, 'b);
 
 dual_quaternion_op_impl!(
     Mul, mul;
     (U4, U1), (U4, U1);
-    self: &'a UnitDualQuaternion<N>, rhs: UnitDualQuaternion<N>, Output = UnitDualQuaternion<N>;
+    self: &'a UnitDualQuaternion<T>, rhs: UnitDualQuaternion<T>, Output = UnitDualQuaternion<T>;
     self * &rhs;
     'a);
 
 dual_quaternion_op_impl!(
     Mul, mul;
     (U4, U1), (U4, U1);
-    self: UnitDualQuaternion<N>, rhs: &'b UnitDualQuaternion<N>, Output = UnitDualQuaternion<N>;
+    self: UnitDualQuaternion<T>, rhs: &'b UnitDualQuaternion<T>, Output = UnitDualQuaternion<T>;
     &self * rhs;
     'b);
 
 dual_quaternion_op_impl!(
     Mul, mul;
     (U4, U1), (U4, U1);
-    self: UnitDualQuaternion<N>, rhs: UnitDualQuaternion<N>, Output = UnitDualQuaternion<N>;
+    self: UnitDualQuaternion<T>, rhs: UnitDualQuaternion<T>, Output = UnitDualQuaternion<T>;
     &self * &rhs; );
 
 // UnitDualQuaternion ÷ UnitDualQuaternion
 dual_quaternion_op_impl!(
     Div, div;
     (U4, U1), (U4, U1);
-    self: &'a UnitDualQuaternion<N>, rhs: &'b UnitDualQuaternion<N>, Output = UnitDualQuaternion<N>;
+    self: &'a UnitDualQuaternion<T>, rhs: &'b UnitDualQuaternion<T>, Output = UnitDualQuaternion<T>;
     #[allow(clippy::suspicious_arithmetic_impl)] { self * rhs.inverse() };
     'a, 'b);
 
 dual_quaternion_op_impl!(
     Div, div;
     (U4, U1), (U4, U1);
-    self: &'a UnitDualQuaternion<N>, rhs: UnitDualQuaternion<N>, Output = UnitDualQuaternion<N>;
+    self: &'a UnitDualQuaternion<T>, rhs: UnitDualQuaternion<T>, Output = UnitDualQuaternion<T>;
     self / &rhs;
     'a);
 
 dual_quaternion_op_impl!(
     Div, div;
     (U4, U1), (U4, U1);
-    self: UnitDualQuaternion<N>, rhs: &'b UnitDualQuaternion<N>, Output = UnitDualQuaternion<N>;
+    self: UnitDualQuaternion<T>, rhs: &'b UnitDualQuaternion<T>, Output = UnitDualQuaternion<T>;
     &self / rhs;
     'b);
 
 dual_quaternion_op_impl!(
     Div, div;
     (U4, U1), (U4, U1);
-    self: UnitDualQuaternion<N>, rhs: UnitDualQuaternion<N>, Output = UnitDualQuaternion<N>;
+    self: UnitDualQuaternion<T>, rhs: UnitDualQuaternion<T>, Output = UnitDualQuaternion<T>;
     &self / &rhs; );
 
 // UnitDualQuaternion × DualQuaternion
 dual_quaternion_op_impl!(
     Mul, mul;
     (U4, U1), (U4, U1);
-    self: &'a UnitDualQuaternion<N>, rhs: &'b DualQuaternion<N>,
-    Output = DualQuaternion<N> => U1, U4;
+    self: &'a UnitDualQuaternion<T>, rhs: &'b DualQuaternion<T>,
+    Output = DualQuaternion<T> => U1, U4;
     self.dual_quaternion() * rhs;
     'a, 'b);
 
 dual_quaternion_op_impl!(
     Mul, mul;
     (U4, U1), (U4, U1);
-    self: &'a UnitDualQuaternion<N>, rhs: DualQuaternion<N>,
-    Output = DualQuaternion<N> => U3, U3;
+    self: &'a UnitDualQuaternion<T>, rhs: DualQuaternion<T>,
+    Output = DualQuaternion<T> => U3, U3;
     self.dual_quaternion() * rhs;
     'a);
 
 dual_quaternion_op_impl!(
     Mul, mul;
     (U4, U1), (U4, U1);
-    self: UnitDualQuaternion<N>, rhs: &'b DualQuaternion<N>,
-    Output = DualQuaternion<N> => U3, U3;
+    self: UnitDualQuaternion<T>, rhs: &'b DualQuaternion<T>,
+    Output = DualQuaternion<T> => U3, U3;
     self.dual_quaternion() * rhs;
     'b);
 
 dual_quaternion_op_impl!(
     Mul, mul;
     (U4, U1), (U4, U1);
-    self: UnitDualQuaternion<N>, rhs: DualQuaternion<N>,
-    Output = DualQuaternion<N> => U3, U3;
+    self: UnitDualQuaternion<T>, rhs: DualQuaternion<T>,
+    Output = DualQuaternion<T> => U3, U3;
     self.dual_quaternion() * rhs;);
 
 // UnitDualQuaternion × UnitQuaternion
 dual_quaternion_op_impl!(
     Mul, mul;
     (U4, U1), (U4, U1);
-    self: &'a UnitDualQuaternion<N>, rhs: &'b UnitQuaternion<N>,
-    Output = UnitDualQuaternion<N> => U1, U4;
-    self * UnitDualQuaternion::<N>::new_unchecked(DualQuaternion::from_real(rhs.into_inner()));
+    self: &'a UnitDualQuaternion<T>, rhs: &'b UnitQuaternion<T>,
+    Output = UnitDualQuaternion<T> => U1, U4;
+    self * UnitDualQuaternion::<T>::new_unchecked(DualQuaternion::from_real(rhs.into_inner()));
     'a, 'b);
 
 dual_quaternion_op_impl!(
     Mul, mul;
     (U4, U1), (U4, U1);
-    self: &'a UnitDualQuaternion<N>, rhs: UnitQuaternion<N>,
-    Output = UnitDualQuaternion<N> => U3, U3;
-    self * UnitDualQuaternion::<N>::new_unchecked(DualQuaternion::from_real(rhs.into_inner()));
+    self: &'a UnitDualQuaternion<T>, rhs: UnitQuaternion<T>,
+    Output = UnitDualQuaternion<T> => U3, U3;
+    self * UnitDualQuaternion::<T>::new_unchecked(DualQuaternion::from_real(rhs.into_inner()));
     'a);
 
 dual_quaternion_op_impl!(
     Mul, mul;
     (U4, U1), (U4, U1);
-    self: UnitDualQuaternion<N>, rhs: &'b UnitQuaternion<N>,
-    Output = UnitDualQuaternion<N> => U3, U3;
-    self * UnitDualQuaternion::<N>::new_unchecked(DualQuaternion::from_real(rhs.into_inner()));
+    self: UnitDualQuaternion<T>, rhs: &'b UnitQuaternion<T>,
+    Output = UnitDualQuaternion<T> => U3, U3;
+    self * UnitDualQuaternion::<T>::new_unchecked(DualQuaternion::from_real(rhs.into_inner()));
     'b);
 
 dual_quaternion_op_impl!(
     Mul, mul;
     (U4, U1), (U4, U1);
-    self: UnitDualQuaternion<N>, rhs: UnitQuaternion<N>,
-    Output = UnitDualQuaternion<N> => U3, U3;
-    self * UnitDualQuaternion::<N>::new_unchecked(DualQuaternion::from_real(rhs.into_inner())););
+    self: UnitDualQuaternion<T>, rhs: UnitQuaternion<T>,
+    Output = UnitDualQuaternion<T> => U3, U3;
+    self * UnitDualQuaternion::<T>::new_unchecked(DualQuaternion::from_real(rhs.into_inner())););
 
 // UnitQuaternion × UnitDualQuaternion
 dual_quaternion_op_impl!(
     Mul, mul;
     (U4, U1), (U4, U1);
-    self: &'a UnitQuaternion<N>, rhs: &'b UnitDualQuaternion<N>,
-    Output = UnitDualQuaternion<N> => U1, U4;
-    UnitDualQuaternion::<N>::new_unchecked(DualQuaternion::from_real(self.into_inner())) * rhs;
+    self: &'a UnitQuaternion<T>, rhs: &'b UnitDualQuaternion<T>,
+    Output = UnitDualQuaternion<T> => U1, U4;
+    UnitDualQuaternion::<T>::new_unchecked(DualQuaternion::from_real(self.into_inner())) * rhs;
     'a, 'b);
 
 dual_quaternion_op_impl!(
     Mul, mul;
     (U4, U1), (U4, U1);
-    self: &'a UnitQuaternion<N>, rhs: UnitDualQuaternion<N>,
-    Output = UnitDualQuaternion<N> => U3, U3;
-    UnitDualQuaternion::<N>::new_unchecked(DualQuaternion::from_real(self.into_inner())) * rhs;
+    self: &'a UnitQuaternion<T>, rhs: UnitDualQuaternion<T>,
+    Output = UnitDualQuaternion<T> => U3, U3;
+    UnitDualQuaternion::<T>::new_unchecked(DualQuaternion::from_real(self.into_inner())) * rhs;
     'a);
 
 dual_quaternion_op_impl!(
     Mul, mul;
     (U4, U1), (U4, U1);
-    self: UnitQuaternion<N>, rhs: &'b UnitDualQuaternion<N>,
-    Output = UnitDualQuaternion<N> => U3, U3;
-    UnitDualQuaternion::<N>::new_unchecked(DualQuaternion::from_real(self.into_inner())) * rhs;
+    self: UnitQuaternion<T>, rhs: &'b UnitDualQuaternion<T>,
+    Output = UnitDualQuaternion<T> => U3, U3;
+    UnitDualQuaternion::<T>::new_unchecked(DualQuaternion::from_real(self.into_inner())) * rhs;
     'b);
 
 dual_quaternion_op_impl!(
     Mul, mul;
     (U4, U1), (U4, U1);
-    self: UnitQuaternion<N>, rhs: UnitDualQuaternion<N>,
-    Output = UnitDualQuaternion<N> => U3, U3;
-    UnitDualQuaternion::<N>::new_unchecked(DualQuaternion::from_real(self.into_inner())) * rhs;);
+    self: UnitQuaternion<T>, rhs: UnitDualQuaternion<T>,
+    Output = UnitDualQuaternion<T> => U3, U3;
+    UnitDualQuaternion::<T>::new_unchecked(DualQuaternion::from_real(self.into_inner())) * rhs;);
 
 // UnitDualQuaternion ÷ UnitQuaternion
 dual_quaternion_op_impl!(
     Div, div;
     (U4, U1), (U4, U1);
-    self: &'a UnitDualQuaternion<N>, rhs: &'b UnitQuaternion<N>,
-    Output = UnitDualQuaternion<N> => U1, U4;
+    self: &'a UnitDualQuaternion<T>, rhs: &'b UnitQuaternion<T>,
+    Output = UnitDualQuaternion<T> => U1, U4;
     #[allow(clippy::suspicious_arithmetic_impl)]
-    { self * UnitDualQuaternion::<N>::from_rotation(rhs.inverse()) };
+    { self * UnitDualQuaternion::<T>::from_rotation(rhs.inverse()) };
     'a, 'b);
 
 dual_quaternion_op_impl!(
     Div, div;
     (U4, U1), (U4, U1);
-    self: &'a UnitDualQuaternion<N>, rhs: UnitQuaternion<N>,
-    Output = UnitDualQuaternion<N> => U3, U3;
+    self: &'a UnitDualQuaternion<T>, rhs: UnitQuaternion<T>,
+    Output = UnitDualQuaternion<T> => U3, U3;
     #[allow(clippy::suspicious_arithmetic_impl)]
-    { self * UnitDualQuaternion::<N>::from_rotation(rhs.inverse()) };
+    { self * UnitDualQuaternion::<T>::from_rotation(rhs.inverse()) };
     'a);
 
 dual_quaternion_op_impl!(
     Div, div;
     (U4, U1), (U4, U1);
-    self: UnitDualQuaternion<N>, rhs: &'b UnitQuaternion<N>,
-    Output = UnitDualQuaternion<N> => U3, U3;
+    self: UnitDualQuaternion<T>, rhs: &'b UnitQuaternion<T>,
+    Output = UnitDualQuaternion<T> => U3, U3;
     #[allow(clippy::suspicious_arithmetic_impl)]
-    { self * UnitDualQuaternion::<N>::from_rotation(rhs.inverse()) };
+    { self * UnitDualQuaternion::<T>::from_rotation(rhs.inverse()) };
     'b);
 
 dual_quaternion_op_impl!(
     Div, div;
     (U4, U1), (U4, U1);
-    self: UnitDualQuaternion<N>, rhs: UnitQuaternion<N>,
-    Output = UnitDualQuaternion<N> => U3, U3;
+    self: UnitDualQuaternion<T>, rhs: UnitQuaternion<T>,
+    Output = UnitDualQuaternion<T> => U3, U3;
     #[allow(clippy::suspicious_arithmetic_impl)]
-    { self * UnitDualQuaternion::<N>::from_rotation(rhs.inverse()) };);
+    { self * UnitDualQuaternion::<T>::from_rotation(rhs.inverse()) };);
 
 // UnitQuaternion ÷ UnitDualQuaternion
 dual_quaternion_op_impl!(
     Div, div;
     (U4, U1), (U4, U1);
-    self: &'a UnitQuaternion<N>, rhs: &'b UnitDualQuaternion<N>,
-    Output = UnitDualQuaternion<N> => U1, U4;
+    self: &'a UnitQuaternion<T>, rhs: &'b UnitDualQuaternion<T>,
+    Output = UnitDualQuaternion<T> => U1, U4;
     #[allow(clippy::suspicious_arithmetic_impl)]
     {
-        UnitDualQuaternion::<N>::new_unchecked(
+        UnitDualQuaternion::<T>::new_unchecked(
             DualQuaternion::from_real(self.into_inner())
         ) * rhs.inverse()
     }; 'a, 'b);
@@ -528,11 +525,11 @@ dual_quaternion_op_impl!(
 dual_quaternion_op_impl!(
     Div, div;
     (U4, U1), (U4, U1);
-    self: &'a UnitQuaternion<N>, rhs: UnitDualQuaternion<N>,
-    Output = UnitDualQuaternion<N> => U3, U3;
+    self: &'a UnitQuaternion<T>, rhs: UnitDualQuaternion<T>,
+    Output = UnitDualQuaternion<T> => U3, U3;
     #[allow(clippy::suspicious_arithmetic_impl)]
     {
-        UnitDualQuaternion::<N>::new_unchecked(
+        UnitDualQuaternion::<T>::new_unchecked(
             DualQuaternion::from_real(self.into_inner())
         ) * rhs.inverse()
     }; 'a);
@@ -540,11 +537,11 @@ dual_quaternion_op_impl!(
 dual_quaternion_op_impl!(
     Div, div;
     (U4, U1), (U4, U1);
-    self: UnitQuaternion<N>, rhs: &'b UnitDualQuaternion<N>,
-    Output = UnitDualQuaternion<N> => U3, U3;
+    self: UnitQuaternion<T>, rhs: &'b UnitDualQuaternion<T>,
+    Output = UnitDualQuaternion<T> => U3, U3;
     #[allow(clippy::suspicious_arithmetic_impl)]
     {
-        UnitDualQuaternion::<N>::new_unchecked(
+        UnitDualQuaternion::<T>::new_unchecked(
             DualQuaternion::from_real(self.into_inner())
         ) * rhs.inverse()
     }; 'b);
@@ -552,11 +549,11 @@ dual_quaternion_op_impl!(
 dual_quaternion_op_impl!(
     Div, div;
     (U4, U1), (U4, U1);
-    self: UnitQuaternion<N>, rhs: UnitDualQuaternion<N>,
-    Output = UnitDualQuaternion<N> => U3, U3;
+    self: UnitQuaternion<T>, rhs: UnitDualQuaternion<T>,
+    Output = UnitDualQuaternion<T> => U3, U3;
     #[allow(clippy::suspicious_arithmetic_impl)]
     {
-        UnitDualQuaternion::<N>::new_unchecked(
+        UnitDualQuaternion::<T>::new_unchecked(
             DualQuaternion::from_real(self.into_inner())
         ) * rhs.inverse()
     };);
@@ -565,305 +562,305 @@ dual_quaternion_op_impl!(
 dual_quaternion_op_impl!(
     Mul, mul;
     (U4, U1), (U3, U1);
-    self: &'a UnitDualQuaternion<N>, rhs: &'b Translation3<N>,
-    Output = UnitDualQuaternion<N> => U3, U1;
-    self * UnitDualQuaternion::<N>::from_parts(rhs.clone(), UnitQuaternion::identity());
+    self: &'a UnitDualQuaternion<T>, rhs: &'b Translation3<T>,
+    Output = UnitDualQuaternion<T> => U3, U1;
+    self * UnitDualQuaternion::<T>::from_parts(rhs.clone(), UnitQuaternion::identity());
     'a, 'b);
 
 dual_quaternion_op_impl!(
     Mul, mul;
     (U4, U1), (U3, U3);
-    self: &'a UnitDualQuaternion<N>, rhs: Translation3<N>,
-    Output = UnitDualQuaternion<N> => U3, U1;
-    self * UnitDualQuaternion::<N>::from_parts(rhs, UnitQuaternion::identity());
+    self: &'a UnitDualQuaternion<T>, rhs: Translation3<T>,
+    Output = UnitDualQuaternion<T> => U3, U1;
+    self * UnitDualQuaternion::<T>::from_parts(rhs, UnitQuaternion::identity());
     'a);
 
 dual_quaternion_op_impl!(
     Mul, mul;
     (U4, U1), (U3, U3);
-    self: UnitDualQuaternion<N>, rhs: &'b Translation3<N>,
-    Output = UnitDualQuaternion<N> => U3, U1;
-    self * UnitDualQuaternion::<N>::from_parts(rhs.clone(), UnitQuaternion::identity());
+    self: UnitDualQuaternion<T>, rhs: &'b Translation3<T>,
+    Output = UnitDualQuaternion<T> => U3, U1;
+    self * UnitDualQuaternion::<T>::from_parts(rhs.clone(), UnitQuaternion::identity());
     'b);
 
 dual_quaternion_op_impl!(
     Mul, mul;
     (U4, U1), (U3, U3);
-    self: UnitDualQuaternion<N>, rhs: Translation3<N>,
-    Output = UnitDualQuaternion<N> => U3, U1;
-    self * UnitDualQuaternion::<N>::from_parts(rhs, UnitQuaternion::identity()); );
+    self: UnitDualQuaternion<T>, rhs: Translation3<T>,
+    Output = UnitDualQuaternion<T> => U3, U1;
+    self * UnitDualQuaternion::<T>::from_parts(rhs, UnitQuaternion::identity()); );
 
 // UnitDualQuaternion ÷ Translation3
 dual_quaternion_op_impl!(
     Div, div;
     (U4, U1), (U3, U1);
-    self: &'a UnitDualQuaternion<N>, rhs: &'b Translation3<N>,
-    Output = UnitDualQuaternion<N> => U3, U1;
+    self: &'a UnitDualQuaternion<T>, rhs: &'b Translation3<T>,
+    Output = UnitDualQuaternion<T> => U3, U1;
     #[allow(clippy::suspicious_arithmetic_impl)]
-    { self * UnitDualQuaternion::<N>::from_parts(rhs.inverse(), UnitQuaternion::identity()) };
+    { self * UnitDualQuaternion::<T>::from_parts(rhs.inverse(), UnitQuaternion::identity()) };
     'a, 'b);
 
 dual_quaternion_op_impl!(
     Div, div;
     (U4, U1), (U3, U3);
-    self: &'a UnitDualQuaternion<N>, rhs: Translation3<N>,
-    Output = UnitDualQuaternion<N> => U3, U1;
+    self: &'a UnitDualQuaternion<T>, rhs: Translation3<T>,
+    Output = UnitDualQuaternion<T> => U3, U1;
     #[allow(clippy::suspicious_arithmetic_impl)]
-    { self * UnitDualQuaternion::<N>::from_parts(rhs.inverse(), UnitQuaternion::identity()) };
+    { self * UnitDualQuaternion::<T>::from_parts(rhs.inverse(), UnitQuaternion::identity()) };
     'a);
 
 dual_quaternion_op_impl!(
     Div, div;
     (U4, U1), (U3, U3);
-    self: UnitDualQuaternion<N>, rhs: &'b Translation3<N>,
-    Output = UnitDualQuaternion<N> => U3, U1;
+    self: UnitDualQuaternion<T>, rhs: &'b Translation3<T>,
+    Output = UnitDualQuaternion<T> => U3, U1;
     #[allow(clippy::suspicious_arithmetic_impl)]
-    { self * UnitDualQuaternion::<N>::from_parts(rhs.inverse(), UnitQuaternion::identity()) };
+    { self * UnitDualQuaternion::<T>::from_parts(rhs.inverse(), UnitQuaternion::identity()) };
     'b);
 
 dual_quaternion_op_impl!(
     Div, div;
     (U4, U1), (U3, U3);
-    self: UnitDualQuaternion<N>, rhs: Translation3<N>,
-    Output = UnitDualQuaternion<N> => U3, U1;
+    self: UnitDualQuaternion<T>, rhs: Translation3<T>,
+    Output = UnitDualQuaternion<T> => U3, U1;
     #[allow(clippy::suspicious_arithmetic_impl)]
-    { self * UnitDualQuaternion::<N>::from_parts(rhs.inverse(), UnitQuaternion::identity()) };);
+    { self * UnitDualQuaternion::<T>::from_parts(rhs.inverse(), UnitQuaternion::identity()) };);
 
 // Translation3 × UnitDualQuaternion
 dual_quaternion_op_impl!(
     Mul, mul;
     (U3, U1), (U4, U1);
-    self: &'b Translation3<N>, rhs: &'a UnitDualQuaternion<N>,
-    Output = UnitDualQuaternion<N> => U3, U1;
-    UnitDualQuaternion::<N>::from_parts(self.clone(), UnitQuaternion::identity()) * rhs;
+    self: &'b Translation3<T>, rhs: &'a UnitDualQuaternion<T>,
+    Output = UnitDualQuaternion<T> => U3, U1;
+    UnitDualQuaternion::<T>::from_parts(self.clone(), UnitQuaternion::identity()) * rhs;
     'a, 'b);
 
 dual_quaternion_op_impl!(
     Mul, mul;
     (U3, U1), (U4, U1);
-    self: &'a Translation3<N>, rhs: UnitDualQuaternion<N>,
-    Output = UnitDualQuaternion<N> => U3, U1;
-    UnitDualQuaternion::<N>::from_parts(self.clone(), UnitQuaternion::identity()) * rhs;
+    self: &'a Translation3<T>, rhs: UnitDualQuaternion<T>,
+    Output = UnitDualQuaternion<T> => U3, U1;
+    UnitDualQuaternion::<T>::from_parts(self.clone(), UnitQuaternion::identity()) * rhs;
     'a);
 
 dual_quaternion_op_impl!(
     Mul, mul;
     (U3, U1), (U4, U1);
-    self: Translation3<N>, rhs: &'b UnitDualQuaternion<N>,
-    Output = UnitDualQuaternion<N> => U3, U1;
-    UnitDualQuaternion::<N>::from_parts(self, UnitQuaternion::identity()) * rhs;
+    self: Translation3<T>, rhs: &'b UnitDualQuaternion<T>,
+    Output = UnitDualQuaternion<T> => U3, U1;
+    UnitDualQuaternion::<T>::from_parts(self, UnitQuaternion::identity()) * rhs;
     'b);
 
 dual_quaternion_op_impl!(
     Mul, mul;
     (U3, U1), (U4, U1);
-    self: Translation3<N>, rhs: UnitDualQuaternion<N>,
-    Output = UnitDualQuaternion<N> => U3, U1;
-    UnitDualQuaternion::<N>::from_parts(self, UnitQuaternion::identity()) * rhs;);
+    self: Translation3<T>, rhs: UnitDualQuaternion<T>,
+    Output = UnitDualQuaternion<T> => U3, U1;
+    UnitDualQuaternion::<T>::from_parts(self, UnitQuaternion::identity()) * rhs;);
 
 // Translation3 ÷ UnitDualQuaternion
 dual_quaternion_op_impl!(
     Div, div;
     (U3, U1), (U4, U1);
-    self: &'b Translation3<N>, rhs: &'a UnitDualQuaternion<N>,
-    Output = UnitDualQuaternion<N> => U3, U1;
-    UnitDualQuaternion::<N>::from_parts(self.clone(), UnitQuaternion::identity()) / rhs;
+    self: &'b Translation3<T>, rhs: &'a UnitDualQuaternion<T>,
+    Output = UnitDualQuaternion<T> => U3, U1;
+    UnitDualQuaternion::<T>::from_parts(self.clone(), UnitQuaternion::identity()) / rhs;
     'a, 'b);
 
 dual_quaternion_op_impl!(
     Div, div;
     (U3, U1), (U4, U1);
-    self: &'a Translation3<N>, rhs: UnitDualQuaternion<N>,
-    Output = UnitDualQuaternion<N> => U3, U1;
-    UnitDualQuaternion::<N>::from_parts(self.clone(), UnitQuaternion::identity()) / rhs;
+    self: &'a Translation3<T>, rhs: UnitDualQuaternion<T>,
+    Output = UnitDualQuaternion<T> => U3, U1;
+    UnitDualQuaternion::<T>::from_parts(self.clone(), UnitQuaternion::identity()) / rhs;
     'a);
 
 dual_quaternion_op_impl!(
     Div, div;
     (U3, U1), (U4, U1);
-    self: Translation3<N>, rhs: &'b UnitDualQuaternion<N>,
-    Output = UnitDualQuaternion<N> => U3, U1;
-    UnitDualQuaternion::<N>::from_parts(self, UnitQuaternion::identity()) / rhs;
+    self: Translation3<T>, rhs: &'b UnitDualQuaternion<T>,
+    Output = UnitDualQuaternion<T> => U3, U1;
+    UnitDualQuaternion::<T>::from_parts(self, UnitQuaternion::identity()) / rhs;
     'b);
 
 dual_quaternion_op_impl!(
     Div, div;
     (U3, U1), (U4, U1);
-    self: Translation3<N>, rhs: UnitDualQuaternion<N>,
-    Output = UnitDualQuaternion<N> => U3, U1;
-    UnitDualQuaternion::<N>::from_parts(self, UnitQuaternion::identity()) / rhs;);
+    self: Translation3<T>, rhs: UnitDualQuaternion<T>,
+    Output = UnitDualQuaternion<T> => U3, U1;
+    UnitDualQuaternion::<T>::from_parts(self, UnitQuaternion::identity()) / rhs;);
 
 // UnitDualQuaternion × Isometry3
 dual_quaternion_op_impl!(
     Mul, mul;
     (U4, U1), (U3, U1);
-    self: &'a UnitDualQuaternion<N>, rhs: &'b Isometry3<N>,
-    Output = UnitDualQuaternion<N> => U3, U1;
-    self * UnitDualQuaternion::<N>::from_isometry(rhs);
+    self: &'a UnitDualQuaternion<T>, rhs: &'b Isometry3<T>,
+    Output = UnitDualQuaternion<T> => U3, U1;
+    self * UnitDualQuaternion::<T>::from_isometry(rhs);
     'a, 'b);
 
 dual_quaternion_op_impl!(
     Mul, mul;
     (U4, U1), (U3, U3);
-    self: &'a UnitDualQuaternion<N>, rhs: Isometry3<N>,
-    Output = UnitDualQuaternion<N> => U3, U1;
-    self * UnitDualQuaternion::<N>::from_isometry(&rhs);
+    self: &'a UnitDualQuaternion<T>, rhs: Isometry3<T>,
+    Output = UnitDualQuaternion<T> => U3, U1;
+    self * UnitDualQuaternion::<T>::from_isometry(&rhs);
     'a);
 
 dual_quaternion_op_impl!(
     Mul, mul;
     (U4, U1), (U3, U3);
-    self: UnitDualQuaternion<N>, rhs: &'b Isometry3<N>,
-    Output = UnitDualQuaternion<N> => U3, U1;
-    self * UnitDualQuaternion::<N>::from_isometry(rhs);
+    self: UnitDualQuaternion<T>, rhs: &'b Isometry3<T>,
+    Output = UnitDualQuaternion<T> => U3, U1;
+    self * UnitDualQuaternion::<T>::from_isometry(rhs);
     'b);
 
 dual_quaternion_op_impl!(
     Mul, mul;
     (U4, U1), (U3, U3);
-    self: UnitDualQuaternion<N>, rhs: Isometry3<N>,
-    Output = UnitDualQuaternion<N> => U3, U1;
-    self * UnitDualQuaternion::<N>::from_isometry(&rhs); );
+    self: UnitDualQuaternion<T>, rhs: Isometry3<T>,
+    Output = UnitDualQuaternion<T> => U3, U1;
+    self * UnitDualQuaternion::<T>::from_isometry(&rhs); );
 
 // UnitDualQuaternion ÷ Isometry3
 dual_quaternion_op_impl!(
     Div, div;
     (U4, U1), (U3, U1);
-    self: &'a UnitDualQuaternion<N>, rhs: &'b Isometry3<N>,
-    Output = UnitDualQuaternion<N> => U3, U1;
+    self: &'a UnitDualQuaternion<T>, rhs: &'b Isometry3<T>,
+    Output = UnitDualQuaternion<T> => U3, U1;
     // TODO: can we avoid the conversion to a rotation matrix?
-    self / UnitDualQuaternion::<N>::from_isometry(rhs);
+    self / UnitDualQuaternion::<T>::from_isometry(rhs);
     'a, 'b);
 
 dual_quaternion_op_impl!(
     Div, div;
     (U4, U1), (U3, U3);
-    self: &'a UnitDualQuaternion<N>, rhs: Isometry3<N>,
-    Output = UnitDualQuaternion<N> => U3, U1;
-    self / UnitDualQuaternion::<N>::from_isometry(&rhs);
+    self: &'a UnitDualQuaternion<T>, rhs: Isometry3<T>,
+    Output = UnitDualQuaternion<T> => U3, U1;
+    self / UnitDualQuaternion::<T>::from_isometry(&rhs);
     'a);
 
 dual_quaternion_op_impl!(
     Div, div;
     (U4, U1), (U3, U3);
-    self: UnitDualQuaternion<N>, rhs: &'b Isometry3<N>,
-    Output = UnitDualQuaternion<N> => U3, U1;
-    self / UnitDualQuaternion::<N>::from_isometry(rhs);
+    self: UnitDualQuaternion<T>, rhs: &'b Isometry3<T>,
+    Output = UnitDualQuaternion<T> => U3, U1;
+    self / UnitDualQuaternion::<T>::from_isometry(rhs);
     'b);
 
 dual_quaternion_op_impl!(
     Div, div;
     (U4, U1), (U3, U3);
-    self: UnitDualQuaternion<N>, rhs: Isometry3<N>,
-    Output = UnitDualQuaternion<N> => U3, U1;
-    self / UnitDualQuaternion::<N>::from_isometry(&rhs); );
+    self: UnitDualQuaternion<T>, rhs: Isometry3<T>,
+    Output = UnitDualQuaternion<T> => U3, U1;
+    self / UnitDualQuaternion::<T>::from_isometry(&rhs); );
 
 // Isometry × UnitDualQuaternion
 dual_quaternion_op_impl!(
     Mul, mul;
     (U3, U1), (U4, U1);
-    self: &'a Isometry3<N>, rhs: &'b UnitDualQuaternion<N>,
-    Output = UnitDualQuaternion<N> => U3, U1;
-    UnitDualQuaternion::<N>::from_isometry(self) * rhs;
+    self: &'a Isometry3<T>, rhs: &'b UnitDualQuaternion<T>,
+    Output = UnitDualQuaternion<T> => U3, U1;
+    UnitDualQuaternion::<T>::from_isometry(self) * rhs;
     'a, 'b);
 
 dual_quaternion_op_impl!(
     Mul, mul;
     (U3, U1), (U4, U1);
-    self: &'a Isometry3<N>, rhs: UnitDualQuaternion<N>,
-    Output = UnitDualQuaternion<N> => U3, U1;
-    UnitDualQuaternion::<N>::from_isometry(self) * rhs;
+    self: &'a Isometry3<T>, rhs: UnitDualQuaternion<T>,
+    Output = UnitDualQuaternion<T> => U3, U1;
+    UnitDualQuaternion::<T>::from_isometry(self) * rhs;
     'a);
 
 dual_quaternion_op_impl!(
     Mul, mul;
     (U3, U1), (U4, U1);
-    self: Isometry3<N>, rhs: &'b UnitDualQuaternion<N>,
-    Output = UnitDualQuaternion<N> => U3, U1;
-    UnitDualQuaternion::<N>::from_isometry(&self) * rhs;
+    self: Isometry3<T>, rhs: &'b UnitDualQuaternion<T>,
+    Output = UnitDualQuaternion<T> => U3, U1;
+    UnitDualQuaternion::<T>::from_isometry(&self) * rhs;
     'b);
 
 dual_quaternion_op_impl!(
     Mul, mul;
     (U3, U1), (U4, U1);
-    self: Isometry3<N>, rhs: UnitDualQuaternion<N>,
-    Output = UnitDualQuaternion<N> => U3, U1;
-    UnitDualQuaternion::<N>::from_isometry(&self) * rhs; );
+    self: Isometry3<T>, rhs: UnitDualQuaternion<T>,
+    Output = UnitDualQuaternion<T> => U3, U1;
+    UnitDualQuaternion::<T>::from_isometry(&self) * rhs; );
 
 // Isometry ÷ UnitDualQuaternion
 dual_quaternion_op_impl!(
     Div, div;
     (U3, U1), (U4, U1);
-    self: &'a Isometry3<N>, rhs: &'b UnitDualQuaternion<N>,
-    Output = UnitDualQuaternion<N> => U3, U1;
+    self: &'a Isometry3<T>, rhs: &'b UnitDualQuaternion<T>,
+    Output = UnitDualQuaternion<T> => U3, U1;
     // TODO: can we avoid the conversion from a rotation matrix?
-    UnitDualQuaternion::<N>::from_isometry(self) / rhs;
+    UnitDualQuaternion::<T>::from_isometry(self) / rhs;
     'a, 'b);
 
 dual_quaternion_op_impl!(
     Div, div;
     (U3, U1), (U4, U1);
-    self: &'a Isometry3<N>, rhs: UnitDualQuaternion<N>,
-    Output = UnitDualQuaternion<N> => U3, U1;
-    UnitDualQuaternion::<N>::from_isometry(self) / rhs;
+    self: &'a Isometry3<T>, rhs: UnitDualQuaternion<T>,
+    Output = UnitDualQuaternion<T> => U3, U1;
+    UnitDualQuaternion::<T>::from_isometry(self) / rhs;
     'a);
 
 dual_quaternion_op_impl!(
     Div, div;
     (U3, U1), (U4, U1);
-    self: Isometry3<N>, rhs: &'b UnitDualQuaternion<N>,
-    Output = UnitDualQuaternion<N> => U3, U1;
-    UnitDualQuaternion::<N>::from_isometry(&self) / rhs;
+    self: Isometry3<T>, rhs: &'b UnitDualQuaternion<T>,
+    Output = UnitDualQuaternion<T> => U3, U1;
+    UnitDualQuaternion::<T>::from_isometry(&self) / rhs;
     'b);
 
 dual_quaternion_op_impl!(
     Div, div;
     (U3, U1), (U4, U1);
-    self: Isometry3<N>, rhs: UnitDualQuaternion<N>,
-    Output = UnitDualQuaternion<N> => U3, U1;
-    UnitDualQuaternion::<N>::from_isometry(&self) / rhs; );
+    self: Isometry3<T>, rhs: UnitDualQuaternion<T>,
+    Output = UnitDualQuaternion<T> => U3, U1;
+    UnitDualQuaternion::<T>::from_isometry(&self) / rhs; );
 
 // UnitDualQuaternion × Vector
 dual_quaternion_op_impl!(
     Mul, mul;
-    (U4, U1), (U3, U1) for SB: Storage<N, U3> ;
-    self: &'a UnitDualQuaternion<N>, rhs: &'b Vector<N, U3, SB>,
-    Output = Vector3<N> => U3, U1;
+    (U4, U1), (U3, U1) for SB: Storage<T, U3> ;
+    self: &'a UnitDualQuaternion<T>, rhs: &'b Vector<T, U3, SB>,
+    Output = Vector3<T> => U3, U1;
     Unit::new_unchecked(self.as_ref().real) * rhs;
     'a, 'b);
 
 dual_quaternion_op_impl!(
     Mul, mul;
-    (U4, U1), (U3, U1) for SB: Storage<N, U3> ;
-    self: &'a UnitDualQuaternion<N>, rhs: Vector<N, U3, SB>,
-    Output = Vector3<N> => U3, U1;
+    (U4, U1), (U3, U1) for SB: Storage<T, U3> ;
+    self: &'a UnitDualQuaternion<T>, rhs: Vector<T, U3, SB>,
+    Output = Vector3<T> => U3, U1;
     self * &rhs;
     'a);
 
 dual_quaternion_op_impl!(
     Mul, mul;
-    (U4, U1), (U3, U1) for SB: Storage<N, U3> ;
-    self: UnitDualQuaternion<N>, rhs: &'b Vector<N, U3, SB>,
-    Output = Vector3<N> => U3, U1;
+    (U4, U1), (U3, U1) for SB: Storage<T, U3> ;
+    self: UnitDualQuaternion<T>, rhs: &'b Vector<T, U3, SB>,
+    Output = Vector3<T> => U3, U1;
     &self * rhs;
     'b);
 
 dual_quaternion_op_impl!(
     Mul, mul;
-    (U4, U1), (U3, U1) for SB: Storage<N, U3> ;
-    self: UnitDualQuaternion<N>, rhs: Vector<N, U3, SB>,
-    Output = Vector3<N> => U3, U1;
+    (U4, U1), (U3, U1) for SB: Storage<T, U3> ;
+    self: UnitDualQuaternion<T>, rhs: Vector<T, U3, SB>,
+    Output = Vector3<T> => U3, U1;
     &self * &rhs; );
 
 // UnitDualQuaternion × Point
 dual_quaternion_op_impl!(
     Mul, mul;
     (U4, U1), (U3, U1);
-    self: &'a UnitDualQuaternion<N>, rhs: &'b Point3<N>,
-    Output = Point3<N> => U3, U1;
+    self: &'a UnitDualQuaternion<T>, rhs: &'b Point3<T>,
+    Output = Point3<T> => U3, U1;
     {
-        let two: N = crate::convert(2.0f64);
-        let q_point = Quaternion::from_parts(N::zero(), rhs.coords.clone());
+        let two: T = crate::convert(2.0f64);
+        let q_point = Quaternion::from_parts(T::zero(), rhs.coords.clone());
         Point::from(
             ((self.as_ref().real * q_point + self.as_ref().dual * two) * self.as_ref().real.conjugate())
                 .vector()
@@ -875,56 +872,56 @@ dual_quaternion_op_impl!(
 dual_quaternion_op_impl!(
     Mul, mul;
     (U4, U1), (U3, U1);
-    self: &'a UnitDualQuaternion<N>, rhs: Point3<N>,
-    Output = Point3<N> => U3, U1;
+    self: &'a UnitDualQuaternion<T>, rhs: Point3<T>,
+    Output = Point3<T> => U3, U1;
     self * &rhs;
     'a);
 
 dual_quaternion_op_impl!(
     Mul, mul;
     (U4, U1), (U3, U1);
-    self: UnitDualQuaternion<N>, rhs: &'b Point3<N>,
-    Output = Point3<N> => U3, U1;
+    self: UnitDualQuaternion<T>, rhs: &'b Point3<T>,
+    Output = Point3<T> => U3, U1;
     &self * rhs;
     'b);
 
 dual_quaternion_op_impl!(
     Mul, mul;
     (U4, U1), (U3, U1);
-    self: UnitDualQuaternion<N>, rhs: Point3<N>,
-    Output = Point3<N> => U3, U1;
+    self: UnitDualQuaternion<T>, rhs: Point3<T>,
+    Output = Point3<T> => U3, U1;
     &self * &rhs; );
 
 // UnitDualQuaternion × Unit<Vector>
 dual_quaternion_op_impl!(
     Mul, mul;
-    (U4, U1), (U3, U1) for SB: Storage<N, U3> ;
-    self: &'a UnitDualQuaternion<N>, rhs: &'b Unit<Vector<N, U3, SB>>,
-    Output = Unit<Vector3<N>> => U3, U4;
+    (U4, U1), (U3, U1) for SB: Storage<T, U3> ;
+    self: &'a UnitDualQuaternion<T>, rhs: &'b Unit<Vector<T, U3, SB>>,
+    Output = Unit<Vector3<T>> => U3, U4;
     Unit::new_unchecked(self * rhs.as_ref());
     'a, 'b);
 
 dual_quaternion_op_impl!(
     Mul, mul;
-    (U4, U1), (U3, U1) for SB: Storage<N, U3> ;
-    self: &'a UnitDualQuaternion<N>, rhs: Unit<Vector<N, U3, SB>>,
-    Output = Unit<Vector3<N>> => U3, U4;
+    (U4, U1), (U3, U1) for SB: Storage<T, U3> ;
+    self: &'a UnitDualQuaternion<T>, rhs: Unit<Vector<T, U3, SB>>,
+    Output = Unit<Vector3<T>> => U3, U4;
     Unit::new_unchecked(self * rhs.into_inner());
     'a);
 
 dual_quaternion_op_impl!(
     Mul, mul;
-    (U4, U1), (U3, U1) for SB: Storage<N, U3> ;
-    self: UnitDualQuaternion<N>, rhs: &'b Unit<Vector<N, U3, SB>>,
-    Output = Unit<Vector3<N>> => U3, U4;
+    (U4, U1), (U3, U1) for SB: Storage<T, U3> ;
+    self: UnitDualQuaternion<T>, rhs: &'b Unit<Vector<T, U3, SB>>,
+    Output = Unit<Vector3<T>> => U3, U4;
     Unit::new_unchecked(self * rhs.as_ref());
     'b);
 
 dual_quaternion_op_impl!(
     Mul, mul;
-    (U4, U1), (U3, U1) for SB: Storage<N, U3> ;
-    self: UnitDualQuaternion<N>, rhs: Unit<Vector<N, U3, SB>>,
-    Output = Unit<Vector3<N>> => U3, U4;
+    (U4, U1), (U3, U1) for SB: Storage<T, U3> ;
+    self: UnitDualQuaternion<T>, rhs: Unit<Vector<T, U3, SB>>,
+    Output = Unit<Vector3<T>> => U3, U4;
     Unit::new_unchecked(self * rhs.into_inner()); );
 
 macro_rules! left_scalar_mul_impl(
@@ -962,10 +959,8 @@ macro_rules! dual_quaternion_op_impl(
      ($LhsRDim: ident, $LhsCDim: ident), ($RhsRDim: ident, $RhsCDim: ident);
      $lhs: ident: $Lhs: ty, $rhs: ident: $Rhs: ty $(=> $VDimA: ty, $VDimB: ty)*;
      $action: expr; $($lives: tt),*) => {
-        impl<$($lives ,)* N: SimdRealField> $OpAssign<$Rhs> for $Lhs
-            where N::Element: SimdRealField,
-                  DefaultAllocator: Allocator<N, $LhsRDim, $LhsCDim> +
-                                    Allocator<N, $RhsRDim, $RhsCDim> {
+        impl<$($lives ,)* T: SimdRealField> $OpAssign<$Rhs> for $Lhs
+            where T::Element: SimdRealField {
 
             #[inline]
             fn $op_assign(&mut $lhs, $rhs: $Rhs) {
@@ -979,7 +974,7 @@ macro_rules! dual_quaternion_op_impl(
 dual_quaternion_op_impl!(
     AddAssign, add_assign;
     (U4, U1), (U4, U1);
-    self: DualQuaternion<N>, rhs: &'b DualQuaternion<N>;
+    self: DualQuaternion<T>, rhs: &'b DualQuaternion<T>;
     {
         self.real += &rhs.real;
         self.dual += &rhs.dual;
@@ -989,7 +984,7 @@ dual_quaternion_op_impl!(
 dual_quaternion_op_impl!(
     AddAssign, add_assign;
     (U4, U1), (U4, U1);
-    self: DualQuaternion<N>, rhs: DualQuaternion<N>;
+    self: DualQuaternion<T>, rhs: DualQuaternion<T>;
     {
         self.real += rhs.real;
         self.dual += rhs.dual;
@@ -999,7 +994,7 @@ dual_quaternion_op_impl!(
 dual_quaternion_op_impl!(
     SubAssign, sub_assign;
     (U4, U1), (U4, U1);
-    self: DualQuaternion<N>, rhs: &'b DualQuaternion<N>;
+    self: DualQuaternion<T>, rhs: &'b DualQuaternion<T>;
     {
         self.real -= &rhs.real;
         self.dual -= &rhs.dual;
@@ -1009,7 +1004,7 @@ dual_quaternion_op_impl!(
 dual_quaternion_op_impl!(
     SubAssign, sub_assign;
     (U4, U1), (U4, U1);
-    self: DualQuaternion<N>, rhs: DualQuaternion<N>;
+    self: DualQuaternion<T>, rhs: DualQuaternion<T>;
     {
         self.real -= rhs.real;
         self.dual -= rhs.dual;
@@ -1019,7 +1014,7 @@ dual_quaternion_op_impl!(
 dual_quaternion_op_impl!(
     MulAssign, mul_assign;
     (U4, U1), (U4, U1);
-    self: DualQuaternion<N>, rhs: &'b DualQuaternion<N>;
+    self: DualQuaternion<T>, rhs: &'b DualQuaternion<T>;
     {
         let res = &*self * rhs;
         self.real.coords.copy_from(&res.real.coords);
@@ -1030,14 +1025,14 @@ dual_quaternion_op_impl!(
 dual_quaternion_op_impl!(
     MulAssign, mul_assign;
     (U4, U1), (U4, U1);
-    self: DualQuaternion<N>, rhs: DualQuaternion<N>;
+    self: DualQuaternion<T>, rhs: DualQuaternion<T>;
     *self *= &rhs;);
 
 // DualQuaternion ×= UnitDualQuaternion
 dual_quaternion_op_impl!(
     MulAssign, mul_assign;
     (U4, U1), (U4, U1);
-    self: DualQuaternion<N>, rhs: &'b UnitDualQuaternion<N>;
+    self: DualQuaternion<T>, rhs: &'b UnitDualQuaternion<T>;
     {
         let res = &*self * rhs;
         self.real.coords.copy_from(&res.real.coords);
@@ -1048,14 +1043,14 @@ dual_quaternion_op_impl!(
 dual_quaternion_op_impl!(
     MulAssign, mul_assign;
     (U4, U1), (U4, U1);
-    self: DualQuaternion<N>, rhs: UnitDualQuaternion<N>;
+    self: DualQuaternion<T>, rhs: UnitDualQuaternion<T>;
     *self *= &rhs; );
 
 // DualQuaternion ÷= UnitDualQuaternion
 dual_quaternion_op_impl!(
     DivAssign, div_assign;
     (U4, U1), (U4, U1);
-    self: DualQuaternion<N>, rhs: &'b UnitDualQuaternion<N>;
+    self: DualQuaternion<T>, rhs: &'b UnitDualQuaternion<T>;
     {
         let res = &*self / rhs;
         self.real.coords.copy_from(&res.real.coords);
@@ -1066,14 +1061,14 @@ dual_quaternion_op_impl!(
 dual_quaternion_op_impl!(
     DivAssign, div_assign;
     (U4, U1), (U4, U1);
-    self: DualQuaternion<N>, rhs: UnitDualQuaternion<N>;
+    self: DualQuaternion<T>, rhs: UnitDualQuaternion<T>;
     *self /= &rhs; );
 
 // UnitDualQuaternion ×= UnitDualQuaternion
 dual_quaternion_op_impl!(
     MulAssign, mul_assign;
     (U4, U1), (U4, U1);
-    self: UnitDualQuaternion<N>, rhs: &'b UnitDualQuaternion<N>;
+    self: UnitDualQuaternion<T>, rhs: &'b UnitDualQuaternion<T>;
     {
         let res = &*self * rhs;
         self.as_mut_unchecked().real.coords.copy_from(&res.as_ref().real.coords);
@@ -1084,14 +1079,14 @@ dual_quaternion_op_impl!(
 dual_quaternion_op_impl!(
     MulAssign, mul_assign;
     (U4, U1), (U4, U1);
-    self: UnitDualQuaternion<N>, rhs: UnitDualQuaternion<N>;
+    self: UnitDualQuaternion<T>, rhs: UnitDualQuaternion<T>;
     *self *= &rhs; );
 
 // UnitDualQuaternion ÷= UnitDualQuaternion
 dual_quaternion_op_impl!(
     DivAssign, div_assign;
     (U4, U1), (U4, U1);
-    self: UnitDualQuaternion<N>, rhs: &'b UnitDualQuaternion<N>;
+    self: UnitDualQuaternion<T>, rhs: &'b UnitDualQuaternion<T>;
     {
         let res = &*self / rhs;
         self.as_mut_unchecked().real.coords.copy_from(&res.as_ref().real.coords);
@@ -1102,14 +1097,14 @@ dual_quaternion_op_impl!(
 dual_quaternion_op_impl!(
     DivAssign, div_assign;
     (U4, U1), (U4, U1);
-    self: UnitDualQuaternion<N>, rhs: UnitDualQuaternion<N>;
+    self: UnitDualQuaternion<T>, rhs: UnitDualQuaternion<T>;
     *self /= &rhs; );
 
 // UnitDualQuaternion ×= UnitQuaternion
 dual_quaternion_op_impl!(
     MulAssign, mul_assign;
     (U4, U1), (U4, U1);
-    self: UnitDualQuaternion<N>, rhs: UnitQuaternion<N>;
+    self: UnitDualQuaternion<T>, rhs: UnitQuaternion<T>;
     {
         let res = &*self * UnitDualQuaternion::from_rotation(rhs);
         self.as_mut_unchecked().real.coords.copy_from(&res.as_ref().real.coords);
@@ -1119,14 +1114,14 @@ dual_quaternion_op_impl!(
 dual_quaternion_op_impl!(
     MulAssign, mul_assign;
     (U4, U1), (U4, U1);
-    self: UnitDualQuaternion<N>, rhs: &'b UnitQuaternion<N>;
+    self: UnitDualQuaternion<T>, rhs: &'b UnitQuaternion<T>;
     *self *= rhs.clone(); 'b);
 
 // UnitDualQuaternion ÷= UnitQuaternion
 dual_quaternion_op_impl!(
     DivAssign, div_assign;
     (U4, U1), (U4, U1);
-    self: UnitDualQuaternion<N>, rhs: &'b UnitQuaternion<N>;
+    self: UnitDualQuaternion<T>, rhs: &'b UnitQuaternion<T>;
     #[allow(clippy::suspicious_op_assign_impl)]
     {
         let res = &*self * UnitDualQuaternion::from_rotation(rhs.inverse());
@@ -1138,14 +1133,14 @@ dual_quaternion_op_impl!(
 dual_quaternion_op_impl!(
     DivAssign, div_assign;
     (U4, U1), (U4, U1);
-    self: UnitDualQuaternion<N>, rhs: UnitQuaternion<N>;
+    self: UnitDualQuaternion<T>, rhs: UnitQuaternion<T>;
     *self /= &rhs; );
 
 // UnitDualQuaternion ×= Translation3
 dual_quaternion_op_impl!(
     MulAssign, mul_assign;
     (U4, U1), (U4, U1);
-    self: UnitDualQuaternion<N>, rhs: Translation3<N>;
+    self: UnitDualQuaternion<T>, rhs: Translation3<T>;
     {
         let res = &*self * UnitDualQuaternion::from_parts(rhs, UnitQuaternion::identity());
         self.as_mut_unchecked().real.coords.copy_from(&res.as_ref().real.coords);
@@ -1155,14 +1150,14 @@ dual_quaternion_op_impl!(
 dual_quaternion_op_impl!(
     MulAssign, mul_assign;
     (U4, U1), (U4, U1);
-    self: UnitDualQuaternion<N>, rhs: &'b Translation3<N>;
+    self: UnitDualQuaternion<T>, rhs: &'b Translation3<T>;
     *self *= rhs.clone(); 'b);
 
 // UnitDualQuaternion ÷= Translation3
 dual_quaternion_op_impl!(
     DivAssign, div_assign;
     (U4, U1), (U4, U1);
-    self: UnitDualQuaternion<N>, rhs: &'b Translation3<N>;
+    self: UnitDualQuaternion<T>, rhs: &'b Translation3<T>;
     #[allow(clippy::suspicious_op_assign_impl)]
     {
         let res = &*self * UnitDualQuaternion::from_parts(rhs.inverse(), UnitQuaternion::identity());
@@ -1174,14 +1169,14 @@ dual_quaternion_op_impl!(
 dual_quaternion_op_impl!(
     DivAssign, div_assign;
     (U4, U1), (U4, U1);
-    self: UnitDualQuaternion<N>, rhs: Translation3<N>;
+    self: UnitDualQuaternion<T>, rhs: Translation3<T>;
     *self /= &rhs; );
 
 // UnitDualQuaternion ×= Isometry3
 dual_quaternion_op_impl!(
     MulAssign, mul_assign;
     (U4, U1), (U3, U1);
-    self: UnitDualQuaternion<N>, rhs: &'b Isometry3<N> => U3, U1;
+    self: UnitDualQuaternion<T>, rhs: &'b Isometry3<T> => U3, U1;
     {
         let res = &*self * rhs;
         self.as_mut_unchecked().real.coords.copy_from(&res.as_ref().real.coords);
@@ -1192,14 +1187,14 @@ dual_quaternion_op_impl!(
 dual_quaternion_op_impl!(
     MulAssign, mul_assign;
     (U4, U1), (U3, U1);
-    self: UnitDualQuaternion<N>, rhs: Isometry3<N> => U3, U1;
+    self: UnitDualQuaternion<T>, rhs: Isometry3<T> => U3, U1;
     *self *= &rhs; );
 
 // UnitDualQuaternion ÷= Isometry3
 dual_quaternion_op_impl!(
     DivAssign, div_assign;
     (U4, U1), (U3, U1);
-    self: UnitDualQuaternion<N>, rhs: &'b Isometry3<N> => U3, U1;
+    self: UnitDualQuaternion<T>, rhs: &'b Isometry3<T> => U3, U1;
     {
         let res = &*self / rhs;
         self.as_mut_unchecked().real.coords.copy_from(&res.as_ref().real.coords);
@@ -1210,17 +1205,17 @@ dual_quaternion_op_impl!(
 dual_quaternion_op_impl!(
     DivAssign, div_assign;
     (U4, U1), (U3, U1);
-    self: UnitDualQuaternion<N>, rhs: Isometry3<N> => U3, U1;
+    self: UnitDualQuaternion<T>, rhs: Isometry3<T> => U3, U1;
     *self /= &rhs; );
 
 macro_rules! scalar_op_impl(
     ($($Op: ident, $op: ident, $OpAssign: ident, $op_assign: ident);* $(;)*) => {$(
-        impl<N: SimdRealField> $Op<N> for DualQuaternion<N>
-         where N::Element: SimdRealField {
-            type Output = DualQuaternion<N>;
+        impl<T: SimdRealField> $Op<T> for DualQuaternion<T>
+         where T::Element: SimdRealField {
+            type Output = DualQuaternion<T>;
 
             #[inline]
-            fn $op(self, n: N) -> Self::Output {
+            fn $op(self, n: T) -> Self::Output {
                 DualQuaternion::from_real_and_dual(
                     self.real.$op(n),
                     self.dual.$op(n)
@@ -1228,12 +1223,12 @@ macro_rules! scalar_op_impl(
             }
         }
 
-        impl<'a, N: SimdRealField> $Op<N> for &'a DualQuaternion<N>
-         where N::Element: SimdRealField {
-            type Output = DualQuaternion<N>;
+        impl<'a, T: SimdRealField> $Op<T> for &'a DualQuaternion<T>
+         where T::Element: SimdRealField {
+            type Output = DualQuaternion<T>;
 
             #[inline]
-            fn $op(self, n: N) -> Self::Output {
+            fn $op(self, n: T) -> Self::Output {
                 DualQuaternion::from_real_and_dual(
                     self.real.$op(n),
                     self.dual.$op(n)
@@ -1241,11 +1236,11 @@ macro_rules! scalar_op_impl(
             }
         }
 
-        impl<N: SimdRealField> $OpAssign<N> for DualQuaternion<N>
-         where N::Element: SimdRealField {
+        impl<T: SimdRealField> $OpAssign<T> for DualQuaternion<T>
+         where T::Element: SimdRealField {
 
             #[inline]
-            fn $op_assign(&mut self, n: N) {
+            fn $op_assign(&mut self, n: T) {
                 self.real.$op_assign(n);
                 self.dual.$op_assign(n);
             }
diff --git a/src/geometry/isometry.rs b/src/geometry/isometry.rs
index 7e4b703d..5d79901f 100755
--- a/src/geometry/isometry.rs
+++ b/src/geometry/isometry.rs
@@ -14,9 +14,9 @@ use simba::scalar::{RealField, SubsetOf};
 use simba::simd::SimdRealField;
 
 use crate::base::allocator::Allocator;
-use crate::base::dimension::{DimName, DimNameAdd, DimNameSum, U1};
+use crate::base::dimension::{DimNameAdd, DimNameSum, U1};
 use crate::base::storage::Owned;
-use crate::base::{DefaultAllocator, MatrixN, Scalar, Unit, VectorN};
+use crate::base::{Const, DefaultAllocator, OMatrix, SVector, Scalar, Unit};
 use crate::geometry::{AbstractRotation, Point, Translation};
 
 /// A direct isometry, i.e., a rotation followed by a translation (aka. a rigid-body motion).
@@ -59,33 +59,28 @@ use crate::geometry::{AbstractRotation, Point, Translation};
 #[cfg_attr(
     feature = "serde-serialize",
     serde(bound(serialize = "R: Serialize,
-                     DefaultAllocator: Allocator<N, D>,
-                     Owned<N, D>: Serialize"))
+                     DefaultAllocator: Allocator<T, Const<D>>,
+                     Owned<T, Const<D>>: Serialize"))
 )]
 #[cfg_attr(
     feature = "serde-serialize",
     serde(bound(deserialize = "R: Deserialize<'de>,
-                       DefaultAllocator: Allocator<N, D>,
-                       Owned<N, D>: Deserialize<'de>"))
+                       DefaultAllocator: Allocator<T, Const<D>>,
+                       Owned<T, Const<D>>: Deserialize<'de>"))
 )]
-pub struct Isometry<N: Scalar, D: DimName, R>
-where
-    DefaultAllocator: Allocator<N, D>,
-{
+pub struct Isometry<T: Scalar, R, const D: usize> {
     /// The pure rotational part of this isometry.
     pub rotation: R,
     /// The pure translational part of this isometry.
-    pub translation: Translation<N, D>,
+    pub translation: Translation<T, D>,
 }
 
 #[cfg(feature = "abomonation-serialize")]
-impl<N, D, R> Abomonation for Isometry<N, D, R>
+impl<T, R, const D: usize> Abomonation for Isometry<T, R, D>
 where
-    N: SimdRealField,
-    D: DimName,
+    T: SimdRealField,
     R: Abomonation,
-    Translation<N, D>: Abomonation,
-    DefaultAllocator: Allocator<N, D>,
+    Translation<T, D>: Abomonation,
 {
     unsafe fn entomb<W: Write>(&self, writer: &mut W) -> IOResult<()> {
         self.rotation.entomb(writer)?;
@@ -103,11 +98,9 @@ where
     }
 }
 
-impl<N: Scalar + hash::Hash, D: DimName + hash::Hash, R: hash::Hash> hash::Hash
-    for Isometry<N, D, R>
+impl<T: Scalar + hash::Hash, R: hash::Hash, const D: usize> hash::Hash for Isometry<T, R, D>
 where
-    DefaultAllocator: Allocator<N, D>,
-    Owned<N, D>: hash::Hash,
+    Owned<T, Const<D>>: hash::Hash,
 {
     fn hash<H: hash::Hasher>(&self, state: &mut H) {
         self.translation.hash(state);
@@ -115,17 +108,12 @@ where
     }
 }
 
-impl<N: Scalar + Copy, D: DimName + Copy, R: Copy> Copy for Isometry<N, D, R>
-where
-    DefaultAllocator: Allocator<N, D>,
-    Owned<N, D>: Copy,
+impl<T: Scalar + Copy, R: Copy, const D: usize> Copy for Isometry<T, R, D> where
+    Owned<T, Const<D>>: Copy
 {
 }
 
-impl<N: Scalar, D: DimName, R: Clone> Clone for Isometry<N, D, R>
-where
-    DefaultAllocator: Allocator<N, D>,
-{
+impl<T: Scalar, R: Clone, const D: usize> Clone for Isometry<T, R, D> {
     #[inline]
     fn clone(&self) -> Self {
         Self {
@@ -135,10 +123,7 @@ where
     }
 }
 /// # From the translation and rotation parts
-impl<N: Scalar, D: DimName, R: AbstractRotation<N, D>> Isometry<N, D, R>
-where
-    DefaultAllocator: Allocator<N, D>,
-{
+impl<T: Scalar, R: AbstractRotation<T, D>, const D: usize> Isometry<T, R, D> {
     /// Creates a new isometry from its rotational and translational parts.
     ///
     /// # Example
@@ -154,7 +139,7 @@ where
     /// assert_relative_eq!(iso * Point3::new(1.0, 2.0, 3.0), Point3::new(-1.0, 2.0, 0.0), epsilon = 1.0e-6);
     /// ```
     #[inline]
-    pub fn from_parts(translation: Translation<N, D>, rotation: R) -> Self {
+    pub fn from_parts(translation: Translation<T, D>, rotation: R) -> Self {
         Self {
             rotation,
             translation,
@@ -163,10 +148,9 @@ where
 }
 
 /// # Inversion and in-place composition
-impl<N: SimdRealField, D: DimName, R: AbstractRotation<N, D>> Isometry<N, D, R>
+impl<T: SimdRealField, R: AbstractRotation<T, D>, const D: usize> Isometry<T, R, D>
 where
-    N::Element: SimdRealField,
-    DefaultAllocator: Allocator<N, D>,
+    T::Element: SimdRealField,
 {
     /// Inverts `self`.
     ///
@@ -223,7 +207,7 @@ where
     /// assert_eq!(iso1.inverse() * iso2, iso1.inv_mul(&iso2));
     /// ```
     #[inline]
-    pub fn inv_mul(&self, rhs: &Isometry<N, D, R>) -> Self {
+    pub fn inv_mul(&self, rhs: &Isometry<T, R, D>) -> Self {
         let inv_rot1 = self.rotation.inverse();
         let tr_12 = rhs.translation.vector.clone() - self.translation.vector.clone();
         Isometry::from_parts(
@@ -247,7 +231,7 @@ where
     /// assert_eq!(iso.translation, Translation2::new(4.0, 6.0));
     /// ```
     #[inline]
-    pub fn append_translation_mut(&mut self, t: &Translation<N, D>) {
+    pub fn append_translation_mut(&mut self, t: &Translation<T, D>) {
         self.translation.vector += &t.vector
     }
 
@@ -289,7 +273,7 @@ where
     /// assert_relative_eq!(iso * pt, Point2::new(-2.0, 0.0), epsilon = 1.0e-6);
     /// ```
     #[inline]
-    pub fn append_rotation_wrt_point_mut(&mut self, r: &R, p: &Point<N, D>) {
+    pub fn append_rotation_wrt_point_mut(&mut self, r: &R, p: &Point<T, D>) {
         self.translation.vector -= &p.coords;
         self.append_rotation_mut(r);
         self.translation.vector += &p.coords;
@@ -318,10 +302,9 @@ where
 }
 
 /// # Transformation of a vector or a point
-impl<N: SimdRealField, D: DimName, R: AbstractRotation<N, D>> Isometry<N, D, R>
+impl<T: SimdRealField, R: AbstractRotation<T, D>, const D: usize> Isometry<T, R, D>
 where
-    N::Element: SimdRealField,
-    DefaultAllocator: Allocator<N, D>,
+    T::Element: SimdRealField,
 {
     /// Transform the given point by this isometry.
     ///
@@ -341,7 +324,7 @@ where
     /// assert_relative_eq!(transformed_point, Point3::new(3.0, 2.0, 2.0), epsilon = 1.0e-6);
     /// ```
     #[inline]
-    pub fn transform_point(&self, pt: &Point<N, D>) -> Point<N, D> {
+    pub fn transform_point(&self, pt: &Point<T, D>) -> Point<T, D> {
         self * pt
     }
 
@@ -364,7 +347,7 @@ where
     /// assert_relative_eq!(transformed_point, Vector3::new(3.0, 2.0, -1.0), epsilon = 1.0e-6);
     /// ```
     #[inline]
-    pub fn transform_vector(&self, v: &VectorN<N, D>) -> VectorN<N, D> {
+    pub fn transform_vector(&self, v: &SVector<T, D>) -> SVector<T, D> {
         self * v
     }
 
@@ -386,7 +369,7 @@ where
     /// assert_relative_eq!(transformed_point, Point3::new(0.0, 2.0, 1.0), epsilon = 1.0e-6);
     /// ```
     #[inline]
-    pub fn inverse_transform_point(&self, pt: &Point<N, D>) -> Point<N, D> {
+    pub fn inverse_transform_point(&self, pt: &Point<T, D>) -> Point<T, D> {
         self.rotation
             .inverse_transform_point(&(pt - &self.translation.vector))
     }
@@ -410,7 +393,7 @@ where
     /// assert_relative_eq!(transformed_point, Vector3::new(-3.0, 2.0, 1.0), epsilon = 1.0e-6);
     /// ```
     #[inline]
-    pub fn inverse_transform_vector(&self, v: &VectorN<N, D>) -> VectorN<N, D> {
+    pub fn inverse_transform_vector(&self, v: &SVector<T, D>) -> SVector<T, D> {
         self.rotation.inverse_transform_vector(v)
     }
 
@@ -433,7 +416,7 @@ where
     /// assert_relative_eq!(transformed_point, -Vector3::y_axis(), epsilon = 1.0e-6);
     /// ```
     #[inline]
-    pub fn inverse_transform_unit_vector(&self, v: &Unit<VectorN<N, D>>) -> Unit<VectorN<N, D>> {
+    pub fn inverse_transform_unit_vector(&self, v: &Unit<SVector<T, D>>) -> Unit<SVector<T, D>> {
         self.rotation.inverse_transform_unit_vector(v)
     }
 }
@@ -443,10 +426,7 @@ where
 // This is OK since all constructors of the isometry enforce the Rotation bound already (and
 // explicit struct construction is prevented by the dummy ZST field).
 /// # Conversion to a matrix
-impl<N: SimdRealField, D: DimName, R> Isometry<N, D, R>
-where
-    DefaultAllocator: Allocator<N, D>,
-{
+impl<T: SimdRealField, R, const D: usize> Isometry<T, R, D> {
     /// Converts this isometry into its equivalent homogeneous transformation matrix.
     ///
     /// This is the same as `self.to_matrix()`.
@@ -465,14 +445,14 @@ where
     /// assert_relative_eq!(iso.to_homogeneous(), expected, epsilon = 1.0e-6);
     /// ```
     #[inline]
-    pub fn to_homogeneous(&self) -> MatrixN<N, DimNameSum<D, U1>>
+    pub fn to_homogeneous(&self) -> OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
     where
-        D: DimNameAdd<U1>,
-        R: SubsetOf<MatrixN<N, DimNameSum<D, U1>>>,
-        DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
+        Const<D>: DimNameAdd<U1>,
+        R: SubsetOf<OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>>,
+        DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
     {
-        let mut res: MatrixN<N, _> = crate::convert_ref(&self.rotation);
-        res.fixed_slice_mut::<D, U1>(0, D::dim())
+        let mut res: OMatrix<T, _, _> = crate::convert_ref(&self.rotation);
+        res.fixed_slice_mut::<D, 1>(0, D)
             .copy_from(&self.translation.vector);
 
         res
@@ -496,27 +476,24 @@ where
     /// assert_relative_eq!(iso.to_matrix(), expected, epsilon = 1.0e-6);
     /// ```
     #[inline]
-    pub fn to_matrix(&self) -> MatrixN<N, DimNameSum<D, U1>>
+    pub fn to_matrix(&self) -> OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
     where
-        D: DimNameAdd<U1>,
-        R: SubsetOf<MatrixN<N, DimNameSum<D, U1>>>,
-        DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
+        Const<D>: DimNameAdd<U1>,
+        R: SubsetOf<OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>>,
+        DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
     {
         self.to_homogeneous()
     }
 }
 
-impl<N: SimdRealField, D: DimName, R> Eq for Isometry<N, D, R>
-where
-    R: AbstractRotation<N, D> + Eq,
-    DefaultAllocator: Allocator<N, D>,
+impl<T: SimdRealField, R, const D: usize> Eq for Isometry<T, R, D> where
+    R: AbstractRotation<T, D> + Eq
 {
 }
 
-impl<N: SimdRealField, D: DimName, R> PartialEq for Isometry<N, D, R>
+impl<T: SimdRealField, R, const D: usize> PartialEq for Isometry<T, R, D>
 where
-    R: AbstractRotation<N, D> + PartialEq,
-    DefaultAllocator: Allocator<N, D>,
+    R: AbstractRotation<T, D> + PartialEq,
 {
     #[inline]
     fn eq(&self, right: &Self) -> bool {
@@ -524,17 +501,16 @@ where
     }
 }
 
-impl<N: RealField, D: DimName, R> AbsDiffEq for Isometry<N, D, R>
+impl<T: RealField, R, const D: usize> AbsDiffEq for Isometry<T, R, D>
 where
-    R: AbstractRotation<N, D> + AbsDiffEq<Epsilon = N::Epsilon>,
-    DefaultAllocator: Allocator<N, D>,
-    N::Epsilon: Copy,
+    R: AbstractRotation<T, D> + AbsDiffEq<Epsilon = T::Epsilon>,
+    T::Epsilon: Copy,
 {
-    type Epsilon = N::Epsilon;
+    type Epsilon = T::Epsilon;
 
     #[inline]
     fn default_epsilon() -> Self::Epsilon {
-        N::default_epsilon()
+        T::default_epsilon()
     }
 
     #[inline]
@@ -544,15 +520,14 @@ where
     }
 }
 
-impl<N: RealField, D: DimName, R> RelativeEq for Isometry<N, D, R>
+impl<T: RealField, R, const D: usize> RelativeEq for Isometry<T, R, D>
 where
-    R: AbstractRotation<N, D> + RelativeEq<Epsilon = N::Epsilon>,
-    DefaultAllocator: Allocator<N, D>,
-    N::Epsilon: Copy,
+    R: AbstractRotation<T, D> + RelativeEq<Epsilon = T::Epsilon>,
+    T::Epsilon: Copy,
 {
     #[inline]
     fn default_max_relative() -> Self::Epsilon {
-        N::default_max_relative()
+        T::default_max_relative()
     }
 
     #[inline]
@@ -570,15 +545,14 @@ where
     }
 }
 
-impl<N: RealField, D: DimName, R> UlpsEq for Isometry<N, D, R>
+impl<T: RealField, R, const D: usize> UlpsEq for Isometry<T, R, D>
 where
-    R: AbstractRotation<N, D> + UlpsEq<Epsilon = N::Epsilon>,
-    DefaultAllocator: Allocator<N, D>,
-    N::Epsilon: Copy,
+    R: AbstractRotation<T, D> + UlpsEq<Epsilon = T::Epsilon>,
+    T::Epsilon: Copy,
 {
     #[inline]
     fn default_max_ulps() -> u32 {
-        N::default_max_ulps()
+        T::default_max_ulps()
     }
 
     #[inline]
@@ -594,10 +568,9 @@ where
  * Display
  *
  */
-impl<N: RealField + fmt::Display, D: DimName, R> fmt::Display for Isometry<N, D, R>
+impl<T: RealField + fmt::Display, R, const D: usize> fmt::Display for Isometry<T, R, D>
 where
     R: fmt::Display,
-    DefaultAllocator: Allocator<N, D> + Allocator<usize, D>,
 {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let precision = f.precision().unwrap_or(3);
diff --git a/src/geometry/isometry_alias.rs b/src/geometry/isometry_alias.rs
index 8eecd3ee..98206812 100644
--- a/src/geometry/isometry_alias.rs
+++ b/src/geometry/isometry_alias.rs
@@ -1,5 +1,3 @@
-use crate::base::dimension::{U2, U3};
-
 use crate::geometry::{Isometry, Rotation2, Rotation3, UnitComplex, UnitQuaternion};
 
 /// A 2-dimensional direct isometry using a unit complex number for its rotational part.
@@ -8,28 +6,28 @@ use crate::geometry::{Isometry, Rotation2, Rotation3, UnitComplex, UnitQuaternio
 ///
 /// Also known as a 2D rigid-body motion, or as an element of SE(2).
 
-pub type Isometry2<N> = Isometry<N, U2, UnitComplex<N>>;
+pub type Isometry2<T> = Isometry<T, UnitComplex<T>, 2>;
 
 /// A 3-dimensional direct isometry using a unit quaternion for its rotational part.
 ///
 /// **Because this is an alias, not all its methods are listed here. See the [`Isometry`](crate::Isometry) type too.**
 ///
 /// Also known as a rigid-body motion, or as an element of SE(3).
-pub type Isometry3<N> = Isometry<N, U3, UnitQuaternion<N>>;
+pub type Isometry3<T> = Isometry<T, UnitQuaternion<T>, 3>;
 
 /// A 2-dimensional direct isometry using a rotation matrix for its rotational part.
 ///
 /// **Because this is an alias, not all its methods are listed here. See the [`Isometry`](crate::Isometry) type too.**
 ///
 /// Also known as a rigid-body motion, or as an element of SE(2).
-pub type IsometryMatrix2<N> = Isometry<N, U2, Rotation2<N>>;
+pub type IsometryMatrix2<T> = Isometry<T, Rotation2<T>, 2>;
 
 /// A 3-dimensional direct isometry using a rotation matrix for its rotational part.
 ///
 /// **Because this is an alias, not all its methods are listed here. See the [`Isometry`](crate::Isometry) type too.**
 ///
 /// Also known as a rigid-body motion, or as an element of SE(3).
-pub type IsometryMatrix3<N> = Isometry<N, U3, Rotation3<N>>;
+pub type IsometryMatrix3<T> = Isometry<T, Rotation3<T>, 3>;
 
 // This tests that the types correctly implement `Copy`, without having to run tests
 // (when targeting no-std for example).
diff --git a/src/geometry/isometry_construction.rs b/src/geometry/isometry_construction.rs
index 1edf269b..e13bde29 100644
--- a/src/geometry/isometry_construction.rs
+++ b/src/geometry/isometry_construction.rs
@@ -13,9 +13,7 @@ use rand::{
 use simba::scalar::SupersetOf;
 use simba::simd::SimdRealField;
 
-use crate::base::allocator::Allocator;
-use crate::base::dimension::{DimName, U2};
-use crate::base::{DefaultAllocator, Vector2, Vector3};
+use crate::base::{Vector2, Vector3};
 
 use crate::{
     AbstractRotation, Isometry, Isometry2, Isometry3, IsometryMatrix2, IsometryMatrix3, Point,
@@ -23,10 +21,9 @@ use crate::{
     UnitQuaternion,
 };
 
-impl<N: SimdRealField, D: DimName, R: AbstractRotation<N, D>> Isometry<N, D, R>
+impl<T: SimdRealField, R: AbstractRotation<T, D>, const D: usize> Isometry<T, R, D>
 where
-    N::Element: SimdRealField,
-    DefaultAllocator: Allocator<N, D>,
+    T::Element: SimdRealField,
 {
     /// Creates a new identity isometry.
     ///
@@ -65,16 +62,15 @@ where
     /// assert_relative_eq!(iso * Point2::new(1.0, 2.0), Point2::new(1.0, -2.0), epsilon = 1.0e-6);
     /// ```
     #[inline]
-    pub fn rotation_wrt_point(r: R, p: Point<N, D>) -> Self {
+    pub fn rotation_wrt_point(r: R, p: Point<T, D>) -> Self {
         let shift = r.transform_vector(&-&p.coords);
         Self::from_parts(Translation::from(shift + p.coords), r)
     }
 }
 
-impl<N: SimdRealField, D: DimName, R: AbstractRotation<N, D>> One for Isometry<N, D, R>
+impl<T: SimdRealField, R: AbstractRotation<T, D>, const D: usize> One for Isometry<T, R, D>
 where
-    N::Element: SimdRealField,
-    DefaultAllocator: Allocator<N, D>,
+    T::Element: SimdRealField,
 {
     /// Creates a new identity isometry.
     #[inline]
@@ -84,26 +80,24 @@ where
 }
 
 #[cfg(feature = "rand-no-std")]
-impl<N: crate::RealField, D: DimName, R> Distribution<Isometry<N, D, R>> for Standard
+impl<T: crate::RealField, R, const D: usize> Distribution<Isometry<T, R, D>> for Standard
 where
-    R: AbstractRotation<N, D>,
-    Standard: Distribution<N> + Distribution<R>,
-    DefaultAllocator: Allocator<N, D>,
+    R: AbstractRotation<T, D>,
+    Standard: Distribution<T> + Distribution<R>,
 {
     #[inline]
-    fn sample<'a, G: Rng + ?Sized>(&self, rng: &'a mut G) -> Isometry<N, D, R> {
+    fn sample<'a, G: Rng + ?Sized>(&self, rng: &'a mut G) -> Isometry<T, R, D> {
         Isometry::from_parts(rng.gen(), rng.gen())
     }
 }
 
 #[cfg(feature = "arbitrary")]
-impl<N, D: DimName, R> Arbitrary for Isometry<N, D, R>
+impl<T, R, const D: usize> Arbitrary for Isometry<T, R, D>
 where
-    N: SimdRealField + Arbitrary + Send,
-    N::Element: SimdRealField,
-    R: AbstractRotation<N, D> + Arbitrary + Send,
-    Owned<N, D>: Send,
-    DefaultAllocator: Allocator<N, D>,
+    T: SimdRealField + Arbitrary + Send,
+    T::Element: SimdRealField,
+    R: AbstractRotation<T, D> + Arbitrary + Send,
+    Owned<T, crate::Const<D>>: Send,
 {
     #[inline]
     fn arbitrary(rng: &mut Gen) -> Self {
@@ -118,9 +112,9 @@ where
  */
 
 /// # Construction from a 2D vector and/or a rotation angle
-impl<N: SimdRealField> IsometryMatrix2<N>
+impl<T: SimdRealField> IsometryMatrix2<T>
 where
-    N::Element: SimdRealField,
+    T::Element: SimdRealField,
 {
     /// Creates a new 2D isometry from a translation and a rotation angle.
     ///
@@ -136,22 +130,19 @@ where
     /// assert_eq!(iso * Point2::new(3.0, 4.0), Point2::new(-3.0, 5.0));
     /// ```
     #[inline]
-    pub fn new(translation: Vector2<N>, angle: N) -> Self {
-        Self::from_parts(
-            Translation::from(translation),
-            Rotation::<N, U2>::new(angle),
-        )
+    pub fn new(translation: Vector2<T>, angle: T) -> Self {
+        Self::from_parts(Translation::from(translation), Rotation::<T, 2>::new(angle))
     }
 
     /// Creates a new isometry from the given translation coordinates.
     #[inline]
-    pub fn translation(x: N, y: N) -> Self {
-        Self::new(Vector2::new(x, y), N::zero())
+    pub fn translation(x: T, y: T) -> Self {
+        Self::new(Vector2::new(x, y), T::zero())
     }
 
     /// Creates a new isometry from the given rotation angle.
     #[inline]
-    pub fn rotation(angle: N) -> Self {
+    pub fn rotation(angle: T) -> Self {
         Self::new(Vector2::zeros(), angle)
     }
 
@@ -172,9 +163,9 @@ where
     }
 }
 
-impl<N: SimdRealField> Isometry2<N>
+impl<T: SimdRealField> Isometry2<T>
 where
-    N::Element: SimdRealField,
+    T::Element: SimdRealField,
 {
     /// Creates a new 2D isometry from a translation and a rotation angle.
     ///
@@ -190,7 +181,7 @@ where
     /// assert_eq!(iso * Point2::new(3.0, 4.0), Point2::new(-3.0, 5.0));
     /// ```
     #[inline]
-    pub fn new(translation: Vector2<N>, angle: N) -> Self {
+    pub fn new(translation: Vector2<T>, angle: T) -> Self {
         Self::from_parts(
             Translation::from(translation),
             UnitComplex::from_angle(angle),
@@ -199,13 +190,13 @@ where
 
     /// Creates a new isometry from the given translation coordinates.
     #[inline]
-    pub fn translation(x: N, y: N) -> Self {
+    pub fn translation(x: T, y: T) -> Self {
         Self::from_parts(Translation2::new(x, y), UnitComplex::identity())
     }
 
     /// Creates a new isometry from the given rotation angle.
     #[inline]
-    pub fn rotation(angle: N) -> Self {
+    pub fn rotation(angle: T) -> Self {
         Self::new(Vector2::zeros(), angle)
     }
 
@@ -254,7 +245,7 @@ macro_rules! basic_isometry_construction_impl(
         /// assert_relative_eq!(iso * vec, Vector3::new(6.0, 5.0, -4.0), epsilon = 1.0e-6);
         /// ```
         #[inline]
-        pub fn new(translation: Vector3<N>, axisangle: Vector3<N>) -> Self {
+        pub fn new(translation: Vector3<T>, axisangle: Vector3<T>) -> Self {
             Self::from_parts(
                 Translation::from(translation),
                 $RotId::<$($RotParams),*>::from_scaled_axis(axisangle))
@@ -262,13 +253,13 @@ macro_rules! basic_isometry_construction_impl(
 
         /// Creates a new isometry from the given translation coordinates.
         #[inline]
-        pub fn translation(x: N, y: N, z: N) -> Self {
+        pub fn translation(x: T, y: T, z: T) -> Self {
             Self::from_parts(Translation3::new(x, y, z), $RotId::identity())
         }
 
         /// Creates a new isometry from the given rotation angle.
         #[inline]
-        pub fn rotation(axisangle: Vector3<N>) -> Self {
+        pub fn rotation(axisangle: Vector3<T>) -> Self {
             Self::new(Vector3::zeros(), axisangle)
         }
     }
@@ -308,9 +299,9 @@ macro_rules! look_at_isometry_construction_impl(
         /// assert_relative_eq!(iso * Vector3::z(), Vector3::x());
         /// ```
         #[inline]
-        pub fn face_towards(eye:    &Point3<N>,
-                            target: &Point3<N>,
-                            up:     &Vector3<N>)
+        pub fn face_towards(eye:    &Point3<T>,
+                            target: &Point3<T>,
+                            up:     &Vector3<T>)
                             -> Self {
             Self::from_parts(
                 Translation::from(eye.coords.clone()),
@@ -319,9 +310,9 @@ macro_rules! look_at_isometry_construction_impl(
 
         /// Deprecated: Use [Isometry::face_towards] instead.
         #[deprecated(note="renamed to `face_towards`")]
-        pub fn new_observer_frame(eye:    &Point3<N>,
-                                  target: &Point3<N>,
-                                  up:     &Vector3<N>)
+        pub fn new_observer_frame(eye:    &Point3<T>,
+                                  target: &Point3<T>,
+                                  up:     &Vector3<T>)
                                   -> Self {
             Self::face_towards(eye, target, up)
         }
@@ -359,9 +350,9 @@ macro_rules! look_at_isometry_construction_impl(
         /// assert_relative_eq!(iso * Vector3::x(), -Vector3::z());
         /// ```
         #[inline]
-        pub fn look_at_rh(eye:    &Point3<N>,
-                          target: &Point3<N>,
-                          up:     &Vector3<N>)
+        pub fn look_at_rh(eye:    &Point3<T>,
+                          target: &Point3<T>,
+                          up:     &Vector3<T>)
                           -> Self {
             let rotation = $RotId::look_at_rh(&(target - eye), up);
             let trans    = &rotation * (-eye);
@@ -402,9 +393,9 @@ macro_rules! look_at_isometry_construction_impl(
         /// assert_relative_eq!(iso * Vector3::x(), Vector3::z());
         /// ```
         #[inline]
-        pub fn look_at_lh(eye:    &Point3<N>,
-                          target: &Point3<N>,
-                          up:     &Vector3<N>)
+        pub fn look_at_lh(eye:    &Point3<T>,
+                          target: &Point3<T>,
+                          up:     &Vector3<T>)
                           -> Self {
             let rotation = $RotId::look_at_lh(&(target - eye), up);
             let trans    = &rotation * (-eye);
@@ -415,11 +406,11 @@ macro_rules! look_at_isometry_construction_impl(
 );
 
 /// # Construction from a 3D vector and/or an axis-angle
-impl<N: SimdRealField> Isometry3<N>
+impl<T: SimdRealField> Isometry3<T>
 where
-    N::Element: SimdRealField,
+    T::Element: SimdRealField,
 {
-    basic_isometry_construction_impl!(UnitQuaternion<N>);
+    basic_isometry_construction_impl!(UnitQuaternion<T>);
 
     /// Cast the components of `self` to another type.
     ///
@@ -438,11 +429,11 @@ where
     }
 }
 
-impl<N: SimdRealField> IsometryMatrix3<N>
+impl<T: SimdRealField> IsometryMatrix3<T>
 where
-    N::Element: SimdRealField,
+    T::Element: SimdRealField,
 {
-    basic_isometry_construction_impl!(Rotation3<N>);
+    basic_isometry_construction_impl!(Rotation3<T>);
 
     /// Cast the components of `self` to another type.
     ///
@@ -462,16 +453,16 @@ where
 }
 
 /// # Construction from a 3D eye position and target point
-impl<N: SimdRealField> Isometry3<N>
+impl<T: SimdRealField> Isometry3<T>
 where
-    N::Element: SimdRealField,
+    T::Element: SimdRealField,
 {
-    look_at_isometry_construction_impl!(UnitQuaternion<N>);
+    look_at_isometry_construction_impl!(UnitQuaternion<T>);
 }
 
-impl<N: SimdRealField> IsometryMatrix3<N>
+impl<T: SimdRealField> IsometryMatrix3<T>
 where
-    N::Element: SimdRealField,
+    T::Element: SimdRealField,
 {
-    look_at_isometry_construction_impl!(Rotation3<N>);
+    look_at_isometry_construction_impl!(Rotation3<T>);
 }
diff --git a/src/geometry/isometry_conversion.rs b/src/geometry/isometry_conversion.rs
index 0c89958a..b8cc4568 100644
--- a/src/geometry/isometry_conversion.rs
+++ b/src/geometry/isometry_conversion.rs
@@ -2,8 +2,8 @@ use simba::scalar::{RealField, SubsetOf, SupersetOf};
 use simba::simd::{PrimitiveSimdValue, SimdRealField, SimdValue};
 
 use crate::base::allocator::Allocator;
-use crate::base::dimension::{DimMin, DimName, DimNameAdd, DimNameSum, U1};
-use crate::base::{DefaultAllocator, MatrixN, Scalar};
+use crate::base::dimension::{DimMin, DimNameAdd, DimNameSum, U1};
+use crate::base::{Const, DefaultAllocator, OMatrix, Scalar};
 
 use crate::geometry::{
     AbstractRotation, Isometry, Isometry3, Similarity, SuperTCategoryOf, TAffine, Transform,
@@ -21,27 +21,26 @@ use crate::geometry::{
  * Isometry -> Matrix (homogeneous)
  */
 
-impl<N1, N2, D: DimName, R1, R2> SubsetOf<Isometry<N2, D, R2>> for Isometry<N1, D, R1>
+impl<T1, T2, R1, R2, const D: usize> SubsetOf<Isometry<T2, R2, D>> for Isometry<T1, R1, D>
 where
-    N1: RealField,
-    N2: RealField + SupersetOf<N1>,
-    R1: AbstractRotation<N1, D> + SubsetOf<R2>,
-    R2: AbstractRotation<N2, D>,
-    DefaultAllocator: Allocator<N1, D> + Allocator<N2, D>,
+    T1: RealField,
+    T2: RealField + SupersetOf<T1>,
+    R1: AbstractRotation<T1, D> + SubsetOf<R2>,
+    R2: AbstractRotation<T2, D>,
 {
     #[inline]
-    fn to_superset(&self) -> Isometry<N2, D, R2> {
+    fn to_superset(&self) -> Isometry<T2, R2, D> {
         Isometry::from_parts(self.translation.to_superset(), self.rotation.to_superset())
     }
 
     #[inline]
-    fn is_in_subset(iso: &Isometry<N2, D, R2>) -> bool {
-        crate::is_convertible::<_, Translation<N1, D>>(&iso.translation)
+    fn is_in_subset(iso: &Isometry<T2, R2, D>) -> bool {
+        crate::is_convertible::<_, Translation<T1, D>>(&iso.translation)
             && crate::is_convertible::<_, R1>(&iso.rotation)
     }
 
     #[inline]
-    fn from_superset_unchecked(iso: &Isometry<N2, D, R2>) -> Self {
+    fn from_superset_unchecked(iso: &Isometry<T2, R2, D>) -> Self {
         Isometry::from_parts(
             iso.translation.to_subset_unchecked(),
             iso.rotation.to_subset_unchecked(),
@@ -49,126 +48,126 @@ where
     }
 }
 
-impl<N1, N2> SubsetOf<UnitDualQuaternion<N2>> for Isometry3<N1>
+impl<T1, T2> SubsetOf<UnitDualQuaternion<T2>> for Isometry3<T1>
 where
-    N1: RealField,
-    N2: RealField + SupersetOf<N1>,
+    T1: RealField,
+    T2: RealField + SupersetOf<T1>,
 {
     #[inline]
-    fn to_superset(&self) -> UnitDualQuaternion<N2> {
-        let dq = UnitDualQuaternion::<N1>::from_isometry(self);
+    fn to_superset(&self) -> UnitDualQuaternion<T2> {
+        let dq = UnitDualQuaternion::<T1>::from_isometry(self);
         dq.to_superset()
     }
 
     #[inline]
-    fn is_in_subset(dq: &UnitDualQuaternion<N2>) -> bool {
-        crate::is_convertible::<_, UnitQuaternion<N1>>(&dq.rotation())
-            && crate::is_convertible::<_, Translation<N1, _>>(&dq.translation())
+    fn is_in_subset(dq: &UnitDualQuaternion<T2>) -> bool {
+        crate::is_convertible::<_, UnitQuaternion<T1>>(&dq.rotation())
+            && crate::is_convertible::<_, Translation<T1, 3>>(&dq.translation())
     }
 
     #[inline]
-    fn from_superset_unchecked(dq: &UnitDualQuaternion<N2>) -> Self {
-        let dq: UnitDualQuaternion<N1> = crate::convert_ref_unchecked(dq);
+    fn from_superset_unchecked(dq: &UnitDualQuaternion<T2>) -> Self {
+        let dq: UnitDualQuaternion<T1> = crate::convert_ref_unchecked(dq);
         dq.to_isometry()
     }
 }
 
-impl<N1, N2, D: DimName, R1, R2> SubsetOf<Similarity<N2, D, R2>> for Isometry<N1, D, R1>
+impl<T1, T2, R1, R2, const D: usize> SubsetOf<Similarity<T2, R2, D>> for Isometry<T1, R1, D>
 where
-    N1: RealField,
-    N2: RealField + SupersetOf<N1>,
-    R1: AbstractRotation<N1, D> + SubsetOf<R2>,
-    R2: AbstractRotation<N2, D>,
-    DefaultAllocator: Allocator<N1, D> + Allocator<N2, D>,
+    T1: RealField,
+    T2: RealField + SupersetOf<T1>,
+    R1: AbstractRotation<T1, D> + SubsetOf<R2>,
+    R2: AbstractRotation<T2, D>,
 {
     #[inline]
-    fn to_superset(&self) -> Similarity<N2, D, R2> {
-        Similarity::from_isometry(self.to_superset(), N2::one())
+    fn to_superset(&self) -> Similarity<T2, R2, D> {
+        Similarity::from_isometry(self.to_superset(), T2::one())
     }
 
     #[inline]
-    fn is_in_subset(sim: &Similarity<N2, D, R2>) -> bool {
-        crate::is_convertible::<_, Isometry<N1, D, R1>>(&sim.isometry) && sim.scaling() == N2::one()
+    fn is_in_subset(sim: &Similarity<T2, R2, D>) -> bool {
+        crate::is_convertible::<_, Isometry<T1, R1, D>>(&sim.isometry) && sim.scaling() == T2::one()
     }
 
     #[inline]
-    fn from_superset_unchecked(sim: &Similarity<N2, D, R2>) -> Self {
+    fn from_superset_unchecked(sim: &Similarity<T2, R2, D>) -> Self {
         crate::convert_ref_unchecked(&sim.isometry)
     }
 }
 
-impl<N1, N2, D, R, C> SubsetOf<Transform<N2, D, C>> for Isometry<N1, D, R>
+impl<T1, T2, R, C, const D: usize> SubsetOf<Transform<T2, C, D>> for Isometry<T1, R, D>
 where
-    N1: RealField,
-    N2: RealField + SupersetOf<N1>,
+    T1: RealField,
+    T2: RealField + SupersetOf<T1>,
     C: SuperTCategoryOf<TAffine>,
-    R: AbstractRotation<N1, D>
-        + SubsetOf<MatrixN<N1, DimNameSum<D, U1>>>
-        + SubsetOf<MatrixN<N2, DimNameSum<D, U1>>>,
-    D: DimNameAdd<U1> + DimMin<D, Output = D>, // needed by .is_special_orthogonal()
-    DefaultAllocator: Allocator<N1, D>
-        + Allocator<N1, D, D>
-        + Allocator<N1, DimNameSum<D, U1>, DimNameSum<D, U1>>
-        + Allocator<N2, DimNameSum<D, U1>, DimNameSum<D, U1>>
-        + Allocator<N2, DimNameSum<D, U1>, DimNameSum<D, U1>>
-        + Allocator<(usize, usize), D>
-        + Allocator<N2, D, D>
-        + Allocator<N2, D>,
+    R: AbstractRotation<T1, D>
+        + SubsetOf<OMatrix<T1, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>>
+        + SubsetOf<OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>>,
+    Const<D>: DimNameAdd<U1> + DimMin<Const<D>, Output = Const<D>>, // needed by .is_special_orthogonal()
+    DefaultAllocator: Allocator<T1, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
+        + Allocator<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
+        + Allocator<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
+    // + Allocator<T1, D>
+    // + Allocator<(usize, usize), D>
+    // + Allocator<T2, D, D>
+    // + Allocator<T2, D>
 {
     #[inline]
-    fn to_superset(&self) -> Transform<N2, D, C> {
+    fn to_superset(&self) -> Transform<T2, C, D> {
         Transform::from_matrix_unchecked(self.to_homogeneous().to_superset())
     }
 
     #[inline]
-    fn is_in_subset(t: &Transform<N2, D, C>) -> bool {
+    fn is_in_subset(t: &Transform<T2, C, D>) -> bool {
         <Self as SubsetOf<_>>::is_in_subset(t.matrix())
     }
 
     #[inline]
-    fn from_superset_unchecked(t: &Transform<N2, D, C>) -> Self {
+    fn from_superset_unchecked(t: &Transform<T2, C, D>) -> Self {
         Self::from_superset_unchecked(t.matrix())
     }
 }
 
-impl<N1, N2, D, R> SubsetOf<MatrixN<N2, DimNameSum<D, U1>>> for Isometry<N1, D, R>
+impl<T1, T2, R, const D: usize>
+    SubsetOf<OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>> for Isometry<T1, R, D>
 where
-    N1: RealField,
-    N2: RealField + SupersetOf<N1>,
-    R: AbstractRotation<N1, D>
-        + SubsetOf<MatrixN<N1, DimNameSum<D, U1>>>
-        + SubsetOf<MatrixN<N2, DimNameSum<D, U1>>>,
-    D: DimNameAdd<U1> + DimMin<D, Output = D>, // needed by .is_special_orthogonal()
-    DefaultAllocator: Allocator<N1, D>
-        + Allocator<N1, D, D>
-        + Allocator<N1, DimNameSum<D, U1>, DimNameSum<D, U1>>
-        + Allocator<N2, DimNameSum<D, U1>, DimNameSum<D, U1>>
-        + Allocator<N2, DimNameSum<D, U1>, DimNameSum<D, U1>>
-        + Allocator<(usize, usize), D>
-        + Allocator<N2, D, D>
-        + Allocator<N2, D>,
+    T1: RealField,
+    T2: RealField + SupersetOf<T1>,
+    R: AbstractRotation<T1, D>
+        + SubsetOf<OMatrix<T1, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>>
+        + SubsetOf<OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>>,
+    Const<D>: DimNameAdd<U1> + DimMin<Const<D>, Output = Const<D>>, // needed by .is_special_orthogonal()
+    DefaultAllocator: Allocator<T1, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
+        + Allocator<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
+        + Allocator<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>, // + Allocator<(usize, usize), D>
+                                                                             // + Allocator<T2, D, D>
+                                                                             // + Allocator<T2, D>
+                                                                             // + Allocator<T1, D>
+                                                                             // + Allocator<T1, D, D>
 {
     #[inline]
-    fn to_superset(&self) -> MatrixN<N2, DimNameSum<D, U1>> {
+    fn to_superset(&self) -> OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> {
         self.to_homogeneous().to_superset()
     }
 
     #[inline]
-    fn is_in_subset(m: &MatrixN<N2, DimNameSum<D, U1>>) -> bool {
+    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::<U1, D>(D::dim(), 0);
+        let bottom = m.fixed_slice::<1, D>(D, 0);
 
         // Scalar types agree.
-        m.iter().all(|e| SupersetOf::<N1>::is_in_subset(e)) &&
+        m.iter().all(|e| SupersetOf::<T1>::is_in_subset(e)) &&
         // The block part is a rotation.
-        rot.is_special_orthogonal(N2::default_epsilon() * crate::convert(100.0)) &&
+        rot.is_special_orthogonal(T2::default_epsilon() * crate::convert(100.0)) &&
         // The bottom row is (0, 0, ..., 1)
-        bottom.iter().all(|e| e.is_zero()) && m[(D::dim(), D::dim())] == N2::one()
+        bottom.iter().all(|e| e.is_zero()) && m[(D, D)] == T2::one()
     }
 
     #[inline]
-    fn from_superset_unchecked(m: &MatrixN<N2, DimNameSum<D, U1>>) -> Self {
-        let t = m.fixed_slice::<D, U1>(0, D::dim()).into_owned();
+    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 = Translation {
             vector: crate::convert_unchecked(t),
         };
@@ -177,41 +176,39 @@ where
     }
 }
 
-impl<N: SimdRealField, D: DimName, R: AbstractRotation<N, D>> From<Translation<N, D>>
-    for Isometry<N, D, R>
-where
-    DefaultAllocator: Allocator<N, D>,
+impl<T: SimdRealField, R: AbstractRotation<T, D>, const D: usize> From<Translation<T, D>>
+    for Isometry<T, R, D>
 {
     #[inline]
-    fn from(tra: Translation<N, D>) -> Self {
+    fn from(tra: Translation<T, D>) -> Self {
         Self::from_parts(tra, R::identity())
     }
 }
 
-impl<N: SimdRealField, D: DimName, R> From<Isometry<N, D, R>> for MatrixN<N, DimNameSum<D, U1>>
+impl<T: SimdRealField, R, const D: usize> From<Isometry<T, R, D>>
+    for OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
 where
-    D: DimNameAdd<U1>,
-    R: SubsetOf<MatrixN<N, DimNameSum<D, U1>>>,
-    DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<N, D>,
+    Const<D>: DimNameAdd<U1>,
+    R: SubsetOf<OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>>,
+    DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>, // + Allocator<T, D>,
 {
     #[inline]
-    fn from(iso: Isometry<N, D, R>) -> Self {
+    fn from(iso: Isometry<T, R, D>) -> Self {
         iso.to_homogeneous()
     }
 }
 
-impl<N: Scalar + PrimitiveSimdValue, D: DimName, R> From<[Isometry<N::Element, D, R::Element>; 2]>
-    for Isometry<N, D, R>
+impl<T: Scalar + PrimitiveSimdValue, R, const D: usize>
+    From<[Isometry<T::Element, R::Element, D>; 2]> for Isometry<T, R, D>
 where
-    N: From<[<N as SimdValue>::Element; 2]>,
-    R: SimdValue + AbstractRotation<N, D> + From<[<R as SimdValue>::Element; 2]>,
-    R::Element: AbstractRotation<N::Element, D>,
-    N::Element: Scalar + Copy,
+    T: From<[<T as SimdValue>::Element; 2]>,
+    R: SimdValue + AbstractRotation<T, D> + From<[<R as SimdValue>::Element; 2]>,
+    R::Element: AbstractRotation<T::Element, D>,
+    T::Element: Scalar + Copy,
     R::Element: Scalar + Copy,
-    DefaultAllocator: Allocator<N, D> + Allocator<N::Element, D>,
 {
     #[inline]
-    fn from(arr: [Isometry<N::Element, D, R::Element>; 2]) -> Self {
+    fn from(arr: [Isometry<T::Element, R::Element, D>; 2]) -> Self {
         let tra = Translation::from([arr[0].translation.clone(), arr[1].translation.clone()]);
         let rot = R::from([arr[0].rotation, arr[0].rotation]);
 
@@ -219,18 +216,17 @@ where
     }
 }
 
-impl<N: Scalar + PrimitiveSimdValue, D: DimName, R> From<[Isometry<N::Element, D, R::Element>; 4]>
-    for Isometry<N, D, R>
+impl<T: Scalar + PrimitiveSimdValue, R, const D: usize>
+    From<[Isometry<T::Element, R::Element, D>; 4]> for Isometry<T, R, D>
 where
-    N: From<[<N as SimdValue>::Element; 4]>,
-    R: SimdValue + AbstractRotation<N, D> + From<[<R as SimdValue>::Element; 4]>,
-    R::Element: AbstractRotation<N::Element, D>,
-    N::Element: Scalar + Copy,
+    T: From<[<T as SimdValue>::Element; 4]>,
+    R: SimdValue + AbstractRotation<T, D> + From<[<R as SimdValue>::Element; 4]>,
+    R::Element: AbstractRotation<T::Element, D>,
+    T::Element: Scalar + Copy,
     R::Element: Scalar + Copy,
-    DefaultAllocator: Allocator<N, D> + Allocator<N::Element, D>,
 {
     #[inline]
-    fn from(arr: [Isometry<N::Element, D, R::Element>; 4]) -> Self {
+    fn from(arr: [Isometry<T::Element, R::Element, D>; 4]) -> Self {
         let tra = Translation::from([
             arr[0].translation.clone(),
             arr[1].translation.clone(),
@@ -248,18 +244,17 @@ where
     }
 }
 
-impl<N: Scalar + PrimitiveSimdValue, D: DimName, R> From<[Isometry<N::Element, D, R::Element>; 8]>
-    for Isometry<N, D, R>
+impl<T: Scalar + PrimitiveSimdValue, R, const D: usize>
+    From<[Isometry<T::Element, R::Element, D>; 8]> for Isometry<T, R, D>
 where
-    N: From<[<N as SimdValue>::Element; 8]>,
-    R: SimdValue + AbstractRotation<N, D> + From<[<R as SimdValue>::Element; 8]>,
-    R::Element: AbstractRotation<N::Element, D>,
-    N::Element: Scalar + Copy,
+    T: From<[<T as SimdValue>::Element; 8]>,
+    R: SimdValue + AbstractRotation<T, D> + From<[<R as SimdValue>::Element; 8]>,
+    R::Element: AbstractRotation<T::Element, D>,
+    T::Element: Scalar + Copy,
     R::Element: Scalar + Copy,
-    DefaultAllocator: Allocator<N, D> + Allocator<N::Element, D>,
 {
     #[inline]
-    fn from(arr: [Isometry<N::Element, D, R::Element>; 8]) -> Self {
+    fn from(arr: [Isometry<T::Element, R::Element, D>; 8]) -> Self {
         let tra = Translation::from([
             arr[0].translation.clone(),
             arr[1].translation.clone(),
@@ -285,18 +280,17 @@ where
     }
 }
 
-impl<N: Scalar + PrimitiveSimdValue, D: DimName, R> From<[Isometry<N::Element, D, R::Element>; 16]>
-    for Isometry<N, D, R>
+impl<T: Scalar + PrimitiveSimdValue, R, const D: usize>
+    From<[Isometry<T::Element, R::Element, D>; 16]> for Isometry<T, R, D>
 where
-    N: From<[<N as SimdValue>::Element; 16]>,
-    R: SimdValue + AbstractRotation<N, D> + From<[<R as SimdValue>::Element; 16]>,
-    R::Element: AbstractRotation<N::Element, D>,
-    N::Element: Scalar + Copy,
+    T: From<[<T as SimdValue>::Element; 16]>,
+    R: SimdValue + AbstractRotation<T, D> + From<[<R as SimdValue>::Element; 16]>,
+    R::Element: AbstractRotation<T::Element, D>,
+    T::Element: Scalar + Copy,
     R::Element: Scalar + Copy,
-    DefaultAllocator: Allocator<N, D> + Allocator<N::Element, D>,
 {
     #[inline]
-    fn from(arr: [Isometry<N::Element, D, R::Element>; 16]) -> Self {
+    fn from(arr: [Isometry<T::Element, R::Element, D>; 16]) -> Self {
         let tra = Translation::from([
             arr[0].translation.clone(),
             arr[1].translation.clone(),
diff --git a/src/geometry/isometry_interpolation.rs b/src/geometry/isometry_interpolation.rs
index f58b4115..2ee5461a 100644
--- a/src/geometry/isometry_interpolation.rs
+++ b/src/geometry/isometry_interpolation.rs
@@ -1,7 +1,7 @@
 use crate::{Isometry2, Isometry3, IsometryMatrix2, IsometryMatrix3, RealField, SimdRealField};
 
 /// # Interpolation
-impl<N: SimdRealField> Isometry3<N> {
+impl<T: SimdRealField> Isometry3<T> {
     /// Interpolates between two isometries using a linear interpolation for the translation part,
     /// and a spherical interpolation for the rotation part.
     ///
@@ -26,9 +26,9 @@ impl<N: SimdRealField> Isometry3<N> {
     /// assert_eq!(iso3.rotation.euler_angles(), (std::f32::consts::FRAC_PI_2, 0.0, 0.0));
     /// ```
     #[inline]
-    pub fn lerp_slerp(&self, other: &Self, t: N) -> Self
+    pub fn lerp_slerp(&self, other: &Self, t: T) -> Self
     where
-        N: RealField,
+        T: RealField,
     {
         let tr = self.translation.vector.lerp(&other.translation.vector, t);
         let rot = self.rotation.slerp(&other.rotation, t);
@@ -59,9 +59,9 @@ impl<N: SimdRealField> Isometry3<N> {
     /// assert_eq!(iso3.rotation.euler_angles(), (std::f32::consts::FRAC_PI_2, 0.0, 0.0));
     /// ```
     #[inline]
-    pub fn try_lerp_slerp(&self, other: &Self, t: N, epsilon: N) -> Option<Self>
+    pub fn try_lerp_slerp(&self, other: &Self, t: T, epsilon: T) -> Option<Self>
     where
-        N: RealField,
+        T: RealField,
     {
         let tr = self.translation.vector.lerp(&other.translation.vector, t);
         let rot = self.rotation.try_slerp(&other.rotation, t, epsilon)?;
@@ -69,7 +69,7 @@ impl<N: SimdRealField> Isometry3<N> {
     }
 }
 
-impl<N: SimdRealField> IsometryMatrix3<N> {
+impl<T: SimdRealField> IsometryMatrix3<T> {
     /// Interpolates between two isometries using a linear interpolation for the translation part,
     /// and a spherical interpolation for the rotation part.
     ///
@@ -94,9 +94,9 @@ impl<N: SimdRealField> IsometryMatrix3<N> {
     /// assert_eq!(iso3.rotation.euler_angles(), (std::f32::consts::FRAC_PI_2, 0.0, 0.0));
     /// ```
     #[inline]
-    pub fn lerp_slerp(&self, other: &Self, t: N) -> Self
+    pub fn lerp_slerp(&self, other: &Self, t: T) -> Self
     where
-        N: RealField,
+        T: RealField,
     {
         let tr = self.translation.vector.lerp(&other.translation.vector, t);
         let rot = self.rotation.slerp(&other.rotation, t);
@@ -127,9 +127,9 @@ impl<N: SimdRealField> IsometryMatrix3<N> {
     /// assert_eq!(iso3.rotation.euler_angles(), (std::f32::consts::FRAC_PI_2, 0.0, 0.0));
     /// ```
     #[inline]
-    pub fn try_lerp_slerp(&self, other: &Self, t: N, epsilon: N) -> Option<Self>
+    pub fn try_lerp_slerp(&self, other: &Self, t: T, epsilon: T) -> Option<Self>
     where
-        N: RealField,
+        T: RealField,
     {
         let tr = self.translation.vector.lerp(&other.translation.vector, t);
         let rot = self.rotation.try_slerp(&other.rotation, t, epsilon)?;
@@ -137,7 +137,7 @@ impl<N: SimdRealField> IsometryMatrix3<N> {
     }
 }
 
-impl<N: SimdRealField> Isometry2<N> {
+impl<T: SimdRealField> Isometry2<T> {
     /// Interpolates between two isometries using a linear interpolation for the translation part,
     /// and a spherical interpolation for the rotation part.
     ///
@@ -163,9 +163,9 @@ impl<N: SimdRealField> Isometry2<N> {
     /// assert_relative_eq!(iso3.rotation.angle(), std::f32::consts::FRAC_PI_2);
     /// ```
     #[inline]
-    pub fn lerp_slerp(&self, other: &Self, t: N) -> Self
+    pub fn lerp_slerp(&self, other: &Self, t: T) -> Self
     where
-        N: RealField,
+        T: RealField,
     {
         let tr = self.translation.vector.lerp(&other.translation.vector, t);
         let rot = self.rotation.slerp(&other.rotation, t);
@@ -173,7 +173,7 @@ impl<N: SimdRealField> Isometry2<N> {
     }
 }
 
-impl<N: SimdRealField> IsometryMatrix2<N> {
+impl<T: SimdRealField> IsometryMatrix2<T> {
     /// Interpolates between two isometries using a linear interpolation for the translation part,
     /// and a spherical interpolation for the rotation part.
     ///
@@ -199,9 +199,9 @@ impl<N: SimdRealField> IsometryMatrix2<N> {
     /// assert_relative_eq!(iso3.rotation.angle(), std::f32::consts::FRAC_PI_2);
     /// ```
     #[inline]
-    pub fn lerp_slerp(&self, other: &Self, t: N) -> Self
+    pub fn lerp_slerp(&self, other: &Self, t: T) -> Self
     where
-        N: RealField,
+        T: RealField,
     {
         let tr = self.translation.vector.lerp(&other.translation.vector, t);
         let rot = self.rotation.slerp(&other.rotation, t);
diff --git a/src/geometry/isometry_ops.rs b/src/geometry/isometry_ops.rs
index ecca9bb2..2e6477b5 100644
--- a/src/geometry/isometry_ops.rs
+++ b/src/geometry/isometry_ops.rs
@@ -4,9 +4,7 @@ use std::ops::{Div, DivAssign, Mul, MulAssign};
 use simba::scalar::{ClosedAdd, ClosedMul};
 use simba::simd::SimdRealField;
 
-use crate::base::allocator::Allocator;
-use crate::base::dimension::{DimName, U1, U2, U3, U4};
-use crate::base::{DefaultAllocator, Unit, VectorN};
+use crate::base::{SVector, Unit};
 use crate::Scalar;
 
 use crate::geometry::{
@@ -68,10 +66,9 @@ macro_rules! isometry_binop_impl(
     ($Op: ident, $op: ident;
      $lhs: ident: $Lhs: ty, $rhs: ident: $Rhs: ty, Output = $Output: ty;
      $action: expr; $($lives: tt),*) => {
-        impl<$($lives ,)* N: SimdRealField, D: DimName, R> $Op<$Rhs> for $Lhs
-            where N::Element: SimdRealField,
-                  R: AbstractRotation<N, D>,
-                  DefaultAllocator: Allocator<N, D> {
+        impl<$($lives ,)* T: SimdRealField, R, const D: usize> $Op<$Rhs> for $Lhs
+            where T::Element: SimdRealField,
+                  R: AbstractRotation<T, D>, {
             type Output = $Output;
 
             #[inline]
@@ -116,20 +113,18 @@ macro_rules! isometry_binop_assign_impl_all(
      $lhs: ident: $Lhs: ty, $rhs: ident: $Rhs: ty;
      [val] => $action_val: expr;
      [ref] => $action_ref: expr;) => {
-        impl<N: SimdRealField, D: DimName, R> $OpAssign<$Rhs> for $Lhs
-            where N::Element: SimdRealField,
-                  R: AbstractRotation<N, D>,
-                  DefaultAllocator: Allocator<N, D> {
+        impl<T: SimdRealField, R, const D: usize> $OpAssign<$Rhs> for $Lhs
+            where T::Element: SimdRealField,
+                  R: AbstractRotation<T, D> {
             #[inline]
             fn $op_assign(&mut $lhs, $rhs: $Rhs) {
                 $action_val
             }
         }
 
-        impl<'b, N: SimdRealField, D: DimName, R> $OpAssign<&'b $Rhs> for $Lhs
-            where N::Element: SimdRealField,
-                  R: AbstractRotation<N, D>,
-                  DefaultAllocator: Allocator<N, D> {
+        impl<'b, T: SimdRealField, R, const D: usize> $OpAssign<&'b $Rhs> for $Lhs
+            where T::Element: SimdRealField,
+                  R: AbstractRotation<T, D> {
             #[inline]
             fn $op_assign(&mut $lhs, $rhs: &'b $Rhs) {
                 $action_ref
@@ -142,7 +137,7 @@ macro_rules! isometry_binop_assign_impl_all(
 // Isometry ÷ Isometry
 isometry_binop_impl_all!(
     Mul, mul;
-    self: Isometry<N, D, R>, rhs: Isometry<N, D, R>, Output = Isometry<N, D, R>;
+    self: Isometry<T, R, D>, rhs: Isometry<T, R, D>, Output = Isometry<T, R, D>;
     [val val] => &self * &rhs;
     [ref val] => self * &rhs;
     [val ref] => &self * rhs;
@@ -157,7 +152,7 @@ isometry_binop_impl_all!(
 
 isometry_binop_impl_all!(
     Div, div;
-    self: Isometry<N, D, R>, rhs: Isometry<N, D, R>, Output = Isometry<N, D, R>;
+    self: Isometry<T, R, D>, rhs: Isometry<T, R, D>, Output = Isometry<T, R, D>;
     [val val] => #[allow(clippy::suspicious_arithmetic_impl)] { self * rhs.inverse() };
     [ref val] => #[allow(clippy::suspicious_arithmetic_impl)] { self * rhs.inverse() };
     [val ref] => #[allow(clippy::suspicious_arithmetic_impl)] { self * rhs.inverse() };
@@ -167,7 +162,7 @@ isometry_binop_impl_all!(
 // Isometry ×= Translation
 isometry_binop_assign_impl_all!(
     MulAssign, mul_assign;
-    self: Isometry<N, D, R>, rhs: Translation<N, D>;
+    self: Isometry<T, R, D>, rhs: Translation<T, D>;
     [val] => *self *= &rhs;
     [ref] => #[allow(clippy::suspicious_op_assign_impl)] {
         let shift = self.rotation.transform_vector(&rhs.vector);
@@ -179,7 +174,7 @@ isometry_binop_assign_impl_all!(
 // Isometry ÷= Isometry
 isometry_binop_assign_impl_all!(
     MulAssign, mul_assign;
-    self: Isometry<N, D, R>, rhs: Isometry<N, D, R>;
+    self: Isometry<T, R, D>, rhs: Isometry<T, R, D>;
     [val] => *self *= &rhs;
     [ref] => {
         let shift = self.rotation.transform_vector(&rhs.translation.vector);
@@ -190,7 +185,7 @@ isometry_binop_assign_impl_all!(
 
 isometry_binop_assign_impl_all!(
     DivAssign, div_assign;
-    self: Isometry<N, D, R>, rhs: Isometry<N, D, R>;
+    self: Isometry<T, R, D>, rhs: Isometry<T, R, D>;
     [val] => *self /= &rhs;
     [ref] => #[allow(clippy::suspicious_op_assign_impl)] { *self *= rhs.inverse() };
 );
@@ -198,51 +193,57 @@ isometry_binop_assign_impl_all!(
 // Isometry ×= R
 // Isometry ÷= R
 md_assign_impl_all!(
-    MulAssign, mul_assign where N: SimdRealField for N::Element: SimdRealField;
-    (D, U1), (D, D) for D: DimName;
-    self: Isometry<N, D, Rotation<N, D>>, rhs: Rotation<N, D>;
+    MulAssign, mul_assign where T: SimdRealField for T::Element: SimdRealField;
+    (Const<D>, U1), (Const<D>, Const<D>)
+    const D; for; where;
+    self: Isometry<T, Rotation<T, D>, D>, rhs: Rotation<T, D>;
     [val] => self.rotation *= rhs;
     [ref] => self.rotation *= rhs.clone();
 );
 
 md_assign_impl_all!(
-    DivAssign, div_assign where N: SimdRealField for N::Element: SimdRealField;
-    (D, U1), (D, D) for D: DimName;
-    self: Isometry<N, D, Rotation<N, D>>, rhs: Rotation<N, D>;
+    DivAssign, div_assign where T: SimdRealField for T::Element: SimdRealField;
+    (Const<D>, U1), (Const<D>, Const<D>)
+    const D; for; where;
+    self: Isometry<T, Rotation<T, D>, D>, rhs: Rotation<T, D>;
     // TODO: don't invert explicitly?
     [val] => #[allow(clippy::suspicious_op_assign_impl)] { *self *= rhs.inverse() };
     [ref] => #[allow(clippy::suspicious_op_assign_impl)] { *self *= rhs.inverse() };
 );
 
 md_assign_impl_all!(
-    MulAssign, mul_assign where N: SimdRealField for N::Element: SimdRealField;
-    (U3, U3), (U3, U3) for;
-    self: Isometry<N, U3, UnitQuaternion<N>>, rhs: UnitQuaternion<N>;
+    MulAssign, mul_assign where T: SimdRealField for T::Element: SimdRealField;
+    (U3, U3), (U3, U3)
+    const; for; where;
+    self: Isometry<T, UnitQuaternion<T>, 3>, rhs: UnitQuaternion<T>;
     [val] => self.rotation *= rhs;
     [ref] => self.rotation *= *rhs;
 );
 
 md_assign_impl_all!(
-    DivAssign, div_assign where N: SimdRealField for N::Element: SimdRealField;
-    (U3, U3), (U3, U3) for;
-    self: Isometry<N, U3, UnitQuaternion<N>>, rhs: UnitQuaternion<N>;
+    DivAssign, div_assign where T: SimdRealField for T::Element: SimdRealField;
+    (U3, U3), (U3, U3)
+    const; for; where;
+    self: Isometry<T, UnitQuaternion<T>, 3>, rhs: UnitQuaternion<T>;
     // TODO: don't invert explicitly?
     [val] => #[allow(clippy::suspicious_op_assign_impl)] { *self *= rhs.inverse() };
     [ref] => #[allow(clippy::suspicious_op_assign_impl)] { *self *= rhs.inverse() };
 );
 
 md_assign_impl_all!(
-    MulAssign, mul_assign where N: SimdRealField for N::Element: SimdRealField;
-    (U2, U2), (U2, U2) for;
-    self: Isometry<N, U2, UnitComplex<N>>, rhs: UnitComplex<N>;
+    MulAssign, mul_assign where T: SimdRealField for T::Element: SimdRealField;
+    (U2, U2), (U2, U2)
+    const; for; where;
+    self: Isometry<T, UnitComplex<T>, 2>, rhs: UnitComplex<T>;
     [val] => self.rotation *= rhs;
     [ref] => self.rotation *= *rhs;
 );
 
 md_assign_impl_all!(
-    DivAssign, div_assign where N: SimdRealField for N::Element: SimdRealField;
-    (U2, U2), (U2, U2) for;
-    self: Isometry<N, U2, UnitComplex<N>>, rhs: UnitComplex<N>;
+    DivAssign, div_assign where T: SimdRealField for T::Element: SimdRealField;
+    (U2, U2), (U2, U2)
+    const; for; where;
+    self: Isometry<T, UnitComplex<T>, 2>, rhs: UnitComplex<T>;
     // TODO: don't invert explicitly?
     [val] => #[allow(clippy::suspicious_op_assign_impl)] { *self *= rhs.inverse() };
     [ref] => #[allow(clippy::suspicious_op_assign_impl)] { *self *= rhs.inverse() };
@@ -251,7 +252,7 @@ md_assign_impl_all!(
 // Isometry × Point
 isometry_binop_impl_all!(
     Mul, mul;
-    self: Isometry<N, D, R>, right: Point<N, D>, Output = Point<N, D>;
+    self: Isometry<T, R, D>, right: Point<T, D>, Output = Point<T, D>;
     [val val] => self.translation  * self.rotation.transform_point(&right);
     [ref val] => &self.translation * self.rotation.transform_point(&right);
     [val ref] => self.translation  * self.rotation.transform_point(right);
@@ -262,8 +263,8 @@ isometry_binop_impl_all!(
 isometry_binop_impl_all!(
     Mul, mul;
     // TODO: because of `transform_vector`, we cant use a generic storage type for the rhs vector,
-    // i.e., right: Vector<N, D, S> where S: Storage<N, D>.
-    self: Isometry<N, D, R>, right: VectorN<N, D>, Output = VectorN<N, D>;
+    // i.e., right: Vector<T, D, S> where S: Storage<T, D>.
+    self: Isometry<T, R, D>, right: SVector<T, D>, Output = SVector<T, D>;
     [val val] => self.rotation.transform_vector(&right);
     [ref val] => self.rotation.transform_vector(&right);
     [val ref] => self.rotation.transform_vector(right);
@@ -274,8 +275,8 @@ isometry_binop_impl_all!(
 isometry_binop_impl_all!(
     Mul, mul;
     // TODO: because of `transform_vector`, we cant use a generic storage type for the rhs vector,
-    // i.e., right: Vector<N, D, S> where S: Storage<N, D>.
-    self: Isometry<N, D, R>, right: Unit<VectorN<N, D>>, Output = Unit<VectorN<N, D>>;
+    // i.e., right: Vector<T, D, S> where S: Storage<T, D>.
+    self: Isometry<T, R, D>, right: Unit<SVector<T, D>>, Output = Unit<SVector<T, D>>;
     [val val] => Unit::new_unchecked(self.rotation.transform_vector(right.as_ref()));
     [ref val] => Unit::new_unchecked(self.rotation.transform_vector(right.as_ref()));
     [val ref] => Unit::new_unchecked(self.rotation.transform_vector(right.as_ref()));
@@ -285,7 +286,7 @@ isometry_binop_impl_all!(
 // Isometry × Translation
 isometry_binop_impl_all!(
     Mul, mul;
-    self: Isometry<N, D, R>, right: Translation<N, D>, Output = Isometry<N, D, R>;
+    self: Isometry<T, R, D>, right: Translation<T, D>, Output = Isometry<T, R, D>;
     [val val] => &self * &right;
     [ref val] => self * &right;
     [val ref] => &self * right;
@@ -299,7 +300,7 @@ isometry_binop_impl_all!(
 // Translation × Isometry
 isometry_binop_impl_all!(
     Mul, mul;
-    self: Translation<N, D>, right: Isometry<N, D, R>, Output = Isometry<N, D, R>;
+    self: Translation<T, D>, right: Isometry<T, R, D>, Output = Isometry<T, R, D>;
     [val val] => Isometry::from_parts(self * right.translation, right.rotation);
     [ref val] => Isometry::from_parts(self * &right.translation, right.rotation);
     [val ref] => Isometry::from_parts(self * &right.translation, right.rotation.clone());
@@ -308,13 +309,11 @@ isometry_binop_impl_all!(
 
 macro_rules! isometry_from_composition_impl(
     ($Op: ident, $op: ident;
-     ($R1: ty, $C1: ty),($R2: ty, $C2: ty) $(for $Dims: ident: $DimsBound: ident),*;
+     $($Dims: ident),*;
      $lhs: ident: $Lhs: ty, $rhs: ident: $Rhs: ty, Output = $Output: ty;
      $action: expr; $($lives: tt),*) => {
-        impl<$($lives ,)* N: SimdRealField $(, $Dims: $DimsBound)*> $Op<$Rhs> for $Lhs
-            where N::Element: SimdRealField,
-                  DefaultAllocator: Allocator<N, $R1, $C1> +
-                                    Allocator<N, $R2, $C2> {
+        impl<$($lives ,)* T: SimdRealField $(, const $Dims: usize)*> $Op<$Rhs> for $Lhs
+            where T::Element: SimdRealField {
             type Output = $Output;
 
             #[inline]
@@ -327,7 +326,7 @@ macro_rules! isometry_from_composition_impl(
 
 macro_rules! isometry_from_composition_impl_all(
     ($Op: ident, $op: ident;
-     ($R1: ty, $C1: ty),($R2: ty, $C2: ty) $(for $Dims: ident: $DimsBound: ident),*;
+     $($Dims: ident),*;
      $lhs: ident: $Lhs: ty, $rhs: ident: $Rhs: ty, Output = $Output: ty;
      [val val] => $action_val_val: expr;
      [ref val] => $action_ref_val: expr;
@@ -336,25 +335,25 @@ macro_rules! isometry_from_composition_impl_all(
 
         isometry_from_composition_impl!(
             $Op, $op;
-            ($R1, $C1),($R2, $C2) $(for $Dims: $DimsBound),*;
+            $($Dims),*;
             $lhs: $Lhs, $rhs: $Rhs, Output = $Output;
             $action_val_val; );
 
         isometry_from_composition_impl!(
             $Op, $op;
-            ($R1, $C1),($R2, $C2) $(for $Dims: $DimsBound),*;
+            $($Dims),*;
             $lhs: &'a $Lhs, $rhs: $Rhs, Output = $Output;
             $action_ref_val; 'a);
 
         isometry_from_composition_impl!(
             $Op, $op;
-            ($R1, $C1),($R2, $C2) $(for $Dims: $DimsBound),*;
+            $($Dims),*;
             $lhs: $Lhs, $rhs: &'b $Rhs, Output = $Output;
             $action_val_ref; 'b);
 
         isometry_from_composition_impl!(
             $Op, $op;
-            ($R1, $C1),($R2, $C2) $(for $Dims: $DimsBound),*;
+            $($Dims),*;
             $lhs: &'a $Lhs, $rhs: &'b $Rhs, Output = $Output;
             $action_ref_ref; 'a, 'b);
     }
@@ -363,8 +362,8 @@ macro_rules! isometry_from_composition_impl_all(
 // Rotation × Translation
 isometry_from_composition_impl_all!(
     Mul, mul;
-    (D, D), (D, U1) for D: DimName;
-    self: Rotation<N, D>, right: Translation<N, D>, Output = Isometry<N, D, Rotation<N, D>>;
+    D;
+    self: Rotation<T, D>, right: Translation<T, D>, Output = Isometry<T, Rotation<T, D>, D>;
     [val val] => Isometry::from_parts(Translation::from(&self * right.vector),  self);
     [ref val] => Isometry::from_parts(Translation::from(self * right.vector),   self.clone());
     [val ref] => Isometry::from_parts(Translation::from(&self * &right.vector), self);
@@ -374,9 +373,9 @@ isometry_from_composition_impl_all!(
 // UnitQuaternion × Translation
 isometry_from_composition_impl_all!(
     Mul, mul;
-    (U4, U1), (U3, U1);
-    self: UnitQuaternion<N>, right: Translation<N, U3>,
-    Output = Isometry<N, U3, UnitQuaternion<N>>;
+    ;
+    self: UnitQuaternion<T>, right: Translation<T, 3>,
+    Output = Isometry<T, UnitQuaternion<T>, 3>;
     [val val] => Isometry::from_parts(Translation::from(&self *  right.vector), self);
     [ref val] => Isometry::from_parts(Translation::from( self *  right.vector), *self);
     [val ref] => Isometry::from_parts(Translation::from(&self * &right.vector), self);
@@ -386,9 +385,9 @@ isometry_from_composition_impl_all!(
 // Isometry × Rotation
 isometry_from_composition_impl_all!(
     Mul, mul;
-    (D, D), (D, U1) for D: DimName;
-    self: Isometry<N, D, Rotation<N, D>>, rhs: Rotation<N, D>,
-    Output = Isometry<N, D, Rotation<N, D>>;
+    D;
+    self: Isometry<T, Rotation<T, D>, D>, rhs: Rotation<T, D>,
+    Output = Isometry<T, Rotation<T, D>, D>;
     [val val] => Isometry::from_parts(self.translation, self.rotation * rhs);
     [ref val] => Isometry::from_parts(self.translation.clone(), self.rotation.clone() * rhs); // TODO: do not clone.
     [val ref] => Isometry::from_parts(self.translation, self.rotation * rhs.clone());
@@ -398,9 +397,9 @@ isometry_from_composition_impl_all!(
 // Rotation × Isometry
 isometry_from_composition_impl_all!(
     Mul, mul;
-    (D, D), (D, U1) for D: DimName;
-    self: Rotation<N, D>, right: Isometry<N, D, Rotation<N, D>>,
-    Output = Isometry<N, D, Rotation<N, D>>;
+    D;
+    self: Rotation<T, D>, right: Isometry<T, Rotation<T, D>, D>,
+    Output = Isometry<T, Rotation<T, D>, D>;
     [val val] => &self * &right;
     [ref val] =>  self * &right;
     [val ref] => &self * right;
@@ -413,9 +412,9 @@ isometry_from_composition_impl_all!(
 // Isometry ÷ Rotation
 isometry_from_composition_impl_all!(
     Div, div;
-    (D, D), (D, U1) for D: DimName;
-    self: Isometry<N, D, Rotation<N, D>>, rhs: Rotation<N, D>,
-    Output = Isometry<N, D, Rotation<N, D>>;
+    D;
+    self: Isometry<T, Rotation<T, D>, D>, rhs: Rotation<T, D>,
+    Output = Isometry<T, Rotation<T, D>, D>;
     [val val] => Isometry::from_parts(self.translation, self.rotation / rhs);
     [ref val] => Isometry::from_parts(self.translation.clone(), self.rotation.clone() / rhs); // TODO: do not clone.
     [val ref] => Isometry::from_parts(self.translation, self.rotation / rhs.clone());
@@ -425,9 +424,9 @@ isometry_from_composition_impl_all!(
 // Rotation ÷ Isometry
 isometry_from_composition_impl_all!(
     Div, div;
-    (D, D), (D, U1) for D: DimName;
-    self: Rotation<N, D>, right: Isometry<N, D, Rotation<N, D>>,
-    Output = Isometry<N, D, Rotation<N, D>>;
+    D;
+    self: Rotation<T, D>, right: Isometry<T, Rotation<T, D>, D>,
+    Output = Isometry<T, Rotation<T, D>, D>;
     // TODO: don't call inverse explicitly?
     [val val] => #[allow(clippy::suspicious_arithmetic_impl)] { self * right.inverse() };
     [ref val] => #[allow(clippy::suspicious_arithmetic_impl)] { self * right.inverse() };
@@ -438,9 +437,9 @@ isometry_from_composition_impl_all!(
 // Isometry × UnitQuaternion
 isometry_from_composition_impl_all!(
     Mul, mul;
-    (U4, U1), (U3, U1);
-    self: Isometry<N, U3, UnitQuaternion<N>>, rhs: UnitQuaternion<N>,
-    Output = Isometry<N, U3, UnitQuaternion<N>>;
+    ;
+    self: Isometry<T, UnitQuaternion<T>, 3>, rhs: UnitQuaternion<T>,
+    Output = Isometry<T, UnitQuaternion<T>, 3>;
     [val val] => Isometry::from_parts(self.translation, self.rotation * rhs);
     [ref val] => Isometry::from_parts(self.translation.clone(), self.rotation * rhs); // TODO: do not clone.
     [val ref] => Isometry::from_parts(self.translation, self.rotation * *rhs);
@@ -450,9 +449,9 @@ isometry_from_composition_impl_all!(
 // UnitQuaternion × Isometry
 isometry_from_composition_impl_all!(
     Mul, mul;
-    (U4, U1), (U3, U1);
-    self: UnitQuaternion<N>, right: Isometry<N, U3, UnitQuaternion<N>>,
-    Output = Isometry<N, U3, UnitQuaternion<N>>;
+    ;
+    self: UnitQuaternion<T>, right: Isometry<T, UnitQuaternion<T>, 3>,
+    Output = Isometry<T, UnitQuaternion<T>, 3>;
     [val val] => &self * &right;
     [ref val] =>  self * &right;
     [val ref] => &self * right;
@@ -465,9 +464,9 @@ isometry_from_composition_impl_all!(
 // Isometry ÷ UnitQuaternion
 isometry_from_composition_impl_all!(
     Div, div;
-    (U4, U1), (U3, U1);
-    self: Isometry<N, U3, UnitQuaternion<N>>, rhs: UnitQuaternion<N>,
-    Output = Isometry<N, U3, UnitQuaternion<N>>;
+    ;
+    self: Isometry<T, UnitQuaternion<T>, 3>, rhs: UnitQuaternion<T>,
+    Output = Isometry<T, UnitQuaternion<T>, 3>;
     [val val] => Isometry::from_parts(self.translation, self.rotation / rhs);
     [ref val] => Isometry::from_parts(self.translation.clone(), self.rotation / rhs); // TODO: do not clone.
     [val ref] => Isometry::from_parts(self.translation, self.rotation / *rhs);
@@ -477,9 +476,9 @@ isometry_from_composition_impl_all!(
 // UnitQuaternion ÷ Isometry
 isometry_from_composition_impl_all!(
     Div, div;
-    (U4, U1), (U3, U1);
-    self: UnitQuaternion<N>, right: Isometry<N, U3, UnitQuaternion<N>>,
-    Output = Isometry<N, U3, UnitQuaternion<N>>;
+    ;
+    self: UnitQuaternion<T>, right: Isometry<T, UnitQuaternion<T>, 3>,
+    Output = Isometry<T, UnitQuaternion<T>, 3>;
     // TODO: don't call inverse explicitly?
     [val val] => #[allow(clippy::suspicious_arithmetic_impl)] { self * right.inverse() };
     [ref val] => #[allow(clippy::suspicious_arithmetic_impl)] { self * right.inverse() };
@@ -490,8 +489,8 @@ isometry_from_composition_impl_all!(
 // Translation × Rotation
 isometry_from_composition_impl_all!(
     Mul, mul;
-    (D, D), (D, U1) for D: DimName;
-    self: Translation<N, D>, right: Rotation<N, D>, Output = Isometry<N, D, Rotation<N, D>>;
+    D;
+    self: Translation<T, D>, right: Rotation<T, D>, Output = Isometry<T, Rotation<T, D>, D>;
     [val val] => Isometry::from_parts(self, right);
     [ref val] => Isometry::from_parts(self.clone(), right);
     [val ref] => Isometry::from_parts(self, right.clone());
@@ -501,8 +500,8 @@ isometry_from_composition_impl_all!(
 // Translation × UnitQuaternion
 isometry_from_composition_impl_all!(
     Mul, mul;
-    (U4, U1), (U3, U1);
-    self: Translation<N, U3>, right: UnitQuaternion<N>, Output = Isometry<N, U3, UnitQuaternion<N>>;
+    ;
+    self: Translation<T, 3>, right: UnitQuaternion<T>, Output = Isometry<T, UnitQuaternion<T>, 3>;
     [val val] => Isometry::from_parts(self, right);
     [ref val] => Isometry::from_parts(self.clone(), right);
     [val ref] => Isometry::from_parts(self, *right);
@@ -512,9 +511,9 @@ isometry_from_composition_impl_all!(
 // Isometry × UnitComplex
 isometry_from_composition_impl_all!(
     Mul, mul;
-    (U2, U1), (U2, U1);
-    self: Isometry<N, U2, UnitComplex<N>>, rhs: UnitComplex<N>,
-    Output = Isometry<N, U2, UnitComplex<N>>;
+    ;
+    self: Isometry<T, UnitComplex<T>, 2>, rhs: UnitComplex<T>,
+    Output = Isometry<T, UnitComplex<T>, 2>;
     [val val] => Isometry::from_parts(self.translation, self.rotation * rhs);
     [ref val] => Isometry::from_parts(self.translation.clone(), self.rotation * rhs); // TODO: do not clone.
     [val ref] => Isometry::from_parts(self.translation, self.rotation * *rhs);
@@ -524,9 +523,9 @@ isometry_from_composition_impl_all!(
 // Isometry ÷ UnitComplex
 isometry_from_composition_impl_all!(
     Div, div;
-    (U2, U1), (U2, U1);
-    self: Isometry<N, U2, UnitComplex<N>>, rhs: UnitComplex<N>,
-    Output = Isometry<N, U2, UnitComplex<N>>;
+    ;
+    self: Isometry<T, UnitComplex<T>, 2>, rhs: UnitComplex<T>,
+    Output = Isometry<T, UnitComplex<T>, 2>;
     [val val] => Isometry::from_parts(self.translation, self.rotation / rhs);
     [ref val] => Isometry::from_parts(self.translation.clone(), self.rotation / rhs); // TODO: do not clone.
     [val ref] => Isometry::from_parts(self.translation, self.rotation / *rhs);
diff --git a/src/geometry/isometry_simba.rs b/src/geometry/isometry_simba.rs
index e5d2c839..ad482356 100755
--- a/src/geometry/isometry_simba.rs
+++ b/src/geometry/isometry_simba.rs
@@ -1,25 +1,21 @@
 use simba::simd::SimdValue;
 
-use crate::base::allocator::Allocator;
-use crate::base::dimension::DimName;
-use crate::base::DefaultAllocator;
 use crate::SimdRealField;
 
 use crate::geometry::{AbstractRotation, Isometry, Translation};
 
-impl<N: SimdRealField, D: DimName, R> SimdValue for Isometry<N, D, R>
+impl<T: SimdRealField, R, const D: usize> SimdValue for Isometry<T, R, D>
 where
-    N::Element: SimdRealField,
-    R: SimdValue<SimdBool = N::SimdBool> + AbstractRotation<N, D>,
-    R::Element: AbstractRotation<N::Element, D>,
-    DefaultAllocator: Allocator<N, D> + Allocator<N::Element, D>,
+    T::Element: SimdRealField,
+    R: SimdValue<SimdBool = T::SimdBool> + AbstractRotation<T, D>,
+    R::Element: AbstractRotation<T::Element, D>,
 {
-    type Element = Isometry<N::Element, D, R::Element>;
-    type SimdBool = N::SimdBool;
+    type Element = Isometry<T::Element, R::Element, D>;
+    type SimdBool = T::SimdBool;
 
     #[inline]
     fn lanes() -> usize {
-        N::lanes()
+        T::lanes()
     }
 
     #[inline]
diff --git a/src/geometry/op_macros.rs b/src/geometry/op_macros.rs
index 5a9cfa00..a4775d2a 100644
--- a/src/geometry/op_macros.rs
+++ b/src/geometry/op_macros.rs
@@ -5,23 +5,24 @@
 macro_rules! md_impl(
     (
     // Operator, operator method, and scalar bounds.
-     $Op: ident, $op: ident $(where N: $($ScalarBounds: ident),*)*;
+     $Op: ident, $op: ident $(where T: $($ScalarBounds: ident),*)*;
      // Storage dimensions, and dimension bounds.
-     ($R1: ty, $C1: ty),($R2: ty, $C2: ty) for $($Dims: ident: $DimsBound: ident $(<$($BoundParam: ty),*>)*),+
-     // [Optional] Extra allocator bounds.
-     $(where $ConstraintType: ty: $ConstraintBound: ident<$($ConstraintBoundParams: ty $( = $EqBound: ty )*),*> )*;
+     ($R1: ty, $C1: ty),($R2: ty, $C2: ty)
+     // Const type declaration
+     const $($D: ident),*;
+     // Other generic type declarations.
+     for $($DimsDecl: ident),*;
+     // Where clause.
+     where $($ConstraintType: ty: $ConstraintBound: ident$(<$($ConstraintBoundParams: ty $( = $EqBound: ty )*),*>)*),*;
      // Argument identifiers and types + output.
      $lhs: ident: $Lhs: ty, $rhs: ident: $Rhs: ty, Output = $Result: ty;
      // Operator actual implementation.
      $action: expr;
      // Lifetime.
      $($lives: tt),*) => {
-        impl<$($lives ,)* N $(, $Dims: $DimsBound $(<$($BoundParam),*>)*)*> $Op<$Rhs> for $Lhs
-            where N: Scalar + Zero + One + ClosedAdd + ClosedMul $($(+ $ScalarBounds)*)*,
-                  DefaultAllocator: Allocator<N, $R1, $C1> +
-                                    Allocator<N, $R2, $C2> +
-                                    Allocator<N, $R1, $C2>,
-                  $( $ConstraintType: $ConstraintBound<$( $ConstraintBoundParams $( = $EqBound )*),*> ),*
+        impl<$($lives ,)* T $(, $DimsDecl)* $(, const $D: usize)*> $Op<$Rhs> for $Lhs
+            where T: Scalar + Zero + One + ClosedAdd + ClosedMul $($(+ $ScalarBounds)*)*,
+                  $( $ConstraintType: $ConstraintBound$(<$( $ConstraintBoundParams $( = $EqBound )*),*>)* ),*
                    {
             type Output = $Result;
 
@@ -38,11 +39,15 @@ macro_rules! md_impl(
 macro_rules! md_impl_all(
     (
      // Operator, operator method, and scalar bounds.
-     $Op: ident, $op: ident $(where N: $($ScalarBounds: ident),*)*;
+     $Op: ident, $op: ident $(where T: $($ScalarBounds: ident),*)*;
      // Storage dimensions, and dimension bounds.
-     ($R1: ty, $C1: ty),($R2: ty, $C2: ty) for $($Dims: ident: $DimsBound: ident $(<$($BoundParam: ty),*>)*),+
-     // [Optional] Extra allocator bounds.
-     $(where $ConstraintType: ty: $ConstraintBound: ident<$($ConstraintBoundParams: ty $( = $EqBound: ty )*),*> )*;
+     ($R1: ty, $C1: ty),($R2: ty, $C2: ty)
+     // Const type declaration
+     const $($D: ident),*;
+     // Other generic type declarations.
+     for $($DimsDecl: ident),*;
+     // Where clause.
+     where $($ConstraintType: ty: $ConstraintBound: ident$(<$($ConstraintBoundParams: ty $( = $EqBound: ty )*),*>)*),*;
      // Argument identifiers and types + output.
      $lhs: ident: $Lhs: ty, $rhs: ident: $Rhs: ty, Output = $Result: ty;
      // Operators actual implementations.
@@ -52,30 +57,38 @@ macro_rules! md_impl_all(
      [ref ref] => $action_ref_ref: expr;) => {
 
         md_impl!(
-            $Op, $op $(where N: $($ScalarBounds),*)*;
-            ($R1, $C1),($R2, $C2) for $($Dims: $DimsBound $(<$($BoundParam),*>)*),+
-            $(where $ConstraintType: $ConstraintBound<$($ConstraintBoundParams $( = $EqBound )*),*>)*;
+            $Op, $op $(where T: $($ScalarBounds),*)*;
+            ($R1, $C1),($R2, $C2)
+            const $($D),*;
+            for $($DimsDecl),*;
+            where $($ConstraintType: $ConstraintBound$(<$($ConstraintBoundParams $( = $EqBound )*),*>)*),*;
             $lhs: $Lhs, $rhs: $Rhs, Output = $Result;
             $action_val_val; );
 
         md_impl!(
-            $Op, $op $(where N: $($ScalarBounds),*)*;
-            ($R1, $C1),($R2, $C2) for $($Dims: $DimsBound $(<$($BoundParam),*>)*),+
-            $(where $ConstraintType: $ConstraintBound<$($ConstraintBoundParams $( = $EqBound )*),*>)*;
+            $Op, $op $(where T: $($ScalarBounds),*)*;
+            ($R1, $C1),($R2, $C2)
+            const $($D),*;
+            for $($DimsDecl),*;
+            where $($ConstraintType: $ConstraintBound$(<$($ConstraintBoundParams $( = $EqBound )*),*>)*),*;
             $lhs: &'a $Lhs, $rhs: $Rhs, Output = $Result;
             $action_ref_val; 'a);
 
         md_impl!(
-            $Op, $op $(where N: $($ScalarBounds),*)*;
-            ($R1, $C1),($R2, $C2) for $($Dims: $DimsBound $(<$($BoundParam),*>)*),+
-            $(where $ConstraintType: $ConstraintBound<$($ConstraintBoundParams $( = $EqBound )*),*>)*;
+            $Op, $op $(where T: $($ScalarBounds),*)*;
+            ($R1, $C1),($R2, $C2)
+            const $($D),*;
+            for $($DimsDecl),*;
+            where $($ConstraintType: $ConstraintBound$(<$($ConstraintBoundParams $( = $EqBound )*),*>)*),*;
             $lhs: $Lhs, $rhs: &'b $Rhs, Output = $Result;
             $action_val_ref; 'b);
 
         md_impl!(
-            $Op, $op $(where N: $($ScalarBounds),*)*;
-            ($R1, $C1),($R2, $C2) for $($Dims: $DimsBound $(<$($BoundParam),*>)*),+
-            $(where $ConstraintType: $ConstraintBound<$($ConstraintBoundParams $( = $EqBound )*),*>)*;
+            $Op, $op $(where T: $($ScalarBounds),*)*;
+            ($R1, $C1),($R2, $C2)
+            const $($D),*;
+            for $($DimsDecl),*;
+            where $($ConstraintType: $ConstraintBound$(<$($ConstraintBoundParams $( = $EqBound )*),*>)*),*;
             $lhs: &'a $Lhs, $rhs: &'b $Rhs, Output = $Result;
             $action_ref_ref; 'a, 'b);
     }
@@ -85,20 +98,22 @@ macro_rules! md_impl_all(
 macro_rules! md_assign_impl(
     (
      // Operator, operator method, and scalar bounds.
-     $Op: ident, $op: ident $(where N: $($ScalarBounds: ident),*)* $(for N::Element: $ElementBounds: ident)*;
+     $Op: ident, $op: ident $(where T: $($ScalarBounds: ident),*)* $(for T::Element: $($ElementBounds: ident),*)*;
      // Storage dimensions, and dimension bounds.
-     ($R1: ty, $C1: ty),($R2: ty, $C2: ty) for $($Dims: ident: $DimsBound: ident $(<$($BoundParam: ty),*>)*),*
-     // [Optional] Extra allocator bounds.
-     $(where $ConstraintType: ty: $ConstraintBound: ident $(<$($ConstraintBoundParams: ty $( = $EqBound: ty )*),*>)* )*;
+     ($R1: ty, $C1: ty),($R2: ty, $C2: ty)
+     // Const type declaration
+     const $($D: ident),*;
+     // Other generic type declarations.
+     for $($DimsDecl: ident),*;
+     // Where clause.
+     where $($ConstraintType: ty: $ConstraintBound: ident$(<$($ConstraintBoundParams: ty $( = $EqBound: ty )*),*>)*),*;
      // Argument identifiers and types.
      $lhs: ident: $Lhs: ty, $rhs: ident: $Rhs: ty;
      // Actual implementation and lifetimes.
      $action: expr; $($lives: tt),*) => {
-        impl<$($lives ,)* N $(, $Dims: $DimsBound $(<$($BoundParam),*>)*)*> $Op<$Rhs> for $Lhs
-            where N: Scalar + Zero + One + ClosedAdd + ClosedMul $($(+ $ScalarBounds)*)*,
-                  $(N::Element: $ElementBounds,)*
-                  DefaultAllocator: Allocator<N, $R1, $C1> +
-                                    Allocator<N, $R2, $C2>,
+        impl<$($lives ,)* T $(, $DimsDecl)* $(, const $D: usize)*> $Op<$Rhs> for $Lhs
+            where T: Scalar + Zero + One + ClosedAdd + ClosedMul $($(+ $ScalarBounds)*)*,
+                  $($(T::Element: $ElementBounds,)*)*
                   $( $ConstraintType: $ConstraintBound $(<$( $ConstraintBoundParams $( = $EqBound )*),*>)* ),*
         {
             #[inline]
@@ -114,27 +129,35 @@ macro_rules! md_assign_impl(
 macro_rules! md_assign_impl_all(
     (
      // Operator, operator method, and scalar bounds.
-     $Op: ident, $op: ident $(where N: $($ScalarBounds: ident),*)* $(for N::Element: $($ElementBounds: ident),*)*;
+     $Op: ident, $op: ident $(where T: $($ScalarBounds: ident),*)* $(for T::Element: $($ElementBounds: ident),*)*;
      // Storage dimensions, and dimension bounds.
-     ($R1: ty, $C1: ty),($R2: ty, $C2: ty) for $($Dims: ident: $DimsBound: ident $(<$($BoundParam: ty),*>)*),*
-     // [Optional] Extra allocator bounds.
-     $(where $ConstraintType: ty: $ConstraintBound: ident$(<$($ConstraintBoundParams: ty $( = $EqBound: ty )*),*>)* )*;
+     ($R1: ty, $C1: ty),($R2: ty, $C2: ty)
+     // Const type declaration
+     const $($D: ident),*;
+     // Other generic type declarations.
+     for $($DimsDecl: ident),*;
+     // Where clause.
+     where $($ConstraintType: ty: $ConstraintBound: ident$(<$($ConstraintBoundParams: ty $( = $EqBound: ty )*),*>)*),*;
      // Argument identifiers and types.
      $lhs: ident: $Lhs: ty, $rhs: ident: $Rhs: ty;
      // Actual implementation and lifetimes.
      [val] => $action_val: expr;
      [ref] => $action_ref: expr;) => {
         md_assign_impl!(
-            $Op, $op $(where N: $($ScalarBounds),*)* $(for N::Element: $($ElementBounds),*)*;
-            ($R1, $C1),($R2, $C2) for $($Dims: $DimsBound $(<$($BoundParam),*>)*),*
-            $(where $ConstraintType: $ConstraintBound $(<$($ConstraintBoundParams $( = $EqBound )*),*>)*)*;
+            $Op, $op $(where T: $($ScalarBounds),*)* $(for T::Element: $($ElementBounds),*)*;
+            ($R1, $C1),($R2, $C2)
+            const $($D),*;
+            for $($DimsDecl),*;
+            where $($ConstraintType: $ConstraintBound$(<$($ConstraintBoundParams $( = $EqBound )*),*>)*),*;
             $lhs: $Lhs, $rhs: $Rhs;
             $action_val; );
 
         md_assign_impl!(
-            $Op, $op $(where N: $($ScalarBounds),*)* $(for N::Element: $($ElementBounds),*)*;
-            ($R1, $C1),($R2, $C2) for $($Dims: $DimsBound $(<$($BoundParam),*>)*),*
-            $(where $ConstraintType: $ConstraintBound $(<$($ConstraintBoundParams $( = $EqBound )*),*>)*)*;
+            $Op, $op $(where T: $($ScalarBounds),*)* $(for T::Element: $($ElementBounds),*)*;
+            ($R1, $C1),($R2, $C2)
+            const $($D),*;
+            for $($DimsDecl),*;
+            where $($ConstraintType: $ConstraintBound$(<$($ConstraintBoundParams $( = $EqBound )*),*>)*),*;
             $lhs: $Lhs, $rhs: &'b $Rhs;
             $action_ref; 'b);
     }
@@ -144,16 +167,20 @@ macro_rules! md_assign_impl_all(
 /// Macro for the implementation of addition and subtraction.
 macro_rules! add_sub_impl(
     ($Op: ident, $op: ident, $bound: ident;
-     ($R1: ty, $C1: ty),($R2: ty, $C2: ty) $(-> ($RRes: ty))* for $($Dims: ident: $DimsBound: ident $(<$($BoundParam: ty),*>)*),+;
+     ($R1: ty, $C1: ty),($R2: ty, $C2: ty) $(-> ($RRes: ty, $CRes: ty))*
+     // Const type declaration
+     const $($D: ident),*;
+     // Other generic type declarations.
+     for $($DimsDecl: ident),*;
+     // Where clause.
+     where $($ConstraintType: ty: $ConstraintBound: ident$(<$($ConstraintBoundParams: ty $( = $EqBound: ty )*),*>)*),*;
      $lhs: ident: $Lhs: ty, $rhs: ident: $Rhs: ty, Output = $Result: ty;
      $action: expr; $($lives: tt),*) => {
-        impl<$($lives ,)* N $(, $Dims: $DimsBound $(<$($BoundParam),*>)*)*> $Op<$Rhs> for $Lhs
-            where N: Scalar + $bound,
-                  DefaultAllocator: Allocator<N, $R1, $C1> +
-                                    Allocator<N, $R2, $C2> +
-                                    SameShapeAllocator<N, $R1, $C1, $R2, $C2>,
+        impl<$($lives ,)* T $(, $DimsDecl)* $(, const $D: usize)*> $Op<$Rhs> for $Lhs
+            where T: Scalar + $bound,
                   ShapeConstraint: SameNumberOfRows<$R1, $R2 $(, Representative = $RRes)*> +
-                                   SameNumberOfColumns<$C1, $C2> {
+                                   SameNumberOfColumns<$C1, $C2 $(, Representative = $CRes)*>,
+                  $( $ConstraintType: $ConstraintBound$(<$( $ConstraintBoundParams $( = $EqBound )*),*>)* ),* {
             type Output = $Result;
 
             #[inline]
@@ -168,14 +195,11 @@ macro_rules! add_sub_impl(
 /// Macro for the implementation of assignment-addition and assignment-subtraction.
 macro_rules! add_sub_assign_impl(
     ($Op: ident, $op: ident, $bound: ident;
-     ($R1: ty, $C1: ty),($R2: ty, $C2: ty) for $($Dims: ident: $DimsBound: ident),+;
+    $(const $D: ident),*;
      $lhs: ident: $Lhs: ty, $rhs: ident: $Rhs: ty;
      $action: expr; $($lives: tt),*) => {
-        impl<$($lives ,)* N $(, $Dims: $DimsBound)*> $Op<$Rhs> for $Lhs
-            where N: Scalar + $bound,
-                  DefaultAllocator: Allocator<N, $R1, $C1> +
-                                    Allocator<N, $R2, $C2>,
-                  ShapeConstraint: SameNumberOfRows<$R1, $R2> + SameNumberOfColumns<$C1, $C2> {
+        impl<$($lives ,)* T $(, const $D: usize),*> $Op<$Rhs> for $Lhs
+            where T: Scalar + $bound {
             #[inline]
             fn $op(&mut $lhs, $rhs: $Rhs) {
                 $action
diff --git a/src/geometry/orthographic.rs b/src/geometry/orthographic.rs
index 43bf45c6..255faac1 100644
--- a/src/geometry/orthographic.rs
+++ b/src/geometry/orthographic.rs
@@ -19,26 +19,26 @@ use crate::base::{Matrix4, Vector, Vector3};
 use crate::geometry::{Point3, Projective3};
 
 /// A 3D orthographic projection stored as a homogeneous 4x4 matrix.
-pub struct Orthographic3<N: RealField> {
-    matrix: Matrix4<N>,
+pub struct Orthographic3<T: RealField> {
+    matrix: Matrix4<T>,
 }
 
-impl<N: RealField> Copy for Orthographic3<N> {}
+impl<T: RealField> Copy for Orthographic3<T> {}
 
-impl<N: RealField> Clone for Orthographic3<N> {
+impl<T: RealField> Clone for Orthographic3<T> {
     #[inline]
     fn clone(&self) -> Self {
         Self::from_matrix_unchecked(self.matrix)
     }
 }
 
-impl<N: RealField> fmt::Debug for Orthographic3<N> {
+impl<T: RealField> fmt::Debug for Orthographic3<T> {
     fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
         self.matrix.fmt(f)
     }
 }
 
-impl<N: RealField> PartialEq for Orthographic3<N> {
+impl<T: RealField> PartialEq for Orthographic3<T> {
     #[inline]
     fn eq(&self, right: &Self) -> bool {
         self.matrix == right.matrix
@@ -46,7 +46,7 @@ impl<N: RealField> PartialEq for Orthographic3<N> {
 }
 
 #[cfg(feature = "serde-serialize")]
-impl<N: RealField + Serialize> Serialize for Orthographic3<N> {
+impl<T: RealField + Serialize> Serialize for Orthographic3<T> {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
@@ -56,18 +56,18 @@ impl<N: RealField + Serialize> Serialize for Orthographic3<N> {
 }
 
 #[cfg(feature = "serde-serialize")]
-impl<'a, N: RealField + Deserialize<'a>> Deserialize<'a> for Orthographic3<N> {
+impl<'a, T: RealField + Deserialize<'a>> Deserialize<'a> for Orthographic3<T> {
     fn deserialize<Des>(deserializer: Des) -> Result<Self, Des::Error>
     where
         Des: Deserializer<'a>,
     {
-        let matrix = Matrix4::<N>::deserialize(deserializer)?;
+        let matrix = Matrix4::<T>::deserialize(deserializer)?;
 
         Ok(Self::from_matrix_unchecked(matrix))
     }
 }
 
-impl<N: RealField> Orthographic3<N> {
+impl<T: RealField> Orthographic3<T> {
     /// Creates a new orthographic projection matrix.
     ///
     /// This follows the OpenGL convention, so this will flip the `z` axis.
@@ -111,8 +111,8 @@ impl<N: RealField> Orthographic3<N> {
     /// assert_relative_eq!(proj.project_point(&p8), Point3::new(-1.0, -1.0, -1.0));
     /// ```
     #[inline]
-    pub fn new(left: N, right: N, bottom: N, top: N, znear: N, zfar: N) -> Self {
-        let matrix = Matrix4::<N>::identity();
+    pub fn new(left: T, right: T, bottom: T, top: T, znear: T, zfar: T) -> Self {
+        let matrix = Matrix4::<T>::identity();
         let mut res = Self::from_matrix_unchecked(matrix);
 
         res.set_left_and_right(left, right);
@@ -140,23 +140,23 @@ impl<N: RealField> Orthographic3<N> {
     /// assert_eq!(proj, Orthographic3::new(1.0, 10.0, 2.0, 20.0, 0.1, 1000.0));
     /// ```
     #[inline]
-    pub fn from_matrix_unchecked(matrix: Matrix4<N>) -> Self {
+    pub fn from_matrix_unchecked(matrix: Matrix4<T>) -> Self {
         Self { matrix }
     }
 
     /// Creates a new orthographic projection matrix from an aspect ratio and the vertical field of view.
     #[inline]
-    pub fn from_fov(aspect: N, vfov: N, znear: N, zfar: N) -> Self {
+    pub fn from_fov(aspect: T, vfov: T, znear: T, zfar: T) -> Self {
         assert!(
             znear != zfar,
             "The far plane must not be equal to the near plane."
         );
         assert!(
-            !relative_eq!(aspect, N::zero()),
+            !relative_eq!(aspect, T::zero()),
             "The aspect ratio must not be zero."
         );
 
-        let half: N = crate::convert(0.5);
+        let half: T = crate::convert(0.5);
         let width = zfar * (vfov * half).tan();
         let height = width / aspect;
 
@@ -188,12 +188,12 @@ impl<N: RealField> Orthographic3<N> {
     /// assert_relative_eq!(proj.as_matrix() * inv, Matrix4::identity());
     /// ```
     #[inline]
-    pub fn inverse(&self) -> Matrix4<N> {
+    pub fn inverse(&self) -> Matrix4<T> {
         let mut res = self.to_homogeneous();
 
-        let inv_m11 = N::one() / self.matrix[(0, 0)];
-        let inv_m22 = N::one() / self.matrix[(1, 1)];
-        let inv_m33 = N::one() / self.matrix[(2, 2)];
+        let inv_m11 = T::one() / self.matrix[(0, 0)];
+        let inv_m22 = T::one() / self.matrix[(1, 1)];
+        let inv_m33 = T::one() / self.matrix[(2, 2)];
 
         res[(0, 0)] = inv_m11;
         res[(1, 1)] = inv_m22;
@@ -221,7 +221,7 @@ impl<N: RealField> Orthographic3<N> {
     /// assert_eq!(proj.to_homogeneous(), expected);
     /// ```
     #[inline]
-    pub fn to_homogeneous(&self) -> Matrix4<N> {
+    pub fn to_homogeneous(&self) -> Matrix4<T> {
         self.matrix
     }
 
@@ -240,7 +240,7 @@ impl<N: RealField> Orthographic3<N> {
     /// assert_eq!(*proj.as_matrix(), expected);
     /// ```
     #[inline]
-    pub fn as_matrix(&self) -> &Matrix4<N> {
+    pub fn as_matrix(&self) -> &Matrix4<T> {
         &self.matrix
     }
 
@@ -253,7 +253,7 @@ impl<N: RealField> Orthographic3<N> {
     /// assert_eq!(proj.as_projective().to_homogeneous(), proj.to_homogeneous());
     /// ```
     #[inline]
-    pub fn as_projective(&self) -> &Projective3<N> {
+    pub fn as_projective(&self) -> &Projective3<T> {
         unsafe { mem::transmute(self) }
     }
 
@@ -266,7 +266,7 @@ impl<N: RealField> Orthographic3<N> {
     /// assert_eq!(proj.to_projective().to_homogeneous(), proj.to_homogeneous());
     /// ```
     #[inline]
-    pub fn to_projective(&self) -> Projective3<N> {
+    pub fn to_projective(&self) -> Projective3<T> {
         Projective3::from_matrix_unchecked(self.matrix)
     }
 
@@ -286,7 +286,7 @@ impl<N: RealField> Orthographic3<N> {
     /// assert_eq!(proj.into_inner(), expected);
     /// ```
     #[inline]
-    pub fn into_inner(self) -> Matrix4<N> {
+    pub fn into_inner(self) -> Matrix4<T> {
         self.matrix
     }
 
@@ -294,7 +294,7 @@ impl<N: RealField> Orthographic3<N> {
     /// Deprecated: Use [Orthographic3::into_inner] instead.
     #[deprecated(note = "use `.into_inner()` instead")]
     #[inline]
-    pub fn unwrap(self) -> Matrix4<N> {
+    pub fn unwrap(self) -> Matrix4<T> {
         self.matrix
     }
 
@@ -310,8 +310,8 @@ impl<N: RealField> Orthographic3<N> {
     /// assert_relative_eq!(proj.left(), 10.0, epsilon = 1.0e-6);
     /// ```
     #[inline]
-    pub fn left(&self) -> N {
-        (-N::one() - self.matrix[(0, 3)]) / self.matrix[(0, 0)]
+    pub fn left(&self) -> T {
+        (-T::one() - self.matrix[(0, 3)]) / self.matrix[(0, 0)]
     }
 
     /// The right offset of the view cuboid.
@@ -326,8 +326,8 @@ impl<N: RealField> Orthographic3<N> {
     /// assert_relative_eq!(proj.right(), 1.0, epsilon = 1.0e-6);
     /// ```
     #[inline]
-    pub fn right(&self) -> N {
-        (N::one() - self.matrix[(0, 3)]) / self.matrix[(0, 0)]
+    pub fn right(&self) -> T {
+        (T::one() - self.matrix[(0, 3)]) / self.matrix[(0, 0)]
     }
 
     /// The bottom offset of the view cuboid.
@@ -342,8 +342,8 @@ impl<N: RealField> Orthographic3<N> {
     /// assert_relative_eq!(proj.bottom(), 20.0, epsilon = 1.0e-6);
     /// ```
     #[inline]
-    pub fn bottom(&self) -> N {
-        (-N::one() - self.matrix[(1, 3)]) / self.matrix[(1, 1)]
+    pub fn bottom(&self) -> T {
+        (-T::one() - self.matrix[(1, 3)]) / self.matrix[(1, 1)]
     }
 
     /// The top offset of the view cuboid.
@@ -358,8 +358,8 @@ impl<N: RealField> Orthographic3<N> {
     /// assert_relative_eq!(proj.top(), 2.0, epsilon = 1.0e-6);
     /// ```
     #[inline]
-    pub fn top(&self) -> N {
-        (N::one() - self.matrix[(1, 3)]) / self.matrix[(1, 1)]
+    pub fn top(&self) -> T {
+        (T::one() - self.matrix[(1, 3)]) / self.matrix[(1, 1)]
     }
 
     /// The near plane offset of the view cuboid.
@@ -374,8 +374,8 @@ impl<N: RealField> Orthographic3<N> {
     /// assert_relative_eq!(proj.znear(), 1000.0, epsilon = 1.0e-6);
     /// ```
     #[inline]
-    pub fn znear(&self) -> N {
-        (N::one() + self.matrix[(2, 3)]) / self.matrix[(2, 2)]
+    pub fn znear(&self) -> T {
+        (T::one() + self.matrix[(2, 3)]) / self.matrix[(2, 2)]
     }
 
     /// The far plane offset of the view cuboid.
@@ -390,8 +390,8 @@ impl<N: RealField> Orthographic3<N> {
     /// assert_relative_eq!(proj.zfar(), 0.1, epsilon = 1.0e-6);
     /// ```
     #[inline]
-    pub fn zfar(&self) -> N {
-        (-N::one() + self.matrix[(2, 3)]) / self.matrix[(2, 2)]
+    pub fn zfar(&self) -> T {
+        (-T::one() + self.matrix[(2, 3)]) / self.matrix[(2, 2)]
     }
 
     // TODO: when we get specialization, specialize the Mul impl instead.
@@ -422,7 +422,7 @@ impl<N: RealField> Orthographic3<N> {
     /// assert_relative_eq!(proj.project_point(&p8), Point3::new( 1.0,  1.0,  1.0));
     /// ```
     #[inline]
-    pub fn project_point(&self, p: &Point3<N>) -> Point3<N> {
+    pub fn project_point(&self, p: &Point3<T>) -> Point3<T> {
         Point3::new(
             self.matrix[(0, 0)] * p[0] + self.matrix[(0, 3)],
             self.matrix[(1, 1)] * p[1] + self.matrix[(1, 3)],
@@ -457,7 +457,7 @@ impl<N: RealField> Orthographic3<N> {
     /// assert_relative_eq!(proj.unproject_point(&p8), Point3::new(10.0, 20.0, -1000.0), epsilon = 1.0e-6);
     /// ```
     #[inline]
-    pub fn unproject_point(&self, p: &Point3<N>) -> Point3<N> {
+    pub fn unproject_point(&self, p: &Point3<T>) -> Point3<T> {
         Point3::new(
             (p[0] - self.matrix[(0, 3)]) / self.matrix[(0, 0)],
             (p[1] - self.matrix[(1, 3)]) / self.matrix[(1, 1)],
@@ -485,9 +485,9 @@ impl<N: RealField> Orthographic3<N> {
     /// assert_relative_eq!(proj.project_vector(&v3), Vector3::z() * -2.0 / 999.9);
     /// ```
     #[inline]
-    pub fn project_vector<SB>(&self, p: &Vector<N, U3, SB>) -> Vector3<N>
+    pub fn project_vector<SB>(&self, p: &Vector<T, U3, SB>) -> Vector3<T>
     where
-        SB: Storage<N, U3>,
+        SB: Storage<T, U3>,
     {
         Vector3::new(
             self.matrix[(0, 0)] * p[0],
@@ -510,7 +510,7 @@ impl<N: RealField> Orthographic3<N> {
     /// assert_relative_eq!(proj.left(), 20.0, epsilon = 1.0e-6);
     /// ```
     #[inline]
-    pub fn set_left(&mut self, left: N) {
+    pub fn set_left(&mut self, left: T) {
         let right = self.right();
         self.set_left_and_right(left, right);
     }
@@ -529,7 +529,7 @@ impl<N: RealField> Orthographic3<N> {
     /// assert_relative_eq!(proj.right(), -3.0, epsilon = 1.0e-6);
     /// ```
     #[inline]
-    pub fn set_right(&mut self, right: N) {
+    pub fn set_right(&mut self, right: T) {
         let left = self.left();
         self.set_left_and_right(left, right);
     }
@@ -548,7 +548,7 @@ impl<N: RealField> Orthographic3<N> {
     /// assert_relative_eq!(proj.bottom(), 50.0, epsilon = 1.0e-6);
     /// ```
     #[inline]
-    pub fn set_bottom(&mut self, bottom: N) {
+    pub fn set_bottom(&mut self, bottom: T) {
         let top = self.top();
         self.set_bottom_and_top(bottom, top);
     }
@@ -567,7 +567,7 @@ impl<N: RealField> Orthographic3<N> {
     /// assert_relative_eq!(proj.top(), -3.0, epsilon = 1.0e-6);
     /// ```
     #[inline]
-    pub fn set_top(&mut self, top: N) {
+    pub fn set_top(&mut self, top: T) {
         let bottom = self.bottom();
         self.set_bottom_and_top(bottom, top);
     }
@@ -586,7 +586,7 @@ impl<N: RealField> Orthographic3<N> {
     /// assert_relative_eq!(proj.znear(), 5000.0, epsilon = 1.0e-6);
     /// ```
     #[inline]
-    pub fn set_znear(&mut self, znear: N) {
+    pub fn set_znear(&mut self, znear: T) {
         let zfar = self.zfar();
         self.set_znear_and_zfar(znear, zfar);
     }
@@ -605,7 +605,7 @@ impl<N: RealField> Orthographic3<N> {
     /// assert_relative_eq!(proj.zfar(), -3.0, epsilon = 1.0e-6);
     /// ```
     #[inline]
-    pub fn set_zfar(&mut self, zfar: N) {
+    pub fn set_zfar(&mut self, zfar: T) {
         let znear = self.znear();
         self.set_znear_and_zfar(znear, zfar);
     }
@@ -626,12 +626,12 @@ impl<N: RealField> Orthographic3<N> {
     /// assert_relative_eq!(proj.right(), 7.0, epsilon = 1.0e-6);
     /// ```
     #[inline]
-    pub fn set_left_and_right(&mut self, left: N, right: N) {
+    pub fn set_left_and_right(&mut self, left: T, right: T) {
         assert!(
             left != right,
             "The left corner must not be equal to the right corner."
         );
-        self.matrix[(0, 0)] = crate::convert::<_, N>(2.0) / (right - left);
+        self.matrix[(0, 0)] = crate::convert::<_, T>(2.0) / (right - left);
         self.matrix[(0, 3)] = -(right + left) / (right - left);
     }
 
@@ -651,12 +651,12 @@ impl<N: RealField> Orthographic3<N> {
     /// assert_relative_eq!(proj.top(), 7.0, epsilon = 1.0e-6);
     /// ```
     #[inline]
-    pub fn set_bottom_and_top(&mut self, bottom: N, top: N) {
+    pub fn set_bottom_and_top(&mut self, bottom: T, top: T) {
         assert!(
             bottom != top,
             "The top corner must not be equal to the bottom corner."
         );
-        self.matrix[(1, 1)] = crate::convert::<_, N>(2.0) / (top - bottom);
+        self.matrix[(1, 1)] = crate::convert::<_, T>(2.0) / (top - bottom);
         self.matrix[(1, 3)] = -(top + bottom) / (top - bottom);
     }
 
@@ -676,56 +676,56 @@ impl<N: RealField> Orthographic3<N> {
     /// assert_relative_eq!(proj.zfar(), 0.5, epsilon = 1.0e-6);
     /// ```
     #[inline]
-    pub fn set_znear_and_zfar(&mut self, znear: N, zfar: N) {
+    pub fn set_znear_and_zfar(&mut self, znear: T, zfar: T) {
         assert!(
             zfar != znear,
             "The near-plane and far-plane must not be superimposed."
         );
-        self.matrix[(2, 2)] = -crate::convert::<_, N>(2.0) / (zfar - znear);
+        self.matrix[(2, 2)] = -crate::convert::<_, T>(2.0) / (zfar - znear);
         self.matrix[(2, 3)] = -(zfar + znear) / (zfar - znear);
     }
 }
 
 #[cfg(feature = "rand-no-std")]
-impl<N: RealField> Distribution<Orthographic3<N>> for Standard
+impl<T: RealField> Distribution<Orthographic3<T>> for Standard
 where
-    Standard: Distribution<N>,
+    Standard: Distribution<T>,
 {
     /// Generate an arbitrary random variate for testing purposes.
-    fn sample<R: Rng + ?Sized>(&self, r: &mut R) -> Orthographic3<N> {
+    fn sample<R: Rng + ?Sized>(&self, r: &mut R) -> Orthographic3<T> {
         use crate::base::helper;
         let left = r.gen();
-        let right = helper::reject_rand(r, |x: &N| *x > left);
+        let right = helper::reject_rand(r, |x: &T| *x > left);
         let bottom = r.gen();
-        let top = helper::reject_rand(r, |x: &N| *x > bottom);
+        let top = helper::reject_rand(r, |x: &T| *x > bottom);
         let znear = r.gen();
-        let zfar = helper::reject_rand(r, |x: &N| *x > znear);
+        let zfar = helper::reject_rand(r, |x: &T| *x > znear);
 
         Orthographic3::new(left, right, bottom, top, znear, zfar)
     }
 }
 
 #[cfg(feature = "arbitrary")]
-impl<N: RealField + Arbitrary> Arbitrary for Orthographic3<N>
+impl<T: RealField + Arbitrary> Arbitrary for Orthographic3<T>
 where
-    Matrix4<N>: Send,
+    Matrix4<T>: Send,
 {
     fn arbitrary(g: &mut Gen) -> Self {
         use crate::base::helper;
         let left = Arbitrary::arbitrary(g);
-        let right = helper::reject(g, |x: &N| *x > left);
+        let right = helper::reject(g, |x: &T| *x > left);
         let bottom = Arbitrary::arbitrary(g);
-        let top = helper::reject(g, |x: &N| *x > bottom);
+        let top = helper::reject(g, |x: &T| *x > bottom);
         let znear = Arbitrary::arbitrary(g);
-        let zfar = helper::reject(g, |x: &N| *x > znear);
+        let zfar = helper::reject(g, |x: &T| *x > znear);
 
         Self::new(left, right, bottom, top, znear, zfar)
     }
 }
 
-impl<N: RealField> From<Orthographic3<N>> for Matrix4<N> {
+impl<T: RealField> From<Orthographic3<T>> for Matrix4<T> {
     #[inline]
-    fn from(orth: Orthographic3<N>) -> Self {
+    fn from(orth: Orthographic3<T>) -> Self {
         orth.into_inner()
     }
 }
diff --git a/src/geometry/perspective.rs b/src/geometry/perspective.rs
index 64861fbd..e8f582ef 100644
--- a/src/geometry/perspective.rs
+++ b/src/geometry/perspective.rs
@@ -20,26 +20,26 @@ use crate::base::{Matrix4, Scalar, Vector, Vector3};
 use crate::geometry::{Point3, Projective3};
 
 /// A 3D perspective projection stored as a homogeneous 4x4 matrix.
-pub struct Perspective3<N: Scalar> {
-    matrix: Matrix4<N>,
+pub struct Perspective3<T: Scalar> {
+    matrix: Matrix4<T>,
 }
 
-impl<N: RealField> Copy for Perspective3<N> {}
+impl<T: RealField> Copy for Perspective3<T> {}
 
-impl<N: RealField> Clone for Perspective3<N> {
+impl<T: RealField> Clone for Perspective3<T> {
     #[inline]
     fn clone(&self) -> Self {
         Self::from_matrix_unchecked(self.matrix)
     }
 }
 
-impl<N: RealField> fmt::Debug for Perspective3<N> {
+impl<T: RealField> fmt::Debug for Perspective3<T> {
     fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
         self.matrix.fmt(f)
     }
 }
 
-impl<N: RealField> PartialEq for Perspective3<N> {
+impl<T: RealField> PartialEq for Perspective3<T> {
     #[inline]
     fn eq(&self, right: &Self) -> bool {
         self.matrix == right.matrix
@@ -47,7 +47,7 @@ impl<N: RealField> PartialEq for Perspective3<N> {
 }
 
 #[cfg(feature = "serde-serialize")]
-impl<N: RealField + Serialize> Serialize for Perspective3<N> {
+impl<T: RealField + Serialize> Serialize for Perspective3<T> {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
@@ -57,26 +57,26 @@ impl<N: RealField + Serialize> Serialize for Perspective3<N> {
 }
 
 #[cfg(feature = "serde-serialize")]
-impl<'a, N: RealField + Deserialize<'a>> Deserialize<'a> for Perspective3<N> {
+impl<'a, T: RealField + Deserialize<'a>> Deserialize<'a> for Perspective3<T> {
     fn deserialize<Des>(deserializer: Des) -> Result<Self, Des::Error>
     where
         Des: Deserializer<'a>,
     {
-        let matrix = Matrix4::<N>::deserialize(deserializer)?;
+        let matrix = Matrix4::<T>::deserialize(deserializer)?;
 
         Ok(Self::from_matrix_unchecked(matrix))
     }
 }
 
-impl<N: RealField> Perspective3<N> {
+impl<T: RealField> Perspective3<T> {
     /// Creates a new perspective matrix from the aspect ratio, y field of view, and near/far planes.
-    pub fn new(aspect: N, fovy: N, znear: N, zfar: N) -> Self {
+    pub fn new(aspect: T, fovy: T, znear: T, zfar: T) -> Self {
         assert!(
-            !relative_eq!(zfar - znear, N::zero()),
+            !relative_eq!(zfar - znear, T::zero()),
             "The near-plane and far-plane must not be superimposed."
         );
         assert!(
-            !relative_eq!(aspect, N::zero()),
+            !relative_eq!(aspect, T::zero()),
             "The aspect ratio must not be zero."
         );
 
@@ -87,8 +87,8 @@ impl<N: RealField> Perspective3<N> {
         res.set_aspect(aspect);
         res.set_znear_and_zfar(znear, zfar);
 
-        res.matrix[(3, 3)] = N::zero();
-        res.matrix[(3, 2)] = -N::one();
+        res.matrix[(3, 3)] = T::zero();
+        res.matrix[(3, 2)] = -T::one();
 
         res
     }
@@ -98,24 +98,24 @@ impl<N: RealField> Perspective3<N> {
     /// It is not checked whether or not the given matrix actually represents a perspective
     /// projection.
     #[inline]
-    pub fn from_matrix_unchecked(matrix: Matrix4<N>) -> Self {
+    pub fn from_matrix_unchecked(matrix: Matrix4<T>) -> Self {
         Self { matrix }
     }
 
     /// Retrieves the inverse of the underlying homogeneous matrix.
     #[inline]
-    pub fn inverse(&self) -> Matrix4<N> {
+    pub fn inverse(&self) -> Matrix4<T> {
         let mut res = self.to_homogeneous();
 
-        res[(0, 0)] = N::one() / self.matrix[(0, 0)];
-        res[(1, 1)] = N::one() / self.matrix[(1, 1)];
-        res[(2, 2)] = N::zero();
+        res[(0, 0)] = T::one() / self.matrix[(0, 0)];
+        res[(1, 1)] = T::one() / self.matrix[(1, 1)];
+        res[(2, 2)] = T::zero();
 
         let m23 = self.matrix[(2, 3)];
         let m32 = self.matrix[(3, 2)];
 
-        res[(2, 3)] = N::one() / m32;
-        res[(3, 2)] = N::one() / m23;
+        res[(2, 3)] = T::one() / m32;
+        res[(3, 2)] = T::one() / m23;
         res[(3, 3)] = -self.matrix[(2, 2)] / (m23 * m32);
 
         res
@@ -123,31 +123,31 @@ impl<N: RealField> Perspective3<N> {
 
     /// Computes the corresponding homogeneous matrix.
     #[inline]
-    pub fn to_homogeneous(&self) -> Matrix4<N> {
+    pub fn to_homogeneous(&self) -> Matrix4<T> {
         self.matrix.clone_owned()
     }
 
     /// A reference to the underlying homogeneous transformation matrix.
     #[inline]
-    pub fn as_matrix(&self) -> &Matrix4<N> {
+    pub fn as_matrix(&self) -> &Matrix4<T> {
         &self.matrix
     }
 
     /// A reference to this transformation seen as a `Projective3`.
     #[inline]
-    pub fn as_projective(&self) -> &Projective3<N> {
+    pub fn as_projective(&self) -> &Projective3<T> {
         unsafe { mem::transmute(self) }
     }
 
     /// This transformation seen as a `Projective3`.
     #[inline]
-    pub fn to_projective(&self) -> Projective3<N> {
+    pub fn to_projective(&self) -> Projective3<T> {
         Projective3::from_matrix_unchecked(self.matrix)
     }
 
     /// Retrieves the underlying homogeneous matrix.
     #[inline]
-    pub fn into_inner(self) -> Matrix4<N> {
+    pub fn into_inner(self) -> Matrix4<T> {
         self.matrix
     }
 
@@ -155,26 +155,26 @@ impl<N: RealField> Perspective3<N> {
     /// Deprecated: Use [Perspective3::into_inner] instead.
     #[deprecated(note = "use `.into_inner()` instead")]
     #[inline]
-    pub fn unwrap(self) -> Matrix4<N> {
+    pub fn unwrap(self) -> Matrix4<T> {
         self.matrix
     }
 
     /// Gets the `width / height` aspect ratio of the view frustum.
     #[inline]
-    pub fn aspect(&self) -> N {
+    pub fn aspect(&self) -> T {
         self.matrix[(1, 1)] / self.matrix[(0, 0)]
     }
 
     /// Gets the y field of view of the view frustum.
     #[inline]
-    pub fn fovy(&self) -> N {
-        (N::one() / self.matrix[(1, 1)]).atan() * crate::convert(2.0)
+    pub fn fovy(&self) -> T {
+        (T::one() / self.matrix[(1, 1)]).atan() * crate::convert(2.0)
     }
 
     /// Gets the near plane offset of the view frustum.
     #[inline]
-    pub fn znear(&self) -> N {
-        let ratio = (-self.matrix[(2, 2)] + N::one()) / (-self.matrix[(2, 2)] - N::one());
+    pub fn znear(&self) -> T {
+        let ratio = (-self.matrix[(2, 2)] + T::one()) / (-self.matrix[(2, 2)] - T::one());
 
         self.matrix[(2, 3)] / (ratio * crate::convert(2.0))
             - self.matrix[(2, 3)] / crate::convert(2.0)
@@ -182,8 +182,8 @@ impl<N: RealField> Perspective3<N> {
 
     /// Gets the far plane offset of the view frustum.
     #[inline]
-    pub fn zfar(&self) -> N {
-        let ratio = (-self.matrix[(2, 2)] + N::one()) / (-self.matrix[(2, 2)] - N::one());
+    pub fn zfar(&self) -> T {
+        let ratio = (-self.matrix[(2, 2)] + T::one()) / (-self.matrix[(2, 2)] - T::one());
 
         (self.matrix[(2, 3)] - ratio * self.matrix[(2, 3)]) / crate::convert(2.0)
     }
@@ -193,8 +193,8 @@ impl<N: RealField> Perspective3<N> {
     // TODO: when we get specialization, specialize the Mul impl instead.
     /// Projects a point. Faster than matrix multiplication.
     #[inline]
-    pub fn project_point(&self, p: &Point3<N>) -> Point3<N> {
-        let inverse_denom = -N::one() / p[2];
+    pub fn project_point(&self, p: &Point3<T>) -> Point3<T> {
+        let inverse_denom = -T::one() / p[2];
         Point3::new(
             self.matrix[(0, 0)] * p[0] * inverse_denom,
             self.matrix[(1, 1)] * p[1] * inverse_denom,
@@ -204,7 +204,7 @@ impl<N: RealField> Perspective3<N> {
 
     /// Un-projects a point. Faster than multiplication by the matrix inverse.
     #[inline]
-    pub fn unproject_point(&self, p: &Point3<N>) -> Point3<N> {
+    pub fn unproject_point(&self, p: &Point3<T>) -> Point3<T> {
         let inverse_denom = self.matrix[(2, 3)] / (p[2] + self.matrix[(2, 2)]);
 
         Point3::new(
@@ -217,11 +217,11 @@ impl<N: RealField> Perspective3<N> {
     // TODO: when we get specialization, specialize the Mul impl instead.
     /// Projects a vector. Faster than matrix multiplication.
     #[inline]
-    pub fn project_vector<SB>(&self, p: &Vector<N, U3, SB>) -> Vector3<N>
+    pub fn project_vector<SB>(&self, p: &Vector<T, U3, SB>) -> Vector3<T>
     where
-        SB: Storage<N, U3>,
+        SB: Storage<T, U3>,
     {
-        let inverse_denom = -N::one() / p[2];
+        let inverse_denom = -T::one() / p[2];
         Vector3::new(
             self.matrix[(0, 0)] * p[0] * inverse_denom,
             self.matrix[(1, 1)] * p[1] * inverse_denom,
@@ -232,9 +232,9 @@ impl<N: RealField> Perspective3<N> {
     /// Updates this perspective matrix with a new `width / height` aspect ratio of the view
     /// frustum.
     #[inline]
-    pub fn set_aspect(&mut self, aspect: N) {
+    pub fn set_aspect(&mut self, aspect: T) {
         assert!(
-            !relative_eq!(aspect, N::zero()),
+            !relative_eq!(aspect, T::zero()),
             "The aspect ratio must not be zero."
         );
         self.matrix[(0, 0)] = self.matrix[(1, 1)] / aspect;
@@ -242,65 +242,65 @@ impl<N: RealField> Perspective3<N> {
 
     /// Updates this perspective with a new y field of view of the view frustum.
     #[inline]
-    pub fn set_fovy(&mut self, fovy: N) {
+    pub fn set_fovy(&mut self, fovy: T) {
         let old_m22 = self.matrix[(1, 1)];
-        self.matrix[(1, 1)] = N::one() / (fovy / crate::convert(2.0)).tan();
+        self.matrix[(1, 1)] = T::one() / (fovy / crate::convert(2.0)).tan();
         self.matrix[(0, 0)] = self.matrix[(0, 0)] * (self.matrix[(1, 1)] / old_m22);
     }
 
     /// Updates this perspective matrix with a new near plane offset of the view frustum.
     #[inline]
-    pub fn set_znear(&mut self, znear: N) {
+    pub fn set_znear(&mut self, znear: T) {
         let zfar = self.zfar();
         self.set_znear_and_zfar(znear, zfar);
     }
 
     /// Updates this perspective matrix with a new far plane offset of the view frustum.
     #[inline]
-    pub fn set_zfar(&mut self, zfar: N) {
+    pub fn set_zfar(&mut self, zfar: T) {
         let znear = self.znear();
         self.set_znear_and_zfar(znear, zfar);
     }
 
     /// Updates this perspective matrix with new near and far plane offsets of the view frustum.
     #[inline]
-    pub fn set_znear_and_zfar(&mut self, znear: N, zfar: N) {
+    pub fn set_znear_and_zfar(&mut self, znear: T, zfar: T) {
         self.matrix[(2, 2)] = (zfar + znear) / (znear - zfar);
         self.matrix[(2, 3)] = zfar * znear * crate::convert(2.0) / (znear - zfar);
     }
 }
 
 #[cfg(feature = "rand-no-std")]
-impl<N: RealField> Distribution<Perspective3<N>> for Standard
+impl<T: RealField> Distribution<Perspective3<T>> for Standard
 where
-    Standard: Distribution<N>,
+    Standard: Distribution<T>,
 {
     /// Generate an arbitrary random variate for testing purposes.
-    fn sample<'a, R: Rng + ?Sized>(&self, r: &'a mut R) -> Perspective3<N> {
+    fn sample<'a, R: Rng + ?Sized>(&self, r: &'a mut R) -> Perspective3<T> {
         use crate::base::helper;
         let znear = r.gen();
-        let zfar = helper::reject_rand(r, |&x: &N| !(x - znear).is_zero());
-        let aspect = helper::reject_rand(r, |&x: &N| !x.is_zero());
+        let zfar = helper::reject_rand(r, |&x: &T| !(x - znear).is_zero());
+        let aspect = helper::reject_rand(r, |&x: &T| !x.is_zero());
 
         Perspective3::new(aspect, r.gen(), znear, zfar)
     }
 }
 
 #[cfg(feature = "arbitrary")]
-impl<N: RealField + Arbitrary> Arbitrary for Perspective3<N> {
+impl<T: RealField + Arbitrary> Arbitrary for Perspective3<T> {
     fn arbitrary(g: &mut Gen) -> Self {
         use crate::base::helper;
         let znear = Arbitrary::arbitrary(g);
-        let zfar = helper::reject(g, |&x: &N| !(x - znear).is_zero());
-        let aspect = helper::reject(g, |&x: &N| !x.is_zero());
+        let zfar = helper::reject(g, |&x: &T| !(x - znear).is_zero());
+        let aspect = helper::reject(g, |&x: &T| !x.is_zero());
 
         Self::new(aspect, Arbitrary::arbitrary(g), znear, zfar)
     }
 }
 
-impl<N: RealField> From<Perspective3<N>> for Matrix4<N> {
+impl<T: RealField> From<Perspective3<T>> for Matrix4<T> {
     #[inline]
-    fn from(pers: Perspective3<N>) -> Self {
+    fn from(pers: Perspective3<T>) -> Self {
         pers.into_inner()
     }
 }
diff --git a/src/geometry/point.rs b/src/geometry/point.rs
index eeda07e3..33725250 100644
--- a/src/geometry/point.rs
+++ b/src/geometry/point.rs
@@ -17,7 +17,7 @@ use simba::simd::SimdPartialOrd;
 use crate::base::allocator::Allocator;
 use crate::base::dimension::{DimName, DimNameAdd, DimNameSum, U1};
 use crate::base::iter::{MatrixIter, MatrixIterMut};
-use crate::base::{DefaultAllocator, Scalar, VectorN};
+use crate::base::{Const, DefaultAllocator, OVector, SVector, Scalar};
 
 /// A point in an euclidean space.
 ///
@@ -40,55 +40,35 @@ use crate::base::{DefaultAllocator, Scalar, VectorN};
 /// of said transformations for details.
 #[repr(C)]
 #[derive(Debug, Clone)]
-pub struct Point<N: Scalar, D: DimName>
-where
-    DefaultAllocator: Allocator<N, D>,
-{
+pub struct Point<T, const D: usize> {
     /// The coordinates of this point, i.e., the shift from the origin.
-    pub coords: VectorN<N, D>,
+    pub coords: SVector<T, D>,
 }
 
-impl<N: Scalar + hash::Hash, D: DimName + hash::Hash> hash::Hash for Point<N, D>
-where
-    DefaultAllocator: Allocator<N, D>,
-    <DefaultAllocator as Allocator<N, D>>::Buffer: hash::Hash,
-{
+impl<T: Scalar + hash::Hash, const D: usize> hash::Hash for Point<T, D> {
     fn hash<H: hash::Hasher>(&self, state: &mut H) {
         self.coords.hash(state)
     }
 }
 
-impl<N: Scalar + Copy, D: DimName> Copy for Point<N, D>
-where
-    DefaultAllocator: Allocator<N, D>,
-    <DefaultAllocator as Allocator<N, D>>::Buffer: Copy,
+impl<T: Scalar + Copy, const D: usize> Copy for Point<T, D> {}
+
+#[cfg(feature = "bytemuck")]
+unsafe impl<T: Scalar, const D: usize> bytemuck::Zeroable for Point<T, D> where
+    SVector<T, D>: bytemuck::Zeroable
 {
 }
 
 #[cfg(feature = "bytemuck")]
-unsafe impl<N: Scalar, D: DimName> bytemuck::Zeroable for Point<N, D>
+unsafe impl<T: Scalar, const D: usize> bytemuck::Pod for Point<T, D>
 where
-    VectorN<N, D>: bytemuck::Zeroable,
-    DefaultAllocator: Allocator<N, D>,
-{
-}
-
-#[cfg(feature = "bytemuck")]
-unsafe impl<N: Scalar, D: DimName> bytemuck::Pod for Point<N, D>
-where
-    N: Copy,
-    VectorN<N, D>: bytemuck::Pod,
-    DefaultAllocator: Allocator<N, D>,
-    <DefaultAllocator as Allocator<N, D>>::Buffer: Copy,
+    T: Copy,
+    SVector<T, D>: bytemuck::Pod,
 {
 }
 
 #[cfg(feature = "serde-serialize")]
-impl<N: Scalar, D: DimName> Serialize for Point<N, D>
-where
-    DefaultAllocator: Allocator<N, D>,
-    <DefaultAllocator as Allocator<N, D>>::Buffer: Serialize,
-{
+impl<T: Scalar + Serialize, const D: usize> Serialize for Point<T, D> {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
@@ -98,28 +78,22 @@ where
 }
 
 #[cfg(feature = "serde-serialize")]
-impl<'a, N: Scalar, D: DimName> Deserialize<'a> for Point<N, D>
-where
-    DefaultAllocator: Allocator<N, D>,
-    <DefaultAllocator as Allocator<N, D>>::Buffer: Deserialize<'a>,
-{
+impl<'a, T: Scalar + Deserialize<'a>, const D: usize> Deserialize<'a> for Point<T, D> {
     fn deserialize<Des>(deserializer: Des) -> Result<Self, Des::Error>
     where
         Des: Deserializer<'a>,
     {
-        let coords = VectorN::<N, D>::deserialize(deserializer)?;
+        let coords = SVector::<T, D>::deserialize(deserializer)?;
 
         Ok(Self::from(coords))
     }
 }
 
 #[cfg(feature = "abomonation-serialize")]
-impl<N, D> Abomonation for Point<N, D>
+impl<T, const D: usize> Abomonation for Point<T, D>
 where
-    N: Scalar,
-    D: DimName,
-    VectorN<N, D>: Abomonation,
-    DefaultAllocator: Allocator<N, D>,
+    T: Scalar,
+    SVector<T, D>: Abomonation,
 {
     unsafe fn entomb<W: Write>(&self, writer: &mut W) -> IOResult<()> {
         self.coords.entomb(writer)
@@ -134,10 +108,7 @@ where
     }
 }
 
-impl<N: Scalar, D: DimName> Point<N, D>
-where
-    DefaultAllocator: Allocator<N, D>,
-{
+impl<T: Scalar, const D: usize> Point<T, D> {
     /// Returns a point containing the result of `f` applied to each of its entries.
     ///
     /// # Example
@@ -151,10 +122,7 @@ where
     /// assert_eq!(p.map(|e| e as u32), Point3::new(1, 2, 3));
     /// ```
     #[inline]
-    pub fn map<N2: Scalar, F: FnMut(N) -> N2>(&self, f: F) -> Point<N2, D>
-    where
-        DefaultAllocator: Allocator<N2, D>,
-    {
+    pub fn map<T2: Scalar, F: FnMut(T) -> T2>(&self, f: F) -> Point<T2, D> {
         self.coords.map(f).into()
     }
 
@@ -173,7 +141,7 @@ where
     /// assert_eq!(p, Point3::new(10.0, 20.0, 30.0));
     /// ```
     #[inline]
-    pub fn apply<F: FnMut(N) -> N>(&mut self, f: F) {
+    pub fn apply<F: FnMut(T) -> T>(&mut self, f: F) {
         self.coords.apply(f)
     }
 
@@ -193,20 +161,20 @@ where
     /// assert_eq!(p.to_homogeneous(), Vector4::new(10.0, 20.0, 30.0, 1.0));
     /// ```
     #[inline]
-    pub fn to_homogeneous(&self) -> VectorN<N, DimNameSum<D, U1>>
+    pub fn to_homogeneous(&self) -> OVector<T, DimNameSum<Const<D>, U1>>
     where
-        N: One,
-        D: DimNameAdd<U1>,
-        DefaultAllocator: Allocator<N, DimNameSum<D, U1>>,
+        T: One,
+        Const<D>: DimNameAdd<U1>,
+        DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>>,
     {
         let mut res = unsafe {
             crate::unimplemented_or_uninitialized_generic!(
-                <DimNameSum<D, U1> as DimName>::name(),
-                U1
+                <DimNameSum<Const<D>, U1> as DimName>::name(),
+                Const::<1>
             )
         };
-        res.fixed_slice_mut::<D, U1>(0, 0).copy_from(&self.coords);
-        res[(D::dim(), 0)] = N::one();
+        res.fixed_slice_mut::<D, 1>(0, 0).copy_from(&self.coords);
+        res[(D, 0)] = T::one();
 
         res
     }
@@ -214,7 +182,7 @@ where
     /// Creates a new point with the given coordinates.
     #[deprecated(note = "Use Point::from(vector) instead.")]
     #[inline]
-    pub fn from_coordinates(coords: VectorN<N, D>) -> Self {
+    pub fn from_coordinates(coords: SVector<T, D>) -> Self {
         Self { coords }
     }
 
@@ -269,13 +237,16 @@ where
     /// assert_eq!(it.next(), Some(3.0));
     /// assert_eq!(it.next(), None);
     #[inline]
-    pub fn iter(&self) -> MatrixIter<N, D, U1, <DefaultAllocator as Allocator<N, D>>::Buffer> {
+    pub fn iter(
+        &self,
+    ) -> MatrixIter<T, Const<D>, Const<1>, <DefaultAllocator as Allocator<T, Const<D>>>::Buffer>
+    {
         self.coords.iter()
     }
 
     /// Gets a reference to i-th element of this point without bound-checking.
     #[inline]
-    pub unsafe fn get_unchecked(&self, i: usize) -> &N {
+    pub unsafe fn get_unchecked(&self, i: usize) -> &T {
         self.coords.vget_unchecked(i)
     }
 
@@ -294,13 +265,14 @@ where
     #[inline]
     pub fn iter_mut(
         &mut self,
-    ) -> MatrixIterMut<N, D, U1, <DefaultAllocator as Allocator<N, D>>::Buffer> {
+    ) -> MatrixIterMut<T, Const<D>, Const<1>, <DefaultAllocator as Allocator<T, Const<D>>>::Buffer>
+    {
         self.coords.iter_mut()
     }
 
     /// Gets a mutable reference to i-th element of this point without bound-checking.
     #[inline]
-    pub unsafe fn get_unchecked_mut(&mut self, i: usize) -> &mut N {
+    pub unsafe fn get_unchecked_mut(&mut self, i: usize) -> &mut T {
         self.coords.vget_unchecked_mut(i)
     }
 
@@ -311,16 +283,15 @@ where
     }
 }
 
-impl<N: Scalar + AbsDiffEq, D: DimName> AbsDiffEq for Point<N, D>
+impl<T: Scalar + AbsDiffEq, const D: usize> AbsDiffEq for Point<T, D>
 where
-    DefaultAllocator: Allocator<N, D>,
-    N::Epsilon: Copy,
+    T::Epsilon: Copy,
 {
-    type Epsilon = N::Epsilon;
+    type Epsilon = T::Epsilon;
 
     #[inline]
     fn default_epsilon() -> Self::Epsilon {
-        N::default_epsilon()
+        T::default_epsilon()
     }
 
     #[inline]
@@ -329,14 +300,13 @@ where
     }
 }
 
-impl<N: Scalar + RelativeEq, D: DimName> RelativeEq for Point<N, D>
+impl<T: Scalar + RelativeEq, const D: usize> RelativeEq for Point<T, D>
 where
-    DefaultAllocator: Allocator<N, D>,
-    N::Epsilon: Copy,
+    T::Epsilon: Copy,
 {
     #[inline]
     fn default_max_relative() -> Self::Epsilon {
-        N::default_max_relative()
+        T::default_max_relative()
     }
 
     #[inline]
@@ -351,14 +321,13 @@ where
     }
 }
 
-impl<N: Scalar + UlpsEq, D: DimName> UlpsEq for Point<N, D>
+impl<T: Scalar + UlpsEq, const D: usize> UlpsEq for Point<T, D>
 where
-    DefaultAllocator: Allocator<N, D>,
-    N::Epsilon: Copy,
+    T::Epsilon: Copy,
 {
     #[inline]
     fn default_max_ulps() -> u32 {
-        N::default_max_ulps()
+        T::default_max_ulps()
     }
 
     #[inline]
@@ -367,22 +336,16 @@ where
     }
 }
 
-impl<N: Scalar + Eq, D: DimName> Eq for Point<N, D> where DefaultAllocator: Allocator<N, D> {}
+impl<T: Scalar + Eq, const D: usize> Eq for Point<T, D> {}
 
-impl<N: Scalar, D: DimName> PartialEq for Point<N, D>
-where
-    DefaultAllocator: Allocator<N, D>,
-{
+impl<T: Scalar, const D: usize> PartialEq for Point<T, D> {
     #[inline]
     fn eq(&self, right: &Self) -> bool {
         self.coords == right.coords
     }
 }
 
-impl<N: Scalar + PartialOrd, D: DimName> PartialOrd for Point<N, D>
-where
-    DefaultAllocator: Allocator<N, D>,
-{
+impl<T: Scalar + PartialOrd, const D: usize> PartialOrd for Point<T, D> {
     #[inline]
     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
         self.coords.partial_cmp(&other.coords)
@@ -412,25 +375,22 @@ where
 /*
  * inf/sup
  */
-impl<N: Scalar + SimdPartialOrd, D: DimName> Point<N, D>
-where
-    DefaultAllocator: Allocator<N, D>,
-{
+impl<T: Scalar + SimdPartialOrd, const D: usize> Point<T, D> {
     /// Computes the infimum (aka. componentwise min) of two points.
     #[inline]
-    pub fn inf(&self, other: &Self) -> Point<N, D> {
+    pub fn inf(&self, other: &Self) -> Point<T, D> {
         self.coords.inf(&other.coords).into()
     }
 
     /// Computes the supremum (aka. componentwise max) of two points.
     #[inline]
-    pub fn sup(&self, other: &Self) -> Point<N, D> {
+    pub fn sup(&self, other: &Self) -> Point<T, D> {
         self.coords.sup(&other.coords).into()
     }
 
     /// Computes the (infimum, supremum) of two points.
     #[inline]
-    pub fn inf_sup(&self, other: &Self) -> (Point<N, D>, Point<N, D>) {
+    pub fn inf_sup(&self, other: &Self) -> (Point<T, D>, Point<T, D>) {
         let (inf, sup) = self.coords.inf_sup(&other.coords);
         (inf.into(), sup.into())
     }
@@ -441,10 +401,7 @@ where
  * Display
  *
  */
-impl<N: Scalar + fmt::Display, D: DimName> fmt::Display for Point<N, D>
-where
-    DefaultAllocator: Allocator<N, D>,
-{
+impl<T: Scalar + fmt::Display, const D: usize> fmt::Display for Point<T, D> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "{{")?;
 
diff --git a/src/geometry/point_alias.rs b/src/geometry/point_alias.rs
index 05874ae4..54441b09 100644
--- a/src/geometry/point_alias.rs
+++ b/src/geometry/point_alias.rs
@@ -1,28 +1,26 @@
-use crate::base::dimension::{U1, U2, U3, U4, U5, U6};
-
 use crate::geometry::Point;
 
 /// A statically sized 1-dimensional column point.
 ///
 /// **Because this is an alias, not all its methods are listed here. See the [`Point`](crate::Point) type too.**
-pub type Point1<N> = Point<N, U1>;
+pub type Point1<T> = Point<T, 1>;
 /// A statically sized 2-dimensional column point.
 ///
 /// **Because this is an alias, not all its methods are listed here. See the [`Point`](crate::Point) type too.**
-pub type Point2<N> = Point<N, U2>;
+pub type Point2<T> = Point<T, 2>;
 /// A statically sized 3-dimensional column point.
 ///
 /// **Because this is an alias, not all its methods are listed here. See the [`Point`](crate::Point) type too.**
-pub type Point3<N> = Point<N, U3>;
+pub type Point3<T> = Point<T, 3>;
 /// A statically sized 4-dimensional column point.
 ///
 /// **Because this is an alias, not all its methods are listed here. See the [`Point`](crate::Point) type too.**
-pub type Point4<N> = Point<N, U4>;
+pub type Point4<T> = Point<T, 4>;
 /// A statically sized 5-dimensional column point.
 ///
 /// **Because this is an alias, not all its methods are listed here. See the [`Point`](crate::Point) type too.**
-pub type Point5<N> = Point<N, U5>;
+pub type Point5<T> = Point<T, 5>;
 /// A statically sized 6-dimensional column point.
 ///
 /// **Because this is an alias, not all its methods are listed here. See the [`Point`](crate::Point) type too.**
-pub type Point6<N> = Point<N, U6>;
+pub type Point6<T> = Point<T, 6>;
diff --git a/src/geometry/point_construction.rs b/src/geometry/point_construction.rs
index 47b336f4..f50a3fc1 100644
--- a/src/geometry/point_construction.rs
+++ b/src/geometry/point_construction.rs
@@ -9,27 +9,23 @@ use rand::{
 };
 
 use crate::base::allocator::Allocator;
-use crate::base::dimension::{DimName, DimNameAdd, DimNameSum, U1};
-use crate::base::{DefaultAllocator, Scalar, VectorN};
+use crate::base::dimension::{DimNameAdd, DimNameSum, U1};
+use crate::base::{DefaultAllocator, SVector, Scalar};
 use crate::{
-    Point1, Point2, Point3, Point4, Point5, Point6, Vector1, Vector2, Vector3, Vector4, Vector5,
-    Vector6,
+    Const, OVector, Point1, Point2, Point3, Point4, Point5, Point6, Vector1, Vector2, Vector3,
+    Vector4, Vector5, Vector6,
 };
 use simba::scalar::{ClosedDiv, SupersetOf};
 
 use crate::geometry::Point;
 
 /// # Other construction methods
-impl<N: Scalar, D: DimName> Point<N, D>
-where
-    DefaultAllocator: Allocator<N, D>,
-{
+impl<T: Scalar, const D: usize> Point<T, D> {
     /// Creates a new point with uninitialized coordinates.
     #[inline]
     pub unsafe fn new_uninitialized() -> Self {
         Self::from(crate::unimplemented_or_uninitialized_generic!(
-            D::name(),
-            U1
+            Const::<D>, Const::<1>
         ))
     }
 
@@ -51,9 +47,9 @@ where
     #[inline]
     pub fn origin() -> Self
     where
-        N: Zero,
+        T: Zero,
     {
-        Self::from(VectorN::from_element(N::zero()))
+        Self::from(SVector::from_element(T::zero()))
     }
 
     /// Creates a new point from a slice.
@@ -71,8 +67,8 @@ where
     /// assert_eq!(pt, Point3::new(1.0, 2.0, 3.0));
     /// ```
     #[inline]
-    pub fn from_slice(components: &[N]) -> Self {
-        Self::from(VectorN::from_row_slice(components))
+    pub fn from_slice(components: &[T]) -> Self {
+        Self::from(SVector::from_row_slice(components))
     }
 
     /// Creates a new point from its homogeneous vector representation.
@@ -106,14 +102,14 @@ where
     /// assert_eq!(pt, Some(Point2::new(1.0, 2.0)));
     /// ```
     #[inline]
-    pub fn from_homogeneous(v: VectorN<N, DimNameSum<D, U1>>) -> Option<Self>
+    pub fn from_homogeneous(v: OVector<T, DimNameSum<Const<D>, U1>>) -> Option<Self>
     where
-        N: Scalar + Zero + One + ClosedDiv,
-        D: DimNameAdd<U1>,
-        DefaultAllocator: Allocator<N, DimNameSum<D, U1>>,
+        T: Scalar + Zero + One + ClosedDiv,
+        Const<D>: DimNameAdd<U1>,
+        DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>>,
     {
-        if !v[D::dim()].is_zero() {
-            let coords = v.fixed_slice::<D, U1>(0, 0) / v[D::dim()].inlined_clone();
+        if !v[D].is_zero() {
+            let coords = v.fixed_slice::<D, 1>(0, 0) / v[D].inlined_clone();
             Some(Self::from(coords))
         } else {
             None
@@ -132,7 +128,6 @@ where
     pub fn cast<To: Scalar>(self) -> Point<To, D>
     where
         Point<To, D>: SupersetOf<Self>,
-        DefaultAllocator: Allocator<To, D>,
     {
         crate::convert(self)
     }
@@ -143,43 +138,38 @@ where
  * Traits that build points.
  *
  */
-impl<N: Scalar + Bounded, D: DimName> Bounded for Point<N, D>
-where
-    DefaultAllocator: Allocator<N, D>,
-{
+impl<T: Scalar + Bounded, const D: usize> Bounded for Point<T, D> {
     #[inline]
     fn max_value() -> Self {
-        Self::from(VectorN::max_value())
+        Self::from(SVector::max_value())
     }
 
     #[inline]
     fn min_value() -> Self {
-        Self::from(VectorN::min_value())
+        Self::from(SVector::min_value())
     }
 }
 
 #[cfg(feature = "rand-no-std")]
-impl<N: Scalar, D: DimName> Distribution<Point<N, D>> for Standard
+impl<T: Scalar, const D: usize> Distribution<Point<T, D>> for Standard
 where
-    DefaultAllocator: Allocator<N, D>,
-    Standard: Distribution<N>,
+    Standard: Distribution<T>,
 {
-     /// Generate a `Point` where each coordinate is an independent variate from `[0, 1)`.
+    /// Generate a `Point` where each coordinate is an independent variate from `[0, 1)`.
     #[inline]
-    fn sample<'a, G: Rng + ?Sized>(&self, rng: &mut G) -> Point<N, D> {
-        Point::from(rng.gen::<VectorN<N, D>>())
+    fn sample<'a, G: Rng + ?Sized>(&self, rng: &mut G) -> Point<T, D> {
+        Point::from(rng.gen::<SVector<T, D>>())
     }
 }
 
 #[cfg(feature = "arbitrary")]
-impl<N: Scalar + Arbitrary + Send, D: DimName> Arbitrary for Point<N, D>
+impl<T: Scalar + Arbitrary + Send, const D: usize> Arbitrary for Point<T, D>
 where
-    DefaultAllocator: Allocator<N, D>,
-    <DefaultAllocator as Allocator<N, D>>::Buffer: Send,
+    <DefaultAllocator as Allocator<T, Const<D>>>::Buffer: Send,
 {
     #[inline]
     fn arbitrary(g: &mut Gen) -> Self {
-        Self::from(VectorN::arbitrary(g))
+        Self::from(SVector::arbitrary(g))
     }
 }
 
@@ -191,7 +181,7 @@ where
 // NOTE: the impl for Point1 is not with the others so that we
 // can add a section with the impl block comment.
 /// # Construction from individual components
-impl<N: Scalar> Point1<N> {
+impl<T> Point1<T> {
     /// Initializes this point from its components.
     ///
     /// # Example
@@ -202,20 +192,22 @@ impl<N: Scalar> Point1<N> {
     /// assert_eq!(p.x, 1.0);
     /// ```
     #[inline]
-    pub fn new(x: N) -> Self {
-        Vector1::new(x).into()
+    pub const fn new(x: T) -> Self {
+        Point {
+            coords: Vector1::new(x),
+        }
     }
 }
 macro_rules! componentwise_constructors_impl(
     ($($doc: expr; $Point: ident, $Vector: ident, $($args: ident:$irow: expr),*);* $(;)*) => {$(
-        impl<N: Scalar> $Point<N> {
+        impl<T> $Point<T> {
             #[doc = "Initializes this point from its components."]
             #[doc = "# Example\n```"]
             #[doc = $doc]
             #[doc = "```"]
             #[inline]
-            pub fn new($($args: N),*) -> Self {
-                $Vector::new($($args),*).into()
+            pub const fn new($($args: T),*) -> Self {
+                Point { coords: $Vector::new($($args),*) }
             }
         }
     )*}
@@ -236,8 +228,8 @@ componentwise_constructors_impl!(
 
 macro_rules! from_array_impl(
     ($($Point: ident, $len: expr);*) => {$(
-      impl <N: Scalar> From<[N; $len]> for $Point<N> {
-          fn from(coords: [N; $len]) -> Self {
+      impl <T: Scalar> From<[T; $len]> for $Point<T> {
+          fn from(coords: [T; $len]) -> Self {
               Self {
                 coords: coords.into()
               }
diff --git a/src/geometry/point_conversion.rs b/src/geometry/point_conversion.rs
index 6f3d865b..08438ec0 100644
--- a/src/geometry/point_conversion.rs
+++ b/src/geometry/point_conversion.rs
@@ -3,8 +3,8 @@ use simba::scalar::{ClosedDiv, SubsetOf, SupersetOf};
 use simba::simd::PrimitiveSimdValue;
 
 use crate::base::allocator::Allocator;
-use crate::base::dimension::{DimName, DimNameAdd, DimNameSum, U1};
-use crate::base::{DefaultAllocator, Matrix, Scalar, VectorN};
+use crate::base::dimension::{DimNameAdd, DimNameSum, U1};
+use crate::base::{Const, DefaultAllocator, Matrix, OVector, Scalar};
 
 use crate::geometry::Point;
 
@@ -16,107 +16,101 @@ use crate::geometry::Point;
  * Point -> Vector (homogeneous)
  */
 
-impl<N1, N2, D> SubsetOf<Point<N2, D>> for Point<N1, D>
+impl<T1, T2, const D: usize> SubsetOf<Point<T2, D>> for Point<T1, D>
 where
-    D: DimName,
-    N1: Scalar,
-    N2: Scalar + SupersetOf<N1>,
-    DefaultAllocator: Allocator<N2, D> + Allocator<N1, D>,
+    T1: Scalar,
+    T2: Scalar + SupersetOf<T1>,
 {
     #[inline]
-    fn to_superset(&self) -> Point<N2, D> {
+    fn to_superset(&self) -> Point<T2, D> {
         Point::from(self.coords.to_superset())
     }
 
     #[inline]
-    fn is_in_subset(m: &Point<N2, D>) -> bool {
+    fn is_in_subset(m: &Point<T2, D>) -> bool {
         // TODO: is there a way to reuse the `.is_in_subset` from the matrix implementation of
         // SubsetOf?
         m.iter().all(|e| e.is_in_subset())
     }
 
     #[inline]
-    fn from_superset_unchecked(m: &Point<N2, D>) -> Self {
+    fn from_superset_unchecked(m: &Point<T2, D>) -> Self {
         Self::from(Matrix::from_superset_unchecked(&m.coords))
     }
 }
 
-impl<N1, N2, D> SubsetOf<VectorN<N2, DimNameSum<D, U1>>> for Point<N1, D>
+impl<T1, T2, const D: usize> SubsetOf<OVector<T2, DimNameSum<Const<D>, U1>>> for Point<T1, D>
 where
-    D: DimNameAdd<U1>,
-    N1: Scalar,
-    N2: Scalar + Zero + One + ClosedDiv + SupersetOf<N1>,
-    DefaultAllocator: Allocator<N1, D>
-        + Allocator<N1, DimNameSum<D, U1>>
-        + Allocator<N2, DimNameSum<D, U1>>
-        + Allocator<N2, D>,
+    Const<D>: DimNameAdd<U1>,
+    T1: Scalar,
+    T2: Scalar + Zero + One + ClosedDiv + SupersetOf<T1>,
+    DefaultAllocator:
+        Allocator<T1, DimNameSum<Const<D>, U1>> + Allocator<T2, DimNameSum<Const<D>, U1>>,
+    // + Allocator<T1, D>
+    // + Allocator<T2, D>,
 {
     #[inline]
-    fn to_superset(&self) -> VectorN<N2, DimNameSum<D, U1>> {
-        let p: Point<N2, D> = self.to_superset();
+    fn to_superset(&self) -> OVector<T2, DimNameSum<Const<D>, U1>> {
+        let p: Point<T2, D> = self.to_superset();
         p.to_homogeneous()
     }
 
     #[inline]
-    fn is_in_subset(v: &VectorN<N2, DimNameSum<D, U1>>) -> bool {
-        crate::is_convertible::<_, VectorN<N1, DimNameSum<D, U1>>>(v) && !v[D::dim()].is_zero()
+    fn is_in_subset(v: &OVector<T2, DimNameSum<Const<D>, U1>>) -> bool {
+        crate::is_convertible::<_, OVector<T1, DimNameSum<Const<D>, U1>>>(v) && !v[D].is_zero()
     }
 
     #[inline]
-    fn from_superset_unchecked(v: &VectorN<N2, DimNameSum<D, U1>>) -> Self {
-        let coords = v.fixed_slice::<D, U1>(0, 0) / v[D::dim()].inlined_clone();
+    fn from_superset_unchecked(v: &OVector<T2, DimNameSum<Const<D>, U1>>) -> Self {
+        let coords = v.fixed_slice::<D, 1>(0, 0) / v[D].inlined_clone();
         Self {
             coords: crate::convert_unchecked(coords),
         }
     }
 }
 
-impl<N: Scalar + Zero + One, D: DimName> From<Point<N, D>> for VectorN<N, DimNameSum<D, U1>>
+impl<T: Scalar + Zero + One, const D: usize> From<Point<T, D>>
+    for OVector<T, DimNameSum<Const<D>, U1>>
 where
-    D: DimNameAdd<U1>,
-    DefaultAllocator: Allocator<N, D> + Allocator<N, DimNameSum<D, U1>>,
+    Const<D>: DimNameAdd<U1>,
+    DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>>,
 {
     #[inline]
-    fn from(t: Point<N, D>) -> Self {
+    fn from(t: Point<T, D>) -> Self {
         t.to_homogeneous()
     }
 }
 
-impl<N: Scalar, D: DimName> From<VectorN<N, D>> for Point<N, D>
-where
-    DefaultAllocator: Allocator<N, D>,
-{
+impl<T: Scalar, const D: usize> From<OVector<T, Const<D>>> for Point<T, D> {
     #[inline]
-    fn from(coords: VectorN<N, D>) -> Self {
+    fn from(coords: OVector<T, Const<D>>) -> Self {
         Point { coords }
     }
 }
 
-impl<N: Scalar + Copy + PrimitiveSimdValue, D: DimName> From<[Point<N::Element, D>; 2]>
-    for Point<N, D>
+impl<T: Scalar + Copy + PrimitiveSimdValue, const D: usize> From<[Point<T::Element, D>; 2]>
+    for Point<T, D>
 where
-    N: From<[<N as simba::simd::SimdValue>::Element; 2]>,
-    N::Element: Scalar + Copy,
-    DefaultAllocator: Allocator<N, D> + Allocator<N::Element, D>,
-    <DefaultAllocator as Allocator<N::Element, D>>::Buffer: Copy,
+    T: From<[<T as simba::simd::SimdValue>::Element; 2]>,
+    T::Element: Scalar + Copy,
+    <DefaultAllocator as Allocator<T::Element, Const<D>>>::Buffer: Copy,
 {
     #[inline]
-    fn from(arr: [Point<N::Element, D>; 2]) -> Self {
-        Self::from(VectorN::from([arr[0].coords, arr[1].coords]))
+    fn from(arr: [Point<T::Element, D>; 2]) -> Self {
+        Self::from(OVector::from([arr[0].coords, arr[1].coords]))
     }
 }
 
-impl<N: Scalar + Copy + PrimitiveSimdValue, D: DimName> From<[Point<N::Element, D>; 4]>
-    for Point<N, D>
+impl<T: Scalar + Copy + PrimitiveSimdValue, const D: usize> From<[Point<T::Element, D>; 4]>
+    for Point<T, D>
 where
-    N: From<[<N as simba::simd::SimdValue>::Element; 4]>,
-    N::Element: Scalar + Copy,
-    DefaultAllocator: Allocator<N, D> + Allocator<N::Element, D>,
-    <DefaultAllocator as Allocator<N::Element, D>>::Buffer: Copy,
+    T: From<[<T as simba::simd::SimdValue>::Element; 4]>,
+    T::Element: Scalar + Copy,
+    <DefaultAllocator as Allocator<T::Element, Const<D>>>::Buffer: Copy,
 {
     #[inline]
-    fn from(arr: [Point<N::Element, D>; 4]) -> Self {
-        Self::from(VectorN::from([
+    fn from(arr: [Point<T::Element, D>; 4]) -> Self {
+        Self::from(OVector::from([
             arr[0].coords,
             arr[1].coords,
             arr[2].coords,
@@ -125,17 +119,16 @@ where
     }
 }
 
-impl<N: Scalar + Copy + PrimitiveSimdValue, D: DimName> From<[Point<N::Element, D>; 8]>
-    for Point<N, D>
+impl<T: Scalar + Copy + PrimitiveSimdValue, const D: usize> From<[Point<T::Element, D>; 8]>
+    for Point<T, D>
 where
-    N: From<[<N as simba::simd::SimdValue>::Element; 8]>,
-    N::Element: Scalar + Copy,
-    DefaultAllocator: Allocator<N, D> + Allocator<N::Element, D>,
-    <DefaultAllocator as Allocator<N::Element, D>>::Buffer: Copy,
+    T: From<[<T as simba::simd::SimdValue>::Element; 8]>,
+    T::Element: Scalar + Copy,
+    <DefaultAllocator as Allocator<T::Element, Const<D>>>::Buffer: Copy,
 {
     #[inline]
-    fn from(arr: [Point<N::Element, D>; 8]) -> Self {
-        Self::from(VectorN::from([
+    fn from(arr: [Point<T::Element, D>; 8]) -> Self {
+        Self::from(OVector::from([
             arr[0].coords,
             arr[1].coords,
             arr[2].coords,
@@ -148,17 +141,16 @@ where
     }
 }
 
-impl<N: Scalar + Copy + PrimitiveSimdValue, D: DimName> From<[Point<N::Element, D>; 16]>
-    for Point<N, D>
+impl<T: Scalar + Copy + PrimitiveSimdValue, const D: usize> From<[Point<T::Element, D>; 16]>
+    for Point<T, D>
 where
-    N: From<[<N as simba::simd::SimdValue>::Element; 16]>,
-    N::Element: Scalar + Copy,
-    DefaultAllocator: Allocator<N, D> + Allocator<N::Element, D>,
-    <DefaultAllocator as Allocator<N::Element, D>>::Buffer: Copy,
+    T: From<[<T as simba::simd::SimdValue>::Element; 16]>,
+    T::Element: Scalar + Copy,
+    <DefaultAllocator as Allocator<T::Element, Const<D>>>::Buffer: Copy,
 {
     #[inline]
-    fn from(arr: [Point<N::Element, D>; 16]) -> Self {
-        Self::from(VectorN::from([
+    fn from(arr: [Point<T::Element, D>; 16]) -> Self {
+        Self::from(OVector::from([
             arr[0].coords,
             arr[1].coords,
             arr[2].coords,
diff --git a/src/geometry/point_coordinates.rs b/src/geometry/point_coordinates.rs
index 268c9b0d..8d9e9ccc 100644
--- a/src/geometry/point_coordinates.rs
+++ b/src/geometry/point_coordinates.rs
@@ -1,9 +1,7 @@
 use std::ops::{Deref, DerefMut};
 
-use crate::base::allocator::Allocator;
 use crate::base::coordinates::{X, XY, XYZ, XYZW, XYZWA, XYZWAB};
-use crate::base::dimension::{U1, U2, U3, U4, U5, U6};
-use crate::base::{DefaultAllocator, Scalar};
+use crate::base::Scalar;
 
 use crate::geometry::Point;
 
@@ -14,10 +12,10 @@ use crate::geometry::Point;
  */
 
 macro_rules! deref_impl(
-    ($D: ty, $Target: ident $(, $comps: ident)*) => {
-        impl<N: Scalar> Deref for Point<N, $D>
-            where DefaultAllocator: Allocator<N, $D> {
-            type Target = $Target<N>;
+    ($D: expr, $Target: ident $(, $comps: ident)*) => {
+        impl<T: Scalar> Deref for Point<T, $D>
+        {
+            type Target = $Target<T>;
 
             #[inline]
             fn deref(&self) -> &Self::Target {
@@ -25,8 +23,8 @@ macro_rules! deref_impl(
             }
         }
 
-        impl<N: Scalar> DerefMut for Point<N, $D>
-            where DefaultAllocator: Allocator<N, $D> {
+        impl<T: Scalar> DerefMut for Point<T, $D>
+        {
             #[inline]
             fn deref_mut(&mut self) -> &mut Self::Target {
                 &mut *self.coords
@@ -35,9 +33,9 @@ macro_rules! deref_impl(
     }
 );
 
-deref_impl!(U1, X, x);
-deref_impl!(U2, XY, x, y);
-deref_impl!(U3, XYZ, x, y, z);
-deref_impl!(U4, XYZW, x, y, z, w);
-deref_impl!(U5, XYZWA, x, y, z, w, a);
-deref_impl!(U6, XYZWAB, x, y, z, w, a, b);
+deref_impl!(1, X, x);
+deref_impl!(2, XY, x, y);
+deref_impl!(3, XYZ, x, y, z);
+deref_impl!(4, XYZW, x, y, z, w);
+deref_impl!(5, XYZWA, x, y, z, w, a);
+deref_impl!(6, XYZWAB, x, y, z, w, a, b);
diff --git a/src/geometry/point_ops.rs b/src/geometry/point_ops.rs
index 029286ff..576028cc 100644
--- a/src/geometry/point_ops.rs
+++ b/src/geometry/point_ops.rs
@@ -5,13 +5,12 @@ use std::ops::{
 
 use simba::scalar::{ClosedAdd, ClosedDiv, ClosedMul, ClosedNeg, ClosedSub};
 
-use crate::base::allocator::{Allocator, SameShapeAllocator};
 use crate::base::constraint::{
     AreMultipliable, SameNumberOfColumns, SameNumberOfRows, ShapeConstraint,
 };
-use crate::base::dimension::{Dim, DimName, U1};
+use crate::base::dimension::{Dim, U1};
 use crate::base::storage::Storage;
-use crate::base::{DefaultAllocator, Matrix, Scalar, Vector, VectorSum};
+use crate::base::{Const, Matrix, SVector, Scalar, Vector};
 
 use crate::geometry::Point;
 
@@ -20,11 +19,8 @@ use crate::geometry::Point;
  * Indexing.
  *
  */
-impl<N: Scalar, D: DimName> Index<usize> for Point<N, D>
-where
-    DefaultAllocator: Allocator<N, D>,
-{
-    type Output = N;
+impl<T: Scalar, const D: usize> Index<usize> for Point<T, D> {
+    type Output = T;
 
     #[inline]
     fn index(&self, i: usize) -> &Self::Output {
@@ -32,10 +28,7 @@ where
     }
 }
 
-impl<N: Scalar, D: DimName> IndexMut<usize> for Point<N, D>
-where
-    DefaultAllocator: Allocator<N, D>,
-{
+impl<T: Scalar, const D: usize> IndexMut<usize> for Point<T, D> {
     #[inline]
     fn index_mut(&mut self, i: usize) -> &mut Self::Output {
         &mut self.coords[i]
@@ -47,10 +40,7 @@ where
  * Neg.
  *
  */
-impl<N: Scalar + ClosedNeg, D: DimName> Neg for Point<N, D>
-where
-    DefaultAllocator: Allocator<N, D>,
-{
+impl<T: Scalar + ClosedNeg, const D: usize> Neg for Point<T, D> {
     type Output = Self;
 
     #[inline]
@@ -59,11 +49,8 @@ where
     }
 }
 
-impl<'a, N: Scalar + ClosedNeg, D: DimName> Neg for &'a Point<N, D>
-where
-    DefaultAllocator: Allocator<N, D>,
-{
-    type Output = Point<N, D>;
+impl<'a, T: Scalar + ClosedNeg, const D: usize> Neg for &'a Point<T, D> {
+    type Output = Point<T, D>;
 
     #[inline]
     fn neg(self) -> Self::Output {
@@ -79,90 +66,116 @@ where
 
 // Point - Point
 add_sub_impl!(Sub, sub, ClosedSub;
-    (D, U1), (D, U1) for D: DimName;
-    self: &'a Point<N, D>, right: &'b Point<N, D>, Output = VectorSum<N, D, D>;
+    (Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
+    const D; for; where;
+    self: &'a Point<T, D>, right: &'b Point<T, D>, Output = SVector<T, D>;
     &self.coords - &right.coords; 'a, 'b);
 
 add_sub_impl!(Sub, sub, ClosedSub;
-    (D, U1), (D, U1) for D: DimName;
-    self: &'a Point<N, D>, right: Point<N, D>, Output = VectorSum<N, D, D>;
+    (Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
+    const D; for; where;
+    self: &'a Point<T, D>, right: Point<T, D>, Output = SVector<T, D>;
     &self.coords - right.coords; 'a);
 
 add_sub_impl!(Sub, sub, ClosedSub;
-    (D, U1), (D, U1) for D: DimName;
-    self: Point<N, D>, right: &'b Point<N, D>, Output = VectorSum<N, D, D>;
+    (Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
+    const D; for; where;
+    self: Point<T, D>, right: &'b Point<T, D>, Output = SVector<T, D>;
     self.coords - &right.coords; 'b);
 
 add_sub_impl!(Sub, sub, ClosedSub;
-    (D, U1), (D, U1) for D: DimName;
-    self: Point<N, D>, right: Point<N, D>, Output = VectorSum<N, D, D>;
+    (Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
+    const D; for; where;
+    self: Point<T, D>, right: Point<T, D>, Output = SVector<T, D>;
     self.coords - right.coords; );
 
 // Point - Vector
 add_sub_impl!(Sub, sub, ClosedSub;
-    (D1, U1), (D2, U1) -> (D1) for D1: DimName, D2: Dim, SB: Storage<N, D2>;
-    self: &'a Point<N, D1>, right: &'b Vector<N, D2, SB>, Output = Point<N, D1>;
+    (Const<D1>, U1), (D2, U1) -> (Const<D1>, U1)
+    const D1;
+    for D2, SB;
+    where D2: Dim, SB: Storage<T, D2>;
+    self: &'a Point<T, D1>, right: &'b Vector<T, D2, SB>, Output = Point<T, D1>;
     Self::Output::from(&self.coords - right); 'a, 'b);
 
 add_sub_impl!(Sub, sub, ClosedSub;
-    (D1, U1), (D2, U1) -> (D1) for D1: DimName, D2: Dim, SB: Storage<N, D2>;
-    self: &'a Point<N, D1>, right: Vector<N, D2, SB>, Output = Point<N, D1>;
+    (Const<D1>, U1), (D2, U1) -> (Const<D1>, U1)
+    const D1;
+    for D2, SB;
+    where D2: Dim, SB: Storage<T, D2>;
+    self: &'a Point<T, D1>, right: Vector<T, D2, SB>, Output = Point<T, D1>;
     Self::Output::from(&self.coords - &right); 'a); // TODO: should not be a ref to `right`.
 
 add_sub_impl!(Sub, sub, ClosedSub;
-    (D1, U1), (D2, U1) -> (D1) for D1: DimName, D2: Dim, SB: Storage<N, D2>;
-    self: Point<N, D1>, right: &'b Vector<N, D2, SB>, Output = Point<N, D1>;
+    (Const<D1>, U1), (D2, U1) -> (Const<D1>, U1)
+    const D1;
+    for D2, SB;
+    where D2: Dim, SB: Storage<T, D2>;
+    self: Point<T, D1>, right: &'b Vector<T, D2, SB>, Output = Point<T, D1>;
     Self::Output::from(self.coords - right); 'b);
 
 add_sub_impl!(Sub, sub, ClosedSub;
-    (D1, U1), (D2, U1) -> (D1) for D1: DimName, D2: Dim, SB: Storage<N, D2>;
-    self: Point<N, D1>, right: Vector<N, D2, SB>, Output = Point<N, D1>;
+    (Const<D1>, U1), (D2, U1) -> (Const<D1>, U1)
+    const D1;
+    for D2, SB;
+    where D2: Dim, SB: Storage<T, D2>;
+    self: Point<T, D1>, right: Vector<T, D2, SB>, Output = Point<T, D1>;
     Self::Output::from(self.coords - right); );
 
 // Point + Vector
 add_sub_impl!(Add, add, ClosedAdd;
-    (D1, U1), (D2, U1) -> (D1) for D1: DimName, D2: Dim, SB: Storage<N, D2>;
-    self: &'a Point<N, D1>, right: &'b Vector<N, D2, SB>, Output = Point<N, D1>;
+    (Const<D1>, U1), (D2, U1) -> (Const<D1>, U1)
+    const D1;
+    for D2, SB;
+    where D2: Dim, SB: Storage<T, D2>;
+    self: &'a Point<T, D1>, right: &'b Vector<T, D2, SB>, Output = Point<T, D1>;
     Self::Output::from(&self.coords + right); 'a, 'b);
 
 add_sub_impl!(Add, add, ClosedAdd;
-    (D1, U1), (D2, U1) -> (D1) for D1: DimName, D2: Dim, SB: Storage<N, D2>;
-    self: &'a Point<N, D1>, right: Vector<N, D2, SB>, Output = Point<N, D1>;
+    (Const<D1>, U1), (D2, U1) -> (Const<D1>, U1)
+    const D1;
+    for D2, SB;
+    where D2: Dim, SB: Storage<T, D2>;
+    self: &'a Point<T, D1>, right: Vector<T, D2, SB>, Output = Point<T, D1>;
     Self::Output::from(&self.coords + &right); 'a); // TODO: should not be a ref to `right`.
 
 add_sub_impl!(Add, add, ClosedAdd;
-    (D1, U1), (D2, U1) -> (D1) for D1: DimName, D2: Dim, SB: Storage<N, D2>;
-    self: Point<N, D1>, right: &'b Vector<N, D2, SB>, Output = Point<N, D1>;
+    (Const<D1>, U1), (D2, U1) -> (Const<D1>, U1)
+    const D1;
+    for D2, SB;
+    where D2: Dim, SB: Storage<T, D2>;
+    self: Point<T, D1>, right: &'b Vector<T, D2, SB>, Output = Point<T, D1>;
     Self::Output::from(self.coords + right); 'b);
 
 add_sub_impl!(Add, add, ClosedAdd;
-    (D1, U1), (D2, U1) -> (D1) for D1: DimName, D2: Dim, SB: Storage<N, D2>;
-    self: Point<N, D1>, right: Vector<N, D2, SB>, Output = Point<N, D1>;
+    (Const<D1>, U1), (D2, U1) -> (Const<D1>, U1)
+    const D1;
+    for D2, SB;
+    where D2: Dim, SB: Storage<T, D2>;
+    self: Point<T, D1>, right: Vector<T, D2, SB>, Output = Point<T, D1>;
     Self::Output::from(self.coords + right); );
 
-// XXX: replace by the shared macro: add_sub_assign_impl
+// TODO: replace by the shared macro: add_sub_assign_impl?
 macro_rules! op_assign_impl(
     ($($TraitAssign: ident, $method_assign: ident, $bound: ident);* $(;)*) => {$(
-        impl<'b, N, D1: DimName, D2: Dim, SB> $TraitAssign<&'b Vector<N, D2, SB>> for Point<N, D1>
-            where N: Scalar + $bound,
-                  SB: Storage<N, D2>,
-                  DefaultAllocator: Allocator<N, D1>,
-                  ShapeConstraint: SameNumberOfRows<D1, D2> {
+        impl<'b, T, D2: Dim, SB, const D1: usize> $TraitAssign<&'b Vector<T, D2, SB>> for Point<T, D1>
+            where T: Scalar + $bound,
+                  SB: Storage<T, D2>,
+                  ShapeConstraint: SameNumberOfRows<Const<D1>, D2> {
 
             #[inline]
-            fn $method_assign(&mut self, right: &'b Vector<N, D2, SB>) {
+            fn $method_assign(&mut self, right: &'b Vector<T, D2, SB>) {
                 self.coords.$method_assign(right)
             }
         }
 
-        impl<N, D1: DimName, D2: Dim, SB> $TraitAssign<Vector<N, D2, SB>> for Point<N, D1>
-            where N: Scalar + $bound,
-                  SB: Storage<N, D2>,
-                  DefaultAllocator: Allocator<N, D1>,
-                  ShapeConstraint: SameNumberOfRows<D1, D2> {
+        impl<T, D2: Dim, SB, const D1: usize> $TraitAssign<Vector<T, D2, SB>> for Point<T, D1>
+            where T: Scalar + $bound,
+                  SB: Storage<T, D2>,
+                  ShapeConstraint: SameNumberOfRows<Const<D1>, D2> {
 
             #[inline]
-            fn $method_assign(&mut self, right: Vector<N, D2, SB>) {
+            fn $method_assign(&mut self, right: Vector<T, D2, SB>) {
                 self.coords.$method_assign(right)
             }
         }
@@ -181,9 +194,12 @@ op_assign_impl!(
  */
 md_impl_all!(
     Mul, mul;
-    (R1, C1), (D2, U1) for R1: DimName, C1: Dim, D2: DimName, SA: Storage<N, R1, C1>
-    where ShapeConstraint: AreMultipliable<R1, C1, D2, U1>;
-    self: Matrix<N, R1, C1, SA>, right: Point<N, D2>, Output = Point<N, R1>;
+    (Const<R1>, Const<C1>), (Const<D2>, U1)
+    const D2, R1, C1;
+    for SA;
+    where SA: Storage<T, Const<R1>, Const<C1>>,
+          ShapeConstraint: AreMultipliable<Const<R1>, Const<C1>, Const<D2>, U1>;
+    self: Matrix<T, Const<R1>, Const<C1>, SA>, right: Point<T, D2>, Output = Point<T, R1>;
     [val val] => Point::from(self * right.coords);
     [ref val] => Point::from(self * right.coords);
     [val ref] => Point::from(self * &right.coords);
@@ -198,30 +214,31 @@ md_impl_all!(
 macro_rules! componentwise_scalarop_impl(
     ($Trait: ident, $method: ident, $bound: ident;
      $TraitAssign: ident, $method_assign: ident) => {
-        impl<N: Scalar + $bound, D: DimName> $Trait<N> for Point<N, D>
-            where DefaultAllocator: Allocator<N, D> {
-            type Output = Point<N, D>;
+        impl<T: Scalar + $bound, const D: usize> $Trait<T> for Point<T, D>
+        {
+            type Output = Point<T, D>;
 
             #[inline]
-            fn $method(self, right: N) -> Self::Output {
+            fn $method(self, right: T) -> Self::Output {
                 Point::from(self.coords.$method(right))
             }
         }
 
-        impl<'a, N: Scalar + $bound, D: DimName> $Trait<N> for &'a Point<N, D>
-            where DefaultAllocator: Allocator<N, D> {
-            type Output = Point<N, D>;
+        impl<'a, T: Scalar + $bound, const D: usize> $Trait<T> for &'a Point<T, D>
+        {
+            type Output = Point<T, D>;
 
             #[inline]
-            fn $method(self, right: N) -> Self::Output {
+            fn $method(self, right: T) -> Self::Output {
                 Point::from((&self.coords).$method(right))
             }
         }
 
-        impl<N: Scalar + $bound, D: DimName> $TraitAssign<N> for Point<N, D>
-            where DefaultAllocator: Allocator<N, D> {
+        impl<T: Scalar + $bound, const D: usize> $TraitAssign<T> for Point<T, D>
+            /* where DefaultAllocator: Allocator<T, D> */
+        {
             #[inline]
-            fn $method_assign(&mut self, right: N) {
+            fn $method_assign(&mut self, right: T) {
                 self.coords.$method_assign(right)
             }
         }
@@ -233,8 +250,8 @@ componentwise_scalarop_impl!(Div, div, ClosedDiv; DivAssign, div_assign);
 
 macro_rules! left_scalar_mul_impl(
     ($($T: ty),* $(,)*) => {$(
-        impl<D: DimName> Mul<Point<$T, D>> for $T
-            where DefaultAllocator: Allocator<$T, D> {
+        impl<const D: usize> Mul<Point<$T, D>> for $T
+        {
             type Output = Point<$T, D>;
 
             #[inline]
@@ -243,8 +260,8 @@ macro_rules! left_scalar_mul_impl(
             }
         }
 
-        impl<'b, D: DimName> Mul<&'b Point<$T, D>> for $T
-            where DefaultAllocator: Allocator<$T, D> {
+        impl<'b, const D: usize> Mul<&'b Point<$T, D>> for $T
+        {
             type Output = Point<$T, D>;
 
             #[inline]
diff --git a/src/geometry/point_simba.rs b/src/geometry/point_simba.rs
index a6c8465e..ad7433af 100644
--- a/src/geometry/point_simba.rs
+++ b/src/geometry/point_simba.rs
@@ -1,27 +1,24 @@
 use simba::simd::SimdValue;
 
-use crate::base::allocator::Allocator;
-use crate::base::dimension::DimName;
-use crate::base::{DefaultAllocator, Scalar, VectorN};
+use crate::base::{OVector, Scalar};
 
 use crate::geometry::Point;
 
-impl<N: Scalar + SimdValue, D: DimName> SimdValue for Point<N, D>
+impl<T: Scalar + SimdValue, const D: usize> SimdValue for Point<T, D>
 where
-    N::Element: Scalar,
-    DefaultAllocator: Allocator<N, D> + Allocator<N::Element, D>,
+    T::Element: Scalar,
 {
-    type Element = Point<N::Element, D>;
-    type SimdBool = N::SimdBool;
+    type Element = Point<T::Element, D>;
+    type SimdBool = T::SimdBool;
 
     #[inline]
     fn lanes() -> usize {
-        N::lanes()
+        T::lanes()
     }
 
     #[inline]
     fn splat(val: Self::Element) -> Self {
-        VectorN::splat(val.coords).into()
+        OVector::splat(val.coords).into()
     }
 
     #[inline]
diff --git a/src/geometry/quaternion.rs b/src/geometry/quaternion.rs
index 172f2e66..6d45057f 100755
--- a/src/geometry/quaternion.rs
+++ b/src/geometry/quaternion.rs
@@ -1,6 +1,7 @@
 use approx::{AbsDiffEq, RelativeEq, UlpsEq};
 use num::Zero;
 use std::fmt;
+use std::hash::{Hash, Hasher};
 #[cfg(feature = "abomonation-serialize")]
 use std::io::{Result as IOResult, Write};
 
@@ -26,13 +27,28 @@ use crate::geometry::{Point3, Rotation};
 /// A quaternion. See the type alias `UnitQuaternion = Unit<Quaternion>` for a quaternion
 /// that may be used as a rotation.
 #[repr(C)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct Quaternion<N: Scalar> {
+#[derive(Debug, Copy, Clone)]
+pub struct Quaternion<T> {
     /// This quaternion as a 4D vector of coordinates in the `[ x, y, z, w ]` storage order.
-    pub coords: Vector4<N>,
+    pub coords: Vector4<T>,
 }
 
-impl<N: Scalar + Zero> Default for Quaternion<N> {
+impl<T: Scalar + Hash> Hash for Quaternion<T> {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.coords.hash(state)
+    }
+}
+
+impl<T: Scalar + Eq> Eq for Quaternion<T> {}
+
+impl<T: Scalar> PartialEq for Quaternion<T> {
+    #[inline]
+    fn eq(&self, right: &Self) -> bool {
+        self.coords == right.coords
+    }
+}
+
+impl<T: Scalar + Zero> Default for Quaternion<T> {
     fn default() -> Self {
         Quaternion {
             coords: Vector4::zeros(),
@@ -41,20 +57,20 @@ impl<N: Scalar + Zero> Default for Quaternion<N> {
 }
 
 #[cfg(feature = "bytemuck")]
-unsafe impl<N: Scalar> bytemuck::Zeroable for Quaternion<N> where Vector4<N>: bytemuck::Zeroable {}
+unsafe impl<T: Scalar> bytemuck::Zeroable for Quaternion<T> where Vector4<T>: bytemuck::Zeroable {}
 
 #[cfg(feature = "bytemuck")]
-unsafe impl<N: Scalar> bytemuck::Pod for Quaternion<N>
+unsafe impl<T: Scalar> bytemuck::Pod for Quaternion<T>
 where
-    Vector4<N>: bytemuck::Pod,
-    N: Copy,
+    Vector4<T>: bytemuck::Pod,
+    T: Copy,
 {
 }
 
 #[cfg(feature = "abomonation-serialize")]
-impl<N: Scalar> Abomonation for Quaternion<N>
+impl<T: Scalar> Abomonation for Quaternion<T>
 where
-    Vector4<N>: Abomonation,
+    Vector4<T>: Abomonation,
 {
     unsafe fn entomb<W: Write>(&self, writer: &mut W) -> IOResult<()> {
         self.coords.entomb(writer)
@@ -70,9 +86,9 @@ where
 }
 
 #[cfg(feature = "serde-serialize")]
-impl<N: Scalar> Serialize for Quaternion<N>
+impl<T: Scalar> Serialize for Quaternion<T>
 where
-    Owned<N, U4>: Serialize,
+    Owned<T, U4>: Serialize,
 {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
@@ -83,23 +99,23 @@ where
 }
 
 #[cfg(feature = "serde-serialize")]
-impl<'a, N: Scalar> Deserialize<'a> for Quaternion<N>
+impl<'a, T: Scalar> Deserialize<'a> for Quaternion<T>
 where
-    Owned<N, U4>: Deserialize<'a>,
+    Owned<T, U4>: Deserialize<'a>,
 {
     fn deserialize<Des>(deserializer: Des) -> Result<Self, Des::Error>
     where
         Des: Deserializer<'a>,
     {
-        let coords = Vector4::<N>::deserialize(deserializer)?;
+        let coords = Vector4::<T>::deserialize(deserializer)?;
 
         Ok(Self::from(coords))
     }
 }
 
-impl<N: SimdRealField> Quaternion<N>
+impl<T: SimdRealField> Quaternion<T>
 where
-    N::Element: SimdRealField,
+    T::Element: SimdRealField,
 {
     /// Moves this unit quaternion into one that owns its data.
     #[inline]
@@ -133,7 +149,7 @@ where
 
     /// The imaginary part of this quaternion.
     #[inline]
-    pub fn imag(&self) -> Vector3<N> {
+    pub fn imag(&self) -> Vector3<T> {
         self.coords.xyz()
     }
 
@@ -165,8 +181,8 @@ where
     /// assert_eq!(q1.lerp(&q2, 0.1), Quaternion::new(1.9, 3.8, 5.7, 7.6));
     /// ```
     #[inline]
-    pub fn lerp(&self, other: &Self, t: N) -> Self {
-        self * (N::one() - t) + other * t
+    pub fn lerp(&self, other: &Self, t: T) -> Self {
+        self * (T::one() - t) + other * t
     }
 
     /// The vector part `(i, j, k)` of this quaternion.
@@ -180,8 +196,8 @@ where
     /// assert_eq!(q.vector()[2], 4.0);
     /// ```
     #[inline]
-    pub fn vector(&self) -> MatrixSlice<N, U3, U1, RStride<N, U4, U1>, CStride<N, U4, U1>> {
-        self.coords.fixed_rows::<U3>(0)
+    pub fn vector(&self) -> MatrixSlice<T, U3, U1, RStride<T, U4, U1>, CStride<T, U4, U1>> {
+        self.coords.fixed_rows::<3>(0)
     }
 
     /// The scalar part `w` of this quaternion.
@@ -193,7 +209,7 @@ where
     /// assert_eq!(q.scalar(), 1.0);
     /// ```
     #[inline]
-    pub fn scalar(&self) -> N {
+    pub fn scalar(&self) -> T {
         self.coords[3]
     }
 
@@ -208,7 +224,7 @@ where
     /// assert_eq!(*q.as_vector(), Vector4::new(2.0, 3.0, 4.0, 1.0));
     /// ```
     #[inline]
-    pub fn as_vector(&self) -> &Vector4<N> {
+    pub fn as_vector(&self) -> &Vector4<T> {
         &self.coords
     }
 
@@ -222,7 +238,7 @@ where
     /// assert_relative_eq!(q.norm(), 5.47722557, epsilon = 1.0e-6);
     /// ```
     #[inline]
-    pub fn norm(&self) -> N {
+    pub fn norm(&self) -> T {
         self.coords.norm()
     }
 
@@ -239,7 +255,7 @@ where
     /// assert_relative_eq!(q.magnitude(), 5.47722557, epsilon = 1.0e-6);
     /// ```
     #[inline]
-    pub fn magnitude(&self) -> N {
+    pub fn magnitude(&self) -> T {
         self.norm()
     }
 
@@ -252,7 +268,7 @@ where
     /// assert_eq!(q.magnitude_squared(), 30.0);
     /// ```
     #[inline]
-    pub fn norm_squared(&self) -> N {
+    pub fn norm_squared(&self) -> T {
         self.coords.norm_squared()
     }
 
@@ -268,7 +284,7 @@ where
     /// assert_eq!(q.magnitude_squared(), 30.0);
     /// ```
     #[inline]
-    pub fn magnitude_squared(&self) -> N {
+    pub fn magnitude_squared(&self) -> T {
         self.norm_squared()
     }
 
@@ -282,14 +298,14 @@ where
     /// assert_eq!(q1.dot(&q2), 70.0);
     /// ```
     #[inline]
-    pub fn dot(&self, rhs: &Self) -> N {
+    pub fn dot(&self, rhs: &Self) -> T {
         self.coords.dot(&rhs.coords)
     }
 }
 
-impl<N: SimdRealField> Quaternion<N>
+impl<T: SimdRealField> Quaternion<T>
 where
-    N::Element: SimdRealField,
+    T::Element: SimdRealField,
 {
     /// Inverts this quaternion if it is not zero.
     ///
@@ -315,7 +331,7 @@ where
     #[must_use = "Did you mean to use try_inverse_mut()?"]
     pub fn try_inverse(&self) -> Option<Self>
     where
-        N: RealField,
+        T: RealField,
     {
         let mut res = *self;
 
@@ -333,7 +349,7 @@ where
     #[must_use = "Did you mean to use try_inverse_mut()?"]
     pub fn simd_try_inverse(&self) -> SimdOption<Self> {
         let norm_squared = self.norm_squared();
-        let ge = norm_squared.simd_ge(N::simd_default_epsilon());
+        let ge = norm_squared.simd_ge(T::simd_default_epsilon());
         SimdOption::new(self.conjugate() / norm_squared, ge)
     }
 
@@ -392,7 +408,7 @@ where
     #[inline]
     pub fn project(&self, other: &Self) -> Option<Self>
     where
-        N: RealField,
+        T: RealField,
     {
         self.inner(other).right_div(other)
     }
@@ -414,7 +430,7 @@ where
     #[inline]
     pub fn reject(&self, other: &Self) -> Option<Self>
     where
-        N: RealField,
+        T: RealField,
     {
         self.outer(other).right_div(other)
     }
@@ -434,20 +450,20 @@ where
     /// assert_eq!(half_ang, f32::consts::FRAC_PI_2);
     /// assert_eq!(axis, Some(Vector3::x_axis()));
     /// ```
-    pub fn polar_decomposition(&self) -> (N, N, Option<Unit<Vector3<N>>>)
+    pub fn polar_decomposition(&self) -> (T, T, Option<Unit<Vector3<T>>>)
     where
-        N: RealField,
+        T: RealField,
     {
-        if let Some((q, n)) = Unit::try_new_and_get(*self, N::zero()) {
-            if let Some(axis) = Unit::try_new(self.vector().clone_owned(), N::zero()) {
+        if let Some((q, n)) = Unit::try_new_and_get(*self, T::zero()) {
+            if let Some(axis) = Unit::try_new(self.vector().clone_owned(), T::zero()) {
                 let angle = q.angle() / crate::convert(2.0f64);
 
                 (n, angle, Some(axis))
             } else {
-                (n, N::zero(), None)
+                (n, T::zero(), None)
             }
         } else {
-            (N::zero(), N::zero(), None)
+            (T::zero(), T::zero(), None)
         }
     }
 
@@ -480,7 +496,7 @@ where
     /// ```
     #[inline]
     pub fn exp(&self) -> Self {
-        self.exp_eps(N::simd_default_epsilon())
+        self.exp_eps(T::simd_default_epsilon())
     }
 
     /// Compute the exponential of a quaternion. Returns the identity if the vector part of this quaternion
@@ -498,7 +514,7 @@ where
     /// assert_eq!(q.exp_eps(1.0e-6), Quaternion::identity());
     /// ```
     #[inline]
-    pub fn exp_eps(&self, eps: N) -> Self {
+    pub fn exp_eps(&self, eps: T) -> Self {
         let v = self.vector();
         let nn = v.norm_squared();
         let le = nn.simd_le(eps * eps);
@@ -521,7 +537,7 @@ where
     /// assert_relative_eq!(q.powf(1.5), Quaternion::new( -6.2576659, 4.1549037, 6.2323556, 8.3098075), epsilon = 1.0e-6);
     /// ```
     #[inline]
-    pub fn powf(&self, n: N) -> Self {
+    pub fn powf(&self, n: T) -> Self {
         (self.ln() * n).exp()
     }
 
@@ -535,7 +551,7 @@ where
     /// assert!(q.i == 1.0 && q.j == 2.0 && q.k == 3.0 && q.w == 4.0);
     /// ```
     #[inline]
-    pub fn as_vector_mut(&mut self) -> &mut Vector4<N> {
+    pub fn as_vector_mut(&mut self) -> &mut Vector4<T> {
         &mut self.coords
     }
 
@@ -556,8 +572,8 @@ where
     #[inline]
     pub fn vector_mut(
         &mut self,
-    ) -> MatrixSliceMut<N, U3, U1, RStride<N, U4, U1>, CStride<N, U4, U1>> {
-        self.coords.fixed_rows_mut::<U3>(0)
+    ) -> MatrixSliceMut<T, U3, U1, RStride<T, U4, U1>, CStride<T, U4, U1>> {
+        self.coords.fixed_rows_mut::<3>(0)
     }
 
     /// Replaces this quaternion by its conjugate.
@@ -592,9 +608,9 @@ where
     /// assert!(!q.try_inverse_mut());
     /// ```
     #[inline]
-    pub fn try_inverse_mut(&mut self) -> N::SimdBool {
+    pub fn try_inverse_mut(&mut self) -> T::SimdBool {
         let norm_squared = self.norm_squared();
-        let ge = norm_squared.simd_ge(N::simd_default_epsilon());
+        let ge = norm_squared.simd_ge(T::simd_default_epsilon());
         *self = ge.if_else(|| self.conjugate() / norm_squared, || *self);
         ge
     }
@@ -610,7 +626,7 @@ where
     /// assert_relative_eq!(q.norm(), 1.0);
     /// ```
     #[inline]
-    pub fn normalize_mut(&mut self) -> N {
+    pub fn normalize_mut(&mut self) -> T {
         self.coords.normalize_mut()
     }
 
@@ -652,7 +668,7 @@ where
     #[inline]
     pub fn left_div(&self, other: &Self) -> Option<Self>
     where
-        N: RealField,
+        T: RealField,
     {
         other.try_inverse().map(|inv| inv * self)
     }
@@ -674,7 +690,7 @@ where
     #[inline]
     pub fn right_div(&self, other: &Self) -> Option<Self>
     where
-        N: RealField,
+        T: RealField,
     {
         other.try_inverse().map(|inv| self * inv)
     }
@@ -769,7 +785,7 @@ where
     #[inline]
     pub fn tan(&self) -> Self
     where
-        N: RealField,
+        T: RealField,
     {
         self.sin().right_div(&self.cos()).unwrap()
     }
@@ -787,7 +803,7 @@ where
     #[inline]
     pub fn atan(&self) -> Self
     where
-        N: RealField,
+        T: RealField,
     {
         let u = Self::from_imag(self.imag().normalize());
         let num = u + self;
@@ -877,7 +893,7 @@ where
     #[inline]
     pub fn tanh(&self) -> Self
     where
-        N: RealField,
+        T: RealField,
     {
         self.sinh().right_div(&self.cosh()).unwrap()
     }
@@ -900,12 +916,12 @@ where
     }
 }
 
-impl<N: RealField + AbsDiffEq<Epsilon = N>> AbsDiffEq for Quaternion<N> {
-    type Epsilon = N;
+impl<T: RealField + AbsDiffEq<Epsilon = T>> AbsDiffEq for Quaternion<T> {
+    type Epsilon = T;
 
     #[inline]
     fn default_epsilon() -> Self::Epsilon {
-        N::default_epsilon()
+        T::default_epsilon()
     }
 
     #[inline]
@@ -916,10 +932,10 @@ impl<N: RealField + AbsDiffEq<Epsilon = N>> AbsDiffEq for Quaternion<N> {
     }
 }
 
-impl<N: RealField + RelativeEq<Epsilon = N>> RelativeEq for Quaternion<N> {
+impl<T: RealField + RelativeEq<Epsilon = T>> RelativeEq for Quaternion<T> {
     #[inline]
     fn default_max_relative() -> Self::Epsilon {
-        N::default_max_relative()
+        T::default_max_relative()
     }
 
     #[inline]
@@ -935,10 +951,10 @@ impl<N: RealField + RelativeEq<Epsilon = N>> RelativeEq for Quaternion<N> {
     }
 }
 
-impl<N: RealField + UlpsEq<Epsilon = N>> UlpsEq for Quaternion<N> {
+impl<T: RealField + UlpsEq<Epsilon = T>> UlpsEq for Quaternion<T> {
     #[inline]
     fn default_max_ulps() -> u32 {
-        N::default_max_ulps()
+        T::default_max_ulps()
     }
 
     #[inline]
@@ -949,7 +965,7 @@ impl<N: RealField + UlpsEq<Epsilon = N>> UlpsEq for Quaternion<N> {
     }
 }
 
-impl<N: RealField + fmt::Display> fmt::Display for Quaternion<N> {
+impl<T: RealField + fmt::Display> fmt::Display for Quaternion<T> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(
             f,
@@ -960,9 +976,9 @@ impl<N: RealField + fmt::Display> fmt::Display for Quaternion<N> {
 }
 
 /// A unit quaternions. May be used to represent a rotation.
-pub type UnitQuaternion<N> = Unit<Quaternion<N>>;
+pub type UnitQuaternion<T> = Unit<Quaternion<T>>;
 
-impl<N: Scalar + ClosedNeg + PartialEq> PartialEq for UnitQuaternion<N> {
+impl<T: Scalar + ClosedNeg + PartialEq> PartialEq for UnitQuaternion<T> {
     #[inline]
     fn eq(&self, rhs: &Self) -> bool {
         self.coords == rhs.coords ||
@@ -971,18 +987,18 @@ impl<N: Scalar + ClosedNeg + PartialEq> PartialEq for UnitQuaternion<N> {
     }
 }
 
-impl<N: Scalar + ClosedNeg + Eq> Eq for UnitQuaternion<N> {}
+impl<T: Scalar + ClosedNeg + Eq> Eq for UnitQuaternion<T> {}
 
-impl<N: SimdRealField> Normed for Quaternion<N> {
-    type Norm = N::SimdRealField;
+impl<T: SimdRealField> Normed for Quaternion<T> {
+    type Norm = T::SimdRealField;
 
     #[inline]
-    fn norm(&self) -> N::SimdRealField {
+    fn norm(&self) -> T::SimdRealField {
         self.coords.norm()
     }
 
     #[inline]
-    fn norm_squared(&self) -> N::SimdRealField {
+    fn norm_squared(&self) -> T::SimdRealField {
         self.coords.norm_squared()
     }
 
@@ -997,9 +1013,9 @@ impl<N: SimdRealField> Normed for Quaternion<N> {
     }
 }
 
-impl<N: SimdRealField> UnitQuaternion<N>
+impl<T: SimdRealField> UnitQuaternion<T>
 where
-    N::Element: SimdRealField,
+    T::Element: SimdRealField,
 {
     /// The rotation angle in [0; pi] of this unit quaternion.
     ///
@@ -1011,7 +1027,7 @@ where
     /// assert_eq!(rot.angle(), 1.78);
     /// ```
     #[inline]
-    pub fn angle(&self) -> N {
+    pub fn angle(&self) -> T {
         let w = self.quaternion().scalar().simd_abs();
         self.quaternion().imag().norm().simd_atan2(w) * crate::convert(2.0f64)
     }
@@ -1027,7 +1043,7 @@ where
     /// assert_eq!(*axis.quaternion(), Quaternion::new(1.0, 0.0, 0.0, 0.0));
     /// ```
     #[inline]
-    pub fn quaternion(&self) -> &Quaternion<N> {
+    pub fn quaternion(&self) -> &Quaternion<T> {
         self.as_ref()
     }
 
@@ -1075,7 +1091,7 @@ where
     /// assert_relative_eq!(rot1.angle_to(&rot2), 1.0045657, epsilon = 1.0e-6);
     /// ```
     #[inline]
-    pub fn angle_to(&self, other: &Self) -> N {
+    pub fn angle_to(&self, other: &Self) -> T {
         let delta = self.rotation_to(other);
         delta.angle()
     }
@@ -1110,7 +1126,7 @@ where
     /// assert_eq!(q1.lerp(&q2, 0.1), Quaternion::new(0.9, 0.1, 0.0, 0.0));
     /// ```
     #[inline]
-    pub fn lerp(&self, other: &Self, t: N) -> Quaternion<N> {
+    pub fn lerp(&self, other: &Self, t: T) -> Quaternion<T> {
         self.as_ref().lerp(other.as_ref(), t)
     }
 
@@ -1126,7 +1142,7 @@ where
     /// assert_eq!(q1.nlerp(&q2, 0.1), UnitQuaternion::new_normalize(Quaternion::new(0.9, 0.1, 0.0, 0.0)));
     /// ```
     #[inline]
-    pub fn nlerp(&self, other: &Self, t: N) -> Self {
+    pub fn nlerp(&self, other: &Self, t: T) -> Self {
         let mut res = self.lerp(other, t);
         let _ = res.normalize_mut();
 
@@ -1151,11 +1167,11 @@ where
     /// assert_eq!(q.euler_angles(), (std::f32::consts::FRAC_PI_2, 0.0, 0.0));
     /// ```
     #[inline]
-    pub fn slerp(&self, other: &Self, t: N) -> Self
+    pub fn slerp(&self, other: &Self, t: T) -> Self
     where
-        N: RealField,
+        T: RealField,
     {
-        self.try_slerp(other, t, N::default_epsilon())
+        self.try_slerp(other, t, T::default_epsilon())
             .expect("Quaternion slerp: ambiguous configuration.")
     }
 
@@ -1170,11 +1186,11 @@ where
     /// * `epsilon`: the value below which the sinus of the angle separating both quaternion
     /// must be to return `None`.
     #[inline]
-    pub fn try_slerp(&self, other: &Self, t: N, epsilon: N) -> Option<Self>
+    pub fn try_slerp(&self, other: &Self, t: T, epsilon: T) -> Option<Self>
     where
-        N: RealField,
+        T: RealField,
     {
-        let coords = if self.coords.dot(&other.coords) < N::zero() {
+        let coords = if self.coords.dot(&other.coords) < T::zero() {
             Unit::new_unchecked(self.coords).try_slerp(
                 &Unit::new_unchecked(-other.coords),
                 t,
@@ -1229,17 +1245,17 @@ where
     /// assert!(rot.axis().is_none());
     /// ```
     #[inline]
-    pub fn axis(&self) -> Option<Unit<Vector3<N>>>
+    pub fn axis(&self) -> Option<Unit<Vector3<T>>>
     where
-        N: RealField,
+        T: RealField,
     {
-        let v = if self.quaternion().scalar() >= N::zero() {
+        let v = if self.quaternion().scalar() >= T::zero() {
             self.as_ref().vector().clone_owned()
         } else {
             -self.as_ref().vector()
         };
 
-        Unit::try_new(v, N::zero())
+        Unit::try_new(v, T::zero())
     }
 
     /// The rotation axis of this unit quaternion multiplied by the rotation angle.
@@ -1253,9 +1269,9 @@ where
     /// assert_relative_eq!(rot.scaled_axis(), axisangle, epsilon = 1.0e-6);
     /// ```
     #[inline]
-    pub fn scaled_axis(&self) -> Vector3<N>
+    pub fn scaled_axis(&self) -> Vector3<T>
     where
-        N: RealField,
+        T: RealField,
     {
         if let Some(axis) = self.axis() {
             axis.into_inner() * self.angle()
@@ -1281,24 +1297,24 @@ where
     /// assert!(rot.axis_angle().is_none());
     /// ```
     #[inline]
-    pub fn axis_angle(&self) -> Option<(Unit<Vector3<N>>, N)>
+    pub fn axis_angle(&self) -> Option<(Unit<Vector3<T>>, T)>
     where
-        N: RealField,
+        T: RealField,
     {
         self.axis().map(|axis| (axis, self.angle()))
     }
 
     /// Compute the exponential of a quaternion.
     ///
-    /// Note that this function yields a `Quaternion<N>` because it loses the unit property.
+    /// Note that this function yields a `Quaternion<T>` because it loses the unit property.
     #[inline]
-    pub fn exp(&self) -> Quaternion<N> {
+    pub fn exp(&self) -> Quaternion<T> {
         self.as_ref().exp()
     }
 
     /// Compute the natural logarithm of a quaternion.
     ///
-    /// Note that this function yields a `Quaternion<N>` because it loses the unit property.
+    /// Note that this function yields a `Quaternion<T>` because it loses the unit property.
     /// The vector part of the return value corresponds to the axis-angle representation (divided
     /// by 2.0) of this unit quaternion.
     ///
@@ -1311,9 +1327,9 @@ where
     /// assert_relative_eq!(q.ln().vector().into_owned(), axisangle, epsilon = 1.0e-6);
     /// ```
     #[inline]
-    pub fn ln(&self) -> Quaternion<N>
+    pub fn ln(&self) -> Quaternion<T>
     where
-        N: RealField,
+        T: RealField,
     {
         if let Some(v) = self.axis() {
             Quaternion::from_imag(v.into_inner() * self.angle())
@@ -1339,9 +1355,9 @@ where
     /// assert_eq!(pow.angle(), 2.4);
     /// ```
     #[inline]
-    pub fn powf(&self, n: N) -> Self
+    pub fn powf(&self, n: T) -> Self
     where
-        N: RealField,
+        T: RealField,
     {
         if let Some(v) = self.axis() {
             Self::from_axis_angle(&v, self.angle() * n)
@@ -1367,7 +1383,7 @@ where
     /// assert_relative_eq!(*rot.matrix(), expected, epsilon = 1.0e-6);
     /// ```
     #[inline]
-    pub fn to_rotation_matrix(&self) -> Rotation<N, U3> {
+    pub fn to_rotation_matrix(&self) -> Rotation<T, 3> {
         let i = self.as_ref()[0];
         let j = self.as_ref()[1];
         let k = self.as_ref()[2];
@@ -1402,9 +1418,9 @@ where
     /// The angles are produced in the form (roll, pitch, yaw).
     #[inline]
     #[deprecated(note = "This is renamed to use `.euler_angles()`.")]
-    pub fn to_euler_angles(&self) -> (N, N, N)
+    pub fn to_euler_angles(&self) -> (T, T, T)
     where
-        N: RealField,
+        T: RealField,
     {
         self.euler_angles()
     }
@@ -1424,9 +1440,9 @@ where
     /// assert_relative_eq!(euler.2, 0.3, epsilon = 1.0e-6);
     /// ```
     #[inline]
-    pub fn euler_angles(&self) -> (N, N, N)
+    pub fn euler_angles(&self) -> (T, T, T)
     where
-        N: RealField,
+        T: RealField,
     {
         self.to_rotation_matrix().euler_angles()
     }
@@ -1448,7 +1464,7 @@ where
     /// assert_relative_eq!(rot.to_homogeneous(), expected, epsilon = 1.0e-6);
     /// ```
     #[inline]
-    pub fn to_homogeneous(&self) -> Matrix4<N> {
+    pub fn to_homogeneous(&self) -> Matrix4<T> {
         self.to_rotation_matrix().to_homogeneous()
     }
 
@@ -1468,7 +1484,7 @@ where
     /// assert_relative_eq!(transformed_point, Point3::new(3.0, 2.0, -1.0), epsilon = 1.0e-6);
     /// ```
     #[inline]
-    pub fn transform_point(&self, pt: &Point3<N>) -> Point3<N> {
+    pub fn transform_point(&self, pt: &Point3<T>) -> Point3<T> {
         self * pt
     }
 
@@ -1488,7 +1504,7 @@ where
     /// assert_relative_eq!(transformed_vector, Vector3::new(3.0, 2.0, -1.0), epsilon = 1.0e-6);
     /// ```
     #[inline]
-    pub fn transform_vector(&self, v: &Vector3<N>) -> Vector3<N> {
+    pub fn transform_vector(&self, v: &Vector3<T>) -> Vector3<T> {
         self * v
     }
 
@@ -1508,7 +1524,7 @@ where
     /// assert_relative_eq!(transformed_point, Point3::new(-3.0, 2.0, 1.0), epsilon = 1.0e-6);
     /// ```
     #[inline]
-    pub fn inverse_transform_point(&self, pt: &Point3<N>) -> Point3<N> {
+    pub fn inverse_transform_point(&self, pt: &Point3<T>) -> Point3<T> {
         // TODO: would it be useful performancewise not to call inverse explicitly (i-e. implement
         // the inverse transformation explicitly here) ?
         self.inverse() * pt
@@ -1530,7 +1546,7 @@ where
     /// assert_relative_eq!(transformed_vector, Vector3::new(-3.0, 2.0, 1.0), epsilon = 1.0e-6);
     /// ```
     #[inline]
-    pub fn inverse_transform_vector(&self, v: &Vector3<N>) -> Vector3<N> {
+    pub fn inverse_transform_vector(&self, v: &Vector3<T>) -> Vector3<T> {
         self.inverse() * v
     }
 
@@ -1550,7 +1566,7 @@ where
     /// assert_relative_eq!(transformed_vector, -Vector3::y_axis(), epsilon = 1.0e-6);
     /// ```
     #[inline]
-    pub fn inverse_transform_unit_vector(&self, v: &Unit<Vector3<N>>) -> Unit<Vector3<N>> {
+    pub fn inverse_transform_unit_vector(&self, v: &Unit<Vector3<T>>) -> Unit<Vector3<T>> {
         self.inverse() * v
     }
 
@@ -1558,21 +1574,21 @@ where
     ///
     /// This is faster, but approximate, way to compute `UnitQuaternion::new(axisangle) * self`.
     #[inline]
-    pub fn append_axisangle_linearized(&self, axisangle: &Vector3<N>) -> Self {
-        let half: N = crate::convert(0.5);
+    pub fn append_axisangle_linearized(&self, axisangle: &Vector3<T>) -> Self {
+        let half: T = crate::convert(0.5);
         let q1 = self.into_inner();
         let q2 = Quaternion::from_imag(axisangle * half);
         Unit::new_normalize(q1 + q2 * q1)
     }
 }
 
-impl<N: RealField> Default for UnitQuaternion<N> {
+impl<T: RealField> Default for UnitQuaternion<T> {
     fn default() -> Self {
         Self::identity()
     }
 }
 
-impl<N: RealField + fmt::Display> fmt::Display for UnitQuaternion<N> {
+impl<T: RealField + fmt::Display> fmt::Display for UnitQuaternion<T> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         if let Some(axis) = self.axis() {
             let axis = axis.into_inner();
@@ -1594,12 +1610,12 @@ impl<N: RealField + fmt::Display> fmt::Display for UnitQuaternion<N> {
     }
 }
 
-impl<N: RealField + AbsDiffEq<Epsilon = N>> AbsDiffEq for UnitQuaternion<N> {
-    type Epsilon = N;
+impl<T: RealField + AbsDiffEq<Epsilon = T>> AbsDiffEq for UnitQuaternion<T> {
+    type Epsilon = T;
 
     #[inline]
     fn default_epsilon() -> Self::Epsilon {
-        N::default_epsilon()
+        T::default_epsilon()
     }
 
     #[inline]
@@ -1608,10 +1624,10 @@ impl<N: RealField + AbsDiffEq<Epsilon = N>> AbsDiffEq for UnitQuaternion<N> {
     }
 }
 
-impl<N: RealField + RelativeEq<Epsilon = N>> RelativeEq for UnitQuaternion<N> {
+impl<T: RealField + RelativeEq<Epsilon = T>> RelativeEq for UnitQuaternion<T> {
     #[inline]
     fn default_max_relative() -> Self::Epsilon {
-        N::default_max_relative()
+        T::default_max_relative()
     }
 
     #[inline]
@@ -1626,10 +1642,10 @@ impl<N: RealField + RelativeEq<Epsilon = N>> RelativeEq for UnitQuaternion<N> {
     }
 }
 
-impl<N: RealField + UlpsEq<Epsilon = N>> UlpsEq for UnitQuaternion<N> {
+impl<T: RealField + UlpsEq<Epsilon = T>> UlpsEq for UnitQuaternion<T> {
     #[inline]
     fn default_max_ulps() -> u32 {
-        N::default_max_ulps()
+        T::default_max_ulps()
     }
 
     #[inline]
diff --git a/src/geometry/quaternion_construction.rs b/src/geometry/quaternion_construction.rs
index 1b87dba0..f110e3dd 100644
--- a/src/geometry/quaternion_construction.rs
+++ b/src/geometry/quaternion_construction.rs
@@ -7,7 +7,7 @@ use quickcheck::{Arbitrary, Gen};
 
 #[cfg(feature = "rand-no-std")]
 use rand::{
-    distributions::{Distribution, OpenClosed01, Standard, Uniform, uniform::SampleUniform},
+    distributions::{uniform::SampleUniform, Distribution, OpenClosed01, Standard, Uniform},
     Rng,
 };
 
@@ -23,12 +23,12 @@ use crate::{Scalar, SimdRealField};
 
 use crate::geometry::{Quaternion, Rotation3, UnitQuaternion};
 
-impl<N: Scalar> Quaternion<N> {
+impl<T> Quaternion<T> {
     /// Creates a quaternion from a 4D vector. The quaternion scalar part corresponds to the `w`
     /// vector component.
     #[inline]
-    #[deprecated(note = "Use `::from` instead.")]
-    pub fn from_vector(vector: Vector4<N>) -> Self {
+    // #[deprecated(note = "Use `::from` instead.")] // Don't deprecate because this one can be a const-fn.
+    pub const fn from_vector(vector: Vector4<T>) -> Self {
         Self { coords: vector }
     }
 
@@ -46,8 +46,8 @@ impl<N: Scalar> Quaternion<N> {
     /// assert_eq!(*q.as_vector(), Vector4::new(2.0, 3.0, 4.0, 1.0));
     /// ```
     #[inline]
-    pub fn new(w: N, i: N, j: N, k: N) -> Self {
-        Self::from(Vector4::new(i, j, k, w))
+    pub const fn new(w: T, i: T, j: T, k: T) -> Self {
+        Self::from_vector(Vector4::new(i, j, k, w))
     }
 
     /// Cast the components of `self` to another type.
@@ -61,17 +61,18 @@ impl<N: Scalar> Quaternion<N> {
     /// ```
     pub fn cast<To: Scalar>(self) -> Quaternion<To>
     where
-        To: SupersetOf<N>,
+        T: Scalar,
+        To: SupersetOf<T>,
     {
         crate::convert(self)
     }
 }
 
-impl<N: SimdRealField> Quaternion<N> {
+impl<T: SimdRealField> Quaternion<T> {
     /// Constructs a pure quaternion.
     #[inline]
-    pub fn from_imag(vector: Vector3<N>) -> Self {
-        Self::from_parts(N::zero(), vector)
+    pub fn from_imag(vector: Vector3<T>) -> Self {
+        Self::from_parts(T::zero(), vector)
     }
 
     /// Creates a new quaternion from its scalar and vector parts. Note that the arguments order does
@@ -90,16 +91,16 @@ impl<N: SimdRealField> Quaternion<N> {
     /// ```
     #[inline]
     // TODO: take a reference to `vector`?
-    pub fn from_parts<SB>(scalar: N, vector: Vector<N, U3, SB>) -> Self
+    pub fn from_parts<SB>(scalar: T, vector: Vector<T, U3, SB>) -> Self
     where
-        SB: Storage<N, U3>,
+        SB: Storage<T, U3>,
     {
         Self::new(scalar, vector[0], vector[1], vector[2])
     }
 
     /// Constructs a real quaternion.
     #[inline]
-    pub fn from_real(r: N) -> Self {
+    pub fn from_real(r: T) -> Self {
         Self::from_parts(r, Vector3::zero())
     }
 
@@ -116,32 +117,32 @@ impl<N: SimdRealField> Quaternion<N> {
     /// ```
     #[inline]
     pub fn identity() -> Self {
-        Self::from_real(N::one())
+        Self::from_real(T::one())
     }
 }
 
 // TODO: merge with the previous block.
-impl<N: SimdRealField> Quaternion<N>
+impl<T: SimdRealField> Quaternion<T>
 where
-    N::Element: SimdRealField,
+    T::Element: SimdRealField,
 {
     /// Creates a new quaternion from its polar decomposition.
     ///
     /// Note that `axis` is assumed to be a unit vector.
     // TODO: take a reference to `axis`?
-    pub fn from_polar_decomposition<SB>(scale: N, theta: N, axis: Unit<Vector<N, U3, SB>>) -> Self
+    pub fn from_polar_decomposition<SB>(scale: T, theta: T, axis: Unit<Vector<T, U3, SB>>) -> Self
     where
-        SB: Storage<N, U3>,
+        SB: Storage<T, U3>,
     {
-        let rot = UnitQuaternion::<N>::from_axis_angle(&axis, theta * crate::convert(2.0f64));
+        let rot = UnitQuaternion::<T>::from_axis_angle(&axis, theta * crate::convert(2.0f64));
 
         rot.into_inner() * scale
     }
 }
 
-impl<N: SimdRealField> One for Quaternion<N>
+impl<T: SimdRealField> One for Quaternion<T>
 where
-    N::Element: SimdRealField,
+    T::Element: SimdRealField,
 {
     #[inline]
     fn one() -> Self {
@@ -149,9 +150,9 @@ where
     }
 }
 
-impl<N: SimdRealField> Zero for Quaternion<N>
+impl<T: SimdRealField> Zero for Quaternion<T>
 where
-    N::Element: SimdRealField,
+    T::Element: SimdRealField,
 {
     #[inline]
     fn zero() -> Self {
@@ -165,35 +166,35 @@ where
 }
 
 #[cfg(feature = "rand-no-std")]
-impl<N: SimdRealField> Distribution<Quaternion<N>> for Standard
+impl<T: SimdRealField> Distribution<Quaternion<T>> for Standard
 where
-    Standard: Distribution<N>,
+    Standard: Distribution<T>,
 {
     #[inline]
-    fn sample<'a, R: Rng + ?Sized>(&self, rng: &'a mut R) -> Quaternion<N> {
+    fn sample<'a, R: Rng + ?Sized>(&self, rng: &'a mut R) -> Quaternion<T> {
         Quaternion::new(rng.gen(), rng.gen(), rng.gen(), rng.gen())
     }
 }
 
 #[cfg(feature = "arbitrary")]
-impl<N: SimdRealField + Arbitrary> Arbitrary for Quaternion<N>
+impl<T: SimdRealField + Arbitrary> Arbitrary for Quaternion<T>
 where
-    Owned<N, U4>: Send,
+    Owned<T, U4>: Send,
 {
     #[inline]
     fn arbitrary(g: &mut Gen) -> Self {
         Self::new(
-            N::arbitrary(g),
-            N::arbitrary(g),
-            N::arbitrary(g),
-            N::arbitrary(g),
+            T::arbitrary(g),
+            T::arbitrary(g),
+            T::arbitrary(g),
+            T::arbitrary(g),
         )
     }
 }
 
-impl<N: SimdRealField> UnitQuaternion<N>
+impl<T: SimdRealField> UnitQuaternion<T>
 where
-    N::Element: SimdRealField,
+    T::Element: SimdRealField,
 {
     /// The rotation identity.
     ///
@@ -227,7 +228,7 @@ where
     /// ```
     pub fn cast<To: Scalar>(self) -> UnitQuaternion<To>
     where
-        To: SupersetOf<N>,
+        To: SupersetOf<T>,
     {
         crate::convert(self)
     }
@@ -256,9 +257,9 @@ where
     /// assert_eq!(UnitQuaternion::from_scaled_axis(Vector3::<f32>::zeros()), UnitQuaternion::identity());
     /// ```
     #[inline]
-    pub fn from_axis_angle<SB>(axis: &Unit<Vector<N, U3, SB>>, angle: N) -> Self
+    pub fn from_axis_angle<SB>(axis: &Unit<Vector<T, U3, SB>>, angle: T) -> Self
     where
-        SB: Storage<N, U3>,
+        SB: Storage<T, U3>,
     {
         let (sang, cang) = (angle / crate::convert(2.0f64)).simd_sin_cos();
 
@@ -270,7 +271,7 @@ where
     ///
     /// The input quaternion will be normalized.
     #[inline]
-    pub fn from_quaternion(q: Quaternion<N>) -> Self {
+    pub fn from_quaternion(q: Quaternion<T>) -> Self {
         Self::new_normalize(q)
     }
 
@@ -289,7 +290,7 @@ where
     /// assert_relative_eq!(euler.2, 0.3, epsilon = 1.0e-6);
     /// ```
     #[inline]
-    pub fn from_euler_angles(roll: N, pitch: N, yaw: N) -> Self {
+    pub fn from_euler_angles(roll: T, pitch: T, yaw: T) -> Self {
         let (sr, cr) = (roll * crate::convert(0.5f64)).simd_sin_cos();
         let (sp, cp) = (pitch * crate::convert(0.5f64)).simd_sin_cos();
         let (sy, cy) = (yaw * crate::convert(0.5f64)).simd_sin_cos();
@@ -310,7 +311,7 @@ where
     /// orthonormal basis, i.e., all vectors are normalized, and the are
     /// all orthogonal to each other. These invariants are not checked
     /// by this method.
-    pub fn from_basis_unchecked(basis: &[Vector3<N>; 3]) -> Self {
+    pub fn from_basis_unchecked(basis: &[Vector3<T>; 3]) -> Self {
         let rot = Rotation3::from_basis_unchecked(basis);
         Self::from_rotation_matrix(&rot)
     }
@@ -330,15 +331,15 @@ where
     /// assert_relative_eq!(q.angle(), rot.angle(), epsilon = 1.0e-6);
     /// ```
     #[inline]
-    pub fn from_rotation_matrix(rotmat: &Rotation3<N>) -> Self {
+    pub fn from_rotation_matrix(rotmat: &Rotation3<T>) -> Self {
         // Robust matrix to quaternion transformation.
         // See https://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToQuaternion
         let tr = rotmat[(0, 0)] + rotmat[(1, 1)] + rotmat[(2, 2)];
-        let quarter: N = crate::convert(0.25);
+        let quarter: T = crate::convert(0.25);
 
-        let res = tr.simd_gt(N::zero()).if_else3(
+        let res = tr.simd_gt(T::zero()).if_else3(
             || {
-                let denom = (tr + N::one()).simd_sqrt() * crate::convert(2.0);
+                let denom = (tr + T::one()).simd_sqrt() * crate::convert(2.0);
                 Quaternion::new(
                     quarter * denom,
                     (rotmat[(2, 1)] - rotmat[(1, 2)]) / denom,
@@ -349,7 +350,7 @@ where
             (
                 || rotmat[(0, 0)].simd_gt(rotmat[(1, 1)]) & rotmat[(0, 0)].simd_gt(rotmat[(2, 2)]),
                 || {
-                    let denom = (N::one() + rotmat[(0, 0)] - rotmat[(1, 1)] - rotmat[(2, 2)])
+                    let denom = (T::one() + rotmat[(0, 0)] - rotmat[(1, 1)] - rotmat[(2, 2)])
                         .simd_sqrt()
                         * crate::convert(2.0);
                     Quaternion::new(
@@ -363,7 +364,7 @@ where
             (
                 || rotmat[(1, 1)].simd_gt(rotmat[(2, 2)]),
                 || {
-                    let denom = (N::one() + rotmat[(1, 1)] - rotmat[(0, 0)] - rotmat[(2, 2)])
+                    let denom = (T::one() + rotmat[(1, 1)] - rotmat[(0, 0)] - rotmat[(2, 2)])
                         .simd_sqrt()
                         * crate::convert(2.0);
                     Quaternion::new(
@@ -375,7 +376,7 @@ where
                 },
             ),
             || {
-                let denom = (N::one() + rotmat[(2, 2)] - rotmat[(0, 0)] - rotmat[(1, 1)])
+                let denom = (T::one() + rotmat[(2, 2)] - rotmat[(0, 0)] - rotmat[(1, 1)])
                     .simd_sqrt()
                     * crate::convert(2.0);
                 Quaternion::new(
@@ -395,9 +396,9 @@ where
     /// This is an iterative method. See `.from_matrix_eps` to provide mover
     /// convergence parameters and starting solution.
     /// This implements "A Robust Method to Extract the Rotational Part of Deformations" by Müller et al.
-    pub fn from_matrix(m: &Matrix3<N>) -> Self
+    pub fn from_matrix(m: &Matrix3<T>) -> Self
     where
-        N: RealField,
+        T: RealField,
     {
         Rotation3::from_matrix(m).into()
     }
@@ -414,9 +415,9 @@ where
     /// * `guess`: an estimate of the solution. Convergence will be significantly faster if an initial solution close
     ///           to the actual solution is provided. Can be set to `UnitQuaternion::identity()` if no other
     ///           guesses come to mind.
-    pub fn from_matrix_eps(m: &Matrix3<N>, eps: N, max_iter: usize, guess: Self) -> Self
+    pub fn from_matrix_eps(m: &Matrix3<T>, eps: T, max_iter: usize, guess: Self) -> Self
     where
-        N: RealField,
+        T: RealField,
     {
         let guess = Rotation3::from(guess);
         Rotation3::from_matrix_eps(m, eps, max_iter, guess).into()
@@ -437,13 +438,13 @@ where
     /// assert_relative_eq!(q.inverse() * b, a);
     /// ```
     #[inline]
-    pub fn rotation_between<SB, SC>(a: &Vector<N, U3, SB>, b: &Vector<N, U3, SC>) -> Option<Self>
+    pub fn rotation_between<SB, SC>(a: &Vector<T, U3, SB>, b: &Vector<T, U3, SC>) -> Option<Self>
     where
-        N: RealField,
-        SB: Storage<N, U3>,
-        SC: Storage<N, U3>,
+        T: RealField,
+        SB: Storage<T, U3>,
+        SC: Storage<T, U3>,
     {
-        Self::scaled_rotation_between(a, b, N::one())
+        Self::scaled_rotation_between(a, b, T::one())
     }
 
     /// The smallest rotation needed to make `a` and `b` collinear and point toward the same
@@ -462,19 +463,19 @@ where
     /// ```
     #[inline]
     pub fn scaled_rotation_between<SB, SC>(
-        a: &Vector<N, U3, SB>,
-        b: &Vector<N, U3, SC>,
-        s: N,
+        a: &Vector<T, U3, SB>,
+        b: &Vector<T, U3, SC>,
+        s: T,
     ) -> Option<Self>
     where
-        N: RealField,
-        SB: Storage<N, U3>,
-        SC: Storage<N, U3>,
+        T: RealField,
+        SB: Storage<T, U3>,
+        SC: Storage<T, U3>,
     {
         // TODO: code duplication with Rotation.
         if let (Some(na), Some(nb)) = (
-            Unit::try_new(a.clone_owned(), N::zero()),
-            Unit::try_new(b.clone_owned(), N::zero()),
+            Unit::try_new(a.clone_owned(), T::zero()),
+            Unit::try_new(b.clone_owned(), T::zero()),
         ) {
             Self::scaled_rotation_between_axis(&na, &nb, s)
         } else {
@@ -497,15 +498,15 @@ where
     /// ```
     #[inline]
     pub fn rotation_between_axis<SB, SC>(
-        a: &Unit<Vector<N, U3, SB>>,
-        b: &Unit<Vector<N, U3, SC>>,
+        a: &Unit<Vector<T, U3, SB>>,
+        b: &Unit<Vector<T, U3, SC>>,
     ) -> Option<Self>
     where
-        N: RealField,
-        SB: Storage<N, U3>,
-        SC: Storage<N, U3>,
+        T: RealField,
+        SB: Storage<T, U3>,
+        SC: Storage<T, U3>,
     {
-        Self::scaled_rotation_between_axis(a, b, N::one())
+        Self::scaled_rotation_between_axis(a, b, T::one())
     }
 
     /// The smallest rotation needed to make `a` and `b` collinear and point toward the same
@@ -524,30 +525,30 @@ where
     /// ```
     #[inline]
     pub fn scaled_rotation_between_axis<SB, SC>(
-        na: &Unit<Vector<N, U3, SB>>,
-        nb: &Unit<Vector<N, U3, SC>>,
-        s: N,
+        na: &Unit<Vector<T, U3, SB>>,
+        nb: &Unit<Vector<T, U3, SC>>,
+        s: T,
     ) -> Option<Self>
     where
-        N: RealField,
-        SB: Storage<N, U3>,
-        SC: Storage<N, U3>,
+        T: RealField,
+        SB: Storage<T, U3>,
+        SC: Storage<T, U3>,
     {
         // TODO: code duplication with Rotation.
         let c = na.cross(&nb);
 
-        if let Some(axis) = Unit::try_new(c, N::default_epsilon()) {
+        if let Some(axis) = Unit::try_new(c, T::default_epsilon()) {
             let cos = na.dot(&nb);
 
             // The cosinus may be out of [-1, 1] because of inaccuracies.
-            if cos <= -N::one() {
+            if cos <= -T::one() {
                 None
-            } else if cos >= N::one() {
+            } else if cos >= T::one() {
                 Some(Self::identity())
             } else {
                 Some(Self::from_axis_angle(&axis, cos.acos() * s))
             }
-        } else if na.dot(&nb) < N::zero() {
+        } else if na.dot(&nb) < T::zero() {
             // PI
             //
             // The rotation axis is undefined but the angle not zero. This is not a
@@ -582,20 +583,20 @@ where
     /// assert_relative_eq!(q * Vector3::z(), dir.normalize());
     /// ```
     #[inline]
-    pub fn face_towards<SB, SC>(dir: &Vector<N, U3, SB>, up: &Vector<N, U3, SC>) -> Self
+    pub fn face_towards<SB, SC>(dir: &Vector<T, U3, SB>, up: &Vector<T, U3, SC>) -> Self
     where
-        SB: Storage<N, U3>,
-        SC: Storage<N, U3>,
+        SB: Storage<T, U3>,
+        SC: Storage<T, U3>,
     {
         Self::from_rotation_matrix(&Rotation3::face_towards(dir, up))
     }
 
     /// Deprecated: Use [UnitQuaternion::face_towards] instead.
     #[deprecated(note = "renamed to `face_towards`")]
-    pub fn new_observer_frames<SB, SC>(dir: &Vector<N, U3, SB>, up: &Vector<N, U3, SC>) -> Self
+    pub fn new_observer_frames<SB, SC>(dir: &Vector<T, U3, SB>, up: &Vector<T, U3, SC>) -> Self
     where
-        SB: Storage<N, U3>,
-        SC: Storage<N, U3>,
+        SB: Storage<T, U3>,
+        SC: Storage<T, U3>,
     {
         Self::face_towards(dir, up)
     }
@@ -623,10 +624,10 @@ where
     /// assert_relative_eq!(q * dir.normalize(), -Vector3::z());
     /// ```
     #[inline]
-    pub fn look_at_rh<SB, SC>(dir: &Vector<N, U3, SB>, up: &Vector<N, U3, SC>) -> Self
+    pub fn look_at_rh<SB, SC>(dir: &Vector<T, U3, SB>, up: &Vector<T, U3, SC>) -> Self
     where
-        SB: Storage<N, U3>,
-        SC: Storage<N, U3>,
+        SB: Storage<T, U3>,
+        SC: Storage<T, U3>,
     {
         Self::face_towards(&-dir, up).inverse()
     }
@@ -654,17 +655,17 @@ where
     /// assert_relative_eq!(q * dir.normalize(), Vector3::z());
     /// ```
     #[inline]
-    pub fn look_at_lh<SB, SC>(dir: &Vector<N, U3, SB>, up: &Vector<N, U3, SC>) -> Self
+    pub fn look_at_lh<SB, SC>(dir: &Vector<T, U3, SB>, up: &Vector<T, U3, SC>) -> Self
     where
-        SB: Storage<N, U3>,
-        SC: Storage<N, U3>,
+        SB: Storage<T, U3>,
+        SC: Storage<T, U3>,
     {
         Self::face_towards(dir, up).inverse()
     }
 
     /// Creates a new unit quaternion rotation from a rotation axis scaled by the rotation angle.
     ///
-    /// If `axisangle` has a magnitude smaller than `N::default_epsilon()`, this returns the identity rotation.
+    /// If `axisangle` has a magnitude smaller than `T::default_epsilon()`, this returns the identity rotation.
     ///
     /// # Example
     /// ```
@@ -684,12 +685,12 @@ where
     /// assert_eq!(UnitQuaternion::new(Vector3::<f32>::zeros()), UnitQuaternion::identity());
     /// ```
     #[inline]
-    pub fn new<SB>(axisangle: Vector<N, U3, SB>) -> Self
+    pub fn new<SB>(axisangle: Vector<T, U3, SB>) -> Self
     where
-        SB: Storage<N, U3>,
+        SB: Storage<T, U3>,
     {
-        let two: N = crate::convert(2.0f64);
-        let q = Quaternion::<N>::from_imag(axisangle / two).exp();
+        let two: T = crate::convert(2.0f64);
+        let q = Quaternion::<T>::from_imag(axisangle / two).exp();
         Self::new_unchecked(q)
     }
 
@@ -715,18 +716,18 @@ where
     /// assert_eq!(UnitQuaternion::new_eps(Vector3::new(1.0e-8, 1.0e-9, 1.0e-7), 1.0e-6), UnitQuaternion::identity());
     /// ```
     #[inline]
-    pub fn new_eps<SB>(axisangle: Vector<N, U3, SB>, eps: N) -> Self
+    pub fn new_eps<SB>(axisangle: Vector<T, U3, SB>, eps: T) -> Self
     where
-        SB: Storage<N, U3>,
+        SB: Storage<T, U3>,
     {
-        let two: N = crate::convert(2.0f64);
-        let q = Quaternion::<N>::from_imag(axisangle / two).exp_eps(eps);
+        let two: T = crate::convert(2.0f64);
+        let q = Quaternion::<T>::from_imag(axisangle / two).exp_eps(eps);
         Self::new_unchecked(q)
     }
 
     /// Creates a new unit quaternion rotation from a rotation axis scaled by the rotation angle.
     ///
-    /// If `axisangle` has a magnitude smaller than `N::default_epsilon()`, this returns the identity rotation.
+    /// If `axisangle` has a magnitude smaller than `T::default_epsilon()`, this returns the identity rotation.
     /// Same as `Self::new(axisangle)`.
     ///
     /// # Example
@@ -747,9 +748,9 @@ where
     /// assert_eq!(UnitQuaternion::from_scaled_axis(Vector3::<f32>::zeros()), UnitQuaternion::identity());
     /// ```
     #[inline]
-    pub fn from_scaled_axis<SB>(axisangle: Vector<N, U3, SB>) -> Self
+    pub fn from_scaled_axis<SB>(axisangle: Vector<T, U3, SB>) -> Self
     where
-        SB: Storage<N, U3>,
+        SB: Storage<T, U3>,
     {
         Self::new(axisangle)
     }
@@ -777,9 +778,9 @@ where
     /// assert_eq!(UnitQuaternion::from_scaled_axis_eps(Vector3::new(1.0e-8, 1.0e-9, 1.0e-7), 1.0e-6), UnitQuaternion::identity());
     /// ```
     #[inline]
-    pub fn from_scaled_axis_eps<SB>(axisangle: Vector<N, U3, SB>, eps: N) -> Self
+    pub fn from_scaled_axis_eps<SB>(axisangle: Vector<T, U3, SB>, eps: T) -> Self
     where
-        SB: Storage<N, U3>,
+        SB: Storage<T, U3>,
     {
         Self::new_eps(axisangle, eps)
     }
@@ -811,9 +812,9 @@ where
     #[inline]
     pub fn mean_of(unit_quaternions: impl IntoIterator<Item = Self>) -> Self
     where
-        N: RealField,
+        T: RealField,
     {
-        let quaternions_matrix: Matrix4<N> = unit_quaternions
+        let quaternions_matrix: Matrix4<T> = unit_quaternions
             .into_iter()
             .map(|q| q.as_vector() * q.as_vector().transpose())
             .sum();
@@ -821,7 +822,7 @@ where
         assert!(!quaternions_matrix.is_zero());
 
         let eigen_matrix = quaternions_matrix
-            .try_symmetric_eigen(N::RealField::default_epsilon(), 10)
+            .try_symmetric_eigen(T::RealField::default_epsilon(), 10)
             .expect("Quaternions matrix could not be diagonalized. This behavior should not be possible.");
 
         let max_eigenvalue_index = eigen_matrix
@@ -840,9 +841,9 @@ where
     }
 }
 
-impl<N: SimdRealField> One for UnitQuaternion<N>
+impl<T: SimdRealField> One for UnitQuaternion<T>
 where
-    N::Element: SimdRealField,
+    T::Element: SimdRealField,
 {
     #[inline]
     fn one() -> Self {
@@ -851,37 +852,37 @@ where
 }
 
 #[cfg(feature = "rand-no-std")]
-impl<N: SimdRealField> Distribution<UnitQuaternion<N>> for Standard
+impl<T: SimdRealField> Distribution<UnitQuaternion<T>> for Standard
 where
-    N::Element: SimdRealField,
-    OpenClosed01: Distribution<N>,
-    N: SampleUniform,
+    T::Element: SimdRealField,
+    OpenClosed01: Distribution<T>,
+    T: SampleUniform,
 {
     /// Generate a uniformly distributed random rotation quaternion.
     #[inline]
-    fn sample<'a, R: Rng + ?Sized>(&self, rng: &'a mut R) -> UnitQuaternion<N> {
+    fn sample<'a, R: Rng + ?Sized>(&self, rng: &'a mut R) -> UnitQuaternion<T> {
         // Ken Shoemake's Subgroup Algorithm
         // Uniform random rotations.
         // In D. Kirk, editor, Graphics Gems III, pages 124-132. Academic, New York, 1992.
         let x0 = rng.sample(OpenClosed01);
-        let twopi = Uniform::new(N::zero(), N::simd_two_pi());
+        let twopi = Uniform::new(T::zero(), T::simd_two_pi());
         let theta1 = rng.sample(&twopi);
         let theta2 = rng.sample(&twopi);
         let s1 = theta1.simd_sin();
         let c1 = theta1.simd_cos();
         let s2 = theta2.simd_sin();
         let c2 = theta2.simd_cos();
-        let r1 = (N::one() - x0).simd_sqrt();
+        let r1 = (T::one() - x0).simd_sqrt();
         let r2 = x0.simd_sqrt();
         Unit::new_unchecked(Quaternion::new(s1 * r1, c1 * r1, s2 * r2, c2 * r2))
     }
 }
 
 #[cfg(feature = "arbitrary")]
-impl<N: RealField + Arbitrary> Arbitrary for UnitQuaternion<N>
+impl<T: RealField + Arbitrary> Arbitrary for UnitQuaternion<T>
 where
-    Owned<N, U4>: Send,
-    Owned<N, U3>: Send,
+    Owned<T, U4>: Send,
+    Owned<T, U3>: Send,
 {
     #[inline]
     fn arbitrary(g: &mut Gen) -> Self {
diff --git a/src/geometry/quaternion_conversion.rs b/src/geometry/quaternion_conversion.rs
index c8b5c6ed..6dfbfbc6 100644
--- a/src/geometry/quaternion_conversion.rs
+++ b/src/geometry/quaternion_conversion.rs
@@ -3,7 +3,6 @@ use num::Zero;
 use simba::scalar::{RealField, SubsetOf, SupersetOf};
 use simba::simd::{PrimitiveSimdValue, SimdRealField, SimdValue};
 
-use crate::base::dimension::U3;
 use crate::base::{Matrix3, Matrix4, Scalar, Vector4};
 use crate::geometry::{
     AbstractRotation, Isometry, Quaternion, Rotation, Rotation3, Similarity, SuperTCategoryOf,
@@ -16,264 +15,264 @@ use crate::geometry::{
  *
  * Quaternion     -> Quaternion
  * UnitQuaternion -> UnitQuaternion
- * UnitQuaternion -> Rotation<U3>
- * UnitQuaternion -> Isometry<U3>
+ * UnitQuaternion -> Rotation<3>
+ * UnitQuaternion -> Isometry<3>
  * UnitQuaternion -> UnitDualQuaternion
- * UnitQuaternion -> Similarity<U3>
- * UnitQuaternion -> Transform<U3>
+ * UnitQuaternion -> Similarity<3>
+ * UnitQuaternion -> Transform<3>
  * UnitQuaternion -> Matrix<U4> (homogeneous)
  *
  * NOTE:
  * UnitQuaternion -> Quaternion is already provided by: Unit<T> -> T
  */
 
-impl<N1, N2> SubsetOf<Quaternion<N2>> for Quaternion<N1>
+impl<T1, T2> SubsetOf<Quaternion<T2>> for Quaternion<T1>
 where
-    N1: Scalar,
-    N2: Scalar + SupersetOf<N1>,
+    T1: Scalar,
+    T2: Scalar + SupersetOf<T1>,
 {
     #[inline]
-    fn to_superset(&self) -> Quaternion<N2> {
+    fn to_superset(&self) -> Quaternion<T2> {
         Quaternion::from(self.coords.to_superset())
     }
 
     #[inline]
-    fn is_in_subset(q: &Quaternion<N2>) -> bool {
-        crate::is_convertible::<_, Vector4<N1>>(&q.coords)
+    fn is_in_subset(q: &Quaternion<T2>) -> bool {
+        crate::is_convertible::<_, Vector4<T1>>(&q.coords)
     }
 
     #[inline]
-    fn from_superset_unchecked(q: &Quaternion<N2>) -> Self {
+    fn from_superset_unchecked(q: &Quaternion<T2>) -> Self {
         Self {
             coords: q.coords.to_subset_unchecked(),
         }
     }
 }
 
-impl<N1, N2> SubsetOf<UnitQuaternion<N2>> for UnitQuaternion<N1>
+impl<T1, T2> SubsetOf<UnitQuaternion<T2>> for UnitQuaternion<T1>
 where
-    N1: Scalar,
-    N2: Scalar + SupersetOf<N1>,
+    T1: Scalar,
+    T2: Scalar + SupersetOf<T1>,
 {
     #[inline]
-    fn to_superset(&self) -> UnitQuaternion<N2> {
+    fn to_superset(&self) -> UnitQuaternion<T2> {
         UnitQuaternion::new_unchecked(self.as_ref().to_superset())
     }
 
     #[inline]
-    fn is_in_subset(uq: &UnitQuaternion<N2>) -> bool {
-        crate::is_convertible::<_, Quaternion<N1>>(uq.as_ref())
+    fn is_in_subset(uq: &UnitQuaternion<T2>) -> bool {
+        crate::is_convertible::<_, Quaternion<T1>>(uq.as_ref())
     }
 
     #[inline]
-    fn from_superset_unchecked(uq: &UnitQuaternion<N2>) -> Self {
+    fn from_superset_unchecked(uq: &UnitQuaternion<T2>) -> Self {
         Self::new_unchecked(crate::convert_ref_unchecked(uq.as_ref()))
     }
 }
 
-impl<N1, N2> SubsetOf<Rotation<N2, U3>> for UnitQuaternion<N1>
+impl<T1, T2> SubsetOf<Rotation<T2, 3>> for UnitQuaternion<T1>
 where
-    N1: RealField,
-    N2: RealField + SupersetOf<N1>,
+    T1: RealField,
+    T2: RealField + SupersetOf<T1>,
 {
     #[inline]
-    fn to_superset(&self) -> Rotation3<N2> {
-        let q: UnitQuaternion<N2> = self.to_superset();
+    fn to_superset(&self) -> Rotation3<T2> {
+        let q: UnitQuaternion<T2> = self.to_superset();
         q.to_rotation_matrix()
     }
 
     #[inline]
-    fn is_in_subset(rot: &Rotation3<N2>) -> bool {
-        crate::is_convertible::<_, Rotation3<N1>>(rot)
+    fn is_in_subset(rot: &Rotation3<T2>) -> bool {
+        crate::is_convertible::<_, Rotation3<T1>>(rot)
     }
 
     #[inline]
-    fn from_superset_unchecked(rot: &Rotation3<N2>) -> Self {
-        let q = UnitQuaternion::<N2>::from_rotation_matrix(rot);
+    fn from_superset_unchecked(rot: &Rotation3<T2>) -> Self {
+        let q = UnitQuaternion::<T2>::from_rotation_matrix(rot);
         crate::convert_unchecked(q)
     }
 }
 
-impl<N1, N2, R> SubsetOf<Isometry<N2, U3, R>> for UnitQuaternion<N1>
+impl<T1, T2, R> SubsetOf<Isometry<T2, R, 3>> for UnitQuaternion<T1>
 where
-    N1: RealField,
-    N2: RealField + SupersetOf<N1>,
-    R: AbstractRotation<N2, U3> + SupersetOf<Self>,
+    T1: RealField,
+    T2: RealField + SupersetOf<T1>,
+    R: AbstractRotation<T2, 3> + SupersetOf<Self>,
 {
     #[inline]
-    fn to_superset(&self) -> Isometry<N2, U3, R> {
+    fn to_superset(&self) -> Isometry<T2, R, 3> {
         Isometry::from_parts(Translation::identity(), crate::convert_ref(self))
     }
 
     #[inline]
-    fn is_in_subset(iso: &Isometry<N2, U3, R>) -> bool {
+    fn is_in_subset(iso: &Isometry<T2, R, 3>) -> bool {
         iso.translation.vector.is_zero()
     }
 
     #[inline]
-    fn from_superset_unchecked(iso: &Isometry<N2, U3, R>) -> Self {
+    fn from_superset_unchecked(iso: &Isometry<T2, R, 3>) -> Self {
         crate::convert_ref_unchecked(&iso.rotation)
     }
 }
 
-impl<N1, N2> SubsetOf<UnitDualQuaternion<N2>> for UnitQuaternion<N1>
+impl<T1, T2> SubsetOf<UnitDualQuaternion<T2>> for UnitQuaternion<T1>
 where
-    N1: RealField,
-    N2: RealField + SupersetOf<N1>,
+    T1: RealField,
+    T2: RealField + SupersetOf<T1>,
 {
     #[inline]
-    fn to_superset(&self) -> UnitDualQuaternion<N2> {
-        let q: UnitQuaternion<N2> = crate::convert_ref(self);
+    fn to_superset(&self) -> UnitDualQuaternion<T2> {
+        let q: UnitQuaternion<T2> = crate::convert_ref(self);
         UnitDualQuaternion::from_rotation(q)
     }
 
     #[inline]
-    fn is_in_subset(dq: &UnitDualQuaternion<N2>) -> bool {
+    fn is_in_subset(dq: &UnitDualQuaternion<T2>) -> bool {
         dq.translation().vector.is_zero()
     }
 
     #[inline]
-    fn from_superset_unchecked(dq: &UnitDualQuaternion<N2>) -> Self {
+    fn from_superset_unchecked(dq: &UnitDualQuaternion<T2>) -> Self {
         crate::convert_unchecked(dq.rotation())
     }
 }
 
-impl<N1, N2, R> SubsetOf<Similarity<N2, U3, R>> for UnitQuaternion<N1>
+impl<T1, T2, R> SubsetOf<Similarity<T2, R, 3>> for UnitQuaternion<T1>
 where
-    N1: RealField,
-    N2: RealField + SupersetOf<N1>,
-    R: AbstractRotation<N2, U3> + SupersetOf<Self>,
+    T1: RealField,
+    T2: RealField + SupersetOf<T1>,
+    R: AbstractRotation<T2, 3> + SupersetOf<Self>,
 {
     #[inline]
-    fn to_superset(&self) -> Similarity<N2, U3, R> {
-        Similarity::from_isometry(crate::convert_ref(self), N2::one())
+    fn to_superset(&self) -> Similarity<T2, R, 3> {
+        Similarity::from_isometry(crate::convert_ref(self), T2::one())
     }
 
     #[inline]
-    fn is_in_subset(sim: &Similarity<N2, U3, R>) -> bool {
-        sim.isometry.translation.vector.is_zero() && sim.scaling() == N2::one()
+    fn is_in_subset(sim: &Similarity<T2, R, 3>) -> bool {
+        sim.isometry.translation.vector.is_zero() && sim.scaling() == T2::one()
     }
 
     #[inline]
-    fn from_superset_unchecked(sim: &Similarity<N2, U3, R>) -> Self {
+    fn from_superset_unchecked(sim: &Similarity<T2, R, 3>) -> Self {
         crate::convert_ref_unchecked(&sim.isometry)
     }
 }
 
-impl<N1, N2, C> SubsetOf<Transform<N2, U3, C>> for UnitQuaternion<N1>
+impl<T1, T2, C> SubsetOf<Transform<T2, C, 3>> for UnitQuaternion<T1>
 where
-    N1: RealField,
-    N2: RealField + SupersetOf<N1>,
+    T1: RealField,
+    T2: RealField + SupersetOf<T1>,
     C: SuperTCategoryOf<TAffine>,
 {
     #[inline]
-    fn to_superset(&self) -> Transform<N2, U3, C> {
+    fn to_superset(&self) -> Transform<T2, C, 3> {
         Transform::from_matrix_unchecked(self.to_homogeneous().to_superset())
     }
 
     #[inline]
-    fn is_in_subset(t: &Transform<N2, U3, C>) -> bool {
+    fn is_in_subset(t: &Transform<T2, C, 3>) -> bool {
         <Self as SubsetOf<_>>::is_in_subset(t.matrix())
     }
 
     #[inline]
-    fn from_superset_unchecked(t: &Transform<N2, U3, C>) -> Self {
+    fn from_superset_unchecked(t: &Transform<T2, C, 3>) -> Self {
         Self::from_superset_unchecked(t.matrix())
     }
 }
 
-impl<N1: RealField, N2: RealField + SupersetOf<N1>> SubsetOf<Matrix4<N2>> for UnitQuaternion<N1> {
+impl<T1: RealField, T2: RealField + SupersetOf<T1>> SubsetOf<Matrix4<T2>> for UnitQuaternion<T1> {
     #[inline]
-    fn to_superset(&self) -> Matrix4<N2> {
+    fn to_superset(&self) -> Matrix4<T2> {
         self.to_homogeneous().to_superset()
     }
 
     #[inline]
-    fn is_in_subset(m: &Matrix4<N2>) -> bool {
-        crate::is_convertible::<_, Rotation3<N1>>(m)
+    fn is_in_subset(m: &Matrix4<T2>) -> bool {
+        crate::is_convertible::<_, Rotation3<T1>>(m)
     }
 
     #[inline]
-    fn from_superset_unchecked(m: &Matrix4<N2>) -> Self {
-        let rot: Rotation3<N1> = crate::convert_ref_unchecked(m);
+    fn from_superset_unchecked(m: &Matrix4<T2>) -> Self {
+        let rot: Rotation3<T1> = crate::convert_ref_unchecked(m);
         Self::from_rotation_matrix(&rot)
     }
 }
 
-impl<N: SimdRealField> From<UnitQuaternion<N>> for Matrix4<N>
+impl<T: SimdRealField> From<UnitQuaternion<T>> for Matrix4<T>
 where
-    N::Element: SimdRealField,
+    T::Element: SimdRealField,
 {
     #[inline]
-    fn from(q: UnitQuaternion<N>) -> Self {
+    fn from(q: UnitQuaternion<T>) -> Self {
         q.to_homogeneous()
     }
 }
 
-impl<N: SimdRealField> From<UnitQuaternion<N>> for Rotation3<N>
+impl<T: SimdRealField> From<UnitQuaternion<T>> for Rotation3<T>
 where
-    N::Element: SimdRealField,
+    T::Element: SimdRealField,
 {
     #[inline]
-    fn from(q: UnitQuaternion<N>) -> Self {
+    fn from(q: UnitQuaternion<T>) -> Self {
         q.to_rotation_matrix()
     }
 }
 
-impl<N: SimdRealField> From<Rotation3<N>> for UnitQuaternion<N>
+impl<T: SimdRealField> From<Rotation3<T>> for UnitQuaternion<T>
 where
-    N::Element: SimdRealField,
+    T::Element: SimdRealField,
 {
     #[inline]
-    fn from(q: Rotation3<N>) -> Self {
+    fn from(q: Rotation3<T>) -> Self {
         Self::from_rotation_matrix(&q)
     }
 }
 
-impl<N: SimdRealField> From<UnitQuaternion<N>> for Matrix3<N>
+impl<T: SimdRealField> From<UnitQuaternion<T>> for Matrix3<T>
 where
-    N::Element: SimdRealField,
+    T::Element: SimdRealField,
 {
     #[inline]
-    fn from(q: UnitQuaternion<N>) -> Self {
+    fn from(q: UnitQuaternion<T>) -> Self {
         q.to_rotation_matrix().into_inner()
     }
 }
 
-impl<N: Scalar> From<Vector4<N>> for Quaternion<N> {
+impl<T: Scalar> From<Vector4<T>> for Quaternion<T> {
     #[inline]
-    fn from(coords: Vector4<N>) -> Self {
+    fn from(coords: Vector4<T>) -> Self {
         Self { coords }
     }
 }
 
-impl<N: Scalar> From<[N; 4]> for Quaternion<N> {
+impl<T: Scalar> From<[T; 4]> for Quaternion<T> {
     #[inline]
-    fn from(coords: [N; 4]) -> Self {
+    fn from(coords: [T; 4]) -> Self {
         Self {
             coords: coords.into(),
         }
     }
 }
 
-impl<N: Scalar + PrimitiveSimdValue> From<[Quaternion<N::Element>; 2]> for Quaternion<N>
+impl<T: Scalar + PrimitiveSimdValue> From<[Quaternion<T::Element>; 2]> for Quaternion<T>
 where
-    N: From<[<N as SimdValue>::Element; 2]>,
-    N::Element: Scalar + Copy,
+    T: From<[<T as SimdValue>::Element; 2]>,
+    T::Element: Scalar + Copy,
 {
     #[inline]
-    fn from(arr: [Quaternion<N::Element>; 2]) -> Self {
+    fn from(arr: [Quaternion<T::Element>; 2]) -> Self {
         Self::from(Vector4::from([arr[0].coords, arr[1].coords]))
     }
 }
 
-impl<N: Scalar + PrimitiveSimdValue> From<[Quaternion<N::Element>; 4]> for Quaternion<N>
+impl<T: Scalar + PrimitiveSimdValue> From<[Quaternion<T::Element>; 4]> for Quaternion<T>
 where
-    N: From<[<N as SimdValue>::Element; 4]>,
-    N::Element: Scalar + Copy,
+    T: From<[<T as SimdValue>::Element; 4]>,
+    T::Element: Scalar + Copy,
 {
     #[inline]
-    fn from(arr: [Quaternion<N::Element>; 4]) -> Self {
+    fn from(arr: [Quaternion<T::Element>; 4]) -> Self {
         Self::from(Vector4::from([
             arr[0].coords,
             arr[1].coords,
@@ -283,13 +282,13 @@ where
     }
 }
 
-impl<N: Scalar + PrimitiveSimdValue> From<[Quaternion<N::Element>; 8]> for Quaternion<N>
+impl<T: Scalar + PrimitiveSimdValue> From<[Quaternion<T::Element>; 8]> for Quaternion<T>
 where
-    N: From<[<N as SimdValue>::Element; 8]>,
-    N::Element: Scalar + Copy,
+    T: From<[<T as SimdValue>::Element; 8]>,
+    T::Element: Scalar + Copy,
 {
     #[inline]
-    fn from(arr: [Quaternion<N::Element>; 8]) -> Self {
+    fn from(arr: [Quaternion<T::Element>; 8]) -> Self {
         Self::from(Vector4::from([
             arr[0].coords,
             arr[1].coords,
@@ -303,13 +302,13 @@ where
     }
 }
 
-impl<N: Scalar + PrimitiveSimdValue> From<[Quaternion<N::Element>; 16]> for Quaternion<N>
+impl<T: Scalar + PrimitiveSimdValue> From<[Quaternion<T::Element>; 16]> for Quaternion<T>
 where
-    N: From<[<N as SimdValue>::Element; 16]>,
-    N::Element: Scalar + Copy,
+    T: From<[<T as SimdValue>::Element; 16]>,
+    T::Element: Scalar + Copy,
 {
     #[inline]
-    fn from(arr: [Quaternion<N::Element>; 16]) -> Self {
+    fn from(arr: [Quaternion<T::Element>; 16]) -> Self {
         Self::from(Vector4::from([
             arr[0].coords,
             arr[1].coords,
@@ -331,26 +330,26 @@ where
     }
 }
 
-impl<N: Scalar + Copy + PrimitiveSimdValue> From<[UnitQuaternion<N::Element>; 2]>
-    for UnitQuaternion<N>
+impl<T: Scalar + Copy + PrimitiveSimdValue> From<[UnitQuaternion<T::Element>; 2]>
+    for UnitQuaternion<T>
 where
-    N: From<[<N as simba::simd::SimdValue>::Element; 2]>,
-    N::Element: Scalar + Copy,
+    T: From<[<T as simba::simd::SimdValue>::Element; 2]>,
+    T::Element: Scalar + Copy,
 {
     #[inline]
-    fn from(arr: [UnitQuaternion<N::Element>; 2]) -> Self {
+    fn from(arr: [UnitQuaternion<T::Element>; 2]) -> Self {
         Self::new_unchecked(Quaternion::from([arr[0].into_inner(), arr[1].into_inner()]))
     }
 }
 
-impl<N: Scalar + Copy + PrimitiveSimdValue> From<[UnitQuaternion<N::Element>; 4]>
-    for UnitQuaternion<N>
+impl<T: Scalar + Copy + PrimitiveSimdValue> From<[UnitQuaternion<T::Element>; 4]>
+    for UnitQuaternion<T>
 where
-    N: From<[<N as simba::simd::SimdValue>::Element; 4]>,
-    N::Element: Scalar + Copy,
+    T: From<[<T as simba::simd::SimdValue>::Element; 4]>,
+    T::Element: Scalar + Copy,
 {
     #[inline]
-    fn from(arr: [UnitQuaternion<N::Element>; 4]) -> Self {
+    fn from(arr: [UnitQuaternion<T::Element>; 4]) -> Self {
         Self::new_unchecked(Quaternion::from([
             arr[0].into_inner(),
             arr[1].into_inner(),
@@ -360,14 +359,14 @@ where
     }
 }
 
-impl<N: Scalar + Copy + PrimitiveSimdValue> From<[UnitQuaternion<N::Element>; 8]>
-    for UnitQuaternion<N>
+impl<T: Scalar + Copy + PrimitiveSimdValue> From<[UnitQuaternion<T::Element>; 8]>
+    for UnitQuaternion<T>
 where
-    N: From<[<N as simba::simd::SimdValue>::Element; 8]>,
-    N::Element: Scalar + Copy,
+    T: From<[<T as simba::simd::SimdValue>::Element; 8]>,
+    T::Element: Scalar + Copy,
 {
     #[inline]
-    fn from(arr: [UnitQuaternion<N::Element>; 8]) -> Self {
+    fn from(arr: [UnitQuaternion<T::Element>; 8]) -> Self {
         Self::new_unchecked(Quaternion::from([
             arr[0].into_inner(),
             arr[1].into_inner(),
@@ -381,14 +380,14 @@ where
     }
 }
 
-impl<N: Scalar + Copy + PrimitiveSimdValue> From<[UnitQuaternion<N::Element>; 16]>
-    for UnitQuaternion<N>
+impl<T: Scalar + Copy + PrimitiveSimdValue> From<[UnitQuaternion<T::Element>; 16]>
+    for UnitQuaternion<T>
 where
-    N: From<[<N as simba::simd::SimdValue>::Element; 16]>,
-    N::Element: Scalar + Copy,
+    T: From<[<T as simba::simd::SimdValue>::Element; 16]>,
+    T::Element: Scalar + Copy,
 {
     #[inline]
-    fn from(arr: [UnitQuaternion<N::Element>; 16]) -> Self {
+    fn from(arr: [UnitQuaternion<T::Element>; 16]) -> Self {
         Self::new_unchecked(Quaternion::from([
             arr[0].into_inner(),
             arr[1].into_inner(),
diff --git a/src/geometry/quaternion_coordinates.rs b/src/geometry/quaternion_coordinates.rs
index 0d318087..d9901888 100644
--- a/src/geometry/quaternion_coordinates.rs
+++ b/src/geometry/quaternion_coordinates.rs
@@ -8,8 +8,8 @@ use crate::Scalar;
 
 use crate::geometry::Quaternion;
 
-impl<N: Scalar + SimdValue> Deref for Quaternion<N> {
-    type Target = IJKW<N>;
+impl<T: Scalar + SimdValue> Deref for Quaternion<T> {
+    type Target = IJKW<T>;
 
     #[inline]
     fn deref(&self) -> &Self::Target {
@@ -17,7 +17,7 @@ impl<N: Scalar + SimdValue> Deref for Quaternion<N> {
     }
 }
 
-impl<N: Scalar + SimdValue> DerefMut for Quaternion<N> {
+impl<T: Scalar + SimdValue> DerefMut for Quaternion<T> {
     #[inline]
     fn deref_mut(&mut self) -> &mut Self::Target {
         unsafe { mem::transmute(self) }
diff --git a/src/geometry/quaternion_ops.rs b/src/geometry/quaternion_ops.rs
index f9205874..6a2c87a0 100644
--- a/src/geometry/quaternion_ops.rs
+++ b/src/geometry/quaternion_ops.rs
@@ -54,16 +54,15 @@ use std::ops::{
     Add, AddAssign, Div, DivAssign, Index, IndexMut, Mul, MulAssign, Neg, Sub, SubAssign,
 };
 
-use crate::base::allocator::Allocator;
-use crate::base::dimension::{U1, U3, U4};
+use crate::base::dimension::U3;
 use crate::base::storage::Storage;
-use crate::base::{DefaultAllocator, Scalar, Unit, Vector, Vector3};
+use crate::base::{Const, Scalar, Unit, Vector, Vector3};
 use crate::SimdRealField;
 
 use crate::geometry::{Point3, Quaternion, Rotation, UnitQuaternion};
 
-impl<N: Scalar> Index<usize> for Quaternion<N> {
-    type Output = N;
+impl<T: Scalar> Index<usize> for Quaternion<T> {
+    type Output = T;
 
     #[inline]
     fn index(&self, i: usize) -> &Self::Output {
@@ -71,23 +70,20 @@ impl<N: Scalar> Index<usize> for Quaternion<N> {
     }
 }
 
-impl<N: Scalar> IndexMut<usize> for Quaternion<N> {
+impl<T: Scalar> IndexMut<usize> for Quaternion<T> {
     #[inline]
-    fn index_mut(&mut self, i: usize) -> &mut N {
+    fn index_mut(&mut self, i: usize) -> &mut T {
         &mut self.coords[i]
     }
 }
 
 macro_rules! quaternion_op_impl(
     ($Op: ident, $op: ident;
-     ($LhsRDim: ident, $LhsCDim: ident), ($RhsRDim: ident, $RhsCDim: ident)
-     $(for $Storage: ident: $StoragesBound: ident $(<$($BoundParam: ty),*>)*),*;
-     $lhs: ident: $Lhs: ty, $rhs: ident: $Rhs: ty, Output = $Result: ty $(=> $VDimA: ty, $VDimB: ty)*;
+     $($Storage: ident: $StoragesBound: ident $(<$($BoundParam: ty),*>)*),*;
+     $lhs: ident: $Lhs: ty, $rhs: ident: $Rhs: ty, Output = $Result: ty;
      $action: expr; $($lives: tt),*) => {
-        impl<$($lives ,)* N: SimdRealField $(, $Storage: $StoragesBound $(<$($BoundParam),*>)*)*> $Op<$Rhs> for $Lhs
-            where N::Element: SimdRealField,
-                  DefaultAllocator: Allocator<N, $LhsRDim, $LhsCDim> +
-                                    Allocator<N, $RhsRDim, $RhsCDim> {
+        impl<$($lives ,)* T: SimdRealField $(, $Storage: $StoragesBound $(<$($BoundParam),*>)*)*> $Op<$Rhs> for $Lhs
+            where T::Element: SimdRealField {
             type Output = $Result;
 
             #[inline]
@@ -101,64 +97,64 @@ macro_rules! quaternion_op_impl(
 // Quaternion + Quaternion
 quaternion_op_impl!(
     Add, add;
-    (U4, U1), (U4, U1);
-    self: &'a Quaternion<N>, rhs: &'b Quaternion<N>, Output = Quaternion<N>;
+    ;
+    self: &'a Quaternion<T>, rhs: &'b Quaternion<T>, Output = Quaternion<T>;
     Quaternion::from(&self.coords + &rhs.coords);
     'a, 'b);
 
 quaternion_op_impl!(
     Add, add;
-    (U4, U1), (U4, U1);
-    self: &'a Quaternion<N>, rhs: Quaternion<N>, Output = Quaternion<N>;
+    ;
+    self: &'a Quaternion<T>, rhs: Quaternion<T>, Output = Quaternion<T>;
     Quaternion::from(&self.coords + rhs.coords);
     'a);
 
 quaternion_op_impl!(
     Add, add;
-    (U4, U1), (U4, U1);
-    self: Quaternion<N>, rhs: &'b Quaternion<N>, Output = Quaternion<N>;
+    ;
+    self: Quaternion<T>, rhs: &'b Quaternion<T>, Output = Quaternion<T>;
     Quaternion::from(self.coords + &rhs.coords);
     'b);
 
 quaternion_op_impl!(
     Add, add;
-    (U4, U1), (U4, U1);
-    self: Quaternion<N>, rhs: Quaternion<N>, Output = Quaternion<N>;
+    ;
+    self: Quaternion<T>, rhs: Quaternion<T>, Output = Quaternion<T>;
     Quaternion::from(self.coords + rhs.coords); );
 
 // Quaternion - Quaternion
 quaternion_op_impl!(
     Sub, sub;
-    (U4, U1), (U4, U1);
-    self: &'a Quaternion<N>, rhs: &'b Quaternion<N>, Output = Quaternion<N>;
+    ;
+    self: &'a Quaternion<T>, rhs: &'b Quaternion<T>, Output = Quaternion<T>;
     Quaternion::from(&self.coords - &rhs.coords);
     'a, 'b);
 
 quaternion_op_impl!(
     Sub, sub;
-    (U4, U1), (U4, U1);
-    self: &'a Quaternion<N>, rhs: Quaternion<N>, Output = Quaternion<N>;
+    ;
+    self: &'a Quaternion<T>, rhs: Quaternion<T>, Output = Quaternion<T>;
     Quaternion::from(&self.coords - rhs.coords);
     'a);
 
 quaternion_op_impl!(
     Sub, sub;
-    (U4, U1), (U4, U1);
-    self: Quaternion<N>, rhs: &'b Quaternion<N>, Output = Quaternion<N>;
+    ;
+    self: Quaternion<T>, rhs: &'b Quaternion<T>, Output = Quaternion<T>;
     Quaternion::from(self.coords - &rhs.coords);
     'b);
 
 quaternion_op_impl!(
     Sub, sub;
-    (U4, U1), (U4, U1);
-    self: Quaternion<N>, rhs: Quaternion<N>, Output = Quaternion<N>;
+    ;
+    self: Quaternion<T>, rhs: Quaternion<T>, Output = Quaternion<T>;
     Quaternion::from(self.coords - rhs.coords); );
 
 // Quaternion × Quaternion
 quaternion_op_impl!(
     Mul, mul;
-    (U4, U1), (U4, U1);
-    self: &'a Quaternion<N>, rhs: &'b Quaternion<N>, Output = Quaternion<N>;
+    ;
+    self: &'a Quaternion<T>, rhs: &'b Quaternion<T>, Output = Quaternion<T>;
     Quaternion::new(
         self[3] * rhs[3] - self[0] * rhs[0] - self[1] * rhs[1] - self[2] * rhs[2],
         self[3] * rhs[0] + self[0] * rhs[3] + self[1] * rhs[2] - self[2] * rhs[1],
@@ -168,220 +164,220 @@ quaternion_op_impl!(
 
 quaternion_op_impl!(
     Mul, mul;
-    (U4, U1), (U4, U1);
-    self: &'a Quaternion<N>, rhs: Quaternion<N>, Output = Quaternion<N>;
+    ;
+    self: &'a Quaternion<T>, rhs: Quaternion<T>, Output = Quaternion<T>;
     self * &rhs;
     'a);
 
 quaternion_op_impl!(
     Mul, mul;
-    (U4, U1), (U4, U1);
-    self: Quaternion<N>, rhs: &'b Quaternion<N>, Output = Quaternion<N>;
+    ;
+    self: Quaternion<T>, rhs: &'b Quaternion<T>, Output = Quaternion<T>;
     &self * rhs;
     'b);
 
 quaternion_op_impl!(
     Mul, mul;
-    (U4, U1), (U4, U1);
-    self: Quaternion<N>, rhs: Quaternion<N>, Output = Quaternion<N>;
+    ;
+    self: Quaternion<T>, rhs: Quaternion<T>, Output = Quaternion<T>;
     &self * &rhs; );
 
 // UnitQuaternion × UnitQuaternion
 quaternion_op_impl!(
     Mul, mul;
-    (U4, U1), (U4, U1);
-    self: &'a UnitQuaternion<N>, rhs: &'b UnitQuaternion<N>, Output = UnitQuaternion<N>;
+    ;
+    self: &'a UnitQuaternion<T>, rhs: &'b UnitQuaternion<T>, Output = UnitQuaternion<T>;
     UnitQuaternion::new_unchecked(self.quaternion() * rhs.quaternion());
     'a, 'b);
 
 quaternion_op_impl!(
     Mul, mul;
-    (U4, U1), (U4, U1);
-    self: &'a UnitQuaternion<N>, rhs: UnitQuaternion<N>, Output = UnitQuaternion<N>;
+    ;
+    self: &'a UnitQuaternion<T>, rhs: UnitQuaternion<T>, Output = UnitQuaternion<T>;
     self * &rhs;
     'a);
 
 quaternion_op_impl!(
     Mul, mul;
-    (U4, U1), (U4, U1);
-    self: UnitQuaternion<N>, rhs: &'b UnitQuaternion<N>, Output = UnitQuaternion<N>;
+    ;
+    self: UnitQuaternion<T>, rhs: &'b UnitQuaternion<T>, Output = UnitQuaternion<T>;
     &self * rhs;
     'b);
 
 quaternion_op_impl!(
     Mul, mul;
-    (U4, U1), (U4, U1);
-    self: UnitQuaternion<N>, rhs: UnitQuaternion<N>, Output = UnitQuaternion<N>;
+    ;
+    self: UnitQuaternion<T>, rhs: UnitQuaternion<T>, Output = UnitQuaternion<T>;
     &self * &rhs; );
 
 // UnitQuaternion ÷ UnitQuaternion
 quaternion_op_impl!(
     Div, div;
-    (U4, U1), (U4, U1);
-    self: &'a UnitQuaternion<N>, rhs: &'b UnitQuaternion<N>, Output = UnitQuaternion<N>;
+    ;
+    self: &'a UnitQuaternion<T>, rhs: &'b UnitQuaternion<T>, Output = UnitQuaternion<T>;
     #[allow(clippy::suspicious_arithmetic_impl)] { self * rhs.inverse() };
     'a, 'b);
 
 quaternion_op_impl!(
     Div, div;
-    (U4, U1), (U4, U1);
-    self: &'a UnitQuaternion<N>, rhs: UnitQuaternion<N>, Output = UnitQuaternion<N>;
+    ;
+    self: &'a UnitQuaternion<T>, rhs: UnitQuaternion<T>, Output = UnitQuaternion<T>;
     self / &rhs;
     'a);
 
 quaternion_op_impl!(
     Div, div;
-    (U4, U1), (U4, U1);
-    self: UnitQuaternion<N>, rhs: &'b UnitQuaternion<N>, Output = UnitQuaternion<N>;
+    ;
+    self: UnitQuaternion<T>, rhs: &'b UnitQuaternion<T>, Output = UnitQuaternion<T>;
     &self / rhs;
     'b);
 
 quaternion_op_impl!(
     Div, div;
-    (U4, U1), (U4, U1);
-    self: UnitQuaternion<N>, rhs: UnitQuaternion<N>, Output = UnitQuaternion<N>;
+    ;
+    self: UnitQuaternion<T>, rhs: UnitQuaternion<T>, Output = UnitQuaternion<T>;
     &self / &rhs; );
 
 // UnitQuaternion × Rotation
 quaternion_op_impl!(
     Mul, mul;
-    (U4, U1), (U3, U3);
-    self: &'a UnitQuaternion<N>, rhs: &'b Rotation<N, U3>,
-    Output = UnitQuaternion<N> => U3, U3;
-    // TODO: can we avoid the conversion from a rotation matrix?
-    self * UnitQuaternion::<N>::from_rotation_matrix(rhs);
+    ;
+    self: &'a UnitQuaternion<T>, rhs: &'b Rotation<T, 3>,
+    Output = UnitQuaternion<T>;
+    // TODO: can we avoid the conversion from a rotation matrix?
+    self * UnitQuaternion::<T>::from_rotation_matrix(rhs);
     'a, 'b);
 
 quaternion_op_impl!(
     Mul, mul;
-    (U4, U1), (U3, U3);
-    self: &'a UnitQuaternion<N>, rhs: Rotation<N, U3>,
-    Output = UnitQuaternion<N> => U3, U3;
-    self * UnitQuaternion::<N>::from_rotation_matrix(&rhs);
+    ;
+    self: &'a UnitQuaternion<T>, rhs: Rotation<T, 3>,
+    Output = UnitQuaternion<T>;
+    self * UnitQuaternion::<T>::from_rotation_matrix(&rhs);
     'a);
 
 quaternion_op_impl!(
     Mul, mul;
-    (U4, U1), (U3, U3);
-    self: UnitQuaternion<N>, rhs: &'b Rotation<N, U3>,
-    Output = UnitQuaternion<N> => U3, U3;
-    self * UnitQuaternion::<N>::from_rotation_matrix(rhs);
+    ;
+    self: UnitQuaternion<T>, rhs: &'b Rotation<T, 3>,
+    Output = UnitQuaternion<T>;
+    self * UnitQuaternion::<T>::from_rotation_matrix(rhs);
     'b);
 
 quaternion_op_impl!(
     Mul, mul;
-    (U4, U1), (U3, U3);
-    self: UnitQuaternion<N>, rhs: Rotation<N, U3>,
-    Output = UnitQuaternion<N> => U3, U3;
-    self * UnitQuaternion::<N>::from_rotation_matrix(&rhs); );
+    ;
+    self: UnitQuaternion<T>, rhs: Rotation<T, 3>,
+    Output = UnitQuaternion<T>;
+    self * UnitQuaternion::<T>::from_rotation_matrix(&rhs); );
 
 // UnitQuaternion ÷ Rotation
 quaternion_op_impl!(
     Div, div;
-    (U4, U1), (U3, U3);
-    self: &'a UnitQuaternion<N>, rhs: &'b Rotation<N, U3>,
-    Output = UnitQuaternion<N> => U3, U3;
+    ;
+    self: &'a UnitQuaternion<T>, rhs: &'b Rotation<T, 3>,
+    Output = UnitQuaternion<T>;
     // TODO: can we avoid the conversion to a rotation matrix?
-    self / UnitQuaternion::<N>::from_rotation_matrix(rhs);
+    self / UnitQuaternion::<T>::from_rotation_matrix(rhs);
     'a, 'b);
 
 quaternion_op_impl!(
     Div, div;
-    (U4, U1), (U3, U3);
-    self: &'a UnitQuaternion<N>, rhs: Rotation<N, U3>,
-    Output = UnitQuaternion<N> => U3, U3;
-    self / UnitQuaternion::<N>::from_rotation_matrix(&rhs);
+    ;
+    self: &'a UnitQuaternion<T>, rhs: Rotation<T, 3>,
+    Output = UnitQuaternion<T>;
+    self / UnitQuaternion::<T>::from_rotation_matrix(&rhs);
     'a);
 
 quaternion_op_impl!(
     Div, div;
-    (U4, U1), (U3, U3);
-    self: UnitQuaternion<N>, rhs: &'b Rotation<N, U3>,
-    Output = UnitQuaternion<N> => U3, U3;
-    self / UnitQuaternion::<N>::from_rotation_matrix(rhs);
+    ;
+    self: UnitQuaternion<T>, rhs: &'b Rotation<T, 3>,
+    Output = UnitQuaternion<T>;
+    self / UnitQuaternion::<T>::from_rotation_matrix(rhs);
     'b);
 
 quaternion_op_impl!(
     Div, div;
-    (U4, U1), (U3, U3);
-    self: UnitQuaternion<N>, rhs: Rotation<N, U3>,
-    Output = UnitQuaternion<N> => U3, U3;
-    self / UnitQuaternion::<N>::from_rotation_matrix(&rhs); );
+    ;
+    self: UnitQuaternion<T>, rhs: Rotation<T, 3>,
+    Output = UnitQuaternion<T>;
+    self / UnitQuaternion::<T>::from_rotation_matrix(&rhs); );
 
 // Rotation × UnitQuaternion
 quaternion_op_impl!(
     Mul, mul;
-    (U3, U3), (U4, U1);
-    self: &'a Rotation<N, U3>, rhs: &'b UnitQuaternion<N>,
-    Output = UnitQuaternion<N> => U3, U3;
+    ;
+    self: &'a Rotation<T, 3>, rhs: &'b UnitQuaternion<T>,
+    Output = UnitQuaternion<T>;
     // TODO: can we avoid the conversion from a rotation matrix?
-    UnitQuaternion::<N>::from_rotation_matrix(self) * rhs;
+    UnitQuaternion::<T>::from_rotation_matrix(self) * rhs;
     'a, 'b);
 
 quaternion_op_impl!(
     Mul, mul;
-    (U3, U3), (U4, U1);
-    self: &'a Rotation<N, U3>, rhs: UnitQuaternion<N>,
-    Output = UnitQuaternion<N> => U3, U3;
-    UnitQuaternion::<N>::from_rotation_matrix(self) * rhs;
+    ;
+    self: &'a Rotation<T, 3>, rhs: UnitQuaternion<T>,
+    Output = UnitQuaternion<T>;
+    UnitQuaternion::<T>::from_rotation_matrix(self) * rhs;
     'a);
 
 quaternion_op_impl!(
     Mul, mul;
-    (U3, U3), (U4, U1);
-    self: Rotation<N, U3>, rhs: &'b UnitQuaternion<N>,
-    Output = UnitQuaternion<N> => U3, U3;
-    UnitQuaternion::<N>::from_rotation_matrix(&self) * rhs;
+    ;
+    self: Rotation<T, 3>, rhs: &'b UnitQuaternion<T>,
+    Output = UnitQuaternion<T>;
+    UnitQuaternion::<T>::from_rotation_matrix(&self) * rhs;
     'b);
 
 quaternion_op_impl!(
     Mul, mul;
-    (U3, U3), (U4, U1);
-    self: Rotation<N, U3>, rhs: UnitQuaternion<N>,
-    Output = UnitQuaternion<N> => U3, U3;
-    UnitQuaternion::<N>::from_rotation_matrix(&self) * rhs; );
+    ;
+    self: Rotation<T, 3>, rhs: UnitQuaternion<T>,
+    Output = UnitQuaternion<T>;
+    UnitQuaternion::<T>::from_rotation_matrix(&self) * rhs; );
 
 // Rotation ÷ UnitQuaternion
 quaternion_op_impl!(
     Div, div;
-    (U3, U3), (U4, U1);
-    self: &'a Rotation<N, U3>, rhs: &'b UnitQuaternion<N>,
-    Output = UnitQuaternion<N> => U3, U3;
-    // TODO: can we avoid the conversion from a rotation matrix?
-    UnitQuaternion::<N>::from_rotation_matrix(self) / rhs;
+    ;
+    self: &'a Rotation<T, 3>, rhs: &'b UnitQuaternion<T>,
+    Output = UnitQuaternion<T>;
+    // TODO: can we avoid the conversion from a rotation matrix?
+    UnitQuaternion::<T>::from_rotation_matrix(self) / rhs;
     'a, 'b);
 
 quaternion_op_impl!(
     Div, div;
-    (U3, U3), (U4, U1);
-    self: &'a Rotation<N, U3>, rhs: UnitQuaternion<N>,
-    Output = UnitQuaternion<N> => U3, U3;
-    UnitQuaternion::<N>::from_rotation_matrix(self) / rhs;
+    ;
+    self: &'a Rotation<T, 3>, rhs: UnitQuaternion<T>,
+    Output = UnitQuaternion<T>;
+    UnitQuaternion::<T>::from_rotation_matrix(self) / rhs;
     'a);
 
 quaternion_op_impl!(
     Div, div;
-    (U3, U3), (U4, U1);
-    self: Rotation<N, U3>, rhs: &'b UnitQuaternion<N>,
-    Output = UnitQuaternion<N> => U3, U3;
-    UnitQuaternion::<N>::from_rotation_matrix(&self) / rhs;
+    ;
+    self: Rotation<T, 3>, rhs: &'b UnitQuaternion<T>,
+    Output = UnitQuaternion<T>;
+    UnitQuaternion::<T>::from_rotation_matrix(&self) / rhs;
     'b);
 
 quaternion_op_impl!(
     Div, div;
-    (U3, U3), (U4, U1);
-    self: Rotation<N, U3>, rhs: UnitQuaternion<N>,
-    Output = UnitQuaternion<N> => U3, U3;
-    UnitQuaternion::<N>::from_rotation_matrix(&self) / rhs; );
+    ;
+    self: Rotation<T, 3>, rhs: UnitQuaternion<T>,
+    Output = UnitQuaternion<T>;
+    UnitQuaternion::<T>::from_rotation_matrix(&self) / rhs; );
 
 // UnitQuaternion × Vector
 quaternion_op_impl!(
     Mul, mul;
-    (U4, U1), (U3, U1) for SB: Storage<N, U3> ;
-    self: &'a UnitQuaternion<N>, rhs: &'b Vector<N, U3, SB>,
-    Output = Vector3<N> => U3, U4;
+    SB: Storage<T, Const<3>> ;
+    self: &'a UnitQuaternion<T>, rhs: &'b Vector<T, Const<3>, SB>,
+    Output = Vector3<T>;
     {
-        let two: N = crate::convert(2.0f64);
+        let two: T = crate::convert(2.0f64);
         let t = self.as_ref().vector().cross(rhs) * two;
         let cross = self.as_ref().vector().cross(&t);
 
@@ -391,118 +387,118 @@ quaternion_op_impl!(
 
 quaternion_op_impl!(
     Mul, mul;
-    (U4, U1), (U3, U1) for SB: Storage<N, U3> ;
-    self: &'a UnitQuaternion<N>, rhs: Vector<N, U3, SB>,
-    Output = Vector3<N> => U3, U4;
+    SB: Storage<T, Const<3>> ;
+    self: &'a UnitQuaternion<T>, rhs: Vector<T, U3, SB>,
+    Output = Vector3<T>;
     self * &rhs;
     'a);
 
 quaternion_op_impl!(
     Mul, mul;
-    (U4, U1), (U3, U1) for SB: Storage<N, U3> ;
-    self: UnitQuaternion<N>, rhs: &'b Vector<N, U3, SB>,
-    Output = Vector3<N> => U3, U4;
+    SB: Storage<T, Const<3>> ;
+    self: UnitQuaternion<T>, rhs: &'b Vector<T, U3, SB>,
+    Output = Vector3<T>;
     &self * rhs;
     'b);
 
 quaternion_op_impl!(
     Mul, mul;
-    (U4, U1), (U3, U1) for SB: Storage<N, U3> ;
-    self: UnitQuaternion<N>, rhs: Vector<N, U3, SB>,
-    Output = Vector3<N> => U3, U4;
+    SB: Storage<T, Const<3>> ;
+    self: UnitQuaternion<T>, rhs: Vector<T, U3, SB>,
+    Output = Vector3<T>;
     &self * &rhs; );
 
 // UnitQuaternion × Point
 quaternion_op_impl!(
     Mul, mul;
-    (U4, U1), (U3, U1);
-    self: &'a UnitQuaternion<N>, rhs: &'b Point3<N>,
-    Output = Point3<N> => U3, U4;
+    ;
+    self: &'a UnitQuaternion<T>, rhs: &'b Point3<T>,
+    Output = Point3<T>;
     Point3::from(self * &rhs.coords);
     'a, 'b);
 
 quaternion_op_impl!(
     Mul, mul;
-    (U4, U1), (U3, U1);
-    self: &'a UnitQuaternion<N>, rhs: Point3<N>,
-    Output = Point3<N> => U3, U4;
+    ;
+    self: &'a UnitQuaternion<T>, rhs: Point3<T>,
+    Output = Point3<T>;
     Point3::from(self * rhs.coords);
     'a);
 
 quaternion_op_impl!(
     Mul, mul;
-    (U4, U1), (U3, U1);
-    self: UnitQuaternion<N>, rhs: &'b Point3<N>,
-    Output = Point3<N> => U3, U4;
+    ;
+    self: UnitQuaternion<T>, rhs: &'b Point3<T>,
+    Output = Point3<T>;
     Point3::from(self * &rhs.coords);
     'b);
 
 quaternion_op_impl!(
     Mul, mul;
-    (U4, U1), (U3, U1);
-    self: UnitQuaternion<N>, rhs: Point3<N>,
-    Output = Point3<N> => U3, U4;
+    ;
+    self: UnitQuaternion<T>, rhs: Point3<T>,
+    Output = Point3<T>;
     Point3::from(self * rhs.coords); );
 
 // UnitQuaternion × Unit<Vector>
 quaternion_op_impl!(
     Mul, mul;
-    (U4, U1), (U3, U1) for SB: Storage<N, U3> ;
-    self: &'a UnitQuaternion<N>, rhs: &'b Unit<Vector<N, U3, SB>>,
-    Output = Unit<Vector3<N>> => U3, U4;
+    SB: Storage<T, Const<3>> ;
+    self: &'a UnitQuaternion<T>, rhs: &'b Unit<Vector<T, U3, SB>>,
+    Output = Unit<Vector3<T>>;
     Unit::new_unchecked(self * rhs.as_ref());
     'a, 'b);
 
 quaternion_op_impl!(
     Mul, mul;
-    (U4, U1), (U3, U1) for SB: Storage<N, U3> ;
-    self: &'a UnitQuaternion<N>, rhs: Unit<Vector<N, U3, SB>>,
-    Output = Unit<Vector3<N>> => U3, U4;
+    SB: Storage<T, Const<3>> ;
+    self: &'a UnitQuaternion<T>, rhs: Unit<Vector<T, U3, SB>>,
+    Output = Unit<Vector3<T>>;
     Unit::new_unchecked(self * rhs.into_inner());
     'a);
 
 quaternion_op_impl!(
     Mul, mul;
-    (U4, U1), (U3, U1) for SB: Storage<N, U3> ;
-    self: UnitQuaternion<N>, rhs: &'b Unit<Vector<N, U3, SB>>,
-    Output = Unit<Vector3<N>> => U3, U4;
+    SB: Storage<T, Const<3>> ;
+    self: UnitQuaternion<T>, rhs: &'b Unit<Vector<T, U3, SB>>,
+    Output = Unit<Vector3<T>>;
     Unit::new_unchecked(self * rhs.as_ref());
     'b);
 
 quaternion_op_impl!(
     Mul, mul;
-    (U4, U1), (U3, U1) for SB: Storage<N, U3> ;
-    self: UnitQuaternion<N>, rhs: Unit<Vector<N, U3, SB>>,
-    Output = Unit<Vector3<N>> => U3, U4;
+    SB: Storage<T, Const<3>> ;
+    self: UnitQuaternion<T>, rhs: Unit<Vector<T, U3, SB>>,
+    Output = Unit<Vector3<T>>;
     Unit::new_unchecked(self * rhs.into_inner()); );
 
 macro_rules! scalar_op_impl(
     ($($Op: ident, $op: ident, $OpAssign: ident, $op_assign: ident);* $(;)*) => {$(
-        impl<N: SimdRealField> $Op<N> for Quaternion<N>
-         where N::Element: SimdRealField {
-            type Output = Quaternion<N>;
+        impl<T: SimdRealField> $Op<T> for Quaternion<T>
+         where T::Element: SimdRealField {
+            type Output = Quaternion<T>;
 
             #[inline]
-            fn $op(self, n: N) -> Self::Output {
+            fn $op(self, n: T) -> Self::Output {
                 Quaternion::from(self.coords.$op(n))
             }
         }
 
-        impl<'a, N: SimdRealField> $Op<N> for &'a Quaternion<N>
-         where N::Element: SimdRealField {
-            type Output = Quaternion<N>;
+        impl<'a, T: SimdRealField> $Op<T> for &'a Quaternion<T>
+         where T::Element: SimdRealField {
+            type Output = Quaternion<T>;
 
             #[inline]
-            fn $op(self, n: N) -> Self::Output {
+            fn $op(self, n: T) -> Self::Output {
                 Quaternion::from((&self.coords).$op(n))
             }
         }
 
-        impl<N: SimdRealField> $OpAssign<N> for Quaternion<N>
-         where N::Element: SimdRealField {
+        impl<T: SimdRealField> $OpAssign<T> for Quaternion<T>
+         where T::Element: SimdRealField {
 
             #[inline]
-            fn $op_assign(&mut self, n: N) {
+            fn $op_assign(&mut self, n: T) {
                 self.coords.$op_assign(n)
             }
         }
@@ -538,11 +534,11 @@ macro_rules! left_scalar_mul_impl(
 
 left_scalar_mul_impl!(f32, f64);
 
-impl<N: SimdRealField> Neg for Quaternion<N>
+impl<T: SimdRealField> Neg for Quaternion<T>
 where
-    N::Element: SimdRealField,
+    T::Element: SimdRealField,
 {
-    type Output = Quaternion<N>;
+    type Output = Quaternion<T>;
 
     #[inline]
     fn neg(self) -> Self::Output {
@@ -550,11 +546,11 @@ where
     }
 }
 
-impl<'a, N: SimdRealField> Neg for &'a Quaternion<N>
+impl<'a, T: SimdRealField> Neg for &'a Quaternion<T>
 where
-    N::Element: SimdRealField,
+    T::Element: SimdRealField,
 {
-    type Output = Quaternion<N>;
+    type Output = Quaternion<T>;
 
     #[inline]
     fn neg(self) -> Self::Output {
@@ -564,13 +560,10 @@ where
 
 macro_rules! quaternion_op_impl(
     ($OpAssign: ident, $op_assign: ident;
-     ($LhsRDim: ident, $LhsCDim: ident), ($RhsRDim: ident, $RhsCDim: ident);
      $lhs: ident: $Lhs: ty, $rhs: ident: $Rhs: ty $(=> $VDimA: ty, $VDimB: ty)*;
      $action: expr; $($lives: tt),*) => {
-        impl<$($lives ,)* N: SimdRealField> $OpAssign<$Rhs> for $Lhs
-            where N::Element: SimdRealField,
-                  DefaultAllocator: Allocator<N, $LhsRDim, $LhsCDim> +
-                                    Allocator<N, $RhsRDim, $RhsCDim> {
+        impl<$($lives ,)* T: SimdRealField> $OpAssign<$Rhs> for $Lhs
+            where T::Element: SimdRealField {
 
             #[inline]
             fn $op_assign(&mut $lhs, $rhs: $Rhs) {
@@ -583,36 +576,31 @@ macro_rules! quaternion_op_impl(
 // Quaternion += Quaternion
 quaternion_op_impl!(
     AddAssign, add_assign;
-    (U4, U1), (U4, U1);
-    self: Quaternion<N>, rhs: &'b Quaternion<N>;
+    self: Quaternion<T>, rhs: &'b Quaternion<T>;
     self.coords += &rhs.coords;
     'b);
 
 quaternion_op_impl!(
     AddAssign, add_assign;
-    (U4, U1), (U4, U1);
-    self: Quaternion<N>, rhs: Quaternion<N>;
+    self: Quaternion<T>, rhs: Quaternion<T>;
     self.coords += rhs.coords; );
 
 // Quaternion -= Quaternion
 quaternion_op_impl!(
     SubAssign, sub_assign;
-    (U4, U1), (U4, U1);
-    self: Quaternion<N>, rhs: &'b Quaternion<N>;
+    self: Quaternion<T>, rhs: &'b Quaternion<T>;
     self.coords -= &rhs.coords;
     'b);
 
 quaternion_op_impl!(
     SubAssign, sub_assign;
-    (U4, U1), (U4, U1);
-    self: Quaternion<N>, rhs: Quaternion<N>;
+    self: Quaternion<T>, rhs: Quaternion<T>;
     self.coords -= rhs.coords; );
 
 // Quaternion ×= Quaternion
 quaternion_op_impl!(
     MulAssign, mul_assign;
-    (U4, U1), (U4, U1);
-    self: Quaternion<N>, rhs: &'b Quaternion<N>;
+    self: Quaternion<T>, rhs: &'b Quaternion<T>;
     {
         let res = &*self * rhs;
         // TODO: will this be optimized away?
@@ -622,15 +610,13 @@ quaternion_op_impl!(
 
 quaternion_op_impl!(
     MulAssign, mul_assign;
-    (U4, U1), (U4, U1);
-    self: Quaternion<N>, rhs: Quaternion<N>;
+    self: Quaternion<T>, rhs: Quaternion<T>;
     *self *= &rhs; );
 
 // UnitQuaternion ×= UnitQuaternion
 quaternion_op_impl!(
     MulAssign, mul_assign;
-    (U4, U1), (U4, U1);
-    self: UnitQuaternion<N>, rhs: &'b UnitQuaternion<N>;
+    self: UnitQuaternion<T>, rhs: &'b UnitQuaternion<T>;
     {
         let res = &*self * rhs;
         self.as_mut_unchecked().coords.copy_from(&res.as_ref().coords);
@@ -639,15 +625,13 @@ quaternion_op_impl!(
 
 quaternion_op_impl!(
     MulAssign, mul_assign;
-    (U4, U1), (U4, U1);
-    self: UnitQuaternion<N>, rhs: UnitQuaternion<N>;
+    self: UnitQuaternion<T>, rhs: UnitQuaternion<T>;
     *self *= &rhs; );
 
 // UnitQuaternion ÷= UnitQuaternion
 quaternion_op_impl!(
     DivAssign, div_assign;
-    (U4, U1), (U4, U1);
-    self: UnitQuaternion<N>, rhs: &'b UnitQuaternion<N>;
+    self: UnitQuaternion<T>, rhs: &'b UnitQuaternion<T>;
     {
         let res = &*self / rhs;
         self.as_mut_unchecked().coords.copy_from(&res.as_ref().coords);
@@ -656,15 +640,13 @@ quaternion_op_impl!(
 
 quaternion_op_impl!(
     DivAssign, div_assign;
-    (U4, U1), (U4, U1);
-    self: UnitQuaternion<N>, rhs: UnitQuaternion<N>;
+    self: UnitQuaternion<T>, rhs: UnitQuaternion<T>;
     *self /= &rhs; );
 
 // UnitQuaternion ×= Rotation
 quaternion_op_impl!(
     MulAssign, mul_assign;
-    (U4, U1), (U3, U3);
-    self: UnitQuaternion<N>, rhs: &'b Rotation<N, U3> => U3, U3;
+    self: UnitQuaternion<T>, rhs: &'b Rotation<T, 3>;
     {
         let res = &*self * rhs;
         self.as_mut_unchecked().coords.copy_from(&res.as_ref().coords);
@@ -673,15 +655,13 @@ quaternion_op_impl!(
 
 quaternion_op_impl!(
     MulAssign, mul_assign;
-    (U4, U1), (U3, U3);
-    self: UnitQuaternion<N>, rhs: Rotation<N, U3> => U3, U3;
+    self: UnitQuaternion<T>, rhs: Rotation<T, 3>;
     *self *= &rhs; );
 
 // UnitQuaternion ÷= Rotation
 quaternion_op_impl!(
     DivAssign, div_assign;
-    (U4, U1), (U3, U3);
-    self: UnitQuaternion<N>, rhs: &'b Rotation<N, U3> => U3, U3;
+    self: UnitQuaternion<T>, rhs: &'b Rotation<T, 3>;
     {
         let res = &*self / rhs;
         self.as_mut_unchecked().coords.copy_from(&res.as_ref().coords);
@@ -690,6 +670,5 @@ quaternion_op_impl!(
 
 quaternion_op_impl!(
     DivAssign, div_assign;
-    (U4, U1), (U3, U3);
-    self: UnitQuaternion<N>, rhs: Rotation<N, U3> => U3, U3;
+    self: UnitQuaternion<T>, rhs: Rotation<T, 3>;
     *self /= &rhs; );
diff --git a/src/geometry/quaternion_simba.rs b/src/geometry/quaternion_simba.rs
index b43db8d9..162d7a63 100755
--- a/src/geometry/quaternion_simba.rs
+++ b/src/geometry/quaternion_simba.rs
@@ -4,16 +4,16 @@ use crate::base::Vector4;
 use crate::geometry::{Quaternion, UnitQuaternion};
 use crate::Scalar;
 
-impl<N: Scalar + SimdValue> SimdValue for Quaternion<N>
+impl<T: Scalar + SimdValue> SimdValue for Quaternion<T>
 where
-    N::Element: Scalar,
+    T::Element: Scalar,
 {
-    type Element = Quaternion<N::Element>;
-    type SimdBool = N::SimdBool;
+    type Element = Quaternion<T::Element>;
+    type SimdBool = T::SimdBool;
 
     #[inline]
     fn lanes() -> usize {
-        N::lanes()
+        T::lanes()
     }
 
     #[inline]
@@ -47,16 +47,16 @@ where
     }
 }
 
-impl<N: Scalar + SimdValue> SimdValue for UnitQuaternion<N>
+impl<T: Scalar + SimdValue> SimdValue for UnitQuaternion<T>
 where
-    N::Element: Scalar,
+    T::Element: Scalar,
 {
-    type Element = UnitQuaternion<N::Element>;
-    type SimdBool = N::SimdBool;
+    type Element = UnitQuaternion<T::Element>;
+    type SimdBool = T::SimdBool;
 
     #[inline]
     fn lanes() -> usize {
-        N::lanes()
+        T::lanes()
     }
 
     #[inline]
diff --git a/src/geometry/reflection.rs b/src/geometry/reflection.rs
index d5e950ec..e48c700a 100644
--- a/src/geometry/reflection.rs
+++ b/src/geometry/reflection.rs
@@ -1,68 +1,65 @@
-use crate::base::allocator::Allocator;
 use crate::base::constraint::{AreMultipliable, DimEq, SameNumberOfRows, ShapeConstraint};
-use crate::base::{DefaultAllocator, Matrix, Scalar, Unit, Vector};
-use crate::dimension::{Dim, DimName, U1};
+use crate::base::{Const, Matrix, Scalar, Unit, Vector};
+use crate::dimension::{Dim, U1};
 use crate::storage::{Storage, StorageMut};
 use simba::scalar::ComplexField;
 
 use crate::geometry::Point;
 
 /// A reflection wrt. a plane.
-pub struct Reflection<N: Scalar, D: Dim, S: Storage<N, D>> {
-    axis: Vector<N, D, S>,
-    bias: N,
+pub struct Reflection<T: Scalar, D: Dim, S: Storage<T, D>> {
+    axis: Vector<T, D, S>,
+    bias: T,
 }
 
-impl<N: ComplexField, D: Dim, S: Storage<N, D>> Reflection<N, D, S> {
+impl<T: ComplexField, S: Storage<T, Const<D>>, const D: usize> Reflection<T, Const<D>, S> {
+    /// Creates a new reflection wrt. the plane orthogonal to the given axis and that contains the
+    /// point `pt`.
+    pub fn new_containing_point(axis: Unit<Vector<T, Const<D>, S>>, pt: &Point<T, D>) -> Self {
+        let bias = axis.dotc(&pt.coords);
+        Self::new(axis, bias)
+    }
+}
+
+impl<T: ComplexField, D: Dim, S: Storage<T, D>> Reflection<T, D, S> {
     /// Creates a new reflection wrt the plane orthogonal to the given axis and bias.
     ///
     /// The bias is the position of the plane on the axis. In particular, a bias equal to zero
     /// represents a plane that passes through the origin.
-    pub fn new(axis: Unit<Vector<N, D, S>>, bias: N) -> Self {
+    pub fn new(axis: Unit<Vector<T, D, S>>, bias: T) -> Self {
         Self {
             axis: axis.into_inner(),
             bias,
         }
     }
 
-    /// Creates a new reflection wrt. the plane orthogonal to the given axis and that contains the
-    /// point `pt`.
-    pub fn new_containing_point(axis: Unit<Vector<N, D, S>>, pt: &Point<N, D>) -> Self
-    where
-        D: DimName,
-        DefaultAllocator: Allocator<N, D>,
-    {
-        let bias = axis.dotc(&pt.coords);
-        Self::new(axis, bias)
-    }
-
     /// The reflexion axis.
-    pub fn axis(&self) -> &Vector<N, D, S> {
+    pub fn axis(&self) -> &Vector<T, D, S> {
         &self.axis
     }
 
     // TODO: naming convention: reflect_to, reflect_assign ?
     /// Applies the reflection to the columns of `rhs`.
-    pub fn reflect<R2: Dim, C2: Dim, S2>(&self, rhs: &mut Matrix<N, R2, C2, S2>)
+    pub fn reflect<R2: Dim, C2: Dim, S2>(&self, rhs: &mut Matrix<T, R2, C2, S2>)
     where
-        S2: StorageMut<N, R2, C2>,
+        S2: StorageMut<T, R2, C2>,
         ShapeConstraint: SameNumberOfRows<R2, D>,
     {
         for i in 0..rhs.ncols() {
             // NOTE: we borrow the column twice here. First it is borrowed immutably for the
             // dot product, and then mutably. Somehow, this allows significantly
             // better optimizations of the dot product from the compiler.
-            let m_two: N = crate::convert(-2.0f64);
+            let m_two: T = crate::convert(-2.0f64);
             let factor = (self.axis.dotc(&rhs.column(i)) - self.bias) * m_two;
-            rhs.column_mut(i).axpy(factor, &self.axis, N::one());
+            rhs.column_mut(i).axpy(factor, &self.axis, T::one());
         }
     }
 
     // TODO: naming convention: reflect_to, reflect_assign ?
     /// Applies the reflection to the columns of `rhs`.
-    pub fn reflect_with_sign<R2: Dim, C2: Dim, S2>(&self, rhs: &mut Matrix<N, R2, C2, S2>, sign: N)
+    pub fn reflect_with_sign<R2: Dim, C2: Dim, S2>(&self, rhs: &mut Matrix<T, R2, C2, S2>, sign: T)
     where
-        S2: StorageMut<N, R2, C2>,
+        S2: StorageMut<T, R2, C2>,
         ShapeConstraint: SameNumberOfRows<R2, D>,
     {
         for i in 0..rhs.ncols() {
@@ -78,11 +75,11 @@ impl<N: ComplexField, D: Dim, S: Storage<N, D>> Reflection<N, D, S> {
     /// Applies the reflection to the rows of `lhs`.
     pub fn reflect_rows<R2: Dim, C2: Dim, S2, S3>(
         &self,
-        lhs: &mut Matrix<N, R2, C2, S2>,
-        work: &mut Vector<N, R2, S3>,
+        lhs: &mut Matrix<T, R2, C2, S2>,
+        work: &mut Vector<T, R2, S3>,
     ) where
-        S2: StorageMut<N, R2, C2>,
-        S3: StorageMut<N, R2>,
+        S2: StorageMut<T, R2, C2>,
+        S3: StorageMut<T, R2>,
         ShapeConstraint: DimEq<C2, D> + AreMultipliable<R2, C2, D, U1>,
     {
         lhs.mul_to(&self.axis, work);
@@ -91,19 +88,19 @@ impl<N: ComplexField, D: Dim, S: Storage<N, D>> Reflection<N, D, S> {
             work.add_scalar_mut(-self.bias);
         }
 
-        let m_two: N = crate::convert(-2.0f64);
-        lhs.gerc(m_two, &work, &self.axis, N::one());
+        let m_two: T = crate::convert(-2.0f64);
+        lhs.gerc(m_two, &work, &self.axis, T::one());
     }
 
     /// Applies the reflection to the rows of `lhs`.
     pub fn reflect_rows_with_sign<R2: Dim, C2: Dim, S2, S3>(
         &self,
-        lhs: &mut Matrix<N, R2, C2, S2>,
-        work: &mut Vector<N, R2, S3>,
-        sign: N,
+        lhs: &mut Matrix<T, R2, C2, S2>,
+        work: &mut Vector<T, R2, S3>,
+        sign: T,
     ) where
-        S2: StorageMut<N, R2, C2>,
-        S3: StorageMut<N, R2>,
+        S2: StorageMut<T, R2, C2>,
+        S3: StorageMut<T, R2>,
         ShapeConstraint: DimEq<C2, D> + AreMultipliable<R2, C2, D, U1>,
     {
         lhs.mul_to(&self.axis, work);
diff --git a/src/geometry/rotation.rs b/src/geometry/rotation.rs
index e4f69fe6..74843b21 100755
--- a/src/geometry/rotation.rs
+++ b/src/geometry/rotation.rs
@@ -18,8 +18,8 @@ use simba::scalar::RealField;
 use simba::simd::SimdRealField;
 
 use crate::base::allocator::Allocator;
-use crate::base::dimension::{DimName, DimNameAdd, DimNameSum, U1};
-use crate::base::{DefaultAllocator, MatrixN, Scalar, Unit, VectorN};
+use crate::base::dimension::{DimNameAdd, DimNameSum, U1};
+use crate::base::{Const, DefaultAllocator, OMatrix, SMatrix, SVector, Scalar, Unit};
 use crate::geometry::Point;
 
 /// A rotation matrix.
@@ -55,34 +55,27 @@ use crate::geometry::Point;
 ///
 #[repr(C)]
 #[derive(Debug)]
-pub struct Rotation<N: Scalar, D: DimName>
-where
-    DefaultAllocator: Allocator<N, D, D>,
-{
-    matrix: MatrixN<N, D>,
+pub struct Rotation<T: Scalar, const D: usize> {
+    matrix: SMatrix<T, D, D>,
 }
 
-impl<N: Scalar + hash::Hash, D: DimName + hash::Hash> hash::Hash for Rotation<N, D>
+impl<T: Scalar + hash::Hash, const D: usize> hash::Hash for Rotation<T, D>
 where
-    DefaultAllocator: Allocator<N, D, D>,
-    <DefaultAllocator as Allocator<N, D, D>>::Buffer: hash::Hash,
+    <DefaultAllocator as Allocator<T, Const<D>, Const<D>>>::Buffer: hash::Hash,
 {
     fn hash<H: hash::Hasher>(&self, state: &mut H) {
         self.matrix.hash(state)
     }
 }
 
-impl<N: Scalar + Copy, D: DimName> Copy for Rotation<N, D>
-where
-    DefaultAllocator: Allocator<N, D, D>,
-    <DefaultAllocator as Allocator<N, D, D>>::Buffer: Copy,
+impl<T: Scalar + Copy, const D: usize> Copy for Rotation<T, D> where
+    <DefaultAllocator as Allocator<T, Const<D>, Const<D>>>::Buffer: Copy
 {
 }
 
-impl<N: Scalar, D: DimName> Clone for Rotation<N, D>
+impl<T: Scalar, const D: usize> Clone for Rotation<T, D>
 where
-    DefaultAllocator: Allocator<N, D, D>,
-    <DefaultAllocator as Allocator<N, D, D>>::Buffer: Clone,
+    <DefaultAllocator as Allocator<T, Const<D>, Const<D>>>::Buffer: Clone,
 {
     #[inline]
     fn clone(&self) -> Self {
@@ -91,12 +84,10 @@ where
 }
 
 #[cfg(feature = "abomonation-serialize")]
-impl<N, D> Abomonation for Rotation<N, D>
+impl<T, const D: usize> Abomonation for Rotation<T, D>
 where
-    N: Scalar,
-    D: DimName,
-    MatrixN<N, D>: Abomonation,
-    DefaultAllocator: Allocator<N, D, D>,
+    T: Scalar,
+    SMatrix<T, D, D>: Abomonation,
 {
     unsafe fn entomb<W: Write>(&self, writer: &mut W) -> IOResult<()> {
         self.matrix.entomb(writer)
@@ -112,10 +103,9 @@ where
 }
 
 #[cfg(feature = "serde-serialize")]
-impl<N: Scalar, D: DimName> Serialize for Rotation<N, D>
+impl<T: Scalar, const D: usize> Serialize for Rotation<T, D>
 where
-    DefaultAllocator: Allocator<N, D, D>,
-    Owned<N, D, D>: Serialize,
+    Owned<T, Const<D>, Const<D>>: Serialize,
 {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
@@ -126,25 +116,21 @@ where
 }
 
 #[cfg(feature = "serde-serialize")]
-impl<'a, N: Scalar, D: DimName> Deserialize<'a> for Rotation<N, D>
+impl<'a, T: Scalar, const D: usize> Deserialize<'a> for Rotation<T, D>
 where
-    DefaultAllocator: Allocator<N, D, D>,
-    Owned<N, D, D>: Deserialize<'a>,
+    Owned<T, Const<D>, Const<D>>: Deserialize<'a>,
 {
     fn deserialize<Des>(deserializer: Des) -> Result<Self, Des::Error>
     where
         Des: Deserializer<'a>,
     {
-        let matrix = MatrixN::<N, D>::deserialize(deserializer)?;
+        let matrix = SMatrix::<T, D, D>::deserialize(deserializer)?;
 
         Ok(Self::from_matrix_unchecked(matrix))
     }
 }
 
-impl<N: Scalar, D: DimName> Rotation<N, D>
-where
-    DefaultAllocator: Allocator<N, D, D>,
-{
+impl<T: Scalar, const D: usize> Rotation<T, D> {
     /// Creates a new rotation from the given square matrix.
     ///
     /// The matrix squareness is checked but not its orthonormality.
@@ -168,7 +154,7 @@ where
     /// assert_eq!(*rot.matrix(), mat);
     /// ```
     #[inline]
-    pub fn from_matrix_unchecked(matrix: MatrixN<N, D>) -> Self {
+    pub fn from_matrix_unchecked(matrix: SMatrix<T, D, D>) -> Self {
         assert!(
             matrix.is_square(),
             "Unable to create a rotation from a non-square matrix."
@@ -179,10 +165,7 @@ where
 }
 
 /// # Conversion to a matrix
-impl<N: Scalar, D: DimName> Rotation<N, D>
-where
-    DefaultAllocator: Allocator<N, D, D>,
-{
+impl<T: Scalar, const D: usize> Rotation<T, D> {
     /// A reference to the underlying matrix representation of this rotation.
     ///
     /// # Example
@@ -202,14 +185,14 @@ where
     /// assert_eq!(*rot.matrix(), expected);
     /// ```
     #[inline]
-    pub fn matrix(&self) -> &MatrixN<N, D> {
+    pub fn matrix(&self) -> &SMatrix<T, D, D> {
         &self.matrix
     }
 
     /// A mutable reference to the underlying matrix representation of this rotation.
     #[inline]
     #[deprecated(note = "Use `.matrix_mut_unchecked()` instead.")]
-    pub unsafe fn matrix_mut(&mut self) -> &mut MatrixN<N, D> {
+    pub unsafe fn matrix_mut(&mut self) -> &mut SMatrix<T, D, D> {
         &mut self.matrix
     }
 
@@ -219,7 +202,7 @@ where
     /// non-square, non-inversible, or non-orthonormal. If one of those properties is broken,
     /// subsequent method calls may be UB.
     #[inline]
-    pub fn matrix_mut_unchecked(&mut self) -> &mut MatrixN<N, D> {
+    pub fn matrix_mut_unchecked(&mut self) -> &mut SMatrix<T, D, D> {
         &mut self.matrix
     }
 
@@ -244,7 +227,7 @@ where
     /// assert_eq!(mat, expected);
     /// ```
     #[inline]
-    pub fn into_inner(self) -> MatrixN<N, D> {
+    pub fn into_inner(self) -> SMatrix<T, D, D> {
         self.matrix
     }
 
@@ -252,7 +235,7 @@ where
     /// Deprecated: Use [Rotation::into_inner] instead.
     #[deprecated(note = "use `.into_inner()` instead")]
     #[inline]
-    pub fn unwrap(self) -> MatrixN<N, D> {
+    pub fn unwrap(self) -> SMatrix<T, D, D> {
         self.matrix
     }
 
@@ -279,16 +262,16 @@ where
     /// assert_eq!(rot.to_homogeneous(), expected);
     /// ```
     #[inline]
-    pub fn to_homogeneous(&self) -> MatrixN<N, DimNameSum<D, U1>>
+    pub fn to_homogeneous(&self) -> OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
     where
-        N: Zero + One,
-        D: DimNameAdd<U1>,
-        DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
+        T: Zero + One,
+        Const<D>: DimNameAdd<U1>,
+        DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
     {
-        // We could use `MatrixN::to_homogeneous()` here, but that would imply
+        // We could use `SMatrix::to_homogeneous()` here, but that would imply
         // adding the additional traits `DimAdd` and `IsNotStaticOne`. Maybe
         // these things will get nicer once specialization lands in Rust.
-        let mut res = MatrixN::<N, DimNameSum<D, U1>>::identity();
+        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
@@ -296,10 +279,7 @@ where
 }
 
 /// # Transposition and inversion
-impl<N: Scalar, D: DimName> Rotation<N, D>
-where
-    DefaultAllocator: Allocator<N, D, D>,
-{
+impl<T: Scalar, const D: usize> Rotation<T, D> {
     /// Transposes `self`.
     ///
     /// Same as `.inverse()` because the inverse of a rotation matrix is its transform.
@@ -404,10 +384,9 @@ where
 }
 
 /// # Transformation of a vector or a point
-impl<N: SimdRealField, D: DimName> Rotation<N, D>
+impl<T: SimdRealField, const D: usize> Rotation<T, D>
 where
-    N::Element: SimdRealField,
-    DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>,
+    T::Element: SimdRealField,
 {
     /// Rotate the given point.
     ///
@@ -424,7 +403,7 @@ where
     /// assert_relative_eq!(transformed_point, Point3::new(3.0, 2.0, -1.0), epsilon = 1.0e-6);
     /// ```
     #[inline]
-    pub fn transform_point(&self, pt: &Point<N, D>) -> Point<N, D> {
+    pub fn transform_point(&self, pt: &Point<T, D>) -> Point<T, D> {
         self * pt
     }
 
@@ -443,7 +422,7 @@ where
     /// assert_relative_eq!(transformed_vector, Vector3::new(3.0, 2.0, -1.0), epsilon = 1.0e-6);
     /// ```
     #[inline]
-    pub fn transform_vector(&self, v: &VectorN<N, D>) -> VectorN<N, D> {
+    pub fn transform_vector(&self, v: &SVector<T, D>) -> SVector<T, D> {
         self * v
     }
 
@@ -462,7 +441,7 @@ where
     /// assert_relative_eq!(transformed_point, Point3::new(-3.0, 2.0, 1.0), epsilon = 1.0e-6);
     /// ```
     #[inline]
-    pub fn inverse_transform_point(&self, pt: &Point<N, D>) -> Point<N, D> {
+    pub fn inverse_transform_point(&self, pt: &Point<T, D>) -> Point<T, D> {
         Point::from(self.inverse_transform_vector(&pt.coords))
     }
 
@@ -481,7 +460,7 @@ where
     /// assert_relative_eq!(transformed_vector, Vector3::new(-3.0, 2.0, 1.0), epsilon = 1.0e-6);
     /// ```
     #[inline]
-    pub fn inverse_transform_vector(&self, v: &VectorN<N, D>) -> VectorN<N, D> {
+    pub fn inverse_transform_vector(&self, v: &SVector<T, D>) -> SVector<T, D> {
         self.matrix().tr_mul(v)
     }
 
@@ -500,34 +479,30 @@ where
     /// assert_relative_eq!(transformed_vector, -Vector3::y_axis(), epsilon = 1.0e-6);
     /// ```
     #[inline]
-    pub fn inverse_transform_unit_vector(&self, v: &Unit<VectorN<N, D>>) -> Unit<VectorN<N, D>> {
+    pub fn inverse_transform_unit_vector(&self, v: &Unit<SVector<T, D>>) -> Unit<SVector<T, D>> {
         Unit::new_unchecked(self.inverse_transform_vector(&**v))
     }
 }
 
-impl<N: Scalar + Eq, D: DimName> Eq for Rotation<N, D> where DefaultAllocator: Allocator<N, D, D> {}
+impl<T: Scalar + Eq, const D: usize> Eq for Rotation<T, D> {}
 
-impl<N: Scalar + PartialEq, D: DimName> PartialEq for Rotation<N, D>
-where
-    DefaultAllocator: Allocator<N, D, D>,
-{
+impl<T: Scalar + PartialEq, const D: usize> PartialEq for Rotation<T, D> {
     #[inline]
     fn eq(&self, right: &Self) -> bool {
         self.matrix == right.matrix
     }
 }
 
-impl<N, D: DimName> AbsDiffEq for Rotation<N, D>
+impl<T, const D: usize> AbsDiffEq for Rotation<T, D>
 where
-    N: Scalar + AbsDiffEq,
-    DefaultAllocator: Allocator<N, D, D>,
-    N::Epsilon: Copy,
+    T: Scalar + AbsDiffEq,
+    T::Epsilon: Copy,
 {
-    type Epsilon = N::Epsilon;
+    type Epsilon = T::Epsilon;
 
     #[inline]
     fn default_epsilon() -> Self::Epsilon {
-        N::default_epsilon()
+        T::default_epsilon()
     }
 
     #[inline]
@@ -536,15 +511,14 @@ where
     }
 }
 
-impl<N, D: DimName> RelativeEq for Rotation<N, D>
+impl<T, const D: usize> RelativeEq for Rotation<T, D>
 where
-    N: Scalar + RelativeEq,
-    DefaultAllocator: Allocator<N, D, D>,
-    N::Epsilon: Copy,
+    T: Scalar + RelativeEq,
+    T::Epsilon: Copy,
 {
     #[inline]
     fn default_max_relative() -> Self::Epsilon {
-        N::default_max_relative()
+        T::default_max_relative()
     }
 
     #[inline]
@@ -559,15 +533,14 @@ where
     }
 }
 
-impl<N, D: DimName> UlpsEq for Rotation<N, D>
+impl<T, const D: usize> UlpsEq for Rotation<T, D>
 where
-    N: Scalar + UlpsEq,
-    DefaultAllocator: Allocator<N, D, D>,
-    N::Epsilon: Copy,
+    T: Scalar + UlpsEq,
+    T::Epsilon: Copy,
 {
     #[inline]
     fn default_max_ulps() -> u32 {
-        N::default_max_ulps()
+        T::default_max_ulps()
     }
 
     #[inline]
@@ -581,10 +554,9 @@ where
  * Display
  *
  */
-impl<N, D: DimName> fmt::Display for Rotation<N, D>
+impl<T, const D: usize> fmt::Display for Rotation<T, D>
 where
-    N: RealField + fmt::Display,
-    DefaultAllocator: Allocator<N, D, D> + Allocator<usize, D, D>,
+    T: RealField + fmt::Display,
 {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let precision = f.precision().unwrap_or(3);
@@ -600,11 +572,11 @@ where
 //          //          * Absolute
 //          //          *
 //          //          */
-//          //         impl<N: Absolute> Absolute for $t<N> {
-//          //             type AbsoluteValue = $submatrix<N::AbsoluteValue>;
+//          //         impl<T: Absolute> Absolute for $t<T> {
+//          //             type AbsoluteValue = $submatrix<T::AbsoluteValue>;
 //          //
 //          //             #[inline]
-//          //             fn abs(m: &$t<N>) -> $submatrix<N::AbsoluteValue> {
+//          //             fn abs(m: &$t<T>) -> $submatrix<T::AbsoluteValue> {
 //          //                 Absolute::abs(&m.submatrix)
 //          //             }
 //          //         }
diff --git a/src/geometry/rotation_alias.rs b/src/geometry/rotation_alias.rs
index f9e0230b..f44e24bc 100644
--- a/src/geometry/rotation_alias.rs
+++ b/src/geometry/rotation_alias.rs
@@ -1,13 +1,11 @@
-use crate::base::dimension::{U2, U3};
-
 use crate::geometry::Rotation;
 
 /// A 2-dimensional rotation matrix.
 ///
 /// **Because this is an alias, not all its methods are listed here. See the [`Rotation`](crate::Rotation) type too.**
-pub type Rotation2<N> = Rotation<N, U2>;
+pub type Rotation2<T> = Rotation<T, 2>;
 
 /// A 3-dimensional rotation matrix.
 ///
 /// **Because this is an alias, not all its methods are listed here. See the [`Rotation`](crate::Rotation) type too.**
-pub type Rotation3<N> = Rotation<N, U3>;
+pub type Rotation3<T> = Rotation<T, 3>;
diff --git a/src/geometry/rotation_construction.rs b/src/geometry/rotation_construction.rs
index f198fc92..c18c6a58 100644
--- a/src/geometry/rotation_construction.rs
+++ b/src/geometry/rotation_construction.rs
@@ -2,17 +2,14 @@ use num::{One, Zero};
 
 use simba::scalar::{ClosedAdd, ClosedMul, SupersetOf};
 
-use crate::base::allocator::Allocator;
-use crate::base::dimension::DimName;
-use crate::base::{DefaultAllocator, MatrixN, Scalar};
+use crate::base::{SMatrix, Scalar};
 
 use crate::geometry::Rotation;
 
 /// # Identity
-impl<N, D: DimName> Rotation<N, D>
+impl<T, const D: usize> Rotation<T, D>
 where
-    N: Scalar + Zero + One,
-    DefaultAllocator: Allocator<N, D, D>,
+    T: Scalar + Zero + One,
 {
     /// Creates a new square identity rotation of the given `dimension`.
     ///
@@ -26,15 +23,12 @@ where
     /// assert_eq!(rot2 * rot1, rot2);
     /// ```
     #[inline]
-    pub fn identity() -> Rotation<N, D> {
-        Self::from_matrix_unchecked(MatrixN::<N, D>::identity())
+    pub fn identity() -> Rotation<T, D> {
+        Self::from_matrix_unchecked(SMatrix::<T, D, D>::identity())
     }
 }
 
-impl<N: Scalar, D: DimName> Rotation<N, D>
-where
-    DefaultAllocator: Allocator<N, D, D>,
-{
+impl<T: Scalar, const D: usize> Rotation<T, D> {
     /// Cast the components of `self` to another type.
     ///
     /// # Example
@@ -47,16 +41,14 @@ where
     pub fn cast<To: Scalar>(self) -> Rotation<To, D>
     where
         Rotation<To, D>: SupersetOf<Self>,
-        DefaultAllocator: Allocator<To, D, D>,
     {
         crate::convert(self)
     }
 }
 
-impl<N, D: DimName> One for Rotation<N, D>
+impl<T, const D: usize> One for Rotation<T, D>
 where
-    N: Scalar + Zero + One + ClosedAdd + ClosedMul,
-    DefaultAllocator: Allocator<N, D, D>,
+    T: Scalar + Zero + One + ClosedAdd + ClosedMul,
 {
     #[inline]
     fn one() -> Self {
diff --git a/src/geometry/rotation_conversion.rs b/src/geometry/rotation_conversion.rs
index 21f5a936..0e83d60f 100644
--- a/src/geometry/rotation_conversion.rs
+++ b/src/geometry/rotation_conversion.rs
@@ -4,8 +4,8 @@ use simba::scalar::{RealField, SubsetOf, SupersetOf};
 use simba::simd::{PrimitiveSimdValue, SimdValue};
 
 use crate::base::allocator::Allocator;
-use crate::base::dimension::{DimMin, DimName, DimNameAdd, DimNameSum, U1};
-use crate::base::{DefaultAllocator, Matrix2, Matrix3, Matrix4, MatrixN, Scalar};
+use crate::base::dimension::{DimMin, DimNameAdd, DimNameSum, U1};
+use crate::base::{Const, DefaultAllocator, Matrix2, Matrix3, Matrix4, OMatrix, SMatrix, Scalar};
 
 use crate::geometry::{
     AbstractRotation, Isometry, Rotation, Rotation2, Rotation3, Similarity, SuperTCategoryOf,
@@ -27,265 +27,262 @@ use crate::geometry::{
 
 */
 
-impl<N1, N2, D: DimName> SubsetOf<Rotation<N2, D>> for Rotation<N1, D>
+impl<T1, T2, const D: usize> SubsetOf<Rotation<T2, D>> for Rotation<T1, D>
 where
-    N1: RealField,
-    N2: RealField + SupersetOf<N1>,
-    DefaultAllocator: Allocator<N1, D, D> + Allocator<N2, D, D>,
+    T1: RealField,
+    T2: RealField + SupersetOf<T1>,
 {
     #[inline]
-    fn to_superset(&self) -> Rotation<N2, D> {
+    fn to_superset(&self) -> Rotation<T2, D> {
         Rotation::from_matrix_unchecked(self.matrix().to_superset())
     }
 
     #[inline]
-    fn is_in_subset(rot: &Rotation<N2, D>) -> bool {
-        crate::is_convertible::<_, MatrixN<N1, D>>(rot.matrix())
+    fn is_in_subset(rot: &Rotation<T2, D>) -> bool {
+        crate::is_convertible::<_, SMatrix<T1, D, D>>(rot.matrix())
     }
 
     #[inline]
-    fn from_superset_unchecked(rot: &Rotation<N2, D>) -> Self {
+    fn from_superset_unchecked(rot: &Rotation<T2, D>) -> Self {
         Rotation::from_matrix_unchecked(rot.matrix().to_subset_unchecked())
     }
 }
 
-impl<N1, N2> SubsetOf<UnitQuaternion<N2>> for Rotation3<N1>
+impl<T1, T2> SubsetOf<UnitQuaternion<T2>> for Rotation3<T1>
 where
-    N1: RealField,
-    N2: RealField + SupersetOf<N1>,
+    T1: RealField,
+    T2: RealField + SupersetOf<T1>,
 {
     #[inline]
-    fn to_superset(&self) -> UnitQuaternion<N2> {
-        let q = UnitQuaternion::<N1>::from_rotation_matrix(self);
+    fn to_superset(&self) -> UnitQuaternion<T2> {
+        let q = UnitQuaternion::<T1>::from_rotation_matrix(self);
         q.to_superset()
     }
 
     #[inline]
-    fn is_in_subset(q: &UnitQuaternion<N2>) -> bool {
-        crate::is_convertible::<_, UnitQuaternion<N1>>(q)
+    fn is_in_subset(q: &UnitQuaternion<T2>) -> bool {
+        crate::is_convertible::<_, UnitQuaternion<T1>>(q)
     }
 
     #[inline]
-    fn from_superset_unchecked(q: &UnitQuaternion<N2>) -> Self {
-        let q: UnitQuaternion<N1> = crate::convert_ref_unchecked(q);
+    fn from_superset_unchecked(q: &UnitQuaternion<T2>) -> Self {
+        let q: UnitQuaternion<T1> = crate::convert_ref_unchecked(q);
         q.to_rotation_matrix()
     }
 }
 
-impl<N1, N2> SubsetOf<UnitDualQuaternion<N2>> for Rotation3<N1>
+impl<T1, T2> SubsetOf<UnitDualQuaternion<T2>> for Rotation3<T1>
 where
-    N1: RealField,
-    N2: RealField + SupersetOf<N1>,
+    T1: RealField,
+    T2: RealField + SupersetOf<T1>,
 {
     #[inline]
-    fn to_superset(&self) -> UnitDualQuaternion<N2> {
-        let q = UnitQuaternion::<N1>::from_rotation_matrix(self);
+    fn to_superset(&self) -> UnitDualQuaternion<T2> {
+        let q = UnitQuaternion::<T1>::from_rotation_matrix(self);
         let dq = UnitDualQuaternion::from_rotation(q);
         dq.to_superset()
     }
 
     #[inline]
-    fn is_in_subset(dq: &UnitDualQuaternion<N2>) -> bool {
-        crate::is_convertible::<_, UnitQuaternion<N1>>(&dq.rotation())
+    fn is_in_subset(dq: &UnitDualQuaternion<T2>) -> bool {
+        crate::is_convertible::<_, UnitQuaternion<T1>>(&dq.rotation())
             && dq.translation().vector.is_zero()
     }
 
     #[inline]
-    fn from_superset_unchecked(dq: &UnitDualQuaternion<N2>) -> Self {
-        let dq: UnitDualQuaternion<N1> = crate::convert_ref_unchecked(dq);
+    fn from_superset_unchecked(dq: &UnitDualQuaternion<T2>) -> Self {
+        let dq: UnitDualQuaternion<T1> = crate::convert_ref_unchecked(dq);
         dq.rotation().to_rotation_matrix()
     }
 }
 
-impl<N1, N2> SubsetOf<UnitComplex<N2>> for Rotation2<N1>
+impl<T1, T2> SubsetOf<UnitComplex<T2>> for Rotation2<T1>
 where
-    N1: RealField,
-    N2: RealField + SupersetOf<N1>,
+    T1: RealField,
+    T2: RealField + SupersetOf<T1>,
 {
     #[inline]
-    fn to_superset(&self) -> UnitComplex<N2> {
-        let q = UnitComplex::<N1>::from_rotation_matrix(self);
+    fn to_superset(&self) -> UnitComplex<T2> {
+        let q = UnitComplex::<T1>::from_rotation_matrix(self);
         q.to_superset()
     }
 
     #[inline]
-    fn is_in_subset(q: &UnitComplex<N2>) -> bool {
-        crate::is_convertible::<_, UnitComplex<N1>>(q)
+    fn is_in_subset(q: &UnitComplex<T2>) -> bool {
+        crate::is_convertible::<_, UnitComplex<T1>>(q)
     }
 
     #[inline]
-    fn from_superset_unchecked(q: &UnitComplex<N2>) -> Self {
-        let q: UnitComplex<N1> = crate::convert_ref_unchecked(q);
+    fn from_superset_unchecked(q: &UnitComplex<T2>) -> Self {
+        let q: UnitComplex<T1> = crate::convert_ref_unchecked(q);
         q.to_rotation_matrix()
     }
 }
 
-impl<N1, N2, D: DimName, R> SubsetOf<Isometry<N2, D, R>> for Rotation<N1, D>
+impl<T1, T2, R, const D: usize> SubsetOf<Isometry<T2, R, D>> for Rotation<T1, D>
 where
-    N1: RealField,
-    N2: RealField + SupersetOf<N1>,
-    R: AbstractRotation<N2, D> + SupersetOf<Self>,
-    DefaultAllocator: Allocator<N1, D, D> + Allocator<N2, D>,
+    T1: RealField,
+    T2: RealField + SupersetOf<T1>,
+    R: AbstractRotation<T2, D> + SupersetOf<Self>,
 {
     #[inline]
-    fn to_superset(&self) -> Isometry<N2, D, R> {
+    fn to_superset(&self) -> Isometry<T2, R, D> {
         Isometry::from_parts(Translation::identity(), crate::convert_ref(self))
     }
 
     #[inline]
-    fn is_in_subset(iso: &Isometry<N2, D, R>) -> bool {
+    fn is_in_subset(iso: &Isometry<T2, R, D>) -> bool {
         iso.translation.vector.is_zero()
     }
 
     #[inline]
-    fn from_superset_unchecked(iso: &Isometry<N2, D, R>) -> Self {
+    fn from_superset_unchecked(iso: &Isometry<T2, R, D>) -> Self {
         crate::convert_ref_unchecked(&iso.rotation)
     }
 }
 
-impl<N1, N2, D: DimName, R> SubsetOf<Similarity<N2, D, R>> for Rotation<N1, D>
+impl<T1, T2, R, const D: usize> SubsetOf<Similarity<T2, R, D>> for Rotation<T1, D>
 where
-    N1: RealField,
-    N2: RealField + SupersetOf<N1>,
-    R: AbstractRotation<N2, D> + SupersetOf<Self>,
-    DefaultAllocator: Allocator<N1, D, D> + Allocator<N2, D>,
+    T1: RealField,
+    T2: RealField + SupersetOf<T1>,
+    R: AbstractRotation<T2, D> + SupersetOf<Self>,
 {
     #[inline]
-    fn to_superset(&self) -> Similarity<N2, D, R> {
-        Similarity::from_parts(Translation::identity(), crate::convert_ref(self), N2::one())
+    fn to_superset(&self) -> Similarity<T2, R, D> {
+        Similarity::from_parts(Translation::identity(), crate::convert_ref(self), T2::one())
     }
 
     #[inline]
-    fn is_in_subset(sim: &Similarity<N2, D, R>) -> bool {
-        sim.isometry.translation.vector.is_zero() && sim.scaling() == N2::one()
+    fn is_in_subset(sim: &Similarity<T2, R, D>) -> bool {
+        sim.isometry.translation.vector.is_zero() && sim.scaling() == T2::one()
     }
 
     #[inline]
-    fn from_superset_unchecked(sim: &Similarity<N2, D, R>) -> Self {
+    fn from_superset_unchecked(sim: &Similarity<T2, R, D>) -> Self {
         crate::convert_ref_unchecked(&sim.isometry.rotation)
     }
 }
 
-impl<N1, N2, D, C> SubsetOf<Transform<N2, D, C>> for Rotation<N1, D>
+impl<T1, T2, C, const D: usize> SubsetOf<Transform<T2, C, D>> for Rotation<T1, D>
 where
-    N1: RealField,
-    N2: RealField + SupersetOf<N1>,
+    T1: RealField,
+    T2: RealField + SupersetOf<T1>,
     C: SuperTCategoryOf<TAffine>,
-    D: DimNameAdd<U1> + DimMin<D, Output = D>, // needed by .is_special_orthogonal()
-    DefaultAllocator: Allocator<N1, D, D>
-        + Allocator<N2, D, D>
-        + Allocator<N1, DimNameSum<D, U1>, DimNameSum<D, U1>>
-        + Allocator<N2, DimNameSum<D, U1>, DimNameSum<D, U1>>
-        + Allocator<(usize, usize), D>,
+    Const<D>: DimNameAdd<U1> + DimMin<Const<D>, Output = Const<D>>, // needed by .is_special_orthogonal()
+    DefaultAllocator: Allocator<T1, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
+        + Allocator<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
+    // + Allocator<(usize, usize), D>,
+    // Allocator<T1, D, D>
+    //     + Allocator<T2, D, D>
 {
     // needed by .is_special_orthogonal()
     #[inline]
-    fn to_superset(&self) -> Transform<N2, D, C> {
+    fn to_superset(&self) -> Transform<T2, C, D> {
         Transform::from_matrix_unchecked(self.to_homogeneous().to_superset())
     }
 
     #[inline]
-    fn is_in_subset(t: &Transform<N2, D, C>) -> bool {
+    fn is_in_subset(t: &Transform<T2, C, D>) -> bool {
         <Self as SubsetOf<_>>::is_in_subset(t.matrix())
     }
 
     #[inline]
-    fn from_superset_unchecked(t: &Transform<N2, D, C>) -> Self {
+    fn from_superset_unchecked(t: &Transform<T2, C, D>) -> Self {
         Self::from_superset_unchecked(t.matrix())
     }
 }
 
-impl<N1, N2, D> SubsetOf<MatrixN<N2, DimNameSum<D, U1>>> for Rotation<N1, D>
+impl<T1, T2, const D: usize>
+    SubsetOf<OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>> for Rotation<T1, D>
 where
-    N1: RealField,
-    N2: RealField + SupersetOf<N1>,
-    D: DimNameAdd<U1> + DimMin<D, Output = D>, // needed by .is_special_orthogonal()
-    DefaultAllocator: Allocator<N1, D, D>
-        + Allocator<N2, D, D>
-        + Allocator<N1, DimNameSum<D, U1>, DimNameSum<D, U1>>
-        + Allocator<N2, DimNameSum<D, U1>, DimNameSum<D, U1>>
-        + Allocator<(usize, usize), D>,
+    T1: RealField,
+    T2: RealField + SupersetOf<T1>,
+    Const<D>: DimNameAdd<U1> + DimMin<Const<D>, Output = Const<D>>, // needed by .is_special_orthogonal()
+    DefaultAllocator: Allocator<T1, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
+        + Allocator<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>, // + Allocator<(usize, usize), D>,
+                                                                             // + Allocator<T1, D, D>
+                                                                             // + Allocator<T2, D, D>
 {
     // needed by .is_special_orthogonal()
     #[inline]
-    fn to_superset(&self) -> MatrixN<N2, DimNameSum<D, U1>> {
+    fn to_superset(&self) -> OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> {
         self.to_homogeneous().to_superset()
     }
 
     #[inline]
-    fn is_in_subset(m: &MatrixN<N2, DimNameSum<D, U1>>) -> bool {
+    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::<U1, D>(D::dim(), 0);
+        let bottom = m.fixed_slice::<1, D>(D, 0);
 
         // Scalar types agree.
-        m.iter().all(|e| SupersetOf::<N1>::is_in_subset(e)) &&
+        m.iter().all(|e| SupersetOf::<T1>::is_in_subset(e)) &&
         // The block part is a rotation.
-        rot.is_special_orthogonal(N2::default_epsilon() * crate::convert(100.0)) &&
+        rot.is_special_orthogonal(T2::default_epsilon() * crate::convert(100.0)) &&
         // The bottom row is (0, 0, ..., 1)
-        bottom.iter().all(|e| e.is_zero()) && m[(D::dim(), D::dim())] == N2::one()
+        bottom.iter().all(|e| e.is_zero()) && m[(D, D)] == T2::one()
     }
 
     #[inline]
-    fn from_superset_unchecked(m: &MatrixN<N2, DimNameSum<D, U1>>) -> Self {
+    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);
         Self::from_matrix_unchecked(crate::convert_unchecked(r.into_owned()))
     }
 }
 
-impl<N: RealField> From<Rotation2<N>> for Matrix3<N> {
+impl<T: RealField> From<Rotation2<T>> for Matrix3<T> {
     #[inline]
-    fn from(q: Rotation2<N>) -> Self {
+    fn from(q: Rotation2<T>) -> Self {
         q.to_homogeneous()
     }
 }
 
-impl<N: RealField> From<Rotation2<N>> for Matrix2<N> {
+impl<T: RealField> From<Rotation2<T>> for Matrix2<T> {
     #[inline]
-    fn from(q: Rotation2<N>) -> Self {
+    fn from(q: Rotation2<T>) -> Self {
         q.into_inner()
     }
 }
 
-impl<N: RealField> From<Rotation3<N>> for Matrix4<N> {
+impl<T: RealField> From<Rotation3<T>> for Matrix4<T> {
     #[inline]
-    fn from(q: Rotation3<N>) -> Self {
+    fn from(q: Rotation3<T>) -> Self {
         q.to_homogeneous()
     }
 }
 
-impl<N: RealField> From<Rotation3<N>> for Matrix3<N> {
+impl<T: RealField> From<Rotation3<T>> for Matrix3<T> {
     #[inline]
-    fn from(q: Rotation3<N>) -> Self {
+    fn from(q: Rotation3<T>) -> Self {
         q.into_inner()
     }
 }
 
-impl<N: Scalar + PrimitiveSimdValue, D: DimName> From<[Rotation<N::Element, D>; 2]>
-    for Rotation<N, D>
+impl<T: Scalar + PrimitiveSimdValue, const D: usize> From<[Rotation<T::Element, D>; 2]>
+    for Rotation<T, D>
 where
-    N: From<[<N as SimdValue>::Element; 2]>,
-    N::Element: Scalar + Copy,
-    DefaultAllocator: Allocator<N, D, D> + Allocator<N::Element, D, D>,
+    T: From<[<T as SimdValue>::Element; 2]>,
+    T::Element: Scalar + Copy,
 {
     #[inline]
-    fn from(arr: [Rotation<N::Element, D>; 2]) -> Self {
-        Self::from_matrix_unchecked(MatrixN::from([
+    fn from(arr: [Rotation<T::Element, D>; 2]) -> Self {
+        Self::from_matrix_unchecked(OMatrix::from([
             arr[0].clone().into_inner(),
             arr[1].clone().into_inner(),
         ]))
     }
 }
 
-impl<N: Scalar + PrimitiveSimdValue, D: DimName> From<[Rotation<N::Element, D>; 4]>
-    for Rotation<N, D>
+impl<T: Scalar + PrimitiveSimdValue, const D: usize> From<[Rotation<T::Element, D>; 4]>
+    for Rotation<T, D>
 where
-    N: From<[<N as SimdValue>::Element; 4]>,
-    N::Element: Scalar + Copy,
-    DefaultAllocator: Allocator<N, D, D> + Allocator<N::Element, D, D>,
+    T: From<[<T as SimdValue>::Element; 4]>,
+    T::Element: Scalar + Copy,
 {
     #[inline]
-    fn from(arr: [Rotation<N::Element, D>; 4]) -> Self {
-        Self::from_matrix_unchecked(MatrixN::from([
+    fn from(arr: [Rotation<T::Element, D>; 4]) -> Self {
+        Self::from_matrix_unchecked(OMatrix::from([
             arr[0].clone().into_inner(),
             arr[1].clone().into_inner(),
             arr[2].clone().into_inner(),
@@ -294,16 +291,15 @@ where
     }
 }
 
-impl<N: Scalar + PrimitiveSimdValue, D: DimName> From<[Rotation<N::Element, D>; 8]>
-    for Rotation<N, D>
+impl<T: Scalar + PrimitiveSimdValue, const D: usize> From<[Rotation<T::Element, D>; 8]>
+    for Rotation<T, D>
 where
-    N: From<[<N as SimdValue>::Element; 8]>,
-    N::Element: Scalar + Copy,
-    DefaultAllocator: Allocator<N, D, D> + Allocator<N::Element, D, D>,
+    T: From<[<T as SimdValue>::Element; 8]>,
+    T::Element: Scalar + Copy,
 {
     #[inline]
-    fn from(arr: [Rotation<N::Element, D>; 8]) -> Self {
-        Self::from_matrix_unchecked(MatrixN::from([
+    fn from(arr: [Rotation<T::Element, D>; 8]) -> Self {
+        Self::from_matrix_unchecked(OMatrix::from([
             arr[0].clone().into_inner(),
             arr[1].clone().into_inner(),
             arr[2].clone().into_inner(),
@@ -316,16 +312,15 @@ where
     }
 }
 
-impl<N: Scalar + PrimitiveSimdValue, D: DimName> From<[Rotation<N::Element, D>; 16]>
-    for Rotation<N, D>
+impl<T: Scalar + PrimitiveSimdValue, const D: usize> From<[Rotation<T::Element, D>; 16]>
+    for Rotation<T, D>
 where
-    N: From<[<N as SimdValue>::Element; 16]>,
-    N::Element: Scalar + Copy,
-    DefaultAllocator: Allocator<N, D, D> + Allocator<N::Element, D, D>,
+    T: From<[<T as SimdValue>::Element; 16]>,
+    T::Element: Scalar + Copy,
 {
     #[inline]
-    fn from(arr: [Rotation<N::Element, D>; 16]) -> Self {
-        Self::from_matrix_unchecked(MatrixN::from([
+    fn from(arr: [Rotation<T::Element, D>; 16]) -> Self {
+        Self::from_matrix_unchecked(OMatrix::from([
             arr[0].clone().into_inner(),
             arr[1].clone().into_inner(),
             arr[2].clone().into_inner(),
diff --git a/src/geometry/rotation_interpolation.rs b/src/geometry/rotation_interpolation.rs
index 5f861428..bf1c9094 100644
--- a/src/geometry/rotation_interpolation.rs
+++ b/src/geometry/rotation_interpolation.rs
@@ -1,7 +1,7 @@
 use crate::{RealField, Rotation2, Rotation3, SimdRealField, UnitComplex, UnitQuaternion};
 
 /// # Interpolation
-impl<N: SimdRealField> Rotation2<N> {
+impl<T: SimdRealField> Rotation2<T> {
     /// Spherical linear interpolation between two rotation matrices.
     ///
     /// # Examples:
@@ -18,9 +18,9 @@ impl<N: SimdRealField> Rotation2<N> {
     /// assert_relative_eq!(rot.angle(), std::f32::consts::FRAC_PI_2);
     /// ```
     #[inline]
-    pub fn slerp(&self, other: &Self, t: N) -> Self
+    pub fn slerp(&self, other: &Self, t: T) -> Self
     where
-        N::Element: SimdRealField,
+        T::Element: SimdRealField,
     {
         let c1 = UnitComplex::from(*self);
         let c2 = UnitComplex::from(*other);
@@ -28,7 +28,7 @@ impl<N: SimdRealField> Rotation2<N> {
     }
 }
 
-impl<N: SimdRealField> Rotation3<N> {
+impl<T: SimdRealField> Rotation3<T> {
     /// Spherical linear interpolation between two rotation matrices.
     ///
     /// Panics if the angle between both rotations is 180 degrees (in which case the interpolation
@@ -47,9 +47,9 @@ impl<N: SimdRealField> Rotation3<N> {
     /// assert_eq!(q.euler_angles(), (std::f32::consts::FRAC_PI_2, 0.0, 0.0));
     /// ```
     #[inline]
-    pub fn slerp(&self, other: &Self, t: N) -> Self
+    pub fn slerp(&self, other: &Self, t: T) -> Self
     where
-        N: RealField,
+        T: RealField,
     {
         let q1 = UnitQuaternion::from(*self);
         let q2 = UnitQuaternion::from(*other);
@@ -67,9 +67,9 @@ impl<N: SimdRealField> Rotation3<N> {
     /// * `epsilon`: the value below which the sinus of the angle separating both rotations
     /// must be to return `None`.
     #[inline]
-    pub fn try_slerp(&self, other: &Self, t: N, epsilon: N) -> Option<Self>
+    pub fn try_slerp(&self, other: &Self, t: T, epsilon: T) -> Option<Self>
     where
-        N: RealField,
+        T: RealField,
     {
         let q1 = Rotation3::from(*self);
         let q2 = Rotation3::from(*other);
diff --git a/src/geometry/rotation_ops.rs b/src/geometry/rotation_ops.rs
index ae66c02e..863acd39 100644
--- a/src/geometry/rotation_ops.rs
+++ b/src/geometry/rotation_ops.rs
@@ -24,20 +24,19 @@ use simba::scalar::{ClosedAdd, ClosedMul};
 
 use crate::base::allocator::Allocator;
 use crate::base::constraint::{AreMultipliable, ShapeConstraint};
-use crate::base::dimension::{Dim, DimName, U1};
+use crate::base::dimension::{Dim, U1};
 use crate::base::storage::Storage;
-use crate::base::{DefaultAllocator, Matrix, MatrixMN, Scalar, Unit, Vector, VectorN};
+use crate::base::{
+    Const, DefaultAllocator, Matrix, OMatrix, SMatrix, SVector, Scalar, Unit, Vector,
+};
 
 use crate::geometry::{Point, Rotation};
 
-impl<N: Scalar, D: DimName> Index<(usize, usize)> for Rotation<N, D>
-where
-    DefaultAllocator: Allocator<N, D, D>,
-{
-    type Output = N;
+impl<T: Scalar, const D: usize> Index<(usize, usize)> for Rotation<T, D> {
+    type Output = T;
 
     #[inline]
-    fn index(&self, row_col: (usize, usize)) -> &N {
+    fn index(&self, row_col: (usize, usize)) -> &T {
         self.matrix().index(row_col)
     }
 }
@@ -45,8 +44,11 @@ where
 // Rotation × Rotation
 md_impl_all!(
     Mul, mul;
-    (D, D), (D, D) for D: DimName;
-    self: Rotation<N, D>, right: Rotation<N, D>, Output = Rotation<N, D>;
+    (Const<D>, Const<D>), (Const<D>, Const<D>)
+    const D;
+    for;
+    where;
+    self: Rotation<T, D>, right: Rotation<T, D>, Output = Rotation<T, D>;
     [val val] => Rotation::from_matrix_unchecked(self.into_inner() * right.into_inner());
     [ref val] => Rotation::from_matrix_unchecked(self.matrix() * right.into_inner());
     [val ref] => Rotation::from_matrix_unchecked(self.into_inner() * right.matrix());
@@ -57,8 +59,11 @@ md_impl_all!(
 // TODO: instead of calling inverse explicitly, could we just add a `mul_tr` or `mul_inv` method?
 md_impl_all!(
     Div, div;
-    (D, D), (D, D) for D: DimName;
-    self: Rotation<N, D>, right: Rotation<N, D>, Output = Rotation<N, D>;
+    (Const<D>, Const<D>), (Const<D>, Const<D>)
+    const D;
+    for;
+    where;
+    self: Rotation<T, D>, right: Rotation<T, D>, Output = Rotation<T, D>;
     [val val] => #[allow(clippy::suspicious_arithmetic_impl)] { self * right.inverse() };
     [ref val] => #[allow(clippy::suspicious_arithmetic_impl)] { self * right.inverse() };
     [val ref] => #[allow(clippy::suspicious_arithmetic_impl)] { self * right.inverse() };
@@ -68,10 +73,13 @@ md_impl_all!(
 // Rotation × Matrix
 md_impl_all!(
     Mul, mul;
-    (D1, D1), (R2, C2) for D1: DimName, R2: Dim, C2: Dim, SB: Storage<N, R2, C2>
-    where DefaultAllocator: Allocator<N, D1, C2>
-    where ShapeConstraint: AreMultipliable<D1, D1, R2, C2>;
-    self: Rotation<N, D1>, right: Matrix<N, R2, C2, SB>, Output = MatrixMN<N, D1, C2>;
+    (Const<D1>, Const<D1>), (R2, C2)
+    const D1;
+    for R2, C2, SB;
+    where R2: Dim, C2: Dim, SB: Storage<T, R2, C2>,
+          DefaultAllocator: Allocator<T, Const<D1>, C2>,
+          ShapeConstraint: AreMultipliable<Const<D1>, Const<D1>, R2, C2>;
+    self: Rotation<T, D1>, right: Matrix<T, R2, C2, SB>, Output = OMatrix<T, Const<D1>, C2>;
     [val val] => self.into_inner() * right;
     [ref val] => self.matrix() * right;
     [val ref] => self.into_inner() * right;
@@ -81,10 +89,13 @@ md_impl_all!(
 // Matrix × Rotation
 md_impl_all!(
     Mul, mul;
-    (R1, C1), (D2, D2) for R1: Dim, C1: Dim, D2: DimName, SA: Storage<N, R1, C1>
-    where DefaultAllocator: Allocator<N, R1, D2>
-    where ShapeConstraint:  AreMultipliable<R1, C1, D2, D2>;
-    self: Matrix<N, R1, C1, SA>, right: Rotation<N, D2>, Output = MatrixMN<N, R1, D2>;
+    (R1, C1), (Const<D2>, Const<D2>)
+    const D2;
+    for R1, C1, SA;
+    where R1: Dim, C1: Dim, SA: Storage<T, R1, C1>,
+          DefaultAllocator: Allocator<T, R1, Const<D2>>,
+          ShapeConstraint:  AreMultipliable<R1, C1, Const<D2>, Const<D2>>;
+    self: Matrix<T, R1, C1, SA>, right: Rotation<T, D2>, Output = OMatrix<T, R1, Const<D2>>;
     [val val] => self * right.into_inner();
     [ref val] => self * right.into_inner();
     [val ref] => self * right.matrix();
@@ -94,10 +105,13 @@ md_impl_all!(
 // Matrix ÷ Rotation
 md_impl_all!(
     Div, div;
-    (R1, C1), (D2, D2) for R1: Dim, C1: Dim, D2: DimName, SA: Storage<N, R1, C1>
-    where DefaultAllocator: Allocator<N, R1, D2>
-    where ShapeConstraint: AreMultipliable<R1, C1, D2, D2>;
-    self: Matrix<N, R1, C1, SA>, right: Rotation<N, D2>, Output = MatrixMN<N, R1, D2>;
+    (R1, C1), (Const<D2>, Const<D2>)
+    const D2;
+    for R1, C1, SA;
+    where R1: Dim, C1: Dim, SA: Storage<T, R1, C1>,
+          DefaultAllocator: Allocator<T, R1, Const<D2>>,
+          ShapeConstraint: AreMultipliable<R1, C1, Const<D2>, Const<D2>>;
+    self: Matrix<T, R1, C1, SA>, right: Rotation<T, D2>, Output = OMatrix<T, R1, Const<D2>>;
     [val val] => #[allow(clippy::suspicious_arithmetic_impl)] { self * right.inverse() };
     [ref val] => #[allow(clippy::suspicious_arithmetic_impl)] { self * right.inverse() };
     [val ref] => #[allow(clippy::suspicious_arithmetic_impl)] { self * right.inverse() };
@@ -109,10 +123,11 @@ md_impl_all!(
 // behavior?
 md_impl_all!(
     Mul, mul;
-    (D, D), (D, U1) for D: DimName
-    where DefaultAllocator: Allocator<N, D>
-    where ShapeConstraint:  AreMultipliable<D, D, D, U1>;
-    self: Rotation<N, D>, right: Point<N, D>, Output = Point<N, D>;
+    (Const<D>, Const<D>), (Const<D>, U1)
+    const D;
+    for;
+    where ShapeConstraint:  AreMultipliable<Const<D>, Const<D>, Const<D>, U1>;
+    self: Rotation<T, D>, right: Point<T, D>, Output = Point<T, D>;
     [val val] => self.into_inner() * right;
     [ref val] => self.matrix() * right;
     [val ref] => self.into_inner() * right;
@@ -122,10 +137,12 @@ md_impl_all!(
 // Rotation × Unit<Vector>
 md_impl_all!(
     Mul, mul;
-    (D, D), (D, U1) for D: DimName, S: Storage<N, D>
-    where DefaultAllocator: Allocator<N, D>
-    where ShapeConstraint:  AreMultipliable<D, D, D, U1>;
-    self: Rotation<N, D>, right: Unit<Vector<N, D, S>>, Output = Unit<VectorN<N, D>>;
+    (Const<D>, Const<D>), (Const<D>, U1)
+    const D;
+    for S;
+    where S: Storage<T, Const<D>>,
+          ShapeConstraint: AreMultipliable<Const<D>, Const<D>, Const<D>, U1>;
+    self: Rotation<T, D>, right: Unit<Vector<T, Const<D>, S>>, Output = Unit<SVector<T, D>>;
     [val val] => Unit::new_unchecked(self.into_inner() * right.into_inner());
     [ref val] => Unit::new_unchecked(self.matrix() * right.into_inner());
     [val ref] => Unit::new_unchecked(self.into_inner() * right.as_ref());
@@ -137,16 +154,18 @@ md_impl_all!(
 
 md_assign_impl_all!(
     MulAssign, mul_assign;
-    (D, D), (D, D) for D: DimName;
-    self: Rotation<N, D>, right: Rotation<N, D>;
+    (Const<D>, Const<D>), (Const<D>, Const<D>)
+    const D; for; where;
+    self: Rotation<T, D>, right: Rotation<T, D>;
     [val] => self.matrix_mut_unchecked().mul_assign(right.into_inner());
     [ref] => self.matrix_mut_unchecked().mul_assign(right.matrix());
 );
 
 md_assign_impl_all!(
     DivAssign, div_assign;
-    (D, D), (D, D) for D: DimName;
-    self: Rotation<N, D>, right: Rotation<N, D>;
+    (Const<D>, Const<D>), (Const<D>, Const<D>)
+    const D; for; where;
+    self: Rotation<T, D>, right: Rotation<T, D>;
     [val] => self.matrix_mut_unchecked().mul_assign(right.inverse().into_inner());
     [ref] => self.matrix_mut_unchecked().mul_assign(right.inverse().matrix());
 );
@@ -159,16 +178,18 @@ md_assign_impl_all!(
 
 md_assign_impl_all!(
     MulAssign, mul_assign;
-    (R1, C1), (C1, C1) for R1: DimName, C1: DimName;
-    self: MatrixMN<N, R1, C1>, right: Rotation<N, C1>;
+    (Const<R1>, Const<C1>), (Const<C1>, Const<C1>)
+    const R1, C1; for; where;
+    self: SMatrix<T, R1, C1>, right: Rotation<T, C1>;
     [val] => self.mul_assign(right.into_inner());
     [ref] => self.mul_assign(right.matrix());
 );
 
 md_assign_impl_all!(
     DivAssign, div_assign;
-    (R1, C1), (C1, C1) for R1: DimName, C1: DimName;
-    self: MatrixMN<N, R1, C1>, right: Rotation<N, C1>;
+    (Const<R1>, Const<C1>), (Const<C1>, Const<C1>)
+    const R1, C1; for; where;
+    self: SMatrix<T, R1, C1>, right: Rotation<T, C1>;
     [val] => self.mul_assign(right.inverse().into_inner());
     [ref] => self.mul_assign(right.inverse().matrix());
 );
diff --git a/src/geometry/rotation_simba.rs b/src/geometry/rotation_simba.rs
index cb064a81..39b60aa3 100755
--- a/src/geometry/rotation_simba.rs
+++ b/src/geometry/rotation_simba.rs
@@ -1,29 +1,25 @@
 use simba::simd::SimdValue;
 
-use crate::base::allocator::Allocator;
-use crate::base::dimension::DimName;
-use crate::base::{DefaultAllocator, MatrixN, Scalar};
+use crate::base::{OMatrix, Scalar};
 
 use crate::geometry::Rotation;
 
-impl<N, D> SimdValue for Rotation<N, D>
+impl<T, const D: usize> SimdValue for Rotation<T, D>
 where
-    N: Scalar + SimdValue,
-    D: DimName,
-    N::Element: Scalar,
-    DefaultAllocator: Allocator<N, D, D> + Allocator<N::Element, D, D>,
+    T: Scalar + SimdValue,
+    T::Element: Scalar,
 {
-    type Element = Rotation<N::Element, D>;
-    type SimdBool = N::SimdBool;
+    type Element = Rotation<T::Element, D>;
+    type SimdBool = T::SimdBool;
 
     #[inline]
     fn lanes() -> usize {
-        N::lanes()
+        T::lanes()
     }
 
     #[inline]
     fn splat(val: Self::Element) -> Self {
-        Rotation::from_matrix_unchecked(MatrixN::splat(val.into_inner()))
+        Rotation::from_matrix_unchecked(OMatrix::splat(val.into_inner()))
     }
 
     #[inline]
diff --git a/src/geometry/rotation_specialization.rs b/src/geometry/rotation_specialization.rs
index fe431804..bb71f4f8 100644
--- a/src/geometry/rotation_specialization.rs
+++ b/src/geometry/rotation_specialization.rs
@@ -7,7 +7,7 @@ use num::Zero;
 
 #[cfg(feature = "rand-no-std")]
 use rand::{
-    distributions::{Distribution, OpenClosed01, Standard, Uniform, uniform::SampleUniform},
+    distributions::{uniform::SampleUniform, Distribution, OpenClosed01, Standard, Uniform},
     Rng,
 };
 
@@ -17,7 +17,7 @@ use std::ops::Neg;
 
 use crate::base::dimension::{U1, U2, U3};
 use crate::base::storage::Storage;
-use crate::base::{Matrix2, Matrix3, MatrixN, Unit, Vector, Vector1, Vector2, Vector3, VectorN};
+use crate::base::{Matrix2, Matrix3, SMatrix, SVector, Unit, Vector, Vector1, Vector2, Vector3};
 
 use crate::geometry::{Rotation2, Rotation3, UnitComplex, UnitQuaternion};
 
@@ -27,7 +27,7 @@ use crate::geometry::{Rotation2, Rotation3, UnitComplex, UnitQuaternion};
  *
  */
 /// # Construction from a 2D rotation angle
-impl<N: SimdRealField> Rotation2<N> {
+impl<T: SimdRealField> Rotation2<T> {
     /// Builds a 2 dimensional rotation matrix from an angle in radian.
     ///
     /// # Example
@@ -40,7 +40,7 @@ impl<N: SimdRealField> Rotation2<N> {
     ///
     /// assert_relative_eq!(rot * Point2::new(3.0, 4.0), Point2::new(-4.0, 3.0));
     /// ```
-    pub fn new(angle: N) -> Self {
+    pub fn new(angle: T) -> Self {
         let (sia, coa) = angle.simd_sin_cos();
         Self::from_matrix_unchecked(Matrix2::new(coa, -sia, sia, coa))
     }
@@ -51,20 +51,20 @@ impl<N: SimdRealField> Rotation2<N> {
     /// This is generally used in the context of generic programming. Using
     /// the `::new(angle)` method instead is more common.
     #[inline]
-    pub fn from_scaled_axis<SB: Storage<N, U1>>(axisangle: Vector<N, U1, SB>) -> Self {
+    pub fn from_scaled_axis<SB: Storage<T, U1>>(axisangle: Vector<T, U1, SB>) -> Self {
         Self::new(axisangle[0])
     }
 }
 
 /// # Construction from an existing 2D matrix or rotations
-impl<N: SimdRealField> Rotation2<N> {
+impl<T: SimdRealField> Rotation2<T> {
     /// Builds a rotation from a basis assumed to be orthonormal.
     ///
     /// In order to get a valid unit-quaternion, the input must be an
     /// orthonormal basis, i.e., all vectors are normalized, and the are
     /// all orthogonal to each other. These invariants are not checked
     /// by this method.
-    pub fn from_basis_unchecked(basis: &[Vector2<N>; 2]) -> Self {
+    pub fn from_basis_unchecked(basis: &[Vector2<T>; 2]) -> Self {
         let mat = Matrix2::from_columns(&basis[..]);
         Self::from_matrix_unchecked(mat)
     }
@@ -74,11 +74,11 @@ impl<N: SimdRealField> Rotation2<N> {
     /// This is an iterative method. See `.from_matrix_eps` to provide mover
     /// convergence parameters and starting solution.
     /// This implements "A Robust Method to Extract the Rotational Part of Deformations" by Müller et al.
-    pub fn from_matrix(m: &Matrix2<N>) -> Self
+    pub fn from_matrix(m: &Matrix2<T>) -> Self
     where
-        N: RealField,
+        T: RealField,
     {
-        Self::from_matrix_eps(m, N::default_epsilon(), 0, Self::identity())
+        Self::from_matrix_eps(m, T::default_epsilon(), 0, Self::identity())
     }
 
     /// Builds a rotation matrix by extracting the rotation part of the given transformation `m`.
@@ -93,9 +93,9 @@ impl<N: SimdRealField> Rotation2<N> {
     /// * `guess`: an estimate of the solution. Convergence will be significantly faster if an initial solution close
     ///           to the actual solution is provided. Can be set to `Rotation2::identity()` if no other
     ///           guesses come to mind.
-    pub fn from_matrix_eps(m: &Matrix2<N>, eps: N, mut max_iter: usize, guess: Self) -> Self
+    pub fn from_matrix_eps(m: &Matrix2<T>, eps: T, mut max_iter: usize, guess: Self) -> Self
     where
-        N: RealField,
+        T: RealField,
     {
         if max_iter == 0 {
             max_iter = usize::max_value();
@@ -107,7 +107,7 @@ impl<N: SimdRealField> Rotation2<N> {
             let axis = rot.column(0).perp(&m.column(0)) + rot.column(1).perp(&m.column(1));
             let denom = rot.column(0).dot(&m.column(0)) + rot.column(1).dot(&m.column(1));
 
-            let angle = axis / (denom.abs() + N::default_epsilon());
+            let angle = axis / (denom.abs() + T::default_epsilon());
             if angle.abs() > eps {
                 rot = Self::new(angle) * rot;
             } else {
@@ -133,11 +133,11 @@ impl<N: SimdRealField> Rotation2<N> {
     /// assert_relative_eq!(rot.inverse() * b, a);
     /// ```
     #[inline]
-    pub fn rotation_between<SB, SC>(a: &Vector<N, U2, SB>, b: &Vector<N, U2, SC>) -> Self
+    pub fn rotation_between<SB, SC>(a: &Vector<T, U2, SB>, b: &Vector<T, U2, SC>) -> Self
     where
-        N: RealField,
-        SB: Storage<N, U2>,
-        SC: Storage<N, U2>,
+        T: RealField,
+        SB: Storage<T, U2>,
+        SC: Storage<T, U2>,
     {
         crate::convert(UnitComplex::rotation_between(a, b).to_rotation_matrix())
     }
@@ -158,14 +158,14 @@ impl<N: SimdRealField> Rotation2<N> {
     /// ```
     #[inline]
     pub fn scaled_rotation_between<SB, SC>(
-        a: &Vector<N, U2, SB>,
-        b: &Vector<N, U2, SC>,
-        s: N,
+        a: &Vector<T, U2, SB>,
+        b: &Vector<T, U2, SC>,
+        s: T,
     ) -> Self
     where
-        N: RealField,
-        SB: Storage<N, U2>,
-        SC: Storage<N, U2>,
+        T: RealField,
+        SB: Storage<T, U2>,
+        SC: Storage<T, U2>,
     {
         crate::convert(UnitComplex::scaled_rotation_between(a, b, s).to_rotation_matrix())
     }
@@ -195,12 +195,12 @@ impl<N: SimdRealField> Rotation2<N> {
     #[inline]
     pub fn renormalize(&mut self)
     where
-        N: RealField,
+        T: RealField,
     {
         let mut c = UnitComplex::from(*self);
         let _ = c.renormalize();
 
-        *self = Self::from_matrix_eps(self.matrix(), N::default_epsilon(), 0, c.into())
+        *self = Self::from_matrix_eps(self.matrix(), T::default_epsilon(), 0, c.into())
     }
 
     /// Raise the quaternion to a given floating power, i.e., returns the rotation with the angle
@@ -215,13 +215,13 @@ impl<N: SimdRealField> Rotation2<N> {
     /// assert_relative_eq!(pow.angle(), 2.0 * 0.78);
     /// ```
     #[inline]
-    pub fn powf(&self, n: N) -> Self {
+    pub fn powf(&self, n: T) -> Self {
         Self::new(self.angle() * n)
     }
 }
 
 /// # 2D angle extraction
-impl<N: SimdRealField> Rotation2<N> {
+impl<T: SimdRealField> Rotation2<T> {
     /// The rotation angle.
     ///
     /// # Example
@@ -232,7 +232,7 @@ impl<N: SimdRealField> Rotation2<N> {
     /// assert_relative_eq!(rot.angle(), 1.78);
     /// ```
     #[inline]
-    pub fn angle(&self) -> N {
+    pub fn angle(&self) -> T {
         self.matrix()[(1, 0)].simd_atan2(self.matrix()[(0, 0)])
     }
 
@@ -247,7 +247,7 @@ impl<N: SimdRealField> Rotation2<N> {
     /// assert_relative_eq!(rot1.angle_to(&rot2), 1.6);
     /// ```
     #[inline]
-    pub fn angle_to(&self, other: &Self) -> N {
+    pub fn angle_to(&self, other: &Self) -> T {
         self.rotation_to(other).angle()
     }
 
@@ -256,34 +256,34 @@ impl<N: SimdRealField> Rotation2<N> {
     /// This is generally used in the context of generic programming. Using
     /// the `.angle()` method instead is more common.
     #[inline]
-    pub fn scaled_axis(&self) -> VectorN<N, U1> {
+    pub fn scaled_axis(&self) -> SVector<T, 1> {
         Vector1::new(self.angle())
     }
 }
 
 #[cfg(feature = "rand-no-std")]
-impl<N: SimdRealField> Distribution<Rotation2<N>> for Standard
+impl<T: SimdRealField> Distribution<Rotation2<T>> for Standard
 where
-    N::Element: SimdRealField,
-    N: SampleUniform,
+    T::Element: SimdRealField,
+    T: SampleUniform,
 {
     /// Generate a uniformly distributed random rotation.
     #[inline]
-    fn sample<'a, R: Rng + ?Sized>(&self, rng: &'a mut R) -> Rotation2<N> {
-        let twopi = Uniform::new(N::zero(), N::simd_two_pi());
+    fn sample<'a, R: Rng + ?Sized>(&self, rng: &'a mut R) -> Rotation2<T> {
+        let twopi = Uniform::new(T::zero(), T::simd_two_pi());
         Rotation2::new(rng.sample(twopi))
     }
 }
 
 #[cfg(feature = "arbitrary")]
-impl<N: SimdRealField + Arbitrary> Arbitrary for Rotation2<N>
+impl<T: SimdRealField + Arbitrary> Arbitrary for Rotation2<T>
 where
-    N::Element: SimdRealField,
-    Owned<N, U2, U2>: Send,
+    T::Element: SimdRealField,
+    Owned<T, U2, U2>: Send,
 {
     #[inline]
     fn arbitrary(g: &mut Gen) -> Self {
-        Self::new(N::arbitrary(g))
+        Self::new(T::arbitrary(g))
     }
 }
 
@@ -293,9 +293,9 @@ where
  *
  */
 /// # Construction from a 3D axis and/or angles
-impl<N: SimdRealField> Rotation3<N>
+impl<T: SimdRealField> Rotation3<T>
 where
-    N::Element: SimdRealField,
+    T::Element: SimdRealField,
 {
     /// Builds a 3 dimensional rotation matrix from an axis and an angle.
     ///
@@ -320,7 +320,7 @@ where
     /// // A zero vector yields an identity.
     /// assert_eq!(Rotation3::new(Vector3::<f32>::zeros()), Rotation3::identity());
     /// ```
-    pub fn new<SB: Storage<N, U3>>(axisangle: Vector<N, U3, SB>) -> Self {
+    pub fn new<SB: Storage<T, U3>>(axisangle: Vector<T, U3, SB>) -> Self {
         let axisangle = axisangle.into_owned();
         let (axis, angle) = Unit::new_and_get(axisangle);
         Self::from_axis_angle(&axis, angle)
@@ -347,7 +347,7 @@ where
     /// // A zero vector yields an identity.
     /// assert_eq!(Rotation3::from_scaled_axis(Vector3::<f32>::zeros()), Rotation3::identity());
     /// ```
-    pub fn from_scaled_axis<SB: Storage<N, U3>>(axisangle: Vector<N, U3, SB>) -> Self {
+    pub fn from_scaled_axis<SB: Storage<T, U3>>(axisangle: Vector<T, U3, SB>) -> Self {
         Self::new(axisangle)
     }
 
@@ -373,11 +373,11 @@ where
     /// // A zero vector yields an identity.
     /// assert_eq!(Rotation3::from_scaled_axis(Vector3::<f32>::zeros()), Rotation3::identity());
     /// ```
-    pub fn from_axis_angle<SB>(axis: &Unit<Vector<N, U3, SB>>, angle: N) -> Self
+    pub fn from_axis_angle<SB>(axis: &Unit<Vector<T, U3, SB>>, angle: T) -> Self
     where
-        SB: Storage<N, U3>,
+        SB: Storage<T, U3>,
     {
-        angle.simd_ne(N::zero()).if_else(
+        angle.simd_ne(T::zero()).if_else(
             || {
                 let ux = axis.as_ref()[0];
                 let uy = axis.as_ref()[1];
@@ -386,18 +386,18 @@ where
                 let sqy = uy * uy;
                 let sqz = uz * uz;
                 let (sin, cos) = angle.simd_sin_cos();
-                let one_m_cos = N::one() - cos;
+                let one_m_cos = T::one() - cos;
 
-                Self::from_matrix_unchecked(MatrixN::<N, U3>::new(
-                    sqx + (N::one() - sqx) * cos,
+                Self::from_matrix_unchecked(SMatrix::<T, 3, 3>::new(
+                    sqx + (T::one() - sqx) * cos,
                     ux * uy * one_m_cos - uz * sin,
                     ux * uz * one_m_cos + uy * sin,
                     ux * uy * one_m_cos + uz * sin,
-                    sqy + (N::one() - sqy) * cos,
+                    sqy + (T::one() - sqy) * cos,
                     uy * uz * one_m_cos - ux * sin,
                     ux * uz * one_m_cos - uy * sin,
                     uy * uz * one_m_cos + ux * sin,
-                    sqz + (N::one() - sqz) * cos,
+                    sqz + (T::one() - sqz) * cos,
                 ))
             },
             Self::identity,
@@ -418,12 +418,12 @@ where
     /// assert_relative_eq!(euler.1, 0.2, epsilon = 1.0e-6);
     /// assert_relative_eq!(euler.2, 0.3, epsilon = 1.0e-6);
     /// ```
-    pub fn from_euler_angles(roll: N, pitch: N, yaw: N) -> Self {
+    pub fn from_euler_angles(roll: T, pitch: T, yaw: T) -> Self {
         let (sr, cr) = roll.simd_sin_cos();
         let (sp, cp) = pitch.simd_sin_cos();
         let (sy, cy) = yaw.simd_sin_cos();
 
-        Self::from_matrix_unchecked(MatrixN::<N, U3>::new(
+        Self::from_matrix_unchecked(SMatrix::<T, 3, 3>::new(
             cy * cp,
             cy * sp * sr - sy * cr,
             cy * sp * cr + sy * sr,
@@ -438,9 +438,9 @@ where
 }
 
 /// # Construction from a 3D eye position and target point
-impl<N: SimdRealField> Rotation3<N>
+impl<T: SimdRealField> Rotation3<T>
 where
-    N::Element: SimdRealField,
+    T::Element: SimdRealField,
 {
     /// Creates a rotation that corresponds to the local frame of an observer standing at the
     /// origin and looking toward `dir`.
@@ -464,26 +464,26 @@ where
     /// assert_relative_eq!(rot * Vector3::z(), dir.normalize());
     /// ```
     #[inline]
-    pub fn face_towards<SB, SC>(dir: &Vector<N, U3, SB>, up: &Vector<N, U3, SC>) -> Self
+    pub fn face_towards<SB, SC>(dir: &Vector<T, U3, SB>, up: &Vector<T, U3, SC>) -> Self
     where
-        SB: Storage<N, U3>,
-        SC: Storage<N, U3>,
+        SB: Storage<T, U3>,
+        SC: Storage<T, U3>,
     {
         let zaxis = dir.normalize();
         let xaxis = up.cross(&zaxis).normalize();
         let yaxis = zaxis.cross(&xaxis).normalize();
 
-        Self::from_matrix_unchecked(MatrixN::<N, U3>::new(
+        Self::from_matrix_unchecked(SMatrix::<T, 3, 3>::new(
             xaxis.x, yaxis.x, zaxis.x, xaxis.y, yaxis.y, zaxis.y, xaxis.z, yaxis.z, zaxis.z,
         ))
     }
 
     /// Deprecated: Use [Rotation3::face_towards] instead.
     #[deprecated(note = "renamed to `face_towards`")]
-    pub fn new_observer_frames<SB, SC>(dir: &Vector<N, U3, SB>, up: &Vector<N, U3, SC>) -> Self
+    pub fn new_observer_frames<SB, SC>(dir: &Vector<T, U3, SB>, up: &Vector<T, U3, SC>) -> Self
     where
-        SB: Storage<N, U3>,
-        SC: Storage<N, U3>,
+        SB: Storage<T, U3>,
+        SC: Storage<T, U3>,
     {
         Self::face_towards(dir, up)
     }
@@ -511,10 +511,10 @@ where
     /// assert_relative_eq!(rot * dir.normalize(), -Vector3::z());
     /// ```
     #[inline]
-    pub fn look_at_rh<SB, SC>(dir: &Vector<N, U3, SB>, up: &Vector<N, U3, SC>) -> Self
+    pub fn look_at_rh<SB, SC>(dir: &Vector<T, U3, SB>, up: &Vector<T, U3, SC>) -> Self
     where
-        SB: Storage<N, U3>,
-        SC: Storage<N, U3>,
+        SB: Storage<T, U3>,
+        SC: Storage<T, U3>,
     {
         Self::face_towards(&dir.neg(), up).inverse()
     }
@@ -542,19 +542,19 @@ where
     /// assert_relative_eq!(rot * dir.normalize(), Vector3::z());
     /// ```
     #[inline]
-    pub fn look_at_lh<SB, SC>(dir: &Vector<N, U3, SB>, up: &Vector<N, U3, SC>) -> Self
+    pub fn look_at_lh<SB, SC>(dir: &Vector<T, U3, SB>, up: &Vector<T, U3, SC>) -> Self
     where
-        SB: Storage<N, U3>,
-        SC: Storage<N, U3>,
+        SB: Storage<T, U3>,
+        SC: Storage<T, U3>,
     {
         Self::face_towards(dir, up).inverse()
     }
 }
 
 /// # Construction from an existing 3D matrix or rotations
-impl<N: SimdRealField> Rotation3<N>
+impl<T: SimdRealField> Rotation3<T>
 where
-    N::Element: SimdRealField,
+    T::Element: SimdRealField,
 {
     /// The rotation matrix required to align `a` and `b` but with its angle.
     ///
@@ -571,13 +571,13 @@ where
     /// assert_relative_eq!(rot.inverse() * b, a, epsilon = 1.0e-6);
     /// ```
     #[inline]
-    pub fn rotation_between<SB, SC>(a: &Vector<N, U3, SB>, b: &Vector<N, U3, SC>) -> Option<Self>
+    pub fn rotation_between<SB, SC>(a: &Vector<T, U3, SB>, b: &Vector<T, U3, SC>) -> Option<Self>
     where
-        N: RealField,
-        SB: Storage<N, U3>,
-        SC: Storage<N, U3>,
+        T: RealField,
+        SB: Storage<T, U3>,
+        SC: Storage<T, U3>,
     {
-        Self::scaled_rotation_between(a, b, N::one())
+        Self::scaled_rotation_between(a, b, T::one())
     }
 
     /// The smallest rotation needed to make `a` and `b` collinear and point toward the same
@@ -596,25 +596,25 @@ where
     /// ```
     #[inline]
     pub fn scaled_rotation_between<SB, SC>(
-        a: &Vector<N, U3, SB>,
-        b: &Vector<N, U3, SC>,
-        n: N,
+        a: &Vector<T, U3, SB>,
+        b: &Vector<T, U3, SC>,
+        n: T,
     ) -> Option<Self>
     where
-        N: RealField,
-        SB: Storage<N, U3>,
-        SC: Storage<N, U3>,
+        T: RealField,
+        SB: Storage<T, U3>,
+        SC: Storage<T, U3>,
     {
         // TODO: code duplication with Rotation.
-        if let (Some(na), Some(nb)) = (a.try_normalize(N::zero()), b.try_normalize(N::zero())) {
+        if let (Some(na), Some(nb)) = (a.try_normalize(T::zero()), b.try_normalize(T::zero())) {
             let c = na.cross(&nb);
 
-            if let Some(axis) = Unit::try_new(c, N::default_epsilon()) {
+            if let Some(axis) = Unit::try_new(c, T::default_epsilon()) {
                 return Some(Self::from_axis_angle(&axis, na.dot(&nb).acos() * n));
             }
 
             // Zero or PI.
-            if na.dot(&nb) < N::zero() {
+            if na.dot(&nb) < T::zero() {
                 // PI
                 //
                 // The rotation axis is undefined but the angle not zero. This is not a
@@ -659,14 +659,14 @@ where
     /// assert_eq!(pow.angle(), 2.4);
     /// ```
     #[inline]
-    pub fn powf(&self, n: N) -> Self
+    pub fn powf(&self, n: T) -> Self
     where
-        N: RealField,
+        T: RealField,
     {
         if let Some(axis) = self.axis() {
             Self::from_axis_angle(&axis, self.angle() * n)
-        } else if self.matrix()[(0, 0)] < N::zero() {
-            let minus_id = MatrixN::<N, U3>::from_diagonal_element(-N::one());
+        } else if self.matrix()[(0, 0)] < T::zero() {
+            let minus_id = SMatrix::<T, 3, 3>::from_diagonal_element(-T::one());
             Self::from_matrix_unchecked(minus_id)
         } else {
             Self::identity()
@@ -679,7 +679,7 @@ where
     /// orthonormal basis, i.e., all vectors are normalized, and the are
     /// all orthogonal to each other. These invariants are not checked
     /// by this method.
-    pub fn from_basis_unchecked(basis: &[Vector3<N>; 3]) -> Self {
+    pub fn from_basis_unchecked(basis: &[Vector3<T>; 3]) -> Self {
         let mat = Matrix3::from_columns(&basis[..]);
         Self::from_matrix_unchecked(mat)
     }
@@ -689,11 +689,11 @@ where
     /// This is an iterative method. See `.from_matrix_eps` to provide mover
     /// convergence parameters and starting solution.
     /// This implements "A Robust Method to Extract the Rotational Part of Deformations" by Müller et al.
-    pub fn from_matrix(m: &Matrix3<N>) -> Self
+    pub fn from_matrix(m: &Matrix3<T>) -> Self
     where
-        N: RealField,
+        T: RealField,
     {
-        Self::from_matrix_eps(m, N::default_epsilon(), 0, Self::identity())
+        Self::from_matrix_eps(m, T::default_epsilon(), 0, Self::identity())
     }
 
     /// Builds a rotation matrix by extracting the rotation part of the given transformation `m`.
@@ -708,9 +708,9 @@ where
     /// * `guess`: a guess of the solution. Convergence will be significantly faster if an initial solution close
     ///           to the actual solution is provided. Can be set to `Rotation3::identity()` if no other
     ///           guesses come to mind.
-    pub fn from_matrix_eps(m: &Matrix3<N>, eps: N, mut max_iter: usize, guess: Self) -> Self
+    pub fn from_matrix_eps(m: &Matrix3<T>, eps: T, mut max_iter: usize, guess: Self) -> Self
     where
-        N: RealField,
+        T: RealField,
     {
         if max_iter == 0 {
             max_iter = usize::max_value();
@@ -726,7 +726,7 @@ where
                 + rot.column(1).dot(&m.column(1))
                 + rot.column(2).dot(&m.column(2));
 
-            let axisangle = axis / (denom.abs() + N::default_epsilon());
+            let axisangle = axis / (denom.abs() + T::default_epsilon());
 
             if let Some((axis, angle)) = Unit::try_new_and_get(axisangle, eps) {
                 rot = Rotation3::from_axis_angle(&axis, angle) * rot;
@@ -743,17 +743,17 @@ where
     #[inline]
     pub fn renormalize(&mut self)
     where
-        N: RealField,
+        T: RealField,
     {
         let mut c = UnitQuaternion::from(*self);
         let _ = c.renormalize();
 
-        *self = Self::from_matrix_eps(self.matrix(), N::default_epsilon(), 0, c.into())
+        *self = Self::from_matrix_eps(self.matrix(), T::default_epsilon(), 0, c.into())
     }
 }
 
 /// # 3D axis and angle extraction
-impl<N: SimdRealField> Rotation3<N> {
+impl<T: SimdRealField> Rotation3<T> {
     /// The rotation angle in [0; pi].
     ///
     /// # Example
@@ -765,8 +765,8 @@ impl<N: SimdRealField> Rotation3<N> {
     /// assert_relative_eq!(rot.angle(), 1.78);
     /// ```
     #[inline]
-    pub fn angle(&self) -> N {
-        ((self.matrix()[(0, 0)] + self.matrix()[(1, 1)] + self.matrix()[(2, 2)] - N::one())
+    pub fn angle(&self) -> T {
+        ((self.matrix()[(0, 0)] + self.matrix()[(1, 1)] + self.matrix()[(2, 2)] - T::one())
             / crate::convert(2.0))
         .simd_acos()
     }
@@ -787,17 +787,17 @@ impl<N: SimdRealField> Rotation3<N> {
     /// assert!(rot.axis().is_none());
     /// ```
     #[inline]
-    pub fn axis(&self) -> Option<Unit<Vector3<N>>>
+    pub fn axis(&self) -> Option<Unit<Vector3<T>>>
     where
-        N: RealField,
+        T: RealField,
     {
-        let axis = VectorN::<N, U3>::new(
+        let axis = SVector::<T, 3>::new(
             self.matrix()[(2, 1)] - self.matrix()[(1, 2)],
             self.matrix()[(0, 2)] - self.matrix()[(2, 0)],
             self.matrix()[(1, 0)] - self.matrix()[(0, 1)],
         );
 
-        Unit::try_new(axis, N::default_epsilon())
+        Unit::try_new(axis, T::default_epsilon())
     }
 
     /// The rotation axis multiplied by the rotation angle.
@@ -811,9 +811,9 @@ impl<N: SimdRealField> Rotation3<N> {
     /// assert_relative_eq!(rot.scaled_axis(), axisangle, epsilon = 1.0e-6);
     /// ```
     #[inline]
-    pub fn scaled_axis(&self) -> Vector3<N>
+    pub fn scaled_axis(&self) -> Vector3<T>
     where
-        N: RealField,
+        T: RealField,
     {
         if let Some(axis) = self.axis() {
             axis.into_inner() * self.angle()
@@ -842,9 +842,9 @@ impl<N: SimdRealField> Rotation3<N> {
     /// assert!(rot.axis_angle().is_none());
     /// ```
     #[inline]
-    pub fn axis_angle(&self) -> Option<(Unit<Vector3<N>>, N)>
+    pub fn axis_angle(&self) -> Option<(Unit<Vector3<T>>, T)>
     where
-        N: RealField,
+        T: RealField,
     {
         if let Some(axis) = self.axis() {
             Some((axis, self.angle()))
@@ -864,9 +864,9 @@ impl<N: SimdRealField> Rotation3<N> {
     /// assert_relative_eq!(rot1.angle_to(&rot2), 1.0045657, epsilon = 1.0e-6);
     /// ```
     #[inline]
-    pub fn angle_to(&self, other: &Self) -> N
+    pub fn angle_to(&self, other: &Self) -> T
     where
-        N::Element: SimdRealField,
+        T::Element: SimdRealField,
     {
         self.rotation_to(other).angle()
     }
@@ -875,9 +875,9 @@ impl<N: SimdRealField> Rotation3<N> {
     ///
     /// The angles are produced in the form (roll, pitch, yaw).
     #[deprecated(note = "This is renamed to use `.euler_angles()`.")]
-    pub fn to_euler_angles(&self) -> (N, N, N)
+    pub fn to_euler_angles(&self) -> (T, T, T)
     where
-        N: RealField,
+        T: RealField,
     {
         self.euler_angles()
     }
@@ -896,57 +896,57 @@ impl<N: SimdRealField> Rotation3<N> {
     /// assert_relative_eq!(euler.1, 0.2, epsilon = 1.0e-6);
     /// assert_relative_eq!(euler.2, 0.3, epsilon = 1.0e-6);
     /// ```
-    pub fn euler_angles(&self) -> (N, N, N)
+    pub fn euler_angles(&self) -> (T, T, T)
     where
-        N: RealField,
+        T: RealField,
     {
         // 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
-        if self[(2, 0)].abs() < N::one() {
+        if self[(2, 0)].abs() < T::one() {
             let yaw = -self[(2, 0)].asin();
             let roll = (self[(2, 1)] / yaw.cos()).atan2(self[(2, 2)] / yaw.cos());
             let pitch = (self[(1, 0)] / yaw.cos()).atan2(self[(0, 0)] / yaw.cos());
             (roll, yaw, pitch)
-        } else if self[(2, 0)] <= -N::one() {
-            (self[(0, 1)].atan2(self[(0, 2)]), N::frac_pi_2(), N::zero())
+        } else if self[(2, 0)] <= -T::one() {
+            (self[(0, 1)].atan2(self[(0, 2)]), T::frac_pi_2(), T::zero())
         } else {
             (
                 -self[(0, 1)].atan2(-self[(0, 2)]),
-                -N::frac_pi_2(),
-                N::zero(),
+                -T::frac_pi_2(),
+                T::zero(),
             )
         }
     }
 }
 
 #[cfg(feature = "rand-no-std")]
-impl<N: SimdRealField> Distribution<Rotation3<N>> for Standard
+impl<T: SimdRealField> Distribution<Rotation3<T>> for Standard
 where
-    N::Element: SimdRealField,
-    OpenClosed01: Distribution<N>,
-    N: SampleUniform,
+    T::Element: SimdRealField,
+    OpenClosed01: Distribution<T>,
+    T: SampleUniform,
 {
     /// Generate a uniformly distributed random rotation.
     #[inline]
-    fn sample<'a, R: Rng + ?Sized>(&self, rng: &mut R) -> Rotation3<N> {
+    fn sample<'a, R: Rng + ?Sized>(&self, rng: &mut R) -> Rotation3<T> {
         // James Arvo.
         // Fast random rotation matrices.
         // In D. Kirk, editor, Graphics Gems III, pages 117-120. Academic, New York, 1992.
 
         // Compute a random rotation around Z
-        let twopi = Uniform::new(N::zero(), N::simd_two_pi());
+        let twopi = Uniform::new(T::zero(), T::simd_two_pi());
         let theta = rng.sample(&twopi);
         let (ts, tc) = theta.simd_sin_cos();
-        let a = MatrixN::<N, U3>::new(
+        let a = SMatrix::<T, 3, 3>::new(
             tc,
             ts,
-            N::zero(),
+            T::zero(),
             -ts,
             tc,
-            N::zero(),
-            N::zero(),
-            N::zero(),
-            N::one(),
+            T::zero(),
+            T::zero(),
+            T::zero(),
+            T::one(),
         );
 
         // Compute a random rotation *of* Z
@@ -954,24 +954,24 @@ where
         let z = rng.sample(OpenClosed01);
         let (ps, pc) = phi.simd_sin_cos();
         let sqrt_z = z.simd_sqrt();
-        let v = Vector3::new(pc * sqrt_z, ps * sqrt_z, (N::one() - z).simd_sqrt());
+        let v = Vector3::new(pc * sqrt_z, ps * sqrt_z, (T::one() - z).simd_sqrt());
         let mut b = v * v.transpose();
         b += b;
-        b -= MatrixN::<N, U3>::identity();
+        b -= SMatrix::<T, 3, 3>::identity();
 
         Rotation3::from_matrix_unchecked(b * a)
     }
 }
 
 #[cfg(feature = "arbitrary")]
-impl<N: SimdRealField + Arbitrary> Arbitrary for Rotation3<N>
+impl<T: SimdRealField + Arbitrary> Arbitrary for Rotation3<T>
 where
-    N::Element: SimdRealField,
-    Owned<N, U3, U3>: Send,
-    Owned<N, U3>: Send,
+    T::Element: SimdRealField,
+    Owned<T, U3, U3>: Send,
+    Owned<T, U3>: Send,
 {
     #[inline]
     fn arbitrary(g: &mut Gen) -> Self {
-        Self::new(VectorN::arbitrary(g))
+        Self::new(SVector::arbitrary(g))
     }
 }
diff --git a/src/geometry/similarity.rs b/src/geometry/similarity.rs
index fab54759..c11de6aa 100755
--- a/src/geometry/similarity.rs
+++ b/src/geometry/similarity.rs
@@ -16,9 +16,9 @@ use simba::scalar::{RealField, SubsetOf};
 use simba::simd::SimdRealField;
 
 use crate::base::allocator::Allocator;
-use crate::base::dimension::{DimName, DimNameAdd, DimNameSum, U1};
+use crate::base::dimension::{DimNameAdd, DimNameSum, U1};
 use crate::base::storage::Owned;
-use crate::base::{DefaultAllocator, MatrixN, Scalar, VectorN};
+use crate::base::{Const, DefaultAllocator, OMatrix, SVector, Scalar};
 use crate::geometry::{AbstractRotation, Isometry, Point, Translation};
 
 /// A similarity, i.e., an uniform scaling, followed by a rotation, followed by a translation.
@@ -27,32 +27,28 @@ use crate::geometry::{AbstractRotation, Isometry, Point, Translation};
 #[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
 #[cfg_attr(
     feature = "serde-serialize",
-    serde(bound(serialize = "N: Serialize,
+    serde(bound(serialize = "T: Serialize,
                      R: Serialize,
-                     DefaultAllocator: Allocator<N, D>,
-                     Owned<N, D>: Serialize"))
+                     DefaultAllocator: Allocator<T, Const<D>>,
+                     Owned<T, Const<D>>: Serialize"))
 )]
 #[cfg_attr(
     feature = "serde-serialize",
-    serde(bound(deserialize = "N: Deserialize<'de>,
+    serde(bound(deserialize = "T: Deserialize<'de>,
                        R: Deserialize<'de>,
-                       DefaultAllocator: Allocator<N, D>,
-                       Owned<N, D>: Deserialize<'de>"))
+                       DefaultAllocator: Allocator<T, Const<D>>,
+                       Owned<T, Const<D>>: Deserialize<'de>"))
 )]
-pub struct Similarity<N: Scalar, D: DimName, R>
-where
-    DefaultAllocator: Allocator<N, D>,
-{
+pub struct Similarity<T: Scalar, R, const D: usize> {
     /// The part of this similarity that does not include the scaling factor.
-    pub isometry: Isometry<N, D, R>,
-    scaling: N,
+    pub isometry: Isometry<T, R, D>,
+    scaling: T,
 }
 
 #[cfg(feature = "abomonation-serialize")]
-impl<N: Scalar, D: DimName, R> Abomonation for Similarity<N, D, R>
+impl<T: Scalar, R, const D: usize> Abomonation for Similarity<T, R, D>
 where
-    Isometry<N, D, R>: Abomonation,
-    DefaultAllocator: Allocator<N, D>,
+    Isometry<T, R, D>: Abomonation,
 {
     unsafe fn entomb<W: Write>(&self, writer: &mut W) -> IOResult<()> {
         self.isometry.entomb(writer)
@@ -67,11 +63,9 @@ where
     }
 }
 
-impl<N: Scalar + hash::Hash, D: DimName + hash::Hash, R: hash::Hash> hash::Hash
-    for Similarity<N, D, R>
+impl<T: Scalar + hash::Hash, R: hash::Hash, const D: usize> hash::Hash for Similarity<T, R, D>
 where
-    DefaultAllocator: Allocator<N, D>,
-    Owned<N, D>: hash::Hash,
+    Owned<T, Const<D>>: hash::Hash,
 {
     fn hash<H: hash::Hasher>(&self, state: &mut H) {
         self.isometry.hash(state);
@@ -79,17 +73,15 @@ where
     }
 }
 
-impl<N: Scalar + Copy + Zero, D: DimName + Copy, R: AbstractRotation<N, D> + Copy> Copy
-    for Similarity<N, D, R>
+impl<T: Scalar + Copy + Zero, R: AbstractRotation<T, D> + Copy, const D: usize> Copy
+    for Similarity<T, R, D>
 where
-    DefaultAllocator: Allocator<N, D>,
-    Owned<N, D>: Copy,
+    Owned<T, Const<D>>: Copy,
 {
 }
 
-impl<N: Scalar + Zero, D: DimName, R: AbstractRotation<N, D> + Clone> Clone for Similarity<N, D, R>
-where
-    DefaultAllocator: Allocator<N, D>,
+impl<T: Scalar + Zero, R: AbstractRotation<T, D> + Clone, const D: usize> Clone
+    for Similarity<T, R, D>
 {
     #[inline]
     fn clone(&self) -> Self {
@@ -97,20 +89,19 @@ where
     }
 }
 
-impl<N: Scalar + Zero, D: DimName, R> Similarity<N, D, R>
+impl<T: Scalar + Zero, R, const D: usize> Similarity<T, R, D>
 where
-    R: AbstractRotation<N, D>,
-    DefaultAllocator: Allocator<N, D>,
+    R: AbstractRotation<T, D>,
 {
     /// Creates a new similarity from its rotational and translational parts.
     #[inline]
-    pub fn from_parts(translation: Translation<N, D>, rotation: R, scaling: N) -> Self {
+    pub fn from_parts(translation: Translation<T, D>, rotation: R, scaling: T) -> Self {
         Self::from_isometry(Isometry::from_parts(translation, rotation), scaling)
     }
 
     /// Creates a new similarity from its rotational and translational parts.
     #[inline]
-    pub fn from_isometry(isometry: Isometry<N, D, R>, scaling: N) -> Self {
+    pub fn from_isometry(isometry: Isometry<T, R, D>, scaling: T) -> Self {
         assert!(!scaling.is_zero(), "The scaling factor must not be zero.");
 
         Self { isometry, scaling }
@@ -118,7 +109,7 @@ where
 
     /// The scaling factor of this similarity transformation.
     #[inline]
-    pub fn set_scaling(&mut self, scaling: N) {
+    pub fn set_scaling(&mut self, scaling: T) {
         assert!(
             !scaling.is_zero(),
             "The similarity scaling factor must not be zero."
@@ -128,26 +119,22 @@ where
     }
 }
 
-impl<N: Scalar, D: DimName, R> Similarity<N, D, R>
-where
-    DefaultAllocator: Allocator<N, D>,
-{
+impl<T: Scalar, R, const D: usize> Similarity<T, R, D> {
     /// The scaling factor of this similarity transformation.
     #[inline]
-    pub fn scaling(&self) -> N {
+    pub fn scaling(&self) -> T {
         self.scaling.inlined_clone()
     }
 }
 
-impl<N: SimdRealField, D: DimName, R> Similarity<N, D, R>
+impl<T: SimdRealField, R, const D: usize> Similarity<T, R, D>
 where
-    N::Element: SimdRealField,
-    R: AbstractRotation<N, D>,
-    DefaultAllocator: Allocator<N, D>,
+    T::Element: SimdRealField,
+    R: AbstractRotation<T, D>,
 {
     /// Creates a new similarity that applies only a scaling factor.
     #[inline]
-    pub fn from_scaling(scaling: N) -> Self {
+    pub fn from_scaling(scaling: T) -> Self {
         Self::from_isometry(Isometry::identity(), scaling)
     }
 
@@ -163,7 +150,7 @@ where
     /// Inverts `self` in-place.
     #[inline]
     pub fn inverse_mut(&mut self) {
-        self.scaling = N::one() / self.scaling;
+        self.scaling = T::one() / self.scaling;
         self.isometry.inverse_mut();
         self.isometry.translation.vector *= self.scaling;
     }
@@ -171,7 +158,7 @@ where
     /// The similarity transformation that applies a scaling factor `scaling` before `self`.
     #[inline]
     #[must_use = "Did you mean to use prepend_scaling_mut()?"]
-    pub fn prepend_scaling(&self, scaling: N) -> Self {
+    pub fn prepend_scaling(&self, scaling: T) -> Self {
         assert!(
             !scaling.is_zero(),
             "The similarity scaling factor must not be zero."
@@ -183,7 +170,7 @@ where
     /// The similarity transformation that applies a scaling factor `scaling` after `self`.
     #[inline]
     #[must_use = "Did you mean to use append_scaling_mut()?"]
-    pub fn append_scaling(&self, scaling: N) -> Self {
+    pub fn append_scaling(&self, scaling: T) -> Self {
         assert!(
             !scaling.is_zero(),
             "The similarity scaling factor must not be zero."
@@ -198,7 +185,7 @@ where
 
     /// Sets `self` to the similarity transformation that applies a scaling factor `scaling` before `self`.
     #[inline]
-    pub fn prepend_scaling_mut(&mut self, scaling: N) {
+    pub fn prepend_scaling_mut(&mut self, scaling: T) {
         assert!(
             !scaling.is_zero(),
             "The similarity scaling factor must not be zero."
@@ -209,7 +196,7 @@ where
 
     /// Sets `self` to the similarity transformation that applies a scaling factor `scaling` after `self`.
     #[inline]
-    pub fn append_scaling_mut(&mut self, scaling: N) {
+    pub fn append_scaling_mut(&mut self, scaling: T) {
         assert!(
             !scaling.is_zero(),
             "The similarity scaling factor must not be zero."
@@ -221,7 +208,7 @@ where
 
     /// Appends to `self` the given translation in-place.
     #[inline]
-    pub fn append_translation_mut(&mut self, t: &Translation<N, D>) {
+    pub fn append_translation_mut(&mut self, t: &Translation<T, D>) {
         self.isometry.append_translation_mut(t)
     }
 
@@ -234,7 +221,7 @@ where
     /// Appends in-place to `self` a rotation centered at the point `p`, i.e., the rotation that
     /// lets `p` invariant.
     #[inline]
-    pub fn append_rotation_wrt_point_mut(&mut self, r: &R, p: &Point<N, D>) {
+    pub fn append_rotation_wrt_point_mut(&mut self, r: &R, p: &Point<T, D>) {
         self.isometry.append_rotation_wrt_point_mut(r, p)
     }
 
@@ -261,7 +248,7 @@ where
     /// assert_relative_eq!(transformed_point, Point3::new(19.0, 17.0, -9.0), epsilon = 1.0e-5);
     /// ```
     #[inline]
-    pub fn transform_point(&self, pt: &Point<N, D>) -> Point<N, D> {
+    pub fn transform_point(&self, pt: &Point<T, D>) -> Point<T, D> {
         self * pt
     }
 
@@ -282,7 +269,7 @@ where
     /// assert_relative_eq!(transformed_vector, Vector3::new(18.0, 15.0, -12.0), epsilon = 1.0e-5);
     /// ```
     #[inline]
-    pub fn transform_vector(&self, v: &VectorN<N, D>) -> VectorN<N, D> {
+    pub fn transform_vector(&self, v: &SVector<T, D>) -> SVector<T, D> {
         self * v
     }
 
@@ -302,7 +289,7 @@ where
     /// assert_relative_eq!(transformed_point, Point3::new(-1.5, 1.5, 1.5), epsilon = 1.0e-5);
     /// ```
     #[inline]
-    pub fn inverse_transform_point(&self, pt: &Point<N, D>) -> Point<N, D> {
+    pub fn inverse_transform_point(&self, pt: &Point<T, D>) -> Point<T, D> {
         self.isometry.inverse_transform_point(pt) / self.scaling()
     }
 
@@ -322,7 +309,7 @@ where
     /// assert_relative_eq!(transformed_vector, Vector3::new(-3.0, 2.5, 2.0), epsilon = 1.0e-5);
     /// ```
     #[inline]
-    pub fn inverse_transform_vector(&self, v: &VectorN<N, D>) -> VectorN<N, D> {
+    pub fn inverse_transform_vector(&self, v: &SVector<T, D>) -> SVector<T, D> {
         self.isometry.inverse_transform_vector(v) / self.scaling()
     }
 }
@@ -331,17 +318,14 @@ where
 // and makes it harder to use it, e.g., for Transform × Isometry implementation.
 // This is OK since all constructors of the isometry enforce the Rotation bound already (and
 // explicit struct construction is prevented by the private scaling factor).
-impl<N: SimdRealField, D: DimName, R> Similarity<N, D, R>
-where
-    DefaultAllocator: Allocator<N, D>,
-{
+impl<T: SimdRealField, R, const D: usize> Similarity<T, R, D> {
     /// Converts this similarity into its equivalent homogeneous transformation matrix.
     #[inline]
-    pub fn to_homogeneous(&self) -> MatrixN<N, DimNameSum<D, U1>>
+    pub fn to_homogeneous(&self) -> OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
     where
-        D: DimNameAdd<U1>,
-        R: SubsetOf<MatrixN<N, DimNameSum<D, U1>>>,
-        DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
+        Const<D>: DimNameAdd<U1>,
+        R: SubsetOf<OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>>,
+        DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
     {
         let mut res = self.isometry.to_homogeneous();
 
@@ -353,17 +337,14 @@ where
     }
 }
 
-impl<N: SimdRealField, D: DimName, R> Eq for Similarity<N, D, R>
-where
-    R: AbstractRotation<N, D> + Eq,
-    DefaultAllocator: Allocator<N, D>,
+impl<T: SimdRealField, R, const D: usize> Eq for Similarity<T, R, D> where
+    R: AbstractRotation<T, D> + Eq
 {
 }
 
-impl<N: SimdRealField, D: DimName, R> PartialEq for Similarity<N, D, R>
+impl<T: SimdRealField, R, const D: usize> PartialEq for Similarity<T, R, D>
 where
-    R: AbstractRotation<N, D> + PartialEq,
-    DefaultAllocator: Allocator<N, D>,
+    R: AbstractRotation<T, D> + PartialEq,
 {
     #[inline]
     fn eq(&self, right: &Self) -> bool {
@@ -371,17 +352,16 @@ where
     }
 }
 
-impl<N: RealField, D: DimName, R> AbsDiffEq for Similarity<N, D, R>
+impl<T: RealField, R, const D: usize> AbsDiffEq for Similarity<T, R, D>
 where
-    R: AbstractRotation<N, D> + AbsDiffEq<Epsilon = N::Epsilon>,
-    DefaultAllocator: Allocator<N, D>,
-    N::Epsilon: Copy,
+    R: AbstractRotation<T, D> + AbsDiffEq<Epsilon = T::Epsilon>,
+    T::Epsilon: Copy,
 {
-    type Epsilon = N::Epsilon;
+    type Epsilon = T::Epsilon;
 
     #[inline]
     fn default_epsilon() -> Self::Epsilon {
-        N::default_epsilon()
+        T::default_epsilon()
     }
 
     #[inline]
@@ -391,15 +371,14 @@ where
     }
 }
 
-impl<N: RealField, D: DimName, R> RelativeEq for Similarity<N, D, R>
+impl<T: RealField, R, const D: usize> RelativeEq for Similarity<T, R, D>
 where
-    R: AbstractRotation<N, D> + RelativeEq<Epsilon = N::Epsilon>,
-    DefaultAllocator: Allocator<N, D>,
-    N::Epsilon: Copy,
+    R: AbstractRotation<T, D> + RelativeEq<Epsilon = T::Epsilon>,
+    T::Epsilon: Copy,
 {
     #[inline]
     fn default_max_relative() -> Self::Epsilon {
-        N::default_max_relative()
+        T::default_max_relative()
     }
 
     #[inline]
@@ -417,15 +396,14 @@ where
     }
 }
 
-impl<N: RealField, D: DimName, R> UlpsEq for Similarity<N, D, R>
+impl<T: RealField, R, const D: usize> UlpsEq for Similarity<T, R, D>
 where
-    R: AbstractRotation<N, D> + UlpsEq<Epsilon = N::Epsilon>,
-    DefaultAllocator: Allocator<N, D>,
-    N::Epsilon: Copy,
+    R: AbstractRotation<T, D> + UlpsEq<Epsilon = T::Epsilon>,
+    T::Epsilon: Copy,
 {
     #[inline]
     fn default_max_ulps() -> u32 {
-        N::default_max_ulps()
+        T::default_max_ulps()
     }
 
     #[inline]
@@ -440,11 +418,10 @@ where
  * Display
  *
  */
-impl<N, D: DimName, R> fmt::Display for Similarity<N, D, R>
+impl<T, R, const D: usize> fmt::Display for Similarity<T, R, D>
 where
-    N: RealField + fmt::Display,
-    R: AbstractRotation<N, D> + fmt::Display,
-    DefaultAllocator: Allocator<N, D> + Allocator<usize, D>,
+    T: RealField + fmt::Display,
+    R: AbstractRotation<T, D> + fmt::Display,
 {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let precision = f.precision().unwrap_or(3);
diff --git a/src/geometry/similarity_alias.rs b/src/geometry/similarity_alias.rs
index c2c887ac..184769a1 100644
--- a/src/geometry/similarity_alias.rs
+++ b/src/geometry/similarity_alias.rs
@@ -1,15 +1,13 @@
-use crate::base::dimension::{U2, U3};
-
 use crate::geometry::{Rotation2, Rotation3, Similarity, UnitComplex, UnitQuaternion};
 
 /// A 2-dimensional similarity.
-pub type Similarity2<N> = Similarity<N, U2, UnitComplex<N>>;
+pub type Similarity2<T> = Similarity<T, UnitComplex<T>, 2>;
 
 /// A 3-dimensional similarity.
-pub type Similarity3<N> = Similarity<N, U3, UnitQuaternion<N>>;
+pub type Similarity3<T> = Similarity<T, UnitQuaternion<T>, 3>;
 
 /// A 2-dimensional similarity using a rotation matrix for its rotation part.
-pub type SimilarityMatrix2<N> = Similarity<N, U2, Rotation2<N>>;
+pub type SimilarityMatrix2<T> = Similarity<T, Rotation2<T>, 2>;
 
 /// A 3-dimensional similarity using a rotation matrix for its rotation part.
-pub type SimilarityMatrix3<N> = Similarity<N, U3, Rotation3<N>>;
+pub type SimilarityMatrix3<T> = Similarity<T, Rotation3<T>, 3>;
diff --git a/src/geometry/similarity_construction.rs b/src/geometry/similarity_construction.rs
index 0c814534..3c1b2b42 100644
--- a/src/geometry/similarity_construction.rs
+++ b/src/geometry/similarity_construction.rs
@@ -13,20 +13,17 @@ use rand::{
 use simba::scalar::SupersetOf;
 use simba::simd::SimdRealField;
 
-use crate::base::allocator::Allocator;
-use crate::base::dimension::{DimName, U2, U3};
-use crate::base::{DefaultAllocator, Vector2, Vector3};
+use crate::base::{Vector2, Vector3};
 
 use crate::{
     AbstractRotation, Isometry, Point, Point3, Rotation2, Rotation3, Scalar, Similarity,
     Translation, UnitComplex, UnitQuaternion,
 };
 
-impl<N: SimdRealField, D: DimName, R> Similarity<N, D, R>
+impl<T: SimdRealField, R, const D: usize> Similarity<T, R, D>
 where
-    N::Element: SimdRealField,
-    R: AbstractRotation<N, D>,
-    DefaultAllocator: Allocator<N, D>,
+    T::Element: SimdRealField,
+    R: AbstractRotation<T, D>,
 {
     /// Creates a new identity similarity.
     ///
@@ -45,15 +42,14 @@ where
     /// ```
     #[inline]
     pub fn identity() -> Self {
-        Self::from_isometry(Isometry::identity(), N::one())
+        Self::from_isometry(Isometry::identity(), T::one())
     }
 }
 
-impl<N: SimdRealField, D: DimName, R> One for Similarity<N, D, R>
+impl<T: SimdRealField, R, const D: usize> One for Similarity<T, R, D>
 where
-    N::Element: SimdRealField,
-    R: AbstractRotation<N, D>,
-    DefaultAllocator: Allocator<N, D>,
+    T::Element: SimdRealField,
+    R: AbstractRotation<T, D>,
 {
     /// Creates a new identity similarity.
     #[inline]
@@ -63,17 +59,16 @@ where
 }
 
 #[cfg(feature = "rand-no-std")]
-impl<N: crate::RealField, D: DimName, R> Distribution<Similarity<N, D, R>> for Standard
+impl<T: crate::RealField, R, const D: usize> Distribution<Similarity<T, R, D>> for Standard
 where
-    R: AbstractRotation<N, D>,
-    DefaultAllocator: Allocator<N, D>,
-    Standard: Distribution<N> + Distribution<R>,
+    R: AbstractRotation<T, D>,
+    Standard: Distribution<T> + Distribution<R>,
 {
     /// Generate an arbitrary random variate for testing purposes.
     #[inline]
-    fn sample<'a, G: Rng + ?Sized>(&self, rng: &mut G) -> Similarity<N, D, R> {
+    fn sample<'a, G: Rng + ?Sized>(&self, rng: &mut G) -> Similarity<T, R, D> {
         let mut s = rng.gen();
-        while relative_eq!(s, N::zero()) {
+        while relative_eq!(s, T::zero()) {
             s = rng.gen()
         }
 
@@ -81,11 +76,10 @@ where
     }
 }
 
-impl<N: SimdRealField, D: DimName, R> Similarity<N, D, R>
+impl<T: SimdRealField, R, const D: usize> Similarity<T, R, D>
 where
-    N::Element: SimdRealField,
-    R: AbstractRotation<N, D>,
-    DefaultAllocator: Allocator<N, D>,
+    T::Element: SimdRealField,
+    R: AbstractRotation<T, D>,
 {
     /// The similarity that applies the scaling factor `scaling`, followed by the rotation `r` with
     /// its axis passing through the point `p`.
@@ -103,24 +97,23 @@ where
     /// assert_relative_eq!(sim * Point2::new(1.0, 2.0), Point2::new(-3.0, 3.0), epsilon = 1.0e-6);
     /// ```
     #[inline]
-    pub fn rotation_wrt_point(r: R, p: Point<N, D>, scaling: N) -> Self {
+    pub fn rotation_wrt_point(r: R, p: Point<T, D>, scaling: T) -> Self {
         let shift = r.transform_vector(&-&p.coords);
         Self::from_parts(Translation::from(shift + p.coords), r, scaling)
     }
 }
 
 #[cfg(feature = "arbitrary")]
-impl<N, D: DimName, R> Arbitrary for Similarity<N, D, R>
+impl<T, R, const D: usize> Arbitrary for Similarity<T, R, D>
 where
-    N: crate::RealField + Arbitrary + Send,
-    N::Element: crate::RealField,
-    R: AbstractRotation<N, D> + Arbitrary + Send,
-    DefaultAllocator: Allocator<N, D>,
-    Owned<N, D>: Send,
+    T: crate::RealField + Arbitrary + Send,
+    T::Element: crate::RealField,
+    R: AbstractRotation<T, D> + Arbitrary + Send,
+    Owned<T, crate::Const<D>>: Send,
 {
     #[inline]
     fn arbitrary(rng: &mut Gen) -> Self {
-        let mut s: N = Arbitrary::arbitrary(rng);
+        let mut s: T = Arbitrary::arbitrary(rng);
         while s.is_zero() {
             s = Arbitrary::arbitrary(rng)
         }
@@ -136,9 +129,9 @@ where
  */
 
 // 2D similarity.
-impl<N: SimdRealField> Similarity<N, U2, Rotation2<N>>
+impl<T: SimdRealField> Similarity<T, Rotation2<T>, 2>
 where
-    N::Element: SimdRealField,
+    T::Element: SimdRealField,
 {
     /// Creates a new similarity from a translation, a rotation, and an uniform scaling factor.
     ///
@@ -153,7 +146,7 @@ where
     /// assert_relative_eq!(sim * Point2::new(2.0, 4.0), Point2::new(-11.0, 8.0), epsilon = 1.0e-6);
     /// ```
     #[inline]
-    pub fn new(translation: Vector2<N>, angle: N, scaling: N) -> Self {
+    pub fn new(translation: Vector2<T>, angle: T, scaling: T) -> Self {
         Self::from_parts(
             Translation::from(translation),
             Rotation2::new(angle),
@@ -170,17 +163,17 @@ where
     /// let sim2 = sim.cast::<f32>();
     /// assert_eq!(sim2, SimilarityMatrix2::<f32>::identity());
     /// ```
-    pub fn cast<To: Scalar>(self) -> Similarity<To, U2, Rotation2<To>>
+    pub fn cast<To: Scalar>(self) -> Similarity<To, Rotation2<To>, 2>
     where
-        Similarity<To, U2, Rotation2<To>>: SupersetOf<Self>,
+        Similarity<To, Rotation2<To>, 2>: SupersetOf<Self>,
     {
         crate::convert(self)
     }
 }
 
-impl<N: SimdRealField> Similarity<N, U2, UnitComplex<N>>
+impl<T: SimdRealField> Similarity<T, UnitComplex<T>, 2>
 where
-    N::Element: SimdRealField,
+    T::Element: SimdRealField,
 {
     /// Creates a new similarity from a translation and a rotation angle.
     ///
@@ -195,7 +188,7 @@ where
     /// assert_relative_eq!(sim * Point2::new(2.0, 4.0), Point2::new(-11.0, 8.0), epsilon = 1.0e-6);
     /// ```
     #[inline]
-    pub fn new(translation: Vector2<N>, angle: N, scaling: N) -> Self {
+    pub fn new(translation: Vector2<T>, angle: T, scaling: T) -> Self {
         Self::from_parts(
             Translation::from(translation),
             UnitComplex::new(angle),
@@ -212,9 +205,9 @@ where
     /// let sim2 = sim.cast::<f32>();
     /// assert_eq!(sim2, Similarity2::<f32>::identity());
     /// ```
-    pub fn cast<To: Scalar>(self) -> Similarity<To, U2, UnitComplex<To>>
+    pub fn cast<To: Scalar>(self) -> Similarity<To, UnitComplex<To>, 2>
     where
-        Similarity<To, U2, UnitComplex<To>>: SupersetOf<Self>,
+        Similarity<To, UnitComplex<To>, 2>: SupersetOf<Self>,
     {
         crate::convert(self)
     }
@@ -223,8 +216,8 @@ where
 // 3D rotation.
 macro_rules! similarity_construction_impl(
     ($Rot: ident) => {
-        impl<N: SimdRealField> Similarity<N, U3, $Rot<N>>
-        where N::Element: SimdRealField {
+        impl<T: SimdRealField> Similarity<T, $Rot<T>, 3>
+        where T::Element: SimdRealField {
             /// Creates a new similarity from a translation, rotation axis-angle, and scaling
             /// factor.
             ///
@@ -251,9 +244,9 @@ macro_rules! similarity_construction_impl(
             /// assert_relative_eq!(sim * vec, Vector3::new(18.0, 15.0, -12.0), epsilon = 1.0e-5);
             /// ```
             #[inline]
-            pub fn new(translation: Vector3<N>, axisangle: Vector3<N>, scaling: N) -> Self
+            pub fn new(translation: Vector3<T>, axisangle: Vector3<T>, scaling: T) -> Self
             {
-                Self::from_isometry(Isometry::<_, U3, $Rot<N>>::new(translation, axisangle), scaling)
+                Self::from_isometry(Isometry::<_, $Rot<T>, 3>::new(translation, axisangle), scaling)
             }
 
             /// Cast the components of `self` to another type.
@@ -265,9 +258,9 @@ macro_rules! similarity_construction_impl(
             /// let sim2 = sim.cast::<f32>();
             /// assert_eq!(sim2, Similarity3::<f32>::identity());
             /// ```
-            pub fn cast<To: Scalar>(self) -> Similarity<To, U3, $Rot<To>>
+            pub fn cast<To: Scalar>(self) -> Similarity<To, $Rot<To>, 3>
             where
-                Similarity<To, U3, $Rot<To>>: SupersetOf<Self>,
+                Similarity<To, $Rot<To>, 3>: SupersetOf<Self>,
             {
                 crate::convert(self)
             }
@@ -305,21 +298,21 @@ macro_rules! similarity_construction_impl(
             /// assert_relative_eq!(sim * Vector3::z(), Vector3::x() * 3.0, epsilon = 1.0e-6);
             /// ```
             #[inline]
-            pub fn face_towards(eye:    &Point3<N>,
-                                      target: &Point3<N>,
-                                      up:     &Vector3<N>,
-                                      scaling: N)
-                                      -> Self {
-                Self::from_isometry(Isometry::<_, U3, $Rot<N>>::face_towards(eye, target, up), scaling)
+            pub fn face_towards(eye:    &Point3<T>,
+                                target: &Point3<T>,
+                                up:     &Vector3<T>,
+                                scaling: T)
+                                -> Self {
+                Self::from_isometry(Isometry::<_, $Rot<T>, 3>::face_towards(eye, target, up), scaling)
             }
 
             /// Deprecated: Use [SimilarityMatrix3::face_towards] instead.
             #[deprecated(note="renamed to `face_towards`")]
-            pub fn new_observer_frames(eye:    &Point3<N>,
-                                      target: &Point3<N>,
-                                      up:     &Vector3<N>,
-                                      scaling: N)
-                                      -> Self {
+            pub fn new_observer_frames(eye:    &Point3<T>,
+                                       target: &Point3<T>,
+                                       up:     &Vector3<T>,
+                                       scaling: T)
+                                       -> Self {
                 Self::face_towards(eye, target, up, scaling)
             }
 
@@ -353,12 +346,12 @@ macro_rules! similarity_construction_impl(
             /// assert_relative_eq!(iso * Vector3::x(), -Vector3::z() * 3.0, epsilon = 1.0e-6);
             /// ```
             #[inline]
-            pub fn look_at_rh(eye:     &Point3<N>,
-                              target:  &Point3<N>,
-                              up:      &Vector3<N>,
-                              scaling: N)
+            pub fn look_at_rh(eye:     &Point3<T>,
+                              target:  &Point3<T>,
+                              up:      &Vector3<T>,
+                              scaling: T)
                               -> Self {
-                Self::from_isometry(Isometry::<_, U3, $Rot<N>>::look_at_rh(eye, target, up), scaling)
+                Self::from_isometry(Isometry::<_, $Rot<T>, 3>::look_at_rh(eye, target, up), scaling)
             }
 
             /// Builds a left-handed look-at view matrix including a scaling factor.
@@ -391,12 +384,12 @@ macro_rules! similarity_construction_impl(
             /// assert_relative_eq!(sim * Vector3::x(), Vector3::z() * 3.0, epsilon = 1.0e-6);
             /// ```
             #[inline]
-            pub fn look_at_lh(eye:     &Point3<N>,
-                              target:  &Point3<N>,
-                              up:      &Vector3<N>,
-                              scaling: N)
+            pub fn look_at_lh(eye:     &Point3<T>,
+                              target:  &Point3<T>,
+                              up:      &Vector3<T>,
+                              scaling: T)
                               -> Self {
-                Self::from_isometry(Isometry::<_, _, $Rot<N>>::look_at_lh(eye, target, up), scaling)
+                Self::from_isometry(Isometry::<_, $Rot<T>, 3>::look_at_lh(eye, target, up), scaling)
             }
         }
     }
diff --git a/src/geometry/similarity_conversion.rs b/src/geometry/similarity_conversion.rs
index abcd7187..2a2338b0 100644
--- a/src/geometry/similarity_conversion.rs
+++ b/src/geometry/similarity_conversion.rs
@@ -4,8 +4,8 @@ use simba::scalar::{RealField, SubsetOf, SupersetOf};
 use simba::simd::{PrimitiveSimdValue, SimdRealField, SimdValue};
 
 use crate::base::allocator::Allocator;
-use crate::base::dimension::{DimMin, DimName, DimNameAdd, DimNameSum, U1};
-use crate::base::{DefaultAllocator, MatrixN, Scalar};
+use crate::base::dimension::{DimMin, DimNameAdd, DimNameSum, U1};
+use crate::base::{Const, DefaultAllocator, OMatrix, Scalar};
 
 use crate::geometry::{
     AbstractRotation, Isometry, Similarity, SuperTCategoryOf, TAffine, Transform, Translation,
@@ -20,27 +20,26 @@ use crate::geometry::{
  * Similarity -> Matrix (homogeneous)
  */
 
-impl<N1, N2, D: DimName, R1, R2> SubsetOf<Similarity<N2, D, R2>> for Similarity<N1, D, R1>
+impl<T1, T2, R1, R2, const D: usize> SubsetOf<Similarity<T2, R2, D>> for Similarity<T1, R1, D>
 where
-    N1: RealField + SubsetOf<N2>,
-    N2: RealField + SupersetOf<N1>,
-    R1: AbstractRotation<N1, D> + SubsetOf<R2>,
-    R2: AbstractRotation<N2, D>,
-    DefaultAllocator: Allocator<N1, D> + Allocator<N2, D>,
+    T1: RealField + SubsetOf<T2>,
+    T2: RealField + SupersetOf<T1>,
+    R1: AbstractRotation<T1, D> + SubsetOf<R2>,
+    R2: AbstractRotation<T2, D>,
 {
     #[inline]
-    fn to_superset(&self) -> Similarity<N2, D, R2> {
+    fn to_superset(&self) -> Similarity<T2, R2, D> {
         Similarity::from_isometry(self.isometry.to_superset(), self.scaling().to_superset())
     }
 
     #[inline]
-    fn is_in_subset(sim: &Similarity<N2, D, R2>) -> bool {
-        crate::is_convertible::<_, Isometry<N1, D, R1>>(&sim.isometry)
-            && crate::is_convertible::<_, N1>(&sim.scaling())
+    fn is_in_subset(sim: &Similarity<T2, R2, D>) -> bool {
+        crate::is_convertible::<_, Isometry<T1, R1, D>>(&sim.isometry)
+            && crate::is_convertible::<_, T1>(&sim.scaling())
     }
 
     #[inline]
-    fn from_superset_unchecked(sim: &Similarity<N2, D, R2>) -> Self {
+    fn from_superset_unchecked(sim: &Similarity<T2, R2, D>) -> Self {
         Similarity::from_isometry(
             sim.isometry.to_subset_unchecked(),
             sim.scaling().to_subset_unchecked(),
@@ -48,117 +47,120 @@ where
     }
 }
 
-impl<N1, N2, D, R, C> SubsetOf<Transform<N2, D, C>> for Similarity<N1, D, R>
+impl<T1, T2, R, C, const D: usize> SubsetOf<Transform<T2, C, D>> for Similarity<T1, R, D>
 where
-    N1: RealField,
-    N2: RealField + SupersetOf<N1>,
+    T1: RealField,
+    T2: RealField + SupersetOf<T1>,
     C: SuperTCategoryOf<TAffine>,
-    R: AbstractRotation<N1, D>
-        + SubsetOf<MatrixN<N1, DimNameSum<D, U1>>>
-        + SubsetOf<MatrixN<N2, DimNameSum<D, U1>>>,
-    D: DimNameAdd<U1> + DimMin<D, Output = D>, // needed by .determinant()
-    DefaultAllocator: Allocator<N1, D>
-        + Allocator<N1, D, D>
-        + Allocator<N1, DimNameSum<D, U1>, DimNameSum<D, U1>>
-        + Allocator<N2, DimNameSum<D, U1>, DimNameSum<D, U1>>
-        + Allocator<(usize, usize), D>
-        + Allocator<N2, DimNameSum<D, U1>, DimNameSum<D, U1>>
-        + Allocator<N2, D, D>
-        + Allocator<N2, D>,
+    R: AbstractRotation<T1, D>
+        + SubsetOf<OMatrix<T1, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>>
+        + SubsetOf<OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>>,
+    Const<D>: DimNameAdd<U1> + DimMin<Const<D>, Output = Const<D>>, // needed by .determinant()
+    DefaultAllocator: Allocator<T1, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
+        + Allocator<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
+        + Allocator<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
+    // + Allocator<(usize, usize), D>
+    // + Allocator<T1, D>
+    // + Allocator<T1, D, D>
+    // + Allocator<T2, D, D>
+    // + Allocator<T2, D>,
 {
     #[inline]
-    fn to_superset(&self) -> Transform<N2, D, C> {
+    fn to_superset(&self) -> Transform<T2, C, D> {
         Transform::from_matrix_unchecked(self.to_homogeneous().to_superset())
     }
 
     #[inline]
-    fn is_in_subset(t: &Transform<N2, D, C>) -> bool {
+    fn is_in_subset(t: &Transform<T2, C, D>) -> bool {
         <Self as SubsetOf<_>>::is_in_subset(t.matrix())
     }
 
     #[inline]
-    fn from_superset_unchecked(t: &Transform<N2, D, C>) -> Self {
+    fn from_superset_unchecked(t: &Transform<T2, C, D>) -> Self {
         Self::from_superset_unchecked(t.matrix())
     }
 }
 
-impl<N1, N2, D, R> SubsetOf<MatrixN<N2, DimNameSum<D, U1>>> for Similarity<N1, D, R>
+impl<T1, T2, R, const D: usize>
+    SubsetOf<OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>>
+    for Similarity<T1, R, D>
 where
-    N1: RealField,
-    N2: RealField + SupersetOf<N1>,
-    R: AbstractRotation<N1, D>
-        + SubsetOf<MatrixN<N1, DimNameSum<D, U1>>>
-        + SubsetOf<MatrixN<N2, DimNameSum<D, U1>>>,
-    D: DimNameAdd<U1> + DimMin<D, Output = D>, // needed by .determinant()
-    DefaultAllocator: Allocator<N1, D>
-        + Allocator<N1, D, D>
-        + Allocator<N1, DimNameSum<D, U1>, DimNameSum<D, U1>>
-        + Allocator<N2, DimNameSum<D, U1>, DimNameSum<D, U1>>
-        + Allocator<(usize, usize), D>
-        + Allocator<N2, DimNameSum<D, U1>, DimNameSum<D, U1>>
-        + Allocator<N2, D, D>
-        + Allocator<N2, D>,
+    T1: RealField,
+    T2: RealField + SupersetOf<T1>,
+    R: AbstractRotation<T1, D>
+        + SubsetOf<OMatrix<T1, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>>
+        + SubsetOf<OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>>,
+    Const<D>: DimNameAdd<U1> + DimMin<Const<D>, Output = Const<D>>, // needed by .determinant()
+    DefaultAllocator: Allocator<T1, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
+        + Allocator<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
+        + Allocator<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>, // + Allocator<(usize, usize), D>
+                                                                             // + Allocator<T1, D>
+                                                                             // + Allocator<T1, D, D>
+                                                                             // + Allocator<T2, D, D>
+                                                                             // + Allocator<T2, D>
 {
     #[inline]
-    fn to_superset(&self) -> MatrixN<N2, DimNameSum<D, U1>> {
+    fn to_superset(&self) -> OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> {
         self.to_homogeneous().to_superset()
     }
 
     #[inline]
-    fn is_in_subset(m: &MatrixN<N2, DimNameSum<D, U1>>) -> bool {
+    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();
         if rot
-            .fixed_columns_mut::<U1>(0)
-            .try_normalize_mut(N2::zero())
+            .fixed_columns_mut::<1>(0)
+            .try_normalize_mut(T2::zero())
             .is_some()
             && rot
-                .fixed_columns_mut::<U1>(1)
-                .try_normalize_mut(N2::zero())
+                .fixed_columns_mut::<1>(1)
+                .try_normalize_mut(T2::zero())
                 .is_some()
             && rot
-                .fixed_columns_mut::<U1>(2)
-                .try_normalize_mut(N2::zero())
+                .fixed_columns_mut::<1>(2)
+                .try_normalize_mut(T2::zero())
                 .is_some()
         {
             // TODO: could we avoid explicit the computation of the determinant?
             // (its sign is needed to see if the scaling factor is negative).
-            if rot.determinant() < N2::zero() {
-                rot.fixed_columns_mut::<U1>(0).neg_mut();
-                rot.fixed_columns_mut::<U1>(1).neg_mut();
-                rot.fixed_columns_mut::<U1>(2).neg_mut();
+            if rot.determinant() < T2::zero() {
+                rot.fixed_columns_mut::<1>(0).neg_mut();
+                rot.fixed_columns_mut::<1>(1).neg_mut();
+                rot.fixed_columns_mut::<1>(2).neg_mut();
             }
 
-            let bottom = m.fixed_slice::<U1, D>(D::dim(), 0);
+            let bottom = m.fixed_slice::<1, D>(D, 0);
             // Scalar types agree.
-            m.iter().all(|e| SupersetOf::<N1>::is_in_subset(e)) &&
+            m.iter().all(|e| SupersetOf::<T1>::is_in_subset(e)) &&
             // The normalized block part is a rotation.
-            // rot.is_special_orthogonal(N2::default_epsilon().sqrt()) &&
+            // rot.is_special_orthogonal(T2::default_epsilon().sqrt()) &&
             // The bottom row is (0, 0, ..., 1)
-            bottom.iter().all(|e| e.is_zero()) && m[(D::dim(), D::dim())] == N2::one()
+            bottom.iter().all(|e| e.is_zero()) && m[(D, D)] == T2::one()
         } else {
             false
         }
     }
 
     #[inline]
-    fn from_superset_unchecked(m: &MatrixN<N2, DimNameSum<D, U1>>) -> Self {
+    fn from_superset_unchecked(
+        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, U1>(0, 0).normalize_mut();
-        let nb = mm.fixed_slice_mut::<D, U1>(0, 1).normalize_mut();
-        let nc = mm.fixed_slice_mut::<D, U1>(0, 2).normalize_mut();
+        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 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() < N2::zero() {
-            mm.fixed_slice_mut::<D, U1>(0, 0).neg_mut();
-            mm.fixed_slice_mut::<D, U1>(0, 1).neg_mut();
-            mm.fixed_slice_mut::<D, U1>(0, 2).neg_mut();
+        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();
             scale = -scale;
         }
 
-        let t = m.fixed_slice::<D, U1>(0, D::dim()).into_owned();
+        let t = m.fixed_slice::<D, 1>(0, D).into_owned();
         let t = Translation {
             vector: crate::convert_unchecked(t),
         };
@@ -171,56 +173,55 @@ where
     }
 }
 
-impl<N: SimdRealField, D: DimName, R> From<Similarity<N, D, R>> for MatrixN<N, DimNameSum<D, U1>>
+impl<T: SimdRealField, R, const D: usize> From<Similarity<T, R, D>>
+    for OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
 where
-    D: DimNameAdd<U1>,
-    R: SubsetOf<MatrixN<N, DimNameSum<D, U1>>>,
-    DefaultAllocator: Allocator<N, D> + Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
+    Const<D>: DimNameAdd<U1>,
+    R: SubsetOf<OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>>,
+    DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>, // + Allocator<T, D>
 {
     #[inline]
-    fn from(sim: Similarity<N, D, R>) -> Self {
+    fn from(sim: Similarity<T, R, D>) -> Self {
         sim.to_homogeneous()
     }
 }
 
-impl<N: Scalar + Zero + PrimitiveSimdValue, D: DimName, R>
-    From<[Similarity<N::Element, D, R::Element>; 2]> for Similarity<N, D, R>
+impl<T: Scalar + Zero + PrimitiveSimdValue, R, const D: usize>
+    From<[Similarity<T::Element, R::Element, D>; 2]> for Similarity<T, R, D>
 where
-    N: From<[<N as SimdValue>::Element; 2]>,
-    R: SimdValue + AbstractRotation<N, D> + From<[<R as SimdValue>::Element; 2]>,
-    R::Element: AbstractRotation<N::Element, D>,
-    N::Element: Scalar + Zero + Copy,
+    T: From<[<T as SimdValue>::Element; 2]>,
+    R: SimdValue + AbstractRotation<T, D> + From<[<R as SimdValue>::Element; 2]>,
+    R::Element: AbstractRotation<T::Element, D>,
+    T::Element: Scalar + Zero + Copy,
     R::Element: Scalar + Zero + Copy,
-    DefaultAllocator: Allocator<N, D> + Allocator<N::Element, D>,
 {
     #[inline]
-    fn from(arr: [Similarity<N::Element, D, R::Element>; 2]) -> Self {
+    fn from(arr: [Similarity<T::Element, R::Element, D>; 2]) -> Self {
         let iso = Isometry::from([arr[0].isometry.clone(), arr[1].isometry.clone()]);
-        let scale = N::from([arr[0].scaling(), arr[1].scaling()]);
+        let scale = T::from([arr[0].scaling(), arr[1].scaling()]);
 
         Self::from_isometry(iso, scale)
     }
 }
 
-impl<N: Scalar + Zero + PrimitiveSimdValue, D: DimName, R>
-    From<[Similarity<N::Element, D, R::Element>; 4]> for Similarity<N, D, R>
+impl<T: Scalar + Zero + PrimitiveSimdValue, R, const D: usize>
+    From<[Similarity<T::Element, R::Element, D>; 4]> for Similarity<T, R, D>
 where
-    N: From<[<N as SimdValue>::Element; 4]>,
-    R: SimdValue + AbstractRotation<N, D> + From<[<R as SimdValue>::Element; 4]>,
-    R::Element: AbstractRotation<N::Element, D>,
-    N::Element: Scalar + Zero + Copy,
+    T: From<[<T as SimdValue>::Element; 4]>,
+    R: SimdValue + AbstractRotation<T, D> + From<[<R as SimdValue>::Element; 4]>,
+    R::Element: AbstractRotation<T::Element, D>,
+    T::Element: Scalar + Zero + Copy,
     R::Element: Scalar + Zero + Copy,
-    DefaultAllocator: Allocator<N, D> + Allocator<N::Element, D>,
 {
     #[inline]
-    fn from(arr: [Similarity<N::Element, D, R::Element>; 4]) -> Self {
+    fn from(arr: [Similarity<T::Element, R::Element, D>; 4]) -> Self {
         let iso = Isometry::from([
             arr[0].isometry.clone(),
             arr[1].isometry.clone(),
             arr[2].isometry.clone(),
             arr[3].isometry.clone(),
         ]);
-        let scale = N::from([
+        let scale = T::from([
             arr[0].scaling(),
             arr[1].scaling(),
             arr[2].scaling(),
@@ -231,18 +232,17 @@ where
     }
 }
 
-impl<N: Scalar + Zero + PrimitiveSimdValue, D: DimName, R>
-    From<[Similarity<N::Element, D, R::Element>; 8]> for Similarity<N, D, R>
+impl<T: Scalar + Zero + PrimitiveSimdValue, R, const D: usize>
+    From<[Similarity<T::Element, R::Element, D>; 8]> for Similarity<T, R, D>
 where
-    N: From<[<N as SimdValue>::Element; 8]>,
-    R: SimdValue + AbstractRotation<N, D> + From<[<R as SimdValue>::Element; 8]>,
-    R::Element: AbstractRotation<N::Element, D>,
-    N::Element: Scalar + Zero + Copy,
+    T: From<[<T as SimdValue>::Element; 8]>,
+    R: SimdValue + AbstractRotation<T, D> + From<[<R as SimdValue>::Element; 8]>,
+    R::Element: AbstractRotation<T::Element, D>,
+    T::Element: Scalar + Zero + Copy,
     R::Element: Scalar + Zero + Copy,
-    DefaultAllocator: Allocator<N, D> + Allocator<N::Element, D>,
 {
     #[inline]
-    fn from(arr: [Similarity<N::Element, D, R::Element>; 8]) -> Self {
+    fn from(arr: [Similarity<T::Element, R::Element, D>; 8]) -> Self {
         let iso = Isometry::from([
             arr[0].isometry.clone(),
             arr[1].isometry.clone(),
@@ -253,7 +253,7 @@ where
             arr[6].isometry.clone(),
             arr[7].isometry.clone(),
         ]);
-        let scale = N::from([
+        let scale = T::from([
             arr[0].scaling(),
             arr[1].scaling(),
             arr[2].scaling(),
@@ -268,18 +268,17 @@ where
     }
 }
 
-impl<N: Scalar + Zero + PrimitiveSimdValue, D: DimName, R>
-    From<[Similarity<N::Element, D, R::Element>; 16]> for Similarity<N, D, R>
+impl<T: Scalar + Zero + PrimitiveSimdValue, R, const D: usize>
+    From<[Similarity<T::Element, R::Element, D>; 16]> for Similarity<T, R, D>
 where
-    N: From<[<N as SimdValue>::Element; 16]>,
-    R: SimdValue + AbstractRotation<N, D> + From<[<R as SimdValue>::Element; 16]>,
-    R::Element: AbstractRotation<N::Element, D>,
-    N::Element: Scalar + Zero + Copy,
+    T: From<[<T as SimdValue>::Element; 16]>,
+    R: SimdValue + AbstractRotation<T, D> + From<[<R as SimdValue>::Element; 16]>,
+    R::Element: AbstractRotation<T::Element, D>,
+    T::Element: Scalar + Zero + Copy,
     R::Element: Scalar + Zero + Copy,
-    DefaultAllocator: Allocator<N, D> + Allocator<N::Element, D>,
 {
     #[inline]
-    fn from(arr: [Similarity<N::Element, D, R::Element>; 16]) -> Self {
+    fn from(arr: [Similarity<T::Element, R::Element, D>; 16]) -> Self {
         let iso = Isometry::from([
             arr[0].isometry.clone(),
             arr[1].isometry.clone(),
@@ -298,7 +297,7 @@ where
             arr[14].isometry.clone(),
             arr[15].isometry.clone(),
         ]);
-        let scale = N::from([
+        let scale = T::from([
             arr[0].scaling(),
             arr[1].scaling(),
             arr[2].scaling(),
diff --git a/src/geometry/similarity_ops.rs b/src/geometry/similarity_ops.rs
index 319d8647..c164acaa 100644
--- a/src/geometry/similarity_ops.rs
+++ b/src/geometry/similarity_ops.rs
@@ -4,9 +4,7 @@ use std::ops::{Div, DivAssign, Mul, MulAssign};
 use simba::scalar::{ClosedAdd, ClosedMul};
 use simba::simd::SimdRealField;
 
-use crate::base::allocator::Allocator;
-use crate::base::dimension::{DimName, U1, U2, U3, U4};
-use crate::base::{DefaultAllocator, Scalar, VectorN};
+use crate::base::{SVector, Scalar};
 
 use crate::geometry::{
     AbstractRotation, Isometry, Point, Rotation, Similarity, Translation, UnitComplex,
@@ -70,10 +68,9 @@ macro_rules! similarity_binop_impl(
     ($Op: ident, $op: ident;
      $lhs: ident: $Lhs: ty, $rhs: ident: $Rhs: ty, Output = $Output: ty;
      $action: expr; $($lives: tt),*) => {
-        impl<$($lives ,)* N: SimdRealField, D: DimName, R> $Op<$Rhs> for $Lhs
-            where N::Element: SimdRealField,
-                  R: AbstractRotation<N, D>,
-                  DefaultAllocator: Allocator<N, D> {
+        impl<$($lives ,)* T: SimdRealField, R, const D: usize> $Op<$Rhs> for $Lhs
+            where T::Element: SimdRealField,
+                  R: AbstractRotation<T, D> {
             type Output = $Output;
 
             #[inline]
@@ -118,20 +115,18 @@ macro_rules! similarity_binop_assign_impl_all(
      $lhs: ident: $Lhs: ty, $rhs: ident: $Rhs: ty;
      [val] => $action_val: expr;
      [ref] => $action_ref: expr;) => {
-        impl<N: SimdRealField, D: DimName, R> $OpAssign<$Rhs> for $Lhs
-            where N::Element: SimdRealField,
-                  R: AbstractRotation<N, D>,
-                  DefaultAllocator: Allocator<N, D> {
+        impl<T: SimdRealField, R, const D: usize> $OpAssign<$Rhs> for $Lhs
+            where T::Element: SimdRealField,
+                  R: AbstractRotation<T, D>{
             #[inline]
             fn $op_assign(&mut $lhs, $rhs: $Rhs) {
                 $action_val
             }
         }
 
-        impl<'b, N: SimdRealField, D: DimName, R> $OpAssign<&'b $Rhs> for $Lhs
-            where N::Element: SimdRealField,
-                  R: AbstractRotation<N, D>,
-                  DefaultAllocator: Allocator<N, D> {
+        impl<'b, T: SimdRealField, R, const D: usize> $OpAssign<&'b $Rhs> for $Lhs
+            where T::Element: SimdRealField,
+                  R: AbstractRotation<T, D> {
             #[inline]
             fn $op_assign(&mut $lhs, $rhs: &'b $Rhs) {
                 $action_ref
@@ -144,7 +139,7 @@ macro_rules! similarity_binop_assign_impl_all(
 // Similarity ÷ Similarity
 similarity_binop_impl_all!(
     Mul, mul;
-    self: Similarity<N, D, R>, rhs: Similarity<N, D, R>, Output = Similarity<N, D, R>;
+    self: Similarity<T, R, D>, rhs: Similarity<T, R, D>, Output = Similarity<T, R, D>;
     [val val] => &self * &rhs;
     [ref val] =>  self * &rhs;
     [val ref] => &self *  rhs;
@@ -157,7 +152,7 @@ similarity_binop_impl_all!(
 
 similarity_binop_impl_all!(
     Div, div;
-    self: Similarity<N, D, R>, rhs: Similarity<N, D, R>, Output = Similarity<N, D, R>;
+    self: Similarity<T, R, D>, rhs: Similarity<T, R, D>, Output = Similarity<T, R, D>;
     [val val] => #[allow(clippy::suspicious_arithmetic_impl)] { self * rhs.inverse() };
     [ref val] => #[allow(clippy::suspicious_arithmetic_impl)] { self * rhs.inverse() };
     [val ref] => #[allow(clippy::suspicious_arithmetic_impl)] { self * rhs.inverse() };
@@ -167,7 +162,7 @@ similarity_binop_impl_all!(
 // Similarity ×= Translation
 similarity_binop_assign_impl_all!(
     MulAssign, mul_assign;
-    self: Similarity<N, D, R>, rhs: Translation<N, D>;
+    self: Similarity<T, R, D>, rhs: Translation<T, D>;
     [val] => *self *= &rhs;
     [ref] => {
         let shift = self.isometry.rotation.transform_vector(&rhs.vector) * self.scaling();
@@ -179,7 +174,7 @@ similarity_binop_assign_impl_all!(
 // Similarity ÷= Similarity
 similarity_binop_assign_impl_all!(
     MulAssign, mul_assign;
-    self: Similarity<N, D, R>, rhs: Similarity<N, D, R>;
+    self: Similarity<T, R, D>, rhs: Similarity<T, R, D>;
     [val] => *self *= &rhs;
     [ref] => {
         *self *= &rhs.isometry;
@@ -189,7 +184,7 @@ similarity_binop_assign_impl_all!(
 
 similarity_binop_assign_impl_all!(
     DivAssign, div_assign;
-    self: Similarity<N, D, R>, rhs: Similarity<N, D, R>;
+    self: Similarity<T, R, D>, rhs: Similarity<T, R, D>;
     [val] => *self /= &rhs;
     // TODO: don't invert explicitly.
     [ref] => #[allow(clippy::suspicious_op_assign_impl)] { *self *= rhs.inverse() };
@@ -199,7 +194,7 @@ similarity_binop_assign_impl_all!(
 // Similarity ÷= Isometry
 similarity_binop_assign_impl_all!(
     MulAssign, mul_assign;
-    self: Similarity<N, D, R>, rhs: Isometry<N, D, R>;
+    self: Similarity<T, R, D>, rhs: Isometry<T, R, D>;
     [val] => *self *= &rhs;
     [ref] => {
         let shift = self.isometry.rotation.transform_vector(&rhs.translation.vector) * self.scaling();
@@ -210,7 +205,7 @@ similarity_binop_assign_impl_all!(
 
 similarity_binop_assign_impl_all!(
     DivAssign, div_assign;
-    self: Similarity<N, D, R>, rhs: Isometry<N, D, R>;
+    self: Similarity<T, R, D>, rhs: Isometry<T, R, D>;
     [val] => *self /= &rhs;
     // TODO: don't invert explicitly.
     [ref] => #[allow(clippy::suspicious_op_assign_impl)] { *self *= rhs.inverse() };
@@ -219,51 +214,57 @@ similarity_binop_assign_impl_all!(
 // Similarity ×= R
 // Similarity ÷= R
 md_assign_impl_all!(
-    MulAssign, mul_assign where N: SimdRealField for N::Element: SimdRealField;
-    (D, U1), (D, D) for D: DimName;
-    self: Similarity<N, D, Rotation<N, D>>, rhs: Rotation<N, D>;
+    MulAssign, mul_assign where T: SimdRealField for T::Element: SimdRealField;
+    (Const<D>, U1), (Const<D>, Const<D>)
+    const D; for; where;
+    self: Similarity<T, Rotation<T, D>, D>, rhs: Rotation<T, D>;
     [val] => self.isometry.rotation *= rhs;
     [ref] => self.isometry.rotation *= rhs.clone();
 );
 
 md_assign_impl_all!(
-    DivAssign, div_assign where N: SimdRealField for N::Element: SimdRealField;
-    (D, U1), (D, D) for D: DimName;
-    self: Similarity<N, D, Rotation<N, D>>, rhs: Rotation<N, D>;
+    DivAssign, div_assign where T: SimdRealField for T::Element: SimdRealField;
+    (Const<D>, U1), (Const<D>, Const<D>)
+    const D; for; where;
+    self: Similarity<T, Rotation<T, D>, D>, rhs: Rotation<T, D>;
     // TODO: don't invert explicitly?
     [val] => #[allow(clippy::suspicious_op_assign_impl)] { *self *= rhs.inverse() };
     [ref] => #[allow(clippy::suspicious_op_assign_impl)] { *self *= rhs.inverse() };
 );
 
 md_assign_impl_all!(
-    MulAssign, mul_assign where N: SimdRealField for N::Element: SimdRealField;
-    (U3, U3), (U3, U3) for;
-    self: Similarity<N, U3, UnitQuaternion<N>>, rhs: UnitQuaternion<N>;
+    MulAssign, mul_assign where T: SimdRealField for T::Element: SimdRealField;
+    (U3, U3), (U3, U3)
+    const; for; where;
+    self: Similarity<T, UnitQuaternion<T>, 3>, rhs: UnitQuaternion<T>;
     [val] => self.isometry.rotation *= rhs;
     [ref] => self.isometry.rotation *= *rhs;
 );
 
 md_assign_impl_all!(
-    DivAssign, div_assign where N: SimdRealField for N::Element: SimdRealField;
-    (U3, U3), (U3, U3) for;
-    self: Similarity<N, U3, UnitQuaternion<N>>, rhs: UnitQuaternion<N>;
+    DivAssign, div_assign where T: SimdRealField for T::Element: SimdRealField;
+    (U3, U3), (U3, U3)
+    const; for; where;
+    self: Similarity<T, UnitQuaternion<T>, 3>, rhs: UnitQuaternion<T>;
     // TODO: don't invert explicitly?
     [val] => #[allow(clippy::suspicious_op_assign_impl)] { *self *= rhs.inverse() };
     [ref] => #[allow(clippy::suspicious_op_assign_impl)] { *self *= rhs.inverse() };
 );
 
 md_assign_impl_all!(
-    MulAssign, mul_assign where N: SimdRealField for N::Element: SimdRealField;
-    (U2, U2), (U2, U2) for;
-    self: Similarity<N, U2, UnitComplex<N>>, rhs: UnitComplex<N>;
+    MulAssign, mul_assign where T: SimdRealField for T::Element: SimdRealField;
+    (U2, U2), (U2, U2)
+    const; for; where;
+    self: Similarity<T, UnitComplex<T>, 2>, rhs: UnitComplex<T>;
     [val] => self.isometry.rotation *= rhs;
     [ref] => self.isometry.rotation *= *rhs;
 );
 
 md_assign_impl_all!(
-    DivAssign, div_assign where N: SimdRealField for N::Element: SimdRealField;
-    (U2, U2), (U2, U2) for;
-    self: Similarity<N, U2, UnitComplex<N>>, rhs: UnitComplex<N>;
+    DivAssign, div_assign where T: SimdRealField for T::Element: SimdRealField;
+    (U2, U2), (U2, U2)
+    const; for; where;
+    self: Similarity<T, UnitComplex<T>, 2>, rhs: UnitComplex<T>;
     // TODO: don't invert explicitly?
     [val] => #[allow(clippy::suspicious_op_assign_impl)] { *self *= rhs.inverse() };
     [ref] => #[allow(clippy::suspicious_op_assign_impl)] { *self *= rhs.inverse() };
@@ -273,7 +274,7 @@ md_assign_impl_all!(
 // Similarity ÷ Isometry
 similarity_binop_impl_all!(
     Mul, mul;
-    self: Similarity<N, D, R>, rhs: Isometry<N, D, R>, Output = Similarity<N, D, R>;
+    self: Similarity<T, R, D>, rhs: Isometry<T, R, D>, Output = Similarity<T, R, D>;
     [val val] => &self * &rhs;
     [ref val] => self * &rhs;
     [val ref] => &self * rhs;
@@ -289,7 +290,7 @@ similarity_binop_impl_all!(
 
 similarity_binop_impl_all!(
     Div, div;
-    self: Similarity<N, D, R>, rhs: Isometry<N, D, R>, Output = Similarity<N, D, R>;
+    self: Similarity<T, R, D>, rhs: Isometry<T, R, D>, Output = Similarity<T, R, D>;
     [val val] => #[allow(clippy::suspicious_arithmetic_impl)] { self * rhs.inverse() };
     [ref val] => #[allow(clippy::suspicious_arithmetic_impl)] { self * rhs.inverse() };
     [val ref] => #[allow(clippy::suspicious_arithmetic_impl)] { self * rhs.inverse() };
@@ -300,7 +301,7 @@ similarity_binop_impl_all!(
 // Isometry ÷ Similarity
 similarity_binop_impl_all!(
     Mul, mul;
-    self: Isometry<N, D, R>, rhs: Similarity<N, D, R>, Output = Similarity<N, D, R>;
+    self: Isometry<T, R, D>, rhs: Similarity<T, R, D>, Output = Similarity<T, R, D>;
     [val val] => {
         let scaling = rhs.scaling();
         Similarity::from_isometry(self * rhs.isometry, scaling)
@@ -321,7 +322,7 @@ similarity_binop_impl_all!(
 
 similarity_binop_impl_all!(
     Div, div;
-    self: Isometry<N, D, R>, rhs: Similarity<N, D, R>, Output = Similarity<N, D, R>;
+    self: Isometry<T, R, D>, rhs: Similarity<T, R, D>, Output = Similarity<T, R, D>;
     [val val] => #[allow(clippy::suspicious_arithmetic_impl)] { self * rhs.inverse() };
     [ref val] => #[allow(clippy::suspicious_arithmetic_impl)] { self * rhs.inverse() };
     [val ref] => #[allow(clippy::suspicious_arithmetic_impl)] { self * rhs.inverse() };
@@ -331,7 +332,7 @@ similarity_binop_impl_all!(
 // Similarity × Point
 similarity_binop_impl_all!(
     Mul, mul;
-    self: Similarity<N, D, R>, right: Point<N, D>, Output = Point<N, D>;
+    self: Similarity<T, R, D>, right: Point<T, D>, Output = Point<T, D>;
     [val val] => {
         let scaling = self.scaling();
         self.isometry.translation * (self.isometry.rotation.transform_point(&right) * scaling)
@@ -347,7 +348,7 @@ similarity_binop_impl_all!(
 // Similarity × Vector
 similarity_binop_impl_all!(
     Mul, mul;
-    self: Similarity<N, D, R>, right: VectorN<N, D>, Output = VectorN<N, D>;
+    self: Similarity<T, R, D>, right: SVector<T, D>, Output = SVector<T, D>;
     [val val] => self.isometry.rotation.transform_vector(&right) * self.scaling();
     [ref val] => self.isometry.rotation.transform_vector(&right) * self.scaling();
     [val ref] => self.isometry.rotation.transform_vector(right) * self.scaling();
@@ -357,7 +358,7 @@ similarity_binop_impl_all!(
 // Similarity × Translation
 similarity_binop_impl_all!(
     Mul, mul;
-    self: Similarity<N, D, R>, right: Translation<N, D>, Output = Similarity<N, D, R>;
+    self: Similarity<T, R, D>, right: Translation<T, D>, Output = Similarity<T, R, D>;
     [val val] => &self * &right;
     [ref val] => self * &right;
     [val ref] => &self * right;
@@ -374,7 +375,7 @@ similarity_binop_impl_all!(
 // Translation × Similarity
 similarity_binop_impl_all!(
     Mul, mul;
-    self: Translation<N, D>, right: Similarity<N, D, R>, Output = Similarity<N, D, R>;
+    self: Translation<T, D>, right: Similarity<T, R, D>, Output = Similarity<T, R, D>;
     [val val] => {
         let scaling = right.scaling();
         Similarity::from_isometry(self * right.isometry, scaling)
@@ -389,13 +390,11 @@ similarity_binop_impl_all!(
 
 macro_rules! similarity_from_composition_impl(
     ($Op: ident, $op: ident;
-     ($R1: ty, $C1: ty),($R2: ty, $C2: ty) $(for $Dims: ident: $DimsBound: ident),*;
+     $($Dims: ident),*;
      $lhs: ident: $Lhs: ty, $rhs: ident: $Rhs: ty, Output = $Output: ty;
      $action: expr; $($lives: tt),*) => {
-        impl<$($lives ,)* N: SimdRealField $(, $Dims: $DimsBound)*> $Op<$Rhs> for $Lhs
-            where N::Element: SimdRealField,
-                  DefaultAllocator: Allocator<N, $R1, $C1> +
-                                    Allocator<N, $R2, $C2> {
+        impl<$($lives ,)* T: SimdRealField $(, const $Dims: usize)*> $Op<$Rhs> for $Lhs
+            where T::Element: SimdRealField {
             type Output = $Output;
 
             #[inline]
@@ -408,7 +407,7 @@ macro_rules! similarity_from_composition_impl(
 
 macro_rules! similarity_from_composition_impl_all(
     ($Op: ident, $op: ident;
-     ($R1: ty, $C1: ty),($R2: ty, $C2: ty) $(for $Dims: ident: $DimsBound: ident),*;
+     $($Dims: ident),*;
      $lhs: ident: $Lhs: ty, $rhs: ident: $Rhs: ty, Output = $Output: ty;
      [val val] => $action_val_val: expr;
      [ref val] => $action_ref_val: expr;
@@ -417,25 +416,25 @@ macro_rules! similarity_from_composition_impl_all(
 
         similarity_from_composition_impl!(
             $Op, $op;
-            ($R1, $C1),($R2, $C2) $(for $Dims: $DimsBound),*;
+            $($Dims),*;
             $lhs: $Lhs, $rhs: $Rhs, Output = $Output;
             $action_val_val; );
 
         similarity_from_composition_impl!(
             $Op, $op;
-            ($R1, $C1),($R2, $C2) $(for $Dims: $DimsBound),*;
+            $($Dims),*;
             $lhs: &'a $Lhs, $rhs: $Rhs, Output = $Output;
             $action_ref_val; 'a);
 
         similarity_from_composition_impl!(
             $Op, $op;
-            ($R1, $C1),($R2, $C2) $(for $Dims: $DimsBound),*;
+            $($Dims),*;
             $lhs: $Lhs, $rhs: &'b $Rhs, Output = $Output;
             $action_val_ref; 'b);
 
         similarity_from_composition_impl!(
             $Op, $op;
-            ($R1, $C1),($R2, $C2) $(for $Dims: $DimsBound),*;
+            $($Dims),*;
             $lhs: &'a $Lhs, $rhs: &'b $Rhs, Output = $Output;
             $action_ref_ref; 'a, 'b);
     }
@@ -444,9 +443,9 @@ macro_rules! similarity_from_composition_impl_all(
 // Similarity × Rotation
 similarity_from_composition_impl_all!(
     Mul, mul;
-    (D, D), (D, U1) for D: DimName;
-    self: Similarity<N, D, Rotation<N, D>>, rhs: Rotation<N, D>,
-    Output = Similarity<N, D, Rotation<N, D>>;
+    D;
+    self: Similarity<T, Rotation<T, D>, D>, rhs: Rotation<T, D>,
+    Output = Similarity<T, Rotation<T, D>, D>;
     [val val] => {
         let scaling = self.scaling();
         Similarity::from_isometry(self.isometry * rhs, scaling)
@@ -462,9 +461,9 @@ similarity_from_composition_impl_all!(
 // Rotation × Similarity
 similarity_from_composition_impl_all!(
     Mul, mul;
-    (D, D), (D, U1) for D: DimName;
-    self: Rotation<N, D>, right: Similarity<N, D, Rotation<N, D>>,
-    Output = Similarity<N, D, Rotation<N, D>>;
+    D;
+    self: Rotation<T, D>, right: Similarity<T, Rotation<T, D>, D>,
+    Output = Similarity<T, Rotation<T, D>, D>;
     [val val] => &self * &right;
     [ref val] =>  self * &right;
     [val ref] => &self *  right;
@@ -474,9 +473,9 @@ similarity_from_composition_impl_all!(
 // Similarity ÷ Rotation
 similarity_from_composition_impl_all!(
     Div, div;
-    (D, D), (D, U1) for D: DimName;
-    self: Similarity<N, D, Rotation<N, D>>, rhs: Rotation<N, D>,
-    Output = Similarity<N, D, Rotation<N, D>>;
+    D;
+    self: Similarity<T, Rotation<T, D>, D>, rhs: Rotation<T, D>,
+    Output = Similarity<T, Rotation<T, D>, D>;
     [val val] => {
         let scaling = self.scaling();
         Similarity::from_isometry(self.isometry / rhs, scaling)
@@ -492,9 +491,9 @@ similarity_from_composition_impl_all!(
 // Rotation ÷ Similarity
 similarity_from_composition_impl_all!(
     Div, div;
-    (D, D), (D, U1) for D: DimName;
-    self: Rotation<N, D>, right: Similarity<N, D, Rotation<N, D>>,
-    Output = Similarity<N, D, Rotation<N, D>>;
+    D;
+    self: Rotation<T, D>, right: Similarity<T, Rotation<T, D>, D>,
+    Output = Similarity<T, Rotation<T, D>, D>;
     // TODO: don't call inverse explicitly?
     [val val] => #[allow(clippy::suspicious_arithmetic_impl)] { self * right.inverse() };
     [ref val] => #[allow(clippy::suspicious_arithmetic_impl)] { self * right.inverse() };
@@ -505,9 +504,9 @@ similarity_from_composition_impl_all!(
 // Similarity × UnitQuaternion
 similarity_from_composition_impl_all!(
     Mul, mul;
-    (U4, U1), (U3, U1);
-    self: Similarity<N, U3, UnitQuaternion<N>>, rhs: UnitQuaternion<N>,
-    Output = Similarity<N, U3, UnitQuaternion<N>>;
+    ;
+    self: Similarity<T, UnitQuaternion<T>, 3>, rhs: UnitQuaternion<T>,
+    Output = Similarity<T, UnitQuaternion<T>, 3>;
     [val val] => {
         let scaling = self.scaling();
         Similarity::from_isometry(self.isometry * rhs, scaling)
@@ -523,9 +522,9 @@ similarity_from_composition_impl_all!(
 // UnitQuaternion × Similarity
 similarity_from_composition_impl_all!(
     Mul, mul;
-    (U4, U1), (U3, U1);
-    self: UnitQuaternion<N>, right: Similarity<N, U3, UnitQuaternion<N>>,
-    Output = Similarity<N, U3, UnitQuaternion<N>>;
+    ;
+    self: UnitQuaternion<T>, right: Similarity<T, UnitQuaternion<T>, 3>,
+    Output = Similarity<T, UnitQuaternion<T>, 3>;
     [val val] => &self * &right;
     [ref val] =>  self * &right;
     [val ref] => &self *  right;
@@ -535,9 +534,9 @@ similarity_from_composition_impl_all!(
 // Similarity ÷ UnitQuaternion
 similarity_from_composition_impl_all!(
     Div, div;
-    (U4, U1), (U3, U1);
-    self: Similarity<N, U3, UnitQuaternion<N>>, rhs: UnitQuaternion<N>,
-    Output = Similarity<N, U3, UnitQuaternion<N>>;
+    ;
+    self: Similarity<T, UnitQuaternion<T>, 3>, rhs: UnitQuaternion<T>,
+    Output = Similarity<T, UnitQuaternion<T>, 3>;
     [val val] => {
         let scaling = self.scaling();
         Similarity::from_isometry(self.isometry / rhs, scaling)
@@ -553,9 +552,9 @@ similarity_from_composition_impl_all!(
 // UnitQuaternion ÷ Similarity
 similarity_from_composition_impl_all!(
     Div, div;
-    (U4, U1), (U3, U1);
-    self: UnitQuaternion<N>, right: Similarity<N, U3, UnitQuaternion<N>>,
-    Output = Similarity<N, U3, UnitQuaternion<N>>;
+    ;
+    self: UnitQuaternion<T>, right: Similarity<T, UnitQuaternion<T>, 3>,
+    Output = Similarity<T, UnitQuaternion<T>, 3>;
     // TODO: don't call inverse explicitly?
     [val val] => #[allow(clippy::suspicious_arithmetic_impl)] { self * right.inverse() };
     [ref val] => #[allow(clippy::suspicious_arithmetic_impl)] { self * right.inverse() };
@@ -566,9 +565,9 @@ similarity_from_composition_impl_all!(
 // Similarity × UnitComplex
 similarity_from_composition_impl_all!(
     Mul, mul;
-    (U2, U1), (U2, U1);
-    self: Similarity<N, U2, UnitComplex<N>>, rhs: UnitComplex<N>,
-    Output = Similarity<N, U2, UnitComplex<N>>;
+    ;
+    self: Similarity<T, UnitComplex<T>, 2>, rhs: UnitComplex<T>,
+    Output = Similarity<T, UnitComplex<T>, 2>;
     [val val] => {
         let scaling = self.scaling();
         Similarity::from_isometry(self.isometry * rhs, scaling)
@@ -584,9 +583,9 @@ similarity_from_composition_impl_all!(
 // Similarity ÷ UnitComplex
 similarity_from_composition_impl_all!(
     Div, div;
-    (U2, U1), (U2, U1);
-    self: Similarity<N, U2, UnitComplex<N>>, rhs: UnitComplex<N>,
-    Output = Similarity<N, U2, UnitComplex<N>>;
+    ;
+    self: Similarity<T, UnitComplex<T>, 2>, rhs: UnitComplex<T>,
+    Output = Similarity<T, UnitComplex<T>, 2>;
     [val val] => {
         let scaling = self.scaling();
         Similarity::from_isometry(self.isometry / rhs, scaling)
diff --git a/src/geometry/similarity_simba.rs b/src/geometry/similarity_simba.rs
index bf3858f7..e4de581d 100755
--- a/src/geometry/similarity_simba.rs
+++ b/src/geometry/similarity_simba.rs
@@ -1,29 +1,24 @@
 use simba::simd::{SimdRealField, SimdValue};
 
-use crate::base::allocator::Allocator;
-use crate::base::dimension::DimName;
-use crate::base::DefaultAllocator;
-
 use crate::geometry::{AbstractRotation, Isometry, Similarity};
 
-impl<N: SimdRealField, D: DimName, R> SimdValue for Similarity<N, D, R>
+impl<T: SimdRealField, R, const D: usize> SimdValue for Similarity<T, R, D>
 where
-    N::Element: SimdRealField,
-    R: SimdValue<SimdBool = N::SimdBool> + AbstractRotation<N, D>,
-    R::Element: AbstractRotation<N::Element, D>,
-    DefaultAllocator: Allocator<N, D> + Allocator<N::Element, D>,
+    T::Element: SimdRealField,
+    R: SimdValue<SimdBool = T::SimdBool> + AbstractRotation<T, D>,
+    R::Element: AbstractRotation<T::Element, D>,
 {
-    type Element = Similarity<N::Element, D, R::Element>;
-    type SimdBool = N::SimdBool;
+    type Element = Similarity<T::Element, R::Element, D>;
+    type SimdBool = T::SimdBool;
 
     #[inline]
     fn lanes() -> usize {
-        N::lanes()
+        T::lanes()
     }
 
     #[inline]
     fn splat(val: Self::Element) -> Self {
-        let scaling = N::splat(val.scaling());
+        let scaling = T::splat(val.scaling());
         Similarity::from_isometry(Isometry::splat(val.isometry), scaling)
     }
 
diff --git a/src/geometry/swizzle.rs b/src/geometry/swizzle.rs
index 26971b74..6e4c6df8 100644
--- a/src/geometry/swizzle.rs
+++ b/src/geometry/swizzle.rs
@@ -1,5 +1,4 @@
-use crate::base::allocator::Allocator;
-use crate::base::{DefaultAllocator, DimName, Scalar};
+use crate::base::{Const, Scalar, ToTypenum};
 use crate::geometry::{Point, Point2, Point3};
 use typenum::{self, Cmp, Greater};
 
@@ -9,8 +8,8 @@ macro_rules! impl_swizzle {
             $(
                 /// Builds a new point from components of `self`.
                 #[inline]
-                pub fn $name(&self) -> $Result<N>
-                 where D::Value: Cmp<typenum::$BaseDim, Output=Greater> {
+                pub fn $name(&self) -> $Result<T>
+                 where <Const<D> as ToTypenum>::Typenum: Cmp<typenum::$BaseDim, Output=Greater> {
                     $Result::new($(self[$i].inlined_clone()),*)
                 }
             )*
@@ -19,9 +18,9 @@ macro_rules! impl_swizzle {
 }
 
 /// # Swizzling
-impl<N: Scalar, D: DimName> Point<N, D>
+impl<T: Scalar, const D: usize> Point<T, D>
 where
-    DefaultAllocator: Allocator<N, D>,
+    Const<D>: ToTypenum,
 {
     impl_swizzle!(
         where U0: xx()  -> Point2[0, 0],
diff --git a/src/geometry/transform.rs b/src/geometry/transform.rs
index b15eb28f..cbc855ea 100755
--- a/src/geometry/transform.rs
+++ b/src/geometry/transform.rs
@@ -9,9 +9,9 @@ use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use simba::scalar::RealField;
 
 use crate::base::allocator::Allocator;
-use crate::base::dimension::{DimName, DimNameAdd, DimNameSum, U1};
+use crate::base::dimension::{DimNameAdd, DimNameSum, U1};
 use crate::base::storage::Owned;
-use crate::base::{DefaultAllocator, MatrixN, VectorN};
+use crate::base::{Const, DefaultAllocator, DimName, OMatrix, SVector};
 
 use crate::geometry::Point;
 
@@ -28,10 +28,10 @@ pub trait TCategory: Any + Debug + Copy + PartialEq + Send {
 
     /// Checks that the given matrix is a valid homogeneous representation of an element of the
     /// category `Self`.
-    fn check_homogeneous_invariants<N: RealField, D: DimName>(mat: &MatrixN<N, D>) -> bool
+    fn check_homogeneous_invariants<T: RealField, D: DimName>(mat: &OMatrix<T, D, D>) -> bool
     where
-        N::Epsilon: Copy,
-        DefaultAllocator: Allocator<N, D, D>;
+        T::Epsilon: Copy,
+        DefaultAllocator: Allocator<T, D, D>;
 }
 
 /// Traits that gives the `Transform` category that is compatible with the result of the
@@ -71,10 +71,10 @@ pub enum TAffine {}
 
 impl TCategory for TGeneral {
     #[inline]
-    fn check_homogeneous_invariants<N: RealField, D: DimName>(_: &MatrixN<N, D>) -> bool
+    fn check_homogeneous_invariants<T: RealField, D: DimName>(_: &OMatrix<T, D, D>) -> bool
     where
-        N::Epsilon: Copy,
-        DefaultAllocator: Allocator<N, D, D>,
+        T::Epsilon: Copy,
+        DefaultAllocator: Allocator<T, D, D>,
     {
         true
     }
@@ -82,10 +82,10 @@ impl TCategory for TGeneral {
 
 impl TCategory for TProjective {
     #[inline]
-    fn check_homogeneous_invariants<N: RealField, D: DimName>(mat: &MatrixN<N, D>) -> bool
+    fn check_homogeneous_invariants<T: RealField, D: DimName>(mat: &OMatrix<T, D, D>) -> bool
     where
-        N::Epsilon: Copy,
-        DefaultAllocator: Allocator<N, D, D>,
+        T::Epsilon: Copy,
+        DefaultAllocator: Allocator<T, D, D>,
     {
         mat.is_invertible()
     }
@@ -98,14 +98,14 @@ impl TCategory for TAffine {
     }
 
     #[inline]
-    fn check_homogeneous_invariants<N: RealField, D: DimName>(mat: &MatrixN<N, D>) -> bool
+    fn check_homogeneous_invariants<T: RealField, D: DimName>(mat: &OMatrix<T, D, D>) -> bool
     where
-        N::Epsilon: Copy,
-        DefaultAllocator: Allocator<N, D, D>,
+        T::Epsilon: Copy,
+        DefaultAllocator: Allocator<T, D, D>,
     {
         let last = D::dim() - 1;
         mat.is_invertible()
-            && mat[(last, last)] == N::one()
+            && mat[(last, last)] == T::one()
             && (0..last).all(|i| mat[(last, i)].is_zero())
     }
 }
@@ -157,33 +157,36 @@ super_tcategory_impl!(
 /// 3D transformation.
 #[repr(C)]
 #[derive(Debug)]
-pub struct Transform<N: RealField, D: DimNameAdd<U1>, C: TCategory>
+pub struct Transform<T: RealField, C: TCategory, const D: usize>
 where
-    DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
+    Const<D>: DimNameAdd<U1>,
+    DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
 {
-    matrix: MatrixN<N, DimNameSum<D, U1>>,
+    matrix: OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
     _phantom: PhantomData<C>,
 }
 
 // TODO
-// impl<N: RealField + hash::Hash, D: DimNameAdd<U1> + hash::Hash, C: TCategory> hash::Hash for Transform<N, D, C>
-//     where DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
-//           Owned<N, DimNameSum<D, U1>, DimNameSum<D, U1>>: hash::Hash {
+// impl<T: RealField + hash::Hash, D: DimNameAdd<U1> + hash::Hash, C: TCategory> hash::Hash for Transform<T, C, D>
+//     where DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
+//           Owned<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>: hash::Hash {
 //     fn hash<H: hash::Hasher>(&self, state: &mut H) {
 //         self.matrix.hash(state);
 //     }
 // }
 
-impl<N: RealField, D: DimNameAdd<U1> + Copy, C: TCategory> Copy for Transform<N, D, C>
+impl<T: RealField, C: TCategory, const D: usize> Copy for Transform<T, C, D>
 where
-    DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
-    Owned<N, DimNameSum<D, U1>, DimNameSum<D, U1>>: Copy,
+    Const<D>: DimNameAdd<U1>,
+    DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
+    Owned<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>: Copy,
 {
 }
 
-impl<N: RealField, D: DimNameAdd<U1>, C: TCategory> Clone for Transform<N, D, C>
+impl<T: RealField, C: TCategory, const D: usize> Clone for Transform<T, C, D>
 where
-    DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
+    Const<D>: DimNameAdd<U1>,
+    DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
 {
     #[inline]
     fn clone(&self) -> Self {
@@ -192,10 +195,11 @@ where
 }
 
 #[cfg(feature = "serde-serialize")]
-impl<N: RealField, D: DimNameAdd<U1>, C: TCategory> Serialize for Transform<N, D, C>
+impl<T: RealField, C: TCategory, const D: usize> Serialize for Transform<T, C, D>
 where
-    DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
-    Owned<N, DimNameSum<D, U1>, DimNameSum<D, U1>>: Serialize,
+    Const<D>: DimNameAdd<U1>,
+    DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
+    Owned<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>: Serialize,
 {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
@@ -206,29 +210,35 @@ where
 }
 
 #[cfg(feature = "serde-serialize")]
-impl<'a, N: RealField, D: DimNameAdd<U1>, C: TCategory> Deserialize<'a> for Transform<N, D, C>
+impl<'a, T: RealField, C: TCategory, const D: usize> Deserialize<'a> for Transform<T, C, D>
 where
-    DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
-    Owned<N, DimNameSum<D, U1>, DimNameSum<D, U1>>: Deserialize<'a>,
+    Const<D>: DimNameAdd<U1>,
+    DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
+    Owned<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>: Deserialize<'a>,
 {
     fn deserialize<Des>(deserializer: Des) -> Result<Self, Des::Error>
     where
         Des: Deserializer<'a>,
     {
-        let matrix = MatrixN::<N, DimNameSum<D, U1>>::deserialize(deserializer)?;
+        let matrix = OMatrix::<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>::deserialize(
+            deserializer,
+        )?;
 
         Ok(Transform::from_matrix_unchecked(matrix))
     }
 }
 
-impl<N: RealField + Eq, D: DimNameAdd<U1>, C: TCategory> Eq for Transform<N, D, C> where
-    DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>
+impl<T: RealField + Eq, C: TCategory, const D: usize> Eq for Transform<T, C, D>
+where
+    Const<D>: DimNameAdd<U1>,
+    DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
 {
 }
 
-impl<N: RealField, D: DimNameAdd<U1>, C: TCategory> PartialEq for Transform<N, D, C>
+impl<T: RealField, C: TCategory, const D: usize> PartialEq for Transform<T, C, D>
 where
-    DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
+    Const<D>: DimNameAdd<U1>,
+    DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
 {
     #[inline]
     fn eq(&self, right: &Self) -> bool {
@@ -236,14 +246,17 @@ where
     }
 }
 
-impl<N: RealField, D: DimNameAdd<U1>, C: TCategory> Transform<N, D, C>
+impl<T: RealField, C: TCategory, const D: usize> Transform<T, C, D>
 where
-    DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
+    Const<D>: DimNameAdd<U1>,
+    DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
 {
     /// Creates a new transformation from the given homogeneous matrix. The transformation category
     /// of `Self` is not checked to be verified by the given matrix.
     #[inline]
-    pub fn from_matrix_unchecked(matrix: MatrixN<N, DimNameSum<D, U1>>) -> Self {
+    pub fn from_matrix_unchecked(
+        matrix: OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
+    ) -> Self {
         Transform {
             matrix,
             _phantom: PhantomData,
@@ -263,7 +276,7 @@ where
     /// assert_eq!(t.into_inner(), m);
     /// ```
     #[inline]
-    pub fn into_inner(self) -> MatrixN<N, DimNameSum<D, U1>> {
+    pub fn into_inner(self) -> OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> {
         self.matrix
     }
 
@@ -271,7 +284,7 @@ where
     /// Deprecated: Use [Transform::into_inner] instead.
     #[deprecated(note = "use `.into_inner()` instead")]
     #[inline]
-    pub fn unwrap(self) -> MatrixN<N, DimNameSum<D, U1>> {
+    pub fn unwrap(self) -> OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> {
         self.matrix
     }
 
@@ -288,7 +301,7 @@ where
     /// assert_eq!(*t.matrix(), m);
     /// ```
     #[inline]
-    pub fn matrix(&self) -> &MatrixN<N, DimNameSum<D, U1>> {
+    pub fn matrix(&self) -> &OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> {
         &self.matrix
     }
 
@@ -315,7 +328,9 @@ where
     /// assert_eq!(*t.matrix(), expected);
     /// ```
     #[inline]
-    pub fn matrix_mut_unchecked(&mut self) -> &mut MatrixN<N, DimNameSum<D, U1>> {
+    pub fn matrix_mut_unchecked(
+        &mut self,
+    ) -> &mut OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> {
         &mut self.matrix
     }
 
@@ -326,7 +341,7 @@ where
     /// `TAffine` because not all projective transformations are affine (the other way-round is
     /// valid though).
     #[inline]
-    pub fn set_category<CNew: SuperTCategoryOf<C>>(self) -> Transform<N, D, CNew> {
+    pub fn set_category<CNew: SuperTCategoryOf<C>>(self) -> Transform<T, CNew, D> {
         Transform::from_matrix_unchecked(self.matrix)
     }
 
@@ -335,7 +350,7 @@ where
     #[deprecated(
         note = "This method is redundant with automatic `Copy` and the `.clone()` method and will be removed in a future release."
     )]
-    pub fn clone_owned(&self) -> Transform<N, D, C> {
+    pub fn clone_owned(&self) -> Transform<T, C, D> {
         Transform::from_matrix_unchecked(self.matrix.clone_owned())
     }
 
@@ -352,7 +367,7 @@ where
     /// assert_eq!(t.into_inner(), m);
     /// ```
     #[inline]
-    pub fn to_homogeneous(&self) -> MatrixN<N, DimNameSum<D, U1>> {
+    pub fn to_homogeneous(&self) -> OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> {
         self.matrix().clone_owned()
     }
 
@@ -381,7 +396,7 @@ where
     /// ```
     #[inline]
     #[must_use = "Did you mean to use try_inverse_mut()?"]
-    pub fn try_inverse(self) -> Option<Transform<N, D, C>> {
+    pub fn try_inverse(self) -> Option<Transform<T, C, D>> {
         if let Some(m) = self.matrix.try_inverse() {
             Some(Transform::from_matrix_unchecked(m))
         } else {
@@ -407,7 +422,7 @@ where
     /// ```
     #[inline]
     #[must_use = "Did you mean to use inverse_mut()?"]
-    pub fn inverse(self) -> Transform<N, D, C>
+    pub fn inverse(self) -> Transform<T, C, D>
     where
         C: SubTCategoryOf<TProjective>,
     {
@@ -470,20 +485,20 @@ where
     }
 }
 
-impl<N, D: DimNameAdd<U1>, C> Transform<N, D, C>
+impl<T, C, const D: usize> Transform<T, C, D>
 where
-    N: RealField,
+    T: RealField,
     C: TCategory,
-    DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>
-        + Allocator<N, DimNameSum<D, U1>>
-        + Allocator<N, D, D>
-        + Allocator<N, D>,
+    Const<D>: DimNameAdd<U1>,
+    DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
+        + Allocator<T, DimNameSum<Const<D>, U1>>, // + Allocator<T, D, D>
+                                                  // + Allocator<T, D>
 {
     /// Transform the given point by this transformation.
     ///
     /// This is the same as the multiplication `self * pt`.
     #[inline]
-    pub fn transform_point(&self, pt: &Point<N, D>) -> Point<N, D> {
+    pub fn transform_point(&self, pt: &Point<T, D>) -> Point<T, D> {
         self * pt
     }
 
@@ -492,24 +507,24 @@ where
     ///
     /// This is the same as the multiplication `self * v`.
     #[inline]
-    pub fn transform_vector(&self, v: &VectorN<N, D>) -> VectorN<N, D> {
+    pub fn transform_vector(&self, v: &SVector<T, D>) -> SVector<T, D> {
         self * v
     }
 }
 
-impl<N: RealField, D: DimNameAdd<U1>, C: TCategory> Transform<N, D, C>
+impl<T: RealField, C: TCategory, const D: usize> Transform<T, C, D>
 where
+    Const<D>: DimNameAdd<U1>,
     C: SubTCategoryOf<TProjective>,
-    DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>
-        + Allocator<N, DimNameSum<D, U1>>
-        + Allocator<N, D, D>
-        + Allocator<N, D>,
+    DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
+        + Allocator<T, DimNameSum<Const<D>, U1>>, // + Allocator<T, D, D>
+                                                  // + Allocator<T, D>
 {
     /// Transform the given point by the inverse of this transformation.
     /// This may be cheaper than inverting the transformation and transforming
     /// the point.
     #[inline]
-    pub fn inverse_transform_point(&self, pt: &Point<N, D>) -> Point<N, D> {
+    pub fn inverse_transform_point(&self, pt: &Point<T, D>) -> Point<T, D> {
         self.clone().inverse() * pt
     }
 
@@ -517,33 +532,37 @@ where
     /// This may be cheaper than inverting the transformation and transforming
     /// the vector.
     #[inline]
-    pub fn inverse_transform_vector(&self, v: &VectorN<N, D>) -> VectorN<N, D> {
+    pub fn inverse_transform_vector(&self, v: &SVector<T, D>) -> SVector<T, D> {
         self.clone().inverse() * v
     }
 }
 
-impl<N: RealField, D: DimNameAdd<U1>> Transform<N, D, TGeneral>
+impl<T: RealField, const D: usize> Transform<T, TGeneral, D>
 where
-    DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
+    Const<D>: DimNameAdd<U1>,
+    DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
 {
     /// A mutable reference to underlying matrix. Use `.matrix_mut_unchecked` instead if this
     /// transformation category is not `TGeneral`.
     #[inline]
-    pub fn matrix_mut(&mut self) -> &mut MatrixN<N, DimNameSum<D, U1>> {
+    pub fn matrix_mut(
+        &mut self,
+    ) -> &mut OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> {
         self.matrix_mut_unchecked()
     }
 }
 
-impl<N: RealField, D: DimNameAdd<U1>, C: TCategory> AbsDiffEq for Transform<N, D, C>
+impl<T: RealField, C: TCategory, const D: usize> AbsDiffEq for Transform<T, C, D>
 where
-    N::Epsilon: Copy,
-    DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
+    Const<D>: DimNameAdd<U1>,
+    T::Epsilon: Copy,
+    DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
 {
-    type Epsilon = N::Epsilon;
+    type Epsilon = T::Epsilon;
 
     #[inline]
     fn default_epsilon() -> Self::Epsilon {
-        N::default_epsilon()
+        T::default_epsilon()
     }
 
     #[inline]
@@ -552,14 +571,15 @@ where
     }
 }
 
-impl<N: RealField, D: DimNameAdd<U1>, C: TCategory> RelativeEq for Transform<N, D, C>
+impl<T: RealField, C: TCategory, const D: usize> RelativeEq for Transform<T, C, D>
 where
-    N::Epsilon: Copy,
-    DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
+    Const<D>: DimNameAdd<U1>,
+    T::Epsilon: Copy,
+    DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
 {
     #[inline]
     fn default_max_relative() -> Self::Epsilon {
-        N::default_max_relative()
+        T::default_max_relative()
     }
 
     #[inline]
@@ -574,14 +594,15 @@ where
     }
 }
 
-impl<N: RealField, D: DimNameAdd<U1>, C: TCategory> UlpsEq for Transform<N, D, C>
+impl<T: RealField, C: TCategory, const D: usize> UlpsEq for Transform<T, C, D>
 where
-    N::Epsilon: Copy,
-    DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
+    Const<D>: DimNameAdd<U1>,
+    T::Epsilon: Copy,
+    DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
 {
     #[inline]
     fn default_max_ulps() -> u32 {
-        N::default_max_ulps()
+        T::default_max_ulps()
     }
 
     #[inline]
diff --git a/src/geometry/transform_alias.rs b/src/geometry/transform_alias.rs
index 58a5ee1e..179a8189 100644
--- a/src/geometry/transform_alias.rs
+++ b/src/geometry/transform_alias.rs
@@ -1,17 +1,15 @@
-use crate::base::dimension::{U2, U3};
-
 use crate::geometry::{TAffine, TGeneral, TProjective, Transform};
 
 /// A 2D general transformation that may not be invertible. Stored as a homogeneous 3x3 matrix.
-pub type Transform2<N> = Transform<N, U2, TGeneral>;
+pub type Transform2<T> = Transform<T, TGeneral, 2>;
 /// An invertible 2D general transformation. Stored as a homogeneous 3x3 matrix.
-pub type Projective2<N> = Transform<N, U2, TProjective>;
+pub type Projective2<T> = Transform<T, TProjective, 2>;
 /// A 2D affine transformation. Stored as a homogeneous 3x3 matrix.
-pub type Affine2<N> = Transform<N, U2, TAffine>;
+pub type Affine2<T> = Transform<T, TAffine, 2>;
 
 /// A 3D general transformation that may not be inversible. Stored as a homogeneous 4x4 matrix.
-pub type Transform3<N> = Transform<N, U3, TGeneral>;
+pub type Transform3<T> = Transform<T, TGeneral, 3>;
 /// An invertible 3D general transformation. Stored as a homogeneous 4x4 matrix.
-pub type Projective3<N> = Transform<N, U3, TProjective>;
+pub type Projective3<T> = Transform<T, TProjective, 3>;
 /// A 3D affine transformation. Stored as a homogeneous 4x4 matrix.
-pub type Affine3<N> = Transform<N, U3, TAffine>;
+pub type Affine3<T> = Transform<T, TAffine, 3>;
diff --git a/src/geometry/transform_construction.rs b/src/geometry/transform_construction.rs
index e0826eeb..e9601864 100644
--- a/src/geometry/transform_construction.rs
+++ b/src/geometry/transform_construction.rs
@@ -4,13 +4,14 @@ use simba::scalar::RealField;
 
 use crate::base::allocator::Allocator;
 use crate::base::dimension::{DimNameAdd, DimNameSum, U1};
-use crate::base::{DefaultAllocator, MatrixN};
+use crate::base::{Const, DefaultAllocator, OMatrix};
 
 use crate::geometry::{TCategory, Transform};
 
-impl<N: RealField, D: DimNameAdd<U1>, C: TCategory> Transform<N, D, C>
+impl<T: RealField, C: TCategory, const D: usize> Transform<T, C, D>
 where
-    DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
+    Const<D>: DimNameAdd<U1>,
+    DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
 {
     /// Creates a new identity transform.
     ///
@@ -42,13 +43,18 @@ where
     /// ```
     #[inline]
     pub fn identity() -> Self {
-        Self::from_matrix_unchecked(MatrixN::<_, DimNameSum<D, U1>>::identity())
+        Self::from_matrix_unchecked(OMatrix::<
+            _,
+            DimNameSum<Const<D>, U1>,
+            DimNameSum<Const<D>, U1>,
+        >::identity())
     }
 }
 
-impl<N: RealField, D: DimNameAdd<U1>, C: TCategory> One for Transform<N, D, C>
+impl<T: RealField, C: TCategory, const D: usize> One for Transform<T, C, D>
 where
-    DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
+    Const<D>: DimNameAdd<U1>,
+    DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
 {
     /// Creates a new identity transform.
     #[inline]
diff --git a/src/geometry/transform_conversion.rs b/src/geometry/transform_conversion.rs
index 6c531f84..e8eb3908 100644
--- a/src/geometry/transform_conversion.rs
+++ b/src/geometry/transform_conversion.rs
@@ -1,74 +1,79 @@
 use simba::scalar::{RealField, SubsetOf};
 
 use crate::base::allocator::Allocator;
-use crate::base::dimension::{DimName, DimNameAdd, DimNameSum, U1};
-use crate::base::{DefaultAllocator, MatrixN};
+use crate::base::dimension::{DimNameAdd, DimNameSum, U1};
+use crate::base::{Const, DefaultAllocator, OMatrix};
 
 use crate::geometry::{SuperTCategoryOf, TCategory, Transform};
 
-impl<N1, N2, D: DimName, C1, C2> SubsetOf<Transform<N2, D, C2>> for Transform<N1, D, C1>
+impl<T1, T2, C1, C2, const D: usize> SubsetOf<Transform<T2, C2, D>> for Transform<T1, C1, D>
 where
-    N1: RealField + SubsetOf<N2>,
-    N2: RealField,
+    T1: RealField + SubsetOf<T2>,
+    T2: RealField,
     C1: TCategory,
     C2: SuperTCategoryOf<C1>,
-    D: DimNameAdd<U1>,
-    DefaultAllocator: Allocator<N1, DimNameSum<D, U1>, DimNameSum<D, U1>>
-        + Allocator<N2, DimNameSum<D, U1>, DimNameSum<D, U1>>,
-    N1::Epsilon: Copy,
-    N2::Epsilon: Copy,
+    Const<D>: DimNameAdd<U1>,
+    DefaultAllocator: Allocator<T1, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
+        + Allocator<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
+    T1::Epsilon: Copy,
+    T2::Epsilon: Copy,
 {
     #[inline]
-    fn to_superset(&self) -> Transform<N2, D, C2> {
+    fn to_superset(&self) -> Transform<T2, C2, D> {
         Transform::from_matrix_unchecked(self.to_homogeneous().to_superset())
     }
 
     #[inline]
-    fn is_in_subset(t: &Transform<N2, D, C2>) -> bool {
+    fn is_in_subset(t: &Transform<T2, C2, D>) -> bool {
         <Self as SubsetOf<_>>::is_in_subset(t.matrix())
     }
 
     #[inline]
-    fn from_superset_unchecked(t: &Transform<N2, D, C2>) -> Self {
+    fn from_superset_unchecked(t: &Transform<T2, C2, D>) -> Self {
         Self::from_superset_unchecked(t.matrix())
     }
 }
 
-impl<N1, N2, D: DimName, C> SubsetOf<MatrixN<N2, DimNameSum<D, U1>>> for Transform<N1, D, C>
+impl<T1, T2, C, const D: usize>
+    SubsetOf<OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>>
+    for Transform<T1, C, D>
 where
-    N1: RealField + SubsetOf<N2>,
-    N2: RealField,
+    T1: RealField + SubsetOf<T2>,
+    T2: RealField,
     C: TCategory,
-    D: DimNameAdd<U1>,
-    DefaultAllocator: Allocator<N1, DimNameSum<D, U1>, DimNameSum<D, U1>>
-        + Allocator<N2, DimNameSum<D, U1>, DimNameSum<D, U1>>,
-    N1::Epsilon: Copy,
-    N2::Epsilon: Copy,
+    Const<D>: DimNameAdd<U1>,
+    DefaultAllocator: Allocator<T1, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
+        + Allocator<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
+    T1::Epsilon: Copy,
+    T2::Epsilon: Copy,
 {
     #[inline]
-    fn to_superset(&self) -> MatrixN<N2, DimNameSum<D, U1>> {
+    fn to_superset(&self) -> OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> {
         self.matrix().to_superset()
     }
 
     #[inline]
-    fn is_in_subset(m: &MatrixN<N2, DimNameSum<D, U1>>) -> bool {
+    fn is_in_subset(m: &OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>) -> bool {
         C::check_homogeneous_invariants(m)
     }
 
     #[inline]
-    fn from_superset_unchecked(m: &MatrixN<N2, DimNameSum<D, U1>>) -> Self {
+    fn from_superset_unchecked(
+        m: &OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
+    ) -> Self {
         Self::from_matrix_unchecked(crate::convert_ref_unchecked(m))
     }
 }
 
-impl<N: RealField, D: DimName, C> From<Transform<N, D, C>> for MatrixN<N, DimNameSum<D, U1>>
+impl<T: RealField, C, const D: usize> From<Transform<T, C, D>>
+    for OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
 where
-    D: DimNameAdd<U1>,
+    Const<D>: DimNameAdd<U1>,
     C: TCategory,
-    DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
+    DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
 {
     #[inline]
-    fn from(t: Transform<N, D, C>) -> Self {
+    fn from(t: Transform<T, C, D>) -> Self {
         t.to_homogeneous()
     }
 }
diff --git a/src/geometry/transform_ops.rs b/src/geometry/transform_ops.rs
index 01cf4d3d..29781c3c 100644
--- a/src/geometry/transform_ops.rs
+++ b/src/geometry/transform_ops.rs
@@ -4,8 +4,8 @@ use std::ops::{Div, DivAssign, Index, IndexMut, Mul, MulAssign};
 use simba::scalar::{ClosedAdd, ClosedMul, RealField, SubsetOf};
 
 use crate::base::allocator::Allocator;
-use crate::base::dimension::{DimName, DimNameAdd, DimNameSum, U1, U3, U4};
-use crate::base::{DefaultAllocator, MatrixN, Scalar, VectorN};
+use crate::base::dimension::{DimNameAdd, DimNameSum, U1};
+use crate::base::{Const, DefaultAllocator, OMatrix, SVector, Scalar};
 
 use crate::geometry::{
     Isometry, Point, Rotation, Similarity, SubTCategoryOf, SuperTCategoryOf, TAffine, TCategory,
@@ -79,36 +79,40 @@ use crate::geometry::{
  * Indexing.
  *
  */
-impl<N: RealField, D, C: TCategory> Index<(usize, usize)> for Transform<N, D, C>
+impl<T: RealField, C: TCategory, const D: usize> Index<(usize, usize)> for Transform<T, C, D>
 where
-    D: DimName + DimNameAdd<U1>,
-    DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
+    Const<D>: DimNameAdd<U1>,
+    DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
 {
-    type Output = N;
+    type Output = T;
 
     #[inline]
-    fn index(&self, ij: (usize, usize)) -> &N {
+    fn index(&self, ij: (usize, usize)) -> &T {
         self.matrix().index(ij)
     }
 }
 
 // Only general transformations are mutably indexable.
-impl<N: RealField, D> IndexMut<(usize, usize)> for Transform<N, D, TGeneral>
+impl<T: RealField, const D: usize> IndexMut<(usize, usize)> for Transform<T, TGeneral, D>
 where
-    D: DimName + DimNameAdd<U1>,
-    DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
+    Const<D>: DimNameAdd<U1>,
+    DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
 {
     #[inline]
-    fn index_mut(&mut self, ij: (usize, usize)) -> &mut N {
+    fn index_mut(&mut self, ij: (usize, usize)) -> &mut T {
         self.matrix_mut().index_mut(ij)
     }
 }
 
 // Transform × Vector
 md_impl_all!(
-    Mul, mul where N: RealField;
-    (DimNameSum<D, U1>, DimNameSum<D, U1>), (D, U1) for D: DimNameAdd<U1>, C: TCategory;
-    self: Transform<N, D, C>, rhs: VectorN<N, D>, Output = VectorN<N, D>;
+    Mul, mul where T: RealField;
+    (DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>), (Const<D>, U1)
+    const D;
+    for C;
+    where Const<D>: DimNameAdd<U1>, C: TCategory,
+          DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>;
+    self: Transform<T, C, D>, rhs: SVector<T, D>, Output = SVector<T, D>;
     [val val] => &self * &rhs;
     [ref val] =>  self * &rhs;
     [val ref] => &self *  rhs;
@@ -116,7 +120,7 @@ md_impl_all!(
         let transform = self.matrix().fixed_slice::<D, D>(0, 0);
 
         if C::has_normalizer() {
-            let normalizer = self.matrix().fixed_slice::<U1, D>(D::dim(), 0);
+            let normalizer = self.matrix().fixed_slice::<1, D>(D, 0);
             let n = normalizer.tr_dot(&rhs);
 
             if !n.is_zero() {
@@ -130,21 +134,24 @@ md_impl_all!(
 
 // Transform × Point
 md_impl_all!(
-    Mul, mul where N: RealField;
-    (DimNameSum<D, U1>, DimNameSum<D, U1>), (D, U1) for D: DimNameAdd<U1>, C: TCategory
-    where DefaultAllocator: Allocator<N, D, D>;
-    self: Transform<N, D, C>, rhs: Point<N, D>, Output = Point<N, D>;
+    Mul, mul where T: RealField;
+    (DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>), (Const<D>, U1)
+    const D;
+    for C;
+    where Const<D>: DimNameAdd<U1>, C: TCategory,
+          DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>;
+    self: Transform<T, C, D>, rhs: Point<T, D>, Output = Point<T, D>;
     [val val] => &self * &rhs;
     [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, U1>(0, D::dim());
+        let translation = self.matrix().fixed_slice::<D, 1>(0, D);
 
         if C::has_normalizer() {
-            let normalizer = self.matrix().fixed_slice::<U1, D>(D::dim(), 0);
+            let normalizer = self.matrix().fixed_slice::<1, D>(D, 0);
             #[allow(clippy::suspicious_arithmetic_impl)]
-            let n = normalizer.tr_dot(&rhs.coords) + unsafe { *self.matrix().get_unchecked((D::dim(), D::dim())) };
+            let n = normalizer.tr_dot(&rhs.coords) + unsafe { *self.matrix().get_unchecked((D, D)) };
 
             if !n.is_zero() {
                 return (transform * rhs + translation) / n;
@@ -157,9 +164,13 @@ md_impl_all!(
 
 // Transform × Transform
 md_impl_all!(
-    Mul, mul where N: RealField;
-    (DimNameSum<D, U1>, DimNameSum<D, U1>), (DimNameSum<D, U1>, DimNameSum<D, U1>) for D: DimNameAdd<U1>, CA: TCategoryMul<CB>, CB: TCategory;
-    self: Transform<N, D, CA>, rhs: Transform<N, D, CB>, Output = Transform<N, D, CA::Representative>;
+    Mul, mul where T: RealField;
+    (DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>), (DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>)
+    const D;
+    for CA, CB;
+    where Const<D>: DimNameAdd<U1>, CA: TCategoryMul<CB>, CB: TCategory,
+          DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>;
+    self: Transform<T, CA, D>, rhs: Transform<T, CB, D>, Output = Transform<T, CA::Representative, D>;
     [val val] => Self::Output::from_matrix_unchecked(self.into_inner() * rhs.into_inner());
     [ref val] => Self::Output::from_matrix_unchecked(self.matrix() * rhs.into_inner());
     [val ref] => Self::Output::from_matrix_unchecked(self.into_inner() * rhs.matrix());
@@ -168,9 +179,14 @@ md_impl_all!(
 
 // Transform × Rotation
 md_impl_all!(
-    Mul, mul where N: RealField;
-    (DimNameSum<D, U1>, DimNameSum<D, U1>), (D, D) for D: DimNameAdd<U1>, C: TCategoryMul<TAffine>;
-    self: Transform<N, D, C>, rhs: Rotation<N, D>, Output = Transform<N, D, C::Representative>;
+    Mul, mul
+    where T: RealField;
+    (DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>), (Const<D>, Const<D>)
+    const D;
+    for C;
+    where Const<D>: DimNameAdd<U1>, C: TCategoryMul<TAffine>,
+          DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>;
+    self: Transform<T, C, D>, rhs: Rotation<T, D>, Output = Transform<T, C::Representative, D>;
     [val val] => Self::Output::from_matrix_unchecked(self.into_inner() * rhs.to_homogeneous());
     [ref val] => Self::Output::from_matrix_unchecked(self.matrix() * rhs.to_homogeneous());
     [val ref] => Self::Output::from_matrix_unchecked(self.into_inner() * rhs.to_homogeneous());
@@ -179,9 +195,13 @@ md_impl_all!(
 
 // Rotation × Transform
 md_impl_all!(
-    Mul, mul where N: RealField;
-    (D, D), (DimNameSum<D, U1>, DimNameSum<D, U1>) for D: DimNameAdd<U1>, C: TCategoryMul<TAffine>;
-    self: Rotation<N, D>, rhs: Transform<N, D, C>, Output = Transform<N, D, C::Representative>;
+    Mul, mul where T: RealField;
+    (Const<D>, Const<D>), (DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>)
+    const D;
+    for C;
+    where Const<D>: DimNameAdd<U1>, C: TCategoryMul<TAffine>,
+          DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>;
+    self: Rotation<T, D>, rhs: Transform<T, C, D>, Output = Transform<T, C::Representative, D>;
     [val val] => Self::Output::from_matrix_unchecked(self.to_homogeneous() * rhs.into_inner());
     [ref val] => Self::Output::from_matrix_unchecked(self.to_homogeneous() * rhs.into_inner());
     [val ref] => Self::Output::from_matrix_unchecked(self.to_homogeneous() * rhs.matrix());
@@ -190,9 +210,12 @@ md_impl_all!(
 
 // Transform × UnitQuaternion
 md_impl_all!(
-    Mul, mul where N: RealField;
-    (U4, U4), (U4, U1) for C: TCategoryMul<TAffine>;
-    self: Transform<N, U3, C>, rhs: UnitQuaternion<N>, Output = Transform<N, U3, C::Representative>;
+    Mul, mul where T: RealField;
+    (U4, U4), (U4, U1)
+    const;
+    for C;
+    where C: TCategoryMul<TAffine>;
+    self: Transform<T, C, 3>, rhs: UnitQuaternion<T>, Output = Transform<T, C::Representative, 3>;
     [val val] => Self::Output::from_matrix_unchecked(self.into_inner() * rhs.to_homogeneous());
     [ref val] => Self::Output::from_matrix_unchecked(self.matrix() * rhs.to_homogeneous());
     [val ref] => Self::Output::from_matrix_unchecked(self.into_inner() * rhs.to_homogeneous());
@@ -201,9 +224,12 @@ md_impl_all!(
 
 // UnitQuaternion × Transform
 md_impl_all!(
-    Mul, mul where N: RealField;
-    (U4, U1), (U4, U4) for C: TCategoryMul<TAffine>;
-    self: UnitQuaternion<N>, rhs: Transform<N, U3, C>, Output = Transform<N, U3, C::Representative>;
+    Mul, mul where T: RealField;
+    (U4, U1), (U4, U4)
+    const;
+    for C;
+    where C: TCategoryMul<TAffine>;
+    self: UnitQuaternion<T>, rhs: Transform<T, C, 3>, Output = Transform<T, C::Representative, 3>;
     [val val] => Self::Output::from_matrix_unchecked(self.to_homogeneous() * rhs.into_inner());
     [ref val] => Self::Output::from_matrix_unchecked(self.to_homogeneous() * rhs.into_inner());
     [val ref] => Self::Output::from_matrix_unchecked(self.to_homogeneous() * rhs.matrix());
@@ -212,10 +238,13 @@ md_impl_all!(
 
 // Transform × Isometry
 md_impl_all!(
-    Mul, mul where N: RealField;
-    (DimNameSum<D, U1>, DimNameSum<D, U1>), (D, U1)
-    for D: DimNameAdd<U1>, C: TCategoryMul<TAffine>, R: SubsetOf<MatrixN<N, DimNameSum<D, U1>> >;
-    self: Transform<N, D, C>, rhs: Isometry<N, D, R>, Output = Transform<N, D, C::Representative>;
+    Mul, mul where T: RealField;
+    (DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>), (Const<D>, U1)
+    const D;
+    for C, R;
+    where Const<D>: DimNameAdd<U1>, C: TCategoryMul<TAffine>, R: SubsetOf<OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> >,
+          DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>;
+    self: Transform<T, C, D>, rhs: Isometry<T, R, D>, Output = Transform<T, C::Representative, D>;
     [val val] => Self::Output::from_matrix_unchecked(self.into_inner() * rhs.to_homogeneous());
     [ref val] => Self::Output::from_matrix_unchecked(self.matrix() * rhs.to_homogeneous());
     [val ref] => Self::Output::from_matrix_unchecked(self.into_inner() * rhs.to_homogeneous());
@@ -224,10 +253,13 @@ md_impl_all!(
 
 // Isometry × Transform
 md_impl_all!(
-    Mul, mul where N: RealField;
-    (D, U1), (DimNameSum<D, U1>, DimNameSum<D, U1>)
-    for D: DimNameAdd<U1>, C: TCategoryMul<TAffine>, R: SubsetOf<MatrixN<N, DimNameSum<D, U1>> >;
-    self: Isometry<N, D, R>, rhs: Transform<N, D, C>, Output = Transform<N, D, C::Representative>;
+    Mul, mul where T: RealField;
+    (Const<D>, U1), (DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>)
+    const D;
+    for C, R;
+    where Const<D>: DimNameAdd<U1>, C: TCategoryMul<TAffine>, R: SubsetOf<OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> >,
+          DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>;
+    self: Isometry<T, R, D>, rhs: Transform<T, C, D>, Output = Transform<T, C::Representative, D>;
     [val val] => Self::Output::from_matrix_unchecked(self.to_homogeneous() * rhs.into_inner());
     [ref val] => Self::Output::from_matrix_unchecked(self.to_homogeneous() * rhs.into_inner());
     [val ref] => Self::Output::from_matrix_unchecked(self.to_homogeneous() * rhs.matrix());
@@ -236,10 +268,13 @@ md_impl_all!(
 
 // Transform × Similarity
 md_impl_all!(
-    Mul, mul where N: RealField;
-    (DimNameSum<D, U1>, DimNameSum<D, U1>), (D, U1)
-    for D: DimNameAdd<U1>, C: TCategoryMul<TAffine>, R: SubsetOf<MatrixN<N, DimNameSum<D, U1>> >;
-    self: Transform<N, D, C>, rhs: Similarity<N, D, R>, Output = Transform<N, D, C::Representative>;
+    Mul, mul where T: RealField;
+    (DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>), (Const<D>, U1)
+    const D;
+    for C, R;
+    where Const<D>: DimNameAdd<U1>, C: TCategoryMul<TAffine>, R: SubsetOf<OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> >,
+          DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>;
+    self: Transform<T, C, D>, rhs: Similarity<T, R, D>, Output = Transform<T, C::Representative, D>;
     [val val] => Self::Output::from_matrix_unchecked(self.into_inner() * rhs.to_homogeneous());
     [ref val] => Self::Output::from_matrix_unchecked(self.matrix() * rhs.to_homogeneous());
     [val ref] => Self::Output::from_matrix_unchecked(self.into_inner() * rhs.to_homogeneous());
@@ -248,10 +283,13 @@ md_impl_all!(
 
 // Similarity × Transform
 md_impl_all!(
-    Mul, mul where N: RealField;
-    (D, U1), (DimNameSum<D, U1>, DimNameSum<D, U1>)
-    for D: DimNameAdd<U1>, C: TCategoryMul<TAffine>, R: SubsetOf<MatrixN<N, DimNameSum<D, U1>> >;
-    self: Similarity<N, D, R>, rhs: Transform<N, D, C>, Output = Transform<N, D, C::Representative>;
+    Mul, mul where T: RealField;
+    (Const<D>, U1), (DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>)
+    const D;
+    for C, R;
+    where Const<D>: DimNameAdd<U1>, C: TCategoryMul<TAffine>, R: SubsetOf<OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> >,
+          DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>;
+    self: Similarity<T, R, D>, rhs: Transform<T, C, D>, Output = Transform<T, C::Representative, D>;
     [val val] => Self::Output::from_matrix_unchecked(self.to_homogeneous() * rhs.into_inner());
     [ref val] => Self::Output::from_matrix_unchecked(self.to_homogeneous() * rhs.into_inner());
     [val ref] => Self::Output::from_matrix_unchecked(self.to_homogeneous() * rhs.matrix());
@@ -268,9 +306,13 @@ md_impl_all!(
  */
 // Transform × Translation
 md_impl_all!(
-    Mul, mul where N: RealField;
-    (DimNameSum<D, U1>, DimNameSum<D, U1>), (D, U1) for D: DimNameAdd<U1>, C: TCategoryMul<TAffine>;
-    self: Transform<N, D, C>, rhs: Translation<N, D>, Output = Transform<N, D, C::Representative>;
+    Mul, mul where T: RealField;
+    (DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>), (Const<D>, U1)
+    const D;
+    for C;
+    where Const<D>: DimNameAdd<U1>, C: TCategoryMul<TAffine>,
+          DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>;
+    self: Transform<T, C, D>, rhs: Translation<T, D>, Output = Transform<T, C::Representative, D>;
     [val val] => Self::Output::from_matrix_unchecked(self.into_inner() * rhs.to_homogeneous());
     [ref val] => Self::Output::from_matrix_unchecked(self.matrix() * rhs.to_homogeneous());
     [val ref] => Self::Output::from_matrix_unchecked(self.into_inner() * rhs.to_homogeneous());
@@ -279,10 +321,13 @@ md_impl_all!(
 
 // Translation × Transform
 md_impl_all!(
-    Mul, mul where N: RealField;
-    (D, U1), (DimNameSum<D, U1>, DimNameSum<D, U1>)
-    for D: DimNameAdd<U1>, C: TCategoryMul<TAffine>;
-    self: Translation<N, D>, rhs: Transform<N, D, C>, Output = Transform<N, D, C::Representative>;
+    Mul, mul where T: RealField;
+    (Const<D>, U1), (DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>)
+    const D;
+    for C;
+    where Const<D>: DimNameAdd<U1>, C: TCategoryMul<TAffine>,
+          DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>;
+    self: Translation<T, D>, rhs: Transform<T, C, D>, Output = Transform<T, C::Representative, D>;
     [val val] => Self::Output::from_matrix_unchecked(self.to_homogeneous() * rhs.into_inner());
     [ref val] => Self::Output::from_matrix_unchecked(self.to_homogeneous() * rhs.into_inner());
     [val ref] => Self::Output::from_matrix_unchecked(self.to_homogeneous() * rhs.matrix());
@@ -291,9 +336,13 @@ md_impl_all!(
 
 // Transform ÷ Transform
 md_impl_all!(
-    Div, div where N: RealField;
-    (DimNameSum<D, U1>, DimNameSum<D, U1>), (DimNameSum<D, U1>, DimNameSum<D, U1>) for D: DimNameAdd<U1>, CA: TCategoryMul<CB>, CB: SubTCategoryOf<TProjective>;
-    self: Transform<N, D, CA>, rhs: Transform<N, D, CB>, Output = Transform<N, D, CA::Representative>;
+    Div, div where T: RealField;
+    (DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>), (DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>)
+    const D;
+    for CA, CB;
+    where Const<D>: DimNameAdd<U1>, CA: TCategoryMul<CB>, CB: SubTCategoryOf<TProjective>,
+          DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>;
+    self: Transform<T, CA, D>, rhs: Transform<T, CB, D>, Output = Transform<T, CA::Representative, D>;
     [val val] => #[allow(clippy::suspicious_arithmetic_impl)] { self * rhs.inverse() };
     [ref val] => #[allow(clippy::suspicious_arithmetic_impl)] { self * rhs.inverse() };
     [val ref] => #[allow(clippy::suspicious_arithmetic_impl)] { self * rhs.clone().inverse() };
@@ -302,9 +351,13 @@ md_impl_all!(
 
 // Transform ÷ Rotation
 md_impl_all!(
-    Div, div where N: RealField;
-    (DimNameSum<D, U1>, DimNameSum<D, U1>), (D, D) for D: DimNameAdd<U1>, C: TCategoryMul<TAffine>;
-    self: Transform<N, D, C>, rhs: Rotation<N, D>, Output = Transform<N, D, C::Representative>;
+    Div, div where T: RealField;
+    (DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>), (Const<D>, Const<D>)
+    const D;
+    for C;
+    where Const<D>: DimNameAdd<U1>, C: TCategoryMul<TAffine>,
+          DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>;
+    self: Transform<T, C, D>, rhs: Rotation<T, D>, Output = Transform<T, C::Representative, D>;
     [val val] => #[allow(clippy::suspicious_arithmetic_impl)] { self * rhs.inverse() };
     [ref val] => #[allow(clippy::suspicious_arithmetic_impl)] { self * rhs.inverse() };
     [val ref] => #[allow(clippy::suspicious_arithmetic_impl)] { self * rhs.inverse() };
@@ -313,9 +366,13 @@ md_impl_all!(
 
 // Rotation ÷ Transform
 md_impl_all!(
-    Div, div where N: RealField;
-    (D, D), (DimNameSum<D, U1>, DimNameSum<D, U1>) for D: DimNameAdd<U1>, C: TCategoryMul<TAffine>;
-    self: Rotation<N, D>, rhs: Transform<N, D, C>, Output = Transform<N, D, C::Representative>;
+    Div, div where T: RealField;
+    (Const<D>, Const<D>), (DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>)
+    const D;
+    for C;
+    where Const<D>: DimNameAdd<U1>, C: TCategoryMul<TAffine>,
+          DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>;
+    self: Rotation<T, D>, rhs: Transform<T, C, D>, Output = Transform<T, C::Representative, D>;
     [val val] => #[allow(clippy::suspicious_arithmetic_impl)] { self.inverse() * rhs };
     [ref val] => #[allow(clippy::suspicious_arithmetic_impl)] { self.inverse() * rhs };
     [val ref] => #[allow(clippy::suspicious_arithmetic_impl)] { self.inverse() * rhs };
@@ -324,9 +381,12 @@ md_impl_all!(
 
 // Transform ÷ UnitQuaternion
 md_impl_all!(
-    Div, div where N: RealField;
-    (U4, U4), (U4, U1) for C: TCategoryMul<TAffine>;
-    self: Transform<N, U3, C>, rhs: UnitQuaternion<N>, Output = Transform<N, U3, C::Representative>;
+    Div, div where T: RealField;
+    (U4, U4), (U4, U1)
+    const;
+    for C;
+    where C: TCategoryMul<TAffine>;
+    self: Transform<T, C, 3>, rhs: UnitQuaternion<T>, Output = Transform<T, C::Representative, 3>;
     [val val] => #[allow(clippy::suspicious_arithmetic_impl)] { self * rhs.inverse() };
     [ref val] => #[allow(clippy::suspicious_arithmetic_impl)] { self * rhs.inverse() };
     [val ref] => #[allow(clippy::suspicious_arithmetic_impl)] { self * rhs.inverse() };
@@ -335,9 +395,12 @@ md_impl_all!(
 
 // UnitQuaternion ÷ Transform
 md_impl_all!(
-    Div, div where N: RealField;
-    (U4, U1), (U4, U4) for C: TCategoryMul<TAffine>;
-    self: UnitQuaternion<N>, rhs: Transform<N, U3, C>, Output = Transform<N, U3, C::Representative>;
+    Div, div where T: RealField;
+    (U4, U1), (U4, U4)
+    const;
+    for C;
+    where C: TCategoryMul<TAffine>;
+    self: UnitQuaternion<T>, rhs: Transform<T, C, 3>, Output = Transform<T, C::Representative, 3>;
     [val val] => #[allow(clippy::suspicious_arithmetic_impl)] { self.inverse() * rhs };
     [ref val] => #[allow(clippy::suspicious_arithmetic_impl)] { self.inverse() * rhs };
     [val ref] => #[allow(clippy::suspicious_arithmetic_impl)] { self.inverse() * rhs };
@@ -346,11 +409,11 @@ md_impl_all!(
 
 //      // Transform ÷ Isometry
 //      md_impl_all!(
-//          Div, div where N: RealField;
-//          (DimNameSum<D, U1>, DimNameSum<D, U1>), (D, U1)
-//          for D: DimNameAdd<U1>, C: TCategoryMul<TAffine>, R: SubsetOf<MatrixN<N, DimNameSum<D, U1>> >
-//          where SB::Alloc: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1> >;
-//          self: Transform<N, D, C>, rhs: Isometry<N, D, R>, Output = Transform<N, D, C::Representative>;
+//          Div, div where T: RealField;
+//          (DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>), (Const<D>, U1)
+//          for Const<D>: DimNameAdd<U1>, C: TCategoryMul<TAffine>, R: SubsetOf<OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> >
+//          where SB::Alloc: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1> >;
+//          self: Transform<T, C, D>, rhs: Isometry<T, R, D>, Output = Transform<T, C::Representative, D>;
 //          [val val] => Self::Output::from_matrix_unchecked(self.into_inner() * rhs.inverse().to_homogeneous());
 //          [ref val] => Self::Output::from_matrix_unchecked(self.matrix() * rhs.inverse().to_homogeneous());
 //          [val ref] => Self::Output::from_matrix_unchecked(self.into_inner() * rhs.inverse().to_homogeneous());
@@ -359,11 +422,11 @@ md_impl_all!(
 
 //      // Isometry ÷ Transform
 //      md_impl_all!(
-//          Div, div where N: RealField;
-//          (D, U1), (DimNameSum<D, U1>, DimNameSum<D, U1>)
-//          for D: DimNameAdd<U1>, C: TCategoryMul<TAffine>, R: SubsetOf<MatrixN<N, DimNameSum<D, U1>> >
-//          where SA::Alloc: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1> >;
-//          self: Isometry<N, D, R>, rhs: Transform<N, D, C>, Output = Transform<N, D, C::Representative>;
+//          Div, div where T: RealField;
+//          (Const<D>, U1), (DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>)
+//          for Const<D>: DimNameAdd<U1>, C: TCategoryMul<TAffine>, R: SubsetOf<OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> >
+//          where SA::Alloc: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1> >;
+//          self: Isometry<T, R, D>, rhs: Transform<T, C, D>, Output = Transform<T, C::Representative, D>;
 //          [val val] => Self::Output::from_matrix_unchecked(self.to_homogeneous() * rhs.into_inner());
 //          [ref val] => Self::Output::from_matrix_unchecked(self.to_homogeneous() * rhs.into_inner());
 //          [val ref] => Self::Output::from_matrix_unchecked(self.to_homogeneous() * rhs.matrix());
@@ -372,12 +435,12 @@ md_impl_all!(
 
 //      // Transform ÷ Similarity
 //      md_impl_all!(
-//          Div, div where N: RealField;
-//          (DimNameSum<D, U1>, DimNameSum<D, U1>), (D, U1)
-//          for D: DimNameAdd<U1>, C: TCategoryMul<TAffine>, R: SubsetOf<MatrixN<N, DimNameSum<D, U1>> >
-//          where SB::Alloc: Allocator<N, D, D >
-//          where SB::Alloc: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1> >;
-//          self: Transform<N, D, C>, rhs: Similarity<N, D, R>, Output = Transform<N, D, C::Representative>;
+//          Div, div where T: RealField;
+//          (DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>), (Const<D>, U1)
+//          for Const<D>: DimNameAdd<U1>, C: TCategoryMul<TAffine>, R: SubsetOf<OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> >
+//          where SB::Alloc: Allocator<T, D, D >
+//          where SB::Alloc: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1> >;
+//          self: Transform<T, C, D>, rhs: Similarity<T, R, D>, Output = Transform<T, C::Representative, D>;
 //          [val val] => Self::Output::from_matrix_unchecked(self.into_inner() * rhs.to_homogeneous());
 //          [ref val] => Self::Output::from_matrix_unchecked(self.matrix() * rhs.to_homogeneous());
 //          [val ref] => Self::Output::from_matrix_unchecked(self.into_inner() * rhs.to_homogeneous());
@@ -386,12 +449,12 @@ md_impl_all!(
 
 //      // Similarity ÷ Transform
 //      md_impl_all!(
-//          Div, div where N: RealField;
-//          (D, U1), (DimNameSum<D, U1>, DimNameSum<D, U1>)
-//          for D: DimNameAdd<U1>, C: TCategoryMul<TAffine>, R: SubsetOf<MatrixN<N, DimNameSum<D, U1>> >
-//          where SA::Alloc: Allocator<N, D, D >
-//          where SA::Alloc: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1> >;
-//          self: Similarity<N, D, R>, rhs: Transform<N, D, C>, Output = Transform<N, D, C::Representative>;
+//          Div, div where T: RealField;
+//          (Const<D>, U1), (DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>)
+//          for Const<D>: DimNameAdd<U1>, C: TCategoryMul<TAffine>, R: SubsetOf<OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> >
+//          where SA::Alloc: Allocator<T, D, D >
+//          where SA::Alloc: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1> >;
+//          self: Similarity<T, R, D>, rhs: Transform<T, C, D>, Output = Transform<T, C::Representative, D>;
 //          [val val] => Self::Output::from_matrix_unchecked(self.to_homogeneous() * rhs.into_inner());
 //          [ref val] => Self::Output::from_matrix_unchecked(self.to_homogeneous() * rhs.into_inner());
 //          [val ref] => Self::Output::from_matrix_unchecked(self.to_homogeneous() * rhs.matrix());
@@ -400,9 +463,13 @@ md_impl_all!(
 
 // Transform ÷ Translation
 md_impl_all!(
-    Div, div where N: RealField;
-    (DimNameSum<D, U1>, DimNameSum<D, U1>), (D, U1) for D: DimNameAdd<U1>, C: TCategoryMul<TAffine>;
-    self: Transform<N, D, C>, rhs: Translation<N, D>, Output = Transform<N, D, C::Representative>;
+    Div, div where T: RealField;
+    (DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>), (Const<D>, U1)
+    const D;
+    for C;
+    where Const<D>: DimNameAdd<U1>, C: TCategoryMul<TAffine>,
+          DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>;
+    self: Transform<T, C, D>, rhs: Translation<T, D>, Output = Transform<T, C::Representative, D>;
     [val val] => #[allow(clippy::suspicious_arithmetic_impl)] { self * rhs.inverse() };
     [ref val] => #[allow(clippy::suspicious_arithmetic_impl)] { self * rhs.inverse() };
     [val ref] => #[allow(clippy::suspicious_arithmetic_impl)] { self * rhs.inverse() };
@@ -411,10 +478,13 @@ md_impl_all!(
 
 // Translation ÷ Transform
 md_impl_all!(
-    Div, div where N: RealField;
-    (D, U1), (DimNameSum<D, U1>, DimNameSum<D, U1>)
-    for D: DimNameAdd<U1>, C: TCategoryMul<TAffine>;
-    self: Translation<N, D>, rhs: Transform<N, D, C>, Output = Transform<N, D, C::Representative>;
+    Div, div where T: RealField;
+    (Const<D>, U1), (DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>)
+    const D;
+    for C;
+    where Const<D>: DimNameAdd<U1>, C: TCategoryMul<TAffine>,
+          DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>;
+    self: Translation<T, D>, rhs: Transform<T, C, D>, Output = Transform<T, C::Representative, D>;
     [val val] => #[allow(clippy::suspicious_arithmetic_impl)] { self.inverse() * rhs };
     [ref val] => #[allow(clippy::suspicious_arithmetic_impl)] { self.inverse() * rhs };
     [val ref] => #[allow(clippy::suspicious_arithmetic_impl)] { self.inverse() * rhs };
@@ -423,29 +493,39 @@ md_impl_all!(
 
 // Transform ×= Transform
 md_assign_impl_all!(
-    MulAssign, mul_assign where N: RealField;
-    (DimNameSum<D, U1>, DimNameSum<D, U1>), (DimNameSum<D, U1>, DimNameSum<D, U1>) for D: DimNameAdd<U1>, CA: TCategory, CB: SubTCategoryOf<CA>;
-    self: Transform<N, D, CA>, rhs: Transform<N, D, CB>;
+    MulAssign, mul_assign where T: RealField;
+    (DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>), (DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>)
+    const D;
+    for CA, CB;
+    where Const<D>: DimNameAdd<U1>, CA: TCategory, CB: SubTCategoryOf<CA>,
+          DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>;
+    self: Transform<T, CA, D>, rhs: Transform<T, CB, D>;
     [val] => *self.matrix_mut_unchecked() *= rhs.into_inner();
     [ref] => *self.matrix_mut_unchecked() *= rhs.matrix();
 );
 
 // Transform ×= Similarity
 md_assign_impl_all!(
-    MulAssign, mul_assign where N: RealField;
-    (DimNameSum<D, U1>, DimNameSum<D, U1>), (D, U1)
-    for D: DimNameAdd<U1>, C: TCategory, R: SubsetOf<MatrixN<N, DimNameSum<D, U1>> >;
-    self: Transform<N, D, C>, rhs: Similarity<N, D, R>;
+    MulAssign, mul_assign where T: RealField;
+    (DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>), (Const<D>, U1)
+    const D;
+    for C, R;
+    where Const<D>: DimNameAdd<U1>, C: TCategory, R: SubsetOf<OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> >,
+          DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>;
+    self: Transform<T, C, D>, rhs: Similarity<T, R, D>;
     [val] => *self.matrix_mut_unchecked() *= rhs.to_homogeneous();
     [ref] => *self.matrix_mut_unchecked() *= rhs.to_homogeneous();
 );
 
 // Transform ×= Isometry
 md_assign_impl_all!(
-    MulAssign, mul_assign where N: RealField;
-    (DimNameSum<D, U1>, DimNameSum<D, U1>), (D, U1)
-    for D: DimNameAdd<U1>, C: TCategory, R: SubsetOf<MatrixN<N, DimNameSum<D, U1>> >;
-    self: Transform<N, D, C>, rhs: Isometry<N, D, R>;
+    MulAssign, mul_assign where T: RealField;
+    (DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>), (Const<D>, U1)
+    const D;
+    for C, R;
+    where Const<D>: DimNameAdd<U1>, C: TCategory, R: SubsetOf<OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> >,
+          DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>;
+    self: Transform<T, C, D>, rhs: Isometry<T, R, D>;
     [val] => *self.matrix_mut_unchecked() *= rhs.to_homogeneous();
     [ref] => *self.matrix_mut_unchecked() *= rhs.to_homogeneous();
 );
@@ -460,37 +540,51 @@ md_assign_impl_all!(
  */
 // Transform ×= Translation
 md_assign_impl_all!(
-    MulAssign, mul_assign where N: RealField;
-    (DimNameSum<D, U1>, DimNameSum<D, U1>), (D, U1) for D: DimNameAdd<U1>, C: TCategory;
-    self: Transform<N, D, C>, rhs: Translation<N, D>;
+    MulAssign, mul_assign where T: RealField;
+    (DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>), (Const<D>, U1)
+    const D;
+    for C;
+    where Const<D>: DimNameAdd<U1>, C: TCategory,
+          DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>;
+    self: Transform<T, C, D>, rhs: Translation<T, D>;
     [val] => *self.matrix_mut_unchecked() *= rhs.to_homogeneous();
     [ref] => *self.matrix_mut_unchecked() *= rhs.to_homogeneous();
 );
 
 // Transform ×= Rotation
 md_assign_impl_all!(
-    MulAssign, mul_assign where N: RealField;
-    (DimNameSum<D, U1>, DimNameSum<D, U1>), (D, D) for D: DimNameAdd<U1>, C: TCategory;
-    self: Transform<N, D, C>, rhs: Rotation<N, D>;
+    MulAssign, mul_assign where T: RealField;
+    (DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>), (Const<D>, Const<D>)
+    const D;
+    for C;
+    where Const<D>: DimNameAdd<U1>, C: TCategory,
+          DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>;
+    self: Transform<T, C, D>, rhs: Rotation<T, D>;
     [val] => *self.matrix_mut_unchecked() *= rhs.to_homogeneous();
     [ref] => *self.matrix_mut_unchecked() *= rhs.to_homogeneous();
 );
 
 // Transform ×= UnitQuaternion
 md_assign_impl_all!(
-    MulAssign, mul_assign where N: RealField;
-    (U4, U4), (U4, U1) for C: TCategory;
-    self: Transform<N, U3, C>, rhs: UnitQuaternion<N>;
+    MulAssign, mul_assign where T: RealField;
+    (U4, U4), (U4, U1)
+    const;
+    for C;
+    where C: TCategory;
+    self: Transform<T, C, 3>, rhs: UnitQuaternion<T>;
     [val] => *self.matrix_mut_unchecked() *= rhs.to_homogeneous();
     [ref] => *self.matrix_mut_unchecked() *= rhs.to_homogeneous();
 );
 
 // Transform ÷= Transform
 md_assign_impl_all!(
-    DivAssign, div_assign where N: RealField;
-    (DimNameSum<D, U1>, DimNameSum<D, U1>), (DimNameSum<D, U1>, DimNameSum<D, U1>)
-    for D: DimNameAdd<U1>, CA: SuperTCategoryOf<CB>, CB: SubTCategoryOf<TProjective>;
-    self: Transform<N, D, CA>, rhs: Transform<N, D, CB>;
+    DivAssign, div_assign where T: RealField;
+    (DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>), (DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>)
+    const D;
+    for CA, CB;
+    where Const<D>: DimNameAdd<U1>, CA: SuperTCategoryOf<CB>, CB: SubTCategoryOf<TProjective>,
+          DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>;
+    self: Transform<T, CA, D>, rhs: Transform<T, CB, D>;
     [val] => #[allow(clippy::suspicious_op_assign_impl)] { *self *= rhs.inverse() };
     [ref] => #[allow(clippy::suspicious_op_assign_impl)] { *self *= rhs.clone().inverse() };
 );
@@ -498,9 +592,9 @@ md_assign_impl_all!(
 //      // Transform ÷= Similarity
 //      md_assign_impl_all!(
 //          DivAssign, div_assign;
-//          (DimNameSum<D, U1>, DimNameSum<D, U1>), (D, U1)
-//          for D: DimNameAdd<U1>, C: TCategory, R: SubsetOf<MatrixN<N, DimNameSum<D, U1>> >;
-//          self: Transform<N, D, C>, rhs: Similarity<N, D, R>;
+//          (DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>), (Const<D>, U1)
+//          for Const<D>: DimNameAdd<U1>, C: TCategory, R: SubsetOf<OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> >;
+//          self: Transform<T, C, D>, rhs: Similarity<T, R, D>;
 //          [val] => *self *= rhs.inverse();
 //          [ref] => *self *= rhs.inverse();
 //      );
@@ -509,36 +603,47 @@ md_assign_impl_all!(
 //      // Transform ÷= Isometry
 //      md_assign_impl_all!(
 //          DivAssign, div_assign;
-//          (DimNameSum<D, U1>, DimNameSum<D, U1>), (D, U1)
-//          for D: DimNameAdd<U1>, C: TCategory, R: SubsetOf<MatrixN<N, DimNameSum<D, U1>> >;
-//          self: Transform<N, D, C>, rhs: Isometry<N, D, R>;
+//          (DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>), (Const<D>, U1)
+//          for Const<D>: DimNameAdd<U1>, C: TCategory, R: SubsetOf<OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> >;
+//          self: Transform<T, C, D>, rhs: Isometry<T, R, D>;
 //          [val] => *self *= rhs.inverse();
 //          [ref] => *self *= rhs.inverse();
 //      );
 
 // Transform ÷= Translation
 md_assign_impl_all!(
-    DivAssign, div_assign where N: RealField;
-    (DimNameSum<D, U1>, DimNameSum<D, U1>), (D, U1) for D: DimNameAdd<U1>, C: TCategory;
-    self: Transform<N, D, C>, rhs: Translation<N, D>;
+    DivAssign, div_assign where T: RealField;
+    (DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>), (Const<D>, U1)
+    const D;
+    for C;
+    where Const<D>: DimNameAdd<U1>, C: TCategory,
+          DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>;
+    self: Transform<T, C, D>, rhs: Translation<T, D>;
     [val] => #[allow(clippy::suspicious_op_assign_impl)] { *self *= rhs.inverse() };
     [ref] => #[allow(clippy::suspicious_op_assign_impl)] { *self *= rhs.inverse() };
 );
 
 // Transform ÷= Rotation
 md_assign_impl_all!(
-    DivAssign, div_assign where N: RealField;
-    (DimNameSum<D, U1>, DimNameSum<D, U1>), (D, D) for D: DimNameAdd<U1>, C: TCategory;
-    self: Transform<N, D, C>, rhs: Rotation<N, D>;
+    DivAssign, div_assign where T: RealField;
+    (DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>), (Const<D>, Const<D>)
+    const D;
+    for C;
+    where Const<D>: DimNameAdd<U1>, C: TCategory,
+          DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>;
+    self: Transform<T, C, D>, rhs: Rotation<T, D>;
     [val] => #[allow(clippy::suspicious_op_assign_impl)] { *self *= rhs.inverse() };
     [ref] => #[allow(clippy::suspicious_op_assign_impl)] { *self *= rhs.inverse() };
 );
 
 // Transform ÷= UnitQuaternion
 md_assign_impl_all!(
-    DivAssign, div_assign where N: RealField;
-    (U4, U4), (U4, U1) for C: TCategory;
-    self: Transform<N, U3, C>, rhs: UnitQuaternion<N>;
+    DivAssign, div_assign where T: RealField;
+    (U4, U4), (U4, U1)
+    const;
+    for C;
+    where C: TCategory;
+    self: Transform<T, C, 3>, rhs: UnitQuaternion<T>;
     [val] => #[allow(clippy::suspicious_op_assign_impl)] { *self *= rhs.inverse() };
     [ref] => #[allow(clippy::suspicious_op_assign_impl)] { *self *= rhs.inverse() };
 );
diff --git a/src/geometry/transform_simba.rs b/src/geometry/transform_simba.rs
index d50843f4..db794712 100755
--- a/src/geometry/transform_simba.rs
+++ b/src/geometry/transform_simba.rs
@@ -2,29 +2,30 @@ use simba::simd::SimdValue;
 
 use crate::base::allocator::Allocator;
 use crate::base::dimension::{DimNameAdd, DimNameSum, U1};
-use crate::base::{DefaultAllocator, MatrixN, Scalar};
+use crate::base::{Const, DefaultAllocator, OMatrix, Scalar};
 use crate::RealField;
 
 use crate::geometry::{TCategory, Transform};
 
-impl<N: RealField, D: DimNameAdd<U1>, C> SimdValue for Transform<N, D, C>
+impl<T: RealField, C, const D: usize> SimdValue for Transform<T, C, D>
 where
-    N::Element: Scalar,
+    T::Element: Scalar,
     C: TCategory,
-    DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>
-        + Allocator<N::Element, DimNameSum<D, U1>, DimNameSum<D, U1>>,
+    Const<D>: DimNameAdd<U1>,
+    DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
+        + Allocator<T::Element, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
 {
-    type Element = Transform<N::Element, D, C>;
-    type SimdBool = N::SimdBool;
+    type Element = Transform<T::Element, C, D>;
+    type SimdBool = T::SimdBool;
 
     #[inline]
     fn lanes() -> usize {
-        N::lanes()
+        T::lanes()
     }
 
     #[inline]
     fn splat(val: Self::Element) -> Self {
-        Transform::from_matrix_unchecked(MatrixN::splat(val.into_inner()))
+        Transform::from_matrix_unchecked(OMatrix::splat(val.into_inner()))
     }
 
     #[inline]
diff --git a/src/geometry/translation.rs b/src/geometry/translation.rs
index 26bbfd12..5a4fe357 100755
--- a/src/geometry/translation.rs
+++ b/src/geometry/translation.rs
@@ -14,45 +14,35 @@ use abomonation::Abomonation;
 use simba::scalar::{ClosedAdd, ClosedNeg, ClosedSub};
 
 use crate::base::allocator::Allocator;
-use crate::base::dimension::{DimName, DimNameAdd, DimNameSum, U1};
+use crate::base::dimension::{DimNameAdd, DimNameSum, U1};
 use crate::base::storage::Owned;
-use crate::base::{DefaultAllocator, MatrixN, Scalar, VectorN};
+use crate::base::{Const, DefaultAllocator, OMatrix, SVector, Scalar};
 
 use crate::geometry::Point;
 
 /// A translation.
 #[repr(C)]
 #[derive(Debug)]
-pub struct Translation<N: Scalar, D: DimName>
-where
-    DefaultAllocator: Allocator<N, D>,
-{
+pub struct Translation<T, const D: usize> {
     /// The translation coordinates, i.e., how much is added to a point's coordinates when it is
     /// translated.
-    pub vector: VectorN<N, D>,
+    pub vector: SVector<T, D>,
 }
 
-impl<N: Scalar + hash::Hash, D: DimName + hash::Hash> hash::Hash for Translation<N, D>
+impl<T: Scalar + hash::Hash, const D: usize> hash::Hash for Translation<T, D>
 where
-    DefaultAllocator: Allocator<N, D>,
-    Owned<N, D>: hash::Hash,
+    Owned<T, Const<D>>: hash::Hash,
 {
     fn hash<H: hash::Hasher>(&self, state: &mut H) {
         self.vector.hash(state)
     }
 }
 
-impl<N: Scalar + Copy, D: DimName> Copy for Translation<N, D>
-where
-    DefaultAllocator: Allocator<N, D>,
-    Owned<N, D>: Copy,
-{
-}
+impl<T: Scalar + Copy, const D: usize> Copy for Translation<T, D> where Owned<T, Const<D>>: Copy {}
 
-impl<N: Scalar, D: DimName> Clone for Translation<N, D>
+impl<T: Scalar, const D: usize> Clone for Translation<T, D>
 where
-    DefaultAllocator: Allocator<N, D>,
-    Owned<N, D>: Clone,
+    Owned<T, Const<D>>: Clone,
 {
     #[inline]
     fn clone(&self) -> Self {
@@ -61,12 +51,10 @@ where
 }
 
 #[cfg(feature = "abomonation-serialize")]
-impl<N, D> Abomonation for Translation<N, D>
+impl<T, const D: usize> Abomonation for Translation<T, D>
 where
-    N: Scalar,
-    D: DimName,
-    VectorN<N, D>: Abomonation,
-    DefaultAllocator: Allocator<N, D>,
+    T: Scalar,
+    SVector<T, D>: Abomonation,
 {
     unsafe fn entomb<W: Write>(&self, writer: &mut W) -> IOResult<()> {
         self.vector.entomb(writer)
@@ -82,10 +70,9 @@ where
 }
 
 #[cfg(feature = "serde-serialize")]
-impl<N: Scalar, D: DimName> Serialize for Translation<N, D>
+impl<T: Scalar, const D: usize> Serialize for Translation<T, D>
 where
-    DefaultAllocator: Allocator<N, D>,
-    Owned<N, D>: Serialize,
+    Owned<T, Const<D>>: Serialize,
 {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
@@ -96,29 +83,25 @@ where
 }
 
 #[cfg(feature = "serde-serialize")]
-impl<'a, N: Scalar, D: DimName> Deserialize<'a> for Translation<N, D>
+impl<'a, T: Scalar, const D: usize> Deserialize<'a> for Translation<T, D>
 where
-    DefaultAllocator: Allocator<N, D>,
-    Owned<N, D>: Deserialize<'a>,
+    Owned<T, Const<D>>: Deserialize<'a>,
 {
     fn deserialize<Des>(deserializer: Des) -> Result<Self, Des::Error>
     where
         Des: Deserializer<'a>,
     {
-        let matrix = VectorN::<N, D>::deserialize(deserializer)?;
+        let matrix = SVector::<T, D>::deserialize(deserializer)?;
 
         Ok(Translation::from(matrix))
     }
 }
 
-impl<N: Scalar, D: DimName> Translation<N, D>
-where
-    DefaultAllocator: Allocator<N, D>,
-{
+impl<T: Scalar, const D: usize> Translation<T, D> {
     /// Creates a new translation from the given vector.
     #[inline]
     #[deprecated(note = "Use `::from` instead.")]
-    pub fn from_vector(vector: VectorN<N, D>) -> Translation<N, D> {
+    pub fn from_vector(vector: SVector<T, D>) -> Translation<T, D> {
         Translation { vector }
     }
 
@@ -138,9 +121,9 @@ where
     /// ```
     #[inline]
     #[must_use = "Did you mean to use inverse_mut()?"]
-    pub fn inverse(&self) -> Translation<N, D>
+    pub fn inverse(&self) -> Translation<T, D>
     where
-        N: ClosedNeg,
+        T: ClosedNeg,
     {
         Translation::from(-&self.vector)
     }
@@ -164,15 +147,14 @@ where
     /// assert_eq!(t.to_homogeneous(), expected);
     /// ```
     #[inline]
-    pub fn to_homogeneous(&self) -> MatrixN<N, DimNameSum<D, U1>>
+    pub fn to_homogeneous(&self) -> OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
     where
-        N: Zero + One,
-        D: DimNameAdd<U1>,
-        DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
+        T: Zero + One,
+        Const<D>: DimNameAdd<U1>,
+        DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
     {
-        let mut res = MatrixN::<N, DimNameSum<D, U1>>::identity();
-        res.fixed_slice_mut::<D, U1>(0, D::dim())
-            .copy_from(&self.vector);
+        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
     }
@@ -198,16 +180,13 @@ where
     #[inline]
     pub fn inverse_mut(&mut self)
     where
-        N: ClosedNeg,
+        T: ClosedNeg,
     {
         self.vector.neg_mut()
     }
 }
 
-impl<N: Scalar + ClosedAdd, D: DimName> Translation<N, D>
-where
-    DefaultAllocator: Allocator<N, D>,
-{
+impl<T: Scalar + ClosedAdd, const D: usize> Translation<T, D> {
     /// Translate the given point.
     ///
     /// This is the same as the multiplication `self * pt`.
@@ -219,15 +198,12 @@ where
     /// let transformed_point = t.transform_point(&Point3::new(4.0, 5.0, 6.0));
     /// assert_eq!(transformed_point, Point3::new(5.0, 7.0, 9.0));
     #[inline]
-    pub fn transform_point(&self, pt: &Point<N, D>) -> Point<N, D> {
+    pub fn transform_point(&self, pt: &Point<T, D>) -> Point<T, D> {
         pt + &self.vector
     }
 }
 
-impl<N: Scalar + ClosedSub, D: DimName> Translation<N, D>
-where
-    DefaultAllocator: Allocator<N, D>,
-{
+impl<T: Scalar + ClosedSub, const D: usize> Translation<T, D> {
     /// Translate the given point by the inverse of this translation.
     ///
     /// # Example
@@ -237,33 +213,29 @@ where
     /// let transformed_point = t.inverse_transform_point(&Point3::new(4.0, 5.0, 6.0));
     /// assert_eq!(transformed_point, Point3::new(3.0, 3.0, 3.0));
     #[inline]
-    pub fn inverse_transform_point(&self, pt: &Point<N, D>) -> Point<N, D> {
+    pub fn inverse_transform_point(&self, pt: &Point<T, D>) -> Point<T, D> {
         pt - &self.vector
     }
 }
 
-impl<N: Scalar + Eq, D: DimName> Eq for Translation<N, D> where DefaultAllocator: Allocator<N, D> {}
+impl<T: Scalar + Eq, const D: usize> Eq for Translation<T, D> {}
 
-impl<N: Scalar + PartialEq, D: DimName> PartialEq for Translation<N, D>
-where
-    DefaultAllocator: Allocator<N, D>,
-{
+impl<T: Scalar + PartialEq, const D: usize> PartialEq for Translation<T, D> {
     #[inline]
-    fn eq(&self, right: &Translation<N, D>) -> bool {
+    fn eq(&self, right: &Translation<T, D>) -> bool {
         self.vector == right.vector
     }
 }
 
-impl<N: Scalar + AbsDiffEq, D: DimName> AbsDiffEq for Translation<N, D>
+impl<T: Scalar + AbsDiffEq, const D: usize> AbsDiffEq for Translation<T, D>
 where
-    DefaultAllocator: Allocator<N, D>,
-    N::Epsilon: Copy,
+    T::Epsilon: Copy,
 {
-    type Epsilon = N::Epsilon;
+    type Epsilon = T::Epsilon;
 
     #[inline]
     fn default_epsilon() -> Self::Epsilon {
-        N::default_epsilon()
+        T::default_epsilon()
     }
 
     #[inline]
@@ -272,14 +244,13 @@ where
     }
 }
 
-impl<N: Scalar + RelativeEq, D: DimName> RelativeEq for Translation<N, D>
+impl<T: Scalar + RelativeEq, const D: usize> RelativeEq for Translation<T, D>
 where
-    DefaultAllocator: Allocator<N, D>,
-    N::Epsilon: Copy,
+    T::Epsilon: Copy,
 {
     #[inline]
     fn default_max_relative() -> Self::Epsilon {
-        N::default_max_relative()
+        T::default_max_relative()
     }
 
     #[inline]
@@ -294,14 +265,13 @@ where
     }
 }
 
-impl<N: Scalar + UlpsEq, D: DimName> UlpsEq for Translation<N, D>
+impl<T: Scalar + UlpsEq, const D: usize> UlpsEq for Translation<T, D>
 where
-    DefaultAllocator: Allocator<N, D>,
-    N::Epsilon: Copy,
+    T::Epsilon: Copy,
 {
     #[inline]
     fn default_max_ulps() -> u32 {
-        N::default_max_ulps()
+        T::default_max_ulps()
     }
 
     #[inline]
@@ -315,10 +285,7 @@ where
  * Display
  *
  */
-impl<N: Scalar + fmt::Display, D: DimName> fmt::Display for Translation<N, D>
-where
-    DefaultAllocator: Allocator<N, D> + Allocator<usize, D>,
-{
+impl<T: Scalar + fmt::Display, const D: usize> fmt::Display for Translation<T, D> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let precision = f.precision().unwrap_or(3);
 
diff --git a/src/geometry/translation_alias.rs b/src/geometry/translation_alias.rs
index 13db0495..06dc0794 100644
--- a/src/geometry/translation_alias.rs
+++ b/src/geometry/translation_alias.rs
@@ -1,21 +1,19 @@
-use crate::base::dimension::{U1, U2, U3, U4, U5, U6};
-
 use crate::geometry::Translation;
 
 /// A 1-dimensional translation.
-pub type Translation1<N> = Translation<N, U1>;
+pub type Translation1<T> = Translation<T, 1>;
 
 /// A 2-dimensional translation.
-pub type Translation2<N> = Translation<N, U2>;
+pub type Translation2<T> = Translation<T, 2>;
 
 /// A 3-dimensional translation.
-pub type Translation3<N> = Translation<N, U3>;
+pub type Translation3<T> = Translation<T, 3>;
 
 /// A 4-dimensional translation.
-pub type Translation4<N> = Translation<N, U4>;
+pub type Translation4<T> = Translation<T, 4>;
 
 /// A 5-dimensional translation.
-pub type Translation5<N> = Translation<N, U5>;
+pub type Translation5<T> = Translation<T, 5>;
 
 /// A 6-dimensional translation.
-pub type Translation6<N> = Translation<N, U6>;
+pub type Translation6<T> = Translation<T, 6>;
diff --git a/src/geometry/translation_construction.rs b/src/geometry/translation_construction.rs
index c1c02862..c6e9d7d3 100644
--- a/src/geometry/translation_construction.rs
+++ b/src/geometry/translation_construction.rs
@@ -12,16 +12,10 @@ use rand::{
 
 use simba::scalar::{ClosedAdd, SupersetOf};
 
-use crate::base::allocator::Allocator;
-use crate::base::dimension::{DimName, U1, U2, U3, U4, U5, U6};
-use crate::base::{DefaultAllocator, Scalar, VectorN};
-
+use crate::base::{SVector, Scalar};
 use crate::geometry::Translation;
 
-impl<N: Scalar, D: DimName> Translation<N, D>
-where
-    DefaultAllocator: Allocator<N, D>,
-{
+impl<T: Scalar, const D: usize> Translation<T, D> {
     /// Creates a new identity translation.
     ///
     /// # Example
@@ -37,11 +31,11 @@ where
     /// assert_eq!(t * p, p);
     /// ```
     #[inline]
-    pub fn identity() -> Translation<N, D>
+    pub fn identity() -> Translation<T, D>
     where
-        N: Zero,
+        T: Zero,
     {
-        Self::from(VectorN::<N, D>::from_element(N::zero()))
+        Self::from(SVector::<T, D>::from_element(T::zero()))
     }
 
     /// Cast the components of `self` to another type.
@@ -56,16 +50,12 @@ where
     pub fn cast<To: Scalar>(self) -> Translation<To, D>
     where
         Translation<To, D>: SupersetOf<Self>,
-        DefaultAllocator: Allocator<To, D>,
     {
         crate::convert(self)
     }
 }
 
-impl<N: Scalar + Zero + ClosedAdd, D: DimName> One for Translation<N, D>
-where
-    DefaultAllocator: Allocator<N, D>,
-{
+impl<T: Scalar + Zero + ClosedAdd, const D: usize> One for Translation<T, D> {
     #[inline]
     fn one() -> Self {
         Self::identity()
@@ -73,27 +63,25 @@ where
 }
 
 #[cfg(feature = "rand-no-std")]
-impl<N: Scalar, D: DimName> Distribution<Translation<N, D>> for Standard
+impl<T: Scalar, const D: usize> Distribution<Translation<T, D>> for Standard
 where
-    DefaultAllocator: Allocator<N, D>,
-    Standard: Distribution<N>,
+    Standard: Distribution<T>,
 {
     /// Generate an arbitrary random variate for testing purposes.
     #[inline]
-    fn sample<'a, G: Rng + ?Sized>(&self, rng: &'a mut G) -> Translation<N, D> {
-        Translation::from(rng.gen::<VectorN<N, D>>())
+    fn sample<'a, G: Rng + ?Sized>(&self, rng: &'a mut G) -> Translation<T, D> {
+        Translation::from(rng.gen::<SVector<T, D>>())
     }
 }
 
 #[cfg(feature = "arbitrary")]
-impl<N: Scalar + Arbitrary + Send, D: DimName> Arbitrary for Translation<N, D>
+impl<T: Scalar + Arbitrary + Send, const D: usize> Arbitrary for Translation<T, D>
 where
-    DefaultAllocator: Allocator<N, D>,
-    Owned<N, D>: Send,
+    Owned<T, crate::Const<D>>: Send,
 {
     #[inline]
     fn arbitrary(rng: &mut Gen) -> Self {
-        let v: VectorN<N, D> = Arbitrary::arbitrary(rng);
+        let v: SVector<T, D> = Arbitrary::arbitrary(rng);
         Self::from(v)
     }
 }
@@ -104,16 +92,16 @@ where
  *
  */
 macro_rules! componentwise_constructors_impl(
-    ($($doc: expr; $D: ty, $($args: ident:$irow: expr),*);* $(;)*) => {$(
-        impl<N: Scalar> Translation<N, $D>
-            where DefaultAllocator: Allocator<N, $D> {
+    ($($doc: expr; $D: expr, $($args: ident:$irow: expr),*);* $(;)*) => {$(
+        impl<T> Translation<T, $D>
+             {
             #[doc = "Initializes this translation from its components."]
             #[doc = "# Example\n```"]
             #[doc = $doc]
             #[doc = "```"]
             #[inline]
-            pub fn new($($args: N),*) -> Self {
-                Self::from(VectorN::<N, $D>::new($($args),*))
+            pub const fn new($($args: T),*) -> Self {
+                Self { vector: SVector::<T, $D>::new($($args),*) }
             }
         }
     )*}
@@ -121,15 +109,15 @@ macro_rules! componentwise_constructors_impl(
 
 componentwise_constructors_impl!(
     "# use nalgebra::Translation1;\nlet t = Translation1::new(1.0);\nassert!(t.vector.x == 1.0);";
-    U1, x:0;
+    1, x:0;
     "# use nalgebra::Translation2;\nlet t = Translation2::new(1.0, 2.0);\nassert!(t.vector.x == 1.0 && t.vector.y == 2.0);";
-    U2, x:0, y:1;
+    2, x:0, y:1;
     "# use nalgebra::Translation3;\nlet t = Translation3::new(1.0, 2.0, 3.0);\nassert!(t.vector.x == 1.0 && t.vector.y == 2.0 && t.vector.z == 3.0);";
-    U3, x:0, y:1, z:2;
+    3, x:0, y:1, z:2;
     "# use nalgebra::Translation4;\nlet t = Translation4::new(1.0, 2.0, 3.0, 4.0);\nassert!(t.vector.x == 1.0 && t.vector.y == 2.0 && t.vector.z == 3.0 && t.vector.w == 4.0);";
-    U4, x:0, y:1, z:2, w:3;
+    4, x:0, y:1, z:2, w:3;
     "# use nalgebra::Translation5;\nlet t = Translation5::new(1.0, 2.0, 3.0, 4.0, 5.0);\nassert!(t.vector.x == 1.0 && t.vector.y == 2.0 && t.vector.z == 3.0 && t.vector.w == 4.0 && t.vector.a == 5.0);";
-    U5, x:0, y:1, z:2, w:3, a:4;
+    5, x:0, y:1, z:2, w:3, a:4;
     "# use nalgebra::Translation6;\nlet t = Translation6::new(1.0, 2.0, 3.0, 4.0, 5.0, 6.0);\nassert!(t.vector.x == 1.0 && t.vector.y == 2.0 && t.vector.z == 3.0 && t.vector.w == 4.0 && t.vector.a == 5.0 && t.vector.b == 6.0);";
-    U6, x:0, y:1, z:2, w:3, a:4, b:5;
+    6, x:0, y:1, z:2, w:3, a:4, b:5;
 );
diff --git a/src/geometry/translation_conversion.rs b/src/geometry/translation_conversion.rs
index 9e915073..8c8f860f 100644
--- a/src/geometry/translation_conversion.rs
+++ b/src/geometry/translation_conversion.rs
@@ -4,8 +4,8 @@ use simba::scalar::{RealField, SubsetOf, SupersetOf};
 use simba::simd::PrimitiveSimdValue;
 
 use crate::base::allocator::Allocator;
-use crate::base::dimension::{DimName, DimNameAdd, DimNameSum, U1};
-use crate::base::{DefaultAllocator, MatrixN, Scalar, VectorN};
+use crate::base::dimension::{DimNameAdd, DimNameSum, U1};
+use crate::base::{Const, DefaultAllocator, DimName, OMatrix, OVector, SVector, Scalar};
 
 use crate::geometry::{
     AbstractRotation, Isometry, Similarity, SuperTCategoryOf, TAffine, Transform, Translation,
@@ -24,210 +24,205 @@ use crate::geometry::{
  * Translation -> Matrix (homogeneous)
  */
 
-impl<N1, N2, D: DimName> SubsetOf<Translation<N2, D>> for Translation<N1, D>
+impl<T1, T2, const D: usize> SubsetOf<Translation<T2, D>> for Translation<T1, D>
 where
-    N1: Scalar,
-    N2: Scalar + SupersetOf<N1>,
-    DefaultAllocator: Allocator<N1, D> + Allocator<N2, D>,
+    T1: Scalar,
+    T2: Scalar + SupersetOf<T1>,
 {
     #[inline]
-    fn to_superset(&self) -> Translation<N2, D> {
+    fn to_superset(&self) -> Translation<T2, D> {
         Translation::from(self.vector.to_superset())
     }
 
     #[inline]
-    fn is_in_subset(rot: &Translation<N2, D>) -> bool {
-        crate::is_convertible::<_, VectorN<N1, D>>(&rot.vector)
+    fn is_in_subset(rot: &Translation<T2, D>) -> bool {
+        crate::is_convertible::<_, SVector<T1, D>>(&rot.vector)
     }
 
     #[inline]
-    fn from_superset_unchecked(rot: &Translation<N2, D>) -> Self {
+    fn from_superset_unchecked(rot: &Translation<T2, D>) -> Self {
         Translation {
             vector: rot.vector.to_subset_unchecked(),
         }
     }
 }
 
-impl<N1, N2, D: DimName, R> SubsetOf<Isometry<N2, D, R>> for Translation<N1, D>
+impl<T1, T2, R, const D: usize> SubsetOf<Isometry<T2, R, D>> for Translation<T1, D>
 where
-    N1: RealField,
-    N2: RealField + SupersetOf<N1>,
-    R: AbstractRotation<N2, D>,
-    DefaultAllocator: Allocator<N1, D> + Allocator<N2, D>,
+    T1: RealField,
+    T2: RealField + SupersetOf<T1>,
+    R: AbstractRotation<T2, D>,
 {
     #[inline]
-    fn to_superset(&self) -> Isometry<N2, D, R> {
+    fn to_superset(&self) -> Isometry<T2, R, D> {
         Isometry::from_parts(self.to_superset(), R::identity())
     }
 
     #[inline]
-    fn is_in_subset(iso: &Isometry<N2, D, R>) -> bool {
+    fn is_in_subset(iso: &Isometry<T2, R, D>) -> bool {
         iso.rotation == R::identity()
     }
 
     #[inline]
-    fn from_superset_unchecked(iso: &Isometry<N2, D, R>) -> Self {
+    fn from_superset_unchecked(iso: &Isometry<T2, R, D>) -> Self {
         Self::from_superset_unchecked(&iso.translation)
     }
 }
 
-impl<N1, N2> SubsetOf<UnitDualQuaternion<N2>> for Translation3<N1>
+impl<T1, T2> SubsetOf<UnitDualQuaternion<T2>> for Translation3<T1>
 where
-    N1: RealField,
-    N2: RealField + SupersetOf<N1>,
+    T1: RealField,
+    T2: RealField + SupersetOf<T1>,
 {
     #[inline]
-    fn to_superset(&self) -> UnitDualQuaternion<N2> {
-        let dq = UnitDualQuaternion::<N1>::from_parts(self.clone(), UnitQuaternion::identity());
+    fn to_superset(&self) -> UnitDualQuaternion<T2> {
+        let dq = UnitDualQuaternion::<T1>::from_parts(self.clone(), UnitQuaternion::identity());
         dq.to_superset()
     }
 
     #[inline]
-    fn is_in_subset(dq: &UnitDualQuaternion<N2>) -> bool {
-        crate::is_convertible::<_, Translation<N1, _>>(&dq.translation())
+    fn is_in_subset(dq: &UnitDualQuaternion<T2>) -> bool {
+        crate::is_convertible::<_, Translation<T1, 3>>(&dq.translation())
             && dq.rotation() == UnitQuaternion::identity()
     }
 
     #[inline]
-    fn from_superset_unchecked(dq: &UnitDualQuaternion<N2>) -> Self {
-        let dq: UnitDualQuaternion<N1> = crate::convert_ref_unchecked(dq);
+    fn from_superset_unchecked(dq: &UnitDualQuaternion<T2>) -> Self {
+        let dq: UnitDualQuaternion<T1> = crate::convert_ref_unchecked(dq);
         dq.translation()
     }
 }
 
-impl<N1, N2, D: DimName, R> SubsetOf<Similarity<N2, D, R>> for Translation<N1, D>
+impl<T1, T2, R, const D: usize> SubsetOf<Similarity<T2, R, D>> for Translation<T1, D>
 where
-    N1: RealField,
-    N2: RealField + SupersetOf<N1>,
-    R: AbstractRotation<N2, D>,
-    DefaultAllocator: Allocator<N1, D> + Allocator<N2, D>,
+    T1: RealField,
+    T2: RealField + SupersetOf<T1>,
+    R: AbstractRotation<T2, D>,
 {
     #[inline]
-    fn to_superset(&self) -> Similarity<N2, D, R> {
-        Similarity::from_parts(self.to_superset(), R::identity(), N2::one())
+    fn to_superset(&self) -> Similarity<T2, R, D> {
+        Similarity::from_parts(self.to_superset(), R::identity(), T2::one())
     }
 
     #[inline]
-    fn is_in_subset(sim: &Similarity<N2, D, R>) -> bool {
-        sim.isometry.rotation == R::identity() && sim.scaling() == N2::one()
+    fn is_in_subset(sim: &Similarity<T2, R, D>) -> bool {
+        sim.isometry.rotation == R::identity() && sim.scaling() == T2::one()
     }
 
     #[inline]
-    fn from_superset_unchecked(sim: &Similarity<N2, D, R>) -> Self {
+    fn from_superset_unchecked(sim: &Similarity<T2, R, D>) -> Self {
         Self::from_superset_unchecked(&sim.isometry.translation)
     }
 }
 
-impl<N1, N2, D, C> SubsetOf<Transform<N2, D, C>> for Translation<N1, D>
+impl<T1, T2, C, const D: usize> SubsetOf<Transform<T2, C, D>> for Translation<T1, D>
 where
-    N1: RealField,
-    N2: RealField + SupersetOf<N1>,
+    T1: RealField,
+    T2: RealField + SupersetOf<T1>,
     C: SuperTCategoryOf<TAffine>,
-    D: DimNameAdd<U1>,
-    DefaultAllocator: Allocator<N1, D>
-        + Allocator<N2, D>
-        + Allocator<N1, DimNameSum<D, U1>, DimNameSum<D, U1>>
-        + Allocator<N2, DimNameSum<D, U1>, DimNameSum<D, U1>>,
+    Const<D>: DimNameAdd<U1>,
+    DefaultAllocator: Allocator<T1, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
+        + Allocator<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
 {
     #[inline]
-    fn to_superset(&self) -> Transform<N2, D, C> {
+    fn to_superset(&self) -> Transform<T2, C, D> {
         Transform::from_matrix_unchecked(self.to_homogeneous().to_superset())
     }
 
     #[inline]
-    fn is_in_subset(t: &Transform<N2, D, C>) -> bool {
+    fn is_in_subset(t: &Transform<T2, C, D>) -> bool {
         <Self as SubsetOf<_>>::is_in_subset(t.matrix())
     }
 
     #[inline]
-    fn from_superset_unchecked(t: &Transform<N2, D, C>) -> Self {
+    fn from_superset_unchecked(t: &Transform<T2, C, D>) -> Self {
         Self::from_superset_unchecked(t.matrix())
     }
 }
 
-impl<N1, N2, D> SubsetOf<MatrixN<N2, DimNameSum<D, U1>>> for Translation<N1, D>
+impl<T1, T2, const D: usize>
+    SubsetOf<OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>> for Translation<T1, D>
 where
-    N1: RealField,
-    N2: RealField + SupersetOf<N1>,
-    D: DimNameAdd<U1>,
-    DefaultAllocator: Allocator<N1, D>
-        + Allocator<N2, D>
-        + Allocator<N1, DimNameSum<D, U1>, DimNameSum<D, U1>>
-        + Allocator<N2, DimNameSum<D, U1>, DimNameSum<D, U1>>,
+    T1: RealField,
+    T2: RealField + SupersetOf<T1>,
+    Const<D>: DimNameAdd<U1>,
+    DefaultAllocator: Allocator<T1, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
+        + Allocator<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
+    // + Allocator<T1, D>
+    // + Allocator<T2, D>
 {
     #[inline]
-    fn to_superset(&self) -> MatrixN<N2, DimNameSum<D, U1>> {
+    fn to_superset(&self) -> OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> {
         self.to_homogeneous().to_superset()
     }
 
     #[inline]
-    fn is_in_subset(m: &MatrixN<N2, DimNameSum<D, U1>>) -> bool {
-        let id = m.fixed_slice::<DimNameSum<D, U1>, D>(0, 0);
+    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>));
 
         // Scalar types agree.
-        m.iter().all(|e| SupersetOf::<N1>::is_in_subset(e)) &&
+        m.iter().all(|e| SupersetOf::<T1>::is_in_subset(e)) &&
         // The block part does nothing.
-        id.is_identity(N2::zero()) &&
+        id.is_identity(T2::zero()) &&
         // The normalization factor is one.
-        m[(D::dim(), D::dim())] == N2::one()
+        m[(D, D)] == T2::one()
     }
 
     #[inline]
-    fn from_superset_unchecked(m: &MatrixN<N2, DimNameSum<D, U1>>) -> Self {
-        let t = m.fixed_slice::<D, U1>(0, D::dim());
+    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);
         Self {
             vector: crate::convert_unchecked(t.into_owned()),
         }
     }
 }
 
-impl<N: Scalar + Zero + One, D: DimName> From<Translation<N, D>> for MatrixN<N, DimNameSum<D, U1>>
+impl<T: Scalar + Zero + One, const D: usize> From<Translation<T, D>>
+    for OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
 where
-    D: DimNameAdd<U1>,
-    DefaultAllocator: Allocator<N, D> + Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
+    Const<D>: DimNameAdd<U1>,
+    DefaultAllocator:
+        Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> + Allocator<T, Const<D>>,
 {
     #[inline]
-    fn from(t: Translation<N, D>) -> Self {
+    fn from(t: Translation<T, D>) -> Self {
         t.to_homogeneous()
     }
 }
 
-impl<N: Scalar, D: DimName> From<VectorN<N, D>> for Translation<N, D>
-where
-    DefaultAllocator: Allocator<N, D>,
-{
+impl<T: Scalar, const D: usize> From<OVector<T, Const<D>>> for Translation<T, D> {
     #[inline]
-    fn from(vector: VectorN<N, D>) -> Self {
+    fn from(vector: OVector<T, Const<D>>) -> Self {
         Translation { vector }
     }
 }
 
-impl<N: Scalar + PrimitiveSimdValue, D: DimName> From<[Translation<N::Element, D>; 2]>
-    for Translation<N, D>
+impl<T: Scalar + PrimitiveSimdValue, const D: usize> From<[Translation<T::Element, D>; 2]>
+    for Translation<T, D>
 where
-    N: From<[<N as simba::simd::SimdValue>::Element; 2]>,
-    N::Element: Scalar,
-    DefaultAllocator: Allocator<N, D> + Allocator<N::Element, D>,
+    T: From<[<T as simba::simd::SimdValue>::Element; 2]>,
+    T::Element: Scalar,
 {
     #[inline]
-    fn from(arr: [Translation<N::Element, D>; 2]) -> Self {
-        Self::from(VectorN::from([
+    fn from(arr: [Translation<T::Element, D>; 2]) -> Self {
+        Self::from(OVector::from([
             arr[0].vector.clone(),
             arr[1].vector.clone(),
         ]))
     }
 }
 
-impl<N: Scalar + PrimitiveSimdValue, D: DimName> From<[Translation<N::Element, D>; 4]>
-    for Translation<N, D>
+impl<T: Scalar + PrimitiveSimdValue, const D: usize> From<[Translation<T::Element, D>; 4]>
+    for Translation<T, D>
 where
-    N: From<[<N as simba::simd::SimdValue>::Element; 4]>,
-    N::Element: Scalar,
-    DefaultAllocator: Allocator<N, D> + Allocator<N::Element, D>,
+    T: From<[<T as simba::simd::SimdValue>::Element; 4]>,
+    T::Element: Scalar,
 {
     #[inline]
-    fn from(arr: [Translation<N::Element, D>; 4]) -> Self {
-        Self::from(VectorN::from([
+    fn from(arr: [Translation<T::Element, D>; 4]) -> Self {
+        Self::from(OVector::from([
             arr[0].vector.clone(),
             arr[1].vector.clone(),
             arr[2].vector.clone(),
@@ -236,16 +231,15 @@ where
     }
 }
 
-impl<N: Scalar + PrimitiveSimdValue, D: DimName> From<[Translation<N::Element, D>; 8]>
-    for Translation<N, D>
+impl<T: Scalar + PrimitiveSimdValue, const D: usize> From<[Translation<T::Element, D>; 8]>
+    for Translation<T, D>
 where
-    N: From<[<N as simba::simd::SimdValue>::Element; 8]>,
-    N::Element: Scalar,
-    DefaultAllocator: Allocator<N, D> + Allocator<N::Element, D>,
+    T: From<[<T as simba::simd::SimdValue>::Element; 8]>,
+    T::Element: Scalar,
 {
     #[inline]
-    fn from(arr: [Translation<N::Element, D>; 8]) -> Self {
-        Self::from(VectorN::from([
+    fn from(arr: [Translation<T::Element, D>; 8]) -> Self {
+        Self::from(OVector::from([
             arr[0].vector.clone(),
             arr[1].vector.clone(),
             arr[2].vector.clone(),
@@ -258,16 +252,15 @@ where
     }
 }
 
-impl<N: Scalar + PrimitiveSimdValue, D: DimName> From<[Translation<N::Element, D>; 16]>
-    for Translation<N, D>
+impl<T: Scalar + PrimitiveSimdValue, const D: usize> From<[Translation<T::Element, D>; 16]>
+    for Translation<T, D>
 where
-    N: From<[<N as simba::simd::SimdValue>::Element; 16]>,
-    N::Element: Scalar,
-    DefaultAllocator: Allocator<N, D> + Allocator<N::Element, D>,
+    T: From<[<T as simba::simd::SimdValue>::Element; 16]>,
+    T::Element: Scalar,
 {
     #[inline]
-    fn from(arr: [Translation<N::Element, D>; 16]) -> Self {
-        Self::from(VectorN::from([
+    fn from(arr: [Translation<T::Element, D>; 16]) -> Self {
+        Self::from(OVector::from([
             arr[0].vector.clone(),
             arr[1].vector.clone(),
             arr[2].vector.clone(),
diff --git a/src/geometry/translation_coordinates.rs b/src/geometry/translation_coordinates.rs
index c422415c..9a9bf44a 100644
--- a/src/geometry/translation_coordinates.rs
+++ b/src/geometry/translation_coordinates.rs
@@ -1,10 +1,8 @@
 use std::mem;
 use std::ops::{Deref, DerefMut};
 
-use crate::base::allocator::Allocator;
 use crate::base::coordinates::{X, XY, XYZ, XYZW, XYZWA, XYZWAB};
-use crate::base::dimension::{U1, U2, U3, U4, U5, U6};
-use crate::base::{DefaultAllocator, Scalar};
+use crate::base::Scalar;
 
 use crate::geometry::Translation;
 
@@ -15,10 +13,9 @@ use crate::geometry::Translation;
  */
 
 macro_rules! deref_impl(
-    ($D: ty, $Target: ident $(, $comps: ident)*) => {
-        impl<N: Scalar> Deref for Translation<N, $D>
-            where DefaultAllocator: Allocator<N, $D> {
-            type Target = $Target<N>;
+    ($D: expr, $Target: ident $(, $comps: ident)*) => {
+        impl<T: Scalar> Deref for Translation<T, $D> {
+            type Target = $Target<T>;
 
             #[inline]
             fn deref(&self) -> &Self::Target {
@@ -26,8 +23,8 @@ macro_rules! deref_impl(
             }
         }
 
-        impl<N: Scalar> DerefMut for Translation<N, $D>
-            where DefaultAllocator: Allocator<N, $D> {
+        impl<T: Scalar> DerefMut for Translation<T, $D>
+             {
             #[inline]
             fn deref_mut(&mut self) -> &mut Self::Target {
                 unsafe { mem::transmute(self) }
@@ -36,9 +33,9 @@ macro_rules! deref_impl(
     }
 );
 
-deref_impl!(U1, X, x);
-deref_impl!(U2, XY, x, y);
-deref_impl!(U3, XYZ, x, y, z);
-deref_impl!(U4, XYZW, x, y, z, w);
-deref_impl!(U5, XYZWA, x, y, z, w, a);
-deref_impl!(U6, XYZWAB, x, y, z, w, a, b);
+deref_impl!(1, X, x);
+deref_impl!(2, XY, x, y);
+deref_impl!(3, XYZ, x, y, z);
+deref_impl!(4, XYZW, x, y, z, w);
+deref_impl!(5, XYZWA, x, y, z, w, a);
+deref_impl!(6, XYZWAB, x, y, z, w, a, b);
diff --git a/src/geometry/translation_ops.rs b/src/geometry/translation_ops.rs
index fc53b1e6..8851183a 100644
--- a/src/geometry/translation_ops.rs
+++ b/src/geometry/translation_ops.rs
@@ -2,107 +2,118 @@ use std::ops::{Div, DivAssign, Mul, MulAssign};
 
 use simba::scalar::{ClosedAdd, ClosedSub};
 
-use crate::base::allocator::{Allocator, SameShapeAllocator};
 use crate::base::constraint::{SameNumberOfColumns, SameNumberOfRows, ShapeConstraint};
-use crate::base::dimension::{DimName, U1};
-use crate::base::{DefaultAllocator, Scalar};
+use crate::base::dimension::U1;
+use crate::base::{Const, Scalar};
 
 use crate::geometry::{Point, Translation};
 
 // Translation × Translation
 add_sub_impl!(Mul, mul, ClosedAdd;
-    (D, U1), (D, U1) -> (D) for D: DimName;
-    self: &'a Translation<N, D>, right: &'b Translation<N, D>, Output = Translation<N, D>;
+    (Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
+    const D; for; where;
+    self: &'a Translation<T, D>, right: &'b Translation<T, D>, Output = Translation<T, D>;
     #[allow(clippy::suspicious_arithmetic_impl)] { Translation::from(&self.vector + &right.vector) };
     'a, 'b);
 
 add_sub_impl!(Mul, mul, ClosedAdd;
-    (D, U1), (D, U1) -> (D) for D: DimName;
-    self: &'a Translation<N, D>, right: Translation<N, D>, Output = Translation<N, D>;
+    (Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
+    const D; for; where;
+    self: &'a Translation<T, D>, right: Translation<T, D>, Output = Translation<T, D>;
     #[allow(clippy::suspicious_arithmetic_impl)] { Translation::from(&self.vector + right.vector) };
     'a);
 
 add_sub_impl!(Mul, mul, ClosedAdd;
-    (D, U1), (D, U1) -> (D) for D: DimName;
-    self: Translation<N, D>, right: &'b Translation<N, D>, Output = Translation<N, D>;
+    (Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
+    const D; for; where;
+    self: Translation<T, D>, right: &'b Translation<T, D>, Output = Translation<T, D>;
     #[allow(clippy::suspicious_arithmetic_impl)] { Translation::from(self.vector + &right.vector) };
     'b);
 
 add_sub_impl!(Mul, mul, ClosedAdd;
-    (D, U1), (D, U1) -> (D) for D: DimName;
-    self: Translation<N, D>, right: Translation<N, D>, Output = Translation<N, D>;
+    (Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
+    const D; for; where;
+    self: Translation<T, D>, right: Translation<T, D>, Output = Translation<T, D>;
     #[allow(clippy::suspicious_arithmetic_impl)] { Translation::from(self.vector + right.vector) }; );
 
 // Translation ÷ Translation
 // TODO: instead of calling inverse explicitly, could we just add a `mul_tr` or `mul_inv` method?
 add_sub_impl!(Div, div, ClosedSub;
-    (D, U1), (D, U1) -> (D) for D: DimName;
-    self: &'a Translation<N, D>, right: &'b Translation<N, D>, Output = Translation<N, D>;
+    (Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
+    const D; for; where;
+    self: &'a Translation<T, D>, right: &'b Translation<T, D>, Output = Translation<T, D>;
     #[allow(clippy::suspicious_arithmetic_impl)] { Translation::from(&self.vector - &right.vector) };
     'a, 'b);
 
 add_sub_impl!(Div, div, ClosedSub;
-    (D, U1), (D, U1) -> (D) for D: DimName;
-    self: &'a Translation<N, D>, right: Translation<N, D>, Output = Translation<N, D>;
+    (Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
+    const D; for; where;
+    self: &'a Translation<T, D>, right: Translation<T, D>, Output = Translation<T, D>;
     #[allow(clippy::suspicious_arithmetic_impl)] { Translation::from(&self.vector - right.vector) };
     'a);
 
 add_sub_impl!(Div, div, ClosedSub;
-    (D, U1), (D, U1) -> (D) for D: DimName;
-    self: Translation<N, D>, right: &'b Translation<N, D>, Output = Translation<N, D>;
+    (Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
+    const D; for; where;
+    self: Translation<T, D>, right: &'b Translation<T, D>, Output = Translation<T, D>;
     #[allow(clippy::suspicious_arithmetic_impl)] { Translation::from(self.vector - &right.vector) };
     'b);
 
 add_sub_impl!(Div, div, ClosedSub;
-    (D, U1), (D, U1) -> (D) for D: DimName;
-    self: Translation<N, D>, right: Translation<N, D>, Output = Translation<N, D>;
+    (Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
+    const D; for; where;
+    self: Translation<T, D>, right: Translation<T, D>, Output = Translation<T, D>;
     #[allow(clippy::suspicious_arithmetic_impl)] { Translation::from(self.vector - right.vector) }; );
 
 // Translation × Point
 // TODO: we don't handle properly non-zero origins here. Do we want this to be the intended
 // behavior?
 add_sub_impl!(Mul, mul, ClosedAdd;
-    (D, U1), (D, U1) -> (D) for D: DimName;
-    self: &'a Translation<N, D>, right: &'b Point<N, D>, Output = Point<N, D>;
+    (Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
+    const D; for; where;
+    self: &'a Translation<T, D>, right: &'b Point<T, D>, Output = Point<T, D>;
     #[allow(clippy::suspicious_arithmetic_impl)] { right + &self.vector };
     'a, 'b);
 
 add_sub_impl!(Mul, mul, ClosedAdd;
-    (D, U1), (D, U1) -> (D) for D: DimName;
-    self: &'a Translation<N, D>, right: Point<N, D>, Output = Point<N, D>;
+    (Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
+    const D; for; where;
+    self: &'a Translation<T, D>, right: Point<T, D>, Output = Point<T, D>;
     #[allow(clippy::suspicious_arithmetic_impl)] { right + &self.vector };
     'a);
 
 add_sub_impl!(Mul, mul, ClosedAdd;
-    (D, U1), (D, U1) -> (D) for D: DimName;
-    self: Translation<N, D>, right: &'b Point<N, D>, Output = Point<N, D>;
+    (Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
+    const D; for; where;
+    self: Translation<T, D>, right: &'b Point<T, D>, Output = Point<T, D>;
     #[allow(clippy::suspicious_arithmetic_impl)] { right + self.vector };
     'b);
 
 add_sub_impl!(Mul, mul, ClosedAdd;
-    (D, U1), (D, U1) -> (D) for D: DimName;
-    self: Translation<N, D>, right: Point<N, D>, Output = Point<N, D>;
+    (Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
+    const D; for; where;
+    self: Translation<T, D>, right: Point<T, D>, Output = Point<T, D>;
     #[allow(clippy::suspicious_arithmetic_impl)] { right + self.vector }; );
 
 // Translation *= Translation
 add_sub_assign_impl!(MulAssign, mul_assign, ClosedAdd;
-    (D, U1), (D, U1) for D: DimName;
-    self: Translation<N, D>, right: &'b Translation<N, D>;
+    const D;
+    self: Translation<T, D>, right: &'b Translation<T, D>;
     #[allow(clippy::suspicious_op_assign_impl)] { self.vector += &right.vector };
     'b);
 
 add_sub_assign_impl!(MulAssign, mul_assign, ClosedAdd;
-    (D, U1), (D, U1) for D: DimName;
-    self: Translation<N, D>, right: Translation<N, D>;
+    const D;
+    self: Translation<T, D>, right: Translation<T, D>;
     #[allow(clippy::suspicious_op_assign_impl)] { self.vector += right.vector }; );
 
 add_sub_assign_impl!(DivAssign, div_assign, ClosedSub;
-    (D, U1), (D, U1) for D: DimName;
-    self: Translation<N, D>, right: &'b Translation<N, D>;
+    const D;
+    self: Translation<T, D>, right: &'b Translation<T, D>;
     #[allow(clippy::suspicious_op_assign_impl)] { self.vector -= &right.vector };
     'b);
 
 add_sub_assign_impl!(DivAssign, div_assign, ClosedSub;
-    (D, U1), (D, U1) for D: DimName;
-    self: Translation<N, D>, right: Translation<N, D>;
+    const D;
+    self: Translation<T, D>, right: Translation<T, D>;
     #[allow(clippy::suspicious_op_assign_impl)] { self.vector -= right.vector }; );
diff --git a/src/geometry/translation_simba.rs b/src/geometry/translation_simba.rs
index c439a5d2..7f7f7ebf 100755
--- a/src/geometry/translation_simba.rs
+++ b/src/geometry/translation_simba.rs
@@ -1,28 +1,25 @@
 use simba::simd::SimdValue;
 
-use crate::base::allocator::Allocator;
-use crate::base::dimension::DimName;
-use crate::base::{DefaultAllocator, VectorN};
+use crate::base::OVector;
 use crate::Scalar;
 
 use crate::geometry::Translation;
 
-impl<N: Scalar + SimdValue, D: DimName> SimdValue for Translation<N, D>
+impl<T: Scalar + SimdValue, const D: usize> SimdValue for Translation<T, D>
 where
-    N::Element: Scalar,
-    DefaultAllocator: Allocator<N, D> + Allocator<N::Element, D>,
+    T::Element: Scalar,
 {
-    type Element = Translation<N::Element, D>;
-    type SimdBool = N::SimdBool;
+    type Element = Translation<T::Element, D>;
+    type SimdBool = T::SimdBool;
 
     #[inline]
     fn lanes() -> usize {
-        N::lanes()
+        T::lanes()
     }
 
     #[inline]
     fn splat(val: Self::Element) -> Self {
-        VectorN::splat(val.vector).into()
+        OVector::splat(val.vector).into()
     }
 
     #[inline]
diff --git a/src/geometry/unit_complex.rs b/src/geometry/unit_complex.rs
index 43ef7324..fe2e87ba 100755
--- a/src/geometry/unit_complex.rs
+++ b/src/geometry/unit_complex.rs
@@ -29,29 +29,29 @@ use std::cmp::{Eq, PartialEq};
 ///
 /// # Conversion
 /// * [Conversion to a matrix <span style="float:right;">`to_rotation_matrix`, `to_homogeneous`…</span>](#conversion-to-a-matrix)
-pub type UnitComplex<N> = Unit<Complex<N>>;
+pub type UnitComplex<T> = Unit<Complex<T>>;
 
-impl<N: Scalar + PartialEq> PartialEq for UnitComplex<N> {
+impl<T: Scalar + PartialEq> PartialEq for UnitComplex<T> {
     #[inline]
     fn eq(&self, rhs: &Self) -> bool {
         (**self).eq(&**rhs)
     }
 }
 
-impl<N: Scalar + Eq> Eq for UnitComplex<N> {}
+impl<T: Scalar + Eq> Eq for UnitComplex<T> {}
 
-impl<N: SimdRealField> Normed for Complex<N> {
-    type Norm = N::SimdRealField;
+impl<T: SimdRealField> Normed for Complex<T> {
+    type Norm = T::SimdRealField;
 
     #[inline]
-    fn norm(&self) -> N::SimdRealField {
+    fn norm(&self) -> T::SimdRealField {
         // We don't use `.norm_sqr()` because it requires
         // some very strong Num trait requirements.
         (self.re * self.re + self.im * self.im).simd_sqrt()
     }
 
     #[inline]
-    fn norm_squared(&self) -> N::SimdRealField {
+    fn norm_squared(&self) -> T::SimdRealField {
         // We don't use `.norm_sqr()` because it requires
         // some very strong Num trait requirements.
         self.re * self.re + self.im * self.im
@@ -71,9 +71,9 @@ impl<N: SimdRealField> Normed for Complex<N> {
 }
 
 /// # Angle extraction
-impl<N: SimdRealField> UnitComplex<N>
+impl<T: SimdRealField> UnitComplex<T>
 where
-    N::Element: SimdRealField,
+    T::Element: SimdRealField,
 {
     /// The rotation angle in `]-pi; pi]` of this unit complex number.
     ///
@@ -84,7 +84,7 @@ where
     /// assert_eq!(rot.angle(), 1.78);
     /// ```
     #[inline]
-    pub fn angle(&self) -> N {
+    pub fn angle(&self) -> T {
         self.im.simd_atan2(self.re)
     }
 
@@ -98,7 +98,7 @@ where
     /// assert_eq!(rot.sin_angle(), angle.sin());
     /// ```
     #[inline]
-    pub fn sin_angle(&self) -> N {
+    pub fn sin_angle(&self) -> T {
         self.im
     }
 
@@ -112,7 +112,7 @@ where
     /// assert_eq!(rot.cos_angle(),angle.cos());
     /// ```
     #[inline]
-    pub fn cos_angle(&self) -> N {
+    pub fn cos_angle(&self) -> T {
         self.re
     }
 
@@ -121,7 +121,7 @@ where
     /// This is generally used in the context of generic programming. Using
     /// the `.angle()` method instead is more common.
     #[inline]
-    pub fn scaled_axis(&self) -> Vector1<N> {
+    pub fn scaled_axis(&self) -> Vector1<T> {
         Vector1::new(self.angle())
     }
 
@@ -131,9 +131,9 @@ where
     /// the `.angle()` method instead is more common.
     /// Returns `None` if the angle is zero.
     #[inline]
-    pub fn axis_angle(&self) -> Option<(Unit<Vector1<N>>, N)>
+    pub fn axis_angle(&self) -> Option<(Unit<Vector1<T>>, T)>
     where
-        N: RealField,
+        T: RealField,
     {
         let ang = self.angle();
 
@@ -142,7 +142,7 @@ where
         } else if ang.is_sign_negative() {
             Some((Unit::new_unchecked(Vector1::x()), -ang))
         } else {
-            Some((Unit::new_unchecked(-Vector1::<N>::x()), ang))
+            Some((Unit::new_unchecked(-Vector1::<T>::x()), ang))
         }
     }
 
@@ -157,16 +157,16 @@ where
     /// assert_relative_eq!(rot1.angle_to(&rot2), 1.6);
     /// ```
     #[inline]
-    pub fn angle_to(&self, other: &Self) -> N {
+    pub fn angle_to(&self, other: &Self) -> T {
         let delta = self.rotation_to(other);
         delta.angle()
     }
 }
 
 /// # Conjugation and inversion
-impl<N: SimdRealField> UnitComplex<N>
+impl<T: SimdRealField> UnitComplex<T>
 where
-    N::Element: SimdRealField,
+    T::Element: SimdRealField,
 {
     /// Compute the conjugate of this unit complex number.
     ///
@@ -239,9 +239,9 @@ where
 }
 
 /// # Conversion to a matrix
-impl<N: SimdRealField> UnitComplex<N>
+impl<T: SimdRealField> UnitComplex<T>
 where
-    N::Element: SimdRealField,
+    T::Element: SimdRealField,
 {
     /// Builds the rotation matrix corresponding to this unit complex number.
     ///
@@ -254,7 +254,7 @@ where
     /// assert_eq!(rot.to_rotation_matrix(), expected);
     /// ```
     #[inline]
-    pub fn to_rotation_matrix(&self) -> Rotation2<N> {
+    pub fn to_rotation_matrix(&self) -> Rotation2<T> {
         let r = self.re;
         let i = self.im;
 
@@ -274,15 +274,15 @@ where
     /// assert_eq!(rot.to_homogeneous(), expected);
     /// ```
     #[inline]
-    pub fn to_homogeneous(&self) -> Matrix3<N> {
+    pub fn to_homogeneous(&self) -> Matrix3<T> {
         self.to_rotation_matrix().to_homogeneous()
     }
 }
 
 /// # Transformation of a vector or a point
-impl<N: SimdRealField> UnitComplex<N>
+impl<T: SimdRealField> UnitComplex<T>
 where
-    N::Element: SimdRealField,
+    T::Element: SimdRealField,
 {
     /// Rotate the given point by this unit complex number.
     ///
@@ -298,7 +298,7 @@ where
     /// assert_relative_eq!(transformed_point, Point2::new(-2.0, 1.0), epsilon = 1.0e-6);
     /// ```
     #[inline]
-    pub fn transform_point(&self, pt: &Point2<N>) -> Point2<N> {
+    pub fn transform_point(&self, pt: &Point2<T>) -> Point2<T> {
         self * pt
     }
 
@@ -316,7 +316,7 @@ where
     /// assert_relative_eq!(transformed_vector, Vector2::new(-2.0, 1.0), epsilon = 1.0e-6);
     /// ```
     #[inline]
-    pub fn transform_vector(&self, v: &Vector2<N>) -> Vector2<N> {
+    pub fn transform_vector(&self, v: &Vector2<T>) -> Vector2<T> {
         self * v
     }
 
@@ -332,7 +332,7 @@ where
     /// assert_relative_eq!(transformed_point, Point2::new(2.0, -1.0), epsilon = 1.0e-6);
     /// ```
     #[inline]
-    pub fn inverse_transform_point(&self, pt: &Point2<N>) -> Point2<N> {
+    pub fn inverse_transform_point(&self, pt: &Point2<T>) -> Point2<T> {
         // TODO: would it be useful performancewise not to call inverse explicitly (i-e. implement
         // the inverse transformation explicitly here) ?
         self.inverse() * pt
@@ -350,7 +350,7 @@ where
     /// assert_relative_eq!(transformed_vector, Vector2::new(2.0, -1.0), epsilon = 1.0e-6);
     /// ```
     #[inline]
-    pub fn inverse_transform_vector(&self, v: &Vector2<N>) -> Vector2<N> {
+    pub fn inverse_transform_vector(&self, v: &Vector2<T>) -> Vector2<T> {
         self.inverse() * v
     }
 
@@ -366,15 +366,15 @@ where
     /// assert_relative_eq!(transformed_vector, -Vector2::y_axis(), epsilon = 1.0e-6);
     /// ```
     #[inline]
-    pub fn inverse_transform_unit_vector(&self, v: &Unit<Vector2<N>>) -> Unit<Vector2<N>> {
+    pub fn inverse_transform_unit_vector(&self, v: &Unit<Vector2<T>>) -> Unit<Vector2<T>> {
         self.inverse() * v
     }
 }
 
 /// # Interpolation
-impl<N: SimdRealField> UnitComplex<N>
+impl<T: SimdRealField> UnitComplex<T>
 where
-    N::Element: SimdRealField,
+    T::Element: SimdRealField,
 {
     /// Spherical linear interpolation between two rotations represented as unit complex numbers.
     ///
@@ -392,23 +392,23 @@ where
     /// assert_relative_eq!(rot.angle(), std::f32::consts::FRAC_PI_2);
     /// ```
     #[inline]
-    pub fn slerp(&self, other: &Self, t: N) -> Self {
-        Self::new(self.angle() * (N::one() - t) + other.angle() * t)
+    pub fn slerp(&self, other: &Self, t: T) -> Self {
+        Self::new(self.angle() * (T::one() - t) + other.angle() * t)
     }
 }
 
-impl<N: RealField + fmt::Display> fmt::Display for UnitComplex<N> {
+impl<T: RealField + fmt::Display> fmt::Display for UnitComplex<T> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "UnitComplex angle: {}", self.angle())
     }
 }
 
-impl<N: RealField> AbsDiffEq for UnitComplex<N> {
-    type Epsilon = N;
+impl<T: RealField> AbsDiffEq for UnitComplex<T> {
+    type Epsilon = T;
 
     #[inline]
     fn default_epsilon() -> Self::Epsilon {
-        N::default_epsilon()
+        T::default_epsilon()
     }
 
     #[inline]
@@ -417,10 +417,10 @@ impl<N: RealField> AbsDiffEq for UnitComplex<N> {
     }
 }
 
-impl<N: RealField> RelativeEq for UnitComplex<N> {
+impl<T: RealField> RelativeEq for UnitComplex<T> {
     #[inline]
     fn default_max_relative() -> Self::Epsilon {
-        N::default_max_relative()
+        T::default_max_relative()
     }
 
     #[inline]
@@ -435,10 +435,10 @@ impl<N: RealField> RelativeEq for UnitComplex<N> {
     }
 }
 
-impl<N: RealField> UlpsEq for UnitComplex<N> {
+impl<T: RealField> UlpsEq for UnitComplex<T> {
     #[inline]
     fn default_max_ulps() -> u32 {
-        N::default_max_ulps()
+        T::default_max_ulps()
     }
 
     #[inline]
diff --git a/src/geometry/unit_complex_construction.rs b/src/geometry/unit_complex_construction.rs
index 9f300f3d..29ed7a01 100644
--- a/src/geometry/unit_complex_construction.rs
+++ b/src/geometry/unit_complex_construction.rs
@@ -2,7 +2,10 @@
 use quickcheck::{Arbitrary, Gen};
 
 #[cfg(feature = "rand-no-std")]
-use rand::{distributions::{Distribution, Standard}, Rng};
+use rand::{
+    distributions::{Distribution, Standard},
+    Rng,
+};
 
 use num::One;
 use num_complex::Complex;
@@ -15,9 +18,9 @@ use simba::scalar::{RealField, SupersetOf};
 use simba::simd::SimdRealField;
 
 /// # Identity
-impl<N: SimdRealField> UnitComplex<N>
+impl<T: SimdRealField> UnitComplex<T>
 where
-    N::Element: SimdRealField,
+    T::Element: SimdRealField,
 {
     /// The unit complex number multiplicative identity.
     ///
@@ -32,14 +35,14 @@ where
     /// ```
     #[inline]
     pub fn identity() -> Self {
-        Self::new_unchecked(Complex::new(N::one(), N::zero()))
+        Self::new_unchecked(Complex::new(T::one(), T::zero()))
     }
 }
 
 /// # Construction from a 2D rotation angle
-impl<N: SimdRealField> UnitComplex<N>
+impl<T: SimdRealField> UnitComplex<T>
 where
-    N::Element: SimdRealField,
+    T::Element: SimdRealField,
 {
     /// Builds the unit complex number corresponding to the rotation with the given angle.
     ///
@@ -54,7 +57,7 @@ where
     /// assert_relative_eq!(rot * Point2::new(3.0, 4.0), Point2::new(-4.0, 3.0));
     /// ```
     #[inline]
-    pub fn new(angle: N) -> Self {
+    pub fn new(angle: T) -> Self {
         let (sin, cos) = angle.simd_sin_cos();
         Self::from_cos_sin_unchecked(cos, sin)
     }
@@ -75,7 +78,7 @@ where
     /// ```
     // TODO: deprecate this.
     #[inline]
-    pub fn from_angle(angle: N) -> Self {
+    pub fn from_angle(angle: T) -> Self {
         Self::new(angle)
     }
 
@@ -96,7 +99,7 @@ where
     /// assert_relative_eq!(rot * Point2::new(3.0, 4.0), Point2::new(-4.0, 3.0));
     /// ```
     #[inline]
-    pub fn from_cos_sin_unchecked(cos: N, sin: N) -> Self {
+    pub fn from_cos_sin_unchecked(cos: T, sin: T) -> Self {
         Self::new_unchecked(Complex::new(cos, sin))
     }
 
@@ -105,15 +108,15 @@ where
     /// This is generally used in the context of generic programming. Using
     /// the `::new(angle)` method instead is more common.
     #[inline]
-    pub fn from_scaled_axis<SB: Storage<N, U1>>(axisangle: Vector<N, U1, SB>) -> Self {
+    pub fn from_scaled_axis<SB: Storage<T, U1>>(axisangle: Vector<T, U1, SB>) -> Self {
         Self::from_angle(axisangle[0])
     }
 }
 
 /// # Construction from an existing 2D matrix or complex number
-impl<N: SimdRealField> UnitComplex<N>
+impl<T: SimdRealField> UnitComplex<T>
 where
-    N::Element: SimdRealField,
+    T::Element: SimdRealField,
 {
     /// Cast the components of `self` to another type.
     ///
@@ -145,7 +148,7 @@ where
     /// assert_eq!(*rot.complex(), Complex::new(angle.cos(), angle.sin()));
     /// ```
     #[inline]
-    pub fn complex(&self) -> &Complex<N> {
+    pub fn complex(&self) -> &Complex<T> {
         self.as_ref()
     }
 
@@ -153,7 +156,7 @@ where
     ///
     /// The input complex number will be normalized.
     #[inline]
-    pub fn from_complex(q: Complex<N>) -> Self {
+    pub fn from_complex(q: Complex<T>) -> Self {
         Self::from_complex_and_get(q).0
     }
 
@@ -161,7 +164,7 @@ where
     ///
     /// The input complex number will be normalized. Returns the norm of the complex number as well.
     #[inline]
-    pub fn from_complex_and_get(q: Complex<N>) -> (Self, N) {
+    pub fn from_complex_and_get(q: Complex<T>) -> (Self, T) {
         let norm = (q.im * q.im + q.re * q.re).simd_sqrt();
         (Self::new_unchecked(q / norm), norm)
     }
@@ -177,7 +180,7 @@ where
     /// ```
     // TODO: add UnitComplex::from(...) instead?
     #[inline]
-    pub fn from_rotation_matrix(rotmat: &Rotation2<N>) -> Self {
+    pub fn from_rotation_matrix(rotmat: &Rotation2<T>) -> Self {
         Self::new_unchecked(Complex::new(rotmat[(0, 0)], rotmat[(1, 0)]))
     }
 
@@ -187,7 +190,7 @@ where
     /// orthonormal basis, i.e., all vectors are normalized, and the are
     /// all orthogonal to each other. These invariants are not checked
     /// by this method.
-    pub fn from_basis_unchecked(basis: &[Vector2<N>; 2]) -> Self {
+    pub fn from_basis_unchecked(basis: &[Vector2<T>; 2]) -> Self {
         let mat = Matrix2::from_columns(&basis[..]);
         let rot = Rotation2::from_matrix_unchecked(mat);
         Self::from_rotation_matrix(&rot)
@@ -198,9 +201,9 @@ where
     /// This is an iterative method. See `.from_matrix_eps` to provide mover
     /// convergence parameters and starting solution.
     /// This implements "A Robust Method to Extract the Rotational Part of Deformations" by Müller et al.
-    pub fn from_matrix(m: &Matrix2<N>) -> Self
+    pub fn from_matrix(m: &Matrix2<T>) -> Self
     where
-        N: RealField,
+        T: RealField,
     {
         Rotation2::from_matrix(m).into()
     }
@@ -217,9 +220,9 @@ where
     /// * `guess`: an estimate of the solution. Convergence will be significantly faster if an initial solution close
     ///           to the actual solution is provided. Can be set to `UnitQuaternion::identity()` if no other
     ///           guesses come to mind.
-    pub fn from_matrix_eps(m: &Matrix2<N>, eps: N, max_iter: usize, guess: Self) -> Self
+    pub fn from_matrix_eps(m: &Matrix2<T>, eps: T, max_iter: usize, guess: Self) -> Self
     where
-        N: RealField,
+        T: RealField,
     {
         let guess = Rotation2::from(guess);
         Rotation2::from_matrix_eps(m, eps, max_iter, guess).into()
@@ -259,15 +262,15 @@ where
     /// assert_relative_eq!(pow.angle(), 2.0 * 0.78);
     /// ```
     #[inline]
-    pub fn powf(&self, n: N) -> Self {
+    pub fn powf(&self, n: T) -> Self {
         Self::from_angle(self.angle() * n)
     }
 }
 
 /// # Construction from two vectors
-impl<N: SimdRealField> UnitComplex<N>
+impl<T: SimdRealField> UnitComplex<T>
 where
-    N::Element: SimdRealField,
+    T::Element: SimdRealField,
 {
     /// The unit complex needed to make `a` and `b` be collinear and point toward the same
     /// direction.
@@ -283,13 +286,13 @@ where
     /// assert_relative_eq!(rot.inverse() * b, a);
     /// ```
     #[inline]
-    pub fn rotation_between<SB, SC>(a: &Vector<N, U2, SB>, b: &Vector<N, U2, SC>) -> Self
+    pub fn rotation_between<SB, SC>(a: &Vector<T, U2, SB>, b: &Vector<T, U2, SC>) -> Self
     where
-        N: RealField,
-        SB: Storage<N, U2>,
-        SC: Storage<N, U2>,
+        T: RealField,
+        SB: Storage<T, U2>,
+        SC: Storage<T, U2>,
     {
-        Self::scaled_rotation_between(a, b, N::one())
+        Self::scaled_rotation_between(a, b, T::one())
     }
 
     /// The smallest rotation needed to make `a` and `b` collinear and point toward the same
@@ -308,19 +311,19 @@ where
     /// ```
     #[inline]
     pub fn scaled_rotation_between<SB, SC>(
-        a: &Vector<N, U2, SB>,
-        b: &Vector<N, U2, SC>,
-        s: N,
+        a: &Vector<T, U2, SB>,
+        b: &Vector<T, U2, SC>,
+        s: T,
     ) -> Self
     where
-        N: RealField,
-        SB: Storage<N, U2>,
-        SC: Storage<N, U2>,
+        T: RealField,
+        SB: Storage<T, U2>,
+        SC: Storage<T, U2>,
     {
         // TODO: code duplication with Rotation.
         if let (Some(na), Some(nb)) = (
-            Unit::try_new(a.clone_owned(), N::zero()),
-            Unit::try_new(b.clone_owned(), N::zero()),
+            Unit::try_new(a.clone_owned(), T::zero()),
+            Unit::try_new(b.clone_owned(), T::zero()),
         ) {
             Self::scaled_rotation_between_axis(&na, &nb, s)
         } else {
@@ -343,14 +346,14 @@ where
     /// ```
     #[inline]
     pub fn rotation_between_axis<SB, SC>(
-        a: &Unit<Vector<N, U2, SB>>,
-        b: &Unit<Vector<N, U2, SC>>,
+        a: &Unit<Vector<T, U2, SB>>,
+        b: &Unit<Vector<T, U2, SC>>,
     ) -> Self
     where
-        SB: Storage<N, U2>,
-        SC: Storage<N, U2>,
+        SB: Storage<T, U2>,
+        SC: Storage<T, U2>,
     {
-        Self::scaled_rotation_between_axis(a, b, N::one())
+        Self::scaled_rotation_between_axis(a, b, T::one())
     }
 
     /// The smallest rotation needed to make `a` and `b` collinear and point toward the same
@@ -369,13 +372,13 @@ where
     /// ```
     #[inline]
     pub fn scaled_rotation_between_axis<SB, SC>(
-        na: &Unit<Vector<N, U2, SB>>,
-        nb: &Unit<Vector<N, U2, SC>>,
-        s: N,
+        na: &Unit<Vector<T, U2, SB>>,
+        nb: &Unit<Vector<T, U2, SC>>,
+        s: T,
     ) -> Self
     where
-        SB: Storage<N, U2>,
-        SC: Storage<N, U2>,
+        SB: Storage<T, U2>,
+        SC: Storage<T, U2>,
     {
         let sang = na.perp(&nb);
         let cang = na.dot(&nb);
@@ -384,9 +387,9 @@ where
     }
 }
 
-impl<N: SimdRealField> One for UnitComplex<N>
+impl<T: SimdRealField> One for UnitComplex<T>
 where
-    N::Element: SimdRealField,
+    T::Element: SimdRealField,
 {
     #[inline]
     fn one() -> Self {
@@ -395,26 +398,26 @@ where
 }
 
 #[cfg(feature = "rand-no-std")]
-impl<N: SimdRealField> Distribution<UnitComplex<N>> for Standard
+impl<T: SimdRealField> Distribution<UnitComplex<T>> for Standard
 where
-    N::Element: SimdRealField,
-    rand_distr::UnitCircle: Distribution<[N; 2]>,
+    T::Element: SimdRealField,
+    rand_distr::UnitCircle: Distribution<[T; 2]>,
 {
     /// Generate a uniformly distributed random `UnitComplex`.
     #[inline]
-    fn sample<'a, R: Rng + ?Sized>(&self, rng: &mut R) -> UnitComplex<N> {
+    fn sample<'a, R: Rng + ?Sized>(&self, rng: &mut R) -> UnitComplex<T> {
         let x = rng.sample(rand_distr::UnitCircle);
         UnitComplex::new_unchecked(Complex::new(x[0], x[1]))
     }
 }
 
 #[cfg(feature = "arbitrary")]
-impl<N: SimdRealField + Arbitrary> Arbitrary for UnitComplex<N>
+impl<T: SimdRealField + Arbitrary> Arbitrary for UnitComplex<T>
 where
-    N::Element: SimdRealField,
+    T::Element: SimdRealField,
 {
     #[inline]
     fn arbitrary(g: &mut Gen) -> Self {
-        UnitComplex::from_angle(N::arbitrary(g))
+        UnitComplex::from_angle(T::arbitrary(g))
     }
 }
diff --git a/src/geometry/unit_complex_conversion.rs b/src/geometry/unit_complex_conversion.rs
index 91736764..04fb41ac 100644
--- a/src/geometry/unit_complex_conversion.rs
+++ b/src/geometry/unit_complex_conversion.rs
@@ -4,7 +4,6 @@ use num_complex::Complex;
 use simba::scalar::{RealField, SubsetOf, SupersetOf};
 use simba::simd::{PrimitiveSimdValue, SimdRealField};
 
-use crate::base::dimension::U2;
 use crate::base::{Matrix2, Matrix3, Scalar};
 use crate::geometry::{
     AbstractRotation, Isometry, Rotation2, Similarity, SuperTCategoryOf, TAffine, Transform,
@@ -17,224 +16,224 @@ use crate::geometry::{
  *
  * UnitComplex -> UnitComplex
  * UnitComplex -> Rotation<U1>
- * UnitComplex -> Isometry<U2>
- * UnitComplex -> Similarity<U2>
- * UnitComplex -> Transform<U2>
+ * UnitComplex -> Isometry<2>
+ * UnitComplex -> Similarity<2>
+ * UnitComplex -> Transform<2>
  * UnitComplex -> Matrix<U3> (homogeneous)
  *
  * NOTE:
  * UnitComplex -> Complex is already provided by: Unit<T> -> T
  */
 
-impl<N1, N2> SubsetOf<UnitComplex<N2>> for UnitComplex<N1>
+impl<T1, T2> SubsetOf<UnitComplex<T2>> for UnitComplex<T1>
 where
-    N1: RealField,
-    N2: RealField + SupersetOf<N1>,
+    T1: RealField,
+    T2: RealField + SupersetOf<T1>,
 {
     #[inline]
-    fn to_superset(&self) -> UnitComplex<N2> {
+    fn to_superset(&self) -> UnitComplex<T2> {
         UnitComplex::new_unchecked(self.as_ref().to_superset())
     }
 
     #[inline]
-    fn is_in_subset(uq: &UnitComplex<N2>) -> bool {
-        crate::is_convertible::<_, Complex<N1>>(uq.as_ref())
+    fn is_in_subset(uq: &UnitComplex<T2>) -> bool {
+        crate::is_convertible::<_, Complex<T1>>(uq.as_ref())
     }
 
     #[inline]
-    fn from_superset_unchecked(uq: &UnitComplex<N2>) -> Self {
+    fn from_superset_unchecked(uq: &UnitComplex<T2>) -> Self {
         Self::new_unchecked(crate::convert_ref_unchecked(uq.as_ref()))
     }
 }
 
-impl<N1, N2> SubsetOf<Rotation2<N2>> for UnitComplex<N1>
+impl<T1, T2> SubsetOf<Rotation2<T2>> for UnitComplex<T1>
 where
-    N1: RealField,
-    N2: RealField + SupersetOf<N1>,
+    T1: RealField,
+    T2: RealField + SupersetOf<T1>,
 {
     #[inline]
-    fn to_superset(&self) -> Rotation2<N2> {
-        let q: UnitComplex<N2> = self.to_superset();
+    fn to_superset(&self) -> Rotation2<T2> {
+        let q: UnitComplex<T2> = self.to_superset();
         q.to_rotation_matrix().to_superset()
     }
 
     #[inline]
-    fn is_in_subset(rot: &Rotation2<N2>) -> bool {
-        crate::is_convertible::<_, Rotation2<N1>>(rot)
+    fn is_in_subset(rot: &Rotation2<T2>) -> bool {
+        crate::is_convertible::<_, Rotation2<T1>>(rot)
     }
 
     #[inline]
-    fn from_superset_unchecked(rot: &Rotation2<N2>) -> Self {
-        let q = UnitComplex::<N2>::from_rotation_matrix(rot);
+    fn from_superset_unchecked(rot: &Rotation2<T2>) -> Self {
+        let q = UnitComplex::<T2>::from_rotation_matrix(rot);
         crate::convert_unchecked(q)
     }
 }
 
-impl<N1, N2, R> SubsetOf<Isometry<N2, U2, R>> for UnitComplex<N1>
+impl<T1, T2, R> SubsetOf<Isometry<T2, R, 2>> for UnitComplex<T1>
 where
-    N1: RealField,
-    N2: RealField + SupersetOf<N1>,
-    R: AbstractRotation<N2, U2> + SupersetOf<Self>,
+    T1: RealField,
+    T2: RealField + SupersetOf<T1>,
+    R: AbstractRotation<T2, 2> + SupersetOf<Self>,
 {
     #[inline]
-    fn to_superset(&self) -> Isometry<N2, U2, R> {
+    fn to_superset(&self) -> Isometry<T2, R, 2> {
         Isometry::from_parts(Translation::identity(), crate::convert_ref(self))
     }
 
     #[inline]
-    fn is_in_subset(iso: &Isometry<N2, U2, R>) -> bool {
+    fn is_in_subset(iso: &Isometry<T2, R, 2>) -> bool {
         iso.translation.vector.is_zero()
     }
 
     #[inline]
-    fn from_superset_unchecked(iso: &Isometry<N2, U2, R>) -> Self {
+    fn from_superset_unchecked(iso: &Isometry<T2, R, 2>) -> Self {
         crate::convert_ref_unchecked(&iso.rotation)
     }
 }
 
-impl<N1, N2, R> SubsetOf<Similarity<N2, U2, R>> for UnitComplex<N1>
+impl<T1, T2, R> SubsetOf<Similarity<T2, R, 2>> for UnitComplex<T1>
 where
-    N1: RealField,
-    N2: RealField + SupersetOf<N1>,
-    R: AbstractRotation<N2, U2> + SupersetOf<Self>,
+    T1: RealField,
+    T2: RealField + SupersetOf<T1>,
+    R: AbstractRotation<T2, 2> + SupersetOf<Self>,
 {
     #[inline]
-    fn to_superset(&self) -> Similarity<N2, U2, R> {
-        Similarity::from_isometry(crate::convert_ref(self), N2::one())
+    fn to_superset(&self) -> Similarity<T2, R, 2> {
+        Similarity::from_isometry(crate::convert_ref(self), T2::one())
     }
 
     #[inline]
-    fn is_in_subset(sim: &Similarity<N2, U2, R>) -> bool {
-        sim.isometry.translation.vector.is_zero() && sim.scaling() == N2::one()
+    fn is_in_subset(sim: &Similarity<T2, R, 2>) -> bool {
+        sim.isometry.translation.vector.is_zero() && sim.scaling() == T2::one()
     }
 
     #[inline]
-    fn from_superset_unchecked(sim: &Similarity<N2, U2, R>) -> Self {
+    fn from_superset_unchecked(sim: &Similarity<T2, R, 2>) -> Self {
         crate::convert_ref_unchecked(&sim.isometry)
     }
 }
 
-impl<N1, N2, C> SubsetOf<Transform<N2, U2, C>> for UnitComplex<N1>
+impl<T1, T2, C> SubsetOf<Transform<T2, C, 2>> for UnitComplex<T1>
 where
-    N1: RealField,
-    N2: RealField + SupersetOf<N1>,
+    T1: RealField,
+    T2: RealField + SupersetOf<T1>,
     C: SuperTCategoryOf<TAffine>,
 {
     #[inline]
-    fn to_superset(&self) -> Transform<N2, U2, C> {
+    fn to_superset(&self) -> Transform<T2, C, 2> {
         Transform::from_matrix_unchecked(self.to_homogeneous().to_superset())
     }
 
     #[inline]
-    fn is_in_subset(t: &Transform<N2, U2, C>) -> bool {
+    fn is_in_subset(t: &Transform<T2, C, 2>) -> bool {
         <Self as SubsetOf<_>>::is_in_subset(t.matrix())
     }
 
     #[inline]
-    fn from_superset_unchecked(t: &Transform<N2, U2, C>) -> Self {
+    fn from_superset_unchecked(t: &Transform<T2, C, 2>) -> Self {
         Self::from_superset_unchecked(t.matrix())
     }
 }
 
-impl<N1: RealField, N2: RealField + SupersetOf<N1>> SubsetOf<Matrix3<N2>> for UnitComplex<N1> {
+impl<T1: RealField, T2: RealField + SupersetOf<T1>> SubsetOf<Matrix3<T2>> for UnitComplex<T1> {
     #[inline]
-    fn to_superset(&self) -> Matrix3<N2> {
+    fn to_superset(&self) -> Matrix3<T2> {
         self.to_homogeneous().to_superset()
     }
 
     #[inline]
-    fn is_in_subset(m: &Matrix3<N2>) -> bool {
-        crate::is_convertible::<_, Rotation2<N1>>(m)
+    fn is_in_subset(m: &Matrix3<T2>) -> bool {
+        crate::is_convertible::<_, Rotation2<T1>>(m)
     }
 
     #[inline]
-    fn from_superset_unchecked(m: &Matrix3<N2>) -> Self {
-        let rot: Rotation2<N1> = crate::convert_ref_unchecked(m);
+    fn from_superset_unchecked(m: &Matrix3<T2>) -> Self {
+        let rot: Rotation2<T1> = crate::convert_ref_unchecked(m);
         Self::from_rotation_matrix(&rot)
     }
 }
 
-impl<N: SimdRealField> From<UnitComplex<N>> for Rotation2<N>
+impl<T: SimdRealField> From<UnitComplex<T>> for Rotation2<T>
 where
-    N::Element: SimdRealField,
+    T::Element: SimdRealField,
 {
     #[inline]
-    fn from(q: UnitComplex<N>) -> Self {
+    fn from(q: UnitComplex<T>) -> Self {
         q.to_rotation_matrix()
     }
 }
 
-impl<N: SimdRealField> From<Rotation2<N>> for UnitComplex<N>
+impl<T: SimdRealField> From<Rotation2<T>> for UnitComplex<T>
 where
-    N::Element: SimdRealField,
+    T::Element: SimdRealField,
 {
     #[inline]
-    fn from(q: Rotation2<N>) -> Self {
+    fn from(q: Rotation2<T>) -> Self {
         Self::from_rotation_matrix(&q)
     }
 }
 
-impl<N: SimdRealField> From<UnitComplex<N>> for Matrix3<N>
+impl<T: SimdRealField> From<UnitComplex<T>> for Matrix3<T>
 where
-    N::Element: SimdRealField,
+    T::Element: SimdRealField,
 {
     #[inline]
-    fn from(q: UnitComplex<N>) -> Matrix3<N> {
+    fn from(q: UnitComplex<T>) -> Matrix3<T> {
         q.to_homogeneous()
     }
 }
 
-impl<N: SimdRealField> From<UnitComplex<N>> for Matrix2<N>
+impl<T: SimdRealField> From<UnitComplex<T>> for Matrix2<T>
 where
-    N::Element: SimdRealField,
+    T::Element: SimdRealField,
 {
     #[inline]
-    fn from(q: UnitComplex<N>) -> Self {
+    fn from(q: UnitComplex<T>) -> Self {
         q.to_rotation_matrix().into_inner()
     }
 }
 
-impl<N: Scalar + Copy + PrimitiveSimdValue> From<[UnitComplex<N::Element>; 2]> for UnitComplex<N>
+impl<T: Scalar + Copy + PrimitiveSimdValue> From<[UnitComplex<T::Element>; 2]> for UnitComplex<T>
 where
-    N: From<[<N as simba::simd::SimdValue>::Element; 2]>,
-    N::Element: Scalar + Copy,
+    T: From<[<T as simba::simd::SimdValue>::Element; 2]>,
+    T::Element: Scalar + Copy,
 {
     #[inline]
-    fn from(arr: [UnitComplex<N::Element>; 2]) -> Self {
+    fn from(arr: [UnitComplex<T::Element>; 2]) -> Self {
         Self::new_unchecked(Complex {
-            re: N::from([arr[0].re, arr[1].re]),
-            im: N::from([arr[0].im, arr[1].im]),
+            re: T::from([arr[0].re, arr[1].re]),
+            im: T::from([arr[0].im, arr[1].im]),
         })
     }
 }
 
-impl<N: Scalar + Copy + PrimitiveSimdValue> From<[UnitComplex<N::Element>; 4]> for UnitComplex<N>
+impl<T: Scalar + Copy + PrimitiveSimdValue> From<[UnitComplex<T::Element>; 4]> for UnitComplex<T>
 where
-    N: From<[<N as simba::simd::SimdValue>::Element; 4]>,
-    N::Element: Scalar + Copy,
+    T: From<[<T as simba::simd::SimdValue>::Element; 4]>,
+    T::Element: Scalar + Copy,
 {
     #[inline]
-    fn from(arr: [UnitComplex<N::Element>; 4]) -> Self {
+    fn from(arr: [UnitComplex<T::Element>; 4]) -> Self {
         Self::new_unchecked(Complex {
-            re: N::from([arr[0].re, arr[1].re, arr[2].re, arr[3].re]),
-            im: N::from([arr[0].im, arr[1].im, arr[2].im, arr[3].im]),
+            re: T::from([arr[0].re, arr[1].re, arr[2].re, arr[3].re]),
+            im: T::from([arr[0].im, arr[1].im, arr[2].im, arr[3].im]),
         })
     }
 }
 
-impl<N: Scalar + Copy + PrimitiveSimdValue> From<[UnitComplex<N::Element>; 8]> for UnitComplex<N>
+impl<T: Scalar + Copy + PrimitiveSimdValue> From<[UnitComplex<T::Element>; 8]> for UnitComplex<T>
 where
-    N: From<[<N as simba::simd::SimdValue>::Element; 8]>,
-    N::Element: Scalar + Copy,
+    T: From<[<T as simba::simd::SimdValue>::Element; 8]>,
+    T::Element: Scalar + Copy,
 {
     #[inline]
-    fn from(arr: [UnitComplex<N::Element>; 8]) -> Self {
+    fn from(arr: [UnitComplex<T::Element>; 8]) -> Self {
         Self::new_unchecked(Complex {
-            re: N::from([
+            re: T::from([
                 arr[0].re, arr[1].re, arr[2].re, arr[3].re, arr[4].re, arr[5].re, arr[6].re,
                 arr[7].re,
             ]),
-            im: N::from([
+            im: T::from([
                 arr[0].im, arr[1].im, arr[2].im, arr[3].im, arr[4].im, arr[5].im, arr[6].im,
                 arr[7].im,
             ]),
@@ -242,20 +241,20 @@ where
     }
 }
 
-impl<N: Scalar + Copy + PrimitiveSimdValue> From<[UnitComplex<N::Element>; 16]> for UnitComplex<N>
+impl<T: Scalar + Copy + PrimitiveSimdValue> From<[UnitComplex<T::Element>; 16]> for UnitComplex<T>
 where
-    N: From<[<N as simba::simd::SimdValue>::Element; 16]>,
-    N::Element: Scalar + Copy,
+    T: From<[<T as simba::simd::SimdValue>::Element; 16]>,
+    T::Element: Scalar + Copy,
 {
     #[inline]
-    fn from(arr: [UnitComplex<N::Element>; 16]) -> Self {
+    fn from(arr: [UnitComplex<T::Element>; 16]) -> Self {
         Self::new_unchecked(Complex {
-            re: N::from([
+            re: T::from([
                 arr[0].re, arr[1].re, arr[2].re, arr[3].re, arr[4].re, arr[5].re, arr[6].re,
                 arr[7].re, arr[8].re, arr[9].re, arr[10].re, arr[11].re, arr[12].re, arr[13].re,
                 arr[14].re, arr[15].re,
             ]),
-            im: N::from([
+            im: T::from([
                 arr[0].im, arr[1].im, arr[2].im, arr[3].im, arr[4].im, arr[5].im, arr[6].im,
                 arr[7].im, arr[8].im, arr[9].im, arr[10].im, arr[11].im, arr[12].im, arr[13].im,
                 arr[14].im, arr[15].im,
diff --git a/src/geometry/unit_complex_ops.rs b/src/geometry/unit_complex_ops.rs
index ef227023..abaa9d4f 100644
--- a/src/geometry/unit_complex_ops.rs
+++ b/src/geometry/unit_complex_ops.rs
@@ -1,9 +1,7 @@
 use std::ops::{Div, DivAssign, Mul, MulAssign};
 
-use crate::base::allocator::Allocator;
-use crate::base::dimension::{U1, U2};
 use crate::base::storage::Storage;
-use crate::base::{DefaultAllocator, Unit, Vector, Vector2};
+use crate::base::{Const, Unit, Vector, Vector2};
 use crate::geometry::{Isometry, Point2, Rotation, Similarity, Translation, UnitComplex};
 use simba::simd::SimdRealField;
 
@@ -42,7 +40,7 @@ use simba::simd::SimdRealField;
  */
 
 // UnitComplex × UnitComplex
-impl<N: SimdRealField> Mul<Self> for UnitComplex<N> {
+impl<T: SimdRealField> Mul<Self> for UnitComplex<T> {
     type Output = Self;
 
     #[inline]
@@ -51,46 +49,46 @@ impl<N: SimdRealField> Mul<Self> for UnitComplex<N> {
     }
 }
 
-impl<'a, N: SimdRealField> Mul<UnitComplex<N>> for &'a UnitComplex<N>
+impl<'a, T: SimdRealField> Mul<UnitComplex<T>> for &'a UnitComplex<T>
 where
-    N::Element: SimdRealField,
+    T::Element: SimdRealField,
 {
-    type Output = UnitComplex<N>;
+    type Output = UnitComplex<T>;
 
     #[inline]
-    fn mul(self, rhs: UnitComplex<N>) -> Self::Output {
+    fn mul(self, rhs: UnitComplex<T>) -> Self::Output {
         Unit::new_unchecked(self.complex() * rhs.into_inner())
     }
 }
 
-impl<'b, N: SimdRealField> Mul<&'b UnitComplex<N>> for UnitComplex<N>
+impl<'b, T: SimdRealField> Mul<&'b UnitComplex<T>> for UnitComplex<T>
 where
-    N::Element: SimdRealField,
+    T::Element: SimdRealField,
 {
     type Output = Self;
 
     #[inline]
-    fn mul(self, rhs: &'b UnitComplex<N>) -> Self::Output {
+    fn mul(self, rhs: &'b UnitComplex<T>) -> Self::Output {
         Unit::new_unchecked(self.into_inner() * rhs.as_ref())
     }
 }
 
-impl<'a, 'b, N: SimdRealField> Mul<&'b UnitComplex<N>> for &'a UnitComplex<N>
+impl<'a, 'b, T: SimdRealField> Mul<&'b UnitComplex<T>> for &'a UnitComplex<T>
 where
-    N::Element: SimdRealField,
+    T::Element: SimdRealField,
 {
-    type Output = UnitComplex<N>;
+    type Output = UnitComplex<T>;
 
     #[inline]
-    fn mul(self, rhs: &'b UnitComplex<N>) -> Self::Output {
+    fn mul(self, rhs: &'b UnitComplex<T>) -> Self::Output {
         Unit::new_unchecked(self.complex() * rhs.as_ref())
     }
 }
 
 // UnitComplex ÷ UnitComplex
-impl<N: SimdRealField> Div<Self> for UnitComplex<N>
+impl<T: SimdRealField> Div<Self> for UnitComplex<T>
 where
-    N::Element: SimdRealField,
+    T::Element: SimdRealField,
 {
     type Output = Self;
 
@@ -101,40 +99,40 @@ where
     }
 }
 
-impl<'a, N: SimdRealField> Div<UnitComplex<N>> for &'a UnitComplex<N>
+impl<'a, T: SimdRealField> Div<UnitComplex<T>> for &'a UnitComplex<T>
 where
-    N::Element: SimdRealField,
+    T::Element: SimdRealField,
 {
-    type Output = UnitComplex<N>;
+    type Output = UnitComplex<T>;
 
     #[inline]
-    fn div(self, rhs: UnitComplex<N>) -> Self::Output {
+    fn div(self, rhs: UnitComplex<T>) -> Self::Output {
         #[allow(clippy::suspicious_arithmetic_impl)]
         Unit::new_unchecked(self.complex() * rhs.conjugate().into_inner())
     }
 }
 
-impl<'b, N: SimdRealField> Div<&'b UnitComplex<N>> for UnitComplex<N>
+impl<'b, T: SimdRealField> Div<&'b UnitComplex<T>> for UnitComplex<T>
 where
-    N::Element: SimdRealField,
+    T::Element: SimdRealField,
 {
     type Output = Self;
 
     #[inline]
-    fn div(self, rhs: &'b UnitComplex<N>) -> Self::Output {
+    fn div(self, rhs: &'b UnitComplex<T>) -> Self::Output {
         #[allow(clippy::suspicious_arithmetic_impl)]
         Unit::new_unchecked(self.into_inner() * rhs.conjugate().into_inner())
     }
 }
 
-impl<'a, 'b, N: SimdRealField> Div<&'b UnitComplex<N>> for &'a UnitComplex<N>
+impl<'a, 'b, T: SimdRealField> Div<&'b UnitComplex<T>> for &'a UnitComplex<T>
 where
-    N::Element: SimdRealField,
+    T::Element: SimdRealField,
 {
-    type Output = UnitComplex<N>;
+    type Output = UnitComplex<T>;
 
     #[inline]
-    fn div(self, rhs: &'b UnitComplex<N>) -> Self::Output {
+    fn div(self, rhs: &'b UnitComplex<T>) -> Self::Output {
         #[allow(clippy::suspicious_arithmetic_impl)]
         Unit::new_unchecked(self.complex() * rhs.conjugate().into_inner())
     }
@@ -142,12 +140,11 @@ where
 
 macro_rules! complex_op_impl(
     ($Op: ident, $op: ident;
-     ($RDim: ident, $CDim: ident) $(for $Storage: ident: $StoragesBound: ident $(<$($BoundParam: ty),*>)*),*;
+     $($Storage: ident: $StoragesBound: ident $(<$($BoundParam: ty),*>)*),*;
      $lhs: ident: $Lhs: ty, $rhs: ident: $Rhs: ty, Output = $Result: ty;
      $action: expr; $($lives: tt),*) => {
-        impl<$($lives ,)* N: SimdRealField $(, $Storage: $StoragesBound $(<$($BoundParam),*>)*)*> $Op<$Rhs> for $Lhs
-            where N::Element: SimdRealField,
-                  DefaultAllocator: Allocator<N, $RDim, $CDim> {
+        impl<$($lives ,)* T: SimdRealField $(, $Storage: $StoragesBound $(<$($BoundParam),*>)*)*> $Op<$Rhs> for $Lhs
+            where T::Element: SimdRealField {
             type Output = $Result;
 
             #[inline]
@@ -160,7 +157,7 @@ macro_rules! complex_op_impl(
 
 macro_rules! complex_op_impl_all(
     ($Op: ident, $op: ident;
-     ($RDim: ident, $CDim: ident) $(for $Storage: ident: $StoragesBound: ident $(<$($BoundParam: ty),*>)*),*;
+     $($Storage: ident: $StoragesBound: ident $(<$($BoundParam: ty),*>)*),*;
      $lhs: ident: $Lhs: ty, $rhs: ident: $Rhs: ty, Output = $Result: ty;
      [val val] => $action_val_val: expr;
      [ref val] => $action_ref_val: expr;
@@ -168,22 +165,22 @@ macro_rules! complex_op_impl_all(
      [ref ref] => $action_ref_ref: expr;) => {
 
     complex_op_impl!($Op, $op;
-                     ($RDim, $CDim) $(for $Storage: $StoragesBound $(<$($BoundParam),*>)*),*;
+                     $($Storage: $StoragesBound $(<$($BoundParam),*>)*),*;
                      $lhs: $Lhs, $rhs: $Rhs, Output = $Result;
                      $action_val_val; );
 
     complex_op_impl!($Op, $op;
-                     ($RDim, $CDim) $(for $Storage: $StoragesBound $(<$($BoundParam),*>)*),*;
+                     $($Storage: $StoragesBound $(<$($BoundParam),*>)*),*;
                      $lhs: &'a $Lhs, $rhs: $Rhs, Output = $Result;
                      $action_ref_val; 'a);
 
     complex_op_impl!($Op, $op;
-                     ($RDim, $CDim) $(for $Storage: $StoragesBound $(<$($BoundParam),*>)*),*;
+                     $($Storage: $StoragesBound $(<$($BoundParam),*>)*),*;
                      $lhs: $Lhs, $rhs: &'b $Rhs, Output = $Result;
                      $action_val_ref; 'b);
 
     complex_op_impl!($Op, $op;
-                     ($RDim, $CDim) $(for $Storage: $StoragesBound $(<$($BoundParam),*>)*),*;
+                     $($Storage: $StoragesBound $(<$($BoundParam),*>)*),*;
                      $lhs: &'a $Lhs, $rhs: &'b $Rhs, Output = $Result;
                      $action_ref_ref; 'a, 'b);
 
@@ -194,8 +191,8 @@ macro_rules! complex_op_impl_all(
 // UnitComplex × Rotation
 complex_op_impl_all!(
     Mul, mul;
-    (U2, U2);
-    self: UnitComplex<N>, rhs: Rotation<N, U2>, Output = UnitComplex<N>;
+    ;
+    self: UnitComplex<T>, rhs: Rotation<T, 2>, Output = UnitComplex<T>;
     [val val] => &self * &rhs;
     [ref val] =>  self * &rhs;
     [val ref] => &self *  rhs;
@@ -205,8 +202,8 @@ complex_op_impl_all!(
 // UnitComplex ÷ Rotation
 complex_op_impl_all!(
     Div, div;
-    (U2, U2);
-    self: UnitComplex<N>, rhs: Rotation<N, U2>, Output = UnitComplex<N>;
+    ;
+    self: UnitComplex<T>, rhs: Rotation<T, 2>, Output = UnitComplex<T>;
     [val val] => &self / &rhs;
     [ref val] =>  self / &rhs;
     [val ref] => &self /  rhs;
@@ -216,8 +213,8 @@ complex_op_impl_all!(
 // Rotation × UnitComplex
 complex_op_impl_all!(
     Mul, mul;
-    (U2, U2);
-    self: Rotation<N, U2>, rhs: UnitComplex<N>, Output = UnitComplex<N>;
+    ;
+    self: Rotation<T, 2>, rhs: UnitComplex<T>, Output = UnitComplex<T>;
     [val val] => &self * &rhs;
     [ref val] =>  self * &rhs;
     [val ref] => &self *  rhs;
@@ -227,8 +224,8 @@ complex_op_impl_all!(
 // Rotation ÷ UnitComplex
 complex_op_impl_all!(
     Div, div;
-    (U2, U2);
-    self: Rotation<N, U2>, rhs: UnitComplex<N>, Output = UnitComplex<N>;
+    ;
+    self: Rotation<T, 2>, rhs: UnitComplex<T>, Output = UnitComplex<T>;
     [val val] => &self / &rhs;
     [ref val] =>  self / &rhs;
     [val ref] => &self /  rhs;
@@ -238,8 +235,8 @@ complex_op_impl_all!(
 // UnitComplex × Point
 complex_op_impl_all!(
     Mul, mul;
-    (U2, U1);
-    self: UnitComplex<N>, rhs: Point2<N>, Output = Point2<N>;
+    ;
+    self: UnitComplex<T>, rhs: Point2<T>, Output = Point2<T>;
     [val val] => &self * &rhs;
     [ref val] =>  self * &rhs;
     [val ref] => &self *  rhs;
@@ -249,8 +246,8 @@ complex_op_impl_all!(
 // UnitComplex × Vector
 complex_op_impl_all!(
     Mul, mul;
-    (U2, U1) for S: Storage<N, U2>;
-    self: UnitComplex<N>, rhs: Vector<N, U2, S>, Output = Vector2<N>;
+    S: Storage<T, Const<2>>;
+    self: UnitComplex<T>, rhs: Vector<T, Const<2>, S>, Output = Vector2<T>;
     [val val] => &self * &rhs;
     [ref val] =>  self * &rhs;
     [val ref] => &self *  rhs;
@@ -264,8 +261,8 @@ complex_op_impl_all!(
 // UnitComplex × Unit<Vector>
 complex_op_impl_all!(
     Mul, mul;
-    (U2, U1) for S: Storage<N, U2>;
-    self: UnitComplex<N>, rhs: Unit<Vector<N, U2, S>>, Output = Unit<Vector2<N>>;
+    S: Storage<T, Const<2>>;
+    self: UnitComplex<T>, rhs: Unit<Vector<T, Const<2>, S>>, Output = Unit<Vector2<T>>;
     [val val] => &self * &rhs;
     [ref val] =>  self * &rhs;
     [val ref] => &self *  rhs;
@@ -275,9 +272,9 @@ complex_op_impl_all!(
 // UnitComplex × Isometry<UnitComplex>
 complex_op_impl_all!(
     Mul, mul;
-    (U2, U1);
-    self: UnitComplex<N>, rhs: Isometry<N, U2, UnitComplex<N>>,
-    Output = Isometry<N, U2, UnitComplex<N>>;
+    ;
+    self: UnitComplex<T>, rhs: Isometry<T, UnitComplex<T>, 2>,
+    Output = Isometry<T, UnitComplex<T>, 2>;
     [val val] => &self * &rhs;
     [ref val] =>  self * &rhs;
     [val ref] => &self *  rhs;
@@ -290,9 +287,9 @@ complex_op_impl_all!(
 // UnitComplex × Similarity<UnitComplex>
 complex_op_impl_all!(
     Mul, mul;
-    (U2, U1);
-    self: UnitComplex<N>, rhs: Similarity<N, U2, UnitComplex<N>>,
-    Output = Similarity<N, U2, UnitComplex<N>>;
+    ;
+    self: UnitComplex<T>, rhs: Similarity<T, UnitComplex<T>, 2>,
+    Output = Similarity<T, UnitComplex<T>, 2>;
     [val val] => &self * &rhs;
     [ref val] =>  self * &rhs;
     [val ref] => &self *  rhs;
@@ -302,9 +299,9 @@ complex_op_impl_all!(
 // UnitComplex × Translation
 complex_op_impl_all!(
     Mul, mul;
-    (U2, U1);
-    self: UnitComplex<N>, rhs: Translation<N, U2>,
-    Output = Isometry<N, U2, UnitComplex<N>>;
+    ;
+    self: UnitComplex<T>, rhs: Translation<T, 2>,
+    Output = Isometry<T, UnitComplex<T>, 2>;
     [val val] => Isometry::from_parts(Translation::from(&self *  rhs.vector), self);
     [ref val] => Isometry::from_parts(Translation::from( self *  rhs.vector), *self);
     [val ref] => Isometry::from_parts(Translation::from(&self * &rhs.vector), self);
@@ -314,9 +311,9 @@ complex_op_impl_all!(
 // Translation × UnitComplex
 complex_op_impl_all!(
     Mul, mul;
-    (U2, U1);
-    self: Translation<N, U2>, right: UnitComplex<N>,
-    Output = Isometry<N, U2, UnitComplex<N>>;
+    ;
+    self: Translation<T, 2>, right: UnitComplex<T>,
+    Output = Isometry<T, UnitComplex<T>, 2>;
     [val val] => Isometry::from_parts(self, right);
     [ref val] => Isometry::from_parts(self.clone(), right);
     [val ref] => Isometry::from_parts(self, *right);
@@ -324,135 +321,127 @@ complex_op_impl_all!(
 );
 
 // UnitComplex ×= UnitComplex
-impl<N: SimdRealField> MulAssign<UnitComplex<N>> for UnitComplex<N>
+impl<T: SimdRealField> MulAssign<UnitComplex<T>> for UnitComplex<T>
 where
-    N::Element: SimdRealField,
+    T::Element: SimdRealField,
 {
     #[inline]
-    fn mul_assign(&mut self, rhs: UnitComplex<N>) {
+    fn mul_assign(&mut self, rhs: UnitComplex<T>) {
         *self = &*self * rhs
     }
 }
 
-impl<'b, N: SimdRealField> MulAssign<&'b UnitComplex<N>> for UnitComplex<N>
+impl<'b, T: SimdRealField> MulAssign<&'b UnitComplex<T>> for UnitComplex<T>
 where
-    N::Element: SimdRealField,
+    T::Element: SimdRealField,
 {
     #[inline]
-    fn mul_assign(&mut self, rhs: &'b UnitComplex<N>) {
+    fn mul_assign(&mut self, rhs: &'b UnitComplex<T>) {
         *self = &*self * rhs
     }
 }
 
 // UnitComplex /= UnitComplex
-impl<N: SimdRealField> DivAssign<UnitComplex<N>> for UnitComplex<N>
+impl<T: SimdRealField> DivAssign<UnitComplex<T>> for UnitComplex<T>
 where
-    N::Element: SimdRealField,
+    T::Element: SimdRealField,
 {
     #[inline]
-    fn div_assign(&mut self, rhs: UnitComplex<N>) {
+    fn div_assign(&mut self, rhs: UnitComplex<T>) {
         *self = &*self / rhs
     }
 }
 
-impl<'b, N: SimdRealField> DivAssign<&'b UnitComplex<N>> for UnitComplex<N>
+impl<'b, T: SimdRealField> DivAssign<&'b UnitComplex<T>> for UnitComplex<T>
 where
-    N::Element: SimdRealField,
+    T::Element: SimdRealField,
 {
     #[inline]
-    fn div_assign(&mut self, rhs: &'b UnitComplex<N>) {
+    fn div_assign(&mut self, rhs: &'b UnitComplex<T>) {
         *self = &*self / rhs
     }
 }
 
 // UnitComplex ×= Rotation
-impl<N: SimdRealField> MulAssign<Rotation<N, U2>> for UnitComplex<N>
+impl<T: SimdRealField> MulAssign<Rotation<T, 2>> for UnitComplex<T>
 where
-    N::Element: SimdRealField,
-    DefaultAllocator: Allocator<N, U2, U2>,
+    T::Element: SimdRealField,
 {
     #[inline]
-    fn mul_assign(&mut self, rhs: Rotation<N, U2>) {
+    fn mul_assign(&mut self, rhs: Rotation<T, 2>) {
         *self = &*self * rhs
     }
 }
 
-impl<'b, N: SimdRealField> MulAssign<&'b Rotation<N, U2>> for UnitComplex<N>
+impl<'b, T: SimdRealField> MulAssign<&'b Rotation<T, 2>> for UnitComplex<T>
 where
-    N::Element: SimdRealField,
-    DefaultAllocator: Allocator<N, U2, U2>,
+    T::Element: SimdRealField,
 {
     #[inline]
-    fn mul_assign(&mut self, rhs: &'b Rotation<N, U2>) {
+    fn mul_assign(&mut self, rhs: &'b Rotation<T, 2>) {
         *self = &*self * rhs
     }
 }
 
 // UnitComplex ÷= Rotation
-impl<N: SimdRealField> DivAssign<Rotation<N, U2>> for UnitComplex<N>
+impl<T: SimdRealField> DivAssign<Rotation<T, 2>> for UnitComplex<T>
 where
-    N::Element: SimdRealField,
-    DefaultAllocator: Allocator<N, U2, U2>,
+    T::Element: SimdRealField,
 {
     #[inline]
-    fn div_assign(&mut self, rhs: Rotation<N, U2>) {
+    fn div_assign(&mut self, rhs: Rotation<T, 2>) {
         *self = &*self / rhs
     }
 }
 
-impl<'b, N: SimdRealField> DivAssign<&'b Rotation<N, U2>> for UnitComplex<N>
+impl<'b, T: SimdRealField> DivAssign<&'b Rotation<T, 2>> for UnitComplex<T>
 where
-    N::Element: SimdRealField,
-    DefaultAllocator: Allocator<N, U2, U2>,
+    T::Element: SimdRealField,
 {
     #[inline]
-    fn div_assign(&mut self, rhs: &'b Rotation<N, U2>) {
+    fn div_assign(&mut self, rhs: &'b Rotation<T, 2>) {
         *self = &*self / rhs
     }
 }
 
 // Rotation ×= UnitComplex
-impl<N: SimdRealField> MulAssign<UnitComplex<N>> for Rotation<N, U2>
+impl<T: SimdRealField> MulAssign<UnitComplex<T>> for Rotation<T, 2>
 where
-    N::Element: SimdRealField,
-    DefaultAllocator: Allocator<N, U2, U2>,
+    T::Element: SimdRealField,
 {
     #[inline]
-    fn mul_assign(&mut self, rhs: UnitComplex<N>) {
+    fn mul_assign(&mut self, rhs: UnitComplex<T>) {
         self.mul_assign(rhs.to_rotation_matrix())
     }
 }
 
-impl<'b, N: SimdRealField> MulAssign<&'b UnitComplex<N>> for Rotation<N, U2>
+impl<'b, T: SimdRealField> MulAssign<&'b UnitComplex<T>> for Rotation<T, 2>
 where
-    N::Element: SimdRealField,
-    DefaultAllocator: Allocator<N, U2, U2>,
+    T::Element: SimdRealField,
 {
     #[inline]
-    fn mul_assign(&mut self, rhs: &'b UnitComplex<N>) {
+    fn mul_assign(&mut self, rhs: &'b UnitComplex<T>) {
         self.mul_assign(rhs.to_rotation_matrix())
     }
 }
 
 // Rotation ÷= UnitComplex
-impl<N: SimdRealField> DivAssign<UnitComplex<N>> for Rotation<N, U2>
+impl<T: SimdRealField> DivAssign<UnitComplex<T>> for Rotation<T, 2>
 where
-    N::Element: SimdRealField,
-    DefaultAllocator: Allocator<N, U2, U2>,
+    T::Element: SimdRealField,
 {
     #[inline]
-    fn div_assign(&mut self, rhs: UnitComplex<N>) {
+    fn div_assign(&mut self, rhs: UnitComplex<T>) {
         self.div_assign(rhs.to_rotation_matrix())
     }
 }
 
-impl<'b, N: SimdRealField> DivAssign<&'b UnitComplex<N>> for Rotation<N, U2>
+impl<'b, T: SimdRealField> DivAssign<&'b UnitComplex<T>> for Rotation<T, 2>
 where
-    N::Element: SimdRealField,
-    DefaultAllocator: Allocator<N, U2, U2>,
+    T::Element: SimdRealField,
 {
     #[inline]
-    fn div_assign(&mut self, rhs: &'b UnitComplex<N>) {
+    fn div_assign(&mut self, rhs: &'b UnitComplex<T>) {
         self.div_assign(rhs.to_rotation_matrix())
     }
 }
diff --git a/src/geometry/unit_complex_simba.rs b/src/geometry/unit_complex_simba.rs
index 5e8bfa78..156cd63a 100755
--- a/src/geometry/unit_complex_simba.rs
+++ b/src/geometry/unit_complex_simba.rs
@@ -6,16 +6,16 @@ use crate::base::Unit;
 use crate::geometry::UnitComplex;
 use crate::SimdRealField;
 
-impl<N: SimdRealField> SimdValue for UnitComplex<N>
+impl<T: SimdRealField> SimdValue for UnitComplex<T>
 where
-    N::Element: SimdRealField,
+    T::Element: SimdRealField,
 {
-    type Element = UnitComplex<N::Element>;
-    type SimdBool = N::SimdBool;
+    type Element = UnitComplex<T::Element>;
+    type SimdBool = T::SimdBool;
 
     #[inline]
     fn lanes() -> usize {
-        N::lanes()
+        T::lanes()
     }
 
     #[inline]
diff --git a/src/io/matrix_market.rs b/src/io/matrix_market.rs
index 9df66661..2b0a0182 100644
--- a/src/io/matrix_market.rs
+++ b/src/io/matrix_market.rs
@@ -11,21 +11,21 @@ struct MatrixMarketParser;
 
 // TODO: return an Error instead of an Option.
 /// Parses a Matrix Market file at the given path, and returns the corresponding sparse matrix.
-pub fn cs_matrix_from_matrix_market<N: RealField, P: AsRef<Path>>(path: P) -> Option<CsMatrix<N>> {
+pub fn cs_matrix_from_matrix_market<T: RealField, P: AsRef<Path>>(path: P) -> Option<CsMatrix<T>> {
     let file = fs::read_to_string(path).ok()?;
     cs_matrix_from_matrix_market_str(&file)
 }
 
 // TODO: return an Error instead of an Option.
 /// Parses a Matrix Market file described by the given string, and returns the corresponding sparse matrix.
-pub fn cs_matrix_from_matrix_market_str<N: RealField>(data: &str) -> Option<CsMatrix<N>> {
+pub fn cs_matrix_from_matrix_market_str<T: RealField>(data: &str) -> Option<CsMatrix<T>> {
     let file = MatrixMarketParser::parse(Rule::Document, data)
         .unwrap()
         .next()?;
     let mut shape = (0, 0, 0);
     let mut rows: Vec<usize> = Vec::new();
     let mut cols: Vec<usize> = Vec::new();
-    let mut data: Vec<N> = Vec::new();
+    let mut data: Vec<T> = Vec::new();
 
     for line in file.into_inner() {
         match line.as_rule() {
diff --git a/src/lib.rs b/src/lib.rs
index d8f48189..9d711680 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -253,10 +253,10 @@ pub fn abs<T: Signed>(a: &T) -> T {
 /// Returns the infimum of `a` and `b`.
 #[deprecated(note = "use the inherent method `Matrix::inf` instead")]
 #[inline]
-pub fn inf<N, R: Dim, C: Dim>(a: &MatrixMN<N, R, C>, b: &MatrixMN<N, R, C>) -> MatrixMN<N, R, C>
+pub fn inf<T, R: Dim, C: Dim>(a: &OMatrix<T, R, C>, b: &OMatrix<T, R, C>) -> OMatrix<T, R, C>
 where
-    N: Scalar + SimdPartialOrd,
-    DefaultAllocator: Allocator<N, R, C>,
+    T: Scalar + SimdPartialOrd,
+    DefaultAllocator: Allocator<T, R, C>,
 {
     a.inf(b)
 }
@@ -264,10 +264,10 @@ where
 /// Returns the supremum of `a` and `b`.
 #[deprecated(note = "use the inherent method `Matrix::sup` instead")]
 #[inline]
-pub fn sup<N, R: Dim, C: Dim>(a: &MatrixMN<N, R, C>, b: &MatrixMN<N, R, C>) -> MatrixMN<N, R, C>
+pub fn sup<T, R: Dim, C: Dim>(a: &OMatrix<T, R, C>, b: &OMatrix<T, R, C>) -> OMatrix<T, R, C>
 where
-    N: Scalar + SimdPartialOrd,
-    DefaultAllocator: Allocator<N, R, C>,
+    T: Scalar + SimdPartialOrd,
+    DefaultAllocator: Allocator<T, R, C>,
 {
     a.sup(b)
 }
@@ -275,13 +275,13 @@ where
 /// Returns simultaneously the infimum and supremum of `a` and `b`.
 #[deprecated(note = "use the inherent method `Matrix::inf_sup` instead")]
 #[inline]
-pub fn inf_sup<N, R: Dim, C: Dim>(
-    a: &MatrixMN<N, R, C>,
-    b: &MatrixMN<N, R, C>,
-) -> (MatrixMN<N, R, C>, MatrixMN<N, R, C>)
+pub fn inf_sup<T, R: Dim, C: Dim>(
+    a: &OMatrix<T, R, C>,
+    b: &OMatrix<T, R, C>,
+) -> (OMatrix<T, R, C>, OMatrix<T, R, C>)
 where
-    N: Scalar + SimdPartialOrd,
-    DefaultAllocator: Allocator<N, R, C>,
+    T: Scalar + SimdPartialOrd,
+    DefaultAllocator: Allocator<T, R, C>,
 {
     a.inf_sup(b)
 }
@@ -384,11 +384,11 @@ pub fn partial_sort2<'a, T: PartialOrd>(a: &'a T, b: &'a T) -> Option<(&'a T, &'
 /// * [distance](fn.distance.html)
 /// * [distance_squared](fn.distance_squared.html)
 #[inline]
-pub fn center<N: SimdComplexField, D: DimName>(p1: &Point<N, D>, p2: &Point<N, D>) -> Point<N, D>
-where
-    DefaultAllocator: Allocator<N, D>,
-{
-    ((&p1.coords + &p2.coords) * convert::<_, N>(0.5)).into()
+pub fn center<T: SimdComplexField, const D: usize>(
+    p1: &Point<T, D>,
+    p2: &Point<T, D>,
+) -> Point<T, D> {
+    ((&p1.coords + &p2.coords) * convert::<_, T>(0.5)).into()
 }
 
 /// The distance between two points.
@@ -398,13 +398,10 @@ where
 /// * [center](fn.center.html)
 /// * [distance_squared](fn.distance_squared.html)
 #[inline]
-pub fn distance<N: SimdComplexField, D: DimName>(
-    p1: &Point<N, D>,
-    p2: &Point<N, D>,
-) -> N::SimdRealField
-where
-    DefaultAllocator: Allocator<N, D>,
-{
+pub fn distance<T: SimdComplexField, const D: usize>(
+    p1: &Point<T, D>,
+    p2: &Point<T, D>,
+) -> T::SimdRealField {
     (&p2.coords - &p1.coords).norm()
 }
 
@@ -415,13 +412,10 @@ where
 /// * [center](fn.center.html)
 /// * [distance](fn.distance.html)
 #[inline]
-pub fn distance_squared<N: SimdComplexField, D: DimName>(
-    p1: &Point<N, D>,
-    p2: &Point<N, D>,
-) -> N::SimdRealField
-where
-    DefaultAllocator: Allocator<N, D>,
-{
+pub fn distance_squared<T: SimdComplexField, const D: usize>(
+    p1: &Point<T, D>,
+    p2: &Point<T, D>,
+) -> T::SimdRealField {
     (&p2.coords - &p1.coords).norm_squared()
 }
 
diff --git a/src/linalg/balancing.rs b/src/linalg/balancing.rs
index e7dbc6fb..3b834563 100644
--- a/src/linalg/balancing.rs
+++ b/src/linalg/balancing.rs
@@ -4,23 +4,23 @@ use simba::scalar::RealField;
 use std::ops::{DivAssign, MulAssign};
 
 use crate::allocator::Allocator;
-use crate::base::dimension::{Dim, U1};
+use crate::base::dimension::Dim;
 use crate::base::storage::Storage;
-use crate::base::{DefaultAllocator, MatrixN, VectorN};
+use crate::base::{Const, DefaultAllocator, OMatrix, OVector};
 
 /// Applies in-place a modified Parlett and Reinsch matrix balancing with 2-norm to the matrix `m` and returns
 /// the corresponding diagonal transformation.
 ///
 /// See https://arxiv.org/pdf/1401.5766.pdf
-pub fn balance_parlett_reinsch<N: RealField, D: Dim>(m: &mut MatrixN<N, D>) -> VectorN<N, D>
+pub fn balance_parlett_reinsch<T: RealField, D: Dim>(m: &mut OMatrix<T, D, D>) -> OVector<T, D>
 where
-    DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>,
+    DefaultAllocator: Allocator<T, D, D> + Allocator<T, D>,
 {
     assert!(m.is_square(), "Unable to balance a non-square matrix.");
 
     let dim = m.data.shape().0;
-    let radix: N = crate::convert(2.0f64);
-    let mut d = VectorN::from_element_generic(dim, U1, N::one());
+    let radix: T = crate::convert(2.0f64);
+    let mut d = OVector::from_element_generic(dim, Const::<1>, T::one());
 
     let mut converged = false;
 
@@ -30,7 +30,7 @@ where
         for i in 0..dim.value() {
             let mut c = m.column(i).norm_squared();
             let mut r = m.row(i).norm_squared();
-            let mut f = N::one();
+            let mut f = T::one();
 
             let s = c + r;
             c = c.sqrt();
@@ -52,7 +52,7 @@ where
                 f /= radix;
             }
 
-            let eps: N = crate::convert(0.95);
+            let eps: T = crate::convert(0.95);
             if c * c + r * r < eps * s {
                 converged = false;
                 d[i] *= f;
@@ -66,16 +66,16 @@ where
 }
 
 /// Computes in-place `D * m * D.inverse()`, where `D` is the matrix with diagonal `d`.
-pub fn unbalance<N: RealField, D: Dim>(m: &mut MatrixN<N, D>, d: &VectorN<N, D>)
+pub fn unbalance<T: RealField, D: Dim>(m: &mut OMatrix<T, D, D>, d: &OVector<T, D>)
 where
-    DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>,
+    DefaultAllocator: Allocator<T, D, D> + Allocator<T, D>,
 {
     assert!(m.is_square(), "Unable to unbalance a non-square matrix.");
     assert_eq!(m.nrows(), d.len(), "Unbalancing: mismatched dimensions.");
 
     for j in 0..d.len() {
         let mut col = m.column_mut(j);
-        let denom = N::one() / d[j];
+        let denom = T::one() / d[j];
 
         for i in 0..d.len() {
             col[i] *= d[i] * denom;
diff --git a/src/linalg/bidiagonal.rs b/src/linalg/bidiagonal.rs
index 33fc81e6..c7c36702 100644
--- a/src/linalg/bidiagonal.rs
+++ b/src/linalg/bidiagonal.rs
@@ -2,8 +2,8 @@
 use serde::{Deserialize, Serialize};
 
 use crate::allocator::Allocator;
-use crate::base::{DefaultAllocator, Matrix, MatrixMN, MatrixN, Unit, VectorN};
-use crate::dimension::{Dim, DimDiff, DimMin, DimMinimum, DimSub, U1};
+use crate::base::{DefaultAllocator, Matrix, OMatrix, OVector, Unit};
+use crate::dimension::{Const, Dim, DimDiff, DimMin, DimMinimum, DimSub, U1};
 use crate::storage::Storage;
 use simba::scalar::ComplexField;
 
@@ -15,64 +15,64 @@ use crate::linalg::householder;
 #[cfg_attr(
     feature = "serde-serialize",
     serde(bound(serialize = "DimMinimum<R, C>: DimSub<U1>,
-         DefaultAllocator: Allocator<N, R, C>             +
-                           Allocator<N, DimMinimum<R, C>> +
-                           Allocator<N, DimDiff<DimMinimum<R, C>, U1>>,
-         MatrixMN<N, R, C>: Serialize,
-         VectorN<N, DimMinimum<R, C>>: Serialize,
-         VectorN<N, DimDiff<DimMinimum<R, C>, U1>>: Serialize"))
+         DefaultAllocator: Allocator<T, R, C>             +
+                           Allocator<T, DimMinimum<R, C>> +
+                           Allocator<T, DimDiff<DimMinimum<R, C>, U1>>,
+         OMatrix<T, R, C>: Serialize,
+         OVector<T, DimMinimum<R, C>>: Serialize,
+         OVector<T, DimDiff<DimMinimum<R, C>, U1>>: Serialize"))
 )]
 #[cfg_attr(
     feature = "serde-serialize",
     serde(bound(deserialize = "DimMinimum<R, C>: DimSub<U1>,
-         DefaultAllocator: Allocator<N, R, C>             +
-                           Allocator<N, DimMinimum<R, C>> +
-                           Allocator<N, DimDiff<DimMinimum<R, C>, U1>>,
-         MatrixMN<N, R, C>: Deserialize<'de>,
-         VectorN<N, DimMinimum<R, C>>: Deserialize<'de>,
-         VectorN<N, DimDiff<DimMinimum<R, C>, U1>>: Deserialize<'de>"))
+         DefaultAllocator: Allocator<T, R, C>             +
+                           Allocator<T, DimMinimum<R, C>> +
+                           Allocator<T, DimDiff<DimMinimum<R, C>, U1>>,
+         OMatrix<T, R, C>: Deserialize<'de>,
+         OVector<T, DimMinimum<R, C>>: Deserialize<'de>,
+         OVector<T, DimDiff<DimMinimum<R, C>, U1>>: Deserialize<'de>"))
 )]
 #[derive(Clone, Debug)]
-pub struct Bidiagonal<N: ComplexField, R: DimMin<C>, C: Dim>
+pub struct Bidiagonal<T: ComplexField, R: DimMin<C>, C: Dim>
 where
     DimMinimum<R, C>: DimSub<U1>,
-    DefaultAllocator: Allocator<N, R, C>
-        + Allocator<N, DimMinimum<R, C>>
-        + Allocator<N, DimDiff<DimMinimum<R, C>, U1>>,
+    DefaultAllocator: Allocator<T, R, C>
+        + Allocator<T, DimMinimum<R, C>>
+        + Allocator<T, DimDiff<DimMinimum<R, C>, U1>>,
 {
     // TODO: perhaps we should pack the axes into different vectors so that axes for `v_t` are
     // contiguous. This prevents some useless copies.
-    uv: MatrixMN<N, R, C>,
+    uv: OMatrix<T, R, C>,
     /// The diagonal elements of the decomposed matrix.
-    diagonal: VectorN<N, DimMinimum<R, C>>,
+    diagonal: OVector<T, DimMinimum<R, C>>,
     /// The off-diagonal elements of the decomposed matrix.
-    off_diagonal: VectorN<N, DimDiff<DimMinimum<R, C>, U1>>,
+    off_diagonal: OVector<T, DimDiff<DimMinimum<R, C>, U1>>,
     upper_diagonal: bool,
 }
 
-impl<N: ComplexField, R: DimMin<C>, C: Dim> Copy for Bidiagonal<N, R, C>
+impl<T: ComplexField, R: DimMin<C>, C: Dim> Copy for Bidiagonal<T, R, C>
 where
     DimMinimum<R, C>: DimSub<U1>,
-    DefaultAllocator: Allocator<N, R, C>
-        + Allocator<N, DimMinimum<R, C>>
-        + Allocator<N, DimDiff<DimMinimum<R, C>, U1>>,
-    MatrixMN<N, R, C>: Copy,
-    VectorN<N, DimMinimum<R, C>>: Copy,
-    VectorN<N, DimDiff<DimMinimum<R, C>, U1>>: Copy,
+    DefaultAllocator: Allocator<T, R, C>
+        + Allocator<T, DimMinimum<R, C>>
+        + Allocator<T, DimDiff<DimMinimum<R, C>, U1>>,
+    OMatrix<T, R, C>: Copy,
+    OVector<T, DimMinimum<R, C>>: Copy,
+    OVector<T, DimDiff<DimMinimum<R, C>, U1>>: Copy,
 {
 }
 
-impl<N: ComplexField, R: DimMin<C>, C: Dim> Bidiagonal<N, R, C>
+impl<T: ComplexField, R: DimMin<C>, C: Dim> Bidiagonal<T, R, C>
 where
     DimMinimum<R, C>: DimSub<U1>,
-    DefaultAllocator: Allocator<N, R, C>
-        + Allocator<N, C>
-        + Allocator<N, R>
-        + Allocator<N, DimMinimum<R, C>>
-        + Allocator<N, DimDiff<DimMinimum<R, C>, U1>>,
+    DefaultAllocator: Allocator<T, R, C>
+        + Allocator<T, C>
+        + Allocator<T, R>
+        + Allocator<T, DimMinimum<R, C>>
+        + Allocator<T, DimDiff<DimMinimum<R, C>, U1>>,
 {
     /// Computes the Bidiagonal decomposition using householder reflections.
-    pub fn new(mut matrix: MatrixMN<N, R, C>) -> Self {
+    pub fn new(mut matrix: OMatrix<T, R, C>) -> Self {
         let (nrows, ncols) = matrix.data.shape();
         let min_nrows_ncols = nrows.min(ncols);
         let dim = min_nrows_ncols.value();
@@ -82,11 +82,16 @@ where
         );
 
         let mut diagonal =
-            unsafe { crate::unimplemented_or_uninitialized_generic!(min_nrows_ncols, U1) };
-        let mut off_diagonal =
-            unsafe { crate::unimplemented_or_uninitialized_generic!(min_nrows_ncols.sub(U1), U1) };
-        let mut axis_packed = unsafe { crate::unimplemented_or_uninitialized_generic!(ncols, U1) };
-        let mut work = unsafe { crate::unimplemented_or_uninitialized_generic!(nrows, U1) };
+            unsafe { crate::unimplemented_or_uninitialized_generic!(min_nrows_ncols, Const::<1>) };
+        let mut off_diagonal = unsafe {
+            crate::unimplemented_or_uninitialized_generic!(
+                min_nrows_ncols.sub(Const::<1>),
+                Const::<1>
+            )
+        };
+        let mut axis_packed =
+            unsafe { crate::unimplemented_or_uninitialized_generic!(ncols, Const::<1>) };
+        let mut work = unsafe { crate::unimplemented_or_uninitialized_generic!(nrows, Const::<1>) };
 
         let upper_diagonal = nrows.value() >= ncols.value();
         if upper_diagonal {
@@ -168,14 +173,14 @@ where
     pub fn unpack(
         self,
     ) -> (
-        MatrixMN<N, R, DimMinimum<R, C>>,
-        MatrixN<N, DimMinimum<R, C>>,
-        MatrixMN<N, DimMinimum<R, C>, C>,
+        OMatrix<T, R, DimMinimum<R, C>>,
+        OMatrix<T, DimMinimum<R, C>, DimMinimum<R, C>>,
+        OMatrix<T, DimMinimum<R, C>, C>,
     )
     where
-        DefaultAllocator: Allocator<N, DimMinimum<R, C>, DimMinimum<R, C>>
-            + Allocator<N, R, DimMinimum<R, C>>
-            + Allocator<N, DimMinimum<R, C>, C>,
+        DefaultAllocator: Allocator<T, DimMinimum<R, C>, DimMinimum<R, C>>
+            + Allocator<T, R, DimMinimum<R, C>>
+            + Allocator<T, DimMinimum<R, C>, C>,
     {
         // TODO: optimize by calling a reallocator.
         (self.u(), self.d(), self.v_t())
@@ -183,28 +188,28 @@ where
 
     /// Retrieves the upper trapezoidal submatrix `R` of this decomposition.
     #[inline]
-    pub fn d(&self) -> MatrixN<N, DimMinimum<R, C>>
+    pub fn d(&self) -> OMatrix<T, DimMinimum<R, C>, DimMinimum<R, C>>
     where
-        DefaultAllocator: Allocator<N, DimMinimum<R, C>, DimMinimum<R, C>>,
+        DefaultAllocator: Allocator<T, DimMinimum<R, C>, DimMinimum<R, C>>,
     {
         let (nrows, ncols) = self.uv.data.shape();
 
         let d = nrows.min(ncols);
-        let mut res = MatrixN::identity_generic(d, d);
-        res.set_partial_diagonal(self.diagonal.iter().map(|e| N::from_real(e.modulus())));
+        let mut res = OMatrix::identity_generic(d, d);
+        res.set_partial_diagonal(self.diagonal.iter().map(|e| T::from_real(e.modulus())));
 
         let start = self.axis_shift();
         res.slice_mut(start, (d.value() - 1, d.value() - 1))
-            .set_partial_diagonal(self.off_diagonal.iter().map(|e| N::from_real(e.modulus())));
+            .set_partial_diagonal(self.off_diagonal.iter().map(|e| T::from_real(e.modulus())));
         res
     }
 
     /// Computes the orthogonal matrix `U` of this `U * D * V` decomposition.
     // TODO: code duplication with householder::assemble_q.
     // Except that we are returning a rectangular matrix here.
-    pub fn u(&self) -> MatrixMN<N, R, DimMinimum<R, C>>
+    pub fn u(&self) -> OMatrix<T, R, DimMinimum<R, C>>
     where
-        DefaultAllocator: Allocator<N, R, DimMinimum<R, C>>,
+        DefaultAllocator: Allocator<T, R, DimMinimum<R, C>>,
     {
         let (nrows, ncols) = self.uv.data.shape();
 
@@ -215,7 +220,7 @@ where
         for i in (0..dim - shift).rev() {
             let axis = self.uv.slice_range(i + shift.., i);
             // TODO: sometimes, the axis might have a zero magnitude.
-            let refl = Reflection::new(Unit::new_unchecked(axis), N::zero());
+            let refl = Reflection::new(Unit::new_unchecked(axis), T::zero());
 
             let mut res_rows = res.slice_range_mut(i + shift.., i..);
 
@@ -232,17 +237,18 @@ where
     }
 
     /// Computes the orthogonal matrix `V_t` of this `U * D * V_t` decomposition.
-    pub fn v_t(&self) -> MatrixMN<N, DimMinimum<R, C>, C>
+    pub fn v_t(&self) -> OMatrix<T, DimMinimum<R, C>, C>
     where
-        DefaultAllocator: Allocator<N, DimMinimum<R, C>, C>,
+        DefaultAllocator: Allocator<T, DimMinimum<R, C>, C>,
     {
         let (nrows, ncols) = self.uv.data.shape();
         let min_nrows_ncols = nrows.min(ncols);
 
         let mut res = Matrix::identity_generic(min_nrows_ncols, ncols);
         let mut work =
-            unsafe { crate::unimplemented_or_uninitialized_generic!(min_nrows_ncols, U1) };
-        let mut axis_packed = unsafe { crate::unimplemented_or_uninitialized_generic!(ncols, U1) };
+            unsafe { crate::unimplemented_or_uninitialized_generic!(min_nrows_ncols, Const::<1>) };
+        let mut axis_packed =
+            unsafe { crate::unimplemented_or_uninitialized_generic!(ncols, Const::<1>) };
 
         let shift = self.axis_shift().1;
 
@@ -251,7 +257,7 @@ where
             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), N::zero());
+            let refl = Reflection::new(Unit::new_unchecked(axis_packed), T::zero());
 
             let mut res_rows = res.slice_range_mut(i.., i + shift..);
 
@@ -268,43 +274,42 @@ where
     }
 
     /// The diagonal part of this decomposed matrix.
-    pub fn diagonal(&self) -> VectorN<N::RealField, DimMinimum<R, C>>
+    pub fn diagonal(&self) -> OVector<T::RealField, DimMinimum<R, C>>
     where
-        DefaultAllocator: Allocator<N::RealField, DimMinimum<R, C>>,
+        DefaultAllocator: Allocator<T::RealField, DimMinimum<R, C>>,
     {
         self.diagonal.map(|e| e.modulus())
     }
 
     /// The off-diagonal part of this decomposed matrix.
-    pub fn off_diagonal(&self) -> VectorN<N::RealField, DimDiff<DimMinimum<R, C>, U1>>
+    pub fn off_diagonal(&self) -> OVector<T::RealField, DimDiff<DimMinimum<R, C>, U1>>
     where
-        DefaultAllocator: Allocator<N::RealField, DimDiff<DimMinimum<R, C>, U1>>,
+        DefaultAllocator: Allocator<T::RealField, DimDiff<DimMinimum<R, C>, U1>>,
     {
         self.off_diagonal.map(|e| e.modulus())
     }
 
     #[doc(hidden)]
-    pub fn uv_internal(&self) -> &MatrixMN<N, R, C> {
+    pub fn uv_internal(&self) -> &OMatrix<T, R, C> {
         &self.uv
     }
 }
 
-// impl<N: ComplexField, D: DimMin<D, Output = D> + DimSub<Dynamic>> Bidiagonal<N, D, D>
-//     where DefaultAllocator: Allocator<N, D, D> +
-//                             Allocator<N, D> {
+// impl<T: ComplexField, D: DimMin<D, Output = D> + DimSub<Dynamic>> 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.
-//     pub fn solve<R2: Dim, C2: Dim, S2>(&self, b: &Matrix<N, R2, C2, S2>) -> MatrixMN<N, R2, C2>
-//         where S2: StorageMut<N, R2, C2>,
-//               ShapeConstraint: SameNumberOfRows<R2, D>,
-//               DefaultAllocator: Allocator<N, R2, C2> {
+//     pub fn solve<R2: Dim, C2: Dim, S2>(&self, b: &Matrix<T, R2, C2, S2>) -> OMatrix<T, R2, C2>
+//         where S2: StorageMut<T, R2, C2>,
+//               ShapeConstraint: SameNumberOfRows<R2, D> {
 //         let mut res = b.clone_owned();
 //         self.solve_mut(&mut res);
 //         res
 //     }
 //
 //     /// Solves the linear system `self * x = b`, where `x` is the unknown to be determined.
-//     pub fn solve_mut<R2: Dim, C2: Dim, S2>(&self, b: &mut Matrix<N, R2, C2, S2>)
-//         where S2: StorageMut<N, R2, C2>,
+//     pub fn solve_mut<R2: Dim, C2: Dim, S2>(&self, b: &mut Matrix<T, R2, C2, S2>)
+//         where S2: StorageMut<T, R2, C2>,
 //               ShapeConstraint: SameNumberOfRows<R2, D> {
 //
 //         assert_eq!(self.uv.nrows(), b.nrows(), "Bidiagonal solve matrix dimension mismatch.");
@@ -315,8 +320,8 @@ where
 //     }
 //
 //     // TODO: duplicate code from the `solve` module.
-//     fn solve_upper_triangular_mut<R2: Dim, C2: Dim, S2>(&self, b: &mut Matrix<N, R2, C2, S2>)
-//         where S2: StorageMut<N, R2, C2>,
+//     fn solve_upper_triangular_mut<R2: Dim, C2: Dim, S2>(&self, b: &mut Matrix<T, R2, C2, S2>)
+//         where S2: StorageMut<T, R2, C2>,
 //               ShapeConstraint: SameNumberOfRows<R2, D> {
 //
 //         let dim  = self.uv.nrows();
@@ -332,28 +337,28 @@ where
 //                     *b.vget_unchecked_mut(i) = coeff;
 //                 }
 //
-//                 b.rows_range_mut(.. i).axpy(-coeff, &self.uv.slice_range(.. i, i), N::one());
+//                 b.rows_range_mut(.. i).axpy(-coeff, &self.uv.slice_range(.. i, i), T::one());
 //             }
 //         }
 //     }
 //
 //     /// Computes the inverse of the decomposed matrix.
-//     pub fn inverse(&self) -> MatrixN<N, D> {
+//     pub fn inverse(&self) -> OMatrix<T, D, D> {
 //         assert!(self.uv.is_square(), "Bidiagonal inverse: unable to compute the inverse of a non-square matrix.");
 //
 //         // TODO: is there a less naive method ?
 //         let (nrows, ncols) = self.uv.data.shape();
-//         let mut res = MatrixN::identity_generic(nrows, ncols);
+//         let mut res = OMatrix::identity_generic(nrows, ncols);
 //         self.solve_mut(&mut res);
 //         res
 //     }
 //
 //     // /// Computes the determinant of the decomposed matrix.
-//     // pub fn determinant(&self) -> N {
+//     // pub fn determinant(&self) -> T {
 //     //     let dim = self.uv.nrows();
 //     //     assert!(self.uv.is_square(), "Bidiagonal determinant: unable to compute the determinant of a non-square matrix.");
 //
-//     //     let mut res = N::one();
+//     //     let mut res = T::one();
 //     //     for i in 0 .. dim {
 //     //         res *= unsafe { *self.diag.vget_unchecked(i) };
 //     //     }
diff --git a/src/linalg/cholesky.rs b/src/linalg/cholesky.rs
index 82f3ad86..36e164ea 100644
--- a/src/linalg/cholesky.rs
+++ b/src/linalg/cholesky.rs
@@ -6,7 +6,7 @@ use simba::scalar::ComplexField;
 use simba::simd::SimdComplexField;
 
 use crate::allocator::Allocator;
-use crate::base::{DefaultAllocator, Matrix, MatrixMN, MatrixN, Vector};
+use crate::base::{Const, DefaultAllocator, Matrix, OMatrix, Vector};
 use crate::constraint::{SameNumberOfRows, ShapeConstraint};
 use crate::dimension::{Dim, DimAdd, DimDiff, DimSub, DimSum, U1};
 use crate::storage::{Storage, StorageMut};
@@ -15,37 +15,37 @@ use crate::storage::{Storage, StorageMut};
 #[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
 #[cfg_attr(
     feature = "serde-serialize",
-    serde(bound(serialize = "DefaultAllocator: Allocator<N, D>,
-         MatrixN<N, D>: Serialize"))
+    serde(bound(serialize = "DefaultAllocator: Allocator<T, D>,
+         OMatrix<T, D, D>: Serialize"))
 )]
 #[cfg_attr(
     feature = "serde-serialize",
-    serde(bound(deserialize = "DefaultAllocator: Allocator<N, D>,
-         MatrixN<N, D>: Deserialize<'de>"))
+    serde(bound(deserialize = "DefaultAllocator: Allocator<T, D>,
+         OMatrix<T, D, D>: Deserialize<'de>"))
 )]
 #[derive(Clone, Debug)]
-pub struct Cholesky<N: SimdComplexField, D: Dim>
+pub struct Cholesky<T: SimdComplexField, D: Dim>
 where
-    DefaultAllocator: Allocator<N, D, D>,
+    DefaultAllocator: Allocator<T, D, D>,
 {
-    chol: MatrixN<N, D>,
+    chol: OMatrix<T, D, D>,
 }
 
-impl<N: SimdComplexField, D: Dim> Copy for Cholesky<N, D>
+impl<T: SimdComplexField, D: Dim> Copy for Cholesky<T, D>
 where
-    DefaultAllocator: Allocator<N, D, D>,
-    MatrixN<N, D>: Copy,
+    DefaultAllocator: Allocator<T, D, D>,
+    OMatrix<T, D, D>: Copy,
 {
 }
 
-impl<N: SimdComplexField, D: Dim> Cholesky<N, D>
+impl<T: SimdComplexField, D: Dim> Cholesky<T, D>
 where
-    DefaultAllocator: Allocator<N, D, D>,
+    DefaultAllocator: Allocator<T, D, D>,
 {
     /// Computes the Cholesky decomposition of `matrix` without checking that the matrix is definite-positive.
     ///
     /// If the input matrix is not definite-positive, the decomposition may contain trash values (Inf, NaN, etc.)
-    pub fn new_unchecked(mut matrix: MatrixN<N, D>) -> Self {
+    pub fn new_unchecked(mut matrix: OMatrix<T, D, D>) -> Self {
         assert!(matrix.is_square(), "The input matrix must be square.");
 
         let n = matrix.nrows();
@@ -57,7 +57,7 @@ where
                 let (mut col_j, col_k) = matrix.columns_range_pair_mut(j, k);
                 let mut col_j = col_j.rows_range_mut(j..);
                 let col_k = col_k.rows_range(j..);
-                col_j.axpy(factor.simd_conjugate(), &col_k, N::one());
+                col_j.axpy(factor.simd_conjugate(), &col_k, T::one());
             }
 
             let diag = unsafe { *matrix.get_unchecked((j, j)) };
@@ -76,8 +76,8 @@ where
 
     /// Retrieves the lower-triangular factor of the Cholesky decomposition with its strictly
     /// upper-triangular part filled with zeros.
-    pub fn unpack(mut self) -> MatrixN<N, D> {
-        self.chol.fill_upper_triangle(N::zero(), 1);
+    pub fn unpack(mut self) -> OMatrix<T, D, D> {
+        self.chol.fill_upper_triangle(T::zero(), 1);
         self.chol
     }
 
@@ -86,13 +86,13 @@ where
     ///
     /// The values of the strict upper-triangular part are garbage and should be ignored by further
     /// computations.
-    pub fn unpack_dirty(self) -> MatrixN<N, D> {
+    pub fn unpack_dirty(self) -> OMatrix<T, D, D> {
         self.chol
     }
 
     /// Retrieves the lower-triangular factor of the Cholesky decomposition with its strictly
     /// uppen-triangular part filled with zeros.
-    pub fn l(&self) -> MatrixN<N, D> {
+    pub fn l(&self) -> OMatrix<T, D, D> {
         self.chol.lower_triangle()
     }
 
@@ -101,16 +101,16 @@ where
     ///
     /// This is an allocation-less version of `self.l()`. The values of the strict upper-triangular
     /// part are garbage and should be ignored by further computations.
-    pub fn l_dirty(&self) -> &MatrixN<N, D> {
+    pub fn l_dirty(&self) -> &OMatrix<T, D, D> {
         &self.chol
     }
 
     /// Solves the system `self * x = b` where `self` is the decomposed matrix and `x` the unknown.
     ///
     /// The result is stored on `b`.
-    pub fn solve_mut<R2: Dim, C2: Dim, S2>(&self, b: &mut Matrix<N, R2, C2, S2>)
+    pub fn solve_mut<R2: Dim, C2: Dim, S2>(&self, b: &mut Matrix<T, R2, C2, S2>)
     where
-        S2: StorageMut<N, R2, C2>,
+        S2: StorageMut<T, R2, C2>,
         ShapeConstraint: SameNumberOfRows<R2, D>,
     {
         self.chol.solve_lower_triangular_unchecked_mut(b);
@@ -119,10 +119,10 @@ where
 
     /// Returns the solution of the system `self * x = b` where `self` is the decomposed matrix and
     /// `x` the unknown.
-    pub fn solve<R2: Dim, C2: Dim, S2>(&self, b: &Matrix<N, R2, C2, S2>) -> MatrixMN<N, R2, C2>
+    pub fn solve<R2: Dim, C2: Dim, S2>(&self, b: &Matrix<T, R2, C2, S2>) -> OMatrix<T, R2, C2>
     where
-        S2: Storage<N, R2, C2>,
-        DefaultAllocator: Allocator<N, R2, C2>,
+        S2: Storage<T, R2, C2>,
+        DefaultAllocator: Allocator<T, R2, C2>,
         ShapeConstraint: SameNumberOfRows<R2, D>,
     {
         let mut res = b.clone_owned();
@@ -131,18 +131,18 @@ where
     }
 
     /// Computes the inverse of the decomposed matrix.
-    pub fn inverse(&self) -> MatrixN<N, D> {
+    pub fn inverse(&self) -> OMatrix<T, D, D> {
         let shape = self.chol.data.shape();
-        let mut res = MatrixN::identity_generic(shape.0, shape.1);
+        let mut res = OMatrix::identity_generic(shape.0, shape.1);
 
         self.solve_mut(&mut res);
         res
     }
 
     /// Computes the determinant of the decomposed matrix.
-    pub fn determinant(&self) -> N::SimdRealField {
+    pub fn determinant(&self) -> T::SimdRealField {
         let dim = self.chol.nrows();
-        let mut prod_diag = N::one();
+        let mut prod_diag = T::one();
         for i in 0..dim {
             prod_diag *= unsafe { *self.chol.get_unchecked((i, i)) };
         }
@@ -150,15 +150,15 @@ where
     }
 }
 
-impl<N: ComplexField, D: Dim> Cholesky<N, D>
+impl<T: ComplexField, D: Dim> Cholesky<T, D>
 where
-    DefaultAllocator: Allocator<N, D, D>,
+    DefaultAllocator: Allocator<T, D, D>,
 {
     /// Attempts to compute the Cholesky decomposition of `matrix`.
     ///
     /// Returns `None` if the input matrix is not definite-positive. The input matrix is assumed
     /// to be symmetric and only the lower-triangular part is read.
-    pub fn new(mut matrix: MatrixN<N, D>) -> Option<Self> {
+    pub fn new(mut matrix: OMatrix<T, D, D>) -> Option<Self> {
         assert!(matrix.is_square(), "The input matrix must be square.");
 
         let n = matrix.nrows();
@@ -171,7 +171,7 @@ where
                 let mut col_j = col_j.rows_range_mut(j..);
                 let col_k = col_k.rows_range(j..);
 
-                col_j.axpy(factor.conjugate(), &col_k, N::one());
+                col_j.axpy(factor.conjugate(), &col_k, T::one());
             }
 
             let diag = unsafe { *matrix.get_unchecked((j, j)) };
@@ -198,10 +198,10 @@ where
     /// Given the Cholesky decomposition of a matrix `M`, a scalar `sigma` and a vector `v`,
     /// performs a rank one update such that we end up with the decomposition of `M + sigma * (v * v.adjoint())`.
     #[inline]
-    pub fn rank_one_update<R2: Dim, S2>(&mut self, x: &Vector<N, R2, S2>, sigma: N::RealField)
+    pub fn rank_one_update<R2: Dim, S2>(&mut self, x: &Vector<T, R2, S2>, sigma: T::RealField)
     where
-        S2: Storage<N, R2, U1>,
-        DefaultAllocator: Allocator<N, R2, U1>,
+        S2: Storage<T, R2, U1>,
+        DefaultAllocator: Allocator<T, R2, U1>,
         ShapeConstraint: SameNumberOfRows<R2, D>,
     {
         Self::xx_rank_one_update(&mut self.chol, &mut x.clone_owned(), sigma)
@@ -212,13 +212,13 @@ where
     pub fn insert_column<R2, S2>(
         &self,
         j: usize,
-        col: Vector<N, R2, S2>,
-    ) -> Cholesky<N, DimSum<D, U1>>
+        col: Vector<T, R2, S2>,
+    ) -> Cholesky<T, DimSum<D, U1>>
     where
         D: DimAdd<U1>,
         R2: Dim,
-        S2: Storage<N, R2, U1>,
-        DefaultAllocator: Allocator<N, DimSum<D, U1>, DimSum<D, U1>> + Allocator<N, R2>,
+        S2: Storage<T, R2, U1>,
+        DefaultAllocator: Allocator<T, DimSum<D, U1>, DimSum<D, U1>> + Allocator<T, R2>,
         ShapeConstraint: SameNumberOfRows<R2, DimSum<D, U1>>,
     {
         let mut col = col.into_owned();
@@ -234,8 +234,8 @@ where
         // loads the data into a new matrix with an additional jth row/column
         let mut chol = unsafe {
             crate::unimplemented_or_uninitialized_generic!(
-                self.chol.data.shape().0.add(U1),
-                self.chol.data.shape().1.add(U1)
+                self.chol.data.shape().0.add(Const::<1>),
+                self.chol.data.shape().1.add(Const::<1>)
             )
         };
         chol.slice_range_mut(..j, ..j)
@@ -260,17 +260,17 @@ where
         new_rowj_adjoint.adjoint_to(&mut chol.slice_range_mut(j, ..j));
 
         // update the center element
-        let center_element = N::sqrt(col_j - N::from_real(new_rowj_adjoint.norm_squared()));
+        let center_element = T::sqrt(col_j - T::from_real(new_rowj_adjoint.norm_squared()));
         chol[(j, j)] = center_element;
 
         // update the jth column
         let bottom_left_corner = self.chol.slice_range(j.., ..j);
         // new_colj = (col_jplus - bottom_left_corner * new_rowj.adjoint()) / center_element;
         new_colj.gemm(
-            -N::one() / center_element,
+            -T::one() / center_element,
             &bottom_left_corner,
             &new_rowj_adjoint,
-            N::one() / center_element,
+            T::one() / center_element,
         );
         chol.slice_range_mut(j + 1.., j).copy_from(&new_colj);
 
@@ -279,7 +279,7 @@ where
         Self::xx_rank_one_update(
             &mut bottom_right_corner,
             &mut new_colj,
-            -N::RealField::one(),
+            -T::RealField::one(),
         );
 
         Cholesky { chol }
@@ -287,10 +287,10 @@ where
 
     /// Updates the decomposition such that we get the decomposition of the factored matrix with its `j`th column removed.
     /// Since the matrix is square, the `j`th row will also be removed.
-    pub fn remove_column(&self, j: usize) -> Cholesky<N, DimDiff<D, U1>>
+    pub fn remove_column(&self, j: usize) -> Cholesky<T, DimDiff<D, U1>>
     where
         D: DimSub<U1>,
-        DefaultAllocator: Allocator<N, DimDiff<D, U1>, DimDiff<D, U1>> + Allocator<N, D>,
+        DefaultAllocator: Allocator<T, DimDiff<D, U1>, DimDiff<D, U1>> + Allocator<T, D>,
     {
         let n = self.chol.nrows();
         assert!(n > 0, "The matrix needs at least one column.");
@@ -299,8 +299,8 @@ where
         // loads the data into a new matrix except for the jth row/column
         let mut chol = unsafe {
             crate::unimplemented_or_uninitialized_generic!(
-                self.chol.data.shape().0.sub(U1),
-                self.chol.data.shape().1.sub(U1)
+                self.chol.data.shape().0.sub(Const::<1>),
+                self.chol.data.shape().1.sub(Const::<1>)
             )
         };
         chol.slice_range_mut(..j, ..j)
@@ -316,7 +316,7 @@ where
         let mut bottom_right_corner = chol.slice_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, N::RealField::one());
+        Self::xx_rank_one_update(&mut bottom_right_corner, &mut old_colj, T::RealField::one());
 
         Cholesky { chol }
     }
@@ -327,15 +327,15 @@ where
     /// 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
     fn xx_rank_one_update<Dm, Sm, Rx, Sx>(
-        chol: &mut Matrix<N, Dm, Dm, Sm>,
-        x: &mut Vector<N, Rx, Sx>,
-        sigma: N::RealField,
+        chol: &mut Matrix<T, Dm, Dm, Sm>,
+        x: &mut Vector<T, Rx, Sx>,
+        sigma: T::RealField,
     ) where
-        //N: ComplexField,
+        //T: ComplexField,
         Dm: Dim,
         Rx: Dim,
-        Sm: StorageMut<N, Dm, Dm>,
-        Sx: StorageMut<N, Rx, U1>,
+        Sm: StorageMut<T, Dm, Dm>,
+        Sx: StorageMut<T, Rx, U1>,
     {
         // heavily inspired by Eigen's `llt_rank_update_lower` implementation https://eigen.tuxfamily.org/dox/LLT_8h_source.html
         let n = x.nrows();
@@ -345,29 +345,29 @@ where
             "The input vector must be of the same size as the factorized matrix."
         );
 
-        let mut beta = crate::one::<N::RealField>();
+        let mut beta = crate::one::<T::RealField>();
 
         for j in 0..n {
             // updates the diagonal
-            let diag = N::real(unsafe { *chol.get_unchecked((j, j)) });
+            let diag = T::real(unsafe { *chol.get_unchecked((j, j)) });
             let diag2 = diag * diag;
             let xj = unsafe { *x.get_unchecked(j) };
-            let sigma_xj2 = sigma * N::modulus_squared(xj);
+            let sigma_xj2 = sigma * T::modulus_squared(xj);
             let gamma = diag2 * beta + sigma_xj2;
             let new_diag = (diag2 + sigma_xj2 / beta).sqrt();
-            unsafe { *chol.get_unchecked_mut((j, j)) = N::from_real(new_diag) };
+            unsafe { *chol.get_unchecked_mut((j, j)) = T::from_real(new_diag) };
             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);
-            // temp_jplus -= (wj / N::from_real(diag)) * col_j;
-            xjplus.axpy(-xj / N::from_real(diag), &col_j, N::one());
-            if gamma != crate::zero::<N::RealField>() {
-                // col_j = N::from_real(nljj / diag) * col_j  + (N::from_real(nljj * sigma / gamma) * N::conjugate(wj)) * temp_jplus;
+            // temp_jplus -= (wj / T::from_real(diag)) * col_j;
+            xjplus.axpy(-xj / T::from_real(diag), &col_j, T::one());
+            if gamma != crate::zero::<T::RealField>() {
+                // col_j = T::from_real(nljj / diag) * col_j  + (T::from_real(nljj * sigma / gamma) * T::conjugate(wj)) * temp_jplus;
                 col_j.axpy(
-                    N::from_real(new_diag * sigma / gamma) * N::conjugate(xj),
+                    T::from_real(new_diag * sigma / gamma) * T::conjugate(xj),
                     &xjplus,
-                    N::from_real(new_diag / diag),
+                    T::from_real(new_diag / diag),
                 );
             }
         }
diff --git a/src/linalg/col_piv_qr.rs b/src/linalg/col_piv_qr.rs
index 302dcd66..5c776b2d 100644
--- a/src/linalg/col_piv_qr.rs
+++ b/src/linalg/col_piv_qr.rs
@@ -3,9 +3,9 @@ use num::Zero;
 use serde::{Deserialize, Serialize};
 
 use crate::allocator::{Allocator, Reallocator};
-use crate::base::{DefaultAllocator, Matrix, MatrixMN, MatrixN, Unit, VectorN};
+use crate::base::{Const, DefaultAllocator, Matrix, OMatrix, OVector, Unit};
 use crate::constraint::{SameNumberOfRows, ShapeConstraint};
-use crate::dimension::{Dim, DimMin, DimMinimum, U1};
+use crate::dimension::{Dim, DimMin, DimMinimum};
 use crate::storage::{Storage, StorageMut};
 use crate::ComplexField;
 
@@ -16,58 +16,58 @@ use crate::linalg::{householder, PermutationSequence};
 #[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
 #[cfg_attr(
     feature = "serde-serialize",
-    serde(bound(serialize = "DefaultAllocator: Allocator<N, R, C> +
-                           Allocator<N, DimMinimum<R, C>>,
-         MatrixMN<N, R, C>: Serialize,
+    serde(bound(serialize = "DefaultAllocator: Allocator<T, R, C> +
+                           Allocator<T, DimMinimum<R, C>>,
+         OMatrix<T, R, C>: Serialize,
          PermutationSequence<DimMinimum<R, C>>: Serialize,
-         VectorN<N, DimMinimum<R, C>>: Serialize"))
+         OVector<T, DimMinimum<R, C>>: Serialize"))
 )]
 #[cfg_attr(
     feature = "serde-serialize",
-    serde(bound(deserialize = "DefaultAllocator: Allocator<N, R, C> +
-                           Allocator<N, DimMinimum<R, C>>,
-         MatrixMN<N, R, C>: Deserialize<'de>,
+    serde(bound(deserialize = "DefaultAllocator: Allocator<T, R, C> +
+                           Allocator<T, DimMinimum<R, C>>,
+         OMatrix<T, R, C>: Deserialize<'de>,
          PermutationSequence<DimMinimum<R, C>>: Deserialize<'de>,
-         VectorN<N, DimMinimum<R, C>>: Deserialize<'de>"))
+         OVector<T, DimMinimum<R, C>>: Deserialize<'de>"))
 )]
 #[derive(Clone, Debug)]
-pub struct ColPivQR<N: ComplexField, R: DimMin<C>, C: Dim>
+pub struct ColPivQR<T: ComplexField, R: DimMin<C>, C: Dim>
 where
-    DefaultAllocator: Allocator<N, R, C>
-        + Allocator<N, DimMinimum<R, C>>
+    DefaultAllocator: Allocator<T, R, C>
+        + Allocator<T, DimMinimum<R, C>>
         + Allocator<(usize, usize), DimMinimum<R, C>>,
 {
-    col_piv_qr: MatrixMN<N, R, C>,
+    col_piv_qr: OMatrix<T, R, C>,
     p: PermutationSequence<DimMinimum<R, C>>,
-    diag: VectorN<N, DimMinimum<R, C>>,
+    diag: OVector<T, DimMinimum<R, C>>,
 }
 
-impl<N: ComplexField, R: DimMin<C>, C: Dim> Copy for ColPivQR<N, R, C>
+impl<T: ComplexField, R: DimMin<C>, C: Dim> Copy for ColPivQR<T, R, C>
 where
-    DefaultAllocator: Allocator<N, R, C>
-        + Allocator<N, DimMinimum<R, C>>
+    DefaultAllocator: Allocator<T, R, C>
+        + Allocator<T, DimMinimum<R, C>>
         + Allocator<(usize, usize), DimMinimum<R, C>>,
-    MatrixMN<N, R, C>: Copy,
+    OMatrix<T, R, C>: Copy,
     PermutationSequence<DimMinimum<R, C>>: Copy,
-    VectorN<N, DimMinimum<R, C>>: Copy,
+    OVector<T, DimMinimum<R, C>>: Copy,
 {
 }
 
-impl<N: ComplexField, R: DimMin<C>, C: Dim> ColPivQR<N, R, C>
+impl<T: ComplexField, R: DimMin<C>, C: Dim> ColPivQR<T, R, C>
 where
-    DefaultAllocator: Allocator<N, R, C>
-        + Allocator<N, R>
-        + Allocator<N, DimMinimum<R, C>>
+    DefaultAllocator: Allocator<T, R, C>
+        + Allocator<T, R>
+        + Allocator<T, DimMinimum<R, C>>
         + Allocator<(usize, usize), DimMinimum<R, C>>,
 {
     /// Computes the ColPivQR decomposition using householder reflections.
-    pub fn new(mut matrix: MatrixMN<N, R, C>) -> Self {
+    pub fn new(mut matrix: OMatrix<T, R, C>) -> Self {
         let (nrows, ncols) = matrix.data.shape();
         let min_nrows_ncols = nrows.min(ncols);
         let mut p = PermutationSequence::identity_generic(min_nrows_ncols);
 
         let mut diag =
-            unsafe { crate::unimplemented_or_uninitialized_generic!(min_nrows_ncols, U1) };
+            unsafe { crate::unimplemented_or_uninitialized_generic!(min_nrows_ncols, Const::<1>) };
 
         if min_nrows_ncols.value() == 0 {
             return ColPivQR {
@@ -95,16 +95,16 @@ where
 
     /// Retrieves the upper trapezoidal submatrix `R` of this decomposition.
     #[inline]
-    pub fn r(&self) -> MatrixMN<N, DimMinimum<R, C>, C>
+    pub fn r(&self) -> OMatrix<T, DimMinimum<R, C>, C>
     where
-        DefaultAllocator: Allocator<N, DimMinimum<R, C>, C>,
+        DefaultAllocator: Allocator<T, DimMinimum<R, C>, C>,
     {
         let (nrows, ncols) = self.col_piv_qr.data.shape();
         let mut res = self
             .col_piv_qr
             .rows_generic(0, nrows.min(ncols))
             .upper_triangle();
-        res.set_partial_diagonal(self.diag.iter().map(|e| N::from_real(e.modulus())));
+        res.set_partial_diagonal(self.diag.iter().map(|e| T::from_real(e.modulus())));
         res
     }
 
@@ -112,23 +112,23 @@ where
     ///
     /// This is usually faster than `r` but consumes `self`.
     #[inline]
-    pub fn unpack_r(self) -> MatrixMN<N, DimMinimum<R, C>, C>
+    pub fn unpack_r(self) -> OMatrix<T, DimMinimum<R, C>, C>
     where
-        DefaultAllocator: Reallocator<N, R, C, DimMinimum<R, C>, C>,
+        DefaultAllocator: Reallocator<T, R, C, DimMinimum<R, C>, C>,
     {
         let (nrows, ncols) = self.col_piv_qr.data.shape();
         let mut res = self
             .col_piv_qr
-            .resize_generic(nrows.min(ncols), ncols, N::zero());
-        res.fill_lower_triangle(N::zero(), 1);
-        res.set_partial_diagonal(self.diag.iter().map(|e| N::from_real(e.modulus())));
+            .resize_generic(nrows.min(ncols), ncols, T::zero());
+        res.fill_lower_triangle(T::zero(), 1);
+        res.set_partial_diagonal(self.diag.iter().map(|e| T::from_real(e.modulus())));
         res
     }
 
     /// Computes the orthogonal matrix `Q` of this decomposition.
-    pub fn q(&self) -> MatrixMN<N, R, DimMinimum<R, C>>
+    pub fn q(&self) -> OMatrix<T, R, DimMinimum<R, C>>
     where
-        DefaultAllocator: Allocator<N, R, DimMinimum<R, C>>,
+        DefaultAllocator: Allocator<T, R, DimMinimum<R, C>>,
     {
         let (nrows, ncols) = self.col_piv_qr.data.shape();
 
@@ -140,7 +140,7 @@ where
         for i in (0..dim).rev() {
             let axis = self.col_piv_qr.slice_range(i.., i);
             // TODO: sometimes, the axis might have a zero magnitude.
-            let refl = Reflection::new(Unit::new_unchecked(axis), N::zero());
+            let refl = Reflection::new(Unit::new_unchecked(axis), T::zero());
 
             let mut res_rows = res.slice_range_mut(i.., i..);
             refl.reflect_with_sign(&mut res_rows, self.diag[i].signum());
@@ -158,34 +158,34 @@ where
     pub fn unpack(
         self,
     ) -> (
-        MatrixMN<N, R, DimMinimum<R, C>>,
-        MatrixMN<N, DimMinimum<R, C>, C>,
+        OMatrix<T, R, DimMinimum<R, C>>,
+        OMatrix<T, DimMinimum<R, C>, C>,
         PermutationSequence<DimMinimum<R, C>>,
     )
     where
         DimMinimum<R, C>: DimMin<C, Output = DimMinimum<R, C>>,
-        DefaultAllocator: Allocator<N, R, DimMinimum<R, C>>
-            + Reallocator<N, R, C, DimMinimum<R, C>, C>
+        DefaultAllocator: Allocator<T, R, DimMinimum<R, C>>
+            + Reallocator<T, R, C, DimMinimum<R, C>, C>
             + Allocator<(usize, usize), DimMinimum<R, C>>,
     {
         (self.q(), self.r(), self.p)
     }
 
     #[doc(hidden)]
-    pub fn col_piv_qr_internal(&self) -> &MatrixMN<N, R, C> {
+    pub fn col_piv_qr_internal(&self) -> &OMatrix<T, R, C> {
         &self.col_piv_qr
     }
 
     /// Multiplies the provided matrix by the transpose of the `Q` matrix of this decomposition.
-    pub fn q_tr_mul<R2: Dim, C2: Dim, S2>(&self, rhs: &mut Matrix<N, R2, C2, S2>)
+    pub fn q_tr_mul<R2: Dim, C2: Dim, S2>(&self, rhs: &mut Matrix<T, R2, C2, S2>)
     where
-        S2: StorageMut<N, R2, C2>,
+        S2: StorageMut<T, R2, C2>,
     {
         let dim = self.diag.len();
 
         for i in 0..dim {
             let axis = self.col_piv_qr.slice_range(i.., i);
-            let refl = Reflection::new(Unit::new_unchecked(axis), N::zero());
+            let refl = Reflection::new(Unit::new_unchecked(axis), T::zero());
 
             let mut rhs_rows = rhs.rows_range_mut(i..);
             refl.reflect_with_sign(&mut rhs_rows, self.diag[i].signum().conjugate());
@@ -193,22 +193,22 @@ where
     }
 }
 
-impl<N: ComplexField, D: DimMin<D, Output = D>> ColPivQR<N, D, D>
+impl<T: ComplexField, D: DimMin<D, Output = D>> ColPivQR<T, D, D>
 where
     DefaultAllocator:
-        Allocator<N, D, D> + Allocator<N, D> + Allocator<(usize, usize), DimMinimum<D, D>>,
+        Allocator<T, D, D> + Allocator<T, D> + Allocator<(usize, usize), DimMinimum<D, D>>,
 {
     /// Solves the linear system `self * x = b`, where `x` is the unknown to be determined.
     ///
     /// Returns `None` if `self` is not invertible.
     pub fn solve<R2: Dim, C2: Dim, S2>(
         &self,
-        b: &Matrix<N, R2, C2, S2>,
-    ) -> Option<MatrixMN<N, R2, C2>>
+        b: &Matrix<T, R2, C2, S2>,
+    ) -> Option<OMatrix<T, R2, C2>>
     where
-        S2: StorageMut<N, R2, C2>,
+        S2: StorageMut<T, R2, C2>,
         ShapeConstraint: SameNumberOfRows<R2, D>,
-        DefaultAllocator: Allocator<N, R2, C2>,
+        DefaultAllocator: Allocator<T, R2, C2>,
     {
         let mut res = b.clone_owned();
 
@@ -223,9 +223,9 @@ where
     ///
     /// If the decomposed matrix is not invertible, this returns `false` and its input `b` is
     /// overwritten with garbage.
-    pub fn solve_mut<R2: Dim, C2: Dim, S2>(&self, b: &mut Matrix<N, R2, C2, S2>) -> bool
+    pub fn solve_mut<R2: Dim, C2: Dim, S2>(&self, b: &mut Matrix<T, R2, C2, S2>) -> bool
     where
-        S2: StorageMut<N, R2, C2>,
+        S2: StorageMut<T, R2, C2>,
         ShapeConstraint: SameNumberOfRows<R2, D>,
     {
         assert_eq!(
@@ -248,10 +248,10 @@ where
     // TODO: duplicate code from the `solve` module.
     fn solve_upper_triangular_mut<R2: Dim, C2: Dim, S2>(
         &self,
-        b: &mut Matrix<N, R2, C2, S2>,
+        b: &mut Matrix<T, R2, C2, S2>,
     ) -> bool
     where
-        S2: StorageMut<N, R2, C2>,
+        S2: StorageMut<T, R2, C2>,
         ShapeConstraint: SameNumberOfRows<R2, D>,
     {
         let dim = self.col_piv_qr.nrows();
@@ -273,7 +273,7 @@ where
                 }
 
                 b.rows_range_mut(..i)
-                    .axpy(-coeff, &self.col_piv_qr.slice_range(..i, i), N::one());
+                    .axpy(-coeff, &self.col_piv_qr.slice_range(..i, i), T::one());
             }
         }
 
@@ -283,7 +283,7 @@ where
     /// Computes the inverse of the decomposed matrix.
     ///
     /// Returns `None` if the decomposed matrix is not invertible.
-    pub fn try_inverse(&self) -> Option<MatrixN<N, D>> {
+    pub fn try_inverse(&self) -> Option<OMatrix<T, D, D>> {
         assert!(
             self.col_piv_qr.is_square(),
             "ColPivQR inverse: unable to compute the inverse of a non-square matrix."
@@ -291,7 +291,7 @@ where
 
         // TODO: is there a less naive method ?
         let (nrows, ncols) = self.col_piv_qr.data.shape();
-        let mut res = MatrixN::identity_generic(nrows, ncols);
+        let mut res = OMatrix::identity_generic(nrows, ncols);
 
         if self.solve_mut(&mut res) {
             Some(res)
@@ -317,14 +317,14 @@ where
     }
 
     /// Computes the determinant of the decomposed matrix.
-    pub fn determinant(&self) -> N {
+    pub fn determinant(&self) -> T {
         let dim = self.col_piv_qr.nrows();
         assert!(
             self.col_piv_qr.is_square(),
             "ColPivQR determinant: unable to compute the determinant of a non-square matrix."
         );
 
-        let mut res = N::one();
+        let mut res = T::one();
         for i in 0..dim {
             res *= unsafe { *self.diag.vget_unchecked(i) };
         }
diff --git a/src/linalg/convolution.rs b/src/linalg/convolution.rs
index df84c301..2729b66b 100644
--- a/src/linalg/convolution.rs
+++ b/src/linalg/convolution.rs
@@ -2,11 +2,11 @@ use std::cmp;
 
 use crate::base::allocator::Allocator;
 use crate::base::default_allocator::DefaultAllocator;
-use crate::base::dimension::{Dim, DimAdd, DimDiff, DimSub, DimSum};
+use crate::base::dimension::{Const, Dim, DimAdd, DimDiff, DimSub, DimSum};
 use crate::storage::Storage;
-use crate::{zero, RealField, Vector, VectorN, U1};
+use crate::{zero, OVector, RealField, Vector, U1};
 
-impl<N: RealField, D1: Dim, S1: Storage<N, D1>> Vector<N, D1, S1> {
+impl<T: RealField, D1: Dim, S1: Storage<T, D1>> Vector<T, D1, S1> {
     /// Returns the convolution of the target vector and a kernel.
     ///
     /// # Arguments
@@ -18,24 +18,29 @@ impl<N: RealField, D1: Dim, S1: Storage<N, D1>> Vector<N, D1, S1> {
     ///
     pub fn convolve_full<D2, S2>(
         &self,
-        kernel: Vector<N, D2, S2>,
-    ) -> VectorN<N, DimDiff<DimSum<D1, D2>, U1>>
+        kernel: Vector<T, D2, S2>,
+    ) -> OVector<T, DimDiff<DimSum<D1, D2>, U1>>
     where
         D1: DimAdd<D2>,
         D2: DimAdd<D1, Output = DimSum<D1, D2>>,
         DimSum<D1, D2>: DimSub<U1>,
-        S2: Storage<N, D2>,
-        DefaultAllocator: Allocator<N, DimDiff<DimSum<D1, D2>, U1>>,
+        S2: Storage<T, D2>,
+        DefaultAllocator: Allocator<T, DimDiff<DimSum<D1, D2>, U1>>,
     {
         let vec = self.len();
         let ker = kernel.len();
 
         if ker == 0 || ker > vec {
-            panic!("convolve_full expects `self.len() >= kernel.len() > 0`, received {} and {} respectively.",vec,ker);
+            panic!("convolve_full expects `self.len() >= kernel.len() > 0`, received {} and {} respectively.", vec, ker);
         }
 
-        let result_len = self.data.shape().0.add(kernel.data.shape().0).sub(U1);
-        let mut conv = VectorN::zeros_generic(result_len, U1);
+        let result_len = self
+            .data
+            .shape()
+            .0
+            .add(kernel.data.shape().0)
+            .sub(Const::<1>);
+        let mut conv = OVector::zeros_generic(result_len, Const::<1>);
 
         for i in 0..(vec + ker - 1) {
             let u_i = if i > vec { i - ker } else { 0 };
@@ -66,14 +71,14 @@ impl<N: RealField, D1: Dim, S1: Storage<N, D1>> Vector<N, D1, S1> {
     ///
     pub fn convolve_valid<D2, S2>(
         &self,
-        kernel: Vector<N, D2, S2>,
-    ) -> VectorN<N, DimDiff<DimSum<D1, U1>, D2>>
+        kernel: Vector<T, D2, S2>,
+    ) -> OVector<T, DimDiff<DimSum<D1, U1>, D2>>
     where
         D1: DimAdd<U1>,
         D2: Dim,
         DimSum<D1, U1>: DimSub<D2>,
-        S2: Storage<N, D2>,
-        DefaultAllocator: Allocator<N, DimDiff<DimSum<D1, U1>, D2>>,
+        S2: Storage<T, D2>,
+        DefaultAllocator: Allocator<T, DimDiff<DimSum<D1, U1>, D2>>,
     {
         let vec = self.len();
         let ker = kernel.len();
@@ -82,8 +87,13 @@ impl<N: RealField, D1: Dim, S1: Storage<N, D1>> Vector<N, D1, S1> {
             panic!("convolve_valid expects `self.len() >= kernel.len() > 0`, received {} and {} respectively.",vec,ker);
         }
 
-        let result_len = self.data.shape().0.add(U1).sub(kernel.data.shape().0);
-        let mut conv = VectorN::zeros_generic(result_len, U1);
+        let result_len = self
+            .data
+            .shape()
+            .0
+            .add(Const::<1>)
+            .sub(kernel.data.shape().0);
+        let mut conv = OVector::zeros_generic(result_len, Const::<1>);
 
         for i in 0..(vec - ker + 1) {
             for j in 0..ker {
@@ -102,11 +112,11 @@ impl<N: RealField, D1: Dim, S1: Storage<N, D1>> Vector<N, D1, S1> {
     ///
     /// # Errors
     /// Inputs must satisfy `self.len() >= kernel.len() > 0`.
-    pub fn convolve_same<D2, S2>(&self, kernel: Vector<N, D2, S2>) -> VectorN<N, D1>
+    pub fn convolve_same<D2, S2>(&self, kernel: Vector<T, D2, S2>) -> OVector<T, D1>
     where
         D2: Dim,
-        S2: Storage<N, D2>,
-        DefaultAllocator: Allocator<N, D1>,
+        S2: Storage<T, D2>,
+        DefaultAllocator: Allocator<T, D1>,
     {
         let vec = self.len();
         let ker = kernel.len();
@@ -115,12 +125,12 @@ impl<N: RealField, D1: Dim, S1: Storage<N, D1>> Vector<N, D1, S1> {
             panic!("convolve_same expects `self.len() >= kernel.len() > 0`, received {} and {} respectively.",vec,ker);
         }
 
-        let mut conv = VectorN::zeros_generic(self.data.shape().0, U1);
+        let mut conv = OVector::zeros_generic(self.data.shape().0, Const::<1>);
 
         for i in 0..vec {
             for j in 0..ker {
                 let val = if i + j < 1 || i + j >= vec + 1 {
-                    zero::<N>()
+                    zero::<T>()
                 } else {
                     self[i + j - 1]
                 };
diff --git a/src/linalg/decomposition.rs b/src/linalg/decomposition.rs
index 6428856b..5b56b65a 100644
--- a/src/linalg/decomposition.rs
+++ b/src/linalg/decomposition.rs
@@ -17,17 +17,17 @@ use crate::{
 /// | LU with partial pivoting | `P⁻¹ * L * U`       | `L` is lower-triangular with a diagonal filled with `1` and `U` is upper-triangular. `P` is a permutation matrix. |
 /// | LU with full pivoting    | `P⁻¹ * L * U * Q⁻¹` | `L` is lower-triangular with a diagonal filled with `1` and `U` is upper-triangular. `P` and `Q` are permutation matrices. |
 /// | SVD                      | `U * Σ * Vᵀ`        | `U` and `V` are two orthogonal matrices and `Σ` is a diagonal matrix containing the singular values. |
-impl<N: ComplexField, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
+impl<T: ComplexField, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
     /// Computes the bidiagonalization using householder reflections.
-    pub fn bidiagonalize(self) -> Bidiagonal<N, R, C>
+    pub fn bidiagonalize(self) -> Bidiagonal<T, R, C>
     where
         R: DimMin<C>,
         DimMinimum<R, C>: DimSub<U1>,
-        DefaultAllocator: Allocator<N, R, C>
-            + Allocator<N, C>
-            + Allocator<N, R>
-            + Allocator<N, DimMinimum<R, C>>
-            + Allocator<N, DimDiff<DimMinimum<R, C>, U1>>,
+        DefaultAllocator: Allocator<T, R, C>
+            + Allocator<T, C>
+            + Allocator<T, R>
+            + Allocator<T, DimMinimum<R, C>>
+            + Allocator<T, DimDiff<DimMinimum<R, C>, U1>>,
     {
         Bidiagonal::new(self.into_owned())
     }
@@ -35,58 +35,58 @@ impl<N: ComplexField, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     /// Computes the LU decomposition with full pivoting of `matrix`.
     ///
     /// This effectively computes `P, L, U, Q` such that `P * matrix * Q = LU`.
-    pub fn full_piv_lu(self) -> FullPivLU<N, R, C>
+    pub fn full_piv_lu(self) -> FullPivLU<T, R, C>
     where
         R: DimMin<C>,
-        DefaultAllocator: Allocator<N, R, C> + Allocator<(usize, usize), DimMinimum<R, C>>,
+        DefaultAllocator: Allocator<T, R, C> + Allocator<(usize, usize), DimMinimum<R, C>>,
     {
         FullPivLU::new(self.into_owned())
     }
 
     /// Computes the LU decomposition with partial (row) pivoting of `matrix`.
-    pub fn lu(self) -> LU<N, R, C>
+    pub fn lu(self) -> LU<T, R, C>
     where
         R: DimMin<C>,
-        DefaultAllocator: Allocator<N, R, C> + Allocator<(usize, usize), DimMinimum<R, C>>,
+        DefaultAllocator: Allocator<T, R, C> + Allocator<(usize, usize), DimMinimum<R, C>>,
     {
         LU::new(self.into_owned())
     }
 
     /// Computes the QR decomposition of this matrix.
-    pub fn qr(self) -> QR<N, R, C>
+    pub fn qr(self) -> QR<T, R, C>
     where
         R: DimMin<C>,
-        DefaultAllocator: Allocator<N, R, C> + Allocator<N, R> + Allocator<N, DimMinimum<R, C>>,
+        DefaultAllocator: Allocator<T, R, C> + Allocator<T, R> + Allocator<T, DimMinimum<R, C>>,
     {
         QR::new(self.into_owned())
     }
 
     /// Computes the QR decomposition (with column pivoting) of this matrix.
-    pub fn col_piv_qr(self) -> ColPivQR<N, R, C>
+    pub fn col_piv_qr(self) -> ColPivQR<T, R, C>
     where
         R: DimMin<C>,
-        DefaultAllocator: Allocator<N, R, C>
-            + Allocator<N, R>
-            + Allocator<N, DimMinimum<R, C>>
+        DefaultAllocator: Allocator<T, R, C>
+            + Allocator<T, R>
+            + Allocator<T, DimMinimum<R, C>>
             + Allocator<(usize, usize), DimMinimum<R, C>>,
     {
         ColPivQR::new(self.into_owned())
     }
 
     /// Computes the Singular Value Decomposition using implicit shift.
-    pub fn svd(self, compute_u: bool, compute_v: bool) -> SVD<N, R, C>
+    pub fn svd(self, compute_u: bool, compute_v: bool) -> SVD<T, R, C>
     where
         R: DimMin<C>,
         DimMinimum<R, C>: DimSub<U1>, // for Bidiagonal.
-        DefaultAllocator: Allocator<N, R, C>
-            + Allocator<N, C>
-            + Allocator<N, R>
-            + Allocator<N, DimDiff<DimMinimum<R, C>, U1>>
-            + Allocator<N, DimMinimum<R, C>, C>
-            + Allocator<N, R, DimMinimum<R, C>>
-            + Allocator<N, DimMinimum<R, C>>
-            + Allocator<N::RealField, DimMinimum<R, C>>
-            + Allocator<N::RealField, DimDiff<DimMinimum<R, C>, U1>>,
+        DefaultAllocator: Allocator<T, R, C>
+            + Allocator<T, C>
+            + Allocator<T, R>
+            + Allocator<T, DimDiff<DimMinimum<R, C>, U1>>
+            + Allocator<T, DimMinimum<R, C>, C>
+            + Allocator<T, R, DimMinimum<R, C>>
+            + Allocator<T, DimMinimum<R, C>>
+            + Allocator<T::RealField, DimMinimum<R, C>>
+            + Allocator<T::RealField, DimDiff<DimMinimum<R, C>, U1>>,
     {
         SVD::new(self.into_owned(), compute_u, compute_v)
     }
@@ -105,21 +105,21 @@ impl<N: ComplexField, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
         self,
         compute_u: bool,
         compute_v: bool,
-        eps: N::RealField,
+        eps: T::RealField,
         max_niter: usize,
-    ) -> Option<SVD<N, R, C>>
+    ) -> Option<SVD<T, R, C>>
     where
         R: DimMin<C>,
         DimMinimum<R, C>: DimSub<U1>, // for Bidiagonal.
-        DefaultAllocator: Allocator<N, R, C>
-            + Allocator<N, C>
-            + Allocator<N, R>
-            + Allocator<N, DimDiff<DimMinimum<R, C>, U1>>
-            + Allocator<N, DimMinimum<R, C>, C>
-            + Allocator<N, R, DimMinimum<R, C>>
-            + Allocator<N, DimMinimum<R, C>>
-            + Allocator<N::RealField, DimMinimum<R, C>>
-            + Allocator<N::RealField, DimDiff<DimMinimum<R, C>, U1>>,
+        DefaultAllocator: Allocator<T, R, C>
+            + Allocator<T, C>
+            + Allocator<T, R>
+            + Allocator<T, DimDiff<DimMinimum<R, C>, U1>>
+            + Allocator<T, DimMinimum<R, C>, C>
+            + Allocator<T, R, DimMinimum<R, C>>
+            + Allocator<T, DimMinimum<R, C>>
+            + Allocator<T::RealField, DimMinimum<R, C>>
+            + Allocator<T::RealField, DimDiff<DimMinimum<R, C>, U1>>,
     {
         SVD::try_new(self.into_owned(), compute_u, compute_v, eps, max_niter)
     }
@@ -138,14 +138,14 @@ impl<N: ComplexField, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
 /// | Schur decomposition      | `Q * T * Qᵀ`             | `Q` is an unitary matrix and `T` a quasi-upper-triangular matrix. |
 /// | Symmetric eigendecomposition | `Q ~ Λ ~ Qᵀ`   | `Q` is an unitary matrix, and `Λ` is a real diagonal matrix. |
 /// | Symmetric tridiagonalization | `Q ~ T ~ Qᵀ`   | `Q` is an unitary matrix, and `T` is a tridiagonal matrix. |
-impl<N: ComplexField, D: Dim, S: Storage<N, D, D>> Matrix<N, D, D, S> {
+impl<T: ComplexField, D: Dim, S: Storage<T, D, D>> Matrix<T, D, D, S> {
     /// Attempts to compute the Cholesky decomposition of this matrix.
     ///
     /// Returns `None` if the input matrix is not definite-positive. The input matrix is assumed
     /// to be symmetric and only the lower-triangular part is read.
-    pub fn cholesky(self) -> Option<Cholesky<N, D>>
+    pub fn cholesky(self) -> Option<Cholesky<T, D>>
     where
-        DefaultAllocator: Allocator<N, D, D>,
+        DefaultAllocator: Allocator<T, D, D>,
     {
         Cholesky::new(self.into_owned())
     }
@@ -154,31 +154,31 @@ impl<N: ComplexField, D: Dim, S: Storage<N, D, D>> Matrix<N, D, D, S> {
     ///
     /// The input matrix `self` is assumed to be symmetric and this decomposition will only read
     /// the upper-triangular part of `self`.
-    pub fn udu(self) -> Option<UDU<N, D>>
+    pub fn udu(self) -> Option<UDU<T, D>>
     where
-        N: RealField,
-        DefaultAllocator: Allocator<N, D> + Allocator<N, D, D>,
+        T: RealField,
+        DefaultAllocator: Allocator<T, D> + Allocator<T, D, D>,
     {
         UDU::new(self.into_owned())
     }
 
     /// Computes the Hessenberg decomposition of this matrix using householder reflections.
-    pub fn hessenberg(self) -> Hessenberg<N, D>
+    pub fn hessenberg(self) -> Hessenberg<T, D>
     where
         D: DimSub<U1>,
-        DefaultAllocator: Allocator<N, D, D> + Allocator<N, D> + Allocator<N, DimDiff<D, U1>>,
+        DefaultAllocator: Allocator<T, D, D> + Allocator<T, D> + Allocator<T, DimDiff<D, U1>>,
     {
         Hessenberg::new(self.into_owned())
     }
 
     /// Computes the Schur decomposition of a square matrix.
-    pub fn schur(self) -> Schur<N, D>
+    pub fn schur(self) -> Schur<T, D>
     where
         D: DimSub<U1>, // For Hessenberg.
-        DefaultAllocator: Allocator<N, D, DimDiff<D, U1>>
-            + Allocator<N, DimDiff<D, U1>>
-            + Allocator<N, D, D>
-            + Allocator<N, D>,
+        DefaultAllocator: Allocator<T, D, DimDiff<D, U1>>
+            + Allocator<T, DimDiff<D, U1>>
+            + Allocator<T, D, D>
+            + Allocator<T, D>,
     {
         Schur::new(self.into_owned())
     }
@@ -194,13 +194,13 @@ impl<N: ComplexField, D: Dim, S: Storage<N, D, D>> Matrix<N, D, D, S> {
     /// * `max_niter` − maximum total number of iterations performed by the algorithm. If this
     /// number of iteration is exceeded, `None` is returned. If `niter == 0`, then the algorithm
     /// continues indefinitely until convergence.
-    pub fn try_schur(self, eps: N::RealField, max_niter: usize) -> Option<Schur<N, D>>
+    pub fn try_schur(self, eps: T::RealField, max_niter: usize) -> Option<Schur<T, D>>
     where
         D: DimSub<U1>, // For Hessenberg.
-        DefaultAllocator: Allocator<N, D, DimDiff<D, U1>>
-            + Allocator<N, DimDiff<D, U1>>
-            + Allocator<N, D, D>
-            + Allocator<N, D>,
+        DefaultAllocator: Allocator<T, D, DimDiff<D, U1>>
+            + Allocator<T, DimDiff<D, U1>>
+            + Allocator<T, D, D>
+            + Allocator<T, D>,
     {
         Schur::try_new(self.into_owned(), eps, max_niter)
     }
@@ -208,13 +208,13 @@ impl<N: ComplexField, D: Dim, S: Storage<N, D, D>> Matrix<N, D, D, S> {
     /// Computes the eigendecomposition of this symmetric matrix.
     ///
     /// Only the lower-triangular part (including the diagonal) of `m` is read.
-    pub fn symmetric_eigen(self) -> SymmetricEigen<N, D>
+    pub fn symmetric_eigen(self) -> SymmetricEigen<T, D>
     where
         D: DimSub<U1>,
-        DefaultAllocator: Allocator<N, D, D>
-            + Allocator<N, DimDiff<D, U1>>
-            + Allocator<N::RealField, D>
-            + Allocator<N::RealField, DimDiff<D, U1>>,
+        DefaultAllocator: Allocator<T, D, D>
+            + Allocator<T, DimDiff<D, U1>>
+            + Allocator<T::RealField, D>
+            + Allocator<T::RealField, DimDiff<D, U1>>,
     {
         SymmetricEigen::new(self.into_owned())
     }
@@ -232,15 +232,15 @@ impl<N: ComplexField, D: Dim, S: Storage<N, D, D>> Matrix<N, D, D, S> {
     /// continues indefinitely until convergence.
     pub fn try_symmetric_eigen(
         self,
-        eps: N::RealField,
+        eps: T::RealField,
         max_niter: usize,
-    ) -> Option<SymmetricEigen<N, D>>
+    ) -> Option<SymmetricEigen<T, D>>
     where
         D: DimSub<U1>,
-        DefaultAllocator: Allocator<N, D, D>
-            + Allocator<N, DimDiff<D, U1>>
-            + Allocator<N::RealField, D>
-            + Allocator<N::RealField, DimDiff<D, U1>>,
+        DefaultAllocator: Allocator<T, D, D>
+            + Allocator<T, DimDiff<D, U1>>
+            + Allocator<T::RealField, D>
+            + Allocator<T::RealField, DimDiff<D, U1>>,
     {
         SymmetricEigen::try_new(self.into_owned(), eps, max_niter)
     }
@@ -248,10 +248,10 @@ impl<N: ComplexField, D: Dim, S: Storage<N, D, D>> Matrix<N, D, D, S> {
     /// Computes the tridiagonalization of this symmetric matrix.
     ///
     /// Only the lower-triangular part (including the diagonal) of `m` is read.
-    pub fn symmetric_tridiagonalize(self) -> SymmetricTridiagonal<N, D>
+    pub fn symmetric_tridiagonalize(self) -> SymmetricTridiagonal<T, D>
     where
         D: DimSub<U1>,
-        DefaultAllocator: Allocator<N, D, D> + Allocator<N, DimDiff<D, U1>>,
+        DefaultAllocator: Allocator<T, D, D> + Allocator<T, DimDiff<D, U1>>,
     {
         SymmetricTridiagonal::new(self.into_owned())
     }
diff --git a/src/linalg/determinant.rs b/src/linalg/determinant.rs
index 73365d78..aa04ff3f 100644
--- a/src/linalg/determinant.rs
+++ b/src/linalg/determinant.rs
@@ -7,14 +7,14 @@ use crate::base::{DefaultAllocator, SquareMatrix};
 
 use crate::linalg::LU;
 
-impl<N: ComplexField, D: DimMin<D, Output = D>, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
+impl<T: ComplexField, D: DimMin<D, Output = D>, S: Storage<T, D, D>> SquareMatrix<T, D, S> {
     /// Computes the matrix determinant.
     ///
     /// If the matrix has a dimension larger than 3, an LU decomposition is used.
     #[inline]
-    pub fn determinant(&self) -> N
+    pub fn determinant(&self) -> T
     where
-        DefaultAllocator: Allocator<N, D, D> + Allocator<(usize, usize), D>,
+        DefaultAllocator: Allocator<T, D, D> + Allocator<(usize, usize), D>,
     {
         assert!(
             self.is_square(),
@@ -24,7 +24,7 @@ impl<N: ComplexField, D: DimMin<D, Output = D>, S: Storage<N, D, D>> SquareMatri
 
         unsafe {
             match dim {
-                0 => N::one(),
+                0 => T::one(),
                 1 => *self.get_unchecked((0, 0)),
                 2 => {
                     let m11 = *self.get_unchecked((0, 0));
diff --git a/src/linalg/eigen.rs b/src/linalg/eigen.rs
index 2177903e..12d83a02 100644
--- a/src/linalg/eigen.rs
+++ b/src/linalg/eigen.rs
@@ -11,7 +11,7 @@ use crate::allocator::Allocator;
 use crate::base::dimension::{Dim, DimDiff, DimSub, Dynamic, U1, U2, U3};
 use crate::base::storage::Storage;
 use crate::base::{
-    DefaultAllocator, Hessenberg, MatrixN, SquareMatrix, Unit, Vector2, Vector3, VectorN,
+    DefaultAllocator, Hessenberg, OMatrix, OVector, SquareMatrix, Unit, Vector2, Vector3,
 };
 use crate::constraint::{DimEq, ShapeConstraint};
 
@@ -23,46 +23,47 @@ use crate::linalg::Schur;
 #[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
 #[cfg_attr(
     feature = "serde-serialize",
-    serde(bound(serialize = "DefaultAllocator: Allocator<N, D>,
-         VectorN<N, D>: Serialize,
-         MatrixN<N, D>: Serialize"))
+    serde(bound(serialize = "DefaultAllocator: Allocator<T, D>,
+         OVector<T, D>: Serialize,
+         OMatrix<T, D, D>: Serialize"))
 )]
 #[cfg_attr(
     feature = "serde-serialize",
-    serde(bound(deserialize = "DefaultAllocator: Allocator<N, D>,
-         VectorN<N, D>: Serialize,
-         MatrixN<N, D>: Deserialize<'de>"))
+    serde(bound(deserialize = "DefaultAllocator: Allocator<T, D>,
+         OVector<T, D>: Serialize,
+         OMatrix<T, D, D>: Deserialize<'de>"))
 )]
 #[derive(Clone, Debug)]
-pub struct Eigen<N: ComplexField, D: Dim>
-where DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>
-{
-    pub eigenvectors: MatrixN<N, D>,
-    pub eigenvalues: VectorN<N, D>,
-}
-
-impl<N: ComplexField, D: Dim> Copy for Eigen<N, D>
+pub struct Eigen<T: ComplexField, D: Dim>
 where
-    DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>,
-    MatrixN<N, D>: Copy,
-    VectorN<N, D>: Copy,
+    DefaultAllocator: Allocator<T, D, D> + Allocator<T, D>,
+{
+    pub eigenvectors: OMatrix<T, D, D>,
+    pub eigenvalues: OVector<T, D>,
+}
+
+impl<T: ComplexField, D: Dim> Copy for Eigen<T, D>
+where
+    DefaultAllocator: Allocator<T, D, D> + Allocator<T, D>,
+    OMatrix<T, D, D>: Copy,
+    OVector<T, D>: Copy,
 {
 }
 
-impl<N: ComplexField, D: Dim> Eigen<N, D>
+impl<T: ComplexField, D: Dim> Eigen<T, D>
 where
     D: DimSub<U1>,                                   // For Hessenberg.
     ShapeConstraint: DimEq<Dynamic, DimDiff<D, U1>>, // For Hessenberg.
-    DefaultAllocator: Allocator<N, D, DimDiff<D, U1>>
-        + Allocator<N, DimDiff<D, U1>>
-        + Allocator<N, D, D>
-        + Allocator<N, D>,
+    DefaultAllocator: Allocator<T, D, DimDiff<D, U1>>
+        + Allocator<T, DimDiff<D, U1>>
+        + Allocator<T, D, D>
+        + Allocator<T, D>,
     // XXX: for debug
     DefaultAllocator: Allocator<usize, D, D>,
-    MatrixN<N, D>: Display,
+    OMatrix<T, D, D>: Display,
 {
     /// Computes the eigendecomposition of a diagonalizable matrix with Complex eigenvalues.
-    pub fn new(m: MatrixN<N, D>) -> Option<Eigen<N, D>> {
+    pub fn new(m: OMatrix<T, D, D>) -> Option<Eigen<T, D>> {
         assert!(
             m.is_square(),
             "Unable to compute the eigendecomposition of a non-square matrix."
diff --git a/src/linalg/exp.rs b/src/linalg/exp.rs
index dc23a947..598c6350 100644
--- a/src/linalg/exp.rs
+++ b/src/linalg/exp.rs
@@ -3,54 +3,54 @@
 use crate::{
     base::{
         allocator::Allocator,
-        dimension::{Dim, DimMin, DimMinimum, U1},
+        dimension::{Const, Dim, DimMin, DimMinimum},
         storage::Storage,
         DefaultAllocator,
     },
-    convert, try_convert, ComplexField, MatrixN, RealField,
+    convert, try_convert, ComplexField, OMatrix, RealField,
 };
 
 use crate::num::Zero;
 
 // https://github.com/scipy/scipy/blob/c1372d8aa90a73d8a52f135529293ff4edb98fc8/scipy/sparse/linalg/matfuncs.py
-struct ExpmPadeHelper<N, D>
+struct ExpmPadeHelper<T, D>
 where
-    N: ComplexField,
+    T: ComplexField,
     D: DimMin<D>,
-    DefaultAllocator: Allocator<N, D, D> + Allocator<(usize, usize), DimMinimum<D, D>>,
+    DefaultAllocator: Allocator<T, D, D> + Allocator<(usize, usize), DimMinimum<D, D>>,
 {
     use_exact_norm: bool,
-    ident: MatrixN<N, D>,
+    ident: OMatrix<T, D, D>,
 
-    a: MatrixN<N, D>,
-    a2: Option<MatrixN<N, D>>,
-    a4: Option<MatrixN<N, D>>,
-    a6: Option<MatrixN<N, D>>,
-    a8: Option<MatrixN<N, D>>,
-    a10: Option<MatrixN<N, D>>,
+    a: OMatrix<T, D, D>,
+    a2: Option<OMatrix<T, D, D>>,
+    a4: Option<OMatrix<T, D, D>>,
+    a6: Option<OMatrix<T, D, D>>,
+    a8: Option<OMatrix<T, D, D>>,
+    a10: Option<OMatrix<T, D, D>>,
 
-    d4_exact: Option<N::RealField>,
-    d6_exact: Option<N::RealField>,
-    d8_exact: Option<N::RealField>,
-    d10_exact: Option<N::RealField>,
+    d4_exact: Option<T::RealField>,
+    d6_exact: Option<T::RealField>,
+    d8_exact: Option<T::RealField>,
+    d10_exact: Option<T::RealField>,
 
-    d4_approx: Option<N::RealField>,
-    d6_approx: Option<N::RealField>,
-    d8_approx: Option<N::RealField>,
-    d10_approx: Option<N::RealField>,
+    d4_approx: Option<T::RealField>,
+    d6_approx: Option<T::RealField>,
+    d8_approx: Option<T::RealField>,
+    d10_approx: Option<T::RealField>,
 }
 
-impl<N, D> ExpmPadeHelper<N, D>
+impl<T, D> ExpmPadeHelper<T, D>
 where
-    N: ComplexField,
+    T: ComplexField,
     D: DimMin<D>,
-    DefaultAllocator: Allocator<N, D, D> + Allocator<(usize, usize), DimMinimum<D, D>>,
+    DefaultAllocator: Allocator<T, D, D> + Allocator<(usize, usize), DimMinimum<D, D>>,
 {
-    fn new(a: MatrixN<N, D>, use_exact_norm: bool) -> Self {
+    fn new(a: OMatrix<T, D, D>, use_exact_norm: bool) -> Self {
         let (nrows, ncols) = a.data.shape();
         ExpmPadeHelper {
             use_exact_norm,
-            ident: MatrixN::<N, D>::identity_generic(nrows, ncols),
+            ident: OMatrix::<T, D, D>::identity_generic(nrows, ncols),
             a,
             a2: None,
             a4: None,
@@ -112,7 +112,7 @@ where
         }
     }
 
-    fn d4_tight(&mut self) -> N::RealField {
+    fn d4_tight(&mut self) -> T::RealField {
         if self.d4_exact.is_none() {
             self.calc_a4();
             self.d4_exact = Some(one_norm(self.a4.as_ref().unwrap()).powf(convert(0.25)));
@@ -120,7 +120,7 @@ where
         self.d4_exact.unwrap()
     }
 
-    fn d6_tight(&mut self) -> N::RealField {
+    fn d6_tight(&mut self) -> T::RealField {
         if self.d6_exact.is_none() {
             self.calc_a6();
             self.d6_exact = Some(one_norm(self.a6.as_ref().unwrap()).powf(convert(1.0 / 6.0)));
@@ -128,7 +128,7 @@ where
         self.d6_exact.unwrap()
     }
 
-    fn d8_tight(&mut self) -> N::RealField {
+    fn d8_tight(&mut self) -> T::RealField {
         if self.d8_exact.is_none() {
             self.calc_a8();
             self.d8_exact = Some(one_norm(self.a8.as_ref().unwrap()).powf(convert(1.0 / 8.0)));
@@ -136,7 +136,7 @@ where
         self.d8_exact.unwrap()
     }
 
-    fn d10_tight(&mut self) -> N::RealField {
+    fn d10_tight(&mut self) -> T::RealField {
         if self.d10_exact.is_none() {
             self.calc_a10();
             self.d10_exact = Some(one_norm(self.a10.as_ref().unwrap()).powf(convert(1.0 / 10.0)));
@@ -144,7 +144,7 @@ where
         self.d10_exact.unwrap()
     }
 
-    fn d4_loose(&mut self) -> N::RealField {
+    fn d4_loose(&mut self) -> T::RealField {
         if self.use_exact_norm {
             return self.d4_tight();
         }
@@ -161,7 +161,7 @@ where
         self.d4_approx.unwrap()
     }
 
-    fn d6_loose(&mut self) -> N::RealField {
+    fn d6_loose(&mut self) -> T::RealField {
         if self.use_exact_norm {
             return self.d6_tight();
         }
@@ -178,7 +178,7 @@ where
         self.d6_approx.unwrap()
     }
 
-    fn d8_loose(&mut self) -> N::RealField {
+    fn d8_loose(&mut self) -> T::RealField {
         if self.use_exact_norm {
             return self.d8_tight();
         }
@@ -195,7 +195,7 @@ where
         self.d8_approx.unwrap()
     }
 
-    fn d10_loose(&mut self) -> N::RealField {
+    fn d10_loose(&mut self) -> T::RealField {
         if self.use_exact_norm {
             return self.d10_tight();
         }
@@ -212,8 +212,8 @@ where
         self.d10_approx.unwrap()
     }
 
-    fn pade3(&mut self) -> (MatrixN<N, D>, MatrixN<N, D>) {
-        let b: [N; 4] = [convert(120.0), convert(60.0), convert(12.0), convert(1.0)];
+    fn pade3(&mut self) -> (OMatrix<T, D, D>, OMatrix<T, D, D>) {
+        let b: [T; 4] = [convert(120.0), convert(60.0), convert(12.0), convert(1.0)];
         self.calc_a2();
         let a2 = self.a2.as_ref().unwrap();
         let u = &self.a * (a2 * b[3] + &self.ident * b[1]);
@@ -221,8 +221,8 @@ where
         (u, v)
     }
 
-    fn pade5(&mut self) -> (MatrixN<N, D>, MatrixN<N, D>) {
-        let b: [N; 6] = [
+    fn pade5(&mut self) -> (OMatrix<T, D, D>, OMatrix<T, D, D>) {
+        let b: [T; 6] = [
             convert(30240.0),
             convert(15120.0),
             convert(3360.0),
@@ -242,8 +242,8 @@ where
         (u, v)
     }
 
-    fn pade7(&mut self) -> (MatrixN<N, D>, MatrixN<N, D>) {
-        let b: [N; 8] = [
+    fn pade7(&mut self) -> (OMatrix<T, D, D>, OMatrix<T, D, D>) {
+        let b: [T; 8] = [
             convert(17_297_280.0),
             convert(8_648_640.0),
             convert(1_995_840.0),
@@ -268,8 +268,8 @@ where
         (u, v)
     }
 
-    fn pade9(&mut self) -> (MatrixN<N, D>, MatrixN<N, D>) {
-        let b: [N; 10] = [
+    fn pade9(&mut self) -> (OMatrix<T, D, D>, OMatrix<T, D, D>) {
+        let b: [T; 10] = [
             convert(17_643_225_600.0),
             convert(8_821_612_800.0),
             convert(2_075_673_600.0),
@@ -299,8 +299,8 @@ where
         (u, v)
     }
 
-    fn pade13_scaled(&mut self, s: u64) -> (MatrixN<N, D>, MatrixN<N, D>) {
-        let b: [N; 14] = [
+    fn pade13_scaled(&mut self, s: u64) -> (OMatrix<T, D, D>, OMatrix<T, D, D>) {
+        let b: [T; 14] = [
             convert(64_764_752_532_480_000.0),
             convert(32_382_376_266_240_000.0),
             convert(7_771_770_303_897_600.0),
@@ -318,13 +318,13 @@ where
         ];
         let s = s as f64;
 
-        let mb = &self.a * convert::<f64, N>(2.0_f64.powf(-s));
+        let mb = &self.a * convert::<f64, T>(2.0_f64.powf(-s));
         self.calc_a2();
         self.calc_a4();
         self.calc_a6();
-        let mb2 = self.a2.as_ref().unwrap() * convert::<f64, N>(2.0_f64.powf(-2.0 * s));
-        let mb4 = self.a4.as_ref().unwrap() * convert::<f64, N>(2.0.powf(-4.0 * s));
-        let mb6 = self.a6.as_ref().unwrap() * convert::<f64, N>(2.0.powf(-6.0 * s));
+        let mb2 = self.a2.as_ref().unwrap() * convert::<f64, T>(2.0_f64.powf(-2.0 * s));
+        let mb4 = self.a4.as_ref().unwrap() * convert::<f64, T>(2.0.powf(-4.0 * s));
+        let mb6 = self.a6.as_ref().unwrap() * convert::<f64, T>(2.0.powf(-6.0 * s));
 
         let u2 = &mb6 * (&mb6 * b[13] + &mb4 * b[11] + &mb2 * b[9]);
         let u = &mb * (&u2 + &mb6 * b[7] + &mb4 * b[5] + &mb2 * b[3] + &self.ident * b[1]);
@@ -342,14 +342,14 @@ fn factorial(n: u128) -> u128 {
 }
 
 /// Compute the 1-norm of a non-negative integer power of a non-negative matrix.
-fn onenorm_matrix_power_nonm<N, D>(a: &MatrixN<N, D>, p: u64) -> N
+fn onenorm_matrix_power_nonm<T, D>(a: &OMatrix<T, D, D>, p: u64) -> T
 where
-    N: RealField,
+    T: RealField,
     D: Dim,
-    DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>,
+    DefaultAllocator: Allocator<T, D, D> + Allocator<T, D>,
 {
     let nrows = a.data.shape().0;
-    let mut v = crate::VectorN::<N, D>::repeat_generic(nrows, U1, convert(1.0));
+    let mut v = crate::OVector::<T, D>::repeat_generic(nrows, Const::<1>, convert(1.0));
     let m = a.transpose();
 
     for _ in 0..p {
@@ -359,14 +359,14 @@ where
     v.max()
 }
 
-fn ell<N, D>(a: &MatrixN<N, D>, m: u64) -> u64
+fn ell<T, D>(a: &OMatrix<T, D, D>, m: u64) -> u64
 where
-    N: ComplexField,
+    T: ComplexField,
     D: Dim,
-    DefaultAllocator: Allocator<N, D, D>
-        + Allocator<N, D>
-        + Allocator<N::RealField, D>
-        + Allocator<N::RealField, D, D>,
+    DefaultAllocator: Allocator<T, D, D>
+        + Allocator<T, D>
+        + Allocator<T::RealField, D>
+        + Allocator<T::RealField, D, D>,
 {
     // 2m choose m = (2m)!/(m! * (2m-m)!)
 
@@ -374,7 +374,7 @@ where
 
     let a_abs_onenorm = onenorm_matrix_power_nonm(&a_abs, 2 * m + 1);
 
-    if a_abs_onenorm == <N as ComplexField>::RealField::zero() {
+    if a_abs_onenorm == <T as ComplexField>::RealField::zero() {
         return 0;
     }
 
@@ -394,11 +394,11 @@ where
     }
 }
 
-fn solve_p_q<N, D>(u: MatrixN<N, D>, v: MatrixN<N, D>) -> MatrixN<N, D>
+fn solve_p_q<T, D>(u: OMatrix<T, D, D>, v: OMatrix<T, D, D>) -> OMatrix<T, D, D>
 where
-    N: ComplexField,
+    T: ComplexField,
     D: DimMin<D, Output = D>,
-    DefaultAllocator: Allocator<N, D, D> + Allocator<(usize, usize), DimMinimum<D, D>>,
+    DefaultAllocator: Allocator<T, D, D> + Allocator<(usize, usize), DimMinimum<D, D>>,
 {
     let p = &u + &v;
     let q = &v - &u;
@@ -406,33 +406,33 @@ where
     q.lu().solve(&p).unwrap()
 }
 
-fn one_norm<N, D>(m: &MatrixN<N, D>) -> N::RealField
+fn one_norm<T, D>(m: &OMatrix<T, D, D>) -> T::RealField
 where
-    N: ComplexField,
+    T: ComplexField,
     D: Dim,
-    DefaultAllocator: Allocator<N, D, D>,
+    DefaultAllocator: Allocator<T, D, D>,
 {
-    let mut max = <N as ComplexField>::RealField::zero();
+    let mut max = <T as ComplexField>::RealField::zero();
 
     for i in 0..m.ncols() {
         let col = m.column(i);
         max = max.max(
             col.iter()
-                .fold(<N as ComplexField>::RealField::zero(), |a, b| a + b.abs()),
+                .fold(<T as ComplexField>::RealField::zero(), |a, b| a + b.abs()),
         );
     }
 
     max
 }
 
-impl<N: ComplexField, D> MatrixN<N, D>
+impl<T: ComplexField, D> OMatrix<T, D, D>
 where
     D: DimMin<D, Output = D>,
-    DefaultAllocator: Allocator<N, D, D>
+    DefaultAllocator: Allocator<T, D, D>
         + Allocator<(usize, usize), DimMinimum<D, D>>
-        + Allocator<N, D>
-        + Allocator<N::RealField, D>
-        + Allocator<N::RealField, D, D>,
+        + Allocator<T, D>
+        + Allocator<T::RealField, D>
+        + Allocator<T::RealField, D, D>,
 {
     /// Computes exponential of this matrix
     pub fn exp(&self) -> Self {
@@ -443,19 +443,19 @@ where
 
         let mut h = ExpmPadeHelper::new(self.clone(), true);
 
-        let eta_1 = N::RealField::max(h.d4_loose(), h.d6_loose());
+        let eta_1 = T::RealField::max(h.d4_loose(), h.d6_loose());
         if eta_1 < convert(1.495_585_217_958_292e-2) && ell(&h.a, 3) == 0 {
             let (u, v) = h.pade3();
             return solve_p_q(u, v);
         }
 
-        let eta_2 = N::RealField::max(h.d4_tight(), h.d6_loose());
+        let eta_2 = T::RealField::max(h.d4_tight(), h.d6_loose());
         if eta_2 < convert(2.539_398_330_063_230e-1) && ell(&h.a, 5) == 0 {
             let (u, v) = h.pade5();
             return solve_p_q(u, v);
         }
 
-        let eta_3 = N::RealField::max(h.d6_tight(), h.d8_loose());
+        let eta_3 = T::RealField::max(h.d6_tight(), h.d8_loose());
         if eta_3 < convert(9.504_178_996_162_932e-1) && ell(&h.a, 7) == 0 {
             let (u, v) = h.pade7();
             return solve_p_q(u, v);
@@ -465,11 +465,11 @@ where
             return solve_p_q(u, v);
         }
 
-        let eta_4 = N::RealField::max(h.d8_loose(), h.d10_loose());
-        let eta_5 = N::RealField::min(eta_3, eta_4);
+        let eta_4 = T::RealField::max(h.d8_loose(), h.d10_loose());
+        let eta_5 = T::RealField::min(eta_3, eta_4);
         let theta_13 = convert(4.25);
 
-        let mut s = if eta_5 == N::RealField::zero() {
+        let mut s = if eta_5 == T::RealField::zero() {
             0
         } else {
             let l2 = try_convert((eta_5 / theta_13).log2().ceil()).unwrap();
@@ -481,7 +481,7 @@ where
             }
         };
 
-        s += ell(&(&h.a * convert::<f64, N>(2.0_f64.powf(-(s as f64)))), 13);
+        s += ell(&(&h.a * convert::<f64, T>(2.0_f64.powf(-(s as f64)))), 13);
 
         let (u, v) = h.pade13_scaled(s);
         let mut x = solve_p_q(u, v);
diff --git a/src/linalg/full_piv_lu.rs b/src/linalg/full_piv_lu.rs
index fb8ff670..ae14f827 100644
--- a/src/linalg/full_piv_lu.rs
+++ b/src/linalg/full_piv_lu.rs
@@ -2,7 +2,7 @@
 use serde::{Deserialize, Serialize};
 
 use crate::allocator::Allocator;
-use crate::base::{DefaultAllocator, Matrix, MatrixMN, MatrixN};
+use crate::base::{DefaultAllocator, Matrix, OMatrix};
 use crate::constraint::{SameNumberOfRows, ShapeConstraint};
 use crate::dimension::{Dim, DimMin, DimMinimum};
 use crate::storage::{Storage, StorageMut};
@@ -15,44 +15,44 @@ use crate::linalg::PermutationSequence;
 #[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
 #[cfg_attr(
     feature = "serde-serialize",
-    serde(bound(serialize = "DefaultAllocator: Allocator<N, R, C> +
+    serde(bound(serialize = "DefaultAllocator: Allocator<T, R, C> +
                            Allocator<(usize, usize), DimMinimum<R, C>>,
-         MatrixMN<N, R, C>: Serialize,
+         OMatrix<T, R, C>: Serialize,
          PermutationSequence<DimMinimum<R, C>>: Serialize"))
 )]
 #[cfg_attr(
     feature = "serde-serialize",
-    serde(bound(deserialize = "DefaultAllocator: Allocator<N, R, C> +
+    serde(bound(deserialize = "DefaultAllocator: Allocator<T, R, C> +
                            Allocator<(usize, usize), DimMinimum<R, C>>,
-         MatrixMN<N, R, C>: Deserialize<'de>,
+         OMatrix<T, R, C>: Deserialize<'de>,
          PermutationSequence<DimMinimum<R, C>>: Deserialize<'de>"))
 )]
 #[derive(Clone, Debug)]
-pub struct FullPivLU<N: ComplexField, R: DimMin<C>, C: Dim>
+pub struct FullPivLU<T: ComplexField, R: DimMin<C>, C: Dim>
 where
-    DefaultAllocator: Allocator<N, R, C> + Allocator<(usize, usize), DimMinimum<R, C>>,
+    DefaultAllocator: Allocator<T, R, C> + Allocator<(usize, usize), DimMinimum<R, C>>,
 {
-    lu: MatrixMN<N, R, C>,
+    lu: OMatrix<T, R, C>,
     p: PermutationSequence<DimMinimum<R, C>>,
     q: PermutationSequence<DimMinimum<R, C>>,
 }
 
-impl<N: ComplexField, R: DimMin<C>, C: Dim> Copy for FullPivLU<N, R, C>
+impl<T: ComplexField, R: DimMin<C>, C: Dim> Copy for FullPivLU<T, R, C>
 where
-    DefaultAllocator: Allocator<N, R, C> + Allocator<(usize, usize), DimMinimum<R, C>>,
-    MatrixMN<N, R, C>: Copy,
+    DefaultAllocator: Allocator<T, R, C> + Allocator<(usize, usize), DimMinimum<R, C>>,
+    OMatrix<T, R, C>: Copy,
     PermutationSequence<DimMinimum<R, C>>: Copy,
 {
 }
 
-impl<N: ComplexField, R: DimMin<C>, C: Dim> FullPivLU<N, R, C>
+impl<T: ComplexField, R: DimMin<C>, C: Dim> FullPivLU<T, R, C>
 where
-    DefaultAllocator: Allocator<N, R, C> + Allocator<(usize, usize), DimMinimum<R, C>>,
+    DefaultAllocator: Allocator<T, R, C> + Allocator<(usize, usize), DimMinimum<R, C>>,
 {
     /// Computes the LU decomposition with full pivoting of `matrix`.
     ///
     /// This effectively computes `P, L, U, Q` such that `P * matrix * Q = LU`.
-    pub fn new(mut matrix: MatrixMN<N, R, C>) -> Self {
+    pub fn new(mut matrix: OMatrix<T, R, C>) -> Self {
         let (nrows, ncols) = matrix.data.shape();
         let min_nrows_ncols = nrows.min(ncols);
 
@@ -90,28 +90,28 @@ where
     }
 
     #[doc(hidden)]
-    pub fn lu_internal(&self) -> &MatrixMN<N, R, C> {
+    pub fn lu_internal(&self) -> &OMatrix<T, R, C> {
         &self.lu
     }
 
     /// The lower triangular matrix of this decomposition.
     #[inline]
-    pub fn l(&self) -> MatrixMN<N, R, DimMinimum<R, C>>
+    pub fn l(&self) -> OMatrix<T, R, DimMinimum<R, C>>
     where
-        DefaultAllocator: Allocator<N, R, DimMinimum<R, C>>,
+        DefaultAllocator: Allocator<T, R, DimMinimum<R, C>>,
     {
         let (nrows, ncols) = self.lu.data.shape();
         let mut m = self.lu.columns_generic(0, nrows.min(ncols)).into_owned();
-        m.fill_upper_triangle(N::zero(), 1);
-        m.fill_diagonal(N::one());
+        m.fill_upper_triangle(T::zero(), 1);
+        m.fill_diagonal(T::one());
         m
     }
 
     /// The upper triangular matrix of this decomposition.
     #[inline]
-    pub fn u(&self) -> MatrixMN<N, DimMinimum<R, C>, C>
+    pub fn u(&self) -> OMatrix<T, DimMinimum<R, C>, C>
     where
-        DefaultAllocator: Allocator<N, DimMinimum<R, C>, C>,
+        DefaultAllocator: Allocator<T, DimMinimum<R, C>, C>,
     {
         let (nrows, ncols) = self.lu.data.shape();
         self.lu.rows_generic(0, nrows.min(ncols)).upper_triangle()
@@ -135,12 +135,12 @@ where
         self,
     ) -> (
         PermutationSequence<DimMinimum<R, C>>,
-        MatrixMN<N, R, DimMinimum<R, C>>,
-        MatrixMN<N, DimMinimum<R, C>, C>,
+        OMatrix<T, R, DimMinimum<R, C>>,
+        OMatrix<T, DimMinimum<R, C>, C>,
         PermutationSequence<DimMinimum<R, C>>,
     )
     where
-        DefaultAllocator: Allocator<N, R, DimMinimum<R, C>> + Allocator<N, DimMinimum<R, C>, C>,
+        DefaultAllocator: Allocator<T, R, DimMinimum<R, C>> + Allocator<T, DimMinimum<R, C>, C>,
     {
         // Use reallocation for either l or u.
         let l = self.l();
@@ -152,21 +152,21 @@ where
     }
 }
 
-impl<N: ComplexField, D: DimMin<D, Output = D>> FullPivLU<N, D, D>
+impl<T: ComplexField, D: DimMin<D, Output = D>> FullPivLU<T, D, D>
 where
-    DefaultAllocator: Allocator<N, D, D> + Allocator<(usize, usize), D>,
+    DefaultAllocator: Allocator<T, D, D> + Allocator<(usize, usize), D>,
 {
     /// Solves the linear system `self * x = b`, where `x` is the unknown to be determined.
     ///
     /// Returns `None` if the decomposed matrix is not invertible.
     pub fn solve<R2: Dim, C2: Dim, S2>(
         &self,
-        b: &Matrix<N, R2, C2, S2>,
-    ) -> Option<MatrixMN<N, R2, C2>>
+        b: &Matrix<T, R2, C2, S2>,
+    ) -> Option<OMatrix<T, R2, C2>>
     where
-        S2: Storage<N, R2, C2>,
+        S2: Storage<T, R2, C2>,
         ShapeConstraint: SameNumberOfRows<R2, D>,
-        DefaultAllocator: Allocator<N, R2, C2>,
+        DefaultAllocator: Allocator<T, R2, C2>,
     {
         let mut res = b.clone_owned();
         if self.solve_mut(&mut res) {
@@ -180,9 +180,9 @@ where
     ///
     /// If the decomposed matrix is not invertible, this returns `false` and its input `b` may
     /// be overwritten with garbage.
-    pub fn solve_mut<R2: Dim, C2: Dim, S2>(&self, b: &mut Matrix<N, R2, C2, S2>) -> bool
+    pub fn solve_mut<R2: Dim, C2: Dim, S2>(&self, b: &mut Matrix<T, R2, C2, S2>) -> bool
     where
-        S2: StorageMut<N, R2, C2>,
+        S2: StorageMut<T, R2, C2>,
         ShapeConstraint: SameNumberOfRows<R2, D>,
     {
         assert_eq!(
@@ -197,7 +197,7 @@ where
 
         if self.is_invertible() {
             self.p.permute_rows(b);
-            let _ = self.lu.solve_lower_triangular_with_diag_mut(b, N::one());
+            let _ = self.lu.solve_lower_triangular_with_diag_mut(b, T::one());
             let _ = self.lu.solve_upper_triangular_mut(b);
             self.q.inv_permute_rows(b);
 
@@ -210,7 +210,7 @@ where
     /// Computes the inverse of the decomposed matrix.
     ///
     /// Returns `None` if the decomposed matrix is not invertible.
-    pub fn try_inverse(&self) -> Option<MatrixN<N, D>> {
+    pub fn try_inverse(&self) -> Option<OMatrix<T, D, D>> {
         assert!(
             self.lu.is_square(),
             "FullPivLU inverse: unable to compute the inverse of a non-square matrix."
@@ -218,7 +218,7 @@ where
 
         let (nrows, ncols) = self.lu.data.shape();
 
-        let mut res = MatrixN::identity_generic(nrows, ncols);
+        let mut res = OMatrix::identity_generic(nrows, ncols);
         if self.solve_mut(&mut res) {
             Some(res)
         } else {
@@ -238,7 +238,7 @@ where
     }
 
     /// Computes the determinant of the decomposed matrix.
-    pub fn determinant(&self) -> N {
+    pub fn determinant(&self) -> T {
         assert!(
             self.lu.is_square(),
             "FullPivLU determinant: unable to compute the determinant of a non-square matrix."
@@ -253,7 +253,7 @@ where
 
             res * self.p.determinant() * self.q.determinant()
         } else {
-            N::zero()
+            T::zero()
         }
     }
 }
diff --git a/src/linalg/givens.rs b/src/linalg/givens.rs
index 32a4204e..6073634e 100644
--- a/src/linalg/givens.rs
+++ b/src/linalg/givens.rs
@@ -10,18 +10,18 @@ use crate::base::{Matrix, Vector};
 
 /// A Givens rotation.
 #[derive(Debug, Clone, Copy)]
-pub struct GivensRotation<N: ComplexField> {
-    c: N::RealField,
-    s: N,
+pub struct GivensRotation<T: ComplexField> {
+    c: T::RealField,
+    s: T,
 }
 
 // Matrix = UnitComplex * Matrix
-impl<N: ComplexField> GivensRotation<N> {
+impl<T: ComplexField> GivensRotation<T> {
     /// The Givents rotation that does nothing.
     pub fn identity() -> Self {
         Self {
-            c: N::RealField::one(),
-            s: N::zero(),
+            c: T::RealField::one(),
+            s: T::zero(),
         }
     }
 
@@ -29,18 +29,18 @@ impl<N: ComplexField> GivensRotation<N> {
     ///
     /// The components are copies as-is. It is not checked whether they describe
     /// an actually valid Givens rotation.
-    pub fn new_unchecked(c: N::RealField, s: N) -> Self {
+    pub fn new_unchecked(c: T::RealField, s: T) -> Self {
         Self { c, s }
     }
 
     /// Initializes a Givens rotation from its non-normalized cosine an sine components.
-    pub fn new(c: N, s: N) -> (Self, N) {
-        Self::try_new(c, s, N::RealField::zero())
-            .unwrap_or_else(|| (GivensRotation::identity(), N::zero()))
+    pub fn new(c: T, s: T) -> (Self, T) {
+        Self::try_new(c, s, T::RealField::zero())
+            .unwrap_or_else(|| (GivensRotation::identity(), T::zero()))
     }
 
     /// Initializes a Givens rotation form its non-normalized cosine an sine components.
-    pub fn try_new(c: N, s: N, eps: N::RealField) -> Option<(Self, N)> {
+    pub fn try_new(c: T, s: T, eps: T::RealField) -> Option<(Self, T)> {
         let (mod0, sign0) = c.to_exp();
         let denom = (mod0 * mod0 + s.modulus_squared()).sqrt();
 
@@ -58,7 +58,7 @@ impl<N: ComplexField> GivensRotation<N> {
     ///
     /// Returns `None` if no rotation is needed (i.e. if `v.y == 0`). Otherwise, this returns the norm
     /// of `v` and the rotation `r` such that `R * v = [ |v|, 0.0 ]^t` where `|v|` is the norm of `v`.
-    pub fn cancel_y<S: Storage<N, U2>>(v: &Vector<N, U2, S>) -> Option<(Self, N)> {
+    pub fn cancel_y<S: Storage<T, U2>>(v: &Vector<T, U2, S>) -> Option<(Self, T)> {
         if !v[1].is_zero() {
             let (mod0, sign0) = v[0].to_exp();
             let denom = (mod0 * mod0 + v[1].modulus_squared()).sqrt();
@@ -75,7 +75,7 @@ impl<N: ComplexField> GivensRotation<N> {
     ///
     /// Returns `None` if no rotation is needed (i.e. if `v.x == 0`). Otherwise, this returns the norm
     /// of `v` and the rotation `r` such that `R * v = [ 0.0, |v| ]^t` where `|v|` is the norm of `v`.
-    pub fn cancel_x<S: Storage<N, U2>>(v: &Vector<N, U2, S>) -> Option<(Self, N)> {
+    pub fn cancel_x<S: Storage<T, U2>>(v: &Vector<T, U2, S>) -> Option<(Self, T)> {
         if !v[0].is_zero() {
             let (mod1, sign1) = v[1].to_exp();
             let denom = (mod1 * mod1 + v[0].modulus_squared()).sqrt();
@@ -89,12 +89,12 @@ impl<N: ComplexField> GivensRotation<N> {
     }
 
     /// The cos part of this roration.
-    pub fn c(&self) -> N::RealField {
+    pub fn c(&self) -> T::RealField {
         self.c
     }
 
     /// The sin part of this roration.
-    pub fn s(&self) -> N {
+    pub fn s(&self) -> T {
         self.s
     }
 
@@ -107,9 +107,9 @@ impl<N: ComplexField> GivensRotation<N> {
     }
 
     /// Performs the multiplication `rhs = self * rhs` in-place.
-    pub fn rotate<R2: Dim, C2: Dim, S2: StorageMut<N, R2, C2>>(
+    pub fn rotate<R2: Dim, C2: Dim, S2: StorageMut<T, R2, C2>>(
         &self,
-        rhs: &mut Matrix<N, R2, C2, S2>,
+        rhs: &mut Matrix<T, R2, C2, S2>,
     ) where
         ShapeConstraint: DimEq<R2, U2>,
     {
@@ -133,9 +133,9 @@ impl<N: ComplexField> GivensRotation<N> {
     }
 
     /// Performs the multiplication `lhs = lhs * self` in-place.
-    pub fn rotate_rows<R2: Dim, C2: Dim, S2: StorageMut<N, R2, C2>>(
+    pub fn rotate_rows<R2: Dim, C2: Dim, S2: StorageMut<T, R2, C2>>(
         &self,
-        lhs: &mut Matrix<N, R2, C2, S2>,
+        lhs: &mut Matrix<T, R2, C2, S2>,
     ) where
         ShapeConstraint: DimEq<C2, U2>,
     {
diff --git a/src/linalg/hessenberg.rs b/src/linalg/hessenberg.rs
index ac3e82b8..09a7d180 100644
--- a/src/linalg/hessenberg.rs
+++ b/src/linalg/hessenberg.rs
@@ -2,8 +2,8 @@
 use serde::{Deserialize, Serialize};
 
 use crate::allocator::Allocator;
-use crate::base::{DefaultAllocator, MatrixN, VectorN};
-use crate::dimension::{DimDiff, DimSub, U1};
+use crate::base::{DefaultAllocator, OMatrix, OVector};
+use crate::dimension::{Const, DimDiff, DimSub, U1};
 use crate::storage::Storage;
 use simba::scalar::ComplexField;
 
@@ -13,43 +13,44 @@ use crate::linalg::householder;
 #[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
 #[cfg_attr(
     feature = "serde-serialize",
-    serde(bound(serialize = "DefaultAllocator: Allocator<N, D, D> +
-                           Allocator<N, DimDiff<D, U1>>,
-         MatrixN<N, D>: Serialize,
-         VectorN<N, DimDiff<D, U1>>: Serialize"))
+    serde(bound(serialize = "DefaultAllocator: Allocator<T, D, D> +
+                           Allocator<T, DimDiff<D, U1>>,
+         OMatrix<T, D, D>: Serialize,
+         OVector<T, DimDiff<D, U1>>: Serialize"))
 )]
 #[cfg_attr(
     feature = "serde-serialize",
-    serde(bound(deserialize = "DefaultAllocator: Allocator<N, D, D> +
-                           Allocator<N, DimDiff<D, U1>>,
-         MatrixN<N, D>: Deserialize<'de>,
-         VectorN<N, DimDiff<D, U1>>: Deserialize<'de>"))
+    serde(bound(deserialize = "DefaultAllocator: Allocator<T, D, D> +
+                           Allocator<T, DimDiff<D, U1>>,
+         OMatrix<T, D, D>: Deserialize<'de>,
+         OVector<T, DimDiff<D, U1>>: Deserialize<'de>"))
 )]
 #[derive(Clone, Debug)]
-pub struct Hessenberg<N: ComplexField, D: DimSub<U1>>
+pub struct Hessenberg<T: ComplexField, D: DimSub<U1>>
 where
-    DefaultAllocator: Allocator<N, D, D> + Allocator<N, DimDiff<D, U1>>,
+    DefaultAllocator: Allocator<T, D, D> + Allocator<T, DimDiff<D, U1>>,
 {
-    hess: MatrixN<N, D>,
-    subdiag: VectorN<N, DimDiff<D, U1>>,
+    hess: OMatrix<T, D, D>,
+    subdiag: OVector<T, DimDiff<D, U1>>,
 }
 
-impl<N: ComplexField, D: DimSub<U1>> Copy for Hessenberg<N, D>
+impl<T: ComplexField, D: DimSub<U1>> Copy for Hessenberg<T, D>
 where
-    DefaultAllocator: Allocator<N, D, D> + Allocator<N, DimDiff<D, U1>>,
-    MatrixN<N, D>: Copy,
-    VectorN<N, DimDiff<D, U1>>: Copy,
+    DefaultAllocator: Allocator<T, D, D> + Allocator<T, DimDiff<D, U1>>,
+    OMatrix<T, D, D>: Copy,
+    OVector<T, DimDiff<D, U1>>: Copy,
 {
 }
 
-impl<N: ComplexField, D: DimSub<U1>> Hessenberg<N, D>
+impl<T: ComplexField, D: DimSub<U1>> Hessenberg<T, D>
 where
-    DefaultAllocator: Allocator<N, D, D> + Allocator<N, D> + Allocator<N, DimDiff<D, U1>>,
+    DefaultAllocator: Allocator<T, D, D> + Allocator<T, D> + Allocator<T, DimDiff<D, U1>>,
 {
     /// Computes the Hessenberg decomposition using householder reflections.
-    pub fn new(hess: MatrixN<N, D>) -> Self {
-        let mut work =
-            unsafe { crate::unimplemented_or_uninitialized_generic!(hess.data.shape().0, U1) };
+    pub fn new(hess: OMatrix<T, D, D>) -> Self {
+        let mut work = unsafe {
+            crate::unimplemented_or_uninitialized_generic!(hess.data.shape().0, Const::<1>)
+        };
         Self::new_with_workspace(hess, &mut work)
     }
 
@@ -57,7 +58,7 @@ where
     ///
     /// The workspace containing `D` elements must be provided but its content does not have to be
     /// initialized.
-    pub fn new_with_workspace(mut hess: MatrixN<N, D>, work: &mut VectorN<N, D>) -> Self {
+    pub fn new_with_workspace(mut hess: OMatrix<T, D, D>, work: &mut OVector<T, D>) -> Self {
         assert!(
             hess.is_square(),
             "Cannot compute the hessenberg decomposition of a non-square matrix."
@@ -75,8 +76,9 @@ where
             "Hessenberg: invalid workspace size."
         );
 
-        let mut subdiag =
-            unsafe { crate::unimplemented_or_uninitialized_generic!(dim.sub(U1), U1) };
+        let mut subdiag = unsafe {
+            crate::unimplemented_or_uninitialized_generic!(dim.sub(Const::<1>), Const::<1>)
+        };
 
         if dim.value() == 0 {
             return Hessenberg { hess, subdiag };
@@ -92,7 +94,7 @@ where
     /// Retrieves `(q, h)` with `q` the orthogonal matrix of this decomposition and `h` the
     /// hessenberg matrix.
     #[inline]
-    pub fn unpack(self) -> (MatrixN<N, D>, MatrixN<N, D>) {
+    pub fn unpack(self) -> (OMatrix<T, D, D>, OMatrix<T, D, D>) {
         let q = self.q();
 
         (q, self.unpack_h())
@@ -100,12 +102,12 @@ where
 
     /// Retrieves the upper trapezoidal submatrix `H` of this decomposition.
     #[inline]
-    pub fn unpack_h(mut self) -> MatrixN<N, D> {
+    pub fn unpack_h(mut self) -> OMatrix<T, D, D> {
         let dim = self.hess.nrows();
-        self.hess.fill_lower_triangle(N::zero(), 2);
+        self.hess.fill_lower_triangle(T::zero(), 2);
         self.hess
             .slice_mut((1, 0), (dim - 1, dim - 1))
-            .set_partial_diagonal(self.subdiag.iter().map(|e| N::from_real(e.modulus())));
+            .set_partial_diagonal(self.subdiag.iter().map(|e| T::from_real(e.modulus())));
         self.hess
     }
 
@@ -114,22 +116,22 @@ where
     ///
     /// This is less efficient than `.unpack_h()` as it allocates a new matrix.
     #[inline]
-    pub fn h(&self) -> MatrixN<N, D> {
+    pub fn h(&self) -> OMatrix<T, D, D> {
         let dim = self.hess.nrows();
         let mut res = self.hess.clone();
-        res.fill_lower_triangle(N::zero(), 2);
+        res.fill_lower_triangle(T::zero(), 2);
         res.slice_mut((1, 0), (dim - 1, dim - 1))
-            .set_partial_diagonal(self.subdiag.iter().map(|e| N::from_real(e.modulus())));
+            .set_partial_diagonal(self.subdiag.iter().map(|e| T::from_real(e.modulus())));
         res
     }
 
     /// Computes the orthogonal matrix `Q` of this decomposition.
-    pub fn q(&self) -> MatrixN<N, D> {
+    pub fn q(&self) -> OMatrix<T, D, D> {
         householder::assemble_q(&self.hess, self.subdiag.as_slice())
     }
 
     #[doc(hidden)]
-    pub fn hess_internal(&self) -> &MatrixN<N, D> {
+    pub fn hess_internal(&self) -> &OMatrix<T, D, D> {
         &self.hess
     }
 }
diff --git a/src/linalg/householder.rs b/src/linalg/householder.rs
index ebbffd30..fbb24e77 100644
--- a/src/linalg/householder.rs
+++ b/src/linalg/householder.rs
@@ -1,7 +1,7 @@
 //! Construction of householder elementary reflections.
 
 use crate::allocator::Allocator;
-use crate::base::{DefaultAllocator, MatrixMN, MatrixN, Unit, Vector, VectorN};
+use crate::base::{DefaultAllocator, OMatrix, OVector, Unit, Vector};
 use crate::dimension::Dim;
 use crate::storage::{Storage, StorageMut};
 use num::Zero;
@@ -16,9 +16,9 @@ use crate::geometry::Reflection;
 /// `column` after reflection and `false` if no reflection was necessary.
 #[doc(hidden)]
 #[inline(always)]
-pub fn reflection_axis_mut<N: ComplexField, D: Dim, S: StorageMut<N, D>>(
-    column: &mut Vector<N, D, S>,
-) -> (N, bool) {
+pub fn reflection_axis_mut<T: ComplexField, D: Dim, S: StorageMut<T, D>>(
+    column: &mut Vector<T, D, S>,
+) -> (T, bool) {
     let reflection_sq_norm = column.norm_squared();
     let reflection_norm = reflection_sq_norm.sqrt();
 
@@ -44,14 +44,14 @@ pub fn reflection_axis_mut<N: ComplexField, D: Dim, S: StorageMut<N, D>>(
 /// Uses an householder reflection to zero out the `icol`-th column, starting with the `shift + 1`-th
 /// subdiagonal element.
 #[doc(hidden)]
-pub fn clear_column_unchecked<N: ComplexField, R: Dim, C: Dim>(
-    matrix: &mut MatrixMN<N, R, C>,
-    diag_elt: &mut N,
+pub fn clear_column_unchecked<T: ComplexField, R: Dim, C: Dim>(
+    matrix: &mut OMatrix<T, R, C>,
+    diag_elt: &mut T,
     icol: usize,
     shift: usize,
-    bilateral: Option<&mut VectorN<N, R>>,
+    bilateral: Option<&mut OVector<T, R>>,
 ) where
-    DefaultAllocator: Allocator<N, R, C> + Allocator<N, R>,
+    DefaultAllocator: Allocator<T, R, C> + Allocator<T, R>,
 {
     let (mut left, mut right) = matrix.columns_range_pair_mut(icol, icol + 1..);
     let mut axis = left.rows_range_mut(icol + shift..);
@@ -60,7 +60,7 @@ pub fn clear_column_unchecked<N: ComplexField, R: Dim, C: Dim>(
     *diag_elt = reflection_norm;
 
     if not_zero {
-        let refl = Reflection::new(Unit::new_unchecked(axis), N::zero());
+        let refl = Reflection::new(Unit::new_unchecked(axis), T::zero());
         let sign = reflection_norm.signum();
         if let Some(mut work) = bilateral {
             refl.reflect_rows_with_sign(&mut right, &mut work, sign);
@@ -72,15 +72,15 @@ pub fn clear_column_unchecked<N: ComplexField, R: Dim, C: Dim>(
 /// Uses an householder reflection to zero out the `irow`-th row, ending before the `shift + 1`-th
 /// superdiagonal element.
 #[doc(hidden)]
-pub fn clear_row_unchecked<N: ComplexField, R: Dim, C: Dim>(
-    matrix: &mut MatrixMN<N, R, C>,
-    diag_elt: &mut N,
-    axis_packed: &mut VectorN<N, C>,
-    work: &mut VectorN<N, R>,
+pub fn clear_row_unchecked<T: ComplexField, R: Dim, C: Dim>(
+    matrix: &mut OMatrix<T, R, C>,
+    diag_elt: &mut T,
+    axis_packed: &mut OVector<T, C>,
+    work: &mut OVector<T, R>,
     irow: usize,
     shift: usize,
 ) where
-    DefaultAllocator: Allocator<N, R, C> + Allocator<N, R> + Allocator<N, C>,
+    DefaultAllocator: Allocator<T, R, C> + Allocator<T, R> + Allocator<T, C>,
 {
     let (mut top, mut bottom) = matrix.rows_range_pair_mut(irow, irow + 1..);
     let mut axis = axis_packed.rows_range_mut(irow + shift..);
@@ -91,7 +91,7 @@ pub fn clear_row_unchecked<N: ComplexField, R: Dim, C: Dim>(
     *diag_elt = reflection_norm;
 
     if not_zero {
-        let refl = Reflection::new(Unit::new_unchecked(axis), N::zero());
+        let refl = Reflection::new(Unit::new_unchecked(axis), T::zero());
         refl.reflect_rows_with_sign(
             &mut bottom.columns_range_mut(irow + shift..),
             &mut work.rows_range_mut(irow + 1..),
@@ -108,20 +108,20 @@ pub fn clear_row_unchecked<N: ComplexField, R: Dim, C: Dim>(
 /// the lower-diagonal element of the given matrix.
 /// matrices.
 #[doc(hidden)]
-pub fn assemble_q<N: ComplexField, D: Dim>(m: &MatrixN<N, D>, signs: &[N]) -> MatrixN<N, D>
+pub fn assemble_q<T: ComplexField, D: Dim>(m: &OMatrix<T, D, D>, signs: &[T]) -> OMatrix<T, D, D>
 where
-    DefaultAllocator: Allocator<N, D, D>,
+    DefaultAllocator: Allocator<T, D, D>,
 {
     assert!(m.is_square());
     let dim = m.data.shape().0;
 
     // NOTE: we could build the identity matrix and call p_mult on it.
     // Instead we don't so that we take in account the matrix sparseness.
-    let mut res = MatrixN::identity_generic(dim, dim);
+    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 refl = Reflection::new(Unit::new_unchecked(axis), N::zero());
+        let refl = Reflection::new(Unit::new_unchecked(axis), T::zero());
 
         let mut res_rows = res.slice_range_mut(i + 1.., i..);
         refl.reflect_with_sign(&mut res_rows, signs[i].signum());
diff --git a/src/linalg/inverse.rs b/src/linalg/inverse.rs
index 2cb10351..f56a95ec 100644
--- a/src/linalg/inverse.rs
+++ b/src/linalg/inverse.rs
@@ -3,17 +3,17 @@ use simba::scalar::ComplexField;
 use crate::base::allocator::Allocator;
 use crate::base::dimension::Dim;
 use crate::base::storage::{Storage, StorageMut};
-use crate::base::{DefaultAllocator, MatrixN, SquareMatrix};
+use crate::base::{DefaultAllocator, OMatrix, SquareMatrix};
 
 use crate::linalg::lu;
 
-impl<N: ComplexField, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
+impl<T: ComplexField, D: Dim, S: Storage<T, D, D>> SquareMatrix<T, D, S> {
     /// Attempts to invert this matrix.
     #[inline]
     #[must_use = "Did you mean to use try_inverse_mut()?"]
-    pub fn try_inverse(self) -> Option<MatrixN<N, D>>
+    pub fn try_inverse(self) -> Option<OMatrix<T, D, D>>
     where
-        DefaultAllocator: Allocator<N, D, D>,
+        DefaultAllocator: Allocator<T, D, D>,
     {
         let mut me = self.into_owned();
         if me.try_inverse_mut() {
@@ -24,13 +24,13 @@ impl<N: ComplexField, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
     }
 }
 
-impl<N: ComplexField, D: Dim, S: StorageMut<N, D, D>> SquareMatrix<N, 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.
     #[inline]
     pub fn try_inverse_mut(&mut self) -> bool
     where
-        DefaultAllocator: Allocator<N, D, D>,
+        DefaultAllocator: Allocator<T, D, D>,
     {
         assert!(self.is_square(), "Unable to invert a non-square matrix.");
 
@@ -44,7 +44,7 @@ impl<N: ComplexField, D: Dim, S: StorageMut<N, D, D>> SquareMatrix<N, D, S> {
                     if determinant.is_zero() {
                         false
                     } else {
-                        *self.get_unchecked_mut((0, 0)) = N::one() / determinant;
+                        *self.get_unchecked_mut((0, 0)) = T::one() / determinant;
                         true
                     }
                 }
@@ -120,12 +120,12 @@ impl<N: ComplexField, D: Dim, S: StorageMut<N, D, D>> SquareMatrix<N, D, S> {
 }
 
 // NOTE: this is an extremely efficient, loop-unrolled matrix inverse from MESA (MIT licensed).
-fn do_inverse4<N: ComplexField, D: Dim, S: StorageMut<N, D, D>>(
-    m: &MatrixN<N, D>,
-    out: &mut SquareMatrix<N, D, S>,
+fn do_inverse4<T: ComplexField, D: Dim, S: StorageMut<T, D, D>>(
+    m: &OMatrix<T, D, D>,
+    out: &mut SquareMatrix<T, D, S>,
 ) -> bool
 where
-    DefaultAllocator: Allocator<N, D, D>,
+    DefaultAllocator: Allocator<T, D, D>,
 {
     let m = m.data.as_slice();
 
@@ -212,7 +212,7 @@ where
     let det = m[0] * out[(0, 0)] + m[1] * out[(0, 1)] + m[2] * out[(0, 2)] + m[3] * out[(0, 3)];
 
     if !det.is_zero() {
-        let inv_det = N::one() / det;
+        let inv_det = T::one() / det;
 
         for j in 0..4 {
             for i in 0..4 {
diff --git a/src/linalg/lu.rs b/src/linalg/lu.rs
index 9e417f10..c09a5b77 100644
--- a/src/linalg/lu.rs
+++ b/src/linalg/lu.rs
@@ -2,7 +2,7 @@
 use serde::{Deserialize, Serialize};
 
 use crate::allocator::{Allocator, Reallocator};
-use crate::base::{DefaultAllocator, Matrix, MatrixMN, MatrixN, Scalar};
+use crate::base::{DefaultAllocator, Matrix, OMatrix, Scalar};
 use crate::constraint::{SameNumberOfRows, ShapeConstraint};
 use crate::dimension::{Dim, DimMin, DimMinimum};
 use crate::storage::{Storage, StorageMut};
@@ -15,31 +15,31 @@ use crate::linalg::PermutationSequence;
 #[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
 #[cfg_attr(
     feature = "serde-serialize",
-    serde(bound(serialize = "DefaultAllocator: Allocator<N, R, C> +
+    serde(bound(serialize = "DefaultAllocator: Allocator<T, R, C> +
                            Allocator<(usize, usize), DimMinimum<R, C>>,
-         MatrixMN<N, R, C>: Serialize,
+         OMatrix<T, R, C>: Serialize,
          PermutationSequence<DimMinimum<R, C>>: Serialize"))
 )]
 #[cfg_attr(
     feature = "serde-serialize",
-    serde(bound(deserialize = "DefaultAllocator: Allocator<N, R, C> +
+    serde(bound(deserialize = "DefaultAllocator: Allocator<T, R, C> +
                            Allocator<(usize, usize), DimMinimum<R, C>>,
-         MatrixMN<N, R, C>: Deserialize<'de>,
+         OMatrix<T, R, C>: Deserialize<'de>,
          PermutationSequence<DimMinimum<R, C>>: Deserialize<'de>"))
 )]
 #[derive(Clone, Debug)]
-pub struct LU<N: ComplexField, R: DimMin<C>, C: Dim>
+pub struct LU<T: ComplexField, R: DimMin<C>, C: Dim>
 where
-    DefaultAllocator: Allocator<N, R, C> + Allocator<(usize, usize), DimMinimum<R, C>>,
+    DefaultAllocator: Allocator<T, R, C> + Allocator<(usize, usize), DimMinimum<R, C>>,
 {
-    lu: MatrixMN<N, R, C>,
+    lu: OMatrix<T, R, C>,
     p: PermutationSequence<DimMinimum<R, C>>,
 }
 
-impl<N: ComplexField, R: DimMin<C>, C: Dim> Copy for LU<N, R, C>
+impl<T: ComplexField, R: DimMin<C>, C: Dim> Copy for LU<T, R, C>
 where
-    DefaultAllocator: Allocator<N, R, C> + Allocator<(usize, usize), DimMinimum<R, C>>,
-    MatrixMN<N, R, C>: Copy,
+    DefaultAllocator: Allocator<T, R, C> + Allocator<(usize, usize), DimMinimum<R, C>>,
+    OMatrix<T, R, C>: Copy,
     PermutationSequence<DimMinimum<R, C>>: Copy,
 {
 }
@@ -47,13 +47,13 @@ where
 /// Performs a LU decomposition to overwrite `out` with the inverse of `matrix`.
 ///
 /// If `matrix` is not invertible, `false` is returned and `out` may contain invalid data.
-pub fn try_invert_to<N: ComplexField, D: Dim, S>(
-    mut matrix: MatrixN<N, D>,
-    out: &mut Matrix<N, D, D, S>,
+pub fn try_invert_to<T: ComplexField, D: Dim, S>(
+    mut matrix: OMatrix<T, D, D>,
+    out: &mut Matrix<T, D, D, S>,
 ) -> bool
 where
-    S: StorageMut<N, D, D>,
-    DefaultAllocator: Allocator<N, D, D>,
+    S: StorageMut<T, D, D>,
+    DefaultAllocator: Allocator<T, D, D>,
 {
     assert!(
         matrix.is_square(),
@@ -80,16 +80,16 @@ where
         }
     }
 
-    let _ = matrix.solve_lower_triangular_with_diag_mut(out, N::one());
+    let _ = matrix.solve_lower_triangular_with_diag_mut(out, T::one());
     matrix.solve_upper_triangular_mut(out)
 }
 
-impl<N: ComplexField, R: DimMin<C>, C: Dim> LU<N, R, C>
+impl<T: ComplexField, R: DimMin<C>, C: Dim> LU<T, R, C>
 where
-    DefaultAllocator: Allocator<N, R, C> + Allocator<(usize, usize), DimMinimum<R, C>>,
+    DefaultAllocator: Allocator<T, R, C> + Allocator<(usize, usize), DimMinimum<R, C>>,
 {
     /// Computes the LU decomposition with partial (row) pivoting of `matrix`.
-    pub fn new(mut matrix: MatrixMN<N, R, C>) -> Self {
+    pub fn new(mut matrix: OMatrix<T, R, C>) -> Self {
         let (nrows, ncols) = matrix.data.shape();
         let min_nrows_ncols = nrows.min(ncols);
 
@@ -121,20 +121,20 @@ where
     }
 
     #[doc(hidden)]
-    pub fn lu_internal(&self) -> &MatrixMN<N, R, C> {
+    pub fn lu_internal(&self) -> &OMatrix<T, R, C> {
         &self.lu
     }
 
     /// The lower triangular matrix of this decomposition.
     #[inline]
-    pub fn l(&self) -> MatrixMN<N, R, DimMinimum<R, C>>
+    pub fn l(&self) -> OMatrix<T, R, DimMinimum<R, C>>
     where
-        DefaultAllocator: Allocator<N, R, DimMinimum<R, C>>,
+        DefaultAllocator: Allocator<T, R, DimMinimum<R, C>>,
     {
         let (nrows, ncols) = self.lu.data.shape();
         let mut m = self.lu.columns_generic(0, nrows.min(ncols)).into_owned();
-        m.fill_upper_triangle(N::zero(), 1);
-        m.fill_diagonal(N::one());
+        m.fill_upper_triangle(T::zero(), 1);
+        m.fill_diagonal(T::one());
         m
     }
 
@@ -142,37 +142,37 @@ where
     fn l_unpack_with_p(
         self,
     ) -> (
-        MatrixMN<N, R, DimMinimum<R, C>>,
+        OMatrix<T, R, DimMinimum<R, C>>,
         PermutationSequence<DimMinimum<R, C>>,
     )
     where
-        DefaultAllocator: Reallocator<N, R, C, R, DimMinimum<R, C>>,
+        DefaultAllocator: Reallocator<T, R, C, R, DimMinimum<R, C>>,
     {
         let (nrows, ncols) = self.lu.data.shape();
-        let mut m = self.lu.resize_generic(nrows, nrows.min(ncols), N::zero());
-        m.fill_upper_triangle(N::zero(), 1);
-        m.fill_diagonal(N::one());
+        let mut m = self.lu.resize_generic(nrows, nrows.min(ncols), T::zero());
+        m.fill_upper_triangle(T::zero(), 1);
+        m.fill_diagonal(T::one());
         (m, self.p)
     }
 
     /// The lower triangular matrix of this decomposition.
     #[inline]
-    pub fn l_unpack(self) -> MatrixMN<N, R, DimMinimum<R, C>>
+    pub fn l_unpack(self) -> OMatrix<T, R, DimMinimum<R, C>>
     where
-        DefaultAllocator: Reallocator<N, R, C, R, DimMinimum<R, C>>,
+        DefaultAllocator: Reallocator<T, R, C, R, DimMinimum<R, C>>,
     {
         let (nrows, ncols) = self.lu.data.shape();
-        let mut m = self.lu.resize_generic(nrows, nrows.min(ncols), N::zero());
-        m.fill_upper_triangle(N::zero(), 1);
-        m.fill_diagonal(N::one());
+        let mut m = self.lu.resize_generic(nrows, nrows.min(ncols), T::zero());
+        m.fill_upper_triangle(T::zero(), 1);
+        m.fill_diagonal(T::one());
         m
     }
 
     /// The upper triangular matrix of this decomposition.
     #[inline]
-    pub fn u(&self) -> MatrixMN<N, DimMinimum<R, C>, C>
+    pub fn u(&self) -> OMatrix<T, DimMinimum<R, C>, C>
     where
-        DefaultAllocator: Allocator<N, DimMinimum<R, C>, C>,
+        DefaultAllocator: Allocator<T, DimMinimum<R, C>, C>,
     {
         let (nrows, ncols) = self.lu.data.shape();
         self.lu.rows_generic(0, nrows.min(ncols)).upper_triangle()
@@ -190,13 +190,13 @@ where
         self,
     ) -> (
         PermutationSequence<DimMinimum<R, C>>,
-        MatrixMN<N, R, DimMinimum<R, C>>,
-        MatrixMN<N, DimMinimum<R, C>, C>,
+        OMatrix<T, R, DimMinimum<R, C>>,
+        OMatrix<T, DimMinimum<R, C>, C>,
     )
     where
-        DefaultAllocator: Allocator<N, R, DimMinimum<R, C>>
-            + Allocator<N, DimMinimum<R, C>, C>
-            + Reallocator<N, R, C, R, DimMinimum<R, C>>,
+        DefaultAllocator: Allocator<T, R, DimMinimum<R, C>>
+            + Allocator<T, DimMinimum<R, C>, C>
+            + Reallocator<T, R, C, R, DimMinimum<R, C>>,
     {
         // Use reallocation for either l or u.
         let u = self.u();
@@ -206,21 +206,21 @@ where
     }
 }
 
-impl<N: ComplexField, D: DimMin<D, Output = D>> LU<N, D, D>
+impl<T: ComplexField, D: DimMin<D, Output = D>> LU<T, D, D>
 where
-    DefaultAllocator: Allocator<N, D, D> + Allocator<(usize, usize), D>,
+    DefaultAllocator: Allocator<T, D, D> + Allocator<(usize, usize), D>,
 {
     /// Solves the linear system `self * x = b`, where `x` is the unknown to be determined.
     ///
     /// Returns `None` if `self` is not invertible.
     pub fn solve<R2: Dim, C2: Dim, S2>(
         &self,
-        b: &Matrix<N, R2, C2, S2>,
-    ) -> Option<MatrixMN<N, R2, C2>>
+        b: &Matrix<T, R2, C2, S2>,
+    ) -> Option<OMatrix<T, R2, C2>>
     where
-        S2: Storage<N, R2, C2>,
+        S2: Storage<T, R2, C2>,
         ShapeConstraint: SameNumberOfRows<R2, D>,
-        DefaultAllocator: Allocator<N, R2, C2>,
+        DefaultAllocator: Allocator<T, R2, C2>,
     {
         let mut res = b.clone_owned();
         if self.solve_mut(&mut res) {
@@ -234,9 +234,9 @@ where
     ///
     /// If the decomposed matrix is not invertible, this returns `false` and its input `b` may
     /// be overwritten with garbage.
-    pub fn solve_mut<R2: Dim, C2: Dim, S2>(&self, b: &mut Matrix<N, R2, C2, S2>) -> bool
+    pub fn solve_mut<R2: Dim, C2: Dim, S2>(&self, b: &mut Matrix<T, R2, C2, S2>) -> bool
     where
-        S2: StorageMut<N, R2, C2>,
+        S2: StorageMut<T, R2, C2>,
         ShapeConstraint: SameNumberOfRows<R2, D>,
     {
         assert_eq!(
@@ -250,21 +250,21 @@ where
         );
 
         self.p.permute_rows(b);
-        let _ = self.lu.solve_lower_triangular_with_diag_mut(b, N::one());
+        let _ = self.lu.solve_lower_triangular_with_diag_mut(b, T::one());
         self.lu.solve_upper_triangular_mut(b)
     }
 
     /// Computes the inverse of the decomposed matrix.
     ///
     /// Returns `None` if the matrix is not invertible.
-    pub fn try_inverse(&self) -> Option<MatrixN<N, D>> {
+    pub fn try_inverse(&self) -> Option<OMatrix<T, D, D>> {
         assert!(
             self.lu.is_square(),
             "LU inverse: unable to compute the inverse of a non-square matrix."
         );
 
         let (nrows, ncols) = self.lu.data.shape();
-        let mut res = MatrixN::identity_generic(nrows, ncols);
+        let mut res = OMatrix::identity_generic(nrows, ncols);
         if self.try_inverse_to(&mut res) {
             Some(res)
         } else {
@@ -276,7 +276,7 @@ where
     ///
     /// If the decomposed matrix is not invertible, this returns `false` and `out` may be
     /// overwritten with garbage.
-    pub fn try_inverse_to<S2: StorageMut<N, D, D>>(&self, out: &mut Matrix<N, D, D, S2>) -> bool {
+    pub fn try_inverse_to<S2: StorageMut<T, D, D>>(&self, out: &mut Matrix<T, D, D, S2>) -> bool {
         assert!(
             self.lu.is_square(),
             "LU inverse: unable to compute the inverse of a non-square matrix."
@@ -291,14 +291,14 @@ where
     }
 
     /// Computes the determinant of the decomposed matrix.
-    pub fn determinant(&self) -> N {
+    pub fn determinant(&self) -> T {
         let dim = self.lu.nrows();
         assert!(
             self.lu.is_square(),
             "LU determinant: unable to compute the determinant of a non-square matrix."
         );
 
-        let mut res = N::one();
+        let mut res = T::one();
         for i in 0..dim {
             res *= unsafe { *self.lu.get_unchecked((i, i)) };
         }
@@ -326,14 +326,14 @@ where
 #[doc(hidden)]
 /// Executes one step of gaussian elimination on the i-th row and column of `matrix`. The diagonal
 /// element `matrix[(i, i)]` is provided as argument.
-pub fn gauss_step<N, R: Dim, C: Dim, S>(matrix: &mut Matrix<N, R, C, S>, diag: N, i: usize)
+pub fn gauss_step<T, R: Dim, C: Dim, S>(matrix: &mut Matrix<T, R, C, S>, diag: T, i: usize)
 where
-    N: Scalar + Field,
-    S: StorageMut<N, R, C>,
+    T: Scalar + Field,
+    S: StorageMut<T, R, C>,
 {
     let mut submat = matrix.slice_range_mut(i.., i..);
 
-    let inv_diag = N::one() / diag;
+    let inv_diag = T::one() / diag;
 
     let (mut coeffs, mut submat) = submat.columns_range_pair_mut(0, 1..);
 
@@ -344,26 +344,26 @@ where
 
     for k in 0..pivot_row.ncols() {
         down.column_mut(k)
-            .axpy(-pivot_row[k].inlined_clone(), &coeffs, N::one());
+            .axpy(-pivot_row[k].inlined_clone(), &coeffs, T::one());
     }
 }
 
 #[doc(hidden)]
 /// Swaps the rows `i` with the row `piv` and executes one step of gaussian elimination on the i-th
 /// row and column of `matrix`. The diagonal element `matrix[(i, i)]` is provided as argument.
-pub fn gauss_step_swap<N, R: Dim, C: Dim, S>(
-    matrix: &mut Matrix<N, R, C, S>,
-    diag: N,
+pub fn gauss_step_swap<T, R: Dim, C: Dim, S>(
+    matrix: &mut Matrix<T, R, C, S>,
+    diag: T,
     i: usize,
     piv: usize,
 ) where
-    N: Scalar + Field,
-    S: StorageMut<N, R, C>,
+    T: Scalar + Field,
+    S: StorageMut<T, R, C>,
 {
     let piv = piv - i;
     let mut submat = matrix.slice_range_mut(i.., i..);
 
-    let inv_diag = N::one() / diag;
+    let inv_diag = T::one() / diag;
 
     let (mut coeffs, mut submat) = submat.columns_range_pair_mut(0, 1..);
 
@@ -376,6 +376,6 @@ pub fn gauss_step_swap<N, R: Dim, C: Dim, S>(
     for k in 0..pivot_row.ncols() {
         mem::swap(&mut pivot_row[k], &mut down[(piv - 1, k)]);
         down.column_mut(k)
-            .axpy(-pivot_row[k].inlined_clone(), &coeffs, N::one());
+            .axpy(-pivot_row[k].inlined_clone(), &coeffs, T::one());
     }
 }
diff --git a/src/linalg/permutation_sequence.rs b/src/linalg/permutation_sequence.rs
index dd389188..09aa4f90 100644
--- a/src/linalg/permutation_sequence.rs
+++ b/src/linalg/permutation_sequence.rs
@@ -5,10 +5,10 @@ use num::One;
 use simba::scalar::ClosedNeg;
 
 use crate::allocator::Allocator;
-use crate::base::{DefaultAllocator, Matrix, Scalar, VectorN};
+use crate::base::{DefaultAllocator, Matrix, OVector, Scalar};
 #[cfg(any(feature = "std", feature = "alloc"))]
 use crate::dimension::Dynamic;
-use crate::dimension::{Dim, DimName, U1};
+use crate::dimension::{Const, Dim, DimName};
 use crate::storage::StorageMut;
 
 /// A sequence of row or column permutations.
@@ -16,12 +16,12 @@ use crate::storage::StorageMut;
 #[cfg_attr(
     feature = "serde-serialize",
     serde(bound(serialize = "DefaultAllocator: Allocator<(usize, usize), D>,
-         VectorN<(usize, usize), D>: Serialize"))
+         OVector<(usize, usize), D>: Serialize"))
 )]
 #[cfg_attr(
     feature = "serde-serialize",
     serde(bound(deserialize = "DefaultAllocator: Allocator<(usize, usize), D>,
-         VectorN<(usize, usize), D>: Deserialize<'de>"))
+         OVector<(usize, usize), D>: Deserialize<'de>"))
 )]
 #[derive(Clone, Debug)]
 pub struct PermutationSequence<D: Dim>
@@ -29,13 +29,13 @@ where
     DefaultAllocator: Allocator<(usize, usize), D>,
 {
     len: usize,
-    ipiv: VectorN<(usize, usize), D>,
+    ipiv: OVector<(usize, usize), D>,
 }
 
 impl<D: Dim> Copy for PermutationSequence<D>
 where
     DefaultAllocator: Allocator<(usize, usize), D>,
-    VectorN<(usize, usize), D>: Copy,
+    OVector<(usize, usize), D>: Copy,
 {
 }
 
@@ -72,7 +72,7 @@ where
         unsafe {
             Self {
                 len: 0,
-                ipiv: crate::unimplemented_or_uninitialized_generic!(dim, U1),
+                ipiv: crate::unimplemented_or_uninitialized_generic!(dim, Const::<1>),
             }
         }
     }
@@ -93,9 +93,9 @@ where
 
     /// Applies this sequence of permutations to the rows of `rhs`.
     #[inline]
-    pub fn permute_rows<N: Scalar, R2: Dim, C2: Dim, S2>(&self, rhs: &mut Matrix<N, R2, C2, S2>)
+    pub fn permute_rows<T: Scalar, R2: Dim, C2: Dim, S2>(&self, rhs: &mut Matrix<T, R2, C2, S2>)
     where
-        S2: StorageMut<N, R2, C2>,
+        S2: StorageMut<T, R2, C2>,
     {
         for i in self.ipiv.rows_range(..self.len).iter() {
             rhs.swap_rows(i.0, i.1)
@@ -104,9 +104,9 @@ where
 
     /// Applies this sequence of permutations in reverse to the rows of `rhs`.
     #[inline]
-    pub fn inv_permute_rows<N: Scalar, R2: Dim, C2: Dim, S2>(&self, rhs: &mut Matrix<N, R2, C2, S2>)
+    pub fn inv_permute_rows<T: Scalar, R2: Dim, C2: Dim, S2>(&self, rhs: &mut Matrix<T, R2, C2, S2>)
     where
-        S2: StorageMut<N, R2, C2>,
+        S2: StorageMut<T, R2, C2>,
     {
         for i in 0..self.len {
             let (i1, i2) = self.ipiv[self.len - i - 1];
@@ -116,9 +116,9 @@ where
 
     /// Applies this sequence of permutations to the columns of `rhs`.
     #[inline]
-    pub fn permute_columns<N: Scalar, R2: Dim, C2: Dim, S2>(&self, rhs: &mut Matrix<N, R2, C2, S2>)
+    pub fn permute_columns<T: Scalar, R2: Dim, C2: Dim, S2>(&self, rhs: &mut Matrix<T, R2, C2, S2>)
     where
-        S2: StorageMut<N, R2, C2>,
+        S2: StorageMut<T, R2, C2>,
     {
         for i in self.ipiv.rows_range(..self.len).iter() {
             rhs.swap_columns(i.0, i.1)
@@ -127,11 +127,11 @@ where
 
     /// Applies this sequence of permutations in reverse to the columns of `rhs`.
     #[inline]
-    pub fn inv_permute_columns<N: Scalar, R2: Dim, C2: Dim, S2>(
+    pub fn inv_permute_columns<T: Scalar, R2: Dim, C2: Dim, S2>(
         &self,
-        rhs: &mut Matrix<N, R2, C2, S2>,
+        rhs: &mut Matrix<T, R2, C2, S2>,
     ) where
-        S2: StorageMut<N, R2, C2>,
+        S2: StorageMut<T, R2, C2>,
     {
         for i in 0..self.len {
             let (i1, i2) = self.ipiv[self.len - i - 1];
@@ -151,11 +151,11 @@ where
 
     /// The determinant of the matrix corresponding to this permutation.
     #[inline]
-    pub fn determinant<N: One + ClosedNeg>(&self) -> N {
+    pub fn determinant<T: One + ClosedNeg>(&self) -> T {
         if self.len % 2 == 0 {
-            N::one()
+            T::one()
         } else {
-            -N::one()
+            -T::one()
         }
     }
 }
diff --git a/src/linalg/pow.rs b/src/linalg/pow.rs
index edcf55dd..33759a90 100644
--- a/src/linalg/pow.rs
+++ b/src/linalg/pow.rs
@@ -2,23 +2,27 @@
 
 use std::ops::DivAssign;
 
-use crate::{allocator::Allocator, DefaultAllocator, DimMin, MatrixN};
+use crate::{
+    allocator::Allocator,
+    storage::{Storage, StorageMut},
+    DefaultAllocator, DimMin, Matrix, OMatrix,
+};
 use num::PrimInt;
 use simba::scalar::ComplexField;
 
-impl<N: ComplexField, D> MatrixN<N, D>
+impl<T: ComplexField, D, S> Matrix<T, D, D, S>
 where
     D: DimMin<D, Output = D>,
-    DefaultAllocator: Allocator<N, D, D>,
-    DefaultAllocator: Allocator<N, D>,
+    S: StorageMut<T, D, D>,
+    DefaultAllocator: Allocator<T, D, D> + Allocator<T, D>,
 {
     /// Attempts to raise this matrix to an integral power `e` in-place. If this
     /// matrix is non-invertible and `e` is negative, it leaves this matrix
     /// untouched and returns `Err(())`. Otherwise, it returns `Ok(())` and
     /// overwrites this matrix with the result.
     #[must_use]
-    pub fn pow_mut<T: PrimInt + DivAssign>(&mut self, mut e: T) -> Result<(), ()> {
-        let zero = T::zero();
+    pub fn pow_mut<I: PrimInt + DivAssign>(&mut self, mut e: I) -> Result<(), ()> {
+        let zero = I::zero();
 
         // A matrix raised to the zeroth power is just the identity.
         if e == zero {
@@ -34,18 +38,19 @@ where
             }
         }
 
-        let one = T::one();
-        let two = T::from(2u8).unwrap();
+        let one = I::one();
+        let two = I::from(2u8).unwrap();
 
         // We use the buffer to hold the result of multiplier ^ 2, thus avoiding
         // extra allocations.
-        let mut multiplier = self.clone();
-        let mut buf = self.clone();
+        let mut multiplier = self.clone_owned();
+        let mut buf = self.clone_owned();
 
         // Exponentiation by squares.
         loop {
             if e % two == one {
-                *self *= &multiplier;
+                self.mul_to(&multiplier, &mut buf);
+                self.copy_from(&buf);
             }
 
             e /= two;
@@ -57,12 +62,20 @@ where
             }
         }
     }
+}
 
+impl<T: ComplexField, D, S: Storage<T, D, D>> Matrix<T, D, D, S>
+where
+    D: DimMin<D, Output = D>,
+    S: StorageMut<T, D, D>,
+    DefaultAllocator: Allocator<T, D, D> + Allocator<T, D>,
+{
     /// Attempts to raise this matrix to an integral power `e`. If this matrix
     /// is non-invertible and `e` is negative, it returns `None`. Otherwise, it
     /// returns the result as a new matrix. Uses exponentiation by squares.
-    pub fn pow<T: PrimInt + DivAssign>(&self, e: T) -> Option<Self> {
-        let mut clone = self.clone();
+    #[must_use]
+    pub fn pow<I: PrimInt + DivAssign>(&self, e: I) -> Option<OMatrix<T, D, D>> {
+        let mut clone = self.clone_owned();
 
         match clone.pow_mut(e) {
             Ok(()) => Some(clone),
diff --git a/src/linalg/qr.rs b/src/linalg/qr.rs
index 5c231c82..a09842d0 100644
--- a/src/linalg/qr.rs
+++ b/src/linalg/qr.rs
@@ -3,9 +3,9 @@ use num::Zero;
 use serde::{Deserialize, Serialize};
 
 use crate::allocator::{Allocator, Reallocator};
-use crate::base::{DefaultAllocator, Matrix, MatrixMN, MatrixN, Unit, VectorN};
+use crate::base::{DefaultAllocator, Matrix, OMatrix, OVector, Unit};
 use crate::constraint::{SameNumberOfRows, ShapeConstraint};
-use crate::dimension::{Dim, DimMin, DimMinimum, U1};
+use crate::dimension::{Const, Dim, DimMin, DimMinimum};
 use crate::storage::{Storage, StorageMut};
 use simba::scalar::ComplexField;
 
@@ -16,46 +16,46 @@ use crate::linalg::householder;
 #[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
 #[cfg_attr(
     feature = "serde-serialize",
-    serde(bound(serialize = "DefaultAllocator: Allocator<N, R, C> +
-                           Allocator<N, DimMinimum<R, C>>,
-         MatrixMN<N, R, C>: Serialize,
-         VectorN<N, DimMinimum<R, C>>: Serialize"))
+    serde(bound(serialize = "DefaultAllocator: Allocator<T, R, C> +
+                           Allocator<T, DimMinimum<R, C>>,
+         OMatrix<T, R, C>: Serialize,
+         OVector<T, DimMinimum<R, C>>: Serialize"))
 )]
 #[cfg_attr(
     feature = "serde-serialize",
-    serde(bound(deserialize = "DefaultAllocator: Allocator<N, R, C> +
-                           Allocator<N, DimMinimum<R, C>>,
-         MatrixMN<N, R, C>: Deserialize<'de>,
-         VectorN<N, DimMinimum<R, C>>: Deserialize<'de>"))
+    serde(bound(deserialize = "DefaultAllocator: Allocator<T, R, C> +
+                           Allocator<T, DimMinimum<R, C>>,
+         OMatrix<T, R, C>: Deserialize<'de>,
+         OVector<T, DimMinimum<R, C>>: Deserialize<'de>"))
 )]
 #[derive(Clone, Debug)]
-pub struct QR<N: ComplexField, R: DimMin<C>, C: Dim>
+pub struct QR<T: ComplexField, R: DimMin<C>, C: Dim>
 where
-    DefaultAllocator: Allocator<N, R, C> + Allocator<N, DimMinimum<R, C>>,
+    DefaultAllocator: Allocator<T, R, C> + Allocator<T, DimMinimum<R, C>>,
 {
-    qr: MatrixMN<N, R, C>,
-    diag: VectorN<N, DimMinimum<R, C>>,
+    qr: OMatrix<T, R, C>,
+    diag: OVector<T, DimMinimum<R, C>>,
 }
 
-impl<N: ComplexField, R: DimMin<C>, C: Dim> Copy for QR<N, R, C>
+impl<T: ComplexField, R: DimMin<C>, C: Dim> Copy for QR<T, R, C>
 where
-    DefaultAllocator: Allocator<N, R, C> + Allocator<N, DimMinimum<R, C>>,
-    MatrixMN<N, R, C>: Copy,
-    VectorN<N, DimMinimum<R, C>>: Copy,
+    DefaultAllocator: Allocator<T, R, C> + Allocator<T, DimMinimum<R, C>>,
+    OMatrix<T, R, C>: Copy,
+    OVector<T, DimMinimum<R, C>>: Copy,
 {
 }
 
-impl<N: ComplexField, R: DimMin<C>, C: Dim> QR<N, R, C>
+impl<T: ComplexField, R: DimMin<C>, C: Dim> QR<T, R, C>
 where
-    DefaultAllocator: Allocator<N, R, C> + Allocator<N, R> + Allocator<N, DimMinimum<R, C>>,
+    DefaultAllocator: Allocator<T, R, C> + Allocator<T, R> + Allocator<T, DimMinimum<R, C>>,
 {
     /// Computes the QR decomposition using householder reflections.
-    pub fn new(mut matrix: MatrixMN<N, R, C>) -> Self {
+    pub fn new(mut matrix: OMatrix<T, R, C>) -> Self {
         let (nrows, ncols) = matrix.data.shape();
         let min_nrows_ncols = nrows.min(ncols);
 
         let mut diag =
-            unsafe { crate::unimplemented_or_uninitialized_generic!(min_nrows_ncols, U1) };
+            unsafe { crate::unimplemented_or_uninitialized_generic!(min_nrows_ncols, Const::<1>) };
 
         if min_nrows_ncols.value() == 0 {
             return QR { qr: matrix, diag };
@@ -70,13 +70,13 @@ where
 
     /// Retrieves the upper trapezoidal submatrix `R` of this decomposition.
     #[inline]
-    pub fn r(&self) -> MatrixMN<N, DimMinimum<R, C>, C>
+    pub fn r(&self) -> OMatrix<T, DimMinimum<R, C>, C>
     where
-        DefaultAllocator: Allocator<N, DimMinimum<R, C>, C>,
+        DefaultAllocator: Allocator<T, DimMinimum<R, C>, C>,
     {
         let (nrows, ncols) = self.qr.data.shape();
         let mut res = self.qr.rows_generic(0, nrows.min(ncols)).upper_triangle();
-        res.set_partial_diagonal(self.diag.iter().map(|e| N::from_real(e.modulus())));
+        res.set_partial_diagonal(self.diag.iter().map(|e| T::from_real(e.modulus())));
         res
     }
 
@@ -84,21 +84,21 @@ where
     ///
     /// This is usually faster than `r` but consumes `self`.
     #[inline]
-    pub fn unpack_r(self) -> MatrixMN<N, DimMinimum<R, C>, C>
+    pub fn unpack_r(self) -> OMatrix<T, DimMinimum<R, C>, C>
     where
-        DefaultAllocator: Reallocator<N, R, C, DimMinimum<R, C>, C>,
+        DefaultAllocator: Reallocator<T, R, C, DimMinimum<R, C>, C>,
     {
         let (nrows, ncols) = self.qr.data.shape();
-        let mut res = self.qr.resize_generic(nrows.min(ncols), ncols, N::zero());
-        res.fill_lower_triangle(N::zero(), 1);
-        res.set_partial_diagonal(self.diag.iter().map(|e| N::from_real(e.modulus())));
+        let mut res = self.qr.resize_generic(nrows.min(ncols), ncols, T::zero());
+        res.fill_lower_triangle(T::zero(), 1);
+        res.set_partial_diagonal(self.diag.iter().map(|e| T::from_real(e.modulus())));
         res
     }
 
     /// Computes the orthogonal matrix `Q` of this decomposition.
-    pub fn q(&self) -> MatrixMN<N, R, DimMinimum<R, C>>
+    pub fn q(&self) -> OMatrix<T, R, DimMinimum<R, C>>
     where
-        DefaultAllocator: Allocator<N, R, DimMinimum<R, C>>,
+        DefaultAllocator: Allocator<T, R, DimMinimum<R, C>>,
     {
         let (nrows, ncols) = self.qr.data.shape();
 
@@ -110,7 +110,7 @@ where
         for i in (0..dim).rev() {
             let axis = self.qr.slice_range(i.., i);
             // TODO: sometimes, the axis might have a zero magnitude.
-            let refl = Reflection::new(Unit::new_unchecked(axis), N::zero());
+            let refl = Reflection::new(Unit::new_unchecked(axis), T::zero());
 
             let mut res_rows = res.slice_range_mut(i.., i..);
             refl.reflect_with_sign(&mut res_rows, self.diag[i].signum());
@@ -123,33 +123,33 @@ where
     pub fn unpack(
         self,
     ) -> (
-        MatrixMN<N, R, DimMinimum<R, C>>,
-        MatrixMN<N, DimMinimum<R, C>, C>,
+        OMatrix<T, R, DimMinimum<R, C>>,
+        OMatrix<T, DimMinimum<R, C>, C>,
     )
     where
         DimMinimum<R, C>: DimMin<C, Output = DimMinimum<R, C>>,
         DefaultAllocator:
-            Allocator<N, R, DimMinimum<R, C>> + Reallocator<N, R, C, DimMinimum<R, C>, C>,
+            Allocator<T, R, DimMinimum<R, C>> + Reallocator<T, R, C, DimMinimum<R, C>, C>,
     {
         (self.q(), self.unpack_r())
     }
 
     #[doc(hidden)]
-    pub fn qr_internal(&self) -> &MatrixMN<N, R, C> {
+    pub fn qr_internal(&self) -> &OMatrix<T, R, C> {
         &self.qr
     }
 
     /// Multiplies the provided matrix by the transpose of the `Q` matrix of this decomposition.
-    pub fn q_tr_mul<R2: Dim, C2: Dim, S2>(&self, rhs: &mut Matrix<N, R2, C2, S2>)
+    pub fn q_tr_mul<R2: Dim, C2: Dim, S2>(&self, rhs: &mut Matrix<T, R2, C2, S2>)
     // TODO: do we need a static constraint on the number of rows of rhs?
     where
-        S2: StorageMut<N, R2, C2>,
+        S2: StorageMut<T, R2, C2>,
     {
         let dim = self.diag.len();
 
         for i in 0..dim {
             let axis = self.qr.slice_range(i.., i);
-            let refl = Reflection::new(Unit::new_unchecked(axis), N::zero());
+            let refl = Reflection::new(Unit::new_unchecked(axis), T::zero());
 
             let mut rhs_rows = rhs.rows_range_mut(i..);
             refl.reflect_with_sign(&mut rhs_rows, self.diag[i].signum().conjugate());
@@ -157,21 +157,21 @@ where
     }
 }
 
-impl<N: ComplexField, D: DimMin<D, Output = D>> QR<N, D, D>
+impl<T: ComplexField, D: DimMin<D, Output = D>> QR<T, D, D>
 where
-    DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>,
+    DefaultAllocator: Allocator<T, D, D> + Allocator<T, D>,
 {
     /// Solves the linear system `self * x = b`, where `x` is the unknown to be determined.
     ///
     /// Returns `None` if `self` is not invertible.
     pub fn solve<R2: Dim, C2: Dim, S2>(
         &self,
-        b: &Matrix<N, R2, C2, S2>,
-    ) -> Option<MatrixMN<N, R2, C2>>
+        b: &Matrix<T, R2, C2, S2>,
+    ) -> Option<OMatrix<T, R2, C2>>
     where
-        S2: Storage<N, R2, C2>,
+        S2: Storage<T, R2, C2>,
         ShapeConstraint: SameNumberOfRows<R2, D>,
-        DefaultAllocator: Allocator<N, R2, C2>,
+        DefaultAllocator: Allocator<T, R2, C2>,
     {
         let mut res = b.clone_owned();
 
@@ -186,9 +186,9 @@ where
     ///
     /// If the decomposed matrix is not invertible, this returns `false` and its input `b` is
     /// overwritten with garbage.
-    pub fn solve_mut<R2: Dim, C2: Dim, S2>(&self, b: &mut Matrix<N, R2, C2, S2>) -> bool
+    pub fn solve_mut<R2: Dim, C2: Dim, S2>(&self, b: &mut Matrix<T, R2, C2, S2>) -> bool
     where
-        S2: StorageMut<N, R2, C2>,
+        S2: StorageMut<T, R2, C2>,
         ShapeConstraint: SameNumberOfRows<R2, D>,
     {
         assert_eq!(
@@ -208,10 +208,10 @@ where
     // TODO: duplicate code from the `solve` module.
     fn solve_upper_triangular_mut<R2: Dim, C2: Dim, S2>(
         &self,
-        b: &mut Matrix<N, R2, C2, S2>,
+        b: &mut Matrix<T, R2, C2, S2>,
     ) -> bool
     where
-        S2: StorageMut<N, R2, C2>,
+        S2: StorageMut<T, R2, C2>,
         ShapeConstraint: SameNumberOfRows<R2, D>,
     {
         let dim = self.qr.nrows();
@@ -233,7 +233,7 @@ where
                 }
 
                 b.rows_range_mut(..i)
-                    .axpy(-coeff, &self.qr.slice_range(..i, i), N::one());
+                    .axpy(-coeff, &self.qr.slice_range(..i, i), T::one());
             }
         }
 
@@ -243,7 +243,7 @@ where
     /// Computes the inverse of the decomposed matrix.
     ///
     /// Returns `None` if the decomposed matrix is not invertible.
-    pub fn try_inverse(&self) -> Option<MatrixN<N, D>> {
+    pub fn try_inverse(&self) -> Option<OMatrix<T, D, D>> {
         assert!(
             self.qr.is_square(),
             "QR inverse: unable to compute the inverse of a non-square matrix."
@@ -251,7 +251,7 @@ where
 
         // TODO: is there a less naive method ?
         let (nrows, ncols) = self.qr.data.shape();
-        let mut res = MatrixN::identity_generic(nrows, ncols);
+        let mut res = OMatrix::identity_generic(nrows, ncols);
 
         if self.solve_mut(&mut res) {
             Some(res)
@@ -277,11 +277,11 @@ where
     }
 
     // /// Computes the determinant of the decomposed matrix.
-    // pub fn determinant(&self) -> N {
+    // pub fn determinant(&self) -> T {
     //     let dim = self.qr.nrows();
     //     assert!(self.qr.is_square(), "QR determinant: unable to compute the determinant of a non-square matrix.");
 
-    //     let mut res = N::one();
+    //     let mut res = T::one();
     //     for i in 0 .. dim {
     //         res *= unsafe { *self.diag.vget_unchecked(i) };
     //     }
diff --git a/src/linalg/schur.rs b/src/linalg/schur.rs
index 4b89567b..1726ffc9 100644
--- a/src/linalg/schur.rs
+++ b/src/linalg/schur.rs
@@ -7,9 +7,9 @@ use simba::scalar::{ComplexField, RealField};
 use std::cmp;
 
 use crate::allocator::Allocator;
-use crate::base::dimension::{Dim, DimDiff, DimSub, Dynamic, U1, U2, U3};
+use crate::base::dimension::{Const, Dim, DimDiff, DimSub, Dynamic, U1, U2};
 use crate::base::storage::Storage;
-use crate::base::{DefaultAllocator, MatrixN, SquareMatrix, Unit, Vector2, Vector3, VectorN};
+use crate::base::{DefaultAllocator, OMatrix, OVector, SquareMatrix, Unit, Vector2, Vector3};
 
 use crate::geometry::Reflection;
 use crate::linalg::givens::GivensRotation;
@@ -22,41 +22,41 @@ use crate::linalg::Hessenberg;
 #[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
 #[cfg_attr(
     feature = "serde-serialize",
-    serde(bound(serialize = "DefaultAllocator: Allocator<N, D, D>,
-         MatrixN<N, D>: Serialize"))
+    serde(bound(serialize = "DefaultAllocator: Allocator<T, D, D>,
+         OMatrix<T, D, D>: Serialize"))
 )]
 #[cfg_attr(
     feature = "serde-serialize",
-    serde(bound(deserialize = "DefaultAllocator: Allocator<N, D, D>,
-         MatrixN<N, D>: Deserialize<'de>"))
+    serde(bound(deserialize = "DefaultAllocator: Allocator<T, D, D>,
+         OMatrix<T, D, D>: Deserialize<'de>"))
 )]
 #[derive(Clone, Debug)]
-pub struct Schur<N: ComplexField, D: Dim>
+pub struct Schur<T: ComplexField, D: Dim>
 where
-    DefaultAllocator: Allocator<N, D, D>,
+    DefaultAllocator: Allocator<T, D, D>,
 {
-    q: MatrixN<N, D>,
-    t: MatrixN<N, D>,
+    q: OMatrix<T, D, D>,
+    t: OMatrix<T, D, D>,
 }
 
-impl<N: ComplexField, D: Dim> Copy for Schur<N, D>
+impl<T: ComplexField, D: Dim> Copy for Schur<T, D>
 where
-    DefaultAllocator: Allocator<N, D, D>,
-    MatrixN<N, D>: Copy,
+    DefaultAllocator: Allocator<T, D, D>,
+    OMatrix<T, D, D>: Copy,
 {
 }
 
-impl<N: ComplexField, D: Dim> Schur<N, D>
+impl<T: ComplexField, D: Dim> Schur<T, D>
 where
     D: DimSub<U1>, // For Hessenberg.
-    DefaultAllocator: Allocator<N, D, DimDiff<D, U1>>
-        + Allocator<N, DimDiff<D, U1>>
-        + Allocator<N, D, D>
-        + Allocator<N, D>,
+    DefaultAllocator: Allocator<T, D, DimDiff<D, U1>>
+        + Allocator<T, DimDiff<D, U1>>
+        + Allocator<T, D, D>
+        + Allocator<T, D>,
 {
     /// Computes the Schur decomposition of a square matrix.
-    pub fn new(m: MatrixN<N, D>) -> Self {
-        Self::try_new(m, N::RealField::default_epsilon(), 0).unwrap()
+    pub fn new(m: OMatrix<T, D, D>) -> Self {
+        Self::try_new(m, T::RealField::default_epsilon(), 0).unwrap()
     }
 
     /// Attempts to compute the Schur decomposition of a square matrix.
@@ -70,21 +70,21 @@ where
     /// * `max_niter` − maximum total number of iterations performed by the algorithm. If this
     /// number of iteration is exceeded, `None` is returned. If `niter == 0`, then the algorithm
     /// continues indefinitely until convergence.
-    pub fn try_new(m: MatrixN<N, D>, eps: N::RealField, max_niter: usize) -> Option<Self> {
+    pub fn try_new(m: OMatrix<T, D, D>, eps: T::RealField, max_niter: usize) -> Option<Self> {
         let mut work =
-            unsafe { crate::unimplemented_or_uninitialized_generic!(m.data.shape().0, U1) };
+            unsafe { crate::unimplemented_or_uninitialized_generic!(m.data.shape().0, Const::<1>) };
 
         Self::do_decompose(m, &mut work, eps, max_niter, true)
             .map(|(q, t)| Schur { q: q.unwrap(), t })
     }
 
     fn do_decompose(
-        mut m: MatrixN<N, D>,
-        work: &mut VectorN<N, D>,
-        eps: N::RealField,
+        mut m: OMatrix<T, D, D>,
+        work: &mut OVector<T, D>,
+        eps: T::RealField,
         max_niter: usize,
         compute_q: bool,
-    ) -> Option<(Option<MatrixN<N, D>>, MatrixN<N, D>)> {
+    ) -> Option<(Option<OMatrix<T, D, D>>, OMatrix<T, D, D>)> {
         assert!(
             m.is_square(),
             "Unable to compute the eigenvectors and eigenvalues of a non-square matrix."
@@ -94,12 +94,12 @@ where
 
         // Specialization would make this easier.
         if dim.value() == 0 {
-            let vecs = Some(MatrixN::from_element_generic(dim, dim, N::zero()));
-            let vals = MatrixN::from_element_generic(dim, dim, N::zero());
+            let vecs = Some(OMatrix::from_element_generic(dim, dim, T::zero()));
+            let vals = OMatrix::from_element_generic(dim, dim, T::zero());
             return Some((vecs, vals));
         } else if dim.value() == 1 {
             if compute_q {
-                let q = MatrixN::from_element_generic(dim, dim, N::one());
+                let q = OMatrix::from_element_generic(dim, dim, T::one());
                 return Some((Some(q), m));
             } else {
                 return Some((None, m));
@@ -163,27 +163,30 @@ where
                     if not_zero {
                         if k > start {
                             t[(k, k - 1)] = norm;
-                            t[(k + 1, k - 1)] = N::zero();
-                            t[(k + 2, k - 1)] = N::zero();
+                            t[(k + 1, k - 1)] = T::zero();
+                            t[(k + 2, k - 1)] = T::zero();
                         }
 
-                        let refl = Reflection::new(Unit::new_unchecked(axis), N::zero());
+                        let refl = Reflection::new(Unit::new_unchecked(axis), T::zero());
 
                         {
                             let krows = cmp::min(k + 4, end + 1);
                             let mut work = work.rows_mut(0, krows);
-                            refl.reflect(
-                                &mut t
-                                    .generic_slice_mut((k, k), (U3, Dynamic::new(dim.value() - k))),
-                            );
+                            refl.reflect(&mut t.generic_slice_mut(
+                                (k, k),
+                                (Const::<3>, Dynamic::new(dim.value() - k)),
+                            ));
                             refl.reflect_rows(
-                                &mut t.generic_slice_mut((0, k), (Dynamic::new(krows), U3)),
+                                &mut t.generic_slice_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, U3)), work);
+                            refl.reflect_rows(
+                                &mut q.generic_slice_mut((0, k), (dim, Const::<3>)),
+                                work,
+                            );
                         }
                     }
 
@@ -199,41 +202,45 @@ where
                 let (norm, not_zero) = householder::reflection_axis_mut(&mut axis);
 
                 if not_zero {
-                    let refl = Reflection::new(Unit::new_unchecked(axis), N::zero());
+                    let refl = Reflection::new(Unit::new_unchecked(axis), T::zero());
 
                     t[(m, m - 1)] = norm;
-                    t[(n, m - 1)] = N::zero();
+                    t[(n, m - 1)] = T::zero();
 
                     {
                         let mut work = work.rows_mut(0, end + 1);
-                        refl.reflect(
-                            &mut t.generic_slice_mut((m, m), (U2, Dynamic::new(dim.value() - m))),
-                        );
+                        refl.reflect(&mut t.generic_slice_mut(
+                            (m, m),
+                            (Const::<2>, Dynamic::new(dim.value() - m)),
+                        ));
                         refl.reflect_rows(
-                            &mut t.generic_slice_mut((0, m), (Dynamic::new(end + 1), U2)),
+                            &mut t.generic_slice_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, U2)), work);
+                        refl.reflect_rows(
+                            &mut q.generic_slice_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::<U2, U2>(start, start)) {
+                if let Some(rot) = compute_2x2_basis(&t.fixed_slice::<2, 2>(start, start)) {
                     let inv_rot = rot.inverse();
                     inv_rot.rotate(&mut t.generic_slice_mut(
                         (start, start),
-                        (U2, Dynamic::new(dim.value() - start)),
+                        (Const::<2>, Dynamic::new(dim.value() - start)),
                     ));
                     rot.rotate_rows(
-                        &mut t.generic_slice_mut((0, start), (Dynamic::new(end + 1), U2)),
+                        &mut t.generic_slice_mut((0, start), (Dynamic::new(end + 1), Const::<2>)),
                     );
-                    t[(end, start)] = N::zero();
+                    t[(end, start)] = T::zero();
 
                     if let Some(ref mut q) = q {
-                        rot.rotate_rows(&mut q.generic_slice_mut((0, start), (dim, U2)));
+                        rot.rotate_rows(&mut q.generic_slice_mut((0, start), (dim, Const::<2>)));
                     }
                 }
 
@@ -262,7 +269,7 @@ where
     }
 
     /// Computes the eigenvalues of the decomposed matrix.
-    fn do_eigenvalues(t: &MatrixN<N, D>, out: &mut VectorN<N, D>) -> bool {
+    fn do_eigenvalues(t: &OMatrix<T, D, D>, out: &mut OVector<T, D>) -> bool {
         let dim = t.nrows();
         let mut m = 0;
 
@@ -286,10 +293,10 @@ where
     }
 
     /// Computes the complex eigenvalues of the decomposed matrix.
-    fn do_complex_eigenvalues(t: &MatrixN<N, D>, out: &mut VectorN<NumComplex<N>, D>)
+    fn do_complex_eigenvalues(t: &OMatrix<T, D, D>, out: &mut OVector<NumComplex<T>, D>)
     where
-        N: RealField,
-        DefaultAllocator: Allocator<NumComplex<N>, D>,
+        T: RealField,
+        DefaultAllocator: Allocator<NumComplex<T>, D>,
     {
         let dim = t.nrows();
         let mut m = 0;
@@ -298,7 +305,7 @@ where
             let n = m + 1;
 
             if t[(n, m)].is_zero() {
-                out[m] = NumComplex::new(t[(m, m)], N::zero());
+                out[m] = NumComplex::new(t[(m, m)], T::zero());
                 m += 1;
             } else {
                 // Solve the 2x2 eigenvalue subproblem.
@@ -313,25 +320,25 @@ where
 
                 // All 2x2 blocks have negative discriminant because we already decoupled those
                 // with positive eigenvalues.
-                let sqrt_discr = NumComplex::new(N::zero(), (-discr).sqrt());
+                let sqrt_discr = NumComplex::new(T::zero(), (-discr).sqrt());
 
                 let half_tra = (hnn + hmm) * crate::convert(0.5);
-                out[m] = NumComplex::new(half_tra, N::zero()) + sqrt_discr;
-                out[m + 1] = NumComplex::new(half_tra, N::zero()) - sqrt_discr;
+                out[m] = NumComplex::new(half_tra, T::zero()) + sqrt_discr;
+                out[m + 1] = NumComplex::new(half_tra, T::zero()) - sqrt_discr;
 
                 m += 2;
             }
         }
 
         if m == dim - 1 {
-            out[m] = NumComplex::new(t[(m, m)], N::zero());
+            out[m] = NumComplex::new(t[(m, m)], T::zero());
         }
     }
 
-    fn delimit_subproblem(t: &mut MatrixN<N, D>, eps: N::RealField, end: usize) -> (usize, usize)
+    fn delimit_subproblem(t: &mut OMatrix<T, D, D>, eps: T::RealField, end: usize) -> (usize, usize)
     where
         D: DimSub<U1>,
-        DefaultAllocator: Allocator<N, DimDiff<D, U1>>,
+        DefaultAllocator: Allocator<T, DimDiff<D, U1>>,
     {
         let mut n = end;
 
@@ -339,7 +346,7 @@ where
             let m = n - 1;
 
             if t[(n, m)].norm1() <= eps * (t[(n, n)].norm1() + t[(m, m)].norm1()) {
-                t[(n, m)] = N::zero();
+                t[(n, m)] = T::zero();
             } else {
                 break;
             }
@@ -359,7 +366,7 @@ where
             if off_diag.is_zero()
                 || off_diag.norm1() <= eps * (t[(new_start, new_start)].norm1() + t[(m, m)].norm1())
             {
-                t[(new_start, m)] = N::zero();
+                t[(new_start, m)] = T::zero();
                 break;
             }
 
@@ -371,16 +378,17 @@ where
 
     /// Retrieves the unitary matrix `Q` and the upper-quasitriangular matrix `T` such that the
     /// decomposed matrix equals `Q * T * Q.transpose()`.
-    pub fn unpack(self) -> (MatrixN<N, D>, MatrixN<N, D>) {
+    pub fn unpack(self) -> (OMatrix<T, D, D>, OMatrix<T, D, D>) {
         (self.q, self.t)
     }
 
     /// Computes the real eigenvalues of the decomposed matrix.
     ///
     /// Return `None` if some eigenvalues are complex.
-    pub fn eigenvalues(&self) -> Option<VectorN<N, D>> {
-        let mut out =
-            unsafe { crate::unimplemented_or_uninitialized_generic!(self.t.data.shape().0, U1) };
+    pub fn eigenvalues(&self) -> Option<OVector<T, D>> {
+        let mut out = unsafe {
+            crate::unimplemented_or_uninitialized_generic!(self.t.data.shape().0, Const::<1>)
+        };
         if Self::do_eigenvalues(&self.t, &mut out) {
             Some(out)
         } else {
@@ -389,40 +397,41 @@ where
     }
 
     /// Computes the complex eigenvalues of the decomposed matrix.
-    pub fn complex_eigenvalues(&self) -> VectorN<NumComplex<N>, D>
+    pub fn complex_eigenvalues(&self) -> OVector<NumComplex<T>, D>
     where
-        N: RealField,
-        DefaultAllocator: Allocator<NumComplex<N>, D>,
+        T: RealField,
+        DefaultAllocator: Allocator<NumComplex<T>, D>,
     {
-        let mut out =
-            unsafe { crate::unimplemented_or_uninitialized_generic!(self.t.data.shape().0, U1) };
+        let mut out = unsafe {
+            crate::unimplemented_or_uninitialized_generic!(self.t.data.shape().0, Const::<1>)
+        };
         Self::do_complex_eigenvalues(&self.t, &mut out);
         out
     }
 }
 
-fn decompose_2x2<N: ComplexField, D: Dim>(
-    mut m: MatrixN<N, D>,
+fn decompose_2x2<T: ComplexField, D: Dim>(
+    mut m: OMatrix<T, D, D>,
     compute_q: bool,
-) -> Option<(Option<MatrixN<N, D>>, MatrixN<N, D>)>
+) -> Option<(Option<OMatrix<T, D, D>>, OMatrix<T, D, D>)>
 where
-    DefaultAllocator: Allocator<N, D, D>,
+    DefaultAllocator: Allocator<T, D, D>,
 {
     let dim = m.data.shape().0;
     let mut q = None;
-    match compute_2x2_basis(&m.fixed_slice::<U2, U2>(0, 0)) {
+    match compute_2x2_basis(&m.fixed_slice::<2, 2>(0, 0)) {
         Some(rot) => {
-            let mut m = m.fixed_slice_mut::<U2, U2>(0, 0);
+            let mut m = m.fixed_slice_mut::<2, 2>(0, 0);
             let inv_rot = rot.inverse();
             inv_rot.rotate(&mut m);
             rot.rotate_rows(&mut m);
-            m[(1, 0)] = N::zero();
+            m[(1, 0)] = T::zero();
 
             if compute_q {
                 // XXX: we have to build the matrix manually because
                 // rot.to_rotation_matrix().unwrap() causes an ICE.
-                let c = N::from_real(rot.c());
-                q = Some(MatrixN::from_column_slice_generic(
+                let c = T::from_real(rot.c());
+                q = Some(OMatrix::from_column_slice_generic(
                     dim,
                     dim,
                     &[c, rot.s(), -rot.s().conjugate(), c],
@@ -431,7 +440,7 @@ where
         }
         None => {
             if compute_q {
-                q = Some(MatrixN::identity_generic(dim, dim));
+                q = Some(OMatrix::identity_generic(dim, dim));
             }
         }
     };
@@ -439,9 +448,9 @@ where
     Some((q, m))
 }
 
-fn compute_2x2_eigvals<N: ComplexField, S: Storage<N, U2, U2>>(
-    m: &SquareMatrix<N, U2, S>,
-) -> Option<(N, N)> {
+fn compute_2x2_eigvals<T: ComplexField, S: Storage<T, U2, U2>>(
+    m: &SquareMatrix<T, U2, S>,
+) -> Option<(T, T)> {
     // Solve the 2x2 eigenvalue subproblem.
     let h00 = m[(0, 0)];
     let h10 = m[(1, 0)];
@@ -465,9 +474,9 @@ fn compute_2x2_eigvals<N: ComplexField, S: Storage<N, U2, U2>>(
 ///
 /// Returns `None` if the matrix has complex eigenvalues, or is upper-triangular. In both case,
 /// the basis is the identity.
-fn compute_2x2_basis<N: ComplexField, S: Storage<N, U2, U2>>(
-    m: &SquareMatrix<N, U2, S>,
-) -> Option<GivensRotation<N>> {
+fn compute_2x2_basis<T: ComplexField, S: Storage<T, U2, U2>>(
+    m: &SquareMatrix<T, U2, S>,
+) -> Option<GivensRotation<T>> {
     let h10 = m[(1, 0)];
 
     if h10.is_zero() {
@@ -491,29 +500,30 @@ fn compute_2x2_basis<N: ComplexField, S: Storage<N, U2, U2>>(
     }
 }
 
-impl<N: ComplexField, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S>
+impl<T: ComplexField, D: Dim, S: Storage<T, D, D>> SquareMatrix<T, D, S>
 where
     D: DimSub<U1>, // For Hessenberg.
-    DefaultAllocator: Allocator<N, D, DimDiff<D, U1>>
-        + Allocator<N, DimDiff<D, U1>>
-        + Allocator<N, D, D>
-        + Allocator<N, D>,
+    DefaultAllocator: Allocator<T, D, DimDiff<D, U1>>
+        + Allocator<T, DimDiff<D, U1>>
+        + Allocator<T, D, D>
+        + Allocator<T, D>,
 {
     /// Computes the eigenvalues of this matrix.
-    pub fn eigenvalues(&self) -> Option<VectorN<N, D>> {
+    pub fn eigenvalues(&self) -> Option<OVector<T, D>> {
         assert!(
             self.is_square(),
             "Unable to compute eigenvalues of a non-square matrix."
         );
 
-        let mut work =
-            unsafe { crate::unimplemented_or_uninitialized_generic!(self.data.shape().0, U1) };
+        let mut work = unsafe {
+            crate::unimplemented_or_uninitialized_generic!(self.data.shape().0, Const::<1>)
+        };
 
         // Special case for 2x2 matrices.
         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::<U2, U2>(0, 0);
+            let me = self.fixed_slice::<2, 2>(0, 0);
             return match compute_2x2_eigvals(&me) {
                 Some((a, b)) => {
                     work[0] = a;
@@ -528,7 +538,7 @@ where
         let schur = Schur::do_decompose(
             self.clone_owned(),
             &mut work,
-            N::RealField::default_epsilon(),
+            T::RealField::default_epsilon(),
             0,
             false,
         )
@@ -541,24 +551,24 @@ where
     }
 
     /// Computes the eigenvalues of this matrix.
-    pub fn complex_eigenvalues(&self) -> VectorN<NumComplex<N>, D>
+    pub fn complex_eigenvalues(&self) -> OVector<NumComplex<T>, D>
     // TODO: add balancing?
     where
-        N: RealField,
-        DefaultAllocator: Allocator<NumComplex<N>, D>,
+        T: RealField,
+        DefaultAllocator: Allocator<NumComplex<T>, D>,
     {
         let dim = self.data.shape().0;
-        let mut work = unsafe { crate::unimplemented_or_uninitialized_generic!(dim, U1) };
+        let mut work = unsafe { crate::unimplemented_or_uninitialized_generic!(dim, Const::<1>) };
 
         let schur = Schur::do_decompose(
             self.clone_owned(),
             &mut work,
-            N::default_epsilon(),
+            T::default_epsilon(),
             0,
             false,
         )
         .unwrap();
-        let mut eig = unsafe { crate::unimplemented_or_uninitialized_generic!(dim, U1) };
+        let mut eig = unsafe { crate::unimplemented_or_uninitialized_generic!(dim, Const::<1>) };
         Schur::do_complex_eigenvalues(&schur.1, &mut eig);
         eig
     }
diff --git a/src/linalg/solve.rs b/src/linalg/solve.rs
index dddc5ecf..8fdab47e 100644
--- a/src/linalg/solve.rs
+++ b/src/linalg/solve.rs
@@ -5,19 +5,19 @@ 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, MatrixMN, SquareMatrix, Vector};
+use crate::base::{DVectorSlice, DefaultAllocator, Matrix, OMatrix, SquareMatrix, Vector};
 
-impl<N: ComplexField, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
+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
     /// the lower-triangular part of `self` (including the diagonal) is considered not-zero.
     #[inline]
     pub fn solve_lower_triangular<R2: Dim, C2: Dim, S2>(
         &self,
-        b: &Matrix<N, R2, C2, S2>,
-    ) -> Option<MatrixMN<N, R2, C2>>
+        b: &Matrix<T, R2, C2, S2>,
+    ) -> Option<OMatrix<T, R2, C2>>
     where
-        S2: Storage<N, R2, C2>,
-        DefaultAllocator: Allocator<N, R2, C2>,
+        S2: Storage<T, R2, C2>,
+        DefaultAllocator: Allocator<T, R2, C2>,
         ShapeConstraint: SameNumberOfRows<R2, D>,
     {
         let mut res = b.clone_owned();
@@ -33,11 +33,11 @@ impl<N: ComplexField, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
     #[inline]
     pub fn solve_upper_triangular<R2: Dim, C2: Dim, S2>(
         &self,
-        b: &Matrix<N, R2, C2, S2>,
-    ) -> Option<MatrixMN<N, R2, C2>>
+        b: &Matrix<T, R2, C2, S2>,
+    ) -> Option<OMatrix<T, R2, C2>>
     where
-        S2: Storage<N, R2, C2>,
-        DefaultAllocator: Allocator<N, R2, C2>,
+        S2: Storage<T, R2, C2>,
+        DefaultAllocator: Allocator<T, R2, C2>,
         ShapeConstraint: SameNumberOfRows<R2, D>,
     {
         let mut res = b.clone_owned();
@@ -52,10 +52,10 @@ impl<N: ComplexField, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
     /// lower-triangular part of `self` (including the diagonal) is considered not-zero.
     pub fn solve_lower_triangular_mut<R2: Dim, C2: Dim, S2>(
         &self,
-        b: &mut Matrix<N, R2, C2, S2>,
+        b: &mut Matrix<T, R2, C2, S2>,
     ) -> bool
     where
-        S2: StorageMut<N, R2, C2>,
+        S2: StorageMut<T, R2, C2>,
         ShapeConstraint: SameNumberOfRows<R2, D>,
     {
         let cols = b.ncols();
@@ -69,9 +69,9 @@ impl<N: ComplexField, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
         true
     }
 
-    fn solve_lower_triangular_vector_mut<R2: Dim, S2>(&self, b: &mut Vector<N, R2, S2>) -> bool
+    fn solve_lower_triangular_vector_mut<R2: Dim, S2>(&self, b: &mut Vector<T, R2, S2>) -> bool
     where
-        S2: StorageMut<N, R2, U1>,
+        S2: StorageMut<T, R2, U1>,
         ShapeConstraint: SameNumberOfRows<R2, D>,
     {
         let dim = self.nrows();
@@ -91,7 +91,7 @@ impl<N: ComplexField, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
             }
 
             b.rows_range_mut(i + 1..)
-                .axpy(-coeff, &self.slice_range(i + 1.., i), N::one());
+                .axpy(-coeff, &self.slice_range(i + 1.., i), T::one());
         }
 
         true
@@ -103,11 +103,11 @@ impl<N: ComplexField, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
     /// assumed to be equal to `diag`. Returns `false` and does not modify its inputs if `diag` is zero.
     pub fn solve_lower_triangular_with_diag_mut<R2: Dim, C2: Dim, S2>(
         &self,
-        b: &mut Matrix<N, R2, C2, S2>,
-        diag: N,
+        b: &mut Matrix<T, R2, C2, S2>,
+        diag: T,
     ) -> bool
     where
-        S2: StorageMut<N, R2, C2>,
+        S2: StorageMut<T, R2, C2>,
         ShapeConstraint: SameNumberOfRows<R2, D>,
     {
         if diag.is_zero() {
@@ -123,7 +123,7 @@ impl<N: ComplexField, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
             for i in 0..dim - 1 {
                 let coeff = unsafe { *bcol.vget_unchecked(i) } / diag;
                 bcol.rows_range_mut(i + 1..)
-                    .axpy(-coeff, &self.slice_range(i + 1.., i), N::one());
+                    .axpy(-coeff, &self.slice_range(i + 1.., i), T::one());
             }
         }
 
@@ -134,10 +134,10 @@ impl<N: ComplexField, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
     /// upper-triangular part of `self` (including the diagonal) is considered not-zero.
     pub fn solve_upper_triangular_mut<R2: Dim, C2: Dim, S2>(
         &self,
-        b: &mut Matrix<N, R2, C2, S2>,
+        b: &mut Matrix<T, R2, C2, S2>,
     ) -> bool
     where
-        S2: StorageMut<N, R2, C2>,
+        S2: StorageMut<T, R2, C2>,
         ShapeConstraint: SameNumberOfRows<R2, D>,
     {
         let cols = b.ncols();
@@ -151,9 +151,9 @@ impl<N: ComplexField, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
         true
     }
 
-    fn solve_upper_triangular_vector_mut<R2: Dim, S2>(&self, b: &mut Vector<N, R2, S2>) -> bool
+    fn solve_upper_triangular_vector_mut<R2: Dim, S2>(&self, b: &mut Vector<T, R2, S2>) -> bool
     where
-        S2: StorageMut<N, R2, U1>,
+        S2: StorageMut<T, R2, U1>,
         ShapeConstraint: SameNumberOfRows<R2, D>,
     {
         let dim = self.nrows();
@@ -173,7 +173,7 @@ impl<N: ComplexField, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
             }
 
             b.rows_range_mut(..i)
-                .axpy(-coeff, &self.slice_range(..i, i), N::one());
+                .axpy(-coeff, &self.slice_range(..i, i), T::one());
         }
 
         true
@@ -189,11 +189,11 @@ impl<N: ComplexField, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
     #[inline]
     pub fn tr_solve_lower_triangular<R2: Dim, C2: Dim, S2>(
         &self,
-        b: &Matrix<N, R2, C2, S2>,
-    ) -> Option<MatrixMN<N, R2, C2>>
+        b: &Matrix<T, R2, C2, S2>,
+    ) -> Option<OMatrix<T, R2, C2>>
     where
-        S2: Storage<N, R2, C2>,
-        DefaultAllocator: Allocator<N, R2, C2>,
+        S2: Storage<T, R2, C2>,
+        DefaultAllocator: Allocator<T, R2, C2>,
         ShapeConstraint: SameNumberOfRows<R2, D>,
     {
         let mut res = b.clone_owned();
@@ -209,11 +209,11 @@ impl<N: ComplexField, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
     #[inline]
     pub fn tr_solve_upper_triangular<R2: Dim, C2: Dim, S2>(
         &self,
-        b: &Matrix<N, R2, C2, S2>,
-    ) -> Option<MatrixMN<N, R2, C2>>
+        b: &Matrix<T, R2, C2, S2>,
+    ) -> Option<OMatrix<T, R2, C2>>
     where
-        S2: Storage<N, R2, C2>,
-        DefaultAllocator: Allocator<N, R2, C2>,
+        S2: Storage<T, R2, C2>,
+        DefaultAllocator: Allocator<T, R2, C2>,
         ShapeConstraint: SameNumberOfRows<R2, D>,
     {
         let mut res = b.clone_owned();
@@ -228,10 +228,10 @@ impl<N: ComplexField, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
     /// lower-triangular part of `self` (including the diagonal) is considered not-zero.
     pub fn tr_solve_lower_triangular_mut<R2: Dim, C2: Dim, S2>(
         &self,
-        b: &mut Matrix<N, R2, C2, S2>,
+        b: &mut Matrix<T, R2, C2, S2>,
     ) -> bool
     where
-        S2: StorageMut<N, R2, C2>,
+        S2: StorageMut<T, R2, C2>,
         ShapeConstraint: SameNumberOfRows<R2, D>,
     {
         let cols = b.ncols();
@@ -253,10 +253,10 @@ impl<N: ComplexField, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
     /// upper-triangular part of `self` (including the diagonal) is considered not-zero.
     pub fn tr_solve_upper_triangular_mut<R2: Dim, C2: Dim, S2>(
         &self,
-        b: &mut Matrix<N, R2, C2, S2>,
+        b: &mut Matrix<T, R2, C2, S2>,
     ) -> bool
     where
-        S2: StorageMut<N, R2, C2>,
+        S2: StorageMut<T, R2, C2>,
         ShapeConstraint: SameNumberOfRows<R2, D>,
     {
         let cols = b.ncols();
@@ -279,11 +279,11 @@ impl<N: ComplexField, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
     #[inline]
     pub fn ad_solve_lower_triangular<R2: Dim, C2: Dim, S2>(
         &self,
-        b: &Matrix<N, R2, C2, S2>,
-    ) -> Option<MatrixMN<N, R2, C2>>
+        b: &Matrix<T, R2, C2, S2>,
+    ) -> Option<OMatrix<T, R2, C2>>
     where
-        S2: Storage<N, R2, C2>,
-        DefaultAllocator: Allocator<N, R2, C2>,
+        S2: Storage<T, R2, C2>,
+        DefaultAllocator: Allocator<T, R2, C2>,
         ShapeConstraint: SameNumberOfRows<R2, D>,
     {
         let mut res = b.clone_owned();
@@ -299,11 +299,11 @@ impl<N: ComplexField, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
     #[inline]
     pub fn ad_solve_upper_triangular<R2: Dim, C2: Dim, S2>(
         &self,
-        b: &Matrix<N, R2, C2, S2>,
-    ) -> Option<MatrixMN<N, R2, C2>>
+        b: &Matrix<T, R2, C2, S2>,
+    ) -> Option<OMatrix<T, R2, C2>>
     where
-        S2: Storage<N, R2, C2>,
-        DefaultAllocator: Allocator<N, R2, C2>,
+        S2: Storage<T, R2, C2>,
+        DefaultAllocator: Allocator<T, R2, C2>,
         ShapeConstraint: SameNumberOfRows<R2, D>,
     {
         let mut res = b.clone_owned();
@@ -318,10 +318,10 @@ impl<N: ComplexField, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
     /// lower-triangular part of `self` (including the diagonal) is considered not-zero.
     pub fn ad_solve_lower_triangular_mut<R2: Dim, C2: Dim, S2>(
         &self,
-        b: &mut Matrix<N, R2, C2, S2>,
+        b: &mut Matrix<T, R2, C2, S2>,
     ) -> bool
     where
-        S2: StorageMut<N, R2, C2>,
+        S2: StorageMut<T, R2, C2>,
         ShapeConstraint: SameNumberOfRows<R2, D>,
     {
         let cols = b.ncols();
@@ -343,10 +343,10 @@ impl<N: ComplexField, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
     /// upper-triangular part of `self` (including the diagonal) is considered not-zero.
     pub fn ad_solve_upper_triangular_mut<R2: Dim, C2: Dim, S2>(
         &self,
-        b: &mut Matrix<N, R2, C2, S2>,
+        b: &mut Matrix<T, R2, C2, S2>,
     ) -> bool
     where
-        S2: StorageMut<N, R2, C2>,
+        S2: StorageMut<T, R2, C2>,
         ShapeConstraint: SameNumberOfRows<R2, D>,
     {
         let cols = b.ncols();
@@ -367,15 +367,15 @@ impl<N: ComplexField, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
     #[inline(always)]
     fn xx_solve_lower_triangular_vector_mut<R2: Dim, S2>(
         &self,
-        b: &mut Vector<N, R2, S2>,
-        conjugate: impl Fn(N) -> N,
+        b: &mut Vector<T, R2, S2>,
+        conjugate: impl Fn(T) -> T,
         dot: impl Fn(
-            &DVectorSlice<N, S::RStride, S::CStride>,
-            &DVectorSlice<N, S2::RStride, S2::CStride>,
-        ) -> N,
+            &DVectorSlice<T, S::RStride, S::CStride>,
+            &DVectorSlice<T, S2::RStride, S2::CStride>,
+        ) -> T,
     ) -> bool
     where
-        S2: StorageMut<N, R2, U1>,
+        S2: StorageMut<T, R2, U1>,
         ShapeConstraint: SameNumberOfRows<R2, D>,
     {
         let dim = self.nrows();
@@ -402,15 +402,15 @@ impl<N: ComplexField, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
     #[inline(always)]
     fn xx_solve_upper_triangular_vector_mut<R2: Dim, S2>(
         &self,
-        b: &mut Vector<N, R2, S2>,
-        conjugate: impl Fn(N) -> N,
+        b: &mut Vector<T, R2, S2>,
+        conjugate: impl Fn(T) -> T,
         dot: impl Fn(
-            &DVectorSlice<N, S::RStride, S::CStride>,
-            &DVectorSlice<N, S2::RStride, S2::CStride>,
-        ) -> N,
+            &DVectorSlice<T, S::RStride, S::CStride>,
+            &DVectorSlice<T, S2::RStride, S2::CStride>,
+        ) -> T,
     ) -> bool
     where
-        S2: StorageMut<N, R2, U1>,
+        S2: StorageMut<T, R2, U1>,
         ShapeConstraint: SameNumberOfRows<R2, D>,
     {
         let dim = self.nrows();
@@ -440,17 +440,17 @@ impl<N: ComplexField, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
  *
  */
 
-impl<N: SimdComplexField, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
+impl<T: SimdComplexField, 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
     /// the lower-triangular part of `self` (including the diagonal) is considered not-zero.
     #[inline]
     pub fn solve_lower_triangular_unchecked<R2: Dim, C2: Dim, S2>(
         &self,
-        b: &Matrix<N, R2, C2, S2>,
-    ) -> MatrixMN<N, R2, C2>
+        b: &Matrix<T, R2, C2, S2>,
+    ) -> OMatrix<T, R2, C2>
     where
-        S2: Storage<N, R2, C2>,
-        DefaultAllocator: Allocator<N, R2, C2>,
+        S2: Storage<T, R2, C2>,
+        DefaultAllocator: Allocator<T, R2, C2>,
         ShapeConstraint: SameNumberOfRows<R2, D>,
     {
         let mut res = b.clone_owned();
@@ -463,11 +463,11 @@ impl<N: SimdComplexField, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
     #[inline]
     pub fn solve_upper_triangular_unchecked<R2: Dim, C2: Dim, S2>(
         &self,
-        b: &Matrix<N, R2, C2, S2>,
-    ) -> MatrixMN<N, R2, C2>
+        b: &Matrix<T, R2, C2, S2>,
+    ) -> OMatrix<T, R2, C2>
     where
-        S2: Storage<N, R2, C2>,
-        DefaultAllocator: Allocator<N, R2, C2>,
+        S2: Storage<T, R2, C2>,
+        DefaultAllocator: Allocator<T, R2, C2>,
         ShapeConstraint: SameNumberOfRows<R2, D>,
     {
         let mut res = b.clone_owned();
@@ -479,9 +479,9 @@ impl<N: SimdComplexField, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
     /// lower-triangular part of `self` (including the diagonal) is considered not-zero.
     pub fn solve_lower_triangular_unchecked_mut<R2: Dim, C2: Dim, S2>(
         &self,
-        b: &mut Matrix<N, R2, C2, S2>,
+        b: &mut Matrix<T, R2, C2, S2>,
     ) where
-        S2: StorageMut<N, R2, C2>,
+        S2: StorageMut<T, R2, C2>,
         ShapeConstraint: SameNumberOfRows<R2, D>,
     {
         for i in 0..b.ncols() {
@@ -489,9 +489,9 @@ impl<N: SimdComplexField, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
         }
     }
 
-    fn solve_lower_triangular_vector_unchecked_mut<R2: Dim, S2>(&self, b: &mut Vector<N, R2, S2>)
+    fn solve_lower_triangular_vector_unchecked_mut<R2: Dim, S2>(&self, b: &mut Vector<T, R2, S2>)
     where
-        S2: StorageMut<N, R2, U1>,
+        S2: StorageMut<T, R2, U1>,
         ShapeConstraint: SameNumberOfRows<R2, D>,
     {
         let dim = self.nrows();
@@ -506,7 +506,7 @@ impl<N: SimdComplexField, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
             }
 
             b.rows_range_mut(i + 1..)
-                .axpy(-coeff, &self.slice_range(i + 1.., i), N::one());
+                .axpy(-coeff, &self.slice_range(i + 1.., i), T::one());
         }
     }
 
@@ -516,10 +516,10 @@ impl<N: SimdComplexField, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
     /// assumed to be equal to `diag`. Returns `false` and does not modify its inputs if `diag` is zero.
     pub fn solve_lower_triangular_with_diag_unchecked_mut<R2: Dim, C2: Dim, S2>(
         &self,
-        b: &mut Matrix<N, R2, C2, S2>,
-        diag: N,
+        b: &mut Matrix<T, R2, C2, S2>,
+        diag: T,
     ) where
-        S2: StorageMut<N, R2, C2>,
+        S2: StorageMut<T, R2, C2>,
         ShapeConstraint: SameNumberOfRows<R2, D>,
     {
         let dim = self.nrows();
@@ -531,7 +531,7 @@ impl<N: SimdComplexField, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
             for i in 0..dim - 1 {
                 let coeff = unsafe { *bcol.vget_unchecked(i) } / diag;
                 bcol.rows_range_mut(i + 1..)
-                    .axpy(-coeff, &self.slice_range(i + 1.., i), N::one());
+                    .axpy(-coeff, &self.slice_range(i + 1.., i), T::one());
             }
         }
     }
@@ -540,9 +540,9 @@ impl<N: SimdComplexField, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
     /// upper-triangular part of `self` (including the diagonal) is considered not-zero.
     pub fn solve_upper_triangular_unchecked_mut<R2: Dim, C2: Dim, S2>(
         &self,
-        b: &mut Matrix<N, R2, C2, S2>,
+        b: &mut Matrix<T, R2, C2, S2>,
     ) where
-        S2: StorageMut<N, R2, C2>,
+        S2: StorageMut<T, R2, C2>,
         ShapeConstraint: SameNumberOfRows<R2, D>,
     {
         for i in 0..b.ncols() {
@@ -550,9 +550,9 @@ impl<N: SimdComplexField, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
         }
     }
 
-    fn solve_upper_triangular_vector_unchecked_mut<R2: Dim, S2>(&self, b: &mut Vector<N, R2, S2>)
+    fn solve_upper_triangular_vector_unchecked_mut<R2: Dim, S2>(&self, b: &mut Vector<T, R2, S2>)
     where
-        S2: StorageMut<N, R2, U1>,
+        S2: StorageMut<T, R2, U1>,
         ShapeConstraint: SameNumberOfRows<R2, D>,
     {
         let dim = self.nrows();
@@ -567,7 +567,7 @@ impl<N: SimdComplexField, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
             }
 
             b.rows_range_mut(..i)
-                .axpy(-coeff, &self.slice_range(..i, i), N::one());
+                .axpy(-coeff, &self.slice_range(..i, i), T::one());
         }
     }
 
@@ -581,11 +581,11 @@ impl<N: SimdComplexField, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
     #[inline]
     pub fn tr_solve_lower_triangular_unchecked<R2: Dim, C2: Dim, S2>(
         &self,
-        b: &Matrix<N, R2, C2, S2>,
-    ) -> MatrixMN<N, R2, C2>
+        b: &Matrix<T, R2, C2, S2>,
+    ) -> OMatrix<T, R2, C2>
     where
-        S2: Storage<N, R2, C2>,
-        DefaultAllocator: Allocator<N, R2, C2>,
+        S2: Storage<T, R2, C2>,
+        DefaultAllocator: Allocator<T, R2, C2>,
         ShapeConstraint: SameNumberOfRows<R2, D>,
     {
         let mut res = b.clone_owned();
@@ -598,11 +598,11 @@ impl<N: SimdComplexField, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
     #[inline]
     pub fn tr_solve_upper_triangular_unchecked<R2: Dim, C2: Dim, S2>(
         &self,
-        b: &Matrix<N, R2, C2, S2>,
-    ) -> MatrixMN<N, R2, C2>
+        b: &Matrix<T, R2, C2, S2>,
+    ) -> OMatrix<T, R2, C2>
     where
-        S2: Storage<N, R2, C2>,
-        DefaultAllocator: Allocator<N, R2, C2>,
+        S2: Storage<T, R2, C2>,
+        DefaultAllocator: Allocator<T, R2, C2>,
         ShapeConstraint: SameNumberOfRows<R2, D>,
     {
         let mut res = b.clone_owned();
@@ -614,9 +614,9 @@ impl<N: SimdComplexField, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
     /// lower-triangular part of `self` (including the diagonal) is considered not-zero.
     pub fn tr_solve_lower_triangular_unchecked_mut<R2: Dim, C2: Dim, S2>(
         &self,
-        b: &mut Matrix<N, R2, C2, S2>,
+        b: &mut Matrix<T, R2, C2, S2>,
     ) where
-        S2: StorageMut<N, R2, C2>,
+        S2: StorageMut<T, R2, C2>,
         ShapeConstraint: SameNumberOfRows<R2, D>,
     {
         for i in 0..b.ncols() {
@@ -632,9 +632,9 @@ impl<N: SimdComplexField, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
     /// upper-triangular part of `self` (including the diagonal) is considered not-zero.
     pub fn tr_solve_upper_triangular_unchecked_mut<R2: Dim, C2: Dim, S2>(
         &self,
-        b: &mut Matrix<N, R2, C2, S2>,
+        b: &mut Matrix<T, R2, C2, S2>,
     ) where
-        S2: StorageMut<N, R2, C2>,
+        S2: StorageMut<T, R2, C2>,
         ShapeConstraint: SameNumberOfRows<R2, D>,
     {
         for i in 0..b.ncols() {
@@ -651,11 +651,11 @@ impl<N: SimdComplexField, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
     #[inline]
     pub fn ad_solve_lower_triangular_unchecked<R2: Dim, C2: Dim, S2>(
         &self,
-        b: &Matrix<N, R2, C2, S2>,
-    ) -> MatrixMN<N, R2, C2>
+        b: &Matrix<T, R2, C2, S2>,
+    ) -> OMatrix<T, R2, C2>
     where
-        S2: Storage<N, R2, C2>,
-        DefaultAllocator: Allocator<N, R2, C2>,
+        S2: Storage<T, R2, C2>,
+        DefaultAllocator: Allocator<T, R2, C2>,
         ShapeConstraint: SameNumberOfRows<R2, D>,
     {
         let mut res = b.clone_owned();
@@ -668,11 +668,11 @@ impl<N: SimdComplexField, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
     #[inline]
     pub fn ad_solve_upper_triangular_unchecked<R2: Dim, C2: Dim, S2>(
         &self,
-        b: &Matrix<N, R2, C2, S2>,
-    ) -> MatrixMN<N, R2, C2>
+        b: &Matrix<T, R2, C2, S2>,
+    ) -> OMatrix<T, R2, C2>
     where
-        S2: Storage<N, R2, C2>,
-        DefaultAllocator: Allocator<N, R2, C2>,
+        S2: Storage<T, R2, C2>,
+        DefaultAllocator: Allocator<T, R2, C2>,
         ShapeConstraint: SameNumberOfRows<R2, D>,
     {
         let mut res = b.clone_owned();
@@ -684,9 +684,9 @@ impl<N: SimdComplexField, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
     /// lower-triangular part of `self` (including the diagonal) is considered not-zero.
     pub fn ad_solve_lower_triangular_unchecked_mut<R2: Dim, C2: Dim, S2>(
         &self,
-        b: &mut Matrix<N, R2, C2, S2>,
+        b: &mut Matrix<T, R2, C2, S2>,
     ) where
-        S2: StorageMut<N, R2, C2>,
+        S2: StorageMut<T, R2, C2>,
         ShapeConstraint: SameNumberOfRows<R2, D>,
     {
         for i in 0..b.ncols() {
@@ -702,9 +702,9 @@ impl<N: SimdComplexField, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
     /// upper-triangular part of `self` (including the diagonal) is considered not-zero.
     pub fn ad_solve_upper_triangular_unchecked_mut<R2: Dim, C2: Dim, S2>(
         &self,
-        b: &mut Matrix<N, R2, C2, S2>,
+        b: &mut Matrix<T, R2, C2, S2>,
     ) where
-        S2: StorageMut<N, R2, C2>,
+        S2: StorageMut<T, R2, C2>,
         ShapeConstraint: SameNumberOfRows<R2, D>,
     {
         for i in 0..b.ncols() {
@@ -719,14 +719,14 @@ impl<N: SimdComplexField, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
     #[inline(always)]
     fn xx_solve_lower_triangular_vector_unchecked_mut<R2: Dim, S2>(
         &self,
-        b: &mut Vector<N, R2, S2>,
-        conjugate: impl Fn(N) -> N,
+        b: &mut Vector<T, R2, S2>,
+        conjugate: impl Fn(T) -> T,
         dot: impl Fn(
-            &DVectorSlice<N, S::RStride, S::CStride>,
-            &DVectorSlice<N, S2::RStride, S2::CStride>,
-        ) -> N,
+            &DVectorSlice<T, S::RStride, S::CStride>,
+            &DVectorSlice<T, S2::RStride, S2::CStride>,
+        ) -> T,
     ) where
-        S2: StorageMut<N, R2, U1>,
+        S2: StorageMut<T, R2, U1>,
         ShapeConstraint: SameNumberOfRows<R2, D>,
     {
         let dim = self.nrows();
@@ -745,14 +745,14 @@ impl<N: SimdComplexField, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
     #[inline(always)]
     fn xx_solve_upper_triangular_vector_unchecked_mut<R2: Dim, S2>(
         &self,
-        b: &mut Vector<N, R2, S2>,
-        conjugate: impl Fn(N) -> N,
+        b: &mut Vector<T, R2, S2>,
+        conjugate: impl Fn(T) -> T,
         dot: impl Fn(
-            &DVectorSlice<N, S::RStride, S::CStride>,
-            &DVectorSlice<N, S2::RStride, S2::CStride>,
-        ) -> N,
+            &DVectorSlice<T, S::RStride, S::CStride>,
+            &DVectorSlice<T, S2::RStride, S2::CStride>,
+        ) -> T,
     ) where
-        S2: StorageMut<N, R2, U1>,
+        S2: StorageMut<T, R2, U1>,
         ShapeConstraint: SameNumberOfRows<R2, D>,
     {
         for i in 0..self.nrows() {
diff --git a/src/linalg/svd.rs b/src/linalg/svd.rs
index 1e942e69..b259ae95 100644
--- a/src/linalg/svd.rs
+++ b/src/linalg/svd.rs
@@ -5,9 +5,9 @@ use approx::AbsDiffEq;
 use num::{One, Zero};
 
 use crate::allocator::Allocator;
-use crate::base::{DefaultAllocator, Matrix, Matrix2x3, MatrixMN, Vector2, VectorN};
+use crate::base::{DefaultAllocator, Matrix, Matrix2x3, OMatrix, OVector, Vector2};
 use crate::constraint::{SameNumberOfRows, ShapeConstraint};
-use crate::dimension::{Dim, DimDiff, DimMin, DimMinimum, DimSub, U1, U2};
+use crate::dimension::{Dim, DimDiff, DimMin, DimMinimum, DimSub, U1};
 use crate::storage::Storage;
 use simba::scalar::{ComplexField, RealField};
 
@@ -20,71 +20,71 @@ use crate::linalg::Bidiagonal;
 #[cfg_attr(
     feature = "serde-serialize",
     serde(bound(
-        serialize = "DefaultAllocator: Allocator<N::RealField, DimMinimum<R, C>>    +
-                           Allocator<N, DimMinimum<R, C>, C> +
-                           Allocator<N, R, DimMinimum<R, C>>,
-         MatrixMN<N, R, DimMinimum<R, C>>: Serialize,
-         MatrixMN<N, DimMinimum<R, C>, C>: Serialize,
-         VectorN<N::RealField, DimMinimum<R, C>>: Serialize"
+        serialize = "DefaultAllocator: Allocator<T::RealField, DimMinimum<R, C>>    +
+                           Allocator<T, DimMinimum<R, C>, C> +
+                           Allocator<T, R, DimMinimum<R, C>>,
+         OMatrix<T, R, DimMinimum<R, C>>: Serialize,
+         OMatrix<T, DimMinimum<R, C>, C>: Serialize,
+         OVector<T::RealField, DimMinimum<R, C>>: Serialize"
     ))
 )]
 #[cfg_attr(
     feature = "serde-serialize",
     serde(bound(
-        deserialize = "DefaultAllocator: Allocator<N::RealField, DimMinimum<R, C>>    +
-                           Allocator<N, DimMinimum<R, C>, C> +
-                           Allocator<N, R, DimMinimum<R, C>>,
-         MatrixMN<N, R, DimMinimum<R, C>>: Deserialize<'de>,
-         MatrixMN<N, DimMinimum<R, C>, C>: Deserialize<'de>,
-         VectorN<N::RealField, DimMinimum<R, C>>: Deserialize<'de>"
+        deserialize = "DefaultAllocator: Allocator<T::RealField, DimMinimum<R, C>>    +
+                           Allocator<T, DimMinimum<R, C>, C> +
+                           Allocator<T, R, DimMinimum<R, C>>,
+         OMatrix<T, R, DimMinimum<R, C>>: Deserialize<'de>,
+         OMatrix<T, DimMinimum<R, C>, C>: Deserialize<'de>,
+         OVector<T::RealField, DimMinimum<R, C>>: Deserialize<'de>"
     ))
 )]
 #[derive(Clone, Debug)]
-pub struct SVD<N: ComplexField, R: DimMin<C>, C: Dim>
+pub struct SVD<T: ComplexField, R: DimMin<C>, C: Dim>
 where
-    DefaultAllocator: Allocator<N, DimMinimum<R, C>, C>
-        + Allocator<N, R, DimMinimum<R, C>>
-        + Allocator<N::RealField, DimMinimum<R, C>>,
+    DefaultAllocator: Allocator<T, DimMinimum<R, C>, C>
+        + Allocator<T, R, DimMinimum<R, C>>
+        + Allocator<T::RealField, DimMinimum<R, C>>,
 {
     /// The left-singular vectors `U` of this SVD.
-    pub u: Option<MatrixMN<N, R, DimMinimum<R, C>>>,
+    pub u: Option<OMatrix<T, R, DimMinimum<R, C>>>,
     /// The right-singular vectors `V^t` of this SVD.
-    pub v_t: Option<MatrixMN<N, DimMinimum<R, C>, C>>,
+    pub v_t: Option<OMatrix<T, DimMinimum<R, C>, C>>,
     /// The singular values of this SVD.
-    pub singular_values: VectorN<N::RealField, DimMinimum<R, C>>,
+    pub singular_values: OVector<T::RealField, DimMinimum<R, C>>,
 }
 
-impl<N: ComplexField, R: DimMin<C>, C: Dim> Copy for SVD<N, R, C>
+impl<T: ComplexField, R: DimMin<C>, C: Dim> Copy for SVD<T, R, C>
 where
-    DefaultAllocator: Allocator<N, DimMinimum<R, C>, C>
-        + Allocator<N, R, DimMinimum<R, C>>
-        + Allocator<N::RealField, DimMinimum<R, C>>,
-    MatrixMN<N, R, DimMinimum<R, C>>: Copy,
-    MatrixMN<N, DimMinimum<R, C>, C>: Copy,
-    VectorN<N::RealField, DimMinimum<R, C>>: Copy,
+    DefaultAllocator: Allocator<T, DimMinimum<R, C>, C>
+        + Allocator<T, R, DimMinimum<R, C>>
+        + Allocator<T::RealField, DimMinimum<R, C>>,
+    OMatrix<T, R, DimMinimum<R, C>>: Copy,
+    OMatrix<T, DimMinimum<R, C>, C>: Copy,
+    OVector<T::RealField, DimMinimum<R, C>>: Copy,
 {
 }
 
-impl<N: ComplexField, R: DimMin<C>, C: Dim> SVD<N, R, C>
+impl<T: ComplexField, R: DimMin<C>, C: Dim> SVD<T, R, C>
 where
     DimMinimum<R, C>: DimSub<U1>, // for Bidiagonal.
-    DefaultAllocator: Allocator<N, R, C>
-        + Allocator<N, C>
-        + Allocator<N, R>
-        + Allocator<N, DimDiff<DimMinimum<R, C>, U1>>
-        + Allocator<N, DimMinimum<R, C>, C>
-        + Allocator<N, R, DimMinimum<R, C>>
-        + Allocator<N, DimMinimum<R, C>>
-        + Allocator<N::RealField, DimMinimum<R, C>>
-        + Allocator<N::RealField, DimDiff<DimMinimum<R, C>, U1>>,
+    DefaultAllocator: Allocator<T, R, C>
+        + Allocator<T, C>
+        + Allocator<T, R>
+        + Allocator<T, DimDiff<DimMinimum<R, C>, U1>>
+        + Allocator<T, DimMinimum<R, C>, C>
+        + Allocator<T, R, DimMinimum<R, C>>
+        + Allocator<T, DimMinimum<R, C>>
+        + Allocator<T::RealField, DimMinimum<R, C>>
+        + Allocator<T::RealField, DimDiff<DimMinimum<R, C>, U1>>,
 {
     /// Computes the Singular Value Decomposition of `matrix` using implicit shift.
-    pub fn new(matrix: MatrixMN<N, R, C>, compute_u: bool, compute_v: bool) -> Self {
+    pub fn new(matrix: OMatrix<T, R, C>, compute_u: bool, compute_v: bool) -> Self {
         Self::try_new(
             matrix,
             compute_u,
             compute_v,
-            N::RealField::default_epsilon(),
+            T::RealField::default_epsilon(),
             0,
         )
         .unwrap()
@@ -101,10 +101,10 @@ where
     /// number of iteration is exceeded, `None` is returned. If `niter == 0`, then the algorithm
     /// continues indefinitely until convergence.
     pub fn try_new(
-        mut matrix: MatrixMN<N, R, C>,
+        mut matrix: OMatrix<T, R, C>,
         compute_u: bool,
         compute_v: bool,
-        eps: N::RealField,
+        eps: T::RealField,
         max_niter: usize,
     ) -> Option<Self> {
         assert!(
@@ -166,7 +166,7 @@ where
 
                 for k in start..n {
                     let m12 = if k == n - 1 {
-                        N::RealField::zero()
+                        T::RealField::zero()
                     } else {
                         off_diagonal[k + 1]
                     };
@@ -174,16 +174,16 @@ where
                     let mut subm = Matrix2x3::new(
                         diagonal[k],
                         off_diagonal[k],
-                        N::RealField::zero(),
-                        N::RealField::zero(),
+                        T::RealField::zero(),
+                        T::RealField::zero(),
                         diagonal[k + 1],
                         m12,
                     );
 
                     if let Some((rot1, norm1)) = GivensRotation::cancel_y(&vec) {
                         rot1.inverse()
-                            .rotate_rows(&mut subm.fixed_columns_mut::<U2>(0));
-                        let rot1 = GivensRotation::new_unchecked(rot1.c(), N::from_real(rot1.s()));
+                            .rotate_rows(&mut subm.fixed_columns_mut::<2>(0));
+                        let rot1 = GivensRotation::new_unchecked(rot1.c(), T::from_real(rot1.s()));
 
                         if k > start {
                             // This is not the first iteration.
@@ -195,26 +195,24 @@ where
                         let (rot2, norm2) = GivensRotation::cancel_y(&v)
                             .unwrap_or((GivensRotation::identity(), subm[(0, 0)]));
 
-                        rot2.rotate(&mut subm.fixed_columns_mut::<U2>(1));
-                        let rot2 = GivensRotation::new_unchecked(rot2.c(), N::from_real(rot2.s()));
+                        rot2.rotate(&mut subm.fixed_columns_mut::<2>(1));
+                        let rot2 = GivensRotation::new_unchecked(rot2.c(), T::from_real(rot2.s()));
 
                         subm[(0, 0)] = norm2;
 
                         if let Some(ref mut v_t) = v_t {
                             if b.is_upper_diagonal() {
-                                rot1.rotate(&mut v_t.fixed_rows_mut::<U2>(k));
+                                rot1.rotate(&mut v_t.fixed_rows_mut::<2>(k));
                             } else {
-                                rot2.rotate(&mut v_t.fixed_rows_mut::<U2>(k));
+                                rot2.rotate(&mut v_t.fixed_rows_mut::<2>(k));
                             }
                         }
 
                         if let Some(ref mut u) = u {
                             if b.is_upper_diagonal() {
-                                rot2.inverse()
-                                    .rotate_rows(&mut u.fixed_columns_mut::<U2>(k));
+                                rot2.inverse().rotate_rows(&mut u.fixed_columns_mut::<2>(k));
                             } else {
-                                rot1.inverse()
-                                    .rotate_rows(&mut u.fixed_columns_mut::<U2>(k));
+                                rot1.inverse().rotate_rows(&mut u.fixed_columns_mut::<2>(k));
                             }
                         }
 
@@ -241,12 +239,12 @@ where
                     compute_u && b.is_upper_diagonal() || compute_v && !b.is_upper_diagonal(),
                     compute_v && b.is_upper_diagonal() || compute_u && !b.is_upper_diagonal(),
                 );
-                let u2 = u2.map(|u2| GivensRotation::new_unchecked(u2.c(), N::from_real(u2.s())));
-                let v2 = v2.map(|v2| GivensRotation::new_unchecked(v2.c(), N::from_real(v2.s())));
+                let u2 = u2.map(|u2| GivensRotation::new_unchecked(u2.c(), T::from_real(u2.s())));
+                let v2 = v2.map(|v2| GivensRotation::new_unchecked(v2.c(), T::from_real(v2.s())));
 
                 diagonal[start] = s[0];
                 diagonal[start + 1] = s[1];
-                off_diagonal[start] = N::RealField::zero();
+                off_diagonal[start] = T::RealField::zero();
 
                 if let Some(ref mut u) = u {
                     let rot = if b.is_upper_diagonal() {
@@ -254,7 +252,7 @@ where
                     } else {
                         v2.unwrap()
                     };
-                    rot.rotate_rows(&mut u.fixed_columns_mut::<U2>(start));
+                    rot.rotate_rows(&mut u.fixed_columns_mut::<2>(start));
                 }
 
                 if let Some(ref mut v_t) = v_t {
@@ -263,7 +261,7 @@ where
                     } else {
                         u2.unwrap()
                     };
-                    rot.inverse().rotate(&mut v_t.fixed_rows_mut::<U2>(start));
+                    rot.inverse().rotate(&mut v_t.fixed_rows_mut::<2>(start));
                 }
 
                 end -= 1;
@@ -294,7 +292,7 @@ where
         for i in 0..dim {
             let sval = diagonal[i];
 
-            if sval < N::RealField::zero() {
+            if sval < T::RealField::zero() {
                 diagonal[i] = -sval;
 
                 if let Some(ref mut u) = u {
@@ -311,7 +309,7 @@ where
     }
 
     /*
-    fn display_bidiag(b: &Bidiagonal<N, R, C>, begin: usize, end: usize) {
+    fn display_bidiag(b: &Bidiagonal<T, R, C>, begin: usize, end: usize) {
         for i in begin .. end {
             for k in begin .. i {
                 print!("    ");
@@ -326,13 +324,13 @@ where
     */
 
     fn delimit_subproblem(
-        diagonal: &mut VectorN<N::RealField, DimMinimum<R, C>>,
-        off_diagonal: &mut VectorN<N::RealField, DimDiff<DimMinimum<R, C>, U1>>,
-        u: &mut Option<MatrixMN<N, R, DimMinimum<R, C>>>,
-        v_t: &mut Option<MatrixMN<N, DimMinimum<R, C>, C>>,
+        diagonal: &mut OVector<T::RealField, DimMinimum<R, C>>,
+        off_diagonal: &mut OVector<T::RealField, DimDiff<DimMinimum<R, C>, U1>>,
+        u: &mut Option<OMatrix<T, R, DimMinimum<R, C>>>,
+        v_t: &mut Option<OMatrix<T, DimMinimum<R, C>, C>>,
         is_upper_diagonal: bool,
         end: usize,
-        eps: N::RealField,
+        eps: T::RealField,
     ) -> (usize, usize) {
         let mut n = end;
 
@@ -342,9 +340,9 @@ where
             if off_diagonal[m].is_zero()
                 || off_diagonal[m].norm1() <= eps * (diagonal[n].norm1() + diagonal[m].norm1())
             {
-                off_diagonal[m] = N::RealField::zero();
+                off_diagonal[m] = T::RealField::zero();
             } else if diagonal[m].norm1() <= eps {
-                diagonal[m] = N::RealField::zero();
+                diagonal[m] = T::RealField::zero();
                 Self::cancel_horizontal_off_diagonal_elt(
                     diagonal,
                     off_diagonal,
@@ -366,7 +364,7 @@ where
                     );
                 }
             } else if diagonal[n].norm1() <= eps {
-                diagonal[n] = N::RealField::zero();
+                diagonal[n] = T::RealField::zero();
                 Self::cancel_vertical_off_diagonal_elt(
                     diagonal,
                     off_diagonal,
@@ -392,12 +390,12 @@ where
 
             if off_diagonal[m].norm1() <= eps * (diagonal[new_start].norm1() + diagonal[m].norm1())
             {
-                off_diagonal[m] = N::RealField::zero();
+                off_diagonal[m] = T::RealField::zero();
                 break;
             }
             // TODO: write a test that enters this case.
             else if diagonal[m].norm1() <= eps {
-                diagonal[m] = N::RealField::zero();
+                diagonal[m] = T::RealField::zero();
                 Self::cancel_horizontal_off_diagonal_elt(
                     diagonal,
                     off_diagonal,
@@ -429,29 +427,29 @@ where
 
     // Cancels the i-th off-diagonal element using givens rotations.
     fn cancel_horizontal_off_diagonal_elt(
-        diagonal: &mut VectorN<N::RealField, DimMinimum<R, C>>,
-        off_diagonal: &mut VectorN<N::RealField, DimDiff<DimMinimum<R, C>, U1>>,
-        u: &mut Option<MatrixMN<N, R, DimMinimum<R, C>>>,
-        v_t: &mut Option<MatrixMN<N, DimMinimum<R, C>, C>>,
+        diagonal: &mut OVector<T::RealField, DimMinimum<R, C>>,
+        off_diagonal: &mut OVector<T::RealField, DimDiff<DimMinimum<R, C>, U1>>,
+        u: &mut Option<OMatrix<T, R, DimMinimum<R, C>>>,
+        v_t: &mut Option<OMatrix<T, DimMinimum<R, C>, C>>,
         is_upper_diagonal: bool,
         i: usize,
         end: usize,
     ) {
         let mut v = Vector2::new(off_diagonal[i], diagonal[i + 1]);
-        off_diagonal[i] = N::RealField::zero();
+        off_diagonal[i] = T::RealField::zero();
 
         for k in i..end {
             if let Some((rot, norm)) = GivensRotation::cancel_x(&v) {
-                let rot = GivensRotation::new_unchecked(rot.c(), N::from_real(rot.s()));
+                let rot = GivensRotation::new_unchecked(rot.c(), T::from_real(rot.s()));
                 diagonal[k + 1] = norm;
 
                 if is_upper_diagonal {
                     if let Some(ref mut u) = *u {
                         rot.inverse()
-                            .rotate_rows(&mut u.fixed_columns_with_step_mut::<U2>(i, k - i));
+                            .rotate_rows(&mut u.fixed_columns_with_step_mut::<2>(i, k - i));
                     }
                 } else if let Some(ref mut v_t) = *v_t {
-                    rot.rotate(&mut v_t.fixed_rows_with_step_mut::<U2>(i, k - i));
+                    rot.rotate(&mut v_t.fixed_rows_with_step_mut::<2>(i, k - i));
                 }
 
                 if k + 1 != end {
@@ -467,28 +465,28 @@ where
 
     // Cancels the i-th off-diagonal element using givens rotations.
     fn cancel_vertical_off_diagonal_elt(
-        diagonal: &mut VectorN<N::RealField, DimMinimum<R, C>>,
-        off_diagonal: &mut VectorN<N::RealField, DimDiff<DimMinimum<R, C>, U1>>,
-        u: &mut Option<MatrixMN<N, R, DimMinimum<R, C>>>,
-        v_t: &mut Option<MatrixMN<N, DimMinimum<R, C>, C>>,
+        diagonal: &mut OVector<T::RealField, DimMinimum<R, C>>,
+        off_diagonal: &mut OVector<T::RealField, DimDiff<DimMinimum<R, C>, U1>>,
+        u: &mut Option<OMatrix<T, R, DimMinimum<R, C>>>,
+        v_t: &mut Option<OMatrix<T, DimMinimum<R, C>, C>>,
         is_upper_diagonal: bool,
         i: usize,
     ) {
         let mut v = Vector2::new(diagonal[i], off_diagonal[i]);
-        off_diagonal[i] = N::RealField::zero();
+        off_diagonal[i] = T::RealField::zero();
 
         for k in (0..i + 1).rev() {
             if let Some((rot, norm)) = GivensRotation::cancel_y(&v) {
-                let rot = GivensRotation::new_unchecked(rot.c(), N::from_real(rot.s()));
+                let rot = GivensRotation::new_unchecked(rot.c(), T::from_real(rot.s()));
                 diagonal[k] = norm;
 
                 if is_upper_diagonal {
                     if let Some(ref mut v_t) = *v_t {
-                        rot.rotate(&mut v_t.fixed_rows_with_step_mut::<U2>(k, i - k));
+                        rot.rotate(&mut v_t.fixed_rows_with_step_mut::<2>(k, i - k));
                     }
                 } else if let Some(ref mut u) = *u {
                     rot.inverse()
-                        .rotate_rows(&mut u.fixed_columns_with_step_mut::<U2>(k, i - k));
+                        .rotate_rows(&mut u.fixed_columns_with_step_mut::<2>(k, i - k));
                 }
 
                 if k > 0 {
@@ -504,9 +502,9 @@ where
 
     /// Computes the rank of the decomposed matrix, i.e., the number of singular values greater
     /// than `eps`.
-    pub fn rank(&self, eps: N::RealField) -> usize {
+    pub fn rank(&self, eps: T::RealField) -> usize {
         assert!(
-            eps >= N::RealField::zero(),
+            eps >= T::RealField::zero(),
             "SVD rank: the epsilon must be non-negative."
         );
         self.singular_values.iter().filter(|e| **e > eps).count()
@@ -517,7 +515,7 @@ where
     /// This is useful if some of the singular values have been manually modified.
     /// Returns `Err` if the right- and left- singular vectors have not been
     /// computed at construction-time.
-    pub fn recompose(self) -> Result<MatrixMN<N, R, C>, &'static str> {
+    pub fn recompose(self) -> Result<OMatrix<T, R, C>, &'static str> {
         match (self.u, self.v_t) {
             (Some(mut u), Some(v_t)) => {
                 for i in 0..self.singular_values.len() {
@@ -537,20 +535,20 @@ where
     /// Any singular value smaller than `eps` is assumed to be zero.
     /// Returns `Err` if the right- and left- singular vectors have not
     /// been computed at construction-time.
-    pub fn pseudo_inverse(mut self, eps: N::RealField) -> Result<MatrixMN<N, C, R>, &'static str>
+    pub fn pseudo_inverse(mut self, eps: T::RealField) -> Result<OMatrix<T, C, R>, &'static str>
     where
-        DefaultAllocator: Allocator<N, C, R>,
+        DefaultAllocator: Allocator<T, C, R>,
     {
-        if eps < N::RealField::zero() {
+        if eps < T::RealField::zero() {
             Err("SVD pseudo inverse: the epsilon must be non-negative.")
         } else {
             for i in 0..self.singular_values.len() {
                 let val = self.singular_values[i];
 
                 if val > eps {
-                    self.singular_values[i] = N::RealField::one() / val;
+                    self.singular_values[i] = T::RealField::one() / val;
                 } else {
-                    self.singular_values[i] = N::RealField::zero();
+                    self.singular_values[i] = T::RealField::zero();
                 }
             }
 
@@ -565,15 +563,15 @@ where
     // TODO: make this more generic wrt the storage types and the dimensions for `b`.
     pub fn solve<R2: Dim, C2: Dim, S2>(
         &self,
-        b: &Matrix<N, R2, C2, S2>,
-        eps: N::RealField,
-    ) -> Result<MatrixMN<N, C, C2>, &'static str>
+        b: &Matrix<T, R2, C2, S2>,
+        eps: T::RealField,
+    ) -> Result<OMatrix<T, C, C2>, &'static str>
     where
-        S2: Storage<N, R2, C2>,
-        DefaultAllocator: Allocator<N, C, C2> + Allocator<N, DimMinimum<R, C>, C2>,
+        S2: Storage<T, R2, C2>,
+        DefaultAllocator: Allocator<T, C, C2> + Allocator<T, DimMinimum<R, C>, C2>,
         ShapeConstraint: SameNumberOfRows<R, R2>,
     {
-        if eps < N::RealField::zero() {
+        if eps < T::RealField::zero() {
             Err("SVD solve: the epsilon must be non-negative.")
         } else {
             match (&self.u, &self.v_t) {
@@ -588,7 +586,7 @@ where
                             if val > eps {
                                 col[i] = col[i].unscale(val);
                             } else {
-                                col[i] = N::zero();
+                                col[i] = T::zero();
                             }
                         }
                     }
@@ -603,28 +601,28 @@ where
     }
 }
 
-impl<N: ComplexField, R: DimMin<C>, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S>
+impl<T: ComplexField, R: DimMin<C>, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S>
 where
     DimMinimum<R, C>: DimSub<U1>, // for Bidiagonal.
-    DefaultAllocator: Allocator<N, R, C>
-        + Allocator<N, C>
-        + Allocator<N, R>
-        + Allocator<N, DimDiff<DimMinimum<R, C>, U1>>
-        + Allocator<N, DimMinimum<R, C>, C>
-        + Allocator<N, R, DimMinimum<R, C>>
-        + Allocator<N, DimMinimum<R, C>>
-        + Allocator<N::RealField, DimMinimum<R, C>>
-        + Allocator<N::RealField, DimDiff<DimMinimum<R, C>, U1>>,
+    DefaultAllocator: Allocator<T, R, C>
+        + Allocator<T, C>
+        + Allocator<T, R>
+        + Allocator<T, DimDiff<DimMinimum<R, C>, U1>>
+        + Allocator<T, DimMinimum<R, C>, C>
+        + Allocator<T, R, DimMinimum<R, C>>
+        + Allocator<T, DimMinimum<R, C>>
+        + Allocator<T::RealField, DimMinimum<R, C>>
+        + Allocator<T::RealField, DimDiff<DimMinimum<R, C>, U1>>,
 {
     /// Computes the singular values of this matrix.
-    pub fn singular_values(&self) -> VectorN<N::RealField, DimMinimum<R, C>> {
+    pub fn singular_values(&self) -> OVector<T::RealField, DimMinimum<R, C>> {
         SVD::new(self.clone_owned(), false, false).singular_values
     }
 
     /// Computes the rank of this matrix.
     ///
     /// All singular values below `eps` are considered equal to 0.
-    pub fn rank(&self, eps: N::RealField) -> usize {
+    pub fn rank(&self, eps: T::RealField) -> usize {
         let svd = SVD::new(self.clone_owned(), false, false);
         svd.rank(eps)
     }
@@ -632,9 +630,9 @@ where
     /// Computes the pseudo-inverse of this matrix.
     ///
     /// All singular values below `eps` are considered equal to 0.
-    pub fn pseudo_inverse(self, eps: N::RealField) -> Result<MatrixMN<N, C, R>, &'static str>
+    pub fn pseudo_inverse(self, eps: T::RealField) -> Result<OMatrix<T, C, R>, &'static str>
     where
-        DefaultAllocator: Allocator<N, C, R>,
+        DefaultAllocator: Allocator<T, C, R>,
     {
         SVD::new(self.clone_owned(), true, true).pseudo_inverse(eps)
     }
@@ -643,19 +641,19 @@ where
 // Explicit formulae inspired from the paper "Computing the Singular Values of 2-by-2 Complex
 // Matrices", Sanzheng Qiao and Xiaohong Wang.
 // http://www.cas.mcmaster.ca/sqrl/papers/sqrl5.pdf
-fn compute_2x2_uptrig_svd<N: RealField>(
-    m11: N,
-    m12: N,
-    m22: N,
+fn compute_2x2_uptrig_svd<T: RealField>(
+    m11: T,
+    m12: T,
+    m22: T,
     compute_u: bool,
     compute_v: bool,
 ) -> (
-    Option<GivensRotation<N>>,
-    Vector2<N>,
-    Option<GivensRotation<N>>,
+    Option<GivensRotation<T>>,
+    Vector2<T>,
+    Option<GivensRotation<T>>,
 ) {
-    let two: N::RealField = crate::convert(2.0f64);
-    let half: N::RealField = crate::convert(0.5f64);
+    let two: T::RealField = crate::convert(2.0f64);
+    let half: T::RealField = crate::convert(0.5f64);
 
     let denom = (m11 + m22).hypot(m12) + (m11 - m22).hypot(m12);
 
diff --git a/src/linalg/symmetric_eigen.rs b/src/linalg/symmetric_eigen.rs
index d30c2f80..370df26e 100644
--- a/src/linalg/symmetric_eigen.rs
+++ b/src/linalg/symmetric_eigen.rs
@@ -5,8 +5,8 @@ use approx::AbsDiffEq;
 use num::Zero;
 
 use crate::allocator::Allocator;
-use crate::base::{DefaultAllocator, Matrix2, MatrixN, SquareMatrix, Vector2, VectorN};
-use crate::dimension::{Dim, DimDiff, DimSub, U1, U2};
+use crate::base::{DefaultAllocator, Matrix2, OMatrix, OVector, SquareMatrix, Vector2};
+use crate::dimension::{Dim, DimDiff, DimSub, U1};
 use crate::storage::Storage;
 use simba::scalar::ComplexField;
 
@@ -17,51 +17,51 @@ use crate::linalg::SymmetricTridiagonal;
 #[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
 #[cfg_attr(
     feature = "serde-serialize",
-    serde(bound(serialize = "DefaultAllocator: Allocator<N, D, D> +
-                           Allocator<N::RealField, D>,
-         VectorN<N::RealField, D>: Serialize,
-         MatrixN<N, D>: Serialize"))
+    serde(bound(serialize = "DefaultAllocator: Allocator<T, D, D> +
+                           Allocator<T::RealField, D>,
+         OVector<T::RealField, D>: Serialize,
+         OMatrix<T, D, D>: Serialize"))
 )]
 #[cfg_attr(
     feature = "serde-serialize",
-    serde(bound(deserialize = "DefaultAllocator: Allocator<N, D, D> +
-                           Allocator<N::RealField, D>,
-         VectorN<N::RealField, D>: Deserialize<'de>,
-         MatrixN<N, D>: Deserialize<'de>"))
+    serde(bound(deserialize = "DefaultAllocator: Allocator<T, D, D> +
+                           Allocator<T::RealField, D>,
+         OVector<T::RealField, D>: Deserialize<'de>,
+         OMatrix<T, D, D>: Deserialize<'de>"))
 )]
 #[derive(Clone, Debug)]
-pub struct SymmetricEigen<N: ComplexField, D: Dim>
+pub struct SymmetricEigen<T: ComplexField, D: Dim>
 where
-    DefaultAllocator: Allocator<N, D, D> + Allocator<N::RealField, D>,
+    DefaultAllocator: Allocator<T, D, D> + Allocator<T::RealField, D>,
 {
     /// The eigenvectors of the decomposed matrix.
-    pub eigenvectors: MatrixN<N, D>,
+    pub eigenvectors: OMatrix<T, D, D>,
 
     /// The unsorted eigenvalues of the decomposed matrix.
-    pub eigenvalues: VectorN<N::RealField, D>,
+    pub eigenvalues: OVector<T::RealField, D>,
 }
 
-impl<N: ComplexField, D: Dim> Copy for SymmetricEigen<N, D>
+impl<T: ComplexField, D: Dim> Copy for SymmetricEigen<T, D>
 where
-    DefaultAllocator: Allocator<N, D, D> + Allocator<N::RealField, D>,
-    MatrixN<N, D>: Copy,
-    VectorN<N::RealField, D>: Copy,
+    DefaultAllocator: Allocator<T, D, D> + Allocator<T::RealField, D>,
+    OMatrix<T, D, D>: Copy,
+    OVector<T::RealField, D>: Copy,
 {
 }
 
-impl<N: ComplexField, D: Dim> SymmetricEigen<N, D>
+impl<T: ComplexField, D: Dim> SymmetricEigen<T, D>
 where
-    DefaultAllocator: Allocator<N, D, D> + Allocator<N::RealField, D>,
+    DefaultAllocator: Allocator<T, D, D> + Allocator<T::RealField, D>,
 {
     /// Computes the eigendecomposition of the given symmetric matrix.
     ///
     /// Only the lower-triangular parts (including its diagonal) of `m` is read.
-    pub fn new(m: MatrixN<N, D>) -> Self
+    pub fn new(m: OMatrix<T, D, D>) -> Self
     where
         D: DimSub<U1>,
-        DefaultAllocator: Allocator<N, DimDiff<D, U1>> + Allocator<N::RealField, DimDiff<D, U1>>,
+        DefaultAllocator: Allocator<T, DimDiff<D, U1>> + Allocator<T::RealField, DimDiff<D, U1>>,
     {
-        Self::try_new(m, N::RealField::default_epsilon(), 0).unwrap()
+        Self::try_new(m, T::RealField::default_epsilon(), 0).unwrap()
     }
 
     /// Computes the eigendecomposition of the given symmetric matrix with user-specified
@@ -75,10 +75,10 @@ where
     /// * `max_niter` − maximum total number of iterations performed by the algorithm. If this
     /// number of iteration is exceeded, `None` is returned. If `niter == 0`, then the algorithm
     /// continues indefinitely until convergence.
-    pub fn try_new(m: MatrixN<N, D>, eps: N::RealField, max_niter: usize) -> Option<Self>
+    pub fn try_new(m: OMatrix<T, D, D>, eps: T::RealField, max_niter: usize) -> Option<Self>
     where
         D: DimSub<U1>,
-        DefaultAllocator: Allocator<N, DimDiff<D, U1>> + Allocator<N::RealField, DimDiff<D, U1>>,
+        DefaultAllocator: Allocator<T, DimDiff<D, U1>> + Allocator<T::RealField, DimDiff<D, U1>>,
     {
         Self::do_decompose(m, true, eps, max_niter).map(|(vals, vecs)| SymmetricEigen {
             eigenvectors: vecs.unwrap(),
@@ -87,14 +87,14 @@ where
     }
 
     fn do_decompose(
-        mut m: MatrixN<N, D>,
+        mut m: OMatrix<T, D, D>,
         eigenvectors: bool,
-        eps: N::RealField,
+        eps: T::RealField,
         max_niter: usize,
-    ) -> Option<(VectorN<N::RealField, D>, Option<MatrixN<N, D>>)>
+    ) -> Option<(OVector<T::RealField, D>, Option<OMatrix<T, D, D>>)>
     where
         D: DimSub<U1>,
-        DefaultAllocator: Allocator<N, DimDiff<D, U1>> + Allocator<N::RealField, DimDiff<D, U1>>,
+        DefaultAllocator: Allocator<T, DimDiff<D, U1>> + Allocator<T::RealField, DimDiff<D, U1>>,
     {
         assert!(
             m.is_square(),
@@ -171,8 +171,8 @@ where
                         }
 
                         if let Some(ref mut q) = q {
-                            let rot = GivensRotation::new_unchecked(rot.c(), N::from_real(rot.s()));
-                            rot.inverse().rotate_rows(&mut q.fixed_columns_mut::<U2>(i));
+                            let rot = GivensRotation::new_unchecked(rot.c(), T::from_real(rot.s()));
+                            rot.inverse().rotate_rows(&mut q.fixed_columns_mut::<2>(i));
                         }
                     } else {
                         break;
@@ -197,8 +197,8 @@ where
 
                 if let Some(ref mut q) = q {
                     if let Some((rot, _)) = GivensRotation::try_new(basis.x, basis.y, eps) {
-                        let rot = GivensRotation::new_unchecked(rot.c(), N::from_real(rot.s()));
-                        rot.rotate_rows(&mut q.fixed_columns_mut::<U2>(start));
+                        let rot = GivensRotation::new_unchecked(rot.c(), T::from_real(rot.s()));
+                        rot.rotate_rows(&mut q.fixed_columns_mut::<2>(start));
                     }
                 }
 
@@ -223,14 +223,14 @@ where
     }
 
     fn delimit_subproblem(
-        diag: &VectorN<N::RealField, D>,
-        off_diag: &mut VectorN<N::RealField, DimDiff<D, U1>>,
+        diag: &OVector<T::RealField, D>,
+        off_diag: &mut OVector<T::RealField, DimDiff<D, U1>>,
         end: usize,
-        eps: N::RealField,
+        eps: T::RealField,
     ) -> (usize, usize)
     where
         D: DimSub<U1>,
-        DefaultAllocator: Allocator<N::RealField, DimDiff<D, U1>>,
+        DefaultAllocator: Allocator<T::RealField, DimDiff<D, U1>>,
     {
         let mut n = end;
 
@@ -255,7 +255,7 @@ where
             if off_diag[m].is_zero()
                 || off_diag[m].norm1() <= eps * (diag[new_start].norm1() + diag[m].norm1())
             {
-                off_diag[m] = N::RealField::zero();
+                off_diag[m] = T::RealField::zero();
                 break;
             }
 
@@ -268,7 +268,7 @@ where
     /// Rebuild the original matrix.
     ///
     /// This is useful if some of the eigenvalues have been manually modified.
-    pub fn recompose(&self) -> MatrixN<N, D> {
+    pub fn recompose(&self) -> OMatrix<T, D, D> {
         let mut u_t = self.eigenvectors.clone();
         for i in 0..self.eigenvalues.len() {
             let val = self.eigenvalues[i];
@@ -285,7 +285,7 @@ where
 /// The inputs are interpreted as the 2x2 matrix:
 ///     tmm  tmn
 ///     tmn  tnn
-pub fn wilkinson_shift<N: ComplexField>(tmm: N, tnn: N, tmn: N) -> N {
+pub fn wilkinson_shift<T: ComplexField>(tmm: T, tnn: T, tmn: T) -> T {
     let sq_tmn = tmn * tmn;
     if !sq_tmn.is_zero() {
         // We have the guarantee that the denominator won't be zero.
@@ -301,21 +301,21 @@ pub fn wilkinson_shift<N: ComplexField>(tmm: N, tnn: N, tmn: N) -> N {
  * Computations of eigenvalues for symmetric matrices.
  *
  */
-impl<N: ComplexField, D: DimSub<U1>, S: Storage<N, D, D>> SquareMatrix<N, D, S>
+impl<T: ComplexField, D: DimSub<U1>, S: Storage<T, D, D>> SquareMatrix<T, D, S>
 where
-    DefaultAllocator: Allocator<N, D, D>
-        + Allocator<N, DimDiff<D, U1>>
-        + Allocator<N::RealField, D>
-        + Allocator<N::RealField, DimDiff<D, U1>>,
+    DefaultAllocator: Allocator<T, D, D>
+        + Allocator<T, DimDiff<D, U1>>
+        + Allocator<T::RealField, D>
+        + Allocator<T::RealField, DimDiff<D, U1>>,
 {
     /// Computes the eigenvalues of this symmetric matrix.
     ///
     /// Only the lower-triangular part of the matrix is read.
-    pub fn symmetric_eigenvalues(&self) -> VectorN<N::RealField, D> {
+    pub fn symmetric_eigenvalues(&self) -> OVector<T::RealField, D> {
         SymmetricEigen::do_decompose(
             self.clone_owned(),
             false,
-            N::RealField::default_epsilon(),
+            T::RealField::default_epsilon(),
             0,
         )
         .unwrap()
diff --git a/src/linalg/symmetric_tridiagonal.rs b/src/linalg/symmetric_tridiagonal.rs
index c05b5558..4e70b59b 100644
--- a/src/linalg/symmetric_tridiagonal.rs
+++ b/src/linalg/symmetric_tridiagonal.rs
@@ -2,8 +2,8 @@
 use serde::{Deserialize, Serialize};
 
 use crate::allocator::Allocator;
-use crate::base::{DefaultAllocator, MatrixN, VectorN};
-use crate::dimension::{DimDiff, DimSub, U1};
+use crate::base::{DefaultAllocator, OMatrix, OVector};
+use crate::dimension::{Const, DimDiff, DimSub, U1};
 use crate::storage::Storage;
 use simba::scalar::ComplexField;
 
@@ -13,43 +13,43 @@ use crate::linalg::householder;
 #[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
 #[cfg_attr(
     feature = "serde-serialize",
-    serde(bound(serialize = "DefaultAllocator: Allocator<N, D, D> +
-                           Allocator<N, DimDiff<D, U1>>,
-         MatrixN<N, D>: Serialize,
-         VectorN<N, DimDiff<D, U1>>: Serialize"))
+    serde(bound(serialize = "DefaultAllocator: Allocator<T, D, D> +
+                           Allocator<T, DimDiff<D, U1>>,
+         OMatrix<T, D, D>: Serialize,
+         OVector<T, DimDiff<D, U1>>: Serialize"))
 )]
 #[cfg_attr(
     feature = "serde-serialize",
-    serde(bound(deserialize = "DefaultAllocator: Allocator<N, D, D> +
-                           Allocator<N, DimDiff<D, U1>>,
-         MatrixN<N, D>: Deserialize<'de>,
-         VectorN<N, DimDiff<D, U1>>: Deserialize<'de>"))
+    serde(bound(deserialize = "DefaultAllocator: Allocator<T, D, D> +
+                           Allocator<T, DimDiff<D, U1>>,
+         OMatrix<T, D, D>: Deserialize<'de>,
+         OVector<T, DimDiff<D, U1>>: Deserialize<'de>"))
 )]
 #[derive(Clone, Debug)]
-pub struct SymmetricTridiagonal<N: ComplexField, D: DimSub<U1>>
+pub struct SymmetricTridiagonal<T: ComplexField, D: DimSub<U1>>
 where
-    DefaultAllocator: Allocator<N, D, D> + Allocator<N, DimDiff<D, U1>>,
+    DefaultAllocator: Allocator<T, D, D> + Allocator<T, DimDiff<D, U1>>,
 {
-    tri: MatrixN<N, D>,
-    off_diagonal: VectorN<N, DimDiff<D, U1>>,
+    tri: OMatrix<T, D, D>,
+    off_diagonal: OVector<T, DimDiff<D, U1>>,
 }
 
-impl<N: ComplexField, D: DimSub<U1>> Copy for SymmetricTridiagonal<N, D>
+impl<T: ComplexField, D: DimSub<U1>> Copy for SymmetricTridiagonal<T, D>
 where
-    DefaultAllocator: Allocator<N, D, D> + Allocator<N, DimDiff<D, U1>>,
-    MatrixN<N, D>: Copy,
-    VectorN<N, DimDiff<D, U1>>: Copy,
+    DefaultAllocator: Allocator<T, D, D> + Allocator<T, DimDiff<D, U1>>,
+    OMatrix<T, D, D>: Copy,
+    OVector<T, DimDiff<D, U1>>: Copy,
 {
 }
 
-impl<N: ComplexField, D: DimSub<U1>> SymmetricTridiagonal<N, D>
+impl<T: ComplexField, D: DimSub<U1>> SymmetricTridiagonal<T, D>
 where
-    DefaultAllocator: Allocator<N, D, D> + Allocator<N, DimDiff<D, U1>>,
+    DefaultAllocator: Allocator<T, D, D> + Allocator<T, DimDiff<D, U1>>,
 {
     /// Computes the tridiagonalization of the symmetric matrix `m`.
     ///
     /// Only the lower-triangular part (including the diagonal) of `m` is read.
-    pub fn new(mut m: MatrixN<N, D>) -> Self {
+    pub fn new(mut m: OMatrix<T, D, D>) -> Self {
         let dim = m.data.shape().0;
 
         assert!(
@@ -61,9 +61,12 @@ where
             "Unable to compute the symmetric tridiagonal decomposition of an empty matrix."
         );
 
-        let mut off_diagonal =
-            unsafe { crate::unimplemented_or_uninitialized_generic!(dim.sub(U1), U1) };
-        let mut p = unsafe { crate::unimplemented_or_uninitialized_generic!(dim.sub(U1), U1) };
+        let mut off_diagonal = unsafe {
+            crate::unimplemented_or_uninitialized_generic!(dim.sub(Const::<1>), Const::<1>)
+        };
+        let mut p = unsafe {
+            crate::unimplemented_or_uninitialized_generic!(dim.sub(Const::<1>), Const::<1>)
+        };
 
         for i in 0..dim.value() - 1 {
             let mut m = m.rows_range_mut(i + 1..);
@@ -75,12 +78,12 @@ where
             if not_zero {
                 let mut p = p.rows_range_mut(i..);
 
-                p.hegemv(crate::convert(2.0), &m, &axis, N::zero());
+                p.hegemv(crate::convert(2.0), &m, &axis, T::zero());
 
                 let dot = axis.dotc(&p);
-                m.hegerc(-N::one(), &p, &axis, N::one());
-                m.hegerc(-N::one(), &axis, &p, N::one());
-                m.hegerc(dot * crate::convert(2.0), &axis, &axis, N::one());
+                m.hegerc(-T::one(), &p, &axis, T::one());
+                m.hegerc(-T::one(), &axis, &p, T::one());
+                m.hegerc(dot * crate::convert(2.0), &axis, &axis, T::one());
             }
         }
 
@@ -92,7 +95,7 @@ where
 
     #[doc(hidden)]
     // For debugging.
-    pub fn internal_tri(&self) -> &MatrixN<N, D> {
+    pub fn internal_tri(&self) -> &OMatrix<T, D, D> {
         &self.tri
     }
 
@@ -101,61 +104,61 @@ where
     pub fn unpack(
         self,
     ) -> (
-        MatrixN<N, D>,
-        VectorN<N::RealField, D>,
-        VectorN<N::RealField, DimDiff<D, U1>>,
+        OMatrix<T, D, D>,
+        OVector<T::RealField, D>,
+        OVector<T::RealField, DimDiff<D, U1>>,
     )
     where
-        DefaultAllocator: Allocator<N::RealField, D> + Allocator<N::RealField, DimDiff<D, U1>>,
+        DefaultAllocator: Allocator<T::RealField, D> + Allocator<T::RealField, DimDiff<D, U1>>,
     {
         let diag = self.diagonal();
         let q = self.q();
 
-        (q, diag, self.off_diagonal.map(N::modulus))
+        (q, diag, self.off_diagonal.map(T::modulus))
     }
 
     /// Retrieve the diagonal, and off diagonal elements of this decomposition.
     pub fn unpack_tridiagonal(
         self,
     ) -> (
-        VectorN<N::RealField, D>,
-        VectorN<N::RealField, DimDiff<D, U1>>,
+        OVector<T::RealField, D>,
+        OVector<T::RealField, DimDiff<D, U1>>,
     )
     where
-        DefaultAllocator: Allocator<N::RealField, D> + Allocator<N::RealField, DimDiff<D, U1>>,
+        DefaultAllocator: Allocator<T::RealField, D> + Allocator<T::RealField, DimDiff<D, U1>>,
     {
-        (self.diagonal(), self.off_diagonal.map(N::modulus))
+        (self.diagonal(), self.off_diagonal.map(T::modulus))
     }
 
     /// The diagonal components of this decomposition.
-    pub fn diagonal(&self) -> VectorN<N::RealField, D>
+    pub fn diagonal(&self) -> OVector<T::RealField, D>
     where
-        DefaultAllocator: Allocator<N::RealField, D>,
+        DefaultAllocator: Allocator<T::RealField, D>,
     {
         self.tri.map_diagonal(|e| e.real())
     }
 
     /// The off-diagonal components of this decomposition.
-    pub fn off_diagonal(&self) -> VectorN<N::RealField, DimDiff<D, U1>>
+    pub fn off_diagonal(&self) -> OVector<T::RealField, DimDiff<D, U1>>
     where
-        DefaultAllocator: Allocator<N::RealField, DimDiff<D, U1>>,
+        DefaultAllocator: Allocator<T::RealField, DimDiff<D, U1>>,
     {
-        self.off_diagonal.map(N::modulus)
+        self.off_diagonal.map(T::modulus)
     }
 
     /// Computes the orthogonal matrix `Q` of this decomposition.
-    pub fn q(&self) -> MatrixN<N, D> {
+    pub fn q(&self) -> OMatrix<T, D, D> {
         householder::assemble_q(&self.tri, self.off_diagonal.as_slice())
     }
 
     /// Recomputes the original symmetric matrix.
-    pub fn recompose(mut self) -> MatrixN<N, D> {
+    pub fn recompose(mut self) -> OMatrix<T, D, D> {
         let q = self.q();
-        self.tri.fill_lower_triangle(N::zero(), 2);
-        self.tri.fill_upper_triangle(N::zero(), 2);
+        self.tri.fill_lower_triangle(T::zero(), 2);
+        self.tri.fill_upper_triangle(T::zero(), 2);
 
         for i in 0..self.off_diagonal.len() {
-            let val = N::from_real(self.off_diagonal[i].modulus());
+            let val = T::from_real(self.off_diagonal[i].modulus());
             self.tri[(i + 1, i)] = val;
             self.tri[(i, i + 1)] = val;
         }
diff --git a/src/linalg/udu.rs b/src/linalg/udu.rs
index 70ff84a7..de3cd2e3 100644
--- a/src/linalg/udu.rs
+++ b/src/linalg/udu.rs
@@ -2,7 +2,7 @@
 use serde::{Deserialize, Serialize};
 
 use crate::allocator::Allocator;
-use crate::base::{DefaultAllocator, MatrixN, VectorN, U1};
+use crate::base::{Const, DefaultAllocator, OMatrix, OVector};
 use crate::dimension::Dim;
 use crate::storage::Storage;
 use simba::scalar::RealField;
@@ -11,36 +11,36 @@ use simba::scalar::RealField;
 #[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
 #[cfg_attr(
     feature = "serde-serialize",
-    serde(bound(serialize = "VectorN<N, D>: Serialize, MatrixN<N, D>: Serialize"))
+    serde(bound(serialize = "OVector<T, D>: Serialize, OMatrix<T, D, D>: Serialize"))
 )]
 #[cfg_attr(
     feature = "serde-serialize",
     serde(bound(
-        deserialize = "VectorN<N, D>: Deserialize<'de>, MatrixN<N, D>: Deserialize<'de>"
+        deserialize = "OVector<T, D>: Deserialize<'de>, OMatrix<T, D, D>: Deserialize<'de>"
     ))
 )]
 #[derive(Clone, Debug)]
-pub struct UDU<N: RealField, D: Dim>
+pub struct UDU<T: RealField, D: Dim>
 where
-    DefaultAllocator: Allocator<N, D> + Allocator<N, D, D>,
+    DefaultAllocator: Allocator<T, D> + Allocator<T, D, D>,
 {
     /// The upper triangular matrix resulting from the factorization
-    pub u: MatrixN<N, D>,
+    pub u: OMatrix<T, D, D>,
     /// The diagonal matrix resulting from the factorization
-    pub d: VectorN<N, D>,
+    pub d: OVector<T, D>,
 }
 
-impl<N: RealField, D: Dim> Copy for UDU<N, D>
+impl<T: RealField, D: Dim> Copy for UDU<T, D>
 where
-    DefaultAllocator: Allocator<N, D> + Allocator<N, D, D>,
-    VectorN<N, D>: Copy,
-    MatrixN<N, D>: Copy,
+    DefaultAllocator: Allocator<T, D> + Allocator<T, D, D>,
+    OVector<T, D>: Copy,
+    OMatrix<T, D, D>: Copy,
 {
 }
 
-impl<N: RealField, D: Dim> UDU<N, D>
+impl<T: RealField, D: Dim> UDU<T, D>
 where
-    DefaultAllocator: Allocator<N, D> + Allocator<N, D, D>,
+    DefaultAllocator: Allocator<T, D> + Allocator<T, D, D>,
 {
     /// Computes the UDU^T factorization.
     ///
@@ -48,12 +48,12 @@ where
     /// the upper-triangular part of `p`.
     ///
     /// Ref.: "Optimal control and estimation-Dover Publications", Robert F. Stengel, (1994) page 360
-    pub fn new(p: MatrixN<N, D>) -> Option<Self> {
+    pub fn new(p: OMatrix<T, D, D>) -> Option<Self> {
         let n = p.ncols();
         let n_dim = p.data.shape().1;
 
-        let mut d = VectorN::zeros_generic(n_dim, U1);
-        let mut u = MatrixN::zeros_generic(n_dim, n_dim);
+        let mut d = OVector::zeros_generic(n_dim, Const::<1>);
+        let mut u = OMatrix::zeros_generic(n_dim, n_dim);
 
         d[n - 1] = p[(n - 1, n - 1)];
 
@@ -62,7 +62,7 @@ where
         }
 
         u.column_mut(n - 1)
-            .axpy(N::one() / d[n - 1], &p.column(n - 1), N::zero());
+            .axpy(T::one() / d[n - 1], &p.column(n - 1), T::zero());
 
         for j in (0..n - 1).rev() {
             let mut d_j = d[j];
@@ -85,14 +85,14 @@ where
                 u[(i, j)] = (p[(i, j)] - u_ij) / d[j];
             }
 
-            u[(j, j)] = N::one();
+            u[(j, j)] = T::one();
         }
 
         Some(Self { u, d })
     }
 
     /// Returns the diagonal elements as a matrix
-    pub fn d_matrix(&self) -> MatrixN<N, D> {
-        MatrixN::from_diagonal(&self.d)
+    pub fn d_matrix(&self) -> OMatrix<T, D, D> {
+        OMatrix::from_diagonal(&self.d)
     }
 }
diff --git a/src/proptest/mod.rs b/src/proptest/mod.rs
index ae263956..d85cd6a2 100644
--- a/src/proptest/mod.rs
+++ b/src/proptest/mod.rs
@@ -18,7 +18,7 @@
 //!
 //! - Using the [matrix](fn.matrix.html) function to generate matrices with constraints
 //!   on dimensions and elements.
-//! - Relying on the `Arbitrary` implementation of `MatrixMN`.
+//! - Relying on the `Arbitrary` implementation of `OMatrix`.
 //!
 //! The first variant is almost always preferred in practice. Read on to discover why.
 //!
@@ -53,20 +53,20 @@
 //! with [matrix](fn.matrix.html) as follows:
 //!
 //! ```rust
-//! use nalgebra::{Dynamic, MatrixMN, U3};
+//! use nalgebra::{Dynamic, OMatrix, Const};
 //! use nalgebra::proptest::matrix;
 //! use proptest::prelude::*;
 //!
-//! type MyMatrix = MatrixMN<i32, U3, Dynamic>;
+//! type MyMatrix = OMatrix<i32, Const::<3>, Dynamic>;
 //!
 //! /// Returns a strategy for pairs of matrices with `U3` rows and the same number of
 //! /// columns.
 //! fn matrix_pairs() -> impl Strategy<Value=(MyMatrix, MyMatrix)> {
-//!     matrix(-5 ..= 5, U3, 0 ..= 10)
+//!     matrix(-5 ..= 5, Const::<3>, 0 ..= 10)
 //!         // We first generate the initial matrix `a`, and then depending on the concrete
 //!         // instances of `a`, we pick a second matrix with the same number of columns
 //!         .prop_flat_map(|a| {
-//!             let b = matrix(-5 .. 5, U3, a.ncols());
+//!             let b = matrix(-5 .. 5, Const::<3>, a.ncols());
 //!             // This returns a new tuple strategy where we keep `a` fixed while
 //!             // the second item is a strategy that generates instances with the same
 //!             // dimensions as `a`
@@ -93,7 +93,7 @@
 //! If you don't care about the dimensions of matrices, you can write tests like these:
 //!
 //! ```rust
-//! use nalgebra::{DMatrix, DVector, Dynamic, Matrix3, MatrixMN, Vector3, U3};
+//! use nalgebra::{DMatrix, DVector, Dynamic, Matrix3, OMatrix, Vector3, U3};
 //! use proptest::prelude::*;
 //!
 //! proptest! {
@@ -108,7 +108,7 @@
 //!     # /*
 //!     #[test]
 //!     # */
-//!     fn test_static_and_mixed(matrix: Matrix3<i32>, matrix2: MatrixMN<i32, U3, Dynamic>) {
+//!     fn test_static_and_mixed(matrix: Matrix3<i32>, matrix2: OMatrix<i32, U3, Dynamic>) {
 //!         // 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::{DefaultAllocator, Dim, DimName, Dynamic, MatrixMN, Scalar, U1};
+use crate::{Const, DefaultAllocator, Dim, DimName, Dynamic, OMatrix, Scalar, U1};
 use proptest::arbitrary::Arbitrary;
 use proptest::collection::vec;
 use proptest::strategy::{BoxedStrategy, Just, NewTree, Strategy, ValueTree};
@@ -225,16 +225,16 @@ fn dynamic_dim_range() -> DimRange<Dynamic> {
 /// ## Examples
 /// ```
 /// use nalgebra::proptest::matrix;
-/// use nalgebra::{MatrixMN, U3, Dynamic};
+/// use nalgebra::{OMatrix, Const, Dynamic};
 /// use proptest::prelude::*;
 ///
 /// proptest! {
 ///     # /*
 ///     #[test]
 ///     # */
-///     fn my_test(a in matrix(0 .. 5i32, U3, 0 ..= 5)) {
+///     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: MatrixMN<_, U3, Dynamic> = a;
+///         let a: OMatrix<_, Const::<3>, Dynamic> = a;
 ///         prop_assert!(a.nrows() == 3);
 ///         prop_assert!(a.ncols() <= 5);
 ///         prop_assert!(a.iter().all(|x_ij| *x_ij >= 0 && *x_ij < 5));
@@ -305,7 +305,7 @@ where
             // Note: R/C::from_usize will panic if nrows/ncols does not fit in the dimension type.
             // However, this should never fail, because we should only be generating
             // this stuff in the first place
-            MatrixMN::from_iterator_generic(R::from_usize(nrows), C::from_usize(ncols), values)
+            OMatrix::from_iterator_generic(R::from_usize(nrows), C::from_usize(ncols), values)
         })
         .boxed();
 
@@ -329,7 +329,7 @@ where
     D: Dim,
     DefaultAllocator: Allocator<ScalarStrategy::Value, D>,
 {
-    matrix_(value_strategy, length.into(), U1.into())
+    matrix_(value_strategy, length.into(), Const::<1>.into())
 }
 
 impl<NParameters, R, C> Default for MatrixParameters<NParameters, R, C>
@@ -388,23 +388,23 @@ where
     }
 }
 
-impl<N, R, C> Arbitrary for MatrixMN<N, R, C>
+impl<T, R, C> Arbitrary for OMatrix<T, R, C>
 where
-    N: Scalar + Arbitrary,
-    <N as Arbitrary>::Strategy: Clone,
+    T: Scalar + Arbitrary,
+    <T as Arbitrary>::Strategy: Clone,
     R: Dim,
     C: Dim,
-    MatrixParameters<N::Parameters, R, C>: Default,
-    DefaultAllocator: Allocator<N, R, C>,
+    MatrixParameters<T::Parameters, R, C>: Default,
+    DefaultAllocator: Allocator<T, R, C>,
 {
-    type Parameters = MatrixParameters<N::Parameters, R, C>;
+    type Parameters = MatrixParameters<T::Parameters, R, C>;
 
     fn arbitrary_with(args: Self::Parameters) -> Self::Strategy {
-        let value_strategy = N::arbitrary_with(args.value_parameters);
+        let value_strategy = T::arbitrary_with(args.value_parameters);
         matrix(value_strategy, args.rows, args.cols)
     }
 
-    type Strategy = MatrixStrategy<N::Strategy, R, C>;
+    type Strategy = MatrixStrategy<T::Strategy, R, C>;
 }
 
 /// A strategy for generating matrices.
@@ -418,7 +418,7 @@ where
     // For now we only internally hold a boxed strategy. The reason for introducing this
     // separate wrapper struct is so that we can replace the strategy logic with custom logic
     // later down the road without introducing significant breaking changes
-    strategy: BoxedStrategy<MatrixMN<NStrategy::Value, R, C>>,
+    strategy: BoxedStrategy<OMatrix<NStrategy::Value, R, C>>,
 }
 
 impl<NStrategy, R, C> Strategy for MatrixStrategy<NStrategy, R, C>
@@ -430,7 +430,7 @@ where
     DefaultAllocator: Allocator<NStrategy::Value, R, C>,
 {
     type Tree = MatrixValueTree<NStrategy::Value, R, C>;
-    type Value = MatrixMN<NStrategy::Value, R, C>;
+    type Value = OMatrix<NStrategy::Value, R, C>;
 
     fn new_tree(&self, runner: &mut TestRunner) -> NewTree<Self> {
         let underlying_tree = self.strategy.new_tree(runner)?;
@@ -441,26 +441,26 @@ where
 }
 
 /// A value tree for matrices.
-pub struct MatrixValueTree<N, R, C>
+pub struct MatrixValueTree<T, R, C>
 where
-    N: Scalar,
+    T: Scalar,
     R: Dim,
     C: Dim,
-    DefaultAllocator: Allocator<N, R, C>,
+    DefaultAllocator: Allocator<T, R, C>,
 {
     // For now we only wrap a boxed value tree. The reason for wrapping is that this allows us
     // to swap out the value tree logic down the road without significant breaking changes.
-    value_tree: Box<dyn ValueTree<Value = MatrixMN<N, R, C>>>,
+    value_tree: Box<dyn ValueTree<Value = OMatrix<T, R, C>>>,
 }
 
-impl<N, R, C> ValueTree for MatrixValueTree<N, R, C>
+impl<T, R, C> ValueTree for MatrixValueTree<T, R, C>
 where
-    N: Scalar,
+    T: Scalar,
     R: Dim,
     C: Dim,
-    DefaultAllocator: Allocator<N, R, C>,
+    DefaultAllocator: Allocator<T, R, C>,
 {
-    type Value = MatrixMN<N, R, C>;
+    type Value = OMatrix<T, R, C>;
 
     fn current(&self) -> Self::Value {
         self.value_tree.current()
diff --git a/src/sparse/cs_matrix.rs b/src/sparse/cs_matrix.rs
index 3b056ab7..c4a0c901 100644
--- a/src/sparse/cs_matrix.rs
+++ b/src/sparse/cs_matrix.rs
@@ -7,24 +7,24 @@ use std::slice;
 
 use crate::allocator::Allocator;
 use crate::sparse::cs_utils;
-use crate::{DefaultAllocator, Dim, Dynamic, Scalar, Vector, VectorN, U1};
+use crate::{Const, DefaultAllocator, Dim, Dynamic, OVector, Scalar, Vector, U1};
 
-pub struct ColumnEntries<'a, N> {
+pub struct ColumnEntries<'a, T> {
     curr: usize,
     i: &'a [usize],
-    v: &'a [N],
+    v: &'a [T],
 }
 
-impl<'a, N> ColumnEntries<'a, N> {
+impl<'a, T> ColumnEntries<'a, T> {
     #[inline]
-    pub fn new(i: &'a [usize], v: &'a [N]) -> Self {
+    pub fn new(i: &'a [usize], v: &'a [T]) -> Self {
         assert_eq!(i.len(), v.len());
         Self { curr: 0, i, v }
     }
 }
 
-impl<'a, N: Clone> Iterator for ColumnEntries<'a, N> {
-    type Item = (usize, N);
+impl<'a, T: Clone> Iterator for ColumnEntries<'a, T> {
+    type Item = (usize, T);
 
     #[inline]
     fn next(&mut self) -> Option<Self::Item> {
@@ -45,11 +45,11 @@ impl<'a, N: Clone> Iterator for ColumnEntries<'a, N> {
 // TODO: this structure exists for now only because impl trait
 // cannot be used for trait method return types.
 /// Trait for iterable compressed-column matrix storage.
-pub trait CsStorageIter<'a, N, R, C = U1> {
+pub trait CsStorageIter<'a, T, R, C = U1> {
     /// Iterator through all the rows of a specific columns.
     ///
     /// The elements are given as a tuple (row_index, value).
-    type ColumnEntries: Iterator<Item = (usize, N)>;
+    type ColumnEntries: Iterator<Item = (usize, T)>;
     /// Iterator through the row indices of a specific column.
     type ColumnRowIndices: Iterator<Item = usize>;
 
@@ -60,13 +60,13 @@ pub trait CsStorageIter<'a, N, R, C = U1> {
 }
 
 /// Trait for mutably iterable compressed-column sparse matrix storage.
-pub trait CsStorageIterMut<'a, N: 'a, R, C = U1> {
+pub trait CsStorageIterMut<'a, T: 'a, R, C = U1> {
     /// Mutable iterator through all the values of the sparse matrix.
-    type ValuesMut: Iterator<Item = &'a mut N>;
+    type ValuesMut: Iterator<Item = &'a mut T>;
     /// Mutable iterator through all the rows of a specific columns.
     ///
     /// The elements are given as a tuple (row_index, value).
-    type ColumnEntriesMut: Iterator<Item = (usize, &'a mut N)>;
+    type ColumnEntriesMut: Iterator<Item = (usize, &'a mut T)>;
 
     /// A mutable iterator through the values buffer of the sparse matrix.
     fn values_mut(&'a mut self) -> Self::ValuesMut;
@@ -75,7 +75,7 @@ pub trait CsStorageIterMut<'a, N: 'a, R, C = U1> {
 }
 
 /// Trait for compressed column sparse matrix storage.
-pub trait CsStorage<N, R, C = U1>: for<'a> CsStorageIter<'a, N, R, C> {
+pub trait CsStorage<T, R, C = U1>: for<'a> CsStorageIter<'a, T, R, C> {
     /// The shape of the stored matrix.
     fn shape(&self) -> (R, C);
     /// Retrieve the i-th row index of the underlying row index buffer.
@@ -85,9 +85,9 @@ pub trait CsStorage<N, R, C = U1>: for<'a> CsStorageIter<'a, N, R, C> {
     /// The i-th value on the contiguous value buffer of this storage.
     ///
     /// No bound-checking is performed.
-    unsafe fn get_value_unchecked(&self, i: usize) -> &N;
+    unsafe fn get_value_unchecked(&self, i: usize) -> &T;
     /// The i-th value on the contiguous value buffer of this storage.
-    fn get_value(&self, i: usize) -> &N;
+    fn get_value(&self, i: usize) -> &T;
     /// Retrieve the i-th row index of the underlying row index buffer.
     fn row_index(&self, i: usize) -> usize;
     /// The value indices for the `i`-th column.
@@ -97,29 +97,29 @@ pub trait CsStorage<N, R, C = U1>: for<'a> CsStorageIter<'a, N, R, C> {
 }
 
 /// Trait for compressed column sparse matrix mutable storage.
-pub trait CsStorageMut<N, R, C = U1>:
-    CsStorage<N, R, C> + for<'a> CsStorageIterMut<'a, N, R, C>
+pub trait CsStorageMut<T, R, C = U1>:
+    CsStorage<T, R, C> + for<'a> CsStorageIterMut<'a, T, R, C>
 {
 }
 
 /// A storage of column-compressed sparse matrix based on a Vec.
 #[derive(Clone, Debug, PartialEq)]
-pub struct CsVecStorage<N: Scalar, R: Dim, C: Dim>
+pub struct CsVecStorage<T: Scalar, R: Dim, C: Dim>
 where
     DefaultAllocator: Allocator<usize, C>,
 {
     pub(crate) shape: (R, C),
-    pub(crate) p: VectorN<usize, C>,
+    pub(crate) p: OVector<usize, C>,
     pub(crate) i: Vec<usize>,
-    pub(crate) vals: Vec<N>,
+    pub(crate) vals: Vec<T>,
 }
 
-impl<N: Scalar, R: Dim, C: Dim> CsVecStorage<N, R, C>
+impl<T: Scalar, R: Dim, C: Dim> CsVecStorage<T, R, C>
 where
     DefaultAllocator: Allocator<usize, C>,
 {
     /// The value buffer of this storage.
-    pub fn values(&self) -> &[N] {
+    pub fn values(&self) -> &[T] {
         &self.vals
     }
 
@@ -134,13 +134,13 @@ where
     }
 }
 
-impl<N: Scalar, R: Dim, C: Dim> CsVecStorage<N, R, C> where DefaultAllocator: Allocator<usize, C> {}
+impl<T: Scalar, R: Dim, C: Dim> CsVecStorage<T, R, C> where DefaultAllocator: Allocator<usize, C> {}
 
-impl<'a, N: Scalar, R: Dim, C: Dim> CsStorageIter<'a, N, R, C> for CsVecStorage<N, R, C>
+impl<'a, T: Scalar, R: Dim, C: Dim> CsStorageIter<'a, T, R, C> for CsVecStorage<T, R, C>
 where
     DefaultAllocator: Allocator<usize, C>,
 {
-    type ColumnEntries = ColumnEntries<'a, N>;
+    type ColumnEntries = ColumnEntries<'a, T>;
     type ColumnRowIndices = iter::Cloned<slice::Iter<'a, usize>>;
 
     #[inline]
@@ -156,7 +156,7 @@ where
     }
 }
 
-impl<N: Scalar, R: Dim, C: Dim> CsStorage<N, R, C> for CsVecStorage<N, R, C>
+impl<T: Scalar, R: Dim, C: Dim> CsStorage<T, R, C> for CsVecStorage<T, R, C>
 where
     DefaultAllocator: Allocator<usize, C>,
 {
@@ -181,12 +181,12 @@ where
     }
 
     #[inline]
-    unsafe fn get_value_unchecked(&self, i: usize) -> &N {
+    unsafe fn get_value_unchecked(&self, i: usize) -> &T {
         self.vals.get_unchecked(i)
     }
 
     #[inline]
-    fn get_value(&self, i: usize) -> &N {
+    fn get_value(&self, i: usize) -> &T {
         &self.vals[i]
     }
 
@@ -202,12 +202,12 @@ where
     }
 }
 
-impl<'a, N: Scalar, R: Dim, C: Dim> CsStorageIterMut<'a, N, R, C> for CsVecStorage<N, R, C>
+impl<'a, T: Scalar, R: Dim, C: Dim> CsStorageIterMut<'a, T, R, C> for CsVecStorage<T, R, C>
 where
     DefaultAllocator: Allocator<usize, C>,
 {
-    type ValuesMut = slice::IterMut<'a, N>;
-    type ColumnEntriesMut = iter::Zip<iter::Cloned<slice::Iter<'a, usize>>, slice::IterMut<'a, N>>;
+    type ValuesMut = slice::IterMut<'a, T>;
+    type ColumnEntriesMut = iter::Zip<iter::Cloned<slice::Iter<'a, usize>>, slice::IterMut<'a, T>>;
 
     #[inline]
     fn values_mut(&'a mut self) -> Self::ValuesMut {
@@ -224,35 +224,35 @@ where
     }
 }
 
-impl<N: Scalar, R: Dim, C: Dim> CsStorageMut<N, R, C> for CsVecStorage<N, R, C> where
+impl<T: Scalar, R: Dim, C: Dim> CsStorageMut<T, R, C> for CsVecStorage<T, R, C> where
     DefaultAllocator: Allocator<usize, C>
 {
 }
 
 /*
-pub struct CsSliceStorage<'a, N: Scalar, R: Dim, C: DimAdd<U1>> {
+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<N, Dynamic>,
+    vals: VectorSlice<T, Dynamic>,
 }*/
 
 /// A compressed sparse column matrix.
 #[derive(Clone, Debug, PartialEq)]
 pub struct CsMatrix<
-    N: Scalar,
+    T: Scalar,
     R: Dim = Dynamic,
     C: Dim = Dynamic,
-    S: CsStorage<N, R, C> = CsVecStorage<N, R, C>,
+    S: CsStorage<T, R, C> = CsVecStorage<T, R, C>,
 > {
     pub(crate) data: S,
-    _phantoms: PhantomData<(N, R, C)>,
+    _phantoms: PhantomData<(T, R, C)>,
 }
 
 /// A column compressed sparse vector.
-pub type CsVector<N, R = Dynamic, S = CsVecStorage<N, R, U1>> = CsMatrix<N, R, U1, S>;
+pub type CsVector<T, R = Dynamic, S = CsVecStorage<T, R, U1>> = CsMatrix<T, R, U1, S>;
 
-impl<N: Scalar, R: Dim, C: Dim> CsMatrix<N, R, C>
+impl<T: Scalar, R: Dim, C: Dim> CsMatrix<T, R, C>
 where
     DefaultAllocator: Allocator<usize, C>,
 {
@@ -274,7 +274,7 @@ where
         CsMatrix {
             data: CsVecStorage {
                 shape: (nrows, ncols),
-                p: VectorN::zeros_generic(ncols, U1),
+                p: OVector::zeros_generic(ncols, Const::<1>),
                 i,
                 vals,
             },
@@ -286,13 +286,13 @@ where
     pub(crate) fn from_parts_generic(
         nrows: R,
         ncols: C,
-        p: VectorN<usize, C>,
+        p: OVector<usize, C>,
         i: Vec<usize>,
-        vals: Vec<N>,
+        vals: Vec<T>,
     ) -> Self
     where
-        N: Zero + ClosedAdd,
-        DefaultAllocator: Allocator<N, R>,
+        T: Zero + ClosedAdd,
+        DefaultAllocator: Allocator<T, R>,
     {
         assert_eq!(ncols.value(), p.len(), "Invalid inptr size.");
         assert_eq!(i.len(), vals.len(), "Invalid value size.");
@@ -330,13 +330,13 @@ where
 }
 
 /*
-impl<N: Scalar + Zero + ClosedAdd> CsMatrix<N> {
+impl<T: Scalar + Zero + ClosedAdd> CsMatrix<T> {
     pub(crate) fn from_parts(
         nrows: usize,
         ncols: usize,
         p: Vec<usize>,
         i: Vec<usize>,
-        vals: Vec<N>,
+        vals: Vec<T>,
     ) -> Self
     {
         let nrows = Dynamic::new(nrows);
@@ -347,7 +347,7 @@ impl<N: Scalar + Zero + ClosedAdd> CsMatrix<N> {
 }
 */
 
-impl<N: Scalar, R: Dim, C: Dim, S: CsStorage<N, R, C>> CsMatrix<N, R, C, S> {
+impl<T: Scalar, R: Dim, C: Dim, S: CsStorage<T, R, C>> CsMatrix<T, R, C, S> {
     pub(crate) fn from_data(data: S) -> Self {
         CsMatrix {
             data,
@@ -409,7 +409,7 @@ impl<N: Scalar, R: Dim, C: Dim, S: CsStorage<N, R, C>> CsMatrix<N, R, C, S> {
     }
 
     /// Computes the transpose of this sparse matrix.
-    pub fn transpose(&self) -> CsMatrix<N, C, R>
+    pub fn transpose(&self) -> CsMatrix<T, C, R>
     where
         DefaultAllocator: Allocator<usize, R>,
     {
@@ -417,7 +417,7 @@ impl<N: Scalar, R: Dim, C: Dim, S: CsStorage<N, R, C>> CsMatrix<N, R, C, S> {
 
         let nvals = self.len();
         let mut res = CsMatrix::new_uninitialized_generic(ncols, nrows, nvals);
-        let mut workspace = Vector::zeros_generic(nrows, U1);
+        let mut workspace = Vector::zeros_generic(nrows, Const::<1>);
 
         // Compute p.
         for i in 0..nvals {
@@ -442,29 +442,30 @@ impl<N: Scalar, R: Dim, C: Dim, S: CsStorage<N, R, C>> CsMatrix<N, R, C, S> {
     }
 }
 
-impl<N: Scalar, R: Dim, C: Dim, S: CsStorageMut<N, R, C>> CsMatrix<N, R, C, S> {
+impl<T: Scalar, R: Dim, C: Dim, S: CsStorageMut<T, R, C>> CsMatrix<T, R, C, S> {
     /// Iterator through all the mutable values of this sparse matrix.
     #[inline]
-    pub fn values_mut(&mut self) -> impl Iterator<Item = &mut N> {
+    pub fn values_mut(&mut self) -> impl Iterator<Item = &mut T> {
         self.data.values_mut()
     }
 }
 
-impl<N: Scalar, R: Dim, C: Dim> CsMatrix<N, R, C>
+impl<T: Scalar, R: Dim, C: Dim> CsMatrix<T, R, C>
 where
     DefaultAllocator: Allocator<usize, C>,
 {
     pub(crate) fn sort(&mut self)
     where
-        DefaultAllocator: Allocator<N, R>,
+        DefaultAllocator: Allocator<T, R>,
     {
         // Size = R
         let nrows = self.data.shape().0;
-        let mut workspace = unsafe { crate::unimplemented_or_uninitialized_generic!(nrows, U1) };
+        let mut workspace =
+            unsafe { crate::unimplemented_or_uninitialized_generic!(nrows, Const::<1>) };
         self.sort_with_workspace(workspace.as_mut_slice());
     }
 
-    pub(crate) fn sort_with_workspace(&mut self, workspace: &mut [N]) {
+    pub(crate) fn sort_with_workspace(&mut self, workspace: &mut [T]) {
         assert!(
             workspace.len() >= self.nrows(),
             "Workspace must be able to hold at least self.nrows() elements."
@@ -490,7 +491,7 @@ where
     // Remove dupliate entries on a sorted CsMatrix.
     pub(crate) fn dedup(&mut self)
     where
-        N: Zero + ClosedAdd,
+        T: Zero + ClosedAdd,
     {
         let mut curr_i = 0;
 
@@ -499,7 +500,7 @@ where
             self.data.p[j] = curr_i;
 
             if range.start != range.end {
-                let mut value = N::zero();
+                let mut value = T::zero();
                 let mut irow = self.data.i[range.start];
 
                 for idx in range {
diff --git a/src/sparse/cs_matrix_cholesky.rs b/src/sparse/cs_matrix_cholesky.rs
index 1a0c15dc..4cd61d2a 100644
--- a/src/sparse/cs_matrix_cholesky.rs
+++ b/src/sparse/cs_matrix_cholesky.rs
@@ -3,12 +3,12 @@ use std::mem;
 
 use crate::allocator::Allocator;
 use crate::sparse::{CsMatrix, CsStorage, CsStorageIter, CsStorageIterMut, CsVecStorage};
-use crate::{DefaultAllocator, Dim, RealField, VectorN, U1};
+use crate::{Const, DefaultAllocator, Dim, OVector, RealField};
 
 /// The cholesky decomposition of a column compressed sparse matrix.
-pub struct CsCholesky<N: RealField, D: Dim>
+pub struct CsCholesky<T: RealField, D: Dim>
 where
-    DefaultAllocator: Allocator<usize, D> + Allocator<N, D>,
+    DefaultAllocator: Allocator<usize, D> + Allocator<T, D>,
 {
     // Non-zero pattern of the original matrix upper-triangular part.
     // Unlike the original matrix, the `original_p` array does contain the last sentinel value
@@ -16,22 +16,22 @@ where
     original_p: Vec<usize>,
     original_i: Vec<usize>,
     // Decomposition result.
-    l: CsMatrix<N, D, D>,
+    l: CsMatrix<T, D, D>,
     // Used only for the pattern.
     // TODO: store only the nonzero pattern instead.
-    u: CsMatrix<N, D, D>,
+    u: CsMatrix<T, D, D>,
     ok: bool,
     // Workspaces.
-    work_x: VectorN<N, D>,
-    work_c: VectorN<usize, D>,
+    work_x: OVector<T, D>,
+    work_c: OVector<usize, D>,
 }
 
-impl<N: RealField, D: Dim> CsCholesky<N, D>
+impl<T: RealField, D: Dim> CsCholesky<T, D>
 where
-    DefaultAllocator: Allocator<usize, D> + Allocator<N, D>,
+    DefaultAllocator: Allocator<usize, D> + Allocator<T, D>,
 {
     /// Computes the cholesky decomposition of the sparse matrix `m`.
-    pub fn new(m: &CsMatrix<N, D, D>) -> Self {
+    pub fn new(m: &CsMatrix<T, D, D>) -> Self {
         let mut me = Self::new_symbolic(m);
         let _ = me.decompose_left_looking(&m.data.vals);
         me
@@ -39,7 +39,7 @@ where
     /// Perform symbolic analysis for the given matrix.
     ///
     /// This does not access the numerical values of `m`.
-    pub fn new_symbolic(m: &CsMatrix<N, D, D>) -> Self {
+    pub fn new_symbolic(m: &CsMatrix<T, D, D>) -> Self {
         assert!(
             m.is_square(),
             "The matrix `m` must be square to compute its elimination tree."
@@ -49,9 +49,9 @@ where
 
         // Workspaces.
         let work_x =
-            unsafe { crate::unimplemented_or_uninitialized_generic!(m.data.shape().0, U1) };
+            unsafe { crate::unimplemented_or_uninitialized_generic!(m.data.shape().0, Const::<1>) };
         let work_c =
-            unsafe { crate::unimplemented_or_uninitialized_generic!(m.data.shape().1, U1) };
+            unsafe { crate::unimplemented_or_uninitialized_generic!(m.data.shape().1, Const::<1>) };
         let mut original_p = m.data.p.as_slice().to_vec();
         original_p.push(m.data.i.len());
 
@@ -67,7 +67,7 @@ where
     }
 
     /// The lower-triangular matrix of the cholesky decomposition.
-    pub fn l(&self) -> Option<&CsMatrix<N, D, D>> {
+    pub fn l(&self) -> Option<&CsMatrix<T, D, D>> {
         if self.ok {
             Some(&self.l)
         } else {
@@ -76,7 +76,7 @@ where
     }
 
     /// Extracts the lower-triangular matrix of the cholesky decomposition.
-    pub fn unwrap_l(self) -> Option<CsMatrix<N, D, D>> {
+    pub fn unwrap_l(self) -> Option<CsMatrix<T, D, D>> {
         if self.ok {
             Some(self.l)
         } else {
@@ -86,7 +86,7 @@ where
 
     /// Perform a numerical left-looking cholesky decomposition of a matrix with the same structure as the
     /// one used to initialize `self`, but with different non-zero values provided by `values`.
-    pub fn decompose_left_looking(&mut self, values: &[N]) -> bool {
+    pub fn decompose_left_looking(&mut self, values: &[T]) -> bool {
         assert!(
             values.len() >= self.original_i.len(),
             "The set of values is too small."
@@ -103,7 +103,7 @@ where
                 let range_k =
                     *self.original_p.get_unchecked(k)..*self.original_p.get_unchecked(k + 1);
 
-                *self.work_x.vget_unchecked_mut(k) = N::zero();
+                *self.work_x.vget_unchecked_mut(k) = T::zero();
                 for p in range_k.clone() {
                     let irow = *self.original_i.get_unchecked(p);
 
@@ -131,7 +131,7 @@ where
 
                 let diag = *self.work_x.vget_unchecked(k);
 
-                if diag > N::zero() {
+                if diag > T::zero() {
                     let denom = diag.sqrt();
                     *self
                         .l
@@ -141,7 +141,7 @@ where
 
                     for (p, val) in self.l.data.column_entries_mut(k) {
                         *val = *self.work_x.vget_unchecked(p) / denom;
-                        *self.work_x.vget_unchecked_mut(p) = N::zero();
+                        *self.work_x.vget_unchecked_mut(p) = T::zero();
                     }
                 } else {
                     self.ok = false;
@@ -156,7 +156,7 @@ where
 
     /// Perform a numerical up-looking cholesky decomposition of a matrix with the same structure as the
     /// one used to initialize `self`, but with different non-zero values provided by `values`.
-    pub fn decompose_up_looking(&mut self, values: &[N]) -> bool {
+    pub fn decompose_up_looking(&mut self, values: &[T]) -> bool {
         assert!(
             values.len() >= self.original_i.len(),
             "The set of values is too small."
@@ -172,7 +172,7 @@ where
                 let column_range =
                     *self.original_p.get_unchecked(k)..*self.original_p.get_unchecked(k + 1);
 
-                *self.work_x.vget_unchecked_mut(k) = N::zero();
+                *self.work_x.vget_unchecked_mut(k) = T::zero();
                 for p in column_range.clone() {
                     let irow = *self.original_i.get_unchecked(p);
 
@@ -182,7 +182,7 @@ where
                 }
 
                 let mut diag = *self.work_x.vget_unchecked(k);
-                *self.work_x.vget_unchecked_mut(k) = N::zero();
+                *self.work_x.vget_unchecked_mut(k) = T::zero();
 
                 // Triangular solve.
                 for irow in self.u.data.column_row_indices(k) {
@@ -196,7 +196,7 @@ where
                             .data
                             .vals
                             .get_unchecked(*self.l.data.p.vget_unchecked(irow));
-                    *self.work_x.vget_unchecked_mut(irow) = N::zero();
+                    *self.work_x.vget_unchecked_mut(irow) = T::zero();
 
                     for p in
                         *self.l.data.p.vget_unchecked(irow) + 1..*self.work_c.vget_unchecked(irow)
@@ -214,7 +214,7 @@ where
                     *self.l.data.vals.get_unchecked_mut(p) = lki;
                 }
 
-                if diag <= N::zero() {
+                if diag <= T::zero() {
                     self.ok = false;
                     return false;
                 }
@@ -231,7 +231,7 @@ where
         true
     }
 
-    fn elimination_tree<S: CsStorage<N, D, D>>(m: &CsMatrix<N, D, D, S>) -> Vec<usize> {
+    fn elimination_tree<S: CsStorage<T, D, D>>(m: &CsMatrix<T, D, D, S>) -> Vec<usize> {
         let nrows = m.nrows();
         let mut forest: Vec<_> = iter::repeat(usize::max_value()).take(nrows).collect();
         let mut ancestor: Vec<_> = iter::repeat(usize::max_value()).take(nrows).collect();
@@ -257,8 +257,8 @@ where
         forest
     }
 
-    fn reach<S: CsStorage<N, D, D>>(
-        m: &CsMatrix<N, D, D, S>,
+    fn reach<S: CsStorage<T, D, D>>(
+        m: &CsMatrix<T, D, D, S>,
         j: usize,
         max_j: usize,
         tree: &[usize],
@@ -287,14 +287,14 @@ where
         out.append(&mut res);
     }
 
-    fn nonzero_pattern<S: CsStorage<N, D, D>>(
-        m: &CsMatrix<N, D, D, S>,
-    ) -> (CsMatrix<N, D, D>, CsMatrix<N, D, D>) {
+    fn nonzero_pattern<S: CsStorage<T, D, D>>(
+        m: &CsMatrix<T, D, D, S>,
+    ) -> (CsMatrix<T, D, D>, CsMatrix<T, D, D>) {
         let etree = Self::elimination_tree(m);
         let (nrows, ncols) = m.data.shape();
         let mut rows = Vec::with_capacity(m.len());
         let mut cols =
-            unsafe { crate::unimplemented_or_uninitialized_generic!(m.data.shape().0, U1) };
+            unsafe { crate::unimplemented_or_uninitialized_generic!(m.data.shape().0, Const::<1>) };
         let mut marks = Vec::new();
 
         // NOTE: the following will actually compute the non-zero pattern of
@@ -329,8 +329,8 @@ where
      * NOTE: All the following methods are untested and currently unused.
      *
      *
-    fn column_counts<S: CsStorage<N, D, D>>(
-        m: &CsMatrix<N, D, D, S>,
+    fn column_counts<S: CsStorage<T, D, D>>(
+        m: &CsMatrix<T, D, D, S>,
         tree: &[usize],
     ) -> Vec<usize> {
         let len = m.data.shape().0.value();
diff --git a/src/sparse/cs_matrix_conversion.rs b/src/sparse/cs_matrix_conversion.rs
index 8025f94e..4fefd325 100644
--- a/src/sparse/cs_matrix_conversion.rs
+++ b/src/sparse/cs_matrix_conversion.rs
@@ -5,24 +5,24 @@ use crate::allocator::Allocator;
 use crate::sparse::cs_utils;
 use crate::sparse::{CsMatrix, CsStorage};
 use crate::storage::Storage;
-use crate::{DefaultAllocator, Dim, Dynamic, Matrix, MatrixMN, Scalar};
+use crate::{DefaultAllocator, Dim, Dynamic, Matrix, OMatrix, Scalar};
 
-impl<'a, N: Scalar + Zero + ClosedAdd> CsMatrix<N> {
+impl<'a, T: Scalar + Zero + ClosedAdd> CsMatrix<T> {
     /// Creates a column-compressed sparse matrix from a sparse matrix in triplet form.
     pub fn from_triplet(
         nrows: usize,
         ncols: usize,
         irows: &[usize],
         icols: &[usize],
-        vals: &[N],
+        vals: &[T],
     ) -> Self {
         Self::from_triplet_generic(Dynamic::new(nrows), Dynamic::new(ncols), irows, icols, vals)
     }
 }
 
-impl<'a, N: Scalar + Zero + ClosedAdd, R: Dim, C: Dim> CsMatrix<N, R, C>
+impl<'a, T: Scalar + Zero + ClosedAdd, R: Dim, C: Dim> CsMatrix<T, R, C>
 where
-    DefaultAllocator: Allocator<usize, C> + Allocator<N, R>,
+    DefaultAllocator: Allocator<usize, C> + Allocator<T, R>,
 {
     /// Creates a column-compressed sparse matrix from a sparse matrix in triplet form.
     pub fn from_triplet_generic(
@@ -30,7 +30,7 @@ where
         ncols: C,
         irows: &[usize],
         icols: &[usize],
-        vals: &[N],
+        vals: &[T],
     ) -> Self {
         assert!(vals.len() == irows.len());
         assert!(vals.len() == icols.len());
@@ -65,14 +65,14 @@ where
     }
 }
 
-impl<'a, N: Scalar + Zero, R: Dim, C: Dim, S> From<CsMatrix<N, R, C, S>> for MatrixMN<N, R, C>
+impl<'a, T: Scalar + Zero, R: Dim, C: Dim, S> From<CsMatrix<T, R, C, S>> for OMatrix<T, R, C>
 where
-    S: CsStorage<N, R, C>,
-    DefaultAllocator: Allocator<N, R, C>,
+    S: CsStorage<T, R, C>,
+    DefaultAllocator: Allocator<T, R, C>,
 {
-    fn from(m: CsMatrix<N, R, C, S>) -> Self {
+    fn from(m: CsMatrix<T, R, C, S>) -> Self {
         let (nrows, ncols) = m.data.shape();
-        let mut res = MatrixMN::zeros_generic(nrows, ncols);
+        let mut res = OMatrix::zeros_generic(nrows, ncols);
 
         for j in 0..ncols.value() {
             for (i, val) in m.data.column_entries(j) {
@@ -84,12 +84,12 @@ where
     }
 }
 
-impl<'a, N: Scalar + Zero, R: Dim, C: Dim, S> From<Matrix<N, R, C, S>> for CsMatrix<N, R, C>
+impl<'a, T: Scalar + Zero, R: Dim, C: Dim, S> From<Matrix<T, R, C, S>> for CsMatrix<T, R, C>
 where
-    S: Storage<N, R, C>,
-    DefaultAllocator: Allocator<N, R, C> + Allocator<usize, C>,
+    S: Storage<T, R, C>,
+    DefaultAllocator: Allocator<T, R, C> + Allocator<usize, C>,
 {
-    fn from(m: Matrix<N, R, C, S>) -> Self {
+    fn from(m: Matrix<T, R, C, S>) -> Self {
         let (nrows, ncols) = m.data.shape();
         let len = m.iter().filter(|e| !e.is_zero()).count();
         let mut res = CsMatrix::new_uninitialized_generic(nrows, ncols, len);
diff --git a/src/sparse/cs_matrix_ops.rs b/src/sparse/cs_matrix_ops.rs
index a440882c..e9daa4ae 100644
--- a/src/sparse/cs_matrix_ops.rs
+++ b/src/sparse/cs_matrix_ops.rs
@@ -6,21 +6,21 @@ use crate::allocator::Allocator;
 use crate::constraint::{AreMultipliable, DimEq, ShapeConstraint};
 use crate::sparse::{CsMatrix, CsStorage, CsStorageMut, CsVector};
 use crate::storage::StorageMut;
-use crate::{DefaultAllocator, Dim, Scalar, Vector, VectorN, U1};
+use crate::{Const, DefaultAllocator, Dim, OVector, Scalar, Vector};
 
-impl<N: Scalar, R: Dim, C: Dim, S: CsStorage<N, R, C>> CsMatrix<N, R, C, S> {
+impl<T: Scalar, R: Dim, C: Dim, S: CsStorage<T, R, C>> CsMatrix<T, R, C, S> {
     fn scatter<R2: Dim, C2: Dim>(
         &self,
         j: usize,
-        beta: N,
+        beta: T,
         timestamps: &mut [usize],
         timestamp: usize,
-        workspace: &mut [N],
+        workspace: &mut [T],
         mut nz: usize,
-        res: &mut CsMatrix<N, R2, C2>,
+        res: &mut CsMatrix<T, R2, C2>,
     ) -> usize
     where
-        N: ClosedAdd + ClosedMul,
+        T: ClosedAdd + ClosedMul,
         DefaultAllocator: Allocator<usize, C2>,
     {
         for (i, val) in self.data.column_entries(j) {
@@ -39,8 +39,8 @@ impl<N: Scalar, R: Dim, C: Dim, S: CsStorage<N, R, C>> CsMatrix<N, R, C, S> {
 }
 
 /*
-impl<N: Scalar, R, S> CsVector<N, R, S> {
-    pub fn axpy(&mut self, alpha: N, x: CsVector<N, R, S>, beta: N) {
+impl<T: Scalar, R, S> CsVector<T, R, S> {
+    pub fn axpy(&mut self, alpha: T, x: CsVector<T, R, S>, beta: T) {
         // First, compute the number of non-zero entries.
         let mut nnzero = 0;
 
@@ -76,11 +76,11 @@ impl<N: Scalar, R, S> CsVector<N, R, S> {
 }
 */
 
-impl<N: Scalar + Zero + ClosedAdd + ClosedMul, D: Dim, S: StorageMut<N, D>> Vector<N, D, S> {
+impl<T: Scalar + Zero + ClosedAdd + ClosedMul, D: Dim, S: StorageMut<T, D>> Vector<T, D, S> {
     /// Perform a sparse axpy operation: `self = alpha * x + beta * self` operation.
-    pub fn axpy_cs<D2: Dim, S2>(&mut self, alpha: N, x: &CsVector<N, D2, S2>, beta: N)
+    pub fn axpy_cs<D2: Dim, S2>(&mut self, alpha: T, x: &CsVector<T, D2, S2>, beta: T)
     where
-        S2: CsStorage<N, D2>,
+        S2: CsStorage<T, D2>,
         ShapeConstraint: DimEq<D, D2>,
     {
         if beta.is_zero() {
@@ -106,9 +106,9 @@ impl<N: Scalar + Zero + ClosedAdd + ClosedMul, D: Dim, S: StorageMut<N, D>> Vect
     }
 
     /*
-    pub fn gemv_sparse<R2: Dim, C2: Dim, S2>(&mut self, alpha: N, a: &CsMatrix<N, R2, C2, S2>, x: &DVector<N>, beta: N)
+    pub fn gemv_sparse<R2: Dim, C2: Dim, S2>(&mut self, alpha: T, a: &CsMatrix<T, R2, C2, S2>, x: &DVector<T>, beta: T)
         where
-            S2: CsStorage<N, R2, C2> {
+            S2: CsStorage<T, R2, C2> {
         let col2 = a.column(0);
         let val = unsafe { *x.vget_unchecked(0) };
         self.axpy_sparse(alpha * val, &col2, beta);
@@ -117,28 +117,28 @@ impl<N: Scalar + Zero + ClosedAdd + ClosedMul, D: Dim, S: StorageMut<N, D>> Vect
             let col2 = a.column(j);
             let val = unsafe { *x.vget_unchecked(j) };
 
-            self.axpy_sparse(alpha * val, &col2, N::one());
+            self.axpy_sparse(alpha * val, &col2, T::one());
         }
     }
     */
 }
 
-impl<'a, 'b, N, R1, R2, C1, C2, S1, S2> Mul<&'b CsMatrix<N, R2, C2, S2>>
-    for &'a CsMatrix<N, R1, C1, S1>
+impl<'a, 'b, T, R1, R2, C1, C2, S1, S2> Mul<&'b CsMatrix<T, R2, C2, S2>>
+    for &'a CsMatrix<T, R1, C1, S1>
 where
-    N: Scalar + ClosedAdd + ClosedMul + Zero,
+    T: Scalar + ClosedAdd + ClosedMul + Zero,
     R1: Dim,
     C1: Dim,
     R2: Dim,
     C2: Dim,
-    S1: CsStorage<N, R1, C1>,
-    S2: CsStorage<N, R2, C2>,
+    S1: CsStorage<T, R1, C1>,
+    S2: CsStorage<T, R2, C2>,
     ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,
-    DefaultAllocator: Allocator<usize, C2> + Allocator<usize, R1> + Allocator<N, R1>,
+    DefaultAllocator: Allocator<usize, C2> + Allocator<usize, R1> + Allocator<T, R1>,
 {
-    type Output = CsMatrix<N, R1, C2>;
+    type Output = CsMatrix<T, R1, C2>;
 
-    fn mul(self, rhs: &'b CsMatrix<N, R2, C2, S2>) -> Self::Output {
+    fn mul(self, rhs: &'b CsMatrix<T, R2, C2, S2>) -> Self::Output {
         let (nrows1, ncols1) = self.data.shape();
         let (nrows2, ncols2) = rhs.data.shape();
         assert_eq!(
@@ -148,14 +148,14 @@ where
         );
 
         let mut res = CsMatrix::new_uninitialized_generic(nrows1, ncols2, self.len() + rhs.len());
-        let mut workspace = VectorN::<N, R1>::zeros_generic(nrows1, U1);
+        let mut workspace = OVector::<T, R1>::zeros_generic(nrows1, Const::<1>);
         let mut nz = 0;
 
         for j in 0..ncols2.value() {
             res.data.p[j] = nz;
             let new_size_bound = nz + nrows1.value();
             res.data.i.resize(new_size_bound, 0);
-            res.data.vals.resize(new_size_bound, N::zero());
+            res.data.vals.resize(new_size_bound, T::zero());
 
             for (i, beta) in rhs.data.column_entries(j) {
                 for (k, val) in self.data.column_entries(i) {
@@ -167,7 +167,7 @@ where
                 if !val.is_zero() {
                     res.data.i[nz] = i;
                     res.data.vals[nz] = val.inlined_clone();
-                    *val = N::zero();
+                    *val = T::zero();
                     nz += 1;
                 }
             }
@@ -177,15 +177,15 @@ where
         // of branching inside of the inner loop.
         //
         // let mut res = CsMatrix::new_uninitialized_generic(nrows1, ncols2, self.len() + rhs.len());
-        // let mut timestamps = VectorN::zeros_generic(nrows1, U1);
-        // let mut workspace = unsafe { VectorN::new_uninitialized_generic(nrows1, U1) };
+        // let mut timestamps = OVector::zeros_generic(nrows1, Const::<)>;
+        // let mut workspace = unsafe { OVector::new_uninitialized_generic(nrows1, Const::<)> };
         // let mut nz = 0;
         //
         // for j in 0..ncols2.value() {
         //     res.data.p[j] = nz;
         //     let new_size_bound = nz + nrows1.value();
         //     res.data.i.resize(new_size_bound, 0);
-        //     res.data.vals.resize(new_size_bound, N::zero());
+        //     res.data.vals.resize(new_size_bound, T::zero());
         //
         //     for (i, val) in rhs.data.column_entries(j) {
         //         nz = self.scatter(
@@ -216,22 +216,22 @@ where
     }
 }
 
-impl<'a, 'b, N, R1, R2, C1, C2, S1, S2> Add<&'b CsMatrix<N, R2, C2, S2>>
-    for &'a CsMatrix<N, R1, C1, S1>
+impl<'a, 'b, T, R1, R2, C1, C2, S1, S2> Add<&'b CsMatrix<T, R2, C2, S2>>
+    for &'a CsMatrix<T, R1, C1, S1>
 where
-    N: Scalar + ClosedAdd + ClosedMul + One,
+    T: Scalar + ClosedAdd + ClosedMul + One,
     R1: Dim,
     C1: Dim,
     R2: Dim,
     C2: Dim,
-    S1: CsStorage<N, R1, C1>,
-    S2: CsStorage<N, R2, C2>,
+    S1: CsStorage<T, R1, C1>,
+    S2: CsStorage<T, R2, C2>,
     ShapeConstraint: DimEq<R1, R2> + DimEq<C1, C2>,
-    DefaultAllocator: Allocator<usize, C2> + Allocator<usize, R1> + Allocator<N, R1>,
+    DefaultAllocator: Allocator<usize, C2> + Allocator<usize, R1> + Allocator<T, R1>,
 {
-    type Output = CsMatrix<N, R1, C2>;
+    type Output = CsMatrix<T, R1, C2>;
 
-    fn add(self, rhs: &'b CsMatrix<N, R2, C2, S2>) -> Self::Output {
+    fn add(self, rhs: &'b CsMatrix<T, R2, C2, S2>) -> Self::Output {
         let (nrows1, ncols1) = self.data.shape();
         let (nrows2, ncols2) = rhs.data.shape();
         assert_eq!(
@@ -241,8 +241,9 @@ where
         );
 
         let mut res = CsMatrix::new_uninitialized_generic(nrows1, ncols2, self.len() + rhs.len());
-        let mut timestamps = VectorN::zeros_generic(nrows1, U1);
-        let mut workspace = unsafe { crate::unimplemented_or_uninitialized_generic!(nrows1, U1) };
+        let mut timestamps = OVector::zeros_generic(nrows1, Const::<1>);
+        let mut workspace =
+            unsafe { crate::unimplemented_or_uninitialized_generic!(nrows1, Const::<1>) };
         let mut nz = 0;
 
         for j in 0..ncols2.value() {
@@ -250,7 +251,7 @@ where
 
             nz = self.scatter(
                 j,
-                N::one(),
+                T::one(),
                 timestamps.as_mut_slice(),
                 j + 1,
                 workspace.as_mut_slice(),
@@ -260,7 +261,7 @@ where
 
             nz = rhs.scatter(
                 j,
-                N::one(),
+                T::one(),
                 timestamps.as_mut_slice(),
                 j + 1,
                 workspace.as_mut_slice(),
@@ -285,16 +286,16 @@ where
     }
 }
 
-impl<'a, 'b, N, R, C, S> Mul<N> for CsMatrix<N, R, C, S>
+impl<'a, 'b, T, R, C, S> Mul<T> for CsMatrix<T, R, C, S>
 where
-    N: Scalar + ClosedAdd + ClosedMul + Zero,
+    T: Scalar + ClosedAdd + ClosedMul + Zero,
     R: Dim,
     C: Dim,
-    S: CsStorageMut<N, R, C>,
+    S: CsStorageMut<T, R, C>,
 {
     type Output = Self;
 
-    fn mul(mut self, rhs: N) -> Self::Output {
+    fn mul(mut self, rhs: T) -> Self::Output {
         for e in self.values_mut() {
             *e *= rhs.inlined_clone()
         }
diff --git a/src/sparse/cs_matrix_solve.rs b/src/sparse/cs_matrix_solve.rs
index bc7c5bc7..52065747 100644
--- a/src/sparse/cs_matrix_solve.rs
+++ b/src/sparse/cs_matrix_solve.rs
@@ -2,17 +2,17 @@ use crate::allocator::Allocator;
 use crate::constraint::{SameNumberOfRows, ShapeConstraint};
 use crate::sparse::{CsMatrix, CsStorage, CsVector};
 use crate::storage::{Storage, StorageMut};
-use crate::{DefaultAllocator, Dim, Matrix, MatrixMN, RealField, VectorN, U1};
+use crate::{Const, DefaultAllocator, Dim, Matrix, OMatrix, OVector, RealField};
 
-impl<N: RealField, D: Dim, S: CsStorage<N, D, D>> CsMatrix<N, D, D, S> {
+impl<T: RealField, D: Dim, S: CsStorage<T, D, D>> CsMatrix<T, D, D, S> {
     /// Solve a lower-triangular system with a dense right-hand-side.
     pub fn solve_lower_triangular<R2: Dim, C2: Dim, S2>(
         &self,
-        b: &Matrix<N, R2, C2, S2>,
-    ) -> Option<MatrixMN<N, R2, C2>>
+        b: &Matrix<T, R2, C2, S2>,
+    ) -> Option<OMatrix<T, R2, C2>>
     where
-        S2: Storage<N, R2, C2>,
-        DefaultAllocator: Allocator<N, R2, C2>,
+        S2: Storage<T, R2, C2>,
+        DefaultAllocator: Allocator<T, R2, C2>,
         ShapeConstraint: SameNumberOfRows<D, R2>,
     {
         let mut b = b.clone_owned();
@@ -26,11 +26,11 @@ impl<N: RealField, D: Dim, S: CsStorage<N, D, D>> CsMatrix<N, D, D, S> {
     /// Solve a lower-triangular system with `self` transposed and a dense right-hand-side.
     pub fn tr_solve_lower_triangular<R2: Dim, C2: Dim, S2>(
         &self,
-        b: &Matrix<N, R2, C2, S2>,
-    ) -> Option<MatrixMN<N, R2, C2>>
+        b: &Matrix<T, R2, C2, S2>,
+    ) -> Option<OMatrix<T, R2, C2>>
     where
-        S2: Storage<N, R2, C2>,
-        DefaultAllocator: Allocator<N, R2, C2>,
+        S2: Storage<T, R2, C2>,
+        DefaultAllocator: Allocator<T, R2, C2>,
         ShapeConstraint: SameNumberOfRows<D, R2>,
     {
         let mut b = b.clone_owned();
@@ -44,10 +44,10 @@ impl<N: RealField, D: Dim, S: CsStorage<N, D, D>> CsMatrix<N, D, D, S> {
     /// Solve in-place a lower-triangular system with a dense right-hand-side.
     pub fn solve_lower_triangular_mut<R2: Dim, C2: Dim, S2>(
         &self,
-        b: &mut Matrix<N, R2, C2, S2>,
+        b: &mut Matrix<T, R2, C2, S2>,
     ) -> bool
     where
-        S2: StorageMut<N, R2, C2>,
+        S2: StorageMut<T, R2, C2>,
         ShapeConstraint: SameNumberOfRows<D, R2>,
     {
         let (nrows, ncols) = self.data.shape();
@@ -90,10 +90,10 @@ impl<N: RealField, D: Dim, S: CsStorage<N, D, D>> CsMatrix<N, D, D, S> {
     /// Solve a lower-triangular system with `self` transposed and a dense right-hand-side.
     pub fn tr_solve_lower_triangular_mut<R2: Dim, C2: Dim, S2>(
         &self,
-        b: &mut Matrix<N, R2, C2, S2>,
+        b: &mut Matrix<T, R2, C2, S2>,
     ) -> bool
     where
-        S2: StorageMut<N, R2, C2>,
+        S2: StorageMut<T, R2, C2>,
         ShapeConstraint: SameNumberOfRows<D, R2>,
     {
         let (nrows, ncols) = self.data.shape();
@@ -137,11 +137,11 @@ impl<N: RealField, D: Dim, S: CsStorage<N, D, D>> CsMatrix<N, D, D, S> {
     /// Solve a lower-triangular system with a sparse right-hand-side.
     pub fn solve_lower_triangular_cs<D2: Dim, S2>(
         &self,
-        b: &CsVector<N, D2, S2>,
-    ) -> Option<CsVector<N, D2>>
+        b: &CsVector<T, D2, S2>,
+    ) -> Option<CsVector<T, D2>>
     where
-        S2: CsStorage<N, D2>,
-        DefaultAllocator: Allocator<bool, D> + Allocator<N, D2> + Allocator<usize, D2>,
+        S2: CsStorage<T, D2>,
+        DefaultAllocator: Allocator<bool, D> + Allocator<T, D2> + Allocator<usize, D2>,
         ShapeConstraint: SameNumberOfRows<D, D2>,
     {
         let mut reach = Vec::new();
@@ -150,10 +150,10 @@ impl<N: RealField, D: Dim, S: CsStorage<N, D, D>> CsMatrix<N, D, D, S> {
         // We sort the reach so the result matrix has sorted indices.
         reach.sort();
         let mut workspace =
-            unsafe { crate::unimplemented_or_uninitialized_generic!(b.data.shape().0, U1) };
+            unsafe { crate::unimplemented_or_uninitialized_generic!(b.data.shape().0, Const::<1>) };
 
         for i in reach.iter().cloned() {
-            workspace[i] = N::zero();
+            workspace[i] = T::zero();
         }
 
         for (i, val) in b.data.column_entries(0) {
@@ -187,7 +187,8 @@ impl<N: RealField, D: Dim, S: CsStorage<N, D, D>> CsMatrix<N, D, D, S> {
         }
 
         // Copy the result into a sparse vector.
-        let mut result = CsVector::new_uninitialized_generic(b.data.shape().0, U1, reach.len());
+        let mut result =
+            CsVector::new_uninitialized_generic(b.data.shape().0, Const::<1>, reach.len());
 
         for (i, val) in reach.iter().zip(result.data.vals.iter_mut()) {
             *val = workspace[*i];
@@ -201,13 +202,13 @@ impl<N: RealField, D: Dim, S: CsStorage<N, D, D>> CsMatrix<N, D, D, S> {
     // Computes the reachable, post-ordered, nodes from `b`.
     fn lower_triangular_reach_postordered<D2: Dim, S2>(
         &self,
-        b: &CsVector<N, D2, S2>,
+        b: &CsVector<T, D2, S2>,
         xi: &mut Vec<usize>,
     ) where
-        S2: CsStorage<N, D2>,
+        S2: CsStorage<T, D2>,
         DefaultAllocator: Allocator<bool, D>,
     {
-        let mut visited = VectorN::repeat_generic(self.data.shape().1, U1, false);
+        let mut visited = OVector::repeat_generic(self.data.shape().1, U1, false);
         let mut stack = Vec::new();
 
         for i in b.data.column_range(0) {
@@ -246,12 +247,12 @@ impl<N: RealField, D: Dim, S: CsStorage<N, D, D>> CsMatrix<N, D, D, S> {
     */
 
     // Computes the nodes reachable from `b` in an arbitrary order.
-    fn lower_triangular_reach<D2: Dim, S2>(&self, b: &CsVector<N, D2, S2>, xi: &mut Vec<usize>)
+    fn lower_triangular_reach<D2: Dim, S2>(&self, b: &CsVector<T, D2, S2>, xi: &mut Vec<usize>)
     where
-        S2: CsStorage<N, D2>,
+        S2: CsStorage<T, D2>,
         DefaultAllocator: Allocator<bool, D>,
     {
-        let mut visited = VectorN::repeat_generic(self.data.shape().1, U1, false);
+        let mut visited = OVector::repeat_generic(self.data.shape().1, Const::<1>, false);
         let mut stack = Vec::new();
 
         for irow in b.data.column_row_indices(0) {
diff --git a/src/sparse/cs_utils.rs b/src/sparse/cs_utils.rs
index c73b9639..5b9d86b0 100644
--- a/src/sparse/cs_utils.rs
+++ b/src/sparse/cs_utils.rs
@@ -1,7 +1,7 @@
 use crate::allocator::Allocator;
-use crate::{DefaultAllocator, Dim, VectorN};
+use crate::{DefaultAllocator, Dim, OVector};
 
-pub fn cumsum<D: Dim>(a: &mut VectorN<usize, D>, b: &mut VectorN<usize, D>) -> usize
+pub fn cumsum<D: Dim>(a: &mut OVector<usize, D>, b: &mut OVector<usize, D>) -> usize
 where
     DefaultAllocator: Allocator<usize, D>,
 {
diff --git a/src/third_party/alga/alga_dual_quaternion.rs b/src/third_party/alga/alga_dual_quaternion.rs
index f6ee9e10..d6a5861e 100644
--- a/src/third_party/alga/alga_dual_quaternion.rs
+++ b/src/third_party/alga/alga_dual_quaternion.rs
@@ -15,35 +15,35 @@ use crate::geometry::{
     DualQuaternion, Point3, Quaternion, Translation3, UnitDualQuaternion, UnitQuaternion,
 };
 
-impl<N: RealField + simba::scalar::RealField> Identity<Multiplicative> for DualQuaternion<N> {
+impl<T: RealField + simba::scalar::RealField> Identity<Multiplicative> for DualQuaternion<T> {
     #[inline]
     fn identity() -> Self {
         Self::identity()
     }
 }
 
-impl<N: RealField + simba::scalar::RealField> Identity<Additive> for DualQuaternion<N> {
+impl<T: RealField + simba::scalar::RealField> Identity<Additive> for DualQuaternion<T> {
     #[inline]
     fn identity() -> Self {
         Self::zero()
     }
 }
 
-impl<N: RealField + simba::scalar::RealField> AbstractMagma<Multiplicative> for DualQuaternion<N> {
+impl<T: RealField + simba::scalar::RealField> AbstractMagma<Multiplicative> for DualQuaternion<T> {
     #[inline]
     fn operate(&self, rhs: &Self) -> Self {
         self * rhs
     }
 }
 
-impl<N: RealField + simba::scalar::RealField> AbstractMagma<Additive> for DualQuaternion<N> {
+impl<T: RealField + simba::scalar::RealField> AbstractMagma<Additive> for DualQuaternion<T> {
     #[inline]
     fn operate(&self, rhs: &Self) -> Self {
         self + rhs
     }
 }
 
-impl<N: RealField + simba::scalar::RealField> TwoSidedInverse<Additive> for DualQuaternion<N> {
+impl<T: RealField + simba::scalar::RealField> TwoSidedInverse<Additive> for DualQuaternion<T> {
     #[inline]
     fn two_sided_inverse(&self) -> Self {
         -self
@@ -52,7 +52,7 @@ impl<N: RealField + simba::scalar::RealField> TwoSidedInverse<Additive> for Dual
 
 macro_rules! impl_structures(
     ($DualQuaternion: ident; $($marker: ident<$operator: ident>),* $(,)*) => {$(
-        impl<N: RealField + simba::scalar::RealField> $marker<$operator> for $DualQuaternion<N> { }
+        impl<T: RealField + simba::scalar::RealField> $marker<$operator> for $DualQuaternion<T> { }
     )*}
 );
 
@@ -74,24 +74,24 @@ impl_structures!(
  * Vector space.
  *
  */
-impl<N: RealField + simba::scalar::RealField> AbstractModule for DualQuaternion<N> {
-    type AbstractRing = N;
+impl<T: RealField + simba::scalar::RealField> AbstractModule for DualQuaternion<T> {
+    type AbstractRing = T;
 
     #[inline]
-    fn multiply_by(&self, n: N) -> Self {
+    fn multiply_by(&self, n: T) -> Self {
         self * n
     }
 }
 
-impl<N: RealField + simba::scalar::RealField> Module for DualQuaternion<N> {
-    type Ring = N;
+impl<T: RealField + simba::scalar::RealField> Module for DualQuaternion<T> {
+    type Ring = T;
 }
 
-impl<N: RealField + simba::scalar::RealField> VectorSpace for DualQuaternion<N> {
-    type Field = N;
+impl<T: RealField + simba::scalar::RealField> VectorSpace for DualQuaternion<T> {
+    type Field = T;
 }
 
-impl<N: RealField + simba::scalar::RealField> FiniteDimVectorSpace for DualQuaternion<N> {
+impl<T: RealField + simba::scalar::RealField> FiniteDimVectorSpace for DualQuaternion<T> {
     #[inline]
     fn dimension() -> usize {
         8
@@ -113,32 +113,32 @@ impl<N: RealField + simba::scalar::RealField> FiniteDimVectorSpace for DualQuate
     }
 
     #[inline]
-    fn dot(&self, other: &Self) -> N {
+    fn dot(&self, other: &Self) -> T {
         self.real.dot(&other.real) + self.dual.dot(&other.dual)
     }
 
     #[inline]
-    unsafe fn component_unchecked(&self, i: usize) -> &N {
+    unsafe fn component_unchecked(&self, i: usize) -> &T {
         self.as_ref().get_unchecked(i)
     }
 
     #[inline]
-    unsafe fn component_unchecked_mut(&mut self, i: usize) -> &mut N {
+    unsafe fn component_unchecked_mut(&mut self, i: usize) -> &mut T {
         self.as_mut().get_unchecked_mut(i)
     }
 }
 
-impl<N: RealField + simba::scalar::RealField> NormedSpace for DualQuaternion<N> {
-    type RealField = N;
-    type ComplexField = N;
+impl<T: RealField + simba::scalar::RealField> NormedSpace for DualQuaternion<T> {
+    type RealField = T;
+    type ComplexField = T;
 
     #[inline]
-    fn norm_squared(&self) -> N {
+    fn norm_squared(&self) -> T {
         self.real.norm_squared()
     }
 
     #[inline]
-    fn norm(&self) -> N {
+    fn norm(&self) -> T {
         self.real.norm()
     }
 
@@ -148,12 +148,12 @@ impl<N: RealField + simba::scalar::RealField> NormedSpace for DualQuaternion<N>
     }
 
     #[inline]
-    fn normalize_mut(&mut self) -> N {
+    fn normalize_mut(&mut self) -> T {
         self.normalize_mut()
     }
 
     #[inline]
-    fn try_normalize(&self, min_norm: N) -> Option<Self> {
+    fn try_normalize(&self, min_norm: T) -> Option<Self> {
         let real_norm = self.real.norm();
         if real_norm > min_norm {
             Some(Self::from_real_and_dual(
@@ -166,7 +166,7 @@ impl<N: RealField + simba::scalar::RealField> NormedSpace for DualQuaternion<N>
     }
 
     #[inline]
-    fn try_normalize_mut(&mut self, min_norm: N) -> Option<N> {
+    fn try_normalize_mut(&mut self, min_norm: T) -> Option<T> {
         let real_norm = self.real.norm();
         if real_norm > min_norm {
             self.real /= real_norm;
@@ -183,15 +183,15 @@ impl<N: RealField + simba::scalar::RealField> NormedSpace for DualQuaternion<N>
  * Implementations for UnitDualQuaternion.
  *
  */
-impl<N: RealField + simba::scalar::RealField> Identity<Multiplicative> for UnitDualQuaternion<N> {
+impl<T: RealField + simba::scalar::RealField> Identity<Multiplicative> for UnitDualQuaternion<T> {
     #[inline]
     fn identity() -> Self {
         Self::identity()
     }
 }
 
-impl<N: RealField + simba::scalar::RealField> AbstractMagma<Multiplicative>
-    for UnitDualQuaternion<N>
+impl<T: RealField + simba::scalar::RealField> AbstractMagma<Multiplicative>
+    for UnitDualQuaternion<T>
 {
     #[inline]
     fn operate(&self, rhs: &Self) -> Self {
@@ -199,8 +199,8 @@ impl<N: RealField + simba::scalar::RealField> AbstractMagma<Multiplicative>
     }
 }
 
-impl<N: RealField + simba::scalar::RealField> TwoSidedInverse<Multiplicative>
-    for UnitDualQuaternion<N>
+impl<T: RealField + simba::scalar::RealField> TwoSidedInverse<Multiplicative>
+    for UnitDualQuaternion<T>
 {
     #[inline]
     fn two_sided_inverse(&self) -> Self {
@@ -222,38 +222,38 @@ impl_structures!(
     AbstractGroup<Multiplicative>
 );
 
-impl<N: RealField + simba::scalar::RealField> Transformation<Point3<N>> for UnitDualQuaternion<N> {
+impl<T: RealField + simba::scalar::RealField> Transformation<Point3<T>> for UnitDualQuaternion<T> {
     #[inline]
-    fn transform_point(&self, pt: &Point3<N>) -> Point3<N> {
+    fn transform_point(&self, pt: &Point3<T>) -> Point3<T> {
         self.transform_point(pt)
     }
 
     #[inline]
-    fn transform_vector(&self, v: &Vector3<N>) -> Vector3<N> {
+    fn transform_vector(&self, v: &Vector3<T>) -> Vector3<T> {
         self.transform_vector(v)
     }
 }
 
-impl<N: RealField + simba::scalar::RealField> ProjectiveTransformation<Point3<N>>
-    for UnitDualQuaternion<N>
+impl<T: RealField + simba::scalar::RealField> ProjectiveTransformation<Point3<T>>
+    for UnitDualQuaternion<T>
 {
     #[inline]
-    fn inverse_transform_point(&self, pt: &Point3<N>) -> Point3<N> {
+    fn inverse_transform_point(&self, pt: &Point3<T>) -> Point3<T> {
         self.inverse_transform_point(pt)
     }
 
     #[inline]
-    fn inverse_transform_vector(&self, v: &Vector3<N>) -> Vector3<N> {
+    fn inverse_transform_vector(&self, v: &Vector3<T>) -> Vector3<T> {
         self.inverse_transform_vector(v)
     }
 }
 
-impl<N: RealField + simba::scalar::RealField> AffineTransformation<Point3<N>>
-    for UnitDualQuaternion<N>
+impl<T: RealField + simba::scalar::RealField> AffineTransformation<Point3<T>>
+    for UnitDualQuaternion<T>
 {
-    type Rotation = UnitQuaternion<N>;
+    type Rotation = UnitQuaternion<T>;
     type NonUniformScaling = Id;
-    type Translation = Translation3<N>;
+    type Translation = Translation3<T>;
 
     #[inline]
     fn decompose(&self) -> (Self::Translation, Self::Rotation, Id, Self::Rotation) {
@@ -296,16 +296,16 @@ impl<N: RealField + simba::scalar::RealField> AffineTransformation<Point3<N>>
     }
 }
 
-impl<N: RealField + simba::scalar::RealField> Similarity<Point3<N>> for UnitDualQuaternion<N> {
+impl<T: RealField + simba::scalar::RealField> Similarity<Point3<T>> for UnitDualQuaternion<T> {
     type Scaling = Id;
 
     #[inline]
-    fn translation(&self) -> Translation3<N> {
+    fn translation(&self) -> Translation3<T> {
         self.translation()
     }
 
     #[inline]
-    fn rotation(&self) -> UnitQuaternion<N> {
+    fn rotation(&self) -> UnitQuaternion<T> {
         self.rotation()
     }
 
@@ -317,7 +317,7 @@ impl<N: RealField + simba::scalar::RealField> Similarity<Point3<N>> for UnitDual
 
 macro_rules! marker_impl(
     ($($Trait: ident),*) => {$(
-        impl<N: RealField + simba::scalar::RealField> $Trait<Point3<N>> for UnitDualQuaternion<N> { }
+        impl<T: RealField + simba::scalar::RealField> $Trait<Point3<T>> for UnitDualQuaternion<T> { }
     )*}
 );
 
diff --git a/src/third_party/alga/alga_isometry.rs b/src/third_party/alga/alga_isometry.rs
index 3cb965a8..e0ec2924 100755
--- a/src/third_party/alga/alga_isometry.rs
+++ b/src/third_party/alga/alga_isometry.rs
@@ -8,9 +8,7 @@ use alga::linear::{
     Transformation,
 };
 
-use crate::base::allocator::Allocator;
-use crate::base::dimension::DimName;
-use crate::base::{DefaultAllocator, VectorN};
+use crate::base::SVector;
 
 use crate::geometry::{AbstractRotation, Isometry, Point, Translation};
 
@@ -19,11 +17,10 @@ use crate::geometry::{AbstractRotation, Isometry, Point, Translation};
  * Algebraic structures.
  *
  */
-impl<N: RealField + simba::scalar::RealField, D: DimName, R> Identity<Multiplicative>
-    for Isometry<N, D, R>
+impl<T: RealField + simba::scalar::RealField, R, const D: usize> Identity<Multiplicative>
+    for Isometry<T, R, D>
 where
-    R: Rotation<Point<N, D>> + AbstractRotation<N, D>,
-    DefaultAllocator: Allocator<N, D>,
+    R: Rotation<Point<T, D>> + AbstractRotation<T, D>,
 {
     #[inline]
     fn identity() -> Self {
@@ -31,11 +28,10 @@ where
     }
 }
 
-impl<N: RealField + simba::scalar::RealField, D: DimName, R> TwoSidedInverse<Multiplicative>
-    for Isometry<N, D, R>
+impl<T: RealField + simba::scalar::RealField, R, const D: usize> TwoSidedInverse<Multiplicative>
+    for Isometry<T, R, D>
 where
-    R: Rotation<Point<N, D>> + AbstractRotation<N, D>,
-    DefaultAllocator: Allocator<N, D>,
+    R: Rotation<Point<T, D>> + AbstractRotation<T, D>,
 {
     #[inline]
     #[must_use = "Did you mean to use two_sided_inverse_mut()?"]
@@ -49,11 +45,10 @@ where
     }
 }
 
-impl<N: RealField + simba::scalar::RealField, D: DimName, R> AbstractMagma<Multiplicative>
-    for Isometry<N, D, R>
+impl<T: RealField + simba::scalar::RealField, R, const D: usize> AbstractMagma<Multiplicative>
+    for Isometry<T, R, D>
 where
-    R: Rotation<Point<N, D>> + AbstractRotation<N, D>,
-    DefaultAllocator: Allocator<N, D>,
+    R: Rotation<Point<T, D>> + AbstractRotation<T, D>,
 {
     #[inline]
     fn operate(&self, rhs: &Self) -> Self {
@@ -63,9 +58,8 @@ where
 
 macro_rules! impl_multiplicative_structures(
     ($($marker: ident<$operator: ident>),* $(,)*) => {$(
-        impl<N: RealField + simba::scalar::RealField, D: DimName, R> $marker<$operator> for Isometry<N, D, R>
-            where R: Rotation<Point<N, D>> + AbstractRotation<N, D>,
-                  DefaultAllocator: Allocator<N, D> { }
+        impl<T: RealField + simba::scalar::RealField, R, const D: usize> $marker<$operator> for Isometry<T, R, D>
+            where R: Rotation<Point<T, D>> + AbstractRotation<T, D> { }
     )*}
 );
 
@@ -82,49 +76,46 @@ impl_multiplicative_structures!(
  * Transformation groups.
  *
  */
-impl<N: RealField + simba::scalar::RealField, D: DimName, R> Transformation<Point<N, D>>
-    for Isometry<N, D, R>
+impl<T: RealField + simba::scalar::RealField, R, const D: usize> Transformation<Point<T, D>>
+    for Isometry<T, R, D>
 where
-    R: Rotation<Point<N, D>> + AbstractRotation<N, D>,
-    DefaultAllocator: Allocator<N, D>,
+    R: Rotation<Point<T, D>> + AbstractRotation<T, D>,
 {
     #[inline]
-    fn transform_point(&self, pt: &Point<N, D>) -> Point<N, D> {
+    fn transform_point(&self, pt: &Point<T, D>) -> Point<T, D> {
         self.transform_point(pt)
     }
 
     #[inline]
-    fn transform_vector(&self, v: &VectorN<N, D>) -> VectorN<N, D> {
+    fn transform_vector(&self, v: &SVector<T, D>) -> SVector<T, D> {
         self.transform_vector(v)
     }
 }
 
-impl<N: RealField + simba::scalar::RealField, D: DimName, R> ProjectiveTransformation<Point<N, D>>
-    for Isometry<N, D, R>
+impl<T: RealField + simba::scalar::RealField, R, const D: usize>
+    ProjectiveTransformation<Point<T, D>> for Isometry<T, R, D>
 where
-    R: Rotation<Point<N, D>> + AbstractRotation<N, D>,
-    DefaultAllocator: Allocator<N, D>,
+    R: Rotation<Point<T, D>> + AbstractRotation<T, D>,
 {
     #[inline]
-    fn inverse_transform_point(&self, pt: &Point<N, D>) -> Point<N, D> {
+    fn inverse_transform_point(&self, pt: &Point<T, D>) -> Point<T, D> {
         self.inverse_transform_point(pt)
     }
 
     #[inline]
-    fn inverse_transform_vector(&self, v: &VectorN<N, D>) -> VectorN<N, D> {
+    fn inverse_transform_vector(&self, v: &SVector<T, D>) -> SVector<T, D> {
         self.inverse_transform_vector(v)
     }
 }
 
-impl<N: RealField + simba::scalar::RealField, D: DimName, R> AffineTransformation<Point<N, D>>
-    for Isometry<N, D, R>
+impl<T: RealField + simba::scalar::RealField, R, const D: usize> AffineTransformation<Point<T, D>>
+    for Isometry<T, R, D>
 where
-    R: Rotation<Point<N, D>> + AbstractRotation<N, D>,
-    DefaultAllocator: Allocator<N, D>,
+    R: Rotation<Point<T, D>> + AbstractRotation<T, D>,
 {
     type Rotation = R;
     type NonUniformScaling = Id;
-    type Translation = Translation<N, D>;
+    type Translation = Translation<T, D>;
 
     #[inline]
     fn decompose(&self) -> (Self::Translation, R, Id, R) {
@@ -132,7 +123,7 @@ where
             self.translation.clone(),
             self.rotation.clone(),
             Id::new(),
-            <R as AbstractRotation<N, D>>::identity(),
+            <R as AbstractRotation<T, D>>::identity(),
         )
     }
 
@@ -168,23 +159,22 @@ where
     }
 
     #[inline]
-    fn append_rotation_wrt_point(&self, r: &Self::Rotation, p: &Point<N, D>) -> Option<Self> {
+    fn append_rotation_wrt_point(&self, r: &Self::Rotation, p: &Point<T, D>) -> Option<Self> {
         let mut res = self.clone();
         res.append_rotation_wrt_point_mut(r, p);
         Some(res)
     }
 }
 
-impl<N: RealField + simba::scalar::RealField, D: DimName, R> Similarity<Point<N, D>>
-    for Isometry<N, D, R>
+impl<T: RealField + simba::scalar::RealField, R, const D: usize> Similarity<Point<T, D>>
+    for Isometry<T, R, D>
 where
-    R: Rotation<Point<N, D>> + AbstractRotation<N, D>,
-    DefaultAllocator: Allocator<N, D>,
+    R: Rotation<Point<T, D>> + AbstractRotation<T, D>,
 {
     type Scaling = Id;
 
     #[inline]
-    fn translation(&self) -> Translation<N, D> {
+    fn translation(&self) -> Translation<T, D> {
         self.translation.clone()
     }
 
@@ -201,9 +191,8 @@ where
 
 macro_rules! marker_impl(
     ($($Trait: ident),*) => {$(
-        impl<N: RealField + simba::scalar::RealField, D: DimName, R> $Trait<Point<N, D>> for Isometry<N, D, R>
-        where R: Rotation<Point<N, D>> + AbstractRotation<N, D>,
-              DefaultAllocator: Allocator<N, D> { }
+        impl<T: RealField + simba::scalar::RealField, R, const D: usize> $Trait<Point<T, D>> for Isometry<T, R, D>
+        where R: Rotation<Point<T, D>> + AbstractRotation<T, D> { }
     )*}
 );
 
diff --git a/src/third_party/alga/alga_matrix.rs b/src/third_party/alga/alga_matrix.rs
index 6e97aedb..0ddd4fdf 100644
--- a/src/third_party/alga/alga_matrix.rs
+++ b/src/third_party/alga/alga_matrix.rs
@@ -16,28 +16,28 @@ use alga::linear::{
 use crate::base::allocator::Allocator;
 use crate::base::dimension::{Dim, DimName};
 use crate::base::storage::{Storage, StorageMut};
-use crate::base::{DefaultAllocator, MatrixMN, MatrixN, Scalar};
+use crate::base::{DefaultAllocator, OMatrix, Scalar};
 
 /*
  *
  * Additive structures.
  *
  */
-impl<N, R: DimName, C: DimName> Identity<Additive> for MatrixMN<N, R, C>
+impl<T, R: DimName, C: DimName> Identity<Additive> for OMatrix<T, R, C>
 where
-    N: Scalar + Zero,
-    DefaultAllocator: Allocator<N, R, C>,
+    T: Scalar + Zero,
+    DefaultAllocator: Allocator<T, R, C>,
 {
     #[inline]
     fn identity() -> Self {
-        Self::from_element(N::zero())
+        Self::from_element(T::zero())
     }
 }
 
-impl<N, R: DimName, C: DimName> AbstractMagma<Additive> for MatrixMN<N, R, C>
+impl<T, R: DimName, C: DimName> AbstractMagma<Additive> for OMatrix<T, R, C>
 where
-    N: Scalar + ClosedAdd,
-    DefaultAllocator: Allocator<N, R, C>,
+    T: Scalar + ClosedAdd,
+    DefaultAllocator: Allocator<T, R, C>,
 {
     #[inline]
     fn operate(&self, other: &Self) -> Self {
@@ -45,10 +45,10 @@ where
     }
 }
 
-impl<N, R: DimName, C: DimName> TwoSidedInverse<Additive> for MatrixMN<N, R, C>
+impl<T, R: DimName, C: DimName> TwoSidedInverse<Additive> for OMatrix<T, R, C>
 where
-    N: Scalar + ClosedNeg,
-    DefaultAllocator: Allocator<N, R, C>,
+    T: Scalar + ClosedNeg,
+    DefaultAllocator: Allocator<T, R, C>,
 {
     #[inline]
     #[must_use = "Did you mean to use two_sided_inverse_mut()?"]
@@ -64,9 +64,9 @@ where
 
 macro_rules! inherit_additive_structure(
     ($($marker: ident<$operator: ident> $(+ $bounds: ident)*),* $(,)*) => {$(
-        impl<N, R: DimName, C: DimName> $marker<$operator> for MatrixMN<N, R, C>
-            where N: Scalar + $marker<$operator> $(+ $bounds)*,
-                  DefaultAllocator: Allocator<N, R, C> { }
+        impl<T, R: DimName, C: DimName> $marker<$operator> for OMatrix<T, R, C>
+            where T: Scalar + $marker<$operator> $(+ $bounds)*,
+                  DefaultAllocator: Allocator<T, R, C> { }
     )*}
 );
 
@@ -79,39 +79,39 @@ inherit_additive_structure!(
     AbstractGroupAbelian<Additive> + Zero + ClosedAdd + ClosedNeg
 );
 
-impl<N, R: DimName, C: DimName> AbstractModule for MatrixMN<N, R, C>
+impl<T, R: DimName, C: DimName> AbstractModule for OMatrix<T, R, C>
 where
-    N: Scalar + RingCommutative,
-    DefaultAllocator: Allocator<N, R, C>,
+    T: Scalar + RingCommutative,
+    DefaultAllocator: Allocator<T, R, C>,
 {
-    type AbstractRing = N;
+    type AbstractRing = T;
 
     #[inline]
-    fn multiply_by(&self, n: N) -> Self {
+    fn multiply_by(&self, n: T) -> Self {
         self * n
     }
 }
 
-impl<N, R: DimName, C: DimName> Module for MatrixMN<N, R, C>
+impl<T, R: DimName, C: DimName> Module for OMatrix<T, R, C>
 where
-    N: Scalar + RingCommutative,
-    DefaultAllocator: Allocator<N, R, C>,
+    T: Scalar + RingCommutative,
+    DefaultAllocator: Allocator<T, R, C>,
 {
-    type Ring = N;
+    type Ring = T;
 }
 
-impl<N, R: DimName, C: DimName> VectorSpace for MatrixMN<N, R, C>
+impl<T, R: DimName, C: DimName> VectorSpace for OMatrix<T, R, C>
 where
-    N: Scalar + Field,
-    DefaultAllocator: Allocator<N, R, C>,
+    T: Scalar + Field,
+    DefaultAllocator: Allocator<T, R, C>,
 {
-    type Field = N;
+    type Field = T;
 }
 
-impl<N, R: DimName, C: DimName> FiniteDimVectorSpace for MatrixMN<N, R, C>
+impl<T, R: DimName, C: DimName> FiniteDimVectorSpace for OMatrix<T, R, C>
 where
-    N: Scalar + Field,
-    DefaultAllocator: Allocator<N, R, C>,
+    T: Scalar + Field,
+    DefaultAllocator: Allocator<T, R, C>,
 {
     #[inline]
     fn dimension() -> usize {
@@ -124,47 +124,47 @@ where
 
         let mut res = Self::zero();
         unsafe {
-            *res.data.get_unchecked_linear_mut(i) = N::one();
+            *res.data.get_unchecked_linear_mut(i) = T::one();
         }
 
         res
     }
 
     #[inline]
-    fn dot(&self, other: &Self) -> N {
+    fn dot(&self, other: &Self) -> T {
         self.dot(other)
     }
 
     #[inline]
-    unsafe fn component_unchecked(&self, i: usize) -> &N {
+    unsafe fn component_unchecked(&self, i: usize) -> &T {
         self.data.get_unchecked_linear(i)
     }
 
     #[inline]
-    unsafe fn component_unchecked_mut(&mut self, i: usize) -> &mut N {
+    unsafe fn component_unchecked_mut(&mut self, i: usize) -> &mut T {
         self.data.get_unchecked_linear_mut(i)
     }
 }
 
 impl<
-        N: ComplexField + simba::scalar::ComplexField<RealField = <N as ComplexField>::RealField>,
+        T: ComplexField + simba::scalar::ComplexField<RealField = <T as ComplexField>::RealField>,
         R: DimName,
         C: DimName,
-    > NormedSpace for MatrixMN<N, R, C>
+    > NormedSpace for OMatrix<T, R, C>
 where
-    <N as ComplexField>::RealField: simba::scalar::RealField,
-    DefaultAllocator: Allocator<N, R, C>,
+    <T as ComplexField>::RealField: simba::scalar::RealField,
+    DefaultAllocator: Allocator<T, R, C>,
 {
-    type RealField = <N as ComplexField>::RealField;
-    type ComplexField = N;
+    type RealField = <T as ComplexField>::RealField;
+    type ComplexField = T;
 
     #[inline]
-    fn norm_squared(&self) -> <N as ComplexField>::RealField {
+    fn norm_squared(&self) -> <T as ComplexField>::RealField {
         self.norm_squared()
     }
 
     #[inline]
-    fn norm(&self) -> <N as ComplexField>::RealField {
+    fn norm(&self) -> <T as ComplexField>::RealField {
         self.norm()
     }
 
@@ -175,41 +175,41 @@ where
     }
 
     #[inline]
-    fn normalize_mut(&mut self) -> <N as ComplexField>::RealField {
+    fn normalize_mut(&mut self) -> <T as ComplexField>::RealField {
         self.normalize_mut()
     }
 
     #[inline]
     #[must_use = "Did you mean to use try_normalize_mut()?"]
-    fn try_normalize(&self, min_norm: <N as ComplexField>::RealField) -> Option<Self> {
+    fn try_normalize(&self, min_norm: <T as ComplexField>::RealField) -> Option<Self> {
         self.try_normalize(min_norm)
     }
 
     #[inline]
     fn try_normalize_mut(
         &mut self,
-        min_norm: <N as ComplexField>::RealField,
-    ) -> Option<<N as ComplexField>::RealField> {
+        min_norm: <T as ComplexField>::RealField,
+    ) -> Option<<T as ComplexField>::RealField> {
         self.try_normalize_mut(min_norm)
     }
 }
 
 impl<
-        N: ComplexField + simba::scalar::ComplexField<RealField = <N as ComplexField>::RealField>,
+        T: ComplexField + simba::scalar::ComplexField<RealField = <T as ComplexField>::RealField>,
         R: DimName,
         C: DimName,
-    > InnerSpace for MatrixMN<N, R, C>
+    > InnerSpace for OMatrix<T, R, C>
 where
-    <N as ComplexField>::RealField: simba::scalar::RealField,
-    DefaultAllocator: Allocator<N, R, C>,
+    <T as ComplexField>::RealField: simba::scalar::RealField,
+    DefaultAllocator: Allocator<T, R, C>,
 {
     #[inline]
-    fn angle(&self, other: &Self) -> <N as ComplexField>::RealField {
+    fn angle(&self, other: &Self) -> <T as ComplexField>::RealField {
         self.angle(other)
     }
 
     #[inline]
-    fn inner_product(&self, other: &Self) -> N {
+    fn inner_product(&self, other: &Self) -> T {
         self.dotc(other)
     }
 }
@@ -219,13 +219,13 @@ where
 //   − use `x()` instead of `::canonical_basis_element`
 //   − use `::new(x, y, z)` instead of `::from_slice`
 impl<
-        N: ComplexField + simba::scalar::ComplexField<RealField = <N as ComplexField>::RealField>,
+        T: ComplexField + simba::scalar::ComplexField<RealField = <T as ComplexField>::RealField>,
         R: DimName,
         C: DimName,
-    > FiniteDimInnerSpace for MatrixMN<N, R, C>
+    > FiniteDimInnerSpace for OMatrix<T, R, C>
 where
-    <N as ComplexField>::RealField: simba::scalar::RealField,
-    DefaultAllocator: Allocator<N, R, C>,
+    <T as ComplexField>::RealField: simba::scalar::RealField,
+    DefaultAllocator: Allocator<T, R, C>,
 {
     #[inline]
     fn orthonormalize(vs: &mut [Self]) -> usize {
@@ -241,7 +241,7 @@ where
             }
 
             if vs[i]
-                .try_normalize_mut(<N as ComplexField>::RealField::zero())
+                .try_normalize_mut(<T as ComplexField>::RealField::zero())
                 .is_some()
             {
                 // TODO: this will be efficient on dynamically-allocated vectors but for
@@ -299,9 +299,9 @@ where
                     let mut a;
 
                     if ComplexField::norm1(v[0]) > ComplexField::norm1(v[1]) {
-                        a = Self::from_column_slice(&[v[2], N::zero(), -v[0]]);
+                        a = Self::from_column_slice(&[v[2], T::zero(), -v[0]]);
                     } else {
-                        a = Self::from_column_slice(&[N::zero(), -v[2], v[1]]);
+                        a = Self::from_column_slice(&[T::zero(), -v[2], v[1]]);
                     };
 
                     let _ = a.normalize_mut();
@@ -331,7 +331,7 @@ where
                         }
 
                         if let Some(subsp_elt) =
-                            elt.try_normalize(<N as ComplexField>::RealField::zero())
+                            elt.try_normalize(<T as ComplexField>::RealField::zero())
                         {
                             if !f(&subsp_elt) {
                                 return;
@@ -358,10 +358,10 @@ where
  *
  *
  */
-impl<N, D: DimName> Identity<Multiplicative> for MatrixN<N, D>
+impl<T, D: DimName> Identity<Multiplicative> for OMatrix<T, D, D>
 where
-    N: Scalar + Zero + One,
-    DefaultAllocator: Allocator<N, D, D>,
+    T: Scalar + Zero + One,
+    DefaultAllocator: Allocator<T, D, D>,
 {
     #[inline]
     fn identity() -> Self {
@@ -369,10 +369,10 @@ where
     }
 }
 
-impl<N, D: DimName> AbstractMagma<Multiplicative> for MatrixN<N, D>
+impl<T, D: DimName> AbstractMagma<Multiplicative> for OMatrix<T, D, D>
 where
-    N: Scalar + Zero + One + ClosedAdd + ClosedMul,
-    DefaultAllocator: Allocator<N, D, D>,
+    T: Scalar + Zero + One + ClosedAdd + ClosedMul,
+    DefaultAllocator: Allocator<T, D, D>,
 {
     #[inline]
     fn operate(&self, other: &Self) -> Self {
@@ -382,9 +382,9 @@ where
 
 macro_rules! impl_multiplicative_structure(
     ($($marker: ident<$operator: ident> $(+ $bounds: ident)*),* $(,)*) => {$(
-        impl<N, D: DimName> $marker<$operator> for MatrixN<N, D>
-            where N: Scalar + Zero + One + ClosedAdd + ClosedMul + $marker<$operator> $(+ $bounds)*,
-                  DefaultAllocator: Allocator<N, D, D> { }
+        impl<T, D: DimName> $marker<$operator> for OMatrix<T, D, D>
+            where T: Scalar + Zero + One + ClosedAdd + ClosedMul + $marker<$operator> $(+ $bounds)*,
+                  DefaultAllocator: Allocator<T, D, D> { }
     )*}
 );
 
@@ -398,10 +398,10 @@ impl_multiplicative_structure!(
  * Ordering
  *
  */
-impl<N, R: Dim, C: Dim> MeetSemilattice for MatrixMN<N, R, C>
+impl<T, R: Dim, C: Dim> MeetSemilattice for OMatrix<T, R, C>
 where
-    N: Scalar + MeetSemilattice,
-    DefaultAllocator: Allocator<N, R, C>,
+    T: Scalar + MeetSemilattice,
+    DefaultAllocator: Allocator<T, R, C>,
 {
     #[inline]
     fn meet(&self, other: &Self) -> Self {
@@ -409,10 +409,10 @@ where
     }
 }
 
-impl<N, R: Dim, C: Dim> JoinSemilattice for MatrixMN<N, R, C>
+impl<T, R: Dim, C: Dim> JoinSemilattice for OMatrix<T, R, C>
 where
-    N: Scalar + JoinSemilattice,
-    DefaultAllocator: Allocator<N, R, C>,
+    T: Scalar + JoinSemilattice,
+    DefaultAllocator: Allocator<T, R, C>,
 {
     #[inline]
     fn join(&self, other: &Self) -> Self {
@@ -420,10 +420,10 @@ where
     }
 }
 
-impl<N, R: Dim, C: Dim> Lattice for MatrixMN<N, R, C>
+impl<T, R: Dim, C: Dim> Lattice for OMatrix<T, R, C>
 where
-    N: Scalar + Lattice,
-    DefaultAllocator: Allocator<N, R, C>,
+    T: Scalar + Lattice,
+    DefaultAllocator: Allocator<T, R, C>,
 {
     #[inline]
     fn meet_join(&self, other: &Self) -> (Self, Self) {
diff --git a/src/third_party/alga/alga_point.rs b/src/third_party/alga/alga_point.rs
index 5a7cace5..f1365af4 100644
--- a/src/third_party/alga/alga_point.rs
+++ b/src/third_party/alga/alga_point.rs
@@ -1,26 +1,20 @@
 use alga::general::{Field, JoinSemilattice, Lattice, MeetSemilattice, RealField};
 use alga::linear::{AffineSpace, EuclideanSpace};
 
-use crate::base::allocator::Allocator;
-use crate::base::dimension::DimName;
-use crate::base::{DefaultAllocator, Scalar, VectorN};
+use crate::base::{SVector, Scalar};
 
 use crate::geometry::Point;
 
-impl<N: Scalar + Field, D: DimName> AffineSpace for Point<N, D>
+impl<T: Scalar + Field, const D: usize> AffineSpace for Point<T, D>
 where
-    N: Scalar + Field,
-    DefaultAllocator: Allocator<N, D>,
+    T: Scalar + Field,
 {
-    type Translation = VectorN<N, D>;
+    type Translation = SVector<T, D>;
 }
 
-impl<N: RealField + simba::scalar::RealField, D: DimName> EuclideanSpace for Point<N, D>
-where
-    DefaultAllocator: Allocator<N, D>,
-{
-    type Coordinates = VectorN<N, D>;
-    type RealField = N;
+impl<T: RealField + simba::scalar::RealField, const D: usize> EuclideanSpace for Point<T, D> {
+    type Coordinates = SVector<T, D>;
+    type RealField = T;
 
     #[inline]
     fn origin() -> Self {
@@ -38,7 +32,7 @@ where
     }
 
     #[inline]
-    fn scale_by(&self, n: N) -> Self {
+    fn scale_by(&self, n: T) -> Self {
         self * n
     }
 }
@@ -48,10 +42,9 @@ where
  * Ordering
  *
  */
-impl<N, D: DimName> MeetSemilattice for Point<N, D>
+impl<T, const D: usize> MeetSemilattice for Point<T, D>
 where
-    N: Scalar + MeetSemilattice,
-    DefaultAllocator: Allocator<N, D>,
+    T: Scalar + MeetSemilattice,
 {
     #[inline]
     fn meet(&self, other: &Self) -> Self {
@@ -59,10 +52,9 @@ where
     }
 }
 
-impl<N, D: DimName> JoinSemilattice for Point<N, D>
+impl<T, const D: usize> JoinSemilattice for Point<T, D>
 where
-    N: Scalar + JoinSemilattice,
-    DefaultAllocator: Allocator<N, D>,
+    T: Scalar + JoinSemilattice,
 {
     #[inline]
     fn join(&self, other: &Self) -> Self {
@@ -70,10 +62,9 @@ where
     }
 }
 
-impl<N, D: DimName> Lattice for Point<N, D>
+impl<T, const D: usize> Lattice for Point<T, D>
 where
-    N: Scalar + Lattice,
-    DefaultAllocator: Allocator<N, D>,
+    T: Scalar + Lattice,
 {
     #[inline]
     fn meet_join(&self, other: &Self) -> (Self, Self) {
diff --git a/src/third_party/alga/alga_quaternion.rs b/src/third_party/alga/alga_quaternion.rs
index 087c8a58..0885f44f 100755
--- a/src/third_party/alga/alga_quaternion.rs
+++ b/src/third_party/alga/alga_quaternion.rs
@@ -14,35 +14,35 @@ use alga::linear::{
 use crate::base::{Vector3, Vector4};
 use crate::geometry::{Point3, Quaternion, UnitQuaternion};
 
-impl<N: RealField + simba::scalar::RealField> Identity<Multiplicative> for Quaternion<N> {
+impl<T: RealField + simba::scalar::RealField> Identity<Multiplicative> for Quaternion<T> {
     #[inline]
     fn identity() -> Self {
         Self::identity()
     }
 }
 
-impl<N: RealField + simba::scalar::RealField> Identity<Additive> for Quaternion<N> {
+impl<T: RealField + simba::scalar::RealField> Identity<Additive> for Quaternion<T> {
     #[inline]
     fn identity() -> Self {
         Self::zero()
     }
 }
 
-impl<N: RealField + simba::scalar::RealField> AbstractMagma<Multiplicative> for Quaternion<N> {
+impl<T: RealField + simba::scalar::RealField> AbstractMagma<Multiplicative> for Quaternion<T> {
     #[inline]
     fn operate(&self, rhs: &Self) -> Self {
         self * rhs
     }
 }
 
-impl<N: RealField + simba::scalar::RealField> AbstractMagma<Additive> for Quaternion<N> {
+impl<T: RealField + simba::scalar::RealField> AbstractMagma<Additive> for Quaternion<T> {
     #[inline]
     fn operate(&self, rhs: &Self) -> Self {
         self + rhs
     }
 }
 
-impl<N: RealField + simba::scalar::RealField> TwoSidedInverse<Additive> for Quaternion<N> {
+impl<T: RealField + simba::scalar::RealField> TwoSidedInverse<Additive> for Quaternion<T> {
     #[inline]
     fn two_sided_inverse(&self) -> Self {
         -self
@@ -51,7 +51,7 @@ impl<N: RealField + simba::scalar::RealField> TwoSidedInverse<Additive> for Quat
 
 macro_rules! impl_structures(
     ($Quaternion: ident; $($marker: ident<$operator: ident>),* $(,)*) => {$(
-        impl<N: RealField + simba::scalar::RealField> $marker<$operator> for $Quaternion<N> { }
+        impl<T: RealField + simba::scalar::RealField> $marker<$operator> for $Quaternion<T> { }
     )*}
 );
 
@@ -73,24 +73,24 @@ impl_structures!(
  * Vector space.
  *
  */
-impl<N: RealField + simba::scalar::RealField> AbstractModule for Quaternion<N> {
-    type AbstractRing = N;
+impl<T: RealField + simba::scalar::RealField> AbstractModule for Quaternion<T> {
+    type AbstractRing = T;
 
     #[inline]
-    fn multiply_by(&self, n: N) -> Self {
+    fn multiply_by(&self, n: T) -> Self {
         self * n
     }
 }
 
-impl<N: RealField + simba::scalar::RealField> Module for Quaternion<N> {
-    type Ring = N;
+impl<T: RealField + simba::scalar::RealField> Module for Quaternion<T> {
+    type Ring = T;
 }
 
-impl<N: RealField + simba::scalar::RealField> VectorSpace for Quaternion<N> {
-    type Field = N;
+impl<T: RealField + simba::scalar::RealField> VectorSpace for Quaternion<T> {
+    type Field = T;
 }
 
-impl<N: RealField + simba::scalar::RealField> FiniteDimVectorSpace for Quaternion<N> {
+impl<T: RealField + simba::scalar::RealField> FiniteDimVectorSpace for Quaternion<T> {
     #[inline]
     fn dimension() -> usize {
         4
@@ -102,32 +102,32 @@ impl<N: RealField + simba::scalar::RealField> FiniteDimVectorSpace for Quaternio
     }
 
     #[inline]
-    fn dot(&self, other: &Self) -> N {
+    fn dot(&self, other: &Self) -> T {
         self.coords.dot(&other.coords)
     }
 
     #[inline]
-    unsafe fn component_unchecked(&self, i: usize) -> &N {
+    unsafe fn component_unchecked(&self, i: usize) -> &T {
         self.coords.component_unchecked(i)
     }
 
     #[inline]
-    unsafe fn component_unchecked_mut(&mut self, i: usize) -> &mut N {
+    unsafe fn component_unchecked_mut(&mut self, i: usize) -> &mut T {
         self.coords.component_unchecked_mut(i)
     }
 }
 
-impl<N: RealField + simba::scalar::RealField> NormedSpace for Quaternion<N> {
-    type RealField = N;
-    type ComplexField = N;
+impl<T: RealField + simba::scalar::RealField> NormedSpace for Quaternion<T> {
+    type RealField = T;
+    type ComplexField = T;
 
     #[inline]
-    fn norm_squared(&self) -> N {
+    fn norm_squared(&self) -> T {
         self.coords.norm_squared()
     }
 
     #[inline]
-    fn norm(&self) -> N {
+    fn norm(&self) -> T {
         self.as_vector().norm()
     }
 
@@ -138,12 +138,12 @@ impl<N: RealField + simba::scalar::RealField> NormedSpace for Quaternion<N> {
     }
 
     #[inline]
-    fn normalize_mut(&mut self) -> N {
+    fn normalize_mut(&mut self) -> T {
         self.coords.normalize_mut()
     }
 
     #[inline]
-    fn try_normalize(&self, min_norm: N) -> Option<Self> {
+    fn try_normalize(&self, min_norm: T) -> Option<Self> {
         if let Some(v) = self.coords.try_normalize(min_norm) {
             Some(Self::from(v))
         } else {
@@ -152,7 +152,7 @@ impl<N: RealField + simba::scalar::RealField> NormedSpace for Quaternion<N> {
     }
 
     #[inline]
-    fn try_normalize_mut(&mut self, min_norm: N) -> Option<N> {
+    fn try_normalize_mut(&mut self, min_norm: T) -> Option<T> {
         self.coords.try_normalize_mut(min_norm)
     }
 }
@@ -162,22 +162,22 @@ impl<N: RealField + simba::scalar::RealField> NormedSpace for Quaternion<N> {
  * Implementations for UnitQuaternion.
  *
  */
-impl<N: RealField + simba::scalar::RealField> Identity<Multiplicative> for UnitQuaternion<N> {
+impl<T: RealField + simba::scalar::RealField> Identity<Multiplicative> for UnitQuaternion<T> {
     #[inline]
     fn identity() -> Self {
         Self::identity()
     }
 }
 
-impl<N: RealField + simba::scalar::RealField> AbstractMagma<Multiplicative> for UnitQuaternion<N> {
+impl<T: RealField + simba::scalar::RealField> AbstractMagma<Multiplicative> for UnitQuaternion<T> {
     #[inline]
     fn operate(&self, rhs: &Self) -> Self {
         self * rhs
     }
 }
 
-impl<N: RealField + simba::scalar::RealField> TwoSidedInverse<Multiplicative>
-    for UnitQuaternion<N>
+impl<T: RealField + simba::scalar::RealField> TwoSidedInverse<Multiplicative>
+    for UnitQuaternion<T>
 {
     #[inline]
     fn two_sided_inverse(&self) -> Self {
@@ -199,34 +199,34 @@ impl_structures!(
     AbstractGroup<Multiplicative>
 );
 
-impl<N: RealField + simba::scalar::RealField> Transformation<Point3<N>> for UnitQuaternion<N> {
+impl<T: RealField + simba::scalar::RealField> Transformation<Point3<T>> for UnitQuaternion<T> {
     #[inline]
-    fn transform_point(&self, pt: &Point3<N>) -> Point3<N> {
+    fn transform_point(&self, pt: &Point3<T>) -> Point3<T> {
         self.transform_point(pt)
     }
 
     #[inline]
-    fn transform_vector(&self, v: &Vector3<N>) -> Vector3<N> {
+    fn transform_vector(&self, v: &Vector3<T>) -> Vector3<T> {
         self.transform_vector(v)
     }
 }
 
-impl<N: RealField + simba::scalar::RealField> ProjectiveTransformation<Point3<N>>
-    for UnitQuaternion<N>
+impl<T: RealField + simba::scalar::RealField> ProjectiveTransformation<Point3<T>>
+    for UnitQuaternion<T>
 {
     #[inline]
-    fn inverse_transform_point(&self, pt: &Point3<N>) -> Point3<N> {
+    fn inverse_transform_point(&self, pt: &Point3<T>) -> Point3<T> {
         self.inverse_transform_point(pt)
     }
 
     #[inline]
-    fn inverse_transform_vector(&self, v: &Vector3<N>) -> Vector3<N> {
+    fn inverse_transform_vector(&self, v: &Vector3<T>) -> Vector3<T> {
         self.inverse_transform_vector(v)
     }
 }
 
-impl<N: RealField + simba::scalar::RealField> AffineTransformation<Point3<N>>
-    for UnitQuaternion<N>
+impl<T: RealField + simba::scalar::RealField> AffineTransformation<Point3<T>>
+    for UnitQuaternion<T>
 {
     type Rotation = Self;
     type NonUniformScaling = Id;
@@ -268,7 +268,7 @@ impl<N: RealField + simba::scalar::RealField> AffineTransformation<Point3<N>>
     }
 }
 
-impl<N: RealField + simba::scalar::RealField> Similarity<Point3<N>> for UnitQuaternion<N> {
+impl<T: RealField + simba::scalar::RealField> Similarity<Point3<T>> for UnitQuaternion<T> {
     type Scaling = Id;
 
     #[inline]
@@ -289,25 +289,25 @@ impl<N: RealField + simba::scalar::RealField> Similarity<Point3<N>> for UnitQuat
 
 macro_rules! marker_impl(
     ($($Trait: ident),*) => {$(
-        impl<N: RealField + simba::scalar::RealField> $Trait<Point3<N>> for UnitQuaternion<N> { }
+        impl<T: RealField + simba::scalar::RealField> $Trait<Point3<T>> for UnitQuaternion<T> { }
     )*}
 );
 
 marker_impl!(Isometry, DirectIsometry, OrthogonalTransformation);
 
-impl<N: RealField + simba::scalar::RealField> Rotation<Point3<N>> for UnitQuaternion<N> {
+impl<T: RealField + simba::scalar::RealField> Rotation<Point3<T>> for UnitQuaternion<T> {
     #[inline]
-    fn powf(&self, n: N) -> Option<Self> {
+    fn powf(&self, n: T) -> Option<Self> {
         Some(self.powf(n))
     }
 
     #[inline]
-    fn rotation_between(a: &Vector3<N>, b: &Vector3<N>) -> Option<Self> {
+    fn rotation_between(a: &Vector3<T>, b: &Vector3<T>) -> Option<Self> {
         Self::rotation_between(a, b)
     }
 
     #[inline]
-    fn scaled_rotation_between(a: &Vector3<N>, b: &Vector3<N>, s: N) -> Option<Self> {
+    fn scaled_rotation_between(a: &Vector3<T>, b: &Vector3<T>, s: T) -> Option<Self> {
         Self::scaled_rotation_between(a, b, s)
     }
 }
diff --git a/src/third_party/alga/alga_rotation.rs b/src/third_party/alga/alga_rotation.rs
index f37ebbd1..a63d7f84 100755
--- a/src/third_party/alga/alga_rotation.rs
+++ b/src/third_party/alga/alga_rotation.rs
@@ -7,10 +7,7 @@ use alga::linear::{
     ProjectiveTransformation, Similarity, Transformation,
 };
 
-use crate::base::allocator::Allocator;
-use crate::base::dimension::DimName;
-use crate::base::{DefaultAllocator, VectorN};
-
+use crate::base::SVector;
 use crate::geometry::{Point, Rotation};
 
 /*
@@ -18,10 +15,8 @@ use crate::geometry::{Point, Rotation};
  * Algebraic structures.
  *
  */
-impl<N: RealField + simba::scalar::RealField, D: DimName> Identity<Multiplicative>
-    for Rotation<N, D>
-where
-    DefaultAllocator: Allocator<N, D, D>,
+impl<T: RealField + simba::scalar::RealField, const D: usize> Identity<Multiplicative>
+    for Rotation<T, D>
 {
     #[inline]
     fn identity() -> Self {
@@ -29,10 +24,8 @@ where
     }
 }
 
-impl<N: RealField + simba::scalar::RealField, D: DimName> TwoSidedInverse<Multiplicative>
-    for Rotation<N, D>
-where
-    DefaultAllocator: Allocator<N, D, D>,
+impl<T: RealField + simba::scalar::RealField, const D: usize> TwoSidedInverse<Multiplicative>
+    for Rotation<T, D>
 {
     #[inline]
     #[must_use = "Did you mean to use two_sided_inverse_mut()?"]
@@ -46,10 +39,8 @@ where
     }
 }
 
-impl<N: RealField + simba::scalar::RealField, D: DimName> AbstractMagma<Multiplicative>
-    for Rotation<N, D>
-where
-    DefaultAllocator: Allocator<N, D, D>,
+impl<T: RealField + simba::scalar::RealField, const D: usize> AbstractMagma<Multiplicative>
+    for Rotation<T, D>
 {
     #[inline]
     fn operate(&self, rhs: &Self) -> Self {
@@ -59,8 +50,8 @@ where
 
 macro_rules! impl_multiplicative_structures(
     ($($marker: ident<$operator: ident>),* $(,)*) => {$(
-        impl<N: RealField + simba::scalar::RealField, D: DimName> $marker<$operator> for Rotation<N, D>
-            where DefaultAllocator: Allocator<N, D, D> { }
+        impl<T: RealField + simba::scalar::RealField, const D: usize> $marker<$operator> for Rotation<T, D>
+            { }
     )*}
 );
 
@@ -77,42 +68,36 @@ impl_multiplicative_structures!(
  * Transformation groups.
  *
  */
-impl<N: RealField + simba::scalar::RealField, D: DimName> Transformation<Point<N, D>>
-    for Rotation<N, D>
-where
-    DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>,
+impl<T: RealField + simba::scalar::RealField, const D: usize> Transformation<Point<T, D>>
+    for Rotation<T, D>
 {
     #[inline]
-    fn transform_point(&self, pt: &Point<N, D>) -> Point<N, D> {
+    fn transform_point(&self, pt: &Point<T, D>) -> Point<T, D> {
         self.transform_point(pt)
     }
 
     #[inline]
-    fn transform_vector(&self, v: &VectorN<N, D>) -> VectorN<N, D> {
+    fn transform_vector(&self, v: &SVector<T, D>) -> SVector<T, D> {
         self.transform_vector(v)
     }
 }
 
-impl<N: RealField + simba::scalar::RealField, D: DimName> ProjectiveTransformation<Point<N, D>>
-    for Rotation<N, D>
-where
-    DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>,
+impl<T: RealField + simba::scalar::RealField, const D: usize> ProjectiveTransformation<Point<T, D>>
+    for Rotation<T, D>
 {
     #[inline]
-    fn inverse_transform_point(&self, pt: &Point<N, D>) -> Point<N, D> {
+    fn inverse_transform_point(&self, pt: &Point<T, D>) -> Point<T, D> {
         self.inverse_transform_point(pt)
     }
 
     #[inline]
-    fn inverse_transform_vector(&self, v: &VectorN<N, D>) -> VectorN<N, D> {
+    fn inverse_transform_vector(&self, v: &SVector<T, D>) -> SVector<T, D> {
         self.inverse_transform_vector(v)
     }
 }
 
-impl<N: RealField + simba::scalar::RealField, D: DimName> AffineTransformation<Point<N, D>>
-    for Rotation<N, D>
-where
-    DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>,
+impl<T: RealField + simba::scalar::RealField, const D: usize> AffineTransformation<Point<T, D>>
+    for Rotation<T, D>
 {
     type Rotation = Self;
     type NonUniformScaling = Id;
@@ -154,9 +139,8 @@ where
     }
 }
 
-impl<N: RealField + simba::scalar::RealField, D: DimName> Similarity<Point<N, D>> for Rotation<N, D>
-where
-    DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>,
+impl<T: RealField + simba::scalar::RealField, const D: usize> Similarity<Point<T, D>>
+    for Rotation<T, D>
 {
     type Scaling = Id;
 
@@ -178,36 +162,33 @@ where
 
 macro_rules! marker_impl(
     ($($Trait: ident),*) => {$(
-        impl<N: RealField + simba::scalar::RealField, D: DimName> $Trait<Point<N, D>> for Rotation<N, D>
-        where DefaultAllocator: Allocator<N, D, D> +
-                                Allocator<N, D> { }
+        impl<T: RealField + simba::scalar::RealField, const D: usize> $Trait<Point<T, D>> for Rotation<T, D>
+        { }
     )*}
 );
 
 marker_impl!(Isometry, DirectIsometry, OrthogonalTransformation);
 
 /// Subgroups of the n-dimensional rotation group `SO(n)`.
-impl<N: RealField + simba::scalar::RealField, D: DimName> linear::Rotation<Point<N, D>>
-    for Rotation<N, D>
-where
-    DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>,
+impl<T: RealField + simba::scalar::RealField, const D: usize> linear::Rotation<Point<T, D>>
+    for Rotation<T, D>
 {
     #[inline]
-    fn powf(&self, _: N) -> Option<Self> {
+    fn powf(&self, _: T) -> Option<Self> {
         // XXX: Add the general case.
         // XXX: Use specialization for 2D and 3D.
         unimplemented!()
     }
 
     #[inline]
-    fn rotation_between(_: &VectorN<N, D>, _: &VectorN<N, D>) -> Option<Self> {
+    fn rotation_between(_: &SVector<T, D>, _: &SVector<T, D>) -> Option<Self> {
         // XXX: Add the general case.
         // XXX: Use specialization for 2D and 3D.
         unimplemented!()
     }
 
     #[inline]
-    fn scaled_rotation_between(_: &VectorN<N, D>, _: &VectorN<N, D>, _: N) -> Option<Self> {
+    fn scaled_rotation_between(_: &SVector<T, D>, _: &SVector<T, D>, _: T) -> Option<Self> {
         // XXX: Add the general case.
         // XXX: Use specialization for 2D and 3D.
         unimplemented!()
@@ -215,10 +196,10 @@ where
 }
 
 /*
-impl<N: RealField + simba::scalar::RealField> Matrix for Rotation<N> {
-    type Field     = N;
-    type Row       = Matrix<N>;
-    type Column    = Matrix<N>;
+impl<T: RealField + simba::scalar::RealField> Matrix for Rotation<T> {
+    type Field     = T;
+    type Row       = Matrix<T>;
+    type Column    = Matrix<T>;
     type Transpose = Self;
 
     #[inline]
@@ -257,8 +238,8 @@ impl<N: RealField + simba::scalar::RealField> Matrix for Rotation<N> {
     }
 }
 
-impl<N: RealField + simba::scalar::RealField> SquareMatrix for Rotation<N> {
-    type Vector = Matrix<N>;
+impl<T: RealField + simba::scalar::RealField> SquareMatrix for Rotation<T> {
+    type Vector = Matrix<T>;
 
     #[inline]
     fn diagonal(&self) -> Self::Coordinates {
@@ -287,5 +268,5 @@ impl<N: RealField + simba::scalar::RealField> SquareMatrix for Rotation<N> {
     }
 }
 
-impl<N: RealField + simba::scalar::RealField> InversibleSquareMatrix for Rotation<N> { }
+impl<T: RealField + simba::scalar::RealField> InversibleSquareMatrix for Rotation<T> { }
 */
diff --git a/src/third_party/alga/alga_similarity.rs b/src/third_party/alga/alga_similarity.rs
index 58dd4563..3825b1c8 100755
--- a/src/third_party/alga/alga_similarity.rs
+++ b/src/third_party/alga/alga_similarity.rs
@@ -5,10 +5,7 @@ use alga::general::{
 use alga::linear::Similarity as AlgaSimilarity;
 use alga::linear::{AffineTransformation, ProjectiveTransformation, Rotation, Transformation};
 
-use crate::base::allocator::Allocator;
-use crate::base::dimension::DimName;
-use crate::base::{DefaultAllocator, VectorN};
-
+use crate::base::SVector;
 use crate::geometry::{AbstractRotation, Point, Similarity, Translation};
 
 /*
@@ -16,11 +13,10 @@ use crate::geometry::{AbstractRotation, Point, Similarity, Translation};
  * Algebraic structures.
  *
  */
-impl<N: RealField + simba::scalar::RealField, D: DimName, R> Identity<Multiplicative>
-    for Similarity<N, D, R>
+impl<T: RealField + simba::scalar::RealField, R, const D: usize> Identity<Multiplicative>
+    for Similarity<T, R, D>
 where
-    R: Rotation<Point<N, D>> + AbstractRotation<N, D>,
-    DefaultAllocator: Allocator<N, D>,
+    R: Rotation<Point<T, D>> + AbstractRotation<T, D>,
 {
     #[inline]
     fn identity() -> Self {
@@ -28,11 +24,10 @@ where
     }
 }
 
-impl<N: RealField + simba::scalar::RealField, D: DimName, R> TwoSidedInverse<Multiplicative>
-    for Similarity<N, D, R>
+impl<T: RealField + simba::scalar::RealField, R, const D: usize> TwoSidedInverse<Multiplicative>
+    for Similarity<T, R, D>
 where
-    R: Rotation<Point<N, D>> + AbstractRotation<N, D>,
-    DefaultAllocator: Allocator<N, D>,
+    R: Rotation<Point<T, D>> + AbstractRotation<T, D>,
 {
     #[inline]
     #[must_use = "Did you mean to use two_sided_inverse_mut()?"]
@@ -46,11 +41,10 @@ where
     }
 }
 
-impl<N: RealField + simba::scalar::RealField, D: DimName, R> AbstractMagma<Multiplicative>
-    for Similarity<N, D, R>
+impl<T: RealField + simba::scalar::RealField, R, const D: usize> AbstractMagma<Multiplicative>
+    for Similarity<T, R, D>
 where
-    R: Rotation<Point<N, D>> + AbstractRotation<N, D>,
-    DefaultAllocator: Allocator<N, D>,
+    R: Rotation<Point<T, D>> + AbstractRotation<T, D>,
 {
     #[inline]
     fn operate(&self, rhs: &Self) -> Self {
@@ -60,9 +54,9 @@ where
 
 macro_rules! impl_multiplicative_structures(
     ($($marker: ident<$operator: ident>),* $(,)*) => {$(
-        impl<N: RealField + simba::scalar::RealField, D: DimName, R> $marker<$operator> for Similarity<N, D, R>
-            where R: Rotation<Point<N, D>> + AbstractRotation<N, D>,
-                  DefaultAllocator: Allocator<N, D> { }
+        impl<T: RealField + simba::scalar::RealField, R, const D: usize> $marker<$operator> for Similarity<T, R, D>
+            where R: Rotation<Point<T, D>> + AbstractRotation<T, D>,
+                  { }
     )*}
 );
 
@@ -79,57 +73,54 @@ impl_multiplicative_structures!(
  * Transformation groups.
  *
  */
-impl<N: RealField + simba::scalar::RealField, D: DimName, R> Transformation<Point<N, D>>
-    for Similarity<N, D, R>
+impl<T: RealField + simba::scalar::RealField, R, const D: usize> Transformation<Point<T, D>>
+    for Similarity<T, R, D>
 where
-    R: Rotation<Point<N, D>> + AbstractRotation<N, D>,
-    DefaultAllocator: Allocator<N, D>,
+    R: Rotation<Point<T, D>> + AbstractRotation<T, D>,
 {
     #[inline]
-    fn transform_point(&self, pt: &Point<N, D>) -> Point<N, D> {
+    fn transform_point(&self, pt: &Point<T, D>) -> Point<T, D> {
         self.transform_point(pt)
     }
 
     #[inline]
-    fn transform_vector(&self, v: &VectorN<N, D>) -> VectorN<N, D> {
+    fn transform_vector(&self, v: &SVector<T, D>) -> SVector<T, D> {
         self.transform_vector(v)
     }
 }
 
-impl<N: RealField + simba::scalar::RealField, D: DimName, R> ProjectiveTransformation<Point<N, D>>
-    for Similarity<N, D, R>
+impl<T: RealField + simba::scalar::RealField, R, const D: usize>
+    ProjectiveTransformation<Point<T, D>> for Similarity<T, R, D>
 where
-    R: Rotation<Point<N, D>> + AbstractRotation<N, D>,
-    DefaultAllocator: Allocator<N, D>,
+    R: Rotation<Point<T, D>> + AbstractRotation<T, D>,
 {
     #[inline]
-    fn inverse_transform_point(&self, pt: &Point<N, D>) -> Point<N, D> {
+    fn inverse_transform_point(&self, pt: &Point<T, D>) -> Point<T, D> {
         self.inverse_transform_point(pt)
     }
 
     #[inline]
-    fn inverse_transform_vector(&self, v: &VectorN<N, D>) -> VectorN<N, D> {
+    fn inverse_transform_vector(&self, v: &SVector<T, D>) -> SVector<T, D> {
         self.inverse_transform_vector(v)
     }
 }
 
-impl<N: RealField + simba::scalar::RealField, D: DimName, R> AffineTransformation<Point<N, D>>
-    for Similarity<N, D, R>
+impl<T: RealField + simba::scalar::RealField, R, const D: usize> AffineTransformation<Point<T, D>>
+    for Similarity<T, R, D>
 where
-    R: Rotation<Point<N, D>> + AbstractRotation<N, D>,
-    DefaultAllocator: Allocator<N, D>,
+    R: Rotation<Point<T, D>> + AbstractRotation<T, D>,
 {
-    type NonUniformScaling = N;
+    type NonUniformScaling = T;
     type Rotation = R;
-    type Translation = Translation<N, D>;
+    type Translation = Translation<T, D>;
 
     #[inline]
-    fn decompose(&self) -> (Translation<N, D>, R, N, R) {
+    fn decompose(&self) -> (Translation<T, D>, R, T, R) {
         (
             self.isometry.translation.clone(),
             self.isometry.rotation.clone(),
             self.scaling(),
-            <R as AbstractRotation<N, D>>::identity(),
+            <R as AbstractRotation<T, D>>::identity(),
         )
     }
 
@@ -164,23 +155,22 @@ where
     }
 
     #[inline]
-    fn append_rotation_wrt_point(&self, r: &Self::Rotation, p: &Point<N, D>) -> Option<Self> {
+    fn append_rotation_wrt_point(&self, r: &Self::Rotation, p: &Point<T, D>) -> Option<Self> {
         let mut res = self.clone();
         res.append_rotation_wrt_point_mut(r, p);
         Some(res)
     }
 }
 
-impl<N: RealField + simba::scalar::RealField, D: DimName, R> AlgaSimilarity<Point<N, D>>
-    for Similarity<N, D, R>
+impl<T: RealField + simba::scalar::RealField, R, const D: usize> AlgaSimilarity<Point<T, D>>
+    for Similarity<T, R, D>
 where
-    R: Rotation<Point<N, D>> + AbstractRotation<N, D>,
-    DefaultAllocator: Allocator<N, D>,
+    R: Rotation<Point<T, D>> + AbstractRotation<T, D>,
 {
-    type Scaling = N;
+    type Scaling = T;
 
     #[inline]
-    fn translation(&self) -> Translation<N, D> {
+    fn translation(&self) -> Translation<T, D> {
         self.isometry.translation()
     }
 
@@ -190,7 +180,7 @@ where
     }
 
     #[inline]
-    fn scaling(&self) -> N {
+    fn scaling(&self) -> T {
         self.scaling()
     }
 }
diff --git a/src/third_party/alga/alga_transform.rs b/src/third_party/alga/alga_transform.rs
index f83a0f8c..ed75018f 100755
--- a/src/third_party/alga/alga_transform.rs
+++ b/src/third_party/alga/alga_transform.rs
@@ -6,7 +6,7 @@ use alga::linear::{ProjectiveTransformation, Transformation};
 
 use crate::base::allocator::Allocator;
 use crate::base::dimension::{DimNameAdd, DimNameSum, U1};
-use crate::base::{DefaultAllocator, VectorN};
+use crate::base::{Const, DefaultAllocator, SVector};
 
 use crate::geometry::{Point, SubTCategoryOf, TCategory, TProjective, Transform};
 
@@ -15,11 +15,12 @@ use crate::geometry::{Point, SubTCategoryOf, TCategory, TProjective, Transform};
  * Algebraic structures.
  *
  */
-impl<N: RealField + simba::scalar::RealField, D: DimNameAdd<U1>, C> Identity<Multiplicative>
-    for Transform<N, D, C>
+impl<T: RealField + simba::scalar::RealField, C, const D: usize> Identity<Multiplicative>
+    for Transform<T, C, D>
 where
+    Const<D>: DimNameAdd<U1>,
     C: TCategory,
-    DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
+    DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
 {
     #[inline]
     fn identity() -> Self {
@@ -27,11 +28,12 @@ where
     }
 }
 
-impl<N: RealField + simba::scalar::RealField, D: DimNameAdd<U1>, C> TwoSidedInverse<Multiplicative>
-    for Transform<N, D, C>
+impl<T: RealField + simba::scalar::RealField, C, const D: usize> TwoSidedInverse<Multiplicative>
+    for Transform<T, C, D>
 where
+    Const<D>: DimNameAdd<U1>,
     C: SubTCategoryOf<TProjective>,
-    DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
+    DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
 {
     #[inline]
     #[must_use = "Did you mean to use two_sided_inverse_mut()?"]
@@ -45,11 +47,12 @@ where
     }
 }
 
-impl<N: RealField + simba::scalar::RealField, D: DimNameAdd<U1>, C> AbstractMagma<Multiplicative>
-    for Transform<N, D, C>
+impl<T: RealField + simba::scalar::RealField, C, const D: usize> AbstractMagma<Multiplicative>
+    for Transform<T, C, D>
 where
+    Const<D>: DimNameAdd<U1>,
     C: TCategory,
-    DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
+    DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
 {
     #[inline]
     fn operate(&self, rhs: &Self) -> Self {
@@ -59,17 +62,21 @@ where
 
 macro_rules! impl_multiplicative_structures(
     ($($marker: ident<$operator: ident>),* $(,)*) => {$(
-        impl<N: RealField + simba::scalar::RealField, D: DimNameAdd<U1>, C> $marker<$operator> for Transform<N, D, C>
-            where C: TCategory,
-                  DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>> { }
+        impl<T: RealField + simba::scalar::RealField, C, const D: usize> $marker<$operator> for Transform<T, C, D>
+            where
+                  Const<D>: DimNameAdd<U1>,
+                  C: TCategory,
+                  DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> { }
     )*}
 );
 
 macro_rules! impl_inversible_multiplicative_structures(
     ($($marker: ident<$operator: ident>),* $(,)*) => {$(
-        impl<N: RealField + simba::scalar::RealField, D: DimNameAdd<U1>, C> $marker<$operator> for Transform<N, D, C>
-            where C: SubTCategoryOf<TProjective>,
-                  DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>> { }
+        impl<T: RealField + simba::scalar::RealField, C, const D: usize> $marker<$operator> for Transform<T, C, D>
+            where
+                  Const<D>: DimNameAdd<U1>,
+                  C: SubTCategoryOf<TProjective>,
+                  DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> { }
     )*}
 );
 
@@ -89,58 +96,54 @@ impl_inversible_multiplicative_structures!(
  * Transformation groups.
  *
  */
-impl<N, D: DimNameAdd<U1>, C> Transformation<Point<N, D>> for Transform<N, D, C>
+impl<T, C, const D: usize> Transformation<Point<T, D>> for Transform<T, C, D>
 where
-    N: RealField + simba::scalar::RealField,
+    Const<D>: DimNameAdd<U1>,
+    T: RealField + simba::scalar::RealField,
     C: TCategory,
-    DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>
-        + Allocator<N, DimNameSum<D, U1>>
-        + Allocator<N, D, D>
-        + Allocator<N, D>,
+    DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
+        + Allocator<T, DimNameSum<Const<D>, U1>>,
 {
     #[inline]
-    fn transform_point(&self, pt: &Point<N, D>) -> Point<N, D> {
+    fn transform_point(&self, pt: &Point<T, D>) -> Point<T, D> {
         self.transform_point(pt)
     }
 
     #[inline]
-    fn transform_vector(&self, v: &VectorN<N, D>) -> VectorN<N, D> {
+    fn transform_vector(&self, v: &SVector<T, D>) -> SVector<T, D> {
         self.transform_vector(v)
     }
 }
 
-impl<N, D: DimNameAdd<U1>, C> ProjectiveTransformation<Point<N, D>> for Transform<N, D, C>
+impl<T, C, const D: usize> ProjectiveTransformation<Point<T, D>> for Transform<T, C, D>
 where
-    N: RealField + simba::scalar::RealField,
+    Const<D>: DimNameAdd<U1>,
+    T: RealField + simba::scalar::RealField,
     C: SubTCategoryOf<TProjective>,
-    DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>
-        + Allocator<N, DimNameSum<D, U1>>
-        + Allocator<N, D, D>
-        + Allocator<N, D>,
+    DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
+        + Allocator<T, DimNameSum<Const<D>, U1>>,
 {
     #[inline]
-    fn inverse_transform_point(&self, pt: &Point<N, D>) -> Point<N, D> {
+    fn inverse_transform_point(&self, pt: &Point<T, D>) -> Point<T, D> {
         self.inverse_transform_point(pt)
     }
 
     #[inline]
-    fn inverse_transform_vector(&self, v: &VectorN<N, D>) -> VectorN<N, D> {
+    fn inverse_transform_vector(&self, v: &SVector<T, D>) -> SVector<T, D> {
         self.inverse_transform_vector(v)
     }
 }
 
 // TODO: we need to implement an SVD for this.
 //
-// impl<N, D: DimNameAdd<U1>, C> AffineTransformation<Point<N, D>> for Transform<N, D, C>
-//     where N:  RealField,
+// impl<T, C, const D: usize> AffineTransformation<Point<T, D>> for Transform<T, C, D>
+//     where T:  RealField,
 //           C: SubTCategoryOf<TAffine>,
-//           DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>> +
-//                             Allocator<N, D, D> +
-//                             Allocator<N, D> {
-//     type PreRotation       = Rotation<N, D>;
-//     type NonUniformScaling = VectorN<N, D>;
-//     type PostRotation      = Rotation<N, D>;
-//     type Translation       = Translation<N, D>;
+//           DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> {
+//     type PreRotation       = Rotation<T, D>;
+//     type NonUniformScaling = OVector<T, D>;
+//     type PostRotation      = Rotation<T, D>;
+//     type Translation       = Translation<T, D>;
 //
 //     #[inline]
 //     fn decompose(&self) -> (Self::Translation, Self::PostRotation, Self::NonUniformScaling, Self::PreRotation) {
diff --git a/src/third_party/alga/alga_translation.rs b/src/third_party/alga/alga_translation.rs
index aba6f1f4..bca6d13f 100755
--- a/src/third_party/alga/alga_translation.rs
+++ b/src/third_party/alga/alga_translation.rs
@@ -8,10 +8,7 @@ use alga::linear::{
     Transformation,
 };
 
-use crate::base::allocator::Allocator;
-use crate::base::dimension::DimName;
-use crate::base::{DefaultAllocator, VectorN};
-
+use crate::base::SVector;
 use crate::geometry::{Point, Translation};
 
 /*
@@ -19,10 +16,8 @@ use crate::geometry::{Point, Translation};
  * Algebraic structures.
  *
  */
-impl<N: RealField + simba::scalar::RealField, D: DimName> Identity<Multiplicative>
-    for Translation<N, D>
-where
-    DefaultAllocator: Allocator<N, D>,
+impl<T: RealField + simba::scalar::RealField, const D: usize> Identity<Multiplicative>
+    for Translation<T, D>
 {
     #[inline]
     fn identity() -> Self {
@@ -30,10 +25,8 @@ where
     }
 }
 
-impl<N: RealField + simba::scalar::RealField, D: DimName> TwoSidedInverse<Multiplicative>
-    for Translation<N, D>
-where
-    DefaultAllocator: Allocator<N, D>,
+impl<T: RealField + simba::scalar::RealField, const D: usize> TwoSidedInverse<Multiplicative>
+    for Translation<T, D>
 {
     #[inline]
     #[must_use = "Did you mean to use two_sided_inverse_mut()?"]
@@ -47,10 +40,8 @@ where
     }
 }
 
-impl<N: RealField + simba::scalar::RealField, D: DimName> AbstractMagma<Multiplicative>
-    for Translation<N, D>
-where
-    DefaultAllocator: Allocator<N, D>,
+impl<T: RealField + simba::scalar::RealField, const D: usize> AbstractMagma<Multiplicative>
+    for Translation<T, D>
 {
     #[inline]
     fn operate(&self, rhs: &Self) -> Self {
@@ -60,8 +51,8 @@ where
 
 macro_rules! impl_multiplicative_structures(
     ($($marker: ident<$operator: ident>),* $(,)*) => {$(
-        impl<N: RealField + simba::scalar::RealField, D: DimName> $marker<$operator> for Translation<N, D>
-            where DefaultAllocator: Allocator<N, D> { }
+        impl<T: RealField + simba::scalar::RealField, const D: usize> $marker<$operator> for Translation<T, D>
+            { }
     )*}
 );
 
@@ -78,42 +69,36 @@ impl_multiplicative_structures!(
  * Transformation groups.
  *
  */
-impl<N: RealField + simba::scalar::RealField, D: DimName> Transformation<Point<N, D>>
-    for Translation<N, D>
-where
-    DefaultAllocator: Allocator<N, D>,
+impl<T: RealField + simba::scalar::RealField, const D: usize> Transformation<Point<T, D>>
+    for Translation<T, D>
 {
     #[inline]
-    fn transform_point(&self, pt: &Point<N, D>) -> Point<N, D> {
+    fn transform_point(&self, pt: &Point<T, D>) -> Point<T, D> {
         self.transform_point(pt)
     }
 
     #[inline]
-    fn transform_vector(&self, v: &VectorN<N, D>) -> VectorN<N, D> {
+    fn transform_vector(&self, v: &SVector<T, D>) -> SVector<T, D> {
         v.clone()
     }
 }
 
-impl<N: RealField + simba::scalar::RealField, D: DimName> ProjectiveTransformation<Point<N, D>>
-    for Translation<N, D>
-where
-    DefaultAllocator: Allocator<N, D>,
+impl<T: RealField + simba::scalar::RealField, const D: usize> ProjectiveTransformation<Point<T, D>>
+    for Translation<T, D>
 {
     #[inline]
-    fn inverse_transform_point(&self, pt: &Point<N, D>) -> Point<N, D> {
+    fn inverse_transform_point(&self, pt: &Point<T, D>) -> Point<T, D> {
         self.inverse_transform_point(pt)
     }
 
     #[inline]
-    fn inverse_transform_vector(&self, v: &VectorN<N, D>) -> VectorN<N, D> {
+    fn inverse_transform_vector(&self, v: &SVector<T, D>) -> SVector<T, D> {
         v.clone()
     }
 }
 
-impl<N: RealField + simba::scalar::RealField, D: DimName> AffineTransformation<Point<N, D>>
-    for Translation<N, D>
-where
-    DefaultAllocator: Allocator<N, D>,
+impl<T: RealField + simba::scalar::RealField, const D: usize> AffineTransformation<Point<T, D>>
+    for Translation<T, D>
 {
     type Rotation = Id;
     type NonUniformScaling = Id;
@@ -155,10 +140,8 @@ where
     }
 }
 
-impl<N: RealField + simba::scalar::RealField, D: DimName> Similarity<Point<N, D>>
-    for Translation<N, D>
-where
-    DefaultAllocator: Allocator<N, D>,
+impl<T: RealField + simba::scalar::RealField, const D: usize> Similarity<Point<T, D>>
+    for Translation<T, D>
 {
     type Scaling = Id;
 
@@ -180,36 +163,34 @@ where
 
 macro_rules! marker_impl(
     ($($Trait: ident),*) => {$(
-        impl<N: RealField + simba::scalar::RealField, D: DimName> $Trait<Point<N, D>> for Translation<N, D>
-            where DefaultAllocator: Allocator<N, D> { }
+        impl<T: RealField + simba::scalar::RealField, const D: usize> $Trait<Point<T, D>> for Translation<T, D>
+            { }
     )*}
 );
 
 marker_impl!(Isometry, DirectIsometry);
 
 /// Subgroups of the n-dimensional translation group `T(n)`.
-impl<N: RealField + simba::scalar::RealField, D: DimName> AlgaTranslation<Point<N, D>>
-    for Translation<N, D>
-where
-    DefaultAllocator: Allocator<N, D>,
+impl<T: RealField + simba::scalar::RealField, const D: usize> AlgaTranslation<Point<T, D>>
+    for Translation<T, D>
 {
     #[inline]
-    fn to_vector(&self) -> VectorN<N, D> {
+    fn to_vector(&self) -> SVector<T, D> {
         self.vector.clone()
     }
 
     #[inline]
-    fn from_vector(v: VectorN<N, D>) -> Option<Self> {
+    fn from_vector(v: SVector<T, D>) -> Option<Self> {
         Some(Self::from(v))
     }
 
     #[inline]
-    fn powf(&self, n: N) -> Option<Self> {
+    fn powf(&self, n: T) -> Option<Self> {
         Some(Self::from(&self.vector * n))
     }
 
     #[inline]
-    fn translation_between(a: &Point<N, D>, b: &Point<N, D>) -> Option<Self> {
+    fn translation_between(a: &Point<T, D>, b: &Point<T, D>) -> Option<Self> {
         Some(Self::from(b - a))
     }
 }
diff --git a/src/third_party/alga/alga_unit_complex.rs b/src/third_party/alga/alga_unit_complex.rs
index 46e30535..44dadb42 100755
--- a/src/third_party/alga/alga_unit_complex.rs
+++ b/src/third_party/alga/alga_unit_complex.rs
@@ -7,9 +7,7 @@ use alga::linear::{
     ProjectiveTransformation, Rotation, Similarity, Transformation,
 };
 
-use crate::base::allocator::Allocator;
-use crate::base::dimension::U2;
-use crate::base::{DefaultAllocator, Vector2};
+use crate::base::Vector2;
 use crate::geometry::{Point2, UnitComplex};
 
 /*
@@ -17,21 +15,21 @@ use crate::geometry::{Point2, UnitComplex};
  * Implementations for UnitComplex.
  *
  */
-impl<N: RealField + simba::scalar::RealField> Identity<Multiplicative> for UnitComplex<N> {
+impl<T: RealField + simba::scalar::RealField> Identity<Multiplicative> for UnitComplex<T> {
     #[inline]
     fn identity() -> Self {
         Self::identity()
     }
 }
 
-impl<N: RealField + simba::scalar::RealField> AbstractMagma<Multiplicative> for UnitComplex<N> {
+impl<T: RealField + simba::scalar::RealField> AbstractMagma<Multiplicative> for UnitComplex<T> {
     #[inline]
     fn operate(&self, rhs: &Self) -> Self {
         self * rhs
     }
 }
 
-impl<N: RealField + simba::scalar::RealField> TwoSidedInverse<Multiplicative> for UnitComplex<N> {
+impl<T: RealField + simba::scalar::RealField> TwoSidedInverse<Multiplicative> for UnitComplex<T> {
     #[inline]
     #[must_use = "Did you mean to use two_sided_inverse_mut()?"]
     fn two_sided_inverse(&self) -> Self {
@@ -46,7 +44,7 @@ impl<N: RealField + simba::scalar::RealField> TwoSidedInverse<Multiplicative> fo
 
 macro_rules! impl_structures(
     ($($marker: ident<$operator: ident>),* $(,)*) => {$(
-        impl<N: RealField + simba::scalar::RealField> $marker<$operator> for UnitComplex<N> {
+        impl<T: RealField + simba::scalar::RealField> $marker<$operator> for UnitComplex<T> {
         }
     )*}
 );
@@ -59,40 +57,33 @@ impl_structures!(
     AbstractGroup<Multiplicative>
 );
 
-impl<N: RealField + simba::scalar::RealField> Transformation<Point2<N>> for UnitComplex<N>
-where
-    DefaultAllocator: Allocator<N, U2>,
-{
+impl<T: RealField + simba::scalar::RealField> Transformation<Point2<T>> for UnitComplex<T> {
     #[inline]
-    fn transform_point(&self, pt: &Point2<N>) -> Point2<N> {
+    fn transform_point(&self, pt: &Point2<T>) -> Point2<T> {
         self.transform_point(pt)
     }
 
     #[inline]
-    fn transform_vector(&self, v: &Vector2<N>) -> Vector2<N> {
+    fn transform_vector(&self, v: &Vector2<T>) -> Vector2<T> {
         self.transform_vector(v)
     }
 }
 
-impl<N: RealField + simba::scalar::RealField> ProjectiveTransformation<Point2<N>> for UnitComplex<N>
-where
-    DefaultAllocator: Allocator<N, U2>,
+impl<T: RealField + simba::scalar::RealField> ProjectiveTransformation<Point2<T>>
+    for UnitComplex<T>
 {
     #[inline]
-    fn inverse_transform_point(&self, pt: &Point2<N>) -> Point2<N> {
+    fn inverse_transform_point(&self, pt: &Point2<T>) -> Point2<T> {
         self.inverse_transform_point(pt)
     }
 
     #[inline]
-    fn inverse_transform_vector(&self, v: &Vector2<N>) -> Vector2<N> {
+    fn inverse_transform_vector(&self, v: &Vector2<T>) -> Vector2<T> {
         self.inverse_transform_vector(v)
     }
 }
 
-impl<N: RealField + simba::scalar::RealField> AffineTransformation<Point2<N>> for UnitComplex<N>
-where
-    DefaultAllocator: Allocator<N, U2>,
-{
+impl<T: RealField + simba::scalar::RealField> AffineTransformation<Point2<T>> for UnitComplex<T> {
     type Rotation = Self;
     type NonUniformScaling = Id;
     type Translation = Id;
@@ -133,10 +124,7 @@ where
     }
 }
 
-impl<N: RealField + simba::scalar::RealField> Similarity<Point2<N>> for UnitComplex<N>
-where
-    DefaultAllocator: Allocator<N, U2>,
-{
+impl<T: RealField + simba::scalar::RealField> Similarity<Point2<T>> for UnitComplex<T> {
     type Scaling = Id;
 
     #[inline]
@@ -157,29 +145,26 @@ where
 
 macro_rules! marker_impl(
     ($($Trait: ident),*) => {$(
-        impl<N: RealField + simba::scalar::RealField> $Trait<Point2<N>> for UnitComplex<N>
-        where DefaultAllocator: Allocator<N, U2> { }
+        impl<T: RealField + simba::scalar::RealField> $Trait<Point2<T>> for UnitComplex<T>
+        { }
     )*}
 );
 
 marker_impl!(Isometry, DirectIsometry, OrthogonalTransformation);
 
-impl<N: RealField + simba::scalar::RealField> Rotation<Point2<N>> for UnitComplex<N>
-where
-    DefaultAllocator: Allocator<N, U2>,
-{
+impl<T: RealField + simba::scalar::RealField> Rotation<Point2<T>> for UnitComplex<T> {
     #[inline]
-    fn powf(&self, n: N) -> Option<Self> {
+    fn powf(&self, n: T) -> Option<Self> {
         Some(self.powf(n))
     }
 
     #[inline]
-    fn rotation_between(a: &Vector2<N>, b: &Vector2<N>) -> Option<Self> {
+    fn rotation_between(a: &Vector2<T>, b: &Vector2<T>) -> Option<Self> {
         Some(Self::rotation_between(a, b))
     }
 
     #[inline]
-    fn scaled_rotation_between(a: &Vector2<N>, b: &Vector2<N>, s: N) -> Option<Self> {
+    fn scaled_rotation_between(a: &Vector2<T>, b: &Vector2<T>, s: T) -> Option<Self> {
         Some(Self::scaled_rotation_between(a, b, s))
     }
 }
diff --git a/src/third_party/mint/mint_matrix.rs b/src/third_party/mint/mint_matrix.rs
index 30800f65..1e0a4d54 100644
--- a/src/third_party/mint/mint_matrix.rs
+++ b/src/third_party/mint/mint_matrix.rs
@@ -5,15 +5,15 @@ use std::ptr;
 use crate::base::allocator::Allocator;
 use crate::base::dimension::{U1, U2, U3, U4};
 use crate::base::storage::{ContiguousStorage, ContiguousStorageMut, Storage, StorageMut};
-use crate::base::{DefaultAllocator, Matrix, MatrixMN, Scalar};
+use crate::base::{DefaultAllocator, Matrix, OMatrix, Scalar};
 
 macro_rules! impl_from_into_mint_1D(
     ($($NRows: ident => $VT:ident [$SZ: expr]);* $(;)*) => {$(
-        impl<N> From<mint::$VT<N>> for MatrixMN<N, $NRows, U1>
-        where N: Scalar,
-              DefaultAllocator: Allocator<N, $NRows, U1> {
+        impl<T> From<mint::$VT<T>> for OMatrix<T, $NRows, U1>
+        where T: Scalar,
+              DefaultAllocator: Allocator<T, $NRows, U1> {
             #[inline]
-            fn from(v: mint::$VT<N>) -> Self {
+            fn from(v: mint::$VT<T>) -> Self {
                 unsafe {
                     let mut res = Self::new_uninitialized();
                     ptr::copy_nonoverlapping(&v.x, (*res.as_mut_ptr()).data.ptr_mut(), $SZ);
@@ -23,35 +23,35 @@ macro_rules! impl_from_into_mint_1D(
             }
         }
 
-        impl<N, S> Into<mint::$VT<N>> for Matrix<N, $NRows, U1, S>
-        where N: Scalar,
-              S: ContiguousStorage<N, $NRows, U1> {
+        impl<T, S> Into<mint::$VT<T>> for Matrix<T, $NRows, U1, S>
+        where T: Scalar,
+              S: ContiguousStorage<T, $NRows, U1> {
             #[inline]
-            fn into(self) -> mint::$VT<N> {
+            fn into(self) -> mint::$VT<T> {
                 unsafe {
-                    let mut res: mint::$VT<N> = mem::MaybeUninit::uninit().assume_init();
+                    let mut res: mint::$VT<T> = mem::MaybeUninit::uninit().assume_init();
                     ptr::copy_nonoverlapping(self.data.ptr(), &mut res.x, $SZ);
                     res
                 }
             }
         }
 
-        impl<N, S> AsRef<mint::$VT<N>> for Matrix<N, $NRows, U1, S>
-        where N: Scalar,
-              S: ContiguousStorage<N, $NRows, U1> {
+        impl<T, S> AsRef<mint::$VT<T>> for Matrix<T, $NRows, U1, S>
+        where T: Scalar,
+              S: ContiguousStorage<T, $NRows, U1> {
             #[inline]
-            fn as_ref(&self) -> &mint::$VT<N> {
+            fn as_ref(&self) -> &mint::$VT<T> {
                 unsafe {
                     mem::transmute(self.data.ptr())
                 }
             }
         }
 
-        impl<N, S> AsMut<mint::$VT<N>> for Matrix<N, $NRows, U1, S>
-        where N: Scalar,
-              S: ContiguousStorageMut<N, $NRows, U1> {
+        impl<T, S> AsMut<mint::$VT<T>> for Matrix<T, $NRows, U1, S>
+        where T: Scalar,
+              S: ContiguousStorageMut<T, $NRows, U1> {
             #[inline]
-            fn as_mut(&mut self) -> &mut mint::$VT<N> {
+            fn as_mut(&mut self) -> &mut mint::$VT<T> {
                 unsafe {
                     mem::transmute(self.data.ptr_mut())
                 }
@@ -69,11 +69,11 @@ impl_from_into_mint_1D!(
 
 macro_rules! impl_from_into_mint_2D(
     ($(($NRows: ty, $NCols: ty) => $MV:ident{ $($component:ident),* }[$SZRows: expr]);* $(;)*) => {$(
-        impl<N> From<mint::$MV<N>> for MatrixMN<N, $NRows, $NCols>
-        where N: Scalar,
-              DefaultAllocator: Allocator<N, $NRows, $NCols> {
+        impl<T> From<mint::$MV<T>> for OMatrix<T, $NRows, $NCols>
+        where T: Scalar,
+              DefaultAllocator: Allocator<T, $NRows, $NCols> {
             #[inline]
-            fn from(m: mint::$MV<N>) -> Self {
+            fn from(m: mint::$MV<T>) -> Self {
                 unsafe {
                     let mut res = Self::new_uninitialized();
                     let mut ptr = (*res.as_mut_ptr()).data.ptr_mut();
@@ -87,13 +87,13 @@ macro_rules! impl_from_into_mint_2D(
             }
         }
 
-        impl<N> Into<mint::$MV<N>> for MatrixMN<N, $NRows, $NCols>
-        where N: Scalar,
-              DefaultAllocator: Allocator<N, $NRows, $NCols> {
+        impl<T> Into<mint::$MV<T>> for OMatrix<T, $NRows, $NCols>
+        where T: Scalar,
+              DefaultAllocator: Allocator<T, $NRows, $NCols> {
             #[inline]
-            fn into(self) -> mint::$MV<N> {
+            fn into(self) -> mint::$MV<T> {
                 unsafe {
-                    let mut res: mint::$MV<N> = mem::MaybeUninit::uninit().assume_init();
+                    let mut res: mint::$MV<T> = mem::MaybeUninit::uninit().assume_init();
                     let mut ptr = self.data.ptr();
                     $(
                         ptr::copy_nonoverlapping(ptr, &mut res.$component.x, $SZRows);
diff --git a/src/third_party/mint/mint_point.rs b/src/third_party/mint/mint_point.rs
index 62a2bf77..fbce1c88 100644
--- a/src/third_party/mint/mint_point.rs
+++ b/src/third_party/mint/mint_point.rs
@@ -1,44 +1,44 @@
 use crate::base::storage::{Storage, StorageMut};
-use crate::{Point, Scalar, VectorN, U2, U3};
+use crate::{OVector, Point, Scalar};
 use std::convert::{AsMut, AsRef};
 
 macro_rules! impl_from_into_mint_1D(
-    ($($NRows: ident => $PT:ident, $VT:ident [$SZ: expr]);* $(;)*) => {$(
-        impl<N> From<mint::$PT<N>> for Point<N, $NRows>
-        where N: Scalar {
+    ($($NRows: expr => $PT:ident, $VT:ident [$SZ: expr]);* $(;)*) => {$(
+        impl<T> From<mint::$PT<T>> for Point<T, $NRows>
+        where T: Scalar {
             #[inline]
-            fn from(p: mint::$PT<N>) -> Self {
+            fn from(p: mint::$PT<T>) -> Self {
                 Self {
-                    coords: VectorN::from(mint::$VT::from(p)),
+                    coords: OVector::from(mint::$VT::from(p)),
                 }
             }
         }
 
-        impl<N> Into<mint::$PT<N>> for Point<N, $NRows>
-        where N: Scalar {
+        impl<T> Into<mint::$PT<T>> for Point<T, $NRows>
+        where T: Scalar {
             #[inline]
-            fn into(self) -> mint::$PT<N> {
-                let mint_vec: mint::$VT<N> = self.coords.into();
+            fn into(self) -> mint::$PT<T> {
+                let mint_vec: mint::$VT<T> = self.coords.into();
                 mint::$PT::from(mint_vec)
             }
         }
 
-        impl<N> AsRef<mint::$PT<N>> for Point<N, $NRows>
-        where N: Scalar {
+        impl<T> AsRef<mint::$PT<T>> for Point<T, $NRows>
+        where T: Scalar {
             #[inline]
-            fn as_ref(&self) -> &mint::$PT<N> {
+            fn as_ref(&self) -> &mint::$PT<T> {
                 unsafe {
-                    &*(self.coords.data.ptr() as *const mint::$PT<N>)
+                    &*(self.coords.data.ptr() as *const mint::$PT<T>)
                 }
             }
         }
 
-        impl<N> AsMut<mint::$PT<N>> for Point<N, $NRows>
-        where N: Scalar {
+        impl<T> AsMut<mint::$PT<T>> for Point<T, $NRows>
+        where T: Scalar {
             #[inline]
-            fn as_mut(&mut self) -> &mut mint::$PT<N> {
+            fn as_mut(&mut self) -> &mut mint::$PT<T> {
                 unsafe {
-                    &mut *(self.coords.data.ptr_mut() as *mut mint::$PT<N>)
+                    &mut *(self.coords.data.ptr_mut() as *mut mint::$PT<T>)
                 }
             }
         }
@@ -47,6 +47,6 @@ macro_rules! impl_from_into_mint_1D(
 
 // Implement for points of dimension 2, 3.
 impl_from_into_mint_1D!(
-    U2 => Point2, Vector2[2];
-    U3 => Point3, Vector3[3];
+    2 => Point2, Vector2[2];
+    3 => Point3, Vector3[3];
 );
diff --git a/src/third_party/mint/mint_quaternion.rs b/src/third_party/mint/mint_quaternion.rs
index 01a1a94c..f41815ce 100644
--- a/src/third_party/mint/mint_quaternion.rs
+++ b/src/third_party/mint/mint_quaternion.rs
@@ -1,13 +1,13 @@
 use crate::{Quaternion, Scalar, SimdValue, UnitQuaternion};
 
-impl<N: Scalar> From<mint::Quaternion<N>> for Quaternion<N> {
-    fn from(q: mint::Quaternion<N>) -> Self {
+impl<T: Scalar> From<mint::Quaternion<T>> for Quaternion<T> {
+    fn from(q: mint::Quaternion<T>) -> Self {
         Self::new(q.s, q.v.x, q.v.y, q.v.z)
     }
 }
 
-impl<N: Scalar> Into<mint::Quaternion<N>> for Quaternion<N> {
-    fn into(self) -> mint::Quaternion<N> {
+impl<T: Scalar> Into<mint::Quaternion<T>> for Quaternion<T> {
+    fn into(self) -> mint::Quaternion<T> {
         mint::Quaternion {
             v: mint::Vector3 {
                 x: self[0].inlined_clone(),
@@ -19,8 +19,8 @@ impl<N: Scalar> Into<mint::Quaternion<N>> for Quaternion<N> {
     }
 }
 
-impl<N: Scalar + SimdValue> Into<mint::Quaternion<N>> for UnitQuaternion<N> {
-    fn into(self) -> mint::Quaternion<N> {
+impl<T: Scalar + SimdValue> Into<mint::Quaternion<T>> for UnitQuaternion<T> {
+    fn into(self) -> mint::Quaternion<T> {
         mint::Quaternion {
             v: mint::Vector3 {
                 x: self[0].inlined_clone(),
diff --git a/src/third_party/mint/mint_rotation.rs b/src/third_party/mint/mint_rotation.rs
index 9903da5d..ce57694e 100644
--- a/src/third_party/mint/mint_rotation.rs
+++ b/src/third_party/mint/mint_rotation.rs
@@ -1,7 +1,7 @@
 use crate::{RealField, Rotation3};
 
-impl<N: RealField> From<mint::EulerAngles<N, mint::IntraXYZ>> for Rotation3<N> {
-    fn from(euler: mint::EulerAngles<N, mint::IntraXYZ>) -> Self {
+impl<T: RealField> From<mint::EulerAngles<T, mint::IntraXYZ>> for Rotation3<T> {
+    fn from(euler: mint::EulerAngles<T, mint::IntraXYZ>) -> Self {
         Self::from_euler_angles(euler.a, euler.b, euler.c)
     }
 }
diff --git a/tests/core/conversion.rs b/tests/core/conversion.rs
index 93545004..58ac179a 100644
--- a/tests/core/conversion.rs
+++ b/tests/core/conversion.rs
@@ -287,12 +287,12 @@ fn matrix_slice_from_matrix_ref() {
         ($mref:expr) => {
             MatrixSlice::<_, U3, U4, U1, U3>::from($mref)
         };
-    };
+    }
     macro_rules! fixed_slice_mut {
         ($mref:expr) => {
             MatrixSliceMut::<_, U3, U4, U1, U3>::from($mref)
         };
-    };
+    }
 
     // TODO: The `into_owned()` is a result of `PartialEq` not being implemented for different
     // Self and RHS. See issue #674. Once this is implemented, we can remove `into_owned`
diff --git a/tests/core/edition.rs b/tests/core/edition.rs
index dac25d45..a8ee2536 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, U2, U3, U5};
+use na::{Dynamic, U3, U5};
 
 #[test]
 #[rustfmt::skip]
@@ -252,9 +252,9 @@ fn remove_columns() {
         21, 22, 25,
         31, 32, 35);
 
-    assert_eq!(m.remove_fixed_columns::<U2>(0), expected1);
-    assert_eq!(m.remove_fixed_columns::<U2>(3), expected2);
-    assert_eq!(m.remove_fixed_columns::<U2>(2), expected3);
+    assert_eq!(m.remove_fixed_columns::<2>(0), expected1);
+    assert_eq!(m.remove_fixed_columns::<2>(3), expected2);
+    assert_eq!(m.remove_fixed_columns::<2>(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);
@@ -366,9 +366,9 @@ fn remove_rows() {
         21, 22, 23,
         51, 52, 53);
 
-    assert_eq!(m.remove_fixed_rows::<U2>(0), expected1);
-    assert_eq!(m.remove_fixed_rows::<U2>(3), expected2);
-    assert_eq!(m.remove_fixed_rows::<U2>(2), expected3);
+    assert_eq!(m.remove_fixed_rows::<2>(0), expected1);
+    assert_eq!(m.remove_fixed_rows::<2>(3), expected2);
+    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);
@@ -483,9 +483,9 @@ fn insert_columns() {
         41, 42, 0, 0, 43,
         51, 52, 0, 0, 53);
 
-    assert_eq!(m.insert_fixed_columns::<U2>(0, 0), expected1);
-    assert_eq!(m.insert_fixed_columns::<U2>(3, 0), expected2);
-    assert_eq!(m.insert_fixed_columns::<U2>(2, 0), expected3);
+    assert_eq!(m.insert_fixed_columns::<2>(0, 0), expected1);
+    assert_eq!(m.insert_fixed_columns::<2>(3, 0), expected2);
+    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);
@@ -556,9 +556,9 @@ fn insert_rows() {
          0,  0,  0,  0,  0,
         31, 32, 33, 34, 35);
 
-    assert_eq!(m.insert_fixed_rows::<U2>(0, 0), expected1);
-    assert_eq!(m.insert_fixed_rows::<U2>(3, 0), expected2);
-    assert_eq!(m.insert_fixed_rows::<U2>(2, 0), expected3);
+    assert_eq!(m.insert_fixed_rows::<2>(0, 0), expected1);
+    assert_eq!(m.insert_fixed_rows::<2>(3, 0), expected2);
+    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);
diff --git a/tests/core/helper.rs b/tests/core/helper.rs
index ec214fc0..4666089d 100644
--- a/tests/core/helper.rs
+++ b/tests/core/helper.rs
@@ -8,9 +8,9 @@ use rand::distributions::{Distribution, Standard};
 use rand::Rng;
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
-pub struct RandComplex<N>(pub Complex<N>);
+pub struct RandComplex<T>(pub Complex<T>);
 
-impl<N: Arbitrary + RealField> Arbitrary for RandComplex<N> {
+impl<T: Arbitrary + RealField> Arbitrary for RandComplex<T> {
     #[inline]
     fn arbitrary(rng: &mut Gen) -> Self {
         let im = Arbitrary::arbitrary(rng);
@@ -19,12 +19,12 @@ impl<N: Arbitrary + RealField> Arbitrary for RandComplex<N> {
     }
 }
 
-impl<N: RealField> Distribution<RandComplex<N>> for Standard
+impl<T: RealField> Distribution<RandComplex<T>> for Standard
 where
-    Standard: Distribution<N>,
+    Standard: Distribution<T>,
 {
     #[inline]
-    fn sample<'a, G: Rng + ?Sized>(&self, rng: &'a mut G) -> RandComplex<N> {
+    fn sample<'a, G: Rng + ?Sized>(&self, rng: &'a mut G) -> RandComplex<T> {
         let re = rng.gen();
         let im = rng.gen();
         RandComplex(Complex::new(re, im))
@@ -36,21 +36,21 @@ where
 //
 // Generates variates in the range [0, 1).
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
-pub struct RandScalar<N>(pub N);
+pub struct RandScalar<T>(pub T);
 
-impl<N: Arbitrary> Arbitrary for RandScalar<N> {
+impl<T: Arbitrary> Arbitrary for RandScalar<T> {
     #[inline]
     fn arbitrary(rng: &mut Gen) -> Self {
         RandScalar(Arbitrary::arbitrary(rng))
     }
 }
 
-impl<N: RealField> Distribution<RandScalar<N>> for Standard
+impl<T: RealField> Distribution<RandScalar<T>> for Standard
 where
-    Standard: Distribution<N>,
+    Standard: Distribution<T>,
 {
     #[inline]
-    fn sample<'a, G: Rng + ?Sized>(&self, rng: &'a mut G) -> RandScalar<N> {
+    fn sample<'a, G: Rng + ?Sized>(&self, rng: &'a mut G) -> RandScalar<T> {
         RandScalar(self.sample(rng))
     }
 }
diff --git a/tests/core/matrix.rs b/tests/core/matrix.rs
index daa8b72f..7befd351 100644
--- a/tests/core/matrix.rs
+++ b/tests/core/matrix.rs
@@ -1,11 +1,11 @@
 use num::{One, Zero};
 use std::cmp::Ordering;
 
-use na::dimension::{U15, U2, U4, U8};
+use na::dimension::{U15, U8};
 use na::{
-    self, DMatrix, DVector, Matrix2, Matrix2x3, Matrix2x4, Matrix3, Matrix3x2, Matrix3x4, Matrix4,
-    Matrix4x3, Matrix4x5, Matrix5, Matrix6, MatrixMN, RowVector3, RowVector4, RowVector5, Vector1,
-    Vector2, Vector3, Vector4, Vector5, Vector6,
+    self, Const, DMatrix, DVector, Matrix2, Matrix2x3, Matrix2x4, Matrix3, Matrix3x2, Matrix3x4,
+    Matrix4, Matrix4x3, Matrix4x5, Matrix5, Matrix6, OMatrix, RowVector3, RowVector4, RowVector5,
+    Vector1, Vector2, Vector3, Vector4, Vector5, Vector6,
 };
 
 #[test]
@@ -79,10 +79,15 @@ fn iter() {
 
 #[test]
 fn debug_output_corresponds_to_data_container() {
-    assert!(
-        format!("{:?}", Matrix2::new(1.0, 2.0, 3.0, 4.0)) == "Matrix { data: [1, 3, 2, 4] }" || // Current output on the stable chanel.
-        format!("{:?}", Matrix2::new(1.0, 2.0, 3.0, 4.0)) == "Matrix { data: [1.0, 3.0, 2.0, 4.0] }" // Current output on the nightyl chanel.
-    );
+    let m = Matrix2::new(1.0, 2.0, 3.0, 4.0);
+    let output_stable = "Matrix { data: [[1, 3], [2, 4]] }"; // Current output on the stable channel.
+    let output_nightly = "Matrix { data: [[1.0, 3.0], [2.0, 4.0]] }"; // Current output on the nightly channel.
+    let current_output = format!("{:?}", m);
+    dbg!(output_stable);
+    dbg!(output_nightly);
+    dbg!(&current_output);
+
+    assert!(current_output == output_stable || current_output == output_nightly);
 }
 
 #[test]
@@ -698,7 +703,7 @@ fn kronecker() {
         440, 450,
     );
 
-    let expected = MatrixMN::<_, U8, U15>::from_row_slice(&[
+    let expected = OMatrix::<_, U8, U15>::from_row_slice(&[
         1210, 1320, 1430, 1540, 1650, 1320, 1440, 1560, 1680, 1800, 1430, 1560, 1690, 1820, 1950,
         2310, 2420, 2530, 2640, 2750, 2520, 2640, 2760, 2880, 3000, 2730, 2860, 2990, 3120, 3250,
         3410, 3520, 3630, 3740, 3850, 3720, 3840, 3960, 4080, 4200, 4030, 4160, 4290, 4420, 4550,
@@ -833,17 +838,16 @@ fn swizzle() {
 mod transposition_tests {
     use super::*;
     use crate::proptest::{dmatrix, matrix, vector4, PROPTEST_F64};
-    use na::{U2, U3, U4, U6};
     use proptest::{prop_assert, prop_assert_eq, proptest};
 
     proptest! {
         #[test]
-        fn transpose_transpose_is_self(m in matrix(PROPTEST_F64, U2, U3)) {
+        fn transpose_transpose_is_self(m in matrix(PROPTEST_F64, Const::<2>, Const::<3>)) {
             prop_assert_eq!(m.transpose().transpose(), m)
         }
 
         #[test]
-        fn transpose_mut_transpose_mut_is_self(m in matrix(PROPTEST_F64, U3, U3)) {
+        fn transpose_mut_transpose_mut_is_self(m in matrix(PROPTEST_F64, Const::<3>, Const::<3>)) {
             let mut mm = m;
             mm.transpose_mut();
             mm.transpose_mut();
@@ -870,7 +874,7 @@ mod transposition_tests {
         }
 
         #[test]
-        fn tr_mul_is_transpose_then_mul(m in matrix(PROPTEST_F64, U4, U6), v in vector4()) {
+        fn tr_mul_is_transpose_then_mul(m in matrix(PROPTEST_F64, Const::<4>, Const::<6>), v in vector4()) {
             prop_assert!(relative_eq!(m.transpose() * v, m.tr_mul(&v), epsilon = 1.0e-7))
         }
     }
@@ -1061,13 +1065,13 @@ fn partial_eq_different_types() {
     let dynamic_mat = DMatrix::from_row_slice(2, 4, &[1, 2, 3, 4, 5, 6, 7, 8]);
     let static_mat = Matrix2x4::new(1, 2, 3, 4, 5, 6, 7, 8);
 
-    let mut typenum_static_mat = MatrixMN::<u8, typenum::U1024, U4>::zeros();
+    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 fslice_of_dmat = dynamic_mat.fixed_slice::<U2, U2>(0, 0);
+    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::<U2, U2>(0, 0);
+    let fslice_of_smat = static_mat.fixed_slice::<2, 2>(0, 0);
     let dslice_of_smat = static_mat.slice((0, 0), (2, 2));
 
     assert_eq!(dynamic_mat, static_mat);
diff --git a/tests/core/matrix_slice.rs b/tests/core/matrix_slice.rs
index 5fd90b0f..ada5297e 100644
--- a/tests/core/matrix_slice.rs
+++ b/tests/core/matrix_slice.rs
@@ -6,7 +6,6 @@ use na::{
     MatrixSlice3, MatrixSlice3x2, MatrixSliceMut2, MatrixSliceMut2x3, MatrixSliceMut2xX,
     MatrixSliceMut3, MatrixSliceMut3x2, MatrixSliceMutXx3, MatrixSliceXx3, RowVector4, Vector3,
 };
-use na::{U2, U3, U4};
 
 #[test]
 #[rustfmt::skip]
@@ -15,9 +14,9 @@ fn nested_fixed_slices() {
                            21.0, 22.0, 23.0, 24.0,
                            31.0, 32.0, 33.0, 34.0);
 
-    let s1 = a.fixed_slice::<U3, U3>(0, 1);                       // Simple slice.
-    let s2 = s1.fixed_slice::<U2, U2>(1, 1);                      // Slice of slice.
-    let s3 = s1.fixed_slice_with_steps::<U2, U2>((0, 0), (1, 1)); // Slice of slice with steps.
+    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 expected_owned_s1 = Matrix3::new(12.0, 13.0, 14.0,
                                          22.0, 23.0, 24.0,
@@ -89,8 +88,8 @@ fn nested_row_slices() {
                            41.0, 42.0,
                            51.0, 52.0,
                            61.0, 62.0);
-    let s1 = a.fixed_rows::<U4>(1);
-    let s2 = s1.fixed_rows_with_step::<U2>(1, 1);
+    let s1 = a.fixed_rows::<4>(1);
+    let s2 = s1.fixed_rows_with_step::<2>(1, 1);
 
     let expected_owned_s1 = Matrix4x2::new(21.0, 22.0,
                                            31.0, 32.0,
@@ -134,8 +133,8 @@ fn row_slice_mut() {
 fn nested_col_slices() {
     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::<U4>(1);
-    let s2 = s1.fixed_columns_with_step::<U2>(1, 1);
+    let s1 = a.fixed_columns::<4>(1);
+    let s2 = s1.fixed_columns_with_step::<2>(1, 1);
 
     let expected_owned_s1 = Matrix2x4::new(12.0, 13.0, 14.0, 15.0,
                                            22.0, 23.0, 24.0, 25.0);
diff --git a/tests/core/matrixcompare.rs b/tests/core/matrixcompare.rs
index ab3ecc2c..5c40d679 100644
--- a/tests/core/matrixcompare.rs
+++ b/tests/core/matrixcompare.rs
@@ -5,7 +5,7 @@
 //! in addition to some sanity checks with example input.
 
 use matrixcompare::assert_matrix_eq;
-use nalgebra::{MatrixMN, U4, U5};
+use nalgebra::{OMatrix, U4, U5};
 
 #[cfg(feature = "proptest-support")]
 use {
@@ -36,7 +36,7 @@ proptest! {
 #[test]
 fn assert_matrix_eq_dense_positive_comparison() {
     #[rustfmt::skip]
-    let a = MatrixMN::<_, U4, U5>::from_row_slice(&[
+    let a = OMatrix::<_, U4, U5>::from_row_slice(&[
         1210, 1320, 1430, 1540, 1650,
         2310, 2420, 2530, 2640, 2750,
         3410, 3520, 3630, 3740, 3850,
@@ -44,7 +44,7 @@ fn assert_matrix_eq_dense_positive_comparison() {
     ]);
 
     #[rustfmt::skip]
-    let b = MatrixMN::<_, U4, U5>::from_row_slice(&[
+    let b = OMatrix::<_, U4, U5>::from_row_slice(&[
         1210, 1320, 1430, 1540, 1650,
         2310, 2420, 2530, 2640, 2750,
         3410, 3520, 3630, 3740, 3850,
@@ -70,7 +70,7 @@ fn assert_matrix_eq_dense_positive_comparison() {
 #[should_panic]
 fn assert_matrix_eq_dense_negative_comparison() {
     #[rustfmt::skip]
-    let a = MatrixMN::<_, U4, U5>::from_row_slice(&[
+    let a = OMatrix::<_, U4, U5>::from_row_slice(&[
         1210, 1320, 1430, 1540, 1650,
         2310, 2420, 2530, 2640, 2750,
         3410, 3520, 3630, 3740, 3850,
@@ -78,7 +78,7 @@ fn assert_matrix_eq_dense_negative_comparison() {
     ]);
 
     #[rustfmt::skip]
-    let b = MatrixMN::<_, U4, U5>::from_row_slice(&[
+    let b = OMatrix::<_, U4, U5>::from_row_slice(&[
         1210, 1320, 1430, 1540, 1650,
         2310, 2420, 2530, 2640, 2750,
         3410, 3520, 3630, 3740, 3850,
diff --git a/tests/linalg/cholesky.rs b/tests/linalg/cholesky.rs
index df69b8b1..6fd83912 100644
--- a/tests/linalg/cholesky.rs
+++ b/tests/linalg/cholesky.rs
@@ -4,7 +4,7 @@ macro_rules! gen_tests(
     ($module: ident, $scalar: ty) => {
         mod $module {
             use na::debug::RandomSDP;
-            use na::dimension::{U4, Dynamic};
+            use na::dimension::{Const, Dynamic};
             use na::{DMatrix, DVector, Matrix4x3, Vector4};
             use rand::random;
             use simba::scalar::ComplexField;
@@ -24,7 +24,7 @@ macro_rules! gen_tests(
 
                 #[test]
                 fn cholesky_static(_n in PROPTEST_MATRIX_DIM) {
-                    let m = RandomSDP::new(U4, || random::<$scalar>().0).unwrap();
+                    let m = RandomSDP::new(Const::<4>, || random::<$scalar>().0).unwrap();
                     let chol = m.cholesky().unwrap();
                     let l    = chol.unpack();
 
@@ -48,7 +48,7 @@ macro_rules! gen_tests(
 
                 #[test]
                 fn cholesky_solve_static(_n in PROPTEST_MATRIX_DIM) {
-                    let m = RandomSDP::new(U4, || random::<$scalar>().0).unwrap();
+                    let m = RandomSDP::new(Const::<4>, || random::<$scalar>().0).unwrap();
                     let chol = m.clone().cholesky().unwrap();
                     let b1 = Vector4::<$scalar>::new_random().map(|e| e.0);
                     let b2 = Matrix4x3::<$scalar>::new_random().map(|e| e.0);
@@ -72,7 +72,7 @@ macro_rules! gen_tests(
 
                 #[test]
                 fn cholesky_inverse_static(_n in PROPTEST_MATRIX_DIM) {
-                    let m = RandomSDP::new(U4, || random::<$scalar>().0).unwrap();
+                    let m = RandomSDP::new(Const::<4>, || random::<$scalar>().0).unwrap();
                     let m1 = m.clone().cholesky().unwrap().inverse();
                     let id1 = &m  * &m1;
                     let id2 = &m1 * &m;
@@ -92,7 +92,7 @@ macro_rules! gen_tests(
 
                 #[test]
                 fn cholesky_determinant_static(_n in PROPTEST_MATRIX_DIM) {
-                    let m = RandomSDP::new(U4, || random::<$scalar>().0).unwrap();
+                    let m = RandomSDP::new(Const::<4>, || 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();
@@ -102,7 +102,7 @@ macro_rules! gen_tests(
 
                 #[test]
                 fn cholesky_rank_one_update(_n in PROPTEST_MATRIX_DIM) {
-                    let mut m = RandomSDP::new(U4, || random::<$scalar>().0).unwrap();
+                    let mut m = RandomSDP::new(Const::<4>, || random::<$scalar>().0).unwrap();
                     let x = Vector4::<$scalar>::new_random().map(|e| e.0);
 
                     // this is dirty but $scalar is not a scalar type (its a Rand) in this file
diff --git a/tests/linalg/eigen.rs b/tests/linalg/eigen.rs
index e9c0522b..162aad6a 100644
--- a/tests/linalg/eigen.rs
+++ b/tests/linalg/eigen.rs
@@ -180,13 +180,13 @@ fn symmetric_eigen_singular_24x24() {
 //    }
 //  }
 //
-// fn verify_eigenvectors<D: Dim>(m: MatrixN<f64, D>, mut eig: RealEigen<f64, D>) -> bool
+// fn verify_eigenvectors<D: Dim>(m: OMatrix<f64, D>, mut eig: RealEigen<f64, D>) -> bool
 //     where DefaultAllocator: Allocator<f64, D, D>   +
 //                             Allocator<f64, D>      +
 //                             Allocator<usize, D, D> +
 //                             Allocator<usize, D>,
-//           MatrixN<f64, D>: Display,
-//           VectorN<f64, D>: Display {
+//           OMatrix<f64, D>: Display,
+//           OVector<f64, D>: Display {
 //     let mv = &m * &eig.eigenvectors;
 //
 //     println!("eigenvalues: {}eigenvectors: {}", eig.eigenvalues, eig.eigenvectors);
diff --git a/tests/linalg/full_piv_lu.rs b/tests/linalg/full_piv_lu.rs
index f782d8fd..7ac95b0f 100644
--- a/tests/linalg/full_piv_lu.rs
+++ b/tests/linalg/full_piv_lu.rs
@@ -429,9 +429,9 @@ fn insert_rows() {
          0,  0,  0,  0,  0,
         31, 32, 33, 34, 35);
 
-    assert_eq!(m.insert_fixed_rows::<U2>(0, 0), expected1);
-    assert_eq!(m.insert_fixed_rows::<U2>(3, 0), expected2);
-    assert_eq!(m.insert_fixed_rows::<U2>(2, 0), expected3);
+    assert_eq!(m.insert_fixed_rows::<2>(0, 0), expected1);
+    assert_eq!(m.insert_fixed_rows::<2>(3, 0), expected2);
+    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);
diff --git a/tests/linalg/solve.rs b/tests/linalg/solve.rs
index 81cd1c71..1918af45 100644
--- a/tests/linalg/solve.rs
+++ b/tests/linalg/solve.rs
@@ -9,10 +9,10 @@ macro_rules! gen_tests(
             use crate::proptest::*;
             use proptest::{prop_assert, proptest};
 
-            fn unzero_diagonal<N: ComplexField>(a: &mut Matrix4<N>) {
+            fn unzero_diagonal<T: ComplexField>(a: &mut Matrix4<T>) {
                 for i in 0..4 {
                     if a[(i, i)].norm1() < na::convert(1.0e-7) {
-                        a[(i, i)] = N::one();
+                        a[(i, i)] = T::one();
                     }
                 }
             }
diff --git a/tests/proptest/mod.rs b/tests/proptest/mod.rs
index 174c0fdd..ec2e2c7b 100644
--- a/tests/proptest/mod.rs
+++ b/tests/proptest/mod.rs
@@ -7,8 +7,8 @@ use nalgebra::base::dimension::*;
 use nalgebra::proptest::{DimRange, MatrixStrategy};
 use nalgebra::{
     DMatrix, DVector, DefaultAllocator, Dim, DualQuaternion, Isometry2, Isometry3, Matrix3,
-    MatrixMN, Point2, Point3, Quaternion, Rotation2, Rotation3, Scalar, Similarity3, Translation2,
-    Translation3, UnitComplex, UnitDualQuaternion, UnitQuaternion, Vector3, U2, U3, U4, U7, U8,
+    OMatrix, Point2, Point3, Quaternion, Rotation2, Rotation3, Scalar, Similarity3, Translation2,
+    Translation3, UnitComplex, UnitDualQuaternion, UnitQuaternion, Vector3, U3, U4,
 };
 use num_complex::Complex;
 use proptest::prelude::*;
@@ -62,7 +62,7 @@ pub fn isometry3() -> impl Strategy<Value = Isometry3<f64>> {
 // }
 
 pub fn similarity3() -> impl Strategy<Value = Similarity3<f64>> {
-    vector(PROPTEST_F64, U7)
+    vector(PROPTEST_F64, Const::<7>)
         .prop_map(|v| Similarity3::new(v.xyz(), Vector3::new(v[3], v[4], v[5]), v[6]))
 }
 
@@ -71,7 +71,7 @@ pub fn unit_dual_quaternion() -> impl Strategy<Value = UnitDualQuaternion<f64>>
 }
 
 pub fn dual_quaternion() -> impl Strategy<Value = DualQuaternion<f64>> {
-    vector(PROPTEST_F64, U8).prop_map(|v| {
+    vector(PROPTEST_F64, Const::<8>).prop_map(|v| {
         DualQuaternion::from_real_and_dual(
             Quaternion::new(v[0], v[1], v[2], v[3]),
             Quaternion::new(v[4], v[5], v[6], v[7]),
@@ -88,7 +88,7 @@ pub fn unit_quaternion() -> impl Strategy<Value = UnitQuaternion<f64>> {
 }
 
 pub fn complex_f64() -> impl Strategy<Value = Complex<f64>> + Clone {
-    vector(PROPTEST_F64, U2).prop_map(|v| Complex::new(v.x, v.y))
+    vector(PROPTEST_F64, Const::<2>).prop_map(|v| Complex::new(v.x, v.y))
 }
 
 pub fn dmatrix() -> impl Strategy<Value = DMatrix<f64>> {
@@ -101,7 +101,7 @@ pub fn dvector() -> impl Strategy<Value = DVector<f64>> {
 
 pub fn dmatrix_<ScalarStrategy>(
     scalar_strategy: ScalarStrategy,
-) -> impl Strategy<Value = DMatrix<ScalarStrategy::Value>>
+) -> impl Strategy<Value = OMatrix<ScalarStrategy::Value, Dynamic, Dynamic>>
 where
     ScalarStrategy: Strategy + Clone + 'static,
     ScalarStrategy::Value: Scalar,
@@ -120,42 +120,41 @@ where
 // }
 
 macro_rules! define_strategies(
-    ($($strategy_: ident $strategy: ident<$nrows: ident, $ncols: ident>),*) => {$(
-        pub fn $strategy() -> impl Strategy<Value = MatrixMN<f64, $nrows, $ncols>> {
-            matrix(PROPTEST_F64, $nrows, $ncols)
+    ($($strategy_: ident $strategy: ident<$nrows: literal, $ncols: literal>),*) => {$(
+        pub fn $strategy() -> impl Strategy<Value = OMatrix<f64, Const<$nrows>, Const<$ncols>>> {
+            matrix(PROPTEST_F64, Const::<$nrows>, Const::<$ncols>)
         }
 
-        pub fn $strategy_<ScalarStrategy>(scalar_strategy: ScalarStrategy) -> impl Strategy<Value = MatrixMN<ScalarStrategy::Value, $nrows, $ncols>>
+        pub fn $strategy_<ScalarStrategy>(scalar_strategy: ScalarStrategy) -> impl Strategy<Value = OMatrix<ScalarStrategy::Value, Const<$nrows>, Const<$ncols>>>
             where
                 ScalarStrategy: Strategy + Clone + 'static,
-                ScalarStrategy::Value: Scalar,
-                DefaultAllocator: Allocator<ScalarStrategy::Value, $nrows, $ncols> {
-            matrix(scalar_strategy, $nrows, $ncols)
+                ScalarStrategy::Value: Scalar, {
+            matrix(scalar_strategy, Const::<$nrows>, Const::<$ncols>)
         }
     )*}
 );
 
 define_strategies!(
-    matrix1_ matrix1<U1, U1>,
-    matrix2_ matrix2<U2, U2>,
-    matrix3_ matrix3<U3, U3>,
-    matrix4_ matrix4<U4, U4>,
-    matrix5_ matrix5<U5, U5>,
-    matrix6_ matrix6<U6, U6>,
+    matrix1_ matrix1<1, 1>,
+    matrix2_ matrix2<2, 2>,
+    matrix3_ matrix3<3, 3>,
+    matrix4_ matrix4<4, 4>,
+    matrix5_ matrix5<5, 5>,
+    matrix6_ matrix6<6, 6>,
 
-    matrix5x2_ matrix5x2<U5, U2>,
-    matrix2x5_ matrix2x5<U2, U5>,
-    matrix5x3_ matrix5x3<U5, U3>,
-    matrix3x5_ matrix3x5<U3, U5>,
-    matrix5x4_ matrix5x4<U5, U4>,
-    matrix4x5_ matrix4x5<U4, U5>,
+    matrix5x2_ matrix5x2<5, 2>,
+    matrix2x5_ matrix2x5<2, 5>,
+    matrix5x3_ matrix5x3<5, 3>,
+    matrix3x5_ matrix3x5<3, 5>,
+    matrix5x4_ matrix5x4<5, 4>,
+    matrix4x5_ matrix4x5<4, 5>,
 
-    vector1_ vector1<U1, U1>,
-    vector2_ vector2<U2, U1>,
-    vector3_ vector3<U3, U1>,
-    vector4_ vector4<U4, U1>,
-    vector5_ vector5<U5, U1>,
-    vector6_ vector6<U6, U1>
+    vector1_ vector1<1, 1>,
+    vector2_ vector2<2, 1>,
+    vector3_ vector3<3, 1>,
+    vector4_ vector4<4, 1>,
+    vector5_ vector5<5, 1>,
+    vector6_ vector6<6, 1>
 );
 
 /// Generate a proptest that tests that all matrices generated with the
@@ -166,7 +165,7 @@ macro_rules! generate_matrix_sanity_test {
         proptest! {
             #[test]
             fn $test_name(a in matrix(-5 ..= 5i32, $rows, $cols)) {
-                // let a: MatrixMN<_, $rows, $cols> = a;
+                // let a: OMatrix<_, $rows, $cols> = a;
                 let rows_range = DimRange::from($rows);
                 let cols_range = DimRange::from($cols);
                 prop_assert!(a.nrows() >= rows_range.lower_bound().value()
@@ -180,16 +179,16 @@ macro_rules! generate_matrix_sanity_test {
 }
 
 // Test all fixed-size matrices with row/col dimensions up to 3
-generate_matrix_sanity_test!(test_matrix_u0_u0, U0, U0);
-generate_matrix_sanity_test!(test_matrix_u1_u0, U1, U0);
-generate_matrix_sanity_test!(test_matrix_u0_u1, U0, U1);
-generate_matrix_sanity_test!(test_matrix_u1_u1, U1, U1);
-generate_matrix_sanity_test!(test_matrix_u2_u1, U2, U1);
-generate_matrix_sanity_test!(test_matrix_u1_u2, U1, U2);
-generate_matrix_sanity_test!(test_matrix_u2_u2, U2, U2);
-generate_matrix_sanity_test!(test_matrix_u3_u2, U3, U2);
-generate_matrix_sanity_test!(test_matrix_u2_u3, U2, U3);
-generate_matrix_sanity_test!(test_matrix_u3_u3, U3, U3);
+generate_matrix_sanity_test!(test_matrix_u0_u0, Const::<0>, Const::<0>);
+generate_matrix_sanity_test!(test_matrix_u1_u0, Const::<1>, Const::<0>);
+generate_matrix_sanity_test!(test_matrix_u0_u1, Const::<0>, Const::<1>);
+generate_matrix_sanity_test!(test_matrix_u1_u1, Const::<1>, Const::<1>);
+generate_matrix_sanity_test!(test_matrix_u2_u1, Const::<2>, Const::<1>);
+generate_matrix_sanity_test!(test_matrix_u1_u2, Const::<1>, Const::<2>);
+generate_matrix_sanity_test!(test_matrix_u2_u2, Const::<2>, Const::<2>);
+generate_matrix_sanity_test!(test_matrix_u3_u2, Const::<3>, Const::<2>);
+generate_matrix_sanity_test!(test_matrix_u2_u3, Const::<2>, Const::<3>);
+generate_matrix_sanity_test!(test_matrix_u3_u3, Const::<3>, Const::<3>);
 
 // Similarly test all heap-allocated but fixed dim ranges
 generate_matrix_sanity_test!(test_matrix_0_0, 0, 0);
@@ -204,32 +203,32 @@ generate_matrix_sanity_test!(test_matrix_2_3, 2, 3);
 generate_matrix_sanity_test!(test_matrix_3_3, 3, 3);
 
 // Test arbitrary inputs
-generate_matrix_sanity_test!(test_matrix_input_1, U5, 1..=5);
+generate_matrix_sanity_test!(test_matrix_input_1, Const::<5>, 1..=5);
 generate_matrix_sanity_test!(test_matrix_input_2, 3..=4, 1..=5);
-generate_matrix_sanity_test!(test_matrix_input_3, 1..=2, U3);
-generate_matrix_sanity_test!(test_matrix_input_4, 3, U4);
+generate_matrix_sanity_test!(test_matrix_input_3, 1..=2, Const::<3>);
+generate_matrix_sanity_test!(test_matrix_input_4, 3, Const::<4>);
 
 #[test]
 fn test_matrix_output_types() {
     // Test that the dimension types are correct for the given inputs
-    let _: MatrixStrategy<_, U3, U4> = matrix(-5..5, U3, U4);
-    let _: MatrixStrategy<_, U3, U3> = matrix(-5..5, U3, U3);
-    let _: MatrixStrategy<_, U3, Dynamic> = matrix(-5..5, U3, 1..=5);
-    let _: MatrixStrategy<_, Dynamic, U3> = matrix(-5..5, 1..=5, U3);
+    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);
 }
 
-// Below we have some tests to ensure that specific instances of MatrixMN are usable
+// Below we have some tests to ensure that specific instances of OMatrix are usable
 // in a typical proptest scenario where we (implicitly) use the `Arbitrary` trait
 proptest! {
     #[test]
     fn ensure_arbitrary_test_compiles_matrix3(_: Matrix3<i32>) {}
 
     #[test]
-    fn ensure_arbitrary_test_compiles_matrixmn_u3_dynamic(_: MatrixMN<i32, U3, Dynamic>) {}
+    fn ensure_arbitrary_test_compiles_matrixmn_u3_dynamic(_: OMatrix<i32, U3, Dynamic>) {}
 
     #[test]
-    fn ensure_arbitrary_test_compiles_matrixmn_dynamic_u3(_: MatrixMN<i32, Dynamic, U3>) {}
+    fn ensure_arbitrary_test_compiles_matrixmn_dynamic_u3(_: OMatrix<i32, Dynamic, U3>) {}
 
     #[test]
     fn ensure_arbitrary_test_compiles_dmatrix(_: DMatrix<i32>) {}
diff --git a/tests/sparse/cs_matrix_market.rs b/tests/sparse/cs_matrix_market.rs
index 7c0cee43..9490464f 100644
--- a/tests/sparse/cs_matrix_market.rs
+++ b/tests/sparse/cs_matrix_market.rs
@@ -18,7 +18,7 @@ fn cs_matrix_market() {
 % |%                                             | <--+
 % |% comments                                    |    |-- 0 or more comment lines
 % |%                                             | <--+
-% |    M  N  L                                   | <--- rows, columns, entries
+% |    M  T  L                                   | <--- rows, columns, entries
 % |    I1  J1  A(I1, J1)                         | <--+
 % |    I2  J2  A(I2, J2)                         |    |
 % |    I3  J3  A(I3, J3)                         |    |-- L lines