Changeset 16652

Timestamp:

03/06/19 13:14:23 (6 years ago)

Author:

gkronber

Message:

#2925: allow arbitrary number of arguments to +,-,*,/ operators, fixed bug in single-argument division

File:

• branches/2925_AutoDiffForDynamicalModels/HeuristicLab.Problems.DynamicalSystemsModelling/3.3/Problem.cs (modified) (8 diffs)

branches/2925_AutoDiffForDynamicalModels/HeuristicLab.Problems.DynamicalSystemsModelling/3.3/Problem.cs

@@ -1161 +1161 @@
         return nodeValues.NodeValue(node);
       } else if (node.Symbol is Addition) {
-        Assert(node.SubtreeCount == 2);
         var f = InterpretRec(node.GetSubtree(0), nodeValues);
-        var g = InterpretRec(node.GetSubtree(1), nodeValues);
-        return f + g;
+        for (int i = 1; i < node.SubtreeCount; i++) {
+          f += InterpretRec(node.GetSubtree(i), nodeValues);
+        }
+        return f;
       } else if (node.Symbol is Multiplication) {
-        Assert(node.SubtreeCount == 2);
         var f = InterpretRec(node.GetSubtree(0), nodeValues);
-        var g = InterpretRec(node.GetSubtree(1), nodeValues);
-        return f * g;
+        for (int i = 1; i < node.SubtreeCount; i++) {
+          f *= InterpretRec(node.GetSubtree(i), nodeValues);
+        }
+        return f;
       } else if (node.Symbol is Subtraction) {
-        Assert(node.SubtreeCount <= 2);
         if (node.SubtreeCount == 1) {
-          var f = InterpretRec(node.GetSubtree(0), nodeValues);
-          return -f;
+          return -InterpretRec(node.GetSubtree(0), nodeValues);
         } else {
           var f = InterpretRec(node.GetSubtree(0), nodeValues);
-          var g = InterpretRec(node.GetSubtree(1), nodeValues);
-
-          return f - g;
+          for (int i = 1; i < node.SubtreeCount; i++) {
+            f -= InterpretRec(node.GetSubtree(i), nodeValues);
+          }
+          return f;
         }
       } else if (node.Symbol is Division) {
-        Assert(node.SubtreeCount <= 2);
-
         if (node.SubtreeCount == 1) {
           var f = InterpretRec(node.GetSubtree(0), nodeValues);
@@ -1194 +1193 @@
         } else {
           var f = InterpretRec(node.GetSubtree(0), nodeValues);
-          var g = InterpretRec(node.GetSubtree(1), nodeValues);
-
-          // protected division
-          if (g.IsAlmost(0.0)) {
-            return 0;
-          } else {
-            return f / g;
-          }
+          for (int i = 1; i < node.SubtreeCount; i++) {
+            var g = InterpretRec(node.GetSubtree(i), nodeValues);
+            // protected division
+            if (g.IsAlmost(0.0)) {
+              return 0;
+            } else {
+              f /= g;
+            }
+          }
+          return f;
         }
       } else if (node.Symbol is Sine) {
@@ -1249 +1250 @@
         dz = Vector.CreateNew(nodeValues.NodeGradient(node)); // original gradient vectors are never changed by evaluation
       } else if (node.Symbol is Addition) {
-
-        Assert(node.SubtreeCount == 2);
         InterpretRec(node.GetSubtree(0), nodeValues, out f, out df);
-        InterpretRec(node.GetSubtree(1), nodeValues, out g, out dg);
-        z = f + g;
-        dz = df.Add(dg);
+        for (int i = 1; i < node.SubtreeCount; i++) {
+          InterpretRec(node.GetSubtree(i), nodeValues, out g, out dg);
+          f = f + g;
+          df = df.Add(dg);
+        }
+        z = f;
+        dz = df;
       } else if (node.Symbol is Multiplication) {
-
-        Assert(node.SubtreeCount == 2);
         InterpretRec(node.GetSubtree(0), nodeValues, out f, out df);
-        InterpretRec(node.GetSubtree(1), nodeValues, out g, out dg);
-        z = f * g;
-        dz = df.Scale(g).Add(dg.Scale(f));  // f'*g + f*g'
-
+        for (int i = 1; i < node.SubtreeCount; i++) {
+          InterpretRec(node.GetSubtree(i), nodeValues, out g, out dg);
+          f = f * g;
+          df = df.Scale(g).Add(dg.Scale(f));  // f'*g + f*g'
+        }
+        z = f;
+        dz = df;
       } else if (node.Symbol is Subtraction) {
-
-        Assert(node.SubtreeCount <= 2);
         if (node.SubtreeCount == 1) {
           InterpretRec(node.GetSubtree(0), nodeValues, out f, out df);
@@ -1272 +1274 @@
         } else {
           InterpretRec(node.GetSubtree(0), nodeValues, out f, out df);
-          InterpretRec(node.GetSubtree(1), nodeValues, out g, out dg);
-          z = f - g;
-          dz = df.Subtract(dg);
-        }
-
+          for (int i = 1; i < node.SubtreeCount; i++) {
+            InterpretRec(node.GetSubtree(i), nodeValues, out g, out dg);
+            f = f - g;
+            df = df.Subtract(dg);
+          }
+          z = f;
+          dz = df;
+        }
       } else if (node.Symbol is Division) {
-
-        Assert(node.SubtreeCount <= 2);
         if (node.SubtreeCount == 1) {
           InterpretRec(node.GetSubtree(0), nodeValues, out f, out df);
@@ -1288 +1291 @@
           } else {
             z = 1.0 / f;
-            dz = df.Scale(z * z);
+            dz = df.Scale(-1 * z * z);
           }
         } else {
           InterpretRec(node.GetSubtree(0), nodeValues, out f, out df);
-          InterpretRec(node.GetSubtree(1), nodeValues, out g, out dg);
-
-          // protected division
-          if (g.IsAlmost(0.0)) {
-            z = 0;
-            dz = Vector.Zero;
-          } else {
-            var inv_g = 1.0 / g;
-            z = f * inv_g;
-
-            dz = dg.Scale(-f * inv_g * inv_g).Add(df.Scale(inv_g));
-          }
-        }
-
+          for (int i = 1; i < node.SubtreeCount; i++) {
+            InterpretRec(node.GetSubtree(i), nodeValues, out g, out dg);
+            // protected division
+            if (g.IsAlmost(0.0)) {
+              z = 0;
+              dz = Vector.Zero;
+              return;
+            } else {
+              var inv_g = 1.0 / g;
+              f = f * inv_g;
+              df = dg.Scale(-f * inv_g * inv_g).Add(df.Scale(inv_g));
+            }
+          }
+          z = f;
+          dz = df;
+        }
       } else if (node.Symbol is Sine) {
-
         Assert(node.SubtreeCount == 1);
         InterpretRec(node.GetSubtree(0), nodeValues, out f, out df);
         z = Math.Sin(f);
         dz = df.Scale(Math.Cos(f));
-
       } else if (node.Symbol is Cosine) {
-
         Assert(node.SubtreeCount == 1);
         InterpretRec(node.GetSubtree(0), nodeValues, out f, out df);
@@ -1320 +1322 @@
         dz = df.Scale(-Math.Sin(f));
       } else if (node.Symbol is Square) {
-
         Assert(node.SubtreeCount == 1);
         InterpretRec(node.GetSubtree(0), nodeValues, out f, out df);
@@ -1326 +1327 @@
         dz = df.Scale(2.0 * f);
       } else if (node.Symbol is Exponential) {
-
         Assert(node.SubtreeCount == 1);
         InterpretRec(node.GetSubtree(0), nodeValues, out f, out df);
@@ -1332 +1332 @@
         dz = df.Scale(Math.Exp(f));
       } else if (node.Symbol is Logarithm) {
-
         Assert(node.SubtreeCount == 1);
         InterpretRec(node.GetSubtree(0), nodeValues, out f, out df);