Index: branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression-3.4.csproj
===================================================================
--- branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression-3.4.csproj	(revision 8085)
+++ branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression-3.4.csproj	(revision 8206)
@@ -112,8 +112,12 @@
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="ReplaceBranchMove.cs" />
     <Compile Include="ReplaceBranchMoveEvaluator.cs" />
     <Compile Include="Interfaces\ISymbolicRegressionMoveEvaluator.cs" />
     <Compile Include="MultiObjective\SymbolicRegressionMultiObjectiveValidationBestSolutionAnalyzer.cs" />
     <Compile Include="Plugin.cs" />
+    <Compile Include="ReplaceBranchMoveMaker.cs" />
+    <Compile Include="ReplaceBranchMoveSoftTabuCriterion.cs" />
+    <Compile Include="ReplaceBranchMoveTabuMaker.cs" />
     <Compile Include="ReplaceBranchMultiMoveGenerator.cs" />
     <Compile Include="SingleObjective\SymbolicRegressionSingleObjectiveValidationParetoBestSolutionAnalyzer.cs" />
@@ -141,5 +145,4 @@
     <Compile Include="SingleObjective\Evaluators\SymbolicRegressionSingleObjectivePearsonRSquaredEvaluator.cs" />
     <Compile Include="SymbolicRegressionSolution.cs" />
-    <Compile Include="SymbolicRegressionMoveEvaluator.cs" />
     <None Include="HeuristicLab.snk" />
     <None Include="Plugin.cs.frame" />
@@ -199,4 +202,8 @@
       <Name>HeuristicLab.Operators-3.3</Name>
       <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Optimization.Operators\3.3\HeuristicLab.Optimization.Operators-3.3.csproj">
+      <Project>{25087811-F74C-4128-BC86-8324271DA13E}</Project>
+      <Name>HeuristicLab.Optimization.Operators-3.3</Name>
     </ProjectReference>
     <ProjectReference Include="..\..\HeuristicLab.Optimization\3.3\HeuristicLab.Optimization-3.3.csproj">
Index: branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectiveProblem.cs
===================================================================
--- branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectiveProblem.cs	(revision 8085)
+++ branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectiveProblem.cs	(revision 8206)
@@ -53,5 +53,8 @@
     [StorableConstructor]
     protected SymbolicRegressionMultiObjectiveProblem(bool deserializing) : base(deserializing) { }
-    protected SymbolicRegressionMultiObjectiveProblem(SymbolicRegressionMultiObjectiveProblem original, Cloner cloner) : base(original, cloner) { }
+    protected SymbolicRegressionMultiObjectiveProblem(SymbolicRegressionMultiObjectiveProblem original, Cloner cloner)
+      : base(original, cloner) {
+      RegisterEventHandlers();
+    }
     public override IDeepCloneable Clone(Cloner cloner) { return new SymbolicRegressionMultiObjectiveProblem(this, cloner); }
 
@@ -66,9 +69,17 @@
       MaximumSymbolicExpressionTreeLength.Value = InitialMaximumTreeLength;
 
-      SymbolicExpressionTreeGrammarParameter.ValueChanged += (o, e) => ConfigureGrammarSymbols();
-
+      RegisterEventHandlers();
       ConfigureGrammarSymbols();
       InitializeOperators();
       UpdateEstimationLimits();
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      RegisterEventHandlers();
+    }
+
+    private void RegisterEventHandlers() {
+      SymbolicExpressionTreeGrammarParameter.ValueChanged += (o, e) => ConfigureGrammarSymbols();
     }
 
@@ -85,6 +96,6 @@
 
     private void UpdateEstimationLimits() {
-      if (ProblemData.TrainingIndizes.Any()) {
-        var targetValues = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TrainingIndizes).ToList();
+      if (ProblemData.TrainingIndices.Any()) {
+        var targetValues = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TrainingIndices).ToList();
         var mean = targetValues.Average();
         var range = targetValues.Max() - targetValues.Min();
Index: branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/ReplaceBranchMove.cs
===================================================================
--- branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/ReplaceBranchMove.cs	(revision 8206)
+++ branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/ReplaceBranchMove.cs	(revision 8206)
@@ -0,0 +1,84 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Regression {
+  [Item("ReplaceBranchMove", "")]
+  [StorableClass]
+  public class ReplaceBranchMove : Item {
+
+    [Storable]
+    public ISymbolicExpressionTree Tree { get; set; }
+
+    [Storable]
+    public ISymbolicExpressionTreeNode Parent { get; set; }
+
+    [Storable]
+    public int SubtreeIndex { get; set; }
+
+    [Storable]
+    public ISymbolicExpressionTreeNode NewBranch { get; set; }
+
+    [Storable]
+    public double[] OriginalOutput { get; private set; }
+
+    [Storable]
+    public double[] NewOutput { get; private set; }
+
+    [Storable]
+    public double Alpha { get; set; }
+
+    [Storable]
+    public double Beta { get; set; }
+
+
+    [StorableConstructor]
+    protected ReplaceBranchMove(bool deserializing) : base(deserializing) { }
+    protected ReplaceBranchMove(ReplaceBranchMove original, Cloner cloner)
+      : base(original, cloner) {
+      this.Tree = cloner.Clone(original.Tree);
+      this.SubtreeIndex = original.SubtreeIndex;
+      this.Parent = cloner.Clone(original.Parent);
+      this.NewBranch = cloner.Clone(original.NewBranch);
+      this.OriginalOutput = original.OriginalOutput;
+      this.NewOutput = original.NewOutput;
+      this.Alpha = original.Alpha;
+      this.Beta = original.Beta;
+    }
+    public ReplaceBranchMove(ISymbolicExpressionTree tree, ISymbolicExpressionTreeNode parent, int subtreeIndex, ISymbolicExpressionTreeNode newChild, double[] originalOutput, double[] newOutput)
+      : base() {
+      this.Tree = tree;
+      this.SubtreeIndex = subtreeIndex;
+      this.Parent = parent;
+      this.NewBranch = newChild;
+      this.OriginalOutput = originalOutput;
+      this.NewOutput = newOutput;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ReplaceBranchMove(this, cloner);
+    }
+  }
+}
Index: branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/ReplaceBranchMoveEvaluator.cs
===================================================================
--- branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/ReplaceBranchMoveEvaluator.cs	(revision 8085)
+++ branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/ReplaceBranchMoveEvaluator.cs	(revision 8206)
@@ -80,6 +80,14 @@
       var move = (ReplaceBranchMove)MoveParameter.ActualValue.Clone();
 
+      // calculate linear scaling
+      OnlineCalculatorError errorState;
+      double alpha, beta;
+      OnlineLinearScalingParameterCalculator.Calculate(move.NewOutput, move.OriginalOutput, out alpha, out beta, out errorState);
+
+      move.Alpha = alpha;
+      move.Beta = beta;
+
       move.Parent.RemoveSubtree(move.SubtreeIndex);
-      move.Parent.InsertSubtree(move.SubtreeIndex, move.NewBranch);
+      move.Parent.InsertSubtree(move.SubtreeIndex, Scale(move.NewBranch, alpha, beta));
 
       var problemData = ProblemDataParameter.ActualValue;
@@ -94,4 +102,20 @@
     }
 
