overload basic maths operators for matrices ans vectors

Author: at0m741

Tests/benchmarks/bench.cpp

@@ -455,6 +455,37 @@ template <typename K, bool RowMajor = false> class Matrix {
         }
 
         return r;
-    }
+	}
+
+	Matrix& operator+=(const Matrix& m) { this->add(m); return *this; }
+	Matrix& operator-=(const Matrix& m) { this->sub(m); return *this; }
+	Matrix& operator*=(K alpha) { this->scl(alpha); return *this; }
 };
+template<typename K, bool RM>
+Matrix<K, RM> operator+(const Matrix<K, RM>& a, const Matrix<K, RM>& b) {
+	Matrix<K, RM> res = a;
+	res.add(b);
+	return res;
+}
+template<typename K, bool RM>
+Matrix<K, RM> operator-(const Matrix<K, RM>& a, const Matrix<K, RM>& b) {
+	Matrix<K, RM> res = a;
+	res.sub(b);
+	return res;
+}
+template<typename K, bool RM>
+Matrix<K, RM> operator*(const Matrix<K, RM>& a, const Matrix<K, RM>& b) {
+	return a._mul_mat(b);
+}
+template<typename K, bool RM>
+Matrix<K, RM> operator*(const Matrix<K, RM>& m, K alpha) {
+	Matrix<K, RM> res = m;
+	res.scl(alpha);
+	return res;
+}
+template<typename K, bool RM>
+Matrix<K, RM> operator*(K alpha, const Matrix<K, RM>& m) {
+	return m * alpha;
+}
+
 } // namespace tensorium

includes/Tensorium/Core/Matrix.hpp

@@ -11,14 +11,13 @@
  * sizes
  *
  */
-
 namespace tensorium {
 template <typename T> class GemmKernelBigger {
   public:
     using Simd = simd::SimdTraits<T, DefaultISA>;
     using reg = typename Simd::reg;
     static constexpr int SimdWidth = Simd::width;
-    static constexpr int TileRows = SimdWidth * 2;
+    static constexpr int TileRows = SimdWidth * 4;
     static constexpr int TileCols = 6;
     static constexpr int NThreads = 16;
 

includes/Tensorium/Core/MatrixKernels/GemmKernel_bigger.hpp

@@ -447,6 +447,11 @@ template <typename K> class Vector {
 
         return r;
     }
+
+	Vector<K>& operator+=(const Vector<K>& m) { this->add(m); return *this; }
+	Vector<K>& operator-=(const Vector<K>& m) { this->sub(m); return *this; }
+	Vector<K>& operator*=(K alpha) { this->scl(alpha); return *this; }
+
 };
 
 template <typename K> inline Vector<K> operator+(const Vector<K> &a, const Vector<K> &b) {