Matrix multiplication in C: solved exercise

Matrix multiplication in C: solved exercise

If you searched for a solved matrix multiplication exercise in C, here is the implementation using the ikj loop order (more cache-friendly than the classic ijk order) and element-by-element result verification.

Multiplying matrix A (m×k) by matrix B (k×n) produces C (m×n) where C[i][j] = Σ A[i][p] * B[p][j] for p = 0..k-1. The complexity is O(m·k·n).

Problem statement

Multiply matrix A (3×2) by matrix B (2×4) and display the result C (3×4).

1
2
3

A = | 1  2 |    B = | 5  6  7  8 |
    | 3  4 |        | 9 10 11 12 |
    | 5  6 |

C solution

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

#include <stdio.h>

#define M 3  /* rows of A */
#define K 2  /* cols of A = rows of B */
#define N 4  /* cols of B */

void multiply(const int A[M][K], const int B[K][N], int C[M][N]) {
    /* Initialize C to zero */
    for (int i = 0; i < M; i++)
        for (int j = 0; j < N; j++)
            C[i][j] = 0;

    /* ikj order: better cache locality than ijk */
    for (int i = 0; i < M; i++)
        for (int p = 0; p < K; p++)
            for (int j = 0; j < N; j++)
                C[i][j] += A[i][p] * B[p][j];
}

void print_matrix(const char *name, const int mat[], int rows, int cols) {
    printf("%s:\n", name);
    for (int i = 0; i < rows; i++) {
        printf("  |");
        for (int j = 0; j < cols; j++)
            printf(" %3d", mat[i * cols + j]);
        printf(" |\n");
    }
}

int main(void) {
    int A[M][K] = {{1, 2}, {3, 4}, {5, 6}};
    int B[K][N] = {{5, 6, 7, 8}, {9, 10, 11, 12}};
    int C[M][N];

    multiply(A, B, C);

    print_matrix("A", (int *)A, M, K);
    print_matrix("B", (int *)B, K, N);
    print_matrix("C = A x B", (int *)C, M, N);

    return 0;
}

Expected output

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

A:
  |   1   2 |
  |   3   4 |
  |   5   6 |
B:
  |   5   6   7   8 |
  |   9  10  11  12 |
C = A x B:
  |  23  26  29  32 |
  |  51  58  65  72 |
  |  79  90 101 112 |

Common mistakes

  • Not initializing C to zero before accumulating: leftover stack values produce incorrect results.
  • Using the ijk loop order without thinking about cache: in ijk, the inner loop accesses B[p][j] with p varying, jumping across rows in memory (C matrices are row-major). The ikj order keeps B[p][j] in the same row, making sequential access and cache lines efficient.
  • Getting dimensions wrong: A[m×k] × B[k×n] = C[m×n]. The number of columns in A must equal the number of rows in B.
  • Using int for large matrices: the product of two 100×100 matrices with values of 1000 can produce entries up to 10^8, within int range, but for larger values use long long.

Practical use

Matrix multiplication is the core of numerical linear algebra, neural networks (forward propagation), 3D graphics (transformations), and scientific computing. Libraries like BLAS implement highly optimized versions with SIMD and multithreading.

Guided practice and full book

If you want a complete path with progressive difficulty:

FAQ

Why is the ikj loop order more efficient than ijk?

Because of cache locality. In ijk, the inner loop accesses B[p][j] with p varying, which jumps across rows in memory (C stores matrices in row-major order). In ikj, the inner loop accesses B[p][j] with j varying, traversing a row sequentially and making full use of loaded cache lines.

How do you verify the multiplication result?

Compute the first elements manually: C[0][0] = A[0][0]*B[0][0] + A[0][1]*B[1][0] = 1*5 + 2*9 = 23. Also check C[2][3] = 5*8 + 6*12 = 40 + 72 = 112.

What is Strassen’s matrix multiplication?

An algorithm that multiplies n×n matrices in O(n^2.807) instead of O(n³), by dividing each matrix into four submatrices and using 7 recursive multiplications instead of 8. In practice it is only used for very large matrices (n > 1000) because the hidden constant is larger than in the standard algorithm.