Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
04/23/11 00:29:24 (13 years ago)
Author:
abeham
Message:

#1425

  • Changed LocalImprovementOperators
    • Changed interface (made Problem a property, added a property that denotes the type of the problem that it can be applied on, added some general parameters)
    • Added some parameters and wiring
    • Changed move discovery and parameterization and added a helper class to ease finding compatible move operators
    • Discovering only IMultiMoveOperators and IExhaustiveMoveOperators and putting the multi move ones first
    • Fixed bug in Apply method that could create an endless string of nested execution contexts
    • Removed all problem specific analyzers in the two local improvement operators and only left the BestAverageWorstQualityAnalyzer since it doesn't make any sense to perform diversity or allele analysis during local improvement in the most common case and those analyzers take a lot of time (one can always add them manually should he/she be interested). The analyzers in the VNS's Analyzer parameter are left untouched.
  • Removed shaking operator and interface from VNS plugin and added that to Optimization and Optimization.Operators
  • Changed some ValueParameters to ConstrainedValueParameters and added type discovery to fill them (using the ProblemType property to get compatible local improvement operators)
  • Added missing GPL license headers
  • Changed some ValueParameters to the new FixedValueParameters
  • Added an additional encoding specific ShakingOperator to each encoding and added that to each problem
    • reason is that only the problem/encoding can really decide if a shaking operator is meaningful or not
  • Fixed an unrelated bug in the BestAverageWorstQualityAnalyzer that I encountered (and made the fix backwards compatible)
    • Also added a snippet for creating the backwards compatible comment marker and region
  • Fixed the operator graph of the VNS main loop
    • The condition to continue only when the local search was not successful is not necessary and is not part of the VNS definition as far as I know it (only condition to break the inner loop is when k reaches k_max)
  • Changed the ShakingOperator to input current index and output the maximum number of neighborhoods instead of a boolean that indicates that the last index has been reached since the maximum number is a little more generally useful and equally powerful in modeling
    • Remodeled the VNS main loop to check for k < k_max in order to continue the inner loop
  • other changes that I forgot...

Still necessary

  • test, test, test
  • check for backwards compatible breakers
  • add a maximum evaluated solutions stop criterion
  • optionally: implement fast problem specific local search improvement operators that do not build on the whole generic overhead (e.g. a 2-opt TSP specific local search operator). The idea of VNS is really to converge to a local optimum which is difficult to achieve using the current rather limited termination options
