Index: /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/BFGSAnalyzer.cs
===================================================================
--- /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/BFGSAnalyzer.cs	(revision 8375)
+++ /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/BFGSAnalyzer.cs	(revision 8375)
@@ -0,0 +1,156 @@
+﻿#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.Linq;
+using HeuristicLab.Analysis;
+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;
+using HeuristicLab.Problems.DataAnalysis;
+
+namespace HeuristicLab.Algorithms.DataAnalysis {
+  [StorableClass]
+  [Item(Name = "BFGSAnalyzer", Description = "Analyzer to collect results for the BFGS algorithm.")]
+  public sealed class BFGSAnalyzer : SingleSuccessorOperator, IAnalyzer {
+    private const string PointParameterName = "Point";
+    private const string QualityGradientsParameterName = "QualityGradients";
+    private const string QualityParameterName = "Quality";
+    private const string ResultCollectionParameterName = "Results";
+    private const string QualitiesTableParameterName = "Qualities";
+    private const string PointsTableParameterName = "PointTable";
+    private const string QualityGradientsTableParameterName = "QualityGradientsTable";
+    private const string BFGSStateParameterName = "BFGSState";
+
+    #region Parameter Properties
+    public ILookupParameter<DoubleArray> QualityGradientsParameter {
+      get { return (ILookupParameter<DoubleArray>)Parameters[QualityGradientsParameterName]; }
+    }
+    public ILookupParameter<DoubleArray> PointParameter {
+      get { return (ILookupParameter<DoubleArray>)Parameters[PointParameterName]; }
+    }
+    public ILookupParameter<DoubleValue> QualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters[QualityParameterName]; }
+    }
+    public ILookupParameter<ResultCollection> ResultCollectionParameter {
+      get { return (ILookupParameter<ResultCollection>)Parameters[ResultCollectionParameterName]; }
+    }
+    public ILookupParameter<DataTable> QualitiesTableParameter {
+      get { return (ILookupParameter<DataTable>)Parameters[QualitiesTableParameterName]; }
+    }
+    public ILookupParameter<DataTable> PointsTableParameter {
+      get { return (ILookupParameter<DataTable>)Parameters[PointsTableParameterName]; }
+    }
+    public ILookupParameter<DataTable> QualityGradientsTableParameter {
+      get { return (ILookupParameter<DataTable>)Parameters[QualityGradientsTableParameterName]; }
+    }
+    public ILookupParameter<BFGSState> BFGSStateParameter {
+      get { return (ILookupParameter<BFGSState>)Parameters[BFGSStateParameterName]; }
+    }
+    #endregion
+
+    #region Properties
+    private DoubleArray QualityGradients { get { return QualityGradientsParameter.ActualValue; } }
+    private DoubleArray Point { get { return PointParameter.ActualValue; } }
+    private DoubleValue Quality { get { return QualityParameter.ActualValue; } }
+    private ResultCollection ResultCollection { get { return ResultCollectionParameter.ActualValue; } }
+
+    public bool EnabledByDefault {
+      get { return true; }
+    }
+
+    #endregion
+
+    [StorableConstructor]
+    private BFGSAnalyzer(bool deserializing) : base(deserializing) { }
+    private BFGSAnalyzer(BFGSAnalyzer original, Cloner cloner) : base(original, cloner) { }
+    public BFGSAnalyzer()
+      : base() {
+      // in
+      Parameters.Add(new LookupParameter<DoubleArray>(PointParameterName, "The current point of the function to optimize."));
+      Parameters.Add(new LookupParameter<DoubleArray>(QualityGradientsParameterName, "The current gradients of the function to optimize."));
+      Parameters.Add(new LookupParameter<DoubleValue>(QualityParameterName, "The current value of the function to optimize."));
+      Parameters.Add(new LookupParameter<DataTable>(QualitiesTableParameterName, "The table of all visited quality values."));
+      Parameters.Add(new LookupParameter<DataTable>(PointsTableParameterName, "The table of all visited points."));
+      Parameters.Add(new LookupParameter<DataTable>(QualityGradientsTableParameterName, "The table of all visited gradient values."));
+      Parameters.Add(new LookupParameter<BFGSState>(BFGSStateParameterName, "The state of the BFGS optimization algorithm."));
+      // in & out
+      Parameters.Add(new LookupParameter<ResultCollection>(ResultCollectionParameterName, "The result collection of the algorithm."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new BFGSAnalyzer(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      if (BFGSStateParameter.ActualValue.State.xupdated) {
+        var f = Quality.Value;
+        var g = QualityGradients.ToArray();
+        var x = Point.ToArray();
+        var resultCollection = ResultCollection;
+
+        // create and add tables on the first time
+        if (QualitiesTableParameter.ActualValue == null) {
+          QualitiesTableParameter.ActualValue = new DataTable(QualityParameter.ActualName);
+          PointsTableParameter.ActualValue = new DataTable(PointParameter.ActualName);
+          QualityGradientsTableParameter.ActualValue = new DataTable(QualityGradientsParameter.ActualName);
+
+          QualitiesTableParameter.ActualValue.Rows.Add(new DataRow(QualityParameter.ActualName));
+
+          resultCollection.Add(new Result(QualitiesTableParameter.ActualName,
+                                          QualitiesTableParameter.ActualValue));
+          resultCollection.Add(new Result(PointsTableParameter.ActualName,
+                                          PointsTableParameter.ActualValue));
+          resultCollection.Add(new Result(QualityGradientsTableParameter.ActualName,
+                                          QualityGradientsTableParameter.ActualValue));
+          resultCollection.Add(new Result(QualityParameter.ActualName, QualityParameter.ActualValue));
+        }
+
+        // update
+        var functionValueRow = QualitiesTableParameter.ActualValue.Rows[QualityParameter.ActualName];
+        resultCollection[QualityParameter.ActualName].Value = Quality;
+        functionValueRow.Values.Add(f);
+
+        AddValues(g, QualityGradientsTableParameter.ActualValue);
+        AddValues(x, PointsTableParameter.ActualValue);
+      }
+      return base.Apply();
+    }
+
+    private void AddValues(double[] x, DataTable dataTable) {
+      if (!dataTable.Rows.Any()) {
+        for (int i = 0; i < x.Length; i++) {
+          var newRow = new DataRow("x" + i);
+          newRow.Values.Add(x[i]);
+          dataTable.Rows.Add(newRow);
+        }
+      } else {
+        for (int i = 0; i < x.Length; i++) {
+          dataTable.Rows.ElementAt(i).Values.Add(x[i]);
+        }
+      }
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/BFGSInitializer.cs
===================================================================
--- /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/BFGSInitializer.cs	(revision 8374)
+++ /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/BFGSInitializer.cs	(revision 8375)
@@ -35,6 +35,6 @@
   [Item(Name = "BFGSInitializer", Description = "Initializes the necessary data structures for the BFGS algorithm.")]
   public sealed class BFGSInitializer : SingleSuccessorOperator {
-    private const string NumberOfHyperparameterParameterName = "NumberOfHyperparameter";
-    private const string HyperparameterParameterName = "Hyperparameter";
+    private const string DimensionParameterName = "Dimension";
+    private const string PointParameterName = "Point";
     private const string BFGSStateParameterName = "BFGSState";
     private const string IterationsParameterName = "Iterations";
@@ -42,6 +42,6 @@
     #region Parameter Properties
     // in
-    public ILookupParameter<IntValue> NumberOfHyperparameterParameter {
-      get { return (ILookupParameter<IntValue>)Parameters[NumberOfHyperparameterParameterName]; }
+    public ILookupParameter<IntValue> DimensionParameter {
+      get { return (ILookupParameter<IntValue>)Parameters[DimensionParameterName]; }
     }
     public ILookupParameter<IntValue> IterationsParameter {
@@ -49,6 +49,6 @@
     }
     // out
-    public ILookupParameter<DoubleArray> HyperparameterParameter {
-      get { return (ILookupParameter<DoubleArray>)Parameters[HyperparameterParameterName]; }
+    public ILookupParameter<DoubleArray> PointParameter {
+      get { return (ILookupParameter<DoubleArray>)Parameters[PointParameterName]; }
     }
     public ILookupParameter<BFGSState> BFGSStateParameter {
@@ -60,6 +60,6 @@
 
     #region Properties
-    public IntValue NumberOfHyperparameter { get { return NumberOfHyperparameterParameter.ActualValue; } }
-    public IntValue Iterations { get { return IterationsParameter.ActualValue; } }
+    private IntValue Dimension { get { return DimensionParameter.ActualValue; } }
+    private IntValue Iterations { get { return IterationsParameter.ActualValue; } }
     #endregion
 
@@ -70,8 +70,8 @@
       : base() {
       // in
-      Parameters.Add(new LookupParameter<IntValue>(NumberOfHyperparameterParameterName, "The number of parameters to optimize."));
+      Parameters.Add(new LookupParameter<IntValue>(DimensionParameterName, "The length of the vector to optimize."));
       Parameters.Add(new LookupParameter<IntValue>(IterationsParameterName, "The maximal number of iterations for the BFGS algorithm."));
       // out
-      Parameters.Add(new LookupParameter<DoubleArray>(HyperparameterParameterName, "The hyperparameters for the Gaussian process model."));
+      Parameters.Add(new LookupParameter<DoubleArray>(PointParameterName, "The initial point for the BFGS algorithm."));
       Parameters.Add(new LookupParameter<BFGSState>(BFGSStateParameterName, "The state of the BFGS algorithm."));
     }
@@ -82,11 +82,12 @@
 
     public override IOperation Apply() {
-      int n = NumberOfHyperparameter.Value;
-      double[] initialHyp = Enumerable.Repeat(0.0, n).ToArray();
+      int n = Dimension.Value;
+      double[] initialPoint = Enumerable.Repeat(0.0, n).ToArray();
       alglib.minlbfgs.minlbfgsstate state = new alglib.minlbfgs.minlbfgsstate();
-      alglib.minlbfgs.minlbfgscreate(n, Math.Min(n, 5), initialHyp, state);
+      alglib.minlbfgs.minlbfgscreate(n, Math.Min(n, 7), initialPoint, state);
       alglib.minlbfgs.minlbfgssetcond(state, 0, 0, 0, Iterations.Value);
+      alglib.minlbfgs.minlbfgssetxrep(state, true);
 
-      HyperparameterParameter.ActualValue = new DoubleArray(initialHyp);
+      PointParameter.ActualValue = new DoubleArray(initialPoint);
       BFGSStateParameter.ActualValue = new BFGSState(state);
       return base.Apply();
Index: /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/BFGSMakeStep.cs
===================================================================
--- /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/BFGSMakeStep.cs	(revision 8374)
+++ /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/BFGSMakeStep.cs	(revision 8375)
@@ -35,5 +35,5 @@
   public sealed class BFGSMakeStep : SingleSuccessorOperator {
     private const string TerminationCriterionParameterName = "TerminationCriterion";
-    private const string HyperparameterParameterName = "Hyperparameter";
+    private const string PointParameterName = "Point";
     private const string BFGSStateParameterName = "BFGSState";
 
@@ -45,6 +45,6 @@
       get { return (ILookupParameter<BoolValue>)Parameters[TerminationCriterionParameterName]; }
     }
-    public ILookupParameter<DoubleArray> HyperparameterParameter {
-      get { return (ILookupParameter<DoubleArray>)Parameters[HyperparameterParameterName]; }
+    public ILookupParameter<DoubleArray> PointParameter {
+      get { return (ILookupParameter<DoubleArray>)Parameters[PointParameterName]; }
     }
     #endregion
@@ -52,5 +52,5 @@
 
     #region Properties
-    public BFGSState BFGSState { get { return BFGSStateParameter.ActualValue; } }
+    private BFGSState BFGSState { get { return BFGSStateParameter.ActualValue; } }
     #endregion
 
@@ -64,5 +64,5 @@
       // out
       Parameters.Add(new LookupParameter<BoolValue>(TerminationCriterionParameterName, "The termination criterion indicating that the BFGS optimization algorithm should stop."));
-      Parameters.Add(new LookupParameter<DoubleArray>(HyperparameterParameterName, "The parameters of the function to optimize."));
+      Parameters.Add(new LookupParameter<DoubleArray>(PointParameterName, "The next point that should be evaluated in the BFGS algorithm."));
     }
 
@@ -73,13 +73,13 @@
     public override IOperation Apply() {
       var state = BFGSState;
-      bool stop = alglib.minlbfgs.minlbfgsiteration(state.State);
-      TerminationCriterionParameter.ActualValue = new BoolValue(stop);
-      if (!stop) {
-        HyperparameterParameter.ActualValue = new DoubleArray(state.State.x);
+      bool @continue = alglib.minlbfgs.minlbfgsiteration(state.State);
+      TerminationCriterionParameter.ActualValue = new BoolValue(!@continue);
+      if (@continue) {
+        PointParameter.ActualValue = new DoubleArray(state.State.x);
       } else {
         double[] x = new double[state.State.x.Length];
         alglib.minlbfgs.minlbfgsreport rep = new alglib.minlbfgs.minlbfgsreport();
         alglib.minlbfgs.minlbfgsresults(state.State, ref x, rep);
-        HyperparameterParameter.ActualValue = new DoubleArray(x);
+        PointParameter.ActualValue = new DoubleArray(x);
       }
       return base.Apply();
Index: /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/BFGSUpdateResults.cs
===================================================================
--- /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/BFGSUpdateResults.cs	(revision 8374)
+++ /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/BFGSUpdateResults.cs	(revision 8375)
@@ -34,14 +34,14 @@
   [Item(Name = "BFGSUpdateResults", Description = "Sets the results (function value and gradients) for the next optimization step in the BFGS algorithm.")]
   public sealed class BFGSUpdateResults : SingleSuccessorOperator {
-    private const string HyperparameterGradientsParameterName = "HyperparameterGradients";
-    private const string FunctionValueParameterName = "NegativeLogLikelihood";
+    private const string QualityGradientsParameterName = "QualityGradients";
+    private const string QualityParameterName = "Quality";
     private const string BFGSStateParameterName = "BFGSState";
 
     #region Parameter Properties
-    public ILookupParameter<DoubleArray> HyperparameterGradientsParameter {
-      get { return (ILookupParameter<DoubleArray>)Parameters[HyperparameterGradientsParameterName]; }
+    public ILookupParameter<DoubleArray> QualityGradientsParameter {
+      get { return (ILookupParameter<DoubleArray>)Parameters[QualityGradientsParameterName]; }
     }
-    public ILookupParameter<DoubleValue> FunctionValueParameter {
-      get { return (ILookupParameter<DoubleValue>)Parameters[FunctionValueParameterName]; }
+    public ILookupParameter<DoubleValue> QualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters[QualityParameterName]; }
     }
     public ILookupParameter<BFGSState> BFGSStateParameter {
@@ -51,7 +51,7 @@
 
     #region Properties
-    public DoubleArray HyperparameterGradients { get { return HyperparameterGradientsParameter.ActualValue; } }
-    public DoubleValue FunctionValue { get { return FunctionValueParameter.ActualValue; } }
-    public BFGSState BFGSState { get { return BFGSStateParameter.ActualValue; } }
+    private DoubleArray QualityGradients { get { return QualityGradientsParameter.ActualValue; } }
+    private DoubleValue Quality { get { return QualityParameter.ActualValue; } }
+    private BFGSState BFGSState { get { return BFGSStateParameter.ActualValue; } }
     #endregion
 
@@ -62,6 +62,6 @@
       : base() {
       // in
-      Parameters.Add(new LookupParameter<DoubleArray>(HyperparameterGradientsParameterName, "The function gradients for the parameters of the function to optimize."));
-      Parameters.Add(new LookupParameter<DoubleValue>(FunctionValueParameterName, "The value of the function to optimize."));
+      Parameters.Add(new LookupParameter<DoubleArray>(QualityGradientsParameterName, "The gradients at the evaluated point of the function to optimize."));
+      Parameters.Add(new LookupParameter<DoubleValue>(QualityParameterName, "The value at the evaluated point of the function to optimize."));
       // in & out
       Parameters.Add(new LookupParameter<BFGSState>(BFGSStateParameterName, "The state of the BFGS algorithm."));
@@ -74,6 +74,6 @@
     public override IOperation Apply() {
       var state = BFGSState;
-      var f = FunctionValue.Value;
-      var g = HyperparameterGradients.ToArray();
+      var f = Quality.Value;
+      var g = QualityGradients.ToArray();
       state.State.f = f;
       state.State.g = g;
Index: /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessModelCreator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessModelCreator.cs	(revision 8374)
+++ /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessModelCreator.cs	(revision 8375)
@@ -65,7 +65,7 @@
 
     #region Properties
-    public DoubleArray Hyperparameter { get { return HyperparameterParameter.ActualValue; } }
-    public IMeanFunction MeanFunction { get { return MeanFunctionParameter.ActualValue; } }
-    public ICovarianceFunction CovarianceFunction { get { return CovarianceFunctionParameter.ActualValue; } }
+    protected DoubleArray Hyperparameter { get { return HyperparameterParameter.ActualValue; } }
+    protected IMeanFunction MeanFunction { get { return MeanFunctionParameter.ActualValue; } }
+    protected ICovarianceFunction CovarianceFunction { get { return CovarianceFunctionParameter.ActualValue; } }
     #endregion
 
Index: /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessRegression.cs
===================================================================
--- /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessRegression.cs	(revision 8374)
+++ /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessRegression.cs	(revision 8375)
@@ -55,6 +55,4 @@
     private const string CovarianceFunctionParameterName = "CovarianceFunction";
     private const string MinimizationIterationsParameterName = "Iterations";
-    //private const string NegativeLogLikelihoodTableParameterName = "NegativeLogLikelihoodTable";
-    //private const string HyperParametersTableParameterName = "HyperParametersTable";
 
     #region parameter properties
@@ -68,10 +66,4 @@
       get { return (IValueParameter<IntValue>)Parameters[MinimizationIterationsParameterName]; }
     }
-    //public ILookupParameter<DataTable> NegativeLogLikelihoodTableParameter {
-    //  get { return (ILookupParameter<DataTable>)Parameters[NegativeLogLikelihoodTableParameterName]; }
-    //}
-    //public ILookupParameter<DataTable> HyperParametersTableParameter {
-    //  get { return (ILookupParameter<DataTable>)Parameters[HyperParametersTableParameterName]; }
-    //}
     #endregion
     #region properties
@@ -106,6 +98,4 @@
         new ItemSet<ICovarianceFunction>(covFunctions), covFunctions.First()));
       Parameters.Add(new ValueParameter<IntValue>(MinimizationIterationsParameterName, "The number of iterations for likelihood optimization with BFGS.", new IntValue(20)));
-      //Parameters.Add(new LookupParameter<DataTable>(NegativeLogLikelihoodTableParameterName, "The negative log likelihood values over the whole run."));
-      //Parameters.Add(new LookupParameter<DataTable>(HyperParametersTableParameterName, "The values of the hyper-parameters over the whole run."));
 
       var setParameterLength = new GaussianProcessSetHyperparameterLength();
@@ -115,4 +105,8 @@
       var modelCreator = new GaussianProcessRegressionModelCreator();
       var updateResults = new BFGSUpdateResults();
+      var analyzer = new BFGSAnalyzer();
+      var finalModelCreator = new GaussianProcessRegressionModelCreator();
+      var finalAnalyzer = new BFGSAnalyzer();
+      var solutionCreator = new GaussianProcessRegressionSolutionCreator();
 
       OperatorGraph.InitialOperator = setParameterLength;
@@ -124,26 +118,53 @@
 
       initializer.IterationsParameter.ActualName = MinimizationIterationsParameterName;
-      initializer.NumberOfHyperparameterParameter.ActualName = setParameterLength.NumberOfHyperparameterParameter.Name;
+      initializer.DimensionParameter.ActualName = setParameterLength.NumberOfHyperparameterParameter.Name;
+      initializer.PointParameter.ActualName = modelCreator.HyperparameterParameter.Name;
       initializer.Successor = makeStep;
 
       makeStep.BFGSStateParameter.ActualName = initializer.BFGSStateParameter.Name;
-      makeStep.HyperparameterParameter.ActualName = initializer.NumberOfHyperparameterParameter.Name;
+      makeStep.PointParameter.ActualName = modelCreator.HyperparameterParameter.Name;
       makeStep.Successor = branch;
 
       branch.ConditionParameter.ActualName = makeStep.TerminationCriterionParameter.Name;
       branch.FalseBranch = modelCreator;
+      branch.TrueBranch = finalModelCreator;
 
       modelCreator.ProblemDataParameter.ActualName = Problem.ProblemDataParameter.Name;
       modelCreator.MeanFunctionParameter.ActualName = MeanFunctionParameterName;
       modelCreator.CovarianceFunctionParameter.ActualName = CovarianceFunctionParameterName;
-      modelCreator.HyperparameterParameter.ActualName = initializer.HyperparameterParameter.Name;
       modelCreator.Successor = updateResults;
 
       updateResults.BFGSStateParameter.ActualName = initializer.BFGSStateParameter.Name;
-      updateResults.FunctionValueParameter.ActualName = modelCreator.NegativeLogLikelihoodParameter.Name;
-      updateResults.HyperparameterGradientsParameter.ActualName = modelCreator.HyperparameterGradientsParameter.Name;
-      updateResults.Successor = makeStep;
+      updateResults.QualityParameter.ActualName = modelCreator.NegativeLogLikelihoodParameter.Name;
+      updateResults.QualityGradientsParameter.ActualName = modelCreator.HyperparameterGradientsParameter.Name;
+      updateResults.Successor = analyzer;
 
+      analyzer.QualityParameter.ActualName = modelCreator.NegativeLogLikelihoodParameter.Name;
+      analyzer.PointParameter.ActualName = modelCreator.HyperparameterParameter.Name;
+      analyzer.QualityGradientsParameter.ActualName = modelCreator.HyperparameterGradientsParameter.Name;
+      analyzer.BFGSStateParameter.ActualName = initializer.BFGSStateParameter.Name;
+      analyzer.PointsTableParameter.ActualName = "Hyperparameter table";
+      analyzer.QualityGradientsTableParameter.ActualName = "Gradients table";
+      analyzer.QualitiesTableParameter.ActualName = "Negative log likelihood table";
+      analyzer.Successor = makeStep;
+
+      finalModelCreator.ProblemDataParameter.ActualName = Problem.ProblemDataParameter.Name;
+      finalModelCreator.MeanFunctionParameter.ActualName = MeanFunctionParameterName;
+      finalModelCreator.CovarianceFunctionParameter.ActualName = CovarianceFunctionParameterName;
+      finalModelCreator.HyperparameterParameter.ActualName = initializer.PointParameter.ActualName;
+      finalModelCreator.Successor = finalAnalyzer;
+
+      finalAnalyzer.QualityParameter.ActualName = modelCreator.NegativeLogLikelihoodParameter.Name;
+      finalAnalyzer.PointParameter.ActualName = modelCreator.HyperparameterParameter.Name;
+      finalAnalyzer.QualityGradientsParameter.ActualName = modelCreator.HyperparameterGradientsParameter.Name;
+      finalAnalyzer.PointsTableParameter.ActualName = analyzer.PointsTableParameter.ActualName;
+      finalAnalyzer.QualityGradientsTableParameter.ActualName = analyzer.QualityGradientsTableParameter.ActualName;
+      finalAnalyzer.QualitiesTableParameter.ActualName = analyzer.QualitiesTableParameter.ActualName;
+      finalAnalyzer.Successor = solutionCreator;
+
+      solutionCreator.ModelParameter.ActualName = finalModelCreator.ModelParameter.Name;
+      solutionCreator.ProblemDataParameter.ActualName = Problem.ProblemDataParameter.Name;
     }
+
     [StorableHook(HookType.AfterDeserialization)]
     private void AfterDeserialization() { }
@@ -152,115 +173,4 @@
       return new GaussianProcessRegression(this, cloner);
     }
-    /*
-    #region Gaussian process regression
-    protected override void Run() {
-      IRegressionProblemData problemData = Problem.ProblemData;
-
-      int nAllowedVariables = problemData.AllowedInputVariables.Count();
-      var mt = new MersenneTwister();
-
-      var hyp0 =
-        Enumerable.Range(0,
-                         1 + MeanFunction.GetNumberOfParameters(nAllowedVariables) +
-                         CovarianceFunction.GetNumberOfParameters(nAllowedVariables))
-          .Select(i => mt.NextDouble())
-          .ToArray();
-
-      double[] hyp;
-
-      // find hyperparameters
-
-      double epsg = 0;
-      double epsf = 0.00001;
-      double epsx = 0;
-
-      alglib.minlbfgsstate state;
-      alglib.minlbfgsreport rep;
-
-      alglib.minlbfgscreate(1, hyp0, out state);
-      alglib.minlbfgssetcond(state, epsg, epsf, epsx, MinimizationIterations);
-      alglib.minlbfgssetxrep(state, true);
-      alglib.minlbfgsoptimize(state, OptimizeGaussianProcessParameters, Report, new object[] { MeanFunction, CovarianceFunction, problemData });
-      alglib.minlbfgsresults(state, out hyp, out rep);
-
-
-      double trainR2, testR2, negativeLogLikelihood;
-      var solution = CreateGaussianProcessSolution(problemData, hyp, MeanFunction, CovarianceFunction,
-        out negativeLogLikelihood, out trainR2, out testR2);
-
-      Results.Add(new Result("Gaussian process regression solution", "The Gaussian process regression solution.", solution));
-      Results.Add(new Result("Training R²", "The Pearson's R² of the Gaussian process solution on the training partition.", new DoubleValue(trainR2)));
-      Results.Add(new Result("Test R²", "The Pearson's R² of the Gaussian process solution on the test partition.", new DoubleValue(testR2)));
-      Results.Add(new Result("Negative log likelihood", "The negative log likelihood of the Gaussian process.", new DoubleValue(negativeLogLikelihood)));
-    }
-
-    public static GaussianProcessRegressionSolution CreateGaussianProcessSolution(IRegressionProblemData problemData,
-      IEnumerable<double> hyp, IMeanFunction mean, ICovarianceFunction cov,
-      out double negativeLogLikelihood, out double trainingR2, out double testR2) {
-
-      Dataset dataset = problemData.Dataset;
-      var allowedInputVariables = problemData.AllowedInputVariables;
-      string targetVariable = problemData.TargetVariable;
-      IEnumerable<int> rows = problemData.TrainingIndices;
-
-      var model = new GaussianProcessModel(dataset, targetVariable, allowedInputVariables, rows, hyp, mean, cov);
-      var solution = new GaussianProcessRegressionSolution(model, (IRegressionProblemData)problemData.Clone());
-      negativeLogLikelihood = model.NegativeLogLikelihood;
-      trainingR2 = solution.TrainingRSquared;
-      testR2 = solution.TestRSquared;
-      return solution;
-    }
-
-    private static void OptimizeGaussianProcessParameters(double[] hyp, ref double func, double[] grad, object obj) {
-      var objArr = (object[])obj;
-      var meanFunction = (IMeanFunction)objArr[0];
-      var covarianceFunction = (ICovarianceFunction)objArr[1];
-      var problemData = (RegressionProblemData)objArr[2];
-      IEnumerable<string> allowedInputVariables = problemData.AllowedInputVariables;
-
-      Dataset ds = problemData.Dataset;
-      string targetVariable = problemData.TargetVariable;
-      IEnumerable<int> rows = problemData.TrainingIndices;
-
-
-      IEnumerable<double> dHyp;
-      var model = new GaussianProcessModel(ds, targetVariable, allowedInputVariables, rows, hyp, meanFunction,
-                                           covarianceFunction);
-      dHyp = model.GetHyperparameterGradients();
-
-      int i = 0;
-      foreach (var e in dHyp) {
-        grad[i++] = e;
-      }
-      func = model.NegativeLogLikelihood;
-    }
-
-    public void Report(double[] arg, double func, object obj) {
-      if (!Results.ContainsKey(NegativeLogLikelihoodTableParameterName)) {
-        Results.Add(new Result(NegativeLogLikelihoodTableParameterName, new DataTable()));
-      }
-      if (!Results.ContainsKey(HyperParametersTableParameterName)) {
-        Results.Add(new Result(HyperParametersTableParameterName, new DataTable()));
-      }
-
-      var nllTable = (DataTable)Results[NegativeLogLikelihoodTableParameterName].Value;
-      if (!nllTable.Rows.ContainsKey("Negative log likelihood"))
-        nllTable.Rows.Add(new DataRow("Negative log likelihood"));
-      var nllRow = nllTable.Rows["Negative log likelihood"];
-
-      nllRow.Values.Add(func);
-
-      var hypTable = (DataTable)Results[HyperParametersTableParameterName].Value;
-      if (hypTable.Rows.Count == 0) {
-        for (int i = 0; i < arg.Length; i++)
-          hypTable.Rows.Add(new DataRow(i.ToString()));
-      }
-      for (int i = 0; i < arg.Length; i++) {
-        hypTable.Rows[i.ToString()].Values.Add(arg[i]);
-      }
-    }
-
-    #endregion
-     */
   }
 }
Index: /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessRegressionModelCreator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessRegressionModelCreator.cs	(revision 8374)
+++ /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessRegressionModelCreator.cs	(revision 8375)
@@ -45,5 +45,5 @@
 
     #region Properties
-    public IRegressionProblemData ProblemData {
+    private IRegressionProblemData ProblemData {
       get { return ProblemDataParameter.ActualValue; }
     }
Index: /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessRegressionSolutionCreator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessRegressionSolutionCreator.cs	(revision 8375)
+++ /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessRegressionSolutionCreator.cs	(revision 8375)
@@ -0,0 +1,99 @@
+﻿#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 System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.DataAnalysis;
+
+namespace HeuristicLab.Algorithms.DataAnalysis {
+  [StorableClass]
+  [Item(Name = "GaussianProcessRegressionSolutionCreator",
+    Description = "Creates a Gaussian process solution from a trained model.")]
+  public sealed class GaussianProcessRegressionSolutionCreator : SingleSuccessorOperator {
+    private const string ProblemDataParameterName = "ProblemData";
+    private const string ModelParameterName = "GaussianProcessRegressionModel";
+    private const string SolutionParameterName = "Solution";
+    private const string ResultsParameterName = "Results";
+    private const string TrainingRSquaredResultName = "Training R²";
+    private const string TestRSquaredResultName = "Test R²";
+
+    #region Parameter Properties
+    public ILookupParameter<IRegressionProblemData> ProblemDataParameter {
+      get { return (ILookupParameter<IRegressionProblemData>)Parameters[ProblemDataParameterName]; }
+    }
+    public ILookupParameter<IGaussianProcessSolution> SolutionParameter {
+      get { return (ILookupParameter<IGaussianProcessSolution>)Parameters[SolutionParameterName]; }
+    }
+    public ILookupParameter<IGaussianProcessModel> ModelParameter {
+      get { return (ILookupParameter<IGaussianProcessModel>)Parameters[ModelParameterName]; }
+    }
+    public ILookupParameter<ResultCollection> ResultsParameter {
+      get { return (ILookupParameter<ResultCollection>)Parameters[ResultsParameterName]; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    private GaussianProcessRegressionSolutionCreator(bool deserializing) : base(deserializing) { }
+    private GaussianProcessRegressionSolutionCreator(GaussianProcessRegressionSolutionCreator original, Cloner cloner) : base(original, cloner) { }
+    public GaussianProcessRegressionSolutionCreator()
+      : base() {
+      // in
+      Parameters.Add(new LookupParameter<IRegressionProblemData>(ProblemDataParameterName, "The regression problem data for the Gaussian process solution."));
+      Parameters.Add(new LookupParameter<IGaussianProcessModel>(ModelParameterName, "The Gaussian process regression model to use for the solution."));
+      // in & out
+      Parameters.Add(new LookupParameter<ResultCollection>(ResultsParameterName, "The result collection of the algorithm."));
+      // out
+      Parameters.Add(new LookupParameter<IGaussianProcessSolution>(SolutionParameterName, "The produced Gaussian process solution."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new GaussianProcessRegressionSolutionCreator(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      var m = ModelParameter.ActualValue;
+      var data = ProblemDataParameter.ActualValue;
+      var s = new GaussianProcessRegressionSolution(m, data);
+
+
+      SolutionParameter.ActualValue = s;
+      var results = ResultsParameter.ActualValue;
+      if (!results.ContainsKey(SolutionParameterName)) {
+        results.Add(new Result(ResultsParameterName, "The Gaussian process regression solution", s));
+        results.Add(new Result(TrainingRSquaredResultName, "The Pearson's R² of the Gaussian process solution on the training partition.", new DoubleValue(s.TrainingRSquared)));
+        results.Add(new Result(TestRSquaredResultName, "The Pearson's R² of the Gaussian process solution on the test partition.", new DoubleValue(s.TestRSquared)));
+      } else {
+        results[ResultsParameterName].Value = s;
+        results[TrainingRSquaredResultName].Value = new DoubleValue(s.TrainingRSquared);
+        results[TestRSquaredResultName].Value = new DoubleValue(s.TestRSquared);
+      }
+      return base.Apply();
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessSetHyperparameterLength.cs
===================================================================
--- /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessSetHyperparameterLength.cs	(revision 8374)
+++ /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessSetHyperparameterLength.cs	(revision 8375)
@@ -58,7 +58,7 @@
 
     #region Properties
-    public IMeanFunction MeanFunction { get { return MeanFunctionParameter.ActualValue; } }
-    public ICovarianceFunction CovarianceFunction { get { return CovarianceFunctionParameter.ActualValue; } }
-    public IDataAnalysisProblemData ProblemData { get { return ProblemDataParameter.ActualValue; } }
+    private IMeanFunction MeanFunction { get { return MeanFunctionParameter.ActualValue; } }
+    private ICovarianceFunction CovarianceFunction { get { return CovarianceFunctionParameter.ActualValue; } }
+    private IDataAnalysisProblemData ProblemData { get { return ProblemDataParameter.ActualValue; } }
     #endregion
 
Index: /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/HeuristicLab.Algorithms.DataAnalysis-3.4.csproj
===================================================================
--- /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/HeuristicLab.Algorithms.DataAnalysis-3.4.csproj	(revision 8374)
+++ /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/HeuristicLab.Algorithms.DataAnalysis-3.4.csproj	(revision 8375)
@@ -126,4 +126,6 @@
     <Compile Include="GaussianProcess\BFGSUpdateResults.cs" />
     <Compile Include="GaussianProcess\BFGSMakeStep.cs" />
+    <Compile Include="GaussianProcess\BFGSAnalyzer.cs" />
+    <Compile Include="GaussianProcess\GaussianProcessRegressionSolutionCreator.cs" />
     <Compile Include="GaussianProcess\GaussianProcessSetHyperparameterLength.cs" />
     <Compile Include="GaussianProcess\GaussianProcessRegressionModelCreator.cs" />
Index: /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/Plugin.cs.frame
===================================================================
--- /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/Plugin.cs.frame	(revision 8374)
+++ /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/Plugin.cs.frame	(revision 8375)
@@ -29,4 +29,5 @@
   [PluginFile("HeuristicLab.Algorithms.DataAnalysis-3.4.dll", PluginFileType.Assembly)]
   [PluginDependency("HeuristicLab.ALGLIB", "3.5.0")]
+  [PluginDependency("HeuristicLab.Analysis", "3.3")]
   [PluginDependency("HeuristicLab.LibSVM", "1.6.3")]
   [PluginDependency("HeuristicLab.Collections", "3.3")]
