Matrix Operations (addition Subtraction And Multiplication) In C++

Matrices are fundamental mathematical objects used extensively in computer science, engineering, and data analysis. Performing operations like addition, subtraction, and multiplication on matrices is a common task in various programming applications.

In this article, you will learn how to implement matrix addition, subtraction, and multiplication in C++ using two-dimensional arrays.

Problem Statement

Many computational problems require manipulating matrices. Whether it's processing image data, solving systems of linear equations, or performing transformations in computer graphics, the ability to correctly perform basic matrix operations is essential. A common challenge is implementing these operations efficiently and clearly in a programming language like C++.

Example

Consider two simple 2x2 matrices:

Matrix A:

1 2
3 4

 

 

Matrix B:

5 6
7 8

 

 

Their sum (A + B) would be:

1+5  2+6   ->   6  8
3+7  4+8   ->  10 12

 

 

Background & Knowledge Prerequisites

To understand and implement matrix operations in C++, you should be familiar with:

• C++ Basics: Variables, data types, input/output operations.
• Arrays: Specifically, two-dimensional arrays (or "arrays of arrays") to represent matrices.
• Loops: for loops are crucial for iterating through matrix elements.
• Functions: Understanding how to define and call functions to encapsulate matrix operations.

 

Relevant setup information: No specific libraries beyond the standard iostream are needed for these basic operations.

Use Cases or Case Studies

Matrix operations are vital in many fields:

• Computer Graphics: Used for transformations (scaling, rotation, translation) of 3D objects, projection, and rendering.
• Image Processing: Operations like blurring, sharpening, and edge detection often involve applying matrix convolutions to image pixel data.
• Linear Algebra: Essential for solving systems of linear equations, finding eigenvalues, and performing decompositions.
• Machine Learning: Core to many algorithms, especially in neural networks where weights and inputs are often represented as matrices, and operations like dot products are frequent.
• Physics and Engineering: Employed in simulations, structural analysis, and solving differential equations.

 

Solution Approaches

Here, we will demonstrate the implementation of matrix addition, subtraction, and multiplication in C++. We will use 2D arrays for representing matrices.

1. Matrix Addition

Adding two matrices involves summing their corresponding elements. This operation is only possible if both matrices have the same number of rows and columns.

• One-line summary: Element-wise sum of two matrices of identical dimensions.

 

// Matrix Addition
#include <iostream>

// Function to print a matrix
void printMatrix(int matrix[3][3], int rows, int cols) {
    for (int i = 0; i < rows; ++i) {
        for (int j = 0; j < cols; ++j) {
            std::cout << matrix[i][j] << " ";
        }
        std::cout << std::endl;
    }
}

int main() {
    // Step 1: Define two matrices (A and B) and a result matrix (C)
    // For addition, matrices must have the same dimensions.
    const int ROWS = 3;
    const int COLS = 3;

    int matrixA[ROWS][COLS] = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };

    int matrixB[ROWS][COLS] = {
        {9, 8, 7},
        {6, 5, 4},
        {3, 2, 1}
    };

    int matrixC[ROWS][COLS]; // To store the result of addition

    std::cout << "Matrix A:" << std::endl;
    printMatrix(matrixA, ROWS, COLS);
    std::cout << std::endl;

    std::cout << "Matrix B:" << std::endl;
    printMatrix(matrixB, ROWS, COLS);
    std::cout << std::endl;

    // Step 2: Perform matrix addition
    std::cout << "Performing Matrix Addition (A + B)..." << std::endl;
    for (int i = 0; i < ROWS; ++i) {
        for (int j = 0; j < COLS; ++j) {
            matrixC[i][j] = matrixA[i][j] + matrixB[i][j];
        }
    }

    // Step 3: Print the result matrix
    std::cout << "Result Matrix (A + B):" << std::endl;
    printMatrix(matrixC, ROWS, COLS);

    return 0;
}

