Changeset 10276

Timestamp:

01/04/14 12:23:59 (10 years ago)

Author:

sawinkle

Message:

#2109:
Refactoring:

• Removed recursive version of mapping in /Mappers/DepthFirstMapper.cs, because only the iterative one is used.
• Removed unused using statements and unused commented code.

Location:

branches/GrammaticalEvolution/HeuristicLab.Problems.GrammaticalEvolution

Files:

• Mappers/DepthFirstMapper.cs (modified) (1 diff)
• Symbolic/GESymbolicDataAnalysisProblem.cs (modified) (10 diffs)
• Symbolic/GESymbolicDataAnalysisSingleObjectiveEvaluator.cs (modified) (1 diff)
• Symbolic/GESymbolicExpressionGrammar.cs (modified) (1 diff)
• Symbolic/GESymbolicRegressionSingleObjectiveEvaluator.cs (modified) (2 diffs)
• Symbolic/GESymbolicRegressionSingleObjectiveProblem.cs (modified) (3 diffs)
• Symbolic/IGESymbolicDataAnalysisProblem.cs (modified) (2 diffs)
• Symbolic/IGESymbolicDataAnalysisSingleObjectiveEvaluator.cs (modified) (1 diff)

branches/GrammaticalEvolution/HeuristicLab.Problems.GrammaticalEvolution/Mappers/DepthFirstMapper.cs

@@ -65 +65 @@
       tree.Root = rootNode;
 
-      //int genotypeIndex = 0;
-      //int currSubtreeCount = 1;
-      //MapDepthFirstRecursively(startNode, genotype,
-      //                         grammar, genotype.Length,
-      //                         ref genotypeIndex, ref currSubtreeCount,
-      //                         new MersenneTwister());
-
       MapDepthFirstIteratively(startNode, genotype, grammar,
                                genotype.Length, new MersenneTwister());
       return tree;
-    }
-
-
-    /// <summary>
-    /// Genotype-to-Phenotype mapper (recursive depth-first approach).
-    /// Appends maximum allowed children (non-terminal symbols) to
-    /// <paramref name="currentNode"/>, as long as <paramref name="currSubtreeCount"/>
-    /// doesn't exceed <paramref name="maxSubtreeCount"/>.
-    /// If at most <paramref name="maxSubtreeCount"/> subtrees were created,
-    /// each non-full node is filled with randomly chosen nodes
-    /// (non-terminal and terminal), and each non-terminal node is again filled with a terminal node.
-    /// </summary>
-    /// <param name="currentNode">current parent node</param>
-    /// <param name="genotype">integer vector, which should be mapped to a tree</param>
-    /// <param name="grammar">grammar to determine the allowed child symbols for currentNode </param>
-    /// <param name="maxSubtreeCount">maximum allowed subtrees (= number of used genomes)</param>
-    /// <param name="genotypeIndex">current index in integer vector</param>
-    /// <param name="currSubtreeCount">number of already determined subtrees (filled or still incomplete)</param>
-    private void MapDepthFirstRecursively(ISymbolicExpressionTreeNode currentNode,
-                                          IntegerVector genotype,
-                                          ISymbolicExpressionGrammar grammar,
-                                          int maxSubtreeCount,
-                                          ref int genotypeIndex,
-                                          ref int currSubtreeCount,
-                                          IRandom random) {
-
-      // TODO: check, if method calls of GetNewChildNode() and GetRandomTerminalNode() don't return null
-      if (currSubtreeCount < maxSubtreeCount) {
-
-        var newNode = GetNewChildNode(currentNode, genotype, grammar, genotypeIndex, random);
-
-        if ((currSubtreeCount + newNode.Symbol.MinimumArity) > maxSubtreeCount) {
-          // TODO: maybe check, if there is any node, which fits in the tree yet
-          currentNode.AddSubtree(GetRandomTerminalNode(currentNode, grammar, random));
-        } else {
-          currentNode.AddSubtree(newNode);
-          genotypeIndex++;
-          currSubtreeCount += newNode.Symbol.MinimumArity;
-
-          while (newNode.Symbol.MinimumArity > newNode.SubtreeCount) {
-            MapDepthFirstRecursively(newNode, genotype,
-                                     grammar, maxSubtreeCount,
-                                     ref genotypeIndex, ref currSubtreeCount, random);
-          }
-        }
-
-      } else {
-        while (currentNode.Symbol.MinimumArity > currentNode.SubtreeCount) {
-          var newNode = GetNewChildNode(currentNode, genotype, grammar, genotypeIndex, random);
-          currentNode.AddSubtree(newNode);
-          genotypeIndex++;
-          while (newNode.Symbol.MinimumArity > newNode.SubtreeCount) {
-            newNode.AddSubtree(GetRandomTerminalNode(newNode, grammar, random));
-          }
-        }
-      }
     }
 