Location:
trunk/sources/HeuristicLab.Algorithms.LocalSearch/3.3
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/sources/HeuristicLab.Algorithms.LocalSearch/3.3/LocalSearch.cs

    r5809 r6042  
    185185      mainLoop.EvaluatedMovesParameter.ActualName = "EvaluatedMoves";
    186186      mainLoop.IterationsParameter.ActualName = "Iterations";
    187       mainLoop.BestQualityParameter.ActualName = "BestQuality";
     187      mainLoop.BestLocalQualityParameter.ActualName = "BestQuality";
    188188
    189189      moveQualityAnalyzer = new BestAverageWorstQualityAnalyzer();

  • trunk/sources/HeuristicLab.Algorithms.LocalSearch/3.3/LocalSearchImprovementOperator.cs

    r5809 r6042  
    2121
    2222using System;
    23 using System.Collections.Generic;
    2423using System.Linq;
    2524using HeuristicLab.Analysis;
    … …  
    2928using HeuristicLab.Operators;
    3029using HeuristicLab.Optimization;
    31 using HeuristicLab.Optimization.Operators;
    3230using HeuristicLab.Parameters;
    3331using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
    … …  
    3937  [Item("LocalSearchImprovementOperator", "A local search improvement operator.")]
    4038  [StorableClass]
    41   public class LocalSearchImprovementOperator : SingleSuccessorOperator, ILocalImprovementOperator {
     39  public sealed class LocalSearchImprovementOperator : SingleSuccessorOperator, IGenericLocalImprovementOperator, IStochasticOperator {
     40    #region IGenericLocalImprovementOperator Properties
     41    public Type ProblemType { get { return typeof(ISingleObjectiveHeuristicOptimizationProblem); } }
     42    public IProblem Problem {
     43      get { return problem; }
     44      set {
     45        if (problem != value) {
     46          if (value != null && !(value is ISingleObjectiveHeuristicOptimizationProblem))
     47            throw new ArgumentException("Only problems of type " + ProblemType.ToString() + " can be assigned.");
     48          if (problem != null) DeregisterProblemEventHandlers();
     49          problem = (ISingleObjectiveHeuristicOptimizationProblem)value;
     50          if (problem != null) RegisterProblemEventHandlers();
     51          UpdateProblem();
     52        }
     53      }
     54    }
     55    #endregion
     56
     57    [Storable]
     58    private ISingleObjectiveHeuristicOptimizationProblem problem;
    4259    [Storable]
    4360    private LocalSearchMainLoop loop;
    44 
    4561    [Storable]
    4662    private BestAverageWorstQualityAnalyzer qualityAnalyzer;
    4763
    48     private ConstrainedValueParameter<IMoveGenerator> MoveGeneratorParameter {
     64    #region Parameter Properties
     65    public ConstrainedValueParameter<IMoveGenerator> MoveGeneratorParameter {
    4966      get { return (ConstrainedValueParameter<IMoveGenerator>)Parameters["MoveGenerator"]; }
    5067    }
    51     private ConstrainedValueParameter<IMoveMaker> MoveMakerParameter {
     68    public ConstrainedValueParameter<IMoveMaker> MoveMakerParameter {
    5269      get { return (ConstrainedValueParameter<IMoveMaker>)Parameters["MoveMaker"]; }
    5370    }
    54     private ConstrainedValueParameter<ISingleObjectiveMoveEvaluator> MoveEvaluatorParameter {
     71    public ConstrainedValueParameter<ISingleObjectiveMoveEvaluator> MoveEvaluatorParameter {
    5572      get { return (ConstrainedValueParameter<ISingleObjectiveMoveEvaluator>)Parameters["MoveEvaluator"]; }
    5673    }
    57     private ValueParameter<IntValue> MaximumIterationsParameter {
    58       get { return (ValueParameter<IntValue>)Parameters["MaximumIterations"]; }
    59     }
    60     private ValueParameter<IntValue> SampleSizeParameter {
    61       get { return (ValueParameter<IntValue>)Parameters["SampleSize"]; }
    62     }
    63     public LookupParameter<IntValue> EvaluatedSolutionsParameter {
    64       get { return (LookupParameter<IntValue>)Parameters["EvaluatedSolutions"]; }
     74    public IValueLookupParameter<IntValue> SampleSizeParameter {
     75      get { return (IValueLookupParameter<IntValue>)Parameters["SampleSize"]; }
    6576    }
    6677    public ValueParameter<MultiAnalyzer> AnalyzerParameter {
    6778      get { return (ValueParameter<MultiAnalyzer>)Parameters["Analyzer"]; }
    6879    }
    69 
     80    public ScopeTreeLookupParameter<DoubleValue> QualityParameter {
     81      get { return (ScopeTreeLookupParameter<DoubleValue>)Parameters["Quality"]; }
     82    }
     83    public ILookupParameter<IRandom> RandomParameter {
     84      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
     85    }
     86    #region ILocalImprovementOperator Parameters
     87    public IValueLookupParameter<IntValue> MaximumIterationsParameter {
     88      get { return (IValueLookupParameter<IntValue>)Parameters["MaximumIterations"]; }
     89    }
     90    public ILookupParameter<IntValue> EvaluatedSolutionsParameter {
     91      get { return (ILookupParameter<IntValue>)Parameters["EvaluatedSolutions"]; }
     92    }
     93    public ILookupParameter<ResultCollection> ResultsParameter {
     94      get { return (ILookupParameter<ResultCollection>)Parameters["Results"]; }
     95    }
     96    #endregion
     97    #endregion
     98
     99    #region Properties
    70100    public IMoveGenerator MoveGenerator {
    71101      get { return MoveGeneratorParameter.Value; }
    … …  
    84114      set { AnalyzerParameter.Value = value; }
    85115    }
     116    #endregion
    86117
    87118    [StorableConstructor]
    88     protected LocalSearchImprovementOperator(bool deserializing) : base(deserializing) { }
    89     [StorableHook(HookType.AfterDeserialization)]
    90     private void AfterDeserialization() {
    91       Initialize();
    92     }
    93     protected LocalSearchImprovementOperator(LocalSearchImprovementOperator original, Cloner cloner)
     119    private LocalSearchImprovementOperator(bool deserializing) : base(deserializing) { }
     120    private LocalSearchImprovementOperator(LocalSearchImprovementOperator original, Cloner cloner)
    94121      : base(original, cloner) {
    95122      this.loop = cloner.Clone(original.loop);
    96123      this.qualityAnalyzer = cloner.Clone(original.qualityAnalyzer);
    97       Initialize();
    98     }
    99     public override IDeepCloneable Clone(Cloner cloner) {
    100       return new LocalSearchImprovementOperator(this, cloner);
     124      this.problem = cloner.Clone(original.problem);
     125      RegisterEventHandlers();
    101126    }
    102127    public LocalSearchImprovementOperator()
    103128      : base() {
    104       loop = new LocalSearchMainLoop();
    105 
    106       ResultsCollector rc = (loop.OperatorGraph.InitialOperator as SingleSuccessorOperator).Successor as ResultsCollector;
    107       rc.CollectedValues.Remove("BestLocalQuality");
    108 
    109       qualityAnalyzer = new BestAverageWorstQualityAnalyzer();
    110 
    111129      Parameters.Add(new ConstrainedValueParameter<IMoveGenerator>("MoveGenerator", "The operator used to generate moves to the neighborhood of the current solution."));
    112130      Parameters.Add(new ConstrainedValueParameter<IMoveMaker>("MoveMaker", "The operator used to perform a move."));
    113131      Parameters.Add(new ConstrainedValueParameter<ISingleObjectiveMoveEvaluator>("MoveEvaluator", "The operator used to evaluate a move."));
    114       Parameters.Add(new ValueParameter<IntValue>("MaximumIterations", "The maximum number of generations which should be processed.", new IntValue(150)));
    115       Parameters.Add(new ValueParameter<IntValue>("SampleSize", "Number of moves that MultiMoveGenerators should create. This is ignored for Exhaustive- and SingleMoveGenerators.", new IntValue(1500)));
     132      Parameters.Add(new ValueLookupParameter<IntValue>("MaximumIterations", "The maximum number of generations which should be processed.", new IntValue(150)));
     133      Parameters.Add(new ValueLookupParameter<IntValue>("SampleSize", "Number of moves that MultiMoveGenerators should create. This is ignored for Exhaustive- and SingleMoveGenerators.", new IntValue(300)));
    116134      Parameters.Add(new LookupParameter<IntValue>("EvaluatedSolutions", "The number of evaluated moves."));
    117135      Parameters.Add(new ValueParameter<MultiAnalyzer>("Analyzer", "The operator used to analyze the solution.", new MultiAnalyzer()));
    118 
    119       Initialize();
    120     }
    121 
    122     private void Initialize() {
     136      Parameters.Add(new LookupParameter<ResultCollection>("Results", "The name of the collection where the results are stored."));
     137      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Quality", "The quality/fitness value of a solution."));
     138      Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator to use."));
     139
     140      loop = new LocalSearchMainLoop();
     141      ParameterizeLSMainLoop();
     142
     143      qualityAnalyzer = new BestAverageWorstQualityAnalyzer();
     144      Analyzer.Operators.Add(qualityAnalyzer);
     145
     146      RegisterEventHandlers();
     147    }
     148
     149    public override IDeepCloneable Clone(Cloner cloner) {
     150      return new LocalSearchImprovementOperator(this, cloner);
     151    }
     152
     153    [StorableHook(HookType.AfterDeserialization)]
     154    private void AfterDeserialization() {
     155      RegisterEventHandlers();
     156    }
     157
     158    #region Event Handler Registration
     159    private void RegisterEventHandlers() {
    123160      MoveGeneratorParameter.ValueChanged += new EventHandler(MoveGeneratorParameter_ValueChanged);
    124     }
    125 
    126     public void OnProblemChanged(IProblem problem) {
    127       UpdateMoveOperators(problem);
     161      if (problem != null)
     162        RegisterProblemEventHandlers();
     163    }
     164
     165    private void RegisterProblemEventHandlers() {
     166      problem.Reset += new EventHandler(problem_Reset);
     167      problem.OperatorsChanged += new EventHandler(problem_OperatorsChanged);
     168    }
     169
     170    private void DeregisterProblemEventHandlers() {
     171      problem.Reset -= new EventHandler(problem_Reset);
     172      problem.OperatorsChanged -= new EventHandler(problem_OperatorsChanged);
     173    }
     174    #endregion
     175
     176    #region Event Handlers
     177    private void MoveGeneratorParameter_ValueChanged(object sender, EventArgs e) {
    128178      ChooseMoveOperators();
    129 
    130       ParameterizeMoveGenerators(problem as ISingleObjectiveHeuristicOptimizationProblem);
    131       ParameterizeMoveEvaluators(problem as ISingleObjectiveHeuristicOptimizationProblem);
    132       ParameterizeMoveMakers(problem as ISingleObjectiveHeuristicOptimizationProblem);
    133 
    134       ParameterizeAnalyzers(problem as ISingleObjectiveHeuristicOptimizationProblem);
    135       UpdateAnalyzers(problem as ISingleObjectiveHeuristicOptimizationProblem);
    136     }
    137 
    138     void ParameterizeAnalyzers(ISingleObjectiveHeuristicOptimizationProblem problem) {
    139       qualityAnalyzer.ResultsParameter.ActualName = "Results";
     179      ParameterizeLSMainLoop();
     180    }
     181
     182    private void problem_Reset(object sender, EventArgs e) {
     183      UpdateProblem();
     184    }
     185
     186    private void problem_OperatorsChanged(object sender, EventArgs e) {
     187      UpdateProblem();
     188    }
     189    #endregion
     190
     191    #region Parameterize and Update Methods
     192    private void UpdateProblem() {
     193      UpdateMoveOperators();
     194      ChooseMoveOperators();
     195
     196      ParameterizeMoveGenerators();
     197
     198      ParameterizeLSMainLoop();
     199      ParameterizeAnalyzers();
     200    }
     201
     202    private void ParameterizeLSMainLoop() {
     203      loop.AnalyzerParameter.ActualName = AnalyzerParameter.Name;
     204      loop.BestLocalQualityParameter.ActualName = QualityParameter.Name;
     205      loop.EvaluatedMovesParameter.ActualName = EvaluatedSolutionsParameter.Name;
     206      loop.IterationsParameter.ActualName = "LocalIterations";
     207      loop.MaximumIterationsParameter.ActualName = MaximumIterationsParameter.Name;
     208      loop.MoveEvaluatorParameter.ActualName = MoveEvaluatorParameter.Name;
     209      loop.MoveGeneratorParameter.ActualName = MoveGeneratorParameter.Name;
     210      loop.MoveMakerParameter.ActualName = MoveMakerParameter.Name;
     211      loop.QualityParameter.ActualName = QualityParameter.Name;
     212      loop.RandomParameter.ActualName = RandomParameter.Name;
     213      loop.ResultsParameter.ActualName = ResultsParameter.Name;
     214
     215      if (problem != null) {
     216        loop.BestKnownQualityParameter.ActualName = problem.BestKnownQualityParameter.Name;
     217        loop.MaximizationParameter.ActualName = problem.MaximizationParameter.Name;
     218      }
     219      if (MoveEvaluator != null) {
     220        loop.MoveQualityParameter.ActualName = MoveEvaluator.MoveQualityParameter.ActualName;
     221      }
     222    }
     223
     224    private void ParameterizeAnalyzers() {
     225      qualityAnalyzer.ResultsParameter.ActualName = ResultsParameter.Name;
    140226      if (problem != null) {
    141227        qualityAnalyzer.MaximizationParameter.ActualName = problem.MaximizationParameter.Name;
    … …  
    146232    }
    147233
    148     void UpdateAnalyzers(ISingleObjectiveHeuristicOptimizationProblem problem) {
    149       Analyzer.Operators.Clear();
    150       if (problem != null) {
    151         foreach (IAnalyzer analyzer in problem.Operators.OfType<IAnalyzer>()) {
    152           IAnalyzer clone = analyzer.Clone() as IAnalyzer;
    153           foreach (IScopeTreeLookupParameter param in clone.Parameters.OfType<IScopeTreeLookupParameter>())
    154             param.Depth = 0;
    155           Analyzer.Operators.Add(clone);
    156         }
    157       }
    158       Analyzer.Operators.Add(qualityAnalyzer);
    159     }
    160 
    161     void MoveGeneratorParameter_ValueChanged(object sender, EventArgs e) {
    162       ChooseMoveOperators();
    163     }
    164 
    165     private void UpdateMoveOperators(IProblem problem) {
     234    private void UpdateMoveOperators() {
    166235      IMoveGenerator oldMoveGenerator = MoveGenerator;
    167236      IMoveMaker oldMoveMaker = MoveMaker;
    … …  
    171240
    172241      if (problem != null) {
    173         foreach (IMoveGenerator generator in problem.Operators.OfType<IMoveGenerator>().OrderBy(x => x.Name))
     242        foreach (IMultiMoveGenerator generator in problem.Operators.OfType<IMultiMoveGenerator>().OrderBy(x => x.Name))
    174243          MoveGeneratorParameter.ValidValues.Add(generator);
    175 
    176         foreach (IMoveMaker maker in problem.Operators.OfType<IMoveMaker>().OrderBy(x => x.Name))
    177           MoveMakerParameter.ValidValues.Add(maker);
    178 
    179         foreach (ISingleObjectiveMoveEvaluator evaluator in problem.Operators.OfType<ISingleObjectiveMoveEvaluator>().OrderBy(x => x.Name))
    180           MoveEvaluatorParameter.ValidValues.Add(evaluator);
    181       }
    182 
    183       if (oldMoveGenerator != null) {
    184         IMoveGenerator newMoveGenerator = MoveGeneratorParameter.ValidValues.FirstOrDefault(x => x.GetType() == oldMoveGenerator.GetType());
    185         if (newMoveGenerator != null) MoveGenerator = newMoveGenerator;
    186       }
    187       if (MoveGenerator == null) {
    188         ClearMoveParameters();
    189       }
    190 
    191       if (oldMoveMaker != null) {
    192         IMoveMaker mm = MoveMakerParameter.ValidValues.FirstOrDefault(x => x.GetType() == oldMoveMaker.GetType());
    193         if (mm != null) MoveMaker = mm;
    194       }
    195 
    196       if (oldMoveEvaluator != null) {
    197         ISingleObjectiveMoveEvaluator me = MoveEvaluatorParameter.ValidValues.FirstOrDefault(x => x.GetType() == oldMoveEvaluator.GetType());
    198         if (me != null) MoveEvaluator = me;
    199       }
    200     }
    201 
    202     private void ChooseMoveOperators() {
    203       IMoveMaker oldMoveMaker = MoveMaker;
    204       ISingleObjectiveMoveEvaluator oldMoveEvaluator = MoveEvaluator;
    205 
    206       if (MoveGenerator != null) {
    207         List<Type> moveTypes = MoveGenerator.GetType().GetInterfaces().Where(x => typeof(IMoveOperator).IsAssignableFrom(x)).ToList();
    208         foreach (Type type in moveTypes.ToList()) {
    209           if (moveTypes.Any(t => t != type && type.IsAssignableFrom(t)))
    210             moveTypes.Remove(type);
    211         }
    212         List<IMoveMaker> validMoveMakers = new List<IMoveMaker>();
    213         List<ISingleObjectiveMoveEvaluator> validMoveEvaluators = new List<ISingleObjectiveMoveEvaluator>();
    214 
    215         foreach (Type type in moveTypes) {
    216           var moveMakers = MoveMakerParameter.ValidValues.Where(x => type.IsAssignableFrom(x.GetType())).OrderBy(x => x.Name);
    217           foreach (IMoveMaker moveMaker in moveMakers)
    218             validMoveMakers.Add(moveMaker);
    219 
    220           var moveEvaluators = MoveEvaluatorParameter.ValidValues.Where(x => type.IsAssignableFrom(x.GetType())).OrderBy(x => x.Name);
    221           foreach (ISingleObjectiveMoveEvaluator moveEvaluator in moveEvaluators)
    222             validMoveEvaluators.Add(moveEvaluator);
    223         }
     244        foreach (IExhaustiveMoveGenerator generator in problem.Operators.OfType<IExhaustiveMoveGenerator>().OrderBy(x => x.Name))
     245          MoveGeneratorParameter.ValidValues.Add(generator);
     246
     247        if (oldMoveGenerator != null) {
     248          IMoveGenerator newMoveGenerator = MoveGeneratorParameter.ValidValues.FirstOrDefault(x => x.GetType() == oldMoveGenerator.GetType());
     249          if (newMoveGenerator != null) MoveGenerator = newMoveGenerator;
     250        }
     251
     252        ChooseMoveOperators(oldMoveMaker, oldMoveEvaluator);
     253      }
     254    }
     255
     256    private void ChooseMoveOperators(IMoveMaker oldMoveMaker = null, ISingleObjectiveMoveEvaluator oldMoveEvaluator = null) {
     257      if (oldMoveMaker == null) oldMoveMaker = MoveMaker;
     258      if (oldMoveEvaluator == null) oldMoveEvaluator = MoveEvaluator;
     259      MoveMakerParameter.ValidValues.Clear();
     260      MoveEvaluatorParameter.ValidValues.Clear();
     261
     262      if (MoveGenerator != null && Problem != null) {
     263        IMoveGenerator generator = MoveGeneratorParameter.Value;
     264        foreach (IMoveMaker moveMaker in MoveHelper.GetCompatibleMoveMakers(generator, Problem.Operators).OrderBy(x => x.Name))
     265          MoveMakerParameter.ValidValues.Add(moveMaker);
     266        foreach (ISingleObjectiveMoveEvaluator moveEvaluator in MoveHelper.GetCompatibleSingleObjectiveMoveEvaluators(generator, Problem.Operators).OrderBy(x => x.Name))
     267          MoveEvaluatorParameter.ValidValues.Add(moveEvaluator);
     268
    224269        if (oldMoveMaker != null) {
    225           IMoveMaker mm = validMoveMakers.FirstOrDefault(x => x.GetType() == oldMoveMaker.GetType());
     270          IMoveMaker mm = MoveMakerParameter.ValidValues.FirstOrDefault(x => x.GetType() == oldMoveMaker.GetType());
    226271          if (mm != null) MoveMaker = mm;
    227           else MoveMaker = validMoveMakers.FirstOrDefault();
    228         }
    229 
     272        }
    230273        if (oldMoveEvaluator != null) {
    231           ISingleObjectiveMoveEvaluator me = validMoveEvaluators.FirstOrDefault(x => x.GetType() == oldMoveEvaluator.GetType());
     274          ISingleObjectiveMoveEvaluator me = MoveEvaluatorParameter.ValidValues.FirstOrDefault(x => x.GetType() == oldMoveEvaluator.GetType());
    232275          if (me != null) MoveEvaluator = me;
    233           else MoveEvaluator = validMoveEvaluators.FirstOrDefault();
    234276        }
    235277      }
    … …  
    242284    }
    243285
    244     private void ParameterizeMoveGenerators(ISingleObjectiveHeuristicOptimizationProblem problem) {
     286    private void ParameterizeMoveGenerators() {
    245287      if (problem != null) {
    246288        foreach (IMultiMoveGenerator generator in problem.Operators.OfType<IMultiMoveGenerator>())
    … …  
    248290      }
    249291    }
    250     private void ParameterizeMoveEvaluators(ISingleObjectiveHeuristicOptimizationProblem problem) {
    251       foreach (ISingleObjectiveMoveEvaluator op in problem.Operators.OfType<ISingleObjectiveMoveEvaluator>()) {
    252         op.QualityParameter.ActualName = problem.Evaluator.QualityParameter.ActualName;
    253       }
    254     }
    255     private void ParameterizeMoveMakers(ISingleObjectiveHeuristicOptimizationProblem problem) {
    256       foreach (IMoveMaker op in problem.Operators.OfType<IMoveMaker>()) {
    257         op.QualityParameter.ActualName = problem.Evaluator.QualityParameter.ActualName;
    258         if (MoveEvaluator != null)
    259           op.MoveQualityParameter.ActualName = MoveEvaluator.MoveQualityParameter.ActualName;
    260       }
    261     }
     292    #endregion
    262293
    263294    public override IOperation Apply() {
    264       Scope subScope = new Scope();
     295      IScope currentScope = ExecutionContext.Scope;
     296
     297      Scope localScope = new Scope();
    265298      Scope individual = new Scope();
    266299
    267       foreach (Variable var in ExecutionContext.Scope.Variables) {
    268         individual.Variables.Add(var);
    269       }
    270       subScope.SubScopes.Add(individual);
    271 
    272       ExecutionContext.Scope.SubScopes.Add(subScope);
    273       int index = subScope.Parent.SubScopes.IndexOf(subScope);
     300      foreach (IVariable var in currentScope.Variables)
     301        individual.Variables.Add(var); // add reference to variable otherwise the analyzer fails (it's looking down the tree)
     302
     303      localScope.SubScopes.Add(individual);
     304      currentScope.SubScopes.Add(localScope);
     305      int index = currentScope.SubScopes.Count - 1;
    274306
    275307      SubScopesProcessor processor = new SubScopesProcessor();
    … …  
    279311      remover.SubScopeIndexParameter.Value = new IntValue(index);
    280312
    281       for (int i = 0; i < index; i++) {
    282         processor.Operators.Add(new EmptyOperator());
     313      if (index > 0) {
     314        EmptyOperator eo = new EmptyOperator();
     315        for (int i = 0; i < index - 1; i++) {
     316          processor.Operators.Add(eo);
     317        }
    283318      }
    284319
    285320      VariableCreator variableCreator = new VariableCreator();
    286       variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("LocalIterations", new IntValue(0)));
    287       variableCreator.CollectedValues.Add(new ValueParameter<DoubleValue>("BestLocalQuality", new DoubleValue(0)));
     321      variableCreator.CollectedValues.Add(new ValueParameter<IntValue>(loop.IterationsParameter.ActualName, new IntValue(0)));
     322      variableCreator.CollectedValues.Add(new ValueParameter<DoubleValue>(loop.BestLocalQualityParameter.ActualName, new DoubleValue(0)));
    288323
    289324      variableCreator.Successor = loop;
    290 
    291       loop.EvaluatedMovesParameter.ActualName = EvaluatedSolutionsParameter.ActualName;
    292325
    293326      processor.Operators.Add(variableCreator);
    294327      processor.Successor = remover;
    295328
    296       IOperation next = base.Apply();
    297       if (next as ExecutionContext != null) {
    298         remover.Successor = (next as ExecutionContext).Operator;
    299       }
    300 
    301       return ExecutionContext.CreateChildOperation(processor);
     329      OperationCollection next = new OperationCollection(base.Apply());
     330      next.Insert(0, ExecutionContext.CreateChildOperation(processor));
     331
     332      return next;
    302333    }
    303334  }

  • trunk/sources/HeuristicLab.Algorithms.LocalSearch/3.3/LocalSearchMainLoop.cs

    r5753 r6042  
    4646      get { return (LookupParameter<DoubleValue>)Parameters["Quality"]; }
    4747    }
    48     public LookupParameter<DoubleValue> BestQualityParameter {
     48    public LookupParameter<DoubleValue> BestLocalQualityParameter {
    4949      get { return (LookupParameter<DoubleValue>)Parameters["BestLocalQuality"]; }
    5050    }
    … …  
    5656    }
    5757    public LookupParameter<IntValue> IterationsParameter {
    58       get { return (LookupParameter<IntValue>)Parameters["LocalIterations"]; }
     58      get { return (LookupParameter<IntValue>)Parameters["Iterations"]; }
    5959    }
    6060    public ValueLookupParameter<IntValue> MaximumIterationsParameter {
    … …  
    8585    public LocalSearchMainLoop()
    8686      : base() {
    87         Initialize();
     87      Initialize();
    8888    }
    8989    private LocalSearchMainLoop(LocalSearchMainLoop original, Cloner cloner)
    … …  
    100100      Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The value which represents the quality of a solution."));
    101101      Parameters.Add(new LookupParameter<DoubleValue>("BestLocalQuality", "The value which represents the best quality found so far."));
    102       Parameters.Add(new ValueLookupParameter<DoubleValue>("BestKnownQuality", "The best known quality value found so far."));
     102      Parameters.Add(new ValueLookupParameter<DoubleValue>("BestKnownQuality", "The problem's best known quality value found so far."));
    103103      Parameters.Add(new LookupParameter<DoubleValue>("MoveQuality", "The value which represents the quality of a move."));
    104       Parameters.Add(new LookupParameter<IntValue>("LocalIterations", "The number of generations."));
     104      Parameters.Add(new LookupParameter<IntValue>("Iterations", "The number of iterations performed."));
    105105      Parameters.Add(new ValueLookupParameter<IntValue>("MaximumIterations", "The maximum number of generations which should be processed."));
    106106      Parameters.Add(new ValueLookupParameter<VariableCollection>("Results", "The variable collection where results should be stored."));
    … …  
    140140
    141141      bestQualityInitializer.Name = "Initialize BestQuality";
    142       bestQualityInitializer.LeftSideParameter.ActualName = BestQualityParameter.Name;
     142      bestQualityInitializer.LeftSideParameter.ActualName = BestLocalQualityParameter.Name;
    143143      bestQualityInitializer.RightSideParameter.ActualName = QualityParameter.Name;
    144144
    … …  
    148148      resultsCollector1.CopyValue = new BoolValue(false);
    149149      resultsCollector1.CollectedValues.Add(new LookupParameter<IntValue>(IterationsParameter.Name));
    150       resultsCollector1.CollectedValues.Add(new LookupParameter<DoubleValue>(BestQualityParameter.Name, null, BestQualityParameter.Name));
     150      resultsCollector1.CollectedValues.Add(new LookupParameter<DoubleValue>(BestLocalQualityParameter.Name, null, BestLocalQualityParameter.Name));
    151151      resultsCollector1.ResultsParameter.ActualName = ResultsParameter.Name;
    152152
    … …  
    177177
    178178      bestQualityUpdater.Name = "Update BestQuality";
    179       bestQualityUpdater.LeftSideParameter.ActualName = BestQualityParameter.Name;
     179      bestQualityUpdater.LeftSideParameter.ActualName = BestLocalQualityParameter.Name;
    180180      bestQualityUpdater.RightSideParameter.ActualName = QualityParameter.Name;
    181181
    182182      resultsCollector2.CopyValue = new BoolValue(false);
    183       resultsCollector2.CollectedValues.Add(new LookupParameter<DoubleValue>(BestQualityParameter.Name, null, BestQualityParameter.Name));
     183      resultsCollector2.CollectedValues.Add(new LookupParameter<DoubleValue>(BestLocalQualityParameter.Name, null, BestLocalQualityParameter.Name));
    184184      resultsCollector2.ResultsParameter.ActualName = ResultsParameter.Name;
    185185
Note: See TracChangeset for help on using the changeset viewer.