Skip to content
Related Articles

Related Articles

Determinant of a Matrix

View Discussion
Improve Article
Save Article
  • Difficulty Level : Medium
  • Last Updated : 29 Aug, 2022
View Discussion
Improve Article
Save Article

The determinant of a Matrix is defined as a special number that is defined only for square matrices (matrices that have the same number of rows and columns). A determinant is used in many places in calculus and other matrices related to algebra, it actually represents the matrix in terms of a real number which can be used in solving a system of a linear equation and finding the inverse of a matrix.

Recommended Practice

Determinant of 2 x 2 Matrix:

Determinant of 2 x 2 matrix

Determinant of 3 x 3 Matrix: 

Determinant of 3 x 3 matrix

How to calculate? 

The value of the determinant of a matrix can be calculated by the following procedure: 

  • For each element of the first row or first column get the cofactor of those elements.
  • Then multiply the element with the determinant of the corresponding cofactor. 
  • Finally, add them with alternate signs. As a base case, the value of the determinant of a 1*1 matrix is the single value itself. 

The cofactor of an element is a matrix that we can get by removing the row and column of that element from that matrix.

C++




// C++ program to find Determinant of a matrix
#include <iostream>
using namespace std;
 
// Dimension of input square matrix
#define N 4
 
// Function to get cofactor of mat[p][q] in temp[][]. n is
// current dimension of mat[][]
void getCofactor(int mat[N][N], int temp[N][N], 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
            //  element which are not in given row and
            //  column
            if (row != p && col != q)
            {
                temp[i][j++] = mat[row][col];
 
                // Row is filled, so increase row index and
                // reset col index
                if (j == n - 1)
                {
                    j = 0;
                    i++;
                }
            }
        }
    }
}
 
/* Recursive function for finding determinant of matrix.
   n is current dimension of mat[][]. */
int determinantOfMatrix(int mat[N][N], int n)
{
    int D = 0; // Initialize result
 
    //  Base case : if matrix contains single element
    if (n == 1)
        return mat[0][0];
 
    int temp[N][N]; // To store cofactors
 
    int sign = 1; // To store sign multiplier
 
    // Iterate for each element of first row
    for (int f = 0; f < n; f++)
    {
        // Getting Cofactor of mat[0][f]
        getCofactor(mat, temp, 0, f, n);
        D += sign * mat[0][f]
             * determinantOfMatrix(temp, n - 1);
 
        // terms are to be added with alternate sign
        sign = -sign;
    }
 
    return D;
}
 
/* function for displaying the matrix */
void display(int mat[N][N], int row, int col)
{
    for (int i = 0; i < row; i++)
    {
        for (int j = 0; j < col; j++)
            cout <<"  " <<  mat[i][j];
        cout <<"n";
    }
}
 
// Driver program to test above functions
int main()
{
    /* int mat[N][N] = {{6, 1, 1},
                     {4, -2, 5},
                     {2, 8, 7}}; */
 
    int mat[N][N] = { { 1, 0, 2, -1 },
                      { 3, 0, 0, 5 },
                      { 2, 1, 4, -3 },
                      { 1, 0, 5, 0 } };
 
    // Function call
    cout <<"Determinant of the matrix is : " << determinantOfMatrix(mat, N);
    return 0;
}
 
// this code is contributed by shivanisinghss2110

C




// C program to find Determinant of a matrix
#include <stdio.h>
 
// Dimension of input square matrix
#define N 4
 
// Function to get cofactor of mat[p][q] in temp[][]. n is
// current dimension of mat[][]
void getCofactor(int mat[N][N], int temp[N][N], 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
            //  element which are not in given row and
            //  column
            if (row != p && col != q)
            {
                temp[i][j++] = mat[row][col];
 
                // Row is filled, so increase row index and
                // reset col index
                if (j == n - 1)
                {
                    j = 0;
                    i++;
                }
            }
        }
    }
}
 
/* Recursive function for finding determinant of matrix.
   n is current dimension of mat[][]. */
