Free cookie consent management tool by TermsFeed Policy Generator

source: branches/TerminationCriteria/HeuristicLab.Algorithms.OffspringSelectionGeneticAlgorithm/3.3/OffspringSelectionGeneticAlgorithm.cs @ 12410

Last change on this file since 12410 was 12410, checked in by pfleck, 9 years ago

#2027

  • Added IThresholdTerminator interface for more flexibility. The ThresholdTerminatorView now uses the interface instead of a concrete terminator.
  • Added MaximumIterationsTerminator and SingleObjectiveQualityTerminator as common used Terminators.
File size: 32.1 KB
Line 
1#region License Information
2/* HeuristicLab
3 * Copyright (C) 2002-2015 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;
23using System.Linq;
24using HeuristicLab.Analysis;
25using HeuristicLab.Common;
26using HeuristicLab.Core;
27using HeuristicLab.Data;
28using HeuristicLab.Operators;
29using HeuristicLab.Optimization;
30using HeuristicLab.Optimization.Operators;
31using HeuristicLab.Parameters;
32using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
33using HeuristicLab.PluginInfrastructure;
34using HeuristicLab.Random;
35using HeuristicLab.Termination;
36
37namespace HeuristicLab.Algorithms.OffspringSelectionGeneticAlgorithm {
38  /// <summary>
39  /// An offspring selection genetic algorithm.
40  /// </summary>
41  [Item("Offspring Selection Genetic Algorithm", "An offspring selection genetic algorithm (Affenzeller, M. et al. 2009. Genetic Algorithms and Genetic Programming - Modern Concepts and Practical Applications. CRC Press).")]
42  [Creatable("Algorithms")]
43  [StorableClass]
44  public sealed class OffspringSelectionGeneticAlgorithm : HeuristicOptimizationEngineAlgorithm, IStorableContent {
45    public string Filename { get; set; }
46
47    #region Problem Properties
48    public override Type ProblemType {
49      get { return typeof(ISingleObjectiveHeuristicOptimizationProblem); }
50    }
51    public new ISingleObjectiveHeuristicOptimizationProblem Problem {
52      get { return (ISingleObjectiveHeuristicOptimizationProblem)base.Problem; }
53      set { base.Problem = value; }
54    }
55    #endregion
56
57    #region Parameter Properties
58    private ValueParameter<IntValue> SeedParameter {
59      get { return (ValueParameter<IntValue>)Parameters["Seed"]; }
60    }
61    private ValueParameter<BoolValue> SetSeedRandomlyParameter {
62      get { return (ValueParameter<BoolValue>)Parameters["SetSeedRandomly"]; }
63    }
64    private ValueParameter<IntValue> PopulationSizeParameter {
65      get { return (ValueParameter<IntValue>)Parameters["PopulationSize"]; }
66    }
67    public IConstrainedValueParameter<ISelector> SelectorParameter {
68      get { return (IConstrainedValueParameter<ISelector>)Parameters["Selector"]; }
69    }
70    public IConstrainedValueParameter<ICrossover> CrossoverParameter {
71      get { return (IConstrainedValueParameter<ICrossover>)Parameters["Crossover"]; }
72    }
73    private ValueParameter<PercentValue> MutationProbabilityParameter {
74      get { return (ValueParameter<PercentValue>)Parameters["MutationProbability"]; }
75    }
76    public IConstrainedValueParameter<IManipulator> MutatorParameter {
77      get { return (IConstrainedValueParameter<IManipulator>)Parameters["Mutator"]; }
78    }
79    private ValueParameter<IntValue> ElitesParameter {
80      get { return (ValueParameter<IntValue>)Parameters["Elites"]; }
81    }
82    private IFixedValueParameter<BoolValue> ReevaluateElitesParameter {
83      get { return (IFixedValueParameter<BoolValue>)Parameters["ReevaluateElites"]; }
84    }
85    private IFixedValueParameter<IntValue> MaximumGenerationsParameter {
86      get { return (IFixedValueParameter<IntValue>)Parameters["MaximumGenerations"]; }
87    }
88    private ValueLookupParameter<DoubleValue> SuccessRatioParameter {
89      get { return (ValueLookupParameter<DoubleValue>)Parameters["SuccessRatio"]; }
90    }
91    private ValueLookupParameter<DoubleValue> ComparisonFactorLowerBoundParameter {
92      get { return (ValueLookupParameter<DoubleValue>)Parameters["ComparisonFactorLowerBound"]; }
93    }
94    private ValueLookupParameter<DoubleValue> ComparisonFactorUpperBoundParameter {
95      get { return (ValueLookupParameter<DoubleValue>)Parameters["ComparisonFactorUpperBound"]; }
96    }
97    public IConstrainedValueParameter<IDiscreteDoubleValueModifier> ComparisonFactorModifierParameter {
98      get { return (IConstrainedValueParameter<IDiscreteDoubleValueModifier>)Parameters["ComparisonFactorModifier"]; }
99    }
100    private ValueLookupParameter<DoubleValue> MaximumSelectionPressureParameter {
101      get { return (ValueLookupParameter<DoubleValue>)Parameters["MaximumSelectionPressure"]; }
102    }
103    private ValueLookupParameter<BoolValue> OffspringSelectionBeforeMutationParameter {
104      get { return (ValueLookupParameter<BoolValue>)Parameters["OffspringSelectionBeforeMutation"]; }
105    }
106    private ValueLookupParameter<IntValue> SelectedParentsParameter {
107      get { return (ValueLookupParameter<IntValue>)Parameters["SelectedParents"]; }
108    }
109    private ValueParameter<MultiAnalyzer> AnalyzerParameter {
110      get { return (ValueParameter<MultiAnalyzer>)Parameters["Analyzer"]; }
111    }
112    private ValueParameter<IntValue> MaximumEvaluatedSolutionsParameter {
113      get { return (ValueParameter<IntValue>)Parameters["MaximumEvaluatedSolutions"]; }
114    }
115    private IFixedValueParameter<BoolValue> FillPopulationWithParentsParameter {
116      get { return (IFixedValueParameter<BoolValue>)Parameters["FillPopulationWithParents"]; }
117    }
118    private IValueParameter<MultiTerminator> TerminationParameter {
119      get { return (IValueParameter<MultiTerminator>)Parameters["Termination"]; }
120    }
121    #endregion
122
123    #region Properties
124    public IntValue Seed {
125      get { return SeedParameter.Value; }
126      set { SeedParameter.Value = value; }
127    }
128    public BoolValue SetSeedRandomly {
129      get { return SetSeedRandomlyParameter.Value; }
130      set { SetSeedRandomlyParameter.Value = value; }
131    }
132    public IntValue PopulationSize {
133      get { return PopulationSizeParameter.Value; }
134      set { PopulationSizeParameter.Value = value; }
135    }
136    public ISelector Selector {
137      get { return SelectorParameter.Value; }
138      set { SelectorParameter.Value = value; }
139    }
140    public ICrossover Crossover {
141      get { return CrossoverParameter.Value; }
142      set { CrossoverParameter.Value = value; }
143    }
144    public PercentValue MutationProbability {
145      get { return MutationProbabilityParameter.Value; }
146      set { MutationProbabilityParameter.Value = value; }
147    }
148    public IManipulator Mutator {
149      get { return MutatorParameter.Value; }
150      set { MutatorParameter.Value = value; }
151    }
152    public IntValue Elites {
153      get { return ElitesParameter.Value; }
154      set { ElitesParameter.Value = value; }
155    }
156    public bool ReevaluteElites {
157      get { return ReevaluateElitesParameter.Value.Value; }
158      set { ReevaluateElitesParameter.Value.Value = value; }
159    }
160    public int MaximumGenerations {
161      get { return MaximumGenerationsParameter.Value.Value; }
162      set { MaximumGenerationsParameter.Value.Value = value; }
163    }
164    public DoubleValue SuccessRatio {
165      get { return SuccessRatioParameter.Value; }
166      set { SuccessRatioParameter.Value = value; }
167    }
168    public DoubleValue ComparisonFactorLowerBound {
169      get { return ComparisonFactorLowerBoundParameter.Value; }
170      set { ComparisonFactorLowerBoundParameter.Value = value; }
171    }
172    public DoubleValue ComparisonFactorUpperBound {
173      get { return ComparisonFactorUpperBoundParameter.Value; }
174      set { ComparisonFactorUpperBoundParameter.Value = value; }
175    }
176    public IDiscreteDoubleValueModifier ComparisonFactorModifier {
177      get { return ComparisonFactorModifierParameter.Value; }
178      set { ComparisonFactorModifierParameter.Value = value; }
179    }
180    public DoubleValue MaximumSelectionPressure {
181      get { return MaximumSelectionPressureParameter.Value; }
182      set { MaximumSelectionPressureParameter.Value = value; }
183    }
184    public BoolValue OffspringSelectionBeforeMutation {
185      get { return OffspringSelectionBeforeMutationParameter.Value; }
186      set { OffspringSelectionBeforeMutationParameter.Value = value; }
187    }
188    public IntValue SelectedParents {
189      get { return SelectedParentsParameter.Value; }
190      set { SelectedParentsParameter.Value = value; }
191    }
192    public MultiAnalyzer Analyzer {
193      get { return AnalyzerParameter.Value; }
194      set { AnalyzerParameter.Value = value; }
195    }
196    public IntValue MaximumEvaluatedSolutions {
197      get { return MaximumEvaluatedSolutionsParameter.Value; }
198      set { MaximumEvaluatedSolutionsParameter.Value = value; }
199    }
200    public bool FillPopulationWithParents {
201      get { return FillPopulationWithParentsParameter.Value.Value; }
202      set { FillPopulationWithParentsParameter.Value.Value = value; }
203    }
204    private MultiTerminator Terminators {
205      get { return TerminationParameter.Value; }
206    }
207    private RandomCreator RandomCreator {
208      get { return (RandomCreator)OperatorGraph.InitialOperator; }
209    }
210    private SolutionsCreator SolutionsCreator {
211      get { return (SolutionsCreator)RandomCreator.Successor; }
212    }
213    private OffspringSelectionGeneticAlgorithmMainLoop MainLoop {
214      get { return FindMainLoop(SolutionsCreator.Successor); }
215    }
216    [Storable]
217    private BestAverageWorstQualityAnalyzer qualityAnalyzer;
218    [Storable]
219    private ValueAnalyzer selectionPressureAnalyzer;
220    [Storable]
221    private SuccessfulOffspringAnalyzer successfulOffspringAnalyzer;
222    [Storable]
223    private MaximumIterationsTerminator generationsTerminator;
224    [Storable]
225    private ComparisonTerminator<IntValue> evaluatedSolutionsTerminator;
226    [Storable]
227    private ComparisonTerminator<DoubleValue> selectionPressureTerminator;
228    [Storable]
229    private SingleObjectiveQualityTerminator qualityTerminator;
230    [Storable]
231    private ExecutionTimeTerminator executionTimeTerminator;
232    #endregion
233
234    [StorableConstructor]
235    private OffspringSelectionGeneticAlgorithm(bool deserializing) : base(deserializing) { }
236    [StorableHook(HookType.AfterDeserialization)]
237    private void AfterDeserialization() {
238      // BackwardsCompatibility3.3
239      #region Backwards compatible code, remove with 3.4
240      if (successfulOffspringAnalyzer == null)
241        successfulOffspringAnalyzer = new SuccessfulOffspringAnalyzer();
242      if (!Parameters.ContainsKey("ReevaluateElites")) {
243        Parameters.Add(new FixedValueParameter<BoolValue>("ReevaluateElites", "Flag to determine if elite individuals should be reevaluated (i.e., if stochastic fitness functions are used.)", (BoolValue)new BoolValue(false).AsReadOnly()) { Hidden = true });
244      }
245      if (!Parameters.ContainsKey("FillPopulationWithParents"))
246        Parameters.Add(new FixedValueParameter<BoolValue>("FillPopulationWithParents", "True if the population should be filled with parent individual or false if worse children should be used when the maximum selection pressure is exceeded.", new BoolValue(false)) { Hidden = true });
247      #endregion
248
249      Initialize();
250    }
251    private OffspringSelectionGeneticAlgorithm(OffspringSelectionGeneticAlgorithm original, Cloner cloner)
252      : base(original, cloner) {
253      qualityAnalyzer = cloner.Clone(original.qualityAnalyzer);
254      selectionPressureAnalyzer = cloner.Clone(original.selectionPressureAnalyzer);
255      successfulOffspringAnalyzer = cloner.Clone(original.successfulOffspringAnalyzer);
256      generationsTerminator = cloner.Clone(original.generationsTerminator);
257      evaluatedSolutionsTerminator = cloner.Clone(original.evaluatedSolutionsTerminator);
258      selectionPressureTerminator = cloner.Clone(original.selectionPressureTerminator);
259      qualityTerminator = cloner.Clone(original.qualityTerminator);
260      executionTimeTerminator = cloner.Clone(original.executionTimeTerminator);
261      Initialize();
262    }
263    public override IDeepCloneable Clone(Cloner cloner) {
264      return new OffspringSelectionGeneticAlgorithm(this, cloner);
265    }
266    public OffspringSelectionGeneticAlgorithm()
267      : base() {
268      Parameters.Add(new ValueParameter<IntValue>("Seed", "The random seed used to initialize the new pseudo random number generator.", new IntValue(0)));
269      Parameters.Add(new ValueParameter<BoolValue>("SetSeedRandomly", "True if the random seed should be set to a random value, otherwise false.", new BoolValue(true)));
270      Parameters.Add(new ValueParameter<IntValue>("PopulationSize", "The size of the population of solutions.", new IntValue(100)));
271      Parameters.Add(new ConstrainedValueParameter<ISelector>("Selector", "The operator used to select solutions for reproduction."));
272      Parameters.Add(new ConstrainedValueParameter<ICrossover>("Crossover", "The operator used to cross solutions."));
273      Parameters.Add(new ValueParameter<PercentValue>("MutationProbability", "The probability that the mutation operator is applied on a solution.", new PercentValue(0.05)));
274      Parameters.Add(new OptionalConstrainedValueParameter<IManipulator>("Mutator", "The operator used to mutate solutions."));
275      Parameters.Add(new ValueParameter<IntValue>("Elites", "The numer of elite solutions which are kept in each generation.", new IntValue(1)));
276      Parameters.Add(new FixedValueParameter<BoolValue>("ReevaluateElites", "Flag to determine if elite individuals should be reevaluated (i.e., if stochastic fitness functions are used.)", new BoolValue(false)) { Hidden = true });
277      Parameters.Add(new FixedValueParameter<IntValue>("MaximumGenerations", "The maximum number of generations which should be processed.", new IntValue(1000)));
278      Parameters.Add(new ValueLookupParameter<DoubleValue>("SuccessRatio", "The ratio of successful to total children that should be achieved.", new DoubleValue(1)));
279      Parameters.Add(new ValueLookupParameter<DoubleValue>("ComparisonFactorLowerBound", "The lower bound of the comparison factor (start).", new DoubleValue(0)));
280      Parameters.Add(new ValueLookupParameter<DoubleValue>("ComparisonFactorUpperBound", "The upper bound of the comparison factor (end).", new DoubleValue(1)));
281      Parameters.Add(new OptionalConstrainedValueParameter<IDiscreteDoubleValueModifier>("ComparisonFactorModifier", "The operator used to modify the comparison factor.", new ItemSet<IDiscreteDoubleValueModifier>(new IDiscreteDoubleValueModifier[] { new LinearDiscreteDoubleValueModifier() }), new LinearDiscreteDoubleValueModifier()));
282      Parameters.Add(new ValueLookupParameter<DoubleValue>("MaximumSelectionPressure", "The maximum selection pressure that terminates the algorithm.", new DoubleValue(100)));
283      Parameters.Add(new ValueLookupParameter<BoolValue>("OffspringSelectionBeforeMutation", "True if the offspring selection step should be applied before mutation, false if it should be applied after mutation.", new BoolValue(false)));
284      Parameters.Add(new ValueLookupParameter<IntValue>("SelectedParents", "How much parents should be selected each time the offspring selection step is performed until the population is filled. This parameter should be about the same or twice the size of PopulationSize for smaller problems, and less for large problems.", new IntValue(200)));
285      Parameters.Add(new ValueParameter<MultiAnalyzer>("Analyzer", "The operator used to analyze each generation.", new MultiAnalyzer()));
286      Parameters.Add(new ValueParameter<IntValue>("MaximumEvaluatedSolutions", "The maximum number of evaluated solutions (approximately).", new IntValue(int.MaxValue)));
287      Parameters.Add(new FixedValueParameter<BoolValue>("FillPopulationWithParents", "True if the population should be filled with parent individual or false if worse children should be used when the maximum selection pressure is exceeded.", new BoolValue(false)) { Hidden = true });
288      Parameters.Add(new ValueParameter<MultiTerminator>("Termination", "The termination criteria which sould be checked.", new MultiTerminator()));
289
290      RandomCreator randomCreator = new RandomCreator();
291      SolutionsCreator solutionsCreator = new SolutionsCreator();
292      SubScopesCounter subScopesCounter = new SubScopesCounter();
293      ResultsCollector resultsCollector = new ResultsCollector();
294      OffspringSelectionGeneticAlgorithmMainLoop mainLoop = new OffspringSelectionGeneticAlgorithmMainLoop();
295      OperatorGraph.InitialOperator = randomCreator;
296
297      randomCreator.RandomParameter.ActualName = "Random";
298      randomCreator.SeedParameter.ActualName = SeedParameter.Name;
299      randomCreator.SeedParameter.Value = null;
300      randomCreator.SetSeedRandomlyParameter.ActualName = SetSeedRandomlyParameter.Name;
301      randomCreator.SetSeedRandomlyParameter.Value = null;
302      randomCreator.Successor = solutionsCreator;
303
304      solutionsCreator.NumberOfSolutionsParameter.ActualName = PopulationSizeParameter.Name;
305      solutionsCreator.Successor = subScopesCounter;
306
307      subScopesCounter.Name = "Initialize EvaluatedSolutions";
308      subScopesCounter.ValueParameter.ActualName = "EvaluatedSolutions";
309      subScopesCounter.Successor = resultsCollector;
310
311      resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("Evaluated Solutions", "", "EvaluatedSolutions"));
312      resultsCollector.ResultsParameter.ActualName = "Results";
313      resultsCollector.Successor = mainLoop;
314
315      mainLoop.AnalyzerParameter.ActualName = AnalyzerParameter.Name;
316      mainLoop.ComparisonFactorModifierParameter.ActualName = ComparisonFactorModifierParameter.Name;
317      mainLoop.ComparisonFactorParameter.ActualName = "ComparisonFactor";
318      mainLoop.ComparisonFactorStartParameter.ActualName = ComparisonFactorLowerBoundParameter.Name;
319      mainLoop.CrossoverParameter.ActualName = CrossoverParameter.Name;
320      mainLoop.ElitesParameter.ActualName = ElitesParameter.Name;
321      mainLoop.ReevaluateElitesParameter.ActualName = ReevaluateElitesParameter.Name;
322      mainLoop.EvaluatedSolutionsParameter.ActualName = "EvaluatedSolutions";
323      mainLoop.MaximumGenerationsParameter.ActualName = MaximumGenerationsParameter.Name;
324      mainLoop.MaximumSelectionPressureParameter.ActualName = MaximumSelectionPressureParameter.Name;
325      mainLoop.MutationProbabilityParameter.ActualName = MutationProbabilityParameter.Name;
326      mainLoop.MutatorParameter.ActualName = MutatorParameter.Name;
327      mainLoop.OffspringSelectionBeforeMutationParameter.ActualName = OffspringSelectionBeforeMutationParameter.Name;
328      mainLoop.RandomParameter.ActualName = RandomCreator.RandomParameter.ActualName;
329      mainLoop.ResultsParameter.ActualName = "Results";
330      mainLoop.SelectorParameter.ActualName = SelectorParameter.Name;
331      mainLoop.SuccessRatioParameter.ActualName = SuccessRatioParameter.Name;
332      mainLoop.FillPopulationWithParentsParameter.ActualName = FillPopulationWithParentsParameter.Name;
333
334      foreach (ISelector selector in ApplicationManager.Manager.GetInstances<ISelector>().Where(x => !(x is IMultiObjectiveSelector)).OrderBy(x => x.Name))
335        SelectorParameter.ValidValues.Add(selector);
336      ISelector proportionalSelector = SelectorParameter.ValidValues.FirstOrDefault(x => x.GetType().Name.Equals("ProportionalSelector"));
337      if (proportionalSelector != null) SelectorParameter.Value = proportionalSelector;
338      ParameterizeSelectors();
339
340      qualityAnalyzer = new BestAverageWorstQualityAnalyzer();
341      selectionPressureAnalyzer = new ValueAnalyzer();
342      successfulOffspringAnalyzer = new SuccessfulOffspringAnalyzer();
343      ParameterizeAnalyzers();
344      UpdateAnalyzers();
345
346      generationsTerminator = new MaximumIterationsTerminator();
347      evaluatedSolutionsTerminator = new ComparisonTerminator<IntValue>("EvaluatedSolutions", ComparisonType.Less, new IntValue(int.MaxValue)) { Name = "Evaluations" };
348      selectionPressureTerminator = new ComparisonTerminator<DoubleValue>("SelectionPressure", ComparisonType.Less, new DoubleValue(200)) { Name = "Selection Pressure" };
349      qualityTerminator = new SingleObjectiveQualityTerminator();
350      executionTimeTerminator = new ExecutionTimeTerminator(this, new TimeSpanValue(TimeSpan.FromMinutes(5))) { Name = "Execution Time" };
351      ParameterizeTerminators();
352      UpdateTerminators();
353
354      foreach (IDiscreteDoubleValueModifier modifier in ApplicationManager.Manager.GetInstances<IDiscreteDoubleValueModifier>().OrderBy(x => x.Name))
355        ComparisonFactorModifierParameter.ValidValues.Add(modifier);
356      IDiscreteDoubleValueModifier linearModifier = ComparisonFactorModifierParameter.ValidValues.FirstOrDefault(x => x.GetType().Name.Equals("LinearDiscreteDoubleValueModifier"));
357      if (linearModifier != null) ComparisonFactorModifierParameter.Value = linearModifier;
358      ParameterizeComparisonFactorModifiers();
359
360      Initialize();
361    }
362
363
364
365    public override void Prepare() {
366      if (Problem != null) base.Prepare();
367    }
368
369    #region Events
370    protected override void OnProblemChanged() {
371      ParameterizeStochasticOperator(Problem.SolutionCreator);
372      ParameterizeStochasticOperator(Problem.Evaluator);
373      foreach (IOperator op in Problem.Operators.OfType<IOperator>()) ParameterizeStochasticOperator(op);
374      ParameterizeSolutionsCreator();
375      ParameterizMainLoop();
376      ParameterizeSelectors();
377      ParameterizeAnalyzers();
378      ParameterizeTerminators();
379      ParameterizeIterationBasedOperators();
380      UpdateCrossovers();
381      UpdateMutators();
382      UpdateAnalyzers();
383      UpdateTerminators();
384      Problem.Evaluator.QualityParameter.ActualNameChanged += new EventHandler(Evaluator_QualityParameter_ActualNameChanged);
385      base.OnProblemChanged();
386    }
387
388    protected override void RegisterProblemEvents() {
389      base.RegisterProblemEvents();
390      var maximizationParameter = (IValueParameter<BoolValue>)Problem.MaximizationParameter;
391      if (maximizationParameter != null) maximizationParameter.ValueChanged += new EventHandler(MaximizationParameter_ValueChanged);
392    }
393    protected override void DeregisterProblemEvents() {
394      var maximizationParameter = (IValueParameter<BoolValue>)Problem.MaximizationParameter;
395      if (maximizationParameter != null) maximizationParameter.ValueChanged -= new EventHandler(MaximizationParameter_ValueChanged);
396      base.DeregisterProblemEvents();
397    }
398
399    protected override void Problem_SolutionCreatorChanged(object sender, EventArgs e) {
400      ParameterizeStochasticOperator(Problem.SolutionCreator);
401      ParameterizeSolutionsCreator();
402      base.Problem_SolutionCreatorChanged(sender, e);
403    }
404    protected override void Problem_EvaluatorChanged(object sender, EventArgs e) {
405      ParameterizeStochasticOperator(Problem.Evaluator);
406      ParameterizeSolutionsCreator();
407      ParameterizMainLoop();
408      ParameterizeSelectors();
409      ParameterizeAnalyzers();
410      Problem.Evaluator.QualityParameter.ActualNameChanged += new EventHandler(Evaluator_QualityParameter_ActualNameChanged);
411      base.Problem_EvaluatorChanged(sender, e);
412    }
413    protected override void Problem_OperatorsChanged(object sender, EventArgs e) {
414      foreach (IOperator op in Problem.Operators.OfType<IOperator>()) ParameterizeStochasticOperator(op);
415      ParameterizeIterationBasedOperators();
416      UpdateCrossovers();
417      UpdateMutators();
418      UpdateAnalyzers();
419      UpdateTerminators();
420      base.Problem_OperatorsChanged(sender, e);
421    }
422    private void ElitesParameter_ValueChanged(object sender, EventArgs e) {
423      Elites.ValueChanged += new EventHandler(Elites_ValueChanged);
424      ParameterizeSelectors();
425    }
426    private void Elites_ValueChanged(object sender, EventArgs e) {
427      ParameterizeSelectors();
428    }
429    private void PopulationSizeParameter_ValueChanged(object sender, EventArgs e) {
430      PopulationSize.ValueChanged += new EventHandler(PopulationSize_ValueChanged);
431      ParameterizeSelectors();
432    }
433    private void PopulationSize_ValueChanged(object sender, EventArgs e) {
434      ParameterizeSelectors();
435    }
436    private void Evaluator_QualityParameter_ActualNameChanged(object sender, EventArgs e) {
437      ParameterizMainLoop();
438      ParameterizeSelectors();
439      ParameterizeAnalyzers();
440    }
441    private void MaximizationParameter_ValueChanged(object sender, EventArgs e) {
442      ParameterizeTerminators();
443    }
444    private void QualityAnalyzer_CurrentBestQualityParameter_NameChanged(object sender, EventArgs e) {
445      ParameterizeTerminators();
446    }
447    #endregion
448
449    #region Helpers
450    private void Initialize() {
451      PopulationSizeParameter.ValueChanged += new EventHandler(PopulationSizeParameter_ValueChanged);
452      PopulationSize.ValueChanged += new EventHandler(PopulationSize_ValueChanged);
453      ElitesParameter.ValueChanged += new EventHandler(ElitesParameter_ValueChanged);
454      Elites.ValueChanged += new EventHandler(Elites_ValueChanged);
455      qualityAnalyzer.CurrentBestQualityParameter.NameChanged += new EventHandler(QualityAnalyzer_CurrentBestQualityParameter_NameChanged);
456      if (Problem != null) {
457        Problem.Evaluator.QualityParameter.ActualNameChanged += new EventHandler(Evaluator_QualityParameter_ActualNameChanged);
458      }
459    }
460    private void ParameterizeSolutionsCreator() {
461      SolutionsCreator.EvaluatorParameter.ActualName = Problem.EvaluatorParameter.Name;
462      SolutionsCreator.SolutionCreatorParameter.ActualName = Problem.SolutionCreatorParameter.Name;
463    }
464    private void ParameterizMainLoop() {
465      MainLoop.EvaluatorParameter.ActualName = Problem.EvaluatorParameter.Name;
466      MainLoop.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
467      MainLoop.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
468    }
469    private void ParameterizeStochasticOperator(IOperator op) {
470      if (op is IStochasticOperator)
471        ((IStochasticOperator)op).RandomParameter.ActualName = RandomCreator.RandomParameter.ActualName;
472    }
473    private void ParameterizeSelectors() {
474      foreach (ISelector selector in SelectorParameter.ValidValues) {
475        selector.CopySelected = new BoolValue(true);
476        selector.NumberOfSelectedSubScopesParameter.Value = null;
477        selector.NumberOfSelectedSubScopesParameter.ActualName = SelectedParentsParameter.Name;
478        ParameterizeStochasticOperator(selector);
479      }
480      if (Problem != null) {
481        foreach (ISingleObjectiveSelector selector in SelectorParameter.ValidValues.OfType<ISingleObjectiveSelector>()) {
482          selector.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
483          selector.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
484        }
485      }
486    }
487    private void ParameterizeAnalyzers() {
488      qualityAnalyzer.ResultsParameter.ActualName = "Results";
489      selectionPressureAnalyzer.Name = "SelectionPressure Analyzer";
490      selectionPressureAnalyzer.ResultsParameter.ActualName = "Results";
491      selectionPressureAnalyzer.ValueParameter.ActualName = "SelectionPressure";
492      selectionPressureAnalyzer.ValueParameter.Depth = 0;
493      selectionPressureAnalyzer.ValuesParameter.ActualName = "Selection Pressure History";
494      successfulOffspringAnalyzer.ResultsParameter.ActualName = "Results";
495      successfulOffspringAnalyzer.GenerationsParameter.ActualName = "Generations";
496      successfulOffspringAnalyzer.SuccessfulOffspringFlagParameter.Value.Value = "SuccessfulOffspring";
497      successfulOffspringAnalyzer.DepthParameter.Value = new IntValue(1);
498      if (Problem != null) {
499        qualityAnalyzer.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
500        qualityAnalyzer.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
501        qualityAnalyzer.BestKnownQualityParameter.ActualName = Problem.BestKnownQualityParameter.Name;
502      }
503    }
504    private void ParameterizeTerminators() {
505      generationsTerminator.IterationsParameter.ActualName = "Generations";
506      generationsTerminator.MaximumIterationsParameter = MaximumGenerationsParameter;
507
508      qualityTerminator.Parameterize(qualityAnalyzer.CurrentBestQualityParameter, Problem);
509    }
510    private void ParameterizeComparisonFactorModifiers() {
511      foreach (IDiscreteDoubleValueModifier modifier in ComparisonFactorModifierParameter.ValidValues) {
512        modifier.IndexParameter.ActualName = "Generations";
513        modifier.EndIndexParameter.ActualName = MaximumGenerationsParameter.Name;
514        modifier.EndValueParameter.ActualName = ComparisonFactorUpperBoundParameter.Name;
515        modifier.StartIndexParameter.Value = new IntValue(0);
516        modifier.StartValueParameter.ActualName = ComparisonFactorLowerBoundParameter.Name;
517        modifier.ValueParameter.ActualName = "ComparisonFactor";
518      }
519    }
520    private void ParameterizeIterationBasedOperators() {
521      if (Problem != null) {
522        foreach (IIterationBasedOperator op in Problem.Operators.OfType<IIterationBasedOperator>()) {
523          op.IterationsParameter.ActualName = "Generations";
524          op.MaximumIterationsParameter.ActualName = MaximumGenerationsParameter.Name;
525        }
526      }
527    }
528    private void UpdateCrossovers() {
529      ICrossover oldCrossover = CrossoverParameter.Value;
530      CrossoverParameter.ValidValues.Clear();
531      ICrossover defaultCrossover = Problem.Operators.OfType<ICrossover>().FirstOrDefault();
532
533      foreach (ICrossover crossover in Problem.Operators.OfType<ICrossover>().OrderBy(x => x.Name))
534        CrossoverParameter.ValidValues.Add(crossover);
535
536      if (oldCrossover != null) {
537        ICrossover crossover = CrossoverParameter.ValidValues.FirstOrDefault(x => x.GetType() == oldCrossover.GetType());
538        if (crossover != null) CrossoverParameter.Value = crossover;
539        else oldCrossover = null;
540      }
541      if (oldCrossover == null && defaultCrossover != null)
542        CrossoverParameter.Value = defaultCrossover;
543    }
544    private void UpdateMutators() {
545      IManipulator oldMutator = MutatorParameter.Value;
546      MutatorParameter.ValidValues.Clear();
547      foreach (IManipulator mutator in Problem.Operators.OfType<IManipulator>().OrderBy(x => x.Name))
548        MutatorParameter.ValidValues.Add(mutator);
549      if (oldMutator != null) {
550        IManipulator mutator = MutatorParameter.ValidValues.FirstOrDefault(x => x.GetType() == oldMutator.GetType());
551        if (mutator != null) MutatorParameter.Value = mutator;
552      }
553    }
554    private void UpdateAnalyzers() {
555      Analyzer.Operators.Clear();
556      if (Problem != null) {
557        foreach (IAnalyzer analyzer in Problem.Operators.OfType<IAnalyzer>()) {
558          foreach (IScopeTreeLookupParameter param in analyzer.Parameters.OfType<IScopeTreeLookupParameter>())
559            param.Depth = 1;
560          Analyzer.Operators.Add(analyzer, analyzer.EnabledByDefault);
561        }
562      }
563      Analyzer.Operators.Add(qualityAnalyzer, qualityAnalyzer.EnabledByDefault);
564      Analyzer.Operators.Add(selectionPressureAnalyzer, selectionPressureAnalyzer.EnabledByDefault);
565      Analyzer.Operators.Add(successfulOffspringAnalyzer, successfulOffspringAnalyzer.EnabledByDefault);
566    }
567    private void UpdateTerminators() {
568      // ToDo restore checked state
569      Terminators.Operators.Clear();
570      if (Problem != null) {
571        foreach (var terminator in Problem.Operators.OfType<ITerminator>())
572          Terminators.Operators.Add(terminator);
573      }
574      Terminators.Operators.Add(generationsTerminator);
575      Terminators.Operators.Add(evaluatedSolutionsTerminator);
576      Terminators.Operators.Add(selectionPressureTerminator);
577      Terminators.Operators.Add(qualityTerminator, checkedState: false);
578      Terminators.Operators.Add(executionTimeTerminator, checkedState: false);
579    }
580    private OffspringSelectionGeneticAlgorithmMainLoop FindMainLoop(IOperator start) {
581      IOperator mainLoop = start;
582      while (mainLoop != null && !(mainLoop is OffspringSelectionGeneticAlgorithmMainLoop))
583        mainLoop = ((SingleSuccessorOperator)mainLoop).Successor;
584      if (mainLoop == null) return null;
585      else return (OffspringSelectionGeneticAlgorithmMainLoop)mainLoop;
586    }
587    #endregion
588  }
589}
Note: See TracBrowser for help on using the repository browser.