Index: branches/HeuristicLab.Problems.Orienteering/HeuristicLab.Problems.Orienteering/3.3/Improvers/OrienteeringLocalImprovementOperator.cs
===================================================================
--- branches/HeuristicLab.Problems.Orienteering/HeuristicLab.Problems.Orienteering/3.3/Improvers/OrienteeringLocalImprovementOperator.cs	(revision 11323)
+++ branches/HeuristicLab.Problems.Orienteering/HeuristicLab.Problems.Orienteering/3.3/Improvers/OrienteeringLocalImprovementOperator.cs	(revision 12721)
@@ -1,5 +1,5 @@
 ﻿#region License Information
 /* HeuristicLab
- * Copyright (C) 2002-2014 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ * Copyright (C) 2002-2015 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
  *
  * This file is part of HeuristicLab.
@@ -20,5 +20,4 @@
 #endregion
 
-using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -33,7 +32,10 @@
 
 namespace HeuristicLab.Problems.Orienteering {
-  [Item("OrienteeringLocalImprovementOperator", @"Iterative improvement consists of three basic operators: shortening, vertex insert and vertex
-exchange. The shortening operator tries to rearrange the vertices within a tour in order to
-minimize the cost of the tour. As shortening operator a 2-opt is applied. (Schilde et. al. 2009)")]
+  /// <summary>
+  /// Iterative improvement consists of three basic operators: shortening, vertex insert and vertex
+  /// exchange. The shortening operator tries to rearrange the vertices within a tour in order to
+  /// minimize the cost of the tour. As shortening operator a 2-opt is applied. (Schilde et. al. 2009)
+  /// </summary>
+  [Item("OrienteeringLocalImprovementOperator", @"Implements the iterative improvement procedure described in Schilde M., Doerner K.F., Hartl R.F., Kiechle G. 2009. Metaheuristics for the bi-objective orienteering problem. Swarm Intelligence, Volume 3, Issue 3, pp 179-201.")]
   [StorableClass]
   public sealed class OrienteeringLocalImprovementOperator : SingleSuccessorOperator, ILocalImprovementOperator {
@@ -125,5 +127,5 @@
       bool useMaxBlockLength = UseMaximumBlockLengthParmeter.Value.Value;
 
-      bool optimizationDone = true;
+      bool solutionChanged = true;
 
       var tour = IntegerVectorParameter.ActualValue.ToList();
@@ -137,6 +139,6 @@
 
       // Check if the tour can be improved by adding or replacing points
-      while (optimizationDone && localIterations.Value < maxIterations) {
-        optimizationDone = false;
+      while (solutionChanged && localIterations.Value < maxIterations) {
+        solutionChanged = false;
 
         if (localIterations.Value == 0)
@@ -152,10 +154,10 @@
         IncludeNewPoints(tour, visitablePoints,
           distances, pointVisitingCosts, maxLength, scores,
-          ref tourLength, ref tourScore, ref evaluations, ref optimizationDone);
+          ref tourLength, ref tourScore, ref evaluations, ref solutionChanged);
 
         // Determine if any of the visitable points can take the place of an already visited point in the tour to improve the scores
         ReplacePoints(tour, visitablePoints,
           distances, maxLength, scores,
-          ref tourLength, ref tourScore, ref evaluations, ref optimizationDone);
+          ref tourLength, ref tourScore, ref evaluations, ref solutionChanged);
 
         localIterations.Value++;
@@ -173,19 +175,19 @@
 
     private void ShortenPath(List<int> tour, DistanceMatrix distances, int maxBlockLength, bool useMaxBlockLength, ref double tourLength, ref int evaluations) {
-      bool optimizationDone = true;
+      bool solutionChanged;
       int pathSize = tour.Count;
       maxBlockLength = (useMaxBlockLength && (pathSize > maxBlockLength + 1)) ? maxBlockLength : (pathSize - 2);
 
       // Perform a 2-opt
-      while (optimizationDone) {
-        optimizationDone = false;
+      do {
+        solutionChanged = false;
 
         for (int blockLength = 2; blockLength < maxBlockLength; blockLength++) {
           // If an optimization has been done, start from the beginning
-          if (optimizationDone) break;
+          if (solutionChanged) break;
 
           for (int position = 1; position < (pathSize - blockLength); position++) {
             // If an optimization has been done, start from the beginning
-            if (optimizationDone) break;
+            if (solutionChanged) break;
 
             evaluations++;
@@ -198,5 +200,6 @@
             newLength += distances[tour[position], tour[position + blockLength]];
 
-            if (newLength < tourLength - 0.00001) { // Avoid cycling caused by precision
+            if (newLength < tourLength - 0.00001) {
+              // Avoid cycling caused by precision
               var reversePart = tour.GetRange(position, blockLength).AsEnumerable().Reverse();
 
@@ -207,21 +210,22 @@
 
               // Re-run the optimization
-              optimizationDone = true;
+              solutionChanged = true;
             }
           }
         }
-      }
-    }
+      } while (solutionChanged);
+    }
+
     private void IncludeNewPoints(List<int> tour, List<int> visitablePoints,
       DistanceMatrix distances, double pointVisitingCosts, double maxLength, DoubleArray scores,
-      ref double tourLength, ref double tourScore, ref int evaluations, ref bool optimizationDone) {
+      ref double tourLength, ref double tourScore, ref int evaluations, ref bool solutionChanged) {
 
       for (int tourPosition = 1; tourPosition < tour.Count; tourPosition++) {
         // If an optimization has been done, start from the beginning
-        if (optimizationDone) break;
+        if (solutionChanged) break;
 
         for (int i = 0; i < visitablePoints.Count; i++) {
           // If an optimization has been done, start from the beginning
-          if (optimizationDone) break;
+          if (solutionChanged) break;
 
           evaluations++;
@@ -239,20 +243,21 @@
 
             // Re-run this optimization
-            optimizationDone = true;
+            solutionChanged = true;
           }
         }
       }
     }
+
     private void ReplacePoints(List<int> tour, List<int> visitablePoints,
       DistanceMatrix distances, double maxLength, DoubleArray scores,
-      ref double tourLength, ref double tourScore, ref int evaluations, ref bool optimizationDone) {
+      ref double tourLength, ref double tourScore, ref int evaluations, ref bool solutionChanged) {
 
       for (int tourPosition = 1; tourPosition < tour.Count - 1; tourPosition++) {
         // If an optimization has been done, start from the beginning
-        if (optimizationDone) break;
+        if (solutionChanged) break;
 
         for (int i = 0; i < visitablePoints.Count; i++) {
           // If an optimization has been done, start from the beginning
-          if (optimizationDone) break;
+          if (solutionChanged) break;
 
           evaluations++;
@@ -274,5 +279,5 @@
 
             // Re-run this optimization
-            optimizationDone = true;
+            solutionChanged = true;
           }
         }
