Index: /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.3/LinearRegression.cs
===================================================================
--- /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.3/LinearRegression.cs	(revision 3891)
+++ /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.3/LinearRegression.cs	(revision 3892)
@@ -120,6 +120,5 @@
 
     protected override void Problem_Reset(object sender, EventArgs e) {
-      TrainingSamplesStartParameter.ActualValue = Problem.DataAnalysisProblemData.TrainingSamplesStart;
-      TrainingSamplesEndParameter.ActualValue = Problem.DataAnalysisProblemData.TrainingSamplesEnd;      
+      UpdateAlgorithmParameterValues();
       base.Problem_Reset(sender, e);
     }
@@ -129,10 +128,10 @@
       solutionCreator.DataAnalysisProblemDataParameter.ActualName = Problem.DataAnalysisProblemDataParameter.Name;
       evaluator.RegressionProblemDataParameter.ActualName = Problem.DataAnalysisProblemDataParameter.Name;
-      analyzer.ProblemDataParameter.ActualName = Problem.DataAnalysisProblemDataParameter.Name; 
-      TrainingSamplesStartParameter.ActualValue = Problem.DataAnalysisProblemData.TrainingSamplesStart;
-      TrainingSamplesEndParameter.ActualValue = Problem.DataAnalysisProblemData.TrainingSamplesEnd;
+      analyzer.ProblemDataParameter.ActualName = Problem.DataAnalysisProblemDataParameter.Name;
+      UpdateAlgorithmParameterValues();
       Problem.Reset += new EventHandler(Problem_Reset);
       base.OnProblemChanged();
     }
+
 
     #endregion
@@ -145,6 +144,4 @@
       solutionCreator.SymbolicExpressionTreeParameter.ActualName = LinearRegressionModelParameterName;
 
-      evaluator.LowerEstimationLimitParameter.Value = new DoubleValue(double.NegativeInfinity);
-      evaluator.UpperEstimationLimitParameter.Value = new DoubleValue(double.PositiveInfinity);
       evaluator.SymbolicExpressionTreeParameter.ActualName = solutionCreator.SymbolicExpressionTreeParameter.ActualName;
       evaluator.SymbolicExpressionTreeInterpreterParameter.ActualName = ModelInterpreterParameter.Name;
@@ -161,6 +158,4 @@
       analyzer.QualityParameter.Depth = 0;
       analyzer.SymbolicExpressionTreeInterpreterParameter.ActualName = ModelInterpreterParameter.Name;
-      analyzer.LowerEstimationLimitParameter.Value = new DoubleValue(double.NegativeInfinity);
-      analyzer.UpperEstimationLimitParameter.Value = new DoubleValue(double.PositiveInfinity);
 
       if (Problem != null) {
@@ -171,4 +166,19 @@
       }
     }
+
+    private void UpdateAlgorithmParameterValues() {
+      TrainingSamplesStartParameter.ActualValue = Problem.DataAnalysisProblemData.TrainingSamplesStart;
+      TrainingSamplesEndParameter.ActualValue = Problem.DataAnalysisProblemData.TrainingSamplesEnd;
+      //var targetValues =
+      //  Problem.DataAnalysisProblemData.Dataset.GetVariableValues(Problem.DataAnalysisProblemData.TargetVariable.Value,
+      //  TrainingSamplesStartParameter.Value.Value, TrainingSamplesEndParameter.Value.Value);
+      //double range = targetValues.Max() - targetValues.Min();
+      //double lowerEstimationLimit = targetValues.Average() - 10.0 * range;
+      //double upperEstimationLimit = targetValues.Average() + 10.0 * range;
+      //evaluator.LowerEstimationLimitParameter.Value = new DoubleValue(lowerEstimationLimit);
+      //evaluator.UpperEstimationLimitParameter.Value = new DoubleValue(upperEstimationLimit);
+      //analyzer.LowerEstimationLimitParameter.Value = new DoubleValue(lowerEstimationLimit);
+      //analyzer.UpperEstimationLimitParameter.Value = new DoubleValue(upperEstimationLimit);
+    }
     #endregion
   }
Index: /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.3/SupportVectorMachine.cs
===================================================================
--- /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.3/SupportVectorMachine.cs	(revision 3891)
+++ /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.3/SupportVectorMachine.cs	(revision 3892)
@@ -169,6 +169,5 @@
 
     protected override void Problem_Reset(object sender, EventArgs e) {
-      TrainingSamplesStartParameter.ActualValue = Problem.DataAnalysisProblemData.TrainingSamplesStart;
-      TrainingSamplesEndParameter.ActualValue = Problem.DataAnalysisProblemData.TrainingSamplesEnd;
+      UpdateAlgorithmParameters();
       base.Problem_Reset(sender, e);
     }
@@ -179,6 +178,5 @@
       evaluator.DataAnalysisProblemDataParameter.ActualName = Problem.DataAnalysisProblemDataParameter.Name;
       analyzer.ProblemDataParameter.ActualName = Problem.DataAnalysisProblemDataParameter.Name;
-      TrainingSamplesStartParameter.ActualValue = Problem.DataAnalysisProblemData.TrainingSamplesStart;
-      TrainingSamplesEndParameter.ActualValue = Problem.DataAnalysisProblemData.TrainingSamplesEnd;
+      UpdateAlgorithmParameters();
       Problem.Reset += new EventHandler(Problem_Reset);
       base.OnProblemChanged();
@@ -210,6 +208,4 @@
       analyzer.QualityParameter.ActualName = mseEvaluator.MeanSquaredErrorParameter.ActualName;
       analyzer.QualityParameter.Depth = 0;