Run

• Sample output:

Matrix A:
1 2 3 
4 5 6 
7 8 9 

Matrix B:
9 8 7 
6 5 4 
3 2 1 

Performing Matrix Addition (A + B)...
Result Matrix (A + B):
10 10 10 
10 10 10 
10 10 10

 

• Stepwise explanation:

1. Two 3x3 matrices, matrixA and matrixB, are initialized. A matrixC of the same dimensions is declared to store the sum.
2. Nested for loops iterate through each element's row (i) and column (j).
3. For each corresponding position, matrixA[i][j] and matrixB[i][j] are added, and the result is stored in matrixC[i][j].
4. Finally, the printMatrix function displays the resultant sum matrix.

2. Matrix Subtraction

Similar to addition, matrix subtraction involves subtracting corresponding elements. This operation also requires both matrices to have the same dimensions.

• One-line summary: Element-wise subtraction of two matrices of identical dimensions.

 

// Matrix Subtraction
#include <iostream>

// Function to print a matrix
void printMatrix(int matrix[3][3], int rows, int cols) {
    for (int i = 0; i < rows; ++i) {
        for (int j = 0; j < cols; ++j) {
            std::cout << matrix[i][j] << " ";
        }
        std::cout << std::endl;
    }
}

int main() {
    // Step 1: Define two matrices (A and B) and a result matrix (C)
    // For subtraction, matrices must have the same dimensions.
    const int ROWS = 3;
    const int COLS = 3;

    int matrixA[ROWS][COLS] = {
        {10, 10, 10},
        {10, 10, 10},
        {10, 10, 10}
    };

    int matrixB[ROWS][COLS] = {
        {9, 8, 7},
        {6, 5, 4},
        {3, 2, 1}
    };

    int matrixC[ROWS][COLS]; // To store the result of subtraction

    std::cout << "Matrix A:" << std::endl;
    printMatrix(matrixA, ROWS, COLS);
    std::cout << std::endl;

    std::cout << "Matrix B:" << std::endl;
    printMatrix(matrixB, ROWS, COLS);
    std::cout << std::endl;

    // Step 2: Perform matrix subtraction
    std::cout << "Performing Matrix Subtraction (A - B)..." << std::endl;
    for (int i = 0; i < ROWS; ++i) {
        for (int j = 0; j < COLS; ++j) {
            matrixC[i][j] = matrixA[i][j] - matrixB[i][j];
        }
    }

    // Step 3: Print the result matrix
    std::cout << "Result Matrix (A - B):" << std::endl;
    printMatrix(matrixC, ROWS, COLS);

    return 0;
}

Run

• Sample output:

Matrix A:
10 10 10 
10 10 10 
10 10 10 

Matrix B:
9 8 7 
6 5 4 
3 2 1 

Performing Matrix Subtraction (A - B)...
Result Matrix (A - B):
1 2 3 
4 5 6 
7 8 9

 

• Stepwise explanation:

1. Two 3x3 matrices, matrixA and matrixB, are initialized. matrixC is declared for the result.
2. Nested for loops iterate through each element's row (i) and column (j).
3. For each position, matrixB[i][j] is subtracted from matrixA[i][j], and the result is stored in matrixC[i][j].
4. The printMatrix function then displays the resulting difference matrix.

3. Matrix Multiplication

Matrix multiplication is more complex than addition or subtraction. To multiply two matrices A (m x n) and B (n x p), the number of columns in A must equal the number of rows in B. The resulting matrix C will have dimensions m x p. Each element C[i][j] is computed as the sum of the products of elements from row i of A and column j of B.

• One-line summary: Row-by-column sum of products, requiring inner dimensions to match.

 

// Matrix Multiplication
#include <iostream>

// Function to print a matrix
void printMatrix(int matrix[3][3], int rows, int cols) {
    for (int i = 0; i < rows; ++i) {
        for (int j = 0; j < cols; ++j) {
            std::cout << matrix[i][j] << " ";
        }
        std::cout << std::endl;
    }
}

