C Program For Matrix Multiplication

Matrix multiplication is a fundamental operation in linear algebra with wide-ranging applications in various fields of science and engineering. Understanding how to implement this operation computationally is a core skill for any programmer. In this article, you will learn how to implement matrix multiplication in the C programming language, covering the underlying logic and a practical code example.

Problem Statement

The problem is to compute the product of two matrices, A and B, to produce a third matrix, C. For two matrices to be multiplied, the number of columns in the first matrix (A) must be equal to the number of rows in the second matrix (B). If matrix A is of size m x n and matrix B is of size n x p, then the resulting matrix C will be of size m x p. Each element C[i][j] is calculated as the sum of the products of corresponding elements from the i-th row of A and the j-th column of B.

Example

Let's consider two matrices, A and B, and their product C:

Matrix A (2x2):

1 2
3 4

Matrix B (2x2):

5 6
7 8

The resulting matrix C (2x2) would be:

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

So, Matrix C:

19 22
43 50

Background & Knowledge Prerequisites

To understand matrix multiplication in C, familiarity with the following concepts is essential:

• C Basics: Understanding of C syntax, variables, data types.
• Arrays: How to declare, initialize, and access elements of one-dimensional and two-dimensional arrays. Matrices are typically represented using 2D arrays.
• Loops: for loops are crucial for iterating through matrix elements and performing calculations.

For this program, no special imports or complex setup beyond standard C compilation are required. The header is sufficient for input/output operations.

Use Cases or Case Studies

Matrix multiplication is a cornerstone in many computational domains:

• Computer Graphics: Used for transformations like rotation, scaling, and translation of 3D objects.
• Machine Learning: Central to neural networks, especially in layers where inputs are multiplied by weight matrices.
• Image Processing: Applied in filters (e.g., convolution kernels), image compression, and transformations.
• Physics and Engineering: Solving systems of linear equations, simulating physical systems, and in finite element analysis.
• Cryptography: Used in certain encryption algorithms, such as Hill cipher, where messages are transformed using matrix operations.

Solution Approaches

The most common and straightforward approach for matrix multiplication involves using three nested loops.

Standard Three-Nested Loop Approach

This method directly implements the mathematical definition of matrix multiplication.

• One-line summary: Uses three nested for loops to iterate through rows of the first matrix, columns of the second, and then sum the products along the inner dimension.

// Matrix Multiplication
#include <stdio.h>

#define ROW1 2
#define COL1 2 // Also ROW2
#define COL2 2

int main() {
    // Step 1: Declare and initialize matrices
    int matrixA[ROW1][COL1] = {
        {1, 2},
        {3, 4}
    };

    int matrixB[COL1][COL2] = { // COL1 of matrixA must be ROW of matrixB
        {5, 6},
        {7, 8}
    };

    int matrixC[ROW1][COL2]; // Resultant matrix

    // Step 2: Check for compatibility (COL1 of A must equal ROW1 of B, which is COL1 here)
    // In this example, COL1 (2) matches ROW of matrixB (which is COL1 itself).
    // This check is often more explicit when dimensions are user-defined.
    // For fixed sizes as defined by #define, we ensure compatibility by design.

    // Step 3: Perform matrix multiplication
    // Outer loop iterates through rows of matrixA (and resultant matrixC)
    for (int i = 0; i < ROW1; i++) {
        // Middle loop iterates through columns of matrixB (and resultant matrixC)
        for (int j = 0; j < COL2; j++) {
            matrixC[i][j] = 0; // Initialize element of resultant matrix to 0
            // Inner loop iterates through columns of matrixA (and rows of matrixB)
            for (int k = 0; k < COL1; k++) { // Or ROW2, they are the same
                matrixC[i][j] += matrixA[i][k] * matrixB[k][j];
            }
        }
    }

    // Step 4: Print the resultant matrix
    printf("Resultant Matrix C (%dx%d):\\n", ROW1, COL2);
    for (int i = 0; i < ROW1; i++) {
        for (int j = 0; j < COL2; j++) {
            printf("%d\\t", matrixC[i][j]);
        }
        printf("\\n");
    }

    return 0;
}

Run

• Sample Output:

Resultant Matrix C (2x2):
19	22	
43	50

• Stepwise Explanation:

1. Define Dimensions and Initialize Matrices: We start by defining the dimensions of our matrices using preprocessor directives (#define). matrixA and matrixB are declared and initialized with integer values. matrixC is declared to store the result.
2. Compatibility Check (Implicit): For this fixed-size example, we ensure COL1 (columns of matrixA) is equal to ROW2 (rows of matrixB) by design. In a more general program where dimensions are taken from user input, an explicit if (COL1 != ROW2) check would be necessary.
3. Outer Loops (i, j): The first two for loops iterate over the rows (i) of matrixA and the columns (j) of matrixB. These loops determine the position of the element currently being calculated in the matrixC.
4. Initialization of matrixC[i][j]: Inside the j loop, matrixC[i][j] is initialized to 0. This is crucial because C[i][j] will accumulate the sum of products.
5. Inner Loop (k): The innermost for loop, controlled by k, performs the actual element-wise multiplication and summation. It iterates COL1 (which is ROW2) times.
   • In each iteration, matrixA[i][k] (an element from the i-th row of A) is multiplied by matrixB[k][j] (an element from the j-th column of B).

The product is then added to matrixC[i][j]. This process continues until all products for C[i][j] are summed up.

1. Print Result: After all calculations are complete, the program iterates through matrixC again to print its elements in a clear, tab-separated format.

Conclusion

Matrix multiplication is a foundational operation in computing, and its implementation using nested loops in C is a clear demonstration of basic array and loop manipulation. While simple, this approach provides a solid understanding of how matrix products are formed. For larger matrices, more optimized algorithms (like Strassen's algorithm) or parallel computing techniques might be employed due to the O(n³) time complexity of the standard approach.

Summary

• Matrix multiplication A * B results in C where C[i][j] is the sum of products of A's i-th row and B's j-th column.
• Compatibility: Number of columns in the first matrix must equal the number of rows in the second matrix.
• Implemented using three nested for loops in C.
• The outer two loops determine the element (i, j) in the result matrix.
• The innermost loop calculates the sum of products for C[i][j].
• Crucial for fields like computer graphics, machine learning, and engineering simulations.