Changeset 3094

Timestamp:

03/18/10 02:03:30 (15 years ago)

Author:

abeham

Message:

Completed main loop of simulated annealing
Added a ProbabilisticQualityComparator (derived from QualityComparator)
Added an exception in ExponentialDiscreteDoubleValueModifier when startValue, endValue, or both are <= 0.
#923

Location:

trunk/sources

Files:

• HeuristicLab 3.3/Files.txt (modified) (1 diff)
• HeuristicLab.Algorithms.SimulatedAnnealing/3.3/SimulatedAnnealingMainLoop.cs (modified) (2 diffs)
• HeuristicLab.Optimization.Operators/3.3/ExponentialDiscreteDoubleValueModifier.cs (modified) (1 diff)
• HeuristicLab.Optimization.Operators/3.3/HeuristicLab.Optimization.Operators-3.3.csproj (modified) (1 diff)
• HeuristicLab.Optimization.Operators/3.3/ProbabilisticQualityComparator.cs (added)
• HeuristicLab.Optimization.Operators/3.3/QualityComparator.cs (modified) (2 diffs)

trunk/sources/HeuristicLab 3.3/Files.txt

@@ -8 +8 @@
 HeuristicLab.Algorithms.TS\3.3:HeuristicLab.Algorithms.TS-3.3.dll
 HeuristicLab.Algorithms.LS\3.3:HeuristicLab.Algorithms.LS-3.3.dll
+HeuristicLab.Algorithms.SimulatedAnnealing\3.3:HeuristicLab.Algorithms.SimulatedAnnealing-3.3.dll
 HeuristicLab.Analysis\3.3:HeuristicLab.Analysis-3.3.dll
 HeuristicLab.Analysis.Views\3.3:HeuristicLab.Analysis.Views-3.3.dll

trunk/sources/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/SimulatedAnnealingMainLoop.cs

@@ -95 +95 @@
       Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The value which represents the quality of a solution."));
       Parameters.Add(new LookupParameter<DoubleValue>("MoveQuality", "The value which represents the quality of a move."));
-      Parameters.Add(new LookupParameter<DoubleValue>("StartTemperature", "The initial temperature."));
-      Parameters.Add(new LookupParameter<DoubleValue>("EndTemperature", "The end temperature."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("StartTemperature", "The initial temperature."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("EndTemperature", "The end temperature."));
       Parameters.Add(new ValueLookupParameter<IntValue>("MaximumIterations", "The maximum number of iterations which should be processed."));
       Parameters.Add(new ValueLookupParameter<VariableCollection>("Results", "The variable collection where results should be stored."));
@@ -109 +109 @@
 
       #region Create operators
+      VariableCreator variableCreator = new VariableCreator();
+      BestQualityMemorizer initializeBestQuality = new BestQualityMemorizer();
+      SequentialSubScopesProcessor sssp = new SequentialSubScopesProcessor();
+      ResultsCollector resultsCollector = new ResultsCollector();
+      BestQualityMemorizer bestQualityMemorizer = new BestQualityMemorizer();
+      Placeholder annealingOperator = new Placeholder();
+      UniformSequentialSubScopesProcessor mainProcessor = new UniformSequentialSubScopesProcessor();
+      Placeholder moveGenerator = new Placeholder();
+      SequentialSubScopesProcessor moveEvaluationProcessor = new SequentialSubScopesProcessor();
+      Placeholder moveEvaluator = new Placeholder();
+      ProbabilisticQualityComparator qualityComparator = new ProbabilisticQualityComparator();
+      ConditionalBranch improvesQualityBranch = new ConditionalBranch();
+      Placeholder moveMaker = new Placeholder();
+      SubScopesRemover subScopesRemover = new SubScopesRemover();
+      DataTableValuesCollector valuesCollector = new DataTableValuesCollector();
+      IntCounter iterationsCounter = new IntCounter();
+      Comparator iterationsComparator = new Comparator();
+      ConditionalBranch iterationsTermination = new ConditionalBranch();
+      EmptyOperator finished = new EmptyOperator();
+
+      variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("Iterations", new IntValue(0)));
+      variableCreator.CollectedValues.Add(new ValueParameter<DataTable>("Qualities", new DataTable("Qualities")));
+      variableCreator.CollectedValues.Add(new ValueParameter<DoubleValue>("Temperature", new DoubleValue(double.MaxValue)));
+
+      resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("Iterations"));
+      resultsCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("Quality"));
+      resultsCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("Best Quality") { ActualName = "BestQuality" });
+      resultsCollector.CollectedValues.Add(new LookupParameter<DataTable>("Qualities"));
+      resultsCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("Temperature"));
+
+      annealingOperator.Name = "Annealing operator (placeholder)";
+      annealingOperator.OperatorParameter.ActualName = "AnnealingOperator";
+
+      moveGenerator.Name = "Move generator (placeholder)";
+      moveGenerator.OperatorParameter.ActualName = "MoveGenerator";
+
+      moveEvaluator.Name = "Move evaluator (placeholder)";
+      moveEvaluator.OperatorParameter.ActualName = "MoveEvaluator";
+
+      qualityComparator.LeftSideParameter.ActualName = "MoveQuality";
+      qualityComparator.RightSideParameter.ActualName = "Quality";
+      qualityComparator.ResultParameter.ActualName = "IsBetter";
+      qualityComparator.DampeningParameter.ActualName = "Temperature";
+
+      improvesQualityBranch.ConditionParameter.ActualName = "IsBetter";
+
+      moveMaker.Name = "Move maker (placeholder)";
+      moveMaker.OperatorParameter.ActualName = "MoveMaker";
+
+      subScopesRemover.RemoveAllSubScopes = true;
+
+      valuesCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("Quality"));
+      valuesCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("BestQuality"));
+      valuesCollector.DataTableParameter.ActualName = "Qualities";
+
+      iterationsCounter.Name = "Increment Iterations";
+      iterationsCounter.Increment = new IntValue(1);
+      iterationsCounter.ValueParameter.ActualName = "Iterations";
+
+      iterationsComparator.Name = "Iterations >= MaximumIterations";
+      iterationsComparator.LeftSideParameter.ActualName = "Iterations";
+      iterationsComparator.RightSideParameter.ActualName = "MaximumIterations";
+      iterationsComparator.ResultParameter.ActualName = "IterationsCondition";
+      iterationsComparator.Comparison.Value = ComparisonType.GreaterOrEqual;
+
+      iterationsTermination.Name = "Iterations termination condition";
+      iterationsTermination.ConditionParameter.ActualName = "IterationsCondition";
+
+      finished.Name = "Finished";
       #endregion
 
       #region Create operator graph
