commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ebo...@apache.org
Subject [5/7] [math] Fix "FastMath#round(..)" to comply to changed contract of "Math#round()" in Java 8
Date Fri, 05 Aug 2016 15:06:53 GMT
http://git-wip-us.apache.org/repos/asf/commons-math/blob/83b70a37/src/test/java/org/apache/commons/math4/util/FastMathTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/math4/util/FastMathTest.java b/src/test/java/org/apache/commons/math4/util/FastMathTest.java
index cc95c9c..1f94352 100644
--- a/src/test/java/org/apache/commons/math4/util/FastMathTest.java
+++ b/src/test/java/org/apache/commons/math4/util/FastMathTest.java
@@ -16,6 +16,10 @@
  */
 package org.apache.commons.math4.util;
 
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
 import java.lang.reflect.Type;
@@ -30,8 +34,6 @@ import org.apache.commons.math4.dfp.DfpMath;
 import org.apache.commons.math4.exception.MathArithmeticException;
 import org.apache.commons.math4.rng.UniformRandomProvider;
 import org.apache.commons.math4.rng.RandomSource;
-import org.apache.commons.math4.util.FastMath;
-import org.apache.commons.math4.util.Precision;
 import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Ignore;
@@ -42,7 +44,6 @@ public class FastMathTest {
     private static final double MAX_ERROR_ULP = 0.51;
     private static final int NUMBER_OF_TRIALS = 1000;
 
-
     private DfpField field;
     private UniformRandomProvider generator;
 
@@ -67,22 +68,22 @@ public class FastMathTest {
             { Precision.SAFE_MIN, Precision.EPSILON }
         };
         for (double[] pair : pairs) {
-            Assert.assertEquals("min(" + pair[0] + ", " + pair[1] + ")",
-                                Math.min(pair[0], pair[1]),
-                                FastMath.min(pair[0], pair[1]),
-                                Precision.EPSILON);
-            Assert.assertEquals("min(" + pair[1] + ", " + pair[0] + ")",
-                                Math.min(pair[1], pair[0]),
-                                FastMath.min(pair[1], pair[0]),
-                                Precision.EPSILON);
-            Assert.assertEquals("max(" + pair[0] + ", " + pair[1] + ")",
-                                Math.max(pair[0], pair[1]),
-                                FastMath.max(pair[0], pair[1]),
-                                Precision.EPSILON);
-            Assert.assertEquals("max(" + pair[1] + ", " + pair[0] + ")",
-                                Math.max(pair[1], pair[0]),
-                                FastMath.max(pair[1], pair[0]),
-                                Precision.EPSILON);
+            assertEquals("min(" + pair[0] + ", " + pair[1] + ")",
+                         Math.min(pair[0], pair[1]),
+                         FastMath.min(pair[0], pair[1]),
+                         Precision.EPSILON);
+            assertEquals("min(" + pair[1] + ", " + pair[0] + ")",
+                         Math.min(pair[1], pair[0]),
+                         FastMath.min(pair[1], pair[0]),
+                         Precision.EPSILON);
+            assertEquals("max(" + pair[0] + ", " + pair[1] + ")",
+                         Math.max(pair[0], pair[1]),
+                         FastMath.max(pair[0], pair[1]),
+                         Precision.EPSILON);
+            assertEquals("max(" + pair[1] + ", " + pair[0] + ")",
+                         Math.max(pair[1], pair[0]),
+                         FastMath.max(pair[1], pair[0]),
+                         Precision.EPSILON);
         }
     }
 
@@ -100,39 +101,39 @@ public class FastMathTest {
             {  Float.NaN, Float.POSITIVE_INFINITY }
         };
         for (float[] pair : pairs) {
-            Assert.assertEquals("min(" + pair[0] + ", " + pair[1] + ")",
-                                Math.min(pair[0], pair[1]),
-                                FastMath.min(pair[0], pair[1]),
-                                Precision.EPSILON);
-            Assert.assertEquals("min(" + pair[1] + ", " + pair[0] + ")",
-                                Math.min(pair[1], pair[0]),
-                                FastMath.min(pair[1], pair[0]),
-                                Precision.EPSILON);
-            Assert.assertEquals("max(" + pair[0] + ", " + pair[1] + ")",
-                                Math.max(pair[0], pair[1]),
-                                FastMath.max(pair[0], pair[1]),
-                                Precision.EPSILON);
-            Assert.assertEquals("max(" + pair[1] + ", " + pair[0] + ")",
-                                Math.max(pair[1], pair[0]),
-                                FastMath.max(pair[1], pair[0]),
-                                Precision.EPSILON);
+            assertEquals("min(" + pair[0] + ", " + pair[1] + ")",
+                    Math.min(pair[0], pair[1]),
+                    FastMath.min(pair[0], pair[1]),
+                    Precision.EPSILON);
+            assertEquals("min(" + pair[1] + ", " + pair[0] + ")",
+                    Math.min(pair[1], pair[0]),
+                    FastMath.min(pair[1], pair[0]),
+                    Precision.EPSILON);
+            assertEquals("max(" + pair[0] + ", " + pair[1] + ")",
+                    Math.max(pair[0], pair[1]),
+                    FastMath.max(pair[0], pair[1]),
+                    Precision.EPSILON);
+            assertEquals("max(" + pair[1] + ", " + pair[0] + ")",
+                    Math.max(pair[1], pair[0]),
+                    FastMath.max(pair[1], pair[0]),
+                    Precision.EPSILON);
         }
     }
 
     @Test
     public void testConstants() {
-        Assert.assertEquals(Math.PI, FastMath.PI, 1.0e-20);
-        Assert.assertEquals(Math.E, FastMath.E, 1.0e-20);
+        assertEquals(Math.PI, FastMath.PI, 1.0e-20);
+        assertEquals(Math.E, FastMath.E, 1.0e-20);
     }
 
     @Test
     public void testAtan2() {
         double y1 = 1.2713504628280707e10;
         double x1 = -5.674940885228782e-10;
-        Assert.assertEquals(Math.atan2(y1, x1), FastMath.atan2(y1, x1), 2 * Precision.EPSILON);
+        assertEquals(Math.atan2(y1, x1), FastMath.atan2(y1, x1), 2 * Precision.EPSILON);
         double y2 = 0.0;
         double x2 = Double.POSITIVE_INFINITY;
-        Assert.assertEquals(Math.atan2(y2, x2), FastMath.atan2(y2, x2), Precision.SAFE_MIN);
+        assertEquals(Math.atan2(y2, x2), FastMath.atan2(y2, x2), Precision.SAFE_MIN);
     }
 
     @Test
@@ -143,7 +144,7 @@ public class FastMathTest {
             double ref = Math.sinh(x);
             maxErr = FastMath.max(maxErr, FastMath.abs(ref - tst) / FastMath.ulp(ref));
         }
-        Assert.assertEquals(0, maxErr, 2);
+        assertEquals(0, maxErr, 2);
 
         maxErr = 0;
         for (double x = -30; x < 30; x += 0.001) {
@@ -151,7 +152,7 @@ public class FastMathTest {
             double ref = Math.cosh(x);
             maxErr = FastMath.max(maxErr, FastMath.abs(ref - tst) / FastMath.ulp(ref));
         }
-        Assert.assertEquals(0, maxErr, 2);
+        assertEquals(0, maxErr, 2);
 
         maxErr = 0;
         for (double x = -0.5; x < 0.5; x += 0.001) {
@@ -159,7 +160,7 @@ public class FastMathTest {
             double ref = Math.tanh(x);
             maxErr = FastMath.max(maxErr, FastMath.abs(ref - tst) / FastMath.ulp(ref));
         }
-        Assert.assertEquals(0, maxErr, 4);
+        assertEquals(0, maxErr, 4);
 
     }
 
@@ -167,10 +168,10 @@ public class FastMathTest {
     public void testMath904() {
         final double x = -1;
         final double y = (5 + 1e-15) * 1e15;
-        Assert.assertEquals(Math.pow(x, y),
-                            FastMath.pow(x, y), 0);
-        Assert.assertEquals(Math.pow(x, -y),
-                            FastMath.pow(x, -y), 0);
+        assertEquals(Math.pow(x, y),
+                     FastMath.pow(x, y), 0);
+        assertEquals(Math.pow(x, -y),
+                FastMath.pow(x, -y), 0);
     }
 
     @Test
@@ -185,14 +186,14 @@ public class FastMathTest {
             final double ref = Math.cosh(x);
             maxErr = FastMath.max(maxErr, FastMath.abs(ref - tst) / FastMath.ulp(ref));
         }
-        Assert.assertEquals(0, maxErr, 3);
+        assertEquals(0, maxErr, 3);
 
         for (double x = start; x < end; x += 1e-3) {
             final double tst = FastMath.sinh(x);
             final double ref = Math.sinh(x);
             maxErr = FastMath.max(maxErr, FastMath.abs(ref - tst) / FastMath.ulp(ref));
         }
-        Assert.assertEquals(0, maxErr, 3);
+        assertEquals(0, maxErr, 3);
     }
 
     @Test
@@ -207,14 +208,14 @@ public class FastMathTest {
             final double ref = Math.cosh(x);
             maxErr = FastMath.max(maxErr, FastMath.abs(ref - tst) / FastMath.ulp(ref));
         }
-        Assert.assertEquals(0, maxErr, 3);
+        assertEquals(0, maxErr, 3);
 
         for (double x = start; x > end; x -= 1e-3) {
             final double tst = FastMath.sinh(x);
             final double ref = Math.sinh(x);
             maxErr = FastMath.max(maxErr, FastMath.abs(ref - tst) / FastMath.ulp(ref));
         }
-        Assert.assertEquals(0, maxErr, 3);
+        assertEquals(0, maxErr, 3);
     }
 
     @Test
@@ -222,8 +223,8 @@ public class FastMathTest {
         final double arg = 709.8125;
         final double vM = Math.exp(arg);
         final double vFM = FastMath.exp(arg);
-        Assert.assertTrue("exp(" + arg + ") is " + vFM + " instead of " + vM,
-                          Precision.equalsIncludingNaN(vM, vFM));
+        assertTrue("exp(" + arg + ") is " + vFM + " instead of " + vM,
+                Precision.equalsIncludingNaN(vM, vFM));
     }
 
     @Test
@@ -232,20 +233,19 @@ public class FastMathTest {
         for (double x = -30; x < 30; x += 0.01) {
             maxErr = FastMath.max(maxErr, FastMath.abs(x - FastMath.sinh(FastMath.asinh(x))) / (2 * FastMath.ulp(x)));
         }
-        Assert.assertEquals(0, maxErr, 3);
+        assertEquals(0, maxErr, 3);
 
         maxErr = 0;
         for (double x = 1; x < 30; x += 0.01) {
             maxErr = FastMath.max(maxErr, FastMath.abs(x - FastMath.cosh(FastMath.acosh(x))) / (2 * FastMath.ulp(x)));
         }
-        Assert.assertEquals(0, maxErr, 2);
+        assertEquals(0, maxErr, 2);
 
         maxErr = 0;
         for (double x = -1 + Precision.EPSILON; x < 1 - Precision.EPSILON; x += 0.0001) {
             maxErr = FastMath.max(maxErr, FastMath.abs(x - FastMath.tanh(FastMath.atanh(x))) / (2 * FastMath.ulp(x)));
         }
-        Assert.assertEquals(0, maxErr, 2);
-
+        assertEquals(0, maxErr, 2);
     }
 
     @Test
@@ -261,8 +261,7 @@ public class FastMathTest {
 
             if (err != 0.0) {
                 double ulp = Math.abs(ref -
-                                      Double.longBitsToDouble((Double
-                                          .doubleToLongBits(ref) ^ 1)));
+                                      Double.longBitsToDouble((Double.doubleToLongBits(ref) ^ 1)));
                 double errulp = field.newDfp(tst).subtract(DfpMath.log(field.newDfp(x))).divide(field.newDfp(ulp)).toDouble();
 //                System.out.println(x + "\t" + tst + "\t" + ref + "\t" + err + "\t" + errulp);
 
@@ -270,7 +269,7 @@ public class FastMathTest {
             }
         }
 
-        Assert.assertTrue("log() had errors in excess of " + MAX_ERROR_ULP + " ULP", maxerrulp < MAX_ERROR_ULP);
+        assertTrue("log() had errors in excess of " + MAX_ERROR_ULP + " ULP", maxerrulp < MAX_ERROR_ULP);
     }
 
     @Test
@@ -294,7 +293,7 @@ public class FastMathTest {
             }
         }
 
-        Assert.assertTrue("log10() had errors in excess of " + MAX_ERROR_ULP + " ULP", maxerrulp < MAX_ERROR_ULP);
+        assertTrue("log10() had errors in excess of " + MAX_ERROR_ULP + " ULP", maxerrulp < MAX_ERROR_ULP);
     }
 
     @Test
@@ -318,302 +317,237 @@ public class FastMathTest {
             }
         }
 
