import java.lang.reflect.Array;

public class MojaMacierz<T> {
    private int kol, wier;
    private T[][] macierz;
    private Class<T> klasa;

    //mnacierz zerowa
    private MojaMacierz(Class<T> c, int wier, int kol) {
        this.wier = wier;
        this.kol = kol;
        this.macierz = (T[][]) Array.newInstance(c, wier, kol);
        this.klasa = c;
        T zero;

        if (c == Ulamek.class)
            zero = (T) Ulamek.valueOf(0);
        else if (c == Float.class)
            zero = (T) Float.valueOf(0);
        else if (c == Double.class)
            zero = (T) Double.valueOf(0);
        else throw new IllegalArgumentException("Zly typ");

        for (int i = 0; i < wier; i++) {
            for (int j = 0; j < kol; j++)
                this.wpisz(zero, i, j);
        }
    }

    MojaMacierz(Class<T> klasa, T[][] tab) {
        this.wier = tab.length;
        this.kol = tab[0].length;
        this.macierz = (T[][]) Array.newInstance(klasa, wier, kol);
        for (int i = 0; i < wier; i++)
            for (int j = 0; j < kol; j++)
                this.macierz[i][j] = tab[i][j];
        this.klasa = klasa;
    }

    MojaMacierz(MojaMacierz<T> MojaMacierz) {
        this.klasa = MojaMacierz.getKlasa();
        this.wier = MojaMacierz.getWier();
        this.kol = MojaMacierz.getKol();
        this.macierz = (T[][]) Array.newInstance(this.klasa, this.wier, this.kol);
        for (int i = 0; i < MojaMacierz.getWier(); i++)
            for (int j = 0; j < MojaMacierz.getKol(); j++)
                this.macierz[i][j] = MojaMacierz.macierz[i][j];
    }

    int getWier() {
        return wier;
    }

    void setWier(int wier) {
        this.wier = wier;
    }

    int getKol() {
        return kol;
    }

    void setKol(int kol) {
        this.kol = kol;
    }

    T[][] getMacierz() {
        return macierz;
    }

    void setMacierz(T[][] macierz) {
        this.macierz = macierz;
    }

    private void wpisz(T num, int i, int j) {
        this.macierz[i][j] = num;
    }

    private T odczytaj(int wiersz, int kolumna) {
        return macierz[wiersz][kolumna];
    }

    private Class<T> getKlasa() {
        return klasa;
    }

    private void zamienWier(int i, int j) {
        T[] tmp = macierz[i];
        macierz[i] = macierz[j];
        macierz[j] = tmp;
    }

    private void zamienKol(int i, int j) {
        T tmp;
        for (int k = 0; k < wier; k++) {
            tmp = macierz[k][i];
            macierz[k][i] = macierz[k][j];
            macierz[k][j] = tmp;
        }
    }

    void absMacierz() {
        for (int i = 0; i < this.getWier(); i++)
            this.wpisz(Matematyka.abs(this.odczytaj(i, 0)), i, 0);
    }

    T macierzAvg() {
        T sum = zeroValue();
        for (int i = 0; i < this.wier; i++)
            for (int j = 0; j < this.kol; j++)
                sum = Matematyka.add(sum, this.odczytaj(i, j));
        return (T) Matematyka.div(sum, valueOf(this.wier * this.kol));
    }

    MojaMacierz<T> sub(MojaMacierz<T> B) {
        MojaMacierz<T> A = this;
        if (B.wier != A.wier || B.kol != A.kol) throw new RuntimeException("Zle wymiary");
        MojaMacierz<T> W = new MojaMacierz<T>(this.klasa, wier, kol);
        for (int i = 0; i < wier; i++)
            for (int j = 0; j < kol; j++)
                W.wpisz(Matematyka.sub(A.macierz[i][j], B.macierz[i][j]), i, j);
        return W;
    }

    MojaMacierz<T> mul(MojaMacierz<T> B) {
        MojaMacierz<T> A = this;
        if (A.kol != B.wier) throw new RuntimeException("Zle wymiary");
        MojaMacierz<T> W = new MojaMacierz<T>(this.klasa, A.wier, B.kol);

        for (int i = 0; i < W.wier; i++)
            for (int j = 0; j < W.kol; j++)
                for (int k = 0; k < A.kol; k++)
                    W.wpisz(Matematyka.add(W.macierz[i][j], Matematyka.mul(A.macierz[i][k], B.macierz[k][j])), i, j);
        return W;
    }

    @Override
    public String toString() {
        StringBuilder stringBuilder = new StringBuilder();
        for (int i = 0; i < wier; i++) {
            stringBuilder.append("[");
            for (int j = 0; j < kol; j++) {
                stringBuilder.append(odczytaj(i, j));
                if (j == kol - 1)
                    stringBuilder.append("]");
                else stringBuilder.append(" ");
            }
            stringBuilder.append("\n");
        }
        return stringBuilder.toString();
    }

