algorithms-for-computing-line-estimators/src/main/java/Presenter/Evaluation/EvaluateAlgorithms.java

package Presenter.Evaluation;

import Model.Interval;
import Model.Line;
import Model.LineModel;
import Presenter.Algorithms.*;
import Presenter.Generator.DatasetGenerator;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Observable;

/**
 * Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
 *
 * @Author: Armin Wolf
 * @Email: a_wolf28@uni-muenster.de
 * @Date: 01.08.2017.
 */
public class EvaluateAlgorithms extends Observable {

    private LineModel arrangement;

    private Thread lmsThread;
    private Thread rmThread;
    private Thread tsThread;

    private Double[] tsRes = new Double[2];
    private Double[] rmRes = new Double[2];
    private Double[] lmsRes = new Double[2];

    private DatasetGenerator generator;

    private String[][] names = {{"MSE", "RMSE", "MAE", "MDAE"}, {"MAPE", "MDAPE", "RMSPE", "RMDSPE"}};

    //übergebene Parameter
    private int type;
    private int iterations;
    private int alg;


    public EvaluateAlgorithms(int type, int iterations, int  alg){
        this.arrangement = new LineModel();
        generator = new DatasetGenerator();
        arrangement.setLines(generator.generateDataCloud());
        this.type = type;
        this.iterations = iterations;
        this.alg = alg;

        setChanged();
        String[] msg = {"eval-dataset-generated"};
        notifyObservers(msg);

        IntersectionCounter counter = new IntersectionCounter();
        counter.run(arrangement.getLines(), new Interval(-99999, 99999));
        counter.calculateIntersectionAbscissas(arrangement);
    }

    public void run() throws InterruptedException {

        ArrayList<String> result = new ArrayList<>();

        switch (type){
            case 0:
                for (int i=0;i<iterations;i++) {

                    //der alg der gewählt wurde
                    if (alg == 0) {
                        startLMS();
                        result = getScaleDependentMeasure(arrangement.getLines(), lmsRes[0], lmsRes[1]);
                    } else if (alg == 1) {
                        startRM();
                        result = getScaleDependentMeasure(arrangement.getLines(), rmRes[0], rmRes[1]);
                    } else {
                        startTS();
                        result = getScaleDependentMeasure(arrangement.getLines(), tsRes[0], tsRes[1]);
                    }
                }
                break;
            case 1:
                break;
        }

        //createGlobalResult(result);
    }

    public void  createGlobalResult(ArrayList<String> result){
        ArrayList<String> tableInput = new ArrayList<>();

        for (int i=0;i<names[type].length;i++) {
            tableInput.add("eval");
            tableInput.add(names[type][i]);
            tableInput.add(result.get(i));
            setChanged();
            notifyObservers(result.stream().toArray(String[]::new));
            tableInput.clear();
        }

        String[] separator = {"eval", "", "", "", ""};
        setChanged();
        notifyObservers(separator);

        //visualisiere m,b

        ArrayList<String> lines = new ArrayList<>();
        lines.add("lines-res");
        //lms res
        lines.add(lmsRes[0]+"");
        lines.add(lmsRes[1]+"");
//
//        //rm res
//        lines.add(rmRes[0]+"");
//        lines.add(rmRes[1]+"");
//
//        //ts res
//        lines.add(tsRes[0]+"");
//        lines.add(tsRes[1]+"");

        setChanged();
        notifyObservers(lines.stream().toArray(String[]::new));
    }

    public void startLMS() throws InterruptedException {
        lmsThread = new Thread(() -> {
            LeastMedianOfSquaresEstimator lmsAlg = new LeastMedianOfSquaresEstimator(arrangement.getLines(), arrangement.getNodes());
            lmsAlg.run();
            lmsAlg.getResult();
            lmsRes[0] = lmsAlg.getSlope();
            lmsRes[1] = lmsAlg.getyInterception();
        });
        lmsThread.start();
        lmsThread.join();
    }

    public void startRM() throws InterruptedException {
        rmThread = new Thread(() -> {
            RepeatedMedianEstimator rmAlg = new RepeatedMedianEstimator(arrangement.getLines());
            rmAlg.run();
            rmAlg.getResult();
            rmRes[0] = rmAlg.getSlope();
            rmRes[1] = rmAlg.getyInterception();
        });
        rmThread.start();
        rmThread.join();
    }

    public void startTS() throws InterruptedException {
        tsThread = new Thread(() -> {
            TheilSenEstimator tsAlg = new TheilSenEstimator(arrangement.getLines(), arrangement.getNodes());
            tsAlg.run();
            tsAlg.getResult();
            tsRes[0] = tsAlg.getSlope();
            tsRes[1] = tsAlg.getyInterception();
        });
        tsThread.start();
        tsThread.join();
    }


    public ArrayList<String> getScaleDependentMeasure(LinkedList<Line> lines, Double m, Double b) {
        ScaleDependentMeasure scaleDependentMeasure = new ScaleDependentMeasure(lines, m, b);
        ArrayList<String> ret = new ArrayList<>();
        ret.add(scaleDependentMeasure.mse().toString());
        ret.add(scaleDependentMeasure.rmse().toString());
        ret.add(scaleDependentMeasure.mae().toString());
        ret.add(scaleDependentMeasure.mdae().toString());

        return ret;
    }

    public ArrayList<String> getPercentigeErrorBasedMeasure(LinkedList<Line> lines, Double m, Double b) {
        PercentageErrorBasedMeasure percentageErrorBasedMeasure = new PercentageErrorBasedMeasure(lines, m, b);
        ArrayList<String> ret = new ArrayList<>();
        ret.add(percentageErrorBasedMeasure.mape().toString());
        ret.add(percentageErrorBasedMeasure.mdape().toString());
        ret.add(percentageErrorBasedMeasure.rmspe().toString());
        ret.add(percentageErrorBasedMeasure.rmdspe().toString());
        return ret;
    }

    public ArrayList<String> getScaledErrorBasedMeasure(LinkedList<Line> lines, Double m, Double b){
        ScaledErrorBasedMeasure scaledErrorBasedMeasure = new ScaledErrorBasedMeasure(lines, m, b);
        ArrayList<String> ret = new ArrayList<>();
        ret.add(scaledErrorBasedMeasure.mse().toString());
        ret.add(scaledErrorBasedMeasure.rmse().toString());
        ret.add(scaledErrorBasedMeasure.mae().toString());
        ret.add(scaledErrorBasedMeasure.mdae().toString());
        return ret;
    }


    public LinkedList<Line> getData(){
        return arrangement.getLines();
    }
}