C Program To Find Determinant Of A Matrix

A matrix determinant is a scalar value that can be computed from the elements of a square matrix. It provides crucial information about the matrix, such as its invertibility and the properties of linear transformations it represents. In this article, you will learn how to compute the determinant of a matrix using C programming, covering approaches for 2x2, 3x3, and general N x N matrices.

Problem Statement

The problem is to calculate the determinant of a given square matrix. This value is fundamental in various mathematical and engineering fields, including solving systems of linear equations, finding eigenvalues, and performing geometric transformations. Without a reliable method to compute determinants, many advanced mathematical operations become impossible.

Example

Consider a simple 2x2 matrix:

A = | 2  3 |
    | 1  4 |

Its determinant is calculated as (2 * 4) - (3 * 1) = 8 - 3 = 5.

Background & Knowledge Prerequisites

To effectively understand and implement the solutions, readers should have a basic understanding of:

• C Programming Basics: Variables, data types, loops (for, while), conditional statements (if-else).
• Arrays: Declaring and manipulating one-dimensional and two-dimensional arrays.
• Functions: Defining and calling functions, passing parameters.
• Recursion: Understanding how functions can call themselves (especially for the general N x N case).
• Matrix Algebra Basics: The concept of a matrix, rows, columns, and square matrices.

Relevant imports for C programming will primarily involve for input/output operations.

Use Cases or Case Studies

Determinants are widely used across various domains:

• Solving Systems of Linear Equations: Cramer's Rule uses determinants to find the unique solution to a system of linear equations.
• Checking Matrix Invertibility: A square matrix is invertible if and only if its determinant is non-zero. This is critical in many numerical algorithms.
• Eigenvalue Calculation: Determinants are used in finding the characteristic polynomial of a matrix, which helps determine its eigenvalues.
• Geometric Interpretation: The absolute value of the determinant of a 2x2 or 3x3 matrix represents the area or volume scaling factor of a linear transformation.
• Cross Product: The cross product of two 3D vectors can be represented as the determinant of a 3x3 matrix involving unit vectors and components of the two vectors.

Solution Approaches

We will explore different methods to calculate the determinant, starting with simpler cases and progressing to a general solution.

Approach 1: Determinant of a 2x2 Matrix

This approach uses the direct formula for a 2x2 matrix.

• Summary: For a matrix | a b | / | c d |, the determinant is (a*d) - (b*c).
• Code Example:

// Determinant of 2x2 Matrix
#include <stdio.h>

// Function to calculate determinant of a 2x2 matrix
int determinant2x2(int matrix[2][2]) {
    return (matrix[0][0] * matrix[1][1]) - (matrix[0][1] * matrix[1][0]);
}

int main() {
    // Step 1: Define a 2x2 matrix
    int matrix[2][2] = {
        {2, 3},
        {1, 4}
    };

    // Step 2: Calculate its determinant
    int det = determinant2x2(matrix);

    // Step 3: Print the result
    printf("The 2x2 matrix:\\n");
    printf("%d %d\\n", matrix[0][0], matrix[0][1]);
    printf("%d %d\\n", matrix[1][0], matrix[1][1]);
    printf("Determinant = %d\\n", det);

    return 0;
}

Run

• Sample Output:

The 2x2 matrix:
2 3
1 4
Determinant = 5

• Stepwise Explanation:

1. A function determinant2x2 is defined that takes a 2x2 integer matrix as input.
2. Inside the function, the determinant is calculated using the formula (matrix[0][0] * matrix[1][1]) - (matrix[0][1] * matrix[1][0]).
3. The main function initializes a sample 2x2 matrix.
4. It calls determinant2x2 with the sample matrix and prints the returned value.

Approach 2: Determinant of a 3x3 Matrix

