test/java/lang/Math/IeeeRecommendedTests.java

Print this page

        

@@ -23,15 +23,18 @@
 
 /*
  * @test
  * @bug 4860891 4826732 4780454 4939441 4826652
  * @summary Tests for IEEE 754[R] recommended functions and similar methods
+ * @library /lib/testlibrary
+ * @build jdk.testlibrary.DoubleUtils jdk.testlibrary.FloatUtils
+ * @run main IeeeRecommendedTests
  * @author Joseph D. Darcy
  */
 
-import sun.misc.DoubleConsts;
-import sun.misc.FloatConsts;
+import jdk.testlibrary.DoubleUtils;
+import jdk.testlibrary.FloatUtils;
 
 public class IeeeRecommendedTests {
     private IeeeRecommendedTests(){}
 
     static final float  NaNf = Float.NaN;

@@ -52,22 +55,22 @@
 
     /**
      * Returns a floating-point power of two in the normal range.
      */
     static double powerOfTwoD(int n) {
-        return Double.longBitsToDouble((((long)n + (long)DoubleConsts.MAX_EXPONENT) <<
-                                        (DoubleConsts.SIGNIFICAND_WIDTH-1))
-                                       & DoubleConsts.EXP_BIT_MASK);
+        return Double.longBitsToDouble((((long)n + (long)Double.MAX_EXPONENT) <<
+                                        (DoubleUtils.SIGNIFICAND_WIDTH-1))
+                                       & DoubleUtils.EXP_BIT_MASK);
     }
 
     /**
      * Returns a floating-point power of two in the normal range.
      */
     static float powerOfTwoF(int n) {
-        return Float.intBitsToFloat(((n + FloatConsts.MAX_EXPONENT) <<
-                                     (FloatConsts.SIGNIFICAND_WIDTH-1))
-                                    & FloatConsts.EXP_BIT_MASK);
+        return Float.intBitsToFloat(((n + Float.MAX_EXPONENT) <<
+                                     (FloatUtils.SIGNIFICAND_WIDTH-1))
+                                    & FloatUtils.EXP_BIT_MASK);
     }
 
     /* ******************** getExponent tests ****************************** */
 
     /*

@@ -127,34 +130,34 @@
                                   +1.0f,
                                   +2.0f,
                                   +16.0f,
                                   +Float.MIN_VALUE,
                                   +Float_MAX_SUBNORMAL,
-                                  +FloatConsts.MIN_NORMAL,
+                                  +Float.MIN_NORMAL,
                                   +Float.MAX_VALUE
         };
 
         int [] specialResults = {Float.MAX_EXPONENT + 1, // NaN results
                                  Float.MAX_EXPONENT + 1, // Infinite results
                                  Float.MIN_EXPONENT - 1, // Zero results
                                  0,
                                  1,
                                  4,
-                                 FloatConsts.MIN_EXPONENT - 1,
-                                 -FloatConsts.MAX_EXPONENT,
-                                 FloatConsts.MIN_EXPONENT,
-                                 FloatConsts.MAX_EXPONENT
+                                 Float.MIN_EXPONENT - 1,
+                                 -Float.MAX_EXPONENT,
+                                 Float.MIN_EXPONENT,
+                                 Float.MAX_EXPONENT
         };
 
         // Special value tests
         for(int i = 0; i < specialValues.length; i++) {
             failures += testGetExponentCase(specialValues[i], specialResults[i]);
         }
 
 
         // Normal exponent tests
-        for(int i = FloatConsts.MIN_EXPONENT; i <= FloatConsts.MAX_EXPONENT; i++) {
+        for(int i = Float.MIN_EXPONENT; i <= Float.MAX_EXPONENT; i++) {
             int result;
 
             // Create power of two
             float po2 = powerOfTwoF(i);
 

@@ -165,19 +168,19 @@
                 int randSignif = rand.nextInt();
                 float randFloat;
 
                 randFloat = Float.intBitsToFloat( // Exponent
                                                  (Float.floatToIntBits(po2)&
-                                                  (~FloatConsts.SIGNIF_BIT_MASK)) |
+                                                  (~FloatUtils.SIGNIF_BIT_MASK)) |
                                                  // Significand
                                                  (randSignif &
-                                                  FloatConsts.SIGNIF_BIT_MASK) );
+                                                  FloatUtils.SIGNIF_BIT_MASK) );
 
                 failures += testGetExponentCase(randFloat, i);
             }
 
-            if (i > FloatConsts.MIN_EXPONENT) {
+            if (i > Float.MIN_EXPONENT) {
                 float po2minus = Math.nextAfter(po2,
                                                  Float.NEGATIVE_INFINITY);
                 failures += testGetExponentCase(po2minus, i-1);
             }
         }

@@ -193,21 +196,21 @@
          * needed.
          */
 
         float top=Float.MIN_VALUE;
         for( int i = 1;
-            i < FloatConsts.SIGNIFICAND_WIDTH;
+            i < FloatUtils.SIGNIFICAND_WIDTH;
             i++, top *= 2.0f) {
 
             failures += testGetExponentCase(top,
-                                            FloatConsts.MIN_EXPONENT - 1);
+                                            Float.MIN_EXPONENT - 1);
 
             // Test largest value in next smaller binade
             if (i >= 3) {// (i == 1) would test 0.0;
                          // (i == 2) would just retest MIN_VALUE
                 testGetExponentCase(Math.nextAfter(top, 0.0f),
-                                    FloatConsts.MIN_EXPONENT - 1);
+                                    Float.MIN_EXPONENT - 1);
 
                 if( i >= 10) {
                     // create a bit mask with (i-1) 1's in the low order
                     // bits
                     int mask = ~((~0)<<(i-1));

@@ -215,11 +218,11 @@
                                                  Float.floatToIntBits(top) |
                                                  // Significand
                                                  (rand.nextInt() & mask ) ) ;
 
                     failures += testGetExponentCase(randFloat,
-                                                    FloatConsts.MIN_EXPONENT - 1);
+                                                    Float.MIN_EXPONENT - 1);
                 }
             }
         }
 
         return failures;

