Changeset 5682 for branches/SuccessProgressAnalysis/HeuristicLab.Algorithms.OffspringSelectionGeneticAlgorithm/3.3/SuccessfulOffspringAnalysis/SuccessfulOffspringAnalyzer.cs

Timestamp:

03/15/11 09:51:22 (14 years ago)

Author:

svonolfe

Message:

Implemented review comments from swagner (#1392)

Location:

branches/SuccessProgressAnalysis/HeuristicLab.Algorithms.OffspringSelectionGeneticAlgorithm/3.3/SuccessfulOffspringAnalysis

Files:

• . (added)
• SuccessfulOffspringAnalyzer.cs (copied) (copied from branches/SuccessProgressAnalysis/HeuristicLab.Algorithms.OffspringSelectionGeneticAlgorithm/3.3/SuccessProgressAnalysis/SuccessProgressAnalyzer.cs) (5 diffs)

branches/SuccessProgressAnalysis/HeuristicLab.Algorithms.OffspringSelectionGeneticAlgorithm/3.3/SuccessfulOffspringAnalysis/SuccessfulOffspringAnalyzer.cs

@@ -33 +33 @@
 using HeuristicLab.Analysis;
 
-namespace HeuristicLab.Algorithms.OffspringSelectionAlgorithm.SuccessProgressAnalysis {
+namespace HeuristicLab.Algorithms.OffspringSelectionGeneticAlgorithm {
   /// <summary>
   /// An operator for analyzing the solution diversity in a population.
   /// </summary>
-  [Item("SuccessProgressAnalyzer", "An operator for analyzing the success progress in a population.")]
+  [Item("SuccessfulOffspringAnalyzer", "An operator for analyzing certain properties in the successful offspring. The properties to be analyzed can be specified in the CollectedValues parameter.")]
   [StorableClass]
-  public sealed class SuccessProgressAnalyzer: SingleSuccessorOperator, IAnalyzer {
+  public sealed class SuccessfulOffspringAnalyzer : SingleSuccessorOperator, IAnalyzer {
     public ValueParameter<StringValue> SuccessfulOffspringFlag {
       get { return (ValueParameter<StringValue>)Parameters["SuccessfulOffspringFlag"]; }
@@ -52 +52 @@
     }
 
-    public LookupParameter<IntValue> Generations {
+    public ILookupParameter<IntValue> GenerationsParameter {
       get { return (LookupParameter<IntValue>)Parameters["Generations"]; }
+    }
+
+    public ValueParameter<IntValue> DepthParameter {
+      get { return (ValueParameter<IntValue>)Parameters["Depth"]; }
     }
     
     public override IDeepCloneable Clone(Cloner cloner) {
-      return new SuccessProgressAnalyzer(this, cloner);
+      return new SuccessfulOffspringAnalyzer(this, cloner);
     }    
     [StorableConstructor]
-    private SuccessProgressAnalyzer(bool deserializing) : base(deserializing) { }
-    private SuccessProgressAnalyzer(SuccessProgressAnalyzer original, Cloner cloner) : base(original, cloner) { }
-    public SuccessProgressAnalyzer()
+    private SuccessfulOffspringAnalyzer(bool deserializing) : base(deserializing) { }
+    private SuccessfulOffspringAnalyzer(SuccessfulOffspringAnalyzer original, Cloner cloner) : base(original, cloner) { }
+    public SuccessfulOffspringAnalyzer()
       : base() {
-        Parameters.Add(new ValueParameter<StringValue>("SuccessfulOffspringFlag", "Indicates if the individual was successful.", new StringValue("SuccessfulOffspring")));
-        Parameters.Add(new ValueParameter<ItemCollection<StringValue>>("CollectedValues", "The values that should be collected.", new ItemCollection<StringValue>()));
+        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 ValueParameter<IntValue>("Depth", "The depth of the individuals in the scope tree.", new IntValue(1)));
     }
 
     public override IOperation Apply() {
       ResultCollection results = ResultsParameter.ActualValue;
-      
+
+      List<IScope> scopes = new List<IScope>() { ExecutionContext.Scope };
+      for (int i = 0; i < DepthParameter.Value.Value; i++)
+        scopes = scopes.Select(x => (IEnumerable<IScope>)x.SubScopes).Aggregate((a, b) => a.Concat(b)).ToList();
+
       ItemCollection<StringValue> collectedValues = CollectedValues.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 < ExecutionContext.Scope.SubScopes.Count; i++) {
-            IScope child = ExecutionContext.Scope.SubScopes[i];
+          for (int i = 0; i < scopes.Count; i++) {
+            IScope child = scopes[i];
             string successfulOffspringFlag = SuccessfulOffspringFlag.Value.Value;
             if (child.Variables.ContainsKey(collected.Value) && 
@@ -92 +102 @@
           }
 
+          //create a data table containing the collected values
           DataTable successProgressAnalysis;
           string resultKey = "Success Progress " + collected.Value;
@@ -111 +122 @@
             if (!successProgressAnalysis.Rows.ContainsKey(value)) {
               row = new DataRow(value);
-              int iterations = Generations.ActualValue.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);
@@ -124 +136 @@
           }
 
+          //fill up all values that are not present in the current generation
           foreach (DataRow row in successProgressAnalysis.Rows) {
             if (!counts.ContainsKey(row.Name))