Index: /branches/DataAnalysis Refactoring/HeuristicLab.Algorithms.DataAnalysis/3.4/CrossValidation.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Algorithms.DataAnalysis/3.4/CrossValidation.cs	(revision 5758)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Algorithms.DataAnalysis/3.4/CrossValidation.cs	(revision 5759)
@@ -271,6 +271,6 @@
             clonedAlgorithm.Name = algorithm.Name + " Fold " + i;
             IDataAnalysisProblem problem = clonedAlgorithm.Problem as IDataAnalysisProblem;
-            problem.ProblemData.TestPartitionEnd.Value = (i + 1) == Folds.Value ? SamplesEnd.Value : (i + 1) * testSamplesCount + SamplesStart.Value;
-            problem.ProblemData.TestPartitionStart.Value = (i * testSamplesCount) + SamplesStart.Value;
+            problem.ProblemData.TestPartition.End = (i + 1) == Folds.Value ? SamplesEnd.Value : (i + 1) * testSamplesCount + SamplesStart.Value;
+            problem.ProblemData.TestPartition.Start = (i * testSamplesCount) + SamplesStart.Value;
             clonedAlgorithms.Add(clonedAlgorithm);
           }
@@ -408,8 +408,8 @@
     }
     private void SamplesStart_ValueChanged(object sender, EventArgs e) {
-      if (Problem != null) Problem.ProblemData.TrainingPartitionStart.Value = SamplesStart.Value;
+      if (Problem != null) Problem.ProblemData.TrainingPartition.Start = SamplesStart.Value;
     }
     private void SamplesEnd_ValueChanged(object sender, EventArgs e) {
-      if (Problem != null) Problem.ProblemData.TrainingPartitionEnd.Value = SamplesEnd.Value;
+      if (Problem != null) Problem.ProblemData.TrainingPartition.End = SamplesEnd.Value;
     }
 
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Algorithms.DataAnalysis/3.4/Linear/LinearDiscriminantAnalysis.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Algorithms.DataAnalysis/3.4/Linear/LinearDiscriminantAnalysis.cs	(revision 5758)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Algorithms.DataAnalysis/3.4/Linear/LinearDiscriminantAnalysis.cs	(revision 5759)
@@ -71,6 +71,6 @@
       string targetVariable = problemData.TargetVariable;
       IEnumerable<string> allowedInputVariables = problemData.AllowedInputVariables;
-      int samplesStart = problemData.TrainingPartitionStart.Value;
-      int samplesEnd = problemData.TrainingPartitionEnd.Value;
+      int samplesStart = problemData.TrainingPartition.Start;
+      int samplesEnd = problemData.TrainingPartition.End;
       IEnumerable<int> rows = Enumerable.Range(samplesStart, samplesEnd - samplesStart);
       int nClasses = problemData.ClassNames.Count();
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Algorithms.DataAnalysis/3.4/Linear/LinearRegression.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Algorithms.DataAnalysis/3.4/Linear/LinearRegression.cs	(revision 5758)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Algorithms.DataAnalysis/3.4/Linear/LinearRegression.cs	(revision 5759)
@@ -73,6 +73,6 @@
       string targetVariable = problemData.TargetVariable;
       IEnumerable<string> allowedInputVariables = problemData.AllowedInputVariables;
