Changeset 17409 for branches/2925_AutoDiffForDynamicalModels/HeuristicLab.Tests/HeuristicLab.Problems.DataAnalysis-3.4

Timestamp:

01/28/20 12:14:21 (5 years ago)

Author:

gkronber

Message:

#2925: merged r17255:17402 from trunk to branch

Location:

branches/2925_AutoDiffForDynamicalModels

Files:

• . (modified) (1 prop)
• HeuristicLab.Tests (modified) (1 prop)
• HeuristicLab.Tests/HeuristicLab.Problems.DataAnalysis-3.4/IntervalTest.cs (modified) (12 diffs)

branches/2925_AutoDiffForDynamicalModels/HeuristicLab.Tests/HeuristicLab.Problems.DataAnalysis-3.4/IntervalTest.cs

@@ -14 +14 @@
     [TestCategory("Problems.DataAnalysis")]
     [TestProperty("Time", "short")]
-    public void TestIntervalAddOperation() {
+    public void AddIntervalTest() {
       //add        [x1,x2] + [y1,y2] = [x1 + y1,x2 + y2]
 
@@ -28 +28 @@
     [TestCategory("Problems.DataAnalysis")]
     [TestProperty("Time", "short")]
-    public void TestIntervalSubOperation() {
+    public void SubtractIntervalTest() {
       //subtract   [x1,x2] − [y1,y2] = [x1 − y2,x2 − y1]
 
@@ -42 +42 @@
     [TestCategory("Problems.DataAnalysis")]
     [TestProperty("Time", "short")]
-    public void TestIntervalMutlipyOperation() {
+    public void MultiplyIntervalTest() {
       //multiply   [x1,x2] * [y1,y2] = [min(x1*y1,x1*y2,x2*y1,x2*y2),max(x1*y1,x1*y2,x2*y1,x2*y2)]
 
@@ -59 +59 @@
     [TestCategory("Problems.DataAnalysis")]
     [TestProperty("Time", "short")]
-    public void TestIntervalDivideOperation() {
+    public void DivideIntervalTest() {
       //divide  [x1, x2] / [y1, y2] = [x1, x2] * (1/[y1, y2]), where 1 / [y1,y2] = [1 / y2,1 / y1] if 0 not in [y_1, y_2].
 
@@ -80 +80 @@
     [TestCategory("Problems.DataAnalysis")]
     [TestProperty("Time", "short")]
-    public void TestIntervalSineOperator() {
+    public void SineIntervalTest() {
       //sine depends on interval
       //sin([0, 2*pi]) = [-1, 1]
@@ -98 +98 @@
     [TestCategory("Problems.DataAnalysis")]
     [TestProperty("Time", "short")]
-    public void TestIntervalCosineOperator() {
+    public void CosineIntervalTest() {
       //Cosine uses sine Interval.Sine(Interval.Subtract(a, new Interval(Math.PI / 2, Math.PI / 2)));
       Assert.AreEqual<Interval>(Interval.Cosine(new Interval(0, 2 * Math.PI)), new Interval(-1, 1));
@@ -107 +107 @@
     [TestCategory("Problems.DataAnalysis")]
     [TestProperty("Time", "short")]
-    public void TestIntervalLogOperator() {
+    public void LogIntervalTest() {
       //Log([3, 5]) = [log(3), log(5)]
       Assert.AreEqual<Interval>(new Interval(Math.Log(3), Math.Log(5)), Interval.Logarithm(new Interval(3, 5)));
@@ -122 +122 @@
     [TestCategory("Problems.DataAnalysis")]
     [TestProperty("Time", "short")]
-    public void TestIntervalExpOperator() {
+    public void ExponentialIntervalTest() {
       //Exp([0, 1]) = [exp(0), exp(1)]
       Assert.AreEqual<Interval>(new Interval(1, Math.Exp(1)), Interval.Exponential(new Interval(0, 1)));
@@ -131 +131 @@
     [TestCategory("Problems.DataAnalysis")]
     [TestProperty("Time", "short")]
-    public void TestIntervalSqrOperator() {
+    public void SquareIntervalTest() {
       Assert.AreEqual<Interval>(new Interval(1, 4), Interval.Square(new Interval(1, 2)));
       Assert.AreEqual<Interval>(new Interval(1, 4), Interval.Square(new Interval(-2, -1)));
@@ -140 +140 @@
     [TestCategory("Problems.DataAnalysis")]
     [TestProperty("Time", "short")]
-    public void TestIntervalSqrtOperator() {
+    public void SquarerootIntervalTest() {
       Assert.AreEqual<Interval>(new Interval(1, 2), Interval.SquareRoot(new Interval(1, 4)));
       Assert.AreEqual<Interval>(new Interval(double.NaN, double.NaN), Interval.SquareRoot(new Interval(-4, -1)));
@@ -148 +148 @@
     [TestCategory("Problems.DataAnalysis")]
     [TestProperty("Time", "short")]
-    public void TestIntervalCubeOperator() {
+    public void CubeIntervalTest() {
       Assert.AreEqual<Interval>(new Interval(1, 8), Interval.Cube(new Interval(1, 2)));
       Assert.AreEqual<Interval>(new Interval(-8, -1), Interval.Cube(new Interval(-2, -1)));
@@ -157 +157 @@
     [TestCategory("Problems.DataAnalysis")]
     [TestProperty("Time", "short")]
-    public void TestIntervalCbrtOperator() {
+    public void CubeRootIntervalTest() {
       Assert.AreEqual<Interval>(new Interval(1, 2), Interval.CubicRoot(new Interval(1, 8)));
-      Assert.AreEqual<Interval>(new Interval(double.NaN, double.NaN), Interval.CubicRoot(new Interval(-8, -1)));
+      Assert.AreEqual<Interval>(new Interval(-2, -2), Interval.CubicRoot(new Interval(-8, -8)));
+      Assert.AreEqual<Interval>(new Interval(-2, 2), Interval.CubicRoot(new Interval(-8, 8)));
+      Assert.AreEqual(new Interval(2, 2), Interval.CubicRoot(new Interval(8, 8)));
+      Assert.AreEqual(new Interval(-Math.Pow(6, 1.0 / 3), 2), Interval.CubicRoot(new Interval(-6, 8)));
+      Assert.AreEqual(new Interval(2, 2), Interval.CubicRoot(new Interval(8, 8)));
+      Assert.AreEqual(new Interval(-2, 0), Interval.CubicRoot(new Interval(-8, 0)));
+    }
+
+    [TestMethod]
+    [TestCategory("Problems.DataAnalysis")]
+    [TestProperty("Time", "short")]
+    public void AbsoluteIntervalTest() {
+      Assert.AreEqual(new Interval(2, 5), Interval.Absolute(new Interval(-5, -2)));
+      Assert.AreEqual(new Interval(2, 5), Interval.Absolute(new Interval(2, 5)));
+      Assert.AreEqual(new Interval(0, 3), Interval.Absolute(new Interval(-3, 0)));
+      Assert.AreEqual(new Interval(0, 5), Interval.Absolute(new Interval(0, 5)));
+      Assert.AreEqual(new Interval(0, 5), Interval.Absolute(new Interval(-2, 5)));
+    }
+
+    [TestMethod]
+    [TestCategory("Problems.DataAnalysis")]
+    [TestProperty("Time", "short")]
+    public void AnalyticalQuotientIntervalTest() {
+      //Analytical Quotient ==> a / sqrt(b^2 + 1)
+      var aPos = new Interval(3, 5);
+      var aZero = new Interval(-3, 5);
+      var aNeg = new Interval(-5, -3);
+
+      var bPos = new Interval(2, 4);
+      var bZero = new Interval(-2, 4);
+      var bNeg = new Interval(-4, -2);
+
+      //Second interval goes over zero
+      Assert.AreEqual(new Interval(aPos.LowerBound/Math.Sqrt(17), aPos.UpperBound), Interval.AnalyticalQuotient(aPos, bZero));
+      Assert.AreEqual(new Interval(aZero.LowerBound, aZero.UpperBound), Interval.AnalyticalQuotient(aZero, bZero));
+      Assert.AreEqual(new Interval(aNeg.LowerBound, aNeg.UpperBound/Math.Sqrt(17)), Interval.AnalyticalQuotient(aNeg, bZero));
+      //Second interval is positive
+      Assert.AreEqual(new Interval(aPos.LowerBound/Math.Sqrt(17), aPos.UpperBound/Math.Sqrt(5)), Interval.AnalyticalQuotient(aPos, bPos));
+      Assert.AreEqual(new Interval(aZero.LowerBound/Math.Sqrt(5), aZero.UpperBound/Math.Sqrt(5)), Interval.AnalyticalQuotient(aZero, bPos));
+      Assert.AreEqual(new Interval(aNeg.LowerBound/Math.Sqrt(5), aNeg.UpperBound/Math.Sqrt(17)), Interval.AnalyticalQuotient(aNeg, bPos));
+      //Second interval is negative
+      Assert.AreEqual(new Interval(aPos.LowerBound/Math.Sqrt(17), aPos.UpperBound/Math.Sqrt(5)), Interval.AnalyticalQuotient(aPos, bNeg));
+      Assert.AreEqual(new Interval(aZero.LowerBound/Math.Sqrt(5), aZero.UpperBound/Math.Sqrt(5)), Interval.AnalyticalQuotient(aZero, bNeg));
+      Assert.AreEqual(new Interval(aNeg.LowerBound/Math.Sqrt(5), aNeg.UpperBound/Math.Sqrt(17)), Interval.AnalyticalQuotient(aNeg, bNeg));
+    }
+
+    [TestMethod]
+    [TestCategory("Problems.DataAnalysis")]
+    [TestProperty("Time", "short")]
+    public void IsNegativeIntervalTest() {
+      Assert.IsTrue(new Interval(-2, -1).IsNegative);
+      Assert.IsFalse(new Interval(-2, 0).IsNegative);
+      Assert.IsFalse(new Interval(-2, 2).IsNegative);
+      Assert.IsFalse(new Interval(2, 4).IsNegative);
+    }
+
+    [TestMethod]
+    [TestCategory("Problems.DataAnalysis")]
+    [TestProperty("Time", "short")]
+    public void IsPositiveIntervalTest() {
+      Assert.IsTrue(new Interval(3, 5).IsPositive);
+      Assert.IsFalse(new Interval(0, 5).IsPositive);
+      Assert.IsFalse(new Interval(-1, 5).IsPositive);
+      Assert.IsFalse(new Interval(-5, -2).IsPositive);
+    }
+
+    [TestMethod]
+    [TestCategory("Problems.DataAnalysis")]
+    [TestProperty("Time", "short")]
+    public void IsAlmostIntervalTest() {
+      var negativeLowerBound = -2E-13;
+      var negativeUpperBound = -1E-13;
+      var positiveLowerBound = 3E-13;
+      var positiveUpperBound = 5E-13;
+
+      var negativeInterval = new Interval(negativeLowerBound, negativeUpperBound);
+      var positiveInterval = new Interval(positiveLowerBound, positiveUpperBound);
+      var zeroInterval = new Interval(negativeUpperBound, positiveLowerBound);
+
+      //Check for right-shift of negative interval
+      Assert.AreEqual(negativeUpperBound, negativeInterval.LowerBound);
+      Assert.AreEqual(negativeUpperBound, negativeInterval.UpperBound);
+      //Check for left-shift of positive interval
+      Assert.AreEqual(positiveLowerBound, positiveInterval.LowerBound);
+      Assert.AreEqual(positiveLowerBound, positiveInterval.UpperBound);
+      //Check for setting interval to zero
+      Assert.AreEqual(0, zeroInterval.LowerBound);
+      Assert.AreEqual(0, zeroInterval.UpperBound);
+
     }
   }