@@ -234,34 +237,34 @@
                                    +1.0,
                                    +2.0,
                                    +16.0,
                                    +Double.MIN_VALUE,
                                    +Double_MAX_SUBNORMAL,
-                                   +DoubleConsts.MIN_NORMAL,
+                                   +Double.MIN_NORMAL,
                                    +Double.MAX_VALUE
         };
 
         int [] specialResults = {Double.MAX_EXPONENT + 1, // NaN results
                                  Double.MAX_EXPONENT + 1, // Infinite results
                                  Double.MIN_EXPONENT - 1, // Zero results
                                  0,
                                  1,
                                  4,
-                                 DoubleConsts.MIN_EXPONENT - 1,
-                                 -DoubleConsts.MAX_EXPONENT,
-                                 DoubleConsts.MIN_EXPONENT,
-                                 DoubleConsts.MAX_EXPONENT
+                                 Double.MIN_EXPONENT - 1,
+                                 -Double.MAX_EXPONENT,
+                                 Double.MIN_EXPONENT,
+                                 Double.MAX_EXPONENT
         };
 
         // Special value tests
         for(int i = 0; i < specialValues.length; i++) {
             failures += testGetExponentCase(specialValues[i], specialResults[i]);
         }
 
 
         // Normal exponent tests
-        for(int i = DoubleConsts.MIN_EXPONENT; i <= DoubleConsts.MAX_EXPONENT; i++) {
+        for(int i = Double.MIN_EXPONENT; i <= Double.MAX_EXPONENT; i++) {
             int result;
 
             // Create power of two
             double po2 = powerOfTwoD(i);
 

@@ -272,19 +275,19 @@
                 long randSignif = rand.nextLong();
                 double randFloat;
 
                 randFloat = Double.longBitsToDouble( // Exponent
                                                  (Double.doubleToLongBits(po2)&
-                                                  (~DoubleConsts.SIGNIF_BIT_MASK)) |
+                                                  (~DoubleUtils.SIGNIF_BIT_MASK)) |
                                                  // Significand
                                                  (randSignif &
-                                                  DoubleConsts.SIGNIF_BIT_MASK) );
+                                                  DoubleUtils.SIGNIF_BIT_MASK) );
 
                 failures += testGetExponentCase(randFloat, i);
             }
 
-            if (i > DoubleConsts.MIN_EXPONENT) {
+            if (i > Double.MIN_EXPONENT) {
                 double po2minus = Math.nextAfter(po2,
                                                     Double.NEGATIVE_INFINITY);
                 failures += testGetExponentCase(po2minus, i-1);
             }
         }

@@ -300,21 +303,21 @@
          * needed.
          */
 
         double top=Double.MIN_VALUE;
         for( int i = 1;
-            i < DoubleConsts.SIGNIFICAND_WIDTH;
+            i < DoubleUtils.SIGNIFICAND_WIDTH;
             i++, top *= 2.0f) {
 
             failures += testGetExponentCase(top,
-                                            DoubleConsts.MIN_EXPONENT - 1);
+                                            Double.MIN_EXPONENT - 1);
 
             // Test largest value in next smaller binade
             if (i >= 3) {// (i == 1) would test 0.0;
                          // (i == 2) would just retest MIN_VALUE
                 testGetExponentCase(Math.nextAfter(top, 0.0),
-                                    DoubleConsts.MIN_EXPONENT - 1);
+                                    Double.MIN_EXPONENT - 1);
 
                 if( i >= 10) {
                     // create a bit mask with (i-1) 1's in the low order
                     // bits
                     long mask = ~((~0L)<<(i-1));

@@ -322,11 +325,11 @@
                                                  Double.doubleToLongBits(top) |
                                                  // Significand
                                                  (rand.nextLong() & mask ) ) ;
 
                     failures += testGetExponentCase(randFloat,
-                                                    DoubleConsts.MIN_EXPONENT - 1);
+                                                    Double.MIN_EXPONENT - 1);
                 }
             }
         }
 
         return failures;

@@ -398,19 +401,19 @@
 
             {Float_MAX_VALUEmm, Float.MAX_VALUE,        Float.MAX_VALUE},
             {Float_MAX_VALUEmm, infinityF,              Float.MAX_VALUE},
             {Float_MAX_VALUEmm, Float_MAX_VALUEmm,      Float_MAX_VALUEmm},
 