int determinantOfMatrix(int mat[N][N], int n)
{
    int D = 0; // Initialize result
 
    //  Base case : if matrix contains single element
    if (n == 1)
        return mat[0][0];
 
    int temp[N][N]; // To store cofactors
 
    int sign = 1; // To store sign multiplier
 
    // Iterate for each element of first row
    for (int f = 0; f < n; f++)
    {
        // Getting Cofactor of mat[0][f]
        getCofactor(mat, temp, 0, f, n);
        D += sign * mat[0][f]
             * determinantOfMatrix(temp, n - 1);
 
        // terms are to be added with alternate sign
        sign = -sign;
    }
 
    return D;
}
 
/* function for displaying the matrix */
void display(int mat[N][N], int row, int col)
{
    for (int i = 0; i < row; i++)
    {
        for (int j = 0; j < col; j++)
            printf("  %d", mat[i][j]);
        printf("n");
    }
}
 
// Driver program to test above functions
int main()
{
    /* int mat[N][N] = {{6, 1, 1},
                     {4, -2, 5},
                     {2, 8, 7}}; */
 
    int mat[N][N] = { { 1, 0, 2, -1 },
                      { 3, 0, 0, 5 },
                      { 2, 1, 4, -3 },
                      { 1, 0, 5, 0 } };
 
    // Function call
    printf("Determinant of the matrix is : %d",
           determinantOfMatrix(mat, N));
    return 0;
}

Java




// Java program to find Determinant of
// a matrix
class GFG {
 
    // Dimension of input square matrix
    static final int N = 4;
 
    // Function to get cofactor of
    // mat[p][q] in temp[][]. n is
    // current dimension of mat[][]
    static void getCofactor(int mat[][], int temp[][],
                            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 element which are
                // not in given row and column
                if (row != p && col != q)
                {
                    temp[i][j++] = mat[row][col];
                    // Row is filled, so increase
                    // row index and reset col
                    // index
                    if (j == n - 1)
                    {
                        j = 0;
                        i++;
                    }
                }
            }
        }
    }
 
    /* Recursive function for finding determinant
    of matrix. n is current dimension of mat[][]. */
    static int determinantOfMatrix(int mat[][], int n)
    {
        int D = 0; // Initialize result
 
        // Base case : if matrix contains single
        // element
        if (n == 1)
            return mat[0][0];
 
        // To store cofactors
        int temp[][] = new int[N][N];
 
        // To store sign multiplier
        int sign = 1;
 
        // Iterate for each element of first row
        for (int f = 0; f < n; f++)
        {
            // Getting Cofactor of mat[0][f]
            getCofactor(mat, temp, 0, f, n);
            D += sign * mat[0][f]
                 * determinantOfMatrix(temp, n - 1);
 
            // terms are to be added with
            // alternate sign
            sign = -sign;
        }
 
        return D;
    }
 
    /* function for displaying the matrix */
    static void display(int mat[][], int row, int col)
    {
        for (int i = 0; i < row; i++)
        {
            for (int j = 0; j < col; j++)
                System.out.print(mat[i][j]);
 
            System.out.print("\n");
        }
    }
 
    // Driver code
    public static void main(String[] args)
    {
 
        int mat[][] = { { 1, 0, 2, -1 },
                        { 3, 0, 0, 5 },
                        { 2, 1, 4, -3 },
                        { 1, 0, 5, 0 } };
 
        System.out.print("Determinant "
                         + "of the matrix is : "
                         + determinantOfMatrix(mat, N));
    }
}
 
// This code is contributed by Anant Agarwal.

Python3




# python program to find
# determinant of matrix.
 
# defining a function to get the
# minor matrix after excluding
# i-th row and j-th column.
 
 
def getcofactor(m, i, j):
    return [row[: j] + row[j+1:] for row in (m[: i] + m[i+1:])]
 
