Changeset 10142 for branches/DataAnalysis.IslandAlgorithms/HeuristicLab.Algorithms.OffspringSelectionGeneticAlgorithm/3.3/IslandOffspringSelectionGeneticAlgorithm.cs

Timestamp:

11/20/13 10:52:38 (10 years ago)

Author:

mkommend

Message:

#1997: Worked on symbolic data analysis island algorithms:

• Refactored and removed unnecessary code in symbolic island GA and symbolic island GA evaluator.
• Added EnumerableItem to ease the passing of rows to the actual evaluator.
• Added prototype of island offspring selection GA.
• Corrected build configuration (plugin classes, project settings, ...)

File:

• branches/DataAnalysis.IslandAlgorithms/HeuristicLab.Algorithms.OffspringSelectionGeneticAlgorithm/3.3/IslandOffspringSelectionGeneticAlgorithm.cs (modified) (19 diffs)

branches/DataAnalysis.IslandAlgorithms/HeuristicLab.Algorithms.OffspringSelectionGeneticAlgorithm/3.3/IslandOffspringSelectionGeneticAlgorithm.cs

@@ -41 +41 @@
   [Creatable("Algorithms")]
   [StorableClass]
-  public sealed class IslandOffspringSelectionGeneticAlgorithm : HeuristicOptimizationEngineAlgorithm, IStorableContent {
+  public class IslandOffspringSelectionGeneticAlgorithm : HeuristicOptimizationEngineAlgorithm, IStorableContent {
     public string Filename { get; set; }
 
@@ -55 +55 @@
 
     #region Parameter Properties
-    private ValueParameter<IntValue> SeedParameter {
+    protected ValueParameter<IntValue> SeedParameter {
       get { return (ValueParameter<IntValue>)Parameters["Seed"]; }
     }
-    private ValueParameter<BoolValue> SetSeedRandomlyParameter {
+    protected ValueParameter<BoolValue> SetSeedRandomlyParameter {
       get { return (ValueParameter<BoolValue>)Parameters["SetSeedRandomly"]; }
     }
-    private ValueParameter<IntValue> NumberOfIslandsParameter {
+    protected ValueParameter<IntValue> NumberOfIslandsParameter {
       get { return (ValueParameter<IntValue>)Parameters["NumberOfIslands"]; }
     }
-    private ValueParameter<IntValue> MigrationIntervalParameter {
+    protected ValueParameter<IntValue> MigrationIntervalParameter {
       get { return (ValueParameter<IntValue>)Parameters["MigrationInterval"]; }
     }
-    private ValueParameter<PercentValue> MigrationRateParameter {
+    protected ValueParameter<PercentValue> MigrationRateParameter {
       get { return (ValueParameter<PercentValue>)Parameters["MigrationRate"]; }
     }
@@ -79 +79 @@
       get { return (IConstrainedValueParameter<IReplacer>)Parameters["ImmigrationReplacer"]; }
     }
-    private ValueParameter<IntValue> PopulationSizeParameter {
+    protected ValueParameter<IntValue> PopulationSizeParameter {
       get { return (ValueParameter<IntValue>)Parameters["PopulationSize"]; }
     }
-    private ValueParameter<IntValue> MaximumGenerationsParameter {
+    protected ValueParameter<IntValue> MaximumGenerationsParameter {
       get { return (ValueParameter<IntValue>)Parameters["MaximumGenerations"]; }
     }
@@ -91 +91 @@
       get { return (IConstrainedValueParameter<ICrossover>)Parameters["Crossover"]; }
     }
-    private ValueParameter<PercentValue> MutationProbabilityParameter {
+    protected ValueParameter<PercentValue> MutationProbabilityParameter {
       get { return (ValueParameter<PercentValue>)Parameters["MutationProbability"]; }
     }
@@ -97 +97 @@
       get { return (IConstrainedValueParameter<IManipulator>)Parameters["Mutator"]; }
     }
-    private ValueParameter<IntValue> ElitesParameter {
+    protected ValueParameter<IntValue> ElitesParameter {
       get { return (ValueParameter<IntValue>)Parameters["Elites"]; }
     }
-    private IFixedValueParameter<BoolValue> ReevaluateElitesParameter {
+    protected IFixedValueParameter<BoolValue> ReevaluateElitesParameter {
       get { return (IFixedValueParameter<BoolValue>)Parameters["ReevaluateElites"]; }
     }
-    private ValueLookupParameter<DoubleValue> SuccessRatioParameter {
+    protected ValueLookupParameter<DoubleValue> SuccessRatioParameter {
       get { return (ValueLookupParameter<DoubleValue>)Parameters["SuccessRatio"]; }
     }
-    private ValueLookupParameter<DoubleValue> ComparisonFactorLowerBoundParameter {
+    protected ValueLookupParameter<DoubleValue> ComparisonFactorLowerBoundParameter {
       get { return (ValueLookupParameter<DoubleValue>)Parameters["ComparisonFactorLowerBound"]; }
     }
-    private ValueLookupParameter<DoubleValue> ComparisonFactorUpperBoundParameter {
+    protected ValueLookupParameter<DoubleValue> ComparisonFactorUpperBoundParameter {
       get { return (ValueLookupParameter<DoubleValue>)Parameters["ComparisonFactorUpperBound"]; }
     }
@@ -115 +115 @@
       get { return (IConstrainedValueParameter<IDiscreteDoubleValueModifier>)Parameters["ComparisonFactorModifier"]; }
     }
-    private ValueLookupParameter<DoubleValue> MaximumSelectionPressureParameter {
+    protected ValueLookupParameter<DoubleValue> MaximumSelectionPressureParameter {
       get { return (ValueLookupParameter<DoubleValue>)Parameters["MaximumSelectionPressure"]; }
     }
-    private ValueLookupParameter<BoolValue> OffspringSelectionBeforeMutationParameter {
+    protected ValueLookupParameter<BoolValue> OffspringSelectionBeforeMutationParameter {
       get { return (ValueLookupParameter<BoolValue>)Parameters["OffspringSelectionBeforeMutation"]; }
     }
-    private ValueLookupParameter<IntValue> SelectedParentsParameter {
+    protected ValueLookupParameter<IntValue> SelectedParentsParameter {
       get { return (ValueLookupParameter<IntValue>)Parameters["SelectedParents"]; }
     }
-    private ValueParameter<MultiAnalyzer> AnalyzerParameter {
+    protected ValueParameter<MultiAnalyzer> AnalyzerParameter {
       get { return (ValueParameter<MultiAnalyzer>)Parameters["Analyzer"]; }
     }
-    private ValueParameter<MultiAnalyzer> IslandAnalyzerParameter {
+    protected ValueParameter<MultiAnalyzer> IslandAnalyzerParameter {
       get { return (ValueParameter<MultiAnalyzer>)Parameters["IslandAnalyzer"]; }
     }
-    private ValueParameter<IntValue> MaximumEvaluatedSolutionsParameter {
+    protected ValueParameter<IntValue> MaximumEvaluatedSolutionsParameter {
       get { return (ValueParameter<IntValue>)Parameters["MaximumEvaluatedSolutions"]; }
     }
@@ -236 +236 @@
       set { MaximumEvaluatedSolutionsParameter.Value = value; }
     }
-    private RandomCreator RandomCreator {
+    protected RandomCreator RandomCreator {
       get { return (RandomCreator)OperatorGraph.InitialOperator; }
     }
-    private UniformSubScopesProcessor IslandProcessor {
+    protected UniformSubScopesProcessor IslandProcessor {
       get { return ((RandomCreator.Successor as SubScopesCreator).Successor as UniformSubScopesProcessor); }
     }
-    private SolutionsCreator SolutionsCreator {
+    protected SolutionsCreator SolutionsCreator {
       get { return (SolutionsCreator)IslandProcessor.Operator; }
     }
-    private IslandOffspringSelectionGeneticAlgorithmMainLoop MainLoop {
+    protected IslandOffspringSelectionGeneticAlgorithmMainLoop MainLoop {
       get { return FindMainLoop(IslandProcessor.Successor); }
     }
@@ -261 +261 @@
 
     [StorableConstructor]
-    private IslandOffspringSelectionGeneticAlgorithm(bool deserializing) : base(deserializing) { }
+    protected IslandOffspringSelectionGeneticAlgorithm(bool deserializing) : base(deserializing) { }
     [StorableHook(HookType.AfterDeserialization)]
     private void AfterDeserialization() {
@@ -275 +275 @@
       Initialize();
     }
-    private IslandOffspringSelectionGeneticAlgorithm(IslandOffspringSelectionGeneticAlgorithm original, Cloner cloner)
+    protected IslandOffspringSelectionGeneticAlgorithm(IslandOffspringSelectionGeneticAlgorithm original, Cloner cloner)
       : base(original, cloner) {
       islandQualityAnalyzer = cloner.Clone(original.islandQualityAnalyzer);
@@ -456 +456 @@
       base.Problem_OperatorsChanged(sender, e);
     }
-    private void ElitesParameter_ValueChanged(object sender, EventArgs e) {
+    protected virtual void ElitesParameter_ValueChanged(object sender, EventArgs e) {
       Elites.ValueChanged += new EventHandler(Elites_ValueChanged);
       ParameterizeSelectors();
     }
-    private void Elites_ValueChanged(object sender, EventArgs e) {
-      ParameterizeSelectors();
-    }
-    private void PopulationSizeParameter_ValueChanged(object sender, EventArgs e) {
+    protected virtual void Elites_ValueChanged(object sender, EventArgs e) {
+      ParameterizeSelectors();
+    }
+    protected virtual void PopulationSizeParameter_ValueChanged(object sender, EventArgs e) {
       NumberOfIslands.ValueChanged += new EventHandler(PopulationSize_ValueChanged);
       ParameterizeSelectors();
     }
-    private void PopulationSize_ValueChanged(object sender, EventArgs e) {
+    protected virtual void PopulationSize_ValueChanged(object sender, EventArgs e) {
       ParameterizeSelectors();
     }
@@ -475 +475 @@
       ParameterizeAnalyzers();
     }
-    private void MigrationRateParameter_ValueChanged(object sender, EventArgs e) {
+    protected virtual void MigrationRateParameter_ValueChanged(object sender, EventArgs e) {
       MigrationRate.ValueChanged += new EventHandler(MigrationRate_ValueChanged);
       ParameterizeSelectors();
     }
-    private void MigrationRate_ValueChanged(object sender, EventArgs e) {
-      ParameterizeSelectors();
-    }
-    private void MaximumMigrationsParameter_ValueChanged(object sender, EventArgs e) {
+    protected virtual void MigrationRate_ValueChanged(object sender, EventArgs e) {
+      ParameterizeSelectors();
+    }
+    protected virtual void MaximumMigrationsParameter_ValueChanged(object sender, EventArgs e) {
       MaximumGenerations.ValueChanged += new EventHandler(MaximumMigrations_ValueChanged);
       ParameterizeComparisonFactorModifiers();
     }
-    private void MaximumMigrations_ValueChanged(object sender, EventArgs e) {
+    protected virtual void MaximumMigrations_ValueChanged(object sender, EventArgs e) {
       ParameterizeComparisonFactorModifiers();
     }
-    private void MigrationIntervalParameter_ValueChanged(object sender, EventArgs e) {
+    protected virtual void MigrationIntervalParameter_ValueChanged(object sender, EventArgs e) {
       MigrationInterval.ValueChanged += new EventHandler(MigrationInterval_ValueChanged);
       ParameterizeComparisonFactorModifiers();
     }
-    private void MigrationInterval_ValueChanged(object sender, EventArgs e) {
+    protected virtual void MigrationInterval_ValueChanged(object sender, EventArgs e) {
       ParameterizeComparisonFactorModifiers();
     }
@@ -514 +514 @@
       }
     }
-    private void ParameterizeSolutionsCreator() {
+    protected virtual void ParameterizeSolutionsCreator() {
       SolutionsCreator.EvaluatorParameter.ActualName = Problem.EvaluatorParameter.Name;
       SolutionsCreator.SolutionCreatorParameter.ActualName = Problem.SolutionCreatorParameter.Name;
     }
-    private void ParameterizeMainLoop() {
+    protected virtual void ParameterizeMainLoop() {
       MainLoop.BestKnownQualityParameter.ActualName = Problem.BestKnownQualityParameter.Name;
       MainLoop.EvaluatorParameter.ActualName = Problem.EvaluatorParameter.Name;
@@ -524 +524 @@
       MainLoop.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
     }
-    private void ParameterizeStochasticOperator(IOperator op) {
+    protected virtual void ParameterizeStochasticOperator(IOperator op) {
       if (op is IStochasticOperator)
         ((IStochasticOperator)op).RandomParameter.ActualName = RandomCreator.RandomParameter.ActualName;
     }
-    private void ParameterizeSelectors() {
+    protected virtual void ParameterizeSelectors() {
       foreach (ISelector selector in SelectorParameter.ValidValues) {
         selector.CopySelected = new BoolValue(true);
@@ -558 +558 @@
       }
     }
-    private void ParameterizeAnalyzers() {
+    protected virtual void ParameterizeAnalyzers() {
       islandQualityAnalyzer.ResultsParameter.ActualName = "Results";
       islandQualityAnalyzer.QualityParameter.Depth = 1;
@@ -591 +591 @@
       }
     }
-    private void ParameterizeComparisonFactorModifiers() {
+    protected virtual void ParameterizeComparisonFactorModifiers() {
       foreach (IDiscreteDoubleValueModifier modifier in ComparisonFactorModifierParameter.ValidValues) {
         modifier.IndexParameter.ActualName = "Generations";
@@ -601 +601 @@
       }
     }
-    private void ParameterizeIterationBasedOperators() {
+    protected virtual void ParameterizeIterationBasedOperators() {
       if (Problem != null) {
         foreach (IIterationBasedOperator op in Problem.Operators.OfType<IIterationBasedOperator>()) {
@@ -609 +609 @@
       }
     }
-    private void UpdateCrossovers() {
+    protected virtual void UpdateCrossovers() {
       ICrossover oldCrossover = CrossoverParameter.Value;
       ICrossover defaultCrossover = Problem.Operators.OfType<ICrossover>().FirstOrDefault();
@@ -623 +623 @@
         CrossoverParameter.Value = defaultCrossover;
     }
-    private void UpdateMutators() {
+    protected virtual void UpdateMutators() {
       IManipulator oldMutator = MutatorParameter.Value;
       MutatorParameter.ValidValues.Clear();
@@ -649 +649 @@
       Analyzer.Operators.Add(successfulOffspringAnalyzer, successfulOffspringAnalyzer.EnabledByDefault);
     }
-    private IslandOffspringSelectionGeneticAlgorithmMainLoop FindMainLoop(IOperator start) {
+    protected virtual IslandOffspringSelectionGeneticAlgorithmMainLoop FindMainLoop(IOperator start) {
       IOperator mainLoop = start;
       while (mainLoop != null && !(mainLoop is IslandOffspringSelectionGeneticAlgorithmMainLoop))