Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
12/04/16 16:18:45 (7 years ago)
Author:
jschiess
Message:

#1836 SA reheating strategies: First version of continuous reheater and fixed reheater, both reheat based on acceptance of solutions.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/SimulatedAnnealingMainLoop.cs

    r14406 r14452  
    11#region License Information
    22/* HeuristicLab
    3  * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
     3 * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
    44 *
    55 * This file is part of HeuristicLab.
    … …  
    2828using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
    2929
    30 namespace HeuristicLab.Algorithms.SimulatedAnnealing {
    31   /// <summary>
    32   /// An operator which represents a simulated annealing.
    33   /// </summary>
    34   [Item("SimulatedAnnealingMainLoop", "An operator which represents the main loop of a simulated annealing algorithm.")]
    35   [StorableClass]
    36   public sealed class SimulatedAnnealingMainLoop : AlgorithmOperator {
    37     #region Parameter properties
    38     public ValueLookupParameter<IRandom> RandomParameter {
    39       get { return (ValueLookupParameter<IRandom>)Parameters["Random"]; }
     30namespace HeuristicLab.Algorithms.SimulatedAnnealing
     31{
     32    [Item("SimulatedAnnealingMainLoop", "An operator which represents the main loop of a simulated annealing algorithm.")]
     33    [StorableClass]
     34    public sealed class SimulatedAnnealingMainLoop : AlgorithmOperator
     35    {
     36        #region Strings
     37        private const string MoveGeneratorName = "MoveGenerator";
     38        private const string MoveEvaluatorName = "MoveEvaluator";
     39        private const string MoveMakerName = "MoveMaker";
     40        private const string AnnealingOperatorName = "AnnealingOperator";
     41        private const string HeatingStrategyOperatorName = "HeatingStrategyOperator";
     42        private const string MaximumIterationsName = "MaximumIterations";
     43        private const string LowerTemperatureName = "LowerTemperature";
     44        private const string AnalyzerName = "Analyzer";
     45        private const string RandomName = "Random";
     46        private const string EvaluatedMovesName = "EvaluatedMoves";
     47        private const string IterationsName = "Iterations";
     48        private const string TemperatureStartIndexName = "TemperatureStartIndex";
     49        private const string CoolingName = "Cooling";
     50        private const string StartTemperatureName = "StartTemperature";
     51        private const string EndTemperatureName = "EndTemperature";
     52        private const string TemperatureName = "Temperature";
     53        private const string ResultsName = "Results";
     54        private const string MaximizationName = "Maximization";
     55        private const string QualityName = "Quality";
     56        private const string BestKnownQualityName = "BestKnownQuality";
     57        private const string MoveQualityName = "MoveQuality";
     58        private const string IsAcceptedName = "IsAccepted";
     59        private const string TerminateName = "Terminate";
     60        private const string AcceptanceMemoryName = "AcceptanceMemory";
     61        #endregion
     62
     63        #region Parameter properties
     64        public IValueLookupParameter<IRandom> RandomParameter
     65        {
     66            get { return (IValueLookupParameter<IRandom>)Parameters[RandomName]; }
     67        }
     68        public IValueLookupParameter<BoolValue> MaximizationParameter
     69        {
     70            get { return (IValueLookupParameter<BoolValue>)Parameters[MaximizationName]; }
     71        }
     72        public ILookupParameter<DoubleValue> QualityParameter
     73        {
     74            get { return (ILookupParameter<DoubleValue>)Parameters[QualityName]; }
     75        }
     76        public IValueLookupParameter<DoubleValue> BestKnownQualityParameter
     77        {
     78            get { return (IValueLookupParameter<DoubleValue>)Parameters[BestKnownQualityName]; }
     79        }
     80        public ILookupParameter<DoubleValue> MoveQualityParameter
     81        {
     82            get { return (ILookupParameter<DoubleValue>)Parameters[MoveQualityName]; }
     83        }
     84        public ILookupParameter<DoubleValue> TemperatureParameter
     85        {
     86            get { return (ILookupParameter<DoubleValue>)Parameters[TemperatureName]; }
     87        }
     88        public IValueLookupParameter<DoubleValue> LowerTemperatureParameter
     89        {
     90            get { return (IValueLookupParameter<DoubleValue>)Parameters[LowerTemperatureName]; }
     91        }
     92        public ILookupParameter<IntValue> IterationsParameter
     93        {
     94            get { return (ILookupParameter<IntValue>)Parameters[IterationsName]; }
     95        }
     96        public IValueLookupParameter<IntValue> MaximumIterationsParameter
     97        {
     98            get { return (IValueLookupParameter<IntValue>)Parameters[MaximumIterationsName]; }
     99        }
     100        public IValueLookupParameter<IOperator> MoveGeneratorParameter
     101        {
     102            get { return (IValueLookupParameter<IOperator>)Parameters[MoveGeneratorName]; }
     103        }
     104        public IValueLookupParameter<IOperator> MoveEvaluatorParameter
     105        {
     106            get { return (IValueLookupParameter<IOperator>)Parameters[MoveEvaluatorName]; }
     107        }
     108        public IValueLookupParameter<IOperator> MoveMakerParameter
     109        {
     110            get { return (IValueLookupParameter<IOperator>)Parameters[MoveMakerName]; }
     111        }
     112        public IValueLookupParameter<IOperator> AnnealingOperatorParameter
     113        {
     114            get { return (IValueLookupParameter<IOperator>)Parameters[AnnealingOperatorName]; }
     115        }
     116        public IValueLookupParameter<IOperator> HeatingStrategyOperatorParameter
     117        {
     118            get { return (IValueLookupParameter<IOperator>)Parameters[HeatingStrategyOperatorName]; }
     119        }
     120        public IValueLookupParameter<IOperator> AnalyzerParameter
     121        {
     122            get { return (IValueLookupParameter<IOperator>)Parameters[AnalyzerName]; }
     123        }
     124        public IValueLookupParameter<VariableCollection> ResultsParameter
     125        {
     126            get { return (IValueLookupParameter<VariableCollection>)Parameters[ResultsName]; }
     127        }
     128        public ILookupParameter<IntValue> EvaluatedMovesParameter
     129        {
     130            get { return (ILookupParameter<IntValue>)Parameters[EvaluatedMovesName]; }
     131        }
     132        public ILookupParameter<DoubleValue> StartTemperatureParameter
     133        {
     134            get { return (ILookupParameter<DoubleValue>)Parameters[StartTemperatureName]; }
     135        }
     136        public ILookupParameter<DoubleValue> EndTemperatureParameter
     137        {
     138            get { return (ILookupParameter<DoubleValue>)Parameters[EndTemperatureName]; }
     139        }
     140        public ILookupParameter<IntValue> TemperatureStartIndexParameter
     141        {
     142            get { return (ILookupParameter<IntValue>)Parameters[TemperatureStartIndexName]; }
     143        }
     144        public ILookupParameter<BoolValue> CoolingParameter
     145        {
     146            get { return (ILookupParameter<BoolValue>)Parameters[CoolingName]; }
     147        }
     148        #endregion
     149
     150        [StorableConstructor]
     151        private SimulatedAnnealingMainLoop(bool deserializing) : base(deserializing) { }
     152        private SimulatedAnnealingMainLoop(SimulatedAnnealingMainLoop original, Cloner cloner)
     153          : base(original, cloner)
     154        {
     155        }
     156        public override IDeepCloneable Clone(Cloner cloner)
     157        {
     158            return new SimulatedAnnealingMainLoop(this, cloner);
     159        }
     160        public SimulatedAnnealingMainLoop()
     161          : base()
     162        {
     163            Initialize();
     164        }
     165
     166        private void Initialize()
     167        {
     168            #region Create parameters
     169            Parameters.Add(new ValueLookupParameter<IRandom>(RandomName, "A pseudo random number generator."));
     170            Parameters.Add(new ValueLookupParameter<BoolValue>(MaximizationName, "True if the problem is a maximization problem, otherwise false."));
     171            Parameters.Add(new LookupParameter<DoubleValue>(QualityName, "The value which represents the quality of a solution."));
     172            Parameters.Add(new ValueLookupParameter<DoubleValue>(BestKnownQualityName, "The best known quality value found so far."));
     173            Parameters.Add(new LookupParameter<DoubleValue>(MoveQualityName, "The value which represents the quality of a move."));
     174            Parameters.Add(new LookupParameter<DoubleValue>(TemperatureName, "The current temperature."));
     175            Parameters.Add(new ValueLookupParameter<DoubleValue>(LowerTemperatureName, "The lower bound of the temperature."));
     176            Parameters.Add(new LookupParameter<IntValue>(IterationsName, "The number of iterations."));
     177            Parameters.Add(new ValueLookupParameter<IntValue>(MaximumIterationsName, "The maximum number of iterations which should be processed."));
     178
     179            Parameters.Add(new ValueLookupParameter<IOperator>(MoveGeneratorName, "The operator that generates the moves."));
     180            Parameters.Add(new ValueLookupParameter<IOperator>(MoveEvaluatorName, "The operator that evaluates a move."));
     181            Parameters.Add(new ValueLookupParameter<IOperator>(MoveMakerName, "The operator that performs a move and updates the quality."));
     182            Parameters.Add(new ValueLookupParameter<IOperator>(AnnealingOperatorName, "The operator that cools the temperature."));
     183            Parameters.Add(new ValueLookupParameter<IOperator>(HeatingStrategyOperatorName, "The operator that heats the temperature."));
     184
     185            Parameters.Add(new ValueLookupParameter<IOperator>(AnalyzerName, "The operator used to analyze each generation."));
     186            Parameters.Add(new ValueLookupParameter<VariableCollection>(ResultsName, "The variable collection where results should be stored."));
     187            Parameters.Add(new LookupParameter<IntValue>(EvaluatedMovesName, "The number of evaluated moves."));
     188
     189            Parameters.Add(new LookupParameter<IntValue>(TemperatureStartIndexName, "The index where the annealing or heating was last changed."));
     190            Parameters.Add(new LookupParameter<BoolValue>(CoolingName, "True when the temperature should be cooled, false otherwise."));
     191            Parameters.Add(new LookupParameter<DoubleValue>(StartTemperatureName, "The temperature from which cooling or reheating should occur."));
     192            Parameters.Add(new LookupParameter<DoubleValue>(EndTemperatureName, "The temperature to which should be cooled or heated."));
     193            #endregion
     194
     195            #region Create operators
     196            var variableCreator = new VariableCreator();
     197            var ssp1 = new SubScopesProcessor();
     198            var analyzer1 = new Placeholder();
     199            var ssp2 = new SubScopesProcessor();
     200            var resultsCollector = new ResultsCollector();
     201            var mainProcessor = new SubScopesProcessor();
     202            var moveGenerator = new Placeholder();
     203            var moveEvaluationProcessor = new SubScopesProcessor();
     204            var moveEvaluator = new Placeholder();
     205            var evaluatedMovesCounter = new IntCounter();
     206            var qualityComparator = new ProbabilisticQualityComparator();
     207            var acceptsQualityBranch = new ConditionalBranch();
     208            var moveMaker = new Placeholder();
     209            var temperatureController = new TemperatureController();
     210            var subScopesRemover = new SubScopesRemover();
     211            var iterationsCounter = new IntCounter();
     212            var iterationsComparator = new Comparator();
     213            var ssp3 = new SubScopesProcessor();
     214            var analyzer2 = new Placeholder();
     215            var iterationsTermination = new ConditionalBranch();
     216
     217            variableCreator.Name = "Initialize Memory";
     218            variableCreator.CollectedValues.Add(new ValueParameter<ItemList<BoolValue>>(AcceptanceMemoryName, new ItemList<BoolValue>()));
     219
     220            analyzer1.Name = "Analyzer";
     221            analyzer1.OperatorParameter.ActualName = AnalyzerParameter.Name;
     222
     223            moveGenerator.Name = "Move generator";
     224            moveGenerator.OperatorParameter.ActualName = MoveGeneratorParameter.Name;
     225
     226            moveEvaluator.Name = "Move evaluator";
     227            moveEvaluator.OperatorParameter.ActualName = MoveEvaluatorParameter.Name;
     228
     229            evaluatedMovesCounter.Name = "EvaluatedMoves++";
     230            evaluatedMovesCounter.ValueParameter.ActualName = EvaluatedMovesParameter.Name;
     231            evaluatedMovesCounter.Increment = new IntValue(1);
     232
     233            qualityComparator.LeftSideParameter.ActualName = MoveQualityParameter.Name;
     234            qualityComparator.RightSideParameter.ActualName = QualityParameter.Name;
     235            qualityComparator.ResultParameter.ActualName = IsAcceptedName;
     236            qualityComparator.DampeningParameter.ActualName = TemperatureParameter.Name;
     237
     238            acceptsQualityBranch.ConditionParameter.ActualName = IsAcceptedName;
     239
     240            moveMaker.Name = "Move maker";
     241            moveMaker.OperatorParameter.ActualName = MoveMakerParameter.Name;
     242
     243            temperatureController.AnnealingOperatorParameter.ActualName = AnnealingOperatorParameter.Name;
     244            temperatureController.AcceptanceMemoryParameter.ActualName = AcceptanceMemoryName;
     245            temperatureController.CoolingParameter.ActualName = CoolingParameter.Name;
     246            temperatureController.EndTemperatureParameter.ActualName = EndTemperatureParameter.Name;
     247            temperatureController.HeatingStrategyOperatorParameter.ActualName = HeatingStrategyOperatorParameter.Name;
     248            temperatureController.IsAcceptedParameter.ActualName = IsAcceptedName;
     249            temperatureController.IterationsParameter.ActualName = IterationsParameter.Name;
     250            temperatureController.LowerTemperatureParameter.ActualName = LowerTemperatureParameter.Name;
     251            temperatureController.MaximumIterationsParameter.ActualName = MaximumIterationsParameter.Name;
     252            temperatureController.StartTemperatureParameter.ActualName = StartTemperatureParameter.Name;
     253            temperatureController.TemperatureParameter.ActualName = TemperatureParameter.Name;
     254            temperatureController.TemperatureStartIndexParameter.ActualName = TemperatureStartIndexParameter.Name;
     255
     256            subScopesRemover.RemoveAllSubScopes = true;
     257
     258            iterationsCounter.Name = "Iterations++";
     259            iterationsCounter.Increment = new IntValue(1);
     260            iterationsCounter.ValueParameter.ActualName = IterationsParameter.Name;
     261
     262            iterationsComparator.Name = "Iterations >= MaximumIterations";
     263            iterationsComparator.LeftSideParameter.ActualName = IterationsParameter.Name;
     264            iterationsComparator.RightSideParameter.ActualName = MaximumIterationsParameter.Name;
     265            iterationsComparator.ResultParameter.ActualName = TerminateName;
     266            iterationsComparator.Comparison.Value = ComparisonType.GreaterOrEqual;
     267
     268            analyzer2.Name = "Analyzer (placeholder)";
     269            analyzer2.OperatorParameter.ActualName = AnalyzerParameter.Name;
     270
     271            iterationsTermination.Name = "Iterations termination condition";
     272            iterationsTermination.ConditionParameter.ActualName = TerminateName;
     273            #endregion
     274
     275            #region Create operator graph
     276            OperatorGraph.InitialOperator = variableCreator;
     277            variableCreator.Successor = ssp1;
     278            ssp1.Operators.Add(analyzer1);
     279            ssp1.Successor = ssp2;
     280            analyzer1.Successor = null;
     281            ssp2.Operators.Add(resultsCollector);
     282            ssp2.Successor = mainProcessor;
     283            resultsCollector.Successor = null;
     284            mainProcessor.Operators.Add(moveGenerator);
     285            mainProcessor.Successor = iterationsCounter;
     286            moveGenerator.Successor = moveEvaluationProcessor;
     287            moveEvaluationProcessor.Operators.Add(moveEvaluator);
     288            moveEvaluationProcessor.Successor = evaluatedMovesCounter;
     289            moveEvaluator.Successor = qualityComparator;
     290            qualityComparator.Successor = acceptsQualityBranch;
     291            acceptsQualityBranch.TrueBranch = moveMaker;
     292            acceptsQualityBranch.FalseBranch = null;
     293            acceptsQualityBranch.Successor = temperatureController;
     294            moveMaker.Successor = null;
     295            temperatureController.Successor = null;
     296            evaluatedMovesCounter.Successor = subScopesRemover;
     297            subScopesRemover.Successor = null;
     298            iterationsCounter.Successor = iterationsComparator;
     299            iterationsComparator.Successor = ssp3;
     300            ssp3.Operators.Add(analyzer2);
     301            ssp3.Successor = iterationsTermination;
     302            iterationsTermination.TrueBranch = null;
     303            iterationsTermination.FalseBranch = mainProcessor;
     304            #endregion
     305        }
     306
     307        public override IOperation Apply()
     308        {
     309            if (MoveGeneratorParameter.ActualValue == null || MoveEvaluatorParameter.ActualValue == null || MoveMakerParameter.ActualValue == null)
     310                return null;
     311            return base.Apply();
     312        }
    40313    }
    41     public ValueLookupParameter<BoolValue> MaximizationParameter {
    42       get { return (ValueLookupParameter<BoolValue>)Parameters["Maximization"]; }
    43     }
    44     public LookupParameter<DoubleValue> QualityParameter {
    45       get { return (LookupParameter<DoubleValue>)Parameters["Quality"]; }
    46     }
    47     public ValueLookupParameter<DoubleValue> BestKnownQualityParameter {
    48       get { return (ValueLookupParameter<DoubleValue>)Parameters["BestKnownQuality"]; }
    49     }
    50     public LookupParameter<DoubleValue> MoveQualityParameter {
    51       get { return (LookupParameter<DoubleValue>)Parameters["MoveQuality"]; }
    52     }
    53     public ILookupParameter<DoubleValue> TemperatureParameter {
    54       get { return (ILookupParameter<DoubleValue>)Parameters["Temperature"]; }
    55     }
    56     public ValueLookupParameter<DoubleValue> StartTemperatureParameter {
    57       get { return (ValueLookupParameter<DoubleValue>)Parameters["StartTemperature"]; }
    58     }
    59     public ValueLookupParameter<DoubleValue> EndTemperatureParameter {
    60       get { return (ValueLookupParameter<DoubleValue>)Parameters["EndTemperature"]; }
    61     }
    62     public ValueLookupParameter<IntValue> InnerIterationsParameter {
    63       get { return (ValueLookupParameter<IntValue>)Parameters["InnerIterations"]; }
    64     }
    65     public LookupParameter<IntValue> IterationsParameter {
    66       get { return (LookupParameter<IntValue>)Parameters["Iterations"]; }
    67     }
    68     public ValueLookupParameter<IntValue> MaximumIterationsParameter {
    69       get { return (ValueLookupParameter<IntValue>)Parameters["MaximumIterations"]; }
    70     }
    71     public ValueLookupParameter<IOperator> MoveGeneratorParameter {
    72       get { return (ValueLookupParameter<IOperator>)Parameters["MoveGenerator"]; }
    73     }
    74     public ValueLookupParameter<IOperator> MoveEvaluatorParameter {
    75       get { return (ValueLookupParameter<IOperator>)Parameters["MoveEvaluator"]; }
    76     }
    77     public ValueLookupParameter<IOperator> MoveMakerParameter {
    78       get { return (ValueLookupParameter<IOperator>)Parameters["MoveMaker"]; }
    79     }
    80     public ValueLookupParameter<IOperator> AnnealingOperatorParameter {
    81       get { return (ValueLookupParameter<IOperator>)Parameters["AnnealingOperator"]; }
    82     }
    83     public ValueLookupParameter<IOperator> AnalyzerParameter {
    84       get { return (ValueLookupParameter<IOperator>)Parameters["Analyzer"]; }
    85     }
    86     public ValueLookupParameter<VariableCollection> ResultsParameter {
    87       get { return (ValueLookupParameter<VariableCollection>)Parameters["Results"]; }
    88     }
    89     public LookupParameter<IntValue> EvaluatedMovesParameter {
    90       get { return (LookupParameter<IntValue>)Parameters["EvaluatedMoves"]; }
    91     }
    92     #endregion
    93 
    94     [StorableConstructor]
    95     private SimulatedAnnealingMainLoop(bool deserializing) : base(deserializing) { }
    96     private SimulatedAnnealingMainLoop(SimulatedAnnealingMainLoop original, Cloner cloner)
    97       : base(original, cloner) {
    98     }
    99     public override IDeepCloneable Clone(Cloner cloner) {
    100       return new SimulatedAnnealingMainLoop(this, cloner);
    101     }
    102     public SimulatedAnnealingMainLoop()
    103       : base() {
    104       Initialize();
    105     }
    106 
    107     private void Initialize() {
    108       #region Create parameters
    109       Parameters.Add(new ValueLookupParameter<IRandom>("Random", "A pseudo random number generator."));
    110       Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "True if the problem is a maximization problem, otherwise false."));
    111       Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The value which represents the quality of a solution."));
    112       Parameters.Add(new ValueLookupParameter<DoubleValue>("BestKnownQuality", "The best known quality value found so far."));
    113       Parameters.Add(new LookupParameter<DoubleValue>("MoveQuality", "The value which represents the quality of a move."));
    114       Parameters.Add(new LookupParameter<DoubleValue>("Temperature", "The current temperature."));
    115       Parameters.Add(new ValueLookupParameter<DoubleValue>("StartTemperature", "The initial temperature."));
    116       Parameters.Add(new ValueLookupParameter<DoubleValue>("EndTemperature", "The end temperature."));
    117       Parameters.Add(new ValueLookupParameter<IntValue>("InnerIterations", "The amount of inner iterations (number of moves before temperature is adjusted again)."));
    118       Parameters.Add(new LookupParameter<IntValue>("Iterations", "The number of iterations."));
    119       Parameters.Add(new ValueLookupParameter<IntValue>("MaximumIterations", "The maximum number of iterations which should be processed."));
    120 
    121       Parameters.Add(new ValueLookupParameter<IOperator>("MoveGenerator", "The operator that generates the moves."));
    122       Parameters.Add(new ValueLookupParameter<IOperator>("MoveEvaluator", "The operator that evaluates a move."));
    123       Parameters.Add(new ValueLookupParameter<IOperator>("MoveMaker", "The operator that performs a move and updates the quality."));
    124       Parameters.Add(new ValueLookupParameter<IOperator>("AnnealingOperator", "The operator that modifies the temperature."));
    125 
    126       Parameters.Add(new ValueLookupParameter<IOperator>("Analyzer", "The operator used to analyze each generation."));
    127       Parameters.Add(new ValueLookupParameter<VariableCollection>("Results", "The variable collection where results should be stored."));
    128       Parameters.Add(new LookupParameter<IntValue>("EvaluatedMoves", "The number of evaluated moves."));
    129       #endregion
    130 
    131       #region Create operators
    132       Assigner temperatureInitializer = new Assigner();
    133       ResultsCollector resultsCollector1 = new ResultsCollector();
    134       SubScopesProcessor subScopesProcessor0 = new SubScopesProcessor();
    135       Placeholder analyzer1 = new Placeholder();
    136       SubScopesProcessor sssp = new SubScopesProcessor();
    137       ResultsCollector resultsCollector = new ResultsCollector();
    138       Placeholder annealingOperator = new Placeholder();
    139       UniformSubScopesProcessor mainProcessor = new UniformSubScopesProcessor();
    140       Placeholder moveGenerator = new Placeholder();
    141       UniformSubScopesProcessor moveEvaluationProcessor = new UniformSubScopesProcessor();
    142       Placeholder moveEvaluator = new Placeholder();
    143       SubScopesCounter subScopesCounter = new SubScopesCounter();
    144       ProbabilisticQualityComparator qualityComparator = new ProbabilisticQualityComparator();
    145       ConditionalBranch improvesQualityBranch = new ConditionalBranch();
    146       Placeholder moveMaker = new Placeholder();
    147       SubScopesRemover subScopesRemover = new SubScopesRemover();
    148       IntCounter iterationsCounter = new IntCounter();
    149       Comparator iterationsComparator = new Comparator();
    150       SubScopesProcessor subScopesProcessor1 = new SubScopesProcessor();
    151       Placeholder analyzer2 = new Placeholder();
    152       ConditionalBranch iterationsTermination = new ConditionalBranch();
    153 
    154       temperatureInitializer.LeftSideParameter.ActualName = TemperatureParameter.ActualName;
    155       temperatureInitializer.RightSideParameter.ActualName = StartTemperatureParameter.Name;
    156 
    157       resultsCollector1.CollectedValues.Add(new LookupParameter<IntValue>(IterationsParameter.Name));
    158       resultsCollector1.ResultsParameter.ActualName = ResultsParameter.Name;
    159 
    160       analyzer1.Name = "Analyzer (placeholder)";
    161       analyzer1.OperatorParameter.ActualName = AnalyzerParameter.Name;
    162 
    163       annealingOperator.Name = "Annealing operator (placeholder)";
    164       annealingOperator.OperatorParameter.ActualName = AnnealingOperatorParameter.Name;
    165 
    166       moveGenerator.Name = "Move generator (placeholder)";
    167       moveGenerator.OperatorParameter.ActualName = MoveGeneratorParameter.Name;
    168 
    169       moveEvaluator.Name = "Move evaluator (placeholder)";
    170       moveEvaluator.OperatorParameter.ActualName = MoveEvaluatorParameter.Name;
    171 
    172       subScopesCounter.Name = "Increment EvaluatedMoves";
    173       subScopesCounter.ValueParameter.ActualName = EvaluatedMovesParameter.Name;
    174 
    175       qualityComparator.LeftSideParameter.ActualName = MoveQualityParameter.Name;
    176       qualityComparator.RightSideParameter.ActualName = QualityParameter.Name;
    177       qualityComparator.ResultParameter.ActualName = "IsBetter";
    178       qualityComparator.DampeningParameter.ActualName = "Temperature";
    179 
    180       improvesQualityBranch.ConditionParameter.ActualName = "IsBetter";
    181 
    182       moveMaker.Name = "Move maker (placeholder)";
    183       moveMaker.OperatorParameter.ActualName = MoveMakerParameter.Name;
    184 
    185       subScopesRemover.RemoveAllSubScopes = true;
    186 
    187       iterationsCounter.Name = "Increment Iterations";
    188       iterationsCounter.Increment = new IntValue(1);
    189       iterationsCounter.ValueParameter.ActualName = IterationsParameter.Name;
    190 
    191       iterationsComparator.Name = "Iterations >= MaximumIterations";
    192       iterationsComparator.LeftSideParameter.ActualName = IterationsParameter.Name;
    193       iterationsComparator.RightSideParameter.ActualName = MaximumIterationsParameter.Name;
    194       iterationsComparator.ResultParameter.ActualName = "Terminate";
    195       iterationsComparator.Comparison.Value = ComparisonType.GreaterOrEqual;
    196 
    197       analyzer2.Name = "Analyzer (placeholder)";
    198       analyzer2.OperatorParameter.ActualName = AnalyzerParameter.Name;
    199 
    200       iterationsTermination.Name = "Iterations termination condition";
    201       iterationsTermination.ConditionParameter.ActualName = "Terminate";
    202       #endregion
    203 
    204       #region Create operator graph
    205       OperatorGraph.InitialOperator = temperatureInitializer;
    206       temperatureInitializer.Successor = resultsCollector1;
    207       resultsCollector1.Successor = subScopesProcessor0;
    208       subScopesProcessor0.Operators.Add(analyzer1);
    209       subScopesProcessor0.Successor = sssp;
    210       analyzer1.Successor = null;
    211       sssp.Operators.Add(resultsCollector);
    212       sssp.Successor = annealingOperator;
    213       resultsCollector.Successor = null;
    214       annealingOperator.Successor = mainProcessor;
    215       mainProcessor.Operator = moveGenerator;
    216       mainProcessor.Successor = iterationsCounter;
    217       moveGenerator.Successor = moveEvaluationProcessor;
    218       moveEvaluationProcessor.Operator = moveEvaluator;
    219       moveEvaluationProcessor.Successor = subScopesCounter;
    220       moveEvaluator.Successor = qualityComparator;
    221       qualityComparator.Successor = improvesQualityBranch;
    222       improvesQualityBranch.TrueBranch = moveMaker;
    223       improvesQualityBranch.FalseBranch = null;
    224       improvesQualityBranch.Successor = null;
    225       moveMaker.Successor = null;
    226       subScopesCounter.Successor = subScopesRemover;
    227       subScopesRemover.Successor = null;
    228       iterationsCounter.Successor = iterationsComparator;
    229       iterationsComparator.Successor = subScopesProcessor1;
    230       subScopesProcessor1.Operators.Add(analyzer2);
    231       subScopesProcessor1.Successor = iterationsTermination;
    232       iterationsTermination.TrueBranch = null;
    233       iterationsTermination.FalseBranch = annealingOperator;
    234       #endregion
    235     }
    236 
    237     [StorableHook(HookType.AfterDeserialization)]
    238     private void AfterDeserialization() {
    239       // BackwardsCompatibility3.3
    240       #region Backwards compatible code (remove with 3.4)
    241       if (!Parameters.ContainsKey("Iterations"))
    242         Parameters.Add(new LookupParameter<IntValue>("Iterations", "The number of iterations."));
    243       if (!Parameters.ContainsKey("Temperature"))
    244         Parameters.Add(new LookupParameter<DoubleValue>("Temperature", "The current temperature."));
    245       #endregion
    246     }
    247 
    248     public override IOperation Apply() {
    249       if (MoveGeneratorParameter.ActualValue == null || MoveEvaluatorParameter.ActualValue == null || MoveMakerParameter.ActualValue == null)
    250         return null;
    251       return base.Apply();
    252     }
    253   }
    254314}
Note: See TracChangeset for help on using the changeset viewer.