Adjoint and Inverse of a Matrix

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  71   0  0  3-3  1  5  03  -1 -9  4For 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 previousmatrix'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 = IThe matrix 'B' is said to be inverse of 'A'.i.e.,  B = A-1`
• 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 ``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

 ``

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

Previous
Next