What You Will Learn

Prerequisites

You need to know how a two-dimensional array is declared and initialised, and how a function receives a pointer. The earlier lecture on checking distinct elements introduced the row-major idea, which we use again here.

Matrix Diagonal Sum Basics: The Two Diagonals

Only a square matrix (same number of rows and columns) has diagonals in the usual sense. We call the line from the top-left corner to the bottom-right corner the principal diagonal (or main diagonal). The line from the top-right corner to the bottom-left corner is the secondary diagonal (anti-diagonal).

By hand: the principal diagonal gives 3 + 9 + 5 + 3 = 20, and the secondary diagonal gives 1 + 2 + 3 + 9 = 15. Keep these two numbers in mind; the program must print the same values.

The Index Rules

A beginner’s version loops over every row and column and tests the rule with an if. That visits n x n cells to collect only n of them. Because each diagonal has exactly one cell in every row, you can skip the inner loop entirely and walk down the rows once. The work drops from O(n squared) to O(n).

Matrix Diagonal Sum in C: The Program

The function below accepts the matrix as a flat const int * plus the size n. A C 2-D array is stored row after row with no gaps, so cell (r, c) of an n x n matrix sits at offset r * n + c. Passing the address of the first element works for any n, with no need to hard-code the column count.

Program: ex52a.c

/* ex52a.c - principal and secondary diagonal sums of an n x n matrix */
#include <stdio.h>

static void diagonal_sums(const int *m, int n, int *principal, int *secondary)
{
    *principal = 0;
    *secondary = 0;
    for (int i = 0; i < n; i++) {
        *principal += m[i * n + i];              /* (0,0) (1,1) (2,2) ...   */
        *secondary += m[i * n + (n - 1 - i)];    /* (0,n-1) (1,n-2) ...     */
    }
}

static void analyse(const char *name, const int *m, int n)
{
    int p, s;
    int centre = (n % 2 == 1) ? m[(n / 2) * n + (n / 2)] : 0;

    diagonal_sums(m, n, &p, &s);
    printf("%s (%dx%d)\n", name, n, n);
    printf("  principal diagonal sum : %d\n", p);
    printf("  secondary diagonal sum : %d\n", s);
    printf("  both together, centre counted once : %d\n", p + s - centre);
}

int main(void)
{
    int even4[4][4] = {
        { 3, 1, 4, 1 },
        { 5, 9, 2, 6 },
        { 5, 3, 5, 8 },
        { 9, 7, 9, 3 }
    };
    int odd3[3][3] = {
        { 7, 2, 9 },
        { 4, 6, 1 },
        { 8, 3, 5 }
    };

    analyse("even4", &even4[0][0], 4);
    analyse("odd3", &odd3[0][0], 3);
    return 0;
}

Reading the Code

• m[i * n + i] is the principal cell of row i. m[i * n + (n - 1 - i)] is the secondary cell of the same row.
• The two results leave the function through the pointers principal and secondary.
• The call &even4[0][0] passes the address of the very first element. A 2-D array is laid out as one contiguous block, so this flat-pointer idiom is the standard way to hand any n x n matrix to a size-independent function. (A strict reading of the C standard frowns on stepping across rows from a pointer to the first element, but it works on every real compiler and is widely used in embedded code.)
• centre exists only when n is odd, because only then does one cell lie on both diagonals. For even n the two diagonals never touch.

Build and Run

gcc -std=c11 -Wall -Wextra -o ex52a ex52a.c
./ex52a

Expected output:

even4 (4x4)
  principal diagonal sum : 20
  secondary diagonal sum : 15
  both together, centre counted once : 35
odd3 (3x3)
  principal diagonal sum : 18
  secondary diagonal sum : 23
  both together, centre counted once : 35

The even4 results, 20 and 15, match the hand calculation. For the 3 x 3 matrix, the principal diagonal is 7 + 6 + 5 = 18 and the secondary is 9 + 6 + 8 = 23. The centre value 6 appears in both, so adding the diagonals naively gives 41, while counting the shared cell once gives 35.

The Centre Cell Trap

Real-World Uses

• Trace of a rotation matrix: for a 3 x 3 rotation matrix the principal diagonal sum equals 1 plus twice the cosine of the rotation angle, so a sensor-fusion routine can read an angle without a full decomposition.
• Image and signal processing: diagonal sums of small kernels act as quick checks for symmetry.
• Games and puzzles: tic-tac-toe, Sudoku and magic square checkers all test both diagonals. The next lecture builds on this directly.
• Linear algebra routines: the trace appears in Kalman filter code and covariance checks.

Common Mistakes and Troubleshooting

• Writing n – i for the secondary column. Arrays start at 0, so the last column is n – 1. Using n – i reads one cell past the row on the first step.
• Applying the code to a non-square matrix. A 3 x 4 matrix has no true diagonals. Add a check or an assertion that rows equal columns.
• Forgetting the centre overlap when the problem asks for a combined total on an odd-sized matrix.
• Integer overflow. Adding many large int values can overflow, which is undefined behaviour for signed types. Use a wider accumulator such as long long or int64_t when values can be large.
• Passing a pointer-to-pointer. A true 2-D array is not an int **. Pass &m[0][0] or use a typed parameter.

Best Practices for Matrix Diagonal Sum Code

• For any matrix diagonal sum, walk only the cells you need. A single loop beats a nested loop with an if on every embedded target.
• Keep the matrix size in a named constant or a parameter, never a magic number scattered through the code.
• On small microcontrollers without a hardware multiplier, i * n + i can be replaced by a running index that grows by n + 1 for the principal diagonal and n - 1 for the secondary one.
• Validate the size before use when it arrives from outside the program. A wrong n turns the loop into an out-of-bounds read.

Summary and Key Takeaways

• Principal diagonal: cells where row equals column. Secondary diagonal: cells where row plus column equals n – 1.
• One loop from 0 to n – 1 is enough for both, so the work is O(n).
• Odd-sized matrices share one centre cell between the diagonals.
• A 2-D array is one contiguous block, so a flat pointer plus the size describes it fully.

With this matrix diagonal sum in C and the matrix diagonal sum formulas above you now have the first building block of the magic square checker, which is the topic of the next lecture in this free embedded C course.

Frequently Asked Questions