Got unit tests compiling

.vscode/launch.json

@@ -0,0 +1,33 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Matrix Tests",
+            "type": "cppdbg",
+            "request": "launch",
+            "program": "enter program name, for example ${workspaceFolder}/build/unit-tests/matrix-tests",
+            "args": [],
+            "stopAtEntry": false,
+            "cwd": "${fileDirname}",
+            "environment": [],
+            "externalConsole": false,
+            "MIMode": "gdb",
+            "setupCommands": [
+                {
+                    "description": "Enable pretty-printing for gdb",
+                    "text": "-enable-pretty-printing",
+                    "ignoreFailures": true
+                },
+                {
+                    "description": "Set Disassembly Flavor to Intel",
+                    "text": "-gdb-set disassembly-flavor intel",
+                    "ignoreFailures": true
+                }
+            ]
+        }
+        
+    ]
+}

.vscode/settings.json

@@ -0,0 +1,74 @@
+{
+    "C_Cpp.intelliSenseEngine": "default",
+    "clangd.arguments": [
+        "--include-directory=build/unit-tests"
+    ],
+    "C_Cpp.default.intelliSenseMode": "linux-gcc-x64",
+    "files.associations": {
+        "*.h": "cpp",
+        "array": "cpp",
+        "atomic": "cpp",
+        "bit": "cpp",
+        "*.tcc": "cpp",
+        "bitset": "cpp",
+        "cctype": "cpp",
+        "chrono": "cpp",
+        "clocale": "cpp",
+        "cmath": "cpp",
+        "compare": "cpp",
+        "concepts": "cpp",
+        "condition_variable": "cpp",
+        "cstdarg": "cpp",
+        "cstddef": "cpp",
+        "cstdint": "cpp",
+        "cstdio": "cpp",
+        "cstdlib": "cpp",
+        "cstring": "cpp",
+        "ctime": "cpp",
+        "cwchar": "cpp",
+        "cwctype": "cpp",
+        "deque": "cpp",
+        "list": "cpp",
+        "map": "cpp",
+        "set": "cpp",
+        "string": "cpp",
+        "unordered_map": "cpp",
+        "vector": "cpp",
+        "exception": "cpp",
+        "algorithm": "cpp",
+        "functional": "cpp",
+        "iterator": "cpp",
+        "memory": "cpp",
+        "memory_resource": "cpp",
+        "numeric": "cpp",
+        "optional": "cpp",
+        "random": "cpp",
+        "ratio": "cpp",
+        "regex": "cpp",
+        "string_view": "cpp",
+        "system_error": "cpp",
+        "tuple": "cpp",
+        "type_traits": "cpp",
+        "utility": "cpp",
+        "fstream": "cpp",
+        "future": "cpp",
+        "initializer_list": "cpp",
+        "iomanip": "cpp",
+        "iosfwd": "cpp",
+        "iostream": "cpp",
+        "istream": "cpp",
+        "limits": "cpp",
+        "mutex": "cpp",
+        "new": "cpp",
+        "numbers": "cpp",
+        "ostream": "cpp",
+        "semaphore": "cpp",
+        "sstream": "cpp",
+        "stdexcept": "cpp",
+        "stop_token": "cpp",
+        "streambuf": "cpp",
+        "thread": "cpp",
+        "typeinfo": "cpp",
+        "variant": "cpp"
+    }
+}

CMakeLists.txt

@@ -5,6 +5,9 @@ add_subdirectory(unit-tests)
 
 set(CMAKE_CXX_STANDARD 11)
 