branches/GrammaticalEvolution/HeuristicLab.Problems.GrammaticalEvolution/Symbolic/GESymbolicDataAnalysisProblem.cs

@@ -51 +51 @@
     private const string SymbolicExpressionTreeGrammarParameterName = "SymbolicExpressionTreeGrammar";
     private const string SymbolicExpressionTreeInterpreterParameterName = "SymbolicExpressionTreeInterpreter";
-    //private const string MaximumSymbolicExpressionTreeDepthParameterName = "MaximumSymbolicExpressionTreeDepth";
     private const string MaximumSymbolicExpressionTreeLengthParameterName = "MaximumSymbolicExpressionTreeLength";
-    //private const string MaximumFunctionDefinitionsParameterName = "MaximumFunctionDefinitions";
-    //private const string MaximumFunctionArgumentsParameterName = "MaximumFunctionArguments";
     private const string RelativeNumberOfEvaluatedSamplesParameterName = "RelativeNumberOfEvaluatedSamples";
     private const string FitnessCalculationPartitionParameterName = "FitnessCalculationPartition";
@@ -90 +87 @@
       get { return (IValueParameter<ISymbolicDataAnalysisExpressionTreeInterpreter>)Parameters[SymbolicExpressionTreeInterpreterParameterName]; }
     }
-    //public IFixedValueParameter<IntValue> MaximumSymbolicExpressionTreeDepthParameter {
-    //  get { return (IFixedValueParameter<IntValue>)Parameters[MaximumSymbolicExpressionTreeDepthParameterName]; }
-    //}
     public IFixedValueParameter<IntValue> MaximumSymbolicExpressionTreeLengthParameter {
       get { return (IFixedValueParameter<IntValue>)Parameters[MaximumSymbolicExpressionTreeLengthParameterName]; }
     }
-    //public IFixedValueParameter<IntValue> MaximumFunctionDefinitionsParameter {
-    //  get { return (IFixedValueParameter<IntValue>)Parameters[MaximumFunctionDefinitionsParameterName]; }
-    //}
-    //public IFixedValueParameter<IntValue> MaximumFunctionArgumentsParameter {
-    //  get { return (IFixedValueParameter<IntValue>)Parameters[MaximumFunctionArgumentsParameterName]; }
-    //}
     public IFixedValueParameter<PercentValue> RelativeNumberOfEvaluatedSamplesParameter {
       get { return (IFixedValueParameter<PercentValue>)Parameters[RelativeNumberOfEvaluatedSamplesParameterName]; }
@@ -143 +131 @@
     }
 
-    //public IntValue MaximumSymbolicExpressionTreeDepth {
-    //  get { return MaximumSymbolicExpressionTreeDepthParameter.Value; }
-    //}
     public IntValue MaximumSymbolicExpressionTreeLength {
       get { return MaximumSymbolicExpressionTreeLengthParameter.Value; }
     }
