Index: branches/2966_interval_calculation/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Interval.cs
===================================================================
--- branches/2966_interval_calculation/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Interval.cs	(revision 16326)
+++ branches/2966_interval_calculation/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Interval.cs	(revision 16327)
@@ -27,14 +27,6 @@
 namespace HeuristicLab.Problems.DataAnalysis {
   public class Interval : IEquatable<Interval> {
-    private double lowerBound;
-    public double LowerBound {
-      get { return lowerBound; }
-      private set { lowerBound = value; }
-    }
-    private double upperBound;
-    public double UpperBound {
-      get { return upperBound; }
-      private set { lowerBound = value; }
-    }
+    public double LowerBound { get; private set; }
+    public double UpperBound { get; private set; }
 
     public Interval(double lowerBound, double upperBound) {
@@ -42,14 +34,14 @@
         throw new ArgumentException("LowerBound must be smaller than UpperBound.");
 
-      this.lowerBound = lowerBound;
-      this.upperBound = upperBound;
+      this.LowerBound = lowerBound;
+      this.UpperBound = upperBound;
     }
 
     public bool Contains(double value) {
-      return lowerBound <= value && value <= upperBound;
+      return LowerBound <= value && value <= UpperBound;
     }
 
     public override string ToString() {
-      return "Interval: [" + lowerBound + ", " + upperBound + "]";
+      return "Interval: [" + LowerBound + ", " + UpperBound + "]";
     }
 
@@ -66,5 +58,5 @@
         return false;
 
-      return this.upperBound.IsAlmost(other.upperBound) && this.lowerBound.IsAlmost(other.lowerBound);
+      return this.UpperBound.IsAlmost(other.UpperBound) && this.LowerBound.IsAlmost(other.LowerBound);
     }
 
@@ -74,5 +66,5 @@
 
     public override int GetHashCode() {
-      return lowerBound.GetHashCode() ^ upperBound.GetHashCode();
+      return LowerBound.GetHashCode() ^ UpperBound.GetHashCode();
     }
 
@@ -90,18 +82,18 @@
     // [x1,x2] + [y1,y2] = [x1 + y1,x2 + y2]
     public static Interval Add(Interval a, Interval b) {
-      return new Interval(a.lowerBound + b.lowerBound, a.upperBound + b.upperBound);
+      return new Interval(a.LowerBound + b.LowerBound, a.UpperBound + b.UpperBound);
     }
 
     // [x1,x2] − [y1,y2] = [x1 − y2,x2 − y1]
     public static Interval Subtract(Interval a, Interval b) {
-      return new Interval(a.lowerBound - b.upperBound, a.upperBound - b.lowerBound);
+      return new Interval(a.LowerBound - b.UpperBound, a.UpperBound - b.LowerBound);
     }
 
     // [x1,x2] * [y1,y2] = [min(x1*y1,x1*y2,x2*y1,x2*y2),max(x1*y1,x1*y2,x2*y1,x2*y2)]
     public static Interval Multiply(Interval a, Interval b) {
-      double v1 = a.lowerBound * b.lowerBound;
-      double v2 = a.lowerBound * b.upperBound;
-      double v3 = a.upperBound * b.lowerBound;
-      double v4 = a.upperBound * b.upperBound;
+      double v1 = a.LowerBound * b.LowerBound;
+      double v2 = a.LowerBound * b.UpperBound;
+      double v3 = a.UpperBound * b.LowerBound;
+      double v4 = a.UpperBound * b.UpperBound;
 
       double min = Math.Min(Math.Min(v1, v2), Math.Min(v3, v4));
@@ -110,17 +102,17 @@
     }
 
-    //mkommend: Divisiont by intervals containing 0 is implemented as defined in
+    //mkommend: Division by intervals containing 0 is implemented as defined in
     //http://en.wikipedia.org/wiki/Interval_arithmetic
     public static Interval Divide(Interval a, Interval b) {
       if (b.Contains(0.0)) {
-        if (b.lowerBound.IsAlmost(0.0)) return Interval.Multiply(a, new Interval(1.0 / b.upperBound, double.PositiveInfinity));
-        else if (b.upperBound.IsAlmost(0.0)) return Interval.Multiply(a, new Interval(double.NegativeInfinity, 1.0 / b.lowerBound));
+        if (b.LowerBound.IsAlmost(0.0)) return Interval.Multiply(a, new Interval(1.0 / b.UpperBound, double.PositiveInfinity));
+        else if (b.UpperBound.IsAlmost(0.0)) return Interval.Multiply(a, new Interval(double.NegativeInfinity, 1.0 / b.LowerBound));
         else return new Interval(double.NegativeInfinity, double.PositiveInfinity);
       }
-      return Interval.Multiply(a, new Interval(1.0 / b.upperBound, 1.0 / b.lowerBound));
+      return Interval.Multiply(a, new Interval(1.0 / b.UpperBound, 1.0 / b.LowerBound));
     }
 
     public static Interval Sine(Interval a) {
-      if (Math.Abs(a.upperBound - a.lowerBound) >= Math.PI * 2) return new Interval(-1, 1);
+      if (Math.Abs(a.UpperBound - a.LowerBound) >= Math.PI * 2) return new Interval(-1, 1);
 
       //divide the interval by PI/2 so that the optima lie at x element of N (0,1,2,3,4,...)
@@ -128,11 +120,11 @@
       Interval scaled = Interval.Divide(a, new Interval(Pihalf, Pihalf));
       //move to positive scale
-      if (scaled.lowerBound < 0) {
-        int periodsToMove = Math.Abs((int)scaled.lowerBound / 4) + 1;
+      if (scaled.LowerBound < 0) {
+        int periodsToMove = Math.Abs((int)scaled.LowerBound / 4) + 1;
         scaled = Interval.Add(scaled, new Interval(periodsToMove * 4, periodsToMove * 4));
       }
 
-      double scaledLowerBound = scaled.lowerBound % 4.0;
-      double scaledUpperBound = scaled.upperBound % 4.0;
+      double scaledLowerBound = scaled.LowerBound % 4.0;
+      double scaledUpperBound = scaled.UpperBound % 4.0;
       if (scaledUpperBound < scaledLowerBound) scaledUpperBound += 4.0;
       List<double> sinValues = new List<double>();
@@ -156,26 +148,26 @@
 
     public static Interval Logarithm(Interval a) {
-      return new Interval(Math.Log(a.lowerBound), Math.Log(a.upperBound));
+      return new Interval(Math.Log(a.LowerBound), Math.Log(a.UpperBound));
     }
     public static Interval Exponential(Interval a) {
-      return new Interval(Math.Exp(a.lowerBound), Math.Exp(a.upperBound));
+      return new Interval(Math.Exp(a.LowerBound), Math.Exp(a.UpperBound));
     }
 
     public static Interval Power(Interval a, Interval b) {
-      if (a.Contains(0.0) && b.lowerBound < 0) return new Interval(double.NaN, double.NaN);
-
-      int bLower = (int)Math.Round(b.lowerBound);
-      int bUpper = (int)Math.Round(b.upperBound);
+      if (a.Contains(0.0) && b.LowerBound < 0) return new Interval(double.NaN, double.NaN);
+
+      int bLower = (int)Math.Round(b.LowerBound);
+      int bUpper = (int)Math.Round(b.UpperBound);
 
       List<double> powerValues = new List<double>();
-      powerValues.Add(Math.Pow(a.upperBound, bUpper));
-      powerValues.Add(Math.Pow(a.upperBound, bUpper - 1));
-      powerValues.Add(Math.Pow(a.upperBound, bLower));
-      powerValues.Add(Math.Pow(a.upperBound, bLower + 1));
-
-      powerValues.Add(Math.Pow(a.lowerBound, bUpper));
-      powerValues.Add(Math.Pow(a.lowerBound, bUpper - 1));
-      powerValues.Add(Math.Pow(a.lowerBound, bLower));
-      powerValues.Add(Math.Pow(a.lowerBound, bLower + 1));
+      powerValues.Add(Math.Pow(a.UpperBound, bUpper));
+      powerValues.Add(Math.Pow(a.UpperBound, bUpper - 1));
+      powerValues.Add(Math.Pow(a.UpperBound, bLower));
+      powerValues.Add(Math.Pow(a.UpperBound, bLower + 1));
+
+      powerValues.Add(Math.Pow(a.LowerBound, bUpper));
+      powerValues.Add(Math.Pow(a.LowerBound, bUpper - 1));
+      powerValues.Add(Math.Pow(a.LowerBound, bLower));
+      powerValues.Add(Math.Pow(a.LowerBound, bLower + 1));
 
       return new Interval(powerValues.Min(), powerValues.Max());
@@ -191,8 +183,8 @@
 
     public static Interval Root(Interval a, Interval b) {
-      int lower = (int)Math.Round(b.lowerBound);
-      int higher = (int)Math.Round(b.upperBound);
-
-      return new Interval(Math.Pow(a.lowerBound, 1.0 / higher), Math.Pow(a.upperBound, 1.0 / lower));
+      int lower = (int)Math.Round(b.LowerBound);
+      int higher = (int)Math.Round(b.UpperBound);
+
+      return new Interval(Math.Pow(a.LowerBound, 1.0 / higher), Math.Pow(a.UpperBound, 1.0 / lower));
     }
 
