From eaf521a54b387909ea7570edec250d5ccc6283a3 Mon Sep 17 00:00:00 2001
From: Modernbeast02 <89138051+Modernbeast02@users.noreply.github.com>
Date: Wed, 8 Feb 2023 21:02:05 +0530
Subject: [PATCH] Resolved Issue #81 (#83)

* Resolved Issue #64

* Fixed All Operators Issue#64

* Resolved Issue#81

* Revert "Resolved Issue#81"

This reverts commit 16031e49efa80167c6d0e127d89d9eed6aa44b80.

* Resolved Issue #81

---------

Co-authored-by: Ishwarendra Jha <75680424+Ishwarendra@users.noreply.github.com>
---
 .gitignore                            |  3 +
 src/slowmokit/ducks/matrix/matrix.cpp | 93 ++++++++++++++++++++++++++-
 src/slowmokit/ducks/matrix/matrix.hpp | 71 +++++++++++++++-----
 3 files changed, 148 insertions(+), 19 deletions(-)

diff --git a/.gitignore b/.gitignore
index f849259..4ed0d3d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -43,5 +43,8 @@ cmake-build-debug
 # CHelper
 **/*__tests
 
+# Binary Executive
+**/*.bin
+
 # build
 build
diff --git a/src/slowmokit/ducks/matrix/matrix.cpp b/src/slowmokit/ducks/matrix/matrix.cpp
index baf04e6..1f02f8d 100644
--- a/src/slowmokit/ducks/matrix/matrix.cpp
+++ b/src/slowmokit/ducks/matrix/matrix.cpp
@@ -33,7 +33,9 @@ template<class T> Matrix<T>::Matrix(const std::vector<std::vector<T>> in)
   }
 }
 
