Changeset 5510 for branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/ArchitectureManipulators/SubroutineCreater.cs

Timestamp:

02/17/11 13:51:04 (14 years ago)

Author:

gkronber

Message:

#1418 Fixed compiler errors in symbolic expression tree encoding

File:

• branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/ArchitectureManipulators/SubroutineCreater.cs (modified) (12 diffs)

branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/ArchitectureManipulators/SubroutineCreater.cs

@@ -28 +28 @@
 using HeuristicLab.Data;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Parameters;
 
 namespace HeuristicLab.Encodings.SymbolicExpressionTreeEncoding {
@@ -35 +36 @@
   /// As described in Koza, Bennett, Andre, Keane, Genetic Programming III - Darwinian Invention and Problem Solving, 1999, pp. 97
   /// </summary>
-  [Item("SubroutineCreater", "Manipulates a symbolic expression by adding one new function-defining branch containing a proportion of a preexisting branch and by creating a reference to the new branch.")]
+  [Item("SubroutineCreater", "Manipulates a symbolic expression by adding one new function-defining branch containing a proportion of a preexisting branch and by creating a reference to the new branch. As described in Koza, Bennett, Andre, Keane, Genetic Programming III - Darwinian Invention and Problem Solving, 1999, pp. 97")]
   [StorableClass]
-  public sealed class SubroutineCreater : SymbolicExpressionTreeArchitectureManipulator {
+  public sealed class SubroutineCreater : SymbolicExpressionTreeArchitectureManipulator, ISymbolicExpressionTreeSizeConstraintOperator {
     private const double ARGUMENT_CUTOFF_PROBABILITY = 0.05;
-
+    private const string MaximumSymbolicExpressionTreeLengthParameterName = "MaximumSymbolicExpressionTreeLength";
+    private const string MaximumSymbolicExpressionTreeDepthParameterName = "MaximumSymbolicExpressionTreeDepth";
+    #region Parameter Properties
+    public IValueLookupParameter<IntValue> MaximumSymbolicExpressionTreeLengthParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters[MaximumSymbolicExpressionTreeLengthParameterName]; }
+    }
+    public IValueLookupParameter<IntValue> MaximumSymbolicExpressionTreeDepthParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters[MaximumSymbolicExpressionTreeDepthParameterName]; }
+    }
+    #endregion
+    #region Properties
+    public IntValue MaximumSymbolicExpressionTreeLength {
+      get { return MaximumSymbolicExpressionTreeLengthParameter.ActualValue; }
+    }
+    public IntValue MaximumSymbolicExpressionTreeDepth {
+      get { return MaximumSymbolicExpressionTreeDepthParameter.ActualValue; }
+    }
+    #endregion
     [StorableConstructor]
     private SubroutineCreater(bool deserializing) : base(deserializing) { }
     private SubroutineCreater(SubroutineCreater original, Cloner cloner) : base(original, cloner) { }