-        Assert.assertTrue("log1p() had errors in excess of " + MAX_ERROR_ULP + " ULP", maxerrulp < MAX_ERROR_ULP);
+        assertTrue("log1p() had errors in excess of " + MAX_ERROR_ULP + " ULP", maxerrulp < MAX_ERROR_ULP);
     }
 
     @Test
     public void testLog1pSpecialCases() {
-
-        Assert.assertTrue("Logp of -1.0 should be -Inf", Double.isInfinite(FastMath.log1p(-1.0)));
-
+        assertTrue("Logp of -1.0 should be -Inf", Double.isInfinite(FastMath.log1p(-1.0)));
     }
 
     @Test
     public void testLogSpecialCases() {
-
-        Assert.assertEquals("Log of zero should be -Inf", Double.NEGATIVE_INFINITY, FastMath.log(0.0), 1.0);
-
-        Assert.assertEquals("Log of -zero should be -Inf", Double.NEGATIVE_INFINITY, FastMath.log(-0.0), 1.0);
-
-        Assert.assertTrue("Log of NaN should be NaN", Double.isNaN(FastMath.log(Double.NaN)));
-
-        Assert.assertTrue("Log of negative number should be NaN", Double.isNaN(FastMath.log(-1.0)));
-
-        Assert.assertEquals("Log of Double.MIN_VALUE should be -744.4400719213812", -744.4400719213812, FastMath.log(Double.MIN_VALUE), Precision.EPSILON);
-
-        Assert.assertEquals("Log of infinity should be infinity", Double.POSITIVE_INFINITY, FastMath.log(Double.POSITIVE_INFINITY), 1.0);
+        assertEquals("Log of zero should be -Inf", Double.NEGATIVE_INFINITY, FastMath.log(0.0), 1.0);
+        assertEquals("Log of -zero should be -Inf", Double.NEGATIVE_INFINITY, FastMath.log(-0.0), 1.0);
+        assertTrue("Log of NaN should be NaN", Double.isNaN(FastMath.log(Double.NaN)));
+        assertTrue("Log of negative number should be NaN", Double.isNaN(FastMath.log(-1.0)));
+        assertEquals("Log of Double.MIN_VALUE should be -744.4400719213812", -744.4400719213812, FastMath.log(Double.MIN_VALUE), Precision.EPSILON);
+        assertEquals("Log of infinity should be infinity", Double.POSITIVE_INFINITY, FastMath.log(Double.POSITIVE_INFINITY), 1.0);
     }
 
     @Test
     public void testExpSpecialCases() {
-
         // Smallest value that will round up to Double.MIN_VALUE
-        Assert.assertEquals(Double.MIN_VALUE, FastMath.exp(-745.1332191019411), Precision.EPSILON);
-
-        Assert.assertEquals("exp(-745.1332191019412) should be 0.0", 0.0, FastMath.exp(-745.1332191019412), Precision.EPSILON);
-
-        Assert.assertTrue("exp of NaN should be NaN", Double.isNaN(FastMath.exp(Double.NaN)));
-
-        Assert.assertEquals("exp of infinity should be infinity", Double.POSITIVE_INFINITY, FastMath.exp(Double.POSITIVE_INFINITY), 1.0);
-
-        Assert.assertEquals("exp of -infinity should be 0.0", 0.0, FastMath.exp(Double.NEGATIVE_INFINITY), Precision.EPSILON);
-
-        Assert.assertEquals("exp(1) should be Math.E", Math.E, FastMath.exp(1.0), Precision.EPSILON);
+        assertEquals(Double.MIN_VALUE, FastMath.exp(-745.1332191019411), Precision.EPSILON);
+        assertEquals("exp(-745.1332191019412) should be 0.0", 0.0, FastMath.exp(-745.1332191019412), Precision.EPSILON);
+        assertTrue("exp of NaN should be NaN", Double.isNaN(FastMath.exp(Double.NaN)));
+        assertEquals("exp of infinity should be infinity", Double.POSITIVE_INFINITY, FastMath.exp(Double.POSITIVE_INFINITY), 1.0);
+        assertEquals("exp of -infinity should be 0.0", 0.0, FastMath.exp(Double.NEGATIVE_INFINITY), Precision.EPSILON);
+        assertEquals("exp(1) should be Math.E", Math.E, FastMath.exp(1.0), Precision.EPSILON);
     }
 
     @Test
     public void testPowSpecialCases() {
         final double EXACT = -1.0;
 
-        Assert.assertEquals("pow(-1, 0) should be 1.0", 1.0, FastMath.pow(-1.0, 0.0), Precision.EPSILON);
-
-        Assert.assertEquals("pow(-1, -0) should be 1.0", 1.0, FastMath.pow(-1.0, -0.0), Precision.EPSILON);
-
-        Assert.assertEquals("pow(PI, 1.0) should be PI", FastMath.PI, FastMath.pow(FastMath.PI, 1.0), Precision.EPSILON);
-
-        Assert.assertEquals("pow(-PI, 1.0) should be -PI", -FastMath.PI, FastMath.pow(-FastMath.PI, 1.0), Precision.EPSILON);
-
-        Assert.assertTrue("pow(PI, NaN) should be NaN", Double.isNaN(FastMath.pow(Math.PI, Double.NaN)));
-
-        Assert.assertTrue("pow(NaN, PI) should be NaN", Double.isNaN(FastMath.pow(Double.NaN, Math.PI)));
-
-        Assert.assertEquals("pow(2.0, Infinity) should be Infinity", Double.POSITIVE_INFINITY, FastMath.pow(2.0, Double.POSITIVE_INFINITY), 1.0);
-
-        Assert.assertEquals("pow(0.5, -Infinity) should be Infinity", Double.POSITIVE_INFINITY, FastMath.pow(0.5, Double.NEGATIVE_INFINITY), 1.0);
-
-        Assert.assertEquals("pow(0.5, Infinity) should be 0.0", 0.0, FastMath.pow(0.5, Double.POSITIVE_INFINITY), Precision.EPSILON);
-
-        Assert.assertEquals("pow(2.0, -Infinity) should be 0.0", 0.0, FastMath.pow(2.0, Double.NEGATIVE_INFINITY), Precision.EPSILON);
-
-        Assert.assertEquals("pow(0.0, 0.5) should be 0.0", 0.0, FastMath.pow(0.0, 0.5), Precision.EPSILON);
-
-        Assert.assertEquals("pow(Infinity, -0.5) should be 0.0", 0.0, FastMath.pow(Double.POSITIVE_INFINITY, -0.5), Precision.EPSILON);
-
-        Assert.assertEquals("pow(0.0, -0.5) should be Inf", Double.POSITIVE_INFINITY, FastMath.pow(0.0, -0.5), 1.0);
-
-        Assert.assertEquals("pow(Inf, 0.5) should be Inf", Double.POSITIVE_INFINITY, FastMath.pow(Double.POSITIVE_INFINITY, 0.5), 1.0);
-
-        Assert.assertEquals("pow(-0.0, -3.0) should be -Inf", Double.NEGATIVE_INFINITY, FastMath.pow(-0.0, -3.0), 1.0);
-
-        Assert.assertEquals("pow(-0.0, Infinity) should be 0.0", 0.0, FastMath.pow(-0.0, Double.POSITIVE_INFINITY), Precision.EPSILON);
-
-        Assert.assertTrue("pow(-0.0, NaN) should be NaN", Double.isNaN(FastMath.pow(-0.0, Double.NaN)));
-
-        Assert.assertEquals("pow(-0.0, -tiny) should be Infinity", Double.POSITIVE_INFINITY, FastMath.pow(-0.0, -Double.MIN_VALUE), 1.0);
-
-        Assert.assertEquals("pow(-0.0, -huge) should be Infinity", Double.POSITIVE_INFINITY, FastMath.pow(-0.0, -Double.MAX_VALUE), 1.0);
-
-        Assert.assertEquals("pow(-Inf, 3.0) should be -Inf", Double.NEGATIVE_INFINITY, FastMath.pow(Double.NEGATIVE_INFINITY, 3.0), 1.0);
-
-        Assert.assertEquals("pow(-Inf, -3.0) should be -0.0", -0.0, FastMath.pow(Double.NEGATIVE_INFINITY, -3.0), EXACT);
-
-        Assert.assertEquals("pow(-0.0, -3.5) should be Inf", Double.POSITIVE_INFINITY, FastMath.pow(-0.0, -3.5), 1.0);
-
-        Assert.assertEquals("pow(Inf, 3.5) should be Inf", Double.POSITIVE_INFINITY, FastMath.pow(Double.POSITIVE_INFINITY, 3.5), 1.0);
-
-        Assert.assertEquals("pow(-2.0, 3.0) should be -8.0", -8.0, FastMath.pow(-2.0, 3.0), Precision.EPSILON);
-
-        Assert.assertTrue("pow(-2.0, 3.5) should be NaN", Double.isNaN(FastMath.pow(-2.0, 3.5)));
-
-        Assert.assertTrue("pow(NaN, -Infinity) should be NaN", Double.isNaN(FastMath.pow(Double.NaN, Double.NEGATIVE_INFINITY)));
-
-        Assert.assertEquals("pow(NaN, 0.0) should be 1.0", 1.0, FastMath.pow(Double.NaN, 0.0), Precision.EPSILON);
-
-        Assert.assertEquals("pow(-Infinity, -Infinity) should be 0.0", 0.0, FastMath.pow(Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY), Precision.EPSILON);
-
-        Assert.assertEquals("pow(-huge, -huge) should be 0.0", 0.0, FastMath.pow(-Double.MAX_VALUE, -Double.MAX_VALUE), Precision.EPSILON);
-
-        Assert.assertTrue("pow(-huge,  huge) should be +Inf", Double.isInfinite(FastMath.pow(-Double.MAX_VALUE, Double.MAX_VALUE)));
-
-        Assert.assertTrue("pow(NaN, -Infinity) should be NaN", Double.isNaN(FastMath.pow(Double.NaN, Double.NEGATIVE_INFINITY)));
-
-        Assert.assertEquals("pow(NaN, -0.0) should be 1.0", 1.0, FastMath.pow(Double.NaN, -0.0), Precision.EPSILON);
-
-        Assert.assertEquals("pow(-Infinity, -Infinity) should be 0.0", 0.0, FastMath.pow(Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY), Precision.EPSILON);
-
-        Assert.assertEquals("pow(-huge, -huge) should be 0.0", 0.0, FastMath.pow(-Double.MAX_VALUE, -Double.MAX_VALUE), Precision.EPSILON);
-
-        Assert.assertEquals("pow(-huge,  huge) should be +Inf", Double.POSITIVE_INFINITY, FastMath.pow(-Double.MAX_VALUE, Double.MAX_VALUE), 1.0);
+        assertEquals("pow(-1, 0) should be 1.0", 1.0, FastMath.pow(-1.0, 0.0), Precision.EPSILON);
+        assertEquals("pow(-1, -0) should be 1.0", 1.0, FastMath.pow(-1.0, -0.0), Precision.EPSILON);
+        assertEquals("pow(PI, 1.0) should be PI", FastMath.PI, FastMath.pow(FastMath.PI, 1.0), Precision.EPSILON);
+        assertEquals("pow(-PI, 1.0) should be -PI", -FastMath.PI, FastMath.pow(-FastMath.PI, 1.0), Precision.EPSILON);
+        assertTrue("pow(PI, NaN) should be NaN", Double.isNaN(FastMath.pow(Math.PI, Double.NaN)));
+        assertTrue("pow(NaN, PI) should be NaN", Double.isNaN(FastMath.pow(Double.NaN, Math.PI)));
+        assertEquals("pow(2.0, Infinity) should be Infinity", Double.POSITIVE_INFINITY, FastMath.pow(2.0, Double.POSITIVE_INFINITY), 1.0);
+        assertEquals("pow(0.5, -Infinity) should be Infinity", Double.POSITIVE_INFINITY, FastMath.pow(0.5, Double.NEGATIVE_INFINITY), 1.0);
+        assertEquals("pow(0.5, Infinity) should be 0.0", 0.0, FastMath.pow(0.5, Double.POSITIVE_INFINITY), Precision.EPSILON);
+        assertEquals("pow(2.0, -Infinity) should be 0.0", 0.0, FastMath.pow(2.0, Double.NEGATIVE_INFINITY), Precision.EPSILON);
+        assertEquals("pow(0.0, 0.5) should be 0.0", 0.0, FastMath.pow(0.0, 0.5), Precision.EPSILON);
+        assertEquals("pow(Infinity, -0.5) should be 0.0", 0.0, FastMath.pow(Double.POSITIVE_INFINITY, -0.5), Precision.EPSILON);
+        assertEquals("pow(0.0, -0.5) should be Inf", Double.POSITIVE_INFINITY, FastMath.pow(0.0, -0.5), 1.0);
+        assertEquals("pow(Inf, 0.5) should be Inf", Double.POSITIVE_INFINITY, FastMath.pow(Double.POSITIVE_INFINITY, 0.5), 1.0);
+        assertEquals("pow(-0.0, -3.0) should be -Inf", Double.NEGATIVE_INFINITY, FastMath.pow(-0.0, -3.0), 1.0);
+        assertEquals("pow(-0.0, Infinity) should be 0.0", 0.0, FastMath.pow(-0.0, Double.POSITIVE_INFINITY), Precision.EPSILON);
+        assertTrue("pow(-0.0, NaN) should be NaN", Double.isNaN(FastMath.pow(-0.0, Double.NaN)));
+        assertEquals("pow(-0.0, -tiny) should be Infinity", Double.POSITIVE_INFINITY, FastMath.pow(-0.0, -Double.MIN_VALUE), 1.0);
+        assertEquals("pow(-0.0, -huge) should be Infinity", Double.POSITIVE_INFINITY, FastMath.pow(-0.0, -Double.MAX_VALUE), 1.0);
+        assertEquals("pow(-Inf, 3.0) should be -Inf", Double.NEGATIVE_INFINITY, FastMath.pow(Double.NEGATIVE_INFINITY, 3.0), 1.0);
+        assertEquals("pow(-Inf, -3.0) should be -0.0", -0.0, FastMath.pow(Double.NEGATIVE_INFINITY, -3.0), EXACT);
+        assertEquals("pow(-0.0, -3.5) should be Inf", Double.POSITIVE_INFINITY, FastMath.pow(-0.0, -3.5), 1.0);
+        assertEquals("pow(Inf, 3.5) should be Inf", Double.POSITIVE_INFINITY, FastMath.pow(Double.POSITIVE_INFINITY, 3.5), 1.0);
+        assertEquals("pow(-2.0, 3.0) should be -8.0", -8.0, FastMath.pow(-2.0, 3.0), Precision.EPSILON);
+        assertTrue("pow(-2.0, 3.5) should be NaN", Double.isNaN(FastMath.pow(-2.0, 3.5)));
+        assertTrue("pow(NaN, -Infinity) should be NaN", Double.isNaN(FastMath.pow(Double.NaN, Double.NEGATIVE_INFINITY)));
+        assertEquals("pow(NaN, 0.0) should be 1.0", 1.0, FastMath.pow(Double.NaN, 0.0), Precision.EPSILON);
+        assertEquals("pow(-Infinity, -Infinity) should be 0.0", 0.0, FastMath.pow(Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY), Precision.EPSILON);
+        assertEquals("pow(-huge, -huge) should be 0.0", 0.0, FastMath.pow(-Double.MAX_VALUE, -Double.MAX_VALUE), Precision.EPSILON);
+        assertTrue("pow(-huge,  huge) should be +Inf", Double.isInfinite(FastMath.pow(-Double.MAX_VALUE, Double.MAX_VALUE)));
+        assertTrue("pow(NaN, -Infinity) should be NaN", Double.isNaN(FastMath.pow(Double.NaN, Double.NEGATIVE_INFINITY)));
+        assertEquals("pow(NaN, -0.0) should be 1.0", 1.0, FastMath.pow(Double.NaN, -0.0), Precision.EPSILON);
+        assertEquals("pow(-Infinity, -Infinity) should be 0.0", 0.0, FastMath.pow(Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY), Precision.EPSILON);
+        assertEquals("pow(-huge, -huge) should be 0.0", 0.0, FastMath.pow(-Double.MAX_VALUE, -Double.MAX_VALUE), Precision.EPSILON);
+        assertEquals("pow(-huge,  huge) should be +Inf", Double.POSITIVE_INFINITY, FastMath.pow(-Double.MAX_VALUE, Double.MAX_VALUE), 1.0);
 
         // Added tests for a 100% coverage
 
-        Assert.assertTrue("pow(+Inf, NaN) should be NaN", Double.isNaN(FastMath.pow(Double.POSITIVE_INFINITY, Double.NaN)));
-
-        Assert.assertTrue("pow(1.0, +Inf) should be NaN", Double.isNaN(FastMath.pow(1.0, Double.POSITIVE_INFINITY)));
-
-        Assert.assertTrue("pow(-Inf, NaN) should be NaN", Double.isNaN(FastMath.pow(Double.NEGATIVE_INFINITY, Double.NaN)));
-
-        Assert.assertEquals("pow(-Inf, -1.0) should be -0.0", -0.0, FastMath.pow(Double.NEGATIVE_INFINITY, -1.0), EXACT);
-
-        Assert.assertEquals("pow(-Inf, -2.0) should be 0.0", 0.0, FastMath.pow(Double.NEGATIVE_INFINITY, -2.0), EXACT);
-
-        Assert.assertEquals("pow(-Inf, 1.0) should be -Inf", Double.NEGATIVE_INFINITY, FastMath.pow(Double.NEGATIVE_INFINITY, 1.0), 1.0);
-
-        Assert.assertEquals("pow(-Inf, 2.0) should be +Inf", Double.POSITIVE_INFINITY, FastMath.pow(Double.NEGATIVE_INFINITY, 2.0), 1.0);
-
-        Assert.assertTrue("pow(1.0, -Inf) should be NaN", Double.isNaN(FastMath.pow(1.0, Double.NEGATIVE_INFINITY)));
-
-        Assert.assertEquals("pow(-0.0, 1.0) should be -0.0", -0.0, FastMath.pow(-0.0, 1.0), EXACT);
-
-        Assert.assertEquals("pow(0.0, 1.0) should be 0.0", 0.0, FastMath.pow(0.0, 1.0), EXACT);
-
-        Assert.assertEquals("pow(0.0, +Inf) should be 0.0", 0.0, FastMath.pow(0.0, Double.POSITIVE_INFINITY), EXACT);
-
-        Assert.assertEquals("pow(-0.0, even) should be 0.0", 0.0, FastMath.pow(-0.0, 6.0), EXACT);
-
-        Assert.assertEquals("pow(-0.0, odd) should be -0.0", -0.0, FastMath.pow(-0.0, 13.0), EXACT);
-
-        Assert.assertEquals("pow(-0.0, -even) should be +Inf", Double.POSITIVE_INFINITY, FastMath.pow(-0.0, -6.0), EXACT);
-
-        Assert.assertEquals("pow(-0.0, -odd) should be -Inf", Double.NEGATIVE_INFINITY, FastMath.pow(-0.0, -13.0), EXACT);
-
-        Assert.assertEquals("pow(-2.0, 4.0) should be 16.0", 16.0, FastMath.pow(-2.0, 4.0), EXACT);
-
-        Assert.assertEquals("pow(-2.0, 4.5) should be NaN", Double.NaN, FastMath.pow(-2.0, 4.5), EXACT);
-
-        Assert.assertEquals("pow(-0.0, -0.0) should be 1.0", 1.0, FastMath.pow(-0.0, -0.0), EXACT);
-
-        Assert.assertEquals("pow(-0.0, 0.0) should be 1.0", 1.0, FastMath.pow(-0.0, 0.0), EXACT);
-
-        Assert.assertEquals("pow(0.0, -0.0) should be 1.0", 1.0, FastMath.pow(0.0, -0.0), EXACT);
-
-        Assert.assertEquals("pow(0.0, 0.0) should be 1.0", 1.0, FastMath.pow(0.0, 0.0), EXACT);
-
+        assertTrue("pow(+Inf, NaN) should be NaN", Double.isNaN(FastMath.pow(Double.POSITIVE_INFINITY, Double.NaN)));
+        assertTrue("pow(1.0, +Inf) should be NaN", Double.isNaN(FastMath.pow(1.0, Double.POSITIVE_INFINITY)));
+        assertTrue("pow(-Inf, NaN) should be NaN", Double.isNaN(FastMath.pow(Double.NEGATIVE_INFINITY, Double.NaN)));
+        assertEquals("pow(-Inf, -1.0) should be -0.0", -0.0, FastMath.pow(Double.NEGATIVE_INFINITY, -1.0), EXACT);
+        assertEquals("pow(-Inf, -2.0) should be 0.0", 0.0, FastMath.pow(Double.NEGATIVE_INFINITY, -2.0), EXACT);
+        assertEquals("pow(-Inf, 1.0) should be -Inf", Double.NEGATIVE_INFINITY, FastMath.pow(Double.NEGATIVE_INFINITY, 1.0), 1.0);
+        assertEquals("pow(-Inf, 2.0) should be +Inf", Double.POSITIVE_INFINITY, FastMath.pow(Double.NEGATIVE_INFINITY, 2.0), 1.0);
+        assertTrue("pow(1.0, -Inf) should be NaN", Double.isNaN(FastMath.pow(1.0, Double.NEGATIVE_INFINITY)));
+        assertEquals("pow(-0.0, 1.0) should be -0.0", -0.0, FastMath.pow(-0.0, 1.0), EXACT);
+        assertEquals("pow(0.0, 1.0) should be 0.0", 0.0, FastMath.pow(0.0, 1.0), EXACT);
+        assertEquals("pow(0.0, +Inf) should be 0.0", 0.0, FastMath.pow(0.0, Double.POSITIVE_INFINITY), EXACT);
+        assertEquals("pow(-0.0, even) should be 0.0", 0.0, FastMath.pow(-0.0, 6.0), EXACT);
+        assertEquals("pow(-0.0, odd) should be -0.0", -0.0, FastMath.pow(-0.0, 13.0), EXACT);
+        assertEquals("pow(-0.0, -even) should be +Inf", Double.POSITIVE_INFINITY, FastMath.pow(-0.0, -6.0), EXACT);
+        assertEquals("pow(-0.0, -odd) should be -Inf", Double.NEGATIVE_INFINITY, FastMath.pow(-0.0, -13.0), EXACT);
+        assertEquals("pow(-2.0, 4.0) should be 16.0", 16.0, FastMath.pow(-2.0, 4.0), EXACT);
+        assertEquals("pow(-2.0, 4.5) should be NaN", Double.NaN, FastMath.pow(-2.0, 4.5), EXACT);
+        assertEquals("pow(-0.0, -0.0) should be 1.0", 1.0, FastMath.pow(-0.0, -0.0), EXACT);
+        assertEquals("pow(-0.0, 0.0) should be 1.0", 1.0, FastMath.pow(-0.0, 0.0), EXACT);
+        assertEquals("pow(0.0, -0.0) should be 1.0", 1.0, FastMath.pow(0.0, -0.0), EXACT);
+        assertEquals("pow(0.0, 0.0) should be 1.0", 1.0, FastMath.pow(0.0, 0.0), EXACT);
     }
 
     @Test(timeout=20000L)
     public void testPowAllSpecialCases() {
         final double EXACT = -1.0;
-        final double DOUBLES[] = new double[]{Double.NEGATIVE_INFINITY, -0.0, Double.NaN, 0.0, Double.POSITIVE_INFINITY,
-                                              Long.MIN_VALUE, Integer.MIN_VALUE, Short.MIN_VALUE, Byte.MIN_VALUE,
-                                              -(double)Long.MIN_VALUE, -(double)Integer.MIN_VALUE, -(double)Short.MIN_VALUE, -(double)Byte.MIN_VALUE,
-                                              Byte.MAX_VALUE, Short.MAX_VALUE, Integer.MAX_VALUE, Long.MAX_VALUE,
-                                              -Byte.MAX_VALUE, -Short.MAX_VALUE, -Integer.MAX_VALUE, -Long.MAX_VALUE,
-                                              Float.MAX_VALUE, Double.MAX_VALUE, Double.MIN_VALUE, Float.MIN_VALUE,
-                                              -Float.MAX_VALUE, -Double.MAX_VALUE, -Double.MIN_VALUE, -Float.MIN_VALUE,
-                                              0.5, 0.1, 0.2, 0.8, 1.1, 1.2, 1.5, 1.8, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 1.3, 2.2, 2.5, 2.8, 33.0, 33.1, 33.5, 33.8, 10.0, 300.0, 400.0, 500.0,
-                                              -0.5, -0.1, -0.2, -0.8, -1.1, -1.2, -1.5, -1.8, -1.0, -2.0, -3.0, -4.0, -5.0, -6.0, -7.0, -8.0, -9.0, -1.3, -2.2, -2.5, -2.8, -33.0, -33.1, -33.5, -33.8, -10.0, -300.0, -400.0, -500.0};
+        final double DOUBLES[] = new double[]
+            {
+                Double.NEGATIVE_INFINITY, -0.0, Double.NaN, 0.0, Double.POSITIVE_INFINITY,
+                Long.MIN_VALUE, Integer.MIN_VALUE, Short.MIN_VALUE, Byte.MIN_VALUE,
+                -(double)Long.MIN_VALUE, -(double)Integer.MIN_VALUE, -(double)Short.MIN_VALUE, -(double)Byte.MIN_VALUE,
+                Byte.MAX_VALUE, Short.MAX_VALUE, Integer.MAX_VALUE, Long.MAX_VALUE,
+                -Byte.MAX_VALUE, -Short.MAX_VALUE, -Integer.MAX_VALUE, -Long.MAX_VALUE,
+                Float.MAX_VALUE, Double.MAX_VALUE, Double.MIN_VALUE, Float.MIN_VALUE,
+                -Float.MAX_VALUE, -Double.MAX_VALUE, -Double.MIN_VALUE, -Float.MIN_VALUE,
+                0.5, 0.1, 0.2, 0.8, 1.1, 1.2, 1.5, 1.8, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 1.3, 2.2, 2.5, 2.8, 33.0, 33.1, 33.5, 33.8, 10.0, 300.0, 400.0, 500.0,
+                -0.5, -0.1, -0.2, -0.8, -1.1, -1.2, -1.5, -1.8, -1.0, -2.0, -3.0, -4.0, -5.0, -6.0, -7.0, -8.0, -9.0, -1.3, -2.2, -2.5, -2.8, -33.0, -33.1, -33.5, -33.8, -10.0, -300.0, -400.0, -500.0
+            };
+
         // Special cases from Math.pow javadoc:
         // If the second argument is positive or negative zero, then the result is 1.0.
         for (double d : DOUBLES) {
-            Assert.assertEquals(1.0, FastMath.pow(d, 0.0), EXACT);
+            assertEquals(1.0, FastMath.pow(d, 0.0), EXACT);
         }
         for (double d : DOUBLES) {
-            Assert.assertEquals(1.0, FastMath.pow(d, -0.0), EXACT);
+            assertEquals(1.0, FastMath.pow(d, -0.0), EXACT);
         }
         // If the second argument is 1.0, then the result is the same as the first argument.
         for (double d : DOUBLES) {
-            Assert.assertEquals(d, FastMath.pow(d, 1.0), EXACT);
+            assertEquals(d, FastMath.pow(d, 1.0), EXACT);
         }
         // If the second argument is NaN, then the result is NaN.
         for (double d : DOUBLES) {
-            Assert.assertEquals(Double.NaN, FastMath.pow(d, Double.NaN), EXACT);
+            assertEquals(Double.NaN, FastMath.pow(d, Double.NaN), EXACT);
         }
         // If the first argument is NaN and the second argument is nonzero, then the result is NaN.
         for (double i : DOUBLES) {
             if (i != 0.0) {
-                Assert.assertEquals(Double.NaN, FastMath.pow(Double.NaN, i), EXACT);
+                assertEquals(Double.NaN, FastMath.pow(Double.NaN, i), EXACT);
             }
         }
         // If the absolute value of the first argument is greater than 1 and the second argument is positive infinity, or
         // the absolute value of the first argument is less than 1 and the second argument is negative infinity, then the result is positive infinity.
         for (double d : DOUBLES) {
             if (Math.abs(d) > 1.0) {
-                Assert.assertEquals(Double.POSITIVE_INFINITY, FastMath.pow(d, Double.POSITIVE_INFINITY), EXACT);
+                assertEquals(Double.POSITIVE_INFINITY, FastMath.pow(d, Double.POSITIVE_INFINITY), EXACT);
             }
         }
         for (double d : DOUBLES) {
             if (Math.abs(d) < 1.0) {
-                Assert.assertEquals(Double.POSITIVE_INFINITY, FastMath.pow(d, Double.NEGATIVE_INFINITY), EXACT);
+                assertEquals(Double.POSITIVE_INFINITY, FastMath.pow(d, Double.NEGATIVE_INFINITY), EXACT);
             }
         }
         // If the absolute value of the first argument is greater than 1 and the second argument is negative infinity, or
         // the absolute value of the first argument is less than 1 and the second argument is positive infinity, then the result is positive zero.
         for (double d : DOUBLES) {
             if (Math.abs(d) > 1.0) {
-                Assert.assertEquals(0.0, FastMath.pow(d, Double.NEGATIVE_INFINITY), EXACT);
+                assertEquals(0.0, FastMath.pow(d, Double.NEGATIVE_INFINITY), EXACT);
             }
         }
         for (double d : DOUBLES) {
             if (Math.abs(d) < 1.0) {
-                Assert.assertEquals(0.0, FastMath.pow(d, Double.POSITIVE_INFINITY), EXACT);
+                assertEquals(0.0, FastMath.pow(d, Double.POSITIVE_INFINITY), EXACT);
             }
         }
         // If the absolute value of the first argument equals 1 and the second argument is infinite, then the result is NaN.
-        Assert.assertEquals(Double.NaN, FastMath.pow(1.0, Double.POSITIVE_INFINITY), EXACT);
-        Assert.assertEquals(Double.NaN, FastMath.pow(1.0, Double.NEGATIVE_INFINITY), EXACT);
-        Assert.assertEquals(Double.NaN, FastMath.pow(-1.0, Double.POSITIVE_INFINITY), EXACT);
-        Assert.assertEquals(Double.NaN, FastMath.pow(-1.0, Double.NEGATIVE_INFINITY), EXACT);
+        assertEquals(Double.NaN, FastMath.pow(1.0, Double.POSITIVE_INFINITY), EXACT);
+        assertEquals(Double.NaN, FastMath.pow(1.0, Double.NEGATIVE_INFINITY), EXACT);
+        assertEquals(Double.NaN, FastMath.pow(-1.0, Double.POSITIVE_INFINITY), EXACT);
+        assertEquals(Double.NaN, FastMath.pow(-1.0, Double.NEGATIVE_INFINITY), EXACT);
         // If the first argument is positive zero and the second argument is greater than zero, or
         // the first argument is positive infinity and the second argument is less than zero, then the result is positive zero.
         for (double i : DOUBLES) {
             if (i > 0.0) {
-                Assert.assertEquals(0.0, FastMath.pow(0.0, i), EXACT);
+                assertEquals(0.0, FastMath.pow(0.0, i), EXACT);
             }
         }
         for (double i : DOUBLES) {
             if (i < 0.0) {
-                Assert.assertEquals(0.0, FastMath.pow(Double.POSITIVE_INFINITY, i), EXACT);
+                assertEquals(0.0, FastMath.pow(Double.POSITIVE_INFINITY, i), EXACT);
             }
         }
         // If the first argument is positive zero and the second argument is less than zero, or
         // the first argument is positive infinity and the second argument is greater than zero, then the result is positive infinity.
         for (double i : DOUBLES) {
             if (i < 0.0) {
-                Assert.assertEquals(Double.POSITIVE_INFINITY, FastMath.pow(0.0, i), EXACT);
+                assertEquals(Double.POSITIVE_INFINITY, FastMath.pow(0.0, i), EXACT);
             }
         }
         for (double i : DOUBLES) {
             if (i > 0.0) {
-                Assert.assertEquals(Double.POSITIVE_INFINITY, FastMath.pow(Double.POSITIVE_INFINITY, i), EXACT);
+                assertEquals(Double.POSITIVE_INFINITY, FastMath.pow(Double.POSITIVE_INFINITY, i), EXACT);
             }
         }
         // If the first argument is negative zero and the second argument is greater than zero but not a finite odd integer, or
         // the first argument is negative infinity and the second argument is less than zero but not a finite odd integer, then the result is positive zero.
         for (double i : DOUBLES) {
             if (i > 0.0 && (Double.isInfinite(i) || i % 2.0 == 0.0)) {
-                Assert.assertEquals(0.0, FastMath.pow(-0.0, i), EXACT);
+                assertEquals(0.0, FastMath.pow(-0.0, i), EXACT);
             }
         }
         for (double i : DOUBLES) {
             if (i < 0.0 && (Double.isInfinite(i) || i % 2.0 == 0.0)) {
-                Assert.assertEquals(0.0, FastMath.pow(Double.NEGATIVE_INFINITY, i), EXACT);
+                assertEquals(0.0, FastMath.pow(Double.NEGATIVE_INFINITY, i), EXACT);
             }
         }
         // If the first argument is negative zero and the second argument is a positive finite odd integer, or
         // the first argument is negative infinity and the second argument is a negative finite odd integer, then the result is negative zero.
         for (double i : DOUBLES) {
             if (i > 0.0 && i % 2.0 == 1.0) {
-                Assert.assertEquals(-0.0, FastMath.pow(-0.0, i), EXACT);
+                assertEquals(-0.0, FastMath.pow(-0.0, i), EXACT);
             }
         }
         for (double i : DOUBLES) {
             if (i < 0.0 && i % 2.0 == -1.0) {
-                Assert.assertEquals(-0.0, FastMath.pow(Double.NEGATIVE_INFINITY, i), EXACT);
+                assertEquals(-0.0, FastMath.pow(Double.NEGATIVE_INFINITY, i), EXACT);
             }
         }
         // If the first argument is negative zero and the second argument is less than zero but not a finite odd integer, or
         // the first argument is negative infinity and the second argument is greater than zero but not a finite odd integer, then the result is positive infinity.
         for (double i : DOUBLES) {
             if (i > 0.0 && (Double.isInfinite(i) || i % 2.0 == 0.0)) {
-                Assert.assertEquals(Double.POSITIVE_INFINITY, FastMath.pow(Double.NEGATIVE_INFINITY, i), EXACT);
+                assertEquals(Double.POSITIVE_INFINITY, FastMath.pow(Double.NEGATIVE_INFINITY, i), EXACT);
             }
         }
         for (double i : DOUBLES) {
             if (i < 0.0 && (Double.isInfinite(i) || i % 2.0 == 0.0)) {
-                Assert.assertEquals(Double.POSITIVE_INFINITY, FastMath.pow(-0.0, i), EXACT);
+                assertEquals(Double.POSITIVE_INFINITY, FastMath.pow(-0.0, i), EXACT);
             }
         }
         // If the first argument is negative zero and the second argument is a negative finite odd integer, or
         // the first argument is negative infinity and the second argument is a positive finite odd integer, then the result is negative infinity.
         for (double i : DOUBLES) {
             if (i > 0.0 && i % 2.0 == 1.0) {
-                Assert.assertEquals(Double.NEGATIVE_INFINITY, FastMath.pow(Double.NEGATIVE_INFINITY, i), EXACT);
+                assertEquals(Double.NEGATIVE_INFINITY, FastMath.pow(Double.NEGATIVE_INFINITY, i), EXACT);
             }
         }
         for (double i : DOUBLES) {
             if (i < 0.0 && i % 2.0 == -1.0) {
-                Assert.assertEquals(Double.NEGATIVE_INFINITY, FastMath.pow(-0.0, i), EXACT);
+                assertEquals(Double.NEGATIVE_INFINITY, FastMath.pow(-0.0, i), EXACT);
             }
         }
         for (double d : DOUBLES) {
@@ -622,11 +556,11 @@ public class FastMathTest {
                 for (double i : DOUBLES) {
                     if (Math.abs(i) <= Double.MAX_VALUE) {
                         // if the second argument is a finite even integer, the result is equal to the result of raising the absolute value of the first argument to the power of the second argument
-                        if (i % 2.0 == 0.0) Assert.assertEquals(FastMath.pow(-d, i), FastMath.pow(d, i), EXACT);
+                        if (i % 2.0 == 0.0) assertEquals(FastMath.pow(-d, i), FastMath.pow(d, i), EXACT);
                         // if the second argument is a finite odd integer, the result is equal to the negative of the result of raising the absolute value of the first argument to the power of the second argument
-                        else if (Math.abs(i) % 2.0 == 1.0) Assert.assertEquals(-FastMath.pow(-d, i), FastMath.pow(d, i), EXACT);
+                        else if (Math.abs(i) % 2.0 == 1.0) assertEquals(-FastMath.pow(-d, i), FastMath.pow(d, i), EXACT);
                         // if the second argument is finite and not an integer, then the result is NaN.
-                        else Assert.assertEquals(Double.NaN, FastMath.pow(d, i), EXACT);
+                        else assertEquals(Double.NaN, FastMath.pow(d, i), EXACT);
                     }
                 }
             }
@@ -658,7 +592,7 @@ public class FastMathTest {
                         if (dNegative && bi.testBit( 0 )) {
                             expected = -expected;
                         }
-                        Assert.assertEquals(d + "^" + i + "=" + expected + ", Math.pow=" + Math.pow(d, i), expected, FastMath.pow(d, i), expected == 0.0 || Double.isInfinite(expected) || Double.isNaN(expected) ? EXACT : 2.0 * Math.ulp(expected));
+                        assertEquals(d + "^" + i + "=" + expected + ", Math.pow=" + Math.pow(d, i), expected, FastMath.pow(d, i), expected == 0.0 || Double.isInfinite(expected) || Double.isNaN(expected) ? EXACT : 2.0 * Math.ulp(expected));
                     }
                 }
             }
