Index: /branches/crossvalidation-2434/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessBase.cs
===================================================================
--- /branches/crossvalidation-2434/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessBase.cs	(revision 12819)
+++ /branches/crossvalidation-2434/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessBase.cs	(revision 12820)
@@ -108,4 +108,8 @@
       Parameters[ApproximateGradientsParameterName].Hidden = true; // should not be changed
 
+      // necessary for BFGS
+      Parameters.Add(new ValueParameter<BoolValue>("Maximization", new BoolValue(false)));
+      Parameters["Maximization"].Hidden = true;
+
       var randomCreator = new HeuristicLab.Random.RandomCreator();
       var gpInitializer = new GaussianProcessHyperparameterInitializer();
@@ -181,4 +185,11 @@
     [StorableHook(HookType.AfterDeserialization)]
     private void AfterDeserialization() {
+      // BackwardsCompatibility3.4
+      #region Backwards compatible code, remove with 3.5
+      if (!Parameters.ContainsKey("Maximization")) {
+        Parameters.Add(new ValueParameter<BoolValue>("Maximization", new BoolValue(false)));
+        Parameters["Maximization"].Hidden = true;
+      }
+      #endregion
     }
   }
Index: /branches/crossvalidation-2434/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessModel.cs
===================================================================
--- /branches/crossvalidation-2434/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessModel.cs	(revision 12819)
+++ /branches/crossvalidation-2434/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessModel.cs	(revision 12820)
@@ -85,9 +85,33 @@
     private double[] covarianceParameter;
 
-    [Storable]
-    private double[,] l;
-
-    [Storable]
-    private double[,] x;
+    private double[,] l; // used to be storable in previous versions (is calculated lazily now)
+    private double[,] x; // scaled training dataset, used to be storable in previous versions (is calculated lazily now)
+
+    // BackwardsCompatibility3.4
+    #region Backwards compatible code, remove with 3.5
+    [Storable(Name = "l")] // restore if available but don't store anymore
+    private double[,] l_storable {
+      set { this.l = value; }
+      get {
+        if (trainingDataset == null) return l; // this model has been created with an old version 
+        else return null; // if the training dataset is available l should not be serialized
+      }
+    }
+    [Storable(Name = "x")] // restore if available but don't store anymore
+    private double[,] x_storable {
+      set { this.x = value; }
+      get {
+        if (trainingDataset == null) return x; // this model has been created with an old version 
+        else return null; // if the training dataset is available x should not be serialized
+      }
+    }
+    #endregion
+
+
+    [Storable]
+    private IDataset trainingDataset; // it is better to store the original training dataset completely because this is more efficient in persistence
+    [Storable]
+    private int[] trainingRows;
+
     [Storable]
     private Scaling inputScaling;
@@ -101,4 +125,5 @@
       this.covarianceFunction = cloner.Clone(original.covarianceFunction);
       this.inputScaling = cloner.Clone(original.inputScaling);
+      this.trainingDataset = cloner.Clone(original.trainingDataset);
       this.negativeLogLikelihood = original.negativeLogLikelihood;
       this.targetVariable = original.targetVariable;
@@ -112,4 +137,5 @@
 
       // shallow copies of arrays because they cannot be modified
+      this.trainingRows = original.trainingRows;
       this.allowedInputVariables = original.allowedInputVariables;
       this.alpha = original.alpha;
@@ -137,17 +163,21 @@
                                              .ToArray();
       sqrSigmaNoise = Math.Exp(2.0 * hyp.Last());
