ADAAD

import Jama.Matrix;

import java.util.ArrayList;

public class Main {

    public static void main(String[] args) {
        double[][] mA = {{1, 3, 4,7}, {-4,11, 3, 1}, {10, 3, 1,11},{2,1,17,4}};
       Matrix matrix = new Matrix(mA);
        //Matrix matrix=Matrix.random(7,7);
        Matrix m=Matrix.identity(matrix.getRowDimension(),matrix.getRowDimension());
        Matrix p=Matrix.identity(matrix.getRowDimension(),matrix.getRowDimension());
        ArrayList<Matrix> permutacje=new ArrayList<>();
        matrix.print(5,2);
        double norm=matrix.normF(),norm1;
        for(int i=0;i<matrix.getColumnDimension()-1;i++)
        {
            System.out.println("Macierz permutacji: ");
            permutacja(matrix,i).print(5,2);
            p=permutacja(matrix,i);
            permutacje.add(permutacja(matrix,i));
            matrix=permutacja(matrix,i).times(matrix);
            System.out.println("Macierz po zmianie: ");
            matrix.print(5,2);
            m=m.times(eliminacja(matrix,i).inverse());
            System.out.println("L: chwil");
            Matrix chw=Matrix.identity(matrix.getRowDimension(),matrix.getRowDimension());
            for(int j=permutacje.size()-1;j>0;j--)
            {
                chw=permutacje.get(j).times(chw);
            }
            m.print(5,2);
            chw.print(5,2);
            chw=chw.times(m);
            chw.print(5,2);

            System.out.println("Macierz eliminacji "+i);
            eliminacja(matrix,i).print(5,2);
            matrix=eliminacja(matrix,i).times(matrix);

            System.out.println("Macierz po eliminacji "+i);
            matrix.print(5,2);

        }
        System.out.println("Sprawdzenie");

        System.out.println("L:");
        Matrix chw=Matrix.identity(matrix.getRowDimension(),matrix.getRowDimension());
        m.print(5,2);
        for(int j=permutacje.size()-1;j>0;j--)
        {
            chw=permutacje.get(j).times(chw);
        }

        System.out.println("U:");
        matrix.print(5,2);
        System.out.println("Pc:");
        p=Matrix.identity(matrix.getColumnDimension(),matrix.getRowDimension());
        for(int j=permutacje.size()-1;j>-1;j--)
        {
            p=permutacje.get(j).times(p);
        }
        p.print(5,2);
        matrix=m.times(matrix);
        System.out.println("L*U");
        matrix=chw.times(matrix);
        matrix.print(5,2);
        System.out.println("Pc*A");
        chw=Matrix.identity(matrix.getRowDimension(),matrix.getRowDimension());
        for(int j=permutacje.size()-1;j>-1;j--)
        {
            chw=permutacje.get(j).times(chw);
        }
        matrix=chw.times(matrix);
        matrix.print(5,2);






    }
    static Matrix eliminacja(Matrix matrix, int column)
    {
        Matrix elim=Matrix.identity(matrix.getRowDimension(),matrix.getRowDimension());
        for(int i=0;i<matrix.getRowDimension();i++)
        {
            if(i>column)
            {
                if(matrix.get(column,column)!=0) {
                    elim.set(i, column, matrix.get(i, column) / matrix.get(column, column) * (-1));
                }
                else{
                    return null;
                }
            }
        }
        return elim;
    }
    static int findmax(Matrix matrix, int column)
    {
        double maxval=0, val;
        int max=0;
        for(int i=column; i<matrix.getRowDimension();i++)
        {
            val=matrix.get(i,column);
            if(val<0)
                val=-val;
            if(val>maxval)
            {
                maxval=val;
                max=i;
            }
        }
        return max;
    }

    static Matrix permutacja(Matrix matrix, int column)
    {
        int max=findmax(matrix,column);

        Matrix m=Matrix.identity(matrix.getRowDimension(),matrix.getRowDimension());
        m.set(column,column,0);
        m.set(max,column,1);

        m.set(max,max,0);
        m.set(column,max,1);


        return m;
    }
}