Convert Double to Binary representation?

Question

I tried to convert a double to its binary representation, but using this Long.toBinaryString(Double.doubleToRawLongBits(d)) doesn't help, since I have large numbers, that Long can't store them i.e 2^900.

The binary representation can only be 64-bit long as a double is 64-bit. I don't know where 2^900 comes from. — Peter Lawrey, Jun 15 '11 at 15:04
Just out of curiosity, what kind of application do you work on to need to work with such a large number ? — glmxndr, Jun 15 '11 at 15:05
Useful link : http://stackoverflow.com/questions/397692/how-do-i-display-the-binary-representation-of-a-float-or-double — Saurabh Gokhale, Jun 15 '11 at 15:13
I have to do some experiments thought to do sampling on those possibilities but I see i need to do random sampling! — Besnik, Jun 15 '11 at 15:17

Matt Ball · Answer 1 · 2013-12-22T15:44:50.660

Long.toBinaryString(Double.doubleToRawLongBits(d)) appears to work just fine.

System.out.println("0:                0b" + Long.toBinaryString(Double.doubleToRawLongBits(0D)));
System.out.println("1:                0b" + Long.toBinaryString(Double.doubleToRawLongBits(1D)));
System.out.println("2:                0b" + Long.toBinaryString(Double.doubleToRawLongBits(2D)));
System.out.println("2^900:            0b" + Long.toBinaryString(Double.doubleToRawLongBits(Math.pow(2, 900))));
System.out.println("Double.MAX_VALUE: 0b" + Long.toBinaryString(Double.doubleToRawLongBits(Double.MAX_VALUE)));

/*
    prints:
    0:                0b0
    1:                0b11111111110000000000000000000000000000000000000000000000000000
    2:                0b100000000000000000000000000000000000000000000000000000000000000
    2^900:            0b111100000110000000000000000000000000000000000000000000000000000
    Double.MAX_VALUE: 0b111111111101111111111111111111111111111111111111111111111111111
*/

Where are the missing 63rd and 64th bits? – razz May 18 '20 at 12:00 — razz, May 18 '20 at 12:00

score 8 · Answer 2 · answered Aug 10 '15 at 19:59

You may want to process whole and fractional part :

public String toBinary(double d, int precision) {
    long wholePart = (long) d;
    return wholeToBinary(wholePart) + '.' + fractionalToBinary(d - wholePart, precision);
}

private String wholeToBinary(long l) {
    return Long.toBinaryString(l);
}

private String fractionalToBinary(double num, int precision) {
    StringBuilder binary = new StringBuilder();
    while (num > 0 && binary.length() < precision) {
        double r = num * 2;
        if (r >= 1) {
            binary.append(1);
            num = r - 1;
        } else {
            binary.append(0);
            num = r;
        }
    }
    return binary.toString();
}

score 1 · Answer 3 · edited May 05 '20 at 15:43

Here is a small snippet which converts the fractional part of the double to binary format:

String convertToBinary(double number) {
    int i=1;
    String num="0.";
    double temp,noofbits=32;
    while (i<=noofbits && number>0) {
        number=number*2;
        temp=Math.floor(number);
        num+=(int)temp;
        number=number-temp;
        i++;
    }

where noofbits gives the bitsize you want the fractional part to be limited to. For the whole number part directly use the Integer.toBinaryString() along with the floor value of the double and append to the fractional binary string.

score 0 · Answer 4 · answered Jun 15 '11 at 15:04

0

Have you tried using java.math.BigInteger and calling toString(int radix) with a parameter of 2?

answered Jun 15 '11 at 15:04

Liv

6,006
1
22
29

1

Double.doubleToRawLongBits(d) is only ever going to return a 64-bit `long`. – Peter Lawrey Jun 15 '11 at 15:05
By the way, the above applies to integer numbers only -- which I have assumed to be the case based on the 2^900 you mentioned? – Liv Jun 15 '11 at 15:05
The thing is that i compute that using the Math.pow(2, 900) which returns double! – Besnik Jun 15 '11 at 15:10
Yup agree :) Thanks for the help all! – Besnik Jun 15 '11 at 15:15
@Peter : LOL ! I do repeat, "all double are 64-bit, all double are 64-bit" ... :-) – Saurabh Gokhale Jun 15 '11 at 15:16

score 0 · Answer 5 · answered Jun 15 '11 at 15:06

0

You can use a BigInteger to hold your large number and the BigInteger.toString() method to retrieve a binary representation of it.

BigInteger bigNum = new BigInteger(sYourNum);
System.out.println( bigNum.toString(2) );

answered Jun 15 '11 at 15:06

Brandon E Taylor

24,881
6
47
71

this does not convert the fractional part of a **double** – m13r Feb 21 '23 at 14:05

score 0 · Answer 6 · answered Mar 09 '22 at 07:44

Though this question is old, and good answers are present.

I just come up with an idea that you can write the double value to a file/memory region through DataOutputStream and read it as bytes.

Therefore we can use ByteArrayOutputStream to hold the binary representation and fetch the bytes directly to avoid I/O operations on disk. (javadoc, also this post)

The scala version of it looks like:

import java.io._

val baos = new ByteArrayOutputStream(8)
val dos = new DataOutputStream(baos)
dos.writeDouble(1.23)
dos.close()

// this 'Array[Byte]' or 'byte[]' in java holds the correct binary representation (big-endian) of the double. 
val binaryRepresentation = baos.toByteArray() 
baos.close()

score -1 · Answer 7 · answered Jun 15 '11 at 15:08

-1

You can use Double.toHexString(d) and then transform the hexadecimal string into a binary one using a for loop and a StringBuilder.

answered Jun 15 '11 at 15:08

Aymen

558
6
13

Thanks this might help on my problem! – Besnik Jun 15 '11 at 15:10

Convert Double to Binary representation?

7 Answers7

Linked

Related