--- old/test/java/lang/Double/BitwiseConversion.java 2014-08-20 17:35:24.000000000 +0800 +++ new/test/java/lang/Double/BitwiseConversion.java 2014-08-20 17:35:24.000000000 +0800 @@ -25,21 +25,23 @@ * @test * @bug 5037596 * @summary Verify bitwise conversion works for non-canonical NaN values + * @library ../Math + * @build DoubleConsts + * @run main BitwiseConversion * @author Joseph D. Darcy */ import static java.lang.Double.*; -import static sun.misc.DoubleConsts.*; public class BitwiseConversion { static int testNanCase(long x) { int errors = 0; // Strip out sign and exponent bits - long y = x & SIGNIF_BIT_MASK; + long y = x & DoubleConsts.SIGNIF_BIT_MASK; double values[] = { - longBitsToDouble(EXP_BIT_MASK | y), - longBitsToDouble(SIGN_BIT_MASK | EXP_BIT_MASK | y) + longBitsToDouble(DoubleConsts.EXP_BIT_MASK | y), + longBitsToDouble(DoubleConsts.SIGN_BIT_MASK | DoubleConsts.EXP_BIT_MASK | y) }; for(double value: values) { @@ -60,7 +62,7 @@ public static void main(String... argv) { int errors = 0; - for (int i = 0; i < SIGNIFICAND_WIDTH-1; i++) { + for (int i = 0; i < DoubleConsts.SIGNIFICAND_WIDTH-1; i++) { errors += testNanCase(1L< 710, expm1(x) should be infinity - for(int i = 10; i <= DoubleConsts.MAX_EXPONENT; i++) { + for(int i = 10; i <= Double.MAX_EXPONENT; i++) { double d = Math.scalb(2, i); failures += testExpm1Case(d, infinityD); } @@ -116,7 +114,7 @@ reachedLimit); } - for(int i = 7; i <= DoubleConsts.MAX_EXPONENT; i++) { + for(int i = 7; i <= Double.MAX_EXPONENT; i++) { double d = -Math.scalb(2, i); failures += testExpm1CaseWithUlpDiff(d, -1.0, 1, reachedLimit); } --- old/test/java/lang/Math/HyperbolicTests.java 2014-08-20 17:35:28.000000000 +0800 +++ new/test/java/lang/Math/HyperbolicTests.java 2014-08-20 17:35:28.000000000 +0800 @@ -28,8 +28,6 @@ * @author Joseph D. Darcy */ -import sun.misc.DoubleConsts; - public class HyperbolicTests { private HyperbolicTests(){} @@ -342,7 +340,7 @@ // sinh(x) overflows for values greater than 710; in // particular, it overflows for all 2^i, i > 10. - for(int i = 10; i <= DoubleConsts.MAX_EXPONENT; i++) { + for(int i = 10; i <= Double.MAX_EXPONENT; i++) { double d = Math.scalb(2.0, i); // Result and expected are the same. @@ -701,7 +699,7 @@ // cosh(x) overflows for values greater than 710; in // particular, it overflows for all 2^i, i > 10. - for(int i = 10; i <= DoubleConsts.MAX_EXPONENT; i++) { + for(int i = 10; i <= Double.MAX_EXPONENT; i++) { double d = Math.scalb(2.0, i); // Result and expected are the same. @@ -996,7 +994,7 @@ failures += testTanhCaseWithUlpDiff(i, 1.0, 2.5); } - for(int i = 5; i <= DoubleConsts.MAX_EXPONENT; i++) { + for(int i = 5; i <= Double.MAX_EXPONENT; i++) { double d = Math.scalb(2.0, i); failures += testTanhCaseWithUlpDiff(d, 1.0, 2.5); --- old/test/java/lang/Math/HypotTests.java 2014-08-20 17:35:29.000000000 +0800 +++ new/test/java/lang/Math/HypotTests.java 2014-08-20 17:35:29.000000000 +0800 @@ -28,8 +28,6 @@ * @author Joseph D. Darcy */ -import sun.misc.DoubleConsts; - public class HypotTests { private HypotTests(){} @@ -87,7 +85,7 @@ // Verify hypot(x, 0.0) is close to x over the entire exponent // range. for(int i = DoubleConsts.MIN_SUB_EXPONENT; - i <= DoubleConsts.MAX_EXPONENT; + i <= Double.MAX_EXPONENT; i++) { double input = Math.scalb(2, i); failures += testHypotCase(input, 0.0, input); @@ -125,7 +123,7 @@ for(int i = 0; i < 1000; i++) { double d = rand.nextDouble(); // Scale d to have an exponent equal to MAX_EXPONENT -15 - d = Math.scalb(d, DoubleConsts.MAX_EXPONENT + d = Math.scalb(d, Double.MAX_EXPONENT -15 - Tests.ilogb(d)); for(int j = 0; j <= 13; j += 1) { failures += testHypotCase(3*d, 4*d, 5*d, 2.5); --- old/test/java/lang/Math/IeeeRecommendedTests.java 2014-08-20 17:35:30.000000000 +0800 +++ new/test/java/lang/Math/IeeeRecommendedTests.java 2014-08-20 17:35:29.000000000 +0800 @@ -28,9 +28,6 @@ * @author Joseph D. Darcy */ -import sun.misc.DoubleConsts; -import sun.misc.FloatConsts; - public class IeeeRecommendedTests { private IeeeRecommendedTests(){} @@ -54,7 +51,7 @@ * 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) << + return Double.longBitsToDouble((((long)n + (long)Double.MAX_EXPONENT) << (DoubleConsts.SIGNIFICAND_WIDTH-1)) & DoubleConsts.EXP_BIT_MASK); } @@ -63,7 +60,7 @@ * Returns a floating-point power of two in the normal range. */ static float powerOfTwoF(int n) { - return Float.intBitsToFloat(((n + FloatConsts.MAX_EXPONENT) << + return Float.intBitsToFloat(((n + Float.MAX_EXPONENT) << (FloatConsts.SIGNIFICAND_WIDTH-1)) & FloatConsts.EXP_BIT_MASK); } @@ -129,7 +126,7 @@ +16.0f, +Float.MIN_VALUE, +Float_MAX_SUBNORMAL, - +FloatConsts.MIN_NORMAL, + +Float.MIN_NORMAL, +Float.MAX_VALUE }; @@ -139,10 +136,10 @@ 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 @@ -152,7 +149,7 @@ // 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 @@ -175,7 +172,7 @@ 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); @@ -199,13 +196,13 @@ 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 @@ -217,7 +214,7 @@ (rand.nextInt() & mask ) ) ; failures += testGetExponentCase(randFloat, - FloatConsts.MIN_EXPONENT - 1); + Float.MIN_EXPONENT - 1); } } } @@ -236,7 +233,7 @@ +16.0, +Double.MIN_VALUE, +Double_MAX_SUBNORMAL, - +DoubleConsts.MIN_NORMAL, + +Double.MIN_NORMAL, +Double.MAX_VALUE }; @@ -246,10 +243,10 @@ 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 @@ -259,7 +256,7 @@ // 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 @@ -282,7 +279,7 @@ 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); @@ -306,13 +303,13 @@ 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 @@ -324,7 +321,7 @@ (rand.nextLong() & mask ) ) ; failures += testGetExponentCase(randFloat, - DoubleConsts.MIN_EXPONENT - 1); + Double.MIN_EXPONENT - 1); } } } @@ -400,15 +397,15 @@ {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}, @@ -472,15 +469,15 @@ {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}, @@ -529,15 +526,15 @@ {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} @@ -567,15 +564,15 @@ {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} @@ -607,16 +604,16 @@ {-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}, }; @@ -646,16 +643,16 @@ {-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}, }; @@ -689,7 +686,7 @@ -Float.MAX_VALUE, -3.0f, -1.0f, - -FloatConsts.MIN_NORMAL, + -Float.MIN_NORMAL, -Float_MAX_SUBNORMALmm, -Float_MAX_SUBNORMAL, -Float.MIN_VALUE, @@ -698,7 +695,7 @@ Float.MIN_VALUE, Float_MAX_SUBNORMALmm, Float_MAX_SUBNORMAL, - FloatConsts.MIN_NORMAL, + Float.MIN_NORMAL, 1.0f, 3.0f, Float_MAX_VALUEmm, @@ -739,7 +736,7 @@ -Double.MAX_VALUE, -3.0d, -1.0d, - -DoubleConsts.MIN_NORMAL, + -Double.MIN_NORMAL, -Double_MAX_SUBNORMALmm, -Double_MAX_SUBNORMAL, -Double.MIN_VALUE, @@ -748,7 +745,7 @@ Double.MIN_VALUE, Double_MAX_SUBNORMALmm, Double_MAX_SUBNORMAL, - DoubleConsts.MIN_NORMAL, + Double.MIN_NORMAL, 1.0d, 3.0d, Double_MAX_VALUEmm, @@ -790,7 +787,7 @@ Float.MIN_VALUE, Float_MAX_SUBNORMALmm, Float_MAX_SUBNORMAL, - FloatConsts.MIN_NORMAL, + Float.MIN_NORMAL, 1.0f, 3.0f, Float_MAX_VALUEmm, @@ -801,7 +798,7 @@ -Float.MAX_VALUE, -3.0f, -1.0f, - -FloatConsts.MIN_NORMAL, + -Float.MIN_NORMAL, -Float_MAX_SUBNORMALmm, -Float_MAX_SUBNORMAL, -Float.MIN_VALUE, @@ -864,7 +861,7 @@ Double.MIN_VALUE, Double_MAX_SUBNORMALmm, Double_MAX_SUBNORMAL, - DoubleConsts.MIN_NORMAL, + Double.MIN_NORMAL, 1.0d, 3.0d, Double_MAX_VALUEmm, @@ -875,7 +872,7 @@ -Double.MAX_VALUE, -3.0d, -1.0d, - -DoubleConsts.MIN_NORMAL, + -Double.MIN_NORMAL, -Double_MAX_SUBNORMALmm, -Double_MAX_SUBNORMAL, -Double.MIN_VALUE, @@ -964,7 +961,7 @@ public static int testFloatScalb() { int failures=0; - int MAX_SCALE = FloatConsts.MAX_EXPONENT + -FloatConsts.MIN_EXPONENT + + int MAX_SCALE = Float.MAX_EXPONENT + -Float.MIN_EXPONENT + FloatConsts.SIGNIFICAND_WIDTH + 1; @@ -988,7 +985,7 @@ 3.0f*Float.MIN_VALUE, Float_MAX_SUBNORMALmm, Float_MAX_SUBNORMAL, - FloatConsts.MIN_NORMAL, + Float.MIN_NORMAL, 1.0f, 2.0f, 3.0f, @@ -998,8 +995,8 @@ }; int [] oneMultiplyScalingFactors = { - FloatConsts.MIN_EXPONENT, - FloatConsts.MIN_EXPONENT+1, + Float.MIN_EXPONENT, + Float.MIN_EXPONENT+1, -3, -2, -1, @@ -1007,8 +1004,8 @@ 1, 2, 3, - FloatConsts.MAX_EXPONENT-1, - FloatConsts.MAX_EXPONENT + Float.MAX_EXPONENT-1, + Float.MAX_EXPONENT }; int [] manyScalingFactors = { @@ -1018,14 +1015,14 @@ -MAX_SCALE, -MAX_SCALE+1, - 2*FloatConsts.MIN_EXPONENT-1, // -253 - 2*FloatConsts.MIN_EXPONENT, // -252 - 2*FloatConsts.MIN_EXPONENT+1, // -251 + 2*Float.MIN_EXPONENT-1, // -253 + 2*Float.MIN_EXPONENT, // -252 + 2*Float.MIN_EXPONENT+1, // -251 - FloatConsts.MIN_EXPONENT - FloatConsts.SIGNIFICAND_WIDTH, + Float.MIN_EXPONENT - FloatConsts.SIGNIFICAND_WIDTH, FloatConsts.MIN_SUB_EXPONENT, - -FloatConsts.MAX_EXPONENT, // -127 - FloatConsts.MIN_EXPONENT, // -126 + -Float.MAX_EXPONENT, // -127 + Float.MIN_EXPONENT, // -126 -2, -1, @@ -1033,13 +1030,13 @@ 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, @@ -1086,7 +1083,7 @@ // 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 @@ -1094,12 +1091,12 @@ 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)) ); @@ -1172,7 +1169,7 @@ public static int testDoubleScalb() { int failures=0; - int MAX_SCALE = DoubleConsts.MAX_EXPONENT + -DoubleConsts.MIN_EXPONENT + + int MAX_SCALE = Double.MAX_EXPONENT + -Double.MIN_EXPONENT + DoubleConsts.SIGNIFICAND_WIDTH + 1; @@ -1195,7 +1192,7 @@ 3.0d*Double.MIN_VALUE, Double_MAX_SUBNORMALmm, Double_MAX_SUBNORMAL, - DoubleConsts.MIN_NORMAL, + Double.MIN_NORMAL, 1.0d, 2.0d, 3.0d, @@ -1205,8 +1202,8 @@ }; int [] oneMultiplyScalingFactors = { - DoubleConsts.MIN_EXPONENT, - DoubleConsts.MIN_EXPONENT+1, + Double.MIN_EXPONENT, + Double.MIN_EXPONENT+1, -3, -2, -1, @@ -1214,8 +1211,8 @@ 1, 2, 3, - DoubleConsts.MAX_EXPONENT-1, - DoubleConsts.MAX_EXPONENT + Double.MAX_EXPONENT-1, + Double.MAX_EXPONENT }; int [] manyScalingFactors = { @@ -1225,15 +1222,15 @@ -MAX_SCALE, -MAX_SCALE+1, - 2*DoubleConsts.MIN_EXPONENT-1, // -2045 - 2*DoubleConsts.MIN_EXPONENT, // -2044 - 2*DoubleConsts.MIN_EXPONENT+1, // -2043 + 2*Double.MIN_EXPONENT-1, // -2045 + 2*Double.MIN_EXPONENT, // -2044 + 2*Double.MIN_EXPONENT+1, // -2043 - DoubleConsts.MIN_EXPONENT, // -1022 - DoubleConsts.MIN_EXPONENT - DoubleConsts.SIGNIFICAND_WIDTH, + Double.MIN_EXPONENT, // -1022 + Double.MIN_EXPONENT - DoubleConsts.SIGNIFICAND_WIDTH, DoubleConsts.MIN_SUB_EXPONENT, - -DoubleConsts.MAX_EXPONENT, // -1023 - DoubleConsts.MIN_EXPONENT, // -1022 + -Double.MAX_EXPONENT, // -1023 + Double.MIN_EXPONENT, // -1022 -2, -1, @@ -1241,13 +1238,13 @@ 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, @@ -1294,7 +1291,7 @@ // 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 @@ -1302,12 +1299,12 @@ 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)) ); @@ -1345,7 +1342,7 @@ 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); @@ -1401,7 +1398,7 @@ +16.0f, +Float.MIN_VALUE, +Float_MAX_SUBNORMAL, - +FloatConsts.MIN_NORMAL, + +Float.MIN_NORMAL, +Float.MAX_VALUE }; @@ -1424,7 +1421,7 @@ // 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 @@ -1448,7 +1445,7 @@ 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); @@ -1506,7 +1503,7 @@ +16.0d, +Double.MIN_VALUE, +Double_MAX_SUBNORMAL, - +DoubleConsts.MIN_NORMAL, + +Double.MIN_NORMAL, +Double.MAX_VALUE }; @@ -1529,7 +1526,7 @@ // 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 @@ -1553,7 +1550,7 @@ 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); @@ -1607,7 +1604,7 @@ {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}, @@ -1617,7 +1614,7 @@ {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}, @@ -1641,7 +1638,7 @@ {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}, @@ -1651,7 +1648,7 @@ {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}, --- old/test/java/lang/Math/Log10Tests.java 2014-08-20 17:35:30.000000000 +0800 +++ new/test/java/lang/Math/Log10Tests.java 2014-08-20 17:35:30.000000000 +0800 @@ -28,8 +28,6 @@ * @author Joseph D. Darcy */ -import sun.misc.DoubleConsts; - public class Log10Tests { private Log10Tests(){} @@ -70,7 +68,7 @@ {Double.NEGATIVE_INFINITY, NaNd}, {-8.0, NaNd}, {-1.0, NaNd}, - {-DoubleConsts.MIN_NORMAL, NaNd}, + {-Double.MIN_NORMAL, NaNd}, {-Double.MIN_VALUE, NaNd}, {-0.0, -infinityD}, {+0.0, -infinityD}, --- old/test/java/lang/Math/Log1pTests.java 2014-08-20 17:35:31.000000000 +0800 +++ new/test/java/lang/Math/Log1pTests.java 2014-08-20 17:35:31.000000000 +0800 @@ -28,8 +28,6 @@ * @author Joseph D. Darcy */ -import sun.misc.DoubleConsts; - public class Log1pTests { private Log1pTests(){} @@ -93,7 +91,7 @@ } // For x > 2^53 log1p(x) ~= log(x) - for(int i = 53; i <= DoubleConsts.MAX_EXPONENT; i++) { + for(int i = 53; i <= Double.MAX_EXPONENT; i++) { double d = Math.scalb(2, i); failures += testLog1pCaseWithUlpDiff(d, StrictMath.log(d), 2.001); } --- old/test/java/lang/Math/Rint.java 2014-08-20 17:35:32.000000000 +0800 +++ new/test/java/lang/Math/Rint.java 2014-08-20 17:35:32.000000000 +0800 @@ -27,8 +27,6 @@ * @summary Check for correct implementation of Math.rint(double) */ -import sun.misc.DoubleConsts; - public class Rint { static int testRintCase(double input, double expected) { @@ -51,8 +49,8 @@ double [][] testCases = { {0.0, 0.0}, {Double.MIN_VALUE, 0.0}, - {Math.nextDown(DoubleConsts.MIN_NORMAL), 0.0}, - {DoubleConsts.MIN_NORMAL, 0.0}, + {Math.nextDown(Double.MIN_NORMAL), 0.0}, + {Double.MIN_NORMAL, 0.0}, {0.2, 0.0}, --- old/test/java/lang/Math/Tests.java 2014-08-20 17:35:32.000000000 +0800 +++ new/test/java/lang/Math/Tests.java 2014-08-20 17:35:32.000000000 +0800 @@ -30,9 +30,6 @@ * and finally the expected result. */ -import sun.misc.FloatConsts; -import sun.misc.DoubleConsts; - public class Tests { private Tests(){}; // do not instantiate @@ -81,13 +78,13 @@ int exponent = Math.getExponent(d); switch (exponent) { - case DoubleConsts.MAX_EXPONENT+1: // NaN or infinity + case Double.MAX_EXPONENT+1: // NaN or infinity if( Double.isNaN(d) ) return (1<<30); // 2^30 else // infinite value return (1<<28); // 2^28 - case DoubleConsts.MIN_EXPONENT-1: // zero or subnormal + case Double.MIN_EXPONENT-1: // zero or subnormal if(d == 0.0) { return -(1<<28); // -(2^28) } @@ -117,14 +114,14 @@ } exponent++; assert( exponent >= - DoubleConsts.MIN_EXPONENT - (DoubleConsts.SIGNIFICAND_WIDTH-1) && - exponent < DoubleConsts.MIN_EXPONENT); + Double.MIN_EXPONENT - (DoubleConsts.SIGNIFICAND_WIDTH-1) && + exponent < Double.MIN_EXPONENT); return exponent; } default: - assert( exponent >= DoubleConsts.MIN_EXPONENT && - exponent <= DoubleConsts.MAX_EXPONENT); + assert( exponent >= Double.MIN_EXPONENT && + exponent <= Double.MAX_EXPONENT); return exponent; } } @@ -150,13 +147,13 @@ int exponent = Math.getExponent(f); switch (exponent) { - case FloatConsts.MAX_EXPONENT+1: // NaN or infinity + case Float.MAX_EXPONENT+1: // NaN or infinity if( Float.isNaN(f) ) return (1<<30); // 2^30 else // infinite value return (1<<28); // 2^28 - case FloatConsts.MIN_EXPONENT-1: // zero or subnormal + case Float.MIN_EXPONENT-1: // zero or subnormal if(f == 0.0f) { return -(1<<28); // -(2^28) } @@ -186,14 +183,14 @@ } exponent++; assert( exponent >= - FloatConsts.MIN_EXPONENT - (FloatConsts.SIGNIFICAND_WIDTH-1) && - exponent < FloatConsts.MIN_EXPONENT); + Float.MIN_EXPONENT - (FloatConsts.SIGNIFICAND_WIDTH-1) && + exponent < Float.MIN_EXPONENT); return exponent; } default: - assert( exponent >= FloatConsts.MIN_EXPONENT && - exponent <= FloatConsts.MAX_EXPONENT); + assert( exponent >= Float.MIN_EXPONENT && + exponent <= Float.MAX_EXPONENT); return exponent; } } --- old/test/java/util/Formatter/BasicDouble.java 2014-08-20 17:35:33.000000000 +0800 +++ new/test/java/util/Formatter/BasicDouble.java 2014-08-20 17:35:33.000000000 +0800 @@ -36,9 +36,6 @@ import java.text.DateFormatSymbols; import java.util.*; -import sun.misc.DoubleConsts; - - import static java.util.Calendar.*; @@ -1313,12 +1310,12 @@ test("%.1a", "-0x1.0p0", -1.0); test("%.11a", "0x1.80000000000p1", 3.0); test("%.1a", "0x1.8p1", 3.0); - test("%.11a", "0x1.00000000000p-1022", DoubleConsts.MIN_NORMAL); - test("%.1a", "0x1.0p-1022", DoubleConsts.MIN_NORMAL); + test("%.11a", "0x1.00000000000p-1022", Double.MIN_NORMAL); + test("%.1a", "0x1.0p-1022", Double.MIN_NORMAL); test("%.11a", "0x1.00000000000p-1022", - Math.nextDown(DoubleConsts.MIN_NORMAL)); + Math.nextDown(Double.MIN_NORMAL)); test("%.1a", "0x1.0p-1022", - Math.nextDown(DoubleConsts.MIN_NORMAL)); + Math.nextDown(Double.MIN_NORMAL)); test("%.11a", "0x1.ffffffffffep-1023", 0x0.fffffffffffp-1022); test("%.1a", "0x1.0p-1022", 0x0.fffffffffffp-1022); test("%.30a", "0x0.000000000000100000000000000000p-1022", Double.MIN_VALUE); --- old/test/sun/misc/FloatingDecimal/OldFloatingDecimalForTest.java 2014-08-20 17:35:34.000000000 +0800 +++ new/test/sun/misc/FloatingDecimal/OldFloatingDecimalForTest.java 2014-08-20 17:35:34.000000000 +0800 @@ -23,8 +23,6 @@ //package sun.misc; -import sun.misc.DoubleConsts; -import sun.misc.FloatConsts; import java.util.regex.*; public class OldFloatingDecimalForTest{ @@ -2217,12 +2215,12 @@ // Check for overflow and update exponent accordingly. - if (exponent > DoubleConsts.MAX_EXPONENT) { // Infinite result + if (exponent > Double.MAX_EXPONENT) { // Infinite result // overflow to properly signed infinity return new OldFloatingDecimalForTest(sign * Double.POSITIVE_INFINITY); } else { // Finite return value - if (exponent <= DoubleConsts.MAX_EXPONENT && // (Usually) normal result - exponent >= DoubleConsts.MIN_EXPONENT) { + if (exponent <= Double.MAX_EXPONENT && // (Usually) normal result + exponent >= Double.MIN_EXPONENT) { // The result returned in this block cannot be a // zero or subnormal; however after the @@ -2242,7 +2240,7 @@ (DoubleConsts.SIGNIF_BIT_MASK & significand); } else { // Subnormal or zero - // (exponent < DoubleConsts.MIN_EXPONENT) + // (exponent < Double.MIN_EXPONENT) if (exponent < (DoubleConsts.MIN_SUB_EXPONENT -1 )) { // No way to round back to nonzero value @@ -2282,7 +2280,7 @@ // Now, discard the bits significand = significand >> bitsDiscarded; - significand = (( ((long)(DoubleConsts.MIN_EXPONENT -1) + // subnorm exp. + significand = (( ((long)(Double.MIN_EXPONENT -1) + // subnorm exp. (long)DoubleConsts.EXP_BIAS) << (DoubleConsts.SIGNIFICAND_WIDTH-1)) & DoubleConsts.EXP_BIT_MASK) | @@ -2350,7 +2348,7 @@ * information must be preserved (i.e. case 1). */ if ((exponent >= FloatConsts.MIN_SUB_EXPONENT-1) && - (exponent <= FloatConsts.MAX_EXPONENT ) ){ + (exponent <= Float.MAX_EXPONENT ) ){ // Outside above exponent range, the float value // will be zero or infinity. --- old/test/sun/misc/FloatingDecimal/TestFloatingDecimal.java 2014-08-20 17:35:34.000000000 +0800 +++ new/test/sun/misc/FloatingDecimal/TestFloatingDecimal.java 2014-08-20 17:35:34.000000000 +0800 @@ -58,6 +58,9 @@ * @test * @bug 7032154 * @summary unit tests of sun.misc.FloatingDecimal + * @library ../../../java/lang/Math + * @build DoubleConsts FloatConsts + * @run main TestFloatingDecimal * @author Brian Burkhalter */ public class TestFloatingDecimal { --- /dev/null 2014-08-20 17:35:35.000000000 +0800 +++ new/test/java/lang/Math/DoubleConsts.java 2014-08-20 17:35:35.000000000 +0800 @@ -0,0 +1,74 @@ +/* + * Copyright (c) 2003, 2014, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/** + * Common library for additional constants of the {@code double} type. + */ +public final class DoubleConsts { + /** + * Don't let anyone instantiate this class. + */ + private DoubleConsts() {} + + /** + * Bias used in representing a {@code double} exponent. + */ + public static final int EXP_BIAS = 1023; + + /** + * Bit mask to isolate the exponent field of a {@code double}. + */ + public static final long EXP_BIT_MASK = 0x7FF0000000000000L; + + /** + * Bit mask to isolate the sign bit of a {@code double}. + */ + public static final long SIGN_BIT_MASK = 0x8000000000000000L; + + /** + * Bit mask to isolate the significand field of a {@code double}. + */ + public static final long SIGNIF_BIT_MASK = 0x000FFFFFFFFFFFFFL; + + /** + * The number of logical bits in the significand of a + * {@code double} number, including the implicit bit. + */ + public static final int SIGNIFICAND_WIDTH = 53; + + /** + * The exponent the smallest positive {@code double} + * subnormal value would have if it could be normalized. + */ + public static final int MIN_SUB_EXPONENT = Double.MIN_EXPONENT - + (SIGNIFICAND_WIDTH - 1); + + static { + // verify bit masks cover all bit positions and that the bit + // masks are non-overlapping + assert(((SIGN_BIT_MASK | EXP_BIT_MASK | SIGNIF_BIT_MASK) == ~0L) && + (((SIGN_BIT_MASK & EXP_BIT_MASK) == 0L) && + ((SIGN_BIT_MASK & SIGNIF_BIT_MASK) == 0L) && + ((EXP_BIT_MASK & SIGNIF_BIT_MASK) == 0L))); + } +} --- /dev/null 2014-08-20 17:35:36.000000000 +0800 +++ new/test/java/lang/Math/FloatConsts.java 2014-08-20 17:35:36.000000000 +0800 @@ -0,0 +1,74 @@ +/* + * Copyright (c) 2003, 2014, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/** + * Common library for additional constants of the {@code float} type. + */ +public final class FloatConsts { + /** + * Don't let anyone instantiate this class. + */ + private FloatConsts() {} + + /** + * Bias used in representing a {@code float} exponent. + */ + public static final int EXP_BIAS = 127; + + /** + * Bit mask to isolate the exponent field of a {@code float}. + */ + public static final int EXP_BIT_MASK = 0x7F800000; + + /** + * Bit mask to isolate the sign bit of a {@code float}. + */ + public static final int SIGN_BIT_MASK = 0x80000000; + + /** + * Bit mask to isolate the significand field of a {@code float}. + */ + public static final int SIGNIF_BIT_MASK = 0x007FFFFF; + + /** + * The number of logical bits in the significand of a + * {@code float} number, including the implicit bit. + */ + public static final int SIGNIFICAND_WIDTH = 24; + + /** + * The exponent the smallest positive {@code float} subnormal + * value would have if it could be normalized. + */ + public static final int MIN_SUB_EXPONENT = Float.MIN_EXPONENT - + (SIGNIFICAND_WIDTH - 1); + + static { + // verify bit masks cover all bit positions and that the bit + // masks are non-overlapping + assert(((SIGN_BIT_MASK | EXP_BIT_MASK | SIGNIF_BIT_MASK) == ~0) && + (((SIGN_BIT_MASK & EXP_BIT_MASK) == 0) && + ((SIGN_BIT_MASK & SIGNIF_BIT_MASK) == 0) && + ((EXP_BIT_MASK & SIGNIF_BIT_MASK) == 0))); + } +}