-
       CalculateModel(ds, rows);
     }
 
     private void CalculateModel(IDataset ds, IEnumerable<int> rows) {
-      inputScaling = new Scaling(ds, allowedInputVariables, rows);
-      x = AlglibUtil.PrepareAndScaleInputMatrix(ds, allowedInputVariables, rows, inputScaling);
+      this.trainingDataset = (IDataset)ds.Clone();
+      this.trainingRows = rows.ToArray();
+      this.inputScaling = new Scaling(trainingDataset, allowedInputVariables, rows);
+      this.x = CalculateX(trainingDataset, allowedInputVariables, rows, inputScaling);
       var y = ds.GetDoubleValues(targetVariable, rows);
 
       int n = x.GetLength(0);
-      l = new double[n, n];
-
-      // calculate means and covariances
+
+      // calculate cholesky decomposed (lower triangular) covariance matrix
+      var cov = covarianceFunction.GetParameterizedCovarianceFunction(covarianceParameter, Enumerable.Range(0, x.GetLength(1)));
+      this.l = CalculateL(x, cov, sqrSigmaNoise);
+
+      // calculate mean
       var mean = meanFunction.GetParameterizedMeanFunction(meanParameter, Enumerable.Range(0, x.GetLength(1)));
       double[] m = Enumerable.Range(0, x.GetLength(0))
@@ -155,25 +185,14 @@
         .ToArray();
 
-      var cov = covarianceFunction.GetParameterizedCovarianceFunction(covarianceParameter, Enumerable.Range(0, x.GetLength(1)));
-      for (int i = 0; i < n; i++) {
-        for (int j = i; j < n; j++) {
-          l[j, i] = cov.Covariance(x, i, j) / sqrSigmaNoise;
-          if (j == i) l[j, i] += 1.0;
-        }
-      }
-
-
-      // cholesky decomposition
+
+
+      // calculate sum of diagonal elements for likelihood
+      double diagSum = Enumerable.Range(0, n).Select(i => Math.Log(l[i, i])).Sum();
+
+      // solve for alpha
+      double[] ym = y.Zip(m, (a, b) => a - b).ToArray();
+
       int info;
       alglib.densesolverreport denseSolveRep;
-
-      var res = alglib.trfac.spdmatrixcholesky(ref l, n, false);
-      if (!res) throw new ArgumentException("Matrix is not positive semidefinite");
-
-      // calculate sum of diagonal elements for likelihood
-      double diagSum = Enumerable.Range(0, n).Select(i => Math.Log(l[i, i])).Sum();
-
-      // solve for alpha
-      double[] ym = y.Zip(m, (a, b) => a - b).ToArray();
 
       alglib.spdmatrixcholeskysolve(l, n, false, ym, out info, out denseSolveRep, out alpha);
@@ -230,4 +249,26 @@
     }
 
