Matrix operations using operator overloading

Pre-requisite: Operator Overloading
Given two matrix mat1[][] and mat2[][] of NxN dimensions, the task is to perform Matrix Operations using Operator Overloading.
Examples:

Input: arr1[][] = { {1, 2, 3}, {4, 5, 6}, {1, 2, 3}}, arr2[][] = { {1, 2, 3}, {4, 5, 16}, {1, 2, 3}}
Output:
Addition of two given Matrices is:
2 4 6
8 10 22
2 4 6
Subtraction of two given Matrices is:
0 0 0
0 0 -10
0 0 0
Multiplication of two given Matrices is:
12 18 44
30 45 110
12 18 44
Input: arr1[][] = { {11, 2, 3}, {4, 5, 0}, {1, 12, 3}}, arr2[][] = { {1, 2, 3}, {41, 5, 16}, {1, 22, 3}}
Output:
Addition of two given Matrices is :
12 4 6
45 10 16
2 34 6
Subtraction of two given Matrices is :
10 0 0
-37 0 -16
0 -10 0
Multiplication of two given Matrices is :
96 98 74
209 33 92
496 128 204

Approach:
To overload +, -, * operators, we will create a class named matrix and then make a public function to overload the operators.

To overload operator '+' use prototype:

Return_Type classname :: operator +(Argument list)
{
    // Function Body
}

For Example:

Let there are two matrix M1[][] and M2[][] of same dimensions. Using Operator Overloading M1[][] and M2[][] can be added as M1 + M2.

In the above statement M1 is treated as global and M2[][] is passed as an argument to the function "void Matrix::operator+(Matrix x)".

In the above overloaded function, the approach for addition of two matrix is implemented by treating M1[][] as first and M2[][] as second Matrix i.e., Matrix x(as the arguments).

To overload operator '-' use prototype:

Return_Type classname :: operator -(Argument list)
{
    // Function Body
}

For Example:

Let there are two matrix M1[][] and M2[][] of same dimensions. Using Operator Overloading M1[][] and M2[][] can be added as M1 - M2

In the above statement M1 is treated hai global and M2[][] is passed as an argument to the function "void Matrix::operator-(Matrix x)".

In the above overloaded function, the approach for subtraction of two matrix is implemented by treating M1[][] as first and M2[][] as second Matrix i.e., Matrix x(as the arguments).

To overload operator '*' use prototype:

Return_Type classname :: operator *(Argument list)
{
    // Function Body
}

Let there are two matrix M1[][] and M2[][] of same dimensions. Using Operator Overloading M1[][] and M2[][] can be added as M1 * M2.

In the above statement M1 is treated hai global and M2[][] is passed as an argument to the function "void Matrix::operator*(Matrix x)".

In the above overloaded function, the approach for multiplication of two matrix is implemented by treating M1[][] as first and M2[][] as second Matrix i.e., Matrix x(as the arguments).

Below is the implementation of the above approach:

C++

// C++ program for the above approach

#include "bits/stdc++.h"
#define rows 50
#define cols 50
using namespace std;

int N;

// Class for Matrix operator overloading
class Matrix {

    // For input Matrix
    int arr[rows][cols];

public:
    // Function to take input to arr[][]
    void input(vector<vector<int> >& A);
    void display();

    // Functions for operator overloading
    void operator+(Matrix x);
    void operator-(Matrix x);
    void operator*(Matrix x);
};

// Functions to get input to Matrix
// array arr[][]
void Matrix::input(vector<vector<int> >& A)
{

    // Traverse the vector A[][]
    for (int i = 0; i < N; i++) {

        for (int j = 0; j < N; j++) {

            arr[i][j] = A[i][j];
        }
    }
}

// Function to display the element
// of Matrix
void Matrix::display()
{

    for (int i = 0; i < N; i++) {

        for (int j = 0; j < N; j++) {

            // Print the element
            cout << arr[i][j] << ' ';
        }
        cout << endl;
    }
}

