Changeset 10386 for branches/HeuristicLab.Problems.GPDL/CodeGenerator/ProblemCodeGen.cs

Timestamp:

01/22/14 19:27:04 (11 years ago)

Author:

gkronber

Message:

#2026 refactoring

File:

• branches/HeuristicLab.Problems.GPDL/CodeGenerator/ProblemCodeGen.cs (modified) (9 diffs)

branches/HeuristicLab.Problems.GPDL/CodeGenerator/ProblemCodeGen.cs

@@ -18 +18 @@
     private const string problemTemplate = @"
 namespace ?PROBLEMNAME? {
-#region class definitions for tree
-  public class Tree {
-    public int altIdx;
-    public List<Tree> subtrees;
-    protected Tree() {
-      // leave subtrees uninitialized
-    }
-    public Tree(int state, int altIdx, int numSubTrees) {
-      subtrees = new List<Tree>();
-      this.altIdx = altIdx;
-    }
-  }
-
-  ?TERMINALNODECLASSDEFINITIONS?
-#endregion
-
   public sealed class ?IDENT?Problem {
    
@@ -54 +38 @@
 #endregion
     }
+    public bool IsBetter(double a, double b) { 
+      return ?MAXIMIZATION? ? a > b : a < b;
+    }
 
 // additional code from the problem definition (CODE section)
@@ -68 +55 @@
 #endregion
   }
+
+#region class definitions for tree
+  public class Tree {
+    public int altIdx;
+    public Tree[] subtrees;
+    protected Tree() {
+      // leave subtrees uninitialized
+    }
+    public Tree(int altIdx, Tree[] subtrees) {
+      this.altIdx = altIdx;
+      this.subtrees = subtrees;
+    }
+  }
+
+  ?TERMINALNODECLASSDEFINITIONS?
+#endregion
+
+#region helper class for the grammar representation
+  public class Grammar {
+    public static readonly Dictionary<int, int[]> transition = new Dictionary<int, int[]>() {
+?TRANSITIONTABLE?
+    };
+    public static readonly Dictionary<int, int> subtreeCount = new Dictionary<int, int>() {
+       { -1, 0 }, // terminals
+?SUBTREECOUNTTABLE?
+    };
+    public static readonly string[] symb = new string[] { ?SYMBOLNAMES? };
+    
+    public static Tree CreateTerminalNode(int state, Random random, ?IDENT?Problem problem) {
+      switch(state) {
+        ?CREATETERMINALNODECODE?
+        default: { throw new ArgumentException(""Unknown state index"" + state); }
+      }
+    }
+  }  
+#endregion
 }";
 
@@ -97 +120 @@
         .AppendLine(problemTemplate)
         .Replace("?FITNESSFUNCTION?", ast.FitnessFunctionNode.SrcCode)
+        .Replace("?MAXIMIZATION?", ast.FitnessFunctionNode.Maximization.ToString().ToLowerInvariant())
         .Replace("?INITSOURCE?", ast.InitCodeNode.SrcCode)
         .Replace("?ADDITIONALCODE?", ast.ClassCodeNode.SrcCode)
@@ -102 +126 @@
         .Replace("?CONSTRAINTSSOURCE?", GenerateConstraintMethods(ast.Terminals))
         .Replace("?TERMINALNODECLASSDEFINITIONS?", GenerateTerminalNodeClassDefinitions(ast.Terminals.OfType<TerminalNode>()))
+        .Replace("?SYMBOLNAMES?", grammar.Symbols.Select(s => s.Name).Aggregate(string.Empty, (str, symb) => str + "\"" + symb + "\", "))
+        .Replace("?TRANSITIONTABLE?", GenerateTransitionTable(grammar))
+        .Replace("?CREATETERMINALNODECODE?", GenerateCreateTerminalCode(grammar))
+        .Replace("?SUBTREECOUNTTABLE?", GenerateSubtreeCountTable(grammar))
        ;
     }
@@ -190 +218 @@
           sb.AppendFormat("public {0} GetMax{1}_{2}() {{ return {3}; }}", fieldType, t.Ident, c.Ident, c.RangeMaxExpression).AppendLine();
           sb.AppendFormat("public {0} GetMin{1}_{2}() {{ return {3}; }}", fieldType, t.Ident, c.Ident, c.RangeMinExpression).AppendLine();
