Changeset 5529 for branches/DataAnalysis Refactoring

Timestamp:

02/21/11 17:49:23 (14 years ago)

Author:

gkronber

Message:

#1418 Removed grammar specific members from ISymbolicExpressionTreeNode interface.

Location:

branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4

Files:

• ArchitectureManipulators/ArgumentCreater.cs (modified) (1 diff)
• ArchitectureManipulators/ArgumentDuplicater.cs (modified) (1 diff)
• ArchitectureManipulators/SubroutineDeleter.cs (modified) (1 diff)
• Creators/ProbabilisticTreeCreator.cs (modified) (5 diffs)
• DefaultSymbolicExpressionGrammar.cs (modified) (1 diff)
• Interfaces/ISymbolicExpressionTreeGrammar.cs (modified) (1 diff)
• Interfaces/ISymbolicExpressionTreeNode.cs (modified) (1 diff)
• Manipulators/ChangeNodeTypeManipulation.cs (modified) (1 diff)
• Manipulators/ReplaceBranchManipulation.cs (modified) (1 diff)
• SymbolicExpressionTreeNode.cs (modified) (1 diff)

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

@@ -180 +180 @@
           subtree.Grammar.SetMinSubtreeCount(matchingSymbol, defunBranch.NumberOfArguments);
           subtree.Grammar.SetMaxSubtreeCount(matchingSymbol, defunBranch.NumberOfArguments);