+      OperatorGraph.InitialOperator = variableCreator;
+      variableCreator.Successor = initializeBestQuality;
+      initializeBestQuality.Successor = sssp;
+      sssp.Operators.Add(resultsCollector);
+      sssp.Successor = bestQualityMemorizer;
+      bestQualityMemorizer.Successor = annealingOperator;
+      annealingOperator.Successor = mainProcessor;
+      mainProcessor.Operator = moveGenerator;
+      mainProcessor.Successor = valuesCollector;
+      moveGenerator.Successor = moveEvaluationProcessor;
+      moveEvaluationProcessor.Operators.Add(moveEvaluator);
+      moveEvaluationProcessor.Successor = subScopesRemover;
+      moveEvaluator.Successor = qualityComparator;
+      qualityComparator.Successor = improvesQualityBranch;
+      improvesQualityBranch.TrueBranch = moveMaker;
+      valuesCollector.Successor = iterationsCounter;
+      iterationsCounter.Successor = iterationsComparator;
+      iterationsComparator.Successor = iterationsTermination;
+      iterationsTermination.TrueBranch = finished;
+      iterationsTermination.FalseBranch = bestQualityMemorizer;
       #endregion
     }

trunk/sources/HeuristicLab.Optimization.Operators/3.3/ExponentialDiscreteDoubleValueModifier.cs

@@ -31 +31 @@
   [StorableClass]
   public class ExponentialDiscreteDoubleValueModifier : DiscreteDoubleValueModifier {
+    /// <summary>
+    /// Calculates a new value based on exponential decay or growth.
+    /// </summary>
+    /// <exception cref="ArgumentException">Thrown when endValue or startValue or both are 0.</exception>
+    /// <param name="value">The last value.</param>
+    /// <param name="startValue">The start value.</param>
+    /// <param name="endValue">The end value.</param>
+    /// <param name="index">The current index.</param>
+    /// <param name="startIndex">The start index.</param>
+    /// <param name="endIndex">The end index.</param>
+    /// <returns>The new value.</returns>
     protected override double Modify(double value, double startValue, double endValue, int index, int startIndex, int endIndex) {
+      if (endValue <= 0 || startValue <= 0) throw new ArgumentException("ExponentialDiscreteDoubleValueModifier: startValue and endValue must be greater than 0.");
       double b = Math.Pow(endValue / startValue, 1.0 / (endIndex - startIndex));
       return startValue * Math.Pow(b, index - startIndex);

trunk/sources/HeuristicLab.Optimization.Operators/3.3/HeuristicLab.Optimization.Operators-3.3.csproj

@@ -81 +81 @@
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="ProbabilisticQualityComparator.cs" />
     <Compile Include="SquareRootDiscreteDoubleValueModifier.cs" />
     <Compile Include="DiscreteDoubleValueModifier.cs" />

trunk/sources/HeuristicLab.Optimization.Operators/3.3/QualityComparator.cs

@@ -56 +56 @@
       DoubleValue right = RightSideParameter.ActualValue;
       BoolValue maximization = MaximizationParameter.ActualValue;
-      bool better = maximization.Value && left.Value > right.Value
-        || !maximization.Value && left.Value < right.Value;
+      bool better = Compare(maximization.Value, left.Value, right.Value);
       if (ResultParameter.ActualValue == null)
         ResultParameter.ActualValue = new BoolValue(better);
@@ -63 +62 @@
       return base.Apply();
     }
+
+    protected virtual bool Compare(bool maximization, double left, double right) {
+      return maximization && left > right || !maximization && left < right;
+    }
   }
 }