# Adjoint and Inverse of a Matrix

Given a square matrix, find adjoint and inverse of the matrix.

We strongly recommend you to refer below as a prerequisite of this.
Determinant of a Matrix

Adjoint (or Adjugate) of a matrix is the matrix obtained by taking 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```

```
Let A[N][N] be input 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 below formula,

```  If det(A) != 0
Else
"Inverse doesn't exist"
```

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

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

## C++

 `// C++ program to find adjoint and inverse of a matrix ` `#include ` `using` `namespace` `std; ` `#define N 4 ` ` `  `// Function to get cofactor of A[p][q] in temp[][]. n is current ` `// dimension of A[][] ` `void` `getCofactor(``int` `A[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++] = 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[][]. */` `int` `determinant(``int` `A[N][N], ``int` `n) ` `{ ` `    ``int` `D = 0; ``// Initialize result ` ` `  `    ``//  Base case : if matrix contains single element ` `    ``if` `(n == 1) ` `        ``return` `A; ` ` `  `    ``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 A[f] ` `        ``getCofactor(A, temp, 0, f, n); ` `        ``D += sign * A[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]. ` `void` `adjoint(``int` `A[N][N],``int` `adj[N][N]) ` `{ ` `    ``if` `(N == 1) ` `    ``{ ` `        ``adj = 1; ` `        ``return``; ` `    ``} ` ` `  `    ``// temp is used to store cofactors of A[][] ` `    ``int` `sign = 1, temp[N][N]; ` ` `  `    ``for` `(``int` `i=0; i ` `void` `display(T A[N][N]) ` `{ ` `    ``for` `(``int` `i=0; i

## 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[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 `

## 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 `

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().

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up

Improved By : Rajput-Ji, 29AjayKumar

Article Tags :
Practice Tags :

3

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.