//Construct the Identity Matrix
identity = new double[rows][coloumns];
for (int x=0;x<rows;x+=1){
        for (int y=0;y<coloumns;y+=1){
                if ( x==y){
                        identity[x][y] = 1;
                }else{
                        identity[x][y] = 0;
                }
        }
}
inverse = new double[rows][coloumns];
for (int x = 0;x<rows;x++){
        for (int y = 0;y<coloumns;y++){
                inverse[x][y] = identity[x][y];
        }
}
 
 
//Outputs initial matrix
System.out.println("Initial:");
for (int x=0;x<rows;x+=1){
for (int y=0;y<coloumns;y+=1){
        output = output +"|"+matrix[x][y];
        }
        System.out.println(output);
        output="";
}
//outputs identity matrix
System.out.println();
System.out.println("Identity");
for (int x=0;x<rows;x+=1){
for (int y=0;y<coloumns;y+=1){
        output = output +"|"+inverse[x][y];
        }
        System.out.println(output);
        output="";
}
System.out.println();
 
 
 
//Begin Guassian Elimination
//for each coloumn, check each row for leading integer. If that integer is not found in the current working row, move it there. If no integer is found in the coloumn, move to next one.
int workingRow=0;
int workingColoumn=0;
boolean leadingI = false;
for (entry=0;entry<coloumns;entry+=1){
for(i=workingRow;i<rows;i+=1){
if (matrix[i][entry]!=0.0){
if (i!=workingRow){
//Bring Row with leading integer to the working row. Do ERO for Identity as well.
for(int j = 0;j<coloumns;j+=1){
        tempdouble=inverse[workingRow][j];
        inverse[workingRow][j] = inverse[i][j];
        inverse[i][j] = tempdouble;
tempdouble = matrix[workingRow][j];
matrix[workingRow][j] = matrix[i][j];
matrix[i][j] = tempdouble;
 
}
}
//Outputs Inverse Matrix
System.out.println();
System.out.println("Inverse");
for (int x=0;x<rows;x+=1){
for (int y=0;y<coloumns;y+=1){
        output = output +"|"+inverse[x][y];
        }
        System.out.println(output);
        output="";
}
System.out.println();
 
 
//Make Working Row a leading 1. Multiply Identity by same scaler.
scaler = 1/matrix[workingRow][workingColoumn];
for (int j = 0;j<coloumns;j+=1){
        System.out.println(matrix[workingRow][j]+"*"+scaler);
inverse[workingRow][j] = inverse[workingRow][j]*scaler;
matrix[workingRow][j] = matrix[workingRow][j]*scaler;
 
 
}
 
//Outputs Inverse Matrix
System.out.println();
System.out.println("Inverse");
 
for (int x=0;x<rows;x+=1){
for (int y=0;y<coloumns;y+=1){
        output = output +"|"+inverse[x][y];
        }
        System.out.println(output);
        output="";
}
System.out.println();
 
 
//Subtract mulitples of the working row from rows beneath, only if the row beneath doesn't have an entry of zero. Do same to Identity.
 
for (int k = workingRow+1; k<rows;k+=1){
 scaler = matrix[k][workingColoumn];
if (matrix[k][workingColoumn] !=0.0){
for (int j=workingColoumn;j<coloumns;j+=1){
        System.out.println(matrix[k][j]+"-"+(matrix[workingRow][j]*scaler)+ "=" + (matrix[k][j]- (matrix[workingRow][j]*scaler)) );
inverse[k][j]=inverse[k][j]-(inverse[workingRow][j]*scaler);
matrix[k][j] = matrix[k][j]- (matrix[workingRow][j]*scaler);
 
}
}
}
leadingI=true;
workingRow+=1;
}
}
 
workingColoumn+=1;
}
 
//Outputs Inverse Matrix
System.out.println();
System.out.println("Inverse");
for (int x=0;x<rows;x+=1){
for (int y=0;y<coloumns;y+=1){
        output = output +"|"+inverse[x][y];
        }
        System.out.println(output);
        output="";
}
System.out.println();
 
//Done Guassian Elimination
 
for (i=0;i<rows;i+=1){
for (entry=0;entry<coloumns;entry+=1){
        output = output +"|"+matrix[i][entry];
        }
        System.out.println(output);
        output="";
}
 
 
 
//Begin Jordan Elimination
 
for (i=rows-1;i>=0;i-=1){
        leadingI=false;
        //For each row, starting at bottom going to top
        for (entry=0;entry<coloumns;entry+=1){
                //For each coloumn going from left to right
                if (matrix[i][entry]==1.0 & leadingI==false){
                        //Find an entry of 1
                for (int k=i-1;k>=0;k-=1){
                        scaler = (matrix[k][entry]);
                        if (matrix[k][entry]!=0.0){
                        for (int j=entry;j<coloumns;j+=1){
                                System.out.println(matrix[k][j]+"-"+(matrix[i][j]*scaler));
                                inverse[k][j]=inverse[k][j]-(inverse[i][j]*scaler);
                                matrix[k][j]=matrix[k][j]- (matrix[i][j]*scaler);
 
                }
}
        }
leadingI=true;
}
}
}
 
System.out.println("Finished");
for (i=0;i<rows;i+=1){
for (entry=0;entry<coloumns;entry+=1){
        output = output +"|"+matrix[i][entry];
        }
        System.out.println(output);
        output="";
}
System.out.println();
System.out.println("Inverse:");
for (i=0;i<rows;i+=1){
for (entry=0;entry<coloumns;entry+=1){
        output = output +"|"+inverse[i][entry];
        }
        System.out.println(output);
        output="";
}
 
 
 
 
}
}