Changeset 12820

Timestamp:

07/30/15 18:42:18 (9 years ago)

Author:

gkronber

Message:

#2434: merged r12787:12819 from trunk to branch

Location:

branches/crossvalidation-2434

Files:

• . (modified) (1 prop)
• HeuristicLab.Algorithms.DataAnalysis (modified) (1 prop)
• HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessBase.cs (modified) (2 diffs)
• HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessModel.cs (modified) (8 diffs)
• HeuristicLab.Algorithms.GradientDescent/3.3/Lbfgs.cs (modified) (3 diffs)
• HeuristicLab.Algorithms.GradientDescent/3.3/LbfgsUpdateResults.cs (modified) (5 diffs)
• HeuristicLab.Optimization.Views (modified) (1 prop)
• HeuristicLab.Optimization.Views/3.3/RunCollectionViews/RunCollectionBoxPlotView.cs (modified) (1 diff)
• HeuristicLab.Optimizer (modified) (1 prop)
• HeuristicLab.Optimizer/3.3/Documents/VNS_OP.hl (modified) (previous)
• HeuristicLab.Problems.DataAnalysis (modified) (1 prop)
• HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationEnsembleSolution.cs (modified) (2 diffs)
• HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionEnsembleSolution.cs (modified) (2 diffs)
• HeuristicLab.Problems.NK/3.3 (modified) (1 prop)
• HeuristicLab.Problems.QuadraticAssignment (modified) (1 prop)
• HeuristicLab.Problems.QuadraticAssignment.Algorithms/3.3/RobustTabooSeachOperator.cs (modified) (5 diffs)
• HeuristicLab.Problems.QuadraticAssignment.Algorithms/3.3/RobustTabooSearch.cs (modified) (3 diffs)
• HeuristicLab.Problems.QuadraticAssignment/3.3/LocalImprovement/QAPExhaustiveInversionLocalImprovement.cs (modified) (1 diff)
• HeuristicLab.Problems.QuadraticAssignment/3.3/LocalImprovement/QAPStochasticScrambleLocalImprovement.cs (modified) (1 diff)
• HeuristicLab.Tests (modified) (1 prop)
• HeuristicLab.Tests/HeuristicLab-3.3/Samples/VnsOpSampleTest.cs (modified) (1 diff)

branches/crossvalidation-2434/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessBase.cs

@@ -108 +108 @@
       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 +185 @@
     [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
     }
   }

branches/crossvalidation-2434/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessModel.cs

@@ -85 +85 @@
     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 +125 @@
       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 +137 @@
 
       // shallow copies of arrays because they cannot be modified
+      this.trainingRows = original.trainingRows;
       this.allowedInputVariables = original.allowedInputVariables;
       this.alpha = original.alpha;
@@ -137 +163 @@
                                              .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 +185 @@
         .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 +249 @@
     }
 
+    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 +299 @@
 
     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 +324 @@
 
     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 

branches/crossvalidation-2434/HeuristicLab.Algorithms.GradientDescent/3.3/Lbfgs.cs

@@ -200 +200 @@
         RegisterEvents();
         solutionCreator.OperatorParameter.ActualName = Problem.SolutionCreatorParameter.Name;
+        solutionCreator.OperatorParameter.Hidden = true;
         evaluator.OperatorParameter.ActualName = Problem.EvaluatorParameter.Name;
+        evaluator.OperatorParameter.Hidden = true;
         UpdateAnalyzers();
         ParameterizeOperators();
@@ -220 +222 @@
     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 +274 @@
         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;
     }
   }

branches/crossvalidation-2434/HeuristicLab.Algorithms.GradientDescent/3.3/LbfgsUpdateResults.cs

@@ -37 +37 @@
     private const string StateParameterName = "State";
     private const string ApproximateGradientsParameterName = "ApproximateGradients";
+    private const string MaximizationParameterName = "Maximization";
 
     #region Parameter Properties
@@ -51 +52 @@
       get { return (ILookupParameter<LbfgsState>)Parameters[StateParameterName]; }
     }