+    private static double[,] CalculateX(IDataset ds, IEnumerable<string> allowedInputVariables, IEnumerable<int> rows, Scaling inputScaling) {
+      return AlglibUtil.PrepareAndScaleInputMatrix(ds, allowedInputVariables, rows, inputScaling);
+    }
+
+    private static double[,] CalculateL(double[,] x, ParameterizedCovarianceFunction cov, double sqrSigmaNoise) {
+      int n = x.GetLength(0);
+      var l = new double[n, n];
+
+      // calculate covariances
+      for (int i = 0; i < n; i++) {
+        for (int j = i; j < n; j++) {
+          l[j, i] = cov.Covariance(x, i, j) / sqrSigmaNoise;
+          if (j == i) l[j, i] += 1.0;
+        }
+      }
+
+      // cholesky decomposition
+      var res = alglib.trfac.spdmatrixcholesky(ref l, n, false);
+      if (!res) throw new ArgumentException("Matrix is not positive semidefinite");
+      return l;
+    }
+
 
     public override IDeepCloneable Clone(Cloner cloner) {
@@ -258,7 +299,12 @@
 
     private IEnumerable<double> GetEstimatedValuesHelper(IDataset dataset, IEnumerable<int> rows) {
+      if (x == null) {
+        this.x = CalculateX(trainingDataset, allowedInputVariables, trainingRows, inputScaling);
+      }
+      int n = x.GetLength(0);
+
       var newX = AlglibUtil.PrepareAndScaleInputMatrix(dataset, allowedInputVariables, rows, inputScaling);
       int newN = newX.GetLength(0);
-      int n = x.GetLength(0);
+
       var Ks = new double[newN, n];
       var mean = meanFunction.GetParameterizedMeanFunction(meanParameter, Enumerable.Range(0, newX.GetLength(1)));
@@ -278,11 +324,19 @@
 
     public IEnumerable<double> GetEstimatedVariance(IDataset dataset, IEnumerable<int> rows) {
+      if (x == null) {
+        this.x = CalculateX(trainingDataset, allowedInputVariables, trainingRows, inputScaling);
+      }
+      int n = x.GetLength(0);
+
       var newX = AlglibUtil.PrepareAndScaleInputMatrix(dataset, allowedInputVariables, rows, inputScaling);
       int newN = newX.GetLength(0);
-      int n = x.GetLength(0);
 
       var kss = new double[newN];
       double[,] sWKs = new double[n, newN];
       var cov = covarianceFunction.GetParameterizedCovarianceFunction(covarianceParameter, Enumerable.Range(0, x.GetLength(1)));
+
+      if (l == null) {
+        l = CalculateL(x, cov, sqrSigmaNoise);
+      }
 
       // for stddev 
Index: /branches/crossvalidation-2434/HeuristicLab.Algorithms.GradientDescent/3.3/Lbfgs.cs
===================================================================
--- /branches/crossvalidation-2434/HeuristicLab.Algorithms.GradientDescent/3.3/Lbfgs.cs	(revision 12819)
+++ /branches/crossvalidation-2434/HeuristicLab.Algorithms.GradientDescent/3.3/Lbfgs.cs	(revision 12820)
@@ -200,5 +200,7 @@
         RegisterEvents();
         solutionCreator.OperatorParameter.ActualName = Problem.SolutionCreatorParameter.Name;
+        solutionCreator.OperatorParameter.Hidden = true;
         evaluator.OperatorParameter.ActualName = Problem.EvaluatorParameter.Name;
+        evaluator.OperatorParameter.Hidden = true;
         UpdateAnalyzers();
         ParameterizeOperators();
@@ -220,5 +222,11 @@
     protected override void Problem_OperatorsChanged(object sender, EventArgs e) {
       base.Problem_OperatorsChanged(sender, e);
+      RegisterEvents();
+      solutionCreator.OperatorParameter.ActualName = Problem.SolutionCreatorParameter.Name;
+      solutionCreator.OperatorParameter.Hidden = true;
+      evaluator.OperatorParameter.ActualName = Problem.EvaluatorParameter.Name;
+      evaluator.OperatorParameter.Hidden = true;
       UpdateAnalyzers();
+      ParameterizeOperators();
     }
 
@@ -266,11 +274,16 @@
         var realVectorParameterName = realVectorCreator.RealVectorParameter.ActualName;
         initializer.PointParameter.ActualName = realVectorParameterName;
+        initializer.PointParameter.Hidden = true;
         makeStep.PointParameter.ActualName = realVectorParameterName;
+        makeStep.PointParameter.Hidden = true;
         analyzer.PointParameter.ActualName = realVectorParameterName;
+        analyzer.PointParameter.Hidden = true;
       }
 
       var qualityParameterName = Problem.Evaluator.QualityParameter.ActualName;
       updateResults.QualityParameter.ActualName = qualityParameterName;
+      updateResults.QualityParameter.Hidden = true;
       analyzer.QualityParameter.ActualName = qualityParameterName;
+      analyzer.QualityParameter.Hidden = true;
     }
   }
Index: /branches/crossvalidation-2434/HeuristicLab.Algorithms.GradientDescent/3.3/LbfgsUpdateResults.cs
===================================================================
--- /branches/crossvalidation-2434/HeuristicLab.Algorithms.GradientDescent/3.3/LbfgsUpdateResults.cs	(revision 12819)
+++ /branches/crossvalidation-2434/HeuristicLab.Algorithms.GradientDescent/3.3/LbfgsUpdateResults.cs	(revision 12820)
@@ -37,4 +37,5 @@
     private const string StateParameterName = "State";
     private const string ApproximateGradientsParameterName = "ApproximateGradients";
