Changeset 18132 for trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Converters/DerivativeCalculator.cs

Timestamp:

12/15/21 11:50:57 (2 years ago)

Author:

gkronber

Message:

#3140: merged r18091:18131 from branch to trunk

Location:

trunk

Files:

• . (modified) (1 prop)
• HeuristicLab.Problems.DataAnalysis.Symbolic (modified) (1 prop)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Converters/DerivativeCalculator.cs (modified) (10 diffs)

trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Converters/DerivativeCalculator.cs

@@ -41 +41 @@
     }
 
-    private static readonly Constant constantSy = new Constant();
+    private static readonly Number numberSy = new Number();
     private static readonly Addition addSy = new Addition();
     private static readonly Subtraction subSy = new Subtraction();
@@ -52 +52 @@
 
     public static ISymbolicExpressionTreeNode Derive(ISymbolicExpressionTreeNode branch, string variableName) {
-      if (branch.Symbol is Constant) {
-        return CreateConstant(0.0);
+      if (branch.Symbol is INumericSymbol) {
+        return CreateNumber(0.0);
       }
       if (branch.Symbol is Variable) {
         var varNode = branch as VariableTreeNode;
         if (varNode.VariableName == variableName) {
-          return CreateConstant(varNode.Weight);
+          return CreateNumber(varNode.Weight);
         } else {
-          return CreateConstant(0.0);
+          return CreateNumber(0.0);
         }
       }
@@ -102 +102 @@
         if (branch.SubtreeCount == 1) {
           var g = (ISymbolicExpressionTreeNode)branch.GetSubtree(0).Clone();
-          var gPrime = Product(CreateConstant(-1.0), Derive(g, variableName));
+          var gPrime = Product(CreateNumber(-1.0), Derive(g, variableName));
           var sqrNode = new Square().CreateTreeNode();
           sqrNode.AddSubtree(g);
@@ -125 +125 @@
       if (branch.Symbol is Logarithm) {
         var f = (ISymbolicExpressionTreeNode)branch.GetSubtree(0).Clone();
-        return Product(Div(CreateConstant(1.0), f), Derive(f, variableName));
+        return Product(Div(CreateNumber(1.0), f), Derive(f, variableName));
       }
       if (branch.Symbol is Exponential) {
@@ -133 +133 @@
       if (branch.Symbol is Square) {
         var f = (ISymbolicExpressionTreeNode)branch.GetSubtree(0).Clone();
-        return Product(Product(CreateConstant(2.0), f), Derive(f, variableName));
+        return Product(Product(CreateNumber(2.0), f), Derive(f, variableName));
       }
       if (branch.Symbol is SquareRoot) {
         var f = (ISymbolicExpressionTreeNode)branch.Clone();
         var u = (ISymbolicExpressionTreeNode)branch.GetSubtree(0).Clone();
-        return Product(Div(CreateConstant(1.0), Product(CreateConstant(2.0), f)), Derive(u, variableName));
+        return Product(Div(CreateNumber(1.0), Product(CreateNumber(2.0), f)), Derive(u, variableName));
       }
       if (branch.Symbol is CubeRoot) {
         var f = (ISymbolicExpressionTreeNode)branch.Clone();
         var u = (ISymbolicExpressionTreeNode)branch.GetSubtree(0).Clone();
-        return Product(Div(CreateConstant(1.0), Product(CreateConstant(3.0), Square(f))), Derive(u, variableName));  // 1/3 1/cbrt(f(x))^2 d/dx f(x)
+        return Product(Div(CreateNumber(1.0), Product(CreateNumber(3.0), Square(f))), Derive(u, variableName));  // 1/3 1/cbrt(f(x))^2 d/dx f(x)
       }
       if (branch.Symbol is Cube) {
         var f = (ISymbolicExpressionTreeNode)branch.GetSubtree(0).Clone();
-        return Product(Product(CreateConstant(3.0), Square(f)), Derive(f, variableName));
+        return Product(Product(CreateNumber(3.0), Square(f)), Derive(f, variableName));
       }
       if (branch.Symbol is Power) {
         // HL evaluators handle power strangely (exponent is rounded to an integer)
         // here we only support the case when the exponent is a constant integer 
-        var exponent = branch.GetSubtree(1) as ConstantTreeNode;
+        var exponent = branch.GetSubtree(1) as INumericTreeNode;
         if (exponent != null && Math.Truncate(exponent.Value) == exponent.Value) {
           var newPower = (ISymbolicExpressionTreeNode)branch.Clone();
           var f = (ISymbolicExpressionTreeNode)newPower.GetSubtree(0).Clone();
-          var newExponent = (ConstantTreeNode)newPower.GetSubtree(1);
-          newExponent.Value -= 1;
-          return Product(Product(CreateConstant(exponent.Value), newPower), Derive(f, variableName));
+          var newExponent = (INumericTreeNode)numberSy.CreateTreeNode();
+          newExponent.Value = ((INumericTreeNode)newPower.GetSubtree(1)).Value - 1;
+          return Product(Product(CreateNumber(exponent.Value), newPower), Derive(f, variableName));
         } else throw new NotSupportedException("Cannot derive non-integer powers");
       }
@@ -171 +171 @@
         var b = (ISymbolicExpressionTreeNode)branch.GetSubtree(1).Clone();
 
-        var definition = Div(a, SquareRoot(Sum(Square(b), CreateConstant(1.0))));
+        var definition = Div(a, SquareRoot(Sum(Square(b), CreateNumber(1.0))));
         return Derive(definition, variableName);
       }
@@ -184 +184 @@
         var sin = (new Sine()).CreateTreeNode();
         sin.AddSubtree(u);
-        return Product(CreateConstant(-1.0), Product(sin, Derive(u, variableName)));
+        return Product(CreateNumber(-1.0), Product(sin, Derive(u, variableName)));
       }
       if (branch.Symbol is Tangent) {
@@ -196 +196 @@
         var fxp = Derive(branch.GetSubtree(0), variableName);
         var tanh = (ISymbolicExpressionTreeNode)branch.Clone();
-        return Product(fxp, Subtract(CreateConstant(1.0), Square(tanh)));
+        return Product(fxp, Subtract(CreateNumber(1.0), Square(tanh)));
       }
       throw new NotSupportedException(string.Format("Symbol {0} is not supported.", branch.Symbol));
@@ -253 +253 @@
     }
 
-    private static ISymbolicExpressionTreeNode CreateConstant(double v) {
-      var constNode = (ConstantTreeNode)constantSy.CreateTreeNode();
-      constNode.Value = v;
-      return constNode;
+    private static ISymbolicExpressionTreeNode CreateNumber(double v) {
+      var numberNode = (NumberTreeNode)numberSy.CreateTreeNode();
+      numberNode.Value = v;
+      return numberNode;
     }
 
@@ -264 +264 @@
         where
           !(n.Symbol is Variable) &&
+          !(n.Symbol is Number) &&
           !(n.Symbol is Constant) &&
           !(n.Symbol is Addition) &&