Free cookie consent management tool by TermsFeed Policy Generator

source: trunk/sources/HeuristicLab.Algorithms.OffspringSelectionGeneticAlgorithm/3.3/SASEGASA.cs @ 9569

Last change on this file since 9569 was 9569, checked in by mkommend, 11 years ago

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