-    //public IntValue MaximumFunctionDefinitions {
-    //  get { return MaximumFunctionDefinitionsParameter.Value; }
-    //}
-    //public IntValue MaximumFunctionArguments {
-    //  get { return MaximumFunctionArgumentsParameter.Value; }
-    //}
+
     public PercentValue RelativeNumberOfEvaluatedSamples {
       get { return RelativeNumberOfEvaluatedSamplesParameter.Value; }
@@ -186 +166 @@
       Parameters.Add(new ValueParameter<GESymbolicExpressionGrammar>(SymbolicExpressionTreeGrammarParameterName, SymbolicExpressionTreeGrammarParameterDescription));
       Parameters.Add(new ValueParameter<ISymbolicDataAnalysisExpressionTreeInterpreter>(SymbolicExpressionTreeInterpreterParameterName, SymoblicExpressionTreeInterpreterParameterDescription));
-      //Parameters.Add(new FixedValueParameter<IntValue>(MaximumSymbolicExpressionTreeDepthParameterName, MaximumSymbolicExpressionTreeDepthParameterDescription));
       Parameters.Add(new FixedValueParameter<IntValue>(MaximumSymbolicExpressionTreeLengthParameterName, MaximumSymbolicExpressionTreeLengthParameterDescription));
-      //Parameters.Add(new FixedValueParameter<IntValue>(MaximumFunctionDefinitionsParameterName, MaximumFunctionDefinitionsParameterDescription));
-      //Parameters.Add(new FixedValueParameter<IntValue>(MaximumFunctionArgumentsParameterName, MaximumFunctionArgumentsParameterDescription));
       Parameters.Add(new FixedValueParameter<IntRange>(FitnessCalculationPartitionParameterName, FitnessCalculationPartitionParameterDescription));
       Parameters.Add(new FixedValueParameter<IntRange>(ValidationPartitionParameterName, ValidationPartitionParameterDescription));
@@ -199 +176 @@
 
       SymbolicExpressionTreeInterpreterParameter.Hidden = true;
-      //MaximumFunctionArgumentsParameter.Hidden = true;
-      //MaximumFunctionDefinitionsParameter.Hidden = true;
       ApplyLinearScalingParameter.Hidden = true;
 
@@ -232 +207 @@
     private void InitializeOperators() {
       Operators.AddRange(ApplicationManager.Manager.GetInstances<IIntegerVectorOperator>().OfType<IOperator>());
-      // Operators.AddRange(ApplicationManager.Manager.GetInstances<ISymbolicDataAnalysisExpressionCrossover<T>>());
       Operators.Add(new SymbolicExpressionSymbolFrequencyAnalyzer());
       Operators.Add(new SymbolicDataAnalysisVariableFrequencyAnalyzer());
@@ -246 +220 @@
 
       RegisterGrammarHandler();
-
-      //MaximumFunctionArguments.ValueChanged += new EventHandler(ArchitectureParameterValue_ValueChanged);
-      //MaximumFunctionDefinitions.ValueChanged += new EventHandler(ArchitectureParameterValue_ValueChanged);
-      //MaximumSymbolicExpressionTreeDepth.ValueChanged += new EventHandler(MaximumSymbolicExpressionTreeDepth_ValueChanged);
     }
 
@@ -263 +233 @@
     }
 
-    //private void MaximumSymbolicExpressionTreeDepth_ValueChanged(object sender, EventArgs e) {
-    //  if (MaximumSymbolicExpressionTreeDepth != null && MaximumSymbolicExpressionTreeDepth.Value < 3)
-    //    MaximumSymbolicExpressionTreeDepth.Value = 3;
-    //}
-
-    //protected override void OnSolutionCreatorChanged() {
-    //  base.OnSolutionCreatorChanged();
-    //  ParameterizeOperators();
-    //}
-
     protected override void OnEvaluatorChanged() {
       base.OnEvaluatorChanged();
@@ -304 +264 @@
         op.SymbolicExpressionTreeGrammarParameter.ActualName = SymbolicExpressionTreeGrammarParameter.Name;
       }
