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

Timestamp:

03/15/11 13:34:38 (13 years ago)

Author:

mkommend

Message:

#1418: Finally added results from the grammar refactoring.

File:

• branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/ArchitectureManipulators/GrammarModifier.cs (modified) (1 diff)

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

@@ -21 +21 @@
 
 using System.Collections.Generic;
+using System.Linq;
 
 namespace HeuristicLab.Encodings.SymbolicExpressionTreeEncoding {
   public static class GrammarModifier {
-    public static void AddDynamicSymbol(ISymbolicExpressionTreeGrammar grammar, ISymbol classRepresentative, string symbolName, int nArgs) {
-      var invokeSym = new InvokeFunction(symbolName);
+    internal static void AddInvokeSymbol(ISymbolicExpressionTreeGrammar grammar, string functionName, int nArgs, CutPoint startCutPoint, IEnumerable<CutPoint> argumentCutPoints) {
+      var invokeSym = new InvokeFunction(functionName);
       grammar.AddSymbol(invokeSym);
-      grammar.SetMinSubtreeCount(invokeSym, nArgs);
-      grammar.SetMaxSubtreeCount(invokeSym, nArgs);
-      SetSyntaxConstraints(grammar, classRepresentative, invokeSym);
-    }
+      grammar.SetSubtreeCount(invokeSym, nArgs, nArgs);
 
+      //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);
+          }
+        }
+      }
 
-    public static void AddDynamicArguments(ISymbolicExpressionTreeGrammar grammar, ISymbol classRepresentative, IEnumerable<int> argumentIndexes) {
-      foreach (int argIndex in argumentIndexes) {
-        var argSymbol = new Argument(argIndex);
-        grammar.AddSymbol(argSymbol);
-        grammar.SetMinSubtreeCount(argSymbol, 0);
-        grammar.SetMaxSubtreeCount(argSymbol, 0);
-        SetSyntaxConstraints(grammar, classRepresentative, argSymbol);
+      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++;
+            }
+          }
+        }
       }
     }
 
-    private static void SetSyntaxConstraints(ISymbolicExpressionTreeGrammar grammar, ISymbol classRepresentative, Symbol newSymbol) {
-      // allow symbol as child of the representative first to make sure that the symbol 
-      // is in the list of parents and children
-      for (int i = 0; i < grammar.GetMaxSubtreeCount(classRepresentative); i++) {
-        grammar.SetAllowedChild(classRepresentative, newSymbol, i);
-      }
-      // for all available symbols add the new symbol as allowed child iff the available symbol is an allowed child of the class representative
-      foreach (var parent in grammar.Symbols) {
-        if (grammar.IsAllowedChild(classRepresentative, parent, 0))
-          for (int arg = 0; arg < grammar.GetMaxSubtreeCount(parent); arg++) {
-            grammar.SetAllowedChild(parent, newSymbol, arg);
+    internal static void AddArgumentSymbol(ISymbolicExpressionTreeGrammar originalGrammar, ISymbolicExpressionTreeGrammar grammar, IEnumerable<int> argumentIndexes, IEnumerable<CutPoint> argumentCutPoints) {
+      foreach (var pair in argumentIndexes.Zip(argumentCutPoints, (a, b) => new { Index = a, CutPoint = b })) {
+        var argSymbol = new Argument(pair.Index);
+        grammar.AddSymbol(argSymbol);
+        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);
+          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 all available symbols add the new symbol as allowed parent iff the available symbol is an allowed child of the class representative
-      foreach (var child in grammar.Symbols) {
-        if (grammar.IsAllowedChild(classRepresentative, child, 0))
-          for (int arg = 0; arg < grammar.GetMaxSubtreeCount(newSymbol); arg++) {
-            grammar.SetAllowedChild(newSymbol, child, arg);
-          }
+        }
       }
     }
-
   }
 }