Index: branches/CEDMA-Refactoring-Ticket419/HeuristicLab.CEDMA.DB.Interfaces/Ontology.cs
===================================================================
--- branches/CEDMA-Refactoring-Ticket419/HeuristicLab.CEDMA.DB.Interfaces/Ontology.cs	(revision 1274)
+++ branches/CEDMA-Refactoring-Ticket419/HeuristicLab.CEDMA.DB.Interfaces/Ontology.cs	(revision 1275)
@@ -116,4 +116,7 @@
       get { return new Entity(CedmaNameSpace + "ValidationMeanSquaredError"); }
     }
+    public static Entity TestMeanSquaredError {
+      get { return new Entity(CedmaNameSpace + "TestMeanSquaredError"); }
+    }
     public static Entity TrainingMeanAbsolutePercentageError {
       get { return new Entity(CedmaNameSpace + "TrainingMeanAbsolutePercentageError"); }
@@ -121,4 +124,43 @@
     public static Entity ValidationMeanAbsolutePercentageError {
       get { return new Entity(CedmaNameSpace + "ValidationMeanAbsolutePercentageError"); }
+    }
+    public static Entity TestMeanAbsolutePercentageError {
+      get { return new Entity(CedmaNameSpace + "TestMeanAbsolutePercentageError"); }
+    }
+    public static Entity TrainingMeanAbsolutePercentageOfRangeError {
+      get { return new Entity(CedmaNameSpace + "TrainingMeanAbsolutePercentageOfRangeError"); }
+    }
+    public static Entity ValidationMeanAbsolutePercentageOfRangeError {
+      get { return new Entity(CedmaNameSpace + "ValidationMeanAbsolutePercentageOfRangeError"); }
+    }
+    public static Entity TestMeanAbsolutePercentageOfRangeError {
+      get { return new Entity(CedmaNameSpace + "TestMeanAbsolutePercentageOfRangeError"); }
+    }
+    public static Entity TrainingCoefficientOfDetermination {
+      get { return new Entity(CedmaNameSpace + "TrainingCoefficientOfDetermination"); }
+    }
+    public static Entity ValidationCoefficientOfDetermination {
+      get { return new Entity(CedmaNameSpace + "ValidationCoefficientOfDetermination"); }
+    }
+    public static Entity TestCoefficientOfDetermination {
+      get { return new Entity(CedmaNameSpace + "TestCoefficientOfDetermination"); }
+    }
+    public static Entity TrainingAccuracy {
+      get { return new Entity(CedmaNameSpace + "TrainingAccuracy"); }
+    }
+    public static Entity ValidationAccuracy {
+      get { return new Entity(CedmaNameSpace + "ValidationAccuracy"); }
+    }
+    public static Entity TestAccuracy {
+      get { return new Entity(CedmaNameSpace + "TestAccuracy"); }
+    }
+    public static Entity TrainingTheilsInequalityCoefficient {
+      get { return new Entity(CedmaNameSpace + "TrainingTheilsInequalityCoefficient"); }
+    }
+    public static Entity ValidationTheilsInequalityCoefficient {
+      get { return new Entity(CedmaNameSpace + "ValidationTheilsInequalityCoefficient"); }
+    }
+    public static Entity TestTheilsInequalityCoefficient {
+      get { return new Entity(CedmaNameSpace + "TestTheilsInequalityCoefficient"); }
     }
     public static Entity TreeSize {
@@ -141,8 +183,37 @@
           new Statement(ValidationMeanSquaredError, PredicateInstanceOf, TypeOrdinalAttribute),
           new Statement(ValidationMeanSquaredError, PredicateInstanceOf, TypeQualityAttribute),
+          new Statement(TestMeanSquaredError, PredicateInstanceOf, TypeOrdinalAttribute),
+          new Statement(TestMeanSquaredError, PredicateInstanceOf, TypeQualityAttribute),
           new Statement(TrainingMeanAbsolutePercentageError, PredicateInstanceOf, TypeOrdinalAttribute),
           new Statement(TrainingMeanAbsolutePercentageError, PredicateInstanceOf, TypeQualityAttribute),
           new Statement(ValidationMeanAbsolutePercentageError, PredicateInstanceOf, TypeOrdinalAttribute),
           new Statement(ValidationMeanAbsolutePercentageError, PredicateInstanceOf, TypeQualityAttribute),
+          new Statement(TestMeanAbsolutePercentageError, PredicateInstanceOf, TypeOrdinalAttribute),
+          new Statement(TestMeanAbsolutePercentageError, PredicateInstanceOf, TypeQualityAttribute),
+          new Statement(TrainingMeanAbsolutePercentageOfRangeError, PredicateInstanceOf, TypeOrdinalAttribute),
+          new Statement(TrainingMeanAbsolutePercentageOfRangeError, PredicateInstanceOf, TypeQualityAttribute),
+          new Statement(ValidationMeanAbsolutePercentageOfRangeError, PredicateInstanceOf, TypeOrdinalAttribute),
+          new Statement(ValidationMeanAbsolutePercentageOfRangeError, PredicateInstanceOf, TypeQualityAttribute),
+          new Statement(TestMeanAbsolutePercentageOfRangeError, PredicateInstanceOf, TypeOrdinalAttribute),
+          new Statement(TestMeanAbsolutePercentageOfRangeError, PredicateInstanceOf, TypeQualityAttribute),
+          new Statement(TrainingCoefficientOfDetermination, PredicateInstanceOf, TypeOrdinalAttribute),
+          new Statement(TrainingCoefficientOfDetermination, PredicateInstanceOf, TypeQualityAttribute),
+          new Statement(ValidationCoefficientOfDetermination, PredicateInstanceOf, TypeOrdinalAttribute),
+          new Statement(ValidationCoefficientOfDetermination, PredicateInstanceOf, TypeQualityAttribute),
+          new Statement(TestCoefficientOfDetermination, PredicateInstanceOf, TypeOrdinalAttribute),
+          new Statement(TestCoefficientOfDetermination, PredicateInstanceOf, TypeQualityAttribute),
+          new Statement(TrainingAccuracy, PredicateInstanceOf, TypeOrdinalAttribute),
+          new Statement(TrainingAccuracy, PredicateInstanceOf, TypeQualityAttribute),
+          new Statement(ValidationAccuracy, PredicateInstanceOf, TypeOrdinalAttribute),
+          new Statement(ValidationAccuracy, PredicateInstanceOf, TypeQualityAttribute),
+          new Statement(TestAccuracy, PredicateInstanceOf, TypeOrdinalAttribute),
+          new Statement(TestAccuracy, PredicateInstanceOf, TypeQualityAttribute),
+          new Statement(TrainingTheilsInequalityCoefficient, PredicateInstanceOf, TypeOrdinalAttribute),
+          new Statement(TrainingTheilsInequalityCoefficient, PredicateInstanceOf, TypeQualityAttribute),
+          new Statement(ValidationTheilsInequalityCoefficient, PredicateInstanceOf, TypeOrdinalAttribute),
+          new Statement(ValidationTheilsInequalityCoefficient, PredicateInstanceOf, TypeQualityAttribute),
+          new Statement(TestTheilsInequalityCoefficient, PredicateInstanceOf, TypeOrdinalAttribute),
+          new Statement(TestTheilsInequalityCoefficient, PredicateInstanceOf, TypeQualityAttribute),
+
           new Statement(TreeSize, PredicateInstanceOf, TypeOrdinalAttribute),
           new Statement(TreeSize, PredicateInstanceOf, TypeComplexityAttribute),
@@ -161,5 +232,4 @@
       get { return new Entity(null); }
     }
-
   }
 }
