Write A Program For Multiplication Of Two 3 3 Matrix In C++

Multiplying matrices is a fundamental operation in linear algebra, widely used across various scientific and engineering disciplines. In this article, you will learn how to write a C++ program to perform the multiplication of two 3x3 matrices efficiently.

Problem Statement

The challenge is to multiply two 3x3 matrices, say matrix A and matrix B, to produce a resulting 3x3 matrix C. Matrix multiplication is not element-wise; instead, each element C[i][j] of the resulting matrix is calculated as the sum of the products of elements from row i of the first matrix and column j of the second matrix. This operation requires careful handling of indices and nested loops.

Example

Consider two 3x3 matrices:

Matrix A:

1 2 3
4 5 6
7 8 9

Matrix B:

9 8 7
6 5 4
3 2 1

The resulting matrix C after multiplication would be:

(1*9 + 2*6 + 3*3) (1*8 + 2*5 + 3*2) (1*7 + 2*4 + 3*1)
(4*9 + 5*6 + 6*3) (4*8 + 5*5 + 6*2) (4*7 + 5*4 + 6*1)
(7*9 + 8*6 + 9*3) (7*8 + 8*5 + 9*2) (7*7 + 8*4 + 9*1)

Which simplifies to:

(9 + 12 + 9) (8 + 10 + 6) (7 + 8 + 3)
(36 + 30 + 18) (32 + 25 + 12) (28 + 20 + 6)
(63 + 48 + 27) (56 + 40 + 18) (49 + 32 + 9)

Final Result Matrix C:

30 24 18
84 69 54
138 114 90

Background & Knowledge Prerequisites

To understand this article, readers should have a basic understanding of:

• C++ Variables and Data Types: How to declare and use integer and floating-point types.
• Arrays: Specifically, two-dimensional arrays to represent matrices.
• Loops: for loops are essential for iterating through matrix elements.
• Basic I/O Operations: Using cout for printing output.

Use Cases or Case Studies

Matrix multiplication is a cornerstone in many computational fields:

• Computer Graphics: Used extensively for transformations like rotation, scaling, and translation of 3D objects.
• Physics and Engineering: Solving systems of linear equations, simulating physical phenomena, and analyzing structures.
• Machine Learning and Data Science: Core operation in neural networks, principal component analysis (PCA), and various algorithms for data manipulation and transformation.
• Cryptography: Involved in encrypting and decrypting data using linear transformations.
• Image Processing: Applying filters, transformations, and feature extraction from images.

Solution Approaches

The standard method for multiplying two matrices involves a triple-nested loop structure. Each element of the resulting matrix C is computed by iterating through the rows of the first matrix, the columns of the second matrix, and then summing products along the inner dimension.

Standard Matrix Multiplication Algorithm

This approach directly implements the mathematical definition of matrix multiplication. It is straightforward and widely used for fixed-size matrices.

• One-line summary: Iterates through rows of the first matrix, columns of the second, and an inner loop for summing products.

// 3x3 Matrix Multiplication
#include <iostream>
#include <iomanip> // For std::setw

int main() {
    // Step 1: Declare and initialize two 3x3 matrices (matrixA, matrixB)
    int matrixA[3][3] = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };

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

    // Step 2: Declare a 3x3 matrix to store the result (resultMatrix)
    int resultMatrix[3][3];

    // Step 3: Initialize resultMatrix with zeros
    for (int i = 0; i < 3; ++i) {
        for (int j = 0; j < 3; ++j) {
            resultMatrix[i][j] = 0;
        }
    }

    // Step 4: Perform matrix multiplication
    // Outer loops iterate through rows of matrixA (i) and columns of matrixB (j)
    for (int i = 0; i < 3; ++i) {
        for (int j = 0; j < 3; ++j) {
            // Inner loop calculates the dot product of row 'i' of matrixA
            // and column 'j' of matrixB
            for (int k = 0; k < 3; ++k) {
                resultMatrix[i][j] += matrixA[i][k] * matrixB[k][j];
            }
        }
    }

    // Step 5: Print the original matrices for verification
    std::cout << "Matrix A:" << std::endl;
    for (int i = 0; i < 3; ++i) {
        for (int j = 0; j < 3; ++j) {
            std::cout << std::setw(4) << matrixA[i][j];
        }
        std::cout << std::endl;
    }

    std::cout << "\\nMatrix B:" << std::endl;
    for (int i = 0; i < 3; ++i) {
        for (int j = 0; j < 3; ++j) {
            std::cout << std::setw(4) << matrixB[i][j];
        }
        std::cout << std::endl;
    }

    // Step 6: Print the resulting matrix
    std::cout << "\\nResultant Matrix (A * B):" << std::endl;
    for (int i = 0; i < 3; ++i) {
        for (int j = 0; j < 3; ++j) {
            std::cout << std::setw(4) << resultMatrix[i][j];
        }
        std::cout << std::endl;
    }

    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

Resultant Matrix (A * B):
  30  24  18
  84  69  54
 138 114  90

Stepwise explanation:

1. Matrix Declaration and Initialization: Two 3x3 integer arrays, matrixA and matrixB, are declared and initialized with specific values. These represent the matrices to be multiplied.
2. Result Matrix Declaration: A third 3x3 integer array, resultMatrix, is declared. This array will store the product of matrixA and matrixB.
3. Initialization of Result Matrix: Before calculation, all elements of resultMatrix are set to 0. This is crucial because values will be added to these elements in the multiplication step.
4. Matrix Multiplication Logic:

• The outermost loop (for int i) iterates through the rows of matrixA.
• The second loop (for int j) iterates through the columns of matrixB.
• For each combination of i and j, the innermost loop (for int k) performs the core multiplication. It takes elements from row i of matrixA (matrixA[i][k]) and elements from column j of matrixB (matrixB[k][j]), multiplies them, and adds the product to resultMatrix[i][j]. The k index ensures we traverse across the current row of matrixA and down the current column of matrixB.

1. Printing Matrices: The program then prints matrixA, matrixB, and resultMatrix using nested loops to display their contents in a clear, matrix-like format. std::setw(4) is used for consistent spacing.

Conclusion

Implementing 3x3 matrix multiplication in C++ is a straightforward application of nested loops, directly translating the mathematical definition into code. This fundamental operation is vital for various computational tasks, from transforming graphics to solving complex scientific problems. By following the standard algorithm, you can reliably compute the product of matrices.

Summary

• Matrix multiplication involves summing products of elements from rows of the first matrix and columns of the second.
• A 3x3 matrix multiplication in C++ typically uses three nested for loops.
• The outermost loop iterates through rows of the first matrix.
• The middle loop iterates through columns of the second matrix.
• The innermost loop calculates the sum of products for each element of the result matrix.
• Matrix multiplication is a core operation in computer graphics, physics, and machine learning.