-      analyzer.LowerEstimationLimitParameter.Value = new DoubleValue(double.NegativeInfinity);
-      analyzer.UpperEstimationLimitParameter.Value = new DoubleValue(double.PositiveInfinity);
 
       if (Problem != null) {
@@ -220,4 +216,9 @@
       }
     }
+
+    private void UpdateAlgorithmParameters() {
+      TrainingSamplesStartParameter.ActualValue = Problem.DataAnalysisProblemData.TrainingSamplesStart;
+      TrainingSamplesEndParameter.ActualValue = Problem.DataAnalysisProblemData.TrainingSamplesEnd;
+    }
     #endregion
   }
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/Analyzers/RegressionSolutionAnalyzer.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/Analyzers/RegressionSolutionAnalyzer.cs	(revision 3892)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/Analyzers/RegressionSolutionAnalyzer.cs	(revision 3892)
@@ -0,0 +1,151 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 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.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HeuristicLab.Problems.DataAnalysis.Regression.Symbolic;
+using HeuristicLab.Problems.DataAnalysis.Symbolic;
+using System.Collections.Generic;
+using HeuristicLab.Problems.DataAnalysis.Symbolic.Symbols;
+using HeuristicLab.Problems.DataAnalysis;
+using HeuristicLab.Problems.DataAnalysis.Evaluators;
+
+namespace HeuristicLab.Problems.DataAnalysis.Regression.Symbolic.Analyzers {
+  [StorableClass]
+  public abstract class RegressionSolutionAnalyzer : SingleSuccessorOperator {
+    private const string ProblemDataParameterName = "ProblemData";
+    private const string QualityParameterName = "Quality";
+    private const string UpperEstimationLimitParameterName = "UpperEstimationLimit";
+    private const string LowerEstimationLimitParameterName = "LowerEstimationLimit";
+    private const string BestSolutionQualityParameterName = "BestSolutionQuality";
+    private const string ResultsParameterName = "Results";
+    private const string BestSolutionResultName = "Best solution (on validiation set)";
+    private const string BestSolutionTrainingRSquared = "Best solution R² (training)";
+    private const string BestSolutionTestRSquared = "Best solution R² (test)";
+    private const string BestSolutionTrainingMse = "Best solution mean squared error (training)";
+    private const string BestSolutionTestMse = "Best solution mean squared error (test)";
+    private const string BestSolutionTrainingRelativeError = "Best solution average relative error (training)";
+    private const string BestSolutionTestRelativeError = "Best solution average relative error (test)";
+
+    #region parameter properties
+    public IValueLookupParameter<DataAnalysisProblemData> ProblemDataParameter {
+      get { return (IValueLookupParameter<DataAnalysisProblemData>)Parameters[ProblemDataParameterName]; }
+    }
+    public ScopeTreeLookupParameter<DoubleValue> QualityParameter {
+      get { return (ScopeTreeLookupParameter<DoubleValue>)Parameters[QualityParameterName]; }
+    }
+    public IValueLookupParameter<DoubleValue> UpperEstimationLimitParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters[UpperEstimationLimitParameterName]; }
+    }
+    public IValueLookupParameter<DoubleValue> LowerEstimationLimitParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters[LowerEstimationLimitParameterName]; }
+    }
+    public ILookupParameter<DoubleValue> BestSolutionQualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters[BestSolutionQualityParameterName]; }
+    }
+    public ILookupParameter<ResultCollection> ResultsParameter {
+      get { return (ILookupParameter<ResultCollection>)Parameters[ResultsParameterName]; }
+    }
+    #endregion
+    #region properties
+    public DoubleValue UpperEstimationLimit {
+      get { return UpperEstimationLimitParameter.ActualValue; }
+    }
+    public DoubleValue LowerEstimationLimit {
+      get { return LowerEstimationLimitParameter.ActualValue; }
+    }
+    public ItemArray<DoubleValue> Quality {
+      get { return QualityParameter.ActualValue; }
+    }
+    public ResultCollection Results {
+      get { return ResultsParameter.ActualValue; }
+    }
+    public DataAnalysisProblemData ProblemData {
+      get { return ProblemDataParameter.ActualValue; }
+    }
+    #endregion
+
+    public RegressionSolutionAnalyzer()
+      : base() {
+      Parameters.Add(new ValueLookupParameter<DataAnalysisProblemData>(ProblemDataParameterName, "The problem data for which the symbolic expression tree is a solution."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>(UpperEstimationLimitParameterName, "The upper estimation limit that was set for the evaluation of the symbolic expression trees."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>(LowerEstimationLimitParameterName, "The lower estimation limit that was set for the evaluation of the symbolic expression trees."));
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>(QualityParameterName, "The qualities of the symbolic regression trees which should be analyzed."));
+      Parameters.Add(new LookupParameter<DoubleValue>(BestSolutionQualityParameterName, "The quality of the best regression solution."));
+      Parameters.Add(new LookupParameter<ResultCollection>(ResultsParameterName, "The result collection where the best symbolic regression solution should be stored."));
+    }
+
+    public override IOperation Apply() {
+      DoubleValue prevBestSolutionQuality = BestSolutionQualityParameter.ActualValue;
+      var bestSolution = UpdateBestSolution();
+      if (prevBestSolutionQuality == null || prevBestSolutionQuality.Value > BestSolutionQualityParameter.ActualValue.Value) {
+        UpdateBestSolutionResults(bestSolution);
+      }
+
+      return base.Apply();
+    }
+    private void UpdateBestSolutionResults(DataAnalysisSolution bestSolution) {
+      var solution = bestSolution;
+      #region update R2,MSE, Rel Error
+      double[] trainingValues = ProblemData.Dataset.GetVariableValues(
+        ProblemData.TargetVariable.Value,
+        ProblemData.TrainingSamplesStart.Value,
+        ProblemData.TrainingSamplesEnd.Value);
+      double[] testValues = ProblemData.Dataset.GetVariableValues(
+        ProblemData.TargetVariable.Value,
+        ProblemData.TestSamplesStart.Value,
+        ProblemData.TestSamplesEnd.Value);
+      double trainingR2 = SimpleRSquaredEvaluator.Calculate(trainingValues, solution.EstimatedTrainingValues);
+      double testR2 = SimpleRSquaredEvaluator.Calculate(testValues, solution.EstimatedTestValues);
+      double trainingMse = SimpleMSEEvaluator.Calculate(trainingValues, solution.EstimatedTrainingValues);
+      double testMse = SimpleMSEEvaluator.Calculate(testValues, solution.EstimatedTestValues);
+      double trainingRelError = SimpleMeanAbsolutePercentageErrorEvaluator.Calculate(trainingValues, solution.EstimatedTrainingValues);
+      double testRelError = SimpleMeanAbsolutePercentageErrorEvaluator.Calculate(testValues, solution.EstimatedTestValues);
+      if (Results.ContainsKey(BestSolutionResultName)) {
+        Results[BestSolutionResultName].Value = solution;
+        Results[BestSolutionTrainingRSquared].Value = new DoubleValue(trainingR2);
+        Results[BestSolutionTestRSquared].Value = new DoubleValue(testR2);
+        Results[BestSolutionTrainingMse].Value = new DoubleValue(trainingMse);
+        Results[BestSolutionTestMse].Value = new DoubleValue(testMse);
+        Results[BestSolutionTrainingRelativeError].Value = new DoubleValue(trainingRelError);
+        Results[BestSolutionTestRelativeError].Value = new DoubleValue(testRelError);
+      } else {
+        Results.Add(new Result(BestSolutionResultName, solution));
+        Results.Add(new Result(BestSolutionTrainingRSquared, new DoubleValue(trainingR2)));
+        Results.Add(new Result(BestSolutionTestRSquared, new DoubleValue(testR2)));
+        Results.Add(new Result(BestSolutionTrainingMse, new DoubleValue(trainingMse)));
+        Results.Add(new Result(BestSolutionTestMse, new DoubleValue(testMse)));
+        Results.Add(new Result(BestSolutionTrainingRelativeError, new DoubleValue(trainingRelError)));
+        Results.Add(new Result(BestSolutionTestRelativeError, new DoubleValue(testRelError)));
+      }
+      #endregion
+    }
+
+    protected abstract DataAnalysisSolution UpdateBestSolution();
+  }
+}
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/HeuristicLab.Problems.DataAnalysis.Regression-3.3.csproj
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/HeuristicLab.Problems.DataAnalysis.Regression-3.3.csproj	(revision 3891)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/HeuristicLab.Problems.DataAnalysis.Regression-3.3.csproj	(revision 3892)
@@ -84,4 +84,7 @@
     <None Include="HeuristicLabProblemsDataAnalysisRegressionPlugin.cs.frame" />
     <None Include="Properties\AssemblyInfo.frame" />
