1 files changed, 40 insertions, 6 deletions

diff --git a/src/Math/Matrix.hpp b/src/Math/Matrix.hpp
index adc34a9..9a6b7e6 100644
--- a/src/Math/Matrix.hpp
+++ b/src/Math/Matrix.hpp
@@ -1,7 +1,7 @@
 #pragma once
 
 #include <sstream>
-#include <stddef.h>
+#include <cstddef>
 #include <iostream>
 
 template <size_t R, size_t C, typename T = float>
@@ -9,8 +9,24 @@ struct Matrix {
 public:
     Matrix<R, C, T>() : elements{} {};
 
+    Matrix<R, C, T>(T scalar) {
+        std::fill(elements, elements + R * C, scalar);
+    };
+
     template<typename ...Args>
-    explicit Matrix<R, C, T>(Args... args): elements{ args... } {};
+    Matrix<R, C, T>(Args... args): elements{ args... } {};
+
+    Matrix<R, C, T>(T values[R * C]) {
+        std::copy(values, values + R * C, elements);
+    };
+
+    static Matrix<R, R, T> identity() {
+        Matrix<R, R, T> result{};
+        for (int i = 0; i < R; i++) {
+            result(i, i) = 1;
+        }
+        return result;
+    }
 
     Vector<C, T> row(size_t index) {
         return { &elements[index * C] };
@@ -24,6 +40,22 @@ public:
         return result;
     }
 
+    Matrix<R, C, T> operator+(Matrix<R, C, T> other) {
+        Matrix<R, C, T> result{};
+        for (int i = 0; i < R * C; i++) {
+            result.elements[i] = elements[i] + other.elements[i];
+        }
+        return result;
+    }
+
+    Matrix<R, C, T> operator*(float scalar) {
+        Matrix<R, C, T> result{};
+        for (int i = 0; i < R * C; i++) {
+            result.elements[i] = elements[i] * scalar;
+        }
+        return result;
+    }
+
     template<size_t N>
     Matrix<R, N, T> operator*(Matrix<C, N, T> other) {
         Matrix<R, N, T> result{};
@@ -34,16 +66,18 @@ public:
 
                 auto dot = r * c;
 
-                std::cout << x << ", " << y << ": "
-                    << "(" << r.string() << ", " << c.string() << ")"
-                    << dot << std::endl;
-
                 result(x, y) = dot;
             }
         }
         return result;
     }
 
+    Vector<R, T> operator*(Vector<R, T> vector) {
+        Matrix<R, 1, T> matrix(vector.elements);
+        matrix = this->operator*(matrix);
+        return { matrix.elements };
+    }
+
     auto& operator()(size_t x, size_t y) {
         return elements[y * C + x];
     }