Emulate Float.intBitsToFloat, Float.floatToIntBits, Double.longBitsToDouble, and Double.doubleToLongBits
Review at http://gwt-code-reviews.appspot.com/1630803
Review by: cromwellian@google.com
git-svn-id: https://google-web-toolkit.googlecode.com/svn/trunk@10840 8db76d5a-ed1c-0410-87a9-c151d255dfc7
diff --git a/dev/core/src/com/google/gwt/dev/js/JsToStringGenerationVisitor.java b/dev/core/src/com/google/gwt/dev/js/JsToStringGenerationVisitor.java
index 93588fa..564191c 100644
--- a/dev/core/src/com/google/gwt/dev/js/JsToStringGenerationVisitor.java
+++ b/dev/core/src/com/google/gwt/dev/js/JsToStringGenerationVisitor.java
@@ -767,6 +767,12 @@
@Override
public boolean visit(JsNumberLiteral x, JsContext ctx) {
double dvalue = x.getValue();
+ if (dvalue == 0.0 && 1.0 / dvalue == Double.NEGATIVE_INFINITY) {
+ // Negative zero is distinct from 0.0 and (integer) 0
+ p.print("-0.");
+ return false;
+ }
+
long lvalue = (long) dvalue;
if (lvalue == dvalue) {
p.print(Long.toString(lvalue));
diff --git a/user/super/com/google/gwt/emul/java/lang/Double.java b/user/super/com/google/gwt/emul/java/lang/Double.java
index 95b0605..3397187 100644
--- a/user/super/com/google/gwt/emul/java/lang/Double.java
+++ b/user/super/com/google/gwt/emul/java/lang/Double.java
@@ -22,16 +22,68 @@
public static final double MAX_VALUE = 1.7976931348623157e+308;
public static final double MIN_VALUE = 4.9e-324;
public static final double MIN_NORMAL = 2.2250738585072014e-308;
- public static final int MAX_EXPONENT = 1023;
+ public static final int MAX_EXPONENT = 1023;
// ==Math.getExponent(Double.MAX_VALUE);
- public static final int MIN_EXPONENT = -1022;
- // ==Math.getExponent(Double.MIN_NORMAL);;
+ public static final int MIN_EXPONENT = -1022;
+ // ==Math.getExponent(Double.MIN_NORMAL);
public static final double NaN = 0d / 0d;
public static final double NEGATIVE_INFINITY = -1d / 0d;
public static final double POSITIVE_INFINITY = 1d / 0d;
public static final int SIZE = 64;
+ // 2^512, 2^-512
+ private static final double POWER_512 = 1.3407807929942597E154;
+ private static final double POWER_MINUS_512 = 7.458340731200207E-155;
+ // 2^256, 2^-256
+ private static final double POWER_256 = 1.157920892373162E77;
+ private static final double POWER_MINUS_256 = 8.636168555094445E-78;
+ // 2^128, 2^-128
+ private static final double POWER_128 = 3.4028236692093846E38;
+ private static final double POWER_MINUS_128 = 2.9387358770557188E-39;
+ // 2^64, 2^-64
+ private static final double POWER_64 = 18446744073709551616.0;
+ private static final double POWER_MINUS_64 = 5.421010862427522E-20;
+ // 2^52, 2^-52
+ private static final double POWER_52 = 4503599627370496.0;
+ private static final double POWER_MINUS_52 = 2.220446049250313E-16;
+ // 2^32, 2^-32
+ private static final double POWER_32 = 4294967296.0;
+ private static final double POWER_MINUS_32 = 2.3283064365386963E-10;
+ // 2^31
+ private static final double POWER_31 = 2147483648.0;
+ // 2^20, 2^-20
+ private static final double POWER_20 = 1048576.0;
+ private static final double POWER_MINUS_20 = 9.5367431640625E-7;
+ // 2^16, 2^-16
+ private static final double POWER_16 = 65536.0;
+ private static final double POWER_MINUS_16 = 0.0000152587890625;
+ // 2^8, 2^-8
+ private static final double POWER_8 = 256.0;
+ private static final double POWER_MINUS_8 = 0.00390625;
+ // 2^4, 2^-4
+ private static final double POWER_4 = 16.0;
+ private static final double POWER_MINUS_4 = 0.0625;
+ // 2^2, 2^-2
+ private static final double POWER_2 = 4.0;
+ private static final double POWER_MINUS_2 = 0.25;
+ // 2^1, 2^-1
+ private static final double POWER_1 = 2.0;
+ private static final double POWER_MINUS_1 = 0.5;
+ // 2^-1022 (smallest double non-denorm)
+ private static final double POWER_MINUS_1022 = 2.2250738585072014E-308;
+
+ private static final double[] powers = {
+ POWER_512, POWER_256, POWER_128, POWER_64, POWER_32, POWER_16, POWER_8,
+ POWER_4, POWER_2, POWER_1
+ };
+
+ private static final double[] invPowers = {
+ POWER_MINUS_512, POWER_MINUS_256, POWER_MINUS_128, POWER_MINUS_64,
+ POWER_MINUS_32, POWER_MINUS_16, POWER_MINUS_8, POWER_MINUS_4, POWER_MINUS_2,
+ POWER_MINUS_1
+ };
+
public static int compare(double x, double y) {
if (isNaN(x)) {
if (isNaN(y)) {
@@ -42,7 +94,7 @@
} else if (isNaN(y)) {
return -1;
}
-
+
if (x < y) {
return -1;
} else if (x > y) {
@@ -52,6 +104,85 @@
}
}
+ public static long doubleToLongBits(double value) {
+ if (isNaN(value)) {
+ return 0x7ff8000000000000L;
+ }
+
+ boolean negative = false;
+ if (value == 0.0) {
+ if (1.0 / value == NEGATIVE_INFINITY) {
+ return 0x8000000000000000L; // -0.0
+ } else {
+ return 0x0L;
+ }
+ }
+ if (value < 0.0) {
+ negative = true;
+ value = -value;
+ }
+ if (isInfinite(value)) {
+ if (negative) {
+ return 0xfff0000000000000L;
+ } else {
+ return 0x7ff0000000000000L;
+ }
+ }
+
+ int exp = 0;
+
+ // Scale d by powers of 2 into the range [1.0, 2.0)
+ // If the exponent would go below -1023, scale into (0.0, 1.0) instead
+ if (value < 1.0) {
+ int bit = 512;
+ for (int i = 0; i < 10; i++, bit >>= 1) {
+ if (value < invPowers[i] && exp - bit >= -1023) {
+ value *= powers[i];
+ exp -= bit;
+ }
+ }
+ // Force into [1.0, 2.0) range
+ if (value < 1.0 && exp - 1 >= -1023) {
+ value *= 2.0;
+ exp--;
+ }
+ } else if (value >= 2.0) {
+ int bit = 512;
+ for (int i = 0; i < 10; i++, bit >>= 1) {
+ if (value >= powers[i]) {
+ value *= invPowers[i];
+ exp += bit;
+ }
+ }
+ }
+
+ if (exp > -1023) {
+ // Remove significand of non-denormalized mantissa
+ value -= 1.0;
+ } else {
+ // Insert 0 bit as significand of denormalized mantissa
+ value *= 0.5;
+ }
+
+ // Extract high 20 bits of mantissa
+ long ihi = (long) (value * POWER_20);
+
+ // Extract low 32 bits of mantissa
+ value -= ihi * POWER_MINUS_20;
+
+ long ilo = (long) (value * POWER_52);
+
+ // Exponent bits
+ ihi |= (exp + 1023) << 20;
+
+ // Sign bit
+ if (negative) {
+ ihi |= 0x80000000L;
+ }
+
+ return (ihi << 32) | ilo;
+ }
+
/**
* @skip Here for shared implementation with Arrays.hashCode
*/
@@ -67,6 +198,58 @@
return isNaN(x);
}-*/;
+ public static double longBitsToDouble(long bits) {
+ long ihi = (long) (bits >> 32);
+ long ilo = (long) (bits & 0xffffffffL);
+ if (ihi < 0) {
+ ihi += 0x100000000L;
+ }
+ if (ilo < 0) {
+ ilo += 0x100000000L;
+ }
+
+ boolean negative = (ihi & 0x80000000) != 0;
+ int exp = (int) ((ihi >> 20) & 0x7ff);
+ ihi &= 0xfffff; // remove sign bit and exponent
+
+ if (exp == 0x0) {
+ double d = (ihi * POWER_MINUS_20) + (ilo * POWER_MINUS_52);
+ d *= POWER_MINUS_1022;
+ return negative ? (d == 0.0 ? -0.0 : -d) : d;
+ } else if (exp == 0x7ff) {
+ if (ihi == 0 && ilo == 0) {
+ return negative ? Double.NEGATIVE_INFINITY : Double.POSITIVE_INFINITY;
+ } else {
+ return Double.NaN;
+ }
+ }
+
+ // Normalize exponent
+ exp -= 1023;
+
+ double d = 1.0 + (ihi * POWER_MINUS_20) + (ilo * POWER_MINUS_52);
+ if (exp > 0) {
+ int bit = 512;
+ for (int i = 0; i < 10; i++, bit >>= 1) {
+ if (exp >= bit) {
+ d *= powers[i];
+ exp -= bit;
+ }
+ }
+ } else if (exp < 0) {
+ while (exp < 0) {
+ int bit = 512;
+ for (int i = 0; i < 10; i++, bit >>= 1) {
+ if (exp <= -bit) {
+ d *= invPowers[i];
+ exp += bit;
+ }
+ }
+ }
+ }
+ return negative ? -d : d;
+ }
+
public static double parseDouble(String s) throws NumberFormatException {
return __parseAndValidateDouble(s);
}
@@ -158,5 +341,4 @@
public String toString() {
return toString(value);
}
-
}
diff --git a/user/super/com/google/gwt/emul/java/lang/Float.java b/user/super/com/google/gwt/emul/java/lang/Float.java
index b3c9576..f0a8f6d 100644
--- a/user/super/com/google/gwt/emul/java/lang/Float.java
+++ b/user/super/com/google/gwt/emul/java/lang/Float.java
@@ -29,6 +29,9 @@
public static final float POSITIVE_INFINITY = 1f / 0f;
public static final int SIZE = 32;
+ private static final long POWER_31_INT = 2147483648L;
+ private static final long POWER_32_INT = 4294967296L;
+
public static int compare(float x, float y) {
if (x < y) {
return -1;
@@ -39,6 +42,54 @@
}
}
+ public static int floatToIntBits(float value) {
+ // Return a canonical NaN
+ if (isNaN(value)) {
+ return 0x7fc00000;
+ }
+
+ if (value == 0.0f) {
+ if (1.0 / value == NEGATIVE_INFINITY) {
+ return 0x80000000; // -0.0f
+ } else {
+ return 0x0;
+ }
+ }
+ boolean negative = false;
+ if (value < 0.0) {
+ negative = true;
+ value = -value;
+ }
+ if (isInfinite(value)) {
+ if (negative) {
+ return 0xff800000;
+ } else {
+ return 0x7f800000;
+ }
+ }
+
+ // Obtain the 64-bit representation and extract its exponent and
+ // mantissa.
+ long l = Double.doubleToLongBits((double) value);
+ int exp = (int) (((l >> 52) & 0x7ff) - 1023);
+ int mantissa = (int) ((l & 0xfffffffffffffL) >> 29);
+
+ // If the number will be a denorm in the float representation
+ // (i.e., its exponent is -127 or smaller), add a leading 1 to the
+ // mantissa and shift it right to maintain an exponent of -127.
+ if (exp <= -127) {
+ mantissa = (0x800000 | mantissa) >> (-127 - exp + 1);
+ exp = -127;
+ }
+
+ // Construct the 32-bit representation
+ long bits = negative ? POWER_31_INT : 0x0L;
+ bits |= (exp + 127) << 23;
+ bits |= mantissa;
+
+ return (int) bits;
+ }
+
/**
* @skip Here for shared implementation with Arrays.hashCode.
* @param f
@@ -48,6 +99,43 @@
return (int) f;
}
+ public static float intBitsToFloat(int bits) {
+ boolean negative = (bits & 0x80000000) != 0;
+ int exp = (bits >> 23) & 0xff;
+ bits &= 0x7fffff;
+
+ if (exp == 0x0) {
+ // Handle +/- 0 here, denorms below
+ if (bits == 0) {
+ return negative ? -0.0f : 0.0f;
+ }
+ } else if (exp == 0xff) {
+ // Inf & NaN
+ if (bits == 0) {
+ return negative ? NEGATIVE_INFINITY : POSITIVE_INFINITY;
+ } else {
+ return NaN;
+ }
+ }
+
+ if (exp == 0) {
+ // Input is denormalized, renormalize by shifting left until there is a
+ // leading 1
+ exp = 1;
+ while ((bits & 0x800000) == 0) {
+ bits <<= 1;
+ exp--;
+ }
+ bits &= 0x7fffff;
+ }
+
+ // Build the bits of a 64-bit double from the incoming bits
+ long bits64 = negative ? 0x8000000000000000L : 0x0L;
+ bits64 |= ((long) (exp + 896)) << 52;
+ bits64 |= ((long) bits) << 29;
+ return (float) Double.longBitsToDouble(bits64);
+ }
+
public static native boolean isInfinite(float x) /*-{
return !isFinite(x);
}-*/;
diff --git a/user/test/com/google/gwt/emultest/java/lang/DoubleTest.java b/user/test/com/google/gwt/emultest/java/lang/DoubleTest.java
index 00520ed..ac9adb3 100644
--- a/user/test/com/google/gwt/emultest/java/lang/DoubleTest.java
+++ b/user/test/com/google/gwt/emultest/java/lang/DoubleTest.java
@@ -158,4 +158,287 @@
assertEquals(1.0d, Double.parseDouble("1.0d"), 0.0);
assertEquals(1.0d, Double.parseDouble("1.0D"), 0.0);
}
+
+ public void testDoubleBits() {
+ // special values
+ compareDoubleBits(0x0000000000000000L, 0.0);
+ compareDoubleBits(0x8000000000000000L, -0.0);
+ compareDoubleBits(0x8000000000000000L, 1.0 / Double.NEGATIVE_INFINITY);
+ compareDoubleBits(0x7ff8000000000000L, Double.NaN);
+ compareDoubleBits(0x7ff0000000000000L, Double.POSITIVE_INFINITY);
+ compareDoubleBits(0xfff0000000000000L, Double.NEGATIVE_INFINITY);
+
+ // values around 1.0 and 2.0
+ compareDoubleBits(0x3feffffffffffff7L, 0.999999999999999);
+ compareDoubleBits(0x3ff0000000000000L, 1.0);
+ compareDoubleBits(0x3ff0000000000005L, 1.000000000000001);
+ compareDoubleBits(0x3ffffffffffffffbL, 1.999999999999999);
+ compareDoubleBits(0x4000000000000000L, 2.0);
+ compareDoubleBits(0x4000000000000002L, 2.000000000000001);
+
+ // basic tests
+ compareDoubleBits(0x3fb999999999999aL, 0.1);
+ compareDoubleBits(0xbfb999999999999aL, -0.1);
+ compareDoubleBits(0x017527e6d48c1653L, 0.1234e-300);
+ compareDoubleBits(0x817527e6d48c1653L, -0.1234e-300);
+ compareDoubleBits(0x7e0795f2d9000b3fL, 0.1234e300);
+ compareDoubleBits(0xfe0795f2d9000b3fL, -0.1234e300);
+ compareDoubleBits(0x3fc999999999999aL, 0.2);
+ compareDoubleBits(0x4272c3598dd61e72L, 1289389399393.902892);
+ compareDoubleBits(0x405edd3c07ee0b0bL, 123.456789);
+ compareDoubleBits(0xc05edd3c07ee0b0bL, -123.456789);
+
+ // max value
+ compareDoubleBits(0x7fefffffffffffffL, 1.7976931348623157E308);
+ compareDoubleBits(0xffefffffffffffffL, -1.7976931348623157E308);
+ // min normalized value
+ compareDoubleBits(0x0010000000000000L, 2.2250738585072014E-308);
+ compareDoubleBits(0x8010000000000000L, -2.2250738585072014E-308);
+
+ // denormalized values
+ compareDoubleBits(0x000ff6a8ebe79958L, 2.22E-308);
+ compareDoubleBits(0x000199999999999aL, 2.2250738585072014E-309);
+ compareDoubleBits(0x800016b9f3c0e51dL, -1.234567E-310);
+ compareDoubleBits(0x000016b9f3c0e51dL, 1.234567E-310);
+ compareDoubleBits(0x00000245cb934a1cL, 1.234567E-311);
+ compareDoubleBits(0x0000003a2df52103L, 1.234567E-312);
+ compareDoubleBits(0x00000005d165501aL, 1.234567E-313);
+ compareDoubleBits(0x0000000094f08803L, 1.234567E-314);
+ compareDoubleBits(0x000000000ee4da67L, 1.234567E-315);
+
+ compareDoubleBits(0x00000000017d490aL, 1.234567E-316);
+ compareDoubleBits(0x00000000002620e7L, 1.234567E-317);
+ compareDoubleBits(0x000000000003d017L, 1.234567E-318);
+ compareDoubleBits(0x000000000000619cL, 1.234567E-319);
+ compareDoubleBits(0x00000000000009c3L, 1.234567E-320);
+ compareDoubleBits(0x00000000000000faL, 1.234567E-321);
+ compareDoubleBits(0x0000000000000019L, 1.234567E-322);
+ compareDoubleBits(0x0000000000000002L, 1.234567E-323);
+ compareDoubleBits(0x0000000000000001L, 4.9E-324);
+ compareDoubleBits(0x8000000000000001L, -4.9E-324);
+
+ // random values between 0 and 1
+ compareDoubleBits(0x3fe9b9bcd3c39dabL, 0.8039230476396616);
+ compareDoubleBits(0x3fe669d4a374efc4L, 0.700418776752024);
+ compareDoubleBits(0x3fd92b7ca312ca7eL, 0.39327922749649946);
+ compareDoubleBits(0x3fbc74aa296b7e18L, 0.11115516196468211);
+ compareDoubleBits(0x3feea888cdfcb13dL, 0.95807304603435);
+ compareDoubleBits(0x3fd88b23cfa7eadaL, 0.3834924247636714);
+ compareDoubleBits(0x3fd62865167eb9bcL, 0.3462155074766107);
+ compareDoubleBits(0x3fe5772b57e62b3fL, 0.6707970349101301);
+ compareDoubleBits(0x3fbd09988fb96be0L, 0.11342767247099017);
+ compareDoubleBits(0x3fb643296d7fa050L, 0.08696230815223882);
+ compareDoubleBits(0x3fde7f76986c1bd4L, 0.4765297401904125);
+ compareDoubleBits(0x3fef4b4433f8efacL, 0.9779377951704098);
+ compareDoubleBits(0x3fd374e530a19278L, 0.3040097212708939);
+ compareDoubleBits(0x3fc17adf98fc3368L, 0.1365622994420861);
+ compareDoubleBits(0x3fd6beb0e5a5055aL, 0.355388855230634);
+ compareDoubleBits(0x3fc3d8128b76ba20L, 0.1550315075850941);
+ compareDoubleBits(0x3fc47c5027f58900L, 0.16004373503808011);
+ compareDoubleBits(0x3fe0ba6a91eeb5a7L, 0.522755894684157);
+ compareDoubleBits(0x3fe68f019034c7b9L, 0.704956800129586);
+ compareDoubleBits(0x3fe3990dbaf329c4L, 0.6124333049167991);
+ compareDoubleBits(0x3faded6423ccf8f0L, 0.058451775903891945);
+ compareDoubleBits(0x3fe51aebf7ee4537L, 0.6595363466641747);
+ compareDoubleBits(0x3fe937bb75080f7dL, 0.7880532537242143);
+ compareDoubleBits(0x3fc693d447054de4L, 0.17638638942535956);
+ compareDoubleBits(0x3fd95091de22548eL, 0.39554259007247417);
+ compareDoubleBits(0x3fe93b21f50b1a41L, 0.788468340492564);
+ compareDoubleBits(0x3fd77d9f7da868b8L, 0.36704242011331756);
+ compareDoubleBits(0x3fcb8abae3f1c05cL, 0.2151712048539619);
+ compareDoubleBits(0x3feec9ed025ddcf3L, 0.9621491476272283);
+ compareDoubleBits(0x3fda1ac9bf0e59c0L, 0.4078850141317183);
+ compareDoubleBits(0x3fe66e66602de93eL, 0.7009765509131183);
+ compareDoubleBits(0x3fe6da2963aecb21L, 0.714131064122146);
+ compareDoubleBits(0x3fb306bb648e4ae0L, 0.07432147221542662);
+ compareDoubleBits(0x3fd06b9877b9b50eL, 0.25656711284575884);
+ compareDoubleBits(0x3fce870599f3a28cL, 0.2384955407826691);
+ compareDoubleBits(0x3fe14a5c59d8ce59L, 0.5403272394964446);
+ compareDoubleBits(0x3fb118ac2dc6a700L, 0.06678272359445359);
+ compareDoubleBits(0x3fafb0e23ecbc770L, 0.06189639107277756);
+ compareDoubleBits(0x3fe4475a31a9723aL, 0.633710000034234);
+ compareDoubleBits(0x3fdd5e0f4a0296f6L, 0.4588659498934783);
+ compareDoubleBits(0x3fefbc13bb0b2b44L, 0.991708627051914);
+ compareDoubleBits(0x3fde5c601db8b162L, 0.4743881502388573);
+ compareDoubleBits(0x3fdda64289b8cde6L, 0.4632726998272275);
+ compareDoubleBits(0x3fea18660f99c86bL, 0.8154783539487317);
+ compareDoubleBits(0x3fec39460d8a8808L, 0.8819914116359096);
+ compareDoubleBits(0x3fd6a29437ecfad4L, 0.3536730333470761);
+ compareDoubleBits(0x3fe1c31fcb975395L, 0.5550688721074147);
+ compareDoubleBits(0x3fc784448f1277b0L, 0.18372399316734578);
+ compareDoubleBits(0x3fe78d52a1f7d63cL, 0.7360013163985921);
+ compareDoubleBits(0x3feb0d9bee281702L, 0.8454112674232592);
+ compareDoubleBits(0x3fc382ec2f0ee738L, 0.15243294046177325);
+ compareDoubleBits(0x3fe616577bf4b8d5L, 0.6902272625937039);
+ compareDoubleBits(0x3fdd6ffcb6caedacL, 0.4599601540646414);
+ compareDoubleBits(0x3fdfa267b07ca0e4L, 0.49428741679231636);
+ compareDoubleBits(0x3fcdc3688fcb9f34L, 0.23252589246043842);
+ compareDoubleBits(0x3fc6bd1204233708L, 0.1776449699595377);
+ compareDoubleBits(0x3fd75236cfc8fafeL, 0.364392950930707);
+ compareDoubleBits(0x3fef34680bd4ce47L, 0.9751472693519155);
+ compareDoubleBits(0x3fc634b5d386b93cL, 0.17348358944350106);
+ compareDoubleBits(0x3feaf69abdedcf4bL, 0.8426030835675901);
+ compareDoubleBits(0x3fdcf973748a67e0L, 0.45272528057978256);
+ compareDoubleBits(0x3fec8f6155ecd410L, 0.8925024679398366);
+ compareDoubleBits(0x3fe3e8d8466d453aL, 0.6221734405063792);
+ compareDoubleBits(0x3fdfa7ff50fced6aL, 0.4946287432573714);
+ compareDoubleBits(0x3fe536d9d49d33beL, 0.6629456665628977);
+ compareDoubleBits(0x3fdfdff0e8e048aeL, 0.4980432771855118);
+ compareDoubleBits(0x3feb4abc3a80aeacL, 0.8528729574804479);
+ compareDoubleBits(0x3fbf44d011fd7950L, 0.12214374961101737);
+ compareDoubleBits(0x3fdb59c21a7ecd6aL, 0.4273534067862871);
+ compareDoubleBits(0x3fbb4128fb635888L, 0.10646301400569957);
+ compareDoubleBits(0x3fc03e9c906fa23cL, 0.12691075375120586);
+ compareDoubleBits(0x3f976c3738766d00L, 0.022873747655109078);
+ compareDoubleBits(0x3fd9a62096187b4eL, 0.4007646051194812);
+ compareDoubleBits(0x3fdcea7def3c0528L, 0.45181225168933503);
+ compareDoubleBits(0x3fe20ea23d703cb2L, 0.5642863464326153);
+ compareDoubleBits(0x3fd6f2c3edcf5bf4L, 0.35856722091324333);
+ compareDoubleBits(0x3fef2c3c9e7a6dc0L, 0.9741499991682119);
+ compareDoubleBits(0x3fcc2142c7ab8c28L, 0.21976504086987458);
+ compareDoubleBits(0x3fea41a3e626ff58L, 0.8205127234614151);
+ compareDoubleBits(0x3fe4162d28c9abe8L, 0.6277070805202785);
+ compareDoubleBits(0x3fce8826a9ca117cL, 0.23852999964232058);
+ compareDoubleBits(0x3fe07fbd24b88c67L, 0.5155931203083924);
+ compareDoubleBits(0x3fdb39c66484189aL, 0.4254013043977324);
+ compareDoubleBits(0x3fcb830d50fac7b0L, 0.21493689016420836);
+ compareDoubleBits(0x3fd927ccb62342c8L, 0.3930541781128736);
+ compareDoubleBits(0x3fb553b2448dd6d8L, 0.08330835508044332);
+ compareDoubleBits(0x3fef870d8a9f527bL, 0.9852359492748087);
+ compareDoubleBits(0x3febe929c4bac429L, 0.8722122995733389);
+ compareDoubleBits(0x3fc9cc2d6286a01cL, 0.20154349623521817);
+ compareDoubleBits(0x3fe5b506615ab5c6L, 0.6783477689220312);
+ compareDoubleBits(0x3fe26c9e0a02bdfeL, 0.5757589526673994);
+ compareDoubleBits(0x3fe6daf54806b05cL, 0.7142282873878787);
+ compareDoubleBits(0x3fefc9bbb28f362eL, 0.9933756339539224);
+ compareDoubleBits(0x3fbd455782e84968L, 0.1143393225286552);
+ compareDoubleBits(0x3fe1f09744a3d0b7L, 0.5606190052626719);
+ compareDoubleBits(0x3fb1c833b64b5470L, 0.06946109009307277);
+ compareDoubleBits(0x3fec140750dfb23bL, 0.8774448947493235);
+ compareDoubleBits(0x3fc3b30746f5e6bcL, 0.15390101399298384);
+ compareDoubleBits(0x3fe844deac963963L, 0.7584069605671114);
+ compareDoubleBits(0x3fd45d6e91a9989eL, 0.31820263123371173);
+
+ // random values throughout the double range
+ compareDoubleBits(0xcdcde6aa7873b572L, -6.297893811982062E66);
+ compareDoubleBits(0xb34ea52b6e9df882L, -1.4898867990306772E-61);
+ compareDoubleBits(0x64adf2aa312ca7e1L, 9.480996430600118E176);
+ compareDoubleBits(0x1c74aa06a5adf865L, 1.3367811675349397E-171);
+ compareDoubleBits(0xf5444671bf9627b5L, -7.610810186261922E256);
+ compareDoubleBits(0x622c8f3efa7eadb0L, 8.223166382138422E164);
+ compareDoubleBits(0x58a1947167eb9bccL, 8.86632413276402E118);
+ compareDoubleBits(0xabb95a84fcc567f2L, -4.6366137067352683E-98);
+ compareDoubleBits(0x1d0998843ee5af9aL, 8.477749983935152E-169);
+ compareDoubleBits(0x1643296db5fe8140L, 1.9557345103545524E-201);
+ compareDoubleBits(0x79fdda7486c1bd5fL, 4.2335912871234087E279);
+ compareDoubleBits(0xfa5a219d7f1df591L, -2.3716857301453343E281);
+ compareDoubleBits(0x4dd394c40a192798L, 8.248528934271815E66);
+ compareDoubleBits(0x22f5bf1fc7e19b49L, 2.853336355041256E-140);
+ compareDoubleBits(0x5afac3aa5a5055b7L, 1.8552153438817665E130);
+ compareDoubleBits(0x27b025195bb5d113L, 1.6005805986130906E-117);
+ compareDoubleBits(0x28f8a05a3fac4815L, 2.5600128085455218E-111);
+ compareDoubleBits(0x85d354a03dd6b4f3L, -1.3311552586579328E-280);
+ compareDoubleBits(0xb4780c890698f727L, -6.129954074000813E-56);
+ compareDoubleBits(0x9cc86de85e65389aL, -5.057128159830759E-170);
+ compareDoubleBits(0x0ef6b2304799f1f0L, 1.3941634112607635E-236);
+ compareDoubleBits(0xa8d75f9ffdc8a6fcL, -6.0744368561933565E-112);
+ compareDoubleBits(0xc9bddb8fa101efb6L, -1.7045710739729275E47);
+ compareDoubleBits(0x2d27a89b382a6f20L, 3.6294490400055576E-91);
+ compareDoubleBits(0x65424775e22548f8L, 5.925748939163494E179);
+ compareDoubleBits(0xc9d90fb1a1634836L, -5.722990169624538E47);
+ compareDoubleBits(0x5df67dbfda868b9eL, 4.3882436353810935E144);
+ compareDoubleBits(0x371575e91f8e02eeL, 2.4058151686870744E-43);
+ compareDoubleBits(0xf64f681f4bbb9e72L, -7.726253195850651E261);
+ compareDoubleBits(0x686b26cff0e59c06L, 9.910208820012368E194);
+ compareDoubleBits(0xb373331d05bd27ceL, -7.467486715472904E-61);
+ compareDoubleBits(0xb6d14b2b75d96425L, -1.211676991363774E-44);
+ compareDoubleBits(0x1306bb6092392b97L, 5.1516895067444726E-217);
+ compareDoubleBits(0x41ae61d47b9b50e7L, 2.548639338033516E8);
+ compareDoubleBits(0x3d0e0b31cf9d1469L, 1.3342095786138988E-14);
+ compareDoubleBits(0x8a52e2e03b19cb38L, -6.141707139267237E-259);
+ compareDoubleBits(0x1118ac38b71a9c13L, 2.603758248081968E-226);
+ compareDoubleBits(0x0fd871017d978ee5L, 2.459857504627046E-232);
+ compareDoubleBits(0xa23ad18a352e4745L, -8.590863325618324E-144);
+ compareDoubleBits(0x75783d29a0296f70L, 7.278962913424277E257);
+ compareDoubleBits(0xfde09de561656888L, -2.1734648688870485E298);
+ compareDoubleBits(0x79718077db8b1623L, 9.695260031659742E276);
+ compareDoubleBits(0x76990a379b8cde6dL, 1.971192366484015E263);
+ compareDoubleBits(0xd0c3304ff3390d67L, -1.1376138095726657E81);
+ compareDoubleBits(0xe1ca3067b1510109L, -1.1782242328468048E163);
+ compareDoubleBits(0x5a8a50c47ecfad55L, 1.425081729881992E128);
+ compareDoubleBits(0x8e18fe5072ea72a0L, -9.37063623070425E-241);
+ compareDoubleBits(0x2f08893a7893bd8dL, 4.0416231167192477E-82);
+ compareDoubleBits(0xbc6a95093efac79fL, -1.1528179597119854E-17);
+ compareDoubleBits(0xd86cdf4ec502e047L, -9.101010985774022E117);
+ compareDoubleBits(0x2705d86b787739cfL, 1.0574785023773003E-120);
+ compareDoubleBits(0xb0b2bbf87e971aa7L, -4.141881119170908E-74);
+ compareDoubleBits(0x75bff2d46caedac7L, 1.5350675559647406E259);
+ compareDoubleBits(0x7e899eea07ca0e54L, 3.4316079097255617E301);
+ compareDoubleBits(0x3b86d1277e5cf9a3L, 6.039611960807865E-22);
+ compareDoubleBits(0x2d7a243c2119b84aL, 1.2833127546095387E-89);
+ compareDoubleBits(0x5d48db16fc8faff2L, 2.3679693140335752E141);
+ compareDoubleBits(0xf9a340497a99c8efL, -8.531434157588162E277);
+ compareDoubleBits(0x2c696ba49c35c9f4L, 9.520836999385529E-95);
+ compareDoubleBits(0xd7b4d5dabdb9e964L, -3.206856786877124E114);
+ compareDoubleBits(0x73e5cde748a67e04L, 1.9514110919532497E250);
+ compareDoubleBits(0xe47b0a84bd9a821eL, -1.0700933026823467E176);
+ compareDoubleBits(0x9f46c209cda8a753L, -5.179951037444452E-158);
+ compareDoubleBits(0x7e9ffd4f0fced6b4L, 8.569252835514251E301);
+ compareDoubleBits(0xa9b6ce9893a677d6L, -9.711135665099199E-108);
+ compareDoubleBits(0x7f7fc3978e048af9L, 1.3940913327465408E306);
+ compareDoubleBits(0xda55e1fe5015d581L, -1.4812924721906427E127);
+ compareDoubleBits(0x1f44d03847f5e54dL, 4.737338914555982E-158);
+ compareDoubleBits(0x6d670848a7ecd6b5L, 1.016307848543568E219);
+ compareDoubleBits(0x1b4128e3ed8d6230L, 2.117302740808736E-177);
+ compareDoubleBits(0x207d392f837d11f6L, 3.4873269549337505E-152);
+ compareDoubleBits(0x05db0dd638766d17L, 1.8630149420804414E-280);
+ compareDoubleBits(0x669882566187b4e0L, 1.6662694932683939E186);
+ compareDoubleBits(0x73a9f7acf3c05283L, 1.452500477811838E249);
+ compareDoubleBits(0x907511ceae07965bL, -2.1713947206680943E-229);
+ compareDoubleBits(0x5bcb0f90dcf5bf4eL, 1.5366281556927236E134);
+ compareDoubleBits(0xf961e4e2cf4db80dL, -4.956276753857123E276);
+ compareDoubleBits(0x3842859a3d5c6147L, 1.0886185451514296E-37);
+ compareDoubleBits(0xd20d1f11c4dfeb10L, -1.8103414291013452E87);
+ compareDoubleBits(0xa0b1697219357d01L, -3.32451488002257E-151);
+ compareDoubleBits(0x3d104d584e508be4L, 1.44791988988344E-14);
+ compareDoubleBits(0x83fde93797118ce8L, -1.9182940419362316E-289);
+ compareDoubleBits(0x6ce719b2484189a7L, 3.9816763934214935E216);
+ compareDoubleBits(0x37061aa687d63d94L, 1.238977854703573E-43);
+ compareDoubleBits(0x649f32e062342c83L, 4.938493427207422E176);
+ compareDoubleBits(0x1553b27712375b61L, 6.135160266378285E-206);
+ compareDoubleBits(0xfc386c6b53ea4f67L, -2.3801480044660797E290);
+ compareDoubleBits(0xdf494e029758853eL, -1.0354031977895994E151);
+ compareDoubleBits(0x33985ae9143500f8L, 3.7890569411337005E-60);
+ compareDoubleBits(0xada8332b2b56b8c5L, -9.503956824431546E-89);
+ compareDoubleBits(0x9364f07f4057bfcaL, -3.0370938126636166E-215);
+ compareDoubleBits(0xb6d7aa7b00d60b8cL, -1.6581522255623348E-44);
+ compareDoubleBits(0xfe4ddda651e6c5caL, -2.500115798151869E300);
+ compareDoubleBits(0x1d45578c0ba125baL, 1.1310118263643858E-167);
+ compareDoubleBits(0x8f84ba31947a16ffL, -6.518932884318998E-234);
+ compareDoubleBits(0x11c833a9d92d51dcL, 5.230715225679756E-223);
+ compareDoubleBits(0xe0a03a901bf64771L, -2.7851790876803525E157);
+ compareDoubleBits(0x27660eb637af35f9L, 6.833565753907854E-119);
+ compareDoubleBits(0xc226f54e92c72c68L, -4.930242390758673E10);
+ compareDoubleBits(0x5175ba4e1a9989e3L, 2.6381145200142355E84);
+ }
+
+ private void compareDoubleBits(long bits, double value) {
+ assertEquals(bits, Double.doubleToLongBits(value));
+ compareDoubles(value, Double.longBitsToDouble(bits));
+
+ assertEquals(bits, Double.doubleToLongBits(Double.longBitsToDouble(bits)));
+ compareDoubles(value, Double.longBitsToDouble(Double.doubleToLongBits(value)));
+ }
+
+ private void compareDoubles(double expected, double actual) {
+ if (Double.isNaN(expected) || Double.isNaN(actual)) {
+ if (Double.isNaN(expected) && Double.isNaN(actual)) {
+ return;
+ }
+ fail("NaN");
+ }
+ // Do we need a special check for +inf == +inf and -inf == -inf?
+ assertEquals(expected, actual);
+ }
}
+
diff --git a/user/test/com/google/gwt/emultest/java/lang/FloatTest.java b/user/test/com/google/gwt/emultest/java/lang/FloatTest.java
index 2afc944..7c2b559 100644
--- a/user/test/com/google/gwt/emultest/java/lang/FloatTest.java
+++ b/user/test/com/google/gwt/emultest/java/lang/FloatTest.java
@@ -94,4 +94,269 @@
// assertEquals("Can't parse MIN_VALUE", Float.MIN_VALUE,
// Float.parseFloat(String.valueOf(Float.MIN_VALUE)), Float.MIN_VALUE);
}
+
+ public void testFloatBits() {
+ compareFloatBits(0x1, 1.401298464324817E-45F);
+ compareFloatBits(0x2, 1.401298464324817E-45F * 2.0F);
+ compareFloatBits(0x3, 1.401298464324817E-45F * 3.0F);
+ compareFloatBits(0x00ba98, 1.401298464324817E-45F * 0x00ba98);
+ compareFloatBits(8034422, 1.401298464324817E-45F * 8034422);
+ compareFloatBits(0x7fffff, 1.401298464324817E-45F * 0x7fffff);
+ compareFloatBits(0x80000001, -1.401298464324817E-45F);
+ compareFloatBits(0x80000002, -1.401298464324817E-45F * 2.0F);
+ compareFloatBits(0x80000003, -1.401298464324817E-45F * 3.0F);
+ compareFloatBits(0x8000ba98, -1.401298464324817E-45F * 0x00ba98);
+ compareFloatBits(0x807a9876, -1.401298464324817E-45F * 0x7a9876);
+ compareFloatBits(0x807fffff, -1.401298464324817E-45F * 0x7fffff);
+
+ // Very small non-denorms
+ compareFloatBits(0x00800000, 1.1754943508222875E-38F);
+ compareFloatBits(0x00800001, 1.175494490952134E-38F);
+ compareFloatBits(0x00801234, 1.176147355906663E-38F);
+ compareFloatBits(0x80800000, -1.1754943508222875E-38F);
+ compareFloatBits(0x80800001, -1.175494490952134E-38F);
+ compareFloatBits(0x80801234, -1.176147355906663E-38F);
+
+ compareFloatBits(0x0, 0.0F);
+ compareFloatBits(0x80000000, -0.0F);
+ compareFloatBits(0x80000000, 1.0F / Float.NEGATIVE_INFINITY);
+ compareFloatBits(0x7fc00000, Float.NaN);
+ compareFloatBits(0x7f800000, Float.POSITIVE_INFINITY);
+ compareFloatBits(0xff800000, Float.NEGATIVE_INFINITY);
+ compareFloatBits(0x3f800000, 1.0F);
+ compareFloatBits(0x40000000, 2.0F);
+ compareFloatBits(0x3f7ffffe, 0.9999998807907104F);
+ compareFloatBits(0x3f800001, 1.0000001192092896F);
+ compareFloatBits(0x3fffffff, 1.9999998807907104F);
+ compareFloatBits(0x40000000, 2.0F);
+ compareFloatBits(0x3dcccccd, 0.10000000149011612F);
+ compareFloatBits(0xbdcccccd, -0.10000000149011612F);
+ compareFloatBits(0x3e4ccccd, 0.20000000298023224F);
+ compareFloatBits(0xbe4ccccd, -0.20000000298023224F);
+ compareFloatBits(0x42f6e9e0, 123.456787109375F);
+ compareFloatBits(0xc2f6e9e0, -123.456787109375F);
+ // Max float
+ compareFloatBits(0x7f7fffff, 3.4028234663852886E38F);
+ compareFloatBits(0xff7fffff, -3.4028234663852886E38F);
+ compareFloatBits(0x80000001, -1.401298464324817E-45F);
+ compareFloatBits(0x3e4cdcd4, 0.2000611424446106F);
+ compareFloatBits(0x3f4ef68e, 0.8084496259689331F);
+ compareFloatBits(0x3dd77088, 0.10519510507583618F);
+ compareFloatBits(0x3e16156c, 0.14656609296798706F);
+ compareFloatBits(0x3ea3776c, 0.3192704916000366F);
+ compareFloatBits(0x3f510cbb, 0.816600501537323F);
+ compareFloatBits(0x3ed6e3d6, 0.4197070002555847F);
+ compareFloatBits(0x3f2209e6, 0.6329635381698608F);
+ compareFloatBits(0x3f20fdd3, 0.6288730502128601F);
+ compareFloatBits(0x3ecd6df2, 0.4012294411659241F);
+ compareFloatBits(0x3f1a107a, 0.6018139123916626F);
+ compareFloatBits(0x3f47e6d3, 0.7808658480644226F);
+ compareFloatBits(0x3da82010, 0.08209240436553955F);
+ compareFloatBits(0x3d1c0c20, 0.038097500801086426F);
+ compareFloatBits(0x3f0adc42, 0.5424233675003052F);
+ compareFloatBits(0x3f5fae9f, 0.8737582564353943F);
+ compareFloatBits(0x3f4eba38, 0.8075289726257324F);
+ compareFloatBits(0x3f23d86a, 0.6400209665298462F);
+ compareFloatBits(0x3ea11a1a, 0.3146522641181946F);
+ compareFloatBits(0x3e7a8824, 0.24465996026992798F);
+ compareFloatBits(0x3ef758b2, 0.483098566532135F);
+ compareFloatBits(0x3e8d1874, 0.275577187538147F);
+ compareFloatBits(0x3dbc6968, 0.09199792146682739F);
+ compareFloatBits(0x3e940d00, 0.28916168212890625F);
+ compareFloatBits(0x3edd7ba2, 0.43258386850357056F);
+ compareFloatBits(0x3edf10da, 0.4356754422187805F);
+ compareFloatBits(0x3e9a3f84, 0.3012658357620239F);
+ compareFloatBits(0x3f21db08, 0.6322484016418457F);
+ compareFloatBits(0x3f10f0c8, 0.5661740303039551F);
+ compareFloatBits(0x3f7b5bc9, 0.9818692803382874F);
+ compareFloatBits(0x3f786c68, 0.9704041481018066F);
+ compareFloatBits(0x3f3b3106, 0.7312167882919312F);
+ compareFloatBits(0x3eef40e6, 0.46729201078414917F);
+ compareFloatBits(0x3f2120ea, 0.6294084787368774F);
+ compareFloatBits(0x3ece201c, 0.40258872509002686F);
+ compareFloatBits(0x3f26e082, 0.6518632173538208F);
+ compareFloatBits(0x3e1edd60, 0.15514135360717773F);
+ compareFloatBits(0x3d2c6760, 0.042090773582458496F);
+ compareFloatBits(0x3f1c99e3, 0.6117231249809265F);
+ compareFloatBits(0x3f62a5de, 0.8853434324264526F);
+ compareFloatBits(0x3f3ca39f, 0.7368716597557068F);
+ compareFloatBits(0x3f2890bd, 0.6584585309028625F);
+ compareFloatBits(0x3d7568a0, 0.059914231300354004F);
+ compareFloatBits(0x3e96620e, 0.2937168478965759F);
+ compareFloatBits(0x3d358bb0, 0.044322669506073F);
+ compareFloatBits(0x3e9e2728, 0.30889248847961426F);
+ compareFloatBits(0x3e887622, 0.2665262818336487F);
+ compareFloatBits(0x3ec71942, 0.38886457681655884F);
+ compareFloatBits(0x3f3ecf0c, 0.7453467845916748F);
+ compareFloatBits(0x3f1d8b64, 0.615408182144165F);
+ compareFloatBits(0x3f22e45e, 0.6362971067428589F);
+ compareFloatBits(0x3f1bc5c0, 0.6084861755371094F);
+ compareFloatBits(0x3ef2ce7c, 0.4742316007614136F);
+ compareFloatBits(0x3ee6d16a, 0.45081645250320435F);
+ compareFloatBits(0x3e22dbf4, 0.15904217958450317F);
+ compareFloatBits(0x3ec8462e, 0.39116042852401733F);
+ compareFloatBits(0x3eed4110, 0.46338701248168945F);
+ compareFloatBits(0x3e7d46f0, 0.24734091758728027F);
+ compareFloatBits(0x3ee4ed1a, 0.44712144136428833F);
+ compareFloatBits(0x3e171310, 0.14753365516662598F);
+ compareFloatBits(0x3f07ee13, 0.5309764742851257F);
+ compareFloatBits(0x3ea82356, 0.3283945918083191F);
+ compareFloatBits(0x3eaad676, 0.33366745710372925F);
+ compareFloatBits(0x3f0b7415, 0.5447400212287903F);
+ compareFloatBits(0x3e5da494, 0.2164481282234192F);
+ compareFloatBits(0x3eb24b98, 0.3482329845428467F);
+ compareFloatBits(0x3dbcf808, 0.09226995706558228F);
+ compareFloatBits(0x3ebff9ec, 0.37495362758636475F);
+ compareFloatBits(0x3ea1c5c6, 0.315962016582489F);
+ compareFloatBits(0x3e922946, 0.2854711413383484F);
+ compareFloatBits(0x3eb24736, 0.3481995463371277F);
+ compareFloatBits(0x3d870700, 0.06593132019042969F);
+ compareFloatBits(0x3db58dc0, 0.08864927291870117F);
+ compareFloatBits(0x3f2fbba4, 0.6864569187164307F);
+ compareFloatBits(0x3e67b5b4, 0.22627907991409302F);
+ compareFloatBits(0x3e1b35d8, 0.151572585105896F);
+ compareFloatBits(0x3eb18776, 0.3467366099357605F);
+ compareFloatBits(0x3e4a1108, 0.19733059406280518F);
+ compareFloatBits(0x3f77debb, 0.968242347240448F);
+ compareFloatBits(0x3f2f3f2c, 0.6845576763153076F);
+ compareFloatBits(0x3ee68150, 0.45020532608032227F);
+ compareFloatBits(0x3da1ca40, 0.07899904251098633F);
+ compareFloatBits(0x3f1a6205, 0.6030581593513489F);
+ compareFloatBits(0x3e596a8c, 0.2123205065727234F);
+ compareFloatBits(0x3f2b9b3d, 0.6703374981880188F);
+ compareFloatBits(0x3f5a41df, 0.8525676131248474F);
+ compareFloatBits(0x3f2ba95b, 0.6705529093742371F);
+ compareFloatBits(0x3c636740, 0.013879597187042236F);
+ compareFloatBits(0x3ea13618, 0.3148658275604248F);
+ compareFloatBits(0x3ef32f54, 0.4749704599380493F);
+ compareFloatBits(0x3db49fd8, 0.08819550275802612F);
+ compareFloatBits(0x3ed2654e, 0.4109291434288025F);
+ compareFloatBits(0x3f18e527, 0.5972465872764587F);
+ compareFloatBits(0x3e86438e, 0.2622341513633728F);
+ compareFloatBits(0x3d94d468, 0.07267075777053833F);
+ compareFloatBits(0x3dec0730, 0.11524808406829834F);
+ compareFloatBits(0x3e746c68, 0.23869478702545166F);
+ compareFloatBits(0x3f7176bc, 0.9432179927825928F);
+ compareFloatBits(0x3eb06baa, 0.34457141160964966F);
+ compareFloatBits(0x3ec7873e, 0.3897036910057068F);
+
+ compareFloatBits(0x3337354c, 4.2656481014091696E-8F);
+ compareFloatBits(0xcef68e86, -2.068267776E9F);
+ compareFloatBits(0x1aee11a3, 9.846298654970688E-23F);
+ compareFloatBits(0x25855b49, 2.313367945844274E-16F);
+ compareFloatBits(0x51bbb6d8, 1.0077831168E11F);
+ compareFloatBits(0xd10cbbd1, -3.7777903616E10F);
+ compareFloatBits(0x6b71ebcc, 2.9246464178639103E26F);
+ compareFloatBits(0xa209e607, -1.868873766564279E-18F);
+ compareFloatBits(0xa0fdd3be, -4.299998635695525E-19F);
+ compareFloatBits(0x66b6f9c2, 4.320389591649362E23F);
+ compareFloatBits(0x9a107a3f, -2.987725166002456E-23F);
+ compareFloatBits(0xc7e6d303, -118182.0234375F);
+ compareFloatBits(0x1504020d, 2.6658805490381716E-26F);
+ compareFloatBits(0x9c0c256, 4.640507130264806E-33F);
+ compareFloatBits(0x8adc428e, -2.1210264479196232E-32F);
+ compareFloatBits(0xdfae9f63, -2.516576947109521E19F);
+ compareFloatBits(0xceba38f7, -1.562147712E9F);
+ compareFloatBits(0xa3d86a36, -2.346374900739753E-17F);
+ compareFloatBits(0x508d0d6d, 1.8931738624E10F);
+ compareFloatBits(0x3ea209d0, 0.3164811134338379F);
+ compareFloatBits(0x7bac59a0, 1.7897857412574353E36F);
+ compareFloatBits(0x468c3af4, 17949.4765625F);
+ compareFloatBits(0x178d2da8, 9.123436692979724E-25F);
+ compareFloatBits(0x4a068058, 2203670.0F);
+ compareFloatBits(0x6ebdd138, 2.937279840252836E28F);
+ compareFloatBits(0x6f886d95, 8.444487576529374E28F);
+ compareFloatBits(0x4d1fc258, 1.67519616E8F);
+ compareFloatBits(0xa1db0894, -1.48422878466768E-18F);
+ compareFloatBits(0x90f0c84b, -9.497190880745409E-29F);
+ compareFloatBits(0xfb5bc94f, -1.1411960353742999E36F);
+ compareFloatBits(0xf86c6851, -1.9179653854596293E34F);
+ compareFloatBits(0xbb31060d, -0.00270116631872952F);
+ compareFloatBits(0x77a07357, 6.508647400938524E33F);
+ compareFloatBits(0xa120ea93, -5.452056501780286E-19F);
+ compareFloatBits(0x67100ede, 6.802950247361373E23F);
+ compareFloatBits(0xa6e082db, -1.5578590790627281E-15F);
+ compareFloatBits(0x27b7589e, 5.088878232380797E-15F);
+ compareFloatBits(0xac6764c, 1.9111204788084013E-32F);
+ compareFloatBits(0x9c99e3b0, -1.0183546536936767E-21F);
+ compareFloatBits(0xe2a5de8f, -1.5298749044800828E21F);
+ compareFloatBits(0xbca39f3d, -0.0199733916670084F);
+ compareFloatBits(0xa890bd69, -1.6069355115761082E-14F);
+ compareFloatBits(0xf568a12, 1.0577605982258498E-29F);
+ compareFloatBits(0x4b310752, 1.1601746E7F);
+ compareFloatBits(0xb58bb7e, 4.1741140243391215E-32F);
+ compareFloatBits(0x4f139499, 2.475989248E9F);
+ compareFloatBits(0x443b1161, 748.2715454101562F);
+ compareFloatBits(0x638ca14d, 5.188334233065301E21F);
+ compareFloatBits(0xbecf0c69, -0.4043915569782257F);
+ compareFloatBits(0x9d8b6455, -3.689673453519375E-21F);
+ compareFloatBits(0xa2e45ebb, -6.189982361684887E-18F);
+ compareFloatBits(0x9bc5c04c, -3.2715185077444394E-22F);
+ compareFloatBits(0x79673ea0, 7.504317251393587E34F);
+ compareFloatBits(0x7368b523, 1.8436992802490676E31F);
+ compareFloatBits(0x28b6fdf6, 2.031619704824343E-14F);
+ compareFloatBits(0x6423179d, 1.2034083200995491E22F);
+ compareFloatBits(0x76a0886c, 1.627996995533634E33F);
+ compareFloatBits(0x3f51bc17, 0.8192762732505798F);
+ compareFloatBits(0x72768dd4, 4.883505414291899E30F);
+ compareFloatBits(0x25c4c43e, 3.4133559007908424E-16F);
+ compareFloatBits(0x87ee1312, -3.582146842575625E-34F);
+ compareFloatBits(0x5411ab9d, 2.502597804032E12F);
+ compareFloatBits(0x556b3b74, 1.616503635968E13F);
+ compareFloatBits(0x8b741536, -4.700864797886097E-32F);
+ compareFloatBits(0x3769256b, 1.3896594282414299E-5F);
+ compareFloatBits(0x5925cc76, 2.916761145966592E15F);
+ compareFloatBits(0x179f010a, 1.0275396467808127E-24F);
+ compareFloatBits(0x5ffcf643, 3.6455660418215444E19F);
+ compareFloatBits(0x50e2e3b3, 3.0452586496E10F);
+ compareFloatBits(0x4914a300, 608816.0F);
+ compareFloatBits(0x59239bd2, 2.878234215579648E15F);
+ compareFloatBits(0x10e0e0b4, 8.869863136638123E-29F);
+ compareFloatBits(0x16b1b8a0, 2.8712407025600733E-25F);
+ compareFloatBits(0xafbba4b9, -3.413214433312106E-10F);
+ compareFloatBits(0x39ed6d41, 4.528556310106069E-4F);
+ compareFloatBits(0x26cd7698, 1.4256877403358119E-15F);
+ compareFloatBits(0x58c3bbb6, 1.721687838031872E15F);
+ compareFloatBits(0x32844205, 1.53968446880981E-8F);
+ compareFloatBits(0xf7debb7d, -9.035098568054132E33F);
+ compareFloatBits(0xaf3f2c18, -1.738701405074039E-10F);
+ compareFloatBits(0x7340a8d9, 1.5264063021291595E31F);
+ compareFloatBits(0x1439482f, 9.354348821593712E-27F);
+ compareFloatBits(0x9a62050f, -4.673979090873511E-23F);
+ compareFloatBits(0x365aa321, 3.257948492318974E-6F);
+ compareFloatBits(0xab9b3d23, -1.1030381252483124E-12F);
+ compareFloatBits(0xda41dfad, -1.3642651156873216E16F);
+ compareFloatBits(0xaba95bd7, -1.2033662911623E-12F);
+ compareFloatBits(0x38d9d45, 8.323342486879323E-37F);
+ compareFloatBits(0x509b0cf8, 2.08105472E10F);
+ compareFloatBits(0x7997aaa7, 9.843725829681495E34F);
+ compareFloatBits(0x1693fb40, 2.3907691910171116E-25F);
+ compareFloatBits(0x6932a7e3, 1.3498851156559247E25F);
+ compareFloatBits(0x98e52756, -5.923483173240392E-24F);
+ compareFloatBits(0x4321c7ba, 161.78018188476562F);
+ compareFloatBits(0x129a8db3, 9.753697906689189E-28F);
+ compareFloatBits(0x1d80e684, 3.411966546003519E-21F);
+ compareFloatBits(0x3d1b1a71, 0.03786701336503029F);
+ compareFloatBits(0xf176bcf8, -1.221788185872419E30F);
+ compareFloatBits(0x5835d550, 7.99711099355136E14F);
+ compareFloatBits(0x63c39f88, 7.217221064844452E21F);
+ }
+
+ private void compareFloatBits(int bits, float value) {
+ assertEquals(bits, Float.floatToIntBits(value));
+ compareFloats(value, Float.intBitsToFloat(bits));
+
+ assertEquals(bits, Float.floatToIntBits(Float.intBitsToFloat(bits)));
+ compareFloats(value, Float.intBitsToFloat(Float.floatToIntBits(value)));
+ }
+
+ private void compareFloats(float expected, float actual) {
+ if (Float.isNaN(expected) || Float.isNaN(actual)) {
+ if (Float.isNaN(expected) && Float.isNaN(actual)) {
+ return;
+ }
+ fail("NaN");
+ }
+ assertEquals(expected, actual);
+ }
}