# defining the function to
# calculate determinant value
# of given matrix a.
 
 
def determinantOfMatrix(mat):
 
    # if given matrix is of order
    # 2*2 then simply return det
    # value by cross multiplying
    # elements of matrix.
    if(len(mat) == 2):
        value = mat[0][0] * mat[1][1] - mat[1][0] * mat[0][1]
        return value
 
    # initialize Sum to zero
    Sum = 0
 
    # loop to traverse each column
    # of matrix a.
    for current_column in range(len(mat)):
 
        # calculating the sign corresponding
        # to co-factor of that sub matrix.
        sign = (-1) ** (current_column)
 
        # calling the function recursily to
        # get determinant value of
        # sub matrix obtained.
        sub_det = determinantOfMatrix(getcofactor(mat, 0, current_column))
 
        # adding the calculated determinant
        # value of particular column
        # matrix to total Sum.
        Sum += (sign * mat[0][current_column] * sub_det)
 
    # returning the final Sum
    return Sum
 
 
# Driver code
if __name__ == '__main__':
 
    # declaring the matrix.
    mat = [[1, 0, 2, -1],
           [3, 0, 0, 5],
           [2, 1, 4, -3],
           [1, 0, 5, 0]]
 
    # printing determinant value
    # by function call
    print('Determinant of the matrix is :', determinantOfMatrix(mat))
 
# This code is contributed by Amit Mangal.

C#




// C# program to find Determinant of
// a matrix
using System;
class GFG {
 
    // Dimension of input square matrix
    static int N = 4;
 
    // Function to get cofactor of
    // mat[p][q] in temp[][]. n is
    // current dimension of mat[][]
    static void getCofactor(int[, ] mat, int[, ] temp,
                            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 element which are
                // not in given row and column
                if (row != p && col != q) {
                    temp[i, j++] = mat[row, col];
 
                    // Row is filled, so increase
                    // row index and reset col
                    // index
                    if (j == n - 1) {
                        j = 0;
                        i++;
                    }
                }
            }
        }
    }
 
    /* Recursive function for
       finding determinant
       of matrix. n is current
       dimension of mat[][]. */
    static int determinantOfMatrix(int[, ] mat, int n)
    {
        int D = 0; // Initialize result
 
        // Base case : if matrix
        // contains single
        // element
        if (n == 1)
            return mat[0, 0];
 
        // To store cofactors
        int[, ] temp = new int[N, N];
 
        // To store sign multiplier
        int sign = 1;
 
        // Iterate for each element
        // of first row
        for (int f = 0; f < n; f++)
        {
            // Getting Cofactor of mat[0][f]
            getCofactor(mat, temp, 0, f, n);
            D += sign * mat[0, f]
                 * determinantOfMatrix(temp, n - 1);
 
            // terms are to be added with
            // alternate sign
            sign = -sign;
        }
 
        return D;
    }
 
    /* function for displaying
       the matrix */
    static void display(int[, ] mat, int row, int col)
    {
        for (int i = 0; i < row; i++)
        {
            for (int j = 0; j < col; j++)
                Console.Write(mat[i, j]);
 
            Console.Write("\n");
        }
    }
 
    // Driver code
    public static void Main()
    {
 
        int[, ] mat = { { 1, 0, 2, -1 },
                        { 3, 0, 0, 5 },
                        { 2, 1, 4, -3 },
                        { 1, 0, 5, 0 } };
 
        Console.Write("Determinant "
                      + "of the matrix is : "
                      + determinantOfMatrix(mat, N));
    }
}
 
// This code is contributed by nitin mittal.

Javascript




<script>
 
// JavaScript program to find Determinant of
// a matrix
 
// Dimension of input square matrix
let N = 4;
 
// Function to get cofactor of
    // mat[p][q] in temp[][]. n is
    // current dimension of mat[][]
function getCofactor(mat,temp,p,q,n)
{
    let i = 0, j = 0;
  
        // Looping for each element of
        // the matrix
        for (let row = 0; row < n; row++)
        {
            for (let col = 0; col < n; col++)
            {
                // Copying into temporary matrix
                // only those element which are
                // not in given row and column
                if (row != p && col != q)
                {
                    temp[i][j++] = mat[row][col];
                    // Row is filled, so increase
                    // row index and reset col
                    // index
                    if (j == n - 1)
                    {
                        j = 0;
                        i++;
                    }
                }
            }
        }
}
 