@@ -668,68 +602,45 @@ public class FastMathTest {
     @Test
     public void testPowLargeIntegralDouble() {
         double y = FastMath.scalb(1.0, 65);
-        Assert.assertEquals(Double.POSITIVE_INFINITY, FastMath.pow(FastMath.nextUp(1.0), y),    1.0);
-        Assert.assertEquals(1.0,                      FastMath.pow(1.0, y),                     1.0);
-        Assert.assertEquals(0.0,                      FastMath.pow(FastMath.nextDown(1.0), y),  1.0);
-        Assert.assertEquals(0.0,                      FastMath.pow(FastMath.nextUp(-1.0), y),   1.0);
-        Assert.assertEquals(1.0,                      FastMath.pow(-1.0, y),                    1.0);
-        Assert.assertEquals(Double.POSITIVE_INFINITY, FastMath.pow(FastMath.nextDown(-1.0), y), 1.0);
+        assertEquals(Double.POSITIVE_INFINITY, FastMath.pow(FastMath.nextUp(1.0), y),    1.0);
+        assertEquals(1.0,                      FastMath.pow(1.0, y),                     1.0);
+        assertEquals(0.0,                      FastMath.pow(FastMath.nextDown(1.0), y),  1.0);
+        assertEquals(0.0,                      FastMath.pow(FastMath.nextUp(-1.0), y),   1.0);
+        assertEquals(1.0,                      FastMath.pow(-1.0, y),                    1.0);
+        assertEquals(Double.POSITIVE_INFINITY, FastMath.pow(FastMath.nextDown(-1.0), y), 1.0);
     }
 
     @Test
     public void testAtan2SpecialCases() {
 
-        Assert.assertTrue("atan2(NaN, 0.0) should be NaN", Double.isNaN(FastMath.atan2(Double.NaN, 0.0)));
-
-        Assert.assertTrue("atan2(0.0, NaN) should be NaN", Double.isNaN(FastMath.atan2(0.0, Double.NaN)));
-
-        Assert.assertEquals("atan2(0.0, 0.0) should be 0.0", 0.0, FastMath.atan2(0.0, 0.0), Precision.EPSILON);
-
-        Assert.assertEquals("atan2(0.0, 0.001) should be 0.0", 0.0, FastMath.atan2(0.0, 0.001), Precision.EPSILON);
-
-        Assert.assertEquals("atan2(0.1, +Inf) should be 0.0", 0.0, FastMath.atan2(0.1, Double.POSITIVE_INFINITY), Precision.EPSILON);
-
-        Assert.assertEquals("atan2(-0.0, 0.0) should be -0.0", -0.0, FastMath.atan2(-0.0, 0.0), Precision.EPSILON);
-
-        Assert.assertEquals("atan2(-0.0, 0.001) should be -0.0", -0.0, FastMath.atan2(-0.0, 0.001), Precision.EPSILON);
-
-        Assert.assertEquals("atan2(-0.0, +Inf) should be -0.0", -0.0, FastMath.atan2(-0.1, Double.POSITIVE_INFINITY), Precision.EPSILON);
-
-        Assert.assertEquals("atan2(0.0, -0.0) should be PI", FastMath.PI, FastMath.atan2(0.0, -0.0), Precision.EPSILON);
-
-        Assert.assertEquals("atan2(0.1, -Inf) should be PI", FastMath.PI, FastMath.atan2(0.1, Double.NEGATIVE_INFINITY), Precision.EPSILON);
-
-        Assert.assertEquals("atan2(-0.0, -0.0) should be -PI", -FastMath.PI, FastMath.atan2(-0.0, -0.0), Precision.EPSILON);
-
-        Assert.assertEquals("atan2(0.1, -Inf) should be -PI", -FastMath.PI, FastMath.atan2(-0.1, Double.NEGATIVE_INFINITY), Precision.EPSILON);
-
-        Assert.assertEquals("atan2(0.1, 0.0) should be PI/2", FastMath.PI / 2.0, FastMath.atan2(0.1, 0.0), Precision.EPSILON);
-
-        Assert.assertEquals("atan2(0.1, -0.0) should be PI/2", FastMath.PI / 2.0, FastMath.atan2(0.1, -0.0), Precision.EPSILON);
-
-        Assert.assertEquals("atan2(Inf, 0.1) should be PI/2", FastMath.PI / 2.0, FastMath.atan2(Double.POSITIVE_INFINITY, 0.1), Precision.EPSILON);
-
-        Assert.assertEquals("atan2(Inf, -0.1) should be PI/2", FastMath.PI / 2.0, FastMath.atan2(Double.POSITIVE_INFINITY, -0.1), Precision.EPSILON);
-
-        Assert.assertEquals("atan2(-0.1, 0.0) should be -PI/2", -FastMath.PI / 2.0, FastMath.atan2(-0.1, 0.0), Precision.EPSILON);
-
-        Assert.assertEquals("atan2(-0.1, -0.0) should be -PI/2", -FastMath.PI / 2.0, FastMath.atan2(-0.1, -0.0), Precision.EPSILON);
-
-        Assert.assertEquals("atan2(-Inf, 0.1) should be -PI/2", -FastMath.PI / 2.0, FastMath.atan2(Double.NEGATIVE_INFINITY, 0.1), Precision.EPSILON);
-
-        Assert.assertEquals("atan2(-Inf, -0.1) should be -PI/2", -FastMath.PI / 2.0, FastMath.atan2(Double.NEGATIVE_INFINITY, -0.1), Precision.EPSILON);
-
-        Assert.assertEquals("atan2(Inf, Inf) should be PI/4", FastMath.PI / 4.0, FastMath.atan2(Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY),
-                Precision.EPSILON);
-
-        Assert.assertEquals("atan2(Inf, -Inf) should be PI * 3/4", FastMath.PI * 3.0 / 4.0,
-                FastMath.atan2(Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY), Precision.EPSILON);
-
-        Assert.assertEquals("atan2(-Inf, Inf) should be -PI/4", -FastMath.PI / 4.0, FastMath.atan2(Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY),
-                Precision.EPSILON);
-
-        Assert.assertEquals("atan2(-Inf, -Inf) should be -PI * 3/4", - FastMath.PI * 3.0 / 4.0,
-                FastMath.atan2(Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY), Precision.EPSILON);
+        assertTrue("atan2(NaN, 0.0) should be NaN", Double.isNaN(FastMath.atan2(Double.NaN, 0.0)));
+        assertTrue("atan2(0.0, NaN) should be NaN", Double.isNaN(FastMath.atan2(0.0, Double.NaN)));
+        assertEquals("atan2(0.0, 0.0) should be 0.0", 0.0, FastMath.atan2(0.0, 0.0), Precision.EPSILON);
+        assertEquals("atan2(0.0, 0.001) should be 0.0", 0.0, FastMath.atan2(0.0, 0.001), Precision.EPSILON);
+        assertEquals("atan2(0.1, +Inf) should be 0.0", 0.0, FastMath.atan2(0.1, Double.POSITIVE_INFINITY), Precision.EPSILON);
+        assertEquals("atan2(-0.0, 0.0) should be -0.0", -0.0, FastMath.atan2(-0.0, 0.0), Precision.EPSILON);
+        assertEquals("atan2(-0.0, 0.001) should be -0.0", -0.0, FastMath.atan2(-0.0, 0.001), Precision.EPSILON);
+        assertEquals("atan2(-0.0, +Inf) should be -0.0", -0.0, FastMath.atan2(-0.1, Double.POSITIVE_INFINITY), Precision.EPSILON);
+        assertEquals("atan2(0.0, -0.0) should be PI", FastMath.PI, FastMath.atan2(0.0, -0.0), Precision.EPSILON);
+        assertEquals("atan2(0.1, -Inf) should be PI", FastMath.PI, FastMath.atan2(0.1, Double.NEGATIVE_INFINITY), Precision.EPSILON);
+        assertEquals("atan2(-0.0, -0.0) should be -PI", -FastMath.PI, FastMath.atan2(-0.0, -0.0), Precision.EPSILON);
+        assertEquals("atan2(0.1, -Inf) should be -PI", -FastMath.PI, FastMath.atan2(-0.1, Double.NEGATIVE_INFINITY), Precision.EPSILON);
+        assertEquals("atan2(0.1, 0.0) should be PI/2", FastMath.PI / 2.0, FastMath.atan2(0.1, 0.0), Precision.EPSILON);
+        assertEquals("atan2(0.1, -0.0) should be PI/2", FastMath.PI / 2.0, FastMath.atan2(0.1, -0.0), Precision.EPSILON);
+        assertEquals("atan2(Inf, 0.1) should be PI/2", FastMath.PI / 2.0, FastMath.atan2(Double.POSITIVE_INFINITY, 0.1), Precision.EPSILON);
+        assertEquals("atan2(Inf, -0.1) should be PI/2", FastMath.PI / 2.0, FastMath.atan2(Double.POSITIVE_INFINITY, -0.1), Precision.EPSILON);
+        assertEquals("atan2(-0.1, 0.0) should be -PI/2", -FastMath.PI / 2.0, FastMath.atan2(-0.1, 0.0), Precision.EPSILON);
+        assertEquals("atan2(-0.1, -0.0) should be -PI/2", -FastMath.PI / 2.0, FastMath.atan2(-0.1, -0.0), Precision.EPSILON);
+        assertEquals("atan2(-Inf, 0.1) should be -PI/2", -FastMath.PI / 2.0, FastMath.atan2(Double.NEGATIVE_INFINITY, 0.1), Precision.EPSILON);
+        assertEquals("atan2(-Inf, -0.1) should be -PI/2", -FastMath.PI / 2.0, FastMath.atan2(Double.NEGATIVE_INFINITY, -0.1), Precision.EPSILON);
+        assertEquals("atan2(Inf, Inf) should be PI/4", FastMath.PI / 4.0, FastMath.atan2(Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY),
+                     Precision.EPSILON);
+        assertEquals("atan2(Inf, -Inf) should be PI * 3/4", FastMath.PI * 3.0 / 4.0,
+                     FastMath.atan2(Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY), Precision.EPSILON);
+        assertEquals("atan2(-Inf, Inf) should be -PI/4", -FastMath.PI / 4.0, FastMath.atan2(Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY),
+                     Precision.EPSILON);
+        assertEquals("atan2(-Inf, -Inf) should be -PI * 3/4", - FastMath.PI * 3.0 / 4.0,
+                     FastMath.atan2(Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY), Precision.EPSILON);
     }
 
     @Test
@@ -753,8 +664,7 @@ public class FastMathTest {
 
             if (err != 0) {
                 double ulp = Math.abs(ref -
-                                      Double.longBitsToDouble((Double
-                                          .doubleToLongBits(ref) ^ 1)));
+                                      Double.longBitsToDouble((Double.doubleToLongBits(ref) ^ 1)));
                 double errulp = field.newDfp(tst).subtract(DfpMath.pow(field.newDfp(x), field.newDfp(y))).divide(field.newDfp(ulp)).toDouble();
 //                System.out.println(x + "\t" + y + "\t" + tst + "\t" + ref + "\t" + err + "\t" + errulp);
 
@@ -762,7 +672,7 @@ public class FastMathTest {
             }
         }
 
-        Assert.assertTrue("pow() had errors in excess of " + MAX_ERROR_ULP + " ULP", maxerrulp < MAX_ERROR_ULP);
+        assertTrue("pow() had errors in excess of " + MAX_ERROR_ULP + " ULP", maxerrulp < MAX_ERROR_ULP);
     }
 
     @Test
