Write A Program For 2 2 Matrix Multiplication In C

This article will guide you through creating a C program to perform multiplication of two 2x2 matrices. You will learn the fundamental logic behind matrix multiplication and how to implement it using nested loops in C.

Problem Statement

Matrix multiplication is a binary operation that produces a matrix from two matrices. For two matrices A (m x n) and B (n x p), their product C (m x p) is defined by the element $C_{ij}$ being the dot product of the $i$-th row of A and the $j$-th column of B. Specifically, for 2x2 matrices, we need to calculate each element of the resulting 2x2 matrix by summing the products of corresponding elements from the rows of the first matrix and columns of the second. This operation is fundamental in fields like computer graphics, physics, and data transformation.

Example

Consider two 2x2 matrices, Matrix A and Matrix B:

Matrix A

| 1  2 |
| 3  4 |

Matrix B

| 5  6 |
| 7  8 |

Their product, Matrix C, would be:

C[0][0] = (1*5) + (2*7) = 5 + 14 = 19
C[0][1] = (1*6) + (2*8) = 6 + 16 = 22
C[1][0] = (3*5) + (4*7) = 15 + 28 = 43
C[1][1] = (3*6) + (4*8) = 18 + 32 = 50

Result Matrix C

| 19  22 |
| 43  50 |

Background & Knowledge Prerequisites

To understand and implement matrix multiplication in C, familiarity with the following concepts is helpful:

• Variables and Data Types: Understanding int for integers.
• Arrays: Declaring and using two-dimensional arrays (e.g., int matrix[2][2];).
• Loops: Basic usage of for loops for iteration.
• Input/Output: Using printf() for output and scanf() for input.

Use Cases or Case Studies

Matrix multiplication is a cornerstone operation across various domains:

• Computer Graphics: Used extensively for transformations like rotation, scaling, and translation of 2D and 3D objects.
• Physics and Engineering: Solving systems of linear equations, simulating physical systems, and analyzing structures.
• Machine Learning and Data Science: Core to algorithms like neural networks (especially in layers performing dot products) and data transformations.
• Cryptography: Employed in certain encryption and decryption algorithms.
• Robotics: Calculating robot arm movements and spatial orientations.

Solution Approaches

For 2x2 matrix multiplication, the most straightforward and commonly used approach involves nested loops.

Approach 1: Using Nested Loops

This approach directly implements the mathematical definition of matrix multiplication using three nested for loops.

Summary: Initialize three 2x2 matrices (two for input, one for result), take user input for the two matrices, then compute the product using nested loops and display the result.

Code Example:

// 2x2 Matrix Multiplication
#include <stdio.h>

int main() {
    int a[2][2], b[2][2], c[2][2], i, j, k;

    // Step 1: Get elements of the first matrix
    printf("Enter elements of 2x2 Matrix A:\\n");
    for (i = 0; i < 2; i++) {
        for (j = 0; j < 2; j++) {
            printf("Enter A[%d][%d]: ", i, j);
            scanf("%d", &a[i][j]);
        }
    }

    // Step 2: Get elements of the second matrix
    printf("\\nEnter elements of 2x2 Matrix B:\\n");
    for (i = 0; i < 2; i++) {
        for (j = 0; j < 2; j++) {
            printf("Enter B[%d][%d]: ", i, j);
            scanf("%d", &b[i][j]);
        }
    }

    // Step 3: Initialize the result matrix C with zeros
    for (i = 0; i < 2; i++) {
        for (j = 0; j < 2; j++) {
            c[i][j] = 0;
        }
    }

    // Step 4: Perform matrix multiplication
    // The outer two loops iterate through rows (i) and columns (j) of the result matrix C.
    // The innermost loop (k) performs the dot product of A's row i and B's column j.
    for (i = 0; i < 2; i++) {
        for (j = 0; j < 2; j++) {
            for (k = 0; k < 2; k++) {
                c[i][j] += a[i][k] * b[k][j];
            }
        }
    }

    // Step 5: Display the resultant matrix
    printf("\\nResultant Matrix C (A * B):\\n");
    for (i = 0; i < 2; i++) {
        for (j = 0; j < 2; j++) {
            printf("%d\\t", c[i][j]);
        }
        printf("\\n"); // New line after each row
    }

    return 0;
}

Run

Sample Output:

Enter elements of 2x2 Matrix A:
Enter A[0][0]: 1
Enter A[0][1]: 2
Enter A[1][0]: 3
Enter A[1][1]: 4

Enter elements of 2x2 Matrix B:
Enter B[0][0]: 5
Enter B[0][1]: 6
Enter B[1][0]: 7
Enter B[1][1]: 8

Resultant Matrix C (A * B):
19	22	
43	50

Stepwise Explanation:

1. Declare Matrices: Three 2x2 integer arrays (a, b, c) are declared to store the first matrix, second matrix, and their product, respectively. Loop counters i, j, and k are also declared.
2. Input Matrix A: Two nested for loops iterate from 0 to 1 (inclusive) for both rows and columns. Inside the loops, scanf() prompts the user to enter each element of matrix a.
3. Input Matrix B: Similarly, the program prompts for and reads the elements of matrix b.
4. Initialize Result Matrix C: It's good practice to initialize all elements of the result matrix c to zero before starting the multiplication. This ensures that the sum c[i][j] += ... works correctly from a clean slate.
5. Matrix Multiplication Logic:
   • The outermost loop (i) iterates through the rows of the first matrix (a) and the result matrix (c).

1. Display Result Matrix: Finally, two nested for loops are used to print the elements of the resultant matrix c in a 2x2 format, with \t for tab spacing and \n to move to the next row after printing two elements.

Conclusion

This article demonstrated how to implement 2x2 matrix multiplication in C using nested loops. This fundamental approach directly translates the mathematical definition of matrix multiplication into code, providing a clear and efficient way to compute the product of two small matrices. Understanding this concept is a stepping stone for more complex matrix operations and algorithms.

Summary

• Matrix multiplication involves multiplying rows of the first matrix by columns of the second.
• For 2x2 matrices, the result is also a 2x2 matrix.
• The C implementation uses three nested for loops: two for iterating through the result matrix's elements and one for performing the summation of products.
• Initializing the result matrix elements to zero before calculation is essential for correctness.
• This core concept is widely applicable in various technical fields.