Changed: consolidate and expand const-evaluability tests via macros

Refactor manual const-evaluation tests in `Ldlt` and `Matrix` into macros
to standardize coverage across matrix dimensions 2 through 5. This
ensures all determinant and norm variants are fully exercised at compile
time.

Refs: #86

Author: acgetchell

src/ldlt.rs

@@ -558,54 +558,63 @@ mod tests {
     // some toolchains; we therefore construct `Ldlt<D>` directly.
     // -----------------------------------------------------------------------
 
-    #[test]
-    fn ldlt_det_const_eval_d2() {
-        const DET: f64 = {
-            // Diagonal D = [4.0, 0.25] ⇒ det = 1.0.
-            let mut factors = Matrix::<2>::identity();
-            factors.rows[0][0] = 4.0;
-            factors.rows[1][1] = 0.25;
-            let ldlt = Ldlt::<2> {
-                factors,
-                tol: DEFAULT_SINGULAR_TOL,
-            };
-            ldlt.det()
-        };
-        assert!((DET - 1.0).abs() <= 1e-12);
-    }
-
-    #[test]
-    fn ldlt_det_const_eval_d3() {
-        const DET: f64 = {
-            // Diagonal D = [2.0, 3.0, 5.0] ⇒ det = 30.0.
-            let mut factors = Matrix::<3>::identity();
-            factors.rows[0][0] = 2.0;
-            factors.rows[1][1] = 3.0;
-            factors.rows[2][2] = 5.0;
-            let ldlt = Ldlt::<3> {
-                factors,
-                tol: DEFAULT_SINGULAR_TOL,
-            };
-            ldlt.det()
-        };
-        assert!((DET - 30.0).abs() <= 1e-12);
-    }
+    macro_rules! gen_ldlt_const_eval_tests {
+        ($d:literal) => {
+            paste! {
+                /// `Ldlt::det` must be fully const-evaluable. Setting
+                /// `factors[0][0] = 2.0` and leaving the remaining identity
+                /// diagonals at `1.0` gives `det = 2.0` for every `D ≥ 1`,
+                /// exercising the multiply-accumulate loop at each dimension.
+                #[test]
+                fn [<ldlt_det_const_eval_ $d d>]() {
+                    const DET: f64 = {
+                        let mut factors = Matrix::<$d>::identity();
+                        factors.rows[0][0] = 2.0;
+                        let ldlt = Ldlt::<$d> {
+                            factors,
+                            tol: DEFAULT_SINGULAR_TOL,
+                        };
+                        ldlt.det()
+                    };
+                    assert!((DET - 2.0).abs() <= 1e-12);
+                }
 
-    #[test]
-    fn ldlt_solve_vec_const_eval_d2() {
-        // Identity factors ⇒ solve_vec returns the RHS untouched.
-        const X: [f64; 2] = {
-            let ldlt = Ldlt::<2> {
-                factors: Matrix::<2>::identity(),
-                tol: DEFAULT_SINGULAR_TOL,
-            };
-            let b = Vector::<2>::new([1.0, 2.0]);
-            match ldlt.solve_vec(b) {
-                Ok(v) => v.into_array(),
-                Err(_) => [0.0, 0.0],
+                /// `Ldlt::solve_vec` must be fully const-evaluable. Identity
+                /// factors with RHS `b = [1.0, 2.0, …, D]` round-trips `b`
+                /// unchanged, exercising the full forward sub / diagonal solve
+                /// / back sub pipeline inside a `const { … }` initializer.
+                #[test]
+                fn [<ldlt_solve_vec_const_eval_ $d d>]() {
+                    #[allow(clippy::cast_precision_loss)]
+                    const X: [f64; $d] = {
+                        let ldlt = Ldlt::<$d> {
+                            factors: Matrix::<$d>::identity(),
+                            tol: DEFAULT_SINGULAR_TOL,
+                        };
+                        let mut b_arr = [0.0f64; $d];
+                        let mut i = 0;
+                        while i < $d {
+                            b_arr[i] = i as f64 + 1.0;
+                            i += 1;
+                        }
+                        let b = Vector::<$d>::new(b_arr);
+                        match ldlt.solve_vec(b) {
+                            Ok(v) => v.into_array(),
+                            Err(_) => [0.0f64; $d],
+                        }
+                    };
+                    #[allow(clippy::cast_precision_loss)]
+                    for i in 0..$d {
+                        let expected = i as f64 + 1.0;
+                        assert!((X[i] - expected).abs() <= 1e-12);
+                    }
+                }
             }
         };
-        assert!((X[0] - 1.0).abs() <= 1e-12);
-        assert!((X[1] - 2.0).abs() <= 1e-12);
     }
+
+    gen_ldlt_const_eval_tests!(2);
+    gen_ldlt_const_eval_tests!(3);
+    gen_ldlt_const_eval_tests!(4);
+    gen_ldlt_const_eval_tests!(5);
 }

src/matrix.rs

@@ -873,23 +873,36 @@ mod tests {
         );
     }
 
-    #[test]
-    fn det_direct_const_eval_d2() {
-        // Const evaluation proves the function is truly const fn.
-        const DET: Option<f64> = {
-            let m = Matrix::<2>::from_rows([[1.0, 0.0], [0.0, 1.0]]);
-            m.det_direct()
+    // === det_direct const-evaluability tests (D = 2..=5) ===
+    //
+    // Every dimension hits a distinct arm of the `match D { … }` body inside
+    // `det_direct`, so exercising each at compile time is the tightest
+    // const-fn proof available.
+
+    macro_rules! gen_det_direct_const_eval_tests {
+        ($d:literal) => {
+            paste! {
+                /// `Matrix::<D>::det_direct()` on the identity must const-evaluate
+                /// to `Some(1.0)` for every closed-form dimension `D ∈ {1, 2, 3, 4}`.
+                #[test]
+                fn [<det_direct_const_eval_ $d d>]() {
+                    const DET: Option<f64> = Matrix::<$d>::identity().det_direct();
+                    assert_eq!(DET, Some(1.0));
+                }
+            }
         };
-        assert_eq!(DET, Some(1.0));
     }
 
+    gen_det_direct_const_eval_tests!(2);
+    gen_det_direct_const_eval_tests!(3);
+    gen_det_direct_const_eval_tests!(4);
+
     #[test]
-    fn det_direct_const_eval_d3() {
-        const DET: Option<f64> = {
-            let m = Matrix::<3>::from_rows([[2.0, 0.0, 0.0], [0.0, 3.0, 0.0], [0.0, 0.0, 5.0]]);
-            m.det_direct()
-        };
-        assert_eq!(DET, Some(30.0));
+    fn det_direct_const_eval_d5_is_none() {
+        // D ≥ 5 has no closed-form arm; `det_direct` returns `None`.  Verify
+        // that the wildcard arm is reachable in a `const { … }` context.
+        const DET: Option<f64> = Matrix::<5>::identity().det_direct();
+        assert_eq!(DET, None);
     }
 
     // === det_errbound tests (no `exact` feature required) ===
@@ -909,46 +922,58 @@ mod tests {
         assert_eq!(Matrix::<5>::identity().det_errbound(), None);
     }
 
-    #[test]
-    fn det_errbound_const_eval_d2() {
-        // Const evaluation proves the function is truly const fn.
-        const BOUND: Option<f64> = {
-            let m = Matrix::<2>::from_rows([[1.0, 2.0], [3.0, 4.0]]);
-            m.det_errbound()
-        };
-        assert!(BOUND.is_some());
-        assert!(BOUND.unwrap() > 0.0);
-    }
+    // === det_errbound const-evaluability tests (D = 2..=5) ===
 
-    #[test]
-    fn det_errbound_const_eval_d3() {
-        const BOUND: Option<f64> = {
-            let m = Matrix::<3>::from_rows([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]]);
-            m.det_errbound()
+    macro_rules! gen_det_errbound_const_eval_tests {
+        ($d:literal) => {
+            paste! {
+                /// `Matrix::<D>::det_errbound()` on the identity must const-evaluate
+                /// to `Some(bound)` with `bound > 0` for every closed-form dimension
+                /// `D ∈ {2, 3, 4}`.  Each dimension hits a distinct arm of
+                /// `det_errbound` with a dimension-specific permanent computation.
+                #[test]
+                fn [<det_errbound_const_eval_ $d d>]() {
+                    const BOUND: Option<f64> = Matrix::<$d>::identity().det_errbound();
+                    assert!(BOUND.is_some());
+                    assert!(BOUND.unwrap() > 0.0);
+                }
+            }
         };
-        assert!(BOUND.is_some());
-        assert!(BOUND.unwrap() > 0.0);
     }
 
+    gen_det_errbound_const_eval_tests!(2);
+    gen_det_errbound_const_eval_tests!(3);
+    gen_det_errbound_const_eval_tests!(4);
+
     #[test]
-    fn inf_norm_const_eval_d2() {
-        // Maximum absolute row sum: row 0 = 3, row 1 = 7 ⇒ 7.
-        const NORM: f64 = {
-            let m = Matrix::<2>::from_rows([[1.0, -2.0], [3.0, 4.0]]);
-            m.inf_norm()
-        };
-        assert!((NORM - 7.0).abs() <= 1e-12);
+    fn det_errbound_const_eval_d5_is_none() {
+        // D ≥ 5 has no fast-filter bound; `det_errbound` returns `None`.
+        const BOUND: Option<f64> = Matrix::<5>::identity().det_errbound();
+        assert_eq!(BOUND, None);
     }
 
-    #[test]
-    fn inf_norm_const_eval_d3() {
-        const NORM: f64 = {
-            let m = Matrix::<3>::identity();
-            m.inf_norm()
+    // === inf_norm const-evaluability tests (D = 2..=5) ===
+
+    macro_rules! gen_inf_norm_const_eval_tests {
+        ($d:literal) => {
+            paste! {
+                /// `Matrix::<D>::inf_norm()` on the identity must const-evaluate
+                /// to `1.0` for every `D ≥ 1` — each row has a single `1.0`
+                /// entry, so the max absolute row sum is exactly `1.0`.
+                #[test]
+                fn [<inf_norm_const_eval_ $d d>]() {
+                    const NORM: f64 = Matrix::<$d>::identity().inf_norm();
+                    assert!((NORM - 1.0).abs() <= 1e-12);
+                }
+            }
         };
-        assert!((NORM - 1.0).abs() <= 1e-12);
     }
 
+    gen_inf_norm_const_eval_tests!(2);
+    gen_inf_norm_const_eval_tests!(3);
+    gen_inf_norm_const_eval_tests!(4);
+    gen_inf_norm_const_eval_tests!(5);
+
     // === inf_norm NaN / Inf propagation (regression tests for #85) ===
 
     macro_rules! gen_inf_norm_nonfinite_tests {