INNOVATION: Algorithm Of Finding Inverse Of Matrix Using Row Reduced Echelon Method

Algorithm Of Finding Inverse Of Matrix Using Row Reduced Echelon Form Method

Here I have one nice algorithm for solving inverse of square matrix with help of echelon form algorithm which i have available on this blog which is quite efficient than any other method.

import java.util.Scanner;

class Matrix
{
 private int Row;
 private int Column;
 private float [][]Elements;
        private float [][]Inverse;
 
 public Matrix(int No_Row,int No_Column)
 {
  Row=No_Row;
  Column=No_Column;
  Elements = new float[No_Row][No_Column];
                if(No_Row==No_Column)
                {
                    Inverse = new float[No_Row][No_Column];

for(int i=0;i<No_Row;i++)
                    {
                        for(int j=0;j<No_Column;j++)
                        {
                             if(i==j){Inverse[i][j]=1;}else{Inverse[i][j]=0;}
                        }
                    }
                }
 }
 
 public void SetElements()
 {
  Scanner x=new Scanner(System.in);
  
  for(int i=0;i<Row;i++)
  {
   for(int j=0;j<Column;j++)
   {
    System.out.print("\nENTER ["+i+"]["+j+"] ELEMENT OF MATRIX :- ");
    Elements[i][j]=x.nextFloat();
   }
  }

}
 
    private void Algorithms_of_EF()
    {
        int R=0;
        for(int i=0;i<Column;i++)
        {
            if(R<Row)
            {  
                if(Elements[R][i]!=0)
                {
                                      
                    for(int k=R+1;k<Row;k++)
                    {
                        float []Array=new float[Column];
                        float []Array1=new float[Column];

if(Temp!=-1)
                    {
                        count++;
                        for(int f=0;f<Column;f++)
                        {
                            float Temp1= Elements[Temp][f];
                            Elements[Temp][f]=Elements[R][f];
                            Elements[R][f]=Temp1;
                            if(Row==Column)
                            {
                                float Temp2= Inverse[Temp][f];
                                Inverse[Temp][f]=Inverse[R][f];
                                Inverse[R][f]=Temp2;                                    
                            }
                        }

for(int k=R+1;k<Row;k++)
                        {
                            float []Array=new float[Column];
                            float []Array1=new float[Column];

for(int l=0;l<Column;l++)
                            {
                                Array[l]=Elements[k][l] - ((Elements[R][l]*Elements[k][i])/Elements[R][i]);
                                if(Row==Column)
                                {
                                    Array1[l]=Inverse[k][l]- ((Inverse[R][l]*Elements[k][i])/Elements[R][i]);
                                }
                            }
                            for(int l=0;l<Column;l++)
                            {
                                Elements[k][l]=Array[l];
                                if(Row==Column)
                                {
                                    Inverse[k][l]=Array1[l];
                                }
                            }
                        }
                        R++;
                    }
                }
            }
        }
    }
 
    public void GET_INVERSE_OF_MATRIX()
    {
        
        if(Row==Column)
        {
            for(int i=0;i<Row;i++)
            {
                for(int j=0;j<Column;j++)
                {
                    System.out.print(Inverse[i][j]+"        ");
                }
                System.out.println();
            }
        }
        else
        {
            System.out.println("\nSORRY BUT INVERSE OF THIS MATRIX MIGHT NOT POSSIBLE\n");
        }
    }
 
         
 public void Display()
 {
  System.out.println("\n\n");
  for(int i=0;i<Row;i++)
  {
   for(int j=0;j<Column;j++)
   {
    if(Elements[i][j]==(-0.0)){Elements[i][j]=0;}
    System.out.print(Elements[i][j]+"  ");
   }
   System.out.println();
  }
 }
}

INNOVATION

Saturday, 8 August 2015

Algorithm Of Finding Inverse Of Matrix Using Row Reduced Echelon Method

Algorithm Of Finding Inverse Of Matrix Using Row Reduced Echelon Form Method

Main Class

No comments:

Post a Comment