Changeset 16026

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

Location:

branches/2886_SymRegGrammarEnumeration

Files:

• HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration/Analysis/RSquaredEvaluator.cs (modified) (7 diffs)
• HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration/Analysis/SearchGraphVisualizer.cs (modified) (1 diff)
• HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration/Analysis/SentenceLogger.cs (modified) (2 diffs)
• HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration/GrammarEnumeration/Grammar.cs (modified) (5 diffs)
• HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration/GrammarEnumeration/GrammarEnumerationAlgorithm.cs (modified) (18 diffs)
• HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration/GrammarEnumeration/SearchDataStructure.cs (modified) (3 diffs)
• HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration/GrammarEnumeration/Sentence.cs (modified) (1 diff)
• HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration/GrammarEnumeration/Symbol.cs (modified) (2 diffs)
• HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration/GrammarEnumeration/SymbolList.cs (added)
• HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration/Hashing/Hasher.cs (modified) (1 diff)
• HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration/HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration.csproj (modified) (1 diff)
• Test/GrammarEnumerationTest.cs (modified) (11 diffs)
• Test/TreeHashingTest.cs (modified) (13 diffs)

branches/2886_SymRegGrammarEnumeration/HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration/Analysis/RSquaredEvaluator.cs

@@ -1 +1 @@
 using System;
 using System.Diagnostics;
-using HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration.GrammarEnumeration;
 using HeuristicLab.Analysis;
 using HeuristicLab.Common;
@@ -51 +50 @@
     private void AlgorithmOnDistinctSentenceGenerated(object sender, PhraseAddedEventArgs phraseAddedEventArgs) {
       GrammarEnumerationAlgorithm algorithm = (GrammarEnumerationAlgorithm)sender;
-      EvaluateSentence(algorithm, phraseAddedEventArgs.NewPhrase, algorithm.OptimizeConstants);
+      EvaluateSentence(algorithm, phraseAddedEventArgs.NewPhrase, algorithm.OptimizeConstants, algorithm.ConstantOptimizationIterations);
     }
 
@@ -69 +68 @@
     }
 
