Changeset 7172 for trunk/sources/HeuristicLab.Algorithms.OffspringSelectionGeneticAlgorithm

Timestamp:

12/12/11 03:39:04 (13 years ago)

Author:

swagner

Message:

Disabled run-time intensive analyzers by default (#1584)

Location:

trunk/sources/HeuristicLab.Algorithms.OffspringSelectionGeneticAlgorithm/3.3

Files:

• IslandOffspringSelectionGeneticAlgorithm.cs (modified) (2 diffs)
• OffspringSelectionGeneticAlgorithm.cs (modified) (2 diffs)
• SASEGASA.cs (modified) (1 diff)
• SuccessfulOffspringAnalysis/SuccessfulOffspringAnalyzer.cs (modified) (6 diffs)

trunk/sources/HeuristicLab.Algorithms.OffspringSelectionGeneticAlgorithm/3.3/IslandOffspringSelectionGeneticAlgorithm.cs ¶

@@ -261 +261 @@
         successfulOffspringAnalyzer = new SuccessfulOffspringAnalyzer();
       #endregion
-      
+
       Initialize();
     }
@@ -619 +619 @@
       IslandAnalyzer.Operators.Clear();
       Analyzer.Operators.Clear();
-      IslandAnalyzer.Operators.Add(islandQualityAnalyzer);
-      IslandAnalyzer.Operators.Add(islandSelectionPressureAnalyzer);
+      IslandAnalyzer.Operators.Add(islandQualityAnalyzer, islandQualityAnalyzer.EnabledByDefault);
+      IslandAnalyzer.Operators.Add(islandSelectionPressureAnalyzer, islandSelectionPressureAnalyzer.EnabledByDefault);
       if (Problem != null) {
         foreach (IAnalyzer analyzer in Problem.Operators.OfType<IAnalyzer>()) {
           foreach (IScopeTreeLookupParameter param in analyzer.Parameters.OfType<IScopeTreeLookupParameter>())
             param.Depth = 2;
-          Analyzer.Operators.Add(analyzer);
+          Analyzer.Operators.Add(analyzer, analyzer.EnabledByDefault);
         }
       }
-      Analyzer.Operators.Add(qualityAnalyzer);
-      Analyzer.Operators.Add(selectionPressureAnalyzer);
-      Analyzer.Operators.Add(successfulOffspringAnalyzer);
-      Analyzer.Operators.SetItemCheckedState(successfulOffspringAnalyzer, false);
+      Analyzer.Operators.Add(qualityAnalyzer, qualityAnalyzer.EnabledByDefault);
+      Analyzer.Operators.Add(selectionPressureAnalyzer, selectionPressureAnalyzer.EnabledByDefault);
+      Analyzer.Operators.Add(successfulOffspringAnalyzer, successfulOffspringAnalyzer.EnabledByDefault);
     }
     private IslandOffspringSelectionGeneticAlgorithmMainLoop FindMainLoop(IOperator start) {

trunk/sources/HeuristicLab.Algorithms.OffspringSelectionGeneticAlgorithm/3.3/OffspringSelectionGeneticAlgorithm.cs ¶

@@ -209 +209 @@
         successfulOffspringAnalyzer = new SuccessfulOffspringAnalyzer();
       #endregion
-      
+
       Initialize();
     }
@@ -470 +470 @@
           foreach (IScopeTreeLookupParameter param in analyzer.Parameters.OfType<IScopeTreeLookupParameter>())
             param.Depth = 1;
-          Analyzer.Operators.Add(analyzer);
+          Analyzer.Operators.Add(analyzer, analyzer.EnabledByDefault);
         }
       }