// Function for addition of two Matrix
// using operator overloading
void Matrix::operator+(Matrix x)
{
    // To store the sum of Matrices
    int mat[N][N];

    // Traverse the Matrix x
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {

            // Add the corresponding
            // blocks of Matrices
            mat[i][j] = arr[i][j]
                        + x.arr[i][j];
        }
    }

    // Display the sum of Matrices
    for (int i = 0; i < N; i++) {

        for (int j = 0; j < N; j++) {

            // Print the element
            cout << mat[i][j] << ' ';
        }
        cout << endl;
    }
}

// Function for subtraction of two Matrix
// using operator overloading
void Matrix::operator-(Matrix x)
{
    // To store the difference of Matrices
    int mat[N][N];

    // Traverse the Matrix x
    for (int i = 0; i < N; i++) {

        for (int j = 0; j < N; j++) {

            // Subtract the corresponding
            // blocks of Matrices
            mat[i][j] = arr[i][j]
                        - x.arr[i][j];
        }
    }

    // Display the difference of Matrices
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {

            // Print the element
            cout << mat[i][j] << ' ';
        }
        cout << endl;
    }
}

// Function for multiplication of
// two Matrix using operator
// overloading
void Matrix::operator*(Matrix x)
{
    // To store the multiplication
    // of Matrices
    int mat[N][N];

    // Traverse the Matrix x
    for (int i = 0; i < N; i++) {

        for (int j = 0; j < N; j++) {

            // Initialise current block
            // with value zero
            mat[i][j] = 0;

            for (int k = 0; k < N; k++) {
                mat[i][j] += arr[i][k]
                             * (x.arr[k][j]);
            }
        }
    }

    // Display the multiplication
    // of Matrices
    for (int i = 0; i < N; i++) {

        for (int j = 0; j < N; j++) {

            // Print the element
            cout << mat[i][j] << ' ';
        }
        cout << endl;
    }
}

// Driver Code
int main()
{

    // Dimension of Matrix
    N = 3;

    vector<vector<int> > arr1
        = { { 1, 2, 3 },
            { 4, 5, 6 },
            { 1, 2, 3 } };

    vector<vector<int> > arr2
        = { { 1, 2, 3 },
            { 4, 5, 16 },
            { 1, 2, 3 } };

    // Declare Matrices
    Matrix mat1, mat2;

    // Take Input to matrix mat1
    mat1.input(arr1);

    // Take Input to matrix mat2
    mat2.input(arr2);

    // For addition of matrix
    cout << "Addition of two given"
         << " Matrices is : \n";
    mat1 + mat2;

    // For subtraction of matrix
    cout << "Subtraction of two given"
         << " Matrices is : \n";
    mat1 - mat2;

    // For multiplication of matrix
    cout << "Multiplication of two"
         << " given Matrices is : \n";
    mat1* mat2;

    return 0;
}

Java

import java.util.*;

public class Matrix {

    int arr[][];
    int N;

    // Constructor to initialize
    // Matrix object
    public Matrix(int n)
    {
        N = n;
        arr = new int[N][N];
    }

