Open In App
Related Articles

Adjoint and Inverse of a Matrix

Improve
Improve
Improve
Like Article
Like
Save Article
Save
Report issue
Report

Given a square matrix, find the adjoint and inverse of the matrix. 
We strongly recommend you to refer below as a prerequisite for this. 

Determinant of a Matrix

Adjoint (or Adjugate) of a matrix is the matrix obtained by taking the transpose of the cofactor matrix of a given square matrix is called its Adjoint or Adjugate matrix. The Adjoint of any square matrix ‘A’ (say) is represented as Adj(A). 

Example: 

Below example and explanation are taken from here.
5 -2 2 7
1 0 0 3
-3 1 5 0
3 -1 -9 4

For instance, the cofactor of the top left corner '5' is
+ |0 0 3|
...|1 5 0| = 3(1 * -9 - (-1) * 5) = -12.
...|-1 -9 4|
(The minor matrix is formed by deleting the row
and column of the given entry.)

As another sample, the cofactor of the top row corner '-2' is
-|1 0 3|
...|-3 5 0| = - [1 (20 - 0) - 0 + 3 (27 - 15)] = -56.
...|3 -9 4|

Proceeding like this, we obtain the matrix
[-12 -56 4 4]
[76 208 4 4]
[-60 -82 -2 20]
[-36 -58 -10 12]

Finally, to get the adjoint, just take the previous
matrix's transpose:
[-12 76 -60 -36]
[-56 208 -82 -58]
[4 4 -2 -10]
[4 4 20 12]

Important properties: 

Product of a square matrix A with its adjoint yields a diagonal matrix, where each diagonal entry is equal to determinant of A. 
i.e. 

A.adj(A) = det(A).I 

I => Identity matrix of same order as of A.
det(A) => Determinant value of A

A non-zero square matrix ‘A’ of order n is said to be invertible if there exists a unique square matrix ‘B’ of order n such that,

   A.B = B.A = I
The matrix 'B' is said to be inverse of 'A'.
i.e., B = A-1
  • adj(AB) = (adj B).(adj A)
  • adj( k A) = kn-1 adj(A)
  • A-1 = (adj A) / |A|
  • (A-1)-1 = A
  • (AB)-1 = B-1A-1

How to find Adjoint? 

We follow the definition given above. 

Let A[N][N] be input matrix.

1) Create a matrix adj[N][N] store the adjoint matrix.
2) For every entry A[i][j] in input matrix where 0 <= i < N
and 0 <= j < N.
a) Find cofactor of A[i][j]
b) Find sign of entry. Sign is + if (i+j) is even else
sign is odd.
c) Place the cofactor at adj[j][i]

How to find Inverse? 

Inverse of a matrix exists only if the matrix is non-singular i.e., determinant should not be 0. 
Using determinant and adjoint, we can easily find the inverse of a square matrix using the below formula,

  If det(A) != 0
A-1 = adj(A)/det(A)
Else
"Inverse doesn't exist"

Inverse is used to find the solution to a system of linear equations.

Below are implementations for finding adjoint and inverse of a matrix.  

C++

// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
int dp[100][3];
 
// Function to find the maximum sum of
// subsequence with consecutive terms
// having different parity
int maxSum(int* arr, int i, int n,
        int prev, bool is_selected)
{
    // Base Case
    if (i == n) {
        return 0;
    }
 
    // Store the parity of number at
    // the ith position
    int cur = abs(arr[i]) % 2;
 
    // If the dp state has already been
    // calculated, return it
    if (dp[i][prev] != -1) {
        return dp[i][prev];
    }
 
    // If the array is traversed and
    // no element has been selected yet
    // then select the current element
    if (i == n - 1 && is_selected == 0)
        return dp[i][prev] = arr[i];
 
    // If the parity of the current and
    // previously selected element are
    // different, then select the
    // current element
    if (cur != prev) {
        dp[i][prev] = arr[i]
                    + maxSum(arr, i + 1,
                            n, cur, 1);
    }
 
    // Skip the current element and move
    // to the next element
    dp[i][prev]
        = max(dp[i][prev],
            maxSum(arr, i + 1, n,
                    prev, is_selected));
 
    // Return the result
    return dp[i][prev];
}
 