/* Recursive function for finding determinant
    of matrix. n is current dimension of mat[][]. */
function determinantOfMatrix(mat,n)
{
    let D = 0; // Initialize result
  
        // Base case : if matrix contains single
        // element
        if (n == 1)
            return mat[0][0];
  
        // To store cofactors
        let temp = new Array(N);
        for(let i=0;i<N;i++)
        {
            temp[i]=new Array(N);
        }
  
        // To store sign multiplier
        let sign = 1;
  
        // Iterate for each element of first row
        for (let f = 0; f < n; f++)
        {
            // Getting Cofactor of mat[0][f]
            getCofactor(mat, temp, 0, f, n);
            D += sign * mat[0][f]
                 * determinantOfMatrix(temp, n - 1);
  
            // terms are to be added with
            // alternate sign
            sign = -sign;
        }
  
        return D;
}
 
/* function for displaying the matrix */
function display(mat,row,col)
{
    for (let i = 0; i < row; i++)
        {
            for (let j = 0; j < col; j++)
                document.write(mat[i][j]);
  
            document.write("<br>");
        }
}
 
// Driver code
let mat=[[ 1, 0, 2, -1 ],
         [ 3, 0, 0, 5 ],
         [ 2, 1, 4, -3 ],
         [ 1, 0, 5, 0 ]];
          
document.write("Determinant "
                         + "of the matrix is : "
                         + determinantOfMatrix(mat, N));
 
 
 
// This code is contributed by rag2127
 
</script>

Output

Determinant of the matrix is : 30

Time Complexity: O(n4)
Space Complexity: O(n2), Auxiliary space used for storing cofactors.

Note: In the above recursive approach when the size of the matrix is large it consumes more stack size.

Determinant of a Matrix using Determinant properties:

  • In this method, we are using the properties of Determinant. 
  • Converting the given matrix into an upper triangular matrix using determinant properties 
  • The determinant of the upper triangular matrix is the product of all diagonal elements. 
  • Iterating every diagonal element and making all the elements down the diagonal as zero using determinant properties 
  • If the diagonal element is zero then search for the next non-zero element in the same column.

There exist two cases:

  • Case 1: If there is no non-zero element. In this case, the determinant of a matrix is zero 
  • Case 2: If there exists a non-zero element there exist two cases 
    • Case A: If the index is with a respective diagonal row element. Using the determinant properties make all the column elements down to it zero
    • Case B: Swap the row with respect to the diagonal element column and continue the Case A operation.

Below is the implementation of the above approach:

C++




// C++ program to find Determinant of a matrix
#include <bits/stdc++.h>
using namespace std;
 
// Dimension of input square matrix
#define N 4
// Function to get determinant of matrix
int determinantOfMatrix(int mat[N][N], int n)
{
    int num1, num2, det = 1, index,
                    total = 1; // Initialize result
 
    // temporary array for storing row
    int temp[n + 1];
 
    // loop for traversing the diagonal elements
    for (int i = 0; i < n; i++)
    {
        index = i; // initialize the index
 
        // finding the index which has non zero value
        while (index < n && mat[index][i] == 0)
        {
            index++;
        }
        if (index == n) // if there is non zero element
        {
            // the determinant of matrix as zero
            continue;
        }
        if (index != i)
        {
            // loop for swapping the diagonal element row and
            // index row
            for (int j = 0; j < n; j++)
            {
                swap(mat[index][j], mat[i][j]);
            }
            // determinant sign changes when we shift rows
            // go through determinant properties
            det = det * pow(-1, index - i);
        }
 
        // storing the values of diagonal row elements
        for (int j = 0; j < n; j++)
        {
            temp[j] = mat[i][j];
        }
        // traversing every row below the diagonal element
        for (int j = i + 1; j < n; j++)
        {
            num1 = temp[i]; // value of diagonal element
            num2 = mat[j][i]; // value of next row element
 
            // traversing every column of row
            // and multiplying to every row
            for (int k = 0; k < n; k++)
            {
                // multiplying to make the diagonal
                // element and next row element equal
                mat[j][k]
                    = (num1 * mat[j][k]) - (num2 * temp[k]);
            }
            total = total * num1; // Det(kA)=kDet(A);
        }
    }
 
    // multiplying the diagonal elements to get determinant
    for (int i = 0; i < n; i++)
    {
        det = det * mat[i][i];
    }
    return (det / total); // Det(kA)/k=Det(A);
}
 
