Index: branches/3106_AnalyticContinuedFractionsRegression/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Interval/Interval.cs
===================================================================
--- branches/3106_AnalyticContinuedFractionsRegression/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Interval/Interval.cs	(revision 17847)
+++ branches/3106_AnalyticContinuedFractionsRegression/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Interval/Interval.cs	(revision 17970)
@@ -33,4 +33,6 @@
     [Storable]
     public double UpperBound { get; private set; }
+
+    public double Width => UpperBound - LowerBound;
 
     [StorableConstructor]
@@ -67,4 +69,6 @@
     }
 
+    private Interval(double v) : this(v, v) { }
+
     public bool Contains(double value) {
       return LowerBound <= value && value <= UpperBound;
@@ -74,5 +78,5 @@
       if (double.IsNegativeInfinity(LowerBound) && double.IsPositiveInfinity(UpperBound)) return true;
       if (other.LowerBound >= LowerBound && other.UpperBound <= UpperBound) return true;
-  
+
       return false;
     }
@@ -93,5 +97,5 @@
     /// </summary>
     public bool IsPositive {
-      get => LowerBound > 0.0; 
+      get => LowerBound > 0.0;
     }
 
@@ -126,6 +130,6 @@
         return false;
 
-      return (UpperBound.IsAlmost(other.UpperBound) || (double.IsNaN(UpperBound) && double.IsNaN(other.UpperBound)))
-        && (LowerBound.IsAlmost(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)));
     }
 
@@ -234,4 +238,20 @@
     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));
+      }
     }
 
@@ -267,5 +287,5 @@
     }
 
-    public static Interval AnalyticalQuotient(Interval a, Interval b) {
+    public static Interval AnalyticQuotient(Interval a, Interval b) {
       var dividend = a;
       var divisor = Add(Square(b), new Interval(1.0, 1.0));
@@ -276,4 +296,34 @@
     }
     #endregion
+
+    #region arithmetic overloads
+    public static Interval operator +(Interval a, Interval b) => Add(a, b);
+    public static Interval operator +(Interval a, double b) => Add(a, new Interval(b));
+    public static Interval operator +(double a, Interval b) => Add(new Interval(a), b);
+    public static Interval operator -(Interval a, Interval b) => Subtract(a, b);
+    public static Interval operator -(Interval a, double b) => Subtract(a, new Interval(b));
+    public static Interval operator -(double a, Interval b) => Subtract(new Interval(a), b);
+    public static Interval operator -(Interval a) => Subtract(new Interval(0), a);
+    public static Interval operator *(Interval a, Interval b) => Multiply(a, b);
+    public static Interval operator *(Interval a, double b) => Multiply(a, new Interval(b));
+    public static Interval operator *(double a, Interval b) => Multiply(new Interval(a), b);
+    public static Interval operator /(Interval a, Interval b) => Divide(a, b);
+    public static Interval operator /(Interval a, double b) => Divide(a, new Interval(b));
+    public static Interval operator /(double a, Interval b) => Divide(new Interval(a), b);
+    public static Interval Exponential(double a) { return Exponential(new Interval(a)); }
+    public static Interval Logarithm(double a) { return Logarithm(new Interval(a)); }
+    public static Interval Sine(double a) { return Sine(new Interval(a)); }
+    public static Interval Cosine(double a) { return Cosine(new Interval(a)); }
+    public static Interval Tangens(double a) { return Tangens(new Interval(a)); }
+    public static Interval HyperbolicTangent(double a) { return HyperbolicTangent(new Interval(a)); }
+    public static Interval Square(double a) { return Square(new Interval(a)); }
+    public static Interval Cube(double a) { return Cube(new Interval(a)); }
+    public static Interval SquareRoot(double a) { return SquareRoot(new Interval(a)); }
+    public static Interval CubicRoot(double a) { return CubicRoot(new Interval(a)); }
+    public static Interval Absolute(double a) { return Absolute(new Interval(a)); }
+    public static Interval AnalyticQuotient(Interval a, double b) { return AnalyticQuotient(a, new Interval(b)); }
+    public static Interval AnalyticQuotient(double a, Interval b) { return AnalyticQuotient(new Interval(a), b); }
+    public static Interval AnalyticQuotient(double a, double b) { return AnalyticQuotient(new Interval(a), new Interval(b)); }
+    #endregion
   }
 }