+    private Addition add = new Addition();
+    private Multiplication mul = new Multiplication();
+    private Constant constant = new Constant();
+
+    private ISymbolicExpressionTreeNode Scale(ISymbolicExpressionTreeNode node, double alpha, double beta) {
+      var constAlpha = (ConstantTreeNode)constant.CreateTreeNode();
+      var constBeta = (ConstantTreeNode)constant.CreateTreeNode();
+      constAlpha.Value = alpha;
+      constBeta.Value = beta;
+      var sum = add.CreateTreeNode();
+      var prod = mul.CreateTreeNode();
+      prod.AddSubtree(node); prod.AddSubtree(constBeta);
+      sum.AddSubtree(prod); sum.AddSubtree(constAlpha);
+      return sum;
+    }
+
     public override IDeepCloneable Clone(Cloner cloner) {
       return new ReplaceBranchMoveEvaluator(this, cloner);
Index: branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/ReplaceBranchMoveMaker.cs
===================================================================
--- branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/ReplaceBranchMoveMaker.cs	(revision 8206)
+++ branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/ReplaceBranchMoveMaker.cs	(revision 8206)
@@ -0,0 +1,97 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+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;
+
+namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Regression {
+  [Item("ReplaceBranchMoveMaker", "")]
+  [StorableClass]
+  public class ReplaceBranchMoveMaker : SingleSuccessorOperator, ISymbolicExpressionTreeMoveOperator, IMoveMaker {
+    public override bool CanChangeName {
+      get { return false; }
+    }
+    public ILookupParameter<DoubleValue> QualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
+    public ILookupParameter<DoubleValue> MoveQualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["MoveQuality"]; }
+    }
+    public ILookupParameter<ReplaceBranchMove> ReplaceBranchMoveParameter {
+      get { return (ILookupParameter<ReplaceBranchMove>)Parameters["ReplaceBranchMove"]; }
+    }
+    public ILookupParameter<ISymbolicExpressionTree> SymbolicExpressionTreeParameter {
+      get { return (ILookupParameter<ISymbolicExpressionTree>)Parameters["SymbolicExpressionTree"]; }
+    }
+
+    [StorableConstructor]
+    protected ReplaceBranchMoveMaker(bool deserializing) : base(deserializing) { }
+    protected ReplaceBranchMoveMaker(ReplaceBranchMoveMaker original, Cloner cloner) : base(original, cloner) { }
+    public ReplaceBranchMoveMaker()
+      : base() {
+      Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The quality of the solution."));
+      Parameters.Add(new LookupParameter<ReplaceBranchMove>("ReplaceBranchMove", "The move to evaluate."));
+      Parameters.Add(new LookupParameter<DoubleValue>("MoveQuality", "The relative quality of the move."));
+      Parameters.Add(new LookupParameter<ISymbolicExpressionTree>("SymbolicExpressionTree", "The symbolic expression tree on which the move should be applied."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ReplaceBranchMoveMaker(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      var move = ReplaceBranchMoveParameter.ActualValue;
+      DoubleValue moveQuality = MoveQualityParameter.ActualValue;
+      DoubleValue quality = QualityParameter.ActualValue;
+
+      var newNode = (ISymbolicExpressionTreeNode)move.NewBranch.Clone();
+      move.Parent.RemoveSubtree(move.SubtreeIndex);
+      move.Parent.InsertSubtree(move.SubtreeIndex, Scale(newNode, move.Alpha, move.Beta));
+
+      quality.Value = moveQuality.Value;
+
+      return base.Apply();
+    }
+
+
+    private Addition add = new Addition();
+    private Multiplication mul = new Multiplication();
+    private Constant constant = new Constant();
+
+    private ISymbolicExpressionTreeNode Scale(ISymbolicExpressionTreeNode node, double alpha, double beta) {
+      var constAlpha = (ConstantTreeNode)constant.CreateTreeNode();
+      var constBeta = (ConstantTreeNode)constant.CreateTreeNode();
+      constAlpha.Value = alpha;
+      constBeta.Value = beta;
+      var sum = add.CreateTreeNode();
+      var prod = mul.CreateTreeNode();
+      prod.AddSubtree(node); prod.AddSubtree(constBeta);
+      sum.AddSubtree(prod); sum.AddSubtree(constAlpha);
+      return sum;
+    }
+  }
+}
Index: branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/ReplaceBranchMoveSoftTabuCriterion.cs
===================================================================
--- branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/ReplaceBranchMoveSoftTabuCriterion.cs	(revision 8206)
+++ branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/ReplaceBranchMoveSoftTabuCriterion.cs	(revision 8206)
@@ -0,0 +1,127 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Collections.Generic;
+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;
+
+namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Regression {
+  [Item("ReplaceBranchMoveSoftTabuCriterion", @"")]
+  [StorableClass]
+  public class ReplaceBranchMoveSoftTabuCriterion : SingleSuccessorOperator, ISymbolicExpressionTreeMoveOperator, ITabuChecker {
+    public override bool CanChangeName {
+      get { return false; }
+    }
+    public ILookupParameter<ReplaceBranchMove> ReplaceBranchMoveParameter {
+      get { return (LookupParameter<ReplaceBranchMove>)Parameters["ReplaceBranchMove"]; }
+    }
+    public ILookupParameter<ISymbolicExpressionTree> SymbolicExpressionTreeParameter {
+      get { return (LookupParameter<ISymbolicExpressionTree>)Parameters["SymbolicExpressionTree"]; }
+    }
+    public ILookupParameter<ItemList<IItem>> TabuListParameter {
+      get { return (ILookupParameter<ItemList<IItem>>)Parameters["TabuList"]; }
+    }
+    public ILookupParameter<BoolValue> MoveTabuParameter {
+      get { return (ILookupParameter<BoolValue>)Parameters["MoveTabu"]; }
+    }
+    public IValueLookupParameter<BoolValue> MaximizationParameter {
+      get { return (IValueLookupParameter<BoolValue>)Parameters["Maximization"]; }
+    }
+    public ILookupParameter<DoubleValue> MoveQualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["MoveQuality"]; }
+    }
+    public ValueParameter<BoolValue> UseAspirationCriterionParameter {
+      get { return (ValueParameter<BoolValue>)Parameters["UseAspirationCriterion"]; }
+    }
+
+    public BoolValue UseAspirationCriterion {
+      get { return UseAspirationCriterionParameter.Value; }
+      set { UseAspirationCriterionParameter.Value = value; }
+    }
+
+    [StorableConstructor]
+    protected ReplaceBranchMoveSoftTabuCriterion(bool deserializing) : base(deserializing) { }
+    protected ReplaceBranchMoveSoftTabuCriterion(ReplaceBranchMoveSoftTabuCriterion original, Cloner cloner) : base(original, cloner) { }
+    public ReplaceBranchMoveSoftTabuCriterion()
+      : base() {
+      Parameters.Add(new LookupParameter<ReplaceBranchMove>("ReplaceBranchMove", "The move to evaluate."));
+      Parameters.Add(new LookupParameter<BoolValue>("MoveTabu", "The variable to store if a move was tabu."));
+      Parameters.Add(new LookupParameter<ISymbolicExpressionTree>("SymbolicExpressionTree", "The solution as symbolic expression tree."));
+      Parameters.Add(new LookupParameter<ItemList<IItem>>("TabuList", "The tabu list."));
+      Parameters.Add(new ValueParameter<BoolValue>("UseAspirationCriterion", "Whether to use the aspiration criterion or not.", new BoolValue(true)));
+      Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "True if the problem is a maximization problem, else if it is a minimization problem."));
+      Parameters.Add(new LookupParameter<DoubleValue>("MoveQuality", "The quality of the current move."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ReplaceBranchMoveSoftTabuCriterion(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      ItemList<IItem> tabuList = TabuListParameter.ActualValue;
+      var move = ReplaceBranchMoveParameter.ActualValue;
+      var tree = SymbolicExpressionTreeParameter.ActualValue;
+      bool isTabu = true;
+      bool useAspiration = UseAspirationCriterion.Value;
+      bool maximization = MaximizationParameter.ActualValue.Value;
+      double moveQuality = MoveQualityParameter.ActualValue.Value;
+
+      List<int> path = new List<int>();
+      path.Add(move.SubtreeIndex);
+      var parent = move.Parent.Parent;
+      var child = move.Parent;
+      while (parent != null) {
+        path.Add(parent.IndexOfSubtree(child));
+        child = parent;
+        parent = parent.Parent;
+      }
+      path.Reverse();
+
+      isTabu = false;
+      for (int i = 0; i < tabuList.Count && isTabu == false; i++) {
+        var tabuAttribute = tabuList[i];
+        var absTabuAttribute = tabuAttribute as ChangeNodeTypeMoveAbsoluteAttribute;
+        if (!useAspiration
+              || maximization && moveQuality <= absTabuAttribute.MoveQuality
+              || !maximization && moveQuality >= absTabuAttribute.MoveQuality) {
+          if (absTabuAttribute != null && absTabuAttribute.Path.Length == path.Count) {
+            isTabu = true;
+            for (int j = 0; j < path.Count; j++) {
+              if (absTabuAttribute.Path[j] != path[j]) {
+                isTabu = false;
+                break;
+              }
+            }
+          }
+        }
+      }
+
+      MoveTabuParameter.ActualValue = new BoolValue(isTabu);
+      return base.Apply();
+    }
+  }
+}
Index: branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/ReplaceBranchMoveTabuMaker.cs
===================================================================
--- branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/ReplaceBranchMoveTabuMaker.cs	(revision 8206)
+++ branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/ReplaceBranchMoveTabuMaker.cs	(revision 8206)
@@ -0,0 +1,73 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Collections.Generic;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HeuristicLab.Optimization.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Regression {
+  [Item("ReplaceBranchMoveTabuMaker", "")]
+  [StorableClass]
+  public class ReplaceBranchMoveTabuMaker : TabuMaker, ISymbolicExpressionTreeMoveOperator {
+    public ILookupParameter<ISymbolicExpressionTree> SymbolicExpressionTreeParameter {
+      get { return (ILookupParameter<ISymbolicExpressionTree>)Parameters["SymbolicExpressionTree"]; }
+    }
+    public ILookupParameter<ReplaceBranchMove> ReplaceBranchMoveParameter {
+      get { return (LookupParameter<ReplaceBranchMove>)Parameters["ReplaceBranchMove"]; }
+    }
+
+    [StorableConstructor]
+    protected ReplaceBranchMoveTabuMaker(bool deserializing) : base(deserializing) { }
+    protected ReplaceBranchMoveTabuMaker(ReplaceBranchMoveTabuMaker original, Cloner cloner) : base(original, cloner) { }
+    public ReplaceBranchMoveTabuMaker()
+      : base() {
+      Parameters.Add(new LookupParameter<ReplaceBranchMove>("ReplaceBranchMove", "The move that was made."));
+      Parameters.Add(new LookupParameter<ISymbolicExpressionTree>("SymbolicExpressionTree", "The solution as symbolic expression tree."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ReplaceBranchMoveTabuMaker(this, cloner);
+    }
+
+    protected override IItem GetTabuAttribute(bool maximization, double quality, double moveQuality) {
+      var move = ReplaceBranchMoveParameter.ActualValue;
+      var tree = SymbolicExpressionTreeParameter.ActualValue;
+      double baseQuality = moveQuality;
+      if (maximization && quality > moveQuality || !maximization && quality < moveQuality) baseQuality = quality; // we make an uphill move, the lower bound is the solution quality
+
+      List<int> path = new List<int>();
+      path.Add(move.SubtreeIndex);
+      var parent = move.Parent.Parent;
+      var child = move.Parent;
+      while (parent != null) {
+        path.Add(parent.IndexOfSubtree(child));
+        child = parent;
+        parent = parent.Parent;
+      }
+      path.Reverse();
+      return new ChangeNodeTypeMoveAbsoluteAttribute(path.ToArray(), baseQuality);
+    }
+  }
+}
Index: branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/ReplaceBranchMultiMoveGenerator.cs
===================================================================
--- branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/ReplaceBranchMultiMoveGenerator.cs	(revision 8085)
+++ branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/ReplaceBranchMultiMoveGenerator.cs	(revision 8206)
@@ -20,4 +20,5 @@
 #endregion
 
+using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -63,4 +64,17 @@
       get { return (LookupParameter<ReplaceBranchMove>)Parameters["ReplaceBranchMove"]; }
     }
+
+    public IValueParameter<IntValue> ReplacementBranchesPoolSize {
+      get { return (IValueParameter<IntValue>)Parameters["ReplacementBranchesPoolSize"]; }
+    }
+
+    public IValueParameter<IntValue> MaxReplacementBranchLength {
+      get { return (IValueParameter<IntValue>)Parameters["MaxReplacementBranchLength"]; }
+    }
+
+    public IValueParameter<IntValue> MaxReplacementBranchDepth {
+      get { return (IValueParameter<IntValue>)Parameters["MaxReplacementBranchDepth"]; }
+    }
+
     protected ScopeParameter CurrentScopeParameter {
       get { return (ScopeParameter)Parameters["CurrentScope"]; }
@@ -84,4 +98,7 @@
       Parameters.Add(new LookupParameter<ISymbolicDataAnalysisExpressionTreeInterpreter>("Interpreter"));
       Parameters.Add(new LookupParameter<IRegressionProblemData>("ProblemData"));
+      Parameters.Add(new ValueParameter<IntValue>("ReplacementBranchesPoolSize", new IntValue(10000)));
+      Parameters.Add(new ValueParameter<IntValue>("MaxReplacementBranchLength", new IntValue(8)));
+      Parameters.Add(new ValueParameter<IntValue>("MaxReplacementBranchDepth", new IntValue(4)));
     }
 
@@ -121,5 +138,4 @@
     public IEnumerable<ReplaceBranchMove> GenerateMoves(ISymbolicExpressionTree tree, IRandom random, int n) {
       int count = 0;
-      var g = tree.Root.Grammar;
       var possibleChildren = (from parent in tree.Root.GetSubtree(0).IterateNodesPrefix()
                               from i in Enumerable.Range(0, parent.SubtreeCount)
@@ -136,4 +152,5 @@
 
       while (count < n) {
+        // select a random replacement point
         var selected = possibleChildren[random.Next(possibleChildren.Length)];
         // evaluate 
@@ -142,14 +159,19 @@
         start.RemoveSubtree(0);
 
-        var bestTrees = new SortedList<double, ISymbolicExpressionTree>();
-        double bestSimilarity = double.MaxValue;
+        var bestTrees = new SortedList<double, Tuple<ISymbolicExpressionTree, double[]>>();
+        double bestSimilarity = 0.0;
+        // iterate over the whole pool of branches for replacement
         for (int i = 0; i < trees.Count; i++) {
+          // if the branch is allowed in the selected point
           if (tree.Root.Grammar.IsAllowedChildSymbol(selected.parent.Symbol, trees[i].Root.GetSubtree(0).GetSubtree(0).Symbol, selected.i)) {
             OnlineCalculatorError error;
-            double similarity = OnlineMeanSquaredErrorCalculator.Calculate(output, treeOutput[i], out error);
-            if (error != OnlineCalculatorError.None) similarity = double.MaxValue;
-            if (similarity < bestSimilarity && !similarity.IsAlmost(0.0)) {
+            // calculate the similarity
+            double similarity = OnlinePearsonsRSquaredCalculator.Calculate(output, treeOutput[i], out error);
+            if (error != OnlineCalculatorError.None) similarity = 0.0;
+
+            // if we found a new bestSimilarity then keep the replacement branch in a sorted list (keep maximally the 30 best for this replacement point)
+            if (similarity > bestSimilarity && !similarity.IsAlmost(1.0)) {
               bestSimilarity = similarity;
-              bestTrees.Add(similarity, trees[i]);
+              bestTrees.Add(similarity, Tuple.Create(trees[i], treeOutput[i]));
               if (bestTrees.Count > 30)
                 bestTrees.RemoveAt(bestTrees.Count - 1);
@@ -157,7 +179,14 @@
           }
         }
-        foreach (var bestTree in bestTrees.Values) {
+        // did not find a move better than similarity 0.0 => create a move to replace it with a random branch
+        // this is necessary to make it possible to replace branches that evaluate to NaN or infinity
+        if (bestTrees.Count == 0) {
+          int r = random.Next(trees.Count);
+          bestTrees.Add(0.0, Tuple.Create(trees[r], treeOutput[r]));
+        }
+        // yield moves (we need to add linear scaling parameters for the inserted tree)
+        foreach (var pair in bestTrees.Values) {
           yield return
-            new ReplaceBranchMove(tree, selected.parent, selected.i, bestTree.Root.GetSubtree(0).GetSubtree(0));
+            new ReplaceBranchMove(tree, selected.parent, selected.i, pair.Item1.Root.GetSubtree(0).GetSubtree(0), output, pair.Item2);
           count++;
         }
@@ -166,9 +195,10 @@
 
     private void InitializeOperator() {
-      trees = new List<ISymbolicExpressionTree>();
-      treeOutput = new List<double[]>();
+      // init locally and set only at the end in case of exceptions
+      var trees = new List<ISymbolicExpressionTree>();
+      var treeOutput = new List<double[]>();
       var random = RandomParameter.ActualValue;
       var g = SymbolicExpressionTreeGrammarParameter.ActualValue;
-      var constSym = g.AllowedSymbols.Single(s => s is Constant);
+      var constSym = g.Symbols.Single(s => s is Constant);
       // temporarily disable constants
       double oldConstFreq = constSym.InitialFrequency;
@@ -177,12 +207,20 @@
       var ds = ProblemDataParameter.ActualValue.Dataset;
       var rows = ProblemDataParameter.ActualValue.TrainingIndizes;
-      for (int i = 0; i < 10000; i++) {
-        var t = ProbabilisticTreeCreator.Create(random, g, 8, 4);
+      // create pool of random branches for replacement (no constants)
+      // and evaluate the output
+      // only keep trees if the output does not contain invalid values
+      var n = ReplacementBranchesPoolSize.Value.Value;
+      while (trees.Count < n) {
+        var t = ProbabilisticTreeCreator.Create(random, g, MaxReplacementBranchLength.Value.Value, MaxReplacementBranchDepth.Value.Value);
         var output = interpreter.GetSymbolicExpressionTreeValues(t, ds, rows);
-        trees.Add(t);
-        treeOutput.Add(output.ToArray());
+        if (!output.Any(x => double.IsInfinity(x) || double.IsNaN(x))) {
+          trees.Add(t);
+          treeOutput.Add(output.ToArray());
+        }
       }
       // enable constants again
       constSym.InitialFrequency = oldConstFreq;
+      this.trees = trees;
+      this.treeOutput = treeOutput;
     }
 
Index: branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/SymbolicRegressionSingleObjectiveEvaluator.cs
===================================================================
--- branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/SymbolicRegressionSingleObjectiveEvaluator.cs	(revision 8085)
+++ branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/SymbolicRegressionSingleObjectiveEvaluator.cs	(revision 8206)
@@ -22,4 +22,5 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -59,5 +60,7 @@
     private static double[] cache;
 
-    protected static void CalculateWithScaling(IEnumerable<double> targetValues, IEnumerable<double> estimatedValues, IOnlineCalculator calculator, int maxRows) {
+    protected static void CalculateWithScaling(IEnumerable<double> targetValues, IEnumerable<double> estimatedValues,
+      double lowerEstimationLimit, double upperEstimationLimit,
+      IOnlineCalculator calculator, int maxRows) {
       if (cache == null || cache.GetLength(0) < maxRows) {
         cache = new double[maxRows];
@@ -83,10 +86,9 @@
       //calculate the quality by using the passed online calculator
       targetValuesEnumerator = targetValues.GetEnumerator();
-      i = 0;
-      while (targetValuesEnumerator.MoveNext()) {
-        double target = targetValuesEnumerator.Current;
-        double estimated = cache[i] * beta + alpha;
-        calculator.Add(target, estimated);
-        i++;
+      var scaledBoundedEstimatedValuesEnumerator = Enumerable.Range(0, i).Select(x => cache[x] * beta + alpha)
+        .LimitToRange(lowerEstimationLimit, upperEstimationLimit).GetEnumerator();
+
+      while (targetValuesEnumerator.MoveNext() & scaledBoundedEstimatedValuesEnumerator.MoveNext()) {
+        calculator.Add(targetValuesEnumerator.Current, scaledBoundedEstimatedValuesEnumerator.Current);
       }
     }
Index: branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/SymbolicRegressionSingleObjectiveMaxAbsoluteErrorEvaluator.cs
===================================================================
--- branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/SymbolicRegressionSingleObjectiveMaxAbsoluteErrorEvaluator.cs	(revision 8085)
+++ branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/SymbolicRegressionSingleObjectiveMaxAbsoluteErrorEvaluator.cs	(revision 8206)
@@ -56,5 +56,4 @@
       IEnumerable<double> estimatedValues = interpreter.GetSymbolicExpressionTreeValues(solution, problemData.Dataset, rows);
       IEnumerable<double> targetValues = problemData.Dataset.GetDoubleValues(problemData.TargetVariable, rows);
-      IEnumerable<double> boundedEstimatedValues = estimatedValues.LimitToRange(lowerEstimationLimit, upperEstimationLimit);
       OnlineCalculatorError errorState;
 
@@ -62,10 +61,11 @@
       if (applyLinearScaling) {
         var maeCalculator = new OnlineMaxAbsoluteErrorCalculator();
-        CalculateWithScaling(targetValues, boundedEstimatedValues, maeCalculator, problemData.Dataset.Rows);
+        CalculateWithScaling(targetValues, estimatedValues, lowerEstimationLimit, upperEstimationLimit, maeCalculator, problemData.Dataset.Rows);
         errorState = maeCalculator.ErrorState;
         mse = maeCalculator.MaxAbsoluteError;
-      } else
+      } else {
+        IEnumerable<double> boundedEstimatedValues = estimatedValues.LimitToRange(lowerEstimationLimit, upperEstimationLimit);
         mse = OnlineMaxAbsoluteErrorCalculator.Calculate(targetValues, boundedEstimatedValues, out errorState);
-
+      }
       if (errorState != OnlineCalculatorError.None) return Double.NaN;
       else return mse;
Index: branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/SymbolicRegressionSingleObjectiveMeanAbsoluteErrorEvaluator.cs
===================================================================
--- branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/SymbolicRegressionSingleObjectiveMeanAbsoluteErrorEvaluator.cs	(revision 8085)
+++ branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/SymbolicRegressionSingleObjectiveMeanAbsoluteErrorEvaluator.cs	(revision 8206)
@@ -56,5 +56,4 @@
       IEnumerable<double> estimatedValues = interpreter.GetSymbolicExpressionTreeValues(solution, problemData.Dataset, rows);
       IEnumerable<double> targetValues = problemData.Dataset.GetDoubleValues(problemData.TargetVariable, rows);
-      IEnumerable<double> boundedEstimatedValues = estimatedValues.LimitToRange(lowerEstimationLimit, upperEstimationLimit);
       OnlineCalculatorError errorState;
 
@@ -62,10 +61,12 @@
       if (applyLinearScaling) {
         var maeCalculator = new OnlineMeanAbsoluteErrorCalculator();
-        CalculateWithScaling(targetValues, boundedEstimatedValues, maeCalculator, problemData.Dataset.Rows);
+        CalculateWithScaling(targetValues, estimatedValues, lowerEstimationLimit, upperEstimationLimit, maeCalculator, problemData.Dataset.Rows);
         errorState = maeCalculator.ErrorState;
         mse = maeCalculator.MeanAbsoluteError;
-      } else
+      } else {
+        IEnumerable<double> boundedEstimatedValues = estimatedValues.LimitToRange(lowerEstimationLimit,
+                                                                                  upperEstimationLimit);
         mse = OnlineMeanSquaredErrorCalculator.Calculate(targetValues, boundedEstimatedValues, out errorState);
-
+      }
       if (errorState != OnlineCalculatorError.None) return Double.NaN;
       else return mse;
Index: branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/SymbolicRegressionSingleObjectiveMeanSquaredErrorEvaluator.cs
===================================================================
--- branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/SymbolicRegressionSingleObjectiveMeanSquaredErrorEvaluator.cs	(revision 8085)
+++ branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/SymbolicRegressionSingleObjectiveMeanSquaredErrorEvaluator.cs	(revision 8206)
@@ -56,5 +56,4 @@
       IEnumerable<double> estimatedValues = interpreter.GetSymbolicExpressionTreeValues(solution, problemData.Dataset, rows);
       IEnumerable<double> targetValues = problemData.Dataset.GetDoubleValues(problemData.TargetVariable, rows);
-      IEnumerable<double> boundedEstimatedValues = estimatedValues.LimitToRange(lowerEstimationLimit, upperEstimationLimit);
       OnlineCalculatorError errorState;
 
@@ -62,10 +61,11 @@
       if (applyLinearScaling) {
         var mseCalculator = new OnlineMeanSquaredErrorCalculator();
-        CalculateWithScaling(targetValues, boundedEstimatedValues, mseCalculator, problemData.Dataset.Rows);
+        CalculateWithScaling(targetValues, estimatedValues, lowerEstimationLimit, upperEstimationLimit, mseCalculator, problemData.Dataset.Rows);
         errorState = mseCalculator.ErrorState;
         mse = mseCalculator.MeanSquaredError;
-      } else
+      } else {
+        IEnumerable<double> boundedEstimatedValues = estimatedValues.LimitToRange(lowerEstimationLimit, upperEstimationLimit);
         mse = OnlineMeanSquaredErrorCalculator.Calculate(targetValues, boundedEstimatedValues, out errorState);
-
+      }
       if (errorState != OnlineCalculatorError.None) return Double.NaN;
       else return mse;
Index: branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/SymbolicRegressionSingleObjectiveProblem.cs
===================================================================
--- branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/SymbolicRegressionSingleObjectiveProblem.cs	(revision 8085)
+++ branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/SymbolicRegressionSingleObjectiveProblem.cs	(revision 8206)
@@ -49,5 +49,8 @@
     [StorableConstructor]
     protected SymbolicRegressionSingleObjectiveProblem(bool deserializing) : base(deserializing) { }
-    protected SymbolicRegressionSingleObjectiveProblem(SymbolicRegressionSingleObjectiveProblem original, Cloner cloner) : base(original, cloner) { }
+    protected SymbolicRegressionSingleObjectiveProblem(SymbolicRegressionSingleObjectiveProblem original, Cloner cloner)
+      : base(original, cloner) {
+      RegisterEventHandlers();
+    }
     public override IDeepCloneable Clone(Cloner cloner) { return new SymbolicRegressionSingleObjectiveProblem(this, cloner); }
 
@@ -62,9 +65,30 @@
       MaximumSymbolicExpressionTreeLength.Value = InitialMaximumTreeLength;
 
-      SymbolicExpressionTreeGrammarParameter.ValueChanged += (o, e) => ConfigureGrammarSymbols();
-
+      RegisterEventHandlers();
       ConfigureGrammarSymbols();
       InitializeOperators();
       UpdateEstimationLimits();
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      RegisterEventHandlers();
+      // compatibility
+      bool changed = false;
+      if (!Operators.OfType<SymbolicRegressionSingleObjectiveTrainingParetoBestSolutionAnalyzer>().Any()) {
+        Operators.Add(new SymbolicRegressionSingleObjectiveTrainingParetoBestSolutionAnalyzer());
+        changed = true;
+      }
+      if (!Operators.OfType<SymbolicRegressionSingleObjectiveValidationParetoBestSolutionAnalyzer>().Any()) {
+        Operators.Add(new SymbolicRegressionSingleObjectiveValidationParetoBestSolutionAnalyzer());
+        changed = true;
+      }
+      if (changed) {
+        ParameterizeOperators();
+      }
+    }
+
+    private void RegisterEventHandlers() {
+      SymbolicExpressionTreeGrammarParameter.ValueChanged += (o, e) => ConfigureGrammarSymbols();
     }
 
@@ -85,6 +109,6 @@
 
     private void UpdateEstimationLimits() {
-      if (ProblemData.TrainingIndizes.Any()) {
-        var targetValues = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TrainingIndizes).ToList();
+      if (ProblemData.TrainingIndices.Any()) {
+        var targetValues = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TrainingIndices).ToList();
         var mean = targetValues.Average();
         var range = targetValues.Max() - targetValues.Min();
Index: branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/SymbolicRegressionSingleObjectiveTrainingParetoBestSolutionAnalyzer.cs
===================================================================
--- branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/SymbolicRegressionSingleObjectiveTrainingParetoBestSolutionAnalyzer.cs	(revision 8085)
+++ branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/SymbolicRegressionSingleObjectiveTrainingParetoBestSolutionAnalyzer.cs	(revision 8206)
@@ -33,20 +33,7 @@
   [Item("SymbolicRegressionSingleObjectiveTrainingParetoBestSolutionAnalyzer", "An operator that collects the training Pareto-best symbolic regression solutions for single objective symbolic regression problems.")]
   [StorableClass]
-  public sealed class SymbolicRegressionSingleObjectiveTrainingParetoBestSolutionAnalyzer : SymbolicDataAnalysisSingleObjectiveTrainingParetoBestSolutionAnalyzer<ISymbolicRegressionSolution>,
-  ISymbolicDataAnalysisInterpreterOperator, ISymbolicDataAnalysisBoundedOperator {
-    private const string ProblemDataParameterName = "ProblemData";
-    private const string SymbolicDataAnalysisTreeInterpreterParameterName = "SymbolicDataAnalysisTreeInterpreter";
-    private const string EstimationLimitsParameterName = "EstimationLimits";
+  public sealed class SymbolicRegressionSingleObjectiveTrainingParetoBestSolutionAnalyzer : SymbolicDataAnalysisSingleObjectiveTrainingParetoBestSolutionAnalyzer<IRegressionProblemData, ISymbolicRegressionSolution> {
     private const string ApplyLinearScalingParameterName = "ApplyLinearScaling";
     #region parameter properties
-    public ILookupParameter<IRegressionProblemData> ProblemDataParameter {
-      get { return (ILookupParameter<IRegressionProblemData>)Parameters[ProblemDataParameterName]; }
-    }
-    public ILookupParameter<ISymbolicDataAnalysisExpressionTreeInterpreter> SymbolicDataAnalysisTreeInterpreterParameter {
-      get { return (ILookupParameter<ISymbolicDataAnalysisExpressionTreeInterpreter>)Parameters[SymbolicDataAnalysisTreeInterpreterParameterName]; }
-    }
-    public IValueLookupParameter<DoubleLimit> EstimationLimitsParameter {
-      get { return (IValueLookupParameter<DoubleLimit>)Parameters[EstimationLimitsParameterName]; }
-    }
     public IValueParameter<BoolValue> ApplyLinearScalingParameter {
       get { return (IValueParameter<BoolValue>)Parameters[ApplyLinearScalingParameterName]; }
@@ -65,7 +52,4 @@
     public SymbolicRegressionSingleObjectiveTrainingParetoBestSolutionAnalyzer()
       : base() {
-      Parameters.Add(new LookupParameter<IRegressionProblemData>(ProblemDataParameterName, "The problem data for the symbolic regression solution."));
-      Parameters.Add(new LookupParameter<ISymbolicDataAnalysisExpressionTreeInterpreter>(SymbolicDataAnalysisTreeInterpreterParameterName, "The symbolic data analysis tree interpreter for the symbolic expression tree."));
-      Parameters.Add(new ValueLookupParameter<DoubleLimit>(EstimationLimitsParameterName, "The lower and upper limit for the estimated values produced by the symbolic regression model."));
       Parameters.Add(new ValueParameter<BoolValue>(ApplyLinearScalingParameterName, "Flag that indicates if the produced symbolic regression solution should be linearly scaled.", new BoolValue(true)));
     }
Index: branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/SymbolicRegressionSingleObjectiveValidationParetoBestSolutionAnalyzer.cs
===================================================================
--- branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/SymbolicRegressionSingleObjectiveValidationParetoBestSolutionAnalyzer.cs	(revision 8085)
+++ branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/SymbolicRegressionSingleObjectiveValidationParetoBestSolutionAnalyzer.cs	(revision 8206)
@@ -33,12 +33,7 @@
   [Item("SymbolicRegressionSingleObjectiveValidationParetoBestSolutionAnalyzer", "An operator that collects the validation Pareto-best symbolic regression solutions for single objective symbolic regression problems.")]
   [StorableClass]
-  public sealed class SymbolicRegressionSingleObjectiveValidationParetoBestSolutionAnalyzer : SymbolicDataAnalysisSingleObjectiveValidationParetoBestSolutionAnalyzer<ISymbolicRegressionSolution, ISymbolicRegressionSingleObjectiveEvaluator, IRegressionProblemData>,
-  ISymbolicDataAnalysisInterpreterOperator, ISymbolicDataAnalysisBoundedOperator {
-    private const string EstimationLimitsParameterName = "EstimationLimits";
+  public sealed class SymbolicRegressionSingleObjectiveValidationParetoBestSolutionAnalyzer : SymbolicDataAnalysisSingleObjectiveValidationParetoBestSolutionAnalyzer<ISymbolicRegressionSolution, ISymbolicRegressionSingleObjectiveEvaluator, IRegressionProblemData> {
     private const string ApplyLinearScalingParameterName = "ApplyLinearScaling";
     #region parameter properties
-    public IValueLookupParameter<DoubleLimit> EstimationLimitsParameter {
-      get { return (IValueLookupParameter<DoubleLimit>)Parameters[EstimationLimitsParameterName]; }
-    }
     public IValueParameter<BoolValue> ApplyLinearScalingParameter {
       get { return (IValueParameter<BoolValue>)Parameters[ApplyLinearScalingParameterName]; }
@@ -57,5 +52,4 @@
     public SymbolicRegressionSingleObjectiveValidationParetoBestSolutionAnalyzer()
       : base() {
-      Parameters.Add(new ValueLookupParameter<DoubleLimit>(EstimationLimitsParameterName, "The lower and upper limit for the estimated values produced by the symbolic regression model."));
       Parameters.Add(new ValueParameter<BoolValue>(ApplyLinearScalingParameterName, "Flag that indicates if the produced symbolic regression solution should be linearly scaled.", new BoolValue(true)));
     }
Index: branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SymbolicRegressionModel.cs
===================================================================
--- branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SymbolicRegressionModel.cs	(revision 8085)
+++ branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SymbolicRegressionModel.cs	(revision 8206)
@@ -73,5 +73,5 @@
       var dataset = problemData.Dataset;
       var targetVariable = problemData.TargetVariable;
-      var rows = problemData.TrainingIndizes;
+      var rows = problemData.TrainingIndices;
       var estimatedValues = model.Interpreter.GetSymbolicExpressionTreeValues(model.SymbolicExpressionTree, dataset, rows);
       var targetValues = dataset.GetDoubleValues(targetVariable, rows);
Index: branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SymbolicRegressionMoveEvaluator.cs
===================================================================
--- branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SymbolicRegressionMoveEvaluator.cs	(revision 8085)
+++ branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SymbolicRegressionMoveEvaluator.cs	(revision 8206)
@@ -81,5 +81,4 @@
       // clone the move and all contained objects to make sure that the items in the scope are untouched
       var move = (ChangeNodeTypeMove)MoveParameter.ActualValue.Clone();
-      var t = SymbolicExpressionTreeParameter.ActualValue;
       var oldNode = move.Parent.GetSubtree(move.SubtreeIndex);
       var children = new List<ISymbolicExpressionTreeNode>(oldNode.Subtrees);
