Integrate min-const-generics.

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 }

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>

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)
                 }
             }));
         }

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));
         })
     });
 }

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))
     });

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;

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())))
     });
 }
 

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())))
     });
 }
 

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()))
     });
 }
 

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())))
     });
 }
 

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,15 +99,17 @@ 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()))
     });
 }
 
 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!(