+    <Compile Include="Analyzers\RegressionSolutionAnalyzer.cs">
+      <SubType>Code</SubType>
+    </Compile>
     <Compile Include="HeuristicLabProblemsDataAnalysisRegressionPlugin.cs" />
     <Compile Include="LinearRegression\LinearRegressionSolutionCreator.cs" />
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/SupportVectorRegression/BestSupportVectorRegressionSolutionAnalyzer.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/SupportVectorRegression/BestSupportVectorRegressionSolutionAnalyzer.cs	(revision 3891)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/SupportVectorRegression/BestSupportVectorRegressionSolutionAnalyzer.cs	(revision 3892)
@@ -36,136 +36,56 @@
 using HeuristicLab.Problems.DataAnalysis.Evaluators;
 using HeuristicLab.Problems.DataAnalysis.SupportVectorMachine;
+using HeuristicLab.Problems.DataAnalysis.Regression.Symbolic.Analyzers;
 
 namespace HeuristicLab.Problems.DataAnalysis.Regression.SupportVectorRegression {
-  [Item("BestSupportVectorRegressionSolutionAnalyzer", "An operator for analyzing the best support vector solution of regression problems.")]
+  [Item("BestSupportVectorRegressionSolutionAnalyzer", "An operator for analyzing the best solution of support vector regression problems.")]
   [StorableClass]
-  public sealed class BestSupportVectorRegressionSolutionAnalyzer : SingleSuccessorOperator, IAnalyzer {
+  public sealed class BestSupportVectorRegressionSolutionAnalyzer : RegressionSolutionAnalyzer {
     private const string SupportVectorRegressionModelParameterName = "SupportVectorRegressionModel";
-    private const string ProblemDataParameterName = "ProblemData";
-    private const string QualityParameterName = "Quality";
-    private const string UpperEstimationLimitParameterName = "UpperEstimationLimit";
-    private const string LowerEstimationLimitParameterName = "LowerEstimationLimit";
+    private const string BestSolutionInputvariableCountResultName = "Variables used by best solution";
     private const string BestSolutionParameterName = "BestSolution";
-    private const string BestSolutionQualityParameterName = "BestSolutionQuality";
-    private const string ResultsParameterName = "Results";
-    private const string BestSolutionResultName = "Best solution (on validiation set)";
-    private const string BestSolutionInputvariableCountResultName = "Variables used by best solution";
-    private const string BestSolutionTrainingRSquared = "Best solution R² (training)";
-    private const string BestSolutionTestRSquared = "Best solution R² (test)";
-    private const string BestSolutionTrainingMse = "Best solution mean squared error (training)";
-    private const string BestSolutionTestMse = "Best solution mean squared error (test)";
-    private const string BestSolutionTrainingRelativeError = "Best solution average relative error (training)";
-    private const string BestSolutionTestRelativeError = "Best solution average relative error (test)";
 
+    #region parameter properties
     public ScopeTreeLookupParameter<SupportVectorMachineModel> SupportVectorRegressionModelParameter {
       get { return (ScopeTreeLookupParameter<SupportVectorMachineModel>)Parameters[SupportVectorRegressionModelParameterName]; }
-    }
-    public IValueLookupParameter<DataAnalysisProblemData> ProblemDataParameter {
-      get { return (IValueLookupParameter<DataAnalysisProblemData>)Parameters[ProblemDataParameterName]; }
-    }
-    public ScopeTreeLookupParameter<DoubleValue> QualityParameter {
-      get { return (ScopeTreeLookupParameter<DoubleValue>)Parameters[QualityParameterName]; }
-    }
-    public IValueLookupParameter<DoubleValue> UpperEstimationLimitParameter {
-      get { return (IValueLookupParameter<DoubleValue>)Parameters[UpperEstimationLimitParameterName]; }
-    }
-    public IValueLookupParameter<DoubleValue> LowerEstimationLimitParameter {
-      get { return (IValueLookupParameter<DoubleValue>)Parameters[LowerEstimationLimitParameterName]; }
     }
     public ILookupParameter<SupportVectorRegressionSolution> BestSolutionParameter {
       get { return (ILookupParameter<SupportVectorRegressionSolution>)Parameters[BestSolutionParameterName]; }
     }
-    public ILookupParameter<DoubleValue> BestSolutionQualityParameter {
-      get { return (ILookupParameter<DoubleValue>)Parameters[BestSolutionQualityParameterName]; }
+    #endregion
+    #region properties
+    public ItemArray<SupportVectorMachineModel> SupportVectorMachineModel {
+      get { return SupportVectorRegressionModelParameter.ActualValue; }
     }
-    public ILookupParameter<ResultCollection> ResultsParameter {
-      get { return (ILookupParameter<ResultCollection>)Parameters[ResultsParameterName]; }
-    }
+    #endregion
 
     public BestSupportVectorRegressionSolutionAnalyzer()
       : base() {
       Parameters.Add(new ScopeTreeLookupParameter<SupportVectorMachineModel>(SupportVectorRegressionModelParameterName, "The support vector regression models to analyze."));
-      Parameters.Add(new ValueLookupParameter<DataAnalysisProblemData>(ProblemDataParameterName, "The problem data for which the support vector model is a solution."));
-      Parameters.Add(new ValueLookupParameter<DoubleValue>(UpperEstimationLimitParameterName, "The upper estimation limit that was set for the evaluation of the support vector model."));
-      Parameters.Add(new ValueLookupParameter<DoubleValue>(LowerEstimationLimitParameterName, "The lower estimation limit that was set for the evaluation of the support vector model."));
-      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>(QualityParameterName, "The qualities of the support vector models which should be analyzed."));
-      Parameters.Add(new LookupParameter<SupportVectorRegressionSolution>(BestSolutionParameterName, "The best support vector solution."));
-      Parameters.Add(new LookupParameter<DoubleValue>(BestSolutionQualityParameterName, "The quality of the best support vector solution."));
-      Parameters.Add(new LookupParameter<ResultCollection>(ResultsParameterName, "The result collection where the best support vector solution should be stored."));
+      Parameters.Add(new LookupParameter<SupportVectorRegressionSolution>(BestSolutionParameterName, "The best support vector regression solution."));
     }
 
-    public override IOperation Apply() {
-      ItemArray<DoubleValue> qualities = QualityParameter.ActualValue;
-      ResultCollection results = ResultsParameter.ActualValue;
-      ItemArray<SupportVectorMachineModel> models = SupportVectorRegressionModelParameter.ActualValue;
-      DataAnalysisProblemData problemData = ProblemDataParameter.ActualValue;
-      DoubleValue upperEstimationLimit = UpperEstimationLimitParameter.ActualValue;
-      DoubleValue lowerEstimationLimit = LowerEstimationLimitParameter.ActualValue;
-      var inputVariables = ProblemDataParameter.ActualValue.InputVariables.Select(x => x.Value);
+    protected override DataAnalysisSolution UpdateBestSolution() {
+      double upperEstimationLimit = UpperEstimationLimit != null ? UpperEstimationLimit.Value : double.PositiveInfinity;
+      double lowerEstimationLimit = LowerEstimationLimit != null ? LowerEstimationLimit.Value : double.NegativeInfinity;
 
-      int i = qualities.Select((x, index) => new { index, x.Value }).OrderBy(x => x.Value).First().index;
+      int i = Quality.Select((x, index) => new { index, x.Value }).OrderBy(x => x.Value).First().index;
 
-      SupportVectorRegressionSolution solution = BestSolutionParameter.ActualValue;
-      if (solution == null) {
-        solution = new SupportVectorRegressionSolution(problemData, models[i], inputVariables, lowerEstimationLimit.Value, upperEstimationLimit.Value);
+      if (BestSolutionQualityParameter.ActualValue == null || BestSolutionQualityParameter.ActualValue.Value > Quality[i].Value) {
+        IEnumerable<string> inputVariables = from var in ProblemData.InputVariables
+                                             where ProblemData.InputVariables.ItemChecked(var)
+                                             select var.Value;
+        var solution = new SupportVectorRegressionSolution(ProblemData, SupportVectorMachineModel[i], inputVariables, lowerEstimationLimit, upperEstimationLimit);
+
         BestSolutionParameter.ActualValue = solution;
-        BestSolutionQualityParameter.ActualValue = qualities[i];
-        results.Add(new Result(BestSolutionResultName, solution));
-        results.Add(new Result(BestSolutionInputvariableCountResultName, new IntValue(inputVariables.Count())));
-        #region calculate R2,MSE,Rel Error
-        double[] trainingValues = problemData.Dataset.GetVariableValues(
-          problemData.TargetVariable.Value,
-          problemData.TrainingSamplesStart.Value,
-          problemData.TrainingSamplesEnd.Value);
-        double[] testValues = problemData.Dataset.GetVariableValues(
-          problemData.TargetVariable.Value,
-          problemData.TestSamplesStart.Value,
-          problemData.TestSamplesEnd.Value);
-        double trainingR2 = SimpleRSquaredEvaluator.Calculate(trainingValues, solution.EstimatedTrainingValues);
-        double testR2 = SimpleRSquaredEvaluator.Calculate(testValues, solution.EstimatedTestValues);
-        double trainingMse = SimpleMSEEvaluator.Calculate(trainingValues, solution.EstimatedTrainingValues);
-        double testMse = SimpleMSEEvaluator.Calculate(testValues, solution.EstimatedTestValues);
-        double trainingRelError = SimpleMeanAbsolutePercentageErrorEvaluator.Calculate(trainingValues, solution.EstimatedTrainingValues);
-        double testRelError = SimpleMeanAbsolutePercentageErrorEvaluator.Calculate(testValues, solution.EstimatedTestValues);
-        results.Add(new Result(BestSolutionTrainingRSquared, new DoubleValue(trainingR2)));
-        results.Add(new Result(BestSolutionTestRSquared, new DoubleValue(testR2)));
-        results.Add(new Result(BestSolutionTrainingMse, new DoubleValue(trainingMse)));
-        results.Add(new Result(BestSolutionTestMse, new DoubleValue(testMse)));
-        results.Add(new Result(BestSolutionTrainingRelativeError, new DoubleValue(trainingRelError)));
-        results.Add(new Result(BestSolutionTestRelativeError, new DoubleValue(testRelError)));
-        #endregion
-      } else {
-        if (BestSolutionQualityParameter.ActualValue.Value > qualities[i].Value) {
-          solution = new SupportVectorRegressionSolution(problemData, models[i], inputVariables, lowerEstimationLimit.Value, upperEstimationLimit.Value);
-          BestSolutionParameter.ActualValue = solution;
-          BestSolutionQualityParameter.ActualValue = qualities[i];
-          results[BestSolutionResultName].Value = solution;
-          results[BestSolutionInputvariableCountResultName].Value = new IntValue(inputVariables.Count());
-          #region update R2,MSE, Rel Error
-          double[] trainingValues = problemData.Dataset.GetVariableValues(
-            problemData.TargetVariable.Value,
-            problemData.TrainingSamplesStart.Value,
-            problemData.TrainingSamplesEnd.Value);
-          double[] testValues = problemData.Dataset.GetVariableValues(
-            problemData.TargetVariable.Value,
-            problemData.TestSamplesStart.Value,
-            problemData.TestSamplesEnd.Value);
-          double trainingR2 = SimpleRSquaredEvaluator.Calculate(trainingValues, solution.EstimatedTrainingValues);
-          double testR2 = SimpleRSquaredEvaluator.Calculate(testValues, solution.EstimatedTestValues);
-          double trainingMse = SimpleMSEEvaluator.Calculate(trainingValues, solution.EstimatedTrainingValues);
-          double testMse = SimpleMSEEvaluator.Calculate(testValues, solution.EstimatedTestValues);
-          double trainingRelError = SimpleMeanAbsolutePercentageErrorEvaluator.Calculate(trainingValues, solution.EstimatedTrainingValues);
-          double testRelError = SimpleMeanAbsolutePercentageErrorEvaluator.Calculate(testValues, solution.EstimatedTestValues);
-          results[BestSolutionTrainingRSquared].Value = new DoubleValue(trainingR2);
-          results[BestSolutionTestRSquared].Value = new DoubleValue(testR2);
-          results[BestSolutionTrainingMse].Value = new DoubleValue(trainingMse);
-          results[BestSolutionTestMse].Value = new DoubleValue(testMse);
-          results[BestSolutionTrainingRelativeError].Value = new DoubleValue(trainingRelError);
-          results[BestSolutionTestRelativeError].Value = new DoubleValue(testRelError);
-          #endregion
+        BestSolutionQualityParameter.ActualValue = Quality[i];
+
+        if (Results.ContainsKey(BestSolutionInputvariableCountResultName)) {
+          Results[BestSolutionInputvariableCountResultName].Value = new IntValue(inputVariables.Count());
+        } else {
+          Results.Add(new Result(BestSolutionInputvariableCountResultName, new IntValue(inputVariables.Count())));
         }
       }
-
-      return base.Apply();
+      return BestSolutionParameter.ActualValue;
     }
   }
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/Symbolic/Analyzers/BestSymbolicRegressionSolutionAnalyzer.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/Symbolic/Analyzers/BestSymbolicRegressionSolutionAnalyzer.cs	(revision 3891)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/Symbolic/Analyzers/BestSymbolicRegressionSolutionAnalyzer.cs	(revision 3892)
@@ -39,23 +39,11 @@
   [Item("BestSymbolicRegressionSolutionAnalyzer", "An operator for analyzing the best solution of symbolic regression problems given in symbolic expression tree encoding.")]
   [StorableClass]
-  public sealed class BestSymbolicRegressionSolutionAnalyzer : SingleSuccessorOperator, ISymbolicRegressionAnalyzer {
+  public sealed class BestSymbolicRegressionSolutionAnalyzer : RegressionSolutionAnalyzer, ISymbolicRegressionAnalyzer {
     private const string SymbolicExpressionTreeParameterName = "SymbolicExpressionTree";
     private const string SymbolicExpressionTreeInterpreterParameterName = "SymbolicExpressionTreeInterpreter";
-    private const string ProblemDataParameterName = "ProblemData";
-    private const string QualityParameterName = "Quality";
-    private const string UpperEstimationLimitParameterName = "UpperEstimationLimit";
-    private const string LowerEstimationLimitParameterName = "LowerEstimationLimit";
+    private const string BestSolutionInputvariableCountResultName = "Variables used by best solution";
     private const string BestSolutionParameterName = "BestSolution";
-    private const string BestSolutionQualityParameterName = "BestSolutionQuality";
-    private const string ResultsParameterName = "Results";
-    private const string BestSolutionResultName = "Best solution (on validiation set)";
-    private const string BestSolutionInputvariableCountResultName = "Variables used by best solution";
-    private const string BestSolutionTrainingRSquared = "Best solution R² (training)";
-    private const string BestSolutionTestRSquared = "Best solution R² (test)";
-    private const string BestSolutionTrainingMse = "Best solution mean squared error (training)";
-    private const string BestSolutionTestMse = "Best solution mean squared error (test)";
-    private const string BestSolutionTrainingRelativeError = "Best solution average relative error (training)";
-    private const string BestSolutionTestRelativeError = "Best solution average relative error (test)";
 
+    #region parameter properties
     public ScopeTreeLookupParameter<SymbolicExpressionTree> SymbolicExpressionTreeParameter {
       get { return (ScopeTreeLookupParameter<SymbolicExpressionTree>)Parameters[SymbolicExpressionTreeParameterName]; }
@@ -64,25 +52,16 @@
       get { return (IValueLookupParameter<ISymbolicExpressionTreeInterpreter>)Parameters[SymbolicExpressionTreeInterpreterParameterName]; }
     }
-    public IValueLookupParameter<DataAnalysisProblemData> ProblemDataParameter {
-      get { return (IValueLookupParameter<DataAnalysisProblemData>)Parameters[ProblemDataParameterName]; }
-    }
-    public ScopeTreeLookupParameter<DoubleValue> QualityParameter {
-      get { return (ScopeTreeLookupParameter<DoubleValue>)Parameters[QualityParameterName]; }
-    }
-    public IValueLookupParameter<DoubleValue> UpperEstimationLimitParameter {
-      get { return (IValueLookupParameter<DoubleValue>)Parameters[UpperEstimationLimitParameterName]; }
-    }
-    public IValueLookupParameter<DoubleValue> LowerEstimationLimitParameter {
-      get { return (IValueLookupParameter<DoubleValue>)Parameters[LowerEstimationLimitParameterName]; }
-    }
     public ILookupParameter<SymbolicRegressionSolution> BestSolutionParameter {
       get { return (ILookupParameter<SymbolicRegressionSolution>)Parameters[BestSolutionParameterName]; }
     }
-    public ILookupParameter<DoubleValue> BestSolutionQualityParameter {
-      get { return (ILookupParameter<DoubleValue>)Parameters[BestSolutionQualityParameterName]; }
+    #endregion
+    #region properties
+    public ISymbolicExpressionTreeInterpreter SymbolicExpressionTreeInterpreter {
+      get { return SymbolicExpressionTreeInterpreterParameter.ActualValue; }
     }
-    public ILookupParameter<ResultCollection> ResultsParameter {
-      get { return (ILookupParameter<ResultCollection>)Parameters[ResultsParameterName]; }
+    public ItemArray<SymbolicExpressionTree> SymbolicExpressionTree {
+      get { return SymbolicExpressionTreeParameter.ActualValue; }
     }
+    #endregion
 
     public BestSymbolicRegressionSolutionAnalyzer()
@@ -90,88 +69,29 @@
       Parameters.Add(new ScopeTreeLookupParameter<SymbolicExpressionTree>(SymbolicExpressionTreeParameterName, "The symbolic expression trees to analyze."));
       Parameters.Add(new ValueLookupParameter<ISymbolicExpressionTreeInterpreter>(SymbolicExpressionTreeInterpreterParameterName, "The interpreter that should be used for the analysis of symbolic expression trees."));
-      Parameters.Add(new ValueLookupParameter<DataAnalysisProblemData>(ProblemDataParameterName, "The problem data for which the symbolic expression tree is a solution."));
-      Parameters.Add(new ValueLookupParameter<DoubleValue>(UpperEstimationLimitParameterName, "The upper estimation limit that was set for the evaluation of the symbolic expression trees."));
-      Parameters.Add(new ValueLookupParameter<DoubleValue>(LowerEstimationLimitParameterName, "The lower estimation limit that was set for the evaluation of the symbolic expression trees."));
-      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>(QualityParameterName, "The qualities of the symbolic regression trees which should be analyzed."));
       Parameters.Add(new LookupParameter<SymbolicRegressionSolution>(BestSolutionParameterName, "The best symbolic regression solution."));
-      Parameters.Add(new LookupParameter<DoubleValue>(BestSolutionQualityParameterName, "The quality of the best symbolic regression solution."));
-      Parameters.Add(new LookupParameter<ResultCollection>(ResultsParameterName, "The result collection where the best symbolic regression solution should be stored."));
     }
 
-    public override IOperation Apply() {
-      ItemArray<DoubleValue> qualities = QualityParameter.ActualValue;
-      ResultCollection results = ResultsParameter.ActualValue;
-      ISymbolicExpressionTreeInterpreter interpreter = SymbolicExpressionTreeInterpreterParameter.ActualValue;
-      ItemArray<SymbolicExpressionTree> expressions = SymbolicExpressionTreeParameter.ActualValue;
-      DataAnalysisProblemData problemData = ProblemDataParameter.ActualValue;
-      DoubleValue upperEstimationLimit = UpperEstimationLimitParameter.ActualValue;
-      DoubleValue lowerEstimationLimit = LowerEstimationLimitParameter.ActualValue;
+    protected override DataAnalysisSolution UpdateBestSolution() {
+      double upperEstimationLimit = UpperEstimationLimit != null ? UpperEstimationLimit.Value : double.PositiveInfinity;
+      double lowerEstimationLimit = LowerEstimationLimit != null ? LowerEstimationLimit.Value : double.NegativeInfinity;
 
-      int i = qualities.Select((x, index) => new { index, x.Value }).OrderBy(x => x.Value).First().index;
+      int i = Quality.Select((x, index) => new { index, x.Value }).OrderBy(x => x.Value).First().index;
 
-      SymbolicRegressionSolution solution = BestSolutionParameter.ActualValue;
-      if (solution == null) {
-        var model = new SymbolicRegressionModel((ISymbolicExpressionTreeInterpreter)interpreter.Clone(), expressions[i], GetInputVariables(expressions[i]));
-        solution = new SymbolicRegressionSolution(problemData, model, lowerEstimationLimit.Value, upperEstimationLimit.Value);
+      if (BestSolutionQualityParameter.ActualValue == null || BestSolutionQualityParameter.ActualValue.Value > Quality[i].Value) {
+        var model = new SymbolicRegressionModel((ISymbolicExpressionTreeInterpreter)SymbolicExpressionTreeInterpreter.Clone(),
+          SymbolicExpressionTree[i],
+          GetInputVariables(SymbolicExpressionTree[i]));
+        var solution = new SymbolicRegressionSolution(ProblemData, model, lowerEstimationLimit, upperEstimationLimit);
+
         BestSolutionParameter.ActualValue = solution;
-        BestSolutionQualityParameter.ActualValue = qualities[i];
-        results.Add(new Result(BestSolutionResultName, solution));
-        results.Add(new Result(BestSolutionInputvariableCountResultName, new IntValue(model.InputVariables.Count())));
-        #region calculate R2,MSE,Rel Error
-        double[] trainingValues = problemData.Dataset.GetVariableValues(
-          problemData.TargetVariable.Value,
-          problemData.TrainingSamplesStart.Value,
-          problemData.TrainingSamplesEnd.Value);
-        double[] testValues = problemData.Dataset.GetVariableValues(
-          problemData.TargetVariable.Value,
-          problemData.TestSamplesStart.Value,
-          problemData.TestSamplesEnd.Value);
-        double trainingR2 = SimpleRSquaredEvaluator.Calculate(trainingValues, solution.EstimatedTrainingValues);
-        double testR2 = SimpleRSquaredEvaluator.Calculate(testValues, solution.EstimatedTestValues);
-        double trainingMse = SimpleMSEEvaluator.Calculate(trainingValues, solution.EstimatedTrainingValues);
-        double testMse = SimpleMSEEvaluator.Calculate(testValues, solution.EstimatedTestValues);
-        double trainingRelError = SimpleMeanAbsolutePercentageErrorEvaluator.Calculate(trainingValues, solution.EstimatedTrainingValues);
-        double testRelError = SimpleMeanAbsolutePercentageErrorEvaluator.Calculate(testValues, solution.EstimatedTestValues);
-        results.Add(new Result(BestSolutionTrainingRSquared, new DoubleValue(trainingR2)));
-        results.Add(new Result(BestSolutionTestRSquared, new DoubleValue(testR2)));
-        results.Add(new Result(BestSolutionTrainingMse, new DoubleValue(trainingMse)));
-        results.Add(new Result(BestSolutionTestMse, new DoubleValue(testMse)));
-        results.Add(new Result(BestSolutionTrainingRelativeError, new DoubleValue(trainingRelError)));
-        results.Add(new Result(BestSolutionTestRelativeError, new DoubleValue(testRelError)));
-        #endregion
-      } else {
-        if (BestSolutionQualityParameter.ActualValue.Value > qualities[i].Value) {
-          var model = new SymbolicRegressionModel((ISymbolicExpressionTreeInterpreter)interpreter.Clone(), expressions[i], GetInputVariables(expressions[i]));
-          solution = new SymbolicRegressionSolution(problemData, model, lowerEstimationLimit.Value, upperEstimationLimit.Value);
-          BestSolutionParameter.ActualValue = solution;
-          BestSolutionQualityParameter.ActualValue = qualities[i];
-          results[BestSolutionResultName].Value = solution;
-          results[BestSolutionInputvariableCountResultName].Value = new IntValue(model.InputVariables.Count());
-          #region update R2,MSE, Rel Error
-          double[] trainingValues = problemData.Dataset.GetVariableValues(
-            problemData.TargetVariable.Value,
-            problemData.TrainingSamplesStart.Value,
-            problemData.TrainingSamplesEnd.Value);
-          double[] testValues = problemData.Dataset.GetVariableValues(
-            problemData.TargetVariable.Value,
-            problemData.TestSamplesStart.Value,
-            problemData.TestSamplesEnd.Value);
-          double trainingR2 = SimpleRSquaredEvaluator.Calculate(trainingValues, solution.EstimatedTrainingValues);
-          double testR2 = SimpleRSquaredEvaluator.Calculate(testValues, solution.EstimatedTestValues);
-          double trainingMse = SimpleMSEEvaluator.Calculate(trainingValues, solution.EstimatedTrainingValues);
-          double testMse = SimpleMSEEvaluator.Calculate(testValues, solution.EstimatedTestValues);
-          double trainingRelError = SimpleMeanAbsolutePercentageErrorEvaluator.Calculate(trainingValues, solution.EstimatedTrainingValues);
-          double testRelError = SimpleMeanAbsolutePercentageErrorEvaluator.Calculate(testValues, solution.EstimatedTestValues);
-          results[BestSolutionTrainingRSquared].Value = new DoubleValue(trainingR2);
-          results[BestSolutionTestRSquared].Value = new DoubleValue(testR2);
-          results[BestSolutionTrainingMse].Value = new DoubleValue(trainingMse);
-          results[BestSolutionTestMse].Value = new DoubleValue(testMse);
-          results[BestSolutionTrainingRelativeError].Value = new DoubleValue(trainingRelError);
-          results[BestSolutionTestRelativeError].Value = new DoubleValue(testRelError);
-          #endregion
+        BestSolutionQualityParameter.ActualValue = Quality[i];
+
+        if (Results.ContainsKey(BestSolutionInputvariableCountResultName)) {
+          Results[BestSolutionInputvariableCountResultName].Value = new IntValue(model.InputVariables.Count());
+        } else {
+          Results.Add(new Result(BestSolutionInputvariableCountResultName, new IntValue(model.InputVariables.Count())));
         }
       }
-
-      return base.Apply();
+      return BestSolutionParameter.ActualValue;
     }
 
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/Symbolic/SimpleSymbolicRegressionEvaluator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/Symbolic/SimpleSymbolicRegressionEvaluator.cs	(revision 3891)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/Symbolic/SimpleSymbolicRegressionEvaluator.cs	(revision 3892)
@@ -125,6 +125,6 @@
       int start = SamplesStart.Value;
       int end = SamplesEnd.Value;
-      double lowerEstimationLimit = LowerEstimationLimit.Value;
-      double upperEstimationLimit = UpperEstimationLimit.Value;
+      double lowerEstimationLimit = LowerEstimationLimit != null ? LowerEstimationLimit.Value : double.NegativeInfinity;
+      double upperEstimationLimit = UpperEstimationLimit != null ? UpperEstimationLimit.Value : double.PositiveInfinity;
       int targetVariableIndex = dataset.GetVariableIndex(targetVariable);
       var estimatedValues = from x in interpreter.GetSymbolicExpressionTreeValues(tree, dataset, Enumerable.Range(start, end - start))
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Dataset.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Dataset.cs	(revision 3891)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Dataset.cs	(revision 3892)
@@ -231,5 +231,5 @@
     public override IDeepCloneable Clone(Cloner cloner) {
       Dataset clone = (Dataset)base.Clone(cloner);
-      clone.data = data;
+      clone.data = (double[,])data.Clone();
       clone.variableNames = (string[])variableNames.Clone();
       return clone;
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/SupportVectorMachine/ParameterAdjustmentProblem/SupportVectorMachineParameterAdjustmentBestSolutionAnalyzer.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/SupportVectorMachine/ParameterAdjustmentProblem/SupportVectorMachineParameterAdjustmentBestSolutionAnalyzer.cs	(revision 3891)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/SupportVectorMachine/ParameterAdjustmentProblem/SupportVectorMachineParameterAdjustmentBestSolutionAnalyzer.cs	(revision 3892)
@@ -81,6 +81,6 @@
       get { return KernelTypeParameter.Value; }
     }
-    public ILookupParameter<SupportVectorMachineModel> BestSolutionParameter {
-      get { return (ILookupParameter<SupportVectorMachineModel>)Parameters[BestSolutionParameterName]; }
+    public ILookupParameter<DataAnalysisSolution> BestSolutionParameter {
+      get { return (ILookupParameter<DataAnalysisSolution>)Parameters[BestSolutionParameterName]; }
     }
     public ILookupParameter<DoubleValue> BestSolutionQualityParameter {
@@ -102,5 +102,5 @@
       Parameters.Add(new ValueLookupParameter<StringValue>(KernelTypeParameterName, "The kernel type to use for the SVM.", rbfKernelType));
       Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>(QualityParameterName, "The cross validation quality reached with the given parameters."));
-      Parameters.Add(new LookupParameter<SupportVectorMachineModel>(BestSolutionParameterName, "The best support vector solution."));
+      Parameters.Add(new LookupParameter<DataAnalysisSolution>(BestSolutionParameterName, "The best support vector solution."));
       Parameters.Add(new LookupParameter<DoubleValue>(BestSolutionQualityParameterName, "The quality of the best support vector model."));
       Parameters.Add(new LookupParameter<ResultCollection>(ResultsParameterName, "The result collection where the best support vector solution should be stored."));
@@ -124,5 +124,5 @@
       DataAnalysisProblemData problemData = DataAnalysisProblemData;
 
-      SupportVectorMachineModel bestModel = BestSolutionParameter.ActualValue;
+      DataAnalysisSolution bestSolution = BestSolutionParameter.ActualValue;
       if (bestModel == null) {
         bestModel = SupportVectorMachineModelCreator.TrainModel(DataAnalysisProblemData,