-      Analyzer.Operators.Add(qualityAnalyzer);
-      Analyzer.Operators.Add(selectionPressureAnalyzer);
-      Analyzer.Operators.Add(successfulOffspringAnalyzer);
-      Analyzer.Operators.SetItemCheckedState(successfulOffspringAnalyzer, false);
+      Analyzer.Operators.Add(qualityAnalyzer, qualityAnalyzer.EnabledByDefault);
+      Analyzer.Operators.Add(selectionPressureAnalyzer, selectionPressureAnalyzer.EnabledByDefault);
+      Analyzer.Operators.Add(successfulOffspringAnalyzer, successfulOffspringAnalyzer.EnabledByDefault);
     }
     private OffspringSelectionGeneticAlgorithmMainLoop FindMainLoop(IOperator start) {

trunk/sources/HeuristicLab.Algorithms.OffspringSelectionGeneticAlgorithm/3.3/SASEGASA.cs ¶

@@ -557 +557 @@
       VillageAnalyzer.Operators.Clear();
       Analyzer.Operators.Clear();
-      VillageAnalyzer.Operators.Add(villageQualityAnalyzer);
-      VillageAnalyzer.Operators.Add(villageSelectionPressureAnalyzer);
+      VillageAnalyzer.Operators.Add(villageQualityAnalyzer, villageQualityAnalyzer.EnabledByDefault);
+      VillageAnalyzer.Operators.Add(villageSelectionPressureAnalyzer, villageSelectionPressureAnalyzer.EnabledByDefault);
       if (Problem != null) {
         foreach (IAnalyzer analyzer in Problem.Operators.OfType<IAnalyzer>()) {
           foreach (IScopeTreeLookupParameter param in analyzer.Parameters.OfType<IScopeTreeLookupParameter>())
             param.Depth = 2;
-          Analyzer.Operators.Add(analyzer);
+          Analyzer.Operators.Add(analyzer, analyzer.EnabledByDefault);
         }
       }
-      Analyzer.Operators.Add(qualityAnalyzer);
-      Analyzer.Operators.Add(selectionPressureAnalyzer);
-      Analyzer.Operators.Add(successfulOffspringAnalyzer);
-      Analyzer.Operators.SetItemCheckedState(successfulOffspringAnalyzer, false);
+      Analyzer.Operators.Add(qualityAnalyzer, qualityAnalyzer.EnabledByDefault);
+      Analyzer.Operators.Add(selectionPressureAnalyzer, selectionPressureAnalyzer.EnabledByDefault);
+      Analyzer.Operators.Add(successfulOffspringAnalyzer, successfulOffspringAnalyzer.EnabledByDefault);
     }
     private SASEGASAMainLoop FindMainLoop(IOperator start) {

trunk/sources/HeuristicLab.Algorithms.OffspringSelectionGeneticAlgorithm/3.3/SuccessfulOffspringAnalysis/SuccessfulOffspringAnalyzer.cs ¶

@@ -23 +23 @@
 using System.Collections.Generic;
 using System.Linq;
-using System.Text;
+using HeuristicLab.Analysis;
+using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Data;
 using HeuristicLab.Operators;
 using HeuristicLab.Optimization;
-using HeuristicLab.Common;
 using HeuristicLab.Parameters;
-using HeuristicLab.Data;
-using HeuristicLab.Analysis;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
 namespace HeuristicLab.Algorithms.OffspringSelectionGeneticAlgorithm {
@@ -40 +39 @@
   [StorableClass]
   public sealed class SuccessfulOffspringAnalyzer : SingleSuccessorOperator, IAnalyzer {
+    public bool EnabledByDefault {
+      get { return false; }
+    }
+
     public ValueParameter<StringValue> SuccessfulOffspringFlagParameter {
       get { return (ValueParameter<StringValue>)Parameters["SuccessfulOffspringFlag"]; }
@@ -53 +56 @@
 
     public LookupParameter<ResultCollection> SuccessfulOffspringAnalysisParameter {
-      get { return (LookupParameter<ResultCollection>)Parameters["SuccessfulOffspringAnalysis"];  }
+      get { return (LookupParameter<ResultCollection>)Parameters["SuccessfulOffspringAnalysis"]; }
     }
 
@@ -63 +66 @@
       get { return (ValueParameter<IntValue>)Parameters["Depth"]; }
     }
-    
+
     public override IDeepCloneable Clone(Cloner cloner) {
       return new SuccessfulOffspringAnalyzer(this, cloner);
-    }    
+    }
     [StorableConstructor]
     private SuccessfulOffspringAnalyzer(bool deserializing) : base(deserializing) { }
@@ -72 +75 @@
     public SuccessfulOffspringAnalyzer()
       : base() {
-        Parameters.Add(new ValueParameter<StringValue>("SuccessfulOffspringFlag", "The name of the flag which indicates if the individual was successful.", new StringValue("SuccessfulOffspring")));
-        Parameters.Add(new ValueParameter<ItemCollection<StringValue>>("CollectedValues", "The properties of the successful offspring that should be collected.", new ItemCollection<StringValue>()));
-        Parameters.Add(new ValueLookupParameter<ResultCollection>("Results", "The result collection where the succedd progress analysis results should be stored."));
-        Parameters.Add(new LookupParameter<IntValue>("Generations", "The current number of generations."));  
-        Parameters.Add(new LookupParameter<ResultCollection>("SuccessfulOffspringAnalysis", "The successful offspring analysis which is created."));
-        Parameters.Add(new ValueParameter<IntValue>("Depth", "The depth of the individuals in the scope tree.", new IntValue(1)));
+      Parameters.Add(new ValueParameter<StringValue>("SuccessfulOffspringFlag", "The name of the flag which indicates if the individual was successful.", new StringValue("SuccessfulOffspring")));
+      Parameters.Add(new ValueParameter<ItemCollection<StringValue>>("CollectedValues", "The properties of the successful offspring that should be collected.", new ItemCollection<StringValue>()));
+      Parameters.Add(new ValueLookupParameter<ResultCollection>("Results", "The result collection where the succedd progress analysis results should be stored."));
+      Parameters.Add(new LookupParameter<IntValue>("Generations", "The current number of generations."));
+      Parameters.Add(new LookupParameter<ResultCollection>("SuccessfulOffspringAnalysis", "The successful offspring analysis which is created."));
+      Parameters.Add(new ValueParameter<IntValue>("Depth", "The depth of the individuals in the scope tree.", new IntValue(1)));
     }
 
@@ -88 +91 @@
 
       ItemCollection<StringValue> collectedValues = CollectedValuesParameter.Value;
-        foreach (StringValue collected in collectedValues) {
-          //collect the values of the successful offspring
-          Dictionary<String, int> counts = new Dictionary<String, int>();
-          for (int i = 0; i < scopes.Count; i++) {
-            IScope child = scopes[i];
-            string successfulOffspringFlag = SuccessfulOffspringFlagParameter.Value.Value;
-            if (child.Variables.ContainsKey(collected.Value) && 
-                child.Variables.ContainsKey(successfulOffspringFlag) && 
-                (child.Variables[successfulOffspringFlag].Value is BoolValue) &&
-                (child.Variables[successfulOffspringFlag].Value as BoolValue).Value) {
-              String key = child.Variables[collected.Value].Value.ToString();
+      foreach (StringValue collected in collectedValues) {
+        //collect the values of the successful offspring
+        Dictionary<String, int> counts = new Dictionary<String, int>();
+        for (int i = 0; i < scopes.Count; i++) {
+          IScope child = scopes[i];
+          string successfulOffspringFlag = SuccessfulOffspringFlagParameter.Value.Value;
+          if (child.Variables.ContainsKey(collected.Value) &&
+              child.Variables.ContainsKey(successfulOffspringFlag) &&
+              (child.Variables[successfulOffspringFlag].Value is BoolValue) &&
+              (child.Variables[successfulOffspringFlag].Value as BoolValue).Value) {
+            String key = child.Variables[collected.Value].Value.ToString();
 
-              if (!counts.ContainsKey(key))
-                counts.Add(key, 1);
-              else
-                counts[key]++;
-            }
+            if (!counts.ContainsKey(key))
+              counts.Add(key, 1);
+            else
+              counts[key]++;
+          }
+        }
+
+        //create a data table containing the collected values
+        ResultCollection successfulOffspringAnalysis;
+
+        if (SuccessfulOffspringAnalysisParameter.ActualValue == null) {
+          successfulOffspringAnalysis = new ResultCollection();
+          SuccessfulOffspringAnalysisParameter.ActualValue = successfulOffspringAnalysis;
+        } else {
+          successfulOffspringAnalysis = SuccessfulOffspringAnalysisParameter.ActualValue;
+        }
+
+        string resultKey = "SuccessfulOffspringAnalyzer Results";
+        if (!results.ContainsKey(resultKey)) {
+          results.Add(new Result(resultKey, successfulOffspringAnalysis));
+        } else {
+          results[resultKey].Value = successfulOffspringAnalysis;
+        }
+
+        DataTable successProgressAnalysis;
+        if (!successfulOffspringAnalysis.ContainsKey(collected.Value)) {
+          successProgressAnalysis = new DataTable();
+          successProgressAnalysis.Name = collected.Value;
+          successfulOffspringAnalysis.Add(new Result(collected.Value, successProgressAnalysis));
+        } else {
+          successProgressAnalysis = successfulOffspringAnalysis[collected.Value].Value as DataTable;
+        }
+
+        int successfulCount = 0;
+        foreach (string key in counts.Keys) {
+          successfulCount += counts[key];
+        }
+
+        foreach (String value in counts.Keys) {
+          DataRow row;
+          if (!successProgressAnalysis.Rows.ContainsKey(value)) {
+            row = new DataRow(value);
+            int iterations = GenerationsParameter.ActualValue.Value;
+
+            //fill up all values seen the first time
+            for (int i = 1; i < iterations; i++)
+              row.Values.Add(0);
+
+            successProgressAnalysis.Rows.Add(row);
+          } else {
+            row = successProgressAnalysis.Rows[value];
           }
 
-          //create a data table containing the collected values
-          ResultCollection successfulOffspringAnalysis;
+          row.Values.Add(counts[value] / (double)successfulCount);
+        }
 
-          if (SuccessfulOffspringAnalysisParameter.ActualValue == null) {
-            successfulOffspringAnalysis = new ResultCollection();
-            SuccessfulOffspringAnalysisParameter.ActualValue = successfulOffspringAnalysis;
-          } else {
-            successfulOffspringAnalysis = SuccessfulOffspringAnalysisParameter.ActualValue;
-          }
-
-          string resultKey = "SuccessfulOffspringAnalyzer Results";
-          if (!results.ContainsKey(resultKey)) {
-            results.Add(new Result(resultKey, successfulOffspringAnalysis));
-          } else {
-            results[resultKey].Value = successfulOffspringAnalysis;
-          }              
-
-          DataTable successProgressAnalysis;
-          if (!successfulOffspringAnalysis.ContainsKey(collected.Value)) {
-            successProgressAnalysis = new DataTable();
-            successProgressAnalysis.Name = collected.Value;
-            successfulOffspringAnalysis.Add(new Result(collected.Value, successProgressAnalysis));
-          } else {
-            successProgressAnalysis = successfulOffspringAnalysis[collected.Value].Value as DataTable;
-          }          
-
-          int successfulCount = 0;
-          foreach (string key in counts.Keys) {
-            successfulCount += counts[key];
-          }
-
-          foreach(String value in counts.Keys) {            
-            DataRow row;
-            if (!successProgressAnalysis.Rows.ContainsKey(value)) {
-              row = new DataRow(value);
-              int iterations = GenerationsParameter.ActualValue.Value;
-
-              //fill up all values seen the first time
-              for (int i = 1; i < iterations; i++)
-                row.Values.Add(0);
-
-              successProgressAnalysis.Rows.Add(row);
-            } else {
-              row = successProgressAnalysis.Rows[value];
-            }
-
-            row.Values.Add(counts[value] / (double)successfulCount);
-          }
-
-          //fill up all values that are not present in the current generation
-          foreach (DataRow row in successProgressAnalysis.Rows) {
-            if (!counts.ContainsKey(row.Name))
-              row.Values.Add(0);
-          }
-        }  
+        //fill up all values that are not present in the current generation
+        foreach (DataRow row in successProgressAnalysis.Rows) {
+          if (!counts.ContainsKey(row.Name))
+            row.Values.Add(0);
+        }
+      }
 
       return base.Apply();