Move tests to seperate repo.

Author: water-chika

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "linear_algebra"]
+	path = linear_algebra
+	url = https://github.com/water-chika/linear_algebra

CMakeLists.txt

@@ -0,0 +1,14 @@
+cmake_minimum_required(VERSION 3.20)
+
+project(linear_algebra_test)
+
+add_subdirectory(linear_algebra)
+
+add_executable(linear_algebra_test
+    linear_algebra_test.cpp
+    matrix_test.hpp
+    vector_test.hpp
+)
+
+set_target_properties(linear_algebra_test PROPERTIES CXX_STANDARD 23)
+target_link_libraries(linear_algebra_test linear_algebra)

linear_algebra

@@ -0,0 +1,8 @@
+#include "matrix_test.hpp"
+#include "vector_test.hpp"
+
+int main() {
+    std::cout << "test gram schmidt: " << (test_gram_schmidt()?"PASSED":"FAILED") << std::endl;
+    test_vector();
+    return 0;
+}

linear_algebra_test.cpp

@@ -0,0 +1,102 @@
+#pragma once
+
+#include <matrix.hpp>
+#include <vector.hpp>
+#include <fixsized_matrix.hpp>
+
+#include "matrix.hpp"
+#include "combined_reference_matrix.hpp"
+#include <iostream>
+#include <concepts>
+
+bool test_gram_schmidt() {
+    auto A = linear_algebra::matrix<float, 3, 3>{
+        {1, 2, 3},
+        {-1, 0, -3},
+        {0, -2, 3}
+    };
+    auto B = linear_algebra::matrix<float, 3, 3>{
+        {       1,       1,       1,},
+        {      -1,       1,       1,},
+        {       0,      -2,       1,},
+    };
+    return B == gram_schmidt(A);
+}
+
+namespace water {
+    namespace concept_helper {
+        template<class T>
+        concept number = std::integral<T> || std::floating_point<T>;
+    }
+}
+
+class linear_algebra_test {
+public:
+    template<water::concept_helper::number Number>
+    class set_number {
+    public:
+        template<std::integral Integral>
+        class set_index {
+        public:
+            static void run() {
+                linear_algebra::fixsized_vector<Number, 2> v{ 4.0f, 1.0f }, u{ 2.0f, -1.0f };
+                auto combination = Number{ 2.0 } *v + Number{ -3.0f }*u;
+                std::cout << combination << std::endl;
+                std::cout << dot_product(Number{ 0.5f } *v * Number{ 2.0f }, Number{ 2.0f } *u * Number{ 0.5f }) << std::endl;
+                linear_algebra::matrix<Number, 2, 2> A{ linear_algebra::column_vector{v}, linear_algebra::column_vector{u} };
+                std::cout << "A is below: " << A << std::endl;
+                std::cout << A.column(0) << std::endl;
+                std::cout << A.column(1) << std::endl;
+                std::cout << A.row(0) << std::endl;
+                std::cout << A.row(1) << std::endl;
+                A.row(1) -= A.row(0) * 2;
+                std::cout << "After subtract 2 * row 0 from row 1, A is below: " << A << std::endl;
+                
+                auto U = linear_algebra::eliminate(A);
+                std::cout << "The elimination U of A is below: " << U << std::endl;
+
+                {
+                    using namespace linear_algebra;
+                    auto A_I = make_matrix_with_columns<double, 3, 6>({fixsized_vector<double, 3>{2,1,1}, fixsized_vector<double, 3>{1,2,1}, fixsized_vector<double, 3>{1,1,2},
+                        fixsized_vector<double, 3>{1,0,0}, fixsized_vector<double, 3>{0,1,0}, fixsized_vector<double, 3>{0,0,1}});
+                    std::cout << "set A_I = " << A_I << std::endl;
+                    auto res = eliminate(A_I);
+                    std::cout << "after eliminate, it =" << res << std::endl;
+                    res = back_substitution(res);
+                    std::cout << "after back substitution, it =" << res << std::endl;
+                }
+                {
+                    auto A = linear_algebra::matrix<int, 3, 3>{
+                        {1, 0, 1},
+                        {2, 3, 0},
+                        {5, 4, 7}
+                    };
+                    std::cout << "test initializer, A = " << A << std::endl;
+                }
+                try{
+                    using namespace linear_algebra;
+                    std::cout << "This is chapter 2, exercise 31." << std::endl;
+                    auto A = matrix<Number, 3, 3>{
+                        {2, 1, 1},
+                        {1, 2, 1},
+                        {1, 1, 2}
+                    };
+                    std::cout << "A = " << A << std::endl;
+                    std::cout << "A inverse = " << inverse(A) << std::endl;
+                    auto B = matrix<Number, 3, 3>{
+                        {2, -1, -1},
+                        {-1, 2, -1},
+                        {-1, -1, 2}
+                    };
+                    std::cout << "B = " << B << std::endl;
+                    auto B_I = concatenate_columns(B, identity_matrix<Number, 3>());
+                    std::cout << "B inverse = " <<
+                        select_columns<3, 4, 5>(back_substitution(eliminate(B_I))) << std::endl;
+                }
+                catch (std::exception& e) {
+                    std::cout << e.what() << std::endl;
+                }
+            }
+        };
+    };
+};

