Changeset 15333 for branches/jschiess

Timestamp:

08/21/17 11:17:24 (7 years ago)

Author:

jschiess

Message:

#1836 SA reheating strategies
+ added an adaptive temperature control strategy
+ some refactorings

Location:

branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4

Files:

• .vs/HeuristicLab.Algorithms.SimulatedAnnealing-3.3/v14/.suo (modified) (previous)
• AcceptanceRatioReheatingOperator.cs (modified) (7 diffs)
• AdaptiveReheatingOperator.cs (added)
• ConsecutiveRejectionTemperatureResetOperator.cs (modified) (4 diffs)
• NoReheatingOperator.cs (modified) (3 diffs)
• RandomWalkReheatingOperator.cs (modified) (7 diffs)
• SimulatedAnnealingMainLoop.cs (modified) (2 diffs)
• TemperatureController.cs (modified) (3 diffs)
• TemperatureInitializerBasedOnAverageHillsize.cs (modified) (1 diff)

branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/AcceptanceRatioReheatingOperator.cs

@@ -39 +39 @@
         private const string AverageAcceptanceRatioName = "AverageAcceptanceRatio";
         private const string ReheatWindowSizeName = "ReheatWindowSize";
+        private const string LastAcceptedQualityName = "LastAcceptedQuality";
+        private const string MoveQualityName = "MoveQuality";
 
 
@@ -67 +69 @@
             get { return (ILookupParameter<IntValue>)Parameters[IterationsName]; }
         }
-        public ILookupParameter<IOperator> AnnealingOperatorParameter
-        {
-            get { return (ILookupParameter<IOperator>)Parameters[AnnealingOperatorName]; }
+        public ILookupParameter<IDiscreteDoubleValueModifier> AnnealingOperatorParameter
+        {
+            get { return (ILookupParameter<IDiscreteDoubleValueModifier>)Parameters[AnnealingOperatorName]; }
         }
         public ILookupParameter<IntValue> MaximumIterationsParameter
@@ -110 +112 @@
         {
             get { return (IValueParameter<IntValue>)Parameters[ReheatWindowSizeName]; }
+        }
+        public ILookupParameter<DoubleValue> MoveQualityParameter
+        {
+            get { return (ILookupParameter<DoubleValue>)Parameters[MoveQualityName]; }
+        }
+        public ILookupParameter<DoubleValue> LastAcceptedQualityParameter
+        {
+            get { return (ILookupParameter<DoubleValue>)Parameters[LastAcceptedQualityName]; }
         }
 
@@ -120 +130 @@
             Parameters.Add(new LookupParameter<DoubleValue>(LowerTemperatureName, "The lower bound of the temperature."));
             Parameters.Add(new LookupParameter<IntValue>(IterationsName, "The number of iterations."));
-            Parameters.Add(new LookupParameter<IOperator>(AnnealingOperatorName, "The operator that cools the temperature."));
+            Parameters.Add(new LookupParameter<IDiscreteDoubleValueModifier>(AnnealingOperatorName, "The operator that cools the temperature."));
             Parameters.Add(new LookupParameter<IntValue>(TemperatureStartIndexName, "The index where the annealing or heating was last changed."));
             Parameters.Add(new LookupParameter<DoubleValue>(StartTemperatureName, "The temperature from which cooling or reheating should occur."));
@@ -134 +144 @@
             Parameters.Add(new LookupParameter<DoubleValue>(AverageAcceptanceRatioName, "Average acceptance over full acceptance memory."));
             Parameters.Add(new ValueParameter<IntValue>(ReheatWindowSizeName, "The amount of iterations each reheat needs to heat the current temperature to upper temperature.", new IntValue(10000)));
+            Parameters.Add(new LookupParameter<DoubleValue>(LastAcceptedQualityName, "Quality of last accepted solution."));
+            Parameters.Add(new LookupParameter<DoubleValue>(MoveQualityName, "The value which represents the quality of a move."));
             #endregion
 
@@ -173 +185 @@
         public override IOperation Apply()
         {
-            var isAccepted = IsAcceptedParameter.ActualValue;
+            var isAccepted = IsAcceptedParameter.ActualValue.Value && LastAcceptedQualityParameter.ActualValue.Value != MoveQualityParameter.ActualValue.Value;
             var acceptances = AcceptanceMemoryParameter.ActualValue;
             var cooling = CoolingParameter.ActualValue.Value;
             var ratioAmount = AverageAcceptanceRatioParameter.ActualValue;
 
-            acceptances.Add(isAccepted);
-
-            ratioAmount.Value += isAccepted.Value ? 1 : 0;
-
+            acceptances.Add(new BoolValue(isAccepted));
+            ratioAmount.Value += isAccepted ? 1 : 0;
 
             if (acceptances.Count > MemorySizeParameter.Value.Value) {
@@ -216 +226 @@
                 CoolingParameter.ActualValue.Value = cooling;
             }
+
+            if (isAccepted)
+            {
+                LastAcceptedQualityParameter.ActualValue.Value = MoveQualityParameter.ActualValue.Value;
+            }
+
             return cooling ? Cool() : Heat();
         }

branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/ConsecutiveRejectionTemperatureResetOperator.cs

@@ -30 +30 @@
         private const string MaximumIterationsName = "MaximumIterations";
         private const string InitialTemperatureName = "InitialTemperature";
-
         private const string ThresholdName = "Threshold";
         private const string IsAcceptedName = "IsAccepted";
         private const string ConsecutiveRejectedSolutionsCountName = "ConsecutiveRejectedSolutions";
         private const string ResetTemperatureName = "ResetTemperature";
+        private const string LastAcceptedQualityName = "LastAcceptedQuality";
+        private const string MoveQualityName = "MoveQuality";
         #endregion
 
@@ -86 +87 @@
             get { return (ILookupParameter<IntValue>)Parameters[ConsecutiveRejectedSolutionsCountName]; }
         }