+    private const string MaximizationParameterName = "Maximization";
 
     #region Parameter Properties
@@ -51,4 +52,7 @@
       get { return (ILookupParameter<LbfgsState>)Parameters[StateParameterName]; }
     }
+    public ILookupParameter<BoolValue> MaximizationParameter {
+      get { return (ILookupParameter<BoolValue>)Parameters[MaximizationParameterName]; }
+    }
     #endregion
 
@@ -58,4 +62,16 @@
     private DoubleValue Quality { get { return QualityParameter.ActualValue; } }
     private LbfgsState State { get { return StateParameter.ActualValue; } }
+
+    private BoolValue Maximization {
+      get {
+        // BackwardsCompatibility3.3
+        #region Backwards compatible code, remove with 3.4
+        // the parameter is new, previously we assumed minimization problems
+        if (MaximizationParameter.ActualValue == null) return new BoolValue(false);
+        #endregion
+        return MaximizationParameter.ActualValue;
+      }
+    }
+
     #endregion
 
@@ -70,6 +86,19 @@
       Parameters.Add(new LookupParameter<BoolValue>(ApproximateGradientsParameterName,
                                                     "Flag that indicates if gradients should be approximated."));
+      Parameters.Add(new LookupParameter<BoolValue>(MaximizationParameterName, "Flag that indicates if we solve a maximization problem."));
       // in & out
       Parameters.Add(new LookupParameter<LbfgsState>(StateParameterName, "The state of the LM-BFGS algorithm."));
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      // BackwardsCompatibility3.3
+
+      #region Backwards compatible code, remove with 3.4
+      if (!Parameters.ContainsKey(MaximizationParameterName)) {
+        // previous behaviour defaulted to minimization
+        Parameters.Add(new LookupParameter<BoolValue>(MaximizationParameterName, "Flag that indicates if we solve a maximization problem."));
+      }
+      #endregion
     }
 