This approach uses the cofactor expansion along the first row (or Sarrus' Rule).

• Summary: For a 3x3 matrix, the determinant can be calculated by expanding along a row or column, reducing it to 2x2 determinants. For example, expanding along the first row |a b c|, it's a*(det of submatrix without a) - b*(det of submatrix without b) + c*(det of submatrix without c).
• Code Example:

// Determinant of 3x3 Matrix
#include <stdio.h>

// Function to calculate determinant of a 2x2 matrix (helper for 3x3)
int determinant2x2_helper(int matrix[2][2]) {
    return (matrix[0][0] * matrix[1][1]) - (matrix[0][1] * matrix[1][0]);
}

// Function to calculate determinant of a 3x3 matrix
int determinant3x3(int matrix[3][3]) {
    int det = 0;

    // Cofactor for first element (0,0)
    // Submatrix: | matrix[1][1] matrix[1][2] |
    //            | matrix[2][1] matrix[2][2] |
    int submatrix1[2][2] = {
        {matrix[1][1], matrix[1][2]},
        {matrix[2][1], matrix[2][2]}
    };
    det += matrix[0][0] * determinant2x2_helper(submatrix1);

    // Cofactor for second element (0,1) with negative sign
    // Submatrix: | matrix[1][0] matrix[1][2] |
    //            | matrix[2][0] matrix[2][2] |
    int submatrix2[2][2] = {
        {matrix[1][0], matrix[1][2]},
        {matrix[2][0], matrix[2][2]}
    };
    det -= matrix[0][1] * determinant2x2_helper(submatrix2);

    // Cofactor for third element (0,2)
    // Submatrix: | matrix[1][0] matrix[1][1] |
    //            | matrix[2][0] matrix[2][1] |
    int submatrix3[2][2] = {
        {matrix[1][0], matrix[1][1]},
        {matrix[2][0], matrix[2][1]}
    };
    det += matrix[0][2] * determinant2x2_helper(submatrix3);

    return det;
}

int main() {
    // Step 1: Define a 3x3 matrix
    int matrix[3][3] = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };

    // Step 2: Calculate its determinant
    int det = determinant3x3(matrix);

    // Step 3: Print the result
    printf("The 3x3 matrix:\\n");
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            printf("%d ", matrix[i][j]);
        }
        printf("\\n");
    }
    printf("Determinant = %d\\n", det);

    // Another example
    int matrix2[3][3] = {
        {6, 1, 1},
        {4, -2, 5},
        {2, 8, 7}
    };
    det = determinant3x3(matrix2);
    printf("\\nThe second 3x3 matrix:\\n");
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            printf("%d ", matrix2[i][j]);
        }
        printf("\\n");
    }
    printf("Determinant = %d\\n", det);


    return 0;
}

Run

• Sample Output:

The 3x3 matrix:
1 2 3 
4 5 6 
7 8 9 
Determinant = 0

The second 3x3 matrix:
6 1 1 
4 -2 5 
2 8 7 
Determinant = -306

• Stepwise Explanation:

1. A helper function determinant2x2_helper is reused from Approach 1.
2. The determinant3x3 function takes a 3x3 matrix.
3. It calculates the determinant by summing the products of each element in the first row with its corresponding cofactor.
4. The cofactor for an element a_ij is (-1)^(i+j) times the determinant of the submatrix obtained by removing row i and column j.
5. For matrix[0][0], the sign is (-1)^(0+0) = +1.
6. For matrix[0][1], the sign is (-1)^(0+1) = -1.
7. For matrix[0][2], the sign is (-1)^(0+2) = +1.
8. Each submatrix is a 2x2 matrix, whose determinant is calculated using the helper function.
9. The main function demonstrates with two example 3x3 matrices.

Approach 3: Determinant of a General N x N Matrix (Recursive Cofactor Expansion)

This approach uses a recursive function to find the determinant of any square matrix of size N x N.

• Summary: This method generalizes the cofactor expansion used for 3x3 matrices. For an N x N matrix, the determinant is calculated by expanding along any row or column. Each element a_ij is multiplied by its cofactor C_ij = (-1)^(i+j) * M_ij, where M_ij is the determinant of the (N-1)x(N-1) submatrix (minor) formed by deleting row i and column j. This process continues recursively until a 2x2 or 1x1 matrix is reached.
• Code Example:

// Determinant of N x N Matrix
#include <stdio.h>
#include <math.h> // For pow function

// Function to get the cofactor of matrix[p][q] in temp matrix
void getCofactor(int matrix[10][10], int temp[10][10], int p, int q, int n) {
    int i = 0, j = 0;

    // Looping for each element of the matrix
    for (int row = 0; row < n; row++) {
        for (int col = 0; col < n; col++) {
            // Copying into temporary matrix only those elements which are not in given row and column
            if (row != p && col != q) {
                temp[i][j++] = matrix[row][col];

                // Row is full, go to next row
                if (j == n - 1) {
                    j = 0;
                    i++;
                }
            }
        }
    }
}

