Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
04/23/11 10:00:31 (14 years ago)
Author:
abeham
Message:

#1465

  • updated branch with trunk changes
Location:
branches/histogram
Files:
2 deleted
5 edited

Legend:

Unmodified
Added
Removed

  • branches/histogram

  • branches/histogram/HeuristicLab.Algorithms.VariableNeighborhoodSearch/3.3/HeuristicLab.Algorithms.VariableNeighborhoodSearch-3.3.csproj

    r5753 r6046  
    108108  <ItemGroup>
    109109    <Compile Include="HeuristicLabAlgorithmsVariableNeighborhoodSearchPlugin.cs" />
    110     <Compile Include="IShakingOperator.cs" />
    111110    <Compile Include="Properties\AssemblyInfo.cs" />
    112     <Compile Include="ShakingOperator.cs" />
    113111    <Compile Include="VariableNeighborhoodSearch.cs" />
    114112    <Compile Include="VariableNeighborhoodSearchMainLoop.cs" />
    … …  
    120118  </ItemGroup>
    121119  <ItemGroup>
    122     <ProjectReference Include="..\..\HeuristicLab.Algorithms.LocalSearch\3.3\HeuristicLab.Algorithms.LocalSearch-3.3.csproj">
    123       <Project>{4AE3FC69-C575-42D2-BC46-0FAD5850EFC5}</Project>
    124       <Name>HeuristicLab.Algorithms.LocalSearch-3.3</Name>
    125     </ProjectReference>
    126120    <ProjectReference Include="..\..\HeuristicLab.Analysis\3.3\HeuristicLab.Analysis-3.3.csproj">
    127121      <Project>{887425B4-4348-49ED-A457-B7D2C26DDBF9}</Project>

  • branches/histogram/HeuristicLab.Algorithms.VariableNeighborhoodSearch/3.3/HeuristicLabAlgorithmsVariableNeighborhoodSearchPlugin.cs.frame

    r5830 r6046  
    2828  [Plugin("HeuristicLab.Algorithms.VariableNeighborhoodSearch", "3.3.3.$WCREV$")]
    2929  [PluginFile("HeuristicLab.Algorithms.VariableNeighborhoodSearch-3.3.dll", PluginFileType.Assembly)]
    30   [PluginDependency("HeuristicLab.Algorithms.LocalSearch", "3.3")]
    3130  [PluginDependency("HeuristicLab.Analysis", "3.3")] 
    3231  [PluginDependency("HeuristicLab.Collections", "3.3")]

  • branches/histogram/HeuristicLab.Algorithms.VariableNeighborhoodSearch/3.3/VariableNeighborhoodSearch.cs

    r5809 r6046  
    1 using System;
    2 using System.Collections.Generic;
     1#region License Information
     2/* HeuristicLab
     3 * Copyright (C) 2002-2011 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
     4 *
     5 * This file is part of HeuristicLab.
     6 *
     7 * HeuristicLab is free software: you can redistribute it and/or modify
     8 * it under the terms of the GNU General Public License as published by
     9 * the Free Software Foundation, either version 3 of the License, or
     10 * (at your option) any later version.
     11 *
     12 * HeuristicLab is distributed in the hope that it will be useful,
     13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
     14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     15 * GNU General Public License for more details.
     16 *
     17 * You should have received a copy of the GNU General Public License
     18 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
     19 */
     20#endregion
     21
     22using System;
    323using System.Linq;
    4 using HeuristicLab.Algorithms.LocalSearch;
    524using HeuristicLab.Analysis;
    625using HeuristicLab.Common;
    … …  
    1231using HeuristicLab.Parameters;
    1332using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
     33using HeuristicLab.PluginInfrastructure;
    1434using HeuristicLab.Random;
    1535
    … …  
    3252
    3353    #region Parameter Properties
    34     private ValueParameter<IntValue> SeedParameter {
    35       get { return (ValueParameter<IntValue>)Parameters["Seed"]; }
    36     }
    37     private ValueParameter<BoolValue> SetSeedRandomlyParameter {
    38       get { return (ValueParameter<BoolValue>)Parameters["SetSeedRandomly"]; }
    39     }
    40     private ValueParameter<ILocalImprovementOperator> LocalImprovementParameter {
    41       get { return (ValueParameter<ILocalImprovementOperator>)Parameters["LocalImprovement"]; }
    42     }
    43     private ValueParameter<IShakingOperator> ShakingParameter {
    44       get { return (ValueParameter<IShakingOperator>)Parameters["Shaking"]; }
    45     }
    46     private ValueParameter<IntValue> MaximumIterationsParameter {
    47       get { return (ValueParameter<IntValue>)Parameters["MaximumIterations"]; }
     54    private FixedValueParameter<IntValue> SeedParameter {
     55      get { return (FixedValueParameter<IntValue>)Parameters["Seed"]; }
     56    }
     57    private FixedValueParameter<BoolValue> SetSeedRandomlyParameter {
     58      get { return (FixedValueParameter<BoolValue>)Parameters["SetSeedRandomly"]; }
     59    }
     60    private ConstrainedValueParameter<ILocalImprovementOperator> LocalImprovementParameter {
     61      get { return (ConstrainedValueParameter<ILocalImprovementOperator>)Parameters["LocalImprovement"]; }
     62    }
     63    private ConstrainedValueParameter<IMultiNeighborhoodShakingOperator> ShakingOperatorParameter {
     64      get { return (ConstrainedValueParameter<IMultiNeighborhoodShakingOperator>)Parameters["ShakingOperator"]; }
     65    }
     66    private FixedValueParameter<IntValue> MaximumIterationsParameter {
     67      get { return (FixedValueParameter<IntValue>)Parameters["MaximumIterations"]; }
    4868    }
    4969    private ValueParameter<MultiAnalyzer> AnalyzerParameter {
    5070      get { return (ValueParameter<MultiAnalyzer>)Parameters["Analyzer"]; }
    5171    }
    52     private VariableNeighborhoodSearchMainLoop VNSMainLoop {
    53       get { return FindMainLoop(SolutionsCreator.Successor); }
     72    public FixedValueParameter<IntValue> LocalImprovementMaximumIterationsParameter {
     73      get { return (FixedValueParameter<IntValue>)Parameters["LocalImprovementMaximumIterations"]; }
    5474    }
    5575    #endregion
    … …  
    6686      get { return (SolutionsCreator)RandomCreator.Successor; }
    6787    }
     88    private VariableNeighborhoodSearchMainLoop MainLoop {
     89      get { return FindMainLoop(SolutionsCreator.Successor); }
     90    }
    6891    #endregion
    6992
    … …  
    7396    [StorableConstructor]
    7497    private VariableNeighborhoodSearch(bool deserializing) : base(deserializing) { }
    75     [StorableHook(HookType.AfterDeserialization)]
    76     private void AfterDeserialization() {
    77 
    78     }
    7998    private VariableNeighborhoodSearch(VariableNeighborhoodSearch original, Cloner cloner)
    8099      : base(original, cloner) {
    81100      qualityAnalyzer = cloner.Clone(original.qualityAnalyzer);
    82       Initialize();
    83     }
    84     public override IDeepCloneable Clone(Cloner cloner) {
    85       return new VariableNeighborhoodSearch(this, cloner);
     101      RegisterEventHandlers();
    86102    }
    87103    public VariableNeighborhoodSearch()
    88104      : base() {
    89       Parameters.Add(new ValueParameter<IntValue>("Seed", "The random seed used to initialize the new pseudo random number generator.", new IntValue(0)));
    90       Parameters.Add(new ValueParameter<BoolValue>("SetSeedRandomly", "True if the random seed should be set to a random value, otherwise false.", new BoolValue(true)));
    91       Parameters.Add(new ValueParameter<ILocalImprovementOperator>("LocalImprovement", "The local improvement operation", new LocalSearchImprovementOperator()));
    92       Parameters.Add(new ValueParameter<IShakingOperator>("Shaking", "The shaking operation"));
    93       Parameters.Add(new ValueParameter<IntValue>("MaximumIterations", "The maximum number of generations which should be processed.", new IntValue(1000)));
     105      Parameters.Add(new FixedValueParameter<IntValue>("Seed", "The random seed used to initialize the new pseudo random number generator.", new IntValue(0)));
     106      Parameters.Add(new FixedValueParameter<BoolValue>("SetSeedRandomly", "True if the random seed should be set to a random value, otherwise false.", new BoolValue(true)));
     107      Parameters.Add(new ConstrainedValueParameter<ILocalImprovementOperator>("LocalImprovement", "The local improvement operation"));
     108      Parameters.Add(new ConstrainedValueParameter<IMultiNeighborhoodShakingOperator>("ShakingOperator", "The operator that performs the shaking of solutions."));
     109      Parameters.Add(new FixedValueParameter<IntValue>("MaximumIterations", "The maximum number of iterations which should be processed.", new IntValue(50)));
     110      Parameters.Add(new FixedValueParameter<IntValue>("LocalImprovementMaximumIterations", "The maximum number of iterations which should be performed in the local improvement phase.", new IntValue(50)));
    94111      Parameters.Add(new ValueParameter<MultiAnalyzer>("Analyzer", "The operator used to analyze the solution and moves.", new MultiAnalyzer()));
    95112
    … …  
    112129
    113130      variableCreator.Name = "Initialize Evaluated Solutions";
    114       variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("EvaluatedSolutions", new IntValue()));
     131
     132      variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("Iterations", new IntValue(0)));
     133      variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("EvaluatedSolutions", new IntValue(0)));
     134      variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("CurrentNeighborhoodIndex", new IntValue(0)));
     135      variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("NeighborhoodCount", new IntValue(0)));
    115136      variableCreator.Successor = resultsCollector;
    116137
    117138      resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("Evaluated Solutions", null, "EvaluatedSolutions"));
     139      resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("Iterations"));
    118140      resultsCollector.ResultsParameter.ActualName = "Results";
    119141      resultsCollector.Successor = mainLoop;
    120142
     143      mainLoop.IterationsParameter.ActualName = "Iterations";
     144      mainLoop.CurrentNeighborhoodIndexParameter.ActualName = "CurrentNeighborhoodIndex";
     145      mainLoop.NeighborhoodCountParameter.ActualName = "NeighborhoodCount";
    121146      mainLoop.LocalImprovementParameter.ActualName = LocalImprovementParameter.Name;
    122       mainLoop.ShakingParameter.ActualName = ShakingParameter.Name;
     147      mainLoop.ShakingOperatorParameter.ActualName = ShakingOperatorParameter.Name;
    123148      mainLoop.MaximumIterationsParameter.ActualName = MaximumIterationsParameter.Name;
    124149      mainLoop.RandomParameter.ActualName = RandomCreator.RandomParameter.ActualName;
    … …  
    127152      mainLoop.EvaluatedSolutionsParameter.ActualName = "EvaluatedSolutions";
    128153
     154      InitializeLocalImprovementOperators();
    129155      qualityAnalyzer = new BestAverageWorstQualityAnalyzer();
    130156      ParameterizeAnalyzers();
    131157      UpdateAnalyzers();
    132158
    133       Initialize();
     159      RegisterEventHandlers();
     160    }
     161
     162    public override IDeepCloneable Clone(Cloner cloner) {
     163      return new VariableNeighborhoodSearch(this, cloner);
     164    }
     165
     166    [StorableHook(HookType.AfterDeserialization)]
     167    private void AfterDeserialization() {
     168      RegisterEventHandlers();
    134169    }
    135170
    … …  
    138173    }
    139174
    140     private void Initialize() {
     175    private void RegisterEventHandlers() {
     176      LocalImprovementParameter.ValueChanged += new EventHandler(LocalImprovementParameter_ValueChanged);
    141177      if (Problem != null) {
    142178        Problem.Evaluator.QualityParameter.ActualNameChanged += new EventHandler(Evaluator_QualityParameter_ActualNameChanged);
    143179      }
    144       LocalImprovementParameter.ValueChanged += new EventHandler(LocalImprovementParameter_ValueChanged);
    145180    }
    146181
    147182    #region Events
    148183    protected override void OnProblemChanged() {
     184      InitializeLocalImprovementOperators();
     185      UpdateShakingOperators();
     186      UpdateAnalyzers();
     187
    149188      ParameterizeStochasticOperator(Problem.SolutionCreator);
    150189      ParameterizeStochasticOperator(Problem.Evaluator);
    151190      foreach (IOperator op in Problem.Operators) ParameterizeStochasticOperator(op);
    152191      ParameterizeSolutionsCreator();
    153       ParameterizeVNSMainLoop();
     192      ParameterizeMainLoop();
    154193      ParameterizeAnalyzers();
    155194      ParameterizeIterationBasedOperators();
    156       UpdateShakingOperator();
    157       UpdateLocalImprovementOperator();
    158       UpdateAnalyzers();
     195      ParameterizeLocalImprovementOperators();
    159196      Problem.Evaluator.QualityParameter.ActualNameChanged += new EventHandler(Evaluator_QualityParameter_ActualNameChanged);
    160197      base.OnProblemChanged();
    161198    }
    162 
    163199    protected override void Problem_SolutionCreatorChanged(object sender, EventArgs e) {
    164200      ParameterizeStochasticOperator(Problem.SolutionCreator);
    … …  
    169205      ParameterizeStochasticOperator(Problem.Evaluator);
    170206      ParameterizeSolutionsCreator();
    171       ParameterizeVNSMainLoop();
     207      ParameterizeMainLoop();
    172208      ParameterizeAnalyzers();
    173209      Problem.Evaluator.QualityParameter.ActualNameChanged += new EventHandler(Evaluator_QualityParameter_ActualNameChanged);
    … …  
    175211    }
    176212    protected override void Problem_OperatorsChanged(object sender, EventArgs e) {
     213      UpdateShakingOperators();
     214      UpdateAnalyzers();
    177215      foreach (IOperator op in Problem.Operators) ParameterizeStochasticOperator(op);
    178216      ParameterizeIterationBasedOperators();
    179       UpdateShakingOperator();
    180       UpdateLocalImprovementOperator();
    181       UpdateAnalyzers();
    182217      base.Problem_OperatorsChanged(sender, e);
    183218    }
    184 
    185219    private void Evaluator_QualityParameter_ActualNameChanged(object sender, EventArgs e) {
    186       ParameterizeVNSMainLoop();
     220      ParameterizeMainLoop();
    187221      ParameterizeAnalyzers();
    188222    }
    189 
    190     void LocalImprovementParameter_ValueChanged(object sender, EventArgs e) {
    191       if (LocalImprovementParameter.Value != null)
    192         LocalImprovementParameter.Value.OnProblemChanged(Problem);
     223    private void LocalImprovementParameter_ValueChanged(object sender, EventArgs e) {
     224      ParameterizeLocalImprovementOperators();
    193225    }
    194226    #endregion
    … …  
    203235        ((IStochasticOperator)op).RandomParameter.ActualName = RandomCreator.RandomParameter.ActualName;
    204236    }
    205     private void ParameterizeVNSMainLoop() {
    206       VNSMainLoop.EvaluatorParameter.ActualName = Problem.EvaluatorParameter.Name;
    207       VNSMainLoop.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
    208       VNSMainLoop.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
     237    private void ParameterizeMainLoop() {
     238      MainLoop.EvaluatorParameter.ActualName = Problem.EvaluatorParameter.Name;
     239      MainLoop.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
     240      MainLoop.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
    209241    }
    210242    private void ParameterizeAnalyzers() {
    … …  
    221253        foreach (IIterationBasedOperator op in Problem.Operators.OfType<IIterationBasedOperator>()) {
    222254          op.IterationsParameter.ActualName = "Iterations";
    223           op.MaximumIterationsParameter.ActualName = "MaximumIterations";
     255          op.MaximumIterationsParameter.ActualName = MaximumIterationsParameter.Name;
    224256        }
    225257      }
    226258    }
    227     private void UpdateShakingOperator() {
    228       Type manipulatorType = typeof(IManipulator);
    229       List<Type> manipulatorInterfaces = new List<Type>();
    230 
    231       foreach (IManipulator mutator in Problem.Operators.OfType<IManipulator>().OrderBy(x => x.Name)) {
    232         Type t = mutator.GetType();
    233         Type[] interfaces = t.GetInterfaces();
    234 
    235         for (int i = 0; i < interfaces.Length; i++) {
    236           if (manipulatorType.IsAssignableFrom(interfaces[i])) {
    237             bool assignable = false;
    238             for (int j = 0; j < interfaces.Length; j++) {
    239               if (i != j && interfaces[i].IsAssignableFrom(interfaces[j])) {
    240                 assignable = true;
    241                 break;
    242               }
    243             }
    244 
    245             if (!assignable)
    246               manipulatorInterfaces.Add(interfaces[i]);
    247           }
     259    private void ParameterizeLocalImprovementOperators() {
     260      foreach (ILocalImprovementOperator op in LocalImprovementParameter.ValidValues) {
     261        if (op != LocalImprovementParameter.Value) op.Problem = null;
     262        op.MaximumIterationsParameter.Value = null;
     263        op.MaximumIterationsParameter.ActualName = LocalImprovementMaximumIterationsParameter.Name;
     264      }
     265      if (LocalImprovementParameter.Value != null)
     266        LocalImprovementParameter.Value.Problem = Problem;
     267    }
     268    private void InitializeLocalImprovementOperators() {
     269      if (Problem == null) {
     270        LocalImprovementParameter.ValidValues.Clear();
     271      } else {
     272        LocalImprovementParameter.ValidValues.RemoveWhere(x => !x.ProblemType.IsAssignableFrom(Problem.GetType()));
     273        foreach (ILocalImprovementOperator op in ApplicationManager.Manager.GetInstances<ILocalImprovementOperator>().Where(x => x.ProblemType.IsAssignableFrom(Problem.GetType()))) {
     274          if (!LocalImprovementParameter.ValidValues.Any(x => x.GetType() == op.GetType()))
     275            LocalImprovementParameter.ValidValues.Add(op);
    248276        }
    249277      }
    250 
    251       foreach (Type manipulatorInterface in manipulatorInterfaces) {
    252         //manipulatorInterface is more specific
    253         if (manipulatorType.IsAssignableFrom(manipulatorInterface)) {
    254           //and compatible to all other found manipulator types
    255           bool compatible = true;
    256           foreach (Type manipulatorInterface2 in manipulatorInterfaces) {
    257             if (!manipulatorInterface.IsAssignableFrom(manipulatorInterface2)) {
    258               compatible = false;
    259               break;
    260             }
    261           }
    262 
    263           if (compatible)
    264             manipulatorType = manipulatorInterface;
    265         }
    266       }
    267 
    268       Type genericType = typeof(ShakingOperator<>).MakeGenericType(manipulatorType);
    269       ShakingParameter.Value = (IShakingOperator)Activator.CreateInstance(genericType, new object[] { });
    270 
    271       ShakingParameter.Value.OnProblemChanged(Problem);
    272     }
    273     private void UpdateLocalImprovementOperator() {
    274       LocalImprovementParameter.Value.OnProblemChanged(Problem);
     278    }
     279    private void UpdateShakingOperators() {
     280      ShakingOperatorParameter.ValidValues.Clear();
     281      foreach (IMultiNeighborhoodShakingOperator op in Problem.Operators.OfType<IMultiNeighborhoodShakingOperator>()) {
     282        ShakingOperatorParameter.ValidValues.Add(op);
     283        op.CurrentNeighborhoodIndexParameter.ActualName = "CurrentNeighborhoodIndex";
     284        op.NeighborhoodCountParameter.ActualName = "NeighborhoodCount";
     285      }
    275286    }
    276287    private void UpdateAnalyzers() {

  • branches/histogram/HeuristicLab.Algorithms.VariableNeighborhoodSearch/3.3/VariableNeighborhoodSearchMainLoop.cs

    r5753 r6046  
    2020#endregion
    2121
    22 using System;
    23 using System.Collections.Generic;
    24 using System.Linq;
    25 using System.Text;
    26 using HeuristicLab.Operators;
    27 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
    2822using HeuristicLab.Common;
    2923using HeuristicLab.Core;
     24using HeuristicLab.Data;
     25using HeuristicLab.Operators;
     26using HeuristicLab.Optimization;
     27using HeuristicLab.Optimization.Operators;
    3028using HeuristicLab.Parameters;
    31 using HeuristicLab.Data;
    32 using HeuristicLab.Optimization.Operators;
     29using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
    3330using HeuristicLab.Selection;
    34 using HeuristicLab.Optimization;
    3531
    3632namespace HeuristicLab.Algorithms.VariableNeighborhoodSearch {
    … …  
    4238  public sealed class VariableNeighborhoodSearchMainLoop : AlgorithmOperator {
    4339    #region Parameter properties
    44     public ValueLookupParameter<IRandom> RandomParameter {
    45       get { return (ValueLookupParameter<IRandom>)Parameters["Random"]; }
    46     }
    47     public ValueLookupParameter<BoolValue> MaximizationParameter {
    48       get { return (ValueLookupParameter<BoolValue>)Parameters["Maximization"]; }
    49     }
    50     public LookupParameter<DoubleValue> QualityParameter {
    51       get { return (LookupParameter<DoubleValue>)Parameters["Quality"]; }
    52     }
    53     public ValueLookupParameter<DoubleValue> BestKnownQualityParameter {
    54       get { return (ValueLookupParameter<DoubleValue>)Parameters["BestKnownQuality"]; }
    55     }
    56     public ValueLookupParameter<IOperator> EvaluatorParameter {
    57       get { return (ValueLookupParameter<IOperator>)Parameters["Evaluator"]; }
    58     }
    59     public ValueLookupParameter<IntValue> MaximumIterationsParameter {
    60       get { return (ValueLookupParameter<IntValue>)Parameters["MaximumIterations"]; }
    61     }
    62     public ValueLookupParameter<VariableCollection> ResultsParameter {
    63       get { return (ValueLookupParameter<VariableCollection>)Parameters["Results"]; }
    64     }
    65     public ValueLookupParameter<IOperator> AnalyzerParameter {
    66       get { return (ValueLookupParameter<IOperator>)Parameters["Analyzer"]; }
    67     }
    68     public LookupParameter<IntValue> EvaluatedSolutionsParameter {
    69       get { return (LookupParameter<IntValue>)Parameters["EvaluatedSolutions"]; }
    70     }
    71     public ValueLookupParameter<ILocalImprovementOperator> LocalImprovementParameter {
    72       get { return (ValueLookupParameter<ILocalImprovementOperator>)Parameters["LocalImprovement"]; }
    73     }
    74     public ValueLookupParameter<IShakingOperator> ShakingParameter {
    75       get { return (ValueLookupParameter<IShakingOperator>)Parameters["Shaking"]; }
     40    public IValueLookupParameter<IRandom> RandomParameter {
     41      get { return (IValueLookupParameter<IRandom>)Parameters["Random"]; }
     42    }
     43    public IValueLookupParameter<BoolValue> MaximizationParameter {
     44      get { return (IValueLookupParameter<BoolValue>)Parameters["Maximization"]; }
     45    }
     46    public ILookupParameter<DoubleValue> QualityParameter {
     47      get { return (ILookupParameter<DoubleValue>)Parameters["Quality"]; }
     48    }
     49    public IValueLookupParameter<DoubleValue> BestKnownQualityParameter {
     50      get { return (IValueLookupParameter<DoubleValue>)Parameters["BestKnownQuality"]; }
     51    }
     52    public IValueLookupParameter<IOperator> EvaluatorParameter {
     53      get { return (IValueLookupParameter<IOperator>)Parameters["Evaluator"]; }
     54    }
     55    public ILookupParameter<IntValue> IterationsParameter {
     56      get { return (ILookupParameter<IntValue>)Parameters["Iterations"]; }
     57    }
     58    public IValueLookupParameter<IntValue> MaximumIterationsParameter {
     59      get { return (IValueLookupParameter<IntValue>)Parameters["MaximumIterations"]; }
     60    }
     61    public IValueLookupParameter<VariableCollection> ResultsParameter {
     62      get { return (IValueLookupParameter<VariableCollection>)Parameters["Results"]; }
     63    }
     64    public IValueLookupParameter<IOperator> AnalyzerParameter {
     65      get { return (IValueLookupParameter<IOperator>)Parameters["Analyzer"]; }
     66    }
     67    public ILookupParameter<IntValue> EvaluatedSolutionsParameter {
     68      get { return (ILookupParameter<IntValue>)Parameters["EvaluatedSolutions"]; }
     69    }
     70    public ILookupParameter<IntValue> CurrentNeighborhoodIndexParameter {
     71      get { return (ILookupParameter<IntValue>)Parameters["CurrentNeighborhoodIndex"]; }
     72    }
     73    public ILookupParameter<IntValue> NeighborhoodCountParameter {
     74      get { return (ILookupParameter<IntValue>)Parameters["NeighborhoodCount"]; }
     75    }
     76    public IValueLookupParameter<ILocalImprovementOperator> LocalImprovementParameter {
     77      get { return (IValueLookupParameter<ILocalImprovementOperator>)Parameters["LocalImprovement"]; }
     78    }
     79    public IValueLookupParameter<IMultiNeighborhoodShakingOperator> ShakingOperatorParameter {
     80      get { return (IValueLookupParameter<IMultiNeighborhoodShakingOperator>)Parameters["ShakingOperator"]; }
    7681    }
    7782    #endregion
    … …  
    8186    public VariableNeighborhoodSearchMainLoop()
    8287      : base() {
    83         Initialize();
     88      Initialize();
    8489    }
    8590    private VariableNeighborhoodSearchMainLoop(VariableNeighborhoodSearchMainLoop original, Cloner cloner)
    … …  
    97102      Parameters.Add(new ValueLookupParameter<DoubleValue>("BestKnownQuality", "The best known quality value found so far."));
    98103      Parameters.Add(new ValueLookupParameter<IOperator>("Evaluator", "The operator used to evaluate solutions. This operator is executed in parallel, if an engine is used which supports parallelization."));
     104      Parameters.Add(new LookupParameter<IntValue>("Iterations", "The iterations to count."));
    99105      Parameters.Add(new ValueLookupParameter<IntValue>("MaximumIterations", "The maximum number of generations which should be processed."));
    100106      Parameters.Add(new ValueLookupParameter<VariableCollection>("Results", "The variable collection where results should be stored."));
    101 
    102107      Parameters.Add(new ValueLookupParameter<IOperator>("Analyzer", "The operator used to analyze the solution."));
    103108      Parameters.Add(new LookupParameter<IntValue>("EvaluatedSolutions", "The number of evaluated solutions."));
    104109      Parameters.Add(new ValueLookupParameter<ILocalImprovementOperator>("LocalImprovement", "The local improvement operation."));
    105       Parameters.Add(new ValueLookupParameter<IShakingOperator>("Shaking", "The shaking operation."));
     110      Parameters.Add(new ValueLookupParameter<IMultiNeighborhoodShakingOperator>("ShakingOperator", "The shaking operation."));
     111      Parameters.Add(new LookupParameter<IntValue>("CurrentNeighborhoodIndex", "The index of the current shaking operation that should be applied."));
     112      Parameters.Add(new LookupParameter<IntValue>("NeighborhoodCount", "The number of neighborhood operators used for shaking."));
    106113      #endregion
    107114
    … …  
    126133
    127134      QualityComparator qualityComparator = new QualityComparator();
    128       ConditionalBranch improvesQualityBranch1 = new ConditionalBranch();
    129       ConditionalBranch improvesQualityBranch2 = new ConditionalBranch();
     135      ConditionalBranch improvesQualityBranch = new ConditionalBranch();
    130136
    131137      Assigner bestQualityUpdater = new Assigner();
    … …  
    139145      Placeholder analyzer2 = new Placeholder();
    140146
     147      Comparator indexComparator = new Comparator();
    141148      ConditionalBranch indexTermination = new ConditionalBranch();
    142149
    … …  
    145152      ConditionalBranch iterationsTermination = new ConditionalBranch();
    146153
    147       variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("Iterations", new IntValue(0)));
    148       variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("Index", new IntValue(0)));
    149       variableCreator.CollectedValues.Add(new ValueParameter<BoolValue>("Continue", new BoolValue(false)));
    150154      variableCreator.CollectedValues.Add(new ValueParameter<BoolValue>("IsBetter", new BoolValue(false)));
    151155      variableCreator.CollectedValues.Add(new ValueParameter<DoubleValue>("BestQuality", new DoubleValue(0)));
    … …  
    159163
    160164      resultsCollector1.CopyValue = new BoolValue(false);
    161       resultsCollector1.CollectedValues.Add(new LookupParameter<IntValue>("Iterations"));
    162165      resultsCollector1.CollectedValues.Add(new LookupParameter<DoubleValue>("Best Quality", null, "BestQuality"));
    163166      resultsCollector1.ResultsParameter.ActualName = ResultsParameter.Name;
    164167
    165       iteration.Name = "Iteration";
    166 
    167       iterationInit.Name = "Init iteration";
    168       iterationInit.LeftSideParameter.ActualName = "Index";
     168      iteration.Name = "MainLoop Body";
     169
     170      iterationInit.Name = "Init k = 0";
     171      iterationInit.LeftSideParameter.ActualName = CurrentNeighborhoodIndexParameter.Name;
    169172      iterationInit.RightSideParameter.Value = new IntValue(0);
    170173
    … …  
    176179
    177180      shaking.Name = "Shaking operator (placeholder)";
    178       shaking.OperatorParameter.ActualName = ShakingParameter.Name;
     181      shaking.OperatorParameter.ActualName = ShakingOperatorParameter.Name;
    179182
    180183      localImprovement.Name = "Local improvement operator (placeholder)";
    … …  
    192195      qualityComparator.ResultParameter.ActualName = "IsBetter";
    193196
    194       improvesQualityBranch1.ConditionParameter.ActualName = "IsBetter";
    195       improvesQualityBranch2.ConditionParameter.ActualName = "IsBetter";
     197      improvesQualityBranch.ConditionParameter.ActualName = "IsBetter";
    196198
    197199      bestQualityUpdater.Name = "Update BestQuality";
    … …  
    204206      bestSelector.QualityParameter.ActualName = QualityParameter.Name;
    205207
    206       indexCounter.Name = "Count index";
     208      indexCounter.Name = "Count neighborhood index";
    207209      indexCounter.Increment.Value = 1;
    208       indexCounter.ValueParameter.ActualName = "Index";
    209 
    210       indexResetter.Name = "Reset index";
    211       indexResetter.LeftSideParameter.ActualName = "Index";
     210      indexCounter.ValueParameter.ActualName = CurrentNeighborhoodIndexParameter.Name;
     211
     212      indexResetter.Name = "Reset neighborhood index";
     213      indexResetter.LeftSideParameter.ActualName = CurrentNeighborhoodIndexParameter.Name;
    212214      indexResetter.RightSideParameter.Value = new IntValue(0);
    213215
    … …  
    217219      iterationsCounter.Name = "Iterations Counter";
    218220      iterationsCounter.Increment = new IntValue(1);
    219       iterationsCounter.ValueParameter.ActualName = "Iterations";
     221      iterationsCounter.ValueParameter.ActualName = IterationsParameter.Name;
    220222
    221223      iterationsComparator.Name = "Iterations >= MaximumIterations";
    222224      iterationsComparator.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
    223       iterationsComparator.LeftSideParameter.ActualName = "Iterations";
     225      iterationsComparator.LeftSideParameter.ActualName = IterationsParameter.Name;
    224226      iterationsComparator.RightSideParameter.ActualName = MaximumIterationsParameter.Name;
    225227      iterationsComparator.ResultParameter.ActualName = "Terminate";
    … …  
    228230      iterationsTermination.ConditionParameter.ActualName = "Terminate";
    229231
     232      indexComparator.Name = "k < k_max (index condition)";
     233      indexComparator.LeftSideParameter.ActualName = CurrentNeighborhoodIndexParameter.Name;
     234      indexComparator.RightSideParameter.ActualName = NeighborhoodCountParameter.Name;
     235      indexComparator.Comparison = new Comparison(ComparisonType.Less);
     236      indexComparator.ResultParameter.ActualName = "ContinueIteration";
     237
    230238      indexTermination.Name = "Index Termination Condition";
    231       indexTermination.ConditionParameter.ActualName = "Continue";
     239      indexTermination.ConditionParameter.ActualName = "ContinueIteration";
    232240      #endregion
    233241
    … …  
    255263      evalCounter.Successor = localImprovement;
    256264      localImprovement.Successor = qualityComparator;
    257       qualityComparator.Successor = improvesQualityBranch1;
    258       improvesQualityBranch1.TrueBranch = bestQualityUpdater;
    259       improvesQualityBranch1.FalseBranch = indexCounter;
     265      qualityComparator.Successor = improvesQualityBranch;
     266      improvesQualityBranch.TrueBranch = bestQualityUpdater;
     267      improvesQualityBranch.FalseBranch = indexCounter;
    260268
    261269      bestQualityUpdater.Successor = indexResetter;
    … …  
    266274      bestSelector.Successor = rightReducer;
    267275      rightReducer.Successor = analyzer2;
    268       analyzer2.Successor = indexTermination;
    269       indexTermination.TrueBranch = improvesQualityBranch2;
     276      analyzer2.Successor = indexComparator;
     277      indexComparator.Successor = indexTermination;
     278      indexTermination.TrueBranch = createChild;
    270279      indexTermination.FalseBranch = null;
    271 
    272       improvesQualityBranch2.TrueBranch = null;
    273       improvesQualityBranch2.FalseBranch = createChild;
    274280
    275281      iterationsCounter.Successor = iterationsComparator;
    … …  
    281287
    282288    public override IOperation Apply() {
    283       if (LocalImprovementParameter.ActualValue == null || EvaluatorParameter.ActualValue == null)
     289      if (LocalImprovementParameter.ActualValue == null || ShakingOperatorParameter.ActualValue == null)
    284290        return null;
    285291      return base.Apply();
Note: See TracChangeset for help on using the changeset viewer.