@@ -789,7 +699,7 @@ public class FastMathTest {
             }
         }
 
-        Assert.assertTrue("exp() had errors in excess of " + MAX_ERROR_ULP + " ULP", maxerrulp < MAX_ERROR_ULP);
+        assertTrue("exp() had errors in excess of " + MAX_ERROR_ULP + " ULP", maxerrulp < MAX_ERROR_ULP);
     }
 
     @Test
@@ -818,7 +728,7 @@ public class FastMathTest {
             }
         }
 
-        Assert.assertTrue("sin() had errors in excess of " + MAX_ERROR_ULP + " ULP", maxerrulp < MAX_ERROR_ULP);
+        assertTrue("sin() had errors in excess of " + MAX_ERROR_ULP + " ULP", maxerrulp < MAX_ERROR_ULP);
     }
 
     @Test
@@ -847,7 +757,7 @@ public class FastMathTest {
             }
         }
 
-        Assert.assertTrue("cos() had errors in excess of " + MAX_ERROR_ULP + " ULP", maxerrulp < MAX_ERROR_ULP);
+        assertTrue("cos() had errors in excess of " + MAX_ERROR_ULP + " ULP", maxerrulp < MAX_ERROR_ULP);
     }
 
     @Test
@@ -876,7 +786,7 @@ public class FastMathTest {
             }
         }
 