@@ -80,8 +109,9 @@
     public override IOperation Apply() {
       var state = State;
-      var f = Quality.Value;
+      var sign = Maximization.Value ? -1.0 : 1.0;
+      var f = sign * Quality.Value;
       state.State.f = f;
       if (!ApproximateGradients.Value) {
-        var g = QualityGradients.ToArray();
+        var g = QualityGradients.Select(gi => sign * gi).ToArray();
         state.State.g = g;
       }
Index: /branches/crossvalidation-2434/HeuristicLab.Optimization.Views/3.3/RunCollectionViews/RunCollectionBoxPlotView.cs
===================================================================
--- /branches/crossvalidation-2434/HeuristicLab.Optimization.Views/3.3/RunCollectionViews/RunCollectionBoxPlotView.cs	(revision 12819)
+++ /branches/crossvalidation-2434/HeuristicLab.Optimization.Views/3.3/RunCollectionViews/RunCollectionBoxPlotView.cs	(revision 12820)
@@ -345,5 +345,15 @@
       switch (axisDimension) {
         case AxisDimension.Color: {
-            value = GetCategoricalValue(-1, run.Color.ToString());
+            const int colorDimension = -1;
+            if (!categoricalMapping.ContainsKey(colorDimension)) {
+              categoricalMapping[colorDimension] = Content.Where(r => r.Visible)
+                  .Select(r => r.Color.Name)
+                  .Distinct()
+                  .OrderBy(c => c, new NaturalStringComparer())
+                  .Select((c, i) => new { Color = c, Index = i })
+                  .ToDictionary(a => (object)a.Color, a => (double)a.Index);
+
+            }
+            value = GetCategoricalValue(colorDimension, run.Color.Name);
             break;
           }
Index: /branches/crossvalidation-2434/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationEnsembleSolution.cs
===================================================================
--- /branches/crossvalidation-2434/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationEnsembleSolution.cs	(revision 12819)
+++ /branches/crossvalidation-2434/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationEnsembleSolution.cs	(revision 12820)
@@ -49,4 +49,5 @@
     }
 
+    [Storable]
     private readonly ItemCollection<IClassificationSolution> classificationSolutions;
     public IItemCollection<IClassificationSolution> ClassificationSolutions {
@@ -66,12 +67,14 @@
     [StorableHook(HookType.AfterDeserialization)]
     private void AfterDeserialization() {
-      foreach (var model in Model.Models) {
-        IClassificationProblemData problemData = (IClassificationProblemData)ProblemData.Clone();
-        problemData.TrainingPartition.Start = trainingPartitions[model].Start;
-        problemData.TrainingPartition.End = trainingPartitions[model].End;
-        problemData.TestPartition.Start = testPartitions[model].Start;
-        problemData.TestPartition.End = testPartitions[model].End;
-
-        classificationSolutions.Add(model.CreateClassificationSolution(problemData));
+      if (!classificationSolutions.Any()) {
+        foreach (var model in Model.Models) {
+          IClassificationProblemData problemData = (IClassificationProblemData)ProblemData.Clone();
+          problemData.TrainingPartition.Start = trainingPartitions[model].Start;
+          problemData.TrainingPartition.End = trainingPartitions[model].End;
+          problemData.TestPartition.Start = testPartitions[model].Start;
+          problemData.TestPartition.End = testPartitions[model].End;
+
+          classificationSolutions.Add(model.CreateClassificationSolution(problemData));
+        }
       }
       RegisterClassificationSolutionsEventHandler();
Index: /branches/crossvalidation-2434/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionEnsembleSolution.cs
===================================================================
--- /branches/crossvalidation-2434/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionEnsembleSolution.cs	(revision 12819)
+++ /branches/crossvalidation-2434/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionEnsembleSolution.cs	(revision 12820)
@@ -50,4 +50,5 @@
     }
 
+    [Storable]
     private readonly ItemCollection<IRegressionSolution> regressionSolutions;
     public IItemCollection<IRegressionSolution> RegressionSolutions {
@@ -67,12 +68,14 @@
     [StorableHook(HookType.AfterDeserialization)]
     private void AfterDeserialization() {
-      foreach (var model in Model.Models) {
-        IRegressionProblemData problemData = (IRegressionProblemData)ProblemData.Clone();
-        problemData.TrainingPartition.Start = trainingPartitions[model].Start;
-        problemData.TrainingPartition.End = trainingPartitions[model].End;
-        problemData.TestPartition.Start = testPartitions[model].Start;
-        problemData.TestPartition.End = testPartitions[model].End;
-
-        regressionSolutions.Add(model.CreateRegressionSolution(problemData));
+      if (!regressionSolutions.Any()) {
+        foreach (var model in Model.Models) {
+          IRegressionProblemData problemData = (IRegressionProblemData)ProblemData.Clone();
+          problemData.TrainingPartition.Start = trainingPartitions[model].Start;
+          problemData.TrainingPartition.End = trainingPartitions[model].End;
+          problemData.TestPartition.Start = testPartitions[model].Start;
+          problemData.TestPartition.End = testPartitions[model].End;
+
+          regressionSolutions.Add(model.CreateRegressionSolution(problemData));
+        }
       }
       RegisterRegressionSolutionsEventHandler();
Index: /branches/crossvalidation-2434/HeuristicLab.Problems.QuadraticAssignment.Algorithms/3.3/RobustTabooSeachOperator.cs
===================================================================
--- /branches/crossvalidation-2434/HeuristicLab.Problems.QuadraticAssignment.Algorithms/3.3/RobustTabooSeachOperator.cs	(revision 12819)
+++ /branches/crossvalidation-2434/HeuristicLab.Problems.QuadraticAssignment.Algorithms/3.3/RobustTabooSeachOperator.cs	(revision 12820)
@@ -90,4 +90,8 @@
     private ILookupParameter<BoolValue> AllMovesTabuParameter {
       get { return (ILookupParameter<BoolValue>)Parameters["AllMovesTabu"]; }
+    }
+
+    public ILookupParameter<IntValue> EvaluatedMovesParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["EvaluatedMoves"]; }
     }
     #endregion
@@ -117,4 +121,5 @@
       Parameters.Add(new ValueLookupParameter<IntValue>("AlternativeAspirationTenure", "The time t that a move will be remembered for the alternative aspiration condition."));
       Parameters.Add(new LookupParameter<BoolValue>("AllMovesTabu", "Indicates that all moves are tabu."));
+      Parameters.Add(new LookupParameter<IntValue>("EvaluatedMoves", "The number of move evaluations made."));
     }
 
@@ -129,4 +134,7 @@
       if (!Parameters.ContainsKey("AllMovesTabu")) {
         Parameters.Add(new LookupParameter<BoolValue>("AllMovesTabu", "Indicates that all moves are tabu."));
+      }
+      if (!Parameters.ContainsKey("EvaluatedMoves")) {
+        Parameters.Add(new LookupParameter<IntValue>("EvaluatedMoves", "The number of move evaluations made."));
       }
       #endregion
@@ -163,10 +171,15 @@
       bool already_aspired = false;
 
+      var evaluatedMoves = 0;
       foreach (Swap2Move move in ExhaustiveSwap2MoveGenerator.Generate(solution)) {
         double moveQuality;
-        if (lastMove == null)
+        if (lastMove == null) {
           moveQuality = QAPSwap2MoveEvaluator.Apply(solution, move, weights, distances);
-        else if (allMovesTabu) moveQuality = moveQualityMatrix[move.Index1, move.Index2];
-        else moveQuality = QAPSwap2MoveEvaluator.Apply(solution, move, moveQualityMatrix[move.Index1, move.Index2], weights, distances, lastMove);
+          evaluatedMoves++;
+        } else if (allMovesTabu) moveQuality = moveQualityMatrix[move.Index1, move.Index2];
+        else {
+          moveQuality = QAPSwap2MoveEvaluator.Apply(solution, move, moveQualityMatrix[move.Index1, move.Index2], weights, distances, lastMove);
+          evaluatedMoves++;
+        }
 
         moveQualityMatrix[move.Index1, move.Index2] = moveQuality;
@@ -200,4 +213,6 @@
         }
       }
+
+      EvaluatedMovesParameter.ActualValue.Value += evaluatedMoves;
 
       allMovesTabu = bestMove == null;
Index: /branches/crossvalidation-2434/HeuristicLab.Problems.QuadraticAssignment.Algorithms/3.3/RobustTabooSearch.cs
===================================================================
--- /branches/crossvalidation-2434/HeuristicLab.Problems.QuadraticAssignment.Algorithms/3.3/RobustTabooSearch.cs	(revision 12819)
+++ /branches/crossvalidation-2434/HeuristicLab.Problems.QuadraticAssignment.Algorithms/3.3/RobustTabooSearch.cs	(revision 12820)
@@ -168,10 +168,18 @@
       VariableCreator variableCreator = new VariableCreator();
       variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("Iterations", new IntValue(0)));
+      variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("EvaluatedSolutions", new IntValue(0)));
+      variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("EvaluatedMoves", new IntValue(0)));
 
       ResultsCollector resultsCollector = new ResultsCollector();
       resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("Iterations", "The actual iteration."));
