Matrix Multiplication

What matrix multiplication means

A matrix is just a grid of numbers arranged in rows and columns — in C we store it as a 2D array. Multiplying two matrices combines them into a new matrix, but not by simply multiplying matching cells. Instead, each cell of the result is built from a whole row of the first matrix and a whole column of the second.

That "row times column" idea is the heart of the topic. Once it clicks, the C program is just three loops that automate it.

The rule: when can you multiply?

You cannot multiply any two matrices. There is one strict rule:

For our example both matrices are 2×2, so columns of A (2) equal rows of B (2), and the result is also 2×2.

How one result cell is calculated

Let's take two 2×2 matrices and compute just the top-left cell, so you see the pattern:

A = | 1  2 |     B = | 5  6 |
    | 3  4 |         | 7  8 |

c[0][0] = (row 0 of A) . (col 0 of B)
        = 1*5 + 2*7
        = 5 + 14
        = 19

So the top-left result is 19. We repeat the same row-times-column idea for every cell: c[0][1] = 1*6 + 2*8 = 22, and so on.

The full program

Here is the complete C program for 2×2 matrices, with the result matrix started at zero.

#include <stdio.h>
int main() {
    int a[2][2] = {{1, 2}, {3, 4}};
    int b[2][2] = {{5, 6}, {7, 8}};
    int c[2][2] = {0};        // start every cell at 0

    for (int i = 0; i < 2; i++)          // each row of result
        for (int j = 0; j < 2; j++)      // each column of result
            for (int k = 0; k < 2; k++)  // shared dimension
                c[i][j] += a[i][k] * b[k][j];

    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 2; j++)
            printf("%d ", c[i][j]);
        printf("\n");
    }
    return 0;
}

Why three nested loops?

Each loop has a clear job:

The outer two loops point at one result cell; the inner loop fills that cell's value by walking along the shared dimension. That is exactly the row-times-column rule turned into code.

Common mistakes

• Forgetting to initialise the result matrix to 0, so += adds onto garbage.
• Multiplying cells directly (a[i][j] * b[i][j]) instead of doing row × column.
• Ignoring the dimension rule and trying to multiply incompatible matrices.
• Swapping the index order in a[i][k] * b[k][j] — the shared k must line up.

Summary

• Matrices multiply by combining a row of the first with a column of the second.
• Columns of the first must equal rows of the second (m×n times n×p gives m×p).
• Each cell c[i][j] sums a[i][k]*b[k][j] over k.
• Three nested loops: row, column, and the shared dimension.
• Always initialise the result matrix to 0 before adding.