diff --git a/fastmath.hpp b/fastmath.hpp
index f58fa6c..40acdd4 100644
--- a/fastmath.hpp
+++ b/fastmath.hpp
@@ -1,8 +1,8 @@
 #ifndef FASTMATH_H
 #define FASTMATH_H
 
-#include <cmath>
 #include <iostream>
+#include <math.h>
 #include <stdint.h>
 #include <stdlib.h>
 #include <vector>
@@ -108,6 +108,14 @@ template <int n, class Dev> struct vec {
         }
         return newV;
     }
+    friend Dev operator+=(const vec<n, Dev> &v1, const vec<n, Dev> &v2) {
+        Dev newV = {};
+
+        for (int i = 0; i < n; i++) {
+            newV.v[i] = v1.v[i] + v2.v[i];
+        }
+        return newV;
+    }
 
     friend Dev operator-(const vec<n, Dev> &v1, const vec<n, Dev> &v2) {
         Dev newV = {};
@@ -143,6 +151,20 @@ template <int n, class Dev> struct vec {
         }
         return newV;
     }
+    static Dev max(const vec<n, Dev> &v1, const vec<n, Dev> &v2) {
+        Dev newV = {};
+        for (int i = 0; i < n; i++) {
+            newV.v[i] = std::max(v1.v[i], v2.v[i]);
+        }
+        return newV;
+    }
+    static Dev min(const vec<n, Dev> &v1, const vec<n, Dev> &v2) {
+        Dev newV = {};
+        for (int i = 0; i < n; i++) {
+            newV.v[i] = std::min(v1.v[i], v2.v[i]);
+        }
+        return newV;
+    }
 
     friend Dev operator*(const decimal &d, const vec<n, Dev> &v) {
         return v * d;
@@ -244,4 +266,108 @@ struct vec4 : public vec<4, vec4> {
     decimal &z() { return v[2]; }
     decimal &w() { return v[3]; }
 };
+
+// template <int n, class Dev> struct mat {
+//
+//     mat(decimal newM[n * n]) {
+//         for (int i = 0; i < n * n; i++) {
+//             m[i] = newM[i];
+//         }
+//     }
+//
+//     mat(std::vector<decimal> newM) {
+//         for (int i = 0; i < n * n; i++) {
+//             m[i] = newM[i];
+//         }
+//     }
+//
+//     mat() : m{} {}
+//
+//     friend Dev operator+(const mat<n, Dev> &m1, const mat<n, Dev> &m2) {
+//         Dev newM = {};
+//
+//         for (int i = 0; i < n * n; i++) {
+//             newM.v[i] = m1.m[i] + m2.m[i];
+//         }
+//         return newM;
+//     }
+//     friend Dev operator+=(const mat<n, Dev> &m1, const mat<n, Dev> &m2) {
+//         Dev newM = {};
+//
+//         for (int i = 0; i < n * n; i++) {
+//             newM.m[i] = m1.m[i] + m2.m[i];
+//         }
+//         return newM;
+//     }
+//
+//     friend Dev operator-(const mat<n, Dev> &m1, const mat<n, Dev> &m2) {
+//         Dev newM = {};
+//
+//         for (int i = 0; i < n * n; i++) {
+//             newM.m[i] = m1.m[i] - m2.m[i];
+//         }
+//         return static_cast<Dev>(newM);
+//     }
+//
+//     friend std::ostream &operator<<(std::ostream &os, const mat<n, Dev> &m) {
+//         os << "(" << m.m[0];
+//         for (int i = 1; i < n * n; i++) {
+//             os << ", " << m.m[i];
+//         }
+//         return (os << ")" << std::endl);
+//     }
+//
+//     friend Dev operator*(const mat<n, Dev> &m, const decimal &d) {
+//         int32_t f = d.i >> HALF_SHIFT;
+//
+//         Dev newM = {};
+//         for (int i = 0; i < n * n; i++) {
+//             newM.m[i] = (m.m[i].i >> HALF_SHIFT) * f;
+//         }
+//         return newM;
+//     }
+//
+//     friend Dev operator*(const decimal &d, const mat<n, Dev> &v) {
+//         return v * d;
+//     }
+//
+//     Dev operator*(const mat<n, Dev> &mat) {
+//         Dev newM = {};
+//         for (int i = 0; i < n; i++) {
+//             for (int j = 0; j < n; j++) {
+//                 newM.m += mat.v[i * n] * m[i];
+//             }
+//         }
+//         return res;
+//     }
+//
+//     friend bool operator==(const mat<n, Dev> &v1, const mat<n, Dev> &m2) {
+//         bool res = true;
+//         for (int i = 0; i < n; i++) {
+//             res &= v1.v[i] == m2.v[i];
+//         }
+//         return res;
+//     }
+//     bool isSmall() {
+//         for (int i = 0; i < n; i++) {
+//             if (!v[i].isSmall())
+//                 return false;
+//         }
+//         return true;
+//     }
+//     decimal &operator[](const int &i) { return v[i]; }
+//
+//     decimal len_sq() { return *this * *this; }
+//
+//     decimal len() { return this->len_sq().sqrt(); }
+//
+//     Dev normalize() {
+//         decimal f = decimal(1.0) / this->len();
+//         return (*this * f);
+//     }
+//
+//   protected:
+//     decimal m[n * n];
+// };
+
 #endif