    //zwraca wartosc 0 danego typu
    private T zeroValue() {
        T zero = null;
        if (klasa == Float.class)
            zero = (T) Float.valueOf(0);
        else if (klasa == Double.class)
            zero = (T) Double.valueOf(0);
        else if (klasa == Ulamek.class)
            zero = (T) Ulamek.valueOf(0);
        return zero;
    }

    private T valueOf(int value) {
        T sum = null;
        if (klasa == Float.class)
            sum = (T) Float.valueOf(value);
        else if (klasa == Double.class)
            sum = (T) Double.valueOf(value);
        else if (klasa == Ulamek.class)
            sum = (T) Ulamek.valueOf(value);
        return sum;
    }

    private void etap1(MojaMacierz<T> macierz, MojaMacierz<T> wynik, int i) {
        for (int j = i + 1; j < wynik.wier; j++) {
            T param = Matematyka.div(macierz.macierz[j][i], macierz.macierz[i][i]);
            wynik.macierz[j][0] = Matematyka.sub(wynik.macierz[j][0], Matematyka.mul(param, wynik.macierz[i][0]));

            for (int k = i; k < wynik.wier; k++)
                macierz.macierz[j][k] = Matematyka.sub(macierz.macierz[j][k], Matematyka.mul(param, macierz.macierz[i][k]));
        }
    }

    //bez wyboru el podst
    MojaMacierz<T> gaussG(MojaMacierz<T> wynik) {
        MojaMacierz<T> macierz = new MojaMacierz<T>(this);
        MojaMacierz<T> result = new MojaMacierz<T>(klasa, wynik.wier, 1);

        for (int i = 0; i < wynik.wier; i++) {
            etap1(macierz, wynik, i);
        }
        gaussResult(wynik, result, macierz);

        return result;
    }

    //czesciowy wybor
    MojaMacierz<T> gaussP(MojaMacierz<T> wynik) {
        MojaMacierz<T> macierz = new MojaMacierz<T>(this);
        MojaMacierz<T> result = new MojaMacierz<T>(klasa, wynik.wier, 1);

        for (int i = 0; i < wynik.wier; i++) {
            int max = i;
            for (int j = i + 1; j < wynik.wier; j++)
                if (Matematyka.compare(Matematyka.abs(macierz.macierz[j][i]), Matematyka.abs(macierz.macierz[max][i])) == 1)
                    max = j;

            macierz.zamienWier(i, max);
            wynik.zamienWier(i, max);

            etap1(macierz, wynik, i);
        }
        gaussResult(wynik, result, macierz);

        return result;
    }

    //pelny wybor - funkcja zapożyczona
    MojaMacierz<T> gaussF(MojaMacierz<T> wynik) {
        MojaMacierz<T> macierz = new MojaMacierz<T>(this);
        MojaMacierz<T> result = new MojaMacierz<T>(klasa, wynik.wier, 1);
        MojaMacierz<T> originalResult = new MojaMacierz<T>(klasa, wynik.wier, 1);

        int[] originalPosition;
        originalPosition = new int[wynik.wier];

        for (int j = 0; j < wynik.wier; j++)
            originalPosition[j] = j;


        for (int i = 0; i < wynik.wier; i++) {
            int maxRow = i;
            int maxColumn = i;

            for (int j = i; j < macierz.wier; j++) {
                for (int k = i; k < macierz.kol; k++) {
                    if (Matematyka.compare(Matematyka.abs(macierz.macierz[j][k]), Matematyka.abs(macierz.macierz[maxRow][maxColumn])) == 1) {
                        maxRow = j;
                        maxColumn = k;
                    }
                }
            }

            int tmp = originalPosition[i];
            originalPosition[i] = originalPosition[maxColumn];
            originalPosition[maxColumn] = tmp;

            macierz.zamienWier(i, maxRow);
            macierz.zamienKol(i, maxColumn);
            wynik.zamienWier(i, maxRow);

            etap1(macierz, wynik, i);
        }

        gaussResult(wynik, result, macierz);

        for (int j = 0; j < wynik.wier; j++)
            originalResult.macierz[originalPosition[j]][0] = result.macierz[j][0];

        return originalResult;
    }

    // zapisuje wyniki eliminacji do result
    private void gaussResult(MojaMacierz<T> wynik, MojaMacierz<T> result, MojaMacierz<T> macierz) {
        for (int i = wynik.wier - 1; i >= 0; i--) {
            T sum = zeroValue();

            for (int j = i + 1; j < wynik.wier; j++)
                sum = Matematyka.add(sum, Matematyka.mul(macierz.macierz[i][j], result.macierz[j][0]));

            result.macierz[i][0] = Matematyka.div(Matematyka.sub(wynik.macierz[i][0], sum), macierz.macierz[i][i]);
        }
    }
}