-        Assert.assertTrue("tan() had errors in excess of " + MAX_ERROR_ULP + " ULP", maxerrulp < MAX_ERROR_ULP);
+        assertTrue("tan() had errors in excess of " + MAX_ERROR_ULP + " ULP", maxerrulp < MAX_ERROR_ULP);
     }
 
     @Test
@@ -907,7 +817,7 @@ public class FastMathTest {
             }
         }
 
-        Assert.assertTrue("atan() had errors in excess of " + MAX_ERROR_ULP + " ULP", maxerrulp < MAX_ERROR_ULP);
+        assertTrue("atan() had errors in excess of " + MAX_ERROR_ULP + " ULP", maxerrulp < MAX_ERROR_ULP);
     }
 
     @Test
@@ -923,8 +833,7 @@ public class FastMathTest {
             // double x = ((generator.nextDouble() * 2.0) - 1.0) * generator.nextDouble();
             /* double x = 3.0 / 512.0 * i - 3.0; */
             double tst = FastMath.atan2(y, x);
-            Dfp refdfp = DfpMath.atan(field.newDfp(y)
-                .divide(field.newDfp(x)));
+            Dfp refdfp = DfpMath.atan(field.newDfp(y).divide(field.newDfp(x)));
             /* Make adjustments for sign */
             if (x < 0.0) {
                 if (y > 0.0)
@@ -938,8 +847,7 @@ public class FastMathTest {
 
             if (err != 0) {
                 double ulp = Math.abs(ref -
-                                      Double.longBitsToDouble((Double
-                                          .doubleToLongBits(ref) ^ 1)));
+                                      Double.longBitsToDouble((Double.doubleToLongBits(ref) ^ 1)));
                 double errulp = field.newDfp(tst).subtract(refdfp).divide(field.newDfp(ulp)).toDouble();
 //                System.out.println(x + "\t" + y + "\t" + tst + "\t" + ref + "\t" + errulp);
 
@@ -947,7 +855,7 @@ public class FastMathTest {
             }
         }
 
-        Assert.assertTrue("atan2() had errors in excess of " + MAX_ERROR_ULP + " ULP", maxerrulp < MAX_ERROR_ULP);
+        assertTrue("atan2() had errors in excess of " + MAX_ERROR_ULP + " ULP", maxerrulp < MAX_ERROR_ULP);
     }
 
     @Test
@@ -965,8 +873,7 @@ public class FastMathTest {
 
             if (err != 0) {
                 double ulp = Math.abs(ref -
-                                      Double.longBitsToDouble((Double
-                                          .doubleToLongBits(ref) ^ 1)));
+                                      Double.longBitsToDouble((Double.doubleToLongBits(ref) ^ 1)));
                 double errulp = field.newDfp(tst).subtract(DfpMath.exp(field.newDfp(x)).subtract(field.getOne())).divide(field.newDfp(ulp)).toDouble();
 //                System.out.println(x + "\t" + tst + "\t" + ref + "\t" + err + "\t" + errulp);
 
@@ -974,7 +881,7 @@ public class FastMathTest {
             }
         }
 
-        Assert.assertTrue("expm1() had errors in excess of " + MAX_ERROR_ULP + " ULP", maxerrulp < MAX_ERROR_ULP);
+        assertTrue("expm1() had errors in excess of " + MAX_ERROR_ULP + " ULP", maxerrulp < MAX_ERROR_ULP);
     }
 
     @Test
@@ -997,7 +904,7 @@ public class FastMathTest {
             }
         }
 
-        Assert.assertTrue("asin() had errors in excess of " + MAX_ERROR_ULP + " ULP", maxerrulp < MAX_ERROR_ULP);
+        assertTrue("asin() had errors in excess of " + MAX_ERROR_ULP + " ULP", maxerrulp < MAX_ERROR_ULP);
     }
 
     @Test
@@ -1020,7 +927,7 @@ public class FastMathTest {
             }
         }
 
