Java Program to Find Inverse of a Matrix

This is the java program to find the inverse of square invertible matrix. The matrix is invertible if its determinant is non zero.

Here is the source code of the Java Program to Find Inverse of a Matrix. The Java program is successfully compiled and run on a Windows system. The program output is also shown below.

//This is sample program to find the inverse of a matrix
 
import java.util.Scanner;
 
public class Inverse 
{
    public static void main(String argv[]) 
    {
        Scanner input = new Scanner(System.in);
        System.out.println("Enter the dimension of square matrix: ");
        int n = input.nextInt();
        double a[][]= new double[n][n];
        System.out.println("Enter the elements of matrix: ");
        for(int i=0; i<n; i++)
            for(int j=0; j<n; j++)
                a[i][j] = input.nextDouble();
 
        double d[][] = invert(a);
 
        System.out.println("The inverse is: ");
        for (int i=0; i<n; ++i) 
        {
            for (int j=0; j<n; ++j)
            {
                System.out.print(d[i][j]+"  ");
            }
            System.out.println();
        }
        input.close();
    }	
 
    public static double[][] invert(double a[][]) 
    {
        int n = a.length;
        double x[][] = new double[n][n];
        double b[][] = new double[n][n];
        int index[] = new int[n];
        for (int i=0; i<n; ++i) 
            b[i][i] = 1;
 
 // Transform the matrix into an upper triangle
        gaussian(a, index);
 
 // Update the matrix b[i][j] with the ratios stored
        for (int i=0; i<n-1; ++i)
            for (int j=i+1; j<n; ++j)
                for (int k=0; k<n; ++k)
                    b[index[j]][k]
                    	    -= a[index[j]][i]*b[index[i]][k];
 
 // Perform backward substitutions
        for (int i=0; i<n; ++i) 
        {
            x[n-1][i] = b[index[n-1]][i]/a[index[n-1]][n-1];
            for (int j=n-2; j>=0; --j) 
            {
                x[j][i] = b[index[j]][i];
                for (int k=j+1; k<n; ++k) 
                {
                    x[j][i] -= a[index[j]][k]*x[k][i];
                }
                x[j][i] /= a[index[j]][j];
            }
        }
        return x;
    }
 
// Method to carry out the partial-pivoting Gaussian
// elimination.  Here index[] stores pivoting order.
 
    public static void gaussian(double a[][], int index[]) 
    {
        int n = index.length;
        double c[] = new double[n];
 
 // Initialize the index
        for (int i=0; i<n; ++i) 
            index[i] = i;
 
 // Find the rescaling factors, one from each row
        for (int i=0; i<n; ++i) 
        {
            double c1 = 0;
            for (int j=0; j<n; ++j) 
            {
                double c0 = Math.abs(a[i][j]);
                if (c0 > c1) c1 = c0;
            }
            c[i] = c1;
        }
 
 // Search the pivoting element from each column
        int k = 0;
        for (int j=0; j<n-1; ++j) 
        {
            double pi1 = 0;
            for (int i=j; i<n; ++i) 
            {
                double pi0 = Math.abs(a[index[i]][j]);
                pi0 /= c[index[i]];
                if (pi0 > pi1) 
                {
                    pi1 = pi0;
                    k = i;
                }
            }
 
   // Interchange rows according to the pivoting order
            int itmp = index[j];
            index[j] = index[k];
            index[k] = itmp;
            for (int i=j+1; i<n; ++i) 	
            {
                double pj = a[index[i]][j]/a[index[j]][j];
 
 // Record pivoting ratios below the diagonal
                a[index[i]][j] = pj;
 
 // Modify other elements accordingly
                for (int l=j+1; l<n; ++l)
                    a[index[i]][l] -= pj*a[index[j]][l];
            }
        }
    }
}

Output:

$ javac Inverse.java
$ java Inverse
Enter the dimension of square matrix: 
2
Enter the elements of matrix: 
1 2 
3 4 
The Inverse is: 
-1.9999999999999998  1.0  
1.4999999999999998  -0.49999999999999994

Related posts:

Một số tính năng mới về xử lý ngoại lệ trong Java 7
Java Program to Perform LU Decomposition of any Matrix
Java Program to Find the Longest Subsequence Common to All Sequences in a Set of Sequences
Spring Autowiring of Generic Types
A Guide to the finalize Method in Java
Call Methods at Runtime Using Java Reflection
@Before vs @BeforeClass vs @BeforeEach vs @BeforeAll
Get the workstation name or IP
Java Program to Implement Fermat Factorization Algorithm
Ways to Iterate Over a List in Java
Java Program to Implement Johnson’s Algorithm
Java Program to Implement Wagner and Fisher Algorithm for online String Matching
Java 8 Stream findFirst() vs. findAny()
Java Program to Check Whether an Undirected Graph Contains a Eulerian Cycle
Versioning a REST API
Java InputStream to Byte Array and ByteBuffer
Comparing getPath(), getAbsolutePath(), and getCanonicalPath() in Java
Allow user:password in URL
Collect a Java Stream to an Immutable Collection
Java Program to find the maximum subarray sum using Binary Search approach
Java Program to Implement Queue using Two Stacks
Java Program to Compute Discrete Fourier Transform Using Naive Approach
Spring Boot - Hystrix
Giới thiệu Java 8
Custom Thread Pools In Java 8 Parallel Streams
Hướng dẫn Java Design Pattern – Mediator
Quick Guide to the Java StringTokenizer
Guide to Apache Commons CircularFifoQueue
Java Program to Find Strongly Connected Components in Graphs
Getting Started with Forms in Spring MVC
Java Program to Give an Implementation of the Traditional Chinese Postman Problem
Creating a Web Application with Spring 5