-          //sb.AppendFormat("public {0} Get{1}_{2}(ISolverState _state) {{ _state. }}", fieldType, t.Ident, c.Ident, )
         } else if (c.Type == ConstraintNodeType.Set) {
           sb.AppendFormat("public IEnumerable<{0}> GetAllowed{1}_{2}() {{ return {3}; }}", fieldType, t.Ident, c.Ident, c.SetExpression).AppendLine();
@@ -289 +316 @@
     }
 
-    private void GenerateSwitchStatement(IEnumerable<Sequence> alts, SourceBuilder sb) {
+    private void GenerateSwitchStatement(IEnumerable<Sequence> alts, SourceBuilder sb)
+    {
       sb.Append("switch(_t.altIdx) {").BeginBlock();
       // generate a case for each alternative
-      int i = 0;
+      int altIdx = 0;
       foreach (var alt in alts) {
-        sb.AppendFormat("case {0}: {{ ", i).BeginBlock();
+        sb.AppendFormat("case {0}: {{ ", altIdx).BeginBlock();
 
         // this only works for alternatives with a single non-terminal symbol (ignoring semantic symbols)!
@@ -302 +330 @@
           GenerateSourceForAction(0, altSymb, sb); // index is always 0 because of the assertion above
         }
-        i++;
+        altIdx++;
         sb.AppendLine("break;").Append("}").EndBlock();
       }
@@ -333 +361 @@
       sb.Append("}").EndBlock();
     }
+
+    private string GenerateCreateTerminalCode(IGrammar grammar) {
+      Debug.Assert(grammar.Symbols.First().Equals(grammar.StartSymbol));
+      var sb = new SourceBuilder();
+      var allSymbols = grammar.Symbols.ToList();
+      foreach (var s in grammar.Symbols) {
+        if (grammar.IsTerminal(s)) {
+          sb.AppendFormat("case {0}: {{ return new {1}Tree(random, problem); }}", allSymbols.IndexOf(s), s.Name).AppendLine();
+        }
+      }
+      return sb.ToString();
+    }
+
+    private string GenerateTransitionTable(IGrammar grammar) {
+      Debug.Assert(grammar.Symbols.First().Equals(grammar.StartSymbol));
+      var sb = new SourceBuilder();
+
+      // state idx = idx of the corresponding symbol in the grammar
+      var allSymbols = grammar.Symbols.ToList();
+      foreach (var s in grammar.Symbols) {
+        var targetStates = new List<int>();
+        if (grammar.IsTerminal(s)) {
+        } else {
+          if (grammar.NumberOfAlternatives(s) > 1) {
+            foreach (var alt in grammar.GetAlternatives(s)) {
+              // only single-symbol alternatives are supported
+              Debug.Assert(alt.Count() == 1);
+              targetStates.Add(allSymbols.IndexOf(alt.Single()));
+            }
+          } else {
+            // rule is a sequence of symbols
+            var seq = grammar.GetAlternatives(s).Single();
+            targetStates.AddRange(seq.Select(symb => allSymbols.IndexOf(symb)));
+          }
+        }
+
+        var targetStateString = targetStates.Aggregate(string.Empty, (str, state) => str + state + ", ");
+
+        var idxOfSourceState = allSymbols.IndexOf(s);
+        sb.AppendFormat("// {0}", s).AppendLine();
+        sb.AppendFormat("{{ {0} , new int[] {{ {1} }} }},", idxOfSourceState, targetStateString).AppendLine();
+      }
+      return sb.ToString();
+    }
+    private string GenerateSubtreeCountTable(IGrammar grammar) {
+      Debug.Assert(grammar.Symbols.First().Equals(grammar.StartSymbol));
+      var sb = new SourceBuilder();
+
+      // state idx = idx of the corresponding symbol in the grammar
+      var allSymbols = grammar.Symbols.ToList();
+      foreach (var s in grammar.Symbols) {
+        int subtreeCount = 0;
+        if (grammar.IsTerminal(s)) {
+        } else {
+          if (grammar.NumberOfAlternatives(s) > 1) {
+            Debug.Assert(grammar.GetAlternatives(s).All(alt => alt.Count() == 1));
+            subtreeCount = 1;
+          } else {
+            subtreeCount = grammar.GetAlternative(s, 0).Count();
+          }
+        }
+
+        sb.AppendFormat("// {0}", s).AppendLine();
+        sb.AppendFormat("{{ {0} , {1} }},", allSymbols.IndexOf(s), subtreeCount).AppendLine();
+      }
+
+      return sb.ToString();
+    }
+
   }
 }