-      /*
-      foreach (var op in operators.OfType<ISymbolicExpressionTreeSizeConstraintOperator>()) {
-        op.MaximumSymbolicExpressionTreeDepthParameter.ActualName = MaximumSymbolicExpressionTreeDepthParameter.Name;
-        op.MaximumSymbolicExpressionTreeLengthParameter.ActualName = MaximumSymbolicExpressionTreeLengthParameter.Name;
-      }
-      foreach (var op in operators.OfType<ISymbolicExpressionTreeArchitectureAlteringOperator>()) {
-        op.MaximumFunctionArgumentsParameter.ActualName = MaximumFunctionArgumentsParameter.Name;
-        op.MaximumFunctionDefinitionsParameter.ActualName = MaximumFunctionDefinitionsParameter.Name;
-      }
-      */
       foreach (var op in operators.OfType<IGESymbolicDataAnalysisEvaluator<T>>()) {
         op.ProblemDataParameter.ActualName = ProblemDataParameterName;
@@ -354 +304 @@
         op.SymbolicDataAnalysisTreeInterpreterParameter.ActualName = SymbolicExpressionTreeInterpreterParameter.Name;
       }
-      /*
-      foreach (var op in operators.OfType<ISymbolicDataAnalysisExpressionCrossover<T>>()) {
-        op.EvaluationPartitionParameter.ActualName = FitnessCalculationPartitionParameter.Name;
-        op.ProblemDataParameter.ActualName = ProblemDataParameter.Name;
-        op.EvaluationPartitionParameter.ActualName = FitnessCalculationPartitionParameter.Name;
-        op.RelativeNumberOfEvaluatedSamplesParameter.ActualName = RelativeNumberOfEvaluatedSamplesParameter.Name;
-        op.EvaluatorParameter.ActualName = EvaluatorParameter.Name;
-      }
-      */
     }
 

branches/GrammaticalEvolution/HeuristicLab.Problems.GrammaticalEvolution/Symbolic/GESymbolicDataAnalysisSingleObjectiveEvaluator.cs

@@ -20 +20 @@
 #endregion
 
