Merge pull request 'Updating the readme' (#7) from update-readme into main

Reviewed-on: #7

README.md

@@ -2,8 +2,11 @@
 This matrix math library is focused on embedded development and avoids any heap memory allocation unless you explicitly ask for it.
 It uses templates to pre-allocate matrices on the stack.
 
-There are still several operations that are works in progress such as:
-- Add a function to calculate eigenvalues/vectors
-- Add a function to compute RREF
-- Add a function for SVD decomposition
-- Add a function for LQ decomposition
+# Building
+1. Initialize the repositiory with the command:
+```bash
+cmake -S . -B build -G Ninja
+```
+
+2. Go into the build folder and run `ninja`
+3. That's it. You can test out the build by running `./unit-tests/matrix-tests`

src/Matrix.cpp

@@ -572,12 +572,13 @@ void Matrix<rows, columns>::EigenQR(Matrix<rows, rows> &eigenVectors,
 
   Matrix<rows, rows> Ak = *this; // Copy original matrix
   Matrix<rows, rows> QQ{Matrix<rows, rows>::Identity()};
+  Matrix<rows, rows> shift{0};
 
   for (uint32_t iter = 0; iter < maxIterations; ++iter) {
-    Matrix<rows, rows> Q, R, shift;
+    Matrix<rows, rows> Q, R;
 
-    // QR shift lets us "attack" the first diagonal to speed up the algorithm
-    shift = Matrix<rows, rows>::Identity() * Ak[rows - 1][rows - 1];
+    // // QR shift lets us "attack" the first diagonal to speed up the algorithm
+    // shift = Matrix<rows, rows>::Identity() * Ak[rows - 1][rows - 1];
     (Ak - shift).QRDecomposition(Q, R);
     Ak = R * Q + shift;
     QQ = QQ * Q;

unit-tests/matrix-tests.cpp

@@ -559,28 +559,6 @@ TEST_CASE("QR Decompositions", "Matrix") {
         REQUIRE(std::fabs(R[i][j]) < 1e-4f);
       }
     }
-
-    // check that all Q values are correct
-    REQUIRE_THAT(Q[0][0], Catch::Matchers::WithinRel(0.1231f, 1e-4f));
-    REQUIRE_THAT(Q[0][1], Catch::Matchers::WithinRel(0.904534f, 1e-4f));
-    REQUIRE_THAT(Q[0][2], Catch::Matchers::WithinRel(0.0f, 1e-4f));
-    REQUIRE_THAT(Q[1][0], Catch::Matchers::WithinRel(0.49237f, 1e-4f));
-    REQUIRE_THAT(Q[1][1], Catch::Matchers::WithinRel(0.301511f, 1e-4f));
-    REQUIRE_THAT(Q[1][2], Catch::Matchers::WithinRel(0.0f, 1e-4f));
-    REQUIRE_THAT(Q[2][0], Catch::Matchers::WithinRel(0.86164f, 1e-4f));
-    REQUIRE_THAT(Q[2][1], Catch::Matchers::WithinRel(-0.30151f, 1e-4f));
-    REQUIRE_THAT(Q[2][2], Catch::Matchers::WithinRel(0.0f, 1e-4f));
-
-    // check that all R values are correct
-    REQUIRE_THAT(R[0][0], Catch::Matchers::WithinRel(8.124038f, 1e-4f));
-    REQUIRE_THAT(R[0][1], Catch::Matchers::WithinRel(9.60114f, 1e-4f));
-    REQUIRE_THAT(R[0][2], Catch::Matchers::WithinRel(11.07823f, 1e-4f));
-    REQUIRE_THAT(R[1][0], Catch::Matchers::WithinRel(0.0f, 1e-4f));
-    REQUIRE_THAT(R[1][1], Catch::Matchers::WithinRel(0.90453f, 1e-4f));
-    REQUIRE_THAT(R[1][2], Catch::Matchers::WithinRel(1.80907f, 1e-4f));
-    REQUIRE_THAT(R[2][0], Catch::Matchers::WithinRel(0.0f, 1e-4f));
-    REQUIRE_THAT(R[2][1], Catch::Matchers::WithinRel(0.0f, 1e-4f));
-    REQUIRE_THAT(R[2][2], Catch::Matchers::WithinRel(0.0f, 1e-4f));
   }
 
   SECTION("4x2 QRDecomposition") {
@@ -622,42 +600,41 @@ TEST_CASE("QR Decompositions", "Matrix") {
   }
 }
 
-// TEST_CASE("Eigenvalues and Vectors", "Matrix") {
-//   SECTION("2x2 Eigen") {
-//     Matrix<2, 2> A{1.0f, 2.0f, 3.0f, 4.0f};
-//     Matrix<2, 2> vectors{};
-//     Matrix<2, 1> values{};
+TEST_CASE("Eigenvalues and Vectors", "Matrix") {
+  SECTION("2x2 Eigen") {
+    Matrix<2, 2> A{1.0f, 2.0f, 3.0f, 4.0f};
+    Matrix<2, 2> vectors{};
+    Matrix<2, 1> values{};
 
-//     A.EigenQR(vectors, values, 1000000, 1e-20f);
+    A.EigenQR(vectors, values, 1000000, 1e-20f);
 
-//     REQUIRE_THAT(vectors[0][0], Catch::Matchers::WithinRel(0.41597f, 1e-4f));
-//     REQUIRE_THAT(vectors[1][0], Catch::Matchers::WithinRel(0.90938f, 1e-4f));
-//     REQUIRE_THAT(values[0][0], Catch::Matchers::WithinRel(5.372282f, 1e-4f));
-//     REQUIRE_THAT(values[1][0], Catch::Matchers::WithinRel(-0.372281f,
-//     1e-4f));
-//   }
+    REQUIRE_THAT(vectors[0][0], Catch::Matchers::WithinRel(0.41597f, 1e-4f));
+    REQUIRE_THAT(vectors[1][0], Catch::Matchers::WithinRel(0.90938f, 1e-4f));
+    REQUIRE_THAT(values[0][0], Catch::Matchers::WithinRel(5.372282f, 1e-4f));
+    REQUIRE_THAT(values[1][0], Catch::Matchers::WithinRel(-0.372281f, 1e-4f));
+  }
 
-//   SECTION("3x3 Eigen") {
-//     // this symmetrix tridiagonal matrix is well behaved for testing
-//     Matrix<3, 3> A{1, 2, 3, 4, 5, 6, 7, 8, 9};
+  SECTION("3x3 Rank Defficient Eigen") {
+    SKIP("Skipping this because QR decomposition isn't ready for it");
+    // this symmetrix tridiagonal matrix is well behaved for testing
+    Matrix<3, 3> A{1, 2, 3, 4, 5, 6, 7, 8, 9};
 
-//     Matrix<3, 3> vectors{};
-//     Matrix<3, 1> values{};
-//     A.EigenQR(vectors, values, 1000000, 1e-8f);
+    Matrix<3, 3> vectors{};
+    Matrix<3, 1> values{};
+    A.EigenQR(vectors, values, 1000000, 1e-8f);
 
-//     std::string strBuf1 = "";
-//     vectors.ToString(strBuf1);
-//     std::cout << "Vectors:\n" << strBuf1 << std::endl;
-//     strBuf1 = "";
-//     values.ToString(strBuf1);
-//     std::cout << "Values:\n" << strBuf1 << std::endl;
+    std::string strBuf1 = "";
+    vectors.ToString(strBuf1);
+    std::cout << "Vectors:\n" << strBuf1 << std::endl;
+    strBuf1 = "";
+    values.ToString(strBuf1);
+    std::cout << "Values:\n" << strBuf1 << std::endl;
 
-//     REQUIRE_THAT(vectors[0][0], Catch::Matchers::WithinRel(0.23197f, 1e-4f));
-//     REQUIRE_THAT(vectors[1][0], Catch::Matchers::WithinRel(0.525322f,
-//     1e-4f)); REQUIRE_THAT(vectors[2][0], Catch::Matchers::WithinRel(0.81867f,
-//     1e-4f)); REQUIRE_THAT(values[0][0], Catch::Matchers::WithinRel(-1.11684f,
-//     1e-4f)); REQUIRE_THAT(values[1][0], Catch::Matchers::WithinRel(0.0f,
-//     1e-4f)); REQUIRE_THAT(values[2][0], Catch::Matchers::WithinRel(16.1168f,
-//     1e-4f));
-//   }
-// }
+    REQUIRE_THAT(vectors[0][0], Catch::Matchers::WithinRel(0.23197f, 1e-4f));
+    REQUIRE_THAT(vectors[1][0], Catch::Matchers::WithinRel(0.525322f, 1e-4f));
+    REQUIRE_THAT(vectors[2][0], Catch::Matchers::WithinRel(0.81867f, 1e-4f));
+    REQUIRE_THAT(values[0][0], Catch::Matchers::WithinRel(-1.11684f, 1e-4f));
+    REQUIRE_THAT(values[1][0], Catch::Matchers::WithinRel(0.0f, 1e-4f));
+    REQUIRE_THAT(values[2][0], Catch::Matchers::WithinRel(16.1168f, 1e-4f));
+  }
+}

unit-tests/matrix-timing-tests.cpp

@@ -8,6 +8,7 @@
 // any other libraries
 #include <array>
 #include <cmath>
+#include <cstdint>
 
 // basically re-run all of the matrix tests with huge matrices and time the
 // results.
@@ -29,13 +30,13 @@ TEST_CASE("Timing Tests", "Matrix") {
   Matrix<4, 4> mat5{};
 
   SECTION("Addition") {
-    for (uint32_t i{0}; i < 10000; i++) {
+    for (uint32_t i{0}; i < 100000; i++) {
       mat3 = mat1 + mat2;
     }
   }
 
   SECTION("Subtraction") {
-    for (uint32_t i{0}; i < 10000; i++) {
+    for (uint32_t i{0}; i < 100000; i++) {
       mat3 = mat1 - mat2;
     }
   }
@@ -47,19 +48,19 @@ TEST_CASE("Timing Tests", "Matrix") {
   }
 
   SECTION("Scalar Multiplication") {
-    for (uint32_t i{0}; i < 10000; i++) {
+    for (uint32_t i{0}; i < 100000; i++) {
       mat3 = mat1 * 3;
     }
   }
 
   SECTION("Element Multiply") {
-    for (uint32_t i{0}; i < 10000; i++) {
+    for (uint32_t i{0}; i < 100000; i++) {
       mat1.ElementMultiply(mat2, mat3);
     }
   }
 
   SECTION("Element Divide") {
-    for (uint32_t i{0}; i < 10000; i++) {
+    for (uint32_t i{0}; i < 100000; i++) {
       mat1.ElementDivide(mat2, mat3);
     }
   }
@@ -68,52 +69,59 @@ TEST_CASE("Timing Tests", "Matrix") {
     // what about matrices of 0,0 or 1,1?
     // minor matrix for 2x2 matrix
     Matrix<49, 49> minorMat1{};
-    for (uint32_t i{0}; i < 10000; i++) {
+    for (uint32_t i{0}; i < 100000; i++) {
       mat1.MinorMatrix(minorMat1, 0, 0);
     }
   }
 
   SECTION("Determinant") {
-    for (uint32_t i{0}; i < 100000; i++) {
+    for (uint32_t i{0}; i < 1000000; i++) {
       float det1 = mat4.Det();
     }
   }
 
   SECTION("Matrix of Minors") {
-    for (uint32_t i{0}; i < 100000; i++) {
+    for (uint32_t i{0}; i < 1000000; i++) {
       mat4.MatrixOfMinors(mat5);
     }
   }
 
   SECTION("Invert") {
-    for (uint32_t i{0}; i < 100000; i++) {
+    for (uint32_t i{0}; i < 1000000; i++) {
       mat5 = mat4.Invert();
     }
   };
 
   SECTION("Transpose") {
-    for (uint32_t i{0}; i < 10000; i++) {
+    for (uint32_t i{0}; i < 100000; i++) {
       mat3 = mat1.Transpose();
     }
   }
 
   SECTION("Normalize") {
-    for (uint32_t i{0}; i < 10000; i++) {
+    for (uint32_t i{0}; i < 100000; i++) {
       mat3 = mat1 / mat1.EuclideanNorm();
     }
   }
 
   SECTION("GET ROW") {
     Matrix<1, 50> mat1Rows{};
-    for (uint32_t i{0}; i < 1000000; i++) {
+    for (uint32_t i{0}; i < 100000000; i++) {
       mat1.GetRow(0, mat1Rows);
     }
   }
 
   SECTION("GET COLUMN") {
     Matrix<50, 1> mat1Columns{};
-    for (uint32_t i{0}; i < 1000000; i++) {
+    for (uint32_t i{0}; i < 100000000; i++) {
       mat1.GetColumn(0, mat1Columns);
     }
   }
+
+  SECTION("QR Decomposition") {
+    Matrix<50, 50> Q, R{};
+    for (uint32_t i{0}; i < 500; i++) {
+      mat1.QRDecomposition(Q, R);
+    }
+  }
 }

unit-tests/timing-results/matrix-timing-tests.txt

@@ -1,56 +1,36 @@
-Randomness seeded to: 2444679151
-0.180 s: Addition
-0.180 s: Timing Tests
-0.177 s: Subtraction
-0.177 s: Timing Tests
-1.868 s: Multiplication
-1.868 s: Timing Tests
-0.127 s: Scalar Multiplication
-0.127 s: Timing Tests
-0.173 s: Element Multiply
-0.173 s: Timing Tests
-0.178 s: Element Divide
-0.178 s: Timing Tests
-0.172 s: Minor Matrix
-0.172 s: Timing Tests
-0.103 s: Determinant
-0.103 s: Timing Tests
-0.411 s: Matrix of Minors
-0.411 s: Timing Tests
-0.109 s: Invert
-0.109 s: Timing Tests
-0.122 s: Transpose
-0.122 s: Timing Tests
-0.190 s: Normalize
-0.190 s: Timing Tests
-0.006 s: GET ROW
-0.006 s: Timing Tests
-0.235 s: GET COLUMN
-0.235 s: Timing Tests
+Running matrix-timing-tests with timing
+Randomness seeded to: 3567651885
+1.857 s: Addition
+1.857 s: Timing Tests
+1.788 s: Subtraction
+1.788 s: Timing Tests
+1.929 s: Multiplication
+1.929 s: Timing Tests
+1.268 s: Scalar Multiplication
+1.268 s: Timing Tests
+1.798 s: Element Multiply
+1.798 s: Timing Tests
+1.802 s: Element Divide
+1.803 s: Timing Tests
+1.553 s: Minor Matrix
+1.554 s: Timing Tests
+1.009 s: Determinant
+1.009 s: Timing Tests
+4.076 s: Matrix of Minors
+4.076 s: Timing Tests
+1.066 s: Invert
+1.066 s: Timing Tests
+1.246 s: Transpose
+1.246 s: Timing Tests
+2.284 s: Normalize
+2.284 s: Timing Tests
+0.606 s: GET ROW
+0.606 s: Timing Tests
+24.629 s: GET COLUMN
+24.630 s: Timing Tests
+3.064 s: QR Decomposition
+3.064 s: Timing Tests
 ===============================================================================
 test cases: 1 | 1 passed
 assertions: - none -
 
-	Command being timed: "build/unit-tests/matrix-timing-tests -d yes"
-	User time (seconds): 4.05
-	System time (seconds): 0.00
-	Percent of CPU this job got: 100%
-	Elapsed (wall clock) time (h:mm:ss or m:ss): 0:04.05
-	Average shared text size (kbytes): 0
-	Average unshared data size (kbytes): 0
-	Average stack size (kbytes): 0
-	Average total size (kbytes): 0
-	Maximum resident set size (kbytes): 3200
-	Average resident set size (kbytes): 0
-	Major (requiring I/O) page faults: 184
-	Minor (reclaiming a frame) page faults: 171
-	Voluntary context switches: 1
-	Involuntary context switches: 26
-	Swaps: 0
-	File system inputs: 12
-	File system outputs: 1
-	Socket messages sent: 0
-	Socket messages received: 0
-	Signals delivered: 0
-	Page size (bytes): 4096
-	Exit status: 0