-    private void EvaluateSentence(GrammarEnumerationAlgorithm algorithm, SymbolString symbolString, bool optimizeConstants) {
+    private void EvaluateSentence(GrammarEnumerationAlgorithm algorithm, SymbolList sentence, bool optimizeConstants, int maxIterations) {
       var results = algorithm.Results;
       var grammar = algorithm.Grammar;
       var problemData = algorithm.Problem.ProblemData;
 
-      SymbolicExpressionTree tree = algorithm.Grammar.ParseSymbolicExpressionTree(symbolString);
+      SymbolicExpressionTree tree = algorithm.Grammar.ParseSymbolicExpressionTree(sentence);
       Debug.Assert(SymbolicRegressionConstantOptimizationEvaluator.CanOptimizeConstants(tree));
 
-      double r2 = Evaluate(problemData, tree, optimizeConstants);
+      double r2 = Evaluate(problemData, tree, optimizeConstants, maxIterations);
       double bestR2 = results.ContainsKey(BestTrainingQualityResultName) ? GetValue<double>(results[BestTrainingQualityResultName].Value) : 0.0;
       if (r2 < bestR2)
@@ -83 +82 @@
 
       var bestComplexity = results.ContainsKey(BestComplexityResultName) ? GetValue<int>(results[BestComplexityResultName].Value) : int.MaxValue;
-      var complexity = grammar.GetComplexity(symbolString);
+      var complexity = sentence.Complexity;
 
       if (algorithm.BestTrainingSentence == null || r2 > bestR2 || (r2.IsAlmost(bestR2) && complexity < bestComplexity)) {
-        algorithm.BestTrainingSentence = symbolString;
+        algorithm.BestTrainingSentence = sentence;
 
         var model = new SymbolicRegressionModel(problemData.TargetVariable, tree, expressionTreeLinearInterpreter);
@@ -110 +109 @@
         dt = (DataTable)results[BestSolutions].Value;
         dt.Rows["Quality"].Values.Add(r2);
-        dt.Rows["Relative Length"].Values.Add((double)symbolString.Count() / algorithm.MaxSentenceLength);
+        dt.Rows["Relative Length"].Values.Add((double)sentence.Count);
         dt.Rows["Complexity"].Values.Add(complexity);
         dt.Rows["Timestamp"].Values.Add(algorithm.ExecutionTime.TotalMilliseconds / 1000d);
@@ -116 +115 @@
     }
 
-    public static double Evaluate(IRegressionProblemData problemData, SymbolicExpressionTree tree, bool optimizeConstants = true) {
+    public static double Evaluate(IRegressionProblemData problemData, SymbolicExpressionTree tree, bool optimizeConstants = true, int maxIterations = 10) {
       double r2;
 
@@ -127 +126 @@
           problemData.TrainingIndices,
           applyLinearScaling: true,
-          maxIterations: 10,
+          maxIterations: maxIterations,
           updateVariableWeights: false,
           updateConstantsInTree: true);

branches/2886_SymRegGrammarEnumeration/HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration/Analysis/SearchGraphVisualizer.cs

@@ -55 +55 @@
       try {
         var alg = (GrammarEnumerationAlgorithm)sender;
-        var phrase0 = new SymbolString(new[] { alg.Grammar.StartSymbol });
+        var phrase0 = new SymbolList(new[] { alg.Grammar.StartSymbol });
         var phrase0Hash = alg.Grammar.Hasher.CalcHashCode(phrase0);
 

branches/2886_SymRegGrammarEnumeration/HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration/Analysis/SentenceLogger.cs

@@ -89 +89 @@
       distinctSentencesFileTrace.WriteLine(ToCsvLine(
         ((uint)phraseAddedEventArgs.NewHash).ToString("D10"),
-        phraseAddedEventArgs.NewPhrase.Count().ToString("D3"),
+        phraseAddedEventArgs.NewPhrase.Count.ToString("D3"),
         //phraseAddedEventArgs.NewPhrase.ToString(),
         ((GrammarEnumerationAlgorithm)sender).Grammar.ToInfixString(phraseAddedEventArgs.NewPhrase)));
@@ -99 +99 @@
       allSentencesFileTrace.WriteLine(ToCsvLine(
         ((uint)phraseAddedEventArgs.NewHash).ToString("D10"),
-        phraseAddedEventArgs.NewPhrase.Count().ToString("D3"),
+        phraseAddedEventArgs.NewPhrase.Count.ToString("D3"),
         //phraseAddedEventArgs.NewPhrase.ToString(),
         ((GrammarEnumerationAlgorithm)sender).Grammar.ToInfixString(phraseAddedEventArgs.NewPhrase)));

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!");
 

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

@@ -32 +32 @@
 
     private readonly string OptimizeConstantsParameterName = "Optimize Constants";
+    private readonly string ConstantOptimizationIterationsParameterName = "Constant Optimization Iterations";
     private readonly string ErrorWeightParameterName = "Error Weight";
     private readonly string SearchDataStructureParameterName = "Search Data Structure";
@@ -55 +56 @@
     }
 
+    public int ConstantOptimizationIterations {
+      get { return ConstantOptimizationIterationsParameter.Value.Value; }
+      set { ConstantOptimizationIterationsParameter.Value.Value = value; }
+    }
+
+    public IFixedValueParameter<IntValue> ConstantOptimizationIterationsParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters[ConstantOptimizationIterationsParameterName]; }
+    }
+
     protected IFixedValueParameter<IntValue> MaxComplexityParameter {
       get { return (IFixedValueParameter<IntValue>)Parameters[MaxComplexityParameterName]; }
@@ -116 +126 @@
 
     [Storable]
-    public SymbolString BestTrainingSentence { get; set; }     // Currently set in RSquaredEvaluator: quite hacky, but makes testing much easier for now...
+    public SymbolList BestTrainingSentence { get; set; }     // Currently set in RSquaredEvaluator: quite hacky, but makes testing much easier for now...
     #endregion
 
@@ -185 +195 @@
       Parameters.Add(new FixedValueParameter<IntValue>(SearchDataStructureSizeParameterName, "The size of the search data structure.", new IntValue((int)1e5)));
       Parameters.Add(new FixedValueParameter<EnumValue<StorageType>>(SearchDataStructureParameterName, new EnumValue<StorageType>(StorageType.SortedSet)));
+      Parameters.Add(new FixedValueParameter<IntValue>(ConstantOptimizationIterationsParameterName, new IntValue(10)));
 
       SearchDataStructureParameter.Value.ValueChanged += (o, e) => Prepare();
@@ -240 +251 @@
     #endregion
 
-    [Storable]
-    private Dictionary<VariableTerminalSymbol, double> variableImportance;
-
     public override void Prepare() {
       DistinctSentencesComplexity = new Dictionary<int, int>();
@@ -259 +267 @@
       if (previousExecutionState != ExecutionState.Paused) {
         InitResults();
-        var phrase0 = new SymbolString(new[] { Grammar.StartSymbol });
+        var phrase0 = new SymbolList(new[] { Grammar.StartSymbol });
         var phrase0Hash = Grammar.Hasher.CalcHashCode(phrase0);
 
@@ -268 +276 @@
       var errorWeight = ErrorWeight;
       var optimizeConstants = OptimizeConstants; // cache value to avoid parameter lookup
+      var iterations = ConstantOptimizationIterations;
       // main search loop
       while (OpenPhrases.Count > 0) {
@@ -278 +287 @@
           continue;
 
-        SymbolString currPhrase = fetchedSearchNode.SymbolString;
+        SymbolList currPhrase = fetchedSearchNode.SymbolList;
 
         OnPhraseFetched(fetchedSearchNode.Hash, currPhrase);
@@ -292 +301 @@
           PhraseExpansionCount++;
 
-          SymbolString newPhrase = currPhrase.DerivePhrase(nonterminalSymbolIndex, appliedProductions[i]);
-          int newPhraseComplexity = Grammar.GetComplexity(newPhrase);
+          SymbolList newPhrase = currPhrase.DerivePhrase(nonterminalSymbolIndex, appliedProductions[i]);
+          int newPhraseComplexity = newPhrase.Complexity;
 
           if (newPhraseComplexity > MaxComplexity)
@@ -300 +309 @@
           var phraseHash = Grammar.Hasher.CalcHashCode(newPhrase);
 
-          OnPhraseDerived(fetchedSearchNode.Hash, fetchedSearchNode.SymbolString, phraseHash, newPhrase, expandedSymbol, appliedProductions[i]);
+          OnPhraseDerived(fetchedSearchNode.Hash, fetchedSearchNode.SymbolList, phraseHash, newPhrase, expandedSymbol, appliedProductions[i]);
 
           if (newPhrase.IsSentence()) {
             AllGeneratedSentencesCount++;
 
-            OnSentenceGenerated(fetchedSearchNode.Hash, fetchedSearchNode.SymbolString, phraseHash, newPhrase, expandedSymbol, appliedProductions[i]);
+            OnSentenceGenerated(fetchedSearchNode.Hash, fetchedSearchNode.SymbolList, phraseHash, newPhrase, expandedSymbol, appliedProductions[i]);
 
             // Is the best solution found? (only if RSquaredEvaluator is activated)
@@ -320 +329 @@
 
               DistinctSentencesComplexity[phraseHash] = newPhraseComplexity;
-              OnDistinctSentenceGenerated(fetchedSearchNode.Hash, fetchedSearchNode.SymbolString, phraseHash, newPhrase, expandedSymbol, appliedProductions[i]);
+              OnDistinctSentenceGenerated(fetchedSearchNode.Hash, fetchedSearchNode.SymbolList, phraseHash, newPhrase, expandedSymbol, appliedProductions[i]);
             }
             UpdateView();
@@ -327 +336 @@
 
             bool isCompleteSentence = IsCompleteSentence(newPhrase);
-            double r2 = isCompleteSentence ? Grammar.EvaluatePhrase(newPhrase, Problem.ProblemData, optimizeConstants) : fetchedSearchNode.R2;
-            double phrasePriority = GetPriority(newPhrase, r2, MaxSentenceLength);
+            double r2 = isCompleteSentence ? Grammar.EvaluatePhrase(newPhrase, Problem.ProblemData, optimizeConstants, iterations) : fetchedSearchNode.R2;
+            double phrasePriority = GetPriority(newPhrase, r2);
 
             SearchNode newSearchNode = new SearchNode(phraseHash, phrasePriority, r2, newPhrase);
@@ -338 +347 @@
     }
 
-    protected static double GetPriority(SymbolString phrase, double r2, int maxSentenceLength) {
-      return (1 - r2) * phrase.Count();
-    }
-
-    private bool IsCompleteSentence(SymbolString phrase) {
+    protected static double GetPriority(SymbolList phrase, double r2) {
+      return (1 - r2) * phrase.Count;
+    }
+
+    private bool IsCompleteSentence(SymbolList phrase) {
       return !phrase.Any(x => x is NonterminalSymbol && x != Grammar.Expr);
     }
@@ -386 +395 @@
         Problem.ProblemData.TrainingIndices,
         applyLinearScaling: true,
-        maxIterations: 10,
+        maxIterations: ConstantOptimizationIterations,
         updateVariableWeights: false,
         updateConstantsInTree: true);
@@ -395 +404 @@
       Results.AddOrUpdateResult(BestTrainingModelResultName, model);
       Results.AddOrUpdateResult(BestTrainingSolutionResultName, bestTrainingSolution);
-      Results.AddOrUpdateResult(BestComplexityResultName, new IntValue(Grammar.GetComplexity(BestTrainingSentence)));
+      Results.AddOrUpdateResult(BestComplexityResultName, new IntValue(BestTrainingSentence.Complexity));
       base.OnStopped();
     }
@@ -450 +459 @@
 
     public event EventHandler<PhraseEventArgs> PhraseFetched;
-    private void OnPhraseFetched(int hash, SymbolString symbolString) {
+    private void OnPhraseFetched(int hash, SymbolList phrase) {
       if (PhraseFetched != null) {
-        PhraseFetched(this, new PhraseEventArgs(hash, symbolString));
+        PhraseFetched(this, new PhraseEventArgs(hash, phrase));
       }
     }
 
     public event EventHandler<PhraseAddedEventArgs> PhraseDerived;
-    private void OnPhraseDerived(int parentHash, SymbolString parentSymbolString, int addedHash, SymbolString addedSymbolString, Symbol expandedSymbol, Production expandedProduction) {
+    private void OnPhraseDerived(int parentHash, SymbolList parentSymbolList, int addedHash, SymbolList addedSymbolList, Symbol expandedSymbol, SymbolList expandedProduction) {
       if (PhraseDerived != null) {
-        PhraseDerived(this, new PhraseAddedEventArgs(parentHash, parentSymbolString, addedHash, addedSymbolString, expandedSymbol, expandedProduction));
+        PhraseDerived(this, new PhraseAddedEventArgs(parentHash, parentSymbolList, addedHash, addedSymbolList, expandedSymbol, expandedProduction));
       }
     }
 
     public event EventHandler<PhraseAddedEventArgs> SentenceGenerated;
-    private void OnSentenceGenerated(int parentHash, SymbolString parentSymbolString, int addedHash, SymbolString addedSymbolString, Symbol expandedSymbol, Production expandedProduction) {
+    private void OnSentenceGenerated(int parentHash, SymbolList parentSymbolList, int addedHash, SymbolList addedSymbolList, Symbol expandedSymbol, SymbolList expandedProduction) {
       if (SentenceGenerated != null) {
-        SentenceGenerated(this, new PhraseAddedEventArgs(parentHash, parentSymbolString, addedHash, addedSymbolString, expandedSymbol, expandedProduction));
+        SentenceGenerated(this, new PhraseAddedEventArgs(parentHash, parentSymbolList, addedHash, addedSymbolList, expandedSymbol, expandedProduction));
       }
     }
 
     public event EventHandler<PhraseAddedEventArgs> DistinctSentenceGenerated;
-    private void OnDistinctSentenceGenerated(int parentHash, SymbolString parentSymbolString, int addedHash, SymbolString addedSymbolString, Symbol expandedSymbol, Production expandedProduction) {
+    private void OnDistinctSentenceGenerated(int parentHash, SymbolList parentSymbolList, int addedHash, SymbolList addedSymbolList, Symbol expandedSymbol, SymbolList expandedProduction) {
       if (DistinctSentenceGenerated != null) {
-        DistinctSentenceGenerated(this, new PhraseAddedEventArgs(parentHash, parentSymbolString, addedHash, addedSymbolString, expandedSymbol, expandedProduction));
+        DistinctSentenceGenerated(this, new PhraseAddedEventArgs(parentHash, parentSymbolList, addedHash, addedSymbolList, expandedSymbol, expandedProduction));
       }
     }
@@ -486 +495 @@
     public int Hash { get; }
 
-    public SymbolString Phrase { get; }
-
-    public PhraseEventArgs(int hash, SymbolString phrase) {
+    public SymbolList Phrase { get; }
+
+    public PhraseEventArgs(int hash, SymbolList phrase) {
       Hash = hash;
       Phrase = phrase;
@@ -498 +507 @@
     public int NewHash { get; }
 
-    public SymbolString ParentPhrase { get; }
-    public SymbolString NewPhrase { get; }
+    public SymbolList ParentPhrase { get; }
+    public SymbolList NewPhrase { get; }
 
     public Symbol ExpandedSymbol { get; }
 
-    public Production ExpandedProduction { get; }
-
-    public PhraseAddedEventArgs(int parentHash, SymbolString parentPhrase, int newHash, SymbolString newPhrase, Symbol expandedSymbol, Production expandedProduction) {
+    public SymbolList ExpandedProduction { get; }
+
+    public PhraseAddedEventArgs(int parentHash, SymbolList parentPhrase, int newHash, SymbolList newPhrase, Symbol expandedSymbol, SymbolList expandedProduction) {
       ParentHash = parentHash;
       ParentPhrase = parentPhrase;

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

@@ -13 +13 @@
 
     [Storable]
-    public readonly SymbolString SymbolString;
+    public readonly SymbolList SymbolList;
 
     [Storable]
@@ -23 +23 @@
     private SearchNode() { }
 
-    public SearchNode(int hash, double priority, double r2, SymbolString symbolString) {
+    public SearchNode(int hash, double priority, double r2, SymbolList symbolList) {
       Hash = hash;
       Priority = priority;
-      SymbolString = symbolString;
+      SymbolList = symbolList;
       R2 = r2;
     }
@@ -33 +33 @@
       Hash = original.Hash;
       Priority = original.Priority;
-      SymbolString = original.SymbolString;
+      SymbolList = original.SymbolList;
       R2 = original.R2;
     }

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

@@ -55 +55 @@
     }
 
-    public SymbolString DerivePhrase(int nonterminalSymbolIndex, Production production) {
+    public SymbolString DerivePhrase(int nonterminalSymbolIndex, SymbolList production) {
       int productionLength = production.Count;
       int newStringLength = Count() + productionLength - 1;

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

@@ -2 +2 @@
 using System.Collections;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
 using HeuristicLab.Common;
@@ -102 +103 @@
   }
 
-  [StorableClass]
-  public class Production : DeepCloneable, IList<Symbol> {
-    [Storable]
-    private List<Symbol> symbols;
-
-    public int Count { get { return symbols.Count; } }
-
-    public bool IsReadOnly {
-      get { return false; }
-    }
-
-    public Symbol this[int index] {
-      get { return symbols[index]; }
-      set { symbols[index] = value; }
-    }
-
-    public Production(params Symbol[] symbols) {
-      this.symbols = symbols.ToList();
-    }
-
-    public Production(IEnumerable<Symbol> symbols) {
-      this.symbols = symbols.ToList();
-    }
-
-    [StorableConstructor]
-    protected Production(bool deserializing) { }
-
-    protected Production(Production original, Cloner cloner) {
-      symbols = original.symbols.Select(cloner.Clone).ToList();
-    }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new Production(this, cloner);
-    }
-
-    public override string ToString() {
-      return string.Join(" ", this);
-    }
-
-    #region IList<Symbol> methods
-    public IEnumerator<Symbol> GetEnumerator() {
-      return symbols.GetEnumerator();
-    }
-
-    IEnumerator IEnumerable.GetEnumerator() {
-      return GetEnumerator();
-    }
-
-    public int IndexOf(Symbol item) {
-      return symbols.IndexOf(item);
-    }
-
-    public void Insert(int index, Symbol item) {
-      symbols.Insert(index, item);
-    }
-
-    public void RemoveAt(int index) {
-      symbols.RemoveAt(index);
-    }
-
-    public void Add(Symbol item) {
-      symbols.Add(item);
-    }
-
-    public void Clear() {
-      symbols.Clear();
-    }
-
-    public bool Contains(Symbol item) {
-      return symbols.Contains(item);
-    }
-
-    public void CopyTo(Symbol[] array, int arrayIndex) {
-      symbols.CopyTo(array, arrayIndex);
-    }
-
-    public void CopyTo(int index, Symbol[] array, int arrayIndex, int count) {
-      symbols.CopyTo(index, array, arrayIndex, count);
-    }
-
-    public bool Remove(Symbol item) {
-      return symbols.Remove(item);
-    }
-    #endregion
-  }
+ 
 }

branches/2886_SymRegGrammarEnumeration/HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration/Hashing/Hasher.cs

@@ -22 +22 @@
     protected abstract THashType AggregateHashes(Symbol operatorSym, IList<THashType> hashes);
 
-    public int CalcHashCode(SymbolString sentence) {
+    public int CalcHashCode(SymbolList sentence) {
       Debug.Assert(sentence.Any(), "Trying to evaluate empty sentence!");
 

branches/2886_SymRegGrammarEnumeration/HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration/HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration.csproj

@@ -123 +123 @@
     <Compile Include="GrammarEnumeration\GrammarEnumerationAlgorithm.cs" />
     <Compile Include="GrammarEnumeration\LruCache.cs" />
+    <Compile Include="GrammarEnumeration\SymbolList.cs" />
     <Compile Include="Hashing\Hasher.cs" />
     <Compile Include="GrammarEnumeration\SearchDataStructure.cs" />
-    <Compile Include="GrammarEnumeration\Sentence.cs" />
     <Compile Include="ProblemInstances\AircraftMaximumLift.cs" />
     <Compile Include="ProblemInstances\FluidDynamics.cs" />

branches/2886_SymRegGrammarEnumeration/Test/GrammarEnumerationTest.cs

@@ -44 +44 @@
     }
 
-
     private void EvaluateGrammarEnumeration() {
       // Evaluate results
@@ -55 +54 @@
       Assert.AreEqual(1.0, ((IRegressionSolution)alg.Results["Best solution (Training)"].Value).TestRSquared, eps, "Test quality too low!");
     }
-
 
     [TestMethod]
@@ -72 +70 @@
       TerminalSymbol addSymbol = alg.Grammar.Addition;
 
-      SymbolString targetSolution = new SymbolString(new[] {
+      SymbolList targetSolution = new SymbolList(new[] {
         constSymbol, varSymbol, varSymbol, varSymbol, mulSymbol, mulSymbol, mulSymbol,
         constSymbol, varSymbol, varSymbol, mulSymbol, mulSymbol, addSymbol,
@@ -132 +130 @@
 
       // c * sin(c x + c) + c * sin(c * x * x + c * x) + c
-      SymbolString targetSolution = new SymbolString(new[] {
+      SymbolList targetSolution = new SymbolList(new[] {
         varSymbol, constSymbol, mulSymbol, constSymbol, addSymbol, sinSymbol, constSymbol, mulSymbol,
         varSymbol, varSymbol, mulSymbol, constSymbol, mulSymbol, varSymbol, constSymbol, mulSymbol, addSymbol, constSymbol, addSymbol, sinSymbol, constSymbol, mulSymbol, addSymbol,
@@ -165 +163 @@
 
       // c*sin(c*x + c) + c*sin(c*y*y + c) + c
-      SymbolString targetSolution = new SymbolString(new[] {
+      SymbolList targetSolution = new SymbolList(new[] {
         xSymbol, constSymbol, mulSymbol, constSymbol, addSymbol, sinSymbol, constSymbol, mulSymbol,
         ySymbol, ySymbol, mulSymbol, constSymbol, mulSymbol, constSymbol, addSymbol, sinSymbol, constSymbol, mulSymbol, addSymbol,
@@ -222 +220 @@
       TerminalSymbol logSymbol = alg.Grammar.Log;
 
-      SymbolString targetSolution = new SymbolString(new[] {
+      SymbolList targetSolution = new SymbolList(new[] {
         varSymbol, constSymbol, mulSymbol, constSymbol, addSymbol, logSymbol, constSymbol, mulSymbol,
         varSymbol, varSymbol, mulSymbol, constSymbol, mulSymbol, constSymbol, addSymbol, logSymbol, constSymbol, mulSymbol, addSymbol,
@@ -266 +264 @@
       TerminalSymbol addSymbol = alg.Grammar.Addition;
 
-      SymbolString targetSolution = new SymbolString(new[] {
+      SymbolList targetSolution = new SymbolList(new[] {
         constSymbol, varSymbol, mulSymbol, constSymbol, addSymbol, alg.Grammar.Sin,
         varSymbol, mulSymbol,
@@ -303 +301 @@
       // 30 * x * z * 1/(x*y*y - 10*y*y)
       // --> x z * c *     x y * y * c *  y y * c * + c + inv c +
-      SymbolString targetSolution = new SymbolString(new[] {
+      SymbolList targetSolution = new SymbolList(new[] {
         xSymbol, zSymbol, mulSymbol, constSymbol, mulSymbol,
         xSymbol, ySymbol, mulSymbol, ySymbol, mulSymbol, constSymbol, mulSymbol,
@@ -337 +335 @@
       TerminalSymbol addSymbol = alg.Grammar.Addition;
 
-      SymbolString targetSolution = new SymbolString(new[] {
+      SymbolList targetSolution = new SymbolList(new[] {
         xSymbol, xSymbol, mulSymbol, xSymbol, mulSymbol, xSymbol, mulSymbol, constSymbol, mulSymbol,
         xSymbol, xSymbol, mulSymbol, xSymbol, mulSymbol, constSymbol, mulSymbol, addSymbol,
@@ -376 +374 @@
 
       // x x mul c mul y y mul c mul add const add inv const mul const add
-      SymbolString targetSolution = new SymbolString(new[] {
+      SymbolList targetSolution = new SymbolList(new[] {
         xSymbol, xSymbol, mulSymbol, constSymbol, mulSymbol,
         ySymbol, ySymbol, mulSymbol, constSymbol, mulSymbol, addSymbol,
@@ -412 +410 @@
 
       // x x * x * const * y y * y * const * + y const * + x const * const +
-      SymbolString targetSolution = new SymbolString(new[] {
+      SymbolList targetSolution = new SymbolList(new[] {
         xSymbol, xSymbol, mulSymbol, xSymbol, mulSymbol, constSymbol, mulSymbol,
         ySymbol, ySymbol, mulSymbol, ySymbol, mulSymbol, constSymbol, mulSymbol, addSymbol,

branches/2886_SymRegGrammarEnumeration/Test/TreeHashingTest.cs

@@ -27 +27 @@
     [TestCategory("TreeHashing")]
     public void SimpleEqualityAddition() {
-      SymbolString s1 = new SymbolString(new[] { varA, varB, grammar.Addition, varC, grammar.Addition });
-      SymbolString s2 = new SymbolString(new[] { varA, varB, grammar.Addition, varC, grammar.Addition });
+      SymbolList s1 = new SymbolList(new[] { varA, varB, grammar.Addition, varC, grammar.Addition });
+      SymbolList s2 = new SymbolList(new[] { varA, varB, grammar.Addition, varC, grammar.Addition });
 
       int hash1 = grammar.Hasher.CalcHashCode(s1);
@@ -39 +39 @@
     [TestCategory("TreeHashing")]
     public void SimpleInequalityAddition() {
-      SymbolString s1 = new SymbolString(new[] { varA, varB, grammar.Addition, varC, grammar.Addition });
-      SymbolString s2 = new SymbolString(new[] { varB, varB, grammar.Addition, varB, grammar.Addition });
+      SymbolList s1 = new SymbolList(new[] { varA, varB, grammar.Addition, varC, grammar.Addition });
+      SymbolList s2 = new SymbolList(new[] { varB, varB, grammar.Addition, varB, grammar.Addition });
 
       int hash1 = grammar.Hasher.CalcHashCode(s1);
@@ -51 +51 @@
     [TestCategory("TreeHashing")]
     public void CommutativityAddition() {
-      SymbolString s1 = new SymbolString(new[] { varA, varB, grammar.Addition });
-      SymbolString s2 = new SymbolString(new[] { varB, varA, grammar.Addition });
+      SymbolList s1 = new SymbolList(new[] { varA, varB, grammar.Addition });
+      SymbolList s2 = new SymbolList(new[] { varB, varA, grammar.Addition });
 
       int hash1 = grammar.Hasher.CalcHashCode(s1);
@@ -63 +63 @@
     [TestCategory("TreeHashing")]
     public void AssociativityAddition() {
-      SymbolString s1 = new SymbolString(new[] { varA, varB, grammar.Addition, varA, grammar.Addition });
-      SymbolString s2 = new SymbolString(new[] { varA, varB, varA, grammar.Addition, grammar.Addition });
+      SymbolList s1 = new SymbolList(new[] { varA, varB, grammar.Addition, varA, grammar.Addition });
+      SymbolList s2 = new SymbolList(new[] { varA, varB, varA, grammar.Addition, grammar.Addition });
 
       int hash1 = grammar.Hasher.CalcHashCode(s1);
@@ -75 +75 @@
     [TestCategory("TreeHashing")]
     public void RepeatedAddition() {
-      SymbolString s1 = new SymbolString(new[] { varA, varA, grammar.Addition, varA, grammar.Addition });
-      SymbolString s2 = new SymbolString(new[] { varA });
+      SymbolList s1 = new SymbolList(new[] { varA, varA, grammar.Addition, varA, grammar.Addition });
+      SymbolList s2 = new SymbolList(new[] { varA });
 
       int hash1 = grammar.Hasher.CalcHashCode(s1);
@@ -87 +87 @@
     [TestCategory("TreeHashing")]
     public void ComplexInequality() {
-      SymbolString s1 = new SymbolString(new[] { varA, varA, varA, grammar.Multiplication, grammar.Multiplication });
-      SymbolString s2 = new SymbolString(new[] { varA, varA, varA, grammar.Multiplication, grammar.Addition });
+      SymbolList s1 = new SymbolList(new[] { varA, varA, varA, grammar.Multiplication, grammar.Multiplication });
+      SymbolList s2 = new SymbolList(new[] { varA, varA, varA, grammar.Multiplication, grammar.Addition });
 
       int hash1 = grammar.Hasher.CalcHashCode(s1);
@@ -99 +99 @@
     [TestCategory("TreeHashing")]
     public void NonterminalHashing() {
-      SymbolString s1 = new SymbolString(new Symbol[] { varA, varA, grammar.Expr, grammar.Addition, grammar.Addition });
-      SymbolString s2 = new SymbolString(new Symbol[] { varA, grammar.Expr, grammar.Addition });
+      SymbolList s1 = new SymbolList(new Symbol[] { varA, varA, grammar.Expr, grammar.Addition, grammar.Addition });
+      SymbolList s2 = new SymbolList(new Symbol[] { varA, grammar.Expr, grammar.Addition });
 
       int hash1 = grammar.Hasher.CalcHashCode(s1);
@@ -112 +112 @@
     public void InverseFactorCancelationSimple() {
       // 1/a * b * a * a
-      SymbolString s1 = new SymbolString(new Symbol[] { varA, grammar.Inv, varB, grammar.Multiplication, varA, grammar.Multiplication, varA, grammar.Multiplication });
+      SymbolList s1 = new SymbolList(new Symbol[] { varA, grammar.Inv, varB, grammar.Multiplication, varA, grammar.Multiplication, varA, grammar.Multiplication });
       // a * b
-      SymbolString s2 = new SymbolString(new Symbol[] { varA, varB, grammar.Multiplication });
+      SymbolList s2 = new SymbolList(new Symbol[] { varA, varB, grammar.Multiplication });
 
       int hash1 = grammar.Hasher.CalcHashCode(s1);
@@ -125 +125 @@
     [TestCategory("TreeHashing")]
     public void InverseFactorCancelationComplex() {
-      SymbolString s1 = new SymbolString(new Symbol[] { varA, grammar.Sin, varA, varA, grammar.Multiplication, varA, grammar.Addition, grammar.Sin, grammar.Addition });
-      SymbolString s2 = new SymbolString(new Symbol[] { varA, varA, varA, grammar.Multiplication, grammar.Addition, grammar.Sin, varA, grammar.Inv, varA, grammar.Sin, varA, grammar.Multiplication, grammar.Multiplication, grammar.Addition });
+      SymbolList s1 = new SymbolList(new Symbol[] { varA, grammar.Sin, varA, varA, grammar.Multiplication, varA, grammar.Addition, grammar.Sin, grammar.Addition });
+      SymbolList s2 = new SymbolList(new Symbol[] { varA, varA, varA, grammar.Multiplication, grammar.Addition, grammar.Sin, varA, grammar.Inv, varA, grammar.Sin, varA, grammar.Multiplication, grammar.Multiplication, grammar.Addition });
 
       int hash1 = grammar.Hasher.CalcHashCode(s1);
@@ -138 +138 @@
     [TestCategory("TreeHashing")]
     public void SimpleConst() {
-      SymbolString s1 = new SymbolString(new Symbol[] { c, varA, grammar.Multiplication, c, grammar.Addition});
-      SymbolString s2 = new SymbolString(new Symbol[] { c, varA, grammar.Multiplication, c, varA, grammar.Multiplication, grammar.Addition, c, grammar.Addition });
+      SymbolList s1 = new SymbolList(new Symbol[] { c, varA, grammar.Multiplication, c, grammar.Addition});
+      SymbolList s2 = new SymbolList(new Symbol[] { c, varA, grammar.Multiplication, c, varA, grammar.Multiplication, grammar.Addition, c, grammar.Addition });
 
       int hash1 = grammar.Hasher.CalcHashCode(s1);
@@ -151 +151 @@
     [TestCategory("TreeHashing")]
     public void CompoundInverseCancellationToSingleInverse() {
-      SymbolString s1 = new SymbolString(new Symbol[] { varA, varB, grammar.Addition, grammar.Inv, grammar.Inv, grammar.Inv });
-      SymbolString s2 = new SymbolString(new Symbol[] { varA, varB, grammar.Addition, grammar.Inv });
+      SymbolList s1 = new SymbolList(new Symbol[] { varA, varB, grammar.Addition, grammar.Inv, grammar.Inv, grammar.Inv });
+      SymbolList s2 = new SymbolList(new Symbol[] { varA, varB, grammar.Addition, grammar.Inv });
 
       int hash1 = grammar.CalcHashCode(s1);
@@ -163 +163 @@
     [TestCategory("TreeHashing")]
     public void CompoundInverseCancellationToDivisor() {
-      SymbolString s1 = new SymbolString(new Symbol[] { varA, varB, grammar.Addition, grammar.Inv, grammar.Inv });
-      SymbolString s2 = new SymbolString(new Symbol[] { varA, varB, grammar.Addition });
+      SymbolList s1 = new SymbolList(new Symbol[] { varA, varB, grammar.Addition, grammar.Inv, grammar.Inv });
+      SymbolList s2 = new SymbolList(new Symbol[] { varA, varB, grammar.Addition });
 
       int hash1 = grammar.CalcHashCode(s1);
@@ -176 +176 @@
     public void UncancelableCompoundInverse() {
       // 1 / ( 1/b + sin(a*c) )
-      SymbolString s1 = new SymbolString(new Symbol[] { varB, grammar.Inv, varA, varC, grammar.Multiplication, grammar.Sin, grammar.Addition, grammar.Inv });
+      SymbolList s1 = new SymbolList(new Symbol[] { varB, grammar.Inv, varA, varC, grammar.Multiplication, grammar.Sin, grammar.Addition, grammar.Inv });
       // b + sin(a*c)
-      SymbolString s2 = new SymbolString(new Symbol[] { varB, varA, varC, grammar.Multiplication, grammar.Sin, grammar.Addition });
+      SymbolList s2 = new SymbolList(new Symbol[] { varB, varA, varC, grammar.Multiplication, grammar.Sin, grammar.Addition });
 
       int hash1 = grammar.CalcHashCode(s1);