AYDIN ÇALIKOĞLU

package com.aydincalikoglu.LinearSolverDeluxeService.impl;

import com.aydincalikoglu.LinearSolverDeluxeService.Solver;

import java.util.*;
import java.util.List;
import java.util.stream.Collectors;

import static java.lang.Math.abs;

/**
 * Created by Aydın on 11.10.2018.
 */
public class GaussianElimination implements Solver {
    private List<List<Double>> katSayilar;
    private List<Double> sabitler;
    private List<Double> x = new ArrayList<Double>();

    /**
     * Kat sayılar ile aldığı sabitleri Gaus Elimination yöntemi ile hesaplar ve sonuçları verir.
     * @param katSayilar
     * @param sabitler
     * @return ArrayList olarak X değerlerini döndürür.
     */
    private List<Double> calculate(List<List<Double>> katSayilar, List<Double> sabitler)
    {
        this.katSayilar=katSayilar;
        this.sabitler = sabitler;
        pivotlama(0,0);
        if (!controlDiagonal(0)) {
            System.out.println(“it couldnt calculate because there is 0 in diagonal of the matrix after GausElimanation“);
            return null;
        }
        else
        {
            BackSubstitution();

        }
        return x;
    }

    /**
     * Hesaplanmış olan üst üçgensel matrisi üzerinde, en alt x değerlerinden başlayarak tüm x değerlerini hesaplar.
     */
    private void BackSubstitution()
    {
        int j=sabitler.size()-2;
        for (int i = sabitler.size()-1; i >-1 ; i--) {
            double sonuc=sabitler.get(i);
            int l=0;
            for (int k = sabitler.size()-1; k >j ; k--) {
                if (l<x.size()) {
                    sonuc-=katSayilar.get(i).get(k)*x.get(l);
                    l++;
                }
                else
                    x.add(sonuc/katSayilar.get(i).get(k));
            }
            j--;
        }
        reverseListX();
    }

    /**
     * Recursive Köşegen Matris kontrolü
     * @param index
     * @return Köşeğen matris ise true değerini verir.
     */
    private boolean controlDiagonal(int index)
    {
        if (index==sabitler.size()) {
            return true;
        }
        if (katSayilar.size()<index)
            return false;
        // Köşegen Matris kontrolü
        if (katSayilar.get(index).get(index)==0) {
            return false;
        }
        return controlDiagonal(index+1);
    }

    /**
     * Maksimum pivotları tekrar hesaplamamak için dinamik bir yapı kullanılmıştır.
     */
    private ArrayList<Double> maxPivot = new ArrayList<>();

    /**
     * Büyük Sayıların olduğu pivotları matris üzerinde en üste taşıyarak, Bölmelerde minumum hata payı elderek
     * Her Satirda Gauss elimination yöntemini kullanılmıştır.
     * @param col
     * @param row
     */
    private void pivotlama(int col,int row)
    {
        // Büyük Sayıların olduğu pivotları en üste taşıyarak, Bölmelerde minumum hata payı elde etmeye çalışıyoruz.
        if (row==sabitler.size()-1) {
            return;
        }
        double rowMaxNum=0;
        int maxValueRowIndex=0;
        for (int i = row; i < katSayilar.size(); i++) {
            double colMaxNum=abs(katSayilar.get(i).get(col));
            for (int j = col+1; j < katSayilar.get(i).size(); j++) {
                double ColumnValue=abs(katSayilar.get(i).get(j));
                if (colMaxNum<ColumnValue)
                {
                    colMaxNum=ColumnValue;
                }
            }
            if (row!=0) {
                colMaxNum = maxPivot.get(i);
            }
            else
                maxPivot.add(colMaxNum);

            colMaxNum=abs(katSayilar.get(i).get(col))/colMaxNum;
            if (rowMaxNum<colMaxNum) {
                rowMaxNum=colMaxNum;
                maxValueRowIndex=i;
            }
        }

        // Kat sayılarda ve sabitlerde yer değiştirme
        if (katSayilar.get(maxValueRowIndex).get(col)!=0) {
            List<Double> tempAr=katSayilar.get(row);
            katSayilar.set(row, katSayilar.get(maxValueRowIndex));
            katSayilar.set(maxValueRowIndex, tempAr);
            double tempSon=sabitler.get(row);
            sabitler.set(row, sabitler.get(maxValueRowIndex));
            sabitler.set(maxValueRowIndex, tempSon);
        }
        gaussElimination(col,row);
        pivotlama(col+1,row+1);
    }

    /**
     * Matris içerisinde verilen satır ve sütun sonrasındaki tüm satırları pivot elemanlarına bölerek üst üçgensel bir matrise yakınlaştırır.
     * @param col
     * @param row
     */
    private void gaussElimination(int col,int row)
    {
        for (int i = row+1; i < katSayilar.size(); i++) {
            if(katSayilar.get(i).get(row)==0)
                continue;
            double kat=katSayilar.get(i).get(row)/katSayilar.get(row).get(row);
            for (int j = col; j < katSayilar.get(i).size(); j++) {
                katSayilar.get(i).set(j, katSayilar.get(i).get(j)-(katSayilar.get(row).get(j)*kat));
            }
            sabitler.set(i,sabitler.get(i)-sabitler.get(row)*kat);
        }
    }

