From 89a2aba0839d28e031e319d0b0e910826c0a2427 Mon Sep 17 00:00:00 2001
From: yashwanthyash225 <54032221+yashwanthyash225@users.noreply.github.com>
Date: Sat, 19 Dec 2020 18:45:36 +0530
Subject: [PATCH 1/3] Started doing Matrix operations

---
 dsalglib/dsalglib.h       |   1 +
 dsalglib/include/matrix.h | 154 +++++++++++++++++++++++++++++++++++++-
 2 files changed, 154 insertions(+), 1 deletion(-)

diff --git a/dsalglib/dsalglib.h b/dsalglib/dsalglib.h
index dffb23a..bb632de 100644
--- a/dsalglib/dsalglib.h
+++ b/dsalglib/dsalglib.h
@@ -16,5 +16,6 @@
 #include "include/tree.h"
 #include "include/heap.h"
 #include "include/graph.h"
+#include "include/matrix.h"
 
 #endif //DSALGLIB_DSALGLIB_H
diff --git a/dsalglib/include/matrix.h b/dsalglib/include/matrix.h
index 2c4c34d..027246c 100644
--- a/dsalglib/include/matrix.h
+++ b/dsalglib/include/matrix.h
@@ -4,9 +4,161 @@
 
 #ifndef DSALGLIB_MATRIX_H
 #define DSALGLIB_MATRIX_H
+#include "array.h"
 namespace dsa
 {
+    template<typename type>
+    array< array<type> > matrix_add(array< array<type> > arr1,array< array<type> > arr2)
+    {
+        long long int n1 = arr1.size(), n2 = arr2.size(), m1 = arr1[0].size(), m2=arr2[0].size();
+        array<type> a(m1);
+        array< array<type> > re(n1);
+        for(int i=0;i<n1;i++)
+        re[i]=a;
+        for(int i=0;i<n1;i++)
+        {
+            for(int j=0;j<m1;j++)
+            {
+                re[i][j]=arr1[i][j]+arr2[i][j];
+            }
+        }
+        return re;
+    }
 
-}
+    template<typename type>
+    array< array<type> > matrix_mul(array< array<type> > arr1,array< array<type> > arr2)
+    {
+        long long int n1 = arr1.size(), n2 = arr2.size(), m1 = arr1[0].size(), m2=arr2[0].size();
+        array<type> a(m2);
+        array< array<type> > re(n1);
+        for(int i=0;i<n1;i++)
+        re[i]=a;
+        for(int i=0;i<n1;i++)
+        {
+            for(int j=0;j<m2;j++)
+            {
+                for(int k=0;k<m1;k++)
+                {
+                    re[i][j]=re[i][j]+arr1[i][k]*arr2[k][j];
+                }
+            }
+        }
+        return re;
+    }
+
+    template<typename type>
+    array< array<type> > matrix_sub(array< array<type> > arr1,array< array<type> > arr2)
+    {
+        long long int n1 = arr1.size(), n2 = arr2.size(), m1 = arr1[0].size(), m2=arr2[0].size();
+        array<type> a(m1);
+        array< array<type> > re(n1);
+        for(int i=0;i<n1;i++)
+        re[i]=a;
+        for(int i=0;i<n1;i++)
+        {
+            for(int j=0;j<m1;j++)
+            {
+                
+                re[i][j]=arr1[i][j]-arr2[i][j];
+            }
+        }
+        return re;
+    }
+
+    template<typename type>
+    array< array<type> > matrix_cons_add(array< array<type> > arr1, type par)
+    {
+        long long int n1 = arr1.size(), m1 = arr1[0].size();
+        array<type> a(m1);
+        array< array<type> > re(n1);
+        for(int i=0;i<n1;i++)
+        re[i]=a;
+        for(int i=0;i<n1;i++)
+        {
+            for(int j=0;j<m1;j++)
+            {
+                
+                re[i][j]=arr1[i][j]+par;
+            }
+        }
+        return re;
+    }
+
+    template<typename type>
+    array< array<type> > matrix_cons_sub(array< array<type> > arr1, type par)
+    {
+        long long int n1 = arr1.size(), m1 = arr1[0].size();
+        array<type> a(m1);
+        array< array<type> > re(n1);
+        for(int i=0;i<n1;i++)
+        re[i]=a;
+        for(int i=0;i<n1;i++)
+        {
+            for(int j=0;j<m1;j++)
+            {
+                
+                re[i][j]=arr1[i][j]-par;
+            }
+        }
+        return re;
+    }
 
