optimize imports

LinearRegressionTool/pom.xml

@@ -64,6 +64,11 @@
                 </executions>
             </plugin>
 
+            <plugin>
+                <groupId>org.sonarsource.scanner.maven</groupId>
+                <artifactId>sonar-maven-plugin</artifactId>
+                <version>3.4.0.905</version>
+            </plugin>
         </plugins>
     </build>
 

LinearRegressionTool/src/main/java/App.java

@@ -1,7 +1,6 @@
-
 import model.Line;
-import model.Point;
 import model.LineModel;
+import model.Point;
 import presenter.Presenter;
 import presenter.algorithms.advanced.LeastMedianOfSquaresEstimator;
 import presenter.algorithms.advanced.RepeatedMedianEstimator;
@@ -9,8 +8,8 @@ import presenter.algorithms.advanced.TheilSenEstimator;
 import presenter.algorithms.naiv.NaivLeastMedianOfSquaresEstimator;
 import presenter.algorithms.naiv.NaivRepeatedMedianEstimator;
 import presenter.algorithms.naiv.NaivTheilSenEstimator;
-import presenter.util.IntersectionComputer;
 import presenter.generator.DatasetGenerator;
+import presenter.util.IntersectionComputer;
 import view.MainFrame;
 
 import javax.swing.*;
