Finishing up and starting lu decomp

test/test_inverse.cpp

@@ -0,0 +1,126 @@
+#include "test_common.h"
+#include "./utils/utils.h"
+#include "./numerics/inverse.h"
+#include "./numerics/matmul.h"
+
+
+TEST_CASE(Inverse_2x2_WellConditioned) {
+    using T = double;
+    // A = [[4,7],[2,6]]  inverse = (1/10) * [[6,-7],[-2,4]]
+    utils::Matrix<T> A(2,2, T{0});
+    A(0,0)=4; A(0,1)=7;
+    A(1,0)=2; A(1,1)=6;
+
+    auto Ainv = numerics::inverse<T>(A);  // out-of-place
+
+    // Check A * Ainv ≈ I and Ainv * A ≈ I
+    auto Ileft  = numerics::matmul(A, Ainv);
+    auto Iright = numerics::matmul(Ainv, A);
+
+    utils::Md Iref(2,2, T{0});
+    for (uint64_t i=0;i<Iref.rows();++i) Iref(i,i)=T{1};
+
+    //auto Iref   = eye<T>(2);
+
+    CHECK((Ileft.nearly_equal(Iref, 1e-12)), "A * inverse(A) ≠ I");
+    CHECK((Iright.nearly_equal(Iref, 1e-12)), "inverse(A) * A ≠ I");
+}
+
+TEST_CASE(Inverse_InPlace_Equals_OutOfPlace) {
+    using T = double;
+    utils::Matrix<T> A(3,3, T{0});
+    // A = [[3, 0, 2],
+    //      [2, 0, -2],
+    //      [0, 1, 1]]
+    A(0,0)=3; A(0,1)=0;  A(0,2)= 2;
+    A(1,0)=2; A(1,1)=0;  A(1,2)=-2;
+    A(2,0)=0; A(2,1)=1;  A(2,2)= 1;
+
+    auto Ainv_ref = numerics::inverse<T>(A);  // copy path
+
+    auto A_inp = A;
+    numerics::inplace_inverse<T>(A_inp);      // in-place path
+
+    CHECK((A_inp.nearly_equal(Ainv_ref, 1e-12)), "in-place inverse differs from out-of-place");
+}
+
+TEST_CASE(Inverse_Singular_Throws) {
+    using T = double;
+    utils::Matrix<T> S(2,2, T{0});
+    // Singular: rows are multiples → det = 0
+    S(0,0)=1; S(0,1)=2;
+    S(1,0)=2; S(1,1)=4;
+
+    bool threw=false;
+    try {
+        auto _ = numerics::inverse<T>(S);
+        (void)_;
+    } catch (const std::runtime_error&) { threw = true; }
+    CHECK(threw, "inverse should throw on singular matrix");
+
+    threw=false;
+    try {
+        numerics::inplace_inverse<T>(S);
+    } catch (const std::runtime_error&) { threw = true; }
+    CHECK(threw, "inplace_inverse should throw on singular matrix");
+}
+
+TEST_CASE(Inverse_RoundTrip_DiagonallyDominant_5x5) {
+    // Build a well-conditioned 5x5: diagonally dominant
+    utils::Md A(5,5,0.0);
+    for (uint64_t i=0;i<5;++i) {
+        double rowsum = 0.0;
+        for (uint64_t j=0;j<5;++j) {
+            if (i==j) continue;
+            A(i,j) = 0.01 * double(1 + ((i+1)*(j+3)) % 7);
+            rowsum += std::fabs(A(i,j));
+        }
+        A(i,i) = rowsum + 1.0; // strictly diagonally dominant
+    }
+
+    utils::Md A_copy = A; // ensure wrapper doesn't mutate input
+    utils::Md Ainv = numerics::inverse<double>(A);
+
+    // Input must be unchanged by the non-inplace wrapper
+    CHECK(A.nearly_equal(A_copy, 0.0), "inverse wrapper modified input");
+
+
+    utils::Md I(5,5, 0);
+    for (uint64_t i=0;i<I.rows();++i) I(i,i)=1;
+
+
+    auto L  = numerics::matmul<double>(A, Ainv);
+    auto R  = numerics::matmul<double>(Ainv, A);
+
+    CHECK(L.nearly_equal(I, 1e-10), "A * Ainv not close to I");
+    CHECK(R.nearly_equal(I, 1e-10), "Ainv * A not close to I");
+}
+
+TEST_CASE(Inverse_NonSquare_Throws) {
+    // Non-square: 2x3 — algorithm expects square; should throw
+    utils::Md A(2,3,0.0);
+    bool threw = false;
+    try {
+        numerics::inplace_inverse<double>(A);
+    } catch (const std::runtime_error&) {
+        threw = true;
+    } catch (...) {
+        threw = true; // any failure is fine; must not silently succeed
+    }
+    CHECK(threw, "inplace_inverse should throw on non-square matrix");
+}
+
+
+TEST_CASE(Inverse_Unknown_Method_Throws) {
+
+    utils::Md A(3,3, 0);
+    for (uint64_t i=0;i<A.rows();++i) A(i,i)=1;
+
+    bool threw = false;
+    try {
+        numerics::inplace_inverse<double>(A, "NotARealMethod");
+    } catch (const std::runtime_error&) {
+        threw = true;
+    }
+    CHECK(threw, "should throw for unknown inverse method");
+}