Index: branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisProblem.cs
===================================================================
--- branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisProblem.cs	(revision 5624)
+++ branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisProblem.cs	(revision 5685)
@@ -47,6 +47,4 @@
     private const string SymbolicExpressionTreeGrammarParameterName = "SymbolicExpressionTreeGrammar";
     private const string SymbolicExpressionTreeInterpreterParameterName = "SymbolicExpressionTreeInterpreter";
-    private const string LowerEstimationLimitParameterName = "LowerEstimationLimit";
-    private const string UpperEstimationLimitParameterName = "UpperEstimationLimit";
     private const string MaximumSymbolicExpressionTreeDepthParameterName = "MaximumSymbolicExpressionTreeDepth";
     private const string MaximumSymbolicExpressionTreeLengthParameterName = "MaximumSymbolicExpressionTreeLength";
@@ -57,6 +55,4 @@
     private const string SymbolicExpressionTreeGrammarParameterDescription = "The grammar that should be used for symbolic expression tree.";
     private const string SymoblicExpressionTreeInterpreterParameterDescription = "The interpreter that should be used to evaluate the symbolic expression tree.";
-    private const string LowerEstimationLimitParameterDescription = "The lower limit for the estimated value that can be returned by the symbolic data analysis model.";
-    private const string UpperEstimationLimitParameterDescription = "The upper limit for the estimated value that can be returned by the symbolic data analysis model.";
     private const string MaximumSymbolicExpressionTreeDepthParameterDescription = "Maximal depth of the symbolic expression. The minimum depth needed for the algorithm is 3 because two levels are reserved for the ProgramRoot and the Start symbol.";
     private const string MaximumSymbolicExpressionTreeLengthParameterDescription = "Maximal length of the symbolic expression.";
@@ -78,10 +74,4 @@
       get { return (IValueParameter<ISymbolicDataAnalysisExpressionTreeInterpreter>)Parameters[SymbolicExpressionTreeInterpreterParameterName]; }
     }
-    public IFixedValueParameter<DoubleValue> LowerEstimationLimitParameter {
-      get { return (IFixedValueParameter<DoubleValue>)Parameters[LowerEstimationLimitParameterName]; }
-    }
-    public IFixedValueParameter<DoubleValue> UpperEstimationLimitParameter {
-      get { return (IFixedValueParameter<DoubleValue>)Parameters[UpperEstimationLimitParameterName]; }
-    }
     public IFixedValueParameter<IntValue> MaximumSymbolicExpressionTreeDepthParameter {
       get { return (IFixedValueParameter<IntValue>)Parameters[MaximumSymbolicExpressionTreeDepthParameterName]; }
@@ -117,11 +107,4 @@
       get { return SymbolicExpressionTreeInterpreterParameter.Value; }
       set { SymbolicExpressionTreeInterpreterParameter.Value = value; }
-    }
-
-    public DoubleValue LowerEstimationLimit {
-      get { return LowerEstimationLimitParameter.Value; }
-    }
-    public DoubleValue UpperEstimationLimit {
-      get { return UpperEstimationLimitParameter.Value; }
     }
 
@@ -156,6 +139,4 @@
       Parameters.Add(new ValueParameter<ISymbolicDataAnalysisGrammar>(SymbolicExpressionTreeGrammarParameterName, SymbolicExpressionTreeGrammarParameterDescription));
       Parameters.Add(new ValueParameter<ISymbolicDataAnalysisExpressionTreeInterpreter>(SymbolicExpressionTreeInterpreterParameterName, SymoblicExpressionTreeInterpreterParameterDescription));