@@ -27,8 +26,17 @@ import java.util.LinkedList;
  */
 public class App {
 
+    /**
+     * Laden der native Library für OpenCV
+     */
+    static {
+        nu.pattern.OpenCV.loadShared();
+        System.loadLibrary(org.opencv.core.Core.NATIVE_LIBRARY_NAME);
+    }
+
     /**
      * Schriftart wird neu gesetzt
+     *
      * @param f Schriftart
      */
     private static void setUIFont(javax.swing.plaf.FontUIResource f) {
@@ -44,7 +52,8 @@ public class App {
 
     /**
      * Das LookAndFeel wird neu gesetzt.
-     * @param view  View Klasse
+     *
+     * @param view View Klasse
      */
     private static void setLookAndFeel(JFrame view) {
         String[] laf = {"com.jtattoo.plaf.aluminium.AluminiumLookAndFeel",
@@ -90,31 +99,24 @@ public class App {
             NaivTheilSenEstimator naivTs = new NaivTheilSenEstimator(lines);
             naivTs.run();
 
-            LeastMedianOfSquaresEstimator lms = new LeastMedianOfSquaresEstimator(lines,points);
+            LeastMedianOfSquaresEstimator lms = new LeastMedianOfSquaresEstimator(lines, points);
             lms.run();
 
             RepeatedMedianEstimator rm = new RepeatedMedianEstimator(lines);
             rm.run();
 
-            TheilSenEstimator ts = new TheilSenEstimator(lines,points);
+            TheilSenEstimator ts = new TheilSenEstimator(lines, points);
             ts.run();
         }
     }
 
-    /**
-     * Laden der native Library für OpenCV
-     */
-    static {
-        nu.pattern.OpenCV.loadShared();
-        System.loadLibrary(org.opencv.core.Core.NATIVE_LIBRARY_NAME);
-    }
-
     /**
      * Maim Methode
+     *
      * @param args
      */
     public static void main(String[] args) {
-        if (args.length > 0 && args[0] == "--benchmark"){
+        if (args.length > 0 && args[0] == "--benchmark") {
             benchmark();
         } else {
             final Presenter presenter = new Presenter(new LineModel(), null);

LinearRegressionTool/src/main/java/model/Interval.java

@@ -15,6 +15,7 @@ public class Interval {
 
     /**
      * Konstruktor
+     *
      * @param lower untere Schranke
      * @param upper obere Schranke
      */
@@ -68,6 +69,7 @@ public class Interval {
 
     /**
      * Berechnet die Distanz zwischen der oberen und unteren Schranke
+     *
      * @return Distanz
      */
     public Double getDistance() {

LinearRegressionTool/src/main/java/model/Line.java

@@ -25,8 +25,9 @@ public class Line {
 
     /**
      * Konstruktor
-     * @param m Steigung
+     *
-     * @param b y-Achsenabschnitt
+     * @param m  Steigung
+     * @param b  y-Achsenabschnitt
      * @param id id
      */
     public Line(double m, double b, String id) {
@@ -42,6 +43,7 @@ public class Line {
 
     /**
      * Konstruktor
+     *
      * @param m Steigung
      * @param b y-Achsenabschnitt
      */
@@ -57,6 +59,7 @@ public class Line {
 
     /**
      * Konstruktor
+     *
      * @param x1 x-Koordiante des Startpunkts
      * @param x2 x-Koordinate des Endpunkts
      * @param y1 y-Koordinate des Startpunkts
@@ -145,6 +148,7 @@ public class Line {
 
     /**
      * Setzt die Koordianten des Segments. Aus dem Segment wird eine Gerade berechnet.
+     *
      * @param x1 x-Koordiante des Startpunkts
      * @param y1 y-Koordiante des Endpunkts
      * @param x2 x-Koordinate des Startpunkts
@@ -161,15 +165,12 @@ public class Line {
 
     /**
      * Vergleich einzelner Geradern
+     *
      * @param other zu vergleichende Gerade
      * @return <code>true</code> falls die Geraden Gleich sind
      */
     public boolean equals(Line other) {
-        if (other.getM() == this.getM() && other.getB() == this.getB()) {
+        return other.getM() == this.getM() && other.getB() == this.getB();
-            return true;
-        } else {
-            return false;
-        }
     }
 
 

LinearRegressionTool/src/main/java/model/LineModel.java

@@ -35,6 +35,7 @@ public class LineModel {
 
     /**
      * Fügt einen Schnittpunkt zum Modell hinzu
+     *
      * @param node Schnittpunkt
      */
     public void addNode(Point node) {
@@ -43,6 +44,7 @@ public class LineModel {
 
     /**
      * Fügt eine Gerade zu dem Modell hinzu
+     *
      * @param line Gerade
      */
     public void addLine(Line line) {

LinearRegressionTool/src/main/java/model/Pair.java

@@ -14,6 +14,7 @@ public class Pair {
 
     /**
      * Konstruktor
+     *
      * @param p1 erstes Element des Tupels
      * @param p2 zweites Element des Tupels
      */

LinearRegressionTool/src/main/java/model/Point.java

@@ -15,6 +15,7 @@ public class Point implements Comparable<Point> {
 
     /**
      * Konstruktor
+     *
      * @param x x-Koordiante
      * @param y y-Koordiante
      */
@@ -25,8 +26,9 @@ public class Point implements Comparable<Point> {
 
     /**
      * Konstruktor
-     * @param x x-Koordiante
+     *
-     * @param y y-Koordiante
+     * @param x  x-Koordiante
+     * @param y  y-Koordiante
      * @param id id des Punkts
      */
     public Point(Double x, Double y, String id) {
@@ -80,15 +82,12 @@ public class Point implements Comparable<Point> {
 
     /**
      * Vergleich zweier Punkte
+     *
      * @param other zu vergleichernder Punkt
      * @return <code>true</code> falls die Punkte gleich sind
      */
     public boolean equals(Point other) {
-        if (other.getX() == this.getX() && other.getY() == this.getY()) {
+        return other.getX() == this.getX() && other.getY() == this.getY();
-            return true;
-        } else {
-            return false;
-        }
     }
 
     /**

LinearRegressionTool/src/main/java/presenter/AbstractPresenter.java

@@ -1,8 +1,8 @@
 package presenter;
 
 import model.LineModel;
-import presenter.util.IntersectionComputer;
 import presenter.evaluation.EvaluateAlgorithms;
+import presenter.util.IntersectionComputer;
 import view.MainFrame;
 
 import javax.swing.*;
@@ -20,14 +20,15 @@ import java.util.concurrent.Executors;
  */
 public abstract class AbstractPresenter implements Observer {
 
+    private final ExecutorService executor;
     private LineModel model;
     private MainFrame view;
     private EvaluateAlgorithms eval;
-    private final ExecutorService executor;
 
 
     /**
      * Konstruktor
+     *
      * @param model Modell
      * @param view  View
      */
@@ -42,11 +43,11 @@ public abstract class AbstractPresenter implements Observer {
         String[] result = ((String[]) arg);
         String observable = result[0];
 
-        switch (observable){
+        switch (observable) {
             case "eval-dataset-generated":
                 SwingUtilities.invokeLater(() -> getView().addEvalDataset(getEval().getData()));
                 break;
-            case  "eval-d":
+            case "eval-d":
                 SwingUtilities.invokeLater(() -> getView().appendEvalResult(result, Integer.parseInt(result[1]), false));
                 break;
             case "eval-ds":
@@ -140,7 +141,7 @@ public abstract class AbstractPresenter implements Observer {
      * Wrapper Methode die das berechnen der Schnittpunkte anstößt und die Ergebnisse(Anzahl der Schnittpunkte)
      * visuell darstellt.
      */
-    protected void computeIntersections(){
+    protected void computeIntersections() {
         Thread t = new Thread(() -> {
             long start, end;
 
@@ -148,7 +149,7 @@ public abstract class AbstractPresenter implements Observer {
             startIntersectionCalculation();
             end = System.currentTimeMillis();
 
-            System.out.println("Zeit: "+(end-start)/1000);
+            System.out.println("Zeit: " + (end - start) / 1000);
         });
         t.start();
         try {

LinearRegressionTool/src/main/java/presenter/Presenter.java

@@ -16,8 +16,6 @@ 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;
 
 
 /**

LinearRegressionTool/src/main/java/presenter/algorithms/Algorithm.java

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

LinearRegressionTool/src/main/java/presenter/algorithms/advanced/LeastMedianOfSquaresEstimator.java

@@ -41,9 +41,10 @@ public class LeastMedianOfSquaresEstimator extends Observable implements Algorit
 
     /**
      * Konstruktor
-     * @param set               Liste der Geraden
+     *
-     * @param intersections     Liste der Schnittpunkte
+     * @param set           Liste der Geraden
-     * @param presenter         Presenter (Beobachter)
+     * @param intersections Liste der Schnittpunkte
+     * @param presenter     Presenter (Beobachter)
      */
     public LeastMedianOfSquaresEstimator(LinkedList<Line> set, ArrayList<Point> intersections,
                                          Presenter presenter) {
@@ -61,8 +62,9 @@ public class LeastMedianOfSquaresEstimator extends Observable implements Algorit
 
     /**
      * Konstruktor
-     * @param set               Liste der Geraden
+     *
-     * @param intersections     Liste der Schnittpunkte
+     * @param set           Liste der Geraden
+     * @param intersections Liste der Schnittpunkte
      */
     public LeastMedianOfSquaresEstimator(LinkedList<Line> set, ArrayList<Point> intersections) {
         this(set, intersections, null);
@@ -70,7 +72,7 @@ public class LeastMedianOfSquaresEstimator extends Observable implements Algorit
 
     /**
      * Algorithmus zum berechnen des LMS-Schätzers
-     *
+     * <p>
      * Paper:
      * Mount, David M, Nathan S Netanyahu, Kathleen Romanik, Ruth Silverman und Angela Y Wu
      * „A practical approximation algorithm for the LMS line estimator“. 2007
@@ -148,13 +150,14 @@ public class LeastMedianOfSquaresEstimator extends Observable implements Algorit
             }
         }
         end = System.currentTimeMillis();
-        System.out.println("Zeit: "+ ((end-start)/1000));
+        System.out.println("Zeit: " + ((end - start) / 1000));
 
         pepareResult();
     }
 
     /**
      * Liefert die Anzahl der Schnittpunkte in einem Intervall
+     *
      * @param interval Intervall
      * @return Anzahl der Schnittpunkte
      */
@@ -217,6 +220,7 @@ public class LeastMedianOfSquaresEstimator extends Observable implements Algorit
     /**
      * Zu einer vertikalen Gerade werden kMinus Segmente erzeugt und geprüft ob eine bessere Lösung
      * als SigmaMin vorliegt.
+     *
      * @param point x-Koordinate zur Konstruktion der vertikalen Gerade
      */
     public void upperBound(double point) {
@@ -248,6 +252,7 @@ public class LeastMedianOfSquaresEstimator extends Observable implements Algorit
 
     /**
      * Die Methode prüft ob das übergebene Intervall die untere Schranke einer potenziellen Lösung erfüllt.
+     *
      * @param pslab übergebene Intervall
      */
     public void lowerBound(Interval pslab) {

LinearRegressionTool/src/main/java/presenter/algorithms/advanced/RepeatedMedianEstimator.java

@@ -55,8 +55,9 @@ public class RepeatedMedianEstimator extends Observable implements Algorithm {
 
     /**
      * Konstruktor
-     * @param set           Liste der Geraden
+     *
-     * @param presenter     Presenter (Beobachter)
+     * @param set       Liste der Geraden
+     * @param presenter Presenter (Beobachter)
      */
     public RepeatedMedianEstimator(LinkedList<Line> set, Presenter presenter) {
         this.set = set;
@@ -83,6 +84,7 @@ public class RepeatedMedianEstimator extends Observable implements Algorithm {
 
     /**
      * Konstruktor
+     *
      * @param set Liste der Geraden
      */
     public RepeatedMedianEstimator(LinkedList<Line> set) {
@@ -91,7 +93,7 @@ public class RepeatedMedianEstimator extends Observable implements Algorithm {
 
     /**
      * Führt den Algortihmus zur Berechnung des RM-Schätzers durch.
-     *
+     * <p>
      * Paper:
      * Matousek, Jiri, D. M. Mount und N. S. Netanyahu
      * „Efficient Randomized Algorithms for the Repeated Median Line Estimator“. 1998
@@ -136,7 +138,7 @@ public class RepeatedMedianEstimator extends Observable implements Algorithm {
 
         }
         end = System.currentTimeMillis();
-        System.out.println("Zeit: "+ ((end-start)/1000));
+        System.out.println("Zeit: " + ((end - start) / 1000));
 
         pepareResult();
     }
@@ -146,7 +148,7 @@ public class RepeatedMedianEstimator extends Observable implements Algorithm {
      * Berechnet die mediane x-Koordinate über den Schnittpunkten.
      *
      * @param sampledLine Stichprobe von Geraden
-     * @return  mediane x-Koordinate über den Schnittpunkten
+     * @return mediane x-Koordinate über den Schnittpunkten
      */
     public Double estimateMedianIntersectionAbscissas(Line sampledLine) {
 
@@ -172,9 +174,9 @@ public class RepeatedMedianEstimator extends Observable implements Algorithm {
      */
     public void computeSlabBorders() {
         kLow = Math.max(1, Math.floor(((r * k) / (linesInCenterSlab.size()))
-                                        - ((3 * Math.sqrt(r)) / (2))));
+                - ((3 * Math.sqrt(r)) / (2))));
         kHigh = Math.min(r, Math.floor(((r * k) / (linesInCenterSlab.size()))
-                                        + ((3 * Math.sqrt(r)) / (2))));
+                + ((3 * Math.sqrt(r)) / (2))));
     }
 
 
@@ -200,9 +202,9 @@ public class RepeatedMedianEstimator extends Observable implements Algorithm {
                 }
             }
 
-            countLeftSlab.set(index,   (double) left);
+            countLeftSlab.set(index, (double) left);
             countCenterSlab.set(index, (double) center);
-            countRightSlab.set(index,  (double) right);
+            countRightSlab.set(index, (double) right);
         }
 
     }
@@ -332,7 +334,7 @@ public class RepeatedMedianEstimator extends Observable implements Algorithm {
     }
 
     /**
-     * @return  verteilung der Punkte
+     * @return verteilung der Punkte
      */
     public ArrayList<Double> getCountLeftSlab() {
         return countLeftSlab;

LinearRegressionTool/src/main/java/presenter/algorithms/advanced/TheilSenEstimator.java

@@ -5,7 +5,10 @@ import model.Line;
 import model.Point;
 import presenter.Presenter;
 import presenter.algorithms.Algorithm;
-import presenter.util.*;
+import presenter.util.BinomialCoeffizient;
+import presenter.util.FastElementSelector;
+import presenter.util.IntersectionCounter;
+import presenter.util.RandomSampler;
 
 import java.util.*;
 
@@ -46,9 +49,10 @@ public class TheilSenEstimator extends Observable implements Algorithm {
 
     /**
      * Konstruktor
-     * @param setOfLines            Liste der Geraden
+     *
-     * @param setOfIntersections    Liste der Schnittpunkte
+     * @param setOfLines         Liste der Geraden
-     * @param presenter             Presenter (Beobachter)
+     * @param setOfIntersections Liste der Schnittpunkte
+     * @param presenter          Presenter (Beobachter)
      */
     public TheilSenEstimator(LinkedList<Line> setOfLines, ArrayList<Point> setOfIntersections, Presenter presenter) {
         this.presenter = presenter;
@@ -69,8 +73,9 @@ public class TheilSenEstimator extends Observable implements Algorithm {
 
     /**
      * Konstruktor
-     * @param setOfLines            Liste der Geraden
+     *
-     * @param setOfIntersections    Liste der Schnittpunkte
+     * @param setOfLines         Liste der Geraden
+     * @param setOfIntersections Liste der Schnittpunkte
      */
     public TheilSenEstimator(LinkedList<Line> setOfLines, ArrayList<Point> setOfIntersections) {
         this(setOfLines, setOfIntersections, null);
@@ -86,7 +91,7 @@ public class TheilSenEstimator extends Observable implements Algorithm {
         //damit eine initiale Ordnung herscht
         //Collections.sort(intervalIntersections);
 
-        r = (double) n;
+        r = n;
         while (true) {
             if (this.N <= n || (Math.abs(interval.getUpper() - interval.getLower())) < EPSILON) {
                 break;
@@ -113,7 +118,7 @@ public class TheilSenEstimator extends Observable implements Algorithm {
                 interval.setLower(aVariant);
                 interval.setUpper(bVariant);
                 intervalIntersections = getOpenIntervalElements(interval.getLower(), interval.getUpper());
-                N = (double) getOpenIntervalSize(interval.getLower(), interval.getUpper(), intervalIntersections);
+                N = getOpenIntervalSize(interval.getLower(), interval.getUpper(), intervalIntersections);
             }
         }
 
@@ -155,16 +160,16 @@ public class TheilSenEstimator extends Observable implements Algorithm {
      * @return Anzahl der Schnittpunkte im Interval [a,b)
      */
     public int getIntervalSize(double a, double b) {
-        IntersectionCounter ic =  new IntersectionCounter();
+        IntersectionCounter ic = new IntersectionCounter();
-        return ic.run(setOfLines, new Interval(a,b));
+        return ic.run(setOfLines, new Interval(a, b));
     }
 
     /**
      * Berechne wieviele von den Schnittpunkten in dem Interval zwischen <code>a</code> und <code>b</code>
      * enthalten sind.
-     *
+     * <p>
      * Inspiriert durch:
-     *   <url>https://stackoverflow.com/questions/136474/best-way-to-pick-a-random-subset-from-a-collection</url>
+     * <url>https://stackoverflow.com/questions/136474/best-way-to-pick-a-random-subset-from-a-collection</url>
      *
      * @param a untere Grenze des Intervals
      * @param b obere Grenze des Intrvals
@@ -219,7 +224,7 @@ public class TheilSenEstimator extends Observable implements Algorithm {
             yCoordinates.add(p.getY());
         }
 
-        int pseudoIndex = (int) getOpenIntervalSize(NEGATIV_INF, interval.getLower(), setOfIntersections);
+        int pseudoIndex = getOpenIntervalSize(NEGATIV_INF, interval.getLower(), setOfIntersections);
         m = FastElementSelector.randomizedSelect(resultAbscissas, k - pseudoIndex);
 
         Set<Double> unique = new LinkedHashSet<>(yCoordinates);

LinearRegressionTool/src/main/java/presenter/algorithms/naiv/NaivLeastMedianOfSquaresEstimator.java

@@ -24,6 +24,7 @@ public class NaivLeastMedianOfSquaresEstimator implements Algorithm {
 
     /**
      * Konstruktor
+     *
      * @param lines Liste des Geraden
      */
     public NaivLeastMedianOfSquaresEstimator(LinkedList<Line> lines) {
@@ -67,11 +68,12 @@ public class NaivLeastMedianOfSquaresEstimator implements Algorithm {
             }
         }
         end = System.currentTimeMillis();
-        System.out.println("Zeit: "+ ((end-start)/1000));
+        System.out.println("Zeit: " + ((end - start) / 1000));
     }
 
     /**
      * Berechnet die Gerade mit dem medianen Fehler
+     *
      * @param a y-Achsenabschnitt
      * @param b Steigung
      * @return medianer Fehler

LinearRegressionTool/src/main/java/presenter/algorithms/naiv/NaivRepeatedMedianEstimator.java

@@ -27,6 +27,7 @@ public class NaivRepeatedMedianEstimator implements Algorithm {
 
     /**
      * Konstruktor
+     *
      * @param lines Liste der Geraden
      */
     public NaivRepeatedMedianEstimator(LinkedList<Line> lines) {
@@ -87,7 +88,7 @@ public class NaivRepeatedMedianEstimator implements Algorithm {
         medianX = FastElementSelector.randomizedSelect(xMedians, xMedians.size() / 2);
         medianY = FastElementSelector.randomizedSelect(yMedians, yMedians.size() / 2);
         end = System.currentTimeMillis();
-        System.out.println("Zeit: "+ ((end-start)/1000));
+        System.out.println("Zeit: " + ((end - start) / 1000));
     }
 
     @Override
@@ -97,8 +98,9 @@ public class NaivRepeatedMedianEstimator implements Algorithm {
 
     /**
      * Berechnet die  Geraden zwischen zwei Punkten im dualen Raum.
+     *
      * @param startPoint Gerade 1 => Startpunkt mit den Koordianten (m,b)
-     * @param endPoint Gerade 2 => Endpunkt mit den Koordianten (m', b')
+     * @param endPoint   Gerade 2 => Endpunkt mit den Koordianten (m', b')
      * @return
      */
     private Point calculateLine(Line startPoint, Line endPoint) {

LinearRegressionTool/src/main/java/presenter/algorithms/naiv/NaivTheilSenEstimator.java

@@ -23,6 +23,7 @@ public class NaivTheilSenEstimator implements Algorithm {
 
     /**
      * Konstruktor
+     *
      * @param lines Liste der Geraden
      */
     public NaivTheilSenEstimator(LinkedList<Line> lines) {
@@ -65,7 +66,7 @@ public class NaivTheilSenEstimator implements Algorithm {
         slope = FastElementSelector.randomizedSelect(slopesList, slopesList.size() / 2);
         yInterception = median2 - slope * median1;
         end = System.currentTimeMillis();
-        System.out.println("Zeit: "+ ((end-start)/1000));
+        System.out.println("Zeit: " + ((end - start) / 1000));
     }
 
     @Override

LinearRegressionTool/src/main/java/presenter/evaluation/EvaluateAlgorithms.java

@@ -9,9 +9,9 @@ import presenter.algorithms.advanced.TheilSenEstimator;
 import presenter.algorithms.naiv.NaivLeastMedianOfSquaresEstimator;
 import presenter.algorithms.naiv.NaivRepeatedMedianEstimator;
 import presenter.algorithms.naiv.NaivTheilSenEstimator;
-import presenter.util.IntersectionComputer;
 import presenter.generator.DatasetGenerator;
 import presenter.io.DataImporter;
+import presenter.util.IntersectionComputer;
 
 import java.io.File;
 import java.util.ArrayList;
@@ -56,15 +56,15 @@ public class EvaluateAlgorithms extends Observable {
     /**
      * Konstruktor zur evaluation
      *
-     * @param type Typ der evaluation
+     * @param type       Typ der evaluation
-     * @param n    Größe des Datensatzes
+     * @param n          Größe des Datensatzes
-     * @param alg  0 = lms,
+     * @param alg        0 = lms,
-     *             1 = rm,
+     *                   1 = rm,
-     *             2 = ts,
+     *                   2 = ts,
-     *             3 = lms, rm,
+     *                   3 = lms, rm,
-     *             4 = lms, ts,
+     *                   4 = lms, ts,
-     *             5 = rm,  ts,
+     *                   5 = rm,  ts,
-     *             6 = lms, rm, ts,
+     *                   6 = lms, rm, ts,
      * @param datasettyp typ der zu generierenden Datensatz
      */
     public EvaluateAlgorithms(int type, int n, int alg, String datasettyp) {
@@ -143,9 +143,10 @@ public class EvaluateAlgorithms extends Observable {
 
     /**
      * Startet die Evaluation zu den passenden Typ. Bei beendigung wird der Beobachter informiert.
+     *
      * @throws InterruptedException
      */
-    public void run()  {
+    public void run() {
         setChanged();
         String[] msg = {"eval-dataset-generated"};
         notifyObservers(msg);
@@ -315,8 +316,9 @@ public class EvaluateAlgorithms extends Observable {
 
     /**
      * Die berechneten Ergebnisse werden an den Beobachter übermittelt um dann visualisiert zu werden.
+     *
      * @param result Ergebnisse
-     * @param col Spalte
+     * @param col    Spalte
      */
     public void sendTableApproximationData(ArrayList<String> result, int col) {
         ArrayList<String> tableInput = new ArrayList<>();
@@ -333,6 +335,7 @@ public class EvaluateAlgorithms extends Observable {
 
     /**
      * Die berechneten Ergebnisse werden an den Beobachter übermittelt um dann visualisiert zu werden.
+     *
      * @param result Ergebnisse
      */
     public void sendTableApproximationData(ArrayList<ArrayList<String>> result) {
@@ -379,6 +382,7 @@ public class EvaluateAlgorithms extends Observable {
     /**
      * Zur visualisierung der berechneten Geraden wird die Steigung und der y-Achsenabschnitt an den
      * Beobachter übermittelt.
+     *
      * @param res Feld mit den Werten für die Steigung und dern y-Achsenabschnitt
      * @param alg code für welchen Algorithmus sich die Werte beziehen
      */
@@ -399,7 +403,8 @@ public class EvaluateAlgorithms extends Observable {
     /**
      * Zur visualisierung der berechneten Geraden wird die Steigung und der y-Achsenabschnitt an den
      * Beobachter übermittelt.
-     * @param res Feld mit den Werten für die Steigung und dern y-Achsenabschnitt (alle)
+     *
+     * @param res  Feld mit den Werten für die Steigung und dern y-Achsenabschnitt (alle)
      * @param algs codes für welchen Algorithmus sich die Werte beziehen (alle)
      */
     public void sendPloteLineResults(ArrayList<Double[]> res, Integer[] algs) {
@@ -418,6 +423,7 @@ public class EvaluateAlgorithms extends Observable {
 
     /**
      * Startet die Berechnung des Alg. zum LMS-Schätzer
+     *
      * @throws InterruptedException
      */
     public void startLMS() throws InterruptedException {
@@ -434,6 +440,7 @@ public class EvaluateAlgorithms extends Observable {
 
     /**
      * Startet die Berechnung des Alg. zum RM-Schätzer
+     *
      * @throws InterruptedException
      */
     public void startRM() throws InterruptedException {
@@ -450,6 +457,7 @@ public class EvaluateAlgorithms extends Observable {
 
     /**
      * Startet die Berechnung des Alg. zum TS-Schätzer
+     *
      * @throws InterruptedException
      */
     public void startTS() throws InterruptedException {
@@ -466,10 +474,11 @@ public class EvaluateAlgorithms extends Observable {
 
     /**
      * Startet die Berechnung der skalierungsabbhängigen Maße.
+     *
      * @param lines Liste der Geraden
      * @param m     Steigung
      * @param b     y-Achsenabschnitt
-     * @return      Liste mit den Ergebnissen, bereit zum visualisieren
+     * @return Liste mit den Ergebnissen, bereit zum visualisieren
      */
     public ArrayList<String> getScaleDependentMeasure(final LinkedList<Line> lines, final Double m, final Double b) {
         ScaleDependentMeasure scaleDependentMeasure = new ScaleDependentMeasure(lines, m, b);
@@ -486,10 +495,11 @@ public class EvaluateAlgorithms extends Observable {
 
     /**
      * Startet die Berechnung der Maße die auf dem prozentualen Fehler basieren.
+     *
      * @param lines Liste der Geraden
      * @param m     Steigung
      * @param b     y-Achsenabschnitt
-     * @return      Liste mit den Ergebnissen, bereit zum visualisieren
+     * @return Liste mit den Ergebnissen, bereit zum visualisieren
      */
     public ArrayList<String> getPercentigeErrorBasedMeasure(final LinkedList<Line> lines, final Double m, final Double b) {
         PercentageErrorBasedMeasure percentageErrorBasedMeasure = new PercentageErrorBasedMeasure(lines, m, b);
@@ -505,10 +515,11 @@ public class EvaluateAlgorithms extends Observable {
 
     /**
      * Startet die Berechnung der skalierungsunabbhängigen Maße.
+     *
      * @param lines Liste der Geraden
      * @param m     Steigung
      * @param b     y-Achsenabschnitt
-     * @return      Liste mit den Ergebnissen, bereit zum visualisieren
+     * @return Liste mit den Ergebnissen, bereit zum visualisieren
      */
     public ArrayList<String> getScaledErrorBasedMeasure(final LinkedList<Line> lines, final Double m, final Double b, final Double nM, final Double nB) {
         ScaledErrorBasedMeasure scaledErrorBasedMeasure = new ScaledErrorBasedMeasure(lines, m, b, nM, nB);
@@ -524,6 +535,7 @@ public class EvaluateAlgorithms extends Observable {
 
     /**
      * Damit es bei der Visualisierung trennende Zeilen gibt.
+     *
      * @return
      */
     private ArrayList<String> fillPseudoResults() {

LinearRegressionTool/src/main/java/presenter/evaluation/PercentageErrorBasedMeasure.java

@@ -20,6 +20,7 @@ public class PercentageErrorBasedMeasure {
 
     /**
      * Konstruktor
+     *
      * @param lines Liste der Geraden
      * @param m     Steigung
      * @param b     y-Achenabschnitt
@@ -45,6 +46,7 @@ public class PercentageErrorBasedMeasure {
 
     /**
      * Mean Absolute Precentage Error
+     *
      * @return Ergebnis
      */
     public Double mape() {
@@ -61,6 +63,7 @@ public class PercentageErrorBasedMeasure {
 
     /**
      * Median Absolute Precentage Error:
+     *
      * @return Ergebnis
      */
     public Double mdape() {
@@ -76,6 +79,7 @@ public class PercentageErrorBasedMeasure {
 
     /**
      * Root Mean Square Percentage Error
+     *
      * @return Ergebnis
      */
     public Double rmspe() {
@@ -92,6 +96,7 @@ public class PercentageErrorBasedMeasure {
 
     /**
      * Root Median Square Percentage Error
+     *
      * @return Ergebnis
      */
     public Double rmdspe() {

LinearRegressionTool/src/main/java/presenter/evaluation/PictureProcessor.java

@@ -1,7 +1,6 @@
 package presenter.evaluation;
 
 import model.Line;
-
 import org.opencv.core.*;
 import org.opencv.imgcodecs.Imgcodecs;
 import org.opencv.imgproc.Imgproc;
@@ -32,6 +31,7 @@ public class PictureProcessor extends Observable {
 
     /**
      * Konstruktor
+     *
      * @param presenter Presenter
      * @param file      Bilddatei
      */
@@ -52,18 +52,19 @@ public class PictureProcessor extends Observable {
 
     /**
      * Vorverarbeitung des Eingabebilds. Dabei wird auf verschiedene OpenCV Methoden zurückgegriffen.
+     *
      * @param image Eingabebild
      * @return Matrix representation des Bilds
      */
     private Mat process(Mat image) {
         Mat threshold = new Mat(image.width(), image.height(), CvType.CV_8UC1);
         Mat source = new Mat(image.width(), image.height(), CvType.CV_8UC1);
-        Imgcodecs.imwrite(file.getAbsolutePath().substring(0,file.getAbsolutePath().lastIndexOf("."))+"-orig.png", image);
+        Imgcodecs.imwrite(file.getAbsolutePath().substring(0, file.getAbsolutePath().lastIndexOf(".")) + "-orig.png", image);
         Imgproc.cvtColor(image, source, Imgproc.COLOR_BGR2GRAY);
-        Imgcodecs.imwrite(file.getAbsolutePath().substring(0,file.getAbsolutePath().lastIndexOf("."))+"-Greyscale.png", source);
+        Imgcodecs.imwrite(file.getAbsolutePath().substring(0, file.getAbsolutePath().lastIndexOf(".")) + "-Greyscale.png", source);
         Imgproc.GaussianBlur(source, threshold, new Size(3, 3), 0, 0);
         Imgproc.Canny(threshold, source, 300, 600, 5, true);
-        Imgcodecs.imwrite(file.getAbsolutePath().substring(0,file.getAbsolutePath().lastIndexOf("."))+"-Canny.png", source);
+        Imgcodecs.imwrite(file.getAbsolutePath().substring(0, file.getAbsolutePath().lastIndexOf(".")) + "-Canny.png", source);
         //Konturen berechnen und filtern
         contours = new ArrayList<>();
         Imgproc.findContours(source, contours, new Mat(), Imgproc.RETR_TREE, Imgproc.CHAIN_APPROX_SIMPLE, new Point(0, 0));
@@ -76,7 +77,7 @@ public class PictureProcessor extends Observable {
                 Imgproc.drawContours(viscont, contours, i, new Scalar(255, 0, 0), 1);
             }
         }
-        Imgcodecs.imwrite(file.getAbsolutePath().substring(0,file.getAbsolutePath().lastIndexOf("."))+"-Contour.png", viscont);
+        Imgcodecs.imwrite(file.getAbsolutePath().substring(0, file.getAbsolutePath().lastIndexOf(".")) + "-Contour.png", viscont);
         Mat resized = new Mat();
         Imgproc.resize(viscont, resized, new Size(560, 560));
         SwingUtilities.invokeLater(() -> {
@@ -93,6 +94,7 @@ public class PictureProcessor extends Observable {
 
     /**
      * Das Bild wird passend umgewandelt, um im nächsten Schritt visualisiert werden zu können.
+     *
      * @param m Matrix representation des Bilds
      * @return visualisierbares Bild
      */

LinearRegressionTool/src/main/java/presenter/evaluation/ScaleDependentMeasure.java

@@ -19,6 +19,7 @@ public class ScaleDependentMeasure {
 
     /**
      * Konstruktor
+     *
      * @param lines Liste des Geraden
      * @param m     Steigung
      * @param b     y-Achsenabschnitt
@@ -39,6 +40,7 @@ public class ScaleDependentMeasure {
 
     /**
      * Mean Square Error:
+     *
      * @return Ergebnis
      */
     public Double mse() {
@@ -55,6 +57,7 @@ public class ScaleDependentMeasure {
 
     /**
      * Root Mean Square Error
+     *
      * @return Ergebnis
      */
     public Double rmse() {
@@ -63,6 +66,7 @@ public class ScaleDependentMeasure {
 
     /**
      * Mean Absolute Error
+     *
      * @return Ergebnis
      */
     public Double mae() {
@@ -76,6 +80,7 @@ public class ScaleDependentMeasure {
 
     /**
      * Median Absolute Error
+     *
      * @return Ergebnis
      */
     public Double mdae() {

LinearRegressionTool/src/main/java/presenter/evaluation/ScaledErrorBasedMeasure.java

@@ -22,11 +22,12 @@ public class ScaledErrorBasedMeasure {
 
     /**
      * Konstruktor
-     * @param lines                 Liste der Geraden
+     *
-     * @param m                     Steigung
+     * @param lines            Liste der Geraden
-     * @param b                     y-Achsenabschnitt
+     * @param m                Steigung
-     * @param naivSlope             naive Steigung
+     * @param b                y-Achsenabschnitt
-     * @param naivInterception      naiver y-Achsenabschnitt
+     * @param naivSlope        naive Steigung
+     * @param naivInterception naiver y-Achsenabschnitt
      */
     public ScaledErrorBasedMeasure(final LinkedList<Line> lines, Double m, Double b, Double naivSlope, Double naivInterception) {
 
@@ -57,6 +58,7 @@ public class ScaledErrorBasedMeasure {
 
     /**
      * Mean Square Error
+     *
      * @return Ergebnis
      */
     public Double mse() {
@@ -70,6 +72,7 @@ public class ScaledErrorBasedMeasure {
 
     /**
      * Root Mean Square Error
+     *
      * @return Ergebnis
      */
     public Double rmse() {
@@ -78,6 +81,7 @@ public class ScaledErrorBasedMeasure {
 
     /**
      * Mean Absolute Error:
+     *
      * @return Ergebnis
      */
     public Double mae() {
@@ -91,6 +95,7 @@ public class ScaledErrorBasedMeasure {
 
     /**
      * Median Absolute Error
+     *
      * @return Ergebnis
      */
     public Double mdae() {

LinearRegressionTool/src/main/java/presenter/generator/DatasetGenerator.java

@@ -22,6 +22,7 @@ public class DatasetGenerator extends Observable {
 
     /**
      * Konstruktor
+     *
      * @param m Steigung
      * @param b y-Achsenabschnitt
      */
@@ -31,6 +32,7 @@ public class DatasetGenerator extends Observable {
         random = new Random();
         random.setSeed(9999);
     }
+
     /**
      * Konstruktor
      */
@@ -40,6 +42,7 @@ public class DatasetGenerator extends Observable {
 
     /**
      * Generiert zu einer gegebenen Größe einen Datensatz des typen: Punktwolke
+     *
      * @param size Größe des Datensatzes
      * @return Liste der Geraden
      */
@@ -54,7 +57,7 @@ public class DatasetGenerator extends Observable {
             double signal = m * i + b;
             signal *= -1;
 
-            Line line = new Line((double) i, signal - y);
+            Line line = new Line(i, signal - y);
             line.setId(i - 1 + "");
             lines.add(line);
         }
@@ -68,6 +71,7 @@ public class DatasetGenerator extends Observable {
 
     /**
      * Wrapper Methode zum generieren eines Datensatzes des typen: Gerade
+     *
      * @param size Größe des Datensatzes
      * @return Liste des Geraden
      */
@@ -79,9 +83,10 @@ public class DatasetGenerator extends Observable {
     /**
      * Generieren eines Datensatzes des typen: Gerade. Die Geraden werden in eine
      * übergebene Liste hinzugefügt.
+     *
      * @param lines Liste der Geraden
      * @param n     Größe des Datensatzes
-     * @return      Liste des Geraden
+     * @return Liste des Geraden
      */
     private LinkedList<Line> generateDataLines(LinkedList<Line> lines, int n) {
         m = 5d;
@@ -105,7 +110,7 @@ public class DatasetGenerator extends Observable {
 
         int idx = lines.size();
         for (Double d : points.keySet()) {
-            Line line = new Line((double) d, points.get(d));
+            Line line = new Line(d, points.get(d));
             line.setId(idx + "");
             lines.add(line);
             idx++;
@@ -121,6 +126,7 @@ public class DatasetGenerator extends Observable {
      * Generiert einen Datensatz des typen: Gerade mit zirkulärer Störung. Zuerst wird die
      * zirkuläre Störung zu der Liste der (dualen-)Geraden hinzugefügt danach wird die wrapper Methode
      * <code>generateDataLines()</code> aufgerufen.
+     *
      * @param size Größe des Datensatzes
      * @return Liste der Geraden
      */

LinearRegressionTool/src/main/java/presenter/io/DataExporter.java

@@ -2,7 +2,6 @@ package presenter.io;
 
 import com.opencsv.CSVWriter;
 import model.Line;
-import model.LineModel;
 
 import java.io.File;
 import java.io.FileWriter;
@@ -24,6 +23,7 @@ public class DataExporter extends Observable {
 
     /**
      * Konstruktor
+     *
      * @param lines Liste der Geraden
      * @param file  Datei in die, die Informationen exportiert werden sollen
      */

LinearRegressionTool/src/main/java/presenter/io/DataImporter.java

@@ -2,8 +2,6 @@ package presenter.io;
 
 import com.opencsv.CSVReader;
 import model.Line;
-import model.LineModel;
-import presenter.Presenter;
 
 import javax.swing.*;
 import java.io.File;
@@ -29,6 +27,7 @@ public class DataImporter extends Observable {
 
     /**
      * Konstruktor
+     *
      * @param file Datei aus der die Informationen imortiert werden sollen.
      */
     public DataImporter(File file) {
@@ -46,6 +45,7 @@ public class DataImporter extends Observable {
      * Diese Methode importiert liest zeile für zeile die Daten aus der Datei und baut eine Liste von Geraden auf.
      * Dabei wird auf die richtige Form geachtet. Falls die Datei nicht, mindestens zwei Spalten enthält wird ein Fehler
      * signalisiert und der Import wird abgebrochen.
+     *
      * @return Liste der Geraden
      */
     public LinkedList<Line> run() {
@@ -69,7 +69,7 @@ public class DataImporter extends Observable {
                     result[2] = counter + "";
                     Thread.sleep(10);
                     notifyObservers(result);
-                } else if (nextLine.length == 2){
+                } else if (nextLine.length == 2) {
                     Double x = Double.parseDouble(nextLine[1]);
                     Double y = Double.parseDouble(nextLine[2]) * (-1);
                     Line line = new Line(x, y);
@@ -84,7 +84,7 @@ public class DataImporter extends Observable {
                     notifyObservers(result);
                 } else {
                     JOptionPane.showMessageDialog(null, "Diese Datei kann nicht importiert werden." +
-                            "Es müssen mindestens zwei Spalten enthalten sein (x,y).", "Fehler bei der Eingabe",JOptionPane.ERROR_MESSAGE);
+                            "Es müssen mindestens zwei Spalten enthalten sein (x,y).", "Fehler bei der Eingabe", JOptionPane.ERROR_MESSAGE);
                     return null;
                 }
             }

LinearRegressionTool/src/main/java/presenter/io/EvalResultLatexExport.java

@@ -21,6 +21,7 @@ public class EvalResultLatexExport {
 
     /**
      * Konstruktor
+     *
      * @param model TableModel aus dem exportiert werden soll
      * @param file  Datei in die exportiert werden soll
      */
@@ -30,7 +31,7 @@ public class EvalResultLatexExport {
     }
 
     /**
-     *  Quelle: <url>https://en.wikibooks.org/wiki/LaTeX/Tables</url>
+     * Quelle: <url>https://en.wikibooks.org/wiki/LaTeX/Tables</url>
      * \begin{tabular}{l*{3}{c}}
      * Team              & P & W & D & L & F  & A & Pts \\\hline
      * Manchester United & 6 & 4 & 0 & 2 & 10 & 5 & 12  \\

LinearRegressionTool/src/main/java/presenter/util/BinomialCoeffizient.java

@@ -10,6 +10,7 @@ package presenter.util;
 public class BinomialCoeffizient {
     /**
      * Berechnet den Binomialkoeffizient zu der eingabe. Bin(n,k)
+     *
      * @param n n
      * @param k k
      * @return Ergebnis

LinearRegressionTool/src/main/java/presenter/util/FastElementSelector.java

@@ -15,6 +15,7 @@ public class FastElementSelector {
 
     /**
      * Liefert das k-te Element aus der Eingabeliste zurück in Theta(n) Zeit.
+     *
      * @param a Eingabeliste
      * @param i Rang des gewünschten Elements
      * @return das Element
@@ -50,9 +51,9 @@ public class FastElementSelector {
     /**
      * Hilfsmethode
      *
-     * @param a         Eingabeliste
+     * @param a     Eingabeliste
-     * @param start     Startindex
+     * @param start Startindex
-     * @param end       Index des letzten Elements
+     * @param end   Index des letzten Elements
      * @return Pivotelement
      */
     private static int randomizedPartition(List<Double> a, int start, int end) {
@@ -73,9 +74,9 @@ public class FastElementSelector {
     /**
      * Hilfsmethode
      *
-     * @param a         Eingabeliste
+     * @param a     Eingabeliste
-     * @param start     Startindex
+     * @param start Startindex
-     * @param end       Index des letzten Elements
+     * @param end   Index des letzten Elements
      * @return Pivotelement
      */
     private static int partition(List<Double> a, int start, int end) {

LinearRegressionTool/src/main/java/presenter/util/IntersectionComputer.java

@@ -30,6 +30,7 @@ public class IntersectionComputer {
 
     /**
      * Konstruktor
+     *
      * @param lines Liste der Geraden
      */
     public IntersectionComputer(LinkedList<Line> lines) {
@@ -47,27 +48,28 @@ public class IntersectionComputer {
      * Berechnet zu einer gegebenen Menge von dualen Geraden die Schnittpunkte. Dafür wird ein modifizierter Merge-Sort
      * Algorithmus verwendett. Um die Performance zu steigern wird die Berechnung ab einer passenden Größe auf vier
      * Threads ausgelagert.
-     * @param lower     untere Schranke
+     *
-     * @param higher    obere Schranke
+     * @param lower  untere Schranke
-     * @return  Liste der Schnittpunkte
+     * @param higher obere Schranke
+     * @return Liste der Schnittpunkte
      */
     public ArrayList<Point> compute(final double lower, final double higher) {
 
         if (lines.size() > 16) {
             worker[0] = new Thread(() -> {
-                work(lines.subList(0, (lines.size() / 4)),lower,higher);
+                work(lines.subList(0, (lines.size() / 4)), lower, higher);
             });
             worker[0].start();
             worker[1] = new Thread(() -> {
-                work(lines.subList((lines.size() / 4) + 1, (lines.size() / 2)),lower,higher);
+                work(lines.subList((lines.size() / 4) + 1, (lines.size() / 2)), lower, higher);
             });
             worker[1].start();
             worker[2] = new Thread(() -> {
-                work(lines.subList((lines.size() / 2) + 1, 3 * (lines.size() / 4)),lower,higher);
+                work(lines.subList((lines.size() / 2) + 1, 3 * (lines.size() / 4)), lower, higher);
             });
             worker[2].start();
             worker[3] = new Thread(() -> {
-                work(lines.subList(3 * (lines.size() / 4) + 1, (lines.size())),lower,higher);
+                work(lines.subList(3 * (lines.size() / 4) + 1, (lines.size())), lower, higher);
             });
             worker[3].start();
 
@@ -80,17 +82,19 @@ public class IntersectionComputer {
                 }
             }
         } else {
-            work(lines,lower,higher);
+            work(lines, lower, higher);
         }
 
         return new ArrayList<>(intersections);
 
     }
+
     /**
      * Berechnet zu einer gegebenen Menge von dualen Geraden die Schnittpunkte. Dafür wird ein modifizierter Merge-Sort
      * Algorithmus verwendett. Um die Performance zu steigern wird die Berechnung ab einer passenden Größe auf vier
      * Threads ausgelagert.
-     * @return  Liste der Schnittpunkte
+     *
+     * @return Liste der Schnittpunkte
      */
     public ArrayList<Point> compute() {
         return compute(-99999, 99999);
@@ -111,6 +115,7 @@ public class IntersectionComputer {
 
     /**
      * Synchronisierter Zugriff auf die Liste der Geraden
+     *
      * @return Liste der Geraden
      */
     public synchronized LinkedList<Line> getLines() {
@@ -119,6 +124,7 @@ public class IntersectionComputer {
 
     /**
      * Synchronisierter hinzufügen eines Schnittpunkts
+     *
      * @param p Schnittpunkt
      */
     public synchronized void addIntersection(Point p) {
@@ -127,20 +133,18 @@ public class IntersectionComputer {
 
     /**
      * Synchronisiertes abfragen ob ein Schnittpunkt bereits gefunden wurde.
+     *
      * @param p Schnittpunkt
      * @return <code>true</code>, falls der Schnittpunkt p bereits gefunden wurde
      */
     public synchronized boolean isFound(Point p) {
-        if (intersections.contains(p)) {
+        return intersections.contains(p);
-            return true;
-        } else {
-            return false;
-        }
     }
 
     /**
      * Zu einem Punkt werden die minimalen, maximalen x- und y-Koordinaten überprüft und ggf.
      * neu gesetzt
+     *
      * @param point Schnittpunkt
      */
     public void setRanges(Point point) {
@@ -152,6 +156,7 @@ public class IntersectionComputer {
 
     /**
      * Synchronisierter Zugriff auf die minimale x-Koordiante
+     *
      * @return minimale x-Koordiante
      */
     public synchronized Double getxMinimum() {
@@ -160,6 +165,7 @@ public class IntersectionComputer {
 
     /**
      * Synchronisierter Zugriff auf die maximale x-Koordinate
+     *
      * @return maximale x-Koordinate
      */
     public synchronized Double getxMaximum() {
@@ -168,6 +174,7 @@ public class IntersectionComputer {
 
     /**
      * Synchronisierter Zugriff auf die minimale y-Koordinate
+     *
      * @return minimale y-Koordinate
      */
     public synchronized Double getyMinimum() {
@@ -176,6 +183,7 @@ public class IntersectionComputer {
 
     /**
      * Synchronisierter Zugriff auf die maximale y-Koordinate
+     *
      * @return maximale y-Koordinate
      */
     public synchronized Double getyMaximum() {

LinearRegressionTool/src/main/java/presenter/util/IntersectionCounter.java

@@ -1,6 +1,9 @@
 package presenter.util;
 
-import model.*;
+import model.Interval;
+import model.Line;
+import model.Pair;
+import model.Point;
 import presenter.util.Comparators.YOrderLineComparatorBegin;
 import presenter.util.Comparators.YOrderLineComparatorEnd;
 

LinearRegressionTool/src/main/java/presenter/util/RandomSampler.java

@@ -44,14 +44,13 @@ public class RandomSampler {
     public static ArrayList<Double> run(ArrayList<Point> set, Double r) {
 
         ArrayList<Double> sampledLines = new ArrayList<>();
-        for (Point p : set){
+        for (Point p : set) {
             sampledLines.add(p.getX());
         }
 
         Random rand = new Random();
         int inputSize = sampledLines.size();
-        for (int i = 0; i < r; i++)
+        for (int i = 0; i < r; i++) {
-        {
             int indexToSwap = i + rand.nextInt(inputSize - i);
             Double temp = sampledLines.get(i);
             sampledLines.set(i, sampledLines.get(indexToSwap));

LinearRegressionTool/src/main/java/view/MainFrame.java

@@ -121,8 +121,9 @@ public class MainFrame extends JFrame {
 
     /**
      * Visualisiert das Ergebnis des LMS-Schätzers
-     * @param m     Steigung
+     *
-     * @param b     y-Achsenabschnitt
+     * @param m Steigung
+     * @param b y-Achsenabschnitt
      */
     public void visualizeLMS(double m, double b) {
         plotLMS = new PlotPanel();
@@ -132,8 +133,9 @@ public class MainFrame extends JFrame {
 
     /**
      * Visualisiert das Ergebnis des RM-Schätzers
-     * @param m     Steigung
+     *
-     * @param b     y-Achsenabschnitt
+     * @param m Steigung
+     * @param b y-Achsenabschnitt
      */
     public void visualizeRM(double m, double b) {
         plotRM = new PlotPanel();
@@ -143,8 +145,9 @@ public class MainFrame extends JFrame {
 
     /**
      * Visualisiert das Ergebnis des TS-Schätzers
-     * @param m     Steigung
+     *
-     * @param b     y-Achsenabschnitt
+     * @param m Steigung
+     * @param b y-Achsenabschnitt
      */
     public void visualizeTS(double m, double b) {
         plotTS = new PlotPanel();
@@ -154,11 +157,12 @@ public class MainFrame extends JFrame {
 
     /**
      * Erzeugt den Plot zu einer Eingabe von Punkten und der Lösung eines Schätzers (m,b)
-     * @param m         Steigung
+     *
-     * @param b         y-Achsenabschnitt
+     * @param m     Steigung
-     * @param plot      Plot
+     * @param b     y-Achsenabschnitt
-     * @param panel     Panel auf dem der Plot plaziert wird
+     * @param plot  Plot
-     * @param name      Bezeichnung der Gerade
+     * @param panel Panel auf dem der Plot plaziert wird
+     * @param name  Bezeichnung der Gerade
      */
     public void createPlot(double m, double b, PlotPanel plot, JPanel panel, String name) {
         SwingUtilities.invokeLater(() -> {
@@ -171,6 +175,7 @@ public class MainFrame extends JFrame {
 
     /**
      * Visualisierung des Import-Prozesses
+     *
      * @param progress akteulle Prozentzahl (0-100)
      */
     public void showImportProgress(Integer progress) {
@@ -207,13 +212,14 @@ public class MainFrame extends JFrame {
 
     /**
      * Fügt der Evaluations-Tabelle eine Spalte mit Daten hinzu
-     * @param res           Daten der Spalte
+     *
-     * @param col           Spalte
+     * @param res       Daten der Spalte
-     * @param isApprCol     <code>true</code>, falls es sich um die Überschirften der Approximationsgüten handelt
+     * @param col       Spalte
+     * @param isApprCol <code>true</code>, falls es sich um die Überschirften der Approximationsgüten handelt
      */
     public void appendEvalResult(Object[] res, int col, boolean isApprCol) {
         SwingUtilities.invokeLater(() -> {
-            Object[] tmp = Arrays.asList(res).subList(2, res.length).toArray();
+            Object[] tmp = Arrays.copyOfRange(res, 2, res.length);
             if (isApprCol) {
                 evaluationPanel.setCurrentRow(tmp.length);
                 evaluationPanel.addColumn(tmp, col, true);
@@ -227,11 +233,12 @@ public class MainFrame extends JFrame {
 
     /**
      * Fügt der Evaluations-Tabelle eine Zeile mit Daten hinzu
-     * @param res    Daten der Spalte
+     *
+     * @param res Daten der Spalte
      */
     public void appendEvalResult(Object[] res) {
         SwingUtilities.invokeLater(() -> {
-            Object[] tmp = Arrays.asList(res).subList(1, res.length).toArray();
+            Object[] tmp = Arrays.copyOfRange(res, 1, res.length);
             evaluationPanel.addRow(tmp);
             evaluationPanel.repaint();
             evaluationPanel.revalidate();
@@ -240,12 +247,13 @@ public class MainFrame extends JFrame {
 
     /**
      * Visualisiert die Ausgleichsgerade zu gegebenen Algorithmen
-     * @param res   Steigungen und y-Achsenabschnitte
+     *
-     * @param alg   Kodierung der Alg.
+     * @param res Steigungen und y-Achsenabschnitte
+     * @param alg Kodierung der Alg.
      */
     public void drawLineResult(Object[] res, int alg) {
         SwingUtilities.invokeLater(() -> {
-            Object[] result = Arrays.asList(res).subList(2, res.length).toArray();
+            Object[] result = Arrays.copyOfRange(res, 2, res.length);
             evaluationPanel.drawLines(result, alg);
             evaluationPanel.repaint();
             evaluationPanel.revalidate();
@@ -254,11 +262,12 @@ public class MainFrame extends JFrame {
 
     /**
      * Visualisiert die Ausgleichsgerade zu einem gegebenen Algorithmus
-     * @param res   Steigungen und y-Achsenabschnitte
+     *
+     * @param res Steigungen und y-Achsenabschnitte
      */
     public void drawLineResults(Object[] res) {
         SwingUtilities.invokeLater(() -> {
-            Object[] result = Arrays.asList(res).subList(1, res.length).toArray();
+            Object[] result = Arrays.copyOfRange(res, 1, res.length);
             ArrayList<Double[]> algs = new ArrayList<>();
 
             for (int i = 0; i < (result.length + 1) / 3; i++) {
@@ -277,6 +286,7 @@ public class MainFrame extends JFrame {
 
     /**
      * Evaluations-Datensätze werden Visualisiert
+     *
      * @param lines Liste der Geraden
      */
     public void addEvalDataset(LinkedList<Line> lines) {
@@ -511,6 +521,7 @@ public class MainFrame extends JFrame {
 
     /**
      * Ausgabe einer Tabelle
+     *
      * @param heading Überschrift
      * @param rows    Zeilen mit Text
      */
@@ -523,28 +534,28 @@ public class MainFrame extends JFrame {
      ******************************************************************************************************************/
 
     /**
-     * @return  liefert den Button, zum visualisieren des dualen Raums zurück
+     * @return liefert den Button, zum visualisieren des dualen Raums zurück
      */
     public JButton getArrangementButton() {
         return arrangementButton;
     }
 
     /**
-     * @return  liefert das Panel zum visualisieren des LMS-Schätzers
+     * @return liefert das Panel zum visualisieren des LMS-Schätzers
      */
     public TabPanel getLmsPanel() {
         return lmsPanel;
     }
 
     /**
-     * @return  liefert das Panel zum visualisieren des RM-Schätzers
+     * @return liefert das Panel zum visualisieren des RM-Schätzers
      */
     public TabPanel getRmPanel() {
         return rmPanel;
     }
 
     /**
-     * @return  liefert die Instanz des Presenters zurück
+     * @return liefert die Instanz des Presenters zurück
      */
     public AbstractPresenter getPresenter() {
         return presenter;
@@ -558,21 +569,21 @@ public class MainFrame extends JFrame {
     }
 
     /**
-     * @return  liefert den Dialog zum visualisieren des Import-Fortschrits
+     * @return liefert den Dialog zum visualisieren des Import-Fortschrits
      */
     public JDialog getProgressDialog() {
         return progressDialog;
     }
 
     /**
-     * @return  liefert das Panel zum visualisieren des TS-Schätzers
+     * @return liefert das Panel zum visualisieren des TS-Schätzers
      */
     public TabPanel getTsPanel() {
         return tsPanel;
     }
 
     /**
-     * @return  liefert den Button, exportieren zurück
+     * @return liefert den Button, exportieren zurück
      */
     public JButton getExportButton() {
         return exportButton;

LinearRegressionTool/src/main/java/view/MenuBar.java

@@ -35,6 +35,7 @@ public class MenuBar {
 
     /**
      * Konstruktor
+     *
      * @param view View
      */
     public MenuBar(MainFrame view) {
@@ -99,7 +100,7 @@ public class MenuBar {
     }
 
     /**
-     * @return      liefert die MenuBar Instanz zurück
+     * @return liefert die MenuBar Instanz zurück
      */
     public JMenuBar getMenuBar() {
         return menuBar;

LinearRegressionTool/src/main/java/view/listener/DualityVisualizerListener.java

@@ -19,6 +19,7 @@ public class DualityVisualizerListener implements ActionListener {
 
     /**
      * Konstruktor
+     *
      * @param presenter Presenter
      */
     public DualityVisualizerListener(Presenter presenter) {

LinearRegressionTool/src/main/java/view/listener/ExportDataListener.java

@@ -24,6 +24,7 @@ public class ExportDataListener implements ActionListener {
 
     /**
      * Konstruktor
+     *
      * @param presenter Presenter
      * @param component visuelle Elternkomponente
      */

LinearRegressionTool/src/main/java/view/listener/GenerateDataListener.java

@@ -25,6 +25,7 @@ public class GenerateDataListener implements ActionListener {
 
     /**
      * Konstruktor
+     *
      * @param presenter Presenter
      */
     public GenerateDataListener(Presenter presenter) {
@@ -34,7 +35,7 @@ public class GenerateDataListener implements ActionListener {
     @Override
     public void actionPerformed(ActionEvent e) {
         SwingUtilities.invokeLater(() -> {
-            if (dialog == null  || !dialog.isVisible()) {
+            if (dialog == null || !dialog.isVisible()) {
                 dialog = new JDialog();
                 dialog.setTitle("generiere Datensatz");
                 dialog.setAlwaysOnTop(true);
@@ -57,7 +58,7 @@ public class GenerateDataListener implements ActionListener {
                 aproveButton.addActionListener(e1 -> {
                     int n = Integer.parseInt(textField.getText());
                     int type = datasetTypeComboBox.getSelectedIndex();
-                    Thread t = new Thread(() -> presenter.generateDataset(n,type));
+                    Thread t = new Thread(() -> presenter.generateDataset(n, type));
                     t.start();
                     dialog.dispose();
                 });

LinearRegressionTool/src/main/java/view/listener/ImportDataListener.java

@@ -24,6 +24,7 @@ public class ImportDataListener implements ActionListener {
 
     /**
      * Konstruktor
+     *
      * @param presenter Presenter
      * @param component visuelle Elternkomponente
      */

LinearRegressionTool/src/main/java/view/listener/PictureImportListener.java

@@ -23,6 +23,7 @@ public class PictureImportListener implements ActionListener {
 
     /**
      * Konstruktor
+     *
      * @param presenter Presenter
      * @param component visuelle Elternkomponente
      */

LinearRegressionTool/src/main/java/view/listener/StartAlgorithmListener.java

@@ -23,6 +23,7 @@ public class StartAlgorithmListener implements ActionListener {
 
     /**
      * Konstruktor
+     *
      * @param presenter Presenter
      * @param tabPanel  Algorithmus Visualisierungskomponente
      */

LinearRegressionTool/src/main/java/view/panels/AboutPanel.java

@@ -34,22 +34,22 @@ public class AboutPanel extends JPanel {
         this.textArea = new JTextPane();
         this.textArea.setEditable(false);
         this.textArea.setOpaque(false);
-        SimpleAttributeSet attrs=new SimpleAttributeSet();
+        SimpleAttributeSet attrs = new SimpleAttributeSet();
         StyleConstants.setAlignment(attrs, StyleConstants.ALIGN_CENTER);
         StyleConstants.setBackground(new SimpleAttributeSet(), new Color(255, 255, 255, 128));
 
-        StyledDocument doc=(StyledDocument)textArea.getDocument();
+        StyledDocument doc = (StyledDocument) textArea.getDocument();
         String text = "\n\n\n\nDiese Software wurde als praktischer Teil der Masterarbeit:\n" +
                 "\"Algorithmen zur Berechnung von Ausgleichsgeraden\"\n" +
                 "entwickelt.\n\n" +
                 " Armin Wolf\n a_wolf28@uni-muenster.de\n" +
                 "Matrikelnummer: 398214";
         try {
-            doc.insertString(0,text,attrs);
+            doc.insertString(0, text, attrs);
         } catch (BadLocationException e) {
             e.printStackTrace();
         }
-        doc.setParagraphAttributes(0,doc.getLength()-1,attrs,false);
+        doc.setParagraphAttributes(0, doc.getLength() - 1, attrs, false);
 
         contentPane.add(this.textArea, BorderLayout.CENTER);
         ClassLoader classLoader = getClass().getClassLoader();

LinearRegressionTool/src/main/java/view/panels/DualityPanel.java

@@ -59,12 +59,13 @@ public class DualityPanel extends JPanel {
 
     /**
      * Hilfsmethode um die Parameter im einem Schritt zu setzen
-     * @param lines     Liste der Geraden
+     *
-     * @param points    Liste der Schnittpunkte
+     * @param lines  Liste der Geraden
-     * @param xmin      minimale x-Koordinate
+     * @param points Liste der Schnittpunkte
-     * @param xmax      maximale x-Koordinate
+     * @param xmin   minimale x-Koordinate
-     * @param ymin      minimale y-Koordinate
+     * @param xmax   maximale x-Koordinate
-     * @param ymax      maximale y-Koordinate
+     * @param ymin   minimale y-Koordinate
+     * @param ymax   maximale y-Koordinate
      */
     public void setPrameters(LinkedList<Line> lines, ArrayList<Point> points, Double xmin, Double xmax, Double ymin, Double ymax) {
         this.lines = new LinkedList<>(lines);
@@ -151,6 +152,7 @@ public class DualityPanel extends JPanel {
 
     /**
      * Hilfmethode für die Zoom-Funktion im Panel
+     *
      * @param component Komponente
      */
     public void addKeyListener(JComponent component) {
@@ -180,6 +182,7 @@ public class DualityPanel extends JPanel {
 
     /**
      * Zoom-Funktionalität für das Panel
+     *
      * @param chartPanel
      */
     protected void addZooming(ChartPanel chartPanel) {
@@ -223,7 +226,7 @@ public class DualityPanel extends JPanel {
              * @param val   Bewegung
              * @param min   minimale Wert
              * @param max   maximale Wert
-             * @return  aktuell Sichtbare Teil des Panels
+             * @return aktuell Sichtbare Teil des Panels
              */
             private DateRange move(Double val, Double min, Double max) {
                 Double minimum = min;

LinearRegressionTool/src/main/java/view/panels/EvaluationPanel.java

@@ -63,6 +63,7 @@ public class EvaluationPanel extends JPanel {
 
     /**
      * Konstruktor
+     *
      * @param view View
      */
     public EvaluationPanel(MainFrame view) {
@@ -186,7 +187,7 @@ public class EvaluationPanel extends JPanel {
 
         TableColumn tm = table.getColumnModel().getColumn(0);
         tm.setCellRenderer(new ColorColumnRenderer(Color.lightGray, Color.blue));
-        for (int i=1;i<4;i++){
+        for (int i = 1; i < 4; i++) {
             DefaultTableCellRenderer rightRenderer = new DefaultTableCellRenderer();
             rightRenderer.setHorizontalAlignment(SwingConstants.RIGHT);
             rightRenderer.setFont(new FontUIResource("Courier", Font.PLAIN, 12));
@@ -210,7 +211,7 @@ public class EvaluationPanel extends JPanel {
             alg = checkSelection();
             n = (Integer) datasetCountChoice.getSelectedItem();
             String datatyp = (String) datasetType.getSelectedItem();
-            if (datatyp == "Import von CSV-Datei"){
+            if (datatyp == "Import von CSV-Datei") {
                 SwingUtilities.invokeLater(() -> {
                     File file = null;
                     JFileChooser chooser = new JFileChooser(FileSystemView.getFileSystemView().getHomeDirectory());
@@ -312,7 +313,7 @@ public class EvaluationPanel extends JPanel {
                         String filename = file.getAbsolutePath().contains(".csv") ? file.getAbsolutePath() : file.getAbsolutePath().concat(".csv");
                         File withExtension = new File(filename);
                         final File input = withExtension;
-                        Thread t = new Thread(() ->((Presenter) view.getPresenter()).startDatasetExportEvaluation(input));
+                        Thread t = new Thread(() -> ((Presenter) view.getPresenter()).startDatasetExportEvaluation(input));
                         t.start();
                     }
                 });
@@ -325,9 +326,9 @@ public class EvaluationPanel extends JPanel {
     /**
      * Fügt der Tabelle eine Spalte hinzu
      *
-     * @param data      Daten der Spalte
+     * @param data    Daten der Spalte
-     * @param col       Spalte
+     * @param col     Spalte
-     * @param isLabel   <code>true</code>, falls es sich um die Approximations Überschriften handelt
+     * @param isLabel <code>true</code>, falls es sich um die Approximations Überschriften handelt
      */
     public void addColumn(Object[] data, int col, boolean isLabel) {
         if (isLabel) {
@@ -343,6 +344,7 @@ public class EvaluationPanel extends JPanel {
 
     /**
      * Fügt der Tabelle eine Zeile hinzu
+     *
      * @param data Daten der Zeile
      */
     public void addRow(Object[] data) {
@@ -358,6 +360,7 @@ public class EvaluationPanel extends JPanel {
 
     /**
      * Visualisierung der Ausgleichsgeraden
+     *
      * @param alg Steigung und y-Achsenabschnitt der Geraden, bestimmt durch die Schätzer
      */
     public void drawLines(ArrayList<Double[]> alg) {
@@ -374,8 +377,9 @@ public class EvaluationPanel extends JPanel {
 
     /**
      * Visualisierung der Ausgleichsgerade
-     * @param results   Steigung und y-Achsenabschnitt der Gerade, bestimmt durch die Schätzer
+     *
-     * @param alg       identifizierung des Alg.
+     * @param results Steigung und y-Achsenabschnitt der Gerade, bestimmt durch die Schätzer
+     * @param alg     identifizierung des Alg.
      */
     public void drawLines(Object[] results, int alg) {
         String[] castedResults = Arrays.copyOf(results, results.length, String[].class);
@@ -394,6 +398,7 @@ public class EvaluationPanel extends JPanel {
 
     /**
      * Visualisierung der dualen Geraden (Eingabemenge)
+     *
      * @param points Liste der Geraden
      */
     public void setDualPoints(LinkedList<Line> points) {
@@ -407,6 +412,7 @@ public class EvaluationPanel extends JPanel {
 
     /**
      * Hilfsmethode
+     *
      * @param n Anzahl der leeren Zeilen
      */
     private void addBlankRows(int n) {
@@ -418,6 +424,7 @@ public class EvaluationPanel extends JPanel {
 
     /**
      * Hilfsmethode
+     *
      * @param val Anzahl der Zeilen die noch hinzugefügt werden
      */
     public void setCurrentRow(int val) {

LinearRegressionTool/src/main/java/view/panels/InfoPanel.java

@@ -38,6 +38,7 @@ public class InfoPanel extends JPanel {
 
     /**
      * Fügt eine Text dem Panel als Paragraph hinzu
+     *
      * @param p Übergebener Text
      */
     public void appendParagraph(String p) {
@@ -47,6 +48,7 @@ public class InfoPanel extends JPanel {
 
     /**
      * Fügt eine Überschrift dem Panel hinzu
+     *
      * @param h1 Überschrift
      */
     public void appendParagraphWithHeading(String h1) {
@@ -56,6 +58,7 @@ public class InfoPanel extends JPanel {
 
     /**
      * Fügt einen Text in roter Schrift als Paragraph dem Panel hinzu
+     *
      * @param p Text
      */
     public void appendParagraphRed(String p) {
@@ -65,6 +68,7 @@ public class InfoPanel extends JPanel {
 
     /**
      * Fügt einen Text in grüner Schrift als Paragraph dem Panel hinzu
+     *
      * @param p Text
      */
     public void appendParagraphGreen(String p) {
@@ -74,8 +78,9 @@ public class InfoPanel extends JPanel {
 
     /**
      * Fügt eine Tabelle mit Werten dem Panel hinzu
-     * @param heading   Überschriften
+     *
-     * @param rows      Liste von Daten pro Zeile
+     * @param heading Überschriften
+     * @param rows    Liste von Daten pro Zeile
      */
     public void logTable(List<String> heading, List<List<String>> rows) {
         content.append("<center>");

LinearRegressionTool/src/main/java/view/panels/PlotPanel.java

@@ -48,7 +48,8 @@ public class PlotPanel extends JPanel {
 
     /**
      * Erzeugen des Plots
-     * @param points    Liste der Geraden
+     *
+     * @param points Liste der Geraden
      */
     public void createPlot(LinkedList<Line> points) {
         if (!points.isEmpty()) {
@@ -103,10 +104,11 @@ public class PlotPanel extends JPanel {
 
     /**
      * Fügt eine Gerade zum Plot hinzu
-     * @param m         Steigung
+     *
-     * @param b         y-Achsenabschnitt
+     * @param m     Steigung
-     * @param color     Farbe
+     * @param b     y-Achsenabschnitt
-     * @param name      Bezeichner
+     * @param color Farbe
+     * @param name  Bezeichner
      */
     public void addLineToPlot(double m, double b, Paint color, String name) {
 
@@ -125,9 +127,10 @@ public class PlotPanel extends JPanel {
 
     /**
      * Fügt eine Gerade zum Plot hinzu
-     * @param m         Steigung
+     *
-     * @param b         y-Achsenabschnitt
+     * @param m    Steigung
-     * @param name      Bezeichner
+     * @param b    y-Achsenabschnitt
+     * @param name Bezeichner
      */
     public void addLineToPlot(double m, double b, String name) {
         XYSeries linesA = new XYSeries(name);
@@ -144,6 +147,7 @@ public class PlotPanel extends JPanel {
 
     /**
      * Wandelt die Daten in ein passendes Format um
+     *
      * @param points Liste der Geraden
      */
     private void convertData(LinkedList<Line> points) {

LinearRegressionTool/src/main/java/view/panels/tabs/LMSPanel.java

@@ -69,8 +69,9 @@ public class LMSPanel extends TabPanel {
 
     /**
      * Hilftmethode um einen Botton an die passende Stelle zu platzieren
-     * @param row       Zeile
+     *
-     * @param button    Button
+     * @param row    Zeile
+     * @param button Button
      */
     private void addButton(int row, JButton button) {
         JPanel buttonPanel = new JPanel();
@@ -89,7 +90,8 @@ public class LMSPanel extends TabPanel {
 
     /**
      * Liefert die Eingaben in Form eines Feldes zurück. Die Parameter werden für den Alg. benötigt.
-     * @return  Eingabe
+     *
+     * @return Eingabe
      */
     public String[] getInput() {
         String[] input = new String[3];

LinearRegressionTool/src/main/java/view/panels/tabs/RMPanel.java

@@ -77,6 +77,7 @@ public class RMPanel extends TabPanel {
 
     /**
      * Liefert die Eingabe zurück. Der Parameter wird für den Alg. benötigt.
+     *
      * @return Eingabe
      */
     public String getInput() {

LinearRegressionTool/src/main/java/view/panels/tabs/TabPanel.java

@@ -46,9 +46,10 @@ public abstract class TabPanel extends JPanel {
 
     /**
      * Fügt in eine Zeile ein Überschrift(JLabel) und eine Eingabekomponente(JTextField)
-     * @param row       Zeile
+     *
-     * @param name      Überschrift
+     * @param row   Zeile
-     * @param value     Standardwert
+     * @param name  Überschrift
+     * @param value Standardwert
      */
     protected void addTextfieldAndInput(int row, String name, Double value) {
         //muss nicht obligatorisch implementiert werden
@@ -56,6 +57,7 @@ public abstract class TabPanel extends JPanel {
 
     /**
      * Hilftmethode um den Plotpanel erst bei Vorhandenen Ergebnissen hinzufügen zu können
+     *
      * @param plotPanel Plotpanel
      */
     public void setPlotPanel(PlotPanel plotPanel) {
@@ -70,21 +72,21 @@ public abstract class TabPanel extends JPanel {
     }
 
     /**
-     * @return  gibt den Startbutton zurück
+     * @return gibt den Startbutton zurück
      */
     public JButton getStartButton() {
         return startButton;
     }
 
     /**
-     * @return  gibt das obere Panel zurück
+     * @return gibt das obere Panel zurück
      */
     public JPanel getNorthPanel() {
         return northPanel;
     }
 
     /**
-     * @return  gibt das untere Panel zurück
+     * @return gibt das untere Panel zurück
      */
     public JPanel getCenterPanel() {
         return centerPanel;
@@ -92,8 +94,9 @@ public abstract class TabPanel extends JPanel {
 
     /**
      * Hilfmethode zum prüfen ob die Eingabe numerisch ist.
-     * @param str   Eingabe
+     *
-     * @return  <code>true</code>, falls es sich bei der Eingabe um numerische Werte handelt
+     * @param str Eingabe
+     * @return <code>true</code>, falls es sich bei der Eingabe um numerische Werte handelt
      */
     public boolean isNumeric(String str) {
         try {