-        Assert.assertTrue("acos() had errors in excess of " + MAX_ERROR_ULP + " ULP", maxerrulp < MAX_ERROR_ULP);
+        assertTrue("acos() had errors in excess of " + MAX_ERROR_ULP + " ULP", maxerrulp < MAX_ERROR_ULP);
     }
 
     /**
@@ -1029,17 +936,12 @@ public class FastMathTest {
     @Test
     public void testAcosSpecialCases() {
 
-        Assert.assertTrue("acos(NaN) should be NaN", Double.isNaN(FastMath.acos(Double.NaN)));
-
-        Assert.assertTrue("acos(-1.1) should be NaN", Double.isNaN(FastMath.acos(-1.1)));
-
-        Assert.assertTrue("acos(-1.1) should be NaN", Double.isNaN(FastMath.acos(1.1)));
-
-        Assert.assertEquals("acos(-1.0) should be PI", FastMath.acos(-1.0), FastMath.PI, Precision.EPSILON);
-
-        Assert.assertEquals("acos(1.0) should be 0.0", FastMath.acos(1.0), 0.0, Precision.EPSILON);
-
-        Assert.assertEquals("acos(0.0) should be PI/2", FastMath.acos(0.0), FastMath.PI / 2.0, Precision.EPSILON);
+        assertTrue("acos(NaN) should be NaN", Double.isNaN(FastMath.acos(Double.NaN)));
+        assertTrue("acos(-1.1) should be NaN", Double.isNaN(FastMath.acos(-1.1)));
+        assertTrue("acos(-1.1) should be NaN", Double.isNaN(FastMath.acos(1.1)));
+        assertEquals("acos(-1.0) should be PI", FastMath.acos(-1.0), FastMath.PI, Precision.EPSILON);
+        assertEquals("acos(1.0) should be 0.0", FastMath.acos(1.0), 0.0, Precision.EPSILON);
+        assertEquals("acos(0.0) should be PI/2", FastMath.acos(0.0), FastMath.PI / 2.0, Precision.EPSILON);
     }
 
     /**
@@ -1048,17 +950,12 @@ public class FastMathTest {
     @Test
     public void testAsinSpecialCases() {
 
-        Assert.assertTrue("asin(NaN) should be NaN", Double.isNaN(FastMath.asin(Double.NaN)));
-
-        Assert.assertTrue("asin(1.1) should be NaN", Double.isNaN(FastMath.asin(1.1)));
-
-        Assert.assertTrue("asin(-1.1) should be NaN", Double.isNaN(FastMath.asin(-1.1)));
-
-        Assert.assertEquals("asin(1.0) should be PI/2", FastMath.asin(1.0), FastMath.PI / 2.0, Precision.EPSILON);
-
-        Assert.assertEquals("asin(-1.0) should be -PI/2", FastMath.asin(-1.0), -FastMath.PI / 2.0, Precision.EPSILON);
-
-        Assert.assertEquals("asin(0.0) should be 0.0", FastMath.asin(0.0), 0.0, Precision.EPSILON);
+        assertTrue("asin(NaN) should be NaN", Double.isNaN(FastMath.asin(Double.NaN)));
+        assertTrue("asin(1.1) should be NaN", Double.isNaN(FastMath.asin(1.1)));
+        assertTrue("asin(-1.1) should be NaN", Double.isNaN(FastMath.asin(-1.1)));
+        assertEquals("asin(1.0) should be PI/2", FastMath.asin(1.0), FastMath.PI / 2.0, Precision.EPSILON);
+        assertEquals("asin(-1.0) should be -PI/2", FastMath.asin(-1.0), -FastMath.PI / 2.0, Precision.EPSILON);
+        assertEquals("asin(0.0) should be 0.0", FastMath.asin(0.0), 0.0, Precision.EPSILON);
     }
 
     private Dfp cosh(Dfp x) {
@@ -1092,7 +989,7 @@ public class FastMathTest {
             }
         }
 
-        Assert.assertTrue("sinh() had errors in excess of " + MAX_ERROR_ULP + " ULP", maxerrulp < MAX_ERROR_ULP);
+        assertTrue("sinh() had errors in excess of " + MAX_ERROR_ULP + " ULP", maxerrulp < MAX_ERROR_ULP);
     }
 
     @Test
@@ -1114,7 +1011,7 @@ public class FastMathTest {
             }
         }
 
-        Assert.assertTrue("cosh() had errors in excess of " + MAX_ERROR_ULP + " ULP", maxerrulp < MAX_ERROR_ULP);
+        assertTrue("cosh() had errors in excess of " + MAX_ERROR_ULP + " ULP", maxerrulp < MAX_ERROR_ULP);
     }
 
     @Test
@@ -1136,7 +1033,7 @@ public class FastMathTest {
             }
         }
 
-        Assert.assertTrue("tanh() had errors in excess of " + MAX_ERROR_ULP + " ULP", maxerrulp < MAX_ERROR_ULP);
+        assertTrue("tanh() had errors in excess of " + MAX_ERROR_ULP + " ULP", maxerrulp < MAX_ERROR_ULP);
     }
 
     @Test
@@ -1158,24 +1055,24 @@ public class FastMathTest {
             }
         }
 
-        Assert.assertTrue("cbrt() had errors in excess of " + MAX_ERROR_ULP + " ULP", maxerrulp < MAX_ERROR_ULP);
+        assertTrue("cbrt() had errors in excess of " + MAX_ERROR_ULP + " ULP", maxerrulp < MAX_ERROR_ULP);
     }
 
     private Dfp cbrt(Dfp x) {
-      boolean negative=false;
+        boolean negative=false;
 
-      if (x.lessThan(field.getZero())) {
-          negative = true;
-          x = x.negate();
-      }
+        if (x.lessThan(field.getZero())) {
+            negative = true;
+            x = x.negate();
+        }
 
-      Dfp y = DfpMath.pow(x, field.getOne().divide(3));
+        Dfp y = DfpMath.pow(x, field.getOne().divide(3));
 
-      if (negative) {
-          y = y.negate();
-      }
+        if (negative) {
+            y = y.negate();
+        }
 
-      return y;
+        return y;
     }
 
     @Test
@@ -1196,8 +1093,7 @@ public class FastMathTest {
                 maxerrulp = Math.max(maxerrulp, Math.abs(errulp));
             }
         }
-        Assert.assertTrue("toDegrees() had errors in excess of " + MAX_ERROR_ULP + " ULP", maxerrulp < MAX_ERROR_ULP);
-
+        assertTrue("toDegrees() had errors in excess of " + MAX_ERROR_ULP + " ULP", maxerrulp < MAX_ERROR_ULP);
     }
 
     @Test
@@ -1211,148 +1107,147 @@ public class FastMathTest {
 
             if (err != 0) {
                 double ulp = Math.abs(ref -
-                                      Double.longBitsToDouble((Double
-                                          .doubleToLongBits(ref) ^ 1)));
+                                      Double.longBitsToDouble((Double.doubleToLongBits(ref) ^ 1)));
                 double errulp = field.newDfp(tst).subtract(DfpMath.exp(field.newDfp(x)).subtract(field.getOne())).divide(field.newDfp(ulp)).toDouble();
 //                System.out.println(x + "\t" + tst + "\t" + ref + "\t" + err + "\t" + errulp);
 
                 maxerrulp = Math.max(maxerrulp, Math.abs(errulp));
             }
         }
-        Assert.assertTrue("toRadians() had errors in excess of " + MAX_ERROR_ULP + " ULP", maxerrulp < MAX_ERROR_ULP);
 
+        assertTrue("toRadians() had errors in excess of " + MAX_ERROR_ULP + " ULP", maxerrulp < MAX_ERROR_ULP);
     }
 
     @Test
     public void testNextAfter() {
         // 0x402fffffffffffff 0x404123456789abcd -> 4030000000000000
-        Assert.assertEquals(16.0, FastMath.nextUp(15.999999999999998), 0.0);
+        assertEquals(16.0, FastMath.nextUp(15.999999999999998), 0.0);
 
         // 0xc02fffffffffffff 0x404123456789abcd -> c02ffffffffffffe
-        Assert.assertEquals(-15.999999999999996, FastMath.nextAfter(-15.999999999999998, 34.27555555555555), 0.0);
+        assertEquals(-15.999999999999996, FastMath.nextAfter(-15.999999999999998, 34.27555555555555), 0.0);
 
         // 0x402fffffffffffff 0x400123456789abcd -> 402ffffffffffffe
-        Assert.assertEquals(15.999999999999996, FastMath.nextDown(15.999999999999998), 0.0);
+        assertEquals(15.999999999999996, FastMath.nextDown(15.999999999999998), 0.0);
 
         // 0xc02fffffffffffff 0x400123456789abcd -> c02ffffffffffffe
-        Assert.assertEquals(-15.999999999999996, FastMath.nextAfter(-15.999999999999998, 2.142222222222222), 0.0);
+        assertEquals(-15.999999999999996, FastMath.nextAfter(-15.999999999999998, 2.142222222222222), 0.0);
 
         // 0x4020000000000000 0x404123456789abcd -> 4020000000000001
-        Assert.assertEquals(8.000000000000002, FastMath.nextAfter(8.0, 34.27555555555555), 0.0);
+        assertEquals(8.000000000000002, FastMath.nextAfter(8.0, 34.27555555555555), 0.0);
 
         // 0xc020000000000000 0x404123456789abcd -> c01fffffffffffff
-        Assert.assertEquals(-7.999999999999999, FastMath.nextAfter(-8.0, 34.27555555555555), 0.0);
+        assertEquals(-7.999999999999999, FastMath.nextAfter(-8.0, 34.27555555555555), 0.0);
 
         // 0x4020000000000000 0x400123456789abcd -> 401fffffffffffff
-        Assert.assertEquals(7.999999999999999, FastMath.nextAfter(8.0, 2.142222222222222), 0.0);
+        assertEquals(7.999999999999999, FastMath.nextAfter(8.0, 2.142222222222222), 0.0);
 
         // 0xc020000000000000 0x400123456789abcd -> c01fffffffffffff
-        Assert.assertEquals(-7.999999999999999, FastMath.nextAfter(-8.0, 2.142222222222222), 0.0);
+        assertEquals(-7.999999999999999, FastMath.nextAfter(-8.0, 2.142222222222222), 0.0);
 
         // 0x3f2e43753d36a223 0x3f2e43753d36a224 -> 3f2e43753d36a224
-        Assert.assertEquals(2.308922399667661E-4, FastMath.nextAfter(2.3089223996676606E-4, 2.308922399667661E-4), 0.0);
+        assertEquals(2.308922399667661E-4, FastMath.nextAfter(2.3089223996676606E-4, 2.308922399667661E-4), 0.0);
 
         // 0x3f2e43753d36a223 0x3f2e43753d36a223 -> 3f2e43753d36a223
-        Assert.assertEquals(2.3089223996676606E-4, FastMath.nextAfter(2.3089223996676606E-4, 2.3089223996676606E-4), 0.0);
+        assertEquals(2.3089223996676606E-4, FastMath.nextAfter(2.3089223996676606E-4, 2.3089223996676606E-4), 0.0);
 
         // 0x3f2e43753d36a223 0x3f2e43753d36a222 -> 3f2e43753d36a222
-        Assert.assertEquals(2.3089223996676603E-4, FastMath.nextAfter(2.3089223996676606E-4, 2.3089223996676603E-4), 0.0);
+        assertEquals(2.3089223996676603E-4, FastMath.nextAfter(2.3089223996676606E-4, 2.3089223996676603E-4), 0.0);
 
         // 0x3f2e43753d36a223 0xbf2e43753d36a224 -> 3f2e43753d36a222
-        Assert.assertEquals(2.3089223996676603E-4, FastMath.nextAfter(2.3089223996676606E-4, -2.308922399667661E-4), 0.0);
+        assertEquals(2.3089223996676603E-4, FastMath.nextAfter(2.3089223996676606E-4, -2.308922399667661E-4), 0.0);
 
         // 0x3f2e43753d36a223 0xbf2e43753d36a223 -> 3f2e43753d36a222
-        Assert.assertEquals(2.3089223996676603E-4, FastMath.nextAfter(2.3089223996676606E-4, -2.3089223996676606E-4), 0.0);
+        assertEquals(2.3089223996676603E-4, FastMath.nextAfter(2.3089223996676606E-4, -2.3089223996676606E-4), 0.0);
 
         // 0x3f2e43753d36a223 0xbf2e43753d36a222 -> 3f2e43753d36a222
-        Assert.assertEquals(2.3089223996676603E-4, FastMath.nextAfter(2.3089223996676606E-4, -2.3089223996676603E-4), 0.0);
+        assertEquals(2.3089223996676603E-4, FastMath.nextAfter(2.3089223996676606E-4, -2.3089223996676603E-4), 0.0);
 
         // 0xbf2e43753d36a223 0x3f2e43753d36a224 -> bf2e43753d36a222
-        Assert.assertEquals(-2.3089223996676603E-4, FastMath.nextAfter(-2.3089223996676606E-4, 2.308922399667661E-4), 0.0);
+        assertEquals(-2.3089223996676603E-4, FastMath.nextAfter(-2.3089223996676606E-4, 2.308922399667661E-4), 0.0);
 
         // 0xbf2e43753d36a223 0x3f2e43753d36a223 -> bf2e43753d36a222
-        Assert.assertEquals(-2.3089223996676603E-4, FastMath.nextAfter(-2.3089223996676606E-4, 2.3089223996676606E-4), 0.0);
+        assertEquals(-2.3089223996676603E-4, FastMath.nextAfter(-2.3089223996676606E-4, 2.3089223996676606E-4), 0.0);
 
         // 0xbf2e43753d36a223 0x3f2e43753d36a222 -> bf2e43753d36a222
-        Assert.assertEquals(-2.3089223996676603E-4, FastMath.nextAfter(-2.3089223996676606E-4, 2.3089223996676603E-4), 0.0);
+        assertEquals(-2.3089223996676603E-4, FastMath.nextAfter(-2.3089223996676606E-4, 2.3089223996676603E-4), 0.0);
 
         // 0xbf2e43753d36a223 0xbf2e43753d36a224 -> bf2e43753d36a224
-        Assert.assertEquals(-2.308922399667661E-4, FastMath.nextAfter(-2.3089223996676606E-4, -2.308922399667661E-4), 0.0);
+        assertEquals(-2.308922399667661E-4, FastMath.nextAfter(-2.3089223996676606E-4, -2.308922399667661E-4), 0.0);
 
         // 0xbf2e43753d36a223 0xbf2e43753d36a223 -> bf2e43753d36a223
-        Assert.assertEquals(-2.3089223996676606E-4, FastMath.nextAfter(-2.3089223996676606E-4, -2.3089223996676606E-4), 0.0);
+        assertEquals(-2.3089223996676606E-4, FastMath.nextAfter(-2.3089223996676606E-4, -2.3089223996676606E-4), 0.0);
 
         // 0xbf2e43753d36a223 0xbf2e43753d36a222 -> bf2e43753d36a222
-        Assert.assertEquals(-2.3089223996676603E-4, FastMath.nextAfter(-2.3089223996676606E-4, -2.3089223996676603E-4), 0.0);
+        assertEquals(-2.3089223996676603E-4, FastMath.nextAfter(-2.3089223996676606E-4, -2.3089223996676603E-4), 0.0);
 
     }
 
     @Test
     public void testDoubleNextAfterSpecialCases() {
-        Assert.assertEquals(-Double.MAX_VALUE,FastMath.nextAfter(Double.NEGATIVE_INFINITY, 0D), 0D);
-        Assert.assertEquals(Double.MAX_VALUE,FastMath.nextAfter(Double.POSITIVE_INFINITY, 0D), 0D);
-        Assert.assertEquals(Double.NaN,FastMath.nextAfter(Double.NaN, 0D), 0D);
-        Assert.assertEquals(Double.POSITIVE_INFINITY,FastMath.nextAfter(Double.MAX_VALUE, Double.POSITIVE_INFINITY), 0D);
-        Assert.assertEquals(Double.NEGATIVE_INFINITY,FastMath.nextAfter(-Double.MAX_VALUE, Double.NEGATIVE_INFINITY), 0D);
-        Assert.assertEquals(Double.MIN_VALUE, FastMath.nextAfter(0D, 1D), 0D);
-        Assert.assertEquals(-Double.MIN_VALUE, FastMath.nextAfter(0D, -1D), 0D);
-        Assert.assertEquals(0D, FastMath.nextAfter(Double.MIN_VALUE, -1), 0D);
-        Assert.assertEquals(0D, FastMath.nextAfter(-Double.MIN_VALUE, 1), 0D);
+        assertEquals(-Double.MAX_VALUE,FastMath.nextAfter(Double.NEGATIVE_INFINITY, 0D), 0D);
+        assertEquals(Double.MAX_VALUE,FastMath.nextAfter(Double.POSITIVE_INFINITY, 0D), 0D);
+        assertEquals(Double.NaN,FastMath.nextAfter(Double.NaN, 0D), 0D);
+        assertEquals(Double.POSITIVE_INFINITY,FastMath.nextAfter(Double.MAX_VALUE, Double.POSITIVE_INFINITY), 0D);
+        assertEquals(Double.NEGATIVE_INFINITY,FastMath.nextAfter(-Double.MAX_VALUE, Double.NEGATIVE_INFINITY), 0D);
+        assertEquals(Double.MIN_VALUE, FastMath.nextAfter(0D, 1D), 0D);
+        assertEquals(-Double.MIN_VALUE, FastMath.nextAfter(0D, -1D), 0D);
+        assertEquals(0D, FastMath.nextAfter(Double.MIN_VALUE, -1), 0D);
+        assertEquals(0D, FastMath.nextAfter(-Double.MIN_VALUE, 1), 0D);
     }
 
     @Test
     public void testFloatNextAfterSpecialCases() {
-        Assert.assertEquals(-Float.MAX_VALUE,FastMath.nextAfter(Float.NEGATIVE_INFINITY, 0F), 0F);
-        Assert.assertEquals(Float.MAX_VALUE,FastMath.nextAfter(Float.POSITIVE_INFINITY, 0F), 0F);
-        Assert.assertEquals(Float.NaN,FastMath.nextAfter(Float.NaN, 0F), 0F);
-        Assert.assertEquals(Float.POSITIVE_INFINITY,FastMath.nextUp(Float.MAX_VALUE), 0F);
-        Assert.assertEquals(Float.NEGATIVE_INFINITY,FastMath.nextDown(-Float.MAX_VALUE), 0F);
-        Assert.assertEquals(Float.MIN_VALUE, FastMath.nextAfter(0F, 1F), 0F);
-        Assert.assertEquals(-Float.MIN_VALUE, FastMath.nextAfter(0F, -1F), 0F);
-        Assert.assertEquals(0F, FastMath.nextAfter(Float.MIN_VALUE, -1F), 0F);
-        Assert.assertEquals(0F, FastMath.nextAfter(-Float.MIN_VALUE, 1F), 0F);
+        assertEquals(-Float.MAX_VALUE, FastMath.nextAfter(Float.NEGATIVE_INFINITY, 0F), 0F);
+        assertEquals(Float.MAX_VALUE, FastMath.nextAfter(Float.POSITIVE_INFINITY, 0F), 0F);
+        assertEquals(Float.NaN, FastMath.nextAfter(Float.NaN, 0F), 0F);
+        assertEquals(Float.POSITIVE_INFINITY, FastMath.nextUp(Float.MAX_VALUE), 0F);
+        assertEquals(Float.NEGATIVE_INFINITY, FastMath.nextDown(-Float.MAX_VALUE), 0F);
+        assertEquals(Float.MIN_VALUE, FastMath.nextAfter(0F, 1F), 0F);
+        assertEquals(-Float.MIN_VALUE, FastMath.nextAfter(0F, -1F), 0F);
+        assertEquals(0F, FastMath.nextAfter(Float.MIN_VALUE, -1F), 0F);
+        assertEquals(0F, FastMath.nextAfter(-Float.MIN_VALUE, 1F), 0F);
     }
 
     @Test
     public void testDoubleScalbSpecialCases() {
-        Assert.assertEquals(2.5269841324701218E-175,  FastMath.scalb(2.2250738585072014E-308, 442), 0D);
-        Assert.assertEquals(1.307993905256674E297,    FastMath.scalb(1.1102230246251565E-16, 1040), 0D);
-        Assert.assertEquals(7.2520887996488946E-217,  FastMath.scalb(Double.MIN_VALUE,        356), 0D);
-        Assert.assertEquals(8.98846567431158E307,     FastMath.scalb(Double.MIN_VALUE,       2097), 0D);
-        Assert.assertEquals(Double.POSITIVE_INFINITY, FastMath.scalb(Double.MIN_VALUE,       2098), 0D);
-        Assert.assertEquals(1.1125369292536007E-308,  FastMath.scalb(2.225073858507201E-308,   -1), 0D);
-        Assert.assertEquals(1.0E-323,                 FastMath.scalb(Double.MAX_VALUE,      -2097), 0D);
-        Assert.assertEquals(Double.MIN_VALUE,         FastMath.scalb(Double.MAX_VALUE,      -2098), 0D);
-        Assert.assertEquals(0,                        FastMath.scalb(Double.MAX_VALUE,      -2099), 0D);
-        Assert.assertEquals(Double.POSITIVE_INFINITY, FastMath.scalb(Double.POSITIVE_INFINITY, -1000000), 0D);
-        Assert.assertEquals(Double.NEGATIVE_INFINITY, FastMath.scalb(-1.1102230246251565E-16, 1078), 0D);
-        Assert.assertEquals(Double.NEGATIVE_INFINITY, FastMath.scalb(-1.1102230246251565E-16,  1079), 0D);
-        Assert.assertEquals(Double.NEGATIVE_INFINITY, FastMath.scalb(-2.2250738585072014E-308, 2047), 0D);
-        Assert.assertEquals(Double.NEGATIVE_INFINITY, FastMath.scalb(-2.2250738585072014E-308, 2048), 0D);
-        Assert.assertEquals(Double.NEGATIVE_INFINITY, FastMath.scalb(-1.7976931348623157E308,  2147483647), 0D);
-        Assert.assertEquals(Double.POSITIVE_INFINITY, FastMath.scalb( 1.7976931348623157E308,  2147483647), 0D);
-        Assert.assertEquals(Double.NEGATIVE_INFINITY, FastMath.scalb(-1.1102230246251565E-16,  2147483647), 0D);
-        Assert.assertEquals(Double.POSITIVE_INFINITY, FastMath.scalb( 1.1102230246251565E-16,  2147483647), 0D);
-        Assert.assertEquals(Double.NEGATIVE_INFINITY, FastMath.scalb(-2.2250738585072014E-308, 2147483647), 0D);
-        Assert.assertEquals(Double.POSITIVE_INFINITY, FastMath.scalb( 2.2250738585072014E-308, 2147483647), 0D);
+        assertEquals(2.5269841324701218E-175,  FastMath.scalb(2.2250738585072014E-308, 442), 0D);
+        assertEquals(1.307993905256674E297,    FastMath.scalb(1.1102230246251565E-16, 1040), 0D);
+        assertEquals(7.2520887996488946E-217,  FastMath.scalb(Double.MIN_VALUE,        356), 0D);
+        assertEquals(8.98846567431158E307,     FastMath.scalb(Double.MIN_VALUE,       2097), 0D);
+        assertEquals(Double.POSITIVE_INFINITY, FastMath.scalb(Double.MIN_VALUE,       2098), 0D);
+        assertEquals(1.1125369292536007E-308,  FastMath.scalb(2.225073858507201E-308,   -1), 0D);
+        assertEquals(1.0E-323,                 FastMath.scalb(Double.MAX_VALUE,      -2097), 0D);
+        assertEquals(Double.MIN_VALUE,         FastMath.scalb(Double.MAX_VALUE,      -2098), 0D);
+        assertEquals(0,                        FastMath.scalb(Double.MAX_VALUE,      -2099), 0D);
+        assertEquals(Double.POSITIVE_INFINITY, FastMath.scalb(Double.POSITIVE_INFINITY, -1000000), 0D);
+        assertEquals(Double.NEGATIVE_INFINITY, FastMath.scalb(-1.1102230246251565E-16, 1078), 0D);
+        assertEquals(Double.NEGATIVE_INFINITY, FastMath.scalb(-1.1102230246251565E-16,  1079), 0D);
+        assertEquals(Double.NEGATIVE_INFINITY, FastMath.scalb(-2.2250738585072014E-308, 2047), 0D);
+        assertEquals(Double.NEGATIVE_INFINITY, FastMath.scalb(-2.2250738585072014E-308, 2048), 0D);
+        assertEquals(Double.NEGATIVE_INFINITY, FastMath.scalb(-1.7976931348623157E308,  2147483647), 0D);
+        assertEquals(Double.POSITIVE_INFINITY, FastMath.scalb( 1.7976931348623157E308,  2147483647), 0D);
+        assertEquals(Double.NEGATIVE_INFINITY, FastMath.scalb(-1.1102230246251565E-16,  2147483647), 0D);
+        assertEquals(Double.POSITIVE_INFINITY, FastMath.scalb( 1.1102230246251565E-16,  2147483647), 0D);
+        assertEquals(Double.NEGATIVE_INFINITY, FastMath.scalb(-2.2250738585072014E-308, 2147483647), 0D);
+        assertEquals(Double.POSITIVE_INFINITY, FastMath.scalb( 2.2250738585072014E-308, 2147483647), 0D);
     }
 
     @Test
     public void testFloatScalbSpecialCases() {
-        Assert.assertEquals(0f,                       FastMath.scalb(Float.MIN_VALUE,  -30), 0F);
-        Assert.assertEquals(2 * Float.MIN_VALUE,      FastMath.scalb(Float.MIN_VALUE,    1), 0F);
-        Assert.assertEquals(7.555786e22f,             FastMath.scalb(Float.MAX_VALUE,  -52), 0F);
-        Assert.assertEquals(1.7014118e38f,            FastMath.scalb(Float.MIN_VALUE,  276), 0F);
-        Assert.assertEquals(Float.POSITIVE_INFINITY,  FastMath.scalb(Float.MIN_VALUE,  277), 0F);
-        Assert.assertEquals(5.8774718e-39f,           FastMath.scalb(1.1754944e-38f,    -1), 0F);
-        Assert.assertEquals(2 * Float.MIN_VALUE,      FastMath.scalb(Float.MAX_VALUE, -276), 0F);
-        Assert.assertEquals(Float.MIN_VALUE,          FastMath.scalb(Float.MAX_VALUE, -277), 0F);
-        Assert.assertEquals(0,                        FastMath.scalb(Float.MAX_VALUE, -278), 0F);
-        Assert.assertEquals(Float.POSITIVE_INFINITY,  FastMath.scalb(Float.POSITIVE_INFINITY, -1000000), 0F);
-        Assert.assertEquals(-3.13994498e38f,          FastMath.scalb(-1.1e-7f,         151), 0F);
-        Assert.assertEquals(Float.NEGATIVE_INFINITY,  FastMath.scalb(-1.1e-7f,         152), 0F);
-        Assert.assertEquals(Float.POSITIVE_INFINITY,  FastMath.scalb(3.4028235E38f,  2147483647), 0F);
-        Assert.assertEquals(Float.NEGATIVE_INFINITY,  FastMath.scalb(-3.4028235E38f, 2147483647), 0F);
+        assertEquals(0f, FastMath.scalb(Float.MIN_VALUE, -30), 0F);
+        assertEquals(2 * Float.MIN_VALUE, FastMath.scalb(Float.MIN_VALUE, 1), 0F);
+        assertEquals(7.555786e22f, FastMath.scalb(Float.MAX_VALUE, -52), 0F);
+        assertEquals(1.7014118e38f, FastMath.scalb(Float.MIN_VALUE, 276), 0F);
+        assertEquals(Float.POSITIVE_INFINITY, FastMath.scalb(Float.MIN_VALUE, 277), 0F);
+        assertEquals(5.8774718e-39f, FastMath.scalb(1.1754944e-38f, -1), 0F);
+        assertEquals(2 * Float.MIN_VALUE, FastMath.scalb(Float.MAX_VALUE, -276), 0F);
+        assertEquals(Float.MIN_VALUE, FastMath.scalb(Float.MAX_VALUE, -277), 0F);
+        assertEquals(0, FastMath.scalb(Float.MAX_VALUE, -278), 0F);
+        assertEquals(Float.POSITIVE_INFINITY, FastMath.scalb(Float.POSITIVE_INFINITY, -1000000), 0F);
+        assertEquals(-3.13994498e38f, FastMath.scalb(-1.1e-7f, 151), 0F);
+        assertEquals(Float.NEGATIVE_INFINITY, FastMath.scalb(-1.1e-7f, 152), 0F);
+        assertEquals(Float.POSITIVE_INFINITY, FastMath.scalb(3.4028235E38f, 2147483647), 0F);
+        assertEquals(Float.NEGATIVE_INFINITY, FastMath.scalb(-3.4028235E38f, 2147483647), 0F);
     }
 
     private boolean compareClassMethods(Class<?> class1, Class<?> class2){
@@ -1374,66 +1269,66 @@ public class FastMathTest {
     @Test
     public void checkMissingFastMathClasses() {
         boolean ok = compareClassMethods(StrictMath.class, FastMath.class);
-        Assert.assertTrue("FastMath should implement all StrictMath methods", ok);
+        assertTrue("FastMath should implement all StrictMath methods", ok);
     }
 
     @Ignore
     @Test
     public void checkExtraFastMathClasses() {
-        compareClassMethods( FastMath.class, StrictMath.class);
+        compareClassMethods(FastMath.class, StrictMath.class);
     }
 
     @Test
     public void testSignumDouble() {
         final double delta = 0.0;
-        Assert.assertEquals(1.0, FastMath.signum(2.0), delta);
-        Assert.assertEquals(0.0, FastMath.signum(0.0), delta);
-        Assert.assertEquals(-1.0, FastMath.signum(-2.0), delta);
+        assertEquals(1.0, FastMath.signum(2.0), delta);
+        assertEquals(0.0, FastMath.signum(0.0), delta);
+        assertEquals(-1.0, FastMath.signum(-2.0), delta);
         TestUtils.assertSame(-0. / 0., FastMath.signum(Double.NaN));
     }
 
     @Test
     public void testSignumFloat() {
         final float delta = 0.0F;
-        Assert.assertEquals(1.0F, FastMath.signum(2.0F), delta);
-        Assert.assertEquals(0.0F, FastMath.signum(0.0F), delta);
-        Assert.assertEquals(-1.0F, FastMath.signum(-2.0F), delta);
+        assertEquals(1.0F, FastMath.signum(2.0F), delta);
+        assertEquals(0.0F, FastMath.signum(0.0F), delta);
+        assertEquals(-1.0F, FastMath.signum(-2.0F), delta);
         TestUtils.assertSame(Float.NaN, FastMath.signum(Float.NaN));
     }
 
     @Test
     public void testLogWithBase() {
-        Assert.assertEquals(2.0, FastMath.log(2, 4), 0);
-        Assert.assertEquals(3.0, FastMath.log(2, 8), 0);
-        Assert.assertTrue(Double.isNaN(FastMath.log(-1, 1)));
-        Assert.assertTrue(Double.isNaN(FastMath.log(1, -1)));
-        Assert.assertTrue(Double.isNaN(FastMath.log(0, 0)));
-        Assert.assertEquals(0, FastMath.log(0, 10), 0);
-        Assert.assertEquals(Double.NEGATIVE_INFINITY, FastMath.log(10, 0), 0);
+        assertEquals(2.0, FastMath.log(2, 4), 0);
+        assertEquals(3.0, FastMath.log(2, 8), 0);
+        assertTrue(Double.isNaN(FastMath.log(-1, 1)));
+        assertTrue(Double.isNaN(FastMath.log(1, -1)));
+        assertTrue(Double.isNaN(FastMath.log(0, 0)));
+        assertEquals(0, FastMath.log(0, 10), 0);
+        assertEquals(Double.NEGATIVE_INFINITY, FastMath.log(10, 0), 0);
     }
 
     @Test
     public void testIndicatorDouble() {
         double delta = 0.0;
-        Assert.assertEquals(1.0, FastMath.copySign(1d, 2.0), delta);
-        Assert.assertEquals(1.0, FastMath.copySign(1d, 0.0), delta);
-        Assert.assertEquals(-1.0, FastMath.copySign(1d, -0.0), delta);
-        Assert.assertEquals(1.0, FastMath.copySign(1d, Double.POSITIVE_INFINITY), delta);
-        Assert.assertEquals(-1.0, FastMath.copySign(1d, Double.NEGATIVE_INFINITY), delta);
-        Assert.assertEquals(1.0, FastMath.copySign(1d, Double.NaN), delta);
-        Assert.assertEquals(-1.0, FastMath.copySign(1d, -2.0), delta);
+        assertEquals(1.0, FastMath.copySign(1d, 2.0), delta);
+        assertEquals(1.0, FastMath.copySign(1d, 0.0), delta);
+        assertEquals(-1.0, FastMath.copySign(1d, -0.0), delta);
+        assertEquals(1.0, FastMath.copySign(1d, Double.POSITIVE_INFINITY), delta);
+        assertEquals(-1.0, FastMath.copySign(1d, Double.NEGATIVE_INFINITY), delta);
+        assertEquals(1.0, FastMath.copySign(1d, Double.NaN), delta);
+        assertEquals(-1.0, FastMath.copySign(1d, -2.0), delta);
     }
 
     @Test
     public void testIndicatorFloat() {
         float delta = 0.0F;
-        Assert.assertEquals(1.0F, FastMath.copySign(1d, 2.0F), delta);
-        Assert.assertEquals(1.0F, FastMath.copySign(1d, 0.0F), delta);
-        Assert.assertEquals(-1.0F, FastMath.copySign(1d, -0.0F), delta);
-        Assert.assertEquals(1.0F, FastMath.copySign(1d, Float.POSITIVE_INFINITY), delta);
-        Assert.assertEquals(-1.0F, FastMath.copySign(1d, Float.NEGATIVE_INFINITY), delta);
-        Assert.assertEquals(1.0F, FastMath.copySign(1d, Float.NaN), delta);
-        Assert.assertEquals(-1.0F, FastMath.copySign(1d, -2.0F), delta);
+        assertEquals(1.0F, FastMath.copySign(1d, 2.0F), delta);
+        assertEquals(1.0F, FastMath.copySign(1d, 0.0F), delta);
+        assertEquals(-1.0F, FastMath.copySign(1d, -0.0F), delta);
+        assertEquals(1.0F, FastMath.copySign(1d, Float.POSITIVE_INFINITY), delta);
+        assertEquals(-1.0F, FastMath.copySign(1d, Float.NEGATIVE_INFINITY), delta);
+        assertEquals(1.0F, FastMath.copySign(1d, Float.NaN), delta);
+        assertEquals(-1.0F, FastMath.copySign(1d, -2.0F), delta);
     }
 
     @Test
@@ -1444,95 +1339,99 @@ public class FastMathTest {
         Dfp baseDfp = field.newDfp(base);
         Dfp dfpPower = field.getOne();
         for (int i = 0; i < maxExp; i++) {
-            Assert.assertEquals("exp=" + i, dfpPower.toDouble(), FastMath.pow(base, i),
-                                0.6 * FastMath.ulp(dfpPower.toDouble()));
+            assertEquals("exp=" + i, dfpPower.toDouble(), FastMath.pow(base, i),
+                         0.6 * FastMath.ulp(dfpPower.toDouble()));
             dfpPower = dfpPower.multiply(baseDfp);
         }
     }
 
     @Test
     public void testIntPowHuge() {
-        Assert.assertTrue(Double.isInfinite(FastMath.pow(FastMath.scalb(1.0, 500), 4)));
+        assertTrue(Double.isInfinite(FastMath.pow(FastMath.scalb(1.0, 500), 4)));
     }
 
     @Test(timeout=5000L) // This test must finish in finite time.
     public void testIntPowLongMinValue() {
-        Assert.assertEquals(1.0, FastMath.pow(1.0, Long.MIN_VALUE), -1.0);
+        assertEquals(1.0, FastMath.pow(1.0, Long.MIN_VALUE), -1.0);
     }
 
     @Test(timeout=5000L)
     public void testIntPowSpecialCases() {
         final double EXACT = -1.0;
-        final double DOUBLES[] = new double[]{Double.NEGATIVE_INFINITY, -0.0, Double.NaN, 0.0, Double.POSITIVE_INFINITY,
-                                              Long.MIN_VALUE, Integer.MIN_VALUE, Short.MIN_VALUE, Byte.MIN_VALUE,
-                                              -(double)Long.MIN_VALUE, -(double)Integer.MIN_VALUE, -(double)Short.MIN_VALUE, -(double)Byte.MIN_VALUE,
-                                              Byte.MAX_VALUE, Short.MAX_VALUE, Integer.MAX_VALUE, Long.MAX_VALUE,
-                                              -Byte.MAX_VALUE, -Short.MAX_VALUE, -Integer.MAX_VALUE, -Long.MAX_VALUE,
-                                              Float.MAX_VALUE, Double.MAX_VALUE, Double.MIN_VALUE, Float.MIN_VALUE,
-                                              -Float.MAX_VALUE, -Double.MAX_VALUE, -Double.MIN_VALUE, -Float.MIN_VALUE,
-                                              0.5, 0.1, 0.2, 0.8, 1.1, 1.2, 1.5, 1.8, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 1.3, 2.2, 2.5, 2.8, 33.0, 33.1, 33.5, 33.8, 10.0, 300.0, 400.0, 500.0,
-                                              -0.5, -0.1, -0.2, -0.8, -1.1, -1.2, -1.5, -1.8, -1.0, -2.0, -3.0, -4.0, -5.0, -6.0, -7.0, -8.0, -9.0, -1.3, -2.2, -2.5, -2.8, -33.0, -33.1, -33.5, -33.8, -10.0, -300.0, -400.0, -500.0};
+        final double DOUBLES[] = new double[]
+            {
+                Double.NEGATIVE_INFINITY, -0.0, Double.NaN, 0.0, Double.POSITIVE_INFINITY,
+                Long.MIN_VALUE, Integer.MIN_VALUE, Short.MIN_VALUE, Byte.MIN_VALUE,
+                -(double)Long.MIN_VALUE, -(double)Integer.MIN_VALUE, -(double)Short.MIN_VALUE, -(double)Byte.MIN_VALUE,
+                Byte.MAX_VALUE, Short.MAX_VALUE, Integer.MAX_VALUE, Long.MAX_VALUE,
+                -Byte.MAX_VALUE, -Short.MAX_VALUE, -Integer.MAX_VALUE, -Long.MAX_VALUE,
+                Float.MAX_VALUE, Double.MAX_VALUE, Double.MIN_VALUE, Float.MIN_VALUE,
+                -Float.MAX_VALUE, -Double.MAX_VALUE, -Double.MIN_VALUE, -Float.MIN_VALUE,
+                0.5, 0.1, 0.2, 0.8, 1.1, 1.2, 1.5, 1.8, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 1.3, 2.2, 2.5, 2.8, 33.0, 33.1, 33.5, 33.8, 10.0, 300.0, 400.0, 500.0,
+                -0.5, -0.1, -0.2, -0.8, -1.1, -1.2, -1.5, -1.8, -1.0, -2.0, -3.0, -4.0, -5.0, -6.0, -7.0, -8.0, -9.0, -1.3, -2.2, -2.5, -2.8, -33.0, -33.1, -33.5, -33.8, -10.0, -300.0, -400.0, -500.0
+            };
+
         final long INTS[] = new long[]{Long.MAX_VALUE, Long.MAX_VALUE - 1, Long.MIN_VALUE, Long.MIN_VALUE + 1, Long.MIN_VALUE + 2, Integer.MAX_VALUE, Integer.MAX_VALUE - 1, Integer.MIN_VALUE, Integer.MIN_VALUE + 1, Integer.MIN_VALUE + 2, 0, 1, 2, 3, 5, 8, 10, 20, 100, 300, 500, -1, -2, -3, -5, -8, -10, -20, -100, -300, -500};
         // Special cases from Math.pow javadoc:
         // If the second argument is positive or negative zero, then the result is 1.0.
         for (double d : DOUBLES) {
-            Assert.assertEquals(1.0, FastMath.pow(d, 0L), EXACT);
+            assertEquals(1.0, FastMath.pow(d, 0L), EXACT);
         }
         // If the second argument is 1.0, then the result is the same as the first argument.
         for (double d : DOUBLES) {
-            Assert.assertEquals(d, FastMath.pow(d, 1L), EXACT);
+            assertEquals(d, FastMath.pow(d, 1L), EXACT);
         }
         // If the second argument is NaN, then the result is NaN. <- Impossible with int.
         // If the first argument is NaN and the second argument is nonzero, then the result is NaN.
         for (long i : INTS) {
             if (i != 0L) {
-                Assert.assertEquals(Double.NaN, FastMath.pow(Double.NaN, i), EXACT);
+                assertEquals(Double.NaN, FastMath.pow(Double.NaN, i), EXACT);
             }
         }
         // If the absolute value of the first argument is greater than 1 and the second argument is positive infinity, or
         // the absolute value of the first argument is less than 1 and the second argument is negative infinity, then the result is positive infinity.
         for (double d : DOUBLES) {
             if (Math.abs(d) > 1.0) {
-                Assert.assertEquals(Double.POSITIVE_INFINITY, FastMath.pow(d, Long.MAX_VALUE - 1L), EXACT);
+                assertEquals(Double.POSITIVE_INFINITY, FastMath.pow(d, Long.MAX_VALUE - 1L), EXACT);
             }
         }
         for (double d : DOUBLES) {
             if (Math.abs(d) < 1.0) {
-                Assert.assertEquals(Double.POSITIVE_INFINITY, FastMath.pow(d, Long.MIN_VALUE), EXACT);
+                assertEquals(Double.POSITIVE_INFINITY, FastMath.pow(d, Long.MIN_VALUE), EXACT);
             }
         }
         // Note: Long.MAX_VALUE isn't actually an infinity, so its parity affects the sign of resulting infinity.
         for (double d : DOUBLES) {
             if (Math.abs(d) > 1.0) {
-                Assert.assertTrue(Double.isInfinite(FastMath.pow(d, Long.MAX_VALUE)));
+                assertTrue(Double.isInfinite(FastMath.pow

<TRUNCATED>

Mime
View raw message