-      Parameters.Add(new FixedValueParameter<DoubleValue>(LowerEstimationLimitParameterName, LowerEstimationLimitParameterDescription, new DoubleValue()));
-      Parameters.Add(new FixedValueParameter<DoubleValue>(UpperEstimationLimitParameterName, UpperEstimationLimitParameterDescription, new DoubleValue()));
       Parameters.Add(new FixedValueParameter<IntValue>(MaximumSymbolicExpressionTreeDepthParameterName, MaximumSymbolicExpressionTreeDepthParameterDescription, new IntValue()));
       Parameters.Add(new FixedValueParameter<IntValue>(MaximumSymbolicExpressionTreeLengthParameterName, MaximumSymbolicExpressionTreeLengthParameterDescription, new IntValue()));
@@ -167,23 +148,37 @@
 
       UpdateGrammar();
-      UpdateEstimationLimits();
+      UpdateDatasetPartitions();
       RegisterEventHandlers();
       InitializeOperators();
     }
 
-    protected abstract void UpdateEstimationLimits();
+    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);
+      }
+    }
+
+    protected virtual void UpdateGrammar() {
+      foreach (var varSymbol in SymbolicExpressionTreeGrammar.Symbols.OfType<HeuristicLab.Problems.DataAnalysis.Symbolic.Variable>()) {
+        varSymbol.VariableNames = ProblemData.AllowedInputVariables;
+      }
+      foreach (var varSymbol in SymbolicExpressionTreeGrammar.Symbols.OfType<HeuristicLab.Problems.DataAnalysis.Symbolic.VariableCondition>()) {
+        varSymbol.VariableNames = ProblemData.AllowedInputVariables;
+      }
+    }
 
     private void InitializeOperators() {
       Operators.AddRange(ApplicationManager.Manager.GetInstances<ISymbolicExpressionTreeOperator>());
       Operators.Add(new SymbolicExpressionSymbolFrequencyAnalyzer());
+      Operators.Add(new SymbolicDataAnalysisVariableFrequencyAnalyzer());
       Operators.Add(new MinAverageMaxSymbolicExpressionTreeLengthAnalyzer());
       ParameterizeOperators();
     }
 
-    private void ProblemDataParameter_ValueChanged(object sender, EventArgs e) {
-      ProblemDataParameter.Value.Changed += (object s, EventArgs args) => OnProblemDataChanged();
-
-      OnProblemDataChanged();
-    }
+    #region events
     private void RegisterEventHandlers() {
       ProblemDataParameter.ValueChanged += new EventHandler(ProblemDataParameter_ValueChanged);
@@ -195,14 +190,11 @@
     }
 
+    private void ProblemDataParameter_ValueChanged(object sender, EventArgs e) {
+      ProblemDataParameter.Value.Changed += (object s, EventArgs args) => OnProblemDataChanged();
+      OnProblemDataChanged();
+    }
+
     private void ArchitectureParameterValue_ValueChanged(object sender, EventArgs e) {
       UpdateGrammar();
-    }
-    protected virtual void UpdateGrammar() {
-      foreach (var varSymbol in SymbolicExpressionTreeGrammar.Symbols.OfType<HeuristicLab.Problems.DataAnalysis.Symbolic.Variable>()) {
-        varSymbol.VariableNames = ProblemData.AllowedInputVariables;
-      }
-      foreach (var varSymbol in SymbolicExpressionTreeGrammar.Symbols.OfType<HeuristicLab.Problems.DataAnalysis.Symbolic.VariableCondition>()) {
-        varSymbol.VariableNames = ProblemData.AllowedInputVariables;
-      }
     }
 
@@ -217,4 +209,5 @@
       ParameterizeOperators();
     }
