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

Timestamp:

03/07/18 12:52:16 (6 years ago)

Author:

lkammere

Message:

#2886: Implement IEquatable interface in symbols.
Minor performance improvements.

File:

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

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

@@ -166 +166 @@
 
       // ADDITION
-      if (ReferenceEquals(currentSymbol, Addition)) {
+      if (currentSymbol == Addition) {
         var uniqueChildHashes = new HashSet<THashType>();
 
         // First subtree
-        if (ReferenceEquals(parseStack.Peek(), Addition)) {
+        if (parseStack.Peek() == Addition) {
           uniqueChildHashes.UnionWith(GetSubtreeHashes(parseStack, aggregateHashes));
         } else {
@@ -177 +177 @@
         }
         // Second subtree
-        if (ReferenceEquals(parseStack.Peek(), Addition)) {
+        if (parseStack.Peek() == Addition) {
           uniqueChildHashes.UnionWith(GetSubtreeHashes(parseStack, aggregateHashes));
         } else {
@@ -190 +190 @@
 
       // MULTIPLICATION
-      if (ReferenceEquals(currentSymbol, Multiplication)) {
+      if (currentSymbol == Multiplication) {
         var childHashes = new List<THashType>();
 
         // First subtree
-        if (ReferenceEquals(parseStack.Peek(), Multiplication)) {
+        if (parseStack.Peek() == Multiplication) {
           childHashes.AddRange(GetSubtreeHashes(parseStack, aggregateHashes));
         } else {
@@ -200 +200 @@
         }
         // Second subtree
-        if (ReferenceEquals(parseStack.Peek(), Multiplication)) {
+        if (parseStack.Peek() == Multiplication) {
           childHashes.AddRange(GetSubtreeHashes(parseStack, aggregateHashes));
         } else {
@@ -231 +231 @@
 
       // LOG, EXP, SIN, INV
-      if (ReferenceEquals(currentSymbol, Log) || ReferenceEquals(currentSymbol, Exp) ||
-          ReferenceEquals(currentSymbol, Sin) || ReferenceEquals(currentSymbol, Cos) ||
-          ReferenceEquals(currentSymbol, Inv)) {
+      if (currentSymbol == Log || currentSymbol == Exp ||
+          currentSymbol == Sin || currentSymbol == Cos ||
+          currentSymbol == Inv) {
         return new[] { aggregateHashes(parseStack.Peek(), GetSubtreeHashes(parseStack, aggregateHashes)) };
       }
@@ -244 +244 @@
       var hashesArray = hashes.ToArray();
 
-      if ((ReferenceEquals(operatorSym, Addition) || ReferenceEquals(operatorSym, Multiplication)) && hashesArray.Count() <= 1) {
+      if ((operatorSym == Addition || operatorSym == Multiplication) && hashesArray.Length <= 1) {
         return hashesArray[0];
       }
@@ -251 +251 @@
       }
 
-      return $"[{hashesArray.Aggregate(operatorSym.StringRepresentation, (result, ti) => string.Concat(result, " ° ", ti))}]";      // TODO: use string join instead of string.Concat
+      return $"[{operatorSym.StringRepresentation} ° {string.Join(" ° ", hashesArray)}]";
     }
 
     private int AggregateIntHashes(Symbol operatorSym, int[] hashes) {
       int start;
-      if ((ReferenceEquals(operatorSym, Addition) || ReferenceEquals(operatorSym, Multiplication)) &&
-          hashes.Length <= 1) {
+      if ((operatorSym == Addition || operatorSym == Multiplication) && hashes.Length <= 1) {
         start = 0;
 
@@ -302 +301 @@
       ISymbolicExpressionTreeNode parsedSubTree = null;
 
-      if (ReferenceEquals(currentSymbol, Addition)) {
+      if (currentSymbol == Addition) {
         parsedSubTree = addSy.CreateTreeNode();
         parsedSubTree.AddSubtree(ParseSymbolicExpressionTree(parseStack)); // left part
         parsedSubTree.AddSubtree(ParseSymbolicExpressionTree(parseStack)); // right part
 
-      } else if (ReferenceEquals(currentSymbol, Multiplication)) {
+      } else if (currentSymbol == Multiplication) {
         parsedSubTree = mulSy.CreateTreeNode();
         parsedSubTree.AddSubtree(ParseSymbolicExpressionTree(parseStack)); // left part
         parsedSubTree.AddSubtree(ParseSymbolicExpressionTree(parseStack)); // right part
 
-      } else if (ReferenceEquals(currentSymbol, Log)) {
+      } else if (currentSymbol == Log) {
         parsedSubTree = logSy.CreateTreeNode();
         parsedSubTree.AddSubtree(ParseSymbolicExpressionTree(parseStack));
 
-      } else if (ReferenceEquals(currentSymbol, Exp)) {
+      } else if (currentSymbol == Exp) {
         parsedSubTree = expSy.CreateTreeNode();
         parsedSubTree.AddSubtree(ParseSymbolicExpressionTree(parseStack));
 
-      } else if (ReferenceEquals(currentSymbol, Sin)) {
+      } else if (currentSymbol == Sin) {
         parsedSubTree = sinSy.CreateTreeNode();
         parsedSubTree.AddSubtree(ParseSymbolicExpressionTree(parseStack));
 
-      } else if (ReferenceEquals(currentSymbol, Cos)) {
+      } else if (currentSymbol ==  Cos) {
         parsedSubTree = cosSy.CreateTreeNode();
         parsedSubTree.AddSubtree(ParseSymbolicExpressionTree(parseStack));
 
-      } else if (ReferenceEquals(currentSymbol, Inv)) {
+      } else if (currentSymbol == Inv) {
         parsedSubTree = divSy.CreateTreeNode();
         ConstantTreeNode dividend = (ConstantTreeNode)constSy.CreateTreeNode();