// Driver code
int main()
{
    /*int mat[N][N] = {{6, 1, 1},
                        {4, -2, 5},
                        {2, 8, 7}}; */
 
    int mat[N][N] = { { 1, 0, 2, -1 },
                      { 3, 0, 0, 5 },
                      { 2, 1, 4, -3 },
                      { 1, 0, 5, 0 } };
 
    // Function call
    printf("Determinant of the matrix is : %d",
           determinantOfMatrix(mat, N));
    return 0;
}

Java




// Java program to find Determinant of a matrix
class GFG
{
 
    // Dimension of input square matrix
    static final int N = 4;
 
    // Function to get determinant of matrix
    static int determinantOfMatrix(int mat[][], int n)
    {
        int num1, num2, det = 1, index,
                        total = 1; // Initialize result
 
        // temporary array for storing row
        int[] temp = new int[n + 1];
 
        // loop for traversing the diagonal elements
        for (int i = 0; i < n; i++)
        {
            index = i; // initialize the index
 
            // finding the index which has non zero value
            while (index < n && mat[index][i] == 0)
            {
                index++;
            }
            if (index == n) // if there is non zero element
            {
                // the determinant of matrix as zero
                continue;
            }
            if (index != i)
            {
                // loop for swapping the diagonal element row
                // and index row
                for (int j = 0; j < n; j++)
                {
                    swap(mat, index, j, i, j);
                }
                // determinant sign changes when we shift
                // rows go through determinant properties
                det = (int)(det * Math.pow(-1, index - i));
            }
 
            // storing the values of diagonal row elements
            for (int j = 0; j < n; j++)
            {
                temp[j] = mat[i][j];
            }
 
            // traversing every row below the diagonal
            // element
            for (int j = i + 1; j < n; j++)
            {
                num1 = temp[i]; // value of diagonal element
                num2 = mat[j]
                          [i]; // value of next row element
 
                // traversing every column of row
                // and multiplying to every row
                for (int k = 0; k < n; k++)
                {
                    // multiplying to make the diagonal
                    // element and next row element equal
                    mat[j][k] = (num1 * mat[j][k])
                                - (num2 * temp[k]);
                }
                total = total * num1; // Det(kA)=kDet(A);
            }
        }
 
        // multiplying the diagonal elements to get
        // determinant
        for (int i = 0; i < n; i++)
        {
            det = det * mat[i][i];
        }
        return (det / total); // Det(kA)/k=Det(A);
    }
 
    static int[][] swap(int[][] arr, int i1, int j1, int i2,
                        int j2)
    {
        int temp = arr[i1][j1];
        arr[i1][j1] = arr[i2][j2];
        arr[i2][j2] = temp;
        return arr;
    }
 
    // Driver code
    public static void main(String[] args)
    {
        /*int mat[N][N] = {{6, 1, 1},
                        {4, -2, 5},
                        {2, 8, 7}}; */
 
        int mat[][] = { { 1, 0, 2, -1 },
                        { 3, 0, 0, 5 },
                        { 2, 1, 4, -3 },
                        { 1, 0, 5, 0 } };
 
        // Function call
        System.out.printf(
            "Determinant of the matrix is : %d",
            determinantOfMatrix(mat, N));
    }
}
 
// This code is contributed by Rajput-Ji

Python3




