Free cookie consent management tool by TermsFeed Policy Generator

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

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

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