为什么要使用Double.doubleToLongBits（）而不是强制转换？

Question

EDIT:

I think my purpose was not understood, and so the negative votes and comments. I am NOT interested in knowing what bit of a floating point(double) means what, and if they match the same position in a long; this is totally irrelevant to me. My problem is the following: I want to use a single primitive array to store all my primitive values. If I choose a double[] as "storage", I need to be able to store longs in it too (I could also do it the other way around, but the problem would not go away, just be reversed). Since both are the same size, it should work, somehow. Using Double.doubleToRawLongBits(double) and Double.longBitsToDouble(long) allow me to do that. But what I wanted to know was: "Can I just put cast a long to an double and back, and always get the same long back?" If THAT is true, then it solves my problem, and I don't care if the bits gets moved around internally. So I wanted to test if I can safely safely do this. The output says all 64 bits could be accessed and modified individually, but possibly this is not sufficient to prove that no long bit gets lost/modified.

I just discovered, with a small test, that I can correctly "address" every bit in a double, just by casting to long and back. Here the test program (which succeeds, at least on Java 7 / Windows 7 64bit):

import static org.junit.Assert.assertTrue;
import org.junit.Test;

public class TestDoubleBits {
    private static double set(final double d, final int bit, final boolean value) {
        if (value) {
            return ((long) d) | (1L << bit);
        } else {
            return ((long) d) & ~(1L << bit);
        }
    }

    private static boolean get(final double d, final int bit) {
        return (((long) d) & (1L << bit)) != 0;
    }

    @Test
    public void testDoubleBits() {
        final double value = Math.random();
        for (int bit = 0; bit < 64; bit++) {
            assertTrue((get(set(value, bit, false), bit) == false));
            assertTrue((get(set(value, bit, true), bit) == true));
        }
    }
}

Assuming my test program correctly "proves" that every bit of a double can be accessed, just by casting to long and back, why do we have the following native methods:

Double.doubleToRawLongBits(double)
Double.longBitsToDouble(long)

Since native methods are usually slower (the content of the method might be faster, but the overhead of native call make it slower), is there any benefit to using those methods?

Answer 1

The bit pattern of a floating point number will NEVER (with ONE exception) remotely resemble the bit pattern of the corresponding integer value, if one exists.

I suggest you run the following program

public class Test
{
    public static void main(String[] args) {
        double d = 1.3;
        long d1 = (long) d;
        long d2 = (Double.doubleToLongBits(d));
        System.out.printf("cast %016X bits %016X\n", d1, d2);
    }
}

Then read What Every Computer Scientist Should Know About Floating-Point Arithmetic

(The exception is, of course, the value zero)

If you want to investigate further, there's a neat interactive floating point converter at CUNY that displays everything you'd ever want to know about any given number's float representations.

Answer 2

This is the test I should have used. It fails at 53, which (I assume) means that only the first 52 bits of a long could be stored in a double "safely" without using those native methods (this also precludes using any negative values).

public class TestDoubleBits {
    public static void main(final String[] args) {
        int failsAt = -1;
        long value = 1;
        for (int bit = 1; bit < 64; bit++) {
            value = value | (1L << bit);
            final double d = value;
            final long l2 = (long) d;
            if (value != l2) {
                failsAt = bit;
                break;
            }
        }
        System.out.println("failsAt: " + failsAt);
        value = value & ~(1L << failsAt);
        System.out.println("Max value decimal: " + value);
        System.out.println("Max value hex:     " + Long.toHexString(value));
        System.out.println("Max value binary:  " + Long.toBinaryString(value));
    }
}

The problem with my original test was that I tested the bits individually . By always setting the first bit to 1, I can find out when I start loosing data , because the least significant bit is the "first to go".