# Python program to find Determinant of a matrix
 
 
def determinantOfMatrix(mat, n):
 
    temp = [0]*# temporary array for storing row
    total = 1
    det = 1  # initialize result
 
    # loop for traversing the diagonal elements
    for i in range(0, n):
        index = # initialize the index
 
        # finding the index which has non zero value
        while(index < n and mat[index][i] == 0):
            index += 1
 
        if(index == n):  # if there is non zero element
            # the determinant of matrix as zero
            continue
 
        if(index != i):
            # loop for swapping the diagonal element row and index row
            for j in range(0, n):
                mat[index][j], mat[i][j] = mat[i][j], mat[index][j]
 
            # determinant sign changes when we shift rows
            # go through determinant properties
            det = det*int(pow(-1, index-i))
 
        # storing the values of diagonal row elements
        for j in range(0, n):
            temp[j] = mat[i][j]
 
        # traversing every row below the diagonal element
        for j in range(i+1, n):
            num1 = temp[i]     # value of diagonal element
            num2 = mat[j][i]   # value of next row element
 
            # traversing every column of row
            # and multiplying to every row
            for k in range(0, n):
                # multiplying to make the diagonal
                # element and next row element equal
 
                mat[j][k] = (num1*mat[j][k]) - (num2*temp[k])
 
            total = total * num1  # Det(kA)=kDet(A);
 
    # multiplying the diagonal elements to get determinant
    for i in range(0, n):
        det = det*mat[i][i]
 
    return int(det/total)  # Det(kA)/k=Det(A);
 
 
# Drivers code
if __name__ == "__main__":
    # mat=[[6 1 1][4 -2 5][2 8 7]]
 
    mat = [[1, 0, 2, -1], [3, 0, 0, 5], [2, 1, 4, -3], [1, 0, 5, 0]]
    N = len(mat)
     
    # Function call
    print("Determinant of the matrix is : ", determinantOfMatrix(mat, N))

C#




// C# program to find Determinant of a matrix
using System;
 
class GFG {
 
    // Dimension of input square matrix
    static readonly int N = 4;
 
    // Function to get determinant of matrix
    static int determinantOfMatrix(int[, ] mat, int n)
    {
        int num1, num2, det = 1, index,
                        total = 1; // Initialize result
 
        // temporary array for storing row
        int[] temp = new int[n + 1];
 
        // loop for traversing the diagonal elements
        for (int i = 0; i < n; i++)
        {
            index = i; // initialize the index
 
            // finding the index which has non zero value
            while(index < n && mat[index, i] == 0)
            {
                index++;
            }
            if (index == n) // if there is non zero element
            {
                // the determinant of matrix as zero
                continue;
            }
            if (index != i)
            {
                // loop for swapping the diagonal element row
                // and index row
                for (int j = 0; j < n; j++)
                {
                    swap(mat, index, j, i, j);
                }
                // determinant sign changes when we shift
                // rows go through determinant properties
                det = (int)(det * Math.Pow(-1, index - i));
            }
 
            // storing the values of diagonal row elements
            for (int j = 0; j < n; j++)
            {
                temp[j] = mat[i, j];
            }
 
            // traversing every row below the diagonal
            // element
            for (int j = i + 1; j < n; j++)
            {
                num1 = temp[i]; // value of diagonal element
                num2 = mat[j,
                           i]; // value of next row element
 
                // traversing every column of row
                // and multiplying to every row
                for (int k = 0; k < n; k++)
                {
 
                    // multiplying to make the diagonal
                    // element and next row element equal
                    mat[j, k] = (num1 * mat[j, k])
                                - (num2 * temp[k]);
                }
                total = total * num1; // Det(kA)=kDet(A);
            }
        }
 
        // multiplying the diagonal elements to get
        // determinant
        for (int i = 0; i < n; i++)
        {
            det = det * mat[i, i];
        }
        return (det / total); // Det(kA)/k=Det(A);
    }
 
    static int[, ] swap(int[, ] arr, int i1, int j1, int i2,
                        int j2)
    {
        int temp = arr[i1, j1];
        arr[i1, j1] = arr[i2, j2];
        arr[i2, j2] = temp;
        return arr;
    }
 