+    template<typename type>
+    array< array<type> > matrix_cons_mul(array< array<type> > arr1, type par)
+    {
+        long long int n1 = arr1.size(), m1 = arr1[0].size();
+        array<type> a(m1);
+        array< array<type> > re(n1);
+        for(int i=0;i<n1;i++)
+        re[i]=a;
+        for(int i=0;i<n1;i++)
+        {
+            for(int j=0;j<m1;j++)
+            {
+                
+                re[i][j]=arr1[i][j]*par;
+            }
+        }
+        return re;
+    }
+
+    template<typename type>
+    array< array<type> > matrix_cons_div(array< array<type> > arr1, type par)
+    {
+        long long int n1 = arr1.size(), m1 = arr1[0].size();
+        array<type> a(m1);
+        array< array<type> > re(n1);
+        for(int i=0;i<n1;i++)
+        re[i]=a;
+        for(int i=0;i<n1;i++)
+        {
+            for(int j=0;j<m1;j++)
+            {
+                
+                re[i][j]=arr1[i][j]/par;
+            }
+        }
+        return re;
+    }
+
+    template<typename type>
+    array< array<type> > matrix_transpose(array< array<type> > arr1)
+    {
+        long long int n1 = arr1.size(), m1 = arr1[0].size();
+        array<type> a(n1);
+        array< array<type> > re(m1);
+        for(int i=0;i<n1;i++)
+        re[i]=a;
+        for(int i=0;i<m1;i++)
+        {
+            for(int j=0;j<n1;j++)
+            {
+                
+                re[i][j]=arr1[j][i];
+            }
+        }
+        return re;
+    }
+
+}
 #endif //DSALGLIB_MATRIX_H

From a1e9a0473976e8dbdc7c8b4804269effb8c90f64 Mon Sep 17 00:00:00 2001
From: yashwanthyash225 <54032221+yashwanthyash225@users.noreply.github.com>
Date: Sun, 20 Dec 2020 01:03:54 +0530
Subject: [PATCH 2/3] Added matrix operations

---
 dsalglib/include/matrix.h | 280 +++++++++++++++++++++++++++++++-------
 1 file changed, 228 insertions(+), 52 deletions(-)

diff --git a/dsalglib/include/matrix.h b/dsalglib/include/matrix.h
index 027246c..b0f24ad 100644
--- a/dsalglib/include/matrix.h
+++ b/dsalglib/include/matrix.h
@@ -1,7 +1,3 @@
-//
-// Created by moghya_s on 12/26/2016.
-//
-
 #ifndef DSALGLIB_MATRIX_H
 #define DSALGLIB_MATRIX_H
 #include "array.h"
