diff --git a/src/main/java/Presenter/Algorithms/TheilSenEstimator.java b/src/main/java/Presenter/Algorithms/TheilSenEstimator.java
index 69e7e56..3045248 100644
--- a/src/main/java/Presenter/Algorithms/TheilSenEstimator.java
+++ b/src/main/java/Presenter/Algorithms/TheilSenEstimator.java
@@ -127,8 +127,13 @@ public class TheilSenEstimator extends Observable implements Algorithm {
      * @return Boolscher Wert ob die Bedingung erfüllt ist
      */
     private Boolean checkCondition() {
-        Double kthElement = FastElementSelector.randomizedSelect(xCoordinates, k);
-        Boolean cond1 = (kthElement > aVariant) && (kthElement <= bVariant);
+        //Double kthElement = FastElementSelector.randomizedSelect(xCoordinates, k);
+        //Boolean cond1 = (kthElement > aVariant) && (kthElement <= bVariant);
+        Boolean conda = k > getIntervalSize(NEGATIV_INF, aVariant, setOfIntersections);
+        Boolean condb = k <= getIntervalSize(NEGATIV_INF, bVariant, setOfIntersections);
+
+        Boolean cond1 = conda && condb;
+
         Boolean cond2 = (getIntervalSize(aVariant+1, bVariant+1, intervalIntersections) <= ((11 * N) / Math.sqrt(r)));
 
         return cond1 && cond2;
diff --git a/src/main/java/Presenter/Evaluation/EvaluateAlgorithms.java b/src/main/java/Presenter/Evaluation/EvaluateAlgorithms.java
index 08ae9f9..f761c64 100644
--- a/src/main/java/Presenter/Evaluation/EvaluateAlgorithms.java
+++ b/src/main/java/Presenter/Evaluation/EvaluateAlgorithms.java
@@ -1,8 +1,8 @@
 package Presenter.Evaluation;
 
-import Model.LineModel;
 import Model.Interval;
 import Model.Line;
+import Model.LineModel;
 import Presenter.Algorithms.*;
 import Presenter.Generator.DatasetGenerator;
 
@@ -18,7 +18,11 @@ import java.util.Observable;
  * @Email: a_wolf28@uni-muenster.de
  * @Date: 01.08.2017.
  */
-public class EvaluateAlgorithms extends Observable{
+public class EvaluateAlgorithms extends Observable {
+
+    private Double m;
+    private Double b;
+    private Integer iterationCount;
 
     private LineModel arrangement;
     private Object[] lmsResult;
@@ -29,79 +33,98 @@ public class EvaluateAlgorithms extends Observable{
     private Thread rmThread;
     private Thread tsThread;
 
-    public EvaluateAlgorithms(){}
+    public EvaluateAlgorithms(Double m, Double b, Integer iterationCount) {
+        this.m = m;
+        this.b = b;
+        this.iterationCount = iterationCount;
+    }
+
+    public EvaluateAlgorithms(){
+        this.m = null;
+        this.b = null;
+        this.iterationCount = 1;
+    }
 
     public void run() throws InterruptedException {
 
-        this.arrangement = new LineModel();
+        for (int i = 0; i < iterationCount; i++) {
+            this.arrangement = new LineModel();
 
-        DatasetGenerator generator = new DatasetGenerator();
-        arrangement.setLines(generator.generateDataset());
+            DatasetGenerator generator;
 
-        IntersectionCounter counter = new IntersectionCounter();
-        counter.run(arrangement.getLines(), new Interval(-99999,99999));
-        counter.calculateIntersectionAbscissas(arrangement);
+            if (m != null && b != null) {
+                generator = new DatasetGenerator(m, b);
+            } else {
+                generator = new DatasetGenerator();
+            }
+
+            arrangement.setLines(generator.generateDataset());
+
+            IntersectionCounter counter = new IntersectionCounter();
+            counter.run(arrangement.getLines(), new Interval(-99999, 99999));
+            counter.calculateIntersectionAbscissas(arrangement);
 
 
-        lmsThread = new Thread(() -> {
-            LeastMedianOfSquaresEstimator lmsAlg = new LeastMedianOfSquaresEstimator(arrangement.getLines()
-                                                                                    ,arrangement.getNodes());
-            lmsAlg.run();
-            lmsAlg.getResult();
-            List<Double> errors = sampsonError(arrangement.getLines(), lmsAlg.getSlope(), lmsAlg.getyInterception());
-            lmsResult = getResults(errors, "Least Median of Squares");
-            setChanged();
-            notifyObservers(lmsResult);
-        });
-        rmThread = new Thread(() -> {
-            RepeatedMedianEstimator rmAlg = new RepeatedMedianEstimator(arrangement.getLines());
-            rmAlg.run();
-            rmAlg.getResult();
-            List<Double> errors = sampsonError(arrangement.getLines(), rmAlg.getSlope(), rmAlg.getyInterception());
-            rmResult = getResults(errors, "Repeated-Median");
-            setChanged();
-            notifyObservers(rmResult);
-        });
-        tsThread = new Thread(() -> {
-            TheilSenEstimator tsAlg = new TheilSenEstimator(arrangement.getLines(), arrangement.getNodes());
-            tsAlg.run();
-            tsAlg.getResult();
-            List<Double> errors = sampsonError(arrangement.getLines(), tsAlg.getSlope(), tsAlg.getyInterception());
-            tsResult = getResults(errors, "Theil-Sen");
-            setChanged();
-            notifyObservers(tsResult);
-        });
+            lmsThread = new Thread(() -> {
+                LeastMedianOfSquaresEstimator lmsAlg = new LeastMedianOfSquaresEstimator(arrangement.getLines()
+                        , arrangement.getNodes());
+                lmsAlg.run();
+                lmsAlg.getResult();
+                List<Double> errors = sampsonError(arrangement.getLines(), lmsAlg.getSlope(), lmsAlg.getyInterception());
+                lmsResult = getResults(errors, "Least Median of Squares");
+                setChanged();
+                notifyObservers(lmsResult);
+            });
+            rmThread = new Thread(() -> {
+                RepeatedMedianEstimator rmAlg = new RepeatedMedianEstimator(arrangement.getLines());
+                rmAlg.run();
+                rmAlg.getResult();
+                List<Double> errors = sampsonError(arrangement.getLines(), rmAlg.getSlope(), rmAlg.getyInterception());
+                rmResult = getResults(errors, "Repeated-Median");
+                setChanged();
+                notifyObservers(rmResult);
+            });
+            tsThread = new Thread(() -> {
+                TheilSenEstimator tsAlg = new TheilSenEstimator(arrangement.getLines(), arrangement.getNodes());
+                tsAlg.run();
+                tsAlg.getResult();
+                List<Double> errors = sampsonError(arrangement.getLines(), tsAlg.getSlope(), tsAlg.getyInterception());
+                tsResult = getResults(errors, "Theil-Sen");
+                setChanged();
+                notifyObservers(tsResult);
+            });
 
-        lmsThread.start();
-        rmThread.start();
-        tsThread.start();
-
-        lmsThread.join();
-        rmThread.join();
-        tsThread.join();
+            lmsThread.start();
+            rmThread.start();
+            tsThread.start();
 
+            lmsThread.join();
+            rmThread.join();
+            tsThread.join();
+        }
     }
 
 
-    public String[] getResults(List<Double> errorValues, String name){
+    public String[] getResults(List<Double> errorValues, String name) {
 
-        String[] ret = new String[6];
-        ret[0] = name;
-        ret[1] = mse(errorValues).toString();
-        ret[2] = rmse(errorValues).toString();
-        ret[3] = mae(errorValues).toString();
-        ret[4] = mdae(errorValues).toString();
-        ret[5] = "eval";
+        ArrayList<String> ret = new ArrayList<>();
+        ret.add("eval");
+        ret.add(name);
+        ret.add(mse(errorValues).toString());
+        ret.add(rmse(errorValues).toString());
+        ret.add(mae(errorValues).toString());
+        ret.add(mdae(errorValues).toString());
 
-        return ret;
+
+        return ret.stream().toArray(String[]::new);
     }
 
     /* Skalierungs Abhängige Approximationsgüten */
-    public Double mse(List<Double> errorValues){
+    public Double mse(List<Double> errorValues) {
         double error = 0;
 
-        for (Double d : errorValues){
-            error += Math.pow(d,2);
+        for (Double d : errorValues) {
+            error += Math.pow(d, 2);
         }
 
         error /= errorValues.size();
@@ -109,14 +132,14 @@ public class EvaluateAlgorithms extends Observable{
         return error;
     }
 
-    public Double rmse(List<Double> errorValues){
+    public Double rmse(List<Double> errorValues) {
         return Math.sqrt(mse(errorValues));
     }
 
-    public Double mae(List<Double> errorValues){
+    public Double mae(List<Double> errorValues) {
         double error = 0;
 
-        for (Double d : errorValues){
+        for (Double d : errorValues) {
             error += Math.abs(d);
         }
 
@@ -125,18 +148,18 @@ public class EvaluateAlgorithms extends Observable{
         return error;
     }
 
-    public Double mdae(List<Double> errorValues){
-        return FastElementSelector.randomizedSelect((ArrayList<Double>) errorValues, errorValues.size()*0.5);
+    public Double mdae(List<Double> errorValues) {
+        return FastElementSelector.randomizedSelect((ArrayList<Double>) errorValues, errorValues.size() * 0.5);
     }
 
 
-    public List<Double> sampsonError(final LinkedList<Line> lines, Double m, Double b){
+    public List<Double> sampsonError(final LinkedList<Line> lines, Double m, Double b) {
 
         //Liste mit den Fehler zu jedem Punkt
         List<Double> sampsonerror = new ArrayList<>();
 
-        for (Line line : lines){
-            Double error = Math.pow(m * line.getM() - line.getB() + b, 2) / (Math.pow(m,2) + 1);
+        for (Line line : lines) {
+            Double error = Math.pow(m * line.getM() - line.getB() + b, 2) / (Math.pow(m, 2) + 1);
             sampsonerror.add(error);
         }
 
diff --git a/src/main/java/Presenter/Generator/DatasetGenerator.java b/src/main/java/Presenter/Generator/DatasetGenerator.java
index ec7df2e..f053983 100644
--- a/src/main/java/Presenter/Generator/DatasetGenerator.java
+++ b/src/main/java/Presenter/Generator/DatasetGenerator.java
@@ -14,17 +14,29 @@ import java.util.Random;
  */
 public class DatasetGenerator {
 
+    private Double m;
+    private Double b;
+    private Random random;
 
-    public DatasetGenerator(){}
+    public DatasetGenerator(Double m, Double b){
+        this.m = m;
+        this.b = b;
+        random = new Random();
+        random.setSeed(9999);
+    }
+
+    public DatasetGenerator(){
+        random = new Random();
+        random.setSeed(9999);
+        m = 1 + random.nextDouble();
+        b = random.nextDouble();
+    }
 
 
     public LinkedList<Line> generateDataset(){
         LinkedList<Line> lines = new LinkedList<>();
-        Random random = new Random();
-        random.setSeed(9999);
 
-        double m = 1 + random.nextDouble();
-        double b = random.nextDouble();
+
 
         for (int i=1;i<101;i++){
             double y = (random.nextGaussian() * 100) % 100;
diff --git a/src/main/java/Presenter/Presenter.java b/src/main/java/Presenter/Presenter.java
index dc32f2a..4d0674e 100644
--- a/src/main/java/Presenter/Presenter.java
+++ b/src/main/java/Presenter/Presenter.java
@@ -44,9 +44,6 @@ public class Presenter implements Observer {
   public Presenter(LineModel model, MainFrame view) {
     this.model = model;
     this.view = view;
-
-    eval = new EvaluateAlgorithms();
-    eval.addObserver(this);
   }
 
 
@@ -54,7 +51,7 @@ public class Presenter implements Observer {
   public void update(Observable o, Object arg) {
     String[] result = ((String[]) arg);
 
-    if (result.length  > 3){
+    if (result[0] == "eval"){
       SwingUtilities.invokeLater(() -> {
         getView().appendEvalResult(result);
       });
@@ -273,11 +270,27 @@ public class Presenter implements Observer {
     }
   }
 
-  public void startEvaluation(){
+  public void startEvaluation(String[] args){
 
     if (evalThread == null || !evalThread.isAlive()){
       evalThread = new Thread(() ->{
+        Double m = null;
+        Double b = null;
+        Integer i = null;
+
+        if (!(args[0].isEmpty() && args[1].isEmpty() && args[2].isEmpty())) {
+          m = Double.parseDouble(args[0]);
+          b = Double.parseDouble(args[1]);
+          i = Integer.parseInt(args[2]);
+        }
+
         try {
+          if (m != null && b!=  null && i != null) {
+            eval = new EvaluateAlgorithms(m, b, i);
+          }else {
+            eval = new EvaluateAlgorithms();
+          }
+          eval.addObserver(this);
           eval.run();
         } catch (InterruptedException e) {
           e.printStackTrace();
diff --git a/src/main/java/View/MainFrame.java b/src/main/java/View/MainFrame.java
index 02b8749..c4b3767 100644
--- a/src/main/java/View/MainFrame.java
+++ b/src/main/java/View/MainFrame.java
@@ -11,6 +11,7 @@ import java.awt.*;
 import java.awt.event.ActionEvent;
 import java.io.File;
 import java.io.IOException;
+import java.util.Arrays;
 import java.util.List;
 
 /**
@@ -150,8 +151,8 @@ public class MainFrame extends JFrame {
 
   public void appendEvalResult(Object[] res){
     SwingUtilities.invokeLater(() -> {
-      Object[] tmp = res;
-      evaluationPanel.appendData(res);
+      Object[] tmp = Arrays.asList(res).subList(1,res.length).toArray();
+      evaluationPanel.appendData(tmp);
       evaluationPanel.repaint();
       evaluationPanel.revalidate();
     });
diff --git a/src/main/java/View/Panels/EvaluationPanel.java b/src/main/java/View/Panels/EvaluationPanel.java
index 4340d16..82174c4 100644
--- a/src/main/java/View/Panels/EvaluationPanel.java
+++ b/src/main/java/View/Panels/EvaluationPanel.java
@@ -49,7 +49,7 @@ public class EvaluationPanel extends JPanel{
 
         buttonPanel = new JPanel(new FlowLayout());
         buttonPanel.add(start);
-        buttonPanel.add(stop);
+        //buttonPanel.add(stop);
 
         comp = new JPanel();
         comp.setLayout(new GridLayout(0,2));
@@ -61,7 +61,8 @@ public class EvaluationPanel extends JPanel{
         comp.add(iYinterception);
 
         start.addActionListener(e -> {
-          view.getPresenter().startEvaluation();
+            String[] params = {iSlope.getText(), iYinterception.getText(), iIteration.getText() };
+          view.getPresenter().startEvaluation(params);
         });
 
         stop.addActionListener(e -> {
@@ -69,10 +70,18 @@ public class EvaluationPanel extends JPanel{
         });
 
         String[] selections = { "Schätzer","MSE", "RMSE", "MAE", "MdAE"};
-        model = new DefaultTableModel();
+        model = new DefaultTableModel(){
+            @Override
+            public boolean isCellEditable(int row, int column) {
+                //all cells false
+                return false;
+            }
+        };
         model.setColumnIdentifiers(selections);
 
         table = new JTable(model);
+        table.setDragEnabled(true);
+
         JScrollPane scrollPane = new JScrollPane(table);
         scrollPane.setWheelScrollingEnabled(true);
         this.add(scrollPane, BorderLayout.CENTER);