+
     private void SolutionCreator_SymbolicExpressionTreeParameter_ActualNameChanged(object sender, EventArgs e) {
       ParameterizeOperators();
@@ -223,4 +216,5 @@
     protected override void OnEvaluatorChanged() {
       base.OnEvaluatorChanged();
+      ParameterizeOperators();
     }
 
@@ -228,5 +222,7 @@
     protected virtual void OnProblemDataChanged() {
       UpdateGrammar();
-      UpdateEstimationLimits();
+      UpdateDatasetPartitions();
+      ParameterizeOperators();
+
       var handler = ProblemDataChanged;
       if (handler != null) handler(this, EventArgs.Empty);
@@ -234,28 +230,25 @@
       OnReset();
     }
-
-    private void ParameterizeOperators() {
+    #endregion
+
+    protected virtual void ParameterizeOperators() {
       var operators = Parameters.OfType<IValueParameter>().Select(p => p.Value).OfType<IOperator>().Union(Operators);
 
       foreach (var op in operators.OfType<ISymbolicExpressionTreeGrammarBasedOperator>()) {
-        op.SymbolicExpressionTreeGrammarParameter.ActualName = SymbolicExpressionTreeGrammarParameter.Name;
+        op.SymbolicExpressionTreeGrammarParameter.ActualName = SymbolicExpressionTreeGrammarParameterName;
       }
       foreach (var op in operators.OfType<ISymbolicExpressionTreeSizeConstraintOperator>()) {
-        op.MaximumSymbolicExpressionTreeDepthParameter.ActualName = MaximumSymbolicExpressionTreeDepthParameter.Name;
-        op.MaximumSymbolicExpressionTreeLengthParameter.ActualName = MaximumSymbolicExpressionTreeLengthParameter.Name;
+        op.MaximumSymbolicExpressionTreeDepthParameter.ActualName = MaximumSymbolicExpressionTreeDepthParameterName;
+        op.MaximumSymbolicExpressionTreeLengthParameter.ActualName = MaximumSymbolicExpressionTreeLengthParameterName;
       }
       foreach (var op in operators.OfType<ISymbolicExpressionTreeArchitectureAlteringOperator>()) {
-        op.MaximumFunctionArgumentsParameter.ActualName = MaximumFunctionArgumentsParameter.Name;
-        op.MaximumFunctionDefinitionsParameter.ActualName = MaximumFunctionDefinitionsParameter.Name;
+        op.MaximumFunctionArgumentsParameter.ActualName = MaximumFunctionArgumentsParameterName;
+        op.MaximumFunctionDefinitionsParameter.ActualName = MaximumFunctionDefinitionsParameterName;
       }
       foreach (var op in operators.OfType<ISymbolicDataAnalysisEvaluator<T>>()) {
-        op.ProblemDataParameter.ActualName = ProblemDataParameter.Name;
+        op.ProblemDataParameter.ActualName = ProblemDataParameterName;
         op.SymbolicExpressionTreeParameter.ActualName = SolutionCreator.SymbolicExpressionTreeParameter.ActualName;
         op.SamplesStartParameter.Value.Value = ProblemData.TrainingPartitionStart.Value;
         op.SamplesEndParameter.Value.Value = ProblemData.TrainingPartitionEnd.Value;
-      }
-      foreach (var op in operators.OfType<ISymbolicDataAnalysisBoundedEvaluator<T>>()) {
-        op.LowerEstimationLimitParameter.ActualName = LowerEstimationLimitParameter.Name;
-        op.UpperEstimationLimitParameter.ActualName = UpperEstimationLimitParameter.Name;
       }
       foreach (var op in operators.OfType<ISymbolicExpressionTreeCrossover>()) {
@@ -269,4 +262,10 @@
         op.SymbolicExpressionTreeParameter.ActualName = SolutionCreator.SymbolicExpressionTreeParameter.ActualName;
       }
+      foreach (var op in operators.OfType<ISymbolicDataAnalysisInterpreterOperator>()) {
+        op.SymbolicDataAnalysisTreeInterpreterParameter.ActualName = SymbolicExpressionTreeInterpreterParameterName;
+      }
+      foreach (var op in operators.OfType<ISymbolicDataAnalysisAnalyzer>()) {
+        op.SymbolicExpressionTreeParameter.ActualName = SolutionCreator.SymbolicExpressionTreeParameter.ActualName;
+      }
     }
 