+        public ILookupParameter<DoubleValue> MoveQualityParameter
+        {
+            get { return (ILookupParameter<DoubleValue>)Parameters[MoveQualityName]; }
+        }
+        public ILookupParameter<DoubleValue> LastAcceptedQualityParameter
+        {
+            get { return (ILookupParameter<DoubleValue>)Parameters[LastAcceptedQualityName]; }
+        }
         #endregion
 
@@ -103 +112 @@
             Parameters.Add(new ValueParameter<IntValue>(ThresholdName, "How many consecutive rejected solutions must occur to trigger a reheat.", new IntValue(10)));
             Parameters.Add(new ValueLookupParameter<DoubleValue>(ResetTemperatureName, "The base reset temperature.", InitialTemperatureName));
-          
+            Parameters.Add(new LookupParameter<DoubleValue>(LastAcceptedQualityName, "Quality of last accepted solution."));
+            Parameters.Add(new LookupParameter<DoubleValue>(MoveQualityName, "The value which represents the quality of a move."));
+
             #endregion
 
@@ -125 +136 @@
         public override IOperation Apply()
         {
-            var count = ConsecutiveRejectedSolutionsCountParameter.ActualValue;
+            if(!IsAcceptedParameter.ActualValue.Value || LastAcceptedQualityParameter.ActualValue.Value.Equals(MoveQualityParameter.ActualValue.Value))
+            {
+                ConsecutiveRejectedSolutionsCountParameter.ActualValue.Value++;
+            }else
+            {
+                ConsecutiveRejectedSolutionsCountParameter.ActualValue.Value = 0;
+            }
 
-            count.Value = !IsAcceptedParameter.ActualValue.Value ? count.Value + 1 : 0;
 
-            var heating = count.Value == ThresholdParameter.Value.Value;
+            var heating = ConsecutiveRejectedSolutionsCountParameter.ActualValue.Value >= ThresholdParameter.Value.Value;
 
-            if(heating) count.Value = 0;
+            if (heating)
+            {
+                ConsecutiveRejectedSolutionsCountParameter.ActualValue.Value = 0;
+            }
+
+            if (IsAcceptedParameter.ActualValue.Value)
+            {
+                LastAcceptedQualityParameter.ActualValue.Value = MoveQualityParameter.ActualValue.Value;
+            }
 
             return heating ? Heat() : Cool();

branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/NoReheatingOperator.cs

@@ -22 +22 @@
         #region Strings
         private const string AnnealingOperatorName = "AnnealingOperator";
-        private const string LowerTemperatureName = "LowerTemperature";
-        private const string IterationsName = "Iterations";
-        private const string TemperatureStartIndexName = "TemperatureStartIndex";
-        private const string StartTemperatureName = "StartTemperature";
-        private const string EndTemperatureName = "EndTemperature";
-        private const string TemperatureName = "Temperature";
-        private const string MaximumIterationsName = "MaximumIterations";
-
 
         #endregion
-        #region Parameters
-        public ILookupParameter<DoubleValue> TemperatureParameter
-        {
-            get { return (ILookupParameter<DoubleValue>)Parameters[TemperatureName]; }
-        }
-        public ILookupParameter<DoubleValue> LowerTemperatureParameter
-        {
-            get { return (ILookupParameter<DoubleValue>)Parameters[LowerTemperatureName]; }
-        }
-        public ILookupParameter<DoubleValue> StartTemperatureParameter
-        {
-            get { return (ILookupParameter<DoubleValue>)Parameters[StartTemperatureName]; }
-        }
-        public ILookupParameter<DoubleValue> EndTemperatureParameter
-        {
-            get { return (ILookupParameter<DoubleValue>)Parameters[EndTemperatureName]; }
-        }
-        public ILookupParameter<IntValue> TemperatureStartIndexParameter
-        {
-            get { return (ILookupParameter<IntValue>)Parameters[TemperatureStartIndexName]; }
-        }
-        public ILookupParameter<IntValue> IterationsParameter
-        {
-            get { return (ILookupParameter<IntValue>)Parameters[IterationsName]; }
-        }
+        #region Parameters      
         public ILookupParameter<IOperator> AnnealingOperatorParameter
         {
             get { return (ILookupParameter<IOperator>)Parameters[AnnealingOperatorName]; }
-        }
-        public ILookupParameter<IntValue> MaximumIterationsParameter
-        {
-            get { return (ILookupParameter<IntValue>)Parameters[MaximumIterationsName]; }
         }
 
@@ -71 +35 @@
         {
             #region Create parameters
-            Parameters.Add(new LookupParameter<DoubleValue>(TemperatureName, "The current temperature."));
-            Parameters.Add(new LookupParameter<DoubleValue>(LowerTemperatureName, "The lower bound of the temperature."));
-            Parameters.Add(new LookupParameter<IntValue>(IterationsName, "The number of iterations."));
-            Parameters.Add(new LookupParameter<IntValue>(TemperatureStartIndexName, "The index where the annealing or heating was last changed."));
-            Parameters.Add(new LookupParameter<DoubleValue>(StartTemperatureName, "The temperature from which cooling or reheating should occur."));
-            Parameters.Add(new LookupParameter<DoubleValue>(EndTemperatureName, "The temperature to which should be cooled or heated."));
-            Parameters.Add(new LookupParameter<IntValue>(MaximumIterationsName, "The maximum number of iterations which should be processed."));
             Parameters.Add(new LookupParameter<IOperator>(AnnealingOperatorName, "The operator that cools the temperature."));
             #endregion
@@ -100 +57 @@
         public override IOperation Apply()
         {
-            TemperatureStartIndexParameter.ActualValue.Value = Math.Max(0, IterationsParameter.ActualValue.Value - 1);
-            StartTemperatureParameter.ActualValue.Value = TemperatureParameter.ActualValue.Value;
-            EndTemperatureParameter.ActualValue.Value = LowerTemperatureParameter.ActualValue.Value;
             return new OperationCollection {
                     ExecutionContext.CreateOperation(AnnealingOperatorParameter.ActualValue),

branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/RandomWalkReheatingOperator.cs

@@ -29 +29 @@
         private const string TemperatureName = "Temperature";
         private const string MaximumIterationsName = "MaximumIterations";
-
-        private const string TemperatureBeforeReheatName = "TemperatureBeforeReheat";
         private const string CurrentRandomWalkStepName = "CurrentRandomWalkStep";
         private const string RandomWalkLengthName = "RandomWalkLength";
@@ -36 +34 @@
         private const string IsAcceptedName = "IsAccepted";
         private const string ConsecutiveRejectedSolutionsCountName = "ConsecutiveRejectedSolutions";
-        private const string QualitiesBeforeReheatingName = "QualitiesBeforeReheating";
-        private const string AmountOfReheatsName = "AmountOfReheats";
-        private const string RetrappedName = "Retrapped";
         private const string LastAcceptedQualityName = "LastAcceptedQuality";
-        private const string ResultsName = "Results";
         private const string MoveQualityName = "MoveQuality";
         private const string CoolingName = "Cooling";
-        private const string TabuListActiveName = "TabuListActive";
 
 
@@ -105 +98 @@
             get { return (ILookupParameter<IntValue>)Parameters[CurrentRandomWalkStepName]; }
         }
-        public ILookupParameter<DoubleValue> TemperatureBeforeReheatParameter
-        {
-            get { return (ILookupParameter<DoubleValue>)Parameters[TemperatureBeforeReheatName]; }
-        }
-        private LookupParameter<ItemList<DoubleValue>> QualitiesBeforeReheatingParameter
-        {
-            get { return (LookupParameter<ItemList<DoubleValue>>)Parameters[QualitiesBeforeReheatingName]; }
-        }
         public ILookupParameter<BoolValue> CoolingParameter
         {
@@ -124 +109 @@
         {
             get { return (ILookupParameter<DoubleValue>)Parameters[LastAcceptedQualityName]; }
-        }
-        public IValueParameter<BoolValue> TabuListActiveParameter
-        {
-            get { return (IValueParameter<BoolValue>)Parameters[TabuListActiveName];  }
         }
 
@@ -145 +126 @@
             Parameters.Add(new LookupParameter<BoolValue>(IsAcceptedName, "Whether the move was accepted or not."));
             Parameters.Add(new LookupParameter<IntValue>(ConsecutiveRejectedSolutionsCountName, "Amount of consecutive rejected solutions."));
-            Parameters.Add(new ValueParameter<IntValue>(ThresholdName, "How many consecutive rejected solutions must occur to trigger a reheat.", new IntValue(10)));
-            Parameters.Add(new ValueParameter<IntValue>(RandomWalkLengthName, "Amount of randomly accepted moves upon reheat.", new IntValue(2)));
+            Parameters.Add(new ValueParameter<IntValue>(ThresholdName, "How many consecutive rejected solutions must occur to trigger a reheat.", new IntValue(10000)));
+            Parameters.Add(new ValueParameter<IntValue>(RandomWalkLengthName, "Amount of randomly accepted moves upon reheat.", new IntValue(1)));
             Parameters.Add(new LookupParameter<IntValue>(CurrentRandomWalkStepName, "Current random walk step."));
-            Parameters.Add(new LookupParameter<DoubleValue>(TemperatureBeforeReheatName, "Temperature before the reheat occured."));
-            Parameters.Add(new LookupParameter<ItemList<DoubleValue>>(QualitiesBeforeReheatingName, "Quality of last optimum."));
             Parameters.Add(new LookupParameter<DoubleValue>(MoveQualityName, "The value which represents the quality of a move."));
             Parameters.Add(new LookupParameter<BoolValue>(CoolingName, "True when the temperature should be cooled, false otherwise."));
             Parameters.Add(new LookupParameter<DoubleValue>(LastAcceptedQualityName, "Quality of last accepted solution."));
-            Parameters.Add(new ValueParameter<BoolValue>(TabuListActiveName, "Determines whether visiting a 'frozen' quality instantly triggers a reheat or not", new BoolValue(true)));
-
             #endregion
 
@@ -176 +153 @@
         public override IOperation Apply()
         {
-            var isAccepted = IsAcceptedParameter.ActualValue.Value;
-            var consecutiveRejectedCount = ConsecutiveRejectedSolutionsCountParameter.ActualValue;
             var cooling = CoolingParameter.ActualValue.Value;
-            var frozenSolutions = QualitiesBeforeReheatingParameter.ActualValue;
             var quality = MoveQualityParameter.ActualValue;
             var lastAcceptedQuality = LastAcceptedQualityParameter.ActualValue;
-            var tabuListActive = TabuListActiveParameter.Value.Value;
-
-            if(isAccepted)
+            var isAccepted = IsAcceptedParameter.ActualValue.Value;
+            var consecutiveRejectedSolutionsCount = ConsecutiveRejectedSolutionsCountParameter.ActualValue;
+
+            if (cooling)
+            {
+                // add acceptance value to consecutive rejected solutions count
+                // if quality hasnt changed, we might be stuck on a plateau
+                if (!isAccepted || quality.Value.Equals(lastAcceptedQuality.Value))
+                {
+                    consecutiveRejectedSolutionsCount.Value++;
+                }
+                else
+                {
+                    consecutiveRejectedSolutionsCount.Value = 0;
+                }
+
+                // check if we are trapped in a local optimum
+                if (consecutiveRejectedSolutionsCount.Value >= ThresholdParameter.Value.Value)
+                {
+                    cooling = false;
+                    consecutiveRejectedSolutionsCount.Value = 0;
+                }
+            }
+
+
+            if (!cooling)
+            {
+                // random walk finished, start cooling again
+                if (RandomWalkLengthParameter.Value.Value <= CurrentRandomWalkStepParameter.ActualValue.Value)
+                {
+                    cooling = true;
+                    CurrentRandomWalkStepParameter.ActualValue.Value = 0;
+                }
+                else
+                {
+                    CurrentRandomWalkStepParameter.ActualValue.Value++;
+                }
+            }
+
+            if (isAccepted)
             {
                 LastAcceptedQualityParameter.ActualValue.Value = quality.Value;
             }
 
-            if (cooling)
-            { 
-                // check if we are re-trapped
-                if (isAccepted && frozenSolutions.Any(frozen => frozen.Value.Equals(quality.Value)) && tabuListActive)
-                {
-                   cooling = false;
-
-                    IntValue retrapped = new IntValue(0);
-                    IResult retrappedAmount;
-                    var results = (ResultCollection)ExecutionContext.Parent.Parent.Scope.Variables[ResultsName].Value;
-                    if (results.TryGetValue(RetrappedName, out retrappedAmount))
-                    {
-                        retrapped = (IntValue)retrappedAmount.Value;
-                        retrapped.Value += 1;
-                    }
-                    else
-                    {
-                        retrapped.Value += 1;
-                        results.Add(new Result(RetrappedName, retrapped));
-                    }
-                    // remember local optimum
-                    frozenSolutions.Add(new DoubleValue(lastAcceptedQuality.Value));
-                }
-                else
-                {
-                    // add acceptance value to consecutive rejected solutions count
-                    consecutiveRejectedCount.Value = !IsAcceptedParameter.ActualValue.Value ? consecutiveRejectedCount.Value + 1 : 0;
-
-                    // check if we are trapped in a new local optimum
-                    if (consecutiveRejectedCount.Value == ThresholdParameter.Value.Value)
-                    {
-                        cooling = false;
-                        consecutiveRejectedCount.Value = 0;
-                        // remember local optimum
-                        frozenSolutions.Add(new DoubleValue(lastAcceptedQuality.Value));
-                    }
-                }
-            }
-            else
-            {
-                // random walk not yet finished
-                if (RandomWalkLengthParameter.Value.Value != CurrentRandomWalkStepParameter.ActualValue.Value)
-                {
-                    if (CurrentRandomWalkStepParameter.ActualValue.Value == 0)
-                    {
-                        DebugIncreaseReheatCounter();
-                    }
-                    CurrentRandomWalkStepParameter.ActualValue.Value++;
-                }
-                else
-                {
-                    // random walk finished start cooling again
-                    cooling = true;
-                    TemperatureStartIndexParameter.ActualValue.Value = Math.Max(0, IterationsParameter.ActualValue.Value - 1);
-                    StartTemperatureParameter.ActualValue.Value = TemperatureBeforeReheatParameter.ActualValue.Value;
-                    EndTemperatureParameter.ActualValue.Value = LowerTemperatureParameter.ActualValue.Value;
-                    consecutiveRejectedCount.Value = isAccepted ? 0 : 1;
-                    CurrentRandomWalkStepParameter.ActualValue.Value = 0;
-
-                }
-            }
             CoolingParameter.ActualValue.Value = cooling;
             return cooling ? Cool() : Heat();
         }
 
-        private void DebugIncreaseReheatCounter()
-        {
-            var reheats = new IntValue(0);
-            var frozen = new ItemList<DoubleValue>();
-            var results = (ResultCollection)ExecutionContext.Parent.Parent.Scope.Variables[ResultsName].Value;
-            IResult amountOfReheats;
-            IResult frozenSolutions;
-            if (results.TryGetValue(AmountOfReheatsName, out amountOfReheats))
-            {
-                reheats = (IntValue)amountOfReheats.Value;
-                reheats.Value += 1;
-            }
-            else
-            {
-                reheats.Value += 1;
-                results.Add(new Result(AmountOfReheatsName, reheats));
-            }
-
-            if (results.TryGetValue(QualitiesBeforeReheatingName, out frozenSolutions))
-            {
-                
-                frozen = (ItemList<DoubleValue>) frozenSolutions.Value;
-                frozen.Add(new DoubleValue(LastAcceptedQualityParameter.ActualValue.Value));
-            }
-            else
-            {
-                frozen.Add(new DoubleValue(LastAcceptedQualityParameter.ActualValue.Value));
-                results.Add(new Result(QualitiesBeforeReheatingName, frozen));
-            }
-        }
-
         private IOperation Heat()
         {
@@ -293 +212 @@
         private IOperation Cool()
         {
-            TemperatureBeforeReheatParameter.ActualValue.Value = TemperatureParameter.ActualValue.Value;
             return new OperationCollection {
                     ExecutionContext.CreateOperation(AnnealingOperatorParameter.ActualValue),

branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/SimulatedAnnealingMainLoop.cs

@@ -64 +64 @@
         private const string LastQualityName = "LastQuality";
         private const string UphillMovesMemoryName = "UphillMovesMemory";
-        private const string TemperatureBeforeReheatName = "TemperatureBeforeReheat";
         private const string CurrentRandomWalkStepName = "CurrentRandomWalkStep";
-        private const string QualitiesBeforeReheatingName = "QualitiesBeforeReheating";
         private const string LastAcceptedQualityName = "LastAcceptedQuality";
         private const string TemperatureInitializerName = "TemperatureInitializer";
@@ -247 +245 @@
             variableCreator.CollectedValues.Add(new ValueParameter<ItemList<DoubleValue>>(UphillMovesMemoryName, new ItemList<DoubleValue>()));
             variableCreator.CollectedValues.Add(new ValueParameter<IntValue>(CurrentRandomWalkStepName, new IntValue(0)));
-            variableCreator.CollectedValues.Add(new ValueParameter<DoubleValue>(TemperatureBeforeReheatName, new DoubleValue(0)));
-            variableCreator.CollectedValues.Add(new ValueParameter<ItemList<DoubleValue>>(QualitiesBeforeReheatingName, new ItemList<DoubleValue>()));
             variableCreator.CollectedValues.Add(new ValueParameter<DoubleValue>(LastAcceptedQualityName, new DoubleValue(-1)));
 

branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/TemperatureController.cs

@@ -58 +58 @@
         private const string MaximizationName = "Maximization";
         private const string MoveQualityName = "MoveQuality";
-        private const string TemperatureBeforeReheatName = "TemperatureBeforeReheat";
         private const string CurrentRandomWalkStepName = "CurrentRandomWalkStep";
-        private const string QualitiesBeforeReheatingName = "QualitiesBeforeReheating";
         private const string LastAcceptedQualityName = "LastAcceptedQuality";
         private const string TemperatureInitializerName = "TemperatureInitializer";
@@ -92 +90 @@
             Parameters.Add(new ValueLookupParameter<IntValue>(MaximumIterationsName, "The maximum number of iterations which should be processed."));
             Parameters.Add(new ValueLookupParameter<BoolValue>(MaximizationName, "True if the problem is a maximization problem, otherwise false."));
-            Parameters.Add(new ValueLookupParameter<IOperator>(AnnealingOperatorName, "The operator that cools the temperature."));
+            Parameters.Add(new ValueLookupParameter<IDiscreteDoubleValueModifier>(AnnealingOperatorName, "The operator that cools the temperature."));
             Parameters.Add(new ValueLookupParameter<IReheatingOperator>(ReheatingOperatorName, "The operator that reheats the temperature if necessary."));
             Parameters.Add(new LookupParameter<IntValue>(TemperatureStartIndexName, "The index where the annealing or heating was last changed."));
@@ -108 +106 @@
             Parameters.Add(new LookupParameter<DoubleValue>(AverageAcceptanceRatioName, "Average acceptance over full acceptance memory."));
             Parameters.Add(new LookupParameter<IntValue>(CurrentRandomWalkStepName, "Current random walk step."));
-            Parameters.Add(new LookupParameter<DoubleValue>(TemperatureBeforeReheatName, "Temperature before the reheat occured."));
-            Parameters.Add(new LookupParameter<ItemList<DoubleValue>>(QualitiesBeforeReheatingName, "List of qualities where the algorithm has been stuck."));
             Parameters.Add(new LookupParameter<DoubleValue>(LastAcceptedQualityName, "Quality of last accepted solution."));
 

branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/TemperatureInitializerBasedOnAverageHillsize.cs

@@ -110 +110 @@
             Parameters.Add(new ValueLookupParameter<BoolValue>(MaximizationName, "True if the problem is a maximization problem, otherwise false."));
             Parameters.Add(new LookupParameter<IntValue>(IterationsName, "The number of iterations."));
-            Parameters.Add(new ValueParameter<DoubleValue>(InitialAcceptanceRateName, "The initial acceptance rate of average-sized hills used to calculate the initial temperature.", new DoubleValue(0.001)));
+            Parameters.Add(new ValueParameter<DoubleValue>(InitialAcceptanceRateName, "The initial acceptance rate of average-sized hills used to calculate the initial temperature.", new DoubleValue(0.1)));
             Parameters.Add(new ValueParameter<IntValue>(UphillMovesMemorySizeName, "The amount of uphill moves necessary to compute the initial temperature.", new IntValue(100)));
             Parameters.Add(new LookupParameter<ItemList<DoubleValue>>(UphillMovesMemoryName, "The field that stores the uphill moves."));