java - 如何在 Java 中使用双位代码和 doubleToLongBits()？

Question

我能够得到双数的二进制代码:

Double d = 1.5E12;
long l = Double.doubleToLongBits(d);
String bin = Long.toBinaryString(l);
System.out.println(bin);
System.out.println(bin.length());

但是，生成的代码并不像双位代码，它没有任何意义:

1.5E12   --> 100001001110101110100111110111101111001100000000000000000000000 (length: 63)
-1.5E12  --> 1100001001110101110100111110111101111001100000000000000000000000 (length: 64)
1.5E-12  --> 11110101111010011000110110011001000001110001001101111100011010 (length: 62)
-1.5E-12 --> 1011110101111010011000110110011001000001110001001101111100011010 (length: 64)

我试图通过对它们进行分组来理解这些数字:

1.5E12   -->     10000100111  0101110100111110111101111001100000000000000000000000
-1.5E12  --> 1   10000100111  0101110100111110111101111001100000000000000000000000
1.5E-12  -->   (0)1111010111  1010011000110110011001000001110001001101111100011010
-1.5E-12 --> 1   01111010111  1010011000110110011001000001110001001101111100011010

首先，它为减号添加/删除了一点(这是一件坏事......说到解析器)。但更重要的是，指数显示出非常可疑的数字:例如10000100111 应该是 1035 (= 1023 + 12) 而不是 1063 (1063 - 1023 = 40!)，并且 (0)1111010111 应该是 1011 (= 1023 - 12) 而不是 983 (983 - 1023 = -40!) .

有谁知道如何阅读这个双位代码？ IE。如何从上面的位码中得到正确的指数和尾数？

(例子:如何从位码中取回值1.5E12？100001001110101110100111110111101111001100000000000000000000000 --?--> 1.5E12)

更新:

使用 Java API 中的掩码，我最终得到了如下值:

static final long SIGN = 0x8000000000000000L;
static final long EXPN = 0x7ff0000000000000L;
static final long SGNF = 0x000fffffffffffffL;

Double d = ...;
long lng = Double.doubleToLongBits(d);
String bin = Long.toBinaryString(lng);
long sign = (lng & SIGN) >>> (bin.length()-1);
long expn = (lng & EXPN) >>> 52;
long sgnf = lng & SGNF;

而且我可以轻松打印它:

System.out.println("sign-bin: "+Long.toBinaryString(sign));
System.out.println("expn-bin: "+Long.toBinaryString(expn));
System.out.println("sgnf-bin: "+Long.toBinaryString(sgnf));
System.out.println("sign-string: "+Long.toString(sign));
System.out.println("expn-string: "+Long.toString(expn));
System.out.println("sgnf-string: "+Long.toString(sgnf));

使用 Double 1.5E12 我得到了这个结果:

sign-bin: 0
expn-bin: 10000100111
sgnf-bin: 101110100111110111101111001100000000000000000000000
sign-string: 0
expn-string: 1063
sgnf-string: 1640400372629504

您知道如何从中获取“真实”的十进制值吗？ (例如 1640400372629504 --> 1.5 和 1063 --> E12)

Answer 1

表示符号 0 的“缺失”只是一种数字书写约定。

在十进制系统中，您会写 1067 而不是 0001067，对吗？这正是 Java 所做的。 0 存在于内存中，它们只是不显示，因为您不需要它们。

---

这也是一个二进制 数的浮点表示。

如果把1.5*10^-12转换成二进制数，开头会有很多个0(我开始了，后来我的论文就结束了——开头肯定不止12个0)。然后将这个二进制数归一化(使得该点之前只有一个 1)，并将这个归一化的指数用作指数。我猜 1.5*10^-12 的二进制指数确实是 40。

换句话说:IEEE 数字的指数表示值 2^exponent，而不是 10^exponent，就像我们在十进制系统中使用的那样。

---

根据 this page您需要将尾数的每个数字乘以 2 的相应幂，从 2^-1 开始，然后是 2^-2 等等，然后将它们相加。

然后你使用这个公式:

(-1)^(sign bit) * (1+fraction) * 2^(exponent - bias)

其中 fraction 是您从尾数中计算出的数字。exponent 是指数的十进制表示。 bias 取决于您的精度，在您的情况下是 double ，这意味着 1023。对于单精度，它仅为 127。

---

您不能将二进制表示部分(比如二进制指数)直接转换为十进制对应部分(十进制指数)。至少我不知道怎么做。

因此您需要将完整的数字转换为十进制，然后将其拆分为数字及其指数。

这是将二进制表示形式转换为十进制的 Java 代码:

static final long SIGN = 0x8000000000000000L;
static final long EXPN = 0x7ff0000000000000L;
static final long SGNF = 0x000fffffffffffffL;

public static void main(String[] args){
    Double d = -0.0000000000015;//1500000000000d;
    long lng = Double.doubleToLongBits(d);
    String bin = Long.toBinaryString(lng);
    long sign = (lng & SIGN) >>> (bin.length()-1);
    long expn = (lng & EXPN) >>> 52;
    long sgnf = lng & SGNF;



    System.out.println("sign-bin: "+Long.toBinaryString(sign));
    System.out.println("expn-bin: "+Long.toBinaryString(expn));
    System.out.println("sgnf-bin: "+Long.toBinaryString(sgnf));
    System.out.println("sign-string: "+Long.toString(sign));
    System.out.println("expn-string: "+Long.toString(expn));
    System.out.println("sgnf-string: "+Long.toString(sgnf));

    String mantisse = Long.toBinaryString(sgnf);
    int pow2 = 2;
    double fraction = 0;
    for(int i = 0; i < mantisse.length(); i++){
        if(mantisse.charAt(i) == '1'){
            double curr = 1.0/pow2;
            fraction += Double.isInfinite(curr)? 0: curr;
        }
        //System.out.println(fraction + " " + pow2);
        pow2 <<= 1;
    }

    System.out.println((1+fraction));
    System.out.println("Back to decimal: " + (sign == 1?(-1):1) * (1+fraction) * Math.pow(2, expn - 1023));
}

请注意，结果并不完全准确，因为计算机中的浮点运算并不准确，而且存储信息的空间有限。

我不知道如何提取数字，它是 double 的指数。我最好的猜测是操纵字符串表示链接:

String[] number = Double.toString(dBack).split("E");
System.out.println("Decimal exponent: " + (number.length == 2?number[1]: 1));
System.out.println("Decimal mantisse: " + number[0]);

希望对您有所帮助。