    /**
     * Kat sayılar matrisi ve sabitler matrisini ekrana yazdırır.
     */
    public void printMatries()
    {
        for (int i = 0; i < katSayilar.size(); i++) {
            for (int j = 0; j < katSayilar.get(i).size(); j++) {
                System.out.printf(“%.4f “,katSayilar.get(i).get(j));
            }
            System.out.printf(“= %.4f 
“,sabitler.get(i));
        }
        System.out.println();
    }

    @Override
    public String toString() {
        return x.stream().map(i -> System.out.format(“%.2f“,i).toString()).collect(Collectors.joining(System.lineSeparator()));
    }

    /**
     * Hesaplanmış olan X değerlerini ekrana yazdırır.
     */
    public void printAllX()
    {
        for (int i = 0; i < x.size(); i++) {
            System.out.printf(“x%d: %.4f “,i+1,x.get(i));
        }
        System.out.println();
    }

    /**
     * x değerlerini doğru sırayla listeye eklenmesi için reverse alınır.
     */
    private void reverseListX()
    {
        if (x.size()==0)
            return;
        double temp=x.get(0);
        x.remove(0);
        reverseListX();
        x.add(temp);
    }

    @Override
    public List<Double> solveMatris(List<List<Double>> katSayilar, List<Double> sabitler) {
        return calculate(katSayilar,sabitler);
    }
}

package com.aydincalikoglu.LinearSolverDeluxeService.impl;

import com.aydincalikoglu.LinearSolverDeluxeService.Solver;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.DoubleStream;

import static java.lang.Math.abs;

public class InverseMatrixMethod implements Solver {
    @Override
    public List<Double> solveMatris(List<List<Double>> katSayilar, List<Double> sabitler) {
        return calculate(katSayilar, sabitler);
    }

    private List<Double> calculate(final List<List<Double>> katSayilar, List<Double> sabitler)
    {
        List<List<Double>> a = katSayilar;
        List<Double> b = sabitler;

        List<List<Double>> inverseA = inverse(a);
        List<Double> result = multiply(inverse(a), b);

        System.out.println(“The inverse is: “);
        for (int i=0; i<inverseA.size(); ++i)
        {
            for (int j=0; j<inverseA.size(); ++j)
            {
                System.out.print(inverseA.get(i).get(j) +“  “);
            }
            System.out.println();
        }

        return result;
    }

    private double determinant(List<List<Double>> matris) {
        if (matris.size() == 2)
            return matris.get(0).get(0) * matris.get(1).get(1) - matris.get(0).get(1) * matris.get(1).get(0);

        double det = 0;
        for (int i = 0; i < matris.get(0).size(); i++) {
            det += Math.pow(-1, i) * matris.get(0).get(i)
                    * determinant(minor(matris, 0, i));
        }
        return det;
    }

    public List<List<Double>> inverse(List<List<Double>> matris) {
        List<List<Double>> inverseMatrix = new ArrayList<>();
        // Minor ve kofaktor hesaplama
        for (int i = 0; i < matris.size(); i++) {
            inverseMatrix.add(new ArrayList<>());
            for (int j = 0; j < matris.get(i).size(); j++) {
                inverseMatrix.get(i).add(Math.pow(-1, i + j) * determinant(
                        minor(matris, i, j)));
            }
        }
        double det = 1.0 / determinant(matris);
        for (int i = 0; i < inverseMatrix.size(); i++) {
            for (int j = 0; j <= i; j++) {
                double temp = inverseMatrix.get(i).get(j);
                inverseMatrix.get(i).set(j, inverseMatrix.get(j).get(i) * det);
                inverseMatrix.get(j).set(i, temp * det);
            }
        }
        return inverseMatrix;
    }

    private List<List<Double>> minor(List<List<Double>> matris, int row, int col) {
        Double[][] minor = new Double[matris.size() - 1][matris.size() - 1];
        for (int i = 0; i < matris.size(); i++)
            for (int j = 0; i != row && j < matris.get(i).size(); j++)
                if (j != col)
                    minor[i < row ? i : i - 1][j < col ? j : j - 1] = matris.get(i).get(j);
        List<List<Double>> result = new ArrayList<>();
        for(Double[] array : minor){
            List<Double> list = Arrays.asList(Arrays.stream(array).toArray( Double[]::new ));
            result.add(list);
        }
        return result;
    }

    private List<Double> multiply(List<List<Double>> a, List<Double> b) {
        List<Double>  result = new ArrayList<>();
        for (int i = 0; i < a.size(); i++) {
                double sum = 0;
                for (int k = 0; k < a.get(i).size(); k++)
                    sum += a.get(i).get(k) * b.get(k);
            result.add(sum);
        }
        return result;
    }
}