INNOVATION: Algorithm For Findind LU Factorization of Given Matrix in Java

Algorithm For Finding LU Factorization of Given Matrix in Java

Here given matrix can be decompose into two part L and U.
Here I have Algorithm for solving LU Factorization for given matrix.
You have to keep in mind that L part of given m * n matrix has dimension of m * m where as U part has dimension of m * n.

import java.util.Scanner;

public class Matrix {
    
    private int Row; //NO OF ROWS
    private int Column; //NO OF COLUMNS
    private float [][]Elements;//FOR CARRING ELEMENTS
    private float [][]U; //FOR LU FACTORIZATION
    private float [][]L; //
    private float []T;
    private int count;//FOR CHECKING EXISTS OF LU FACTORIZATION.
    private boolean write;//FOR CHECKING METRIX EXISTANCES.
    public Matrix(int No_Row,int No_Column)//PARAMETERIZED CONSTRUCTOR
    {
        if(No_Row>0 && No_Column>0)
        {
            count=0;Determinat=0;
            write=true;
            Row=No_Row;
            Column=No_Column;
            Elements = new float[No_Row][No_Column];
                U=new float[No_Row][No_Column];
                L=new float[No_Row][No_Row];
           
            T=new float[No_Column];
            for(int i=0;i<No_Column;i++){T[i]=1;}

}
        else
        {
            write=false;
            System.out.println("\nYOU CAN NOT MAKE MATRIX WITH THIS DIMENTIONS.\n");
        }
    }

public void SET_ELEMENTS_OF_MATRIX()
    {
        //if(!write){return ;}
        Scanner x=new Scanner(System.in);

for(int i=0;i<Row;i++)
        {
            for(int j=0;j<Column;j++)
            {
                System.out.println("ENTER ["+i+"]["+j+"] ELEMENT OF MATRIX :- ");
                Elements[i][j]=x.nextFloat();
            }
        }

int Hold;
        for(int i=0;i<Row;i++)
        {
            for(int j=0;j<Row;j++)
            {
                if(i<j || i>j){L[i][j]=0;}
                else
                {
                    L[i][j]=1;
                }     
            }
        }
        Algorithms_of_EF();
    }
    
    private void Algorithms_of_EF()
    {
        //if(!write){return;}
        int R=0;int CC=-1;int RC=-1;
        for(int i=0;i<Column;i++)
        {
            if(R<Row)
            {  
                if(Elements[R][i]!=0)
                {
                    CC++;
                    RC=CC;
                    if(RC<row && CC<Row)
                    {
                        L[RC][CC]=Elements[R][i];T[CC]=Elements[R][i];
                    }
                                      
                    for(int k=R+1;k<Row;k++)
                    {
                        float []Array=new float[Column];
                            RC++;
                            if(RC<Row && CC<Row){L[RC][CC]=Elements[k][i];}

for(int l=0;l<Column;l++)
                        {
                            Array[l]=Elements[k][l] - ((Elements[R][l]*Elements[k][i])/Elements[R][i]);
                        }
                        for(int l=0;l<Column;l++)
                        {
                            Elements[k][l]=Array[l];
                        }
                    }
                    R++; 
                }
                else
                {
                    int Temp=-1;
                    for(int j=(Row-1);j>R;j--)
                    {
                        if(Elements[j][i]!=0)
                        {
                                Temp=j;
                                break;
                        }
                    }

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;
                        }

CC++; 
                        RC=CC;
                        if(RC<row && CC<Row){L[RC][CC]=Elements[R][i];T[CC]=Elements[R][i];}

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

RC++;
                            if(RC<Row && CC<Row)
                            {
                               L[RC][CC]=Elements[k][i];
                            }

for(int i=0;i<Row;i++)
        {
            for(int j=0;j<Column;j++)
            {
                    U[i][j]=Elements[i][j];
            }
        }
    }

private void Set_L_Part()
    {
        //int Temp;
        for(int i=0;i<Row;i++)
        {
            for(int j=0;j<Row;j++)
            {
                L[j][i]=L[j][i]/T[i];
            }
        }  
    }

public void Get_LU_FACTORIZATION_Part()
    {
        
        if(count==0)
        {
            Set_L_Part();

System.out.println("\n------ L PART ------\n");
            int Temp;
            for(int i=0;i<Row;i++)
            {
                for(int j=0;j<Row;j++)
                {
                        if(L[i][j]==(-0.0)){L[i][j]=0;}
                        System.out.print(L[i][j]+"  ");
                }
                System.out.println();
            }

System.out.println("\n------ U PART ------\n");
                int Temp1;
                for(int i=0;i<Row;i++)
                {
                    for(int j=0;j<Column;j++)
                    {
                            System.out.print(U[i][j]+"      ");
                    }
                    System.out.println();
                }
        }
        else
        {
            System.out.println("\nLU FACTORIZATION IS NOT POSSIBLE THIS MATRIX.\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

Sunday, 20 September 2015

Algorithm For Findind LU Factorization of Given Matrix in Java

Main Class

No comments:

Post a Comment