// Function to calculate the maximum sum
// subsequence with consecutive terms
// having different parity
void maxSumUtil(int arr[], int n)
{
 
    // Initialize the dp[] array with -1
    memset(dp, -1, sizeof(dp));
 
    // Initially the prev value is set to
    // say 2, as the first element can
    // anyways be selected
    cout << maxSum(arr, 0, n, 2, 0);
}
 
// Driver Code
int main()
{
    int arr[] = { 1, 2, 6, 8, -5, 10 };
    int N = sizeof(arr) / sizeof(arr[0]);
    maxSumUtil(arr, N);
 
    return 0;
}

                    

Java

// Java program to find adjoint and inverse of a matrix
class GFG
{
     
static final int N = 4;
 
// Function to get cofactor of A[p][q] in temp[][]. n is current
// dimension of A[][]
static void getCofactor(int A[][], 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++] = A[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 A[][]. */
static int determinant(int A[][], int n)
{
    int D = 0; // Initialize result
 
    // Base case : if matrix contains single element
    if (n == 1)
        return A[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 A[0][f]
        getCofactor(A, temp, 0, f, n);
        D += sign * A[0][f] * determinant(temp, n - 1);
 
        // terms are to be added with alternate sign
        sign = -sign;
    }
 
    return D;
}
 
// Function to get adjoint of A[N][N] in adj[N][N].
static void adjoint(int A[][],int [][]adj)
{
    if (N == 1)
    {
        adj[0][0] = 1;
        return;
    }
 
    // temp is used to store cofactors of A[][]
    int sign = 1;
    int [][]temp = new int[N][N];
 
    for (int i = 0; i < N; i++)
    {
        for (int j = 0; j < N; j++)
        {
            // Get cofactor of A[i][j]
            getCofactor(A, temp, i, j, N);
 
            // sign of adj[j][i] positive if sum of row
            // and column indexes is even.
            sign = ((i + j) % 2 == 0)? 1: -1;
 
            // Interchanging rows and columns to get the
            // transpose of the cofactor matrix
            adj[j][i] = (sign)*(determinant(temp, N-1));
        }
    }
}
 
// Function to calculate and store inverse, returns false if
// matrix is singular
static boolean inverse(int A[][], float [][]inverse)
{
    // Find determinant of A[][]
    int det = determinant(A, N);
    if (det == 0)
    {
        System.out.print("Singular matrix, can't find its inverse");
        return false;
    }
 
    // Find adjoint
    int [][]adj = new int[N][N];
    adjoint(A, adj);
 
    // Find Inverse using formula "inverse(A) = adj(A)/det(A)"
    for (int i = 0; i < N; i++)
        for (int j = 0; j < N; j++)
            inverse[i][j] = adj[i][j]/(float)det;
 
    return true;
}
 
// Generic function to display the matrix. We use it to display
// both adjoin and inverse. adjoin is integer matrix and inverse
// is a float.
 
static void display(int A[][])
{
    for (int i = 0; i < N; i++)
    {
        for (int j = 0; j < N; j++)
            System.out.print(A[i][j]+ " ");
        System.out.println();
    }
}
static void display(float A[][])
{
    for (int i = 0; i < N; i++)
    {
        for (int j = 0; j < N; j++)
            System.out.printf("%.6f ",A[i][j]);
        System.out.println();
    }
}
 
// Driver program
public static void main(String[] args)
{
    int A[][] = { {5, -2, 2, 7},
                    {1, 0, 0, 3},
                    {-3, 1, 5, 0},
                    {3, -1, -9, 4}};
 
    int [][]adj = new int[N][N]; // To store adjoint of A[][]
 
    float [][]inv = new float[N][N]; // To store inverse of A[][]
 
    System.out.print("Input matrix is :\n");
    display(A);
 
    System.out.print("\nThe Adjoint is :\n");
    adjoint(A, adj);
    display(adj);
 
    System.out.print("\nThe Inverse is :\n");
    if (inverse(A, inv))
        display(inv);
 
}
}
 
// This code is contributed by Rajput-Ji

                    

Python3

# Python3 program to find adjoint and
# inverse of a matrix
N = 4
 
# Function to get cofactor of
# A[p][q] in temp[][]. n is current
# dimension of A[][]
def getCofactor(A, 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] = A[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 for finding determinant of matrix.
#  n is current dimension of A[][].
def determinant(A, n):
 
    D = 0   # Initialize result
 
    # Base case : if matrix contains single element
    if (n == 1):
        return A[0][0]
 
    temp = []   # To store cofactors
    for i in range(N):
        temp.append([None for _ in range(N)])
 
    sign = 1   # To store sign multiplier
 
    # Iterate for each element of first row
    for f in range(n):
 
        # Getting Cofactor of A[0][f]
        getCofactor(A, temp, 0, f, n)
        D += sign * A[0][f] * determinant(temp, n - 1)
 
        # terms are to be added with alternate sign
        sign = -sign
 
    return D
 
 
# Function to get adjoint of A[N][N] in adj[N][N].
def adjoint(A, adj):
 
    if (N == 1):
        adj[0][0] = 1
        return
 
    # temp is used to store cofactors of A[][]
    sign = 1
    temp = []   # To store cofactors
    for i in range(N):
        temp.append([None for _ in range(N)])
 
    for i in range(N):
        for j in range(N):
            # Get cofactor of A[i][j]
            getCofactor(A, temp, i, j, N)
 
            # sign of adj[j][i] positive if sum of row
            # and column indexes is even.
            sign = [1, -1][(i + j) % 2]
 
            # Interchanging rows and columns to get the
            # transpose of the cofactor matrix
            adj[j][i] = (sign)*(determinant(temp, N-1))
 
 
# Function to calculate and store inverse, returns false if
# matrix is singular
def inverse(A, inverse):
 
    # Find determinant of A[][]
    det = determinant(A, N)
    if (det == 0):
        print("Singular matrix, can't find its inverse")
        return False
 
    # Find adjoint
    adj = []
    for i in range(N):
        adj.append([None for _ in range(N)])
    adjoint(A, adj)
 
    # Find Inverse using formula "inverse(A) = adj(A)/det(A)"
    for i in range(N):
        for j in range(N):
            inverse[i][j] = adj[i][j] / det
 
    return True
 
 
# Generic function to display the
# matrix. We use it to display
# both adjoin and inverse. adjoin
# is integer matrix and inverse
# is a float.
def display(A):
    for i in range(N):
        for j in range(N):
            print(A[i][j], end=" ")
        print()
 
 
def displays(A):
    for i in range(N):
        for j in range(N):
            print(round(A[i][j], 6), end=" ")
        print()
 
 
# Driver program
 
A = [[5, -2, 2, 7], [1, 0, 0, 3], [-3, 1, 5, 0], [3, -1, -9, 4]]
adj = [None for _ in range(N)]
inv = [None for _ in range(N)]
 
for i in range(N):
    adj[i] = [None for _ in range(N)]
    inv[i] = [None for _ in range(N)]
 
 
print("Input matrix is :")
display(A)
 
print("\nThe Adjoint is :")
adjoint(A, adj)
display(adj)
 
print("\nThe Inverse is :")
if (inverse(A, inv)):
    displays(inv)
 
# This code is contributed by phasing17

                    

C#

// C# program to find adjoint and inverse of a matrix
using System;
using System.Collections.Generic;
 
class GFG
{
     
static readonly int N = 4;
 
// Function to get cofactor of A[p,q] in [,]temp. n is current
// dimension of [,]A
static void getCofactor(int [,]A, 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++] = A[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 [,]A. */
static int determinant(int [,]A, int n)
{
    int D = 0; // Initialize result
 
    // Base case : if matrix contains single element
    if (n == 1)
        return A[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 A[0,f]
        getCofactor(A, temp, 0, f, n);
        D += sign * A[0, f] * determinant(temp, n - 1);
 
        // terms are to be added with alternate sign
        sign = -sign;
    }
    return D;
}
 
// Function to get adjoint of A[N,N] in adj[N,N].
static void adjoint(int [,]A, int [,]adj)
{
    if (N == 1)
    {
        adj[0, 0] = 1;
        return;
    }
 
    // temp is used to store cofactors of [,]A
    int sign = 1;
    int [,]temp = new int[N, N];
 
    for (int i = 0; i < N; i++)
    {
        for (int j = 0; j < N; j++)
        {
            // Get cofactor of A[i,j]
            getCofactor(A, temp, i, j, N);
 
            // sign of adj[j,i] positive if sum of row
            // and column indexes is even.
            sign = ((i + j) % 2 == 0)? 1: -1;
 
            // Interchanging rows and columns to get the
            // transpose of the cofactor matrix
            adj[j, i] = (sign) * (determinant(temp, N - 1));
        }
    }
}
 
// Function to calculate and store inverse, returns false if
// matrix is singular
static bool inverse(int [,]A, float [,]inverse)
{
    // Find determinant of [,]A
    int det = determinant(A, N);
    if (det == 0)
    {
        Console.Write("Singular matrix, can't find its inverse");
        return false;
    }
 
    // Find adjoint
    int [,]adj = new int[N, N];
    adjoint(A, adj);
 
    // Find Inverse using formula "inverse(A) = adj(A)/det(A)"
    for (int i = 0; i < N; i++)
        for (int j = 0; j < N; j++)
            inverse[i, j] = adj[i, j]/(float)det;
 
    return true;
}
 
// Generic function to display the matrix. We use it to display
// both adjoin and inverse. adjoin is integer matrix and inverse
// is a float.
static void display(int [,]A)
{
    for (int i = 0; i < N; i++)
    {
        for (int j = 0; j < N; j++)
            Console.Write(A[i, j]+ " ");
        Console.WriteLine();
    }
}
static void display(float [,]A)
{
    for (int i = 0; i < N; i++)
    {
        for (int j = 0; j < N; j++)
            Console.Write("{0:F6} ", A[i, j]);
        Console.WriteLine();
    }
}
 
// Driver program
public static void Main(String[] args)
{
    int [,]A = { {5, -2, 2, 7},
                    {1, 0, 0, 3},
                    {-3, 1, 5, 0},
                    {3, -1, -9, 4}};
 
    int [,]adj = new int[N, N]; // To store adjoint of [,]A
 
    float [,]inv = new float[N, N]; // To store inverse of [,]A
 
    Console.Write("Input matrix is :\n");
    display(A);
 
    Console.Write("\nThe Adjoint is :\n");
    adjoint(A, adj);
    display(adj);
 
    Console.Write("\nThe Inverse is :\n");
    if (inverse(A, inv))
        display(inv);
}
}
 
// This code is contributed by 29AjayKumar

                    

Javascript

<script>
 
// JavaScript program to find adjoint and
// inverse of a matrix
 
let N = 4;
// Function to get cofactor of
// A[p][q] in temp[][]. n is current
// dimension of A[][]
function getCofactor(A,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++] = A[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 A[][]. */
function determinant(A,n)
{
    let D = 0; // Initialize result
   
    // Base case : if matrix contains single element
    if (n == 1)
        return A[0][0];
   
    let temp = new Array(N);// To store cofactors
    for(let i=0;i<N;i++)
    {
        temp[i]=new Array(N);
    }
   
    let sign = 1; // To store sign multiplier
   
    // Iterate for each element of first row
    for (let f = 0; f < n; f++)
    {
        // Getting Cofactor of A[0][f]
        getCofactor(A, temp, 0, f, n);
        D += sign * A[0][f] * determinant(temp, n - 1);
   
        // terms are to be added with alternate sign
        sign = -sign;
    }
   
    return D;
}
 
// Function to get adjoint of A[N][N] in adj[N][N].
function  adjoint(A,adj)
{
    if (N == 1)
    {
        adj[0][0] = 1;
        return;
    }
   
    // temp is used to store cofactors of A[][]
    let sign = 1;
    let temp = new Array(N);
    for(let i=0;i<N;i++)
    {
        temp[i]=new Array(N);
    }
   
    for (let i = 0; i < N; i++)
    {
        for (let j = 0; j < N; j++)
        {
            // Get cofactor of A[i][j]
            getCofactor(A, temp, i, j, N);
   
            // sign of adj[j][i] positive if sum of row
            // and column indexes is even.
            sign = ((i + j) % 2 == 0)? 1: -1;
   
            // Interchanging rows and columns to get the
            // transpose of the cofactor matrix
            adj[j][i] = (sign)*(determinant(temp, N-1));
        }
    }
}
 
// Function to calculate and store inverse, returns false if
// matrix is singular
function inverse(A,inverse)
{
    // Find determinant of A[][]
    let det = determinant(A, N);
    if (det == 0)
    {
        document.write("Singular matrix, can't find its inverse");
        return false;
    }
   
    // Find adjoint
    let adj = new Array(N);
    for(let i=0;i<N;i++)
    {
        adj[i]=new Array(N);
    }
    adjoint(A, adj);
   
    // Find Inverse using formula "inverse(A) = adj(A)/det(A)"
    for (let i = 0; i < N; i++)
        for (let j = 0; j < N; j++)
            inverse[i][j] = adj[i][j]/det;
   
    return true;
}
 
// Generic function to display the
// matrix. We use it to display
// both adjoin and inverse. adjoin
// is integer matrix and inverse
// is a float.
function display(A)
{
    for (let i = 0; i < N; i++)
    {
        for (let j = 0; j < N; j++)
            document.write(A[i][j]+ " ");
        document.write("<br>");
    }
}
 
 
function displays(A)
{
    for (let i = 0; i < N; i++)
    {
        for (let j = 0; j < N; j++)
            document.write(A[i][j].toFixed(6)+" ");
        document.write("<br>");
    }
}
 
// Driver program
let A=[[5, -2, 2, 7],
                    [1, 0, 0, 3],
                    [-3, 1, 5, 0],
                    [3, -1, -9, 4]];
let adj = new Array(N);
let inv = new Array(N);
 
for(let i=0;i<N;i++)
{
    adj[i]=new Array(N);
    inv[i]=new Array(N);
}
 
document.write("Input matrix is :<br>");
display(A);
 
document.write("<br>The Adjoint is :<br>");
adjoint(A, adj);
display(adj);
 
document.write("<br>The Inverse is :<br>");
if (inverse(A, inv))
    displays(inv);
 
 
 
// This code is contributed by rag2127
 
</script>

                    

Output:

The Adjoint is :
-12 76 -60 -36
-56 208 -82 -58
4 4 -2 -10
4 4 20 12

The Inverse is :
-0.136364 0.863636 -0.681818 -0.409091
-0.636364 2.36364 -0.931818 -0.659091
0.0454545 0.0454545 -0.0227273 -0.113636
0.0454545 0.0454545 0.227273 0.136364

Please refer https://www..geeksforgeeks.org/determinant-of-a-matrix/ for details of getCofactor() and determinant().

 



Last Updated : 22 Dec, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads