some improvements: usage of executor instead of threads and primitve data types
This commit is contained in:
parent
51ada744da
commit
0171629a9a
|
@ -8,6 +8,8 @@ import view.MainFrame;
|
|||
import javax.swing.*;
|
||||
import java.util.Observable;
|
||||
import java.util.Observer;
|
||||
import java.util.concurrent.ExecutorService;
|
||||
import java.util.concurrent.Executors;
|
||||
|
||||
/**
|
||||
* Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
|
||||
|
@ -21,6 +23,7 @@ public abstract class AbstractPresenter implements Observer {
|
|||
private LineModel model;
|
||||
private MainFrame view;
|
||||
private EvaluateAlgorithms eval;
|
||||
private final ExecutorService executor;
|
||||
|
||||
|
||||
/**
|
||||
|
@ -31,6 +34,7 @@ public abstract class AbstractPresenter implements Observer {
|
|||
public AbstractPresenter(LineModel model, MainFrame view) {
|
||||
this.model = model;
|
||||
this.view = view;
|
||||
executor = Executors.newCachedThreadPool();
|
||||
}
|
||||
|
||||
@Override
|
||||
|
@ -204,4 +208,8 @@ public abstract class AbstractPresenter implements Observer {
|
|||
public void setEval(EvaluateAlgorithms eval) {
|
||||
this.eval = eval;
|
||||
}
|
||||
|
||||
public ExecutorService getExecutor() {
|
||||
return executor;
|
||||
}
|
||||
}
|
||||
|
|
|
@ -16,6 +16,8 @@ import view.MainFrame;
|
|||
import javax.swing.table.DefaultTableModel;
|
||||
import java.io.File;
|
||||
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 {
|
||||
|
||||
/* 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) {
|
||||
super(model, view);
|
||||
|
@ -54,12 +45,11 @@ public class Presenter extends AbstractPresenter {
|
|||
|
||||
/**
|
||||
* Die Berechnung durch des Algorithmus zum LMS-Schätzer wird gestartet.
|
||||
*
|
||||
* @param input Parameter für den Algorithmus
|
||||
*/
|
||||
public void calculateLMS(String[] input) {
|
||||
if (input[0] != null && input[1] != null) {
|
||||
if (lmsThread == null || !lmsThread.isAlive()) {
|
||||
lmsThread = new Thread(() -> {
|
||||
//Parameter für den Algortihmus
|
||||
Double constant = Double.parseDouble(input[0]);
|
||||
Double error = Double.parseDouble(input[1]);
|
||||
|
@ -69,66 +59,42 @@ public class Presenter extends AbstractPresenter {
|
|||
lms.setQuantileError(error);
|
||||
//Presenter soll die Klasse überwachen
|
||||
lms.addObserver(this);
|
||||
lms.run();
|
||||
lms.pepareResult();
|
||||
});
|
||||
lmsThread.start();
|
||||
try {
|
||||
lmsThread.join();
|
||||
} catch (InterruptedException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
getExecutor().execute(lms);
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* Die Berechnung durch des Algorithmus zum RM-Schätzer wird gestartet.
|
||||
*
|
||||
* @param input Parameter für den Algorithmus
|
||||
*/
|
||||
public void calculateRM(String input) {
|
||||
if (input != null) {
|
||||
if (rmThread == null || !rmThread.isAlive()) {
|
||||
rmThread = new Thread(() -> {
|
||||
RepeatedMedianEstimator rm = new RepeatedMedianEstimator(getModel().getLines(), this);
|
||||
Double parameter = Double.parseDouble(input);
|
||||
rm.setBeta(parameter);
|
||||
//Presenter soll die Klasse überwachen
|
||||
rm.addObserver(this);
|
||||
rm.run();
|
||||
rm.pepareResult();
|
||||
});
|
||||
rmThread.start();
|
||||
try {
|
||||
rmThread.join();
|
||||
} catch (InterruptedException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
|
||||
getExecutor().execute(rm);
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Die Berechnung durch des Algorithmus zum TS-Schätzer wird gestartet.
|
||||
*
|
||||
* @param input Parameter für den Algorithmus
|
||||
*/
|
||||
public void calculateTS(String input) {
|
||||
if (input != null) {
|
||||
if (tsThread == null || !tsThread.isAlive()) {
|
||||
tsThread = new Thread(() -> {
|
||||
TheilSenEstimator ts = new TheilSenEstimator(getModel().getLines(), getModel().getNodes(), this);
|
||||
//Presenter soll die Klasse überwachen
|
||||
ts.addObserver(this);
|
||||
ts.run();
|
||||
ts.pepareResult();
|
||||
});
|
||||
tsThread.start();
|
||||
try {
|
||||
tsThread.join();
|
||||
} catch (InterruptedException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
|
||||
getExecutor().execute(ts);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -138,128 +104,110 @@ public class Presenter extends AbstractPresenter {
|
|||
|
||||
/**
|
||||
* Startet den Import des Datensatzes.
|
||||
*
|
||||
* @param file importierender Datensatz
|
||||
*/
|
||||
public void startImport(File file) {
|
||||
if (importThread == null || !importThread.isAlive()) {
|
||||
importThread = new Thread(() -> {
|
||||
|
||||
DataImporter importer = new DataImporter(file);
|
||||
//Presenter soll die Klasse überwachen
|
||||
importer.addObserver(this);
|
||||
|
||||
getExecutor().execute(new Runnable() {
|
||||
@Override
|
||||
public void run() {
|
||||
LinkedList<Line> importedLines = importer.run();
|
||||
if (importedLines != null) {
|
||||
//Berechnung der Schnittpunkte und vis. der Ergebnisse (anz. Geraden, anz. Schnittpunkte)
|
||||
getModel().setLines(importedLines);
|
||||
computeIntersections();
|
||||
}
|
||||
}
|
||||
});
|
||||
importThread.start();
|
||||
try {
|
||||
importThread.join();
|
||||
} catch (InterruptedException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Startet den Import eines Bildes.
|
||||
*
|
||||
* @param file importierendes Bild
|
||||
*/
|
||||
public void startPictureDataImport(File file) {
|
||||
if (importPictureThread == null || !importPictureThread.isAlive()) {
|
||||
importPictureThread = new Thread(() -> {
|
||||
PictureProcessor pictureProcessor = new PictureProcessor(this, file);
|
||||
//Presenter soll die Klasse überwachen
|
||||
pictureProcessor.addObserver(this);
|
||||
|
||||
getExecutor().execute(new Runnable() {
|
||||
@Override
|
||||
public void run() {
|
||||
pictureProcessor.run();
|
||||
//Berechnung der Schnittpunkte und vis. der Ergebnisse (anz. Geraden, anz. Schnittpunkte)
|
||||
computeIntersections();
|
||||
}
|
||||
});
|
||||
importPictureThread.start();
|
||||
try {
|
||||
importPictureThread.join();
|
||||
} catch (InterruptedException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* Startet den Export des akteullen Datensatzes (nur der Geraden)
|
||||
*
|
||||
* @param file Datei in der die Informationen gespeichert werden sollen
|
||||
*/
|
||||
public void startExport(File file) {
|
||||
if (exportThread == null || !exportThread.isAlive()) {
|
||||
exportThread = new Thread(() -> {
|
||||
DataExporter exporter = new DataExporter(getModel().getLines(), file);
|
||||
//Presenter soll die Klasse überwachen
|
||||
exporter.addObserver(this);
|
||||
|
||||
getExecutor().execute(new Runnable() {
|
||||
@Override
|
||||
public void run() {
|
||||
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)
|
||||
*
|
||||
* @param file Datei in der die Informationen gespeichert werden sollen
|
||||
*/
|
||||
public void startDatasetExportEvaluation(File file) {
|
||||
if (exportThread == null || !exportThread.isAlive()) {
|
||||
exportThread = new Thread(() -> {
|
||||
DataExporter exporter = new DataExporter(getEval().getData(), file);
|
||||
//Presenter soll die Klasse überwachen
|
||||
exporter.addObserver(this);
|
||||
|
||||
getExecutor().execute(new Runnable() {
|
||||
@Override
|
||||
public void run() {
|
||||
exporter.export();
|
||||
}
|
||||
});
|
||||
exportThread.start();
|
||||
try {
|
||||
exportThread.join();
|
||||
} catch (InterruptedException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Startet den Export der Ergebnisse der Evaluation in Form einer LaTeX Datei
|
||||
*
|
||||
* @param model TableModel das die Berechnenten Ergebnisse enthält
|
||||
* @param file Datei in die exportiert werden soll
|
||||
*/
|
||||
public void startResultExport(DefaultTableModel model, File file) {
|
||||
if (exportResultThread == null || !exportResultThread.isAlive()) {
|
||||
exportResultThread = new Thread(() -> {
|
||||
getExecutor().execute(() -> {
|
||||
EvalResultLatexExport exporter = new EvalResultLatexExport(model, file);
|
||||
exporter.writeFile();
|
||||
});
|
||||
exportResultThread.start();
|
||||
try {
|
||||
exportResultThread.join();
|
||||
} catch (InterruptedException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Startet das generieren der Datensätze der Größe <code>n</code>
|
||||
*
|
||||
* @param n Größe des Datensatzes
|
||||
* @param type Art der Datensatzes
|
||||
*/
|
||||
public void generateDataset(int n, int type) {
|
||||
if (generatorThread == null || !generatorThread.isAlive()) {
|
||||
generatorThread = new Thread(() -> {
|
||||
DatasetGenerator generator = new DatasetGenerator();
|
||||
generator.addObserver(this);
|
||||
switch (type){
|
||||
getExecutor().execute(() -> {
|
||||
switch (type) {
|
||||
case 0:
|
||||
getModel().setLines(generator.generateDataCloud(n));
|
||||
break;
|
||||
|
@ -277,62 +225,46 @@ public class Presenter extends AbstractPresenter {
|
|||
computeIntersections();
|
||||
getView().enableFunctionality();
|
||||
});
|
||||
generatorThread.start();
|
||||
try {
|
||||
generatorThread.join();
|
||||
} catch (InterruptedException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 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
|
||||
* auf einem gegebenen Datensatz.
|
||||
*
|
||||
* @param typ Typ der Evaluation
|
||||
* @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)
|
||||
*/
|
||||
public void startEvaluation(int typ, int n, int alg, String datasettyp) {
|
||||
if (evalThread == null || !evalThread.isAlive()) {
|
||||
evalThread = new Thread(() -> {
|
||||
try {
|
||||
setEval(new EvaluateAlgorithms(typ, n, alg, datasettyp));
|
||||
getEval().addObserver(this);
|
||||
|
||||
getExecutor().submit(() -> {
|
||||
getEval().run();
|
||||
} catch (InterruptedException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
});
|
||||
evalThread.start();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Startet die Evaluation zu einen gegegbenen Datensatz, der importiert wird.
|
||||
* Beispielsweise kann ein Alg. auf mit verschiedenen Datensätzen untersucht werden, oder mehrere Algorithmen
|
||||
* 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 file Typ des Datensatzes (Geradem Punktwolke, Kreis und Gerade)
|
||||
*/
|
||||
public void startEvaluation(int typ, int alg, File file) {
|
||||
if (evalThread == null || !evalThread.isAlive()) {
|
||||
evalThread = new Thread(() -> {
|
||||
try {
|
||||
|
||||
EvaluateAlgorithms evaluateAlgorithms = new EvaluateAlgorithms(typ, alg, file);
|
||||
if (evaluateAlgorithms.getData().size() > 0) {
|
||||
setEval(evaluateAlgorithms);
|
||||
getEval().addObserver(this);
|
||||
|
||||
}
|
||||
getExecutor().submit(() -> {
|
||||
getEval().run();
|
||||
}
|
||||
} catch (InterruptedException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
});
|
||||
evalThread.start();
|
||||
}
|
||||
}).isDone();
|
||||
}
|
||||
}
|
||||
|
|
|
@ -7,10 +7,11 @@ package presenter.algorithms;
|
|||
* @Email: a_wolf28@uni-muenster.de
|
||||
* @Date: 28.05.2017.
|
||||
*/
|
||||
public interface Algorithm {
|
||||
public interface Algorithm extends Runnable{
|
||||
/**
|
||||
* Startet die Berechnung des jeweiligen Algorithmus.
|
||||
*/
|
||||
@Override
|
||||
void run();
|
||||
|
||||
/**
|
||||
|
|
|
@ -33,11 +33,11 @@ public class LeastMedianOfSquaresEstimator extends Observable implements Algorit
|
|||
private Interval subSlabU2;
|
||||
private Line sigmaMin;
|
||||
private double heightsigmaMin;
|
||||
private Double intersectionsPoint;
|
||||
private Double constant = 0.5;
|
||||
private double intersectionsPoint;
|
||||
private double constant = 0.5;
|
||||
|
||||
private Double slope;
|
||||
private Double yInterception;
|
||||
private double slope;
|
||||
private double yInterception;
|
||||
|
||||
/**
|
||||
* Konstruktor
|
||||
|
@ -115,16 +115,16 @@ public class LeastMedianOfSquaresEstimator extends Observable implements Algorit
|
|||
//(c.) otherwise....
|
||||
// get random intersections point...
|
||||
Collections.shuffle(tmpIntersections, new Random());
|
||||
boolean found = false;
|
||||
for (int i = 0; i < tmpIntersections.size(); i++) {
|
||||
if (tmpIntersections.get(i).getX() > interval.getLower()
|
||||
&& tmpIntersections.get(i).getX() < interval.getUpper()) {
|
||||
intersectionsPoint = tmpIntersections.get(i).getX();
|
||||
found = true;
|
||||
break;
|
||||
} else {
|
||||
intersectionsPoint = null;
|
||||
}
|
||||
}
|
||||
if (intersectionsPoint != null) {
|
||||
if (found) {
|
||||
splitActiveSlab(intersectionsPoint, interval);
|
||||
//(d.) this may update sigma min
|
||||
upperBound(intersectionsPoint);
|
||||
|
@ -149,6 +149,8 @@ public class LeastMedianOfSquaresEstimator extends Observable implements Algorit
|
|||
}
|
||||
end = System.currentTimeMillis();
|
||||
System.out.println("Zeit: "+ ((end-start)/1000));
|
||||
|
||||
pepareResult();
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
|
@ -40,18 +40,18 @@ public class RepeatedMedianEstimator extends Observable implements Algorithm {
|
|||
private ArrayList<Line> linesInCenterSlab;
|
||||
private ArrayList<Line> linesInRightSlab;
|
||||
|
||||
private Double r;
|
||||
private Integer n;
|
||||
private Double k;
|
||||
private Double kLow;
|
||||
private Double kHigh;
|
||||
private Double beta;
|
||||
private double r;
|
||||
private int n;
|
||||
private double k;
|
||||
private double kLow;
|
||||
private double kHigh;
|
||||
private double beta;
|
||||
|
||||
private Double thetaLow;
|
||||
private Double thetaHigh;
|
||||
private double thetaLow;
|
||||
private double thetaHigh;
|
||||
|
||||
private Double slope;
|
||||
private Double yInterception;
|
||||
private double slope;
|
||||
private double yInterception;
|
||||
|
||||
/**
|
||||
* Konstruktor
|
||||
|
@ -137,6 +137,8 @@ public class RepeatedMedianEstimator extends Observable implements Algorithm {
|
|||
}
|
||||
end = System.currentTimeMillis();
|
||||
System.out.println("Zeit: "+ ((end-start)/1000));
|
||||
|
||||
pepareResult();
|
||||
}
|
||||
|
||||
|
||||
|
|
|
@ -18,9 +18,9 @@ import java.util.*;
|
|||
*/
|
||||
public class TheilSenEstimator extends Observable implements Algorithm {
|
||||
|
||||
private final Double POSITIV_INF = 99999.0;
|
||||
private final Double NEGATIV_INF = -99999.0;
|
||||
private final Double EPSILON = 0.00001;
|
||||
private final double POSITIV_INF = 99999.0;
|
||||
private final double NEGATIV_INF = -99999.0;
|
||||
private final double EPSILON = 0.00001;
|
||||
private Presenter presenter;
|
||||
private ArrayList<Line> setOfLines;
|
||||
private ArrayList<Point> setOfIntersections;
|
||||
|
@ -30,19 +30,19 @@ public class TheilSenEstimator extends Observable implements Algorithm {
|
|||
private ArrayList<Double> yCoordinates;
|
||||
private ArrayList<Double> xCoordinates;
|
||||
//Hilfsvariablen (siehe original Paper)
|
||||
private Double j;
|
||||
private Integer jA;
|
||||
private Integer jB;
|
||||
private Double r;
|
||||
private Integer n;
|
||||
private Double N;
|
||||
private Integer k;
|
||||
private double j;
|
||||
private int jA;
|
||||
private int jB;
|
||||
private double r;
|
||||
private int n;
|
||||
private double N;
|
||||
private int k;
|
||||
//Intervall und die temporaeren Grenzen
|
||||
private Interval interval;
|
||||
private Double aVariant;
|
||||
private Double bVariant;
|
||||
private Double slope;
|
||||
private Double yInterception;
|
||||
private double aVariant;
|
||||
private double bVariant;
|
||||
private double slope;
|
||||
private double yInterception;
|
||||
|
||||
/**
|
||||
* Konstruktor
|
||||
|
@ -116,6 +116,8 @@ public class TheilSenEstimator extends Observable implements Algorithm {
|
|||
N = (double) getOpenIntervalSize(interval.getLower(), interval.getUpper(), intervalIntersections);
|
||||
}
|
||||
}
|
||||
|
||||
pepareResult();
|
||||
}
|
||||
|
||||
|
||||
|
|
|
@ -19,8 +19,8 @@ import java.util.LinkedList;
|
|||
public class NaivLeastMedianOfSquaresEstimator implements Algorithm {
|
||||
private ArrayList<Point> set = new ArrayList<>();
|
||||
|
||||
private Integer n;
|
||||
private Double ds, b, m;
|
||||
private int n;
|
||||
private double ds, b, m;
|
||||
|
||||
/**
|
||||
* Konstruktor
|
||||
|
@ -40,9 +40,9 @@ public class NaivLeastMedianOfSquaresEstimator implements Algorithm {
|
|||
b = 0d;
|
||||
m = 0d;
|
||||
ArrayList<Point> triple = new ArrayList<>();
|
||||
Double beta;
|
||||
Double alpha;
|
||||
Double dijk;
|
||||
double beta;
|
||||
double alpha;
|
||||
double dijk;
|
||||
System.out.println("=== S T A R T - naiv L M S ===");
|
||||
long start;
|
||||
long end;
|
||||
|
@ -76,7 +76,7 @@ public class NaivLeastMedianOfSquaresEstimator implements Algorithm {
|
|||
* @param b Steigung
|
||||
* @return medianer Fehler
|
||||
*/
|
||||
private Double f(Double a, Double b) {
|
||||
private Double f(double a, double b) {
|
||||
ArrayList<Double> res = new ArrayList<>();
|
||||
for (Point p : set) {
|
||||
res.add(Math.abs(p.getY() - (a + b * p.getX())));
|
||||
|
|
|
@ -22,8 +22,8 @@ public class NaivRepeatedMedianEstimator implements Algorithm {
|
|||
private HashMap<String, ArrayList<Double>> slopesPerLine;
|
||||
private HashMap<String, ArrayList<Double>> interceptPerLine;
|
||||
private ArrayList<Double> xMedians, yMedians;
|
||||
private Double medianX;
|
||||
private Double medianY;
|
||||
private double medianX;
|
||||
private double medianY;
|
||||
|
||||
/**
|
||||
* Konstruktor
|
||||
|
@ -69,7 +69,7 @@ public class NaivRepeatedMedianEstimator implements Algorithm {
|
|||
ArrayList<Double> list = slopesPerLine.get(l);
|
||||
int size = list.size() / 2;
|
||||
if (size > 0) {
|
||||
Double medianX = FastElementSelector.randomizedSelect(list, size);
|
||||
double medianX = FastElementSelector.randomizedSelect(list, size);
|
||||
xMedians.add(medianX);
|
||||
}
|
||||
}
|
||||
|
@ -79,7 +79,7 @@ public class NaivRepeatedMedianEstimator implements Algorithm {
|
|||
ArrayList<Double> list = interceptPerLine.get(l);
|
||||
int size = list.size() / 2;
|
||||
if (size > 0) {
|
||||
Double medianY = FastElementSelector.randomizedSelect(list, size);
|
||||
double medianY = FastElementSelector.randomizedSelect(list, size);
|
||||
yMedians.add(medianY);
|
||||
}
|
||||
}
|
||||
|
@ -102,10 +102,10 @@ public class NaivRepeatedMedianEstimator implements Algorithm {
|
|||
* @return
|
||||
*/
|
||||
private Point calculateLine(Line startPoint, Line endPoint) {
|
||||
Double xi;
|
||||
Double xj;
|
||||
Double yi;
|
||||
Double yj;
|
||||
double xi;
|
||||
double xj;
|
||||
double yi;
|
||||
double yj;
|
||||
|
||||
if (endPoint.getM() > startPoint.getM()) {
|
||||
xi = startPoint.getM();
|
||||
|
@ -120,22 +120,22 @@ public class NaivRepeatedMedianEstimator implements Algorithm {
|
|||
}
|
||||
|
||||
|
||||
Double m = (yj - yi) / (xj - xi);
|
||||
Double b = ((xj * yi) - (xi * yj)) / (xj - xi);
|
||||
double m = (yj - yi) / (xj - xi);
|
||||
double b = ((xj * yi) - (xi * yj)) / (xj - xi);
|
||||
return new Point(m, b);
|
||||
}
|
||||
|
||||
/**
|
||||
* @return Steigung
|
||||
*/
|
||||
public Double getM() {
|
||||
public double getM() {
|
||||
return medianX * -1;
|
||||
}
|
||||
|
||||
/**
|
||||
* @return y-Achsenabschnitt
|
||||
*/
|
||||
public Double getB() {
|
||||
public double getB() {
|
||||
return medianY * -1;
|
||||
}
|
||||
}
|
||||
|
|
|
@ -18,8 +18,8 @@ public class NaivTheilSenEstimator implements Algorithm {
|
|||
|
||||
|
||||
private LinkedList<Line> lines;
|
||||
private Double slope;
|
||||
private Double yInterception;
|
||||
private double slope;
|
||||
private double yInterception;
|
||||
|
||||
/**
|
||||
* Konstruktor
|
||||
|
@ -60,8 +60,8 @@ public class NaivTheilSenEstimator implements Algorithm {
|
|||
list1.add(lines.get(i).getM());
|
||||
list2.add(lines.get(i).getB());
|
||||
}
|
||||
Double median1 = FastElementSelector.randomizedSelect(list1, list1.size() / 2);
|
||||
Double median2 = FastElementSelector.randomizedSelect(list2, list2.size() / 2);
|
||||
double median1 = FastElementSelector.randomizedSelect(list1, list1.size() / 2);
|
||||
double median2 = FastElementSelector.randomizedSelect(list2, list2.size() / 2);
|
||||
slope = FastElementSelector.randomizedSelect(slopesList, slopesList.size() / 2);
|
||||
yInterception = median2 - slope * median1;
|
||||
end = System.currentTimeMillis();
|
||||
|
@ -76,14 +76,14 @@ public class NaivTheilSenEstimator implements Algorithm {
|
|||
/**
|
||||
* @return Steigung
|
||||
*/
|
||||
public Double getM() {
|
||||
public double getM() {
|
||||
return slope * -1;
|
||||
}
|
||||
|
||||
/**
|
||||
* @return y-Achsenabschnitt
|
||||
*/
|
||||
public Double getB() {
|
||||
public double getB() {
|
||||
return yInterception * -1;
|
||||
}
|
||||
}
|
||||
|
|
|
@ -145,7 +145,7 @@ public class EvaluateAlgorithms extends Observable {
|
|||
* Startet die Evaluation zu den passenden Typ. Bei beendigung wird der Beobachter informiert.
|
||||
* @throws InterruptedException
|
||||
*/
|
||||
public void run() throws InterruptedException {
|
||||
public void run() {
|
||||
setChanged();
|
||||
String[] msg = {"eval-dataset-generated"};
|
||||
notifyObservers(msg);
|
||||
|
@ -165,8 +165,12 @@ public class EvaluateAlgorithms extends Observable {
|
|||
b[0] = l.getB();
|
||||
});
|
||||
t.start();
|
||||
try {
|
||||
startLMS();
|
||||
t.join();
|
||||
} catch (InterruptedException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
|
||||
result = getScaleDependentMeasure(arrangement.getLines(), lmsRes[0], lmsRes[1]);
|
||||
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();
|
||||
});
|
||||
t.start();
|
||||
try {
|
||||
startRM();
|
||||
} catch (InterruptedException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
result = getScaleDependentMeasure(arrangement.getLines(), rmRes[0], rmRes[1]);
|
||||
result.addAll(getScaledErrorBasedMeasure(arrangement.getLines(), 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();
|
||||
});
|
||||
t.start();
|
||||
try {
|
||||
startTS();
|
||||
} catch (InterruptedException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
result = getScaleDependentMeasure(arrangement.getLines(), tsRes[0], tsRes[1]);
|
||||
result.addAll(getScaledErrorBasedMeasure(arrangement.getLines(), 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;
|
||||
switch (alg) {
|
||||
case 3:
|
||||
try {
|
||||
startLMS();
|
||||
startRM();
|
||||
} catch (InterruptedException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
|
||||
result = getPercentigeErrorBasedMeasure(arrangement.getLines(), lmsRes[0], lmsRes[1]);
|
||||
multipleResults.add(result);
|
||||
|
@ -227,8 +243,12 @@ public class EvaluateAlgorithms extends Observable {
|
|||
|
||||
break;
|
||||
case 4:
|
||||
try {
|
||||
startLMS();
|
||||
startTS();
|
||||
} catch (InterruptedException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
|
||||
result = getPercentigeErrorBasedMeasure(arrangement.getLines(), lmsRes[0], lmsRes[1]);
|
||||
multipleResults.add(result);
|
||||
|
@ -243,8 +263,12 @@ public class EvaluateAlgorithms extends Observable {
|
|||
sendPloteLineResults(lineRes, new Integer[]{0, 2});
|
||||
break;
|
||||
case 5:
|
||||
try {
|
||||
startRM();
|
||||
startTS();
|
||||
} catch (InterruptedException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
|
||||
result = fillPseudoResults();
|
||||
multipleResults.add(result);
|
||||
|
@ -259,9 +283,13 @@ public class EvaluateAlgorithms extends Observable {
|
|||
sendPloteLineResults(lineRes, new Integer[]{1, 2});
|
||||
break;
|
||||
case 6:
|
||||
try {
|
||||
startLMS();
|
||||
startRM();
|
||||
startTS();
|
||||
} catch (InterruptedException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
|
||||
result = getPercentigeErrorBasedMeasure(arrangement.getLines(), lmsRes[0], lmsRes[1]);
|
||||
multipleResults.add(result);
|
||||
|
|
Loading…
Reference in New Issue