Free cookie consent management tool by TermsFeed Policy Generator

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

Last change on this file since 4068 was 4068, checked in by swagner, 14 years ago

Sorted usings and removed unused usings in entire solution (#1094)
File size: 23.5 KB
Line 
1#region License Information
2/* HeuristicLab
3 * Copyright (C) 2002-2010 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.Optimization;
29using HeuristicLab.Optimization.Operators;
30using HeuristicLab.Parameters;
31using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
32using HeuristicLab.PluginInfrastructure;
33using HeuristicLab.Random;
34
35namespace HeuristicLab.Algorithms.OffspringSelectionGeneticAlgorithm {
36  /// <summary>
37  /// An offspring selection genetic algorithm.
38  /// </summary>
39  [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).")]
40  [Creatable("Algorithms")]
41  [StorableClass]
42  public sealed class OffspringSelectionGeneticAlgorithm : EngineAlgorithm {
43    #region Problem Properties
44    public override Type ProblemType {
45      get { return typeof(ISingleObjectiveProblem); }
46    }
47    public new ISingleObjectiveProblem Problem {
48      get { return (ISingleObjectiveProblem)base.Problem; }
49      set { base.Problem = value; }
50    }
51    #endregion
52
53    #region Parameter Properties
54    private ValueParameter<IntValue> SeedParameter {
55      get { return (ValueParameter<IntValue>)Parameters["Seed"]; }
56    }
57    private ValueParameter<BoolValue> SetSeedRandomlyParameter {
58      get { return (ValueParameter<BoolValue>)Parameters["SetSeedRandomly"]; }
59    }
60    private ValueParameter<IntValue> PopulationSizeParameter {
61      get { return (ValueParameter<IntValue>)Parameters["PopulationSize"]; }
62    }
63    private ConstrainedValueParameter<ISelector> SelectorParameter {
64      get { return (ConstrainedValueParameter<ISelector>)Parameters["Selector"]; }
65    }
66    private ConstrainedValueParameter<ICrossover> CrossoverParameter {
67      get { return (ConstrainedValueParameter<ICrossover>)Parameters["Crossover"]; }
68    }
69    private ValueParameter<PercentValue> MutationProbabilityParameter {
70      get { return (ValueParameter<PercentValue>)Parameters["MutationProbability"]; }
71    }
72    private OptionalConstrainedValueParameter<IManipulator> MutatorParameter {
73      get { return (OptionalConstrainedValueParameter<IManipulator>)Parameters["Mutator"]; }
74    }
75    private ValueParameter<IntValue> ElitesParameter {
76      get { return (ValueParameter<IntValue>)Parameters["Elites"]; }
77    }
78    private ValueParameter<IntValue> MaximumGenerationsParameter {
79      get { return (ValueParameter<IntValue>)Parameters["MaximumGenerations"]; }
80    }
81    private ValueLookupParameter<DoubleValue> SuccessRatioParameter {
82      get { return (ValueLookupParameter<DoubleValue>)Parameters["SuccessRatio"]; }
83    }
84    private ValueLookupParameter<DoubleValue> ComparisonFactorLowerBoundParameter {
85      get { return (ValueLookupParameter<DoubleValue>)Parameters["ComparisonFactorLowerBound"]; }
86    }
87    private ValueLookupParameter<DoubleValue> ComparisonFactorUpperBoundParameter {
88      get { return (ValueLookupParameter<DoubleValue>)Parameters["ComparisonFactorUpperBound"]; }
89    }
90    private OptionalConstrainedValueParameter<IDiscreteDoubleValueModifier> ComparisonFactorModifierParameter {
91      get { return (OptionalConstrainedValueParameter<IDiscreteDoubleValueModifier>)Parameters["ComparisonFactorModifier"]; }
92    }
93    private ValueLookupParameter<DoubleValue> MaximumSelectionPressureParameter {
94      get { return (ValueLookupParameter<DoubleValue>)Parameters["MaximumSelectionPressure"]; }
95    }
96    private ValueLookupParameter<BoolValue> OffspringSelectionBeforeMutationParameter {
97      get { return (ValueLookupParameter<BoolValue>)Parameters["OffspringSelectionBeforeMutation"]; }
98    }
99    private ValueLookupParameter<IntValue> SelectedParentsParameter {
100      get { return (ValueLookupParameter<IntValue>)Parameters["SelectedParents"]; }
101    }
102    private ValueParameter<MultiAnalyzer> AnalyzerParameter {
103      get { return (ValueParameter<MultiAnalyzer>)Parameters["Analyzer"]; }
104    }
105    private ValueParameter<IntValue> MaximumEvaluatedSolutionsParameter {
106      get { return (ValueParameter<IntValue>)Parameters["MaximumEvaluatedSolutions"]; }
107    }
108    #endregion
109
110    #region Properties
111    public IntValue Seed {
112      get { return SeedParameter.Value; }
113      set { SeedParameter.Value = value; }
114    }
115    public BoolValue SetSeedRandomly {
116      get { return SetSeedRandomlyParameter.Value; }
117      set { SetSeedRandomlyParameter.Value = value; }
118    }
119    public IntValue PopulationSize {
120      get { return PopulationSizeParameter.Value; }
121      set { PopulationSizeParameter.Value = value; }
122    }
123    public ISelector Selector {
124      get { return SelectorParameter.Value; }
125      set { SelectorParameter.Value = value; }
126    }
127    public ICrossover Crossover {
128      get { return CrossoverParameter.Value; }
129      set { CrossoverParameter.Value = value; }
130    }
131    public PercentValue MutationProbability {
132      get { return MutationProbabilityParameter.Value; }
133      set { MutationProbabilityParameter.Value = value; }
134    }
135    public IManipulator Mutator {
136      get { return MutatorParameter.Value; }
137      set { MutatorParameter.Value = value; }
138    }
139    public IntValue Elites {
140      get { return ElitesParameter.Value; }
141      set { ElitesParameter.Value = value; }
142    }
143    public IntValue MaximumGenerations {
144      get { return MaximumGenerationsParameter.Value; }
145      set { MaximumGenerationsParameter.Value = value; }
146    }
147    public DoubleValue SuccessRatio {
148      get { return SuccessRatioParameter.Value; }
149      set { SuccessRatioParameter.Value = value; }
150    }
151    public DoubleValue ComparisonFactorLowerBound {
152      get { return ComparisonFactorLowerBoundParameter.Value; }
153      set { ComparisonFactorLowerBoundParameter.Value = value; }
154    }
155    public DoubleValue ComparisonFactorUpperBound {
156      get { return ComparisonFactorUpperBoundParameter.Value; }
157      set { ComparisonFactorUpperBoundParameter.Value = value; }
158    }
159    public IDiscreteDoubleValueModifier ComparisonFactorModifier {
160      get { return ComparisonFactorModifierParameter.Value; }
161      set { ComparisonFactorModifierParameter.Value = value; }
162    }
163    public DoubleValue MaximumSelectionPressure {
164      get { return MaximumSelectionPressureParameter.Value; }
165      set { MaximumSelectionPressureParameter.Value = value; }
166    }
167    public BoolValue OffspringSelectionBeforeMutation {
168      get { return OffspringSelectionBeforeMutationParameter.Value; }
169      set { OffspringSelectionBeforeMutationParameter.Value = value; }
170    }
171    public IntValue SelectedParents {
172      get { return SelectedParentsParameter.Value; }
173      set { SelectedParentsParameter.Value = value; }
174    }
175    public MultiAnalyzer Analyzer {
176      get { return AnalyzerParameter.Value; }
177      set { AnalyzerParameter.Value = value; }
178    }
179    public IntValue MaximumEvaluatedSolutions {
180      get { return MaximumEvaluatedSolutionsParameter.Value; }
181      set { MaximumEvaluatedSolutionsParameter.Value = value; }
182    }
183    private RandomCreator RandomCreator {
184      get { return (RandomCreator)OperatorGraph.InitialOperator; }
185    }
186    private SolutionsCreator SolutionsCreator {
187      get { return (SolutionsCreator)RandomCreator.Successor; }
188    }
189    private OffspringSelectionGeneticAlgorithmMainLoop MainLoop {
190      get { return (OffspringSelectionGeneticAlgorithmMainLoop)SolutionsCreator.Successor; }
191    }
192    [Storable]
193    private BestAverageWorstQualityAnalyzer qualityAnalyzer;
194    [Storable]
195    private ValueAnalyzer selectionPressureAnalyzer;
196    #endregion
197
198    [StorableConstructor]
199    private OffspringSelectionGeneticAlgorithm(bool deserializing) : base(deserializing) { }
200    public OffspringSelectionGeneticAlgorithm()
201      : base() {
202      Parameters.Add(new ValueParameter<IntValue>("Seed", "The random seed used to initialize the new pseudo random number generator.", new IntValue(0)));
203      Parameters.Add(new ValueParameter<BoolValue>("SetSeedRandomly", "True if the random seed should be set to a random value, otherwise false.", new BoolValue(true)));
204      Parameters.Add(new ValueParameter<IntValue>("PopulationSize", "The size of the population of solutions.", new IntValue(100)));
205      Parameters.Add(new ConstrainedValueParameter<ISelector>("Selector", "The operator used to select solutions for reproduction."));
206      Parameters.Add(new ConstrainedValueParameter<ICrossover>("Crossover", "The operator used to cross solutions."));
207      Parameters.Add(new ValueParameter<PercentValue>("MutationProbability", "The probability that the mutation operator is applied on a solution.", new PercentValue(0.05)));
208      Parameters.Add(new OptionalConstrainedValueParameter<IManipulator>("Mutator", "The operator used to mutate solutions."));
209      Parameters.Add(new ValueParameter<IntValue>("Elites", "The numer of elite solutions which are kept in each generation.", new IntValue(1)));
210      Parameters.Add(new ValueParameter<IntValue>("MaximumGenerations", "The maximum number of generations which should be processed.", new IntValue(1000)));
211      Parameters.Add(new ValueLookupParameter<DoubleValue>("SuccessRatio", "The ratio of successful to total children that should be achieved.", new DoubleValue(1)));
212      Parameters.Add(new ValueLookupParameter<DoubleValue>("ComparisonFactorLowerBound", "The lower bound of the comparison factor (start).", new DoubleValue(0)));
213      Parameters.Add(new ValueLookupParameter<DoubleValue>("ComparisonFactorUpperBound", "The upper bound of the comparison factor (end).", new DoubleValue(1)));
214      Parameters.Add(new OptionalConstrainedValueParameter<IDiscreteDoubleValueModifier>("ComparisonFactorModifier", "The operator used to modify the comparison factor.", new ItemSet<IDiscreteDoubleValueModifier>(new IDiscreteDoubleValueModifier[] { new LinearDiscreteDoubleValueModifier() }), new LinearDiscreteDoubleValueModifier()));
215      Parameters.Add(new ValueLookupParameter<DoubleValue>("MaximumSelectionPressure", "The maximum selection pressure that terminates the algorithm.", new DoubleValue(100)));
216      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)));
217      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)));
218      Parameters.Add(new ValueParameter<MultiAnalyzer>("Analyzer", "The operator used to analyze each generation.", new MultiAnalyzer()));
219      Parameters.Add(new ValueParameter<IntValue>("MaximumEvaluatedSolutions", "The maximum number of evaluated solutions (approximately).", new IntValue(int.MaxValue)));
220
221      RandomCreator randomCreator = new RandomCreator();
222      SolutionsCreator solutionsCreator = new SolutionsCreator();
223      OffspringSelectionGeneticAlgorithmMainLoop mainLoop = new OffspringSelectionGeneticAlgorithmMainLoop();
224      OperatorGraph.InitialOperator = randomCreator;
225
226      randomCreator.RandomParameter.ActualName = "Random";
227      randomCreator.SeedParameter.ActualName = SeedParameter.Name;
228      randomCreator.SeedParameter.Value = null;
229      randomCreator.SetSeedRandomlyParameter.ActualName = SetSeedRandomlyParameter.Name;
230      randomCreator.SetSeedRandomlyParameter.Value = null;
231      randomCreator.Successor = solutionsCreator;
232
233      solutionsCreator.NumberOfSolutionsParameter.ActualName = PopulationSizeParameter.Name;
234      solutionsCreator.Successor = mainLoop;
235
236      mainLoop.AnalyzerParameter.ActualName = AnalyzerParameter.Name;
237      mainLoop.ComparisonFactorModifierParameter.ActualName = ComparisonFactorModifierParameter.Name;
238      mainLoop.ComparisonFactorParameter.ActualName = "ComparisonFactor";
239      mainLoop.ComparisonFactorStartParameter.ActualName = ComparisonFactorLowerBoundParameter.Name;
240      mainLoop.CrossoverParameter.ActualName = CrossoverParameter.Name;
241      mainLoop.ElitesParameter.ActualName = ElitesParameter.Name;
242      mainLoop.MaximumGenerationsParameter.ActualName = MaximumGenerationsParameter.Name;
243      mainLoop.MaximumSelectionPressureParameter.ActualName = MaximumSelectionPressureParameter.Name;
244      mainLoop.MutationProbabilityParameter.ActualName = MutationProbabilityParameter.Name;
245      mainLoop.MutatorParameter.ActualName = MutatorParameter.Name;
246      mainLoop.OffspringSelectionBeforeMutationParameter.ActualName = OffspringSelectionBeforeMutationParameter.Name;
247      mainLoop.RandomParameter.ActualName = RandomCreator.RandomParameter.ActualName;
248      mainLoop.ResultsParameter.ActualName = "Results";
249      mainLoop.SelectorParameter.ActualName = SelectorParameter.Name;
250      mainLoop.SuccessRatioParameter.ActualName = SuccessRatioParameter.Name;
251
252      foreach (ISelector selector in ApplicationManager.Manager.GetInstances<ISelector>().Where(x => !(x is IMultiObjectiveSelector)).OrderBy(x => x.Name))
253        SelectorParameter.ValidValues.Add(selector);
254      ISelector proportionalSelector = SelectorParameter.ValidValues.FirstOrDefault(x => x.GetType().Name.Equals("ProportionalSelector"));
255      if (proportionalSelector != null) SelectorParameter.Value = proportionalSelector;
256      ParameterizeSelectors();
257
258      foreach (IDiscreteDoubleValueModifier modifier in ApplicationManager.Manager.GetInstances<IDiscreteDoubleValueModifier>().OrderBy(x => x.Name))
259        ComparisonFactorModifierParameter.ValidValues.Add(modifier);
260      IDiscreteDoubleValueModifier linearModifier = ComparisonFactorModifierParameter.ValidValues.FirstOrDefault(x => x.GetType().Name.Equals("LinearDiscreteDoubleValueModifier"));
261      if (linearModifier != null) ComparisonFactorModifierParameter.Value = linearModifier;
262      ParameterizeComparisonFactorModifiers();
263
264      qualityAnalyzer = new BestAverageWorstQualityAnalyzer();
265      selectionPressureAnalyzer = new ValueAnalyzer();
266      ParameterizeAnalyzers();
267      UpdateAnalyzers();
268
269      Initialize();
270    }
271
272    public override IDeepCloneable Clone(Cloner cloner) {
273      OffspringSelectionGeneticAlgorithm clone = (OffspringSelectionGeneticAlgorithm)base.Clone(cloner);
274      clone.qualityAnalyzer = (BestAverageWorstQualityAnalyzer)cloner.Clone(qualityAnalyzer);
275      clone.selectionPressureAnalyzer = (ValueAnalyzer)cloner.Clone(selectionPressureAnalyzer);
276      clone.Initialize();
277      return clone;
278    }
279
280    public override void Prepare() {
281      if (Problem != null) base.Prepare();
282    }
283
284    #region Events
285    protected override void OnProblemChanged() {
286      ParameterizeStochasticOperator(Problem.SolutionCreator);
287      ParameterizeStochasticOperator(Problem.Evaluator);
288      foreach (IOperator op in Problem.Operators) ParameterizeStochasticOperator(op);
289      ParameterizeSolutionsCreator();
290      ParameterizMainLoop();
291      ParameterizeSelectors();
292      ParameterizeAnalyzers();
293      ParameterizeIterationBasedOperators();
294      UpdateCrossovers();
295      UpdateMutators();
296      UpdateAnalyzers();
297      Problem.Evaluator.QualityParameter.ActualNameChanged += new EventHandler(Evaluator_QualityParameter_ActualNameChanged);
298      base.OnProblemChanged();
299    }
300
301    protected override void Problem_SolutionCreatorChanged(object sender, EventArgs e) {
302      ParameterizeStochasticOperator(Problem.SolutionCreator);
303      ParameterizeSolutionsCreator();
304      base.Problem_SolutionCreatorChanged(sender, e);
305    }
306    protected override void Problem_EvaluatorChanged(object sender, EventArgs e) {
307      ParameterizeStochasticOperator(Problem.Evaluator);
308      ParameterizeSolutionsCreator();
309      ParameterizMainLoop();
310      ParameterizeSelectors();
311      ParameterizeAnalyzers();
312      Problem.Evaluator.QualityParameter.ActualNameChanged += new EventHandler(Evaluator_QualityParameter_ActualNameChanged);
313      base.Problem_EvaluatorChanged(sender, e);
314    }
315    protected override void Problem_OperatorsChanged(object sender, EventArgs e) {
316      foreach (IOperator op in Problem.Operators) ParameterizeStochasticOperator(op);
317      ParameterizeIterationBasedOperators();
318      UpdateCrossovers();
319      UpdateMutators();
320      UpdateAnalyzers();
321      base.Problem_OperatorsChanged(sender, e);
322    }
323    private void ElitesParameter_ValueChanged(object sender, EventArgs e) {
324      Elites.ValueChanged += new EventHandler(Elites_ValueChanged);
325      ParameterizeSelectors();
326    }
327    private void Elites_ValueChanged(object sender, EventArgs e) {
328      ParameterizeSelectors();
329    }
330    private void PopulationSizeParameter_ValueChanged(object sender, EventArgs e) {
331      PopulationSize.ValueChanged += new EventHandler(PopulationSize_ValueChanged);
332      ParameterizeSelectors();
333    }
334    private void PopulationSize_ValueChanged(object sender, EventArgs e) {
335      ParameterizeSelectors();
336    }
337    private void Evaluator_QualityParameter_ActualNameChanged(object sender, EventArgs e) {
338      ParameterizMainLoop();
339      ParameterizeSelectors();
340      ParameterizeAnalyzers();
341    }
342    #endregion
343
344    #region Helpers
345    [StorableHook(HookType.AfterDeserialization)]
346    private void Initialize() {
347      PopulationSizeParameter.ValueChanged += new EventHandler(PopulationSizeParameter_ValueChanged);
348      PopulationSize.ValueChanged += new EventHandler(PopulationSize_ValueChanged);
349      ElitesParameter.ValueChanged += new EventHandler(ElitesParameter_ValueChanged);
350      Elites.ValueChanged += new EventHandler(Elites_ValueChanged);
351      if (Problem != null) {
352        Problem.Evaluator.QualityParameter.ActualNameChanged += new EventHandler(Evaluator_QualityParameter_ActualNameChanged);
353      }
354    }
355    private void ParameterizeSolutionsCreator() {
356      SolutionsCreator.EvaluatorParameter.ActualName = Problem.EvaluatorParameter.Name;
357      SolutionsCreator.SolutionCreatorParameter.ActualName = Problem.SolutionCreatorParameter.Name;
358    }
359    private void ParameterizMainLoop() {
360      MainLoop.EvaluatorParameter.ActualName = Problem.EvaluatorParameter.Name;
361      MainLoop.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
362      MainLoop.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
363    }
364    private void ParameterizeStochasticOperator(IOperator op) {
365      if (op is IStochasticOperator)
366        ((IStochasticOperator)op).RandomParameter.ActualName = RandomCreator.RandomParameter.ActualName;
367    }
368    private void ParameterizeSelectors() {
369      foreach (ISelector selector in SelectorParameter.ValidValues) {
370        selector.CopySelected = new BoolValue(true);
371        selector.NumberOfSelectedSubScopesParameter.Value = null;
372        selector.NumberOfSelectedSubScopesParameter.ActualName = SelectedParentsParameter.Name;
373        ParameterizeStochasticOperator(selector);
374      }
375      if (Problem != null) {
376        foreach (ISingleObjectiveSelector selector in SelectorParameter.ValidValues.OfType<ISingleObjectiveSelector>()) {
377          selector.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
378          selector.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
379        }
380      }
381    }
382    private void ParameterizeAnalyzers() {
383      qualityAnalyzer.ResultsParameter.ActualName = "Results";
384      selectionPressureAnalyzer.Name = "SelectionPressure Analyzer";
385      selectionPressureAnalyzer.ResultsParameter.ActualName = "Results";
386      selectionPressureAnalyzer.ValueParameter.ActualName = "SelectionPressure";
387      selectionPressureAnalyzer.ValueParameter.Depth = 0;
388      selectionPressureAnalyzer.ValuesParameter.ActualName = "Selection Pressure History";
389      if (Problem != null) {
390        qualityAnalyzer.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
391        qualityAnalyzer.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
392        qualityAnalyzer.BestKnownQualityParameter.ActualName = Problem.BestKnownQualityParameter.Name;
393      }
394    }
395    private void ParameterizeComparisonFactorModifiers() {
396      foreach (IDiscreteDoubleValueModifier modifier in ComparisonFactorModifierParameter.ValidValues) {
397        modifier.IndexParameter.ActualName = "Generations";
398        modifier.EndIndexParameter.ActualName = MaximumGenerationsParameter.Name;
399        modifier.EndValueParameter.ActualName = ComparisonFactorUpperBoundParameter.Name;
400        modifier.StartIndexParameter.Value = new IntValue(0);
401        modifier.StartValueParameter.ActualName = ComparisonFactorLowerBoundParameter.Name;
402        modifier.ValueParameter.ActualName = "ComparisonFactor";
403      }
404    }
405    private void ParameterizeIterationBasedOperators() {
406      if (Problem != null) {
407        foreach (IIterationBasedOperator op in Problem.Operators.OfType<IIterationBasedOperator>()) {
408          op.IterationsParameter.ActualName = "Generations";
409          op.MaximumIterationsParameter.ActualName = MaximumGenerationsParameter.Name;
410        }
411      }
412    }
413    private void UpdateCrossovers() {
414      ICrossover oldCrossover = CrossoverParameter.Value;
415      CrossoverParameter.ValidValues.Clear();
416      foreach (ICrossover crossover in Problem.Operators.OfType<ICrossover>().OrderBy(x => x.Name))
417        CrossoverParameter.ValidValues.Add(crossover);
418      if (oldCrossover != null) {
419        ICrossover crossover = CrossoverParameter.ValidValues.FirstOrDefault(x => x.GetType() == oldCrossover.GetType());
420        if (crossover != null) CrossoverParameter.Value = crossover;
421      }
422    }
423    private void UpdateMutators() {
424      IManipulator oldMutator = MutatorParameter.Value;
425      MutatorParameter.ValidValues.Clear();
426      foreach (IManipulator mutator in Problem.Operators.OfType<IManipulator>().OrderBy(x => x.Name))
427        MutatorParameter.ValidValues.Add(mutator);
428      if (oldMutator != null) {
429        IManipulator mutator = MutatorParameter.ValidValues.FirstOrDefault(x => x.GetType() == oldMutator.GetType());
430        if (mutator != null) MutatorParameter.Value = mutator;
431      }
432    }
433    private void UpdateAnalyzers() {
434      Analyzer.Operators.Clear();
435      if (Problem != null) {
436        foreach (IAnalyzer analyzer in Problem.Operators.OfType<IAnalyzer>()) {
437          foreach (IScopeTreeLookupParameter param in analyzer.Parameters.OfType<IScopeTreeLookupParameter>())
438            param.Depth = 1;
439          Analyzer.Operators.Add(analyzer);
440        }
441      }
442      Analyzer.Operators.Add(qualityAnalyzer);
443      Analyzer.Operators.Add(selectionPressureAnalyzer);
444    }
445    #endregion
446  }
447}
Note: See TracBrowser for help on using the repository browser.