-    public SubroutineCreater() : base() { }
+    public SubroutineCreater() : base() {
+      Parameters.Add(new ValueLookupParameter<IntValue>(MaximumSymbolicExpressionTreeLengthParameterName, "The maximal length (number of nodes) of the symbolic expression tree."));
+      Parameters.Add(new ValueLookupParameter<IntValue>(MaximumSymbolicExpressionTreeDepthParameterName, "The maximal depth of the symbolic expression tree (a tree with one node has depth = 0)."));
+    }
 
     public override IDeepCloneable Clone(Cloner cloner) {
@@ -51 +72 @@
     public override sealed void ModifyArchitecture(
       IRandom random,
-      SymbolicExpressionTree symbolicExpressionTree,
-      ISymbolicExpressionGrammar grammar,
-      IntValue maxTreeSize, IntValue maxTreeHeight,
-      IntValue maxFunctionDefiningBranches, IntValue maxFunctionArguments,
-      out bool success) {
-      success = CreateSubroutine(random, symbolicExpressionTree, grammar, maxTreeSize.Value, maxTreeHeight.Value, maxFunctionDefiningBranches.Value, maxFunctionArguments.Value);
+      ISymbolicExpressionTree symbolicExpressionTree,
+      IntValue maxFunctionDefinitions, IntValue maxFunctionArguments) {
+      CreateSubroutine(random, symbolicExpressionTree, MaximumSymbolicExpressionTreeLength.Value, MaximumSymbolicExpressionTreeDepth.Value, maxFunctionDefinitions.Value, maxFunctionArguments.Value);
     }
 
     public static bool CreateSubroutine(
       IRandom random,
-      SymbolicExpressionTree symbolicExpressionTree,
-      ISymbolicExpressionGrammar grammar,
-      int maxTreeSize, int maxTreeHeight,
-      int maxFunctionDefiningBranches, int maxFunctionArguments) {
+      ISymbolicExpressionTree symbolicExpressionTree,
+      int maxTreeLength, int maxTreeDepth,
+      int maxFunctionDefinitions, int maxFunctionArguments) {
       var functionDefiningBranches = symbolicExpressionTree.IterateNodesPrefix().OfType<DefunTreeNode>();
-      if (functionDefiningBranches.Count() >= maxFunctionDefiningBranches)
+      if (functionDefiningBranches.Count() >= maxFunctionDefinitions)
         // allowed maximum number of ADF reached => abort
         return false;
-      if (symbolicExpressionTree.Size + 4 > maxTreeSize)
+      if (symbolicExpressionTree.Size + 4 > maxTreeLength)
         // defining a new function causes an size increase by 4 nodes (max) if the max tree size is reached => abort
         return false;
-      string formatString = new StringBuilder().Append('0', (int)Math.Log10(maxFunctionDefiningBranches * 10 - 1)).ToString(); // >= 100 functions => ###
-      var allowedFunctionNames = from index in Enumerable.Range(0, maxFunctionDefiningBranches)
+      string formatString = new StringBuilder().Append('0', (int)Math.Log10(maxFunctionDefinitions * 10 - 1)).ToString(); // >= 100 functions => ###
+      var allowedFunctionNames = from index in Enumerable.Range(0, maxFunctionDefinitions)
                                  select "ADF" + index.ToString(formatString);
 
@@ -82 +99 @@
       int r = random.Next(totalNumberOfBodyNodes);
       int aggregatedNumberOfBodyNodes = 0;
-      SymbolicExpressionTreeNode selectedBody = null;
+      ISymbolicExpressionTreeNode selectedBody = null;
       foreach (var body in bodies) {
         aggregatedNumberOfBodyNodes += body.Size;
@@ -94 +111 @@
       var allCutPoints = from parent in selectedBody.IterateNodesPrefix()
                          from subtree in parent.SubTrees
-                         select new { Parent = parent, ReplacedBranchIndex = parent.SubTrees.IndexOf(subtree), ReplacedBranch = subtree };
+                         select new { Parent = parent, ReplacedBranchIndex = parent.IndexOfSubTree(subtree), ReplacedBranch = subtree };
       if (allCutPoints.Count() == 0)
         // no cut points => abort
@@ -101 +118 @@
       var selectedCutPoint = allCutPoints.SelectRandom(random);
       // select random branches as argument cut-off points (replaced by argument terminal nodes in the function)
-      List<SymbolicExpressionTreeNode> argumentBranches = SelectRandomArgumentBranches(selectedCutPoint.ReplacedBranch, random, ARGUMENT_CUTOFF_PROBABILITY, maxFunctionArguments);
-      SymbolicExpressionTreeNode functionBody = selectedCutPoint.ReplacedBranch;
+      List<ISymbolicExpressionTreeNode> argumentBranches = SelectRandomArgumentBranches(selectedCutPoint.ReplacedBranch, random, ARGUMENT_CUTOFF_PROBABILITY, maxFunctionArguments);
+      ISymbolicExpressionTreeNode functionBody = selectedCutPoint.ReplacedBranch;
       // disconnect the function body from the tree
       selectedCutPoint.Parent.RemoveSubTree(selectedCutPoint.ReplacedBranchIndex);
@@ -120 +137 @@
       symbolicExpressionTree.Root.AddSubTree(defunNode);
       // the grammar in the newly defined function is a clone of the grammar of the originating branch
-      defunNode.SetGrammar((ISymbolicExpressionGrammar)selectedBody.Grammar.Clone());
+      defunNode.SetGrammar((ISymbolicExpressionTreeGrammar)selectedBody.Grammar.Clone());
       // remove all argument symbols from grammar
       var oldArgumentSymbols = defunNode.Grammar.Symbols.OfType<Argument>().ToList();
@@ -164 +181 @@
     }
 
-    private static SymbolicExpressionTreeNode DisconnectBranches(SymbolicExpressionTreeNode node, List<SymbolicExpressionTreeNode> argumentBranches) {
+    private static ISymbolicExpressionTreeNode DisconnectBranches(ISymbolicExpressionTreeNode node, List<ISymbolicExpressionTreeNode> argumentBranches) {
       if (argumentBranches.Contains(node)) {
         var argumentIndex = argumentBranches.IndexOf(node);
@@ -171 +188 @@
       }
       // remove the subtrees so that we can clone only the root node
-      List<SymbolicExpressionTreeNode> subtrees = new List<SymbolicExpressionTreeNode>(node.SubTrees);
-      while (node.SubTrees.Count > 0) node.RemoveSubTree(0);
+      List<ISymbolicExpressionTreeNode> subtrees = new List<ISymbolicExpressionTreeNode>(node.SubTrees);
+      while (node.SubTrees.Count() > 0) node.RemoveSubTree(0);
       // recursively apply function for subtrees or append a argument terminal node
       foreach (var subtree in subtrees) {
@@ -180 +197 @@
     }
 
-    private static List<SymbolicExpressionTreeNode> SelectRandomArgumentBranches(SymbolicExpressionTreeNode selectedRoot,
+    private static List<ISymbolicExpressionTreeNode> SelectRandomArgumentBranches(ISymbolicExpressionTreeNode selectedRoot,
       IRandom random,
       double cutProbability,
@@ -186 +203 @@
       // breadth first determination of argument cut-off points
       // we must make sure that we cut off all original argument nodes and that the number of new argument is smaller than the limit
-      List<SymbolicExpressionTreeNode> argumentBranches = new List<SymbolicExpressionTreeNode>();
+      List<ISymbolicExpressionTreeNode> argumentBranches = new List<ISymbolicExpressionTreeNode>();
       if (selectedRoot is ArgumentTreeNode) {
         argumentBranches.Add(selectedRoot);
@@ -202 +219 @@
         }
         // cut-off in the sub-trees in random order
-        var randomIndexes = (from index in Enumerable.Range(0, selectedRoot.SubTrees.Count)
+        var randomIndexes = (from index in Enumerable.Range(0, selectedRoot.SubTrees.Count())
                              select new { Index = index, OrderValue = random.NextDouble() }).OrderBy(x => x.OrderValue).Select(x => x.Index);
         foreach (var subtreeIndex in randomIndexes) {
-          var subtree = selectedRoot.SubTrees[subtreeIndex];
+          var subtree = selectedRoot.GetSubTree(subtreeIndex);
           minNewArgumentsForSubtrees[subtreeIndex] = 0;
           // => cut-off at 0..n points somewhere in the current sub-tree