Changeset 18093 for branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Hashing

Timestamp:

11/24/21 13:40:39 (3 years ago)

Author:

chaider

Message:

#3041

• Renaming Constant Symbol to Num, behaves like before
• Adding new Symbol RealConstant (Constant), this symbol behaves now like a real constant, won't be changed by parameter optimization or manipulators
• Refactored classes part1

File:

• branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Hashing/SymbolicExpressionTreeHash.cs (modified) (10 diffs)

branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Hashing/SymbolicExpressionTreeHash.cs

@@ -36 +36 @@
     private static readonly Sine sin = new Sine();
     private static readonly Cosine cos = new Cosine();
-    private static readonly Constant constant = new Constant();
+    private static readonly Num Num = new Num();
 
     private static ISymbolicExpressionTreeNode ActualRoot(this ISymbolicExpressionTree tree) => tree.Root.GetSubtree(0).GetSubtree(0);
@@ -66 +66 @@
       var symbol = node.Symbol;
       var name = symbol.Name;
-      if (node is ConstantTreeNode constantNode) {
+      if (node is NumTreeNode constantNode) {
         name = strict ? constantNode.Value.ToString() : symbol.Name;
       } else if (node is VariableTreeNode variableNode) {
@@ -222 +222 @@
             variableTreeNode.VariableName = variable.VariableName;
             variableTreeNode.Weight = variable.Weight;
-          } else if (node.Data is ConstantTreeNode @const) {
-            var constantTreeNode = (ConstantTreeNode)treeNodes[i];
+          } else if (node.Data is NumTreeNode @const) {
+            var constantTreeNode = (NumTreeNode)treeNodes[i];
             constantTreeNode.Value = @const.Value;
           }
@@ -285 +285 @@
 
         var symbol = child.Data.Symbol;
-        if (child.Data is ConstantTreeNode firstConst) {
+        if (child.Data is NumTreeNode firstConst) {
           // fold sibling constant nodes into the first constant
           for (int k = j + 1; k < children.Length; ++k) {
             var sibling = nodes[children[k]];
-            if (sibling.Data is ConstantTreeNode otherConst) {
+            if (sibling.Data is NumTreeNode otherConst) {
               sibling.Enabled = false;
               node.Arity--;
@@ -301 +301 @@
           for (int k = j + 1; k < children.Length; ++k) {
             var sibling = nodes[children[k]];
-            if (sibling.Data is ConstantTreeNode constantNode) {
+            if (sibling.Data is NumTreeNode constantNode) {
               sibling.Enabled = false;
               node.Arity--;
@@ -329 +329 @@
 
         if (node.Arity == 0) { // if everything is simplified this node becomes constant
-          var constantTreeNode = constant.CreateTreeNode<ConstantTreeNode>();
+          var constantTreeNode = Num.CreateTreeNode<NumTreeNode>();
           constantTreeNode.Value = 1;
           nodes[i] = constantTreeNode.ToHashNode();
@@ -344 +344 @@
       var tmp = nodes;
 
-      if (children.All(x => tmp[x].Data.Symbol is Constant)) {
-        var v = ((ConstantTreeNode)nodes[children.First()].Data).Value;
+      if (children.All(x => tmp[x].Data.Symbol is Num)) {
+        var v = ((NumTreeNode)nodes[children.First()].Data).Value;
         if (node.Arity == 1) {
           v = 1 / v;
         } else if (node.Arity > 1) {
           foreach (var j in children.Skip(1)) {
-            v /= ((ConstantTreeNode)nodes[j].Data).Value;
+            v /= ((NumTreeNode)nodes[j].Data).Value;
           }
         }
-        var constantTreeNode = constant.CreateTreeNode<ConstantTreeNode>();
+        var constantTreeNode = Num.CreateTreeNode<NumTreeNode>();
         constantTreeNode.Value = v;
         nodes[i] = constantTreeNode.ToHashNode();
@@ -368 +368 @@
         }
         if (node.Arity == 0) {
-          var constantTreeNode = constant.CreateTreeNode<ConstantTreeNode>();
+          var constantTreeNode = Num.CreateTreeNode<NumTreeNode>();
           constantTreeNode.Value = 1; // x / x = 1
           nodes[i] = constantTreeNode.ToHashNode();
@@ -383 +383 @@
       var childSymbol = child.Data.Symbol;
 
-      if (childSymbol is Constant) {
+      if (childSymbol is Num) {
         nodes[i].Enabled = false;
       } else if ((parentSymbol is Exponential && childSymbol is Logarithm) || (parentSymbol is Logarithm && childSymbol is Exponential)) {
@@ -393 +393 @@
       var children = nodes.IterateChildren(i);
       var tmp = nodes;
-      if (children.All(x => tmp[x].Data.Symbol is Constant)) {
+      if (children.All(x => tmp[x].Data.Symbol is Num)) {
         foreach (var j in children) {
           nodes[j].Enabled = false;
         }
-        nodes[i] = constant.CreateTreeNode().ToHashNode();
+        nodes[i] = Num.CreateTreeNode().ToHashNode();
       }
     }