+    public ILookupParameter<BoolValue> MaximizationParameter {
+      get { return (ILookupParameter<BoolValue>)Parameters[MaximizationParameterName]; }
+    }
     #endregion
 
@@ -58 +62 @@
     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 +86 @@
       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 +109 @@
     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;
       }

branches/crossvalidation-2434/HeuristicLab.Optimization.Views/3.3/RunCollectionViews/RunCollectionBoxPlotView.cs

@@ -345 +345 @@
       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;
           }

branches/crossvalidation-2434/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationEnsembleSolution.cs

@@ -49 +49 @@
     }
 
+    [Storable]
     private readonly ItemCollection<IClassificationSolution> classificationSolutions;
     public IItemCollection<IClassificationSolution> ClassificationSolutions {
@@ -66 +67 @@
     [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();

branches/crossvalidation-2434/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionEnsembleSolution.cs

@@ -50 +50 @@
     }
 
+    [Storable]
     private readonly ItemCollection<IRegressionSolution> regressionSolutions;
     public IItemCollection<IRegressionSolution> RegressionSolutions {
@@ -67 +68 @@
     [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();

branches/crossvalidation-2434/HeuristicLab.Problems.QuadraticAssignment.Algorithms/3.3/RobustTabooSeachOperator.cs

@@ -90 +90 @@
     private ILookupParameter<BoolValue> AllMovesTabuParameter {
       get { return (ILookupParameter<BoolValue>)Parameters["AllMovesTabu"]; }
+    }
+
+    public ILookupParameter<IntValue> EvaluatedMovesParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["EvaluatedMoves"]; }
     }
     #endregion
@@ -117 +121 @@
       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 +134 @@
       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 +171 @@
       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 +213 @@
         }
       }
+
+      EvaluatedMovesParameter.ActualValue.Value += evaluatedMoves;
 
       allMovesTabu = bestMove == null;

branches/crossvalidation-2434/HeuristicLab.Problems.QuadraticAssignment.Algorithms/3.3/RobustTabooSearch.cs

@@ -168 +168 @@
       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 +202 @@
       mainOperator.ShortTermMemoryParameter.ActualName = "ShortTermMemory";
       mainOperator.UseAlternativeAspirationParameter.ActualName = UseAlternativeAspirationParameter.Name;
+      mainOperator.EvaluatedMovesParameter.ActualName = "EvaluatedMoves";
 
       ConditionalBranch qualityStopBranch = new ConditionalBranch();
@@ -226 +235 @@
       variableCreator.Successor = resultsCollector;
       resultsCollector.Successor = solutionsCreator;
-      solutionsCreator.Successor = analyzer;
+      solutionsCreator.Successor = counter;
+      counter.Successor = analyzer;
       analyzer.Successor = ussp;
       ussp.Operator = mainOperator;

branches/crossvalidation-2434/HeuristicLab.Problems.QuadraticAssignment/3.3/LocalImprovement/QAPExhaustiveInversionLocalImprovement.cs

@@ -108 +108 @@
           }
         }
-        evaluatedSolutions.Value = (int)Math.Ceiling(evaluations);
+        evaluatedSolutions.Value += (int)Math.Ceiling(evaluations);
         if (bestMove == null) break;
         InversionManipulator.Apply(assignment, bestMove.Index1, bestMove.Index2);

branches/crossvalidation-2434/HeuristicLab.Problems.QuadraticAssignment/3.3/LocalImprovement/QAPStochasticScrambleLocalImprovement.cs

@@ -119 +119 @@
           }
         }
-        evaluatedSolutions.Value = (int)Math.Ceiling(evaluations);
+        evaluatedSolutions.Value += (int)Math.Ceiling(evaluations);
         if (bestMove == null) break;
         ScrambleManipulator.Apply(assignment, bestMove.StartIndex, bestMove.ScrambledIndices);

branches/crossvalidation-2434/HeuristicLab.Tests/HeuristicLab-3.3/Samples/VnsOpSampleTest.cs

@@ -75 +75 @@
 
       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;