-template<class T> Matrix<T> &Matrix<T>::operator*=(const T &scalar)
+template<class T>
+template<class G>
+Matrix<T> &Matrix<T>::operator*=(const G &scalar)
 {
   for (int i = 0; i < n; i++)
   {
@@ -44,6 +46,32 @@ template<class T> Matrix<T> &Matrix<T>::operator*=(const T &scalar)
   return *this;
 }
 
+template<class T>
+template<class G>
+Matrix<T> &Matrix<T>::operator+=(const G &scalar)
+{
+  for (int i = 0; i < n; i++)
+  {
+    for (int j = 0; j < m; j++)
+      mat[i][j] += scalar;
+  }
+
+  return *this;
+}
+
+template<class T>
+template<class G>
+Matrix<T> &Matrix<T>::operator-=(const G &scalar)
+{
+  for (int i = 0; i < n; i++)
+  {
+    for (int j = 0; j < m; j++)
+      mat[i][j] -= scalar;
+  }
+
+  return *this;
+}
+
 template<class T> Matrix<T> &Matrix<T>::operator*=(const Matrix<T> &rhs)
 {
   auto [n2, m2] = rhs.getShape();
@@ -142,8 +170,7 @@ template<class T> const std::vector<T> &Matrix<T>::operator[](int i) const
 template<class T>
 std::ostream &operator<<(std::ostream &os, const Matrix<T> &matrix)
 {
-  int n = std::size(matrix);
-  int m = std::size(matrix[0]);
+  auto [n, m] = matrix.getShape();
 
   for (int i = 0; i < n; i++)
   {
@@ -178,3 +205,63 @@ template<class T> Matrix<T> operator-(Matrix<T> lhs, const Matrix<T> &rhs)
   lhs -= rhs;
   return lhs;
 }
+
+template<class T, class G> Matrix<T> operator+(G num, const Matrix<T> &matrix)
+{
+  Matrix<T> res = matrix;
+  res += num;
+  return res;
+}
+
+template<class T, class G> Matrix<T> operator-(G num, const Matrix<T> &matrix)
+{
+  Matrix<T> res = matrix;
+  res -= num;
+  return res;
+}
+
+template<class T, class G> Matrix<T> operator*(G num, const Matrix<T> &matrix)
+{
+  Matrix<T> res = matrix;
+  res *= num;
+  return res;
+}
+
+template<class T, class G> Matrix<T> operator+(Matrix<T> matrix, const G &num)
+{
+  matrix += num;
+  return matrix;
+}
+
+template<class T, class G> Matrix<T> operator-(Matrix<T> matrix, const G &num)
+{
+  matrix -= num;
+  return matrix;
+}
+
+template<class T, class G> Matrix<T> operator*(Matrix<T> matrix, const G &num)
+{
+  matrix *= num;
+  return matrix;
+}
+
+template<class T> Matrix<T> Matrix<T>::matmul(const Matrix<T> rhs)
+{
+  Matrix<T> res = *this;
+  res *= rhs;
+  return res;
+}
+
+template<class T> Matrix<T> Matrix<T>::add(const Matrix<T> rhs)
+{
+  Matrix<T> res = *this;
+  res += rhs;
+  return res;
+}
+
+template<class T> Matrix<T> Matrix<T>::subtract(const Matrix<T> rhs)
+{
+  Matrix<T> res = *this;
+  res -= rhs;
+  return res;
+}
\ No newline at end of file
diff --git a/src/slowmokit/ducks/matrix/matrix.hpp b/src/slowmokit/ducks/matrix/matrix.hpp
index 4ccf044..6a6343c 100644
--- a/src/slowmokit/ducks/matrix/matrix.hpp
+++ b/src/slowmokit/ducks/matrix/matrix.hpp
@@ -55,7 +55,7 @@ template<class T = int> class Matrix
    * @param scalar: Number with which you want to multiply matrix with
    * @returns: Matrix after multiplying current matrix with scalar
    */
-  Matrix &operator*=(const T &);
+  template<class G> Matrix &operator*=(const G &);
 
 
   /**
@@ -69,6 +69,22 @@ template<class T = int> class Matrix
   Matrix &operator*=(const Matrix &);
 
 
+  /**
+   * @brief Overloading += to add a matrix with a scalar
+   * @param scalar: Number with which you want to add matrix with
+   * @returns: Matrix after adding current matrix with scalar
+   */
+  template<class G> Matrix &operator+=(const G &);
+
+
+  /**
+   * @brief Overloading -= to subtract a matrix with a scalar
+   * @param scalar: Number with which you want to subtract matrix with
+   * @returns: Matrix after subtracting scalar from current matrix
+   */
+  template<class G> Matrix &operator-=(const G &);
+
+
   /**
    * @brief function to get dimension of the matrix
    */
@@ -84,10 +100,6 @@ template<class T = int> class Matrix
    */
   Matrix &dot(const Matrix &);
 
-  /**
-   * @brief
-   */
-
 
   /**
    * @brief overloading += operator for adding another matrix to existing matrix
@@ -122,21 +134,48 @@ template<class T = int> class Matrix
    */
   const std::vector<T> &operator[](int) const;
 
+
+  /**
+   * @brief This function will multiply two matrix
+   * @param rhs: This is the matrix which will be multiplied with the main
+   * matrix
+   * @throw: whatever operator *= throws
+   */
+  Matrix matmul(const Matrix);
+
+
   /**
-   * @brief overloading << for easy printing of Matrix
+   * @brief This function will add 2 matrix
+   * @param rhs: This is the matrix which will be added with the main matrix
+   * @throw: whatever operator *= throws
    */
-  friend std::ostream &operator<<(std::ostream &, const Matrix &);
+  Matrix add(const Matrix);
+
+
+  /**
+   * @brief This function will subtract 2 matrix
+   * @param rhs: This is the matrix which will be subtracted from the main
+   * matrix
+   * @throw: whatever operator *= throws
+   */
+  Matrix subtract(const Matrix);
 };
 
+
+/**
+ * @brief overloading << for easy printing of Matrix
+ */
+template<class T> std::ostream &operator<<(std::ostream &, const Matrix<T> &);
+
 /**
  * @brief Free Function to multiply a matrix to a number or another matrix
  * @param lhs: A number or a Matrix
  * @param rhs: A number (only if lhs is not a number) or a Matrix
  * @returns Matrix Object
  */
-template<class T> Matrix<T> operator*(T, const Matrix<T> &);
-template<class T> Matrix<T> operator*(Matrix<T>, const T &);
-template<class T> Matrix<T> operator*(Matrix<T> lhs, const Matrix<T> &rhs);
+template<class T, class G> Matrix<T> operator*(G, const Matrix<T> &);
+template<class T, class G> Matrix<T> operator*(Matrix<T>, const G &);
+template<class T> Matrix<T> operator*(Matrix<T>, const Matrix<T> &);
 
 /**
  * @brief Free Function to add a matrix to a number or another matrix
@@ -144,9 +183,9 @@ template<class T> Matrix<T> operator*(Matrix<T> lhs, const Matrix<T> &rhs);
  * @param rhs: A number (only if lhs is not a number) or a Matrix
  * @returns Matrix Object
  */
-template<class T> Matrix<T> operator+(T, const Matrix<T> &);
-template<class T> Matrix<T> operator+(Matrix<T>, const T &);
-template<class T> Matrix<T> operator+(Matrix<T> lhs, const Matrix<T> &rhs);
+template<class T, class G> Matrix<T> operator+(G, const Matrix<T> &);
+template<class T, class G> Matrix<T> operator+(Matrix<T>, const G &);
+template<class T> Matrix<T> operator+(Matrix<T>, const Matrix<T> &);
 
 /**
  * @brief Free Function to subtract a matrix to a number or another matrix
@@ -154,9 +193,9 @@ template<class T> Matrix<T> operator+(Matrix<T> lhs, const Matrix<T> &rhs);
  * @param rhs: A number (only if lhs is not a number) or a Matrix
  * @returns Matrix Object
  */
-template<class T> Matrix<T> operator-(T, const Matrix<T> &);
-template<class T> Matrix<T> operator-(Matrix<T>, const T &);
-template<class T> Matrix<T> operator-(Matrix<T> lhs, const Matrix<T> &rhs);
+template<class T, class G> Matrix<T> operator-(G, const Matrix<T> &);
+template<class T, class G> Matrix<T> operator-(Matrix<T>, const G &);
+template<class T> Matrix<T> operator-(Matrix<T>, const Matrix<T> &);
 
 
 #endif // SLOWMOKIT_IO_HPP