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

Timestamp:

07/27/18 19:28:18 (6 years ago)

Author:

bburlacu

Message:

#2886:

• replace functionally-overlapping classes Production and SymbolString with a single class SymbolList
• refactor methods from Grammar class as methods and properties of SymbolList
• add parameter for the number of constant optimization iterations
• refactor code

File:

• branches/2886_SymRegGrammarEnumeration/HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration/GrammarEnumeration/Grammar.cs (modified) (5 diffs)

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

@@ -28 +28 @@
     #region Symbols
 
-    public IReadOnlyDictionary<Symbol, IReadOnlyList<Production>> Productions { get; private set; }
+    public IReadOnlyDictionary<Symbol, IReadOnlyList<SymbolList>> Productions { get; private set; }
 
     public NonterminalSymbol Var;
@@ -85 +85 @@
       infixExpressionFormatter = cloner.Clone(original.infixExpressionFormatter);
 
-      Productions = original.Productions.ToDictionary(x => cloner.Clone(x.Key), x => (IReadOnlyList<Production>)x.Value.Select(cloner.Clone).ToList());
+      Productions = original.Productions.ToDictionary(x => cloner.Clone(x.Key), x => (IReadOnlyList<SymbolList>)x.Value.Select(cloner.Clone).ToList());
       VarTerminals = original.VarTerminals.Select(cloner.Clone).ToList();
 
@@ -144 +144 @@
       StartSymbol = Expr;
 
-      Dictionary<Symbol, IReadOnlyList<Production>> productions = new Dictionary<Symbol, IReadOnlyList<Production>>();
+      Dictionary<Symbol, IReadOnlyList<SymbolList>> productions = new Dictionary<Symbol, IReadOnlyList<SymbolList>>();
 
       // 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[Var] = VarTerminals.Select(v => new SymbolList(v)).ToArray();
 
       // Expression Grammar Rules
-      var exprProductions = new List<Production>();
+      var exprProductions = new List<SymbolList>();
       if (includedRules.Contains(GrammarRule.MultipleTerms))
-        exprProductions.Add(new Production(Const, Term, Multiplication, Expr, Addition));
-
-      exprProductions.Add(new Production(Const, Term, Multiplication, Const, Addition));
+        exprProductions.Add(new SymbolList(Const, Term, Multiplication, Expr, Addition));
+
+      exprProductions.Add(new SymbolList(Const, Term, Multiplication, Const, Addition));
       productions[Expr] = exprProductions.ToArray();
 
       // Term Grammar Rules
-      var termProductions = new List<Production>();
+      var termProductions = new List<SymbolList>();
       if (includedRules.Contains(GrammarRule.MultipleFactors))
-        termProductions.Add(new Production(Factor, Term, Multiplication));
+        termProductions.Add(new SymbolList(Factor, Term, Multiplication));
       if (includedRules.Contains(GrammarRule.InverseTerm))
-        termProductions.Add(new Production(InvExpr, Inv));
-      termProductions.Add(new Production(Factor));
+        termProductions.Add(new SymbolList(InvExpr, Inv));
+      termProductions.Add(new SymbolList(Factor));
       productions[Term] = termProductions.ToArray();
 
       // Factor Grammar Rules
-      var factorProductions = new List<Production>();
-      factorProductions.Add(new Production(Var));
+      var factorProductions = new List<SymbolList>();
+      factorProductions.Add(new SymbolList(Var));
       if (includedRules.Contains(GrammarRule.Logarithm))
-        factorProductions.Add(new Production(LogFactor));
+        factorProductions.Add(new SymbolList(LogFactor));
       if (includedRules.Contains(GrammarRule.Exponentiation))
-        factorProductions.Add(new Production(ExpFactor));
+        factorProductions.Add(new SymbolList(ExpFactor));
       if (includedRules.Contains(GrammarRule.Sine))
-        factorProductions.Add(new Production(SinFactor));
+        factorProductions.Add(new SymbolList(SinFactor));
       productions[Factor] = factorProductions.ToArray();
 
