Program to check if matrix is singular or not

0 1 7 minutes read

A matrix is said to be singular if the determinant of the matrix is 0 otherwise it is non-singular .

Examples:

Input :  0 0 0
         4 5 6
         1 2 3
Output : Yes
Determinant value of the matrix is
0 (Note first row is 0)

Input :  1 0 0
         4 5 6
         1 2 3
Output : No
Determinant value of the matrix is 3
(which is non-zero).

First find the determinant of the matrix and the check the condition if the determinant id 0 or not, if it is 0 then matrix is a singular matrix otherwise it is a non-singular matrix .

Implementation:

C++

// C++ program check if a matrix is
// singular or not.
#include <bits/stdc++.h>
using namespace std;
#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 to check if mat[][] is
   singular or not. */
bool isSingular(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] * isSingular(temp, n - 1);
 
        // terms are to be added with alternate sign
        sign = -sign;
    }
 
    return D;
}
 
// Driver program to test above functions
int main()
{
    int mat[N][N] = { { 4, 10, 1 },
                      { 0, 0, 0 },
                      { 1, 4, -3 } };
    if (isSingular(mat, N))
        cout << "Matrix is Singular" << endl;
    else
        cout << "Matrix is non-singular" << endl;
    return 0;
}

Java

// Java program check if a matrix is 
// singular or not. 
class GFG 
{
 
    static final int N = 3;
 
    // 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 to check if mat[][] is 
    singular or not. */
    static int isSingular(int mat[][], int n) 
    {
        int D = 0; // Initialize result 
 
        // Base case : if matrix contains single element 
        if (n == 1)
        {
            return mat[0][0];
        }
 
        int temp[][] = new int[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] * isSingular(temp, n - 1);
 
            // terms are to be added with alternate sign 
            sign = -sign;
        }
 
        return D;
    }
 
    // Driver code 
    public static void main(String[] args) 
    {
        int mat[][] = {{4, 10, 1},
                        {0, 0, 0},
                        {1, 4, -3}};
        if (isSingular(mat, N) == 1) 
        {
            System.out.println("Matrix is Singular");
        } 
        else
        {
            System.out.println("Matrix is non-singular");
        }
    }
}
 
/* This code contributed by PrinciRaj1992 */

Python3

# python 3 program check if a matrix is
# singular or not.
global N
N = 3
 
# Function to get cofactor of mat[p][q] in temp[][].
# n is current dimension of mat[][]
def getCofactor(mat,temp,p,q,n):
    i = 0
    j = 0
     
    # Looping for each element of the matrix
    for row in range(n):
        for col in range(n):
             
            # Copying into temporary matrix only 
            # those element which are not in given 
            # row and column
            if (row != p and col != q):
                temp[i][j] = mat[row][col]
                j += 1
                 
                # Row is filled, so increase row
                # index and reset col index
                if (j == n - 1):
                    j = 0
                    i += 1
 
# Recursive function to check if mat[][] is
# singular or not. */
def isSingular(mat,n):
    D = 0 # Initialize result
     
    # Base case : if matrix contains single element
    if (n == 1):
        return mat[0][0]
         
    temp = [[0 for i in range(N + 1)] for i in range(N + 1)]# To store cofactors
     
    sign = 1 # To store sign multiplier
 
    # Iterate for each element of first row
    for f in range(n):
         
        # Getting Cofactor of mat[0][f]
        getCofactor(mat, temp, 0, f, n)
        D += sign * mat[0][f] * isSingular(temp, n - 1)
         
        # terms are to be added with alternate sign
        sign = -sign
    return D
 
# Driver program to test above functions
if __name__ == '__main__':
    mat = [[4, 10, 1],[0, 0, 0],[1, 4, -3]]
    if (isSingular(mat, N)):
        print("Matrix is Singular")
    else:
        print("Matrix is non-singular")
 
# This code is contributed by
# Surendra_Gangwar

C#

// C# program check if a matrix is 
// singular or not.
using System;
 
class GFG 
{
 
    static readonly int N = 3;
 
    // 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 to check if mat[,] is 
    singular or not. */
    static int isSingular(int [,]mat, int n) 
    {
        int D = 0; // Initialize result 
 
        // Base case : if matrix contains single element 
        if (n == 1)
        {
            return mat[0, 0];
        }
 
        int [,]temp = new int[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] * isSingular(temp, n - 1);
 
            // terms are to be added with alternate sign 
            sign = -sign;
        }
 
        return D;
    }
 
    // Driver code 
    public static void Main(String[] args) 
    {
        int [,]mat = {{4, 10, 1},
                        {0, 0, 0},
                        {1, 4, -3}};
        if (isSingular(mat, N) == 1) 
        {
            Console.WriteLine("Matrix is Singular");
        } 
        else
        {
            Console.WriteLine("Matrix is non-singular");
        }
    }
}
 
// This code contributed by Rajput-Ji

Javascript

<script>
  
// Javascript program check if a matrix is 
// singular or not.
var N = 3;
// Function to get cofactor of mat[p,q] in temp[,]. 
// n is current dimension of mat[,] 
function getCofactor(mat, temp, p, q, n)
{
    var i = 0, j = 0;
    // Looping for each element of the matrix 
    for (var row = 0; row < n; row++) 
    {
        for (var 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 to check if mat[,] is 
singular or not. */
function isSingular(mat, n) 
{
    var D = 0; // Initialize result 
    // Base case : if matrix contains single element 
    if (n == 1)
    {
        return mat[0][0];
    }
    var temp = Array.from(Array(N), ()=>Array(N));// To store cofactors 
    var sign = 1; // To store sign multiplier 
    // Iterate for each element of first row 
    for(var f = 0; f < n; f++)
    {
        // Getting Cofactor of mat[0,f] 
        getCofactor(mat, temp, 0, f, n);
        D += sign * mat[0][f] * isSingular(temp, n - 1);
        // terms are to be added with alternate sign 
        sign = -sign;
    }
    return D;
}
// Driver code 
var mat = [[4, 10, 1],
                [0, 0, 0],
                [1, 4, -3]];
if (isSingular(mat, N) == 1) 
{
    document.write("Matrix is Singular");
} 
else
{
    document.write("Matrix is non-singular");
}
 
// This code is contributed by noob2000.
</script>

Output:

Matrix is non-singular

Time complexity: O(n³)
Auxiliary space: O(n²), for temp array to store co-factors

Feeling lost in the world of random DSA topics, wasting time without progress? It’s time for a change! Join our DSA course, where we’ll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 zambiatek!