@@ -9,17 +5,48 @@ namespace dsa
 {
     template<typename type>
     array< array<type> > matrix_add(array< array<type> > arr1,array< array<type> > arr2)
+    {
+        long long int n1 = arr1.size(), n2 = arr2.size();
+        long long int m1 = arr1[0].size(), m2=arr2[0].size();
+        array< array<type> > re(n1);
+        for(int i=0;i<n1;i++)
+        {
+            re[i]=array<type>(m1);
+            for(int j=0;j<m1;j++)
+            {
+                re[i][j]=arr1[i][j]+arr2[i][j];
+            }
+        }
+        return re;
+    }
+
+    template<typename type>
+    array< array<type> > matrix_sub(array< array<type> > arr1,array< array<type> > arr2)
     {
         long long int n1 = arr1.size(), n2 = arr2.size(), m1 = arr1[0].size(), m2=arr2[0].size();
-        array<type> a(m1);
         array< array<type> > re(n1);
         for(int i=0;i<n1;i++)
-        re[i]=a;
+        {
+            re[i]=array<type>(m1);
+            for(int j=0;j<m1;j++)
+            {
+                re[i][j]=arr1[i][j]-arr2[i][j];
+            }
+        }
+        return re;
+    }
+
+    template<typename type>
+    array< array<type> > matrix_multwo(array< array<type> > arr1,array< array<type> > arr2)
+    {
+        long long int n1 = arr1.size(), n2 = arr2.size(), m1 = arr1[0].size(), m2=arr2[0].size();
+        array< array<type> > re(n1);
         for(int i=0;i<n1;i++)
         {
+            re[i]=array<type>(m1);
             for(int j=0;j<m1;j++)
             {
-                re[i][j]=arr1[i][j]+arr2[i][j];
+                re[i][j]=arr1[i][j]*arr2[i][j];
             }
         }
         return re;
@@ -29,10 +56,9 @@ namespace dsa
     array< array<type> > matrix_mul(array< array<type> > arr1,array< array<type> > arr2)
     {
         long long int n1 = arr1.size(), n2 = arr2.size(), m1 = arr1[0].size(), m2=arr2[0].size();
-        array<type> a(m2);
         array< array<type> > re(n1);
         for(int i=0;i<n1;i++)
-        re[i]=a;
+        re[i]=array<type>(m2);
         for(int i=0;i<n1;i++)
         {
             for(int j=0;j<m2;j++)
@@ -47,118 +73,268 @@ namespace dsa
     }
 
     template<typename type>
-    array< array<type> > matrix_sub(array< array<type> > arr1,array< array<type> > arr2)
+    array< array<type> > matrix_cons_add(array< array<type> > arr, type par)
     {
-        long long int n1 = arr1.size(), n2 = arr2.size(), m1 = arr1[0].size(), m2=arr2[0].size();
-        array<type> a(m1);
+        long long int n1 = arr.size(), m1 = arr[0].size();
         array< array<type> > re(n1);
         for(int i=0;i<n1;i++)
-        re[i]=a;
-        for(int i=0;i<n1;i++)
         {
+            re[i]=array<type>(m1);
             for(int j=0;j<m1;j++)
             {
                 
-                re[i][j]=arr1[i][j]-arr2[i][j];
+                re[i][j]=arr[i][j]+par;
             }
         }
         return re;
-    }
+    } 
 
     template<typename type>
-    array< array<type> > matrix_cons_add(array< array<type> > arr1, type par)
+    array< array<type> > matrix_cons_sub(array< array<type> > arr, type par)
     {
-        long long int n1 = arr1.size(), m1 = arr1[0].size();
-        array<type> a(m1);
+        long long int n1 = arr.size(), m1 = arr[0].size();
         array< array<type> > re(n1);
         for(int i=0;i<n1;i++)
-        re[i]=a;
-        for(int i=0;i<n1;i++)
         {
+            re[i]=array<type>(m1);
             for(int j=0;j<m1;j++)
             {
-                
-                re[i][j]=arr1[i][j]+par;
+                re[i][j]=arr[i][j]-par;
             }
         }
         return re;
     }
 
     template<typename type>
-    array< array<type> > matrix_cons_sub(array< array<type> > arr1, type par)
+    array< array<type> > matrix_cons_mul(array< array<type> > arr, type par)
     {
-        long long int n1 = arr1.size(), m1 = arr1[0].size();
-        array<type> a(m1);
+        long long int n1 = arr.size(), m1 = arr[0].size();
         array< array<type> > re(n1);
         for(int i=0;i<n1;i++)
-        re[i]=a;
-        for(int i=0;i<n1;i++)
         {
+            re[i]=array<type>(m1);
             for(int j=0;j<m1;j++)
             {
-                
-                re[i][j]=arr1[i][j]-par;
+                re[i][j]=arr[i][j]*par;
             }
         }
         return re;
     }
 
     template<typename type>
-    array< array<type> > matrix_cons_mul(array< array<type> > arr1, type par)
+    array< array<float> > matrix_cons_div(array< array<type> > arr, float par)
     {
-        long long int n1 = arr1.size(), m1 = arr1[0].size();
-        array<type> a(m1);
-        array< array<type> > re(n1);
-        for(int i=0;i<n1;i++)
-        re[i]=a;
+        long long int n1 = arr.size(), m1 = arr[0].size();
+        array< array<float> > re(n1);
         for(int i=0;i<n1;i++)
         {
+            re[i]=array<float>(m1);
             for(int j=0;j<m1;j++)
             {
-                
-                re[i][j]=arr1[i][j]*par;
+                re[i][j]=arr[i][j]/par;
             }
         }
         return re;
     }
 
     template<typename type>
-    array< array<type> > matrix_cons_div(array< array<type> > arr1, type par)
+    array< array<float> > matrix_oneby(array< array<type> > arr)
     {
-        long long int n1 = arr1.size(), m1 = arr1[0].size();
-        array<type> a(m1);
-        array< array<type> > re(n1);
-        for(int i=0;i<n1;i++)
-        re[i]=a;
+        long long int n1 = arr.size(), m1 = arr[0].size();
+        array< array<float> > re(n1);
+        float temp=1;
         for(int i=0;i<n1;i++)
         {
+            re[i]=array<float>(m1);
             for(int j=0;j<m1;j++)
             {
-                
-                re[i][j]=arr1[i][j]/par;
+                re[i][j]=temp/arr[i][j];
             }
         }
         return re;
     }
 
     template<typename type>
-    array< array<type> > matrix_transpose(array< array<type> > arr1)
+    array< array<type> > matrix_transpose(array< array<type> > arr)
     {
-        long long int n1 = arr1.size(), m1 = arr1[0].size();
-        array<type> a(n1);
+        long long int n1 = arr.size(), m1 = arr[0].size();
         array< array<type> > re(m1);
-        for(int i=0;i<n1;i++)
-        re[i]=a;
         for(int i=0;i<m1;i++)
         {
+            re[i]=array<type>(n1);
             for(int j=0;j<n1;j++)
             {
+                re[i][j]=arr[j][i];
+            }
+        }
+        return re;
+    }
+
+    template<typename type>
+    array< array<type> > submatrix(array< array<type> > arr, long long int i1, long long int j1, long long int i2, long long int j2)
+    {
+        long long int n = i2-i1+1, m = j2-j1+1;
+        array< array<type> > re(n);
+        int k1=0,k2=0;
+        for(int i=i1;i<=i2;i++)
+        {
+            re[k1]=array<type>(m);
+            for(int j=j1;j<=j2;j++)
+            {
+                re[k1][k2]=arr[i][j];
+                k2++;
+            }
+            k1++;
+            k2=0;
+        }
+        return re;
+    }
+
+    array< array<int> > matrix_zeros(long long int n, long long int m)
+    {
+        array< array<int> > re(n);
+        for(int i=0;i<n;i++)
+        re[i]=array<int>(m);
+        return re;
+    }
+
+    array< array<int> > matrix_ones(long long int n, long long int m)
+    {
+        array<int>a(m);
+        for(int i=0;i<m;i++)
+        a[i]=1;
+        array< array<int> > re(n);
+        for(int i=0;i<n;i++)
+        re[i]=a;
+        return re;
+    }
+
+    template<typename type>
+    array< array<type> > matrix_powerby(array< array<type> > arr, int par)
+    {
+        long long int n1 = arr.size(), m1 = arr[0].size();
+        array< array<type> > re = matrix_ones(n1,m1);
+        for(int i=1;i<=par;i++)
+        {
+            re = matrix_multwo(re,arr);
+        }
+        return re;
+    }
+
+    array< array<int> > matrix_identity(long long int m)
+    {
+        array< array<int> > re(m);
+        for(int i=0;i<m;i++)
+        {
+            re[i]=array<int>(m);
+            for(int j=0;j<m;j++)
+            {
+                if(i==j)
+                re[i][j]=1;
+                else
+                {
+                    re[i][j]=0;
+                }
                 
-                re[i][j]=arr1[j][i];
             }
         }
         return re;
     }
 
+    template<typename type>
+    void getCofactor(array< array<type> > arr, array< array<type> > cotemp, int p, int q, long long int n)
+    {
+        int i = 0, j = 0;
+        for (int row = 0; row < n; row++)
+        {
+            for (int col = 0; col < n; col++) 
+            {
+                if (row != p && col != q) 
+                {
+                    cotemp[i][j++] = arr[row][col];
+                    if (j == n - 1) 
+                    {
+                        j = 0;
+                        i++;
+                    }
+                }
+            }
+        }
+    }
+
+    template<typename type>
+    long long int matrix_det(array< array<type> > arr, long long int n)
+    {
+        int D = 0;
+        if (n == 1)
+        return arr[0][0];
+        array<type>a(n);
+        array< array<type> > cotemp(n);
+        for(int i=0;i<n;i++)
+        cotemp[i]=a;
+        int sign = 1;
+        for (int i = 0; i < n; i++) 
+        {
+            getCofactor(arr, cotemp, 0, i, n);
+            D += sign * arr[0][i] * matrix_det(cotemp, n - 1);
+            sign = -sign;
+        }
+        return D;
+    }
+
+    template<typename type>
+    array< array<type> > matrix_adjoint(array< array<type> >arr)
+    {
+        long long int N = arr.size(); 
+        array< array<type> > adj(N);
+        array<type>a(N);
+        for(int i=0;i<N;i++)
+        adj[i]=a;
+        if (N == 1) 
+        { 
+            adj[0][0] = 1; 
+            return adj; 
+        } 
+        int sign = 1; 
+        array< array<type> > cotemp(N);
+        for(int i=0;i<N;i++)
+        cotemp[i]=a;
+        for (int i=0; i<N; i++) 
+        { 
+            for (int j=0; j<N; j++) 
+            { 
+                getCofactor(arr, cotemp, i, j, N); 
+                if((i+j)%2==0)
+                sign=1;
+                else
+                sign=-1;
+                adj[j][i] = (sign)*(matrix_det(cotemp, N-1)); 
+            } 
+        } 
+        return adj;
+    }
+
+    template<typename type>
+    array< array<float> > matrix_inverse(array< array<type> > arr)
+    {
+        int N = arr.size(); 
+        array< array<float> > re(N);
+        array<float>a(N);
+        for(int i=0;i<N;i++)
+        {
+            re[i]=a;
+        }
+        long long int det = matrix_det(arr, N); 
+        if (det == 0) 
+        { 
+            return re; 
+        } 
+        array< array<type> > adj=matrix_adjoint(arr); 
+        for (int i=0; i<N; i++) 
+            for (int j=0; j<N; j++) 
+                re[i][j] = adj[i][j]/float(det); 
+        return re; 
+    }
+
 }
 #endif //DSALGLIB_MATRIX_H

From c3612bf89141294b942d9cdedbbf25240d709120 Mon Sep 17 00:00:00 2001
From: yashwanthyash225 <54032221+yashwanthyash225@users.noreply.github.com>
Date: Sun, 20 Dec 2020 15:43:09 +0530
Subject: [PATCH 3/3] Added Matrix operations

---
 dsalglib/include/matrix.h | 69 ++++++++++++++++++++++++++++++++++++++-
 1 file changed, 68 insertions(+), 1 deletion(-)

diff --git a/dsalglib/include/matrix.h b/dsalglib/include/matrix.h
index b0f24ad..c17137e 100644
--- a/dsalglib/include/matrix.h
+++ b/dsalglib/include/matrix.h
@@ -3,6 +3,7 @@
 #include "array.h"
 namespace dsa
 {
+    // Addition of Matrices
     template<typename type>
     array< array<type> > matrix_add(array< array<type> > arr1,array< array<type> > arr2)
     {
@@ -20,6 +21,7 @@ namespace dsa
         return re;
     }
 
+    // Subtraction of Matrices
     template<typename type>
     array< array<type> > matrix_sub(array< array<type> > arr1,array< array<type> > arr2)
     {
@@ -36,6 +38,7 @@ namespace dsa
         return re;
     }
 
+    // Muliplying Matrices of same size
     template<typename type>
     array< array<type> > matrix_multwo(array< array<type> > arr1,array< array<type> > arr2)
     {
@@ -52,6 +55,7 @@ namespace dsa
         return re;
     }
 
+    // Matrix Multiplication
     template<typename type>
     array< array<type> > matrix_mul(array< array<type> > arr1,array< array<type> > arr2)
     {
@@ -72,6 +76,7 @@ namespace dsa
         return re;
     }
 
+    // Adding a constant to every element in Matrix
     template<typename type>
     array< array<type> > matrix_cons_add(array< array<type> > arr, type par)
     {
@@ -89,6 +94,7 @@ namespace dsa
         return re;
     } 
 
+    // Subtracting constant from every element of Matrix 
     template<typename type>
     array< array<type> > matrix_cons_sub(array< array<type> > arr, type par)
     {
@@ -105,6 +111,7 @@ namespace dsa
         return re;
     }
 
+    // Multiplying constant to every element of Matrix
     template<typename type>
     array< array<type> > matrix_cons_mul(array< array<type> > arr, type par)
     {
@@ -121,6 +128,7 @@ namespace dsa
         return re;
     }
 
+    // Dividing every element of Matrix by constant
     template<typename type>
     array< array<float> > matrix_cons_div(array< array<type> > arr, float par)
     {
@@ -137,6 +145,7 @@ namespace dsa
         return re;
     }
 
+    // reciprocal of every element in the matrix
     template<typename type>
     array< array<float> > matrix_oneby(array< array<type> > arr)
     {
@@ -154,6 +163,7 @@ namespace dsa
         return re;
     }
 
+    // get the transpose of Matrix
     template<typename type>
     array< array<type> > matrix_transpose(array< array<type> > arr)
     {
@@ -170,6 +180,7 @@ namespace dsa
         return re;
     }
 
+    // get the submatrix by giving top-left and bottom-right indices
     template<typename type>
     array< array<type> > submatrix(array< array<type> > arr, long long int i1, long long int j1, long long int i2, long long int j2)
     {
@@ -190,6 +201,7 @@ namespace dsa
         return re;
     }
 
+    // get the Matrix initialised with 0's
     array< array<int> > matrix_zeros(long long int n, long long int m)
     {
         array< array<int> > re(n);
@@ -198,6 +210,7 @@ namespace dsa
         return re;
     }
 
+    // get the Matrix initialised with 1's
     array< array<int> > matrix_ones(long long int n, long long int m)
     {
         array<int>a(m);
@@ -209,6 +222,7 @@ namespace dsa
         return re;
     }
 
+    // get the Matrix where every element is raised to power
     template<typename type>
     array< array<type> > matrix_powerby(array< array<type> > arr, int par)
     {
@@ -221,6 +235,7 @@ namespace dsa
         return re;
     }
 
+    // get the Identity Matrix initialised with size
     array< array<int> > matrix_identity(long long int m)
     {
         array< array<int> > re(m);
@@ -241,6 +256,7 @@ namespace dsa
         return re;
     }
 
+    // calculating Co-factors where this is used to find determinant and adjoint of Matrix
     template<typename type>
     void getCofactor(array< array<type> > arr, array< array<type> > cotemp, int p, int q, long long int n)
     {
@@ -262,10 +278,11 @@ namespace dsa
         }
     }
 
+    // Calculates the determinant of matrix
     template<typename type>
     long long int matrix_det(array< array<type> > arr, long long int n)
     {
-        int D = 0;
+        long long int D = 0;
         if (n == 1)
         return arr[0][0];
         array<type>a(n);
@@ -282,6 +299,7 @@ namespace dsa
         return D;
     }
 
+    // gets the Adjoint Matrix
     template<typename type>
     array< array<type> > matrix_adjoint(array< array<type> >arr)
     {
@@ -314,6 +332,7 @@ namespace dsa
         return adj;
     }
 
+    // get the Inverse of a Matrix
     template<typename type>
     array< array<float> > matrix_inverse(array< array<type> > arr)
     {
@@ -336,5 +355,53 @@ namespace dsa
         return re; 
     }
 
+    // convert to upper triangular Matrix
+    template<typename type>
+    array< array<type> > matrix_upper(array< array<type> > arr)
+    {
+        long long int n = arr.size(), m = arr[0].size();
+        array< array<type> >re(n);
+        for(int i=0;i<n;i++)
+        {
+            re[i]=array<type>(m);
+            for(int j=0;j<m;j++)
+            {
+                if(i>j)
+                {
+                    re[i][j]=0;
+                }
+                else
+                {
+                    re[i][j]=arr[i][j];
+                }
+            }
+        }
+        return re;
+    }
+
+    // convert to lower triangular matrix
+    template<typename type>
+    array< array<type> > matrix_lower(array< array<type> > arr)
+    {
+        long long int n = arr.size(), m = arr[0].size();
+        array< array<type> >re(n);
+        for(int i=0;i<n;i++)
+        {
+            re[i]=array<type>(m);
+            for(int j=0;j<m;j++)
+            {
+                if(j>i)
+                {
+                    re[i][j]=0;
+                }
+                else
+                {
+                    re[i][j]=arr[i][j];
+                }
+            }
+        }
+        return re;
+    }
+
 }
 #endif //DSALGLIB_MATRIX_H