Index: branches/CEDMA-Refactoring-Ticket419/HeuristicLab.CEDMA.Server/DispatcherBase.cs
===================================================================
--- branches/CEDMA-Refactoring-Ticket419/HeuristicLab.CEDMA.Server/DispatcherBase.cs	(revision 1274)
+++ branches/CEDMA-Refactoring-Ticket419/HeuristicLab.CEDMA.Server/DispatcherBase.cs	(revision 1275)
@@ -49,4 +49,12 @@
     };
 
+    private static int MaxGenerations {
+      get { return 3; }
+    }
+
+    private static int MaxEvaluatedSolutions {
+      get { return 3000; }
+    }
+
     public DispatcherBase(IStore store) {
       this.store = store;
@@ -70,5 +78,5 @@
       DataSet dataSet = new DataSet(store, dataSetEntity);
 
-      int targetVariable = SelectTargetVariable(dataSet, dataSet.Problem.AllowedInputVariables.ToArray());
+      int targetVariable = SelectTargetVariable(dataSet, dataSet.Problem.AllowedTargetVariables.ToArray());
       Algorithm selectedAlgorithm = SelectAlgorithm(dataSet, targetVariable, possibleAlgorithms[dataSet.Problem.LearningTask]);
       string targetVariableName = dataSet.Problem.GetVariableName(targetVariable);
@@ -92,7 +100,8 @@
         case Algorithm.StandardGpRegression: {
             var algo = new HeuristicLab.GP.StructureIdentification.StandardGP();
-            SetGpParameters(algo, complexity);
-            SetProblemParameters(algo, problem, targetVariable);
-            algo.MaxGenerations = 2;
+            SetComplexityParameters(algo, complexity);
+            SetProblemParameters(algo, problem, targetVariable);
+            algo.PopulationSize = 10000;
+            algo.MaxGenerations = MaxGenerations;
             Execution exec = new Execution(algo.Engine);
             exec.Description = "StandardGP - Complexity: " + complexity;
@@ -101,7 +110,7 @@
         case Algorithm.OffspringGpRegression: {
             var algo = new HeuristicLab.GP.StructureIdentification.OffspringSelectionGP();
-            SetGpParameters(algo, complexity);
-            SetProblemParameters(algo, problem, targetVariable);
-            algo.MaxEvaluatedSolutions = 10000;
+            SetComplexityParameters(algo, complexity);
+            SetProblemParameters(algo, problem, targetVariable);
+            algo.MaxEvaluatedSolutions = MaxEvaluatedSolutions;
             Execution exec = new Execution(algo.Engine);
             exec.Description = "OffspringGP - Complexity: " + complexity;
@@ -110,7 +119,8 @@
         case Algorithm.StandardGpClassification: {
             var algo = new HeuristicLab.GP.StructureIdentification.Classification.StandardGP();
-            SetGpParameters(algo, complexity);
-            SetProblemParameters(algo, problem, targetVariable);
-            algo.MaxGenerations = 2;
+            SetComplexityParameters(algo, complexity);
+            SetProblemParameters(algo, problem, targetVariable);
+            algo.PopulationSize = 10000;
+            algo.MaxGenerations = MaxGenerations;
             Execution exec = new Execution(algo.Engine);
             exec.Description = "StandardGP - Complexity: " + complexity;
@@ -119,7 +129,7 @@
         case Algorithm.OffspringGpClassification: {
             var algo = new HeuristicLab.GP.StructureIdentification.Classification.OffspringSelectionGP();
-            SetGpParameters(algo, complexity);
-            SetProblemParameters(algo, problem, targetVariable);
-            algo.MaxEvaluatedSolutions = 10000;
+            SetComplexityParameters(algo, complexity);
+            SetProblemParameters(algo, problem, targetVariable);
+            algo.MaxEvaluatedSolutions = MaxEvaluatedSolutions;
             Execution exec = new Execution(algo.Engine);
             exec.Description = "OffspringGP - Complexity: " + complexity;
@@ -128,7 +138,8 @@
         case Algorithm.StandardGpForecasting: {
             var algo = new HeuristicLab.GP.StructureIdentification.TimeSeries.StandardGP();
-            SetGpParameters(algo, complexity);
-            SetProblemParameters(algo, problem, targetVariable);
-            algo.MaxGenerations = 2;
+            SetComplexityParameters(algo, complexity);
+            SetProblemParameters(algo, problem, targetVariable);
+            algo.PopulationSize = 10000;
+            algo.MaxGenerations = MaxGenerations;
             Execution exec = new Execution(algo.Engine);
             exec.Description = "StandardGP - Complexity: " + complexity;
@@ -137,7 +148,7 @@
         case Algorithm.OffspringGpForecasting: {
             var algo = new HeuristicLab.GP.StructureIdentification.TimeSeries.OffspringSelectionGP();
-            SetGpParameters(algo, complexity);
-            SetProblemParameters(algo, problem, targetVariable);
-            algo.MaxEvaluatedSolutions = 10000;
+            SetComplexityParameters(algo, complexity);
+            SetProblemParameters(algo, problem, targetVariable);
+            algo.MaxEvaluatedSolutions = MaxEvaluatedSolutions;
             Execution exec = new Execution(algo.Engine);
             exec.Description = "OffspringGP - Complexity: " + complexity;
@@ -150,8 +161,5 @@
     }
 
-    private void SetGpParameters(AlgorithmBase algo, ModelComplexity complexity) {
-      algo.SetSeedRandomly = true;
-      algo.PopulationSize = 1000;
-      algo.Elites = 1;
+    private void SetComplexityParameters(AlgorithmBase algo, ModelComplexity complexity) {
       switch (complexity) {
         case ModelComplexity.Low: {
@@ -196,5 +204,5 @@
 
     private IEnumerable<double> GetDifferentClassValues(HeuristicLab.DataAnalysis.Dataset dataset, int targetVariable) {
-      throw new NotImplementedException();
+      return Enumerable.Range(0, dataset.Rows).Select(x => dataset.GetValue(x, targetVariable)).Distinct();
     }
   }
Index: branches/CEDMA-Refactoring-Ticket419/HeuristicLab.CEDMA.Server/Executer.cs
===================================================================
--- branches/CEDMA-Refactoring-Ticket419/HeuristicLab.CEDMA.Server/Executer.cs	(revision 1274)
+++ branches/CEDMA-Refactoring-Ticket419/HeuristicLab.CEDMA.Server/Executer.cs	(revision 1275)
@@ -133,14 +133,33 @@
       StoreModelAttribute(model, Ontology.TargetVariable, finishedExecution.TargetVariable);
       Scope bestModelScope = finishedEngine.GlobalScope.GetVariableValue<Scope>("BestValidationSolution", false);
-      StoreModelAttribute(model, Ontology.TrainingMeanSquaredError, bestModelScope.GetVariableValue<DoubleData>("Quality", false).Data);
-      StoreModelAttribute(model, Ontology.ValidationMeanSquaredError, bestModelScope.GetVariableValue<DoubleData>("ValidationQuality", false).Data);
-      StoreModelAttribute(model, Ontology.TrainingMeanAbsolutePercentageError, bestModelScope.GetVariableValue<DoubleData>("TrainingMAPE", false).Data);
-      StoreModelAttribute(model, Ontology.ValidationMeanAbsolutePercentageError, bestModelScope.GetVariableValue<DoubleData>("ValidationMAPE", false).Data);
-      StoreModelAttribute(model, Ontology.TreeSize, bestModelScope.GetVariableValue<IntData>("TreeSize", false).Data);
-      StoreModelAttribute(model, Ontology.TreeHeight, bestModelScope.GetVariableValue<IntData>("TreeHeight", false).Data);
-      StoreModelAttribute(model, Ontology.EvaluatedSolutions, bestModelScope.GetVariableValue<IntData>("EvaluatedSolutions", false).Data);
+      StoreModelVariable(model, Ontology.TrainingMeanSquaredError, bestModelScope, "Quality");
+      StoreModelVariable(model, Ontology.ValidationMeanSquaredError, bestModelScope, "ValidationQuality");
+      StoreModelVariable(model, Ontology.TestMeanSquaredError, bestModelScope, "TestQuality");
+      StoreModelVariable(model, Ontology.TrainingMeanAbsolutePercentageError, bestModelScope, "TrainingMAPE");
+      StoreModelVariable(model, Ontology.ValidationMeanAbsolutePercentageError, bestModelScope, "ValidationMAPE");
+      StoreModelVariable(model, Ontology.TestMeanAbsolutePercentageError, bestModelScope, "TestMAPE");
+      StoreModelVariable(model, Ontology.TrainingMeanAbsolutePercentageOfRangeError, bestModelScope, "TrainingMAPRE");
+      StoreModelVariable(model, Ontology.ValidationMeanAbsolutePercentageOfRangeError, bestModelScope, "ValidationMAPRE");
+      StoreModelVariable(model, Ontology.TestMeanAbsolutePercentageOfRangeError, bestModelScope, "TestMAPRE");
+      StoreModelVariable(model, Ontology.TrainingCoefficientOfDetermination, bestModelScope, "TrainingR2");
+      StoreModelVariable(model, Ontology.ValidationCoefficientOfDetermination, bestModelScope, "ValidationR2");
+      StoreModelVariable(model, Ontology.TestCoefficientOfDetermination, bestModelScope, "TestR2");
+      StoreModelVariable(model, Ontology.TrainingTheilsInequalityCoefficient, bestModelScope, "TrainingTheilInequalityCoefficient");
+      StoreModelVariable(model, Ontology.ValidationTheilsInequalityCoefficient, bestModelScope, "ValidationTheilInequalityCoefficient");
+      StoreModelVariable(model, Ontology.TestTheilsInequalityCoefficient, bestModelScope, "TestTheilInequalityCoefficient");
+      StoreModelVariable(model, Ontology.TrainingAccuracy, bestModelScope, "TrainingAccuracy");
+      StoreModelVariable(model, Ontology.ValidationAccuracy, bestModelScope, "ValidationAccuracy");
+      StoreModelVariable(model, Ontology.TestAccuracy, bestModelScope, "TestAccuracy");
+      StoreModelVariable(model, Ontology.TreeSize, bestModelScope, "TreeSize");
+      StoreModelVariable(model, Ontology.TreeHeight, bestModelScope, "TreeHeight");
+      StoreModelVariable(model, Ontology.EvaluatedSolutions, bestModelScope, "EvaluatedSolutions");
 
       byte[] serializedModel = PersistenceManager.SaveToGZip(bestModelScope.GetVariableValue("FunctionTree", false));
       store.Add(new Statement(model, Ontology.PredicateSerializedData, new Literal(Convert.ToBase64String(serializedModel))));
+    }
+
+    private void StoreModelVariable(Entity model, Entity entity, Scope scope, string variableName) {
+      if (scope.GetVariable(variableName) != null)
+        StoreModelAttribute(model, entity, scope.GetVariableValue<ObjectData>(variableName, false).Data);
     }
 
@@ -154,5 +173,5 @@
         int i = 0;
         foreach (Execution e in activeExecutions.Values) {
-          retVal[i++] = "Target-Variable: "+e.TargetVariable+" "+e.Description;
+          retVal[i++] = "Target-Variable: " + e.TargetVariable + " " + e.Description;
         }
         return retVal;
Index: branches/CEDMA-Refactoring-Ticket419/HeuristicLab.GP.StructureIdentification/AlgorithmBase.cs
===================================================================
--- branches/CEDMA-Refactoring-Ticket419/HeuristicLab.GP.StructureIdentification/AlgorithmBase.cs	(revision 1274)
+++ branches/CEDMA-Refactoring-Ticket419/HeuristicLab.GP.StructureIdentification/AlgorithmBase.cs	(revision 1275)
@@ -108,4 +108,13 @@
       engine.OperatorGraph.AddOperator(algo);
       engine.OperatorGraph.InitialOperator = algo;
+      SetSeedRandomly = true;
+      Elites = 1;
+      MutationRate = 0.15;
+      PopulationSize = 1000;
+      MaxTreeSize = 100;
+      MaxTreeHeight = 10;
+      Parents = 2000;
+      PunishmentFactor = 10;
+      UseEstimatedTargetValue = false;
     }
 
Index: branches/CEDMA-Refactoring-Ticket419/HeuristicLab.GP.StructureIdentification/StandardGP.cs
===================================================================
--- branches/CEDMA-Refactoring-Ticket419/HeuristicLab.GP.StructureIdentification/StandardGP.cs	(revision 1274)
+++ branches/CEDMA-Refactoring-Ticket419/HeuristicLab.GP.StructureIdentification/StandardGP.cs	(revision 1275)
@@ -58,4 +58,19 @@
     }
 
+    public int MinInitialTreeSize {
+      get { return GetVariableInjector().GetVariable("MinInitialTreeSize").GetValue<IntData>().Data; }
+      set { GetVariableInjector().GetVariable("MinInitialTreeSize").GetValue<IntData>().Data = value; }
+    }
+
+    public override int MaxTreeSize {
+      get {
+        return base.MaxTreeSize;
+      }
+      set {
+        base.MaxTreeSize = value;
+        MinInitialTreeSize = value / 2;
+      }
+    }
+
     public override int PopulationSize {
       get {
@@ -104,4 +119,5 @@
       globalInjector.AddVariable(new HeuristicLab.Core.Variable("FullTreeShakingFactor", new DoubleData()));
       globalInjector.AddVariable(new HeuristicLab.Core.Variable("OnePointShakingFactor", new DoubleData()));
+      globalInjector.AddVariable(new HeuristicLab.Core.Variable("MinInitialTreeSize", new IntData()));
       return globalInjector;
     }
@@ -118,6 +134,5 @@
       treeCreator.Name = "Tree generator";
       treeCreator.GetVariableInfo("OperatorLibrary").ActualName = "FunctionLibrary";
-      treeCreator.GetVariableInfo("MinTreeSize").Local = true;
-      treeCreator.AddVariable(new HeuristicLab.Core.Variable("MinTreeSize", new IntData(30)));
+      treeCreator.GetVariableInfo("MinTreeSize").ActualName = "MinInitialTreeSize";
       return treeCreator;
     }
@@ -169,4 +184,9 @@
     protected internal override IOperator CreateBestSolutionProcessor() {
       SequentialProcessor bestSolutionProcessor = new SequentialProcessor();
+      MeanSquaredErrorEvaluator testMseEvaluator = new MeanSquaredErrorEvaluator();
+      testMseEvaluator.Name = "TestMeanSquaredErrorEvaluator";
+      testMseEvaluator.GetVariableInfo("MSE").ActualName = "TestQuality";
+      testMseEvaluator.GetVariableInfo("SamplesStart").ActualName = "TestSamplesStart";
+      testMseEvaluator.GetVariableInfo("SamplesEnd").ActualName = "TestSamplesEnd";
       MeanAbsolutePercentageErrorEvaluator trainingMapeEvaluator = new MeanAbsolutePercentageErrorEvaluator();
       trainingMapeEvaluator.Name = "TrainingMapeEvaluator";
@@ -179,4 +199,9 @@
       validationMapeEvaluator.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
       validationMapeEvaluator.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
+      MeanAbsolutePercentageErrorEvaluator testMapeEvaluator = new MeanAbsolutePercentageErrorEvaluator();
+      testMapeEvaluator.Name = "TestMapeEvaluator";
+      testMapeEvaluator.GetVariableInfo("MAPE").ActualName = "TestMAPE";
+      testMapeEvaluator.GetVariableInfo("SamplesStart").ActualName = "TestSamplesStart";
+      testMapeEvaluator.GetVariableInfo("SamplesEnd").ActualName = "TestSamplesEnd";
       MeanAbsolutePercentageOfRangeErrorEvaluator trainingMapreEvaluator = new MeanAbsolutePercentageOfRangeErrorEvaluator();
       trainingMapreEvaluator.Name = "TrainingMapreEvaluator";
@@ -189,4 +214,24 @@
       validationMapreEvaluator.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
       validationMapreEvaluator.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
+      MeanAbsolutePercentageOfRangeErrorEvaluator testMapreEvaluator = new MeanAbsolutePercentageOfRangeErrorEvaluator();
+      testMapreEvaluator.Name = "TestMapreEvaluator";
+      testMapreEvaluator.GetVariableInfo("MAPRE").ActualName = "TestMAPRE";
+      testMapreEvaluator.GetVariableInfo("SamplesStart").ActualName = "TestSamplesStart";
+      testMapreEvaluator.GetVariableInfo("SamplesEnd").ActualName = "TestSamplesEnd";
+      CoefficientOfDeterminationEvaluator trainingR2Evaluator = new CoefficientOfDeterminationEvaluator();
+      trainingR2Evaluator.Name = "TrainingR2Evaluator";
+      trainingR2Evaluator.GetVariableInfo("R2").ActualName = "TrainingR2";
+      trainingR2Evaluator.GetVariableInfo("SamplesStart").ActualName = "TrainingSamplesStart";
+      trainingR2Evaluator.GetVariableInfo("SamplesEnd").ActualName = "TrainingSamplesEnd";
+      CoefficientOfDeterminationEvaluator validationR2Evaluator = new CoefficientOfDeterminationEvaluator();
+      validationR2Evaluator.Name = "ValidationR2Evaluator";
+      validationR2Evaluator.GetVariableInfo("R2").ActualName = "ValidationR2";
+      validationR2Evaluator.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
+      validationR2Evaluator.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
+      CoefficientOfDeterminationEvaluator testR2Evaluator = new CoefficientOfDeterminationEvaluator();
+      testR2Evaluator.Name = "TestR2Evaluator";
+      testR2Evaluator.GetVariableInfo("R2").ActualName = "TestR2";
+      testR2Evaluator.GetVariableInfo("SamplesStart").ActualName = "TestSamplesStart";
+      testR2Evaluator.GetVariableInfo("SamplesEnd").ActualName = "TestSamplesEnd";
       ProgrammableOperator progOperator = new ProgrammableOperator();
       progOperator.RemoveVariableInfo("Result");
@@ -196,8 +241,14 @@
 scope.AddVariable(new Variable(""EvaluatedSolutions"", new IntData(evalSolutions)));
 ";
+      bestSolutionProcessor.AddSubOperator(testMseEvaluator);
       bestSolutionProcessor.AddSubOperator(trainingMapeEvaluator);
       bestSolutionProcessor.AddSubOperator(validationMapeEvaluator);
+      bestSolutionProcessor.AddSubOperator(testMapeEvaluator);
       bestSolutionProcessor.AddSubOperator(trainingMapreEvaluator);
       bestSolutionProcessor.AddSubOperator(validationMapreEvaluator);
+      bestSolutionProcessor.AddSubOperator(testMapreEvaluator);
+      bestSolutionProcessor.AddSubOperator(trainingR2Evaluator);
+      bestSolutionProcessor.AddSubOperator(validationR2Evaluator);
+      bestSolutionProcessor.AddSubOperator(testR2Evaluator);
       bestSolutionProcessor.AddSubOperator(progOperator);
       return bestSolutionProcessor;
