generalbgh/algorithms-for-computing-line-estimators
generalbgh
/
algorithms-for-computing-line-estimators
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

some improvements: usage of executor instead of threads and primitve data types

This commit is contained in:
Armin Wolf 2019-08-01 07:19:04 +02:00
parent 51ada744da
commit 0171629a9a
10 changed files with 230 additions and 255 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
LinearRegressionTool/src/main/java/presenter/AbstractPresenter.java
View File

@ -8,6 +8,8 @@ import view.MainFrame;
import javax.swing.*; import javax.swing.*;
import java.util.Observable; import java.util.Observable;
import java.util.Observer; import java.util.Observer;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/** /**
* Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden. * Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
@ -21,6 +23,7 @@ public abstract class AbstractPresenter implements Observer {
private LineModel model; private LineModel model;
private MainFrame view; private MainFrame view;
private EvaluateAlgorithms eval; private EvaluateAlgorithms eval;
private final ExecutorService executor;
/** /**
@ -31,6 +34,7 @@ public abstract class AbstractPresenter implements Observer {
public AbstractPresenter(LineModel model, MainFrame view) { public AbstractPresenter(LineModel model, MainFrame view) {
this.model = model; this.model = model;
this.view = view; this.view = view;
executor = Executors.newCachedThreadPool();
} }
@Override @Override
@ -204,4 +208,8 @@ public abstract class AbstractPresenter implements Observer {
public void setEval(EvaluateAlgorithms eval) { public void setEval(EvaluateAlgorithms eval) {
this.eval = eval; this.eval = eval;
} }
public ExecutorService getExecutor() {
return executor;
}
} }

302
LinearRegressionTool/src/main/java/presenter/Presenter.java
View File

@ -16,6 +16,8 @@ import view.MainFrame;
import javax.swing.table.DefaultTableModel; import javax.swing.table.DefaultTableModel;
import java.io.File; import java.io.File;
import java.util.LinkedList; import java.util.LinkedList;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/** /**
@ -27,17 +29,6 @@ import java.util.LinkedList;
*/ */
public class Presenter extends AbstractPresenter { public class Presenter extends AbstractPresenter {
/* Threads */
private Thread tsThread;
private Thread rmThread;
private Thread lmsThread;
private Thread importThread;
private Thread importPictureThread;
private Thread exportThread;
private Thread exportResultThread;
private Thread generatorThread;
private Thread evalThread;
public Presenter(LineModel model, MainFrame view) { public Presenter(LineModel model, MainFrame view) {
super(model, view); super(model, view);
@ -54,81 +45,56 @@ public class Presenter extends AbstractPresenter {
/** /**
* Die Berechnung durch des Algorithmus zum LMS-Schätzer wird gestartet. * Die Berechnung durch des Algorithmus zum LMS-Schätzer wird gestartet.
*
* @param input Parameter für den Algorithmus * @param input Parameter für den Algorithmus
*/ */
public void calculateLMS(String[] input) { public void calculateLMS(String[] input) {
if (input[0] != null && input[1] != null) { if (input[0] != null && input[1] != null) {
if (lmsThread == null || !lmsThread.isAlive()) { //Parameter für den Algortihmus
lmsThread = new Thread(() -> { Double constant = Double.parseDouble(input[0]);
//Parameter für den Algortihmus Double error = Double.parseDouble(input[1]);
Double constant = Double.parseDouble(input[0]); LeastMedianOfSquaresEstimator lms = new LeastMedianOfSquaresEstimator(getModel().getLines(), getModel().getNodes(), this);
Double error = Double.parseDouble(input[1]); //setzen der Parameter
LeastMedianOfSquaresEstimator lms = new LeastMedianOfSquaresEstimator(getModel().getLines(), getModel().getNodes(), this); lms.setConstant(constant);
//setzen der Parameter lms.setQuantileError(error);
lms.setConstant(constant); //Presenter soll die Klasse überwachen
lms.setQuantileError(error); lms.addObserver(this);
//Presenter soll die Klasse überwachen getExecutor().execute(lms);
lms.addObserver(this);
lms.run();
lms.pepareResult();
});
lmsThread.start();
try {
lmsThread.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
} }
} }
/** /**
* Die Berechnung durch des Algorithmus zum RM-Schätzer wird gestartet. * Die Berechnung durch des Algorithmus zum RM-Schätzer wird gestartet.
*
* @param input Parameter für den Algorithmus * @param input Parameter für den Algorithmus
*/ */
public void calculateRM(String input) { public void calculateRM(String input) {
if (input != null) { if (input != null) {
if (rmThread == null || !rmThread.isAlive()) { RepeatedMedianEstimator rm = new RepeatedMedianEstimator(getModel().getLines(), this);
rmThread = new Thread(() -> { Double parameter = Double.parseDouble(input);
RepeatedMedianEstimator rm = new RepeatedMedianEstimator(getModel().getLines(), this); rm.setBeta(parameter);
Double parameter = Double.parseDouble(input); //Presenter soll die Klasse überwachen
rm.setBeta(parameter); rm.addObserver(this);
//Presenter soll die Klasse überwachen
rm.addObserver(this); getExecutor().execute(rm);
rm.run();
rm.pepareResult();
});
rmThread.start();
try {
rmThread.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
} }
} }
/** /**
* Die Berechnung durch des Algorithmus zum TS-Schätzer wird gestartet. * Die Berechnung durch des Algorithmus zum TS-Schätzer wird gestartet.
*
* @param input Parameter für den Algorithmus * @param input Parameter für den Algorithmus
*/ */
public void calculateTS(String input) { public void calculateTS(String input) {
if (input != null) { if (input != null) {
if (tsThread == null || !tsThread.isAlive()) { TheilSenEstimator ts = new TheilSenEstimator(getModel().getLines(), getModel().getNodes(), this);
tsThread = new Thread(() -> { //Presenter soll die Klasse überwachen
TheilSenEstimator ts = new TheilSenEstimator(getModel().getLines(), getModel().getNodes(), this); ts.addObserver(this);
//Presenter soll die Klasse überwachen
ts.addObserver(this); getExecutor().execute(ts);
ts.run();
ts.pepareResult();
});
tsThread.start();
try {
tsThread.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
} }
} }
@ -138,201 +104,167 @@ public class Presenter extends AbstractPresenter {
/** /**
* Startet den Import des Datensatzes. * Startet den Import des Datensatzes.
*
* @param file importierender Datensatz * @param file importierender Datensatz
*/ */
public void startImport(File file) { public void startImport(File file) {
if (importThread == null || !importThread.isAlive()) {
importThread = new Thread(() -> { DataImporter importer = new DataImporter(file);
DataImporter importer = new DataImporter(file); //Presenter soll die Klasse überwachen
//Presenter soll die Klasse überwachen importer.addObserver(this);
importer.addObserver(this);
getExecutor().execute(new Runnable() {
@Override
public void run() {
LinkedList<Line> importedLines = importer.run(); LinkedList<Line> importedLines = importer.run();
if (importedLines != null) { if (importedLines != null) {
//Berechnung der Schnittpunkte und vis. der Ergebnisse (anz. Geraden, anz. Schnittpunkte) //Berechnung der Schnittpunkte und vis. der Ergebnisse (anz. Geraden, anz. Schnittpunkte)
getModel().setLines(importedLines); getModel().setLines(importedLines);
computeIntersections(); computeIntersections();
} }
});
importThread.start();
try {
importThread.join();
} catch (InterruptedException e) {
e.printStackTrace();
} }
} });
} }
/** /**
* Startet den Import eines Bildes. * Startet den Import eines Bildes.
*
* @param file importierendes Bild * @param file importierendes Bild
*/ */
public void startPictureDataImport(File file) { public void startPictureDataImport(File file) {
if (importPictureThread == null || !importPictureThread.isAlive()) { PictureProcessor pictureProcessor = new PictureProcessor(this, file);
importPictureThread = new Thread(() -> { //Presenter soll die Klasse überwachen
PictureProcessor pictureProcessor = new PictureProcessor(this, file); pictureProcessor.addObserver(this);
//Presenter soll die Klasse überwachen
pictureProcessor.addObserver(this); getExecutor().execute(new Runnable() {
@Override
public void run() {
pictureProcessor.run(); pictureProcessor.run();
//Berechnung der Schnittpunkte und vis. der Ergebnisse (anz. Geraden, anz. Schnittpunkte) //Berechnung der Schnittpunkte und vis. der Ergebnisse (anz. Geraden, anz. Schnittpunkte)
computeIntersections(); computeIntersections();
});
importPictureThread.start();
try {
importPictureThread.join();
} catch (InterruptedException e) {
e.printStackTrace();
} }
} });
} }
/** /**
* Startet den Export des akteullen Datensatzes (nur der Geraden) * Startet den Export des akteullen Datensatzes (nur der Geraden)
*
* @param file Datei in der die Informationen gespeichert werden sollen * @param file Datei in der die Informationen gespeichert werden sollen
*/ */
public void startExport(File file) { public void startExport(File file) {
if (exportThread == null || !exportThread.isAlive()) { DataExporter exporter = new DataExporter(getModel().getLines(), file);
exportThread = new Thread(() -> { //Presenter soll die Klasse überwachen
DataExporter exporter = new DataExporter(getModel().getLines(), file); exporter.addObserver(this);
//Presenter soll die Klasse überwachen
exporter.addObserver(this); getExecutor().execute(new Runnable() {
@Override
public void run() {
exporter.export(); exporter.export();
});
exportThread.start();
try {
exportThread.join();
} catch (InterruptedException e) {
e.printStackTrace();
} }
} });
} }
/** /**
* Startet den Export des akteullen Datensatzes im Rahmen der Evaluation (nur der Geraden) * Startet den Export des akteullen Datensatzes im Rahmen der Evaluation (nur der Geraden)
*
* @param file Datei in der die Informationen gespeichert werden sollen * @param file Datei in der die Informationen gespeichert werden sollen
*/ */
public void startDatasetExportEvaluation(File file) { public void startDatasetExportEvaluation(File file) {
if (exportThread == null || !exportThread.isAlive()) { DataExporter exporter = new DataExporter(getEval().getData(), file);
exportThread = new Thread(() -> { //Presenter soll die Klasse überwachen
DataExporter exporter = new DataExporter(getEval().getData(), file); exporter.addObserver(this);
//Presenter soll die Klasse überwachen
exporter.addObserver(this); getExecutor().execute(new Runnable() {
@Override
public void run() {
exporter.export(); exporter.export();
});
exportThread.start();
try {
exportThread.join();
} catch (InterruptedException e) {
e.printStackTrace();
} }
} });
} }
/** /**
* Startet den Export der Ergebnisse der Evaluation in Form einer LaTeX Datei * Startet den Export der Ergebnisse der Evaluation in Form einer LaTeX Datei
*
* @param model TableModel das die Berechnenten Ergebnisse enthält * @param model TableModel das die Berechnenten Ergebnisse enthält
* @param file Datei in die exportiert werden soll * @param file Datei in die exportiert werden soll
*/ */
public void startResultExport(DefaultTableModel model, File file) { public void startResultExport(DefaultTableModel model, File file) {
if (exportResultThread == null || !exportResultThread.isAlive()) { getExecutor().execute(() -> {
exportResultThread = new Thread(() -> { EvalResultLatexExport exporter = new EvalResultLatexExport(model, file);
EvalResultLatexExport exporter = new EvalResultLatexExport(model, file); exporter.writeFile();
exporter.writeFile(); });
});
exportResultThread.start();
try {
exportResultThread.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
} }
/** /**
* Startet das generieren der Datensätze der Größe <code>n</code> * Startet das generieren der Datensätze der Größe <code>n</code>
* @param n Größe des Datensatzes *
* @param n Größe des Datensatzes
* @param type Art der Datensatzes * @param type Art der Datensatzes
*/ */
public void generateDataset(int n, int type) { public void generateDataset(int n, int type) {
if (generatorThread == null || !generatorThread.isAlive()) { DatasetGenerator generator = new DatasetGenerator();
generatorThread = new Thread(() -> { generator.addObserver(this);
DatasetGenerator generator = new DatasetGenerator(); getExecutor().execute(() -> {
generator.addObserver(this); switch (type) {
switch (type){ case 0:
case 0: getModel().setLines(generator.generateDataCloud(n));
getModel().setLines(generator.generateDataCloud(n)); break;
break; case 1:
case 1: getModel().setLines(generator.generateDataLines(n));
getModel().setLines(generator.generateDataLines(n)); break;
break; case 2:
case 2: getModel().setLines(generator.generateCircle(n));
getModel().setLines(generator.generateCircle(n)); break;
break; default:
default: getModel().setLines(generator.generateDataCloud(n));
getModel().setLines(generator.generateDataCloud(n)); break;
break;
}
computeIntersections();
getView().enableFunctionality();
});
generatorThread.start();
try {
generatorThread.join();
} catch (InterruptedException e) {
e.printStackTrace();
} }
}
computeIntersections();
getView().enableFunctionality();
});
} }
/** /**
* Startet die Evaluation zu einen gegegbenen Typ mit den Informationen zu den Datensatz. * Startet die Evaluation zu einen gegegbenen Typ mit den Informationen zu den Datensatz.
* Beispielsweise kann ein Alg. auf mit verschiedenen Datensätzen untersucht werden, oder mehrere Algorithmen * Beispielsweise kann ein Alg. auf mit verschiedenen Datensätzen untersucht werden, oder mehrere Algorithmen
* auf einem gegebenen Datensatz. * auf einem gegebenen Datensatz.
* @param typ Typ der Evaluation *
* @param n Größe des Datensatzes * @param typ Typ der Evaluation
* @param alg code für die auszuführenden Algorithmen (siehe <code>EvaluationPanel.checkSelection()</code> Method) * @param n Größe des Datensatzes
* @param alg code für die auszuführenden Algorithmen (siehe <code>EvaluationPanel.checkSelection()</code> Method)
* @param datasettyp Typ des Datensatzes (Geradem Punktwolke, Kreis und Gerade) * @param datasettyp Typ des Datensatzes (Geradem Punktwolke, Kreis und Gerade)
*/ */
public void startEvaluation(int typ, int n, int alg, String datasettyp) { public void startEvaluation(int typ, int n, int alg, String datasettyp) {
if (evalThread == null || !evalThread.isAlive()) { setEval(new EvaluateAlgorithms(typ, n, alg, datasettyp));
evalThread = new Thread(() -> { getEval().addObserver(this);
try {
setEval(new EvaluateAlgorithms(typ, n, alg, datasettyp)); getExecutor().submit(() -> {
getEval().addObserver(this); getEval().run();
getEval().run(); });
} catch (InterruptedException e) {
e.printStackTrace();
}
});
evalThread.start();
}
} }
/** /**
* Startet die Evaluation zu einen gegegbenen Datensatz, der importiert wird. * Startet die Evaluation zu einen gegegbenen Datensatz, der importiert wird.
* Beispielsweise kann ein Alg. auf mit verschiedenen Datensätzen untersucht werden, oder mehrere Algorithmen * Beispielsweise kann ein Alg. auf mit verschiedenen Datensätzen untersucht werden, oder mehrere Algorithmen
* auf einem gegebenen Datensatz. * auf einem gegebenen Datensatz.
* @param typ Typ der Evaluation *
* @param alg code für die auszuführenden Algorithmen (siehe <code>EvaluationPanel.checkSelection()</code> Method) * @param typ Typ der Evaluation
* @param alg code für die auszuführenden Algorithmen (siehe <code>EvaluationPanel.checkSelection()</code> Method)
* @param file Typ des Datensatzes (Geradem Punktwolke, Kreis und Gerade) * @param file Typ des Datensatzes (Geradem Punktwolke, Kreis und Gerade)
*/ */
public void startEvaluation(int typ, int alg, File file) { public void startEvaluation(int typ, int alg, File file) {
if (evalThread == null || !evalThread.isAlive()) {
evalThread = new Thread(() -> { EvaluateAlgorithms evaluateAlgorithms = new EvaluateAlgorithms(typ, alg, file);
try { if (evaluateAlgorithms.getData().size() > 0) {
EvaluateAlgorithms evaluateAlgorithms = new EvaluateAlgorithms(typ, alg, file); setEval(evaluateAlgorithms);
if (evaluateAlgorithms.getData().size() > 0) { getEval().addObserver(this);
setEval(evaluateAlgorithms);
getEval().addObserver(this);
getEval().run();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
});
evalThread.start();
} }
getExecutor().submit(() -> {
getEval().run();
}).isDone();
} }
} }

3
LinearRegressionTool/src/main/java/presenter/algorithms/Algorithm.java
View File

@ -7,10 +7,11 @@ package presenter.algorithms;
* @Email: a_wolf28@uni-muenster.de * @Email: a_wolf28@uni-muenster.de
* @Date: 28.05.2017. * @Date: 28.05.2017.
*/ */
public interface Algorithm { public interface Algorithm extends Runnable{
/** /**
* Startet die Berechnung des jeweiligen Algorithmus. * Startet die Berechnung des jeweiligen Algorithmus.
*/ */
@Override
void run(); void run();
/** /**

16
LinearRegressionTool/src/main/java/presenter/algorithms/advanced/LeastMedianOfSquaresEstimator.java
View File

@ -33,11 +33,11 @@ public class LeastMedianOfSquaresEstimator extends Observable implements Algorit
private Interval subSlabU2; private Interval subSlabU2;
private Line sigmaMin; private Line sigmaMin;
private double heightsigmaMin; private double heightsigmaMin;
private Double intersectionsPoint; private double intersectionsPoint;
private Double constant = 0.5; private double constant = 0.5;
private Double slope; private double slope;
private Double yInterception; private double yInterception;
/** /**
* Konstruktor * Konstruktor
@ -115,16 +115,16 @@ public class LeastMedianOfSquaresEstimator extends Observable implements Algorit
//(c.) otherwise.... //(c.) otherwise....
// get random intersections point... // get random intersections point...
Collections.shuffle(tmpIntersections, new Random()); Collections.shuffle(tmpIntersections, new Random());
boolean found = false;
for (int i = 0; i < tmpIntersections.size(); i++) { for (int i = 0; i < tmpIntersections.size(); i++) {
if (tmpIntersections.get(i).getX() > interval.getLower() if (tmpIntersections.get(i).getX() > interval.getLower()
&& tmpIntersections.get(i).getX() < interval.getUpper()) { && tmpIntersections.get(i).getX() < interval.getUpper()) {
intersectionsPoint = tmpIntersections.get(i).getX(); intersectionsPoint = tmpIntersections.get(i).getX();
found = true;
break; break;
} else {
intersectionsPoint = null;
} }
} }
if (intersectionsPoint != null) { if (found) {
splitActiveSlab(intersectionsPoint, interval); splitActiveSlab(intersectionsPoint, interval);
//(d.) this may update sigma min //(d.) this may update sigma min
upperBound(intersectionsPoint); upperBound(intersectionsPoint);
@ -149,6 +149,8 @@ public class LeastMedianOfSquaresEstimator extends Observable implements Algorit
} }
end = System.currentTimeMillis(); end = System.currentTimeMillis();
System.out.println("Zeit: "+ ((end-start)/1000)); System.out.println("Zeit: "+ ((end-start)/1000));
pepareResult();
} }
/** /**

22
LinearRegressionTool/src/main/java/presenter/algorithms/advanced/RepeatedMedianEstimator.java
View File

@ -40,18 +40,18 @@ public class RepeatedMedianEstimator extends Observable implements Algorithm {
private ArrayList<Line> linesInCenterSlab; private ArrayList<Line> linesInCenterSlab;
private ArrayList<Line> linesInRightSlab; private ArrayList<Line> linesInRightSlab;
private Double r; private double r;
private Integer n; private int n;
private Double k; private double k;
private Double kLow; private double kLow;
private Double kHigh; private double kHigh;
private Double beta; private double beta;
private Double thetaLow; private double thetaLow;
private Double thetaHigh; private double thetaHigh;
private Double slope; private double slope;
private Double yInterception; private double yInterception;
/** /**
* Konstruktor * Konstruktor
@ -137,6 +137,8 @@ public class RepeatedMedianEstimator extends Observable implements Algorithm {
} }
end = System.currentTimeMillis(); end = System.currentTimeMillis();
System.out.println("Zeit: "+ ((end-start)/1000)); System.out.println("Zeit: "+ ((end-start)/1000));
pepareResult();
} }

30
LinearRegressionTool/src/main/java/presenter/algorithms/advanced/TheilSenEstimator.java
View File

@ -18,9 +18,9 @@ import java.util.*;
*/ */
public class TheilSenEstimator extends Observable implements Algorithm { public class TheilSenEstimator extends Observable implements Algorithm {
private final Double POSITIV_INF = 99999.0; private final double POSITIV_INF = 99999.0;
private final Double NEGATIV_INF = -99999.0; private final double NEGATIV_INF = -99999.0;
private final Double EPSILON = 0.00001; private final double EPSILON = 0.00001;
private Presenter presenter; private Presenter presenter;
private ArrayList<Line> setOfLines; private ArrayList<Line> setOfLines;
private ArrayList<Point> setOfIntersections; private ArrayList<Point> setOfIntersections;
@ -30,19 +30,19 @@ public class TheilSenEstimator extends Observable implements Algorithm {
private ArrayList<Double> yCoordinates; private ArrayList<Double> yCoordinates;
private ArrayList<Double> xCoordinates; private ArrayList<Double> xCoordinates;
//Hilfsvariablen (siehe original Paper) //Hilfsvariablen (siehe original Paper)
private Double j; private double j;
private Integer jA; private int jA;
private Integer jB; private int jB;
private Double r; private double r;
private Integer n; private int n;
private Double N; private double N;
private Integer k; private int k;
//Intervall und die temporaeren Grenzen //Intervall und die temporaeren Grenzen
private Interval interval; private Interval interval;
private Double aVariant; private double aVariant;
private Double bVariant; private double bVariant;
private Double slope; private double slope;
private Double yInterception; private double yInterception;
/** /**
* Konstruktor * Konstruktor
@ -116,6 +116,8 @@ public class TheilSenEstimator extends Observable implements Algorithm {
N = (double) getOpenIntervalSize(interval.getLower(), interval.getUpper(), intervalIntersections); N = (double) getOpenIntervalSize(interval.getLower(), interval.getUpper(), intervalIntersections);
} }
} }
pepareResult();
} }

12
LinearRegressionTool/src/main/java/presenter/algorithms/naiv/NaivLeastMedianOfSquaresEstimator.java
View File

@ -19,8 +19,8 @@ import java.util.LinkedList;
public class NaivLeastMedianOfSquaresEstimator implements Algorithm { public class NaivLeastMedianOfSquaresEstimator implements Algorithm {
private ArrayList<Point> set = new ArrayList<>(); private ArrayList<Point> set = new ArrayList<>();
private Integer n; private int n;
private Double ds, b, m; private double ds, b, m;
/** /**
* Konstruktor * Konstruktor
@ -40,9 +40,9 @@ public class NaivLeastMedianOfSquaresEstimator implements Algorithm {
b = 0d; b = 0d;
m = 0d; m = 0d;
ArrayList<Point> triple = new ArrayList<>(); ArrayList<Point> triple = new ArrayList<>();
Double beta; double beta;
Double alpha; double alpha;
Double dijk; double dijk;
System.out.println("=== S T A R T - naiv L M S ==="); System.out.println("=== S T A R T - naiv L M S ===");
long start; long start;
long end; long end;
@ -76,7 +76,7 @@ public class NaivLeastMedianOfSquaresEstimator implements Algorithm {
* @param b Steigung * @param b Steigung
* @return medianer Fehler * @return medianer Fehler
*/ */
private Double f(Double a, Double b) { private Double f(double a, double b) {
ArrayList<Double> res = new ArrayList<>(); ArrayList<Double> res = new ArrayList<>();
for (Point p : set) { for (Point p : set) {
res.add(Math.abs(p.getY() - (a + b * p.getX()))); res.add(Math.abs(p.getY() - (a + b * p.getX())));

24
LinearRegressionTool/src/main/java/presenter/algorithms/naiv/NaivRepeatedMedianEstimator.java
View File

@ -22,8 +22,8 @@ public class NaivRepeatedMedianEstimator implements Algorithm {
private HashMap<String, ArrayList<Double>> slopesPerLine; private HashMap<String, ArrayList<Double>> slopesPerLine;
private HashMap<String, ArrayList<Double>> interceptPerLine; private HashMap<String, ArrayList<Double>> interceptPerLine;
private ArrayList<Double> xMedians, yMedians; private ArrayList<Double> xMedians, yMedians;
private Double medianX; private double medianX;
private Double medianY; private double medianY;
/** /**
* Konstruktor * Konstruktor
@ -69,7 +69,7 @@ public class NaivRepeatedMedianEstimator implements Algorithm {
ArrayList<Double> list = slopesPerLine.get(l); ArrayList<Double> list = slopesPerLine.get(l);
int size = list.size() / 2; int size = list.size() / 2;
if (size > 0) { if (size > 0) {
Double medianX = FastElementSelector.randomizedSelect(list, size); double medianX = FastElementSelector.randomizedSelect(list, size);
xMedians.add(medianX); xMedians.add(medianX);
} }
} }
@ -79,7 +79,7 @@ public class NaivRepeatedMedianEstimator implements Algorithm {
ArrayList<Double> list = interceptPerLine.get(l); ArrayList<Double> list = interceptPerLine.get(l);
int size = list.size() / 2; int size = list.size() / 2;
if (size > 0) { if (size > 0) {
Double medianY = FastElementSelector.randomizedSelect(list, size); double medianY = FastElementSelector.randomizedSelect(list, size);
yMedians.add(medianY); yMedians.add(medianY);
} }
} }
@ -102,10 +102,10 @@ public class NaivRepeatedMedianEstimator implements Algorithm {
* @return * @return
*/ */
private Point calculateLine(Line startPoint, Line endPoint) { private Point calculateLine(Line startPoint, Line endPoint) {
Double xi; double xi;
Double xj; double xj;
Double yi; double yi;
Double yj; double yj;
if (endPoint.getM() > startPoint.getM()) { if (endPoint.getM() > startPoint.getM()) {
xi = startPoint.getM(); xi = startPoint.getM();
@ -120,22 +120,22 @@ public class NaivRepeatedMedianEstimator implements Algorithm {
} }
Double m = (yj - yi) / (xj - xi); double m = (yj - yi) / (xj - xi);
Double b = ((xj * yi) - (xi * yj)) / (xj - xi); double b = ((xj * yi) - (xi * yj)) / (xj - xi);
return new Point(m, b); return new Point(m, b);
} }
/** /**
* @return Steigung * @return Steigung
*/ */
public Double getM() { public double getM() {
return medianX * -1; return medianX * -1;
} }
/** /**
* @return y-Achsenabschnitt * @return y-Achsenabschnitt
*/ */
public Double getB() { public double getB() {
return medianY * -1; return medianY * -1;
} }
} }

12
LinearRegressionTool/src/main/java/presenter/algorithms/naiv/NaivTheilSenEstimator.java
View File

@ -18,8 +18,8 @@ public class NaivTheilSenEstimator implements Algorithm {
private LinkedList<Line> lines; private LinkedList<Line> lines;
private Double slope; private double slope;
private Double yInterception; private double yInterception;
/** /**
* Konstruktor * Konstruktor
@ -60,8 +60,8 @@ public class NaivTheilSenEstimator implements Algorithm {
list1.add(lines.get(i).getM()); list1.add(lines.get(i).getM());
list2.add(lines.get(i).getB()); list2.add(lines.get(i).getB());
} }
Double median1 = FastElementSelector.randomizedSelect(list1, list1.size() / 2); double median1 = FastElementSelector.randomizedSelect(list1, list1.size() / 2);
Double median2 = FastElementSelector.randomizedSelect(list2, list2.size() / 2); double median2 = FastElementSelector.randomizedSelect(list2, list2.size() / 2);
slope = FastElementSelector.randomizedSelect(slopesList, slopesList.size() / 2); slope = FastElementSelector.randomizedSelect(slopesList, slopesList.size() / 2);
yInterception = median2 - slope * median1; yInterception = median2 - slope * median1;
end = System.currentTimeMillis(); end = System.currentTimeMillis();
@ -76,14 +76,14 @@ public class NaivTheilSenEstimator implements Algorithm {
/** /**
* @return Steigung * @return Steigung
*/ */
public Double getM() { public double getM() {
return slope * -1; return slope * -1;
} }
/** /**
* @return y-Achsenabschnitt * @return y-Achsenabschnitt
*/ */
public Double getB() { public double getB() {
return yInterception * -1; return yInterception * -1;
} }
} }

56
LinearRegressionTool/src/main/java/presenter/evaluation/EvaluateAlgorithms.java
View File

@ -145,7 +145,7 @@ public class EvaluateAlgorithms extends Observable {
* Startet die Evaluation zu den passenden Typ. Bei beendigung wird der Beobachter informiert. * Startet die Evaluation zu den passenden Typ. Bei beendigung wird der Beobachter informiert.
* @throws InterruptedException * @throws InterruptedException
*/ */
public void run() throws InterruptedException { public void run() {
setChanged(); setChanged();
String[] msg = {"eval-dataset-generated"}; String[] msg = {"eval-dataset-generated"};
notifyObservers(msg); notifyObservers(msg);
@ -165,8 +165,12 @@ public class EvaluateAlgorithms extends Observable {
b[0] = l.getB(); b[0] = l.getB();
}); });
t.start(); t.start();
startLMS(); try {
t.join(); startLMS();
t.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
result = getScaleDependentMeasure(arrangement.getLines(), lmsRes[0], lmsRes[1]); result = getScaleDependentMeasure(arrangement.getLines(), lmsRes[0], lmsRes[1]);
result.addAll(getScaledErrorBasedMeasure(arrangement.getLines(), lmsRes[0], lmsRes[1], m[0], b[0])); result.addAll(getScaledErrorBasedMeasure(arrangement.getLines(), lmsRes[0], lmsRes[1], m[0], b[0]));
@ -182,7 +186,11 @@ public class EvaluateAlgorithms extends Observable {
b[0] = r.getB(); b[0] = r.getB();
}); });
t.start(); t.start();
startRM(); try {
startRM();
} catch (InterruptedException e) {
e.printStackTrace();
}
result = getScaleDependentMeasure(arrangement.getLines(), rmRes[0], rmRes[1]); result = getScaleDependentMeasure(arrangement.getLines(), rmRes[0], rmRes[1]);
result.addAll(getScaledErrorBasedMeasure(arrangement.getLines(), rmRes[0], rmRes[1], m[0], b[0])); result.addAll(getScaledErrorBasedMeasure(arrangement.getLines(), rmRes[0], rmRes[1], m[0], b[0]));
Double[] tmp = {rmRes[0], rmRes[1], m[0], b[0]}; Double[] tmp = {rmRes[0], rmRes[1], m[0], b[0]};
@ -197,7 +205,11 @@ public class EvaluateAlgorithms extends Observable {
b[0] = ts.getB(); b[0] = ts.getB();
}); });
t.start(); t.start();
startTS(); try {
startTS();
} catch (InterruptedException e) {
e.printStackTrace();
}
result = getScaleDependentMeasure(arrangement.getLines(), tsRes[0], tsRes[1]); result = getScaleDependentMeasure(arrangement.getLines(), tsRes[0], tsRes[1]);
result.addAll(getScaledErrorBasedMeasure(arrangement.getLines(), tsRes[0], tsRes[1], m[0], b[0])); result.addAll(getScaledErrorBasedMeasure(arrangement.getLines(), tsRes[0], tsRes[1], m[0], b[0]));
Double[] tmp = {tsRes[0], tsRes[1], m[0], b[0]}; Double[] tmp = {tsRes[0], tsRes[1], m[0], b[0]};
@ -210,8 +222,12 @@ public class EvaluateAlgorithms extends Observable {
ArrayList<Double[]> lineRes; ArrayList<Double[]> lineRes;
switch (alg) { switch (alg) {
case 3: case 3:
startLMS(); try {
startRM(); startLMS();
startRM();
} catch (InterruptedException e) {
e.printStackTrace();
}
result = getPercentigeErrorBasedMeasure(arrangement.getLines(), lmsRes[0], lmsRes[1]); result = getPercentigeErrorBasedMeasure(arrangement.getLines(), lmsRes[0], lmsRes[1]);
multipleResults.add(result); multipleResults.add(result);
@ -227,8 +243,12 @@ public class EvaluateAlgorithms extends Observable {
break; break;
case 4: case 4:
startLMS(); try {
startTS(); startLMS();
startTS();
} catch (InterruptedException e) {
e.printStackTrace();
}
result = getPercentigeErrorBasedMeasure(arrangement.getLines(), lmsRes[0], lmsRes[1]); result = getPercentigeErrorBasedMeasure(arrangement.getLines(), lmsRes[0], lmsRes[1]);
multipleResults.add(result); multipleResults.add(result);
@ -243,8 +263,12 @@ public class EvaluateAlgorithms extends Observable {
sendPloteLineResults(lineRes, new Integer[]{0, 2}); sendPloteLineResults(lineRes, new Integer[]{0, 2});
break; break;
case 5: case 5:
startRM(); try {
startTS(); startRM();
startTS();
} catch (InterruptedException e) {
e.printStackTrace();
}
result = fillPseudoResults(); result = fillPseudoResults();
multipleResults.add(result); multipleResults.add(result);
@ -259,9 +283,13 @@ public class EvaluateAlgorithms extends Observable {
sendPloteLineResults(lineRes, new Integer[]{1, 2}); sendPloteLineResults(lineRes, new Integer[]{1, 2});
break; break;
case 6: case 6:
startLMS(); try {
startRM(); startLMS();
startTS(); startRM();
startTS();
} catch (InterruptedException e) {
e.printStackTrace();
}
result = getPercentigeErrorBasedMeasure(arrangement.getLines(), lmsRes[0], lmsRes[1]); result = getPercentigeErrorBasedMeasure(arrangement.getLines(), lmsRes[0], lmsRes[1]);
multipleResults.add(result); multipleResults.add(result);