-          foreach (var child in subtree.GetAllowedSymbols(0)) {
+          foreach (var child in subtree.Grammar.GetAllowedSymbols(subtree.Symbol, 0)) {
             for (int i = 0; i < subtree.Grammar.GetMaxSubtreeCount(matchingSymbol); i++) {
               subtree.Grammar.SetAllowedChild(matchingSymbol, child, i);

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

@@ -124 +124 @@
           subtree.Grammar.SetMinSubtreeCount(matchingInvokeSymbol, selectedDefunBranch.NumberOfArguments);
           subtree.Grammar.SetMaxSubtreeCount(matchingInvokeSymbol, selectedDefunBranch.NumberOfArguments);
-          foreach (var child in subtree.GetAllowedSymbols(0)) {
+          foreach (var child in subtree.Grammar.GetAllowedSymbols(subtree.Symbol, 0)) {
             for (int i = 0; i < subtree.Grammar.GetMaxSubtreeCount(matchingInvokeSymbol); i++) {
               subtree.Grammar.SetAllowedChild(matchingInvokeSymbol, child, i);

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

@@ -91 +91 @@
         // deletion by random regeneration
         ISymbolicExpressionTreeNode replacementTree = null;
-        var allowedSymbolsList = invocationCutPoint.Parent.GetAllowedSymbols(invocationCutPoint.ReplacedChildIndex).ToList();
+        var allowedSymbolsList = invocationCutPoint.Parent.Grammar.GetAllowedSymbols(invocationCutPoint.Parent.Symbol, invocationCutPoint.ReplacedChildIndex).ToList();
         var weights = allowedSymbolsList.Select(s => s.InitialFrequency);
         var selectedSymbol = allowedSymbolsList.SelectRandom(weights, random);

branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Creators/ProbabilisticTreeCreator.cs

@@ -216 +216 @@
       int argumentIndex, int maxFunctionDefinitions, int maxFunctionArguments) {
       // determine possible symbols that will lead to the smallest possible tree
-      var possibleSymbols = (from s in parent.GetAllowedSymbols(argumentIndex)
+      var possibleSymbols = (from s in parent.Grammar.GetAllowedSymbols(parent.Symbol, argumentIndex)
                              group s by parent.Grammar.GetMinExpressionLength(s) into g
                              orderby g.Key
@@ -227 +227 @@
       parent.InsertSubTree(argumentIndex, tree);
       InitializeNewTreeNode(random, root, tree, maxFunctionDefinitions, maxFunctionArguments);
-      for (int i = 0; i < tree.GetMinSubtreeCount(); i++) {
+      for (int i = 0; i < tree.Grammar.GetMinSubtreeCount(tree.Symbol); i++) {
         // insert a dummy sub-tree and add the pending extension to the list
         var dummy = new SymbolicExpressionTreeNode();
@@ -285 +285 @@
     private static int SampleArity(IRandom random, ISymbolicExpressionTreeNode node, int targetSize) {
       // select actualArity randomly with the constraint that the sub-trees in the minimal arity can become large enough
-      int minArity = node.GetMinSubtreeCount();
-      int maxArity = node.GetMaxSubtreeCount();
+      int minArity = node.Grammar.GetMinSubtreeCount(node.Symbol);
+      int maxArity = node.Grammar.GetMaxSubtreeCount(node.Symbol);
       if (maxArity > targetSize) {
         maxArity = targetSize;
@@ -294 +294 @@
       long aggregatedLongestExpressionLength = 0;
       for (int i = 0; i < maxArity; i++) {
-        aggregatedLongestExpressionLength += (from s in node.GetAllowedSymbols(i)
+        aggregatedLongestExpressionLength += (from s in node.Grammar.GetAllowedSymbols(node.Symbol, i)
                                               select node.Grammar.GetMaxExpressionLength(s)).Max();
         if (aggregatedLongestExpressionLength < targetSize) minArity = i;
@@ -304 +304 @@
       long aggregatedShortestExpressionLength = 0;
       for (int i = 0; i < maxArity; i++) {
-        aggregatedShortestExpressionLength += (from s in node.GetAllowedSymbols(i)
+        aggregatedShortestExpressionLength += (from s in node.Grammar.GetAllowedSymbols(node.Symbol, i)
                                                select node.Grammar.GetMinExpressionLength(s)).Min();
         if (aggregatedShortestExpressionLength > targetSize) {

branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/DefaultSymbolicExpressionGrammar.cs

@@ -229 +229 @@
     }
 
+    public IEnumerable<ISymbol> GetAllowedSymbols(ISymbol parent, int argumentIndex) {
+      return allowedChildSymbols[parent.Name][argumentIndex].Select(x => allSymbols[x]);
+    }
+
     private Dictionary<string, int> cachedMinExpressionLength;
     public int GetMinExpressionLength(ISymbol symbol) {

branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Interfaces/ISymbolicExpressionTreeGrammar.cs

@@ -34 +34 @@
     bool IsAllowedChild(ISymbol parent, ISymbol child, int argumentIndex);
 
+    IEnumerable<ISymbol> GetAllowedSymbols(ISymbol parent, int argumentIndex);
+
     int GetMinExpressionLength(ISymbol start);
     int GetMaxExpressionLength(ISymbol start);

branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Interfaces/ISymbolicExpressionTreeNode.cs

@@ -29 +29 @@
     ISymbol Symbol { get; }
     bool HasLocalParameters { get; }
-    IEnumerable<ISymbol> GetAllowedSymbols(int argumentIndex);
 
     int GetHeight();
     int GetSize();
-    int GetMinSubtreeCount();
-    int GetMaxSubtreeCount();
 
     IEnumerable<ISymbolicExpressionTreeNode> IterateNodesPostfix();

branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Manipulators/ChangeNodeTypeManipulation.cs

@@ -54 +54 @@
       int subTreeCount = manipulationPoint.Node.SubTrees.Count();
       // find possible symbols for the node (also considering the existing branches below it)
-      var allowedSymbols = from symbol in manipulationPoint.Parent.GetAllowedSymbols(manipulationPoint.Index)
+      var allowedSymbols = from symbol in manipulationPoint.Parent.Grammar.GetAllowedSymbols(manipulationPoint.Parent.Symbol, manipulationPoint.Index)
                            where subTreeCount <= manipulationPoint.Node.Grammar.GetMaxSubtreeCount(symbol)
                            where subTreeCount >= manipulationPoint.Node.Grammar.GetMinSubtreeCount(symbol)

branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Manipulators/ReplaceBranchManipulation.cs

@@ -79 +79 @@
       int maxDepth = maxTreeDepth - symbolicExpressionTree.Height + manipulationPoint.Node.GetHeight();
       // find possible symbols for the node (also considering the existing branches below it)
-      var allowedSymbols = (from symbol in manipulationPoint.Parent.GetAllowedSymbols(manipulationPoint.Index)
+      var allowedSymbols = (from symbol in manipulationPoint.Parent.Grammar.GetAllowedSymbols(manipulationPoint.Parent.Symbol, manipulationPoint.Index)
                             where manipulationPoint.Node.Grammar.GetMinExpressionDepth(symbol) <= maxDepth
                             where manipulationPoint.Node.Grammar.GetMinExpressionLength(symbol) <= maxLength

branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/SymbolicExpressionTreeNode.cs

@@ -178 +178 @@
     }
 
-    public IEnumerable<ISymbol> GetAllowedSymbols(int argumentIndex) {
-      return Grammar.Symbols.Where(s => Grammar.IsAllowedChild(Symbol, s, argumentIndex));
-    }
-
-    public int GetMinSubtreeCount() {
-      return Grammar.GetMinSubtreeCount(Symbol);
-    }
-    public int GetMaxSubtreeCount() {
-      return Grammar.GetMaxSubtreeCount(Symbol);
-    }
     public override string ToString() {
       return Symbol.Name;