Added: regression tests for solver and determinant overflow handling

Add test cases to verify that LDLT and LU solvers, as well as determinant
calculations, correctly detect and return `LaError::NonFinite` when
intermediate calculations overflow to infinity despite having finite
inputs.

Refs: #67

Author: acgetchell

src/ldlt.rs

@@ -418,4 +418,19 @@ mod tests {
         let err = ldlt.solve_vec(b).unwrap_err();
         assert_eq!(err, LaError::NonFinite { row: None, col: 1 });
     }
+
+    #[test]
+    fn nonfinite_solve_vec_diagonal_solve_overflow() {
+        // Diagonal SPD matrix with a tiny diagonal entry just above the
+        // singularity tolerance.  Forward substitution passes through the
+        // large RHS unchanged, then the diagonal solve z[1] = y[1] / D[1]
+        // = 1e300 / 1e-11 = 1e311 overflows f64, exercising the
+        // `!v.is_finite()` branch of the diagonal solve.
+        let a = Matrix::<2>::from_rows([[1.0, 0.0], [0.0, 1.0e-11]]);
+        let ldlt = a.ldlt(DEFAULT_SINGULAR_TOL).unwrap();
+
+        let b = Vector::<2>::new([0.0, 1.0e300]);
+        let err = ldlt.solve_vec(b).unwrap_err();
+        assert_eq!(err, LaError::NonFinite { row: None, col: 1 });
+    }
 }

src/lu.rs

@@ -485,4 +485,20 @@ mod tests {
         let err = lu.solve_vec(b).unwrap_err();
         assert_eq!(err, LaError::NonFinite { row: None, col: 1 });
     }
+
+    #[test]
+    fn solve_vec_nonfinite_back_substitution_sum_overflow() {
+        // Upper-triangular U with a very large off-diagonal in row 1 and a
+        // very large x[2] produced by the RHS.  The back-substitution
+        // accumulator `sum = (-row[j]).mul_add(x[j], sum)` overflows while
+        // reducing row 1, so the failure is detected via the `!sum.is_finite()`
+        // branch of the combined diag/sum check (distinct from the
+        // `q = sum / diag` overflow path covered above).
+        let a = Matrix::<3>::from_rows([[1.0, 0.0, 0.0], [0.0, 1.0, 1.0e200], [0.0, 0.0, 1.0]]);
+        let lu = a.lu(DEFAULT_PIVOT_TOL).unwrap();
+
+        let b = Vector::<3>::new([0.0, 0.0, 1.0e200]);
+        let err = lu.solve_vec(b).unwrap_err();
+        assert_eq!(err, LaError::NonFinite { row: None, col: 1 });
+    }
 }

src/matrix.rs

@@ -710,6 +710,19 @@ mod tests {
         );
     }
 
+    #[test]
+    fn det_returns_nonfinite_error_for_overflow_with_finite_entries() {
+        // det_direct produces an overflowing f64 (1e300 * 1e300 = ∞) even
+        // though every matrix entry is finite.  The entry scan in `det`
+        // falls through and returns NonFinite { row: None, col: 0 } to signal
+        // a computed overflow rather than a NaN/∞ input.
+        let m = Matrix::<2>::from_rows([[1e300, 0.0], [0.0, 1e300]]);
+        assert_eq!(
+            m.det(DEFAULT_PIVOT_TOL),
+            Err(LaError::NonFinite { row: None, col: 0 })
+        );
+    }
+
     #[test]
     fn det_direct_is_const_evaluable_d2() {
         // Const evaluation proves the function is truly const fn.