+      resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("EvaluatedSolutions", "The number of full solution evaluations."));
+      resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("EvaluatedMoves", "The number of move evaluations."));
 
       solutionsCreator = new SolutionsCreator();
       solutionsCreator.NumberOfSolutions = new IntValue(1);
+
+      IntCounter counter = new IntCounter();
+      counter.ValueParameter.ActualName = "EvaluatedSolutions";
+      counter.Increment = new IntValue(1);
 
       Placeholder analyzer = new Placeholder();
@@ -194,4 +202,5 @@
       mainOperator.ShortTermMemoryParameter.ActualName = "ShortTermMemory";
       mainOperator.UseAlternativeAspirationParameter.ActualName = UseAlternativeAspirationParameter.Name;
+      mainOperator.EvaluatedMovesParameter.ActualName = "EvaluatedMoves";
 
       ConditionalBranch qualityStopBranch = new ConditionalBranch();
@@ -226,5 +235,6 @@
       variableCreator.Successor = resultsCollector;
       resultsCollector.Successor = solutionsCreator;
-      solutionsCreator.Successor = analyzer;
+      solutionsCreator.Successor = counter;
+      counter.Successor = analyzer;
       analyzer.Successor = ussp;
       ussp.Operator = mainOperator;
Index: /branches/crossvalidation-2434/HeuristicLab.Problems.QuadraticAssignment/3.3/LocalImprovement/QAPExhaustiveInversionLocalImprovement.cs
===================================================================
--- /branches/crossvalidation-2434/HeuristicLab.Problems.QuadraticAssignment/3.3/LocalImprovement/QAPExhaustiveInversionLocalImprovement.cs	(revision 12819)
+++ /branches/crossvalidation-2434/HeuristicLab.Problems.QuadraticAssignment/3.3/LocalImprovement/QAPExhaustiveInversionLocalImprovement.cs	(revision 12820)
@@ -108,5 +108,5 @@
           }
         }