-            {FloatConsts.MIN_NORMAL,    infinityF,              FloatConsts.MIN_NORMAL+
+            {Float.MIN_NORMAL,          infinityF,              Float.MIN_NORMAL+
                                                                 Float.MIN_VALUE},
-            {FloatConsts.MIN_NORMAL,    -infinityF,             Float_MAX_SUBNORMAL},
-            {FloatConsts.MIN_NORMAL,    1.0f,                   FloatConsts.MIN_NORMAL+
+            {Float.MIN_NORMAL,          -infinityF,             Float_MAX_SUBNORMAL},
+            {Float.MIN_NORMAL,          1.0f,                   Float.MIN_NORMAL+
                                                                 Float.MIN_VALUE},
-            {FloatConsts.MIN_NORMAL,    -1.0f,                  Float_MAX_SUBNORMAL},
-            {FloatConsts.MIN_NORMAL,    FloatConsts.MIN_NORMAL, FloatConsts.MIN_NORMAL},
+            {Float.MIN_NORMAL,          -1.0f,                  Float_MAX_SUBNORMAL},
+            {Float.MIN_NORMAL,          Float.MIN_NORMAL,       Float.MIN_NORMAL},
 
-            {Float_MAX_SUBNORMAL,       FloatConsts.MIN_NORMAL, FloatConsts.MIN_NORMAL},
+            {Float_MAX_SUBNORMAL,       Float.MIN_NORMAL,       Float.MIN_NORMAL},
             {Float_MAX_SUBNORMAL,       Float_MAX_SUBNORMAL,    Float_MAX_SUBNORMAL},
             {Float_MAX_SUBNORMAL,       0.0f,                   Float_MAX_SUBNORMALmm},
 
             {Float_MAX_SUBNORMALmm,     Float_MAX_SUBNORMAL,    Float_MAX_SUBNORMAL},
             {Float_MAX_SUBNORMALmm,     0.0f,                   Float_MAX_SUBNORMALmm-Float.MIN_VALUE},

@@ -470,19 +473,19 @@
 
             {Double_MAX_VALUEmm,        Double.MAX_VALUE,       Double.MAX_VALUE},
             {Double_MAX_VALUEmm,        infinityD,              Double.MAX_VALUE},
             {Double_MAX_VALUEmm,        Double_MAX_VALUEmm,     Double_MAX_VALUEmm},
 
-            {DoubleConsts.MIN_NORMAL,   infinityD,              DoubleConsts.MIN_NORMAL+
+            {Double.MIN_NORMAL,         infinityD,              Double.MIN_NORMAL+
                                                                 Double.MIN_VALUE},
-            {DoubleConsts.MIN_NORMAL,   -infinityD,             Double_MAX_SUBNORMAL},
-            {DoubleConsts.MIN_NORMAL,   1.0f,                   DoubleConsts.MIN_NORMAL+
+            {Double.MIN_NORMAL,         -infinityD,             Double_MAX_SUBNORMAL},
+            {Double.MIN_NORMAL,         1.0f,                   Double.MIN_NORMAL+
                                                                 Double.MIN_VALUE},
-            {DoubleConsts.MIN_NORMAL,   -1.0f,                  Double_MAX_SUBNORMAL},
-            {DoubleConsts.MIN_NORMAL,   DoubleConsts.MIN_NORMAL,DoubleConsts.MIN_NORMAL},
+            {Double.MIN_NORMAL,         -1.0f,                  Double_MAX_SUBNORMAL},
+            {Double.MIN_NORMAL,         Double.MIN_NORMAL,      Double.MIN_NORMAL},
 
-            {Double_MAX_SUBNORMAL,      DoubleConsts.MIN_NORMAL,DoubleConsts.MIN_NORMAL},
+            {Double_MAX_SUBNORMAL,      Double.MIN_NORMAL,      Double.MIN_NORMAL},
             {Double_MAX_SUBNORMAL,      Double_MAX_SUBNORMAL,   Double_MAX_SUBNORMAL},
             {Double_MAX_SUBNORMAL,      0.0d,                   Double_MAX_SUBNORMALmm},
 
             {Double_MAX_SUBNORMALmm,    Double_MAX_SUBNORMAL,   Double_MAX_SUBNORMAL},
             {Double_MAX_SUBNORMALmm,    0.0d,                   Double_MAX_SUBNORMALmm-Double.MIN_VALUE},

@@ -527,19 +530,19 @@
          */
         float testCases [][] = {
             {NaNf,                      NaNf},
             {-infinityF,                -Float.MAX_VALUE},
             {-Float.MAX_VALUE,          -Float_MAX_VALUEmm},
-            {-FloatConsts.MIN_NORMAL,   -Float_MAX_SUBNORMAL},
+            {-Float.MIN_NORMAL,         -Float_MAX_SUBNORMAL},
             {-Float_MAX_SUBNORMAL,      -Float_MAX_SUBNORMALmm},
             {-Float.MIN_VALUE,          -0.0f},
             {-0.0f,                     Float.MIN_VALUE},
             {+0.0f,                     Float.MIN_VALUE},
             {Float.MIN_VALUE,           Float.MIN_VALUE*2},
             {Float_MAX_SUBNORMALmm,     Float_MAX_SUBNORMAL},
-            {Float_MAX_SUBNORMAL,       FloatConsts.MIN_NORMAL},
-            {FloatConsts.MIN_NORMAL,    FloatConsts.MIN_NORMAL+Float.MIN_VALUE},
+            {Float_MAX_SUBNORMAL,       Float.MIN_NORMAL},
+            {Float.MIN_NORMAL,          Float.MIN_NORMAL+Float.MIN_VALUE},
             {Float_MAX_VALUEmm,         Float.MAX_VALUE},
             {Float.MAX_VALUE,           infinityF},
             {infinityF,                 infinityF}
         };
 

@@ -565,19 +568,19 @@
          */
         double testCases [][] = {
             {NaNd,                      NaNd},
             {-infinityD,                -Double.MAX_VALUE},
             {-Double.MAX_VALUE,         -Double_MAX_VALUEmm},
-            {-DoubleConsts.MIN_NORMAL,  -Double_MAX_SUBNORMAL},
+            {-Double.MIN_NORMAL,        -Double_MAX_SUBNORMAL},
             {-Double_MAX_SUBNORMAL,     -Double_MAX_SUBNORMALmm},
             {-Double.MIN_VALUE,         -0.0d},
             {-0.0d,                     Double.MIN_VALUE},
             {+0.0d,                     Double.MIN_VALUE},
             {Double.MIN_VALUE,          Double.MIN_VALUE*2},
             {Double_MAX_SUBNORMALmm,    Double_MAX_SUBNORMAL},
-            {Double_MAX_SUBNORMAL,      DoubleConsts.MIN_NORMAL},
-            {DoubleConsts.MIN_NORMAL,   DoubleConsts.MIN_NORMAL+Double.MIN_VALUE},
+            {Double_MAX_SUBNORMAL,      Double.MIN_NORMAL},
+            {Double.MIN_NORMAL,         Double.MIN_NORMAL+Double.MIN_VALUE},
             {Double_MAX_VALUEmm,        Double.MAX_VALUE},
             {Double.MAX_VALUE,          infinityD},
             {infinityD,                 infinityD}
         };
 

@@ -605,20 +608,20 @@
         float testCases [][] = {
             {NaNf,                      NaNf},
             {-infinityF,                -infinityF},
             {-Float.MAX_VALUE,          -infinityF},
             {-Float_MAX_VALUEmm,        -Float.MAX_VALUE},
-            {-Float_MAX_SUBNORMAL,      -FloatConsts.MIN_NORMAL},
+            {-Float_MAX_SUBNORMAL,      -Float.MIN_NORMAL},
             {-Float_MAX_SUBNORMALmm,    -Float_MAX_SUBNORMAL},
             {-0.0f,                     -Float.MIN_VALUE},
             {+0.0f,                     -Float.MIN_VALUE},
             {Float.MIN_VALUE,           0.0f},
             {Float.MIN_VALUE*2,         Float.MIN_VALUE},
             {Float_MAX_SUBNORMAL,       Float_MAX_SUBNORMALmm},
-            {FloatConsts.MIN_NORMAL,    Float_MAX_SUBNORMAL},
-            {FloatConsts.MIN_NORMAL+
-             Float.MIN_VALUE,           FloatConsts.MIN_NORMAL},
+            {Float.MIN_NORMAL,          Float_MAX_SUBNORMAL},
+            {Float.MIN_NORMAL+
+             Float.MIN_VALUE,           Float.MIN_NORMAL},
             {Float.MAX_VALUE,           Float_MAX_VALUEmm},
             {infinityF,                 Float.MAX_VALUE},
         };
 
         for(int i = 0; i < testCases.length; i++) {

@@ -644,20 +647,20 @@
         double testCases [][] = {
             {NaNd,                      NaNd},
             {-infinityD,                -infinityD},
             {-Double.MAX_VALUE,         -infinityD},
             {-Double_MAX_VALUEmm,       -Double.MAX_VALUE},
-            {-Double_MAX_SUBNORMAL,     -DoubleConsts.MIN_NORMAL},
+            {-Double_MAX_SUBNORMAL,     -Double.MIN_NORMAL},
             {-Double_MAX_SUBNORMALmm,   -Double_MAX_SUBNORMAL},
             {-0.0d,                     -Double.MIN_VALUE},
             {+0.0d,                     -Double.MIN_VALUE},
             {Double.MIN_VALUE,          0.0d},
             {Double.MIN_VALUE*2,        Double.MIN_VALUE},
             {Double_MAX_SUBNORMAL,      Double_MAX_SUBNORMALmm},
-            {DoubleConsts.MIN_NORMAL,   Double_MAX_SUBNORMAL},
-            {DoubleConsts.MIN_NORMAL+
-             Double.MIN_VALUE,          DoubleConsts.MIN_NORMAL},
+            {Double.MIN_NORMAL,         Double_MAX_SUBNORMAL},
+            {Double.MIN_NORMAL+
+             Double.MIN_VALUE,          Double.MIN_NORMAL},
             {Double.MAX_VALUE,          Double_MAX_VALUEmm},
             {infinityD,                 Double.MAX_VALUE},
         };
 
         for(int i = 0; i < testCases.length; i++) {

@@ -687,20 +690,20 @@
             -infinityF,
             infinityF,
             -Float.MAX_VALUE,
             -3.0f,
             -1.0f,
-            -FloatConsts.MIN_NORMAL,
+            -Float.MIN_NORMAL,
             -Float_MAX_SUBNORMALmm,
             -Float_MAX_SUBNORMAL,
             -Float.MIN_VALUE,
             -0.0f,
             +0.0f,
             Float.MIN_VALUE,
             Float_MAX_SUBNORMALmm,
             Float_MAX_SUBNORMAL,
-            FloatConsts.MIN_NORMAL,
+            Float.MIN_NORMAL,
             1.0f,
             3.0f,
             Float_MAX_VALUEmm,
             Float.MAX_VALUE
         };

@@ -737,20 +740,20 @@
             -infinityD,
             infinityD,
             -Double.MAX_VALUE,
             -3.0d,
             -1.0d,
-            -DoubleConsts.MIN_NORMAL,
+            -Double.MIN_NORMAL,
             -Double_MAX_SUBNORMALmm,
             -Double_MAX_SUBNORMAL,
             -Double.MIN_VALUE,
             -0.0d,
             +0.0d,
             Double.MIN_VALUE,
             Double_MAX_SUBNORMALmm,
             Double_MAX_SUBNORMAL,
-            DoubleConsts.MIN_NORMAL,
+            Double.MIN_NORMAL,
             1.0d,
             3.0d,
             Double_MAX_VALUEmm,
             Double.MAX_VALUE
         };

@@ -788,22 +791,22 @@
         float testCases [][] = {
             {+0.0f,
              Float.MIN_VALUE,
              Float_MAX_SUBNORMALmm,
              Float_MAX_SUBNORMAL,
-             FloatConsts.MIN_NORMAL,
+             Float.MIN_NORMAL,
              1.0f,
              3.0f,
              Float_MAX_VALUEmm,
              Float.MAX_VALUE,
              infinityF,
             },
             {-infinityF,
              -Float.MAX_VALUE,
              -3.0f,
              -1.0f,
-             -FloatConsts.MIN_NORMAL,
+             -Float.MIN_NORMAL,
              -Float_MAX_SUBNORMALmm,
              -Float_MAX_SUBNORMAL,
              -Float.MIN_VALUE,
              -0.0f}
         };

@@ -862,22 +865,22 @@
         double testCases [][] = {
             {+0.0d,
              Double.MIN_VALUE,
              Double_MAX_SUBNORMALmm,
              Double_MAX_SUBNORMAL,
-             DoubleConsts.MIN_NORMAL,
+             Double.MIN_NORMAL,
              1.0d,
              3.0d,
              Double_MAX_VALUEmm,
              Double.MAX_VALUE,
              infinityD,
             },
             {-infinityD,
              -Double.MAX_VALUE,
              -3.0d,
              -1.0d,
-             -DoubleConsts.MIN_NORMAL,
+             -Double.MIN_NORMAL,
              -Double_MAX_SUBNORMALmm,
              -Double_MAX_SUBNORMAL,
              -Double.MIN_VALUE,
              -0.0d}
         };

@@ -962,12 +965,12 @@
         return failures;
     }
 
     public static int testFloatScalb() {
         int failures=0;
-        int MAX_SCALE = FloatConsts.MAX_EXPONENT + -FloatConsts.MIN_EXPONENT +
-                        FloatConsts.SIGNIFICAND_WIDTH + 1;
+        int MAX_SCALE = Float.MAX_EXPONENT + -Float.MIN_EXPONENT +
+                        FloatUtils.SIGNIFICAND_WIDTH + 1;
 
 
         // Arguments x, where scalb(x,n) is x for any n.
         float [] identityTestCases = {NaNf,
                                       -0.0f,

@@ -986,62 +989,62 @@
         float [] someTestCases = {
             Float.MIN_VALUE,
             3.0f*Float.MIN_VALUE,
             Float_MAX_SUBNORMALmm,
             Float_MAX_SUBNORMAL,
-            FloatConsts.MIN_NORMAL,
+            Float.MIN_NORMAL,
             1.0f,
             2.0f,
             3.0f,
             (float)Math.PI,
             Float_MAX_VALUEmm,
             Float.MAX_VALUE
         };
 
         int [] oneMultiplyScalingFactors = {
-            FloatConsts.MIN_EXPONENT,
-            FloatConsts.MIN_EXPONENT+1,
+            Float.MIN_EXPONENT,
+            Float.MIN_EXPONENT+1,
             -3,
             -2,
             -1,
             0,
             1,
             2,
             3,
-            FloatConsts.MAX_EXPONENT-1,
-            FloatConsts.MAX_EXPONENT
+            Float.MAX_EXPONENT-1,
+            Float.MAX_EXPONENT
         };
 
         int [] manyScalingFactors = {
             Integer.MIN_VALUE,
             Integer.MIN_VALUE+1,
             -MAX_SCALE -1,
             -MAX_SCALE,
             -MAX_SCALE+1,
 
-            2*FloatConsts.MIN_EXPONENT-1,       // -253
-            2*FloatConsts.MIN_EXPONENT,         // -252
-            2*FloatConsts.MIN_EXPONENT+1,       // -251
-
-            FloatConsts.MIN_EXPONENT - FloatConsts.SIGNIFICAND_WIDTH,
-            FloatConsts.MIN_SUB_EXPONENT,
-            -FloatConsts.MAX_EXPONENT,          // -127
-            FloatConsts.MIN_EXPONENT,           // -126
+            2*Float.MIN_EXPONENT-1,       // -253
+            2*Float.MIN_EXPONENT,         // -252
+            2*Float.MIN_EXPONENT+1,       // -251
+
+            Float.MIN_EXPONENT - FloatUtils.SIGNIFICAND_WIDTH,
+            FloatUtils.MIN_SUB_EXPONENT,
+            -Float.MAX_EXPONENT,          // -127
+            Float.MIN_EXPONENT,           // -126
 
             -2,
             -1,
             0,
             1,
             2,
 
-            FloatConsts.MAX_EXPONENT-1,         // 126
-            FloatConsts.MAX_EXPONENT,           // 127
-            FloatConsts.MAX_EXPONENT+1,         // 128
-
-            2*FloatConsts.MAX_EXPONENT-1,       // 253
-            2*FloatConsts.MAX_EXPONENT,         // 254
-            2*FloatConsts.MAX_EXPONENT+1,       // 255
+            Float.MAX_EXPONENT-1,         // 126
+            Float.MAX_EXPONENT,           // 127
+            Float.MAX_EXPONENT+1,         // 128
+
+            2*Float.MAX_EXPONENT-1,       // 253
+            2*Float.MAX_EXPONENT,         // 254
+            2*Float.MAX_EXPONENT+1,       // 255
 
             MAX_SCALE-1,
             MAX_SCALE,
             MAX_SCALE+1,
             Integer.MAX_VALUE-1,

@@ -1084,24 +1087,24 @@
             }
         }
 
         // Create 2^MAX_EXPONENT
         float twoToTheMaxExp = 1.0f; // 2^0
-        for(int i = 0; i < FloatConsts.MAX_EXPONENT; i++)
+        for(int i = 0; i < Float.MAX_EXPONENT; i++)
             twoToTheMaxExp *=2.0f;
 
         // Scale-up subnormal values until they all overflow
         for(int i=0; i < subnormalTestCases.length; i++) {
             float scale = 1.0f; // 2^j
             float value = subnormalTestCases[i];
 
-            for(int j=FloatConsts.MAX_EXPONENT*2; j < MAX_SCALE; j++) { // MAX_SCALE -1 should cause overflow
+            for(int j=Float.MAX_EXPONENT*2; j < MAX_SCALE; j++) { // MAX_SCALE -1 should cause overflow
                 int scaleFactor = j;
 
                 failures+=testScalbCase(value,
                                         scaleFactor,
-                                        (Tests.ilogb(value) +j > FloatConsts.MAX_EXPONENT ) ?
+                                        (Tests.ilogb(value) +j > Float.MAX_EXPONENT ) ?
                                         Math.copySign(infinityF, value) : // overflow
                                         // calculate right answer
                                         twoToTheMaxExp*(twoToTheMaxExp*(scale*value)) );
                 scale*=2.0f;
             }

@@ -1170,12 +1173,12 @@
         return failures;
     }
 
     public static int testDoubleScalb() {
         int failures=0;
-        int MAX_SCALE = DoubleConsts.MAX_EXPONENT + -DoubleConsts.MIN_EXPONENT +
-                        DoubleConsts.SIGNIFICAND_WIDTH + 1;
+        int MAX_SCALE = Double.MAX_EXPONENT + -Double.MIN_EXPONENT +
+                        DoubleUtils.SIGNIFICAND_WIDTH + 1;
 
 
         // Arguments x, where scalb(x,n) is x for any n.
         double [] identityTestCases = {NaNd,
                                       -0.0,

@@ -1193,63 +1196,63 @@
         double [] someTestCases = {
             Double.MIN_VALUE,
             3.0d*Double.MIN_VALUE,
             Double_MAX_SUBNORMALmm,
             Double_MAX_SUBNORMAL,
-            DoubleConsts.MIN_NORMAL,
+            Double.MIN_NORMAL,
             1.0d,
             2.0d,
             3.0d,
             Math.PI,
             Double_MAX_VALUEmm,
             Double.MAX_VALUE
         };
 
         int [] oneMultiplyScalingFactors = {
-            DoubleConsts.MIN_EXPONENT,
-            DoubleConsts.MIN_EXPONENT+1,
+            Double.MIN_EXPONENT,
+            Double.MIN_EXPONENT+1,
             -3,
             -2,
             -1,
             0,
             1,
             2,
             3,
-            DoubleConsts.MAX_EXPONENT-1,
-            DoubleConsts.MAX_EXPONENT
+            Double.MAX_EXPONENT-1,
+            Double.MAX_EXPONENT
         };
 
         int [] manyScalingFactors = {
             Integer.MIN_VALUE,
             Integer.MIN_VALUE+1,
             -MAX_SCALE -1,
             -MAX_SCALE,
             -MAX_SCALE+1,
 
-            2*DoubleConsts.MIN_EXPONENT-1,      // -2045
-            2*DoubleConsts.MIN_EXPONENT,        // -2044
-            2*DoubleConsts.MIN_EXPONENT+1,      // -2043
-
-            DoubleConsts.MIN_EXPONENT,          // -1022
-            DoubleConsts.MIN_EXPONENT - DoubleConsts.SIGNIFICAND_WIDTH,
-            DoubleConsts.MIN_SUB_EXPONENT,
-            -DoubleConsts.MAX_EXPONENT,         // -1023
-            DoubleConsts.MIN_EXPONENT,          // -1022
+            2*Double.MIN_EXPONENT-1,      // -2045
+            2*Double.MIN_EXPONENT,        // -2044
+            2*Double.MIN_EXPONENT+1,      // -2043
+
+            Double.MIN_EXPONENT,          // -1022
+            Double.MIN_EXPONENT - DoubleUtils.SIGNIFICAND_WIDTH,
+            DoubleUtils.MIN_SUB_EXPONENT,
+            -Double.MAX_EXPONENT,         // -1023
+            Double.MIN_EXPONENT,          // -1022
 
             -2,
             -1,
             0,
             1,
             2,
 
-            DoubleConsts.MAX_EXPONENT-1,        // 1022
-            DoubleConsts.MAX_EXPONENT,          // 1023
-            DoubleConsts.MAX_EXPONENT+1,        // 1024
-
-            2*DoubleConsts.MAX_EXPONENT-1,      // 2045
-            2*DoubleConsts.MAX_EXPONENT,        // 2046
-            2*DoubleConsts.MAX_EXPONENT+1,      // 2047
+            Double.MAX_EXPONENT-1,        // 1022
+            Double.MAX_EXPONENT,          // 1023
+            Double.MAX_EXPONENT+1,        // 1024
+
+            2*Double.MAX_EXPONENT-1,      // 2045
+            2*Double.MAX_EXPONENT,        // 2046
+            2*Double.MAX_EXPONENT+1,      // 2047
 
             MAX_SCALE-1,
             MAX_SCALE,
             MAX_SCALE+1,
             Integer.MAX_VALUE-1,

@@ -1292,24 +1295,24 @@
             }
         }
 
         // Create 2^MAX_EXPONENT
         double twoToTheMaxExp = 1.0; // 2^0
-        for(int i = 0; i < DoubleConsts.MAX_EXPONENT; i++)
+        for(int i = 0; i < Double.MAX_EXPONENT; i++)
             twoToTheMaxExp *=2.0;
 
         // Scale-up subnormal values until they all overflow
         for(int i=0; i < subnormalTestCases.length; i++) {
             double scale = 1.0; // 2^j
             double value = subnormalTestCases[i];
 
-            for(int j=DoubleConsts.MAX_EXPONENT*2; j < MAX_SCALE; j++) { // MAX_SCALE -1 should cause overflow
+            for(int j=Double.MAX_EXPONENT*2; j < MAX_SCALE; j++) { // MAX_SCALE -1 should cause overflow
                 int scaleFactor = j;
 
                 failures+=testScalbCase(value,
                                         scaleFactor,
-                                        (Tests.ilogb(value) +j > DoubleConsts.MAX_EXPONENT ) ?
+                                        (Tests.ilogb(value) +j > Double.MAX_EXPONENT ) ?
                                         Math.copySign(infinityD, value) : // overflow
                                         // calculate right answer
                                         twoToTheMaxExp*(twoToTheMaxExp*(scale*value)) );
                 scale*=2.0;
             }

@@ -1343,11 +1346,11 @@
         // multiplies, the value would round twice if the multiplies
         // were done in the wrong order.
 
         double value = 0x1.000000000000bP-1;
         expected     = 0x0.2000000000001P-1022;
-        for(int i = 0; i < DoubleConsts.MAX_EXPONENT+2; i++) {
+        for(int i = 0; i < Double.MAX_EXPONENT+2; i++) {
             failures+=testScalbCase(value,
                                     -1024-i,
                                     expected);
             value *=2.0;
         }

@@ -1399,11 +1402,11 @@
                                   +1.0f,
                                   +2.0f,
                                   +16.0f,
                                   +Float.MIN_VALUE,
                                   +Float_MAX_SUBNORMAL,
-                                  +FloatConsts.MIN_NORMAL,
+                                  +Float.MIN_NORMAL,
                                   +Float.MAX_VALUE
         };
 
         float [] specialResults = {NaNf,
                                    Float.POSITIVE_INFINITY,

@@ -1422,35 +1425,35 @@
             failures += testUlpCase(specialValues[i], specialResults[i]);
         }
 
 
         // Normal exponent tests
-        for(int i = FloatConsts.MIN_EXPONENT; i <= FloatConsts.MAX_EXPONENT; i++) {
+        for(int i = Float.MIN_EXPONENT; i <= Float.MAX_EXPONENT; i++) {
             float expected;
 
             // Create power of two
             float po2 = powerOfTwoF(i);
-            expected = Math.scalb(1.0f, i - (FloatConsts.SIGNIFICAND_WIDTH-1));
+            expected = Math.scalb(1.0f, i - (FloatUtils.SIGNIFICAND_WIDTH-1));
 
             failures += testUlpCase(po2, expected);
 
             // Generate some random bit patterns for the significand
             for(int j = 0; j < 10; j++) {
                 int randSignif = rand.nextInt();
                 float randFloat;
 
                 randFloat = Float.intBitsToFloat( // Exponent
                                                  (Float.floatToIntBits(po2)&
-                                                  (~FloatConsts.SIGNIF_BIT_MASK)) |
+                                                  (~FloatUtils.SIGNIF_BIT_MASK)) |
                                                  // Significand
                                                  (randSignif &
-                                                  FloatConsts.SIGNIF_BIT_MASK) );
+                                                  FloatUtils.SIGNIF_BIT_MASK) );
 
                 failures += testUlpCase(randFloat, expected);
             }
 
-            if (i > FloatConsts.MIN_EXPONENT) {
+            if (i > Float.MIN_EXPONENT) {
                 float po2minus = Math.nextAfter(po2,
                                                    Float.NEGATIVE_INFINITY);
                 failures += testUlpCase(po2minus, expected/2.0f);
             }
         }

@@ -1466,11 +1469,11 @@
          * needed.
          */
 
         float top=Float.MIN_VALUE;
         for( int i = 1;
-            i < FloatConsts.SIGNIFICAND_WIDTH;
+            i < FloatUtils.SIGNIFICAND_WIDTH;
             i++, top *= 2.0f) {
 
             failures += testUlpCase(top, Float.MIN_VALUE);
 
             // Test largest value in next smaller binade

@@ -1504,11 +1507,11 @@
                                   +1.0d,
                                   +2.0d,
                                   +16.0d,
                                   +Double.MIN_VALUE,
                                   +Double_MAX_SUBNORMAL,
-                                  +DoubleConsts.MIN_NORMAL,
+                                  +Double.MIN_NORMAL,
                                   +Double.MAX_VALUE
         };
 
         double [] specialResults = {NaNf,
                                    Double.POSITIVE_INFINITY,

@@ -1527,35 +1530,35 @@
             failures += testUlpCase(specialValues[i], specialResults[i]);
         }
 
 
         // Normal exponent tests
-        for(int i = DoubleConsts.MIN_EXPONENT; i <= DoubleConsts.MAX_EXPONENT; i++) {
+        for(int i = Double.MIN_EXPONENT; i <= Double.MAX_EXPONENT; i++) {
             double expected;
 
             // Create power of two
             double po2 = powerOfTwoD(i);
-            expected = Math.scalb(1.0, i - (DoubleConsts.SIGNIFICAND_WIDTH-1));
+            expected = Math.scalb(1.0, i - (DoubleUtils.SIGNIFICAND_WIDTH-1));
 
             failures += testUlpCase(po2, expected);
 
             // Generate some random bit patterns for the significand
             for(int j = 0; j < 10; j++) {
                 long randSignif = rand.nextLong();
                 double randDouble;
 
                 randDouble = Double.longBitsToDouble( // Exponent
                                                  (Double.doubleToLongBits(po2)&
-                                                  (~DoubleConsts.SIGNIF_BIT_MASK)) |
+                                                  (~DoubleUtils.SIGNIF_BIT_MASK)) |
                                                  // Significand
                                                  (randSignif &
-                                                  DoubleConsts.SIGNIF_BIT_MASK) );
+                                                  DoubleUtils.SIGNIF_BIT_MASK) );
 
                 failures += testUlpCase(randDouble, expected);
             }
 
-            if (i > DoubleConsts.MIN_EXPONENT) {
+            if (i > Double.MIN_EXPONENT) {
                 double po2minus = Math.nextAfter(po2,
                                                     Double.NEGATIVE_INFINITY);
                 failures += testUlpCase(po2minus, expected/2.0f);
             }
         }

@@ -1571,11 +1574,11 @@
          * needed.
          */
 
         double top=Double.MIN_VALUE;
         for( int i = 1;
-            i < DoubleConsts.SIGNIFICAND_WIDTH;
+            i < DoubleUtils.SIGNIFICAND_WIDTH;
             i++, top *= 2.0f) {
 
             failures += testUlpCase(top, Double.MIN_VALUE);
 
             // Test largest value in next smaller binade

@@ -1605,21 +1608,21 @@
         int failures = 0;
         float testCases [][] = {
             {NaNf,                      NaNf},
             {-infinityF,                -1.0f},
             {-Float.MAX_VALUE,          -1.0f},
-            {-FloatConsts.MIN_NORMAL,   -1.0f},
+            {-Float.MIN_NORMAL,         -1.0f},
             {-1.0f,                     -1.0f},
             {-2.0f,                     -1.0f},
             {-Float_MAX_SUBNORMAL,      -1.0f},
             {-Float.MIN_VALUE,          -1.0f},
             {-0.0f,                     -0.0f},
             {+0.0f,                     +0.0f},
             {Float.MIN_VALUE,            1.0f},
             {Float_MAX_SUBNORMALmm,      1.0f},
             {Float_MAX_SUBNORMAL,        1.0f},
-            {FloatConsts.MIN_NORMAL,     1.0f},
+            {Float.MIN_NORMAL,           1.0f},
             {1.0f,                       1.0f},
             {2.0f,                       1.0f},
             {Float_MAX_VALUEmm,          1.0f},
             {Float.MAX_VALUE,            1.0f},
             {infinityF,                  1.0f}

@@ -1639,21 +1642,21 @@
         int failures = 0;
         double testCases [][] = {
             {NaNd,                      NaNd},
             {-infinityD,                -1.0},
             {-Double.MAX_VALUE,         -1.0},
-            {-DoubleConsts.MIN_NORMAL,  -1.0},
+            {-Double.MIN_NORMAL,        -1.0},
             {-1.0,                      -1.0},
             {-2.0,                      -1.0},
             {-Double_MAX_SUBNORMAL,     -1.0},
             {-Double.MIN_VALUE,         -1.0d},
             {-0.0d,                     -0.0d},
             {+0.0d,                     +0.0d},
             {Double.MIN_VALUE,           1.0},
             {Double_MAX_SUBNORMALmm,     1.0},
             {Double_MAX_SUBNORMAL,       1.0},
-            {DoubleConsts.MIN_NORMAL,    1.0},
+            {Double.MIN_NORMAL,          1.0},
             {1.0,                        1.0},
             {2.0,                        1.0},
             {Double_MAX_VALUEmm,         1.0},
             {Double.MAX_VALUE,           1.0},
             {infinityD,                  1.0}