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

Timestamp:

03/17/11 14:07:47 (14 years ago)

Author:

mkommend

Message:

#1418: Corrected problem interfaces & unified naming of subtrees.

File:

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

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

@@ -95 +95 @@
 
       // select a random body (either the result producing branch or an ADF branch)
-      var bodies = from node in symbolicExpressionTree.Root.SubTrees
+      var bodies = from node in symbolicExpressionTree.Root.Subtrees
                    select new { Tree = node, Length = node.GetLength() };
       var totalNumberOfBodyNodes = bodies.Select(x => x.Length).Sum();
@@ -111 +111 @@
       // select a random cut point in the selected branch
       var allCutPoints = (from parent in selectedBody.IterateNodesPrefix()
-                          from subtree in parent.SubTrees
+                          from subtree in parent.Subtrees
                           select new CutPoint(parent, subtree)).ToList();
       if (allCutPoints.Count() == 0)
@@ -122 +122 @@
       ISymbolicExpressionTreeNode functionBody = selectedCutPoint.Child;
       // disconnect the function body from the tree
-      selectedCutPoint.Parent.RemoveSubTree(selectedCutPoint.ChildIndex);
+      selectedCutPoint.Parent.RemoveSubtree(selectedCutPoint.ChildIndex);
       // disconnect the argument branches from the function
       functionBody = DisconnectBranches(functionBody, argumentCutPoints);
       // insert a function invocation symbol instead
       var invokeNode = (InvokeFunctionTreeNode)(new InvokeFunction(newFunctionName)).CreateTreeNode();
-      selectedCutPoint.Parent.InsertSubTree(selectedCutPoint.ChildIndex, invokeNode);
+      selectedCutPoint.Parent.InsertSubtree(selectedCutPoint.ChildIndex, invokeNode);
       // add the branches selected as argument as subtrees of the function invocation node
       foreach (var argumentCutPoint in argumentCutPoints)
-        invokeNode.AddSubTree(argumentCutPoint.Child);
+        invokeNode.AddSubtree(argumentCutPoint.Child);
 
       // insert a new function defining branch
       var defunNode = (DefunTreeNode)(new Defun()).CreateTreeNode();
       defunNode.FunctionName = newFunctionName;
-      defunNode.AddSubTree(functionBody);
-      symbolicExpressionTree.Root.AddSubTree(defunNode);
+      defunNode.AddSubtree(functionBody);
+      symbolicExpressionTree.Root.AddSubtree(defunNode);
       // the grammar in the newly defined function is a clone of the grammar of the originating branch
       defunNode.SetGrammar((ISymbolicExpressionTreeGrammar)selectedBody.Grammar.Clone());
@@ -157 +157 @@
       if (selectedBody.Symbol is Defun) {
         var originalFunctionDefinition = selectedBody as DefunTreeNode;
-        foreach (var subtree in symbolicExpressionTree.Root.SubTrees) {
+        foreach (var subtree in symbolicExpressionTree.Root.Subtrees) {
           var originalBranchInvokeSymbol = (from symb in subtree.Grammar.Symbols.OfType<InvokeFunction>()
                                             where symb.FunctionName == originalFunctionDefinition.FunctionName
@@ -177 +177 @@
       }
       // remove the subtrees so that we can clone only the root node
-      List<ISymbolicExpressionTreeNode> subtrees = new List<ISymbolicExpressionTreeNode>(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) {
-        node.AddSubTree(DisconnectBranches(subtree, argumentCutPoints));
+        node.AddSubtree(DisconnectBranches(subtree, argumentCutPoints));
       }
       return node;
@@ -198 +198 @@
       } else {
         // get the number of argument nodes (which must be cut-off) in the sub-trees
-        var numberOfArgumentsInSubtrees = (from subtree in selectedRoot.SubTrees
+        var numberOfArgumentsInSubtrees = (from subtree in selectedRoot.Subtrees
                                            let nArgumentsInTree = subtree.IterateNodesPrefix().OfType<ArgumentTreeNode>().Count()
                                            select nArgumentsInTree).ToList();
@@ -209 +209 @@
         }
         // 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.GetSubTree(subtreeIndex);
+          var subtree = selectedRoot.GetSubtree(subtreeIndex);
           minNewArgumentsForSubtrees[subtreeIndex] = 0;
           // => cut-off at 0..n points somewhere in the current sub-tree