matrix_test.hpp

@@ -0,0 +1,68 @@
+#pragma once
+#include <vector.hpp>
+#include <fixsized_vector.hpp>
+#include <vector>
+#include <functional>
+
+bool test0() {
+    linear_algebra::fixsized_vector<float, 2> a{1.0f, 0.0f};
+    a *= 2.0f;
+    return a == linear_algebra::fixsized_vector<float, 2>{2.0f, 0.0f};
+}
+
+bool test1() {
+    linear_algebra::fixsized_vector<double, 3> a{ 0.5, 0.5, 0.5 };
+    return 0.75 == dot_product(a, a);
+}
+
+bool test_add() {
+    linear_algebra::fixsized_vector<double, 2> a{ 0.5, -0.5 };
+    linear_algebra::fixsized_vector<double, 2> b{ -1.0, 1.5 };
+    return a + b == linear_algebra::fixsized_vector<double, 2>{-0.5, 1.0};
+}
+bool test_sub() {
+    linear_algebra::fixsized_vector<double, 2> a{ 0.5, -0.5 };
+    linear_algebra::fixsized_vector<double, 2> b{ -1.0, 1.5 };
+    return a - b == linear_algebra::fixsized_vector<double, 2>{1.5, -2.0};
+}
+bool test_element_multi() {
+    linear_algebra::fixsized_vector<double, 2> a{ 0.5, -0.5 };
+    linear_algebra::fixsized_vector<double, 2> b{ -1.0, 1.5 };
+    return element_multi(a, b) == linear_algebra::fixsized_vector<double, 2>{-0.5, -0.5*1.5};
+}
+bool test_ranged_for() {
+    linear_algebra::fixsized_vector<double, 128> a{};
+    for (auto& e : a) {
+        e = 1.0;
+    }
+    bool success = true;
+    for (auto e : a) {
+        success = success && e == 1.0;
+    }
+    return success;
+}
+bool test_negative() {
+    linear_algebra::fixsized_vector<double, 2> a{1.0, -1.0};
+    return -a == linear_algebra::fixsized_vector<double, 2>{-1.0, 1.0};
+}
+
+bool test_vector() {
+    std::vector<std::function<bool()>> tests{
+        test0,
+        test1,
+        test_add,
+        test_sub,
+        test_element_multi,
+        test_ranged_for,
+        test_negative,
+    };
+    for (auto& test : tests) {
+        if (test()) {
+            std::cout << "passed" << std::endl;
+        }
+        else {
+            std::cout << "failed" << std::endl;
+        }
+    }
+    return true;
+}