+add_compile_options(-fdiagnostics-color=always)
+
+# Vector3d
 add_library(Vector3D 
     STATIC
     Vector3D.hpp
@@ -19,6 +22,7 @@ target_include_directories(Vector3D PUBLIC
     include
 )
 
+# Matrix
 add_library(Matrix 
     STATIC
     Matrix.hpp

Matrix.hpp

@@ -10,7 +10,16 @@ template <uint8_t rows, uint8_t columns> class Matrix {
 public:
   Matrix();
 
-  explicit Matrix(const std::array<float, columns> &array);
+  /**
+   * @brief Initialize a matrix with an array
+   */
+  Matrix(const std::array<float, rows*columns> &array);
+
+  /**
+   * @brief Initialize a matrix directly with any number of arguments
+   */
+  // template <typename... Args>
+  // Matrix(Args&&... args);
 
   /**
    * @brief Element-wise matrix addition
@@ -101,15 +110,23 @@ public:
    * @param column the column index of the element
    * @return The value of the element you want to get
    */
-  float &Get(uint8_t row_index, uint8_t column_index) const;
+  float Get(uint8_t row_index, uint8_t column_index) const;
 
   /**
    * @brief get the specified row of the matrix returned as a reference to the
    * internal array
    */
-  std::array<float, columns> &operator[](uint8_t row_index) const;
+  std::array<float, columns> &operator[](uint8_t row_index){
+    return this->matrix[row_index];
+  }
 
-  Matrix<rows, columns> &operator=(const Matrix<rows, columns> &other);
+  Matrix<rows, columns> &operator=(const Matrix<rows, columns> &other){
+    for(uint8_t row_idx{0}; row_idx < rows; row_idx++){
+      for(uint8_t column_idx{0}; column_idx < columns; column_idx++){
+        this->matrix[row_idx][column_idx] = other.Get(row_idx, column_idx);
+      }
+    }
+  }
 
   /**
    * @brief Get a row from the matrix
@@ -170,26 +187,37 @@ template <uint8_t rows, uint8_t columns> Matrix<rows, columns>::Matrix() {
 }
 
 template <uint8_t rows, uint8_t columns>
-Matrix<rows, columns>::Matrix(const std::array<float, columns> &array) {
+Matrix<rows, columns>::Matrix(const std::array<float, rows*columns> &array) {
   for (uint8_t row_idx{0}; row_idx < rows; row_idx++) {
     for (uint8_t column_idx{0}; column_idx < columns; column_idx++) {
       uint16_t array_idx =
           static_cast<uint16_t>(row_idx) + static_cast<uint16_t>(column_idx);
       if (array_idx < array.size()) {
-        this->Get(row_idx, column_idx) = array[array_idx];
+        this->matrix[row_idx][column_idx] = array[array_idx];
       } else {
-        this->Get(row_idx, column_idx) = 0;
+        this->matrix[row_idx][column_idx] = 0;
       }
     }
   }
 }
 
+// template <uint8_t rows, uint8_t columns>
+// template <typename... Args>
+// Matrix<rows, columns>::Matrix(Args&&... args){
+  
+//   // Initialize a std::array with the arguments
+//   std::array<float, sizeof...(args)> values = {args...};
+
+//   // now call our other constructor which can take this array as an argument
+//   this = Matrix<rows, columns>{values};
+// }
+
 template <uint8_t rows, uint8_t columns>
 void Matrix<rows, columns>::Add(const Matrix<rows, columns> &other,
                                 Matrix<rows, columns> &result) const {
-  for (uint8_t row{0}; row < rows; row++) {
-    for (uint8_t column{0}; column < columns; column++) {
-      result.Get(row, column) = this->Get(row, column) + other.Get(row, column);
+  for (uint8_t row_idx{0}; row_idx < rows; row_idx++) {
+    for (uint8_t column_idx{0}; column_idx < columns; column_idx++) {
+      result[row_idx][column_idx] = this->Get(row_idx, column_idx) + other.Get(row_idx, column_idx);
     }
   }
 }
@@ -197,9 +225,9 @@ void Matrix<rows, columns>::Add(const Matrix<rows, columns> &other,
 template <uint8_t rows, uint8_t columns>
 void Matrix<rows, columns>::Subtract(const Matrix<rows, columns> &other,
                                      Matrix<rows, columns> &result) const {
-  for (uint8_t row{0}; row < rows; row++) {
-    for (uint8_t column{0}; column < columns; column++) {
-      result.Get(row, column) = this->Get(row, column) - other.Get(row, column);
+  for (uint8_t row_idx{0}; row_idx < rows; row_idx++) {
+    for (uint8_t column_idx{0}; column_idx < columns; column_idx++) {
+      result[row_idx][column_idx] = this->Get(row_idx, column_idx) - other.Get(row_idx, column_idx);
     }
   }
 }
@@ -222,7 +250,7 @@ void Matrix<rows, columns>::Multiply(
       other_column.Transpose(other_column_t);
 
       // the result's index is equal to the dot product of these two vectors
-      result.Get(row_idx, column_idx) =
+      result[row_idx][column_idx] =
           this->dotProduct(this_row, other_column_t);
     }
   }
@@ -233,7 +261,7 @@ void Matrix<rows, columns>::Multiply(float scalar,
                                      Matrix<rows, columns> &result) const {
   for (uint8_t row_idx{0}; row_idx < rows; row_idx++) {
     for (uint8_t column_idx{0}; column_idx < columns; column_idx++) {
-      result.Get(row_idx, column_idx) = this->Get(row_idx, column_idx) * scalar;
+      result[row_idx][column_idx] = this->Get(row_idx, column_idx) * scalar;
     }
   }
 }
@@ -273,7 +301,7 @@ template <uint8_t rows, uint8_t columns>
 void Matrix<rows, columns>::Transpose(Matrix<columns, rows> &result) const {
   for (uint8_t column_idx{0}; column_idx < rows; column_idx++) {
     for (uint8_t row_idx{0}; row_idx < columns; row_idx++) {
-      result.Get(row_idx, column_idx) = this->Get(column_idx, row_idx);
+      result[row_idx][column_idx] = this->Get(column_idx, row_idx);
     }
   }
 }
@@ -360,7 +388,7 @@ void Matrix<rows, columns>::ElementMultiply(
     const Matrix<rows, columns> &other, Matrix<rows, columns> &result) const {
   for (uint8_t row_idx{0}; row_idx < rows; row_idx++) {
     for (uint8_t column_idx{0}; column_idx < columns; column_idx++) {
-      result.Get(row_idx, column_idx) =
+      result[row_idx][column_idx] =
           this->Get(row_idx, column_idx) * other.Get(row_idx, column_idx);
     }
   }
@@ -371,14 +399,14 @@ void Matrix<rows, columns>::ElementDivide(const Matrix<rows, columns> &other,
                                           Matrix<rows, columns> &result) const {
   for (uint8_t row_idx{0}; row_idx < rows; row_idx++) {
     for (uint8_t column_idx{0}; column_idx < columns; column_idx++) {
-      result.Get(row_idx, column_idx) =
+      result[row_idx][column_idx] =
           this->Get(row_idx, column_idx) / other.Get(row_idx, column_idx);
     }
   }
 }
 
 template <uint8_t rows, uint8_t columns>
-float &Matrix<rows, columns>::Get(uint8_t row_index,
+float Matrix<rows, columns>::Get(uint8_t row_index,
                                   uint8_t column_index) const {
   return this->matrix[row_index][column_index];
 }
@@ -393,7 +421,7 @@ template <uint8_t rows, uint8_t columns>
 void Matrix<rows, columns>::GetColumn(uint8_t column_index,
                                       Matrix<rows, 1> &column) const {
   for (uint8_t row_idx{0}; row_idx < rows; row_idx++) {
-    column.Get(0, column_index) = this->Get(row_idx, column_index);
+    column[0][column_index] = this->Get(row_idx, column_index);
   }
 }
 
@@ -426,7 +454,7 @@ void Matrix<rows, columns>::matrixOfMinors(
   for (uint8_t row_idx{0}; row_idx < rows; row_idx++) {
     for (uint8_t column_idx{0}; column_idx < columns; column_idx++) {
       this->minorMatrix(minorMatrix, row_idx, column_idx);
-      result.Get(row_idx, column_idx) = minorMatrix.Det();
+      result[row_idx][column_idx] = minorMatrix.Det();
     }
   }
 }
@@ -457,7 +485,7 @@ void Matrix<rows, columns>::adjugate(Matrix<rows, columns> &result) const {
     for (uint8_t column_iter{0}; column_iter < columns; column_iter++) {
       float sign = ((row_iter + 1) % 2) == 0 ? -1 : 1;
       sign *= ((column_iter + 1) % 2) == 0 ? -1 : 1;
-      result.Get(row_iter, column_iter) =
+      result[row_iter][column_iter] =
           this->Get(row_iter, column_iter) * sign;
     }
   }
@@ -480,7 +508,7 @@ void Matrix<rows, columns>::normalize(Matrix<rows, columns> &result) const {
 
   for (uint8_t column_idx{0}; column_idx < rows; column_idx++) {
     for (uint8_t row_idx{0}; row_idx < columns; row_idx++) {
-      result.Get(row_idx, column_idx) = this->Get(row_idx, column_idx) / sum;
+      result[row_idx][column_idx] = this->Get(row_idx, column_idx) / sum;
     }
   }
 }

unit-tests/matrix-tests.cpp

@@ -4,6 +4,9 @@
 // include the module you're going to test next
 #include "Matrix.hpp"
 
+// any other libraries
+#include <array>
+
 unsigned int Factorial(unsigned int number) {
   return number <= 1 ? number : Factorial(number - 1) * number;
 }
@@ -16,8 +19,10 @@ TEST_CASE("Factorials are computed", "[factorial]") {
 }
 
 TEST_CASE("Matrix Addition", "Matrix::Add") {
-  Matrix<2, 2> mat1{std::array<float, 4>{1, 2, 3, 4}};
-  Matrix<2, 2> mat2{std::array<float, 4>{5, 6, 7, 8}};
+  std::array<float, 4> arr1{1, 2, 3, 4};
+  std::array<float, 4> arr2{5, 6, 7, 8};
+  Matrix<2, 2> mat1{arr1};
+  Matrix<2, 2> mat2{arr2};
 
   Matrix<2, 2> mat3{};
   mat1.Add(mat2, mat3);