Changeset 17963

Timestamp:

04/23/21 18:26:45 (4 years ago)

Author:

gkronber

Message:

#3121: support integer powers in interval arithmetic (and two simplification rules)

Location:

trunk

Files:

• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Converters/TreeSimplifier.cs (modified) (2 diffs)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/IntervalInterpreter.cs (modified) (2 diffs)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/OpCodes.cs (modified) (1 diff)
• HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Interval/Interval.cs (modified) (4 diffs)

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

@@ -784 +784 @@
       } else if (IsExp(node)) {
         return MakeExp(MakeProduct(node.GetSubtree(0), MakeConstant(2.0))); // sqr(exp(x)) = exp(2x)
+      } else if (IsSquare(node)) {
+        return MakePower(node.GetSubtree(0), MakeConstant(4));
       } else if (IsCube(node)) {
         return MakePower(node.GetSubtree(0), MakeConstant(6));
@@ -809 +811 @@
       } else if (IsSquare(node)) {
         return MakePower(node.GetSubtree(0), MakeConstant(6));
+      } else if (IsCube(node)) {
+        return MakePower(node.GetSubtree(0), MakeConstant(9));
       } else {
         var cubeNode = cubeSymbol.CreateTreeNode();

trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/IntervalInterpreter.cs

@@ -283 +283 @@
             break;
           }
+        case OpCodes.Power: {
+            var a = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
+            var b = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
+            // support only integer powers
+            if(b.LowerBound == b.UpperBound && Math.Truncate(b.LowerBound) == b.LowerBound) {
+              result = Interval.Power(a, (int)b.LowerBound);
+            } else {
+              throw new NotSupportedException("Interval is only supported for integer powers");
+            }
+            break;
+          }
+
         case OpCodes.Absolute: {
             var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
@@ -329 +341 @@
           !(n.Symbol is Cube) &&
           !(n.Symbol is CubeRoot) &&
+          !(n.Symbol is Power) &&
           !(n.Symbol is Absolute) &&
           !(n.Symbol is AnalyticQuotient)

trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/OpCodes.cs

@@ -144 +144 @@
       { typeof(Cosine), OpCodes.Cos },
       { typeof(Tangent), OpCodes.Tan },
-      { typeof (HyperbolicTangent), OpCodes.Tanh},
+      { typeof(HyperbolicTangent), OpCodes.Tanh},
       { typeof(Logarithm), OpCodes.Log },
       { typeof(Exponential), OpCodes.Exp },

trunk/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Interval/Interval.cs

@@ -78 +78 @@
       if (double.IsNegativeInfinity(LowerBound) && double.IsPositiveInfinity(UpperBound)) return true;
       if (other.LowerBound >= LowerBound && other.UpperBound <= UpperBound) return true;
-  
+
       return false;
     }
@@ -97 +97 @@
     /// </summary>
     public bool IsPositive {
-      get => LowerBound > 0.0; 
+      get => LowerBound > 0.0;
     }
 
@@ -130 +130 @@
         return false;
 
-      return (UpperBound==other.UpperBound || (double.IsNaN(UpperBound) && double.IsNaN(other.UpperBound)))
-        && (LowerBound==other.LowerBound || (double.IsNaN(LowerBound) && double.IsNaN(other.LowerBound)));
+      return (UpperBound == other.UpperBound || (double.IsNaN(UpperBound) && double.IsNaN(other.UpperBound)))
+        && (LowerBound == other.LowerBound || (double.IsNaN(LowerBound) && double.IsNaN(other.LowerBound)));
     }
 
@@ -238 +238 @@
     public static Interval Cube(Interval a) {
       return new Interval(Math.Pow(a.LowerBound, 3), Math.Pow(a.UpperBound, 3));
+    }
+
+    public static Interval Power(Interval a, int b) {
+      if (b < 0) return Power(1.0 / a, -b); // a^(-b) = 1/(a^b)
+      if (b == 0 && (a.Contains(0.0) || a.IsInfiniteOrUndefined)) return new Interval(double.NaN, double.NaN);  // 0^0, +/-inf^0 are undefined
+      if (b == 0) return new Interval(1.0, 1.0); // x^0 = 1
+      if (b == 1) return a;
+      if (b % 2 == 0) {
+        // even powers (see x²)
+        if (a.UpperBound <= 0) return new Interval(Math.Pow(a.UpperBound, b), Math.Pow(a.LowerBound, b));     // interval is negative
+        if (a.LowerBound >= 0) return new Interval(Math.Pow(a.LowerBound, b), Math.Pow(a.UpperBound, b)); // interval is positive
+        return new Interval(0, Math.Max(Math.Pow(a.LowerBound, b), Math.Pow(a.UpperBound, b))); // interval goes over zero
+      } else {
+        // odd powers (see x³)
+        return new Interval(Math.Pow(a.LowerBound, b), Math.Pow(a.UpperBound, b));
+      }
     }