int main() {
    // Step 1: Define two matrices (A and B) and a result matrix (C)
    // For multiplication A (m x n) and B (n x p),
    // A's columns (n) must equal B's rows (n).
    // Result C will be (m x p).
    const int A_ROWS = 3;
    const int A_COLS = 3; // Must be equal to B_ROWS
    const int B_ROWS = 3; // Must be equal to A_COLS
    const int B_COLS = 3;

    int matrixA[A_ROWS][A_COLS] = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };

    int matrixB[B_ROWS][B_COLS] = {
        {1, 0, 0},
        {0, 1, 0},
        {0, 0, 1} // Identity matrix for simplicity, A * I = A
    };

    // Resultant matrix will have A_ROWS rows and B_COLS columns
    int matrixC[A_ROWS][B_COLS]; 

    // Initialize result matrix with zeros
    for (int i = 0; i < A_ROWS; ++i) {
        for (int j = 0; j < B_COLS; ++j) {
            matrixC[i][j] = 0;
        }
    }

    std::cout << "Matrix A:" << std::endl;
    printMatrix(matrixA, A_ROWS, A_COLS);
    std::cout << std::endl;

    std::cout << "Matrix B:" << std::endl;
    printMatrix(matrixB, B_ROWS, B_COLS);
    std::cout << std::endl;

    // Step 2: Perform matrix multiplication
    std::cout << "Performing Matrix Multiplication (A * B)..." << std::endl;
    for (int i = 0; i < A_ROWS; ++i) {          // Iterate through rows of matrixA
        for (int j = 0; j < B_COLS; ++j) {       // Iterate through columns of matrixB
            for (int k = 0; k < A_COLS; ++k) {   // Iterate through elements for sum
                matrixC[i][j] += matrixA[i][k] * matrixB[k][j];
            }
        }
    }

    // Step 3: Print the result matrix
    std::cout << "Result Matrix (A * B):" << std::endl;
    printMatrix(matrixC, A_ROWS, B_COLS);

    return 0;
}

Run

• Sample output:

Matrix A:
1 2 3 
4 5 6 
7 8 9 

Matrix B:
1 0 0 
0 1 0 
0 0 1 

Performing Matrix Multiplication (A * B)...
Result Matrix (A * B):
1 2 3 
4 5 6 
7 8 9

 

• Stepwise explanation:

1. matrixA (3x3) and matrixB (3x3 - an identity matrix for a simple verification) are defined. matrixC (3x3) is declared to store the product and initialized to all zeros.
2. Three nested for loops are used:
   • The outer loop (i) iterates through rows of matrixA.

• The middle loop (j) iterates through columns of matrixB.
• The innermost loop (k) calculates the dot product of the current row of matrixA and the current column of matrixB.

1. matrixC[i][j] accumulates the sum of matrixA[i][k] * matrixB[k][j].
2. The printMatrix function displays the final product matrix.

Conclusion

Implementing basic matrix operations like addition, subtraction, and multiplication in C++ primarily involves using nested loops to iterate through two-dimensional arrays. While addition and subtraction are straightforward element-wise operations, matrix multiplication requires a more complex algorithm involving a sum of products for each element in the resulting matrix. Understanding these fundamental implementations provides a solid basis for more advanced matrix manipulations.

Summary

• Matrix Addition: Sums corresponding elements of two matrices of the same dimensions.
• Matrix Subtraction: Subtracts corresponding elements of two matrices of the same dimensions.
• Matrix Multiplication: Computes the dot product of rows from the first matrix with columns from the second. Requires the number of columns in the first matrix to match the number of rows in the second.
• Implementation: Utilizes nested for loops to access and process elements within 2D arrays.
• Use Cases: Crucial in diverse fields such as computer graphics, image processing, linear algebra, and machine learning.