    // Driver code
    public static void Main(String[] args)
    {
        /*int mat[N,N] = {{6, 1, 1},
                        {4, -2, 5},
                        {2, 8, 7}}; */
 
        int[, ] mat = { { 1, 0, 2, -1 },
                        { 3, 0, 0, 5 },
                        { 2, 1, 4, -3 },
                        { 1, 0, 5, 0 } };
 
        // Function call
        Console.Write("Determinant of the matrix is : {0}",
                      determinantOfMatrix(mat, N));
    }
}
 
// This code is contributed by 29AjayKumar

Javascript




Javascript<script>
// javascript program to find Determinant of a matrix
 
 
    // Dimension of input square matrix
      var N = 4;
 
    // Function to get determinant of matrix
    function determinantOfMatrix(mat , n)
    {
        var num1, num2, det = 1, index,
                        total = 1; // Initialize result
 
        // temporary array for storing row
        var temp = Array(n + 1).fill(0);
 
        // loop for traversing the diagonal elements
        for (i = 0; i < n; i++)
        {
            index = i; // initialize the index
 
            // finding the index which has non zero value
            while (index < n && mat[index][i] == 0)
            {
                index++;
            }
            if (index == n) // if there is non zero element
            {
                // the determinant of matrix as zero
                continue;
            }
            if (index != i)
            {
                // loop for swapping the diagonal element row
                // and index row
                for (j = 0; j < n; j++)
                {
                    swap(mat, index, j, i, j);
                }
                // determinant sign changes when we shift
                // rows go through determinant properties
                det = parseInt((det * Math.pow(-1, index - i)));
            }
 
            // storing the values of diagonal row elements
            for (j = 0; j < n; j++)
            {
                temp[j] = mat[i][j];
            }
 
            // traversing every row below the diagonal
            // element
            for (j = i + 1; j < n; j++)
            {
                num1 = temp[i]; // value of diagonal element
                num2 = mat[j]
                          [i]; // value of next row element
 
                // traversing every column of row
                // and multiplying to every row
                for (k = 0; k < n; k++)
                {
                    // multiplying to make the diagonal
                    // element and next row element equal
                    mat[j][k] = (num1 * mat[j][k])
                                - (num2 * temp[k]);
                }
                total = total * num1; // Det(kA)=kDet(A);
            }
        }
 
        // multiplying the diagonal elements to get
        // determinant
        for (i = 0; i < n; i++)
        {
            det = det * mat[i][i];
        }
        return (det / total); // Det(kA)/k=Det(A);
    }
 
     function swap(arr , i1 , j1 , i2,
                         j2)
    {
        var temp = arr[i1][j1];
        arr[i1][j1] = arr[i2][j2];
        arr[i2][j2] = temp;
        return arr;
    }
 
    // Driver code
     
 
        /*var mat[N][N] = [{6, 1, 1],
                        {4, -2, 5],
                        {2, 8, 7}]; */
 
        var mat = [ [ 1, 0, 2, -1 ],
                        [ 3, 0, 0, 5 ],
                        [ 2, 1, 4, -3 ],
                        [ 1, 0, 5, 0 ] ];
 
        // Function call
        document.write(
            "Determinant of the matrix is : ",
            determinantOfMatrix(mat, N));
 
// This code contributed by gauravrajput1
</script>

Output

Determinant of the matrix is : 30

Time complexity: O(n3
Auxiliary Space: O(n), Space used for storing row.
 

Determinant of a Matrix Using the NumPy package in Python

There is a built-in function or method in linalg module of NumPy package in python. It can be called numpy.linalg.det(mat) which returns the determinant value of the matrix mat passed in the argument.

Python3




# importing the numpy package
# as np
import numpy as np
 
def determinant(mat):
     
    # calling the det() method
    det = np.linalg.det(mat)
    return round(det)
 
# Driver Code
# declaring the matrix
mat = [[1, 0, 2, -1],
       [3, 0, 0, 5],
       [2, 1, 4, -3],
       [1, 0, 5, 0]]
 
# Function call
print('Determinant of the matrix is:',
      determinant(mat))

Output:

Determinant of the matrix is: 30

My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!