Changeset 5792 for branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/ArchitectureManipulators

Timestamp:

03/22/11 15:07:20 (14 years ago)

Author:

mkommend

Message:

#1418: Corrected ADFs and adapted unit tests.

Location:

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

Files:

• ArgumentCreater.cs (modified) (3 diffs)
• ArgumentDuplicater.cs (modified) (2 diffs)
• GrammarModifier.cs (modified) (3 diffs)
• SubroutineDuplicater.cs (modified) (1 diff)

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

@@ -124 +124 @@
       // the branch at the cut point is to be replaced by a new argument node
       var cutPoints = (from node in defunBranch.IterateNodesPrefix()
-                       where node.Subtrees.Count() > 0
+                       where node.Subtrees.Count() > 0 &&
+                             !node.IterateNodesPrefix().OfType<ArgumentTreeNode>().Any() &&
+                             !node.IterateNodesPrefix().OfType<InvokeFunctionTreeNode>().Any()
                        from subtree in node.Subtrees
                        select new CutPoint(node, subtree)).ToList();
@@ -169 +171 @@
       defunBranch.Grammar.SetSubtreeCount(newArgumentNode.Symbol, 0, 0);
       // allow the argument as child of any other symbol
-      foreach (var symb in defunBranch.Grammar.Symbols)
-        for (int i = 0; i < defunBranch.Grammar.GetMaximumSubtreeCount(symb); i++) {
-          defunBranch.Grammar.AddAllowedChildSymbol(symb, newArgumentNode.Symbol, i);
-        }
+      GrammarModifier.SetAllowedParentSymbols(defunBranch.Grammar, selectedCutPoint.Child.Symbol, newArgumentNode.Symbol);
+
       foreach (var subtree in tree.Root.Subtrees) {
         // when the changed function is known in the branch then update the number of arguments
@@ -178 +178 @@
         if (matchingSymbol != null) {
           subtree.Grammar.SetSubtreeCount(matchingSymbol, defunBranch.NumberOfArguments, defunBranch.NumberOfArguments);
-          foreach (var child in subtree.Grammar.GetAllowedChildSymbols(subtree.Symbol, 0)) {
-            for (int i = 0; i < subtree.Grammar.GetMaximumSubtreeCount(matchingSymbol); i++) {
-              subtree.Grammar.AddAllowedChildSymbol(matchingSymbol, child, i);
-            }
+          foreach (var symb in subtree.Grammar.Symbols) {
+            if (symb is StartSymbol || symb is ProgramRootSymbol) continue;
+            if (subtree.Grammar.IsAllowedChildSymbol(selectedCutPoint.Parent.Symbol, symb, selectedCutPoint.ChildIndex))
+              subtree.Grammar.AddAllowedChildSymbol(matchingSymbol, symb, newArgumentNode.Symbol.ArgumentIndex);
           }
         }

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

@@ -108 +108 @@
       selectedDefunBranch.Grammar.AddSymbol(newArgSymbol);
       selectedDefunBranch.Grammar.SetSubtreeCount(newArgSymbol, 0, 0);
-      // allow the argument as child of any other symbol
-      foreach (var symb in selectedDefunBranch.Grammar.Symbols)
-        for (int i = 0; i < selectedDefunBranch.Grammar.GetMaximumSubtreeCount(symb); i++) {
-          selectedDefunBranch.Grammar.AddAllowedChildSymbol(symb, newArgSymbol, i);
-        }
+      // allow the duplicated argument as child of all other arguments where the orginal argument was allowed
+      GrammarModifier.SetAllowedParentSymbols(selectedDefunBranch.Grammar, selectedArgumentSymbol, newArgSymbol);
       selectedDefunBranch.NumberOfArguments++;
 
@@ -122 +119 @@
         if (matchingInvokeSymbol != null) {
           subtree.Grammar.SetSubtreeCount(matchingInvokeSymbol, selectedDefunBranch.NumberOfArguments, selectedDefunBranch.NumberOfArguments);
-          foreach (var child in subtree.Grammar.GetAllowedChildSymbols(subtree.Symbol, 0)) {
-            for (int i = 0; i < subtree.Grammar.GetMaximumSubtreeCount(matchingInvokeSymbol); i++) {
-              subtree.Grammar.AddAllowedChildSymbol(matchingInvokeSymbol, child, i);
-            }
+          foreach (var symb in subtree.Grammar.Symbols) {
+            if (symb is StartSymbol || symb is ProgramRootSymbol) continue;
+            if (subtree.Grammar.IsAllowedChildSymbol(matchingInvokeSymbol, symb, selectedArgumentSymbol.ArgumentIndex))
+              subtree.Grammar.AddAllowedChildSymbol(matchingInvokeSymbol, symb, newArgumentIndex);
           }
         }

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

@@ -26 +26 @@
   public static class GrammarModifier {
     internal static void AddInvokeSymbol(ISymbolicExpressionTreeGrammar grammar, string functionName, int nArgs, CutPoint startCutPoint, IEnumerable<CutPoint> argumentCutPoints) {
+      if (!grammar.ContainsSymbol(startCutPoint.Child.Symbol)) return;
+
       var invokeSym = new InvokeFunction(functionName);
       grammar.AddSymbol(invokeSym);
@@ -31 +33 @@
 
       //allow invoke symbol everywhere, where the child of the startCutPoint was allowed
-      foreach (ISymbol parent in grammar.Symbols) {
-        if (grammar.IsAllowedChildSymbol(parent, startCutPoint.Child.Symbol))
-          grammar.AddAllowedChildSymbol(parent, invokeSym);
-        else {
-          for (int i = 0; i < grammar.GetMaximumSubtreeCount(parent); i++) {
-            if (grammar.IsAllowedChildSymbol(parent, startCutPoint.Child.Symbol, i))
-              grammar.AddAllowedChildSymbol(parent, invokeSym, i);
-          }
-        }
-      }
+      SetAllowedParentSymbols(grammar, startCutPoint.Child.Symbol, invokeSym);
 
       if (nArgs > 0) {
         //set allowed child symbols of invoke symbol 
         foreach (ISymbol child in grammar.Symbols) {
-          if (argumentCutPoints.All(x => grammar.IsAllowedChildSymbol(x.Parent.Symbol, child)))
-            grammar.AddAllowedChildSymbol(invokeSym, child);
-          else {
-            int i = 0;
-            foreach (CutPoint argumentCutPoint in argumentCutPoints) {
-              if (grammar.IsAllowedChildSymbol(argumentCutPoint.Parent.Symbol, child, argumentCutPoint.ChildIndex))
-                grammar.AddAllowedChildSymbol(invokeSym, child, i);
-              i++;
-            }
+          int i = 0;
+          foreach (CutPoint argumentCutPoint in argumentCutPoints) {
+            if (grammar.IsAllowedChildSymbol(argumentCutPoint.Parent.Symbol, child, argumentCutPoint.ChildIndex))
+              grammar.AddAllowedChildSymbol(invokeSym, child, i);
+            i++;
           }
         }
       }
     }
+
+
 
     internal static void AddArgumentSymbol(ISymbolicExpressionTreeGrammar originalGrammar, ISymbolicExpressionTreeGrammar grammar, IEnumerable<int> argumentIndexes, IEnumerable<CutPoint> argumentCutPoints) {
@@ -65 +56 @@
         grammar.SetSubtreeCount(argSymbol, 0, 0);
 
-        foreach (ISymbol parent in originalGrammar.Symbols) {
-          if (parent is StartSymbol || parent is ProgramRootSymbol) continue;
-          if (originalGrammar.IsAllowedChildSymbol(parent, pair.CutPoint.Child.Symbol))
-            grammar.AddAllowedChildSymbol(parent, argSymbol);
+        foreach (var symb in grammar.Symbols) {
+          if (symb is ProgramRootSymbol || symb is StartSymbol) continue;
+          if (originalGrammar.IsAllowedChildSymbol(symb, pair.CutPoint.Child.Symbol))
+            grammar.AddAllowedChildSymbol(symb, argSymbol);
           else {
-            for (int i = 0; i < originalGrammar.GetMaximumSubtreeCount(parent); i++) {
-              if (originalGrammar.IsAllowedChildSymbol(parent, pair.CutPoint.Child.Symbol, i))
-                grammar.AddAllowedChildSymbol(parent, argSymbol, i);
+            for (int i = 0; i < grammar.GetMaximumSubtreeCount(symb); i++) {
+              if (originalGrammar.IsAllowedChildSymbol(symb, pair.CutPoint.Child.Symbol, i))
+                grammar.AddAllowedChildSymbol(symb, argSymbol, i);
             }
+          }
+        }
+      }
+    }
+
+    internal static void SetAllowedParentSymbols(ISymbolicExpressionTreeGrammar grammar, ISymbol symbol, ISymbol newSymbol) {
+      foreach (var symb in grammar.Symbols) {
+        if (symb is ProgramRootSymbol) continue;
+        if (newSymbol is Argument && symb is StartSymbol) continue;
+        if (grammar.IsAllowedChildSymbol(symb, symbol))
+          grammar.AddAllowedChildSymbol(symb, newSymbol);
+        else {
+          for (int i = 0; i < grammar.GetMaximumSubtreeCount(symb); i++) {
+            if (grammar.IsAllowedChildSymbol(symb, symbol, i))
+              grammar.AddAllowedChildSymbol(symb, newSymbol, i);
           }
         }

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

@@ -89 +89 @@
               for (int i = 0; i < subtree.Grammar.GetMaximumSubtreeCount(symbol); i++)
                 if (subtree.Grammar.IsAllowedChildSymbol(symbol, matchingInvokeSymbol, i))
-                  subtree.Grammar.AddAllowedChildSymbol(symbol, matchingInvokeSymbol, i);
+                  subtree.Grammar.AddAllowedChildSymbol(symbol, invokeSymbol, i);
             }
           }