LU and LU inverse is done
This commit is contained in:
+95
-106
@@ -4,123 +4,112 @@
|
||||
#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) {
|
||||
TEST_CASE(Inverse_GJ_Basic_3x3) {
|
||||
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;
|
||||
// Well-conditioned 3x3
|
||||
A(0,0)=3; A(0,1)=0.2; A(0,2)=-0.1;
|
||||
A(1,0)=0.1; A(1,1)=2.5; A(1,2)=0.3;
|
||||
A(2,0)=-0.2;A(2,1)=0.4; A(2,2)=2.0;
|
||||
|
||||
auto Ainv_ref = numerics::inverse<T>(A); // copy path
|
||||
auto Ainv = numerics::inverse<T>(A, "Gauss-Jordan");
|
||||
utils::Matrix<T> I;
|
||||
I.eye(3);
|
||||
auto prod = numerics::matmul<T>(A, Ainv);
|
||||
|
||||
auto A_inp = A;
|
||||
numerics::inplace_inverse<T>(A_inp); // in-place path
|
||||
CHECK(prod.nearly_equal(I, (T)1e-10), "inverse(GJ): A*A^{-1} ≈ I");
|
||||
}
|
||||
|
||||
CHECK((A_inp.nearly_equal(Ainv_ref, 1e-12)), "in-place inverse differs from out-of-place");
|
||||
TEST_CASE(Inverse_LU_Basic_3x3) {
|
||||
using T = double;
|
||||
utils::Matrix<T> A(3,3, T{0});
|
||||
A(0,0)=3; A(0,1)=0.2; A(0,2)=-0.1;
|
||||
A(1,0)=0.1; A(1,1)=2.5; A(1,2)=0.3;
|
||||
A(2,0)=-0.2;A(2,1)=0.4; A(2,2)=2.0;
|
||||
|
||||
auto Ainv = numerics::inverse<T>(A, "LU");
|
||||
utils::Matrix<T> I;
|
||||
I.eye(3);
|
||||
auto prod = numerics::matmul<T>(A, Ainv);
|
||||
|
||||
CHECK(prod.nearly_equal(I, (T)1e-10), "inverse(LU): A*A^{-1} ≈ I");
|
||||
}
|
||||
|
||||
TEST_CASE(Inverse_GJ_vs_LU_Consistency) {
|
||||
using T = double;
|
||||
utils::Matrix<T> A(3,3, T{0});
|
||||
A(0,0)=4; A(0,1)=1; A(0,2)=2;
|
||||
A(1,0)=0; A(1,1)=3; A(1,2)=-1;
|
||||
A(2,0)=0; A(2,1)=0; A(2,2)=2;
|
||||
|
||||
auto GJ = numerics::inverse<T>(A, "Gauss-Jordan");
|
||||
auto LU = numerics::inverse<T>(A, "LU");
|
||||
|
||||
CHECK(GJ.nearly_equal(LU, (T)1e-12), "inverse: GJ and LU produce nearly the same result");
|
||||
}
|
||||
|
||||
|
||||
TEST_CASE(Inplace_Inverse_LU) {
|
||||
using T = double;
|
||||
utils::Matrix<T> A(3,3, T{0});
|
||||
A(0,0)=3; A(0,1)=0.2; A(0,2)=-0.1;
|
||||
A(1,0)=0.1; A(1,1)=2.5; A(1,2)=0.3;
|
||||
A(2,0)=-0.2;A(2,1)=0.4; A(2,2)=2.0;
|
||||
|
||||
auto Ainv_ref = numerics::inverse<T>(A, "LU"); // out-of-place
|
||||
auto A_copy = A;
|
||||
numerics::inplace_inverse<T>(A_copy, "LU"); // in-place
|
||||
|
||||
CHECK(A_copy.nearly_equal(Ainv_ref, (T)1e-12), "inplace_inverse(LU) equals out-of-place");
|
||||
}
|
||||
|
||||
TEST_CASE(Inplace_Inverse_GJ) {
|
||||
using T = double;
|
||||
utils::Matrix<T> A(2,2, T{0});
|
||||
A(0,0)=2; A(0,1)=1;
|
||||
A(1,0)=1; A(1,1)=3;
|
||||
|
||||
auto Ainv_ref = numerics::inverse<T>(A, "Gauss-Jordan");
|
||||
auto A_copy = A;
|
||||
numerics::inplace_inverse<T>(A_copy, "Gauss-Jordan");
|
||||
|
||||
CHECK(A_copy.nearly_equal(Ainv_ref, (T)1e-12), "inplace_inverse(GJ) equals out-of-place");
|
||||
}
|
||||
|
||||
TEST_CASE(Inverse_Identity) {
|
||||
using T = double;
|
||||
utils::Matrix<T> I;
|
||||
I.eye(3);
|
||||
auto invI = numerics::inverse<T>(I, "LU");
|
||||
CHECK(invI.nearly_equal(I, (T)0), "inverse(I) == I");
|
||||
}
|
||||
TEST_CASE(Inverse_NonSquare_Throws) {
|
||||
using T = double;
|
||||
utils::Matrix<T> A(2,3, T{0}); // non-square
|
||||
bool threw1=false, threw2=false;
|
||||
try { auto X = numerics::inverse<T>(A, "LU"); (void)X; } catch(...) { threw1=true; }
|
||||
try { numerics::inplace_inverse<T>(A, "Gauss-Jordan"); } catch(...) { threw2=true; }
|
||||
CHECK(threw1 && threw2, "inverse throws on non-square for both methods");
|
||||
}
|
||||
|
||||
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;
|
||||
utils::Matrix<T> S(3,3, T{0});
|
||||
S(0,0)=1; S(0,1)=2; S(0,2)=3;
|
||||
S(1,0)=1; S(1,1)=2; S(1,2)=3; // duplicate row -> singular
|
||||
S(2,0)=0; S(2,1)=1; S(2,2)=0;
|
||||
|
||||
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");
|
||||
bool threw_gj=false, threw_lu=false;
|
||||
try { auto X = numerics::inverse<T>(S, "Gauss-Jordan"); (void)X; } catch(...) { threw_gj=true; }
|
||||
try { auto X = numerics::inverse<T>(S, "LU"); (void)X; } catch(...) { threw_lu=true; }
|
||||
CHECK(threw_gj && threw_lu, "inverse throws on singular for both methods");
|
||||
}
|
||||
|
||||
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");
|
||||
using T = double;
|
||||
utils::Matrix<T> A(2,2, T{0});
|
||||
A(0,0)=1; A(1,1)=1;
|
||||
bool threw=false;
|
||||
try { auto X = numerics::inverse<T>(A, "Foobar"); (void)X; } catch(...) { threw=true; }
|
||||
CHECK(threw, "inverse unknown method throws");
|
||||
}
|
||||
Reference in New Issue
Block a user