Changeset 15834 for branches/2886_SymRegGrammarEnumeration

Timestamp:

03/08/18 11:42:18 (7 years ago)

Author:

lkammere

Message:

#2886: Store production rules in grammar instead of nonterminal symbols.

Location:

branches/2886_SymRegGrammarEnumeration

Files:

• HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration/GrammarEnumeration/Grammar.cs (modified) (3 diffs)
• HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration/GrammarEnumeration/GrammarEnumerationAlgorithm.cs (modified) (1 diff)
• HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration/GrammarEnumeration/Symbol.cs (modified) (1 diff)
• SymRegGrammarEnumeration.sln (modified) (1 diff)
• Test/GrammarEnumerationTest.cs (modified) (3 diffs)
• Test/TreeHashingTest.cs (modified) (1 diff)

branches/2886_SymRegGrammarEnumeration/HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration/GrammarEnumeration/Grammar.cs

@@ -14 +14 @@
 
     #region Symbols
-    public VariableSymbol Var;
+
+    public IReadOnlyDictionary<Symbol, IReadOnlyList<Production>> Productions { get; }
+
+    public NonterminalSymbol Var;
+    public IReadOnlyList<VariableTerminalSymbol> VarTerminals;
 
     public NonterminalSymbol Expr;
@@ -65 +69 @@
     public Grammar(string[] variables) {
       #region Define Symbols
-      Var = new VariableSymbol("var", variables);
+      Var = new NonterminalSymbol("Var");
 
       Expr = new NonterminalSymbol("Expr");
@@ -96 +100 @@
       StartSymbol = Expr;
 
-      Expr.AddProduction(Term, Expr, Addition);
-      Expr.AddProduction(Term);
-
-      Term.AddProduction(Factor, Term, Multiplication);
-      Term.AddProduction(Factor);
-      Term.AddProduction(InvExpr, Inv);
-
-      Factor.AddProduction(Var);
-      Factor.AddProduction(LogFactor);
-      Factor.AddProduction(ExpFactor);
-      Factor.AddProduction(SinFactor);
-      Factor.AddProduction(CosFactor);
-
-      LogFactor.AddProduction(SimpleExpr, Log);
-      ExpFactor.AddProduction(SimpleTerm, Exp);
-      SinFactor.AddProduction(SimpleExpr, Sin);
-      CosFactor.AddProduction(SimpleExpr, Cos);
-
-      SimpleExpr.AddProduction(SimpleTerm, SimpleExpr, Addition);
-      SimpleExpr.AddProduction(SimpleTerm);
-
-      SimpleTerm.AddProduction(Var, SimpleTerm, Multiplication);
-      SimpleTerm.AddProduction(Var);
-
-      InvExpr.AddProduction(InvTerm, InvExpr, Addition);
-      InvExpr.AddProduction(InvTerm);
-
-      InvTerm.AddProduction(Factor, InvTerm, Multiplication);
-      InvTerm.AddProduction(Factor);
+      Dictionary<Symbol, IReadOnlyList<Production>> productions = new Dictionary<Symbol, IReadOnlyList<Production>>();
+
+      // Map each variable to a separate production rule of the "Var" nonterminal symbol.
+      VarTerminals = variables.Select(v => new VariableTerminalSymbol(v)).ToArray();
+      productions[Var] = VarTerminals.Select(v => new Production(v)).ToArray();
+
+      productions[Expr] = new[] {
+        new Production(Term, Expr, Addition),
+        new Production(Term)
+      };
+
+      productions[Term] = new[] {
+        new Production(Factor, Term, Multiplication),
+        new Production(Factor),
+        new Production(InvExpr, Inv)
+      };
+
+      productions[Factor] = new[] {
+        new Production(Var),
+        new Production(LogFactor),
+        new Production(ExpFactor),
+        new Production(SinFactor),
+        new Production(CosFactor),
+      };
+
+      productions[LogFactor] = new[] { new Production(SimpleExpr, Log) };
+      productions[ExpFactor] = new[] { new Production(SimpleTerm, Exp) };
+      productions[SinFactor] = new[] { new Production(SimpleExpr, Sin) };
+      productions[CosFactor] = new[] { new Production(SimpleExpr, Cos) };
+
+      productions[SimpleExpr] = new[] {
+        new Production(SimpleTerm, SimpleExpr, Addition),
+        new Production(SimpleTerm)
+      };
+
+      productions[SimpleTerm] = new[] {
+        new Production(Var, SimpleTerm, Multiplication),
+        new Production(Var)
+      };
+
+      productions[InvExpr] = new[] {
+        new Production(InvTerm, InvExpr, Addition),
+        new Production(InvTerm)
+      };
+
+      productions[InvTerm] = new[] {
+        new Production(Factor, InvTerm, Multiplication),
+        new Production(Factor)
+      };
+
+      Productions = productions;
       #endregion
 

branches/2886_SymRegGrammarEnumeration/HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration/GrammarEnumeration/GrammarEnumerationAlgorithm.cs

@@ -152 +152 @@
         int nonterminalSymbolIndex = currPhrase.NextNonterminalIndex();
         NonterminalSymbol expandedSymbol = (NonterminalSymbol)currPhrase[nonterminalSymbolIndex];
-        var appliedProductions = expandedSymbol.Alternatives;
+        var appliedProductions = Grammar.Productions[expandedSymbol];
 
         for (int i = 0; i < appliedProductions.Count; i++) {

branches/2886_SymRegGrammarEnumeration/HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration/GrammarEnumeration/Symbol.cs

@@ -60 +60 @@
 
   public class NonterminalSymbol : Symbol {
-    private readonly List<Production> alternatives;
-
-    public IReadOnlyList<Production> Alternatives {
-      get { return alternatives.AsReadOnly(); }
-    }
-
-    public NonterminalSymbol(string representation) : base(representation) {
-      alternatives = new List<Production>();
-    }
-
-    public void AddProduction(params Symbol[] production) {
-      alternatives.Add(new Production(production));
-    }
-  }
-
-  public class VariableSymbol : NonterminalSymbol { // Convenience class
-    public IEnumerable<VariableTerminalSymbol> VariableTerminalSymbols { get; }
-
-    public VariableSymbol(string representation, IEnumerable<string> variableNames) : base(representation) {
-      List<VariableTerminalSymbol> createdSymbols = new List<VariableTerminalSymbol>();
-      VariableTerminalSymbols = createdSymbols;
-
-      foreach (string variableName in variableNames) {
-        VariableTerminalSymbol s = new VariableTerminalSymbol(variableName);
-        createdSymbols.Add(s);
-        AddProduction(s);
-      }
-    }
+    public NonterminalSymbol(string representation) : base(representation) { }
   }
 

branches/2886_SymRegGrammarEnumeration/SymRegGrammarEnumeration.sln

@@ -9 +9 @@
 EndProject
 Global
-  GlobalSection(Performance) = preSolution
-    HasPerformanceSessions = true
-  EndGlobalSection
   GlobalSection(SolutionConfigurationPlatforms) = preSolution
     Debug|Any CPU = Debug|Any CPU

branches/2886_SymRegGrammarEnumeration/Test/GrammarEnumerationTest.cs

@@ -62 +62 @@
       alg.Start();
 
-      TerminalSymbol varSymbol = alg.Grammar.Var.VariableTerminalSymbols.First();
+      TerminalSymbol varSymbol = alg.Grammar.VarTerminals.First();
       TerminalSymbol mulSymbol = alg.Grammar.Multiplication;
       TerminalSymbol addSymbol = alg.Grammar.Addition;
@@ -117 +117 @@
       alg.Start();
 
-      TerminalSymbol varSymbol = alg.Grammar.Var.VariableTerminalSymbols.First();
+      TerminalSymbol varSymbol = alg.Grammar.VarTerminals.First();
       TerminalSymbol mulSymbol = alg.Grammar.Multiplication;
       TerminalSymbol addSymbol = alg.Grammar.Addition;
@@ -145 +145 @@
       alg.Start();
 
-      TerminalSymbol xSymbol = alg.Grammar.Var.VariableTerminalSymbols.First(v => v.StringRepresentation == "X");
-      TerminalSymbol ySymbol = alg.Grammar.Var.VariableTerminalSymbols.First(v => v.StringRepresentation == "Y");
+      TerminalSymbol xSymbol = alg.Grammar.VarTerminals.First(v => v.StringRepresentation == "X");
+      TerminalSymbol ySymbol = alg.Grammar.VarTerminals.First(v => v.StringRepresentation == "Y");
       TerminalSymbol mulSymbol = alg.Grammar.Multiplication;
       TerminalSymbol addSymbol = alg.Grammar.Addition;

branches/2886_SymRegGrammarEnumeration/Test/TreeHashingTest.cs

@@ -17 +17 @@
       grammar = new Grammar(new[] { "a", "b", "c" });
 
-      varA = grammar.Var.VariableTerminalSymbols.First(s => s.StringRepresentation == "a");
-      varB = grammar.Var.VariableTerminalSymbols.First(s => s.StringRepresentation == "b");
-      varC = grammar.Var.VariableTerminalSymbols.First(s => s.StringRepresentation == "c");
+      varA = grammar.VarTerminals.First(s => s.StringRepresentation == "a");
+      varB = grammar.VarTerminals.First(s => s.StringRepresentation == "b");
+      varC = grammar.VarTerminals.First(s => s.StringRepresentation == "c");
     }