-      productions[LogFactor] = new[] { new Production(SimpleExpr, Log) };
-      productions[ExpFactor] = new[] { new Production(Const, SimpleTerm, Multiplication, Exp) };
-      productions[SinFactor] = new[] { new Production(SimpleExpr, Sin) };
+      productions[LogFactor] = new[] { new SymbolList(SimpleExpr, Log) };
+      productions[ExpFactor] = new[] { new SymbolList(Const, SimpleTerm, Multiplication, Exp) };
+      productions[SinFactor] = new[] { new SymbolList(SimpleExpr, Sin) };
 
       productions[SimpleExpr] = new[] {
-        new Production(Const, SimpleTerm, Multiplication, SimpleExpr, Addition),
-        new Production(Const, SimpleTerm, Multiplication, Const, Addition)
+        new SymbolList(Const, SimpleTerm, Multiplication, SimpleExpr, Addition),
+        new SymbolList(Const, SimpleTerm, Multiplication, Const, Addition)
       };
 
       productions[SimpleTerm] = new[] {
-        new Production(Var, SimpleTerm, Multiplication),
-        new Production(Var)
+        new SymbolList(Var, SimpleTerm, Multiplication),
+        new SymbolList(Var)
       };
 
       productions[InvExpr] = new[] {
-        new Production(Const, InvTerm, Multiplication, InvExpr, Addition),
-        new Production(Const, InvTerm, Multiplication, Const, Addition)
+        new SymbolList(Const, InvTerm, Multiplication, InvExpr, Addition),
+        new SymbolList(Const, InvTerm, Multiplication, Const, Addition)
       };
 
       productions[InvTerm] = new[] {
-        new Production(Factor, InvTerm, Multiplication),
-        new Production(Factor)
+        new SymbolList(Factor, InvTerm, Multiplication),
+        new SymbolList(Factor)
       };
 
@@ -234 +234 @@
     }
 
-    public int GetComplexity(SymbolString s) {
-      int c = 0;
-      int length = s.Count();
-      for (int i = 0; i < length; i++) {
-        if (s[i] is NonterminalSymbol || s[i] is VariableTerminalSymbol) c++;
-      }
-      return c;
-    }
-
     // returns the maximum achievable sentence length below the maximum complexity
     public int GetMaxSentenceLength(int maxComplexity) {
-      SymbolString s = new SymbolString(StartSymbol);
-
-      while (!s.IsSentence() && GetComplexity(s) <= maxComplexity) {
+      SymbolList s = new SymbolList(StartSymbol);
+
+      while (!s.IsSentence() && s.Complexity <= maxComplexity) {
         int expandedSymbolIndex = s.NextNonterminalIndex();
         NonterminalSymbol expandedSymbol = (NonterminalSymbol)s[expandedSymbolIndex];
 
         var productions = Productions[expandedSymbol];
-        var longestProduction = productions // Find production with most terminal symbols to expand as much as possible...
-          .OrderBy(CountTerminals)          // but with lowest complexity/nonterminal count to keep complexity low.                                                                                     
-          .ThenByDescending(CountNonTerminals)
+        var longestProduction = productions                // Find production with most terminal symbols to expand as much as possible...
+          .OrderBy(x => x.TerminalSymbolCount)             // but with lowest complexity/nonterminal count to keep complexity low.                                                                                     
+          .ThenByDescending(x => x.NonTerminalSymbolCount)
           .First();
 
         s = s.DerivePhrase(expandedSymbolIndex, longestProduction);
       }
-
-      return s.Count();
-    }
-
-    private int CountTerminals(Production p) {
-      return p.Count(s => s is TerminalSymbol);
-    }
-
-    private int CountNonTerminals(Production p) {
-      return p.Count(s => s is NonterminalSymbol);
-    }
-
-    public double EvaluatePhrase(SymbolString s, IRegressionProblemData problemData, bool optimizeConstants) {
+      return s.Count;
+    }
+
+    public double EvaluatePhrase(SymbolList s, IRegressionProblemData problemData, bool optimizeConstants, int iterations) {
       SymbolicExpressionTree tree = ParseSymbolicExpressionTree(s);
 
-      return RSquaredEvaluator.Evaluate(problemData, tree, optimizeConstants);
+      return RSquaredEvaluator.Evaluate(problemData, tree, optimizeConstants, iterations);
     }
 
     #region Parse to SymbolicExpressionTree
 
-    public string ToInfixString(SymbolString sentence) {
+    public string ToInfixString(SymbolList sentence) {
       Debug.Assert(sentence.Any(), "Trying to evaluate empty sentence!");
       Debug.Assert(sentence.All(s => s is TerminalSymbol), "Trying to evaluate symbol sequence with nonterminalsymbols!");
@@ -286 +268 @@
     }
 
-    public SymbolicExpressionTree ParseSymbolicExpressionTree(SymbolString sentence) {
+    public SymbolicExpressionTree ParseSymbolicExpressionTree(SymbolList sentence) {
       Debug.Assert(sentence.Any(), "Trying to evaluate empty sentence!");