-        evaluatedSolutions.Value = (int)Math.Ceiling(evaluations);
+        evaluatedSolutions.Value += (int)Math.Ceiling(evaluations);
         if (bestMove == null) break;
         InversionManipulator.Apply(assignment, bestMove.Index1, bestMove.Index2);
Index: /branches/crossvalidation-2434/HeuristicLab.Problems.QuadraticAssignment/3.3/LocalImprovement/QAPStochasticScrambleLocalImprovement.cs
===================================================================
--- /branches/crossvalidation-2434/HeuristicLab.Problems.QuadraticAssignment/3.3/LocalImprovement/QAPStochasticScrambleLocalImprovement.cs	(revision 12819)
+++ /branches/crossvalidation-2434/HeuristicLab.Problems.QuadraticAssignment/3.3/LocalImprovement/QAPStochasticScrambleLocalImprovement.cs	(revision 12820)
@@ -119,5 +119,5 @@
           }
         }
-        evaluatedSolutions.Value = (int)Math.Ceiling(evaluations);
+        evaluatedSolutions.Value += (int)Math.Ceiling(evaluations);
         if (bestMove == null) break;
         ScrambleManipulator.Apply(assignment, bestMove.StartIndex, bestMove.ScrambledIndices);
Index: /branches/crossvalidation-2434/HeuristicLab.Tests/HeuristicLab-3.3/Samples/VnsOpSampleTest.cs
===================================================================
--- /branches/crossvalidation-2434/HeuristicLab.Tests/HeuristicLab-3.3/Samples/VnsOpSampleTest.cs	(revision 12819)
+++ /branches/crossvalidation-2434/HeuristicLab.Tests/HeuristicLab-3.3/Samples/VnsOpSampleTest.cs	(revision 12820)
@@ -75,9 +75,9 @@
 
       opProblem.Name = "1_p64_t070";
-      opProblem.Description = "Represents a symmetric Traveling Salesman Problem.";
+      opProblem.Description = "Represents an instance of an orienteering problem.";
       #endregion
       #region Algorithm Configuration
-      vns.Name = "Variable Neighborhood Search - TSP";
-      vns.Description = "A variable neighborhood search algorithm which solves a funny TSP instance";
+      vns.Name = "Variable Neighborhood Search - OP";
+      vns.Description = "A variable neighborhood search algorithm which solves an orienteering problem instance";
       vns.Problem = opProblem;
 