    // Function to take input to arr[][]
    void input(List<List<Integer> > A)
    {

        // Traverse the List A[][]
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                arr[i][j] = A.get(i).get(j);
            }
        }
    }

    // Function to display the element of Matrix
    void display()
    {

        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                // Print the element
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }
    }

    // Function for addition of two Matrix using operator
    // overloading
    void add(Matrix x)
    {

        // To store the sum of Matrices
        int mat[][] = new int[N][N];

        // Traverse the Matrix x
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                // Add the corresponding blocks of Matrices
                mat[i][j] = arr[i][j] + x.arr[i][j];
            }
        }

        // Display the sum of Matrices
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                // Print the element
                System.out.print(mat[i][j] + " ");
            }
            System.out.println();
        }
    }

    // Function for subtraction of two Matrix using operator
    // overloading
    void subtract(Matrix x)
    {

        // To store the difference of Matrices
        int mat[][] = new int[N][N];

        // Traverse the Matrix x
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                // Subtract the corresponding blocks of
                // Matrices
                mat[i][j] = arr[i][j] - x.arr[i][j];
            }
        }

        // Display the difference of Matrices
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                // Print the element
                System.out.print(mat[i][j] + " ");
            }
            System.out.println();
        }
    }

    // Function for multiplication of two Matrix using
    // operator overloading
    public void multiply(Matrix x)
    {
        // To store the multiplication
        // of Matrices
        int[][] mat = new int[N][N];

        // Traverse the Matrix x
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                // Initialise current block
                // with value zero
                mat[i][j] = 0;
                for (int k = 0; k < N; k++) {
                    mat[i][j] += arr[i][k] * (x.arr[k][j]);
                }
            }
        }

        // Display the multiplication
        // of Matrices
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                // Print the element
                System.out.print(mat[i][j] + " ");
            }
            System.out.println();
        }
    }
    // Driver Code
    public static void main(String[] args)
    {

        // Dimension of Matrix
        int N = 3;

        List<List<Integer> > arr1 = Arrays.asList(
            Arrays.asList(1, 2, 3), Arrays.asList(4, 5, 6),
            Arrays.asList(1, 2, 3));

        List<List<Integer> > arr2 = Arrays.asList(
            Arrays.asList(1, 2, 3), Arrays.asList(4, 5, 16),
            Arrays.asList(1, 2, 3));

        // Declare Matrices
        Matrix mat1 = new Matrix(N);
        Matrix mat2 = new Matrix(N);

        // Take Input to matrix mat1
        mat1.input(arr1);

        // Take Input to matrix mat2
        mat2.input(arr2);

        // For addition of matrix
        System.out.println(
            "Addition of two given Matrices is : ");
        mat1.add(mat2);

        // For subtraction of matrix
        System.out.println(
            "Subtraction of two given Matrices is : ");
        mat1.subtract(mat2);

        // For multiplication of matrix
        System.out.println(
            "Multiplication of two given Matrices is : ");
        mat1.multiply(mat2);
    }
}

Python3

# Python program for the above approach

# Dimension of Matrix
N = 3
rows = 50
cols = 50

# Class for Matrix operator overloading
class Matrix:
    def __init__(self):
        
        # For input Matrix
        self.arr = [[0 for i in range(cols)] for j in range(rows)]

    # Functions to get input to Matrix
    # array arr[][]
    def input(self, A):
        
        # Traverse the vector A[][]
        for i in range(N):
            for j in range(N):
                self.arr[i][j] = A[i][j]

    # Function to display the element
    # of Matrix
    def display(self):
        for i in range(N):
            for j in range(N):
                
                # Print the element
                print(self.arr[i][j], end=' ')
            print()

    # Function for addition of two Matrix
    # using operator overloading
    def __add__(self, x):
        
        # To store the sum of Matrices
        mat = [[0 for i in range(N)] for j in range(N)]
        for i in range(N):
            for j in range(N):
                
                # Add the corresponding
                # blocks of Matrices
                mat[i][j] = self.arr[i][j] + x.arr[i][j]
            
        # Display the sum of Matrices
        for i in range(N):
            for j in range(N):
                
                # Print the element
                print(mat[i][j], end=' ')
            print()

    # Function for subtraction of two Matrix
    # using operator overloading
    def __sub__(self, x):
        
        # To store the difference of Matrices
        mat = [[0 for i in range(N)] for j in range(N)]
        
        # Traverse the Matrix x
        for i in range(N):
            for j in range(N):
                
                # Subtract the corresponding
                # blocks of Matrices
                mat[i][j] = self.arr[i][j] - x.arr[i][j]
                
        # Display the difference of Matrices
        for i in range(N):
            for j in range(N):
                
                # Print the element
                print(mat[i][j], end=' ')
            print()

    # Function for multiplication of
    # two Matrix using operator
    # overloading
    def __mul__(self, x):
        
        # To store the multiplication
        # of Matrices
        mat = [[0 for i in range(N)] for j in range(N)]
        
        # Traverse the Matrix x
        for i in range(N):
            for j in range(N):
                
                # Initialise current block
                # with value zero
                mat[i][j] = 0
                
                for k in range(N):
                    mat[i][j] += self.arr[i][k] * (x.arr[k][j])
        
        # Display the multiplication
        # of Matrices
        for i in range(N):
            for j in range(N):
                
                # Print the element
                print(mat[i][j], end=' ')
            print()