// Function to calculate determinant of a matrix recursively
int determinant(int matrix[10][10], int n) {
    int D = 0; // Initialize result

    // Base case : if matrix contains single element
    if (n == 1) {
        return matrix[0][0];
    }

    int temp[10][10]; // To store cofactors
    int sign = 1;      // To store sign multiplier

    // Iterate for each element of the first row
    for (int f = 0; f < n; f++) {
        // Getting Cofactor of matrix[0][f]
        getCofactor(matrix, temp, 0, f, n);
        D += sign * matrix[0][f] * determinant(temp, n - 1);

        // Term is multiplied by (-1)^(1+col_index)
        sign = -sign;
    }

    return D;
}

// Function to display the matrix
void displayMatrix(int matrix[10][10], int n) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            printf("%d ", matrix[i][j]);
        }
        printf("\\n");
    }
}

int main() {
    // Step 1: Define an N x N matrix and its size
    int matrix1[10][10] = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };
    int n1 = 3;

    // Step 2: Calculate its determinant
    printf("Matrix 1 (%dx%d):\\n", n1, n1);
    displayMatrix(matrix1, n1);
    printf("Determinant = %d\\n", determinant(matrix1, n1));

    printf("\\n");

    int matrix2[10][10] = {
        {1, 0, 2, -1},
        {3, 0, 0, 5},
        {2, 1, 4, -3},
        {1, 0, 5, 0}
    };
    int n2 = 4;

    printf("Matrix 2 (%dx%d):\\n", n2, n2);
    displayMatrix(matrix2, n2);
    printf("Determinant = %d\\n", determinant(matrix2, n2));

    printf("\\n");

    int matrix3[10][10] = {
        {6, 1, 1},
        {4, -2, 5},
        {2, 8, 7}
    };
    int n3 = 3;

    printf("Matrix 3 (%dx%d):\\n", n3, n3);
    displayMatrix(matrix3, n3);
    printf("Determinant = %d\\n", determinant(matrix3, n3));

    return 0;
}

Run

• Sample Output:

Matrix 1 (3x3):
1 2 3 
4 5 6 
7 8 9 
Determinant = 0

Matrix 2 (4x4):
1 0 2 -1 
3 0 0 5 
2 1 4 -3 
1 0 5 0 
Determinant = 30

Matrix 3 (3x3):
6 1 1 
4 -2 5 
2 8 7 
Determinant = -306

• Stepwise Explanation:

1. getCofactor(matrix, temp, p, q, n) function: This helper function takes an NxN matrix, a temporary (N-1)x(N-1) matrix temp, the row p and column q of the element whose cofactor is being found, and the original matrix size n. It populates temp with the submatrix obtained by deleting row p and column q from matrix.
2. determinant(matrix, n) function: This is the recursive function.
   • Base Case: If n == 1, the matrix has only one element, so its determinant is that element.

Recursive Step:

It initializes D (determinant) to 0 and sign to 1.

It iterates through the elements of the first row (you could choose any row or column).

For each element matrix[0][f]:

It calls getCofactor to construct the (n-1)x(n-1) submatrix temp.

It adds sign * matrix[0][f] * determinant(temp, n - 1) to D. This is the core of the cofactor expansion: element * its cofactor.

The sign flips between +1 and -1 for alternating terms (representing (-1)^(0+f)).

Finally, it returns the calculated D.

1. displayMatrix function: A simple utility to print the matrix for verification.
2. main function: Demonstrates the determinant function with matrices of different sizes (3x3, 4x4) and prints the results. Note the matrix size limit of 10x10 is arbitrarily set by the array declaration, but it can be adjusted.

Conclusion

Calculating the determinant of a matrix is a fundamental operation in linear algebra with widespread applications. We have explored direct formula-based approaches for 2x2 and 3x3 matrices, which are efficient for small fixed sizes. For general N x N matrices, the recursive cofactor expansion method provides a flexible solution, albeit with higher computational complexity (O(N!)). For very large matrices, more advanced algorithms like LU decomposition are often preferred for performance.

Summary

• Determinants are scalar values derived from square matrices, providing insights into matrix properties.
• For 2x2 matrices: Determinant = (a*d) - (b*c).
• For 3x3 matrices: Determinant can be found via cofactor expansion along a row/column, breaking it down into 2x2 determinants.
• For N x N matrices: A recursive cofactor expansion approach can be used, involving:
• A base case for 1x1 matrices.
• A helper function to generate submatrices (cofactors).
• Summing element * (-1)^(row+col) * determinant(submatrix) recursively.
• Determinants are crucial for solving linear equations, checking matrix invertibility, and understanding linear transformations.