From 4602b36e9d5ea08656e3222846a1f161bbb1cec1 Mon Sep 17 00:00:00 2001
From: y-jan137 <yousefjan24000@gmail.com>
Date: Mon, 27 Apr 2026 07:24:41 +0300
Subject: Module refactor

---
 tests/test_triangular_solve.cpp | 31 ++++++++++++++-----------------
 1 file changed, 14 insertions(+), 17 deletions(-)

(limited to 'tests/test_triangular_solve.cpp')

diff --git a/tests/test_triangular_solve.cpp b/tests/test_triangular_solve.cpp
index da7e55c..f1ce709 100644
--- a/tests/test_triangular_solve.cpp
+++ b/tests/test_triangular_solve.cpp
@@ -1,20 +1,17 @@
-#include "linalg_error.hpp"
-#include "matrix.hpp"
-#include "norms.hpp"
-#include "triangular_solve.hpp"
+import linalgebra;
 
 #include <catch2/catch_approx.hpp>
 #include <catch2/catch_test_macros.hpp>
 
-using linalg::DimensionMismatchError;
-using linalg::Matrix;
-using linalg::SingularMatrixError;
-using linalg::Vector;
+using linalgebra::DimensionMismatchError;
+using linalgebra::Matrix;
+using linalgebra::SingularMatrixError;
+using linalgebra::Vector;
 
 namespace {
 
 double residual_norm(const Matrix& a, const Vector& x, const Vector& b) {
-    return linalg::norm2((a * x) - b);
+    return linalgebra::norm2((a * x) - b);
 }
 
 }  // namespace
@@ -28,7 +25,7 @@ TEST_CASE("Forward substitution solves lower-triangular systems", "[triangular]"
     const Vector expected{1.0, 2.0, -1.0};
     const Vector rhs = lower * expected;
 
-    const Vector x = linalg::forward_substitution(lower, rhs);
+    const Vector x = linalgebra::forward_substitution(lower, rhs);
     REQUIRE(x.size() == expected.size());
     CHECK(x[0] == Catch::Approx(expected[0]));
     CHECK(x[1] == Catch::Approx(expected[1]));
@@ -45,7 +42,7 @@ TEST_CASE("Backward substitution solves upper-triangular systems", "[triangular]
     const Vector expected{2.0, -1.0, 3.0};
     const Vector rhs = upper * expected;
 
-    const Vector x = linalg::backward_substitution(upper, rhs);
+    const Vector x = linalgebra::backward_substitution(upper, rhs);
     REQUIRE(x.size() == expected.size());
     CHECK(x[0] == Catch::Approx(expected[0]));
     CHECK(x[1] == Catch::Approx(expected[1]));
@@ -61,7 +58,7 @@ TEST_CASE("Triangular solves support unit-diagonal systems", "[triangular]") {
     };
     const Vector rhs{1.0, 0.0, 4.0};
 
-    const Vector x = linalg::forward_substitution(lower, rhs, 1e-12, true);
+    const Vector x = linalgebra::forward_substitution(lower, rhs, 1e-12, true);
     CHECK(x[0] == Catch::Approx(1.0));
     CHECK(x[1] == Catch::Approx(2.0));
     CHECK(x[2] == Catch::Approx(3.0));
@@ -70,19 +67,19 @@ TEST_CASE("Triangular solves support unit-diagonal systems", "[triangular]") {
 TEST_CASE("Triangular solves reject shape and structure mismatches", "[triangular]") {
     const Matrix nonsquare(2, 3);
     const Vector rhs2{1.0, 2.0};
-    CHECK_THROWS_AS(linalg::forward_substitution(nonsquare, rhs2), DimensionMismatchError);
+    CHECK_THROWS_AS(linalgebra::forward_substitution(nonsquare, rhs2), DimensionMismatchError);
 
     const Matrix lower{
         {1.0, 1.0},
         {2.0, 3.0}
     };
-    CHECK_THROWS_AS(linalg::forward_substitution(lower, rhs2), std::invalid_argument);
+    CHECK_THROWS_AS(linalgebra::forward_substitution(lower, rhs2), std::invalid_argument);
 
     const Matrix upper{
         {1.0, 2.0},
         {1.0, 3.0}
     };
-    CHECK_THROWS_AS(linalg::backward_substitution(upper, rhs2), std::invalid_argument);
+    CHECK_THROWS_AS(linalgebra::backward_substitution(upper, rhs2), std::invalid_argument);
 }
 
 TEST_CASE("Triangular solves detect negligible diagonal entries", "[triangular]") {
@@ -91,11 +88,11 @@ TEST_CASE("Triangular solves detect negligible diagonal entries", "[triangular]"
         {2.0, 1.0}
     };
     const Vector rhs{1.0, 2.0};
-    CHECK_THROWS_AS(linalg::forward_substitution(lower, rhs), SingularMatrixError);
+    CHECK_THROWS_AS(linalgebra::forward_substitution(lower, rhs), SingularMatrixError);
 
     const Matrix upper{
         {1.0, 2.0},
         {0.0, 1e-14}
     };
-    CHECK_THROWS_AS(linalg::backward_substitution(upper, rhs), SingularMatrixError);
+    CHECK_THROWS_AS(linalgebra::backward_substitution(upper, rhs), SingularMatrixError);
 }
-- 
cgit v1.2.3