# Driver Code
arr1 = [[1, 2, 3],
        [4, 5, 6],
        [1, 2, 3]]

arr2 = [[1, 2, 3],
        [4, 5, 16],
        [1, 2, 3]]

# Declare Matrices
mat1 = Matrix()
mat2 = Matrix()

# Take Input to matrix mat1
mat1.input(arr1)

# Take Input to matrix mat2
mat2.input(arr2)

# For addition of matrix
print("Addition of two given Matrices is : ")
mat1 + mat2

# For subtraction of matrix
print("Subtraction of two given Matrices is : ")
mat1 - mat2

# For multiplication of matrix
print("Multiplication of two given Matrices is : ")
mat1 * mat2

JavaScript

function matrixAddition(matrix1, matrix2) {
  var result = [];

  for (var i = 0; i < matrix1.length; i++) {
    var row = [];

    for (var j = 0; j < matrix1[i].length; j++) {
      row.push(matrix1[i][j] + matrix2[i][j]);
    }

    result.push(row.join(" "));
  }

  return result.join("\n");
}

function matrixSubtraction(matrix1, matrix2) {
  var result = [];

  for (var i = 0; i < matrix1.length; i++) {
    var row = [];

    for (var j = 0; j < matrix1[i].length; j++) {
      row.push(matrix1[i][j] - matrix2[i][j]);
    }

    result.push(row.join(" "));
  }

  return result.join("\n");
}

function matrixMultiplication(matrix1, matrix2) {
  var result = [];

  for (var i = 0; i < matrix1.length; i++) {
    var row = [];

    for (var j = 0; j < matrix2[0].length; j++) {
      var sum = 0;

      for (var k = 0; k < matrix1[0].length; k++) {
        sum += matrix1[i][k] * matrix2[k][j];
      }

      row.push(sum);
    }

    result.push(row.join(" "));
  }

  return result.join("\n");
}

var matrix1 = [
  [1, 2, 3],
  [4, 5, 6],
  [1, 2, 3]
];

var matrix2 = [
  [1, 2, 3],
  [4, 5, 16],
  [1, 2, 3]
];

console.log("Addition of two given Matrices is: ");
console.log(matrixAddition(matrix1, matrix2));
console.log("\n");

console.log("Subtraction of two given Matrices is: ");
console.log(matrixSubtraction(matrix1, matrix2));
console.log("\n");

console.log("Multiplication of two given Matrices is: ");
console.log(matrixMultiplication(matrix1, matrix2));
console.log("\n");

Output

Addition of two given Matrices is : 
2 4 6 
8 10 22 
2 4 6 
Subtraction of two given Matrices is : 
0 0 0 
0 0 -10 
0 0 0 
Multiplication of two given Matrices is : 
12 18 44 
30 45 110 
12 18 44

Time Complexity:

The time complexity of the input() function is O(N^2) because it has to traverse the entire input matrix/vector of size NxN.
The time complexity of the display() function is also O(N^2) because it has to print all the elements of the matrix/vector.
The time complexity of the operator overloading functions for addition, subtraction, and multiplication of two matrices is O(N^3) because for each element in the output matrix, we need to calculate the sum/difference/product of N elements from the input matrices.
Therefore, the overall time complexity of the program is O(N^3) for each operator overload.

Auxiliary Space: O(N^2) because we need to store two matrices of size NxN in memory, which takes up O(N^2) space.

Matrix operations using operator overloading

Explore