-using System.Collections.Generic;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Data;
-using HeuristicLab.Encodings.IntegerVectorEncoding;
-using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 using HeuristicLab.Problems.DataAnalysis;
-using HeuristicLab.Problems.DataAnalysis.Symbolic;
 
 namespace HeuristicLab.Problems.GrammaticalEvolution {

branches/GrammaticalEvolution/HeuristicLab.Problems.GrammaticalEvolution/Symbolic/GESymbolicExpressionGrammar.cs

@@ -28 +28 @@
 using HeuristicLab.Problems.DataAnalysis.Symbolic;
 using HeuristicLab.Random;
-using Variable = HeuristicLab.Core.Variable;
 
 namespace HeuristicLab.Problems.GrammaticalEvolution {

branches/GrammaticalEvolution/HeuristicLab.Problems.GrammaticalEvolution/Symbolic/GESymbolicRegressionSingleObjectiveEvaluator.cs

@@ -20 +20 @@
 #endregion
 
-using System.Collections.Generic;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Encodings.IntegerVectorEncoding;
-using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
@@ -33 +30 @@
   [StorableClass]
   public class GESymbolicRegressionSingleObjectiveEvaluator : GESymbolicDataAnalysisSingleObjectiveEvaluator<IRegressionProblemData>,
-                                                                       IGESymbolicRegressionSingleObjectiveEvaluator {
+                                                              IGESymbolicRegressionSingleObjectiveEvaluator {
 
     public const string EvaluatorParameterName = "Evaluator";

branches/GrammaticalEvolution/HeuristicLab.Problems.GrammaticalEvolution/Symbolic/GESymbolicRegressionSingleObjectiveProblem.cs

@@ -31 +31 @@
 
 namespace HeuristicLab.Problems.GrammaticalEvolution {
-  [Item("Grammatical Evolution Symbolic Regression Problem (single objective)", "Represents a single objective symbolic regression problem, implemented in Grammatical Evolution.")]
+  [Item("Grammatical Evolution Symbolic Regression Problem (single objective)",
+        "Represents a single objective symbolic regression problem, implemented in Grammatical Evolution.")]
   [StorableClass]
   [Creatable("Problems")]
@@ -37 +38 @@
                                                             IRegressionProblem {
     private const double PunishmentFactor = 10;
-    //private const int InitialMaximumTreeDepth = 8;
     private const int InitialMaximumTreeLength = 25;
     private const string EstimationLimitsParameterName = "EstimationLimits";
-    private const string EstimationLimitsParameterDescription = "The limits for the estimated value that can be returned by the symbolic regression model.";
+    private const string EstimationLimitsParameterDescription
+      = "The limits for the estimated value that can be returned by the symbolic regression model.";
 
     #region parameter properties
@@ -69 +70 @@
       ApplyLinearScalingParameter.Value.Value = true;
       Maximization.Value = true;
-      //MaximumSymbolicExpressionTreeDepth.Value = InitialMaximumTreeDepth;
       MaximumSymbolicExpressionTreeLength.Value = InitialMaximumTreeLength;
 

branches/GrammaticalEvolution/HeuristicLab.Problems.GrammaticalEvolution/Symbolic/IGESymbolicDataAnalysisProblem.cs

@@ -25 +25 @@
 using HeuristicLab.Problems.DataAnalysis;
 using HeuristicLab.Problems.DataAnalysis.Symbolic;
-using HeuristicLab.Problems.GrammaticalEvolution;
 
 namespace HeuristicLab.Problems.GrammaticalEvolution {
   public interface IGESymbolicDataAnalysisProblem : IDataAnalysisProblem, IHeuristicOptimizationProblem {
+
     IValueParameter<GESymbolicExpressionGrammar> SymbolicExpressionTreeGrammarParameter { get; }
     IValueParameter<ISymbolicDataAnalysisExpressionTreeInterpreter> SymbolicExpressionTreeInterpreterParameter { get; }
-    //IFixedValueParameter<IntValue> MaximumSymbolicExpressionTreeDepthParameter { get; }
     IFixedValueParameter<IntValue> MaximumSymbolicExpressionTreeLengthParameter { get; }
-    //IFixedValueParameter<IntValue> MaximumFunctionDefinitionsParameter { get; }
-    //IFixedValueParameter<IntValue> MaximumFunctionArgumentsParameter { get; }
     IFixedValueParameter<PercentValue> RelativeNumberOfEvaluatedSamplesParameter { get; }
     IFixedValueParameter<IntRange> FitnessCalculationPartitionParameter { get; }
@@ -41 +38 @@
     GESymbolicExpressionGrammar SymbolicExpressionTreeGrammar { get; set; }
     ISymbolicDataAnalysisExpressionTreeInterpreter SymbolicExpressionTreeInterpreter { get; set; }
-    //IntValue MaximumSymbolicExpressionTreeDepth { get; }
     IntValue MaximumSymbolicExpressionTreeLength { get; }
-    //IntValue MaximumFunctionDefinitions { get; }
-    //IntValue MaximumFunctionArguments { get; }
     PercentValue RelativeNumberOfEvaluatedSamples { get; }
     IntRange FitnessCalculationPartition { get; }

branches/GrammaticalEvolution/HeuristicLab.Problems.GrammaticalEvolution/Symbolic/IGESymbolicDataAnalysisSingleObjectiveEvaluator.cs

@@ -20 +20 @@
 #endregion
 
-using System.Collections.Generic;
-using HeuristicLab.Core;
-using HeuristicLab.Encodings.IntegerVectorEncoding;
-using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 using HeuristicLab.Optimization;
 using HeuristicLab.Problems.DataAnalysis;