-      int samplesStart = problemData.TrainingPartitionStart.Value;
-      int samplesEnd = problemData.TrainingPartitionEnd.Value;
+      int samplesStart = problemData.TrainingPartition.Start;
+      int samplesEnd = problemData.TrainingPartition.End;
       IEnumerable<int> rows = Enumerable.Range(samplesStart, samplesEnd - samplesStart);
       double[,] inputMatrix = AlglibUtil.PrepareInputMatrix(dataset, allowedInputVariables.Concat(new string[] { targetVariable }), rows);
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Algorithms.DataAnalysis/3.4/SupportVectorMachine/SupportVectorClassification.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Algorithms.DataAnalysis/3.4/SupportVectorMachine/SupportVectorClassification.cs	(revision 5758)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Algorithms.DataAnalysis/3.4/SupportVectorMachine/SupportVectorClassification.cs	(revision 5759)
@@ -21,4 +21,5 @@
 
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using HeuristicLab.Common;
@@ -29,7 +30,4 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 using HeuristicLab.Problems.DataAnalysis;
-using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
-using System.Collections.Generic;
-using HeuristicLab.Problems.DataAnalysis.Symbolic;
 
 namespace HeuristicLab.Algorithms.DataAnalysis {
@@ -124,6 +122,6 @@
       Dataset dataset = problemData.Dataset;
       string targetVariable = problemData.TargetVariable;
-      int start = problemData.TrainingPartitionStart.Value;
-      int end = problemData.TrainingPartitionEnd.Value;
+      int start = problemData.TrainingPartition.Start;
+      int end = problemData.TrainingPartition.End;
       IEnumerable<int> rows = Enumerable.Range(start, end - start);
 
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Algorithms.DataAnalysis/3.4/SupportVectorMachine/SupportVectorRegression.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Algorithms.DataAnalysis/3.4/SupportVectorMachine/SupportVectorRegression.cs	(revision 5758)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Algorithms.DataAnalysis/3.4/SupportVectorMachine/SupportVectorRegression.cs	(revision 5759)
@@ -132,6 +132,6 @@
       Dataset dataset = problemData.Dataset;
       string targetVariable = problemData.TargetVariable;
-      int start = problemData.TrainingPartitionStart.Value;
-      int end = problemData.TrainingPartitionEnd.Value;
+      int start = problemData.TrainingPartition.Start;
+      int end = problemData.TrainingPartition.End;
       IEnumerable<int> rows = Enumerable.Range(start, end - start);
 
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Algorithms.DataAnalysis/3.4/kMeans/KMeansClustering.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Algorithms.DataAnalysis/3.4/kMeans/KMeansClustering.cs	(revision 5758)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Algorithms.DataAnalysis/3.4/kMeans/KMeansClustering.cs	(revision 5759)
@@ -88,6 +88,6 @@
       Dataset dataset = problemData.Dataset;
       IEnumerable<string> allowedInputVariables = problemData.AllowedInputVariables;
-      int start = problemData.TrainingPartitionStart.Value;
-      int end = problemData.TrainingPartitionEnd.Value;
+      int start = problemData.TrainingPartition.Start;
+      int end = problemData.TrainingPartition.End;
       IEnumerable<int> rows = Enumerable.Range(start, end - start);
       int info;
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Data.Views/3.3/StringConvertibleValueTupleView.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Data.Views/3.3/StringConvertibleValueTupleView.cs	(revision 5758)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Data.Views/3.3/StringConvertibleValueTupleView.cs	(revision 5759)
@@ -48,6 +48,11 @@
     protected override void OnContentChanged() {
       base.OnContentChanged();
-      Item1View.Content = Content.Item1;
-      Item2View.Content = Content.Item2;
+      if (Content != null) {
+        Item1View.Content = Content.Item1;
+        Item2View.Content = Content.Item2;
+      } else {
+        Item1View.Content = null;
+        Item2View.Content = null;
+      }
     }
 
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Data/3.3/DoubleRange.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Data/3.3/DoubleRange.cs	(revision 5758)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Data/3.3/DoubleRange.cs	(revision 5759)
@@ -30,6 +30,12 @@
   public class DoubleRange : StringConvertibleValueTuple<DoubleValue, DoubleValue> {
 
-    public DoubleValue Start { get { return Item1; } }
-    public DoubleValue End { get { return Item2; } }
+    public double Start {
+      get { return Item1.Value; }
+      set { Item1.Value = value; }
+    }
+    public double End {
+      get { return Item2.Value; }
+      set { Item2.Value = value; }
+    }
 
     [StorableConstructor]
@@ -42,6 +48,7 @@
     }
 
-    public DoubleRange() : base() { }
+    public DoubleRange() : base(new DoubleValue(), new DoubleValue()) { }
     public DoubleRange(DoubleValue start, DoubleValue end) : base(start, end) { }
+    public DoubleRange(double start, double end) : base(new DoubleValue(start), new DoubleValue(end)) { }
 
     public override string ToString() {
@@ -51,5 +58,5 @@
     public override StringConvertibleValueTuple<DoubleValue, DoubleValue> AsReadOnly() {
       var readOnly = new DoubleRange();
-      readOnly.values = Tuple.Create<DoubleValue, DoubleValue>((DoubleValue)Start.AsReadOnly(), (DoubleValue)End.AsReadOnly());
+      readOnly.values = Tuple.Create<DoubleValue, DoubleValue>((DoubleValue)Item1.AsReadOnly(), (DoubleValue)Item2.AsReadOnly());
       readOnly.readOnly = true;
       return readOnly;
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Data/3.3/IntRange.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Data/3.3/IntRange.cs	(revision 5758)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Data/3.3/IntRange.cs	(revision 5759)
@@ -30,6 +30,12 @@
   public class IntRange : StringConvertibleValueTuple<IntValue, IntValue> {
 
-    public IntValue Start { get { return Item1; } }
-    public IntValue End { get { return Item2; } }
+    public int Start {
+      get { return Item1.Value; }
+      set { Item1.Value = value; }
+    }
+    public int End {
+      get { return Item2.Value; }
+      set { Item2.Value = value; }
+    }
 
     [StorableConstructor]
@@ -42,6 +48,7 @@
     }
 
-    public IntRange() : base() { }
+    public IntRange() : base(new IntValue(), new IntValue()) { }
     public IntRange(IntValue start, IntValue end) : base(start, end) { }
+    public IntRange(int start, int end) : base(new IntValue(start), new IntValue(end)) { }
 
     public override string ToString() {
@@ -51,5 +58,5 @@
     public override StringConvertibleValueTuple<IntValue, IntValue> AsReadOnly() {
       var readOnly = new IntRange();
-      readOnly.values = Tuple.Create<IntValue, IntValue>((IntValue)Start.AsReadOnly(), (IntValue)End.AsReadOnly());
+      readOnly.values = Tuple.Create<IntValue, IntValue>((IntValue)Item1.AsReadOnly(), (IntValue)Item2.AsReadOnly());
       readOnly.readOnly = true;
       return readOnly;
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Data/3.3/StringConvertibleValueTuple.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Data/3.3/StringConvertibleValueTuple.cs	(revision 5758)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Data/3.3/StringConvertibleValueTuple.cs	(revision 5759)
@@ -55,10 +55,4 @@
     }
 
-    public StringConvertibleValueTuple()
-      : base() {
-      values = Tuple.Create<T, U>(default(T), default(U));
-      readOnly = false;
-      RegisterEventHandler();
-    }
     public StringConvertibleValueTuple(T item1, U item2)
       : base() {
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Tests/AllArchitectureAlteringOperatorsTest.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Tests/AllArchitectureAlteringOperatorsTest.cs	(revision 5758)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Tests/AllArchitectureAlteringOperatorsTest.cs	(revision 5759)
@@ -32,5 +32,5 @@
   public class AllArchitectureAlteringOperatorsTest {
     private const int POPULATION_SIZE = 1000;
-    private const int N_ITERATIONS = 20;
+    private const int N_ITERATIONS = 100;
     private const int MAX_TREE_LENGTH = 100;
     private const int MAX_TREE_DEPTH = 10;
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/MultiObjective/SymbolicClassificationMultiObjectiveMeanSquaredErrorTreeSizeEvaluator.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/MultiObjective/SymbolicClassificationMultiObjectiveMeanSquaredErrorTreeSizeEvaluator.cs	(revision 5758)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/MultiObjective/SymbolicClassificationMultiObjectiveMeanSquaredErrorTreeSizeEvaluator.cs	(revision 5759)
@@ -26,5 +26,4 @@
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using System;
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Classification {
@@ -47,5 +46,5 @@
     public override IOperation Apply() {
       IEnumerable<int> rows = GenerateRowsToEvaluate();
-      double[] qualities = Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, SymbolicExpressionTreeParameter.ActualValue, LowerEstimationLimit.Value, UpperEstimationLimit.Value, ProblemData, rows);
+      double[] qualities = Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, SymbolicExpressionTreeParameter.ActualValue, LowerEstimationLimitParameter.ActualValue.Value, UpperEstimationLimitParameter.ActualValue.Value, ProblemDataParameter.ActualValue, rows);
       QualitiesParameter.ActualValue = new DoubleArray(qualities);
       return base.Apply();
@@ -65,5 +64,5 @@
       UpperEstimationLimitParameter.ExecutionContext = context;
 
-      double[] quality = Calculate(SymbolicDataAnalysisTreeInterpreter, tree, LowerEstimationLimit.Value, UpperEstimationLimit.Value, problemData, rows);
+      double[] quality = Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, tree, LowerEstimationLimitParameter.ActualValue.Value, UpperEstimationLimitParameter.ActualValue.Value, problemData, rows);
 
       SymbolicDataAnalysisTreeInterpreterParameter.ExecutionContext = null;
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/MultiObjective/SymbolicClassificationMultiObjectivePearsonRSquaredTreeSizeEvaluator.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/MultiObjective/SymbolicClassificationMultiObjectivePearsonRSquaredTreeSizeEvaluator.cs	(revision 5758)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/MultiObjective/SymbolicClassificationMultiObjectivePearsonRSquaredTreeSizeEvaluator.cs	(revision 5759)
@@ -1,3 +1,4 @@
-﻿using System.Collections.Generic;
+﻿using System;
+using System.Collections.Generic;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -5,5 +6,4 @@
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using System;
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Classification {
@@ -26,5 +26,5 @@
     public override IOperation Apply() {
       IEnumerable<int> rows = GenerateRowsToEvaluate();
-      double[] qualities = Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, SymbolicExpressionTreeParameter.ActualValue, LowerEstimationLimit.Value, UpperEstimationLimit.Value, ProblemData, rows);
+      double[] qualities = Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, SymbolicExpressionTreeParameter.ActualValue, LowerEstimationLimitParameter.ActualValue.Value, UpperEstimationLimitParameter.ActualValue.Value, ProblemDataParameter.ActualValue, rows);
       QualitiesParameter.ActualValue = new DoubleArray(qualities);
       return base.Apply();
@@ -49,5 +49,5 @@
       UpperEstimationLimitParameter.ExecutionContext = context;
 
-      double[] quality = Calculate(SymbolicDataAnalysisTreeInterpreter, tree, LowerEstimationLimit.Value, UpperEstimationLimit.Value, problemData, rows);
+      double[] quality = Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, tree, LowerEstimationLimitParameter.ActualValue.Value, UpperEstimationLimitParameter.ActualValue.Value, problemData, rows);
 
       SymbolicDataAnalysisTreeInterpreterParameter.ExecutionContext = null;
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/MultiObjective/SymbolicClassificationMultiObjectiveProblem.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/MultiObjective/SymbolicClassificationMultiObjectiveProblem.cs	(revision 5758)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/MultiObjective/SymbolicClassificationMultiObjectiveProblem.cs	(revision 5759)
@@ -71,5 +71,4 @@
       InitializeOperators();
       UpdateEstimationLimits();
-      UpdateDatasetPartitions();
     }
 
@@ -81,6 +80,6 @@
 
     private void UpdateEstimationLimits() {
-      if (ProblemData.TrainingPartitionStart.Value < ProblemData.TrainingPartitionEnd.Value) {
-        var targetValues = ProblemData.Dataset.GetVariableValues(ProblemData.TargetVariable, ProblemData.TrainingPartitionStart.Value, ProblemData.TrainingPartitionEnd.Value);
+      if (ProblemData.TrainingPartition.Start < ProblemData.TrainingPartition.End) {
+        var targetValues = ProblemData.Dataset.GetVariableValues(ProblemData.TargetVariable, ProblemData.TrainingPartition.Start, ProblemData.TrainingPartition.End);
         var mean = targetValues.Average();
         var range = targetValues.Max() - targetValues.Min();
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/MultiObjective/SymbolicClassificationMultiObjectiveValidationBestSolutionAnalyzer.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/MultiObjective/SymbolicClassificationMultiObjectiveValidationBestSolutionAnalyzer.cs	(revision 5758)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/MultiObjective/SymbolicClassificationMultiObjectiveValidationBestSolutionAnalyzer.cs	(revision 5759)
@@ -20,12 +20,8 @@
 #endregion
 
-using System.Collections.Generic;
-using System.Linq;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Data;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
-using HeuristicLab.Operators;
-using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
@@ -47,5 +43,4 @@
       get { return (IValueLookupParameter<DoubleValue>)Parameters[UpperEstimationLimitParameterName]; }
     }
-
     public IValueLookupParameter<DoubleValue> LowerEstimationLimitParameter {
       get { return (IValueLookupParameter<DoubleValue>)Parameters[LowerEstimationLimitParameterName]; }
@@ -57,10 +52,4 @@
 
     #region properties
-    public DoubleValue UpperEstimationLimit {
-      get { return UpperEstimationLimitParameter.ActualValue; }
-    }
-    public DoubleValue LowerEstimationLimit {
-      get { return LowerEstimationLimitParameter.ActualValue; }
-    }
     public BoolValue ApplyLinearScaling {
       get { return ApplyLinearScalingParameter.Value; }
@@ -81,6 +70,6 @@
 
     protected override ISymbolicClassificationSolution CreateSolution(ISymbolicExpressionTree bestTree, double[] bestQualities) {
-      var model = new SymbolicDiscriminantFunctionClassificationModel(bestTree, SymbolicDataAnalysisTreeInterpreter, LowerEstimationLimit.Value, UpperEstimationLimit.Value);
-      var solution = new SymbolicDiscriminantFunctionClassificationSolution(model, ProblemData);
+      var model = new SymbolicDiscriminantFunctionClassificationModel(bestTree, SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, LowerEstimationLimitParameter.ActualValue.Value, UpperEstimationLimitParameter.ActualValue.Value);
+      var solution = new SymbolicDiscriminantFunctionClassificationSolution(model, ProblemDataParameter.ActualValue);
       if (ApplyLinearScaling.Value) {
         solution.ScaleModel();
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SingleObjective/SymbolicClassificationSingleObjectiveBoundedMeanSquaredErrorEvaluator.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SingleObjective/SymbolicClassificationSingleObjectiveBoundedMeanSquaredErrorEvaluator.cs	(revision 5758)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SingleObjective/SymbolicClassificationSingleObjectiveBoundedMeanSquaredErrorEvaluator.cs	(revision 5759)
@@ -47,5 +47,5 @@
     public override IOperation Apply() {
       IEnumerable<int> rows = GenerateRowsToEvaluate();
-      double quality = Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, SymbolicExpressionTreeParameter.ActualValue, LowerEstimationLimit.Value, UpperEstimationLimit.Value, ProblemData, rows);
+      double quality = Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, SymbolicExpressionTreeParameter.ActualValue, LowerEstimationLimitParameter.ActualValue.Value, UpperEstimationLimitParameter.ActualValue.Value, ProblemDataParameter.ActualValue, rows);
       QualityParameter.ActualValue = new DoubleValue(quality);
       return base.Apply();
@@ -88,5 +88,5 @@
 
     public override double Evaluate(IExecutionContext context, ISymbolicExpressionTree tree, IClassificationProblemData problemData, IEnumerable<int> rows) {
-      return Calculate(SymbolicDataAnalysisTreeInterpreter, tree, LowerEstimationLimit.Value, UpperEstimationLimit.Value, problemData, rows);
+      return Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, tree, LowerEstimationLimitParameter.ActualValue.Value, UpperEstimationLimitParameter.ActualValue.Value, problemData, rows);
     }
   }
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SingleObjective/SymbolicClassificationSingleObjectiveMeanSquaredErrorEvaluator.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SingleObjective/SymbolicClassificationSingleObjectiveMeanSquaredErrorEvaluator.cs	(revision 5758)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SingleObjective/SymbolicClassificationSingleObjectiveMeanSquaredErrorEvaluator.cs	(revision 5759)
@@ -26,5 +26,4 @@
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using System;
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Classification {
@@ -47,5 +46,5 @@
     public override IOperation Apply() {
       IEnumerable<int> rows = GenerateRowsToEvaluate();
-      double quality = Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, SymbolicExpressionTreeParameter.ActualValue, LowerEstimationLimit.Value, UpperEstimationLimit.Value, ProblemData, rows);
+      double quality = Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, SymbolicExpressionTreeParameter.ActualValue, LowerEstimationLimitParameter.ActualValue.Value, UpperEstimationLimitParameter.ActualValue.Value, ProblemDataParameter.ActualValue, rows);
       QualityParameter.ActualValue = new DoubleValue(quality);
       return base.Apply();
@@ -64,5 +63,5 @@
       UpperEstimationLimitParameter.ExecutionContext = context;
 
-      double mse = Calculate(SymbolicDataAnalysisTreeInterpreter, tree, LowerEstimationLimit.Value, UpperEstimationLimit.Value, problemData, rows);
+      double mse = Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, tree, LowerEstimationLimitParameter.ActualValue.Value, UpperEstimationLimitParameter.ActualValue.Value, problemData, rows);
 
       SymbolicDataAnalysisTreeInterpreterParameter.ExecutionContext = null;
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SingleObjective/SymbolicClassificationSingleObjectiveOverfittingAnalyzer.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SingleObjective/SymbolicClassificationSingleObjectiveOverfittingAnalyzer.cs	(revision 5758)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SingleObjective/SymbolicClassificationSingleObjectiveOverfittingAnalyzer.cs	(revision 5759)
@@ -20,5 +20,4 @@
 #endregion
 
-using System.Collections.Generic;
 using System.Linq;
 using HeuristicLab.Analysis;
@@ -26,11 +25,7 @@
 using HeuristicLab.Core;
 using HeuristicLab.Data;
-using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
-using HeuristicLab.Operators;
 using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Problems.DataAnalysis.Symbolic;
-using System;
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Classification {
@@ -81,10 +76,10 @@
       double[] trainingQuality = QualityParameter.ActualValue.Select(x => x.Value).ToArray();
       // evaluate on validation partition
-      int start = ValidationSamplesStart.Value;
-      int end = ValidationSamplesEnd.Value;
+      int start = ValidationPartitionParameter.ActualValue.Start;
+      int end = ValidationPartitionParameter.ActualValue.End;
       var rows = Enumerable.Range(start, end - start);
-      IExecutionContext childContext = (IExecutionContext)ExecutionContext.CreateChildOperation(Evaluator);
+      IExecutionContext childContext = (IExecutionContext)ExecutionContext.CreateChildOperation(EvaluatorParameter.ActualValue);
       double[] validationQuality = (from tree in SymbolicExpressionTrees
-                                    select Evaluator.Evaluate(childContext, tree, ProblemData, rows))
+                                    select EvaluatorParameter.ActualValue.Evaluate(childContext, tree, ProblemDataParameter.ActualValue, rows))
                                    .ToArray();
       double r = alglib.spearmancorr2(trainingQuality, validationQuality);
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SingleObjective/SymbolicClassificationSingleObjectivePearsonRSquaredEvaluator.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SingleObjective/SymbolicClassificationSingleObjectivePearsonRSquaredEvaluator.cs	(revision 5758)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SingleObjective/SymbolicClassificationSingleObjectivePearsonRSquaredEvaluator.cs	(revision 5759)
@@ -20,4 +20,5 @@
 #endregion
 
+using System;
 using System.Collections.Generic;
 using HeuristicLab.Common;
@@ -26,5 +27,4 @@
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using System;
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Classification {
@@ -47,5 +47,5 @@
     public override IOperation Apply() {
       IEnumerable<int> rows = GenerateRowsToEvaluate();
-      double quality = Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, SymbolicExpressionTreeParameter.ActualValue, LowerEstimationLimit.Value, UpperEstimationLimit.Value, ProblemData, rows);
+      double quality = Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, SymbolicExpressionTreeParameter.ActualValue, LowerEstimationLimitParameter.ActualValue.Value, UpperEstimationLimitParameter.ActualValue.Value, ProblemDataParameter.ActualValue, rows);
       QualityParameter.ActualValue = new DoubleValue(quality);
       return base.Apply();
@@ -69,5 +69,5 @@
       UpperEstimationLimitParameter.ExecutionContext = context;
 
-      double r2 = Calculate(SymbolicDataAnalysisTreeInterpreter, tree, LowerEstimationLimit.Value, UpperEstimationLimit.Value, problemData, rows);
+      double r2 = Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, tree, LowerEstimationLimitParameter.ActualValue.Value, UpperEstimationLimitParameter.ActualValue.Value, problemData, rows);
 
       SymbolicDataAnalysisTreeInterpreterParameter.ExecutionContext = null;
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SingleObjective/SymbolicClassificationSingleObjectiveProblem.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SingleObjective/SymbolicClassificationSingleObjectiveProblem.cs	(revision 5758)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SingleObjective/SymbolicClassificationSingleObjectiveProblem.cs	(revision 5759)
@@ -70,5 +70,4 @@
       InitializeOperators();
       UpdateEstimationLimits();
-      UpdateDatasetPartitions();
     }
 
@@ -81,6 +80,6 @@
 
     private void UpdateEstimationLimits() {
-      if (ProblemData.TrainingPartitionStart.Value < ProblemData.TrainingPartitionEnd.Value) {
-        var targetValues = ProblemData.Dataset.GetVariableValues(ProblemData.TargetVariable, ProblemData.TrainingPartitionStart.Value, ProblemData.TrainingPartitionEnd.Value);
+      if (ProblemData.TrainingPartition.Start < ProblemData.TrainingPartition.End) {
+        var targetValues = ProblemData.Dataset.GetVariableValues(ProblemData.TargetVariable, ProblemData.TrainingPartition.Start, ProblemData.TrainingPartition.End);
         var mean = targetValues.Average();
         var range = targetValues.Max() - targetValues.Min();
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SingleObjective/SymbolicClassificationSingleObjectiveValidationBestSolutionAnalyzer.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SingleObjective/SymbolicClassificationSingleObjectiveValidationBestSolutionAnalyzer.cs	(revision 5758)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SingleObjective/SymbolicClassificationSingleObjectiveValidationBestSolutionAnalyzer.cs	(revision 5759)
@@ -20,12 +20,8 @@
 #endregion
 
-using System.Collections.Generic;
-using System.Linq;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Data;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
-using HeuristicLab.Operators;
-using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
@@ -47,9 +43,7 @@
       get { return (IValueLookupParameter<DoubleValue>)Parameters[UpperEstimationLimitParameterName]; }
     }
-
     public IValueLookupParameter<DoubleValue> LowerEstimationLimitParameter {
       get { return (IValueLookupParameter<DoubleValue>)Parameters[LowerEstimationLimitParameterName]; }
     }
-
     public IValueParameter<BoolValue> ApplyLinearScalingParameter {
       get { return (IValueParameter<BoolValue>)Parameters[ApplyLinearScalingParameterName]; }
@@ -58,10 +52,4 @@
 
     #region properties
-    public DoubleValue UpperEstimationLimit {
-      get { return UpperEstimationLimitParameter.ActualValue; }
-    }
-    public DoubleValue LowerEstimationLimit {
-      get { return LowerEstimationLimitParameter.ActualValue; }
-    }
     public BoolValue ApplyLinearScaling {
       get { return ApplyLinearScalingParameter.Value; }
@@ -82,6 +70,6 @@
 
     protected override ISymbolicClassificationSolution CreateSolution(ISymbolicExpressionTree bestTree, double bestQuality) {
-      var model = new SymbolicDiscriminantFunctionClassificationModel(bestTree, SymbolicDataAnalysisTreeInterpreter, LowerEstimationLimit.Value, UpperEstimationLimit.Value);
-      var solution = new SymbolicDiscriminantFunctionClassificationSolution(model, ProblemData);
+      var model = new SymbolicDiscriminantFunctionClassificationModel(bestTree, SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, LowerEstimationLimitParameter.ActualValue.Value, UpperEstimationLimitParameter.ActualValue.Value);
+      var solution = new SymbolicDiscriminantFunctionClassificationSolution(model, ProblemDataParameter.ActualValue);
       if (ApplyLinearScaling.Value) {
         solution.ScaleModel();
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectiveMeanSquaredErrorTreeSizeEvaluator.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectiveMeanSquaredErrorTreeSizeEvaluator.cs	(revision 5758)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectiveMeanSquaredErrorTreeSizeEvaluator.cs	(revision 5759)
@@ -26,5 +26,4 @@
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using System;
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Regression {
@@ -47,5 +46,5 @@
     public override Core.IOperation Apply() {
       IEnumerable<int> rows = GenerateRowsToEvaluate();
-      double[] qualities = Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, SymbolicExpressionTreeParameter.ActualValue, LowerEstimationLimit.Value, UpperEstimationLimit.Value, ProblemData, rows);
+      double[] qualities = Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, SymbolicExpressionTreeParameter.ActualValue, LowerEstimationLimitParameter.ActualValue.Value, UpperEstimationLimitParameter.ActualValue.Value, ProblemDataParameter.ActualValue, rows);
       QualitiesParameter.ActualValue = new DoubleArray(qualities);
       return base.Apply();
@@ -65,5 +64,5 @@
       UpperEstimationLimitParameter.ExecutionContext = context;
 
-      double[] quality = Calculate(SymbolicDataAnalysisTreeInterpreter, tree, LowerEstimationLimit.Value, UpperEstimationLimit.Value, problemData, rows);
+      double[] quality = Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, tree, LowerEstimationLimitParameter.ActualValue.Value, UpperEstimationLimitParameter.ActualValue.Value, problemData, rows);
 
       SymbolicDataAnalysisTreeInterpreterParameter.ExecutionContext = null;
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectivePearsonRSquaredTreeSizeEvaluator.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectivePearsonRSquaredTreeSizeEvaluator.cs	(revision 5758)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectivePearsonRSquaredTreeSizeEvaluator.cs	(revision 5759)
@@ -20,4 +20,5 @@
 #endregion
 
+using System;
 using System.Collections.Generic;
 using HeuristicLab.Common;
@@ -26,5 +27,4 @@
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using System;
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Regression {
@@ -47,5 +47,5 @@
     public override IOperation Apply() {
       IEnumerable<int> rows = GenerateRowsToEvaluate();
-      double[] qualities = Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, SymbolicExpressionTreeParameter.ActualValue, LowerEstimationLimit.Value, UpperEstimationLimit.Value, ProblemData, rows);
+      double[] qualities = Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, SymbolicExpressionTreeParameter.ActualValue, LowerEstimationLimitParameter.ActualValue.Value, UpperEstimationLimitParameter.ActualValue.Value, ProblemDataParameter.ActualValue, rows);
       QualitiesParameter.ActualValue = new DoubleArray(qualities);
       return base.Apply();
@@ -70,5 +70,5 @@
       UpperEstimationLimitParameter.ExecutionContext = context;
 
-      double[] quality = Calculate(SymbolicDataAnalysisTreeInterpreter, tree, LowerEstimationLimit.Value, UpperEstimationLimit.Value, problemData, rows);
+      double[] quality = Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, tree, LowerEstimationLimitParameter.ActualValue.Value, UpperEstimationLimitParameter.ActualValue.Value, problemData, rows);
 
       SymbolicDataAnalysisTreeInterpreterParameter.ExecutionContext = null;
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectiveProblem.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectiveProblem.cs	(revision 5758)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectiveProblem.cs	(revision 5759)
@@ -72,5 +72,4 @@
       InitializeOperators();
       UpdateEstimationLimits();
-      UpdateDatasetPartitions();
     }
 
@@ -82,6 +81,6 @@
 
     private void UpdateEstimationLimits() {
-      if (ProblemData.TrainingPartitionStart.Value < ProblemData.TrainingPartitionEnd.Value) {
-        var targetValues = ProblemData.Dataset.GetVariableValues(ProblemData.TargetVariable, ProblemData.TrainingPartitionStart.Value, ProblemData.TrainingPartitionEnd.Value);
+      if (ProblemData.TrainingPartition.Start < ProblemData.TrainingPartition.End) {
+        var targetValues = ProblemData.Dataset.GetVariableValues(ProblemData.TargetVariable, ProblemData.TrainingPartition.Start, ProblemData.TrainingPartition.End);
         var mean = targetValues.Average();
         var range = targetValues.Max() - targetValues.Min();
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectiveValidationBestSolutionAnalyzer.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectiveValidationBestSolutionAnalyzer.cs	(revision 5758)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectiveValidationBestSolutionAnalyzer.cs	(revision 5759)
@@ -20,12 +20,8 @@
 #endregion
 
-using System.Collections.Generic;
-using System.Linq;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Data;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
-using HeuristicLab.Operators;
-using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
@@ -51,5 +47,5 @@
       get { return (IValueLookupParameter<DoubleValue>)Parameters[LowerEstimationLimitParameterName]; }
     }
-        public IValueParameter<BoolValue> ApplyLinearScalingParameter {
+    public IValueParameter<BoolValue> ApplyLinearScalingParameter {
       get { return (IValueParameter<BoolValue>)Parameters[ApplyLinearScalingParameterName]; }
     }
@@ -57,10 +53,4 @@
 
     #region properties
-    public DoubleValue UpperEstimationLimit {
-      get { return UpperEstimationLimitParameter.ActualValue; }
-    }
-    public DoubleValue LowerEstimationLimit {
-      get { return LowerEstimationLimitParameter.ActualValue; }
-    }
     public BoolValue ApplyLinearScaling {
       get { return ApplyLinearScalingParameter.Value; }
@@ -81,6 +71,6 @@
 
     protected override ISymbolicRegressionSolution CreateSolution(ISymbolicExpressionTree bestTree, double[] bestQuality) {
-      var model = new SymbolicRegressionModel(bestTree, SymbolicDataAnalysisTreeInterpreter, LowerEstimationLimit.Value, UpperEstimationLimit.Value);
-      var solution = new SymbolicRegressionSolution(model, ProblemData);
+      var model = new SymbolicRegressionModel(bestTree, SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, LowerEstimationLimitParameter.ActualValue.Value, UpperEstimationLimitParameter.ActualValue.Value);
+      var solution = new SymbolicRegressionSolution(model, ProblemDataParameter.ActualValue);
       if (ApplyLinearScaling.Value)
         solution.ScaleModel();
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/SymbolicRegressionSingleObjectiveMeanSquaredErrorEvaluator.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/SymbolicRegressionSingleObjectiveMeanSquaredErrorEvaluator.cs	(revision 5758)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/SymbolicRegressionSingleObjectiveMeanSquaredErrorEvaluator.cs	(revision 5759)
@@ -26,5 +26,4 @@
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using System;
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Regression {
@@ -47,5 +46,5 @@
     public override IOperation Apply() {
       IEnumerable<int> rows = GenerateRowsToEvaluate();
-      double quality = Calculate(SymbolicDataAnalysisTreeInterpreter, SymbolicExpressionTree, LowerEstimationLimit.Value, UpperEstimationLimit.Value, ProblemData, rows);
+      double quality = Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, SymbolicExpressionTreeParameter.ActualValue, LowerEstimationLimitParameter.ActualValue.Value, UpperEstimationLimitParameter.ActualValue.Value, ProblemDataParameter.ActualValue, rows);
       Quality = new DoubleValue(quality);
       return base.Apply();
@@ -64,5 +63,5 @@
       UpperEstimationLimitParameter.ExecutionContext = context;
 
-      double mse = Calculate(SymbolicDataAnalysisTreeInterpreter, tree, LowerEstimationLimit.Value, UpperEstimationLimit.Value, problemData, rows);
+      double mse = Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, tree, LowerEstimationLimitParameter.ActualValue.Value, UpperEstimationLimitParameter.ActualValue.Value, problemData, rows);
 
       SymbolicDataAnalysisTreeInterpreterParameter.ExecutionContext = null;
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/SymbolicRegressionSingleObjectiveOverfittingAnalyzer.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/SymbolicRegressionSingleObjectiveOverfittingAnalyzer.cs	(revision 5758)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/SymbolicRegressionSingleObjectiveOverfittingAnalyzer.cs	(revision 5759)
@@ -20,5 +20,4 @@
 #endregion
 
-using System.Collections.Generic;
 using System.Linq;
 using HeuristicLab.Analysis;
@@ -26,11 +25,7 @@
 using HeuristicLab.Core;
 using HeuristicLab.Data;
-using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
-using HeuristicLab.Operators;
 using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Problems.DataAnalysis.Symbolic;
-using System;
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Regression {
@@ -81,10 +76,10 @@
       double[] trainingQuality = QualityParameter.ActualValue.Select(x => x.Value).ToArray();
       // evaluate on validation partition
-      int start = ValidationSamplesStart.Value;
-      int end = ValidationSamplesEnd.Value;
+      int start = ValidationPartitionParameter.ActualValue.Start;
+      int end = ValidationPartitionParameter.ActualValue.End;
       var rows = Enumerable.Range(start, end - start);
-      IExecutionContext childContext = (IExecutionContext)ExecutionContext.CreateChildOperation(Evaluator);
+      IExecutionContext childContext = (IExecutionContext)ExecutionContext.CreateChildOperation(EvaluatorParameter.ActualValue);
       double[] validationQuality = (from tree in SymbolicExpressionTrees
-                                    select Evaluator.Evaluate(childContext, tree, ProblemData, rows))
+                                    select EvaluatorParameter.ActualValue.Evaluate(childContext, tree, ProblemDataParameter.ActualValue, rows))
                                    .ToArray();
       double r = alglib.spearmancorr2(trainingQuality, validationQuality);
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/SymbolicRegressionSingleObjectivePearsonRSquaredEvaluator.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/SymbolicRegressionSingleObjectivePearsonRSquaredEvaluator.cs	(revision 5758)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/SymbolicRegressionSingleObjectivePearsonRSquaredEvaluator.cs	(revision 5759)
@@ -20,4 +20,5 @@
 #endregion
 
+using System;
 using System.Collections.Generic;
 using HeuristicLab.Common;
@@ -26,6 +27,4 @@
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using System.Linq;
-using System;
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Regression {
@@ -48,5 +47,5 @@
     public override IOperation Apply() {
       IEnumerable<int> rows = GenerateRowsToEvaluate();
-      double quality = Calculate(SymbolicDataAnalysisTreeInterpreter, SymbolicExpressionTree, LowerEstimationLimit.Value, UpperEstimationLimit.Value, ProblemData, rows);
+      double quality = Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, SymbolicExpressionTreeParameter.ActualValue, LowerEstimationLimitParameter.ActualValue.Value, UpperEstimationLimitParameter.ActualValue.Value, ProblemDataParameter.ActualValue, rows);
       Quality = new DoubleValue(quality);
       return base.Apply();
@@ -70,5 +69,5 @@
       UpperEstimationLimitParameter.ExecutionContext = context;
 
-      double r2 = Calculate(SymbolicDataAnalysisTreeInterpreter, tree, LowerEstimationLimit.Value, UpperEstimationLimit.Value, problemData, rows);
+      double r2 = Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, tree, LowerEstimationLimitParameter.ActualValue.Value, UpperEstimationLimitParameter.ActualValue.Value, problemData, rows);
 
       SymbolicDataAnalysisTreeInterpreterParameter.ExecutionContext = null;
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/SymbolicRegressionSingleObjectiveProblem.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/SymbolicRegressionSingleObjectiveProblem.cs	(revision 5758)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/SymbolicRegressionSingleObjectiveProblem.cs	(revision 5759)
@@ -31,5 +31,5 @@
   [StorableClass]
   [Creatable("Problems")]
-  public class SymbolicRegressionSingleObjectiveProblem : SymbolicDataAnalysisSingleObjectiveProblem<IRegressionProblemData, ISymbolicRegressionSingleObjectiveEvaluator, ISymbolicDataAnalysisSolutionCreator>,IRegressionProblem {
+  public class SymbolicRegressionSingleObjectiveProblem : SymbolicDataAnalysisSingleObjectiveProblem<IRegressionProblemData, ISymbolicRegressionSingleObjectiveEvaluator, ISymbolicDataAnalysisSolutionCreator>, IRegressionProblem {
     private const double PunishmentFactor = 10;
     private const int InitialMaximumTreeDepth = 8;
@@ -72,5 +72,4 @@
       InitializeOperators();
       UpdateEstimationLimits();
-      UpdateDatasetPartitions();
     }
 
@@ -83,6 +82,6 @@
 
     private void UpdateEstimationLimits() {
-      if (ProblemData.TrainingPartitionStart.Value < ProblemData.TrainingPartitionEnd.Value) {
-        var targetValues = ProblemData.Dataset.GetVariableValues(ProblemData.TargetVariable, ProblemData.TrainingPartitionStart.Value, ProblemData.TrainingPartitionEnd.Value);
+      if (ProblemData.TrainingPartition.Start < ProblemData.TrainingPartition.End) {
+        var targetValues = ProblemData.Dataset.GetVariableValues(ProblemData.TargetVariable, ProblemData.TrainingPartition.Start, ProblemData.TrainingPartition.End);
         var mean = targetValues.Average();
         var range = targetValues.Max() - targetValues.Min();
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/SymbolicRegressionSingleObjectiveValidationBestSolutionAnalyzer.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/SymbolicRegressionSingleObjectiveValidationBestSolutionAnalyzer.cs	(revision 5758)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/SymbolicRegressionSingleObjectiveValidationBestSolutionAnalyzer.cs	(revision 5759)
@@ -20,12 +20,8 @@
 #endregion
 
-using System.Collections.Generic;
-using System.Linq;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Data;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
-using HeuristicLab.Operators;
-using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
@@ -50,16 +46,10 @@
       get { return (IValueLookupParameter<DoubleValue>)Parameters[LowerEstimationLimitParameterName]; }
     }
+    public IValueParameter<BoolValue> ApplyLinearScalingParameter {
+      get { return (IValueParameter<BoolValue>)Parameters[ApplyLinearScalingParameterName]; }
+    }
     #endregion
 
     #region properties
-    public DoubleValue UpperEstimationLimit {
-      get { return UpperEstimationLimitParameter.ActualValue; }
-    }
-    public DoubleValue LowerEstimationLimit {
-      get { return LowerEstimationLimitParameter.ActualValue; }
-    }
-    public IValueParameter<BoolValue> ApplyLinearScalingParameter {
-      get { return (IValueParameter<BoolValue>)Parameters[ApplyLinearScalingParameterName]; }
-    }
     public BoolValue ApplyLinearScaling {
       get { return ApplyLinearScalingParameter.Value; }
@@ -82,6 +72,6 @@
 
     protected override ISymbolicRegressionSolution CreateSolution(ISymbolicExpressionTree bestTree, double bestQuality) {
-      var model = new SymbolicRegressionModel(bestTree, SymbolicDataAnalysisTreeInterpreter, LowerEstimationLimit.Value, UpperEstimationLimit.Value);
-      var solution = new SymbolicRegressionSolution(model, ProblemData);
+      var model = new SymbolicRegressionModel(bestTree, SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, LowerEstimationLimitParameter.ActualValue.Value, UpperEstimationLimitParameter.ActualValue.Value);
+      var solution = new SymbolicRegressionSolution(model, ProblemDataParameter.ActualValue);
       if (ApplyLinearScaling.Value)
         solution.ScaleModel();
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisMultiObjectiveValidationAnalyzer.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisMultiObjectiveValidationAnalyzer.cs	(revision 5758)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisMultiObjectiveValidationAnalyzer.cs	(revision 5759)
@@ -20,14 +20,9 @@
 #endregion
 
-using System.Collections.Generic;
-using System.Linq;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Data;
-using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
-using HeuristicLab.Operators;
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Optimization;
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
@@ -43,6 +38,6 @@
     private const string EvaluatorParameterName = "Evaluator";
     private const string SymbolicDataAnalysisTreeInterpreterParameterName = "SymbolicDataAnalysisTreeInterpreter";
-    private const string ValidationSamplesStartParameterName = "ValidationSamplesStart";
-    private const string ValidationSamplesEndParameterName = "ValidationSamplesEnd";
+    private const string ValidationPartitionParameterName = "ValidationPartition";
+    private const string RelativeNumberOfEvaluatedSamplesParameterName = "RelativeNumberOfEvaluatedSamples";
 
     #region parameter properties
@@ -56,18 +51,10 @@
       get { return (ILookupParameter<ISymbolicDataAnalysisExpressionTreeInterpreter>)Parameters[SymbolicDataAnalysisTreeInterpreterParameterName]; }
     }
-    public IValueLookupParameter<IntValue> ValidationSamplesStartParameter {
-      get { return (IValueLookupParameter<IntValue>)Parameters[ValidationSamplesStartParameterName]; }
+    public IValueLookupParameter<IntRange> ValidationPartitionParameter {
+      get { return (IValueLookupParameter<IntRange>)Parameters[ValidationPartitionParameterName]; }
     }
-    public IValueLookupParameter<IntValue> ValidationSamplesEndParameter {
-      get { return (IValueLookupParameter<IntValue>)Parameters[ValidationSamplesEndParameterName]; }
+    public IValueLookupParameter<PercentValue> RelativeNumberOfEvaluatedSamplesParameter {
+      get { return (IValueLookupParameter<PercentValue>)Parameters[RelativeNumberOfEvaluatedSamplesParameterName]; }
     }
-    #endregion
-
-    #region properties
-    public U ProblemData { get { return ProblemDataParameter.ActualValue; } }
-    public T Evaluator { get { return EvaluatorParameter.ActualValue; } }
-    public ISymbolicDataAnalysisExpressionTreeInterpreter SymbolicDataAnalysisTreeInterpreter { get { return SymbolicDataAnalysisTreeInterpreterParameter.ActualValue; } }
-    public IntValue ValidationSamplesStart { get { return ValidationSamplesStartParameter.ActualValue; } }
-    public IntValue ValidationSamplesEnd { get { return ValidationSamplesEndParameter.ActualValue; } }
     #endregion
 
@@ -82,6 +69,6 @@
       Parameters.Add(new LookupParameter<T>(EvaluatorParameterName, "The operator to use for fitness evaluation on the validation partition."));
       Parameters.Add(new LookupParameter<ISymbolicDataAnalysisExpressionTreeInterpreter>(SymbolicDataAnalysisTreeInterpreterParameterName, "The interpreter for symbolic data analysis expression trees."));
-      Parameters.Add(new ValueLookupParameter<IntValue>(ValidationSamplesStartParameterName, "The start index of the validation partition."));
-      Parameters.Add(new ValueLookupParameter<IntValue>(ValidationSamplesEndParameterName, "The end index of the validation partition."));
+      Parameters.Add(new ValueLookupParameter<IntRange>(ValidationPartitionParameterName, "Thes validation partition."));
+      Parameters.Add(new ValueLookupParameter<PercentValue>(RelativeNumberOfEvaluatedSamplesParameterName, "The relative number of samples of the dataset partition, which should be randomly chosen for evaluation between the start and end index."));
     }
   }
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisMultiObjectiveValidationBestSolutionAnalyzer.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisMultiObjectiveValidationBestSolutionAnalyzer.cs	(revision 5758)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisMultiObjectiveValidationBestSolutionAnalyzer.cs	(revision 5759)
@@ -20,4 +20,5 @@
 #endregion
 
+using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -26,9 +27,8 @@
 using HeuristicLab.Data;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
-using HeuristicLab.Operators;
 using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using System;
+using HeuristicLab.Random;
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
@@ -75,4 +75,9 @@
 
     public override IOperation Apply() {
+      int start = ValidationPartitionParameter.ActualValue.Start;
+      int end = ValidationPartitionParameter.ActualValue.End;
+      int count = (int)((end - start) * RelativeNumberOfEvaluatedSamplesParameter.ActualValue.Value);
+      if (count <= 0) return base.Apply();
+
       var results = ResultCollection;
       // create empty parameter and result values
@@ -94,11 +99,9 @@
       bool[] maximization = Maximization.ToArray();
       List<double[]> newNonDominatedQualities = new List<double[]>();
-      var evaluator = Evaluator;
-      int start = ValidationSamplesStart.Value;
-      int end = ValidationSamplesEnd.Value;
-      IEnumerable<int> rows = Enumerable.Range(start, end - start);
+      var evaluator = EvaluatorParameter.ActualValue;
+      IEnumerable<int> rows = RandomEnumerable.SampleRandomNumbers(start, end, count);
       IExecutionContext childContext = (IExecutionContext)ExecutionContext.CreateChildOperation(evaluator);
       for (int i = 0; i < tree.Length; i++) {
-        qualities.Add(evaluator.Evaluate(childContext, tree[i], ProblemData, rows)); // qualities[i] = ...
+        qualities.Add(evaluator.Evaluate(childContext, tree[i], ProblemDataParameter.ActualValue, rows)); // qualities[i] = ...
         if (IsNonDominated(qualities[i], trainingBestQualities, maximization) &&
           IsNonDominated(qualities[i], qualities, maximization)) {
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisSingleObjectiveValidationAnalyzer.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisSingleObjectiveValidationAnalyzer.cs	(revision 5758)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisSingleObjectiveValidationAnalyzer.cs	(revision 5759)
@@ -20,14 +20,9 @@
 #endregion
 
-using System.Collections.Generic;
-using System.Linq;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Data;
-using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
-using HeuristicLab.Operators;
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Optimization;
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
@@ -43,6 +38,6 @@
     private const string EvaluatorParameterName = "Evaluator";
     private const string SymbolicDataAnalysisTreeInterpreterParameterName = "SymbolicDataAnalysisTreeInterpreter";
-    private const string ValidationSamplesStartParameterName = "ValidationSamplesStart";
-    private const string ValidationSamplesEndParameterName = "ValidationSamplesEnd";
+    private const string ValidationPartitionParameterName = "ValidationPartition";
+    private const string RelativeNumberOfEvaluatedSamplesParameterName = "RelativeNumberOfEvaluatedSamples";
 
     #region parameter properties
@@ -56,18 +51,10 @@
       get { return (ILookupParameter<ISymbolicDataAnalysisExpressionTreeInterpreter>)Parameters[SymbolicDataAnalysisTreeInterpreterParameterName]; }
     }
-    public IValueLookupParameter<IntValue> ValidationSamplesStartParameter {
-      get { return (IValueLookupParameter<IntValue>)Parameters[ValidationSamplesStartParameterName]; }
+    public IValueLookupParameter<IntRange> ValidationPartitionParameter {
+      get { return (IValueLookupParameter<IntRange>)Parameters[ValidationPartitionParameterName]; }
     }
-    public IValueLookupParameter<IntValue> ValidationSamplesEndParameter {
-      get { return (IValueLookupParameter<IntValue>)Parameters[ValidationSamplesEndParameterName]; }
+    public IValueLookupParameter<PercentValue> RelativeNumberOfEvaluatedSamplesParameter {
+      get { return (IValueLookupParameter<PercentValue>)Parameters[RelativeNumberOfEvaluatedSamplesParameterName]; }
     }
-    #endregion
-
-    #region properties
-    public U ProblemData { get { return ProblemDataParameter.ActualValue; } }
-    public T Evaluator { get { return EvaluatorParameter.ActualValue; } }
-    public ISymbolicDataAnalysisExpressionTreeInterpreter SymbolicDataAnalysisTreeInterpreter { get { return SymbolicDataAnalysisTreeInterpreterParameter.ActualValue; } }
-    public IntValue ValidationSamplesStart { get { return ValidationSamplesStartParameter.ActualValue; } }
-    public IntValue ValidationSamplesEnd { get { return ValidationSamplesEndParameter.ActualValue; } }
     #endregion
 
@@ -82,6 +69,6 @@
       Parameters.Add(new LookupParameter<T>(EvaluatorParameterName, "The operator to use for fitness evaluation on the validation partition."));
       Parameters.Add(new LookupParameter<ISymbolicDataAnalysisExpressionTreeInterpreter>(SymbolicDataAnalysisTreeInterpreterParameterName, "The interpreter for symbolic data analysis expression trees."));
-      Parameters.Add(new ValueLookupParameter<IntValue>(ValidationSamplesStartParameterName, "The start index of the validation partition."));
-      Parameters.Add(new ValueLookupParameter<IntValue>(ValidationSamplesEndParameterName, "The end index of the validation partition."));
+      Parameters.Add(new ValueLookupParameter<IntRange>(ValidationPartitionParameterName, "Thes validation partition."));
+      Parameters.Add(new ValueLookupParameter<PercentValue>(RelativeNumberOfEvaluatedSamplesParameterName, "The relative number of samples of the dataset partition, which should be randomly chosen for evaluation between the start and end index."));
     }
   }
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisSingleObjectiveValidationBestSolutionAnalyzer.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisSingleObjectiveValidationBestSolutionAnalyzer.cs	(revision 5758)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisSingleObjectiveValidationBestSolutionAnalyzer.cs	(revision 5759)
@@ -26,8 +26,8 @@
 using HeuristicLab.Data;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
-using HeuristicLab.Operators;
 using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Random;
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
@@ -78,11 +78,14 @@
       ISymbolicExpressionTree[] tree = SymbolicExpressionTrees.ToArray();
       double[] quality = new double[tree.Length];
-      var evaluator = Evaluator;
-      int start = ValidationSamplesStart.Value;
-      int end = ValidationSamplesEnd.Value;
-      IEnumerable<int> rows = Enumerable.Range(start, end - start);
+      var evaluator = EvaluatorParameter.ActualValue;
+      int start = ValidationPartitionParameter.ActualValue.Start;
+      int end = ValidationPartitionParameter.ActualValue.End;
+      int count = (int)((end - start) * RelativeNumberOfEvaluatedSamplesParameter.ActualValue.Value);
+      if (count <= 0) return base.Apply();
+
+      IEnumerable<int> rows = RandomEnumerable.SampleRandomNumbers(start, end, count);
       IExecutionContext childContext = (IExecutionContext)ExecutionContext.CreateChildOperation(evaluator);
       for (int i = 0; i < tree.Length; i++) {
-        quality[i] = evaluator.Evaluate(childContext, tree[i], ProblemData, rows);
+        quality[i] = evaluator.Evaluate(childContext, tree[i], ProblemDataParameter.ActualValue, rows);
         if (IsBetter(quality[i], bestQuality, Maximization.Value)) {
           bestQuality = quality[i];
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Evaluators/SymbolicDataAnalysisEvaluator.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Evaluators/SymbolicDataAnalysisEvaluator.cs	(revision 5758)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Evaluators/SymbolicDataAnalysisEvaluator.cs	(revision 5759)
@@ -43,6 +43,5 @@
     private const string UpperEstimationLimitParameterName = "UpperEstimationLimit";
     private const string LowerEstimationLimitParameterName = "LowerEstimationLimit";
-    private const string SamplesStartParameterName = "SamplesStart";
-    private const string SamplesEndParameterName = "SamplesEnd";
+    private const string EvaluationPartitionParameterName = "EvaluationPartition";
     private const string RelativeNumberOfEvaluatedSamplesParameterName = "RelativeNumberOfEvaluatedSamples";
 
@@ -63,9 +62,6 @@
     }
 
-    public IFixedValueParameter<IntValue> SamplesStartParameter {
-      get { return (IFixedValueParameter<IntValue>)Parameters[SamplesStartParameterName]; }
-    }
-    public IFixedValueParameter<IntValue> SamplesEndParameter {
-      get { return (IFixedValueParameter<IntValue>)Parameters[SamplesEndParameterName]; }
+    public IValueLookupParameter<IntRange> EvaluationPartitionParameter {
+      get { return (IValueLookupParameter<IntRange>)Parameters[EvaluationPartitionParameterName]; }
     }
 
@@ -77,38 +73,9 @@
     }
 
-    public IFixedValueParameter<PercentValue> RelativeNumberOfEvaluatedSamplesParameter {
-      get { return (IFixedValueParameter<PercentValue>)Parameters[RelativeNumberOfEvaluatedSamplesParameterName]; }
+    public IValueLookupParameter<PercentValue> RelativeNumberOfEvaluatedSamplesParameter {
+      get { return (IValueLookupParameter<PercentValue>)Parameters[RelativeNumberOfEvaluatedSamplesParameterName]; }
     }
     #endregion
 
-    #region properties
-    public IRandom Random {
-      get { return RandomParameter.ActualValue; }
-    }
-    public ISymbolicExpressionTree SymbolicExpressionTree {
-      get { return SymbolicExpressionTreeParameter.ActualValue; }
-    }
-    public ISymbolicDataAnalysisExpressionTreeInterpreter SymbolicDataAnalysisTreeInterpreter {
-      get { return SymbolicDataAnalysisTreeInterpreterParameter.ActualValue; }
-    }
-    public T ProblemData {
-      get { return ProblemDataParameter.ActualValue; }
-    }
-    public IntValue SamplesStart {
-      get { return SamplesStartParameter.Value; }
-    }
-    public IntValue SamplesEnd {
-      get { return SamplesEndParameter.Value; }
-    }
-    public DoubleValue UpperEstimationLimit {
-      get { return UpperEstimationLimitParameter.ActualValue; }
-    }
-    public DoubleValue LowerEstimationLimit {
-      get { return LowerEstimationLimitParameter.ActualValue; }
-    }
-    public PercentValue RelativeNumberOfEvaluatedSamples {
-      get { return RelativeNumberOfEvaluatedSamplesParameter.Value; }
-    }
-    #endregion
 
     [StorableConstructor]
@@ -123,19 +90,20 @@
       Parameters.Add(new LookupParameter<ISymbolicExpressionTree>(SymbolicExpressionTreeParameterName, "The symbolic data analysis solution encoded as a symbolic expression tree."));
       Parameters.Add(new ValueLookupParameter<T>(ProblemDataParameterName, "The problem data on which the symbolic data analysis solution should be evaluated."));
-      Parameters.Add(new FixedValueParameter<IntValue>(SamplesStartParameterName, "The start index of the dataset partition on which the symbolic data analysis solution should be evaluated.", new IntValue()));
-      Parameters.Add(new FixedValueParameter<IntValue>(SamplesEndParameterName, "The end index of the dataset partition on which the symbolic data analysis solution should be evaluated.", new IntValue()));
+      Parameters.Add(new ValueLookupParameter<IntRange>(EvaluationPartitionParameterName, "The start index of the dataset partition on which the symbolic data analysis solution should be evaluated."));
       Parameters.Add(new ValueLookupParameter<DoubleValue>(UpperEstimationLimitParameterName, "The upper limit that should be used as cut off value for the output values of symbolic data analysis trees."));
       Parameters.Add(new ValueLookupParameter<DoubleValue>(LowerEstimationLimitParameterName, "The lower limit that should be used as cut off value for the output values of symbolic data analysis trees."));
-      Parameters.Add(new FixedValueParameter<PercentValue>(RelativeNumberOfEvaluatedSamplesParameterName, "The relative number of samples of the dataset partition, which should be randomly chosen for evaluation between the start and end index.", new PercentValue(1)));
+      Parameters.Add(new ValueLookupParameter<PercentValue>(RelativeNumberOfEvaluatedSamplesParameterName, "The relative number of samples of the dataset partition, which should be randomly chosen for evaluation between the start and end index."));
     }
 
     protected IEnumerable<int> GenerateRowsToEvaluate() {
       int seed = RandomParameter.ActualValue.Next();
+      int samplesStart = EvaluationPartitionParameter.ActualValue.Start;
+      int samplesEnd = EvaluationPartitionParameter.ActualValue.End;
 
-      if (SamplesEnd.Value < SamplesStart.Value) throw new ArgumentException("Start value is larger than end value.");
-      int count = (int)((SamplesEnd.Value - SamplesStart.Value) * RelativeNumberOfEvaluatedSamples.Value);
+      if (samplesEnd < samplesStart) throw new ArgumentException("Start value is larger than end value.");
+      int count = (int)((samplesEnd - samplesStart) * RelativeNumberOfEvaluatedSamplesParameter.ActualValue.Value);
       if (count == 0) count = 1;
-      return RandomEnumerable.SampleRandomNumbers(seed, SamplesStart.Value, SamplesEnd.Value, count)
-        .Where(i => i < ProblemDataParameter.ActualValue.TestPartitionStart.Value || ProblemDataParameter.ActualValue.TestPartitionEnd.Value <= i);
+      return RandomEnumerable.SampleRandomNumbers(seed, samplesEnd, samplesStart, count)
+        .Where(i => i < ProblemDataParameter.ActualValue.TestPartition.Start || ProblemDataParameter.ActualValue.TestPartition.End <= i);
     }
   }
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interfaces/ISymbolicDataAnalysisEvaluator.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interfaces/ISymbolicDataAnalysisEvaluator.cs	(revision 5758)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interfaces/ISymbolicDataAnalysisEvaluator.cs	(revision 5759)
@@ -27,9 +27,8 @@
   where T : class,IDataAnalysisProblemData {
     ILookupParameter<ISymbolicExpressionTree> SymbolicExpressionTreeParameter { get; }
-    IFixedValueParameter<IntValue> SamplesStartParameter { get; }
-    IFixedValueParameter<IntValue> SamplesEndParameter { get; }
+    IValueLookupParameter<IntRange> EvaluationPartitionParameter { get; }
+    IValueLookupParameter<PercentValue> RelativeNumberOfEvaluatedSamplesParameter { get; }
 
     IValueLookupParameter<T> ProblemDataParameter { get; }
-    T ProblemData { get; }
   }
 }
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interfaces/ISymbolicDataAnalysisValidationAnalyzer.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interfaces/ISymbolicDataAnalysisValidationAnalyzer.cs	(revision 5758)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interfaces/ISymbolicDataAnalysisValidationAnalyzer.cs	(revision 5759)
@@ -27,6 +27,6 @@
     ILookupParameter<U> ProblemDataParameter { get; }
     ILookupParameter<T> EvaluatorParameter { get; }
-    IValueLookupParameter<IntValue> ValidationSamplesStartParameter { get; }
-    IValueLookupParameter<IntValue> ValidationSamplesEndParameter { get; }
+    IValueLookupParameter<IntRange> ValidationPartitionParameter { get; }
+    IValueLookupParameter<PercentValue> RelativeNumberOfEvaluatedSamplesParameter { get; }
   }
 }
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisProblem.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisProblem.cs	(revision 5758)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisProblem.cs	(revision 5759)
@@ -50,7 +50,7 @@
     private const string MaximumFunctionDefinitionsParameterName = "MaximumFunctionDefinitions";
     private const string MaximumFunctionArgumentsParameterName = "MaximumFunctionArguments";
-    private const string RelativeNumberOfEvaluatedSamples = "RelativeNumberOfEvaluatedSamples";
+    private const string RelativeNumberOfEvaluatedSamplesParameterName = "RelativeNumberOfEvaluatedSamples";
     private const string FitnessCalculationPartitionParameterName = "FitnessCalculationPartition";
-    private const string ModelSelectionPartitionParamterName = "ModelSelectionPartition";
+    private const string ModelSelectionPartitionParameterName = "ModelSelectionPartition";
 
     private const string ProblemDataParameterDescription = "";
@@ -61,4 +61,7 @@
     private const string MaximumFunctionDefinitionsParameterDescription = "Maximal number of automatically defined functions";
     private const string MaximumFunctionArgumentsParameterDescription = "Maximal number of arguments of automatically defined functions.";
+    private const string RelativeNumberOfEvaluatedSamplesParameterDescription = "The relative number of samples of the dataset partition, which should be randomly chosen for evaluation.";
+    private const string FitnessCalculationPartitionParameterDescription = "The partition of the problem data training partition, that should be used to calculate the fitness of an individual.";
+    private const string ModelSelectionPartitionParameterDescription = "The partition of the problem data training partition, that should be used the select the best model from (optional).";
     #endregion
 
@@ -88,4 +91,13 @@
       get { return (IFixedValueParameter<IntValue>)Parameters[MaximumFunctionArgumentsParameterName]; }
     }
+    public IFixedValueParameter<PercentValue> RelativeNumberOfEvaluatedSamplesParameter {
+      get { return (IFixedValueParameter<PercentValue>)Parameters[RelativeNumberOfEvaluatedSamplesParameterName]; }
+    }
+    public IFixedValueParameter<IntRange> FitnessCalculationPartitionParameter {
+      get { return (IFixedValueParameter<IntRange>)Parameters[FitnessCalculationPartitionParameterName]; }
+    }
+    public IFixedValueParameter<IntRange> ModelSelectionPartitionParamater {
+      get { return (IFixedValueParameter<IntRange>)Parameters[ModelSelectionPartitionParameterName]; }
+    }
     #endregion
 
@@ -122,4 +134,14 @@
     public IntValue MaximumFunctionArguments {
       get { return MaximumFunctionArgumentsParameter.Value; }
+    }
+    public PercentValue RelativeNumberOfEvaluatedSamples {
+      get { return RelativeNumberOfEvaluatedSamplesParameter.Value; }
+    }
+
+    public IntRange FitnessCalculationPartition {
+      get { return FitnessCalculationPartitionParameter.Value; }
+    }
+    public IntRange ModelSelectionPartition {
+      get { return ModelSelectionPartitionParamater.Value; }
     }
     #endregion
@@ -145,4 +167,7 @@
       Parameters.Add(new FixedValueParameter<IntValue>(MaximumFunctionDefinitionsParameterName, MaximumFunctionDefinitionsParameterDescription, new IntValue()));
       Parameters.Add(new FixedValueParameter<IntValue>(MaximumFunctionArgumentsParameterName, MaximumFunctionArgumentsParameterDescription, new IntValue()));
+      Parameters.Add(new FixedValueParameter<IntRange>(FitnessCalculationPartitionParameterName, FitnessCalculationPartitionParameterDescription, new IntRange()));
+      Parameters.Add(new FixedValueParameter<IntRange>(ModelSelectionPartitionParameterName, ModelSelectionPartitionParameterDescription, new IntRange()));
+      Parameters.Add(new FixedValueParameter<PercentValue>(RelativeNumberOfEvaluatedSamplesParameterName, RelativeNumberOfEvaluatedSamplesParameterDescription, new PercentValue(1)));
 
       SymbolicExpressionTreeGrammar = new TypeCoherentExpressionGrammar();
@@ -152,16 +177,5 @@
 
       UpdateGrammar();
-      UpdateDatasetPartitions();
       RegisterEventHandlers();
-    }
-
-    protected virtual void UpdateDatasetPartitions() {
-      Evaluator.SamplesStartParameter.Value.Value = ProblemData.TrainingPartitionStart.Value;
-      Evaluator.SamplesEndParameter.Value.Value = ProblemData.TrainingPartitionEnd.Value;
-
-      foreach (var analyzer in Operators.OfType<ISymbolicDataAnalysisValidationAnalyzer<U, T>>()) {
-        analyzer.ValidationSamplesStartParameter.Value = new IntValue(ProblemData.TrainingPartitionStart.Value);
-        analyzer.ValidationSamplesEndParameter.Value = new IntValue(ProblemData.TrainingPartitionEnd.Value);
-      }
     }
 
@@ -227,5 +241,4 @@
     protected virtual void OnProblemDataChanged() {
       UpdateGrammar();
-      UpdateDatasetPartitions();
       ParameterizeOperators();
 
@@ -254,6 +267,6 @@
         op.ProblemDataParameter.ActualName = ProblemDataParameterName;
         op.SymbolicExpressionTreeParameter.ActualName = SolutionCreator.SymbolicExpressionTreeParameter.ActualName;
-        op.SamplesStartParameter.Value.Value = ProblemData.TrainingPartitionStart.Value;
-        op.SamplesEndParameter.Value.Value = ProblemData.TrainingPartitionEnd.Value;
+        op.EvaluationPartitionParameter.ActualName = FitnessCalculationPartitionParameter.Name;
+        op.RelativeNumberOfEvaluatedSamplesParameter.ActualName = RelativeNumberOfEvaluatedSamplesParameter.Name;
       }
       foreach (var op in operators.OfType<ISymbolicExpressionTreeCrossover>()) {
@@ -267,9 +280,10 @@
         op.SymbolicExpressionTreeParameter.ActualName = SolutionCreator.SymbolicExpressionTreeParameter.ActualName;
       }
+      foreach (var op in operators.OfType<ISymbolicDataAnalysisValidationAnalyzer<U, T>>()) {
+        op.RelativeNumberOfEvaluatedSamplesParameter.ActualName = RelativeNumberOfEvaluatedSamplesParameter.Name;
+        op.ValidationPartitionParameter.ActualName = ModelSelectionPartitionParamater.Name;
+      }
       foreach (var op in operators.OfType<ISymbolicDataAnalysisInterpreterOperator>()) {
         op.SymbolicDataAnalysisTreeInterpreterParameter.ActualName = SymbolicExpressionTreeInterpreterParameterName;
-      }
-      foreach (var op in operators.OfType<ISymbolicDataAnalysisAnalyzer>()) {
-        op.SymbolicExpressionTreeParameter.ActualName = SolutionCreator.SymbolicExpressionTreeParameter.ActualName;
       }
     }
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Views/3.4/Regression/RegressionSolutionLineChartView.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Views/3.4/Regression/RegressionSolutionLineChartView.cs	(revision 5758)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Views/3.4/Regression/RegressionSolutionLineChartView.cs	(revision 5759)
@@ -136,9 +136,9 @@
       this.chart.ChartAreas[0].AxisX.StripLines.Clear();
       this.CreateAndAddStripLine("Training", Color.FromArgb(20, Color.Green),
-        Content.ProblemData.TrainingPartitionStart.Value,
-        Content.ProblemData.TrainingPartitionEnd.Value);
+        Content.ProblemData.TrainingPartition.Start,
+        Content.ProblemData.TrainingPartition.End);
       this.CreateAndAddStripLine("Test", Color.FromArgb(20, Color.Red),
-        Content.ProblemData.TestPartitionStart.Value,
-        Content.ProblemData.TestPartitionEnd.Value);
+        Content.ProblemData.TestPartition.Start,
+        Content.ProblemData.TestPartition.End);
     }
 
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/DataAnalysisProblemData.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/DataAnalysisProblemData.cs	(revision 5758)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/DataAnalysisProblemData.cs	(revision 5759)
@@ -35,8 +35,6 @@
     private const string DatasetParameterName = "Dataset";
     private const string InputVariablesParameterName = "InputVariables";
-    private const string TrainingPartitionStartParameterName = "TrainingPartitionStart";
-    private const string TrainingPartitionEndParameterName = "TrainingPartitionEnd";
-    private const string TestPartitionStartParameterName = "TestPartitionStart";
-    private const string TestPartitionEndParameterName = "TestPartitionEnd";
+    private const string TrainingPartitionParameterName = "TrainingPartition";
+    private const string TestPartitionParameterName = "TestPartition";
 
     #region parameter properites
@@ -47,15 +45,9 @@
       get { return (IFixedValueParameter<ICheckedItemList<StringValue>>)Parameters[InputVariablesParameterName]; }
     }
-    public IFixedValueParameter<IntValue> TrainingPartitionStartParameter {
-      get { return (IFixedValueParameter<IntValue>)Parameters[TrainingPartitionStartParameterName]; }
+    public IFixedValueParameter<IntRange> TrainingPartitionParameter {
+      get { return (IFixedValueParameter<IntRange>)Parameters[TrainingPartitionParameterName]; }
     }
-    public IFixedValueParameter<IntValue> TrainingPartitionEndParameter {
-      get { return (IFixedValueParameter<IntValue>)Parameters[TrainingPartitionEndParameterName]; }
-    }
-    public IFixedValueParameter<IntValue> TestPartitionStartParameter {
-      get { return (IFixedValueParameter<IntValue>)Parameters[TestPartitionStartParameterName]; }
-    }
-    public IFixedValueParameter<IntValue> TestPartitionEndParameter {
-      get { return (IFixedValueParameter<IntValue>)Parameters[TestPartitionEndParameterName]; }
+    public IFixedValueParameter<IntRange> TestPartitionParameter {
+      get { return (IFixedValueParameter<IntRange>)Parameters[TestPartitionParameterName]; }
     }
     #endregion
@@ -72,26 +64,20 @@
     }
 
-    public IntValue TrainingPartitionStart {
-      get { return TrainingPartitionStartParameter.Value; }
+    public IntRange TrainingPartition {
+      get { return TrainingPartitionParameter.Value; }
     }
-    public IntValue TrainingPartitionEnd {
-      get { return TrainingPartitionEndParameter.Value; }
-    }
-    public IntValue TestPartitionStart {
-      get { return TestPartitionStartParameter.Value; }
-    }
-    public IntValue TestPartitionEnd {
-      get { return TestPartitionEndParameter.Value; }
+    public IntRange TestPartition {
+      get { return TestPartitionParameter.Value; }
     }
 
     public IEnumerable<int> TrainingIndizes {
       get {
-        return Enumerable.Range(TrainingPartitionStart.Value, TrainingPartitionEnd.Value - TrainingPartitionStart.Value)
-                         .Where(i => i >= 0 && i < Dataset.Rows && (i < TestPartitionStart.Value || TestPartitionEnd.Value <= i));
+        return Enumerable.Range(TrainingPartition.Start, TrainingPartition.End - TrainingPartition.Start)
+                         .Where(i => i >= 0 && i < Dataset.Rows && (i < TestPartition.Start || TestPartition.End <= i));
       }
     }
     public IEnumerable<int> TestIndizes {
       get {
-        return Enumerable.Range(TestPartitionStart.Value, TestPartitionEnd.Value - TestPartitionStart.Value)
+        return Enumerable.Range(TestPartition.Start, TestPartition.End - TestPartition.Start)
            .Where(i => i >= 0 && i < Dataset.Rows);
       }
@@ -121,8 +107,6 @@
       Parameters.Add(new FixedValueParameter<Dataset>(DatasetParameterName, "", dataset));
       Parameters.Add(new FixedValueParameter<ICheckedItemList<StringValue>>(InputVariablesParameterName, "", inputVariables.AsReadOnly()));
-      Parameters.Add(new FixedValueParameter<IntValue>(TrainingPartitionStartParameterName, "", new IntValue(trainingPartitionStart)));
-      Parameters.Add(new FixedValueParameter<IntValue>(TrainingPartitionEndParameterName, "", new IntValue(trainingPartitionEnd)));
-      Parameters.Add(new FixedValueParameter<IntValue>(TestPartitionStartParameterName, "", new IntValue(testPartitionStart)));
-      Parameters.Add(new FixedValueParameter<IntValue>(TestPartitionEndParameterName, "", new IntValue(testPartitionEnd)));
+      Parameters.Add(new FixedValueParameter<IntRange>(TrainingPartitionParameterName, "", new IntRange(trainingPartitionStart, trainingPartitionEnd)));
+      Parameters.Add(new FixedValueParameter<IntRange>(TestPartitionParameterName, "", new IntRange(testPartitionStart, testPartitionEnd)));
 
       ((ValueParameter<Dataset>)DatasetParameter).ReactOnValueToStringChangedAndValueItemImageChanged = false;
@@ -133,8 +117,6 @@
       DatasetParameter.ValueChanged += new EventHandler(Parameter_ValueChanged);
       InputVariables.CheckedItemsChanged += new CollectionItemsChangedEventHandler<IndexedItem<StringValue>>(InputVariables_CheckedItemsChanged);
-      TrainingPartitionStart.ValueChanged += new EventHandler(Parameter_ValueChanged);
-      TrainingPartitionEnd.ValueChanged += new EventHandler(Parameter_ValueChanged);
-      TestPartitionStart.ValueChanged += new EventHandler(Parameter_ValueChanged);
-      TestPartitionEnd.ValueChanged += new EventHandler(Parameter_ValueChanged);
+      TrainingPartition.ValueChanged += new EventHandler(Parameter_ValueChanged);
+      TestPartition.ValueChanged += new EventHandler(Parameter_ValueChanged);
     }
 
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/IDataAnalysisProblemData.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/IDataAnalysisProblemData.cs	(revision 5758)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/IDataAnalysisProblemData.cs	(revision 5759)
@@ -31,8 +31,6 @@
     IEnumerable<string> AllowedInputVariables { get; }
 
-    IntValue TrainingPartitionStart { get; }
-    IntValue TrainingPartitionEnd { get; }
-    IntValue TestPartitionStart { get; }
-    IntValue TestPartitionEnd { get; }
+    IntRange TrainingPartition { get; }
+    IntRange TestPartition { get; }
 
     IEnumerable<int> TrainingIndizes { get; }
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis/3.4/OnlineEvaluators/OnlineLinearScalingParameterCalculator.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis/3.4/OnlineEvaluators/OnlineLinearScalingParameterCalculator.cs	(revision 5758)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis/3.4/OnlineEvaluators/OnlineLinearScalingParameterCalculator.cs	(revision 5759)
@@ -78,5 +78,5 @@
     /// </summary>
     public void Add(double original, double target) {
-      // validity of values is checked in mean clculator and covariance calculator
+      // validity of values is checked in mean calculator and covariance calculator
       targetMeanCalculator.Add(target);
       originalMeanAndVarianceCalculator.Add(original);
Index: /branches/DataAnalysis Refactoring/HeuristicLab/3.3/Files.txt
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab/3.3/Files.txt	(revision 5758)
+++ /branches/DataAnalysis Refactoring/HeuristicLab/3.3/Files.txt	(revision 5759)
@@ -59,5 +59,4 @@
 HeuristicLab.Problems.DataAnalysis\3.4:HeuristicLab.Problems.DataAnalysis-3.4.dll
 HeuristicLab.Problems.DataAnalysis.Classification\3.3:HeuristicLab.Problems.DataAnalysis.Classification-3.3.dll
-HeuristicLab.Problems.DataAnalysis.Classification\3.4:HeuristicLab.Problems.DataAnalysis.Classification-3.4.dll
 HeuristicLab.Problems.DataAnalysis.Classification.Views\3.3:HeuristicLab.Problems.DataAnalysis.Classification.Views-3.3.dll
 HeuristicLab.Problems.DataAnalysis.Regression\3.3:HeuristicLab.Problems.DataAnalysis.Regression-3.3.dll
