[数学][原创]解读IEEE标准754：浮点数表示

soloforce

解读IEEE标准754：浮点数表示
[color="Red"]如须转载请注明作者为soloforce@linuxsir.cn，并请保持文章的完整和提供转载出处。
http://bbs.linuxsir.cn/showthread.php?t=262207

[color="Red"]更新：
20060623-06:44 增加了求最大非规格数的公式
20060622-23:40 修改了几处笔误，换掉了实验部分的那张大图，改用代码显示。

　
[color="Blue"]一、背景
　　在IEEE标准754之前，业界并没有一个统一的浮点数标准，相反，很多计算机制造商都设计自己的浮点数规则，以及运算细节。那时，实现的速度和简易性比数字的精确性更受重视。
　　直到1985年Intel打算为其的8086微处理器引进一种浮点数协处理器的时候，聪明地意识到，作为设计芯片者的电子工程师和固体物理学家们，也许并不能通过数值分析来选择最合理的浮点数二进制格式。于是Intel在请加州大学伯克利分校的 William Kahan教授──最优秀的数值分析家之一来为8087 FPU设计浮点数格式; 而这个家伙又找来两个专家来协助他，于是就有了KCS组合（Kahn, Coonan, and Stone）。　他们共同完成了Intel的浮点数格式设计，而且完成地如此出色，以致于IEEE组织决定采用一个非常接近KCS的方案作为IEEE的标准浮点格式。目前，几乎所有计算机都支持该标准，大大改善了科学应用程序的可移植性。

[color="Blue"]二、表示形式
　　从表面上看，浮点数也是一串0和1构成的位序列(bit sequence)，并不是三头六臂的怪物，更不会咬人。然而IEEE标准从逻辑上用三元组{S,E,M}表示一个数N,如下图所示：

　　N的实际值n由下列式子表示：

其中：
　　★ n,s,e,m分别为N,S,E,M对应的实际数值,而N,S,E,M仅仅是一串二进制位。
　　★ S(sign)表示N的符号位。对应值s满足：n>0时，s=0; n<0时，s=1。
　　★ E(exponent)表示N的指数位，位于S和M之间的若干位。对应值e值也可正可负。
　　★ M(mantissa)表示N的尾数位，恰好，它位于N末尾。M也叫有效数字位（sinificand）、系数位（coefficient）, 甚至被称作“小数”。
[color="Blue"]
三、浮点数格式
　　IEEE标准754规定了三种浮点数格式：单精度、双精度、扩展精度。前两者正好对应C语言里头的float、double或者FORTRAN里头的real、double精度类型。限于篇幅，本文仅介绍单精度、双精度浮点格式。
　　★ 单精度:N共32位，其中S占1位，E占8位，M占23位。
　　

　　★ 双精度:N共64位，其中S占1位，E占11位，M占52位。
   

   
　　值得注意的是，M虽然是23位或者52位，但它们只是表示小数点之后的二进制位数，也就是说，假定 M为“010110011...”, 在二进制数值上其实是“.010110011...”。而事实上，标准规定小数点左边还有一个隐含位，这个隐含位通常，哦不，应该说绝大多数情况下是1，那什么情况下是0呢？答案是N对应的n非常小的时候，比如小于 2^(-126)(32位单精度浮点数)。不要困惑怎么计算出来的，看到后面你就会明白。总之，隐含位算是赚来了一位精度,于是M对应的m最后结果可能是"m=1.010110011...”或者“m=0.010110011...”

[color="Blue"]四、计算e、m
　　首先将提到令初学者头疼的“规格化(normalized)”、“非规格化(denormalized)”。噢，其实并没有这么难的，跟我来！掌握它以后你会发现一切都很优雅,更美妙的是，规格化、非规格化本身的概念几乎不怎么重要。请牢记这句话：规格化与否全看指数E！
　　下面分三种情况讨论E，并分别计算e和m:
　　
　　[color="Red"]1、规格化：当E的二进制位不全为0,也不全为1时，N为规格化形式。此时e被解释为表示偏置（biased）形式的整数,e值计算公式如下图所示：

　　上图中，|E|表示E的二进制序列表示的整数值,例如E为"10000100",则|E|=132,e=132-127=5 。 k则表示E的位数，对单精度来说，k=8,则bias=127，对双精度来说，k=11,则bias=1023。
　　此时m的计算公式如下图所示：
　　

　　标准规定此时小数点左侧的隐含位为1,那么m=|1.M|。如M="101"，则|1.M|=|1.101|=1.625,即 m=1.625

[color="Red"]　　2、非规格化：当E的二进制位全部为0时，N为非规格化形式。此时e，m的计算都非常简单。
   

　　注意，此时小数点左侧的隐含位为0。   为什么e会等于(1-bias)而不是(-bias)，这主要是为规格化数值、非规格化数值之间的平滑过渡设计的。后文我们还会继续讨论。
　　有了非规格化形式，我们就可以表示0了。把符号位S值1,其余所有位均置0后，我们得到了 -0.0; 同理，把所有位均置0,则得到 +0.0。非规格化数还有其他用途，比如表示非常接近0的小数，而且这些小数均匀地接近0,称为“逐渐下溢(gradually underflow)”属性。
　　
　　[color="Red"]3、特殊数值： 当E的二进制位全为1时为特殊数值。此时，若M的二进制位全为0，则n表示无穷大，若S为1则为负无穷大，若S为0则为正无穷大; 若M的二进制位不全为0时，表示NaN(Not a Number)，表示这不是一个合法实数或无穷，或者该数未经初始化。
　　
[color="Blue"]五、范例
　　仔细研读第四点后，再回忆一下文章开头计算n的公式，你应该写出一个浮点编码的实际值n了吧？ 还不能吗？不急，我先给你示范一下。我们假定N是一个8位浮点数，其中，S占1位，E占4位，M占3位。下面这张表罗列了N可能的正数形式，也包含了e、m等值，请你对照着这张表，重温一下第四点，你会慢慢明白的。说实在的，这张表花了我不少功夫呢,幸好TeX画表格还算省事！　
　　

　　这张表里头有很多有趣的地方，我提醒一下：
　　★ 看 N 列，从上到下，二进制位表示是均匀递增的，且增量都是一个最小二进制位。这不是偶然，正是巧妙设计的结果。观察最大的非规格数，发现恰好就是M全为1, E全为0的情况。于是我们求出最大的非规格数为：

　　上面的公式中，h为M的位数(如范例中为3)。注意，公式等号右边的第一项同时又是最小规格数的值（如范例中为 8/512 ）;第二项则正是最小非规格数的值(如范例中为1/512)即该浮点数能表示的最小正数。
　　★ 看 m 列，规格化数都是 1+ x 的形式，这个1正是隐含位1; 而非规格化数隐含位为0, 所以没有 "1+" 。
　　★ 看 n 列，非规格化数从上到下的增量都是 1/512, 且过渡到规格化数时，增量是平滑的，依旧是1/512。这正是非规格化数中e等于(1-bias)而不是(-bias)的缘故，也是巧妙设计的结果。 再继续往下看，发现增量值逐渐增大。可见，浮点数的取值范围不是均匀的。
　　
[color="Blue"]六、实战
　　我们用一小段汇编来测试一下，浮点数在内存中是如何表示的。测试环境： GentooLinux2006.0/GNU assembler version 2.16.1/GNU gdb 6.4/AMD XP1600+。 如下所示

2. ~/coding/assemble $  gdb float
3. GNU gdb 6.4
4. Copyright 2005 Free Software Foundation, Inc.
5. GDB is free software, covered by the GNU General Public License, and you are
6. welcome to change it and/or distribute copies of it under certain conditions.
7. Type "show copying" to see the conditions.
8. There is absolutely no warranty for GDB.  Type "show warranty" for details.
9. This GDB was configured as "i686-pc-linux-gnu"...Using host libthread_db library "/lib/libthread_db.so.1".
11. (gdb) list
12. 1        .section .data
13. 2        f1:
14. 3            .float  5
15. 4        f2:
16. 5            .float  0.1   
17. 6        .section .text
18. 7            .global _start
19. 8        _start:
20. 9            nop
21. 10       
22. (gdb) x/f &f1
23. 0x80490a4 <f1>:        5
24. (gdb) x/xw &f1
25. 0x80490a4 <f1>:        0x40a00000
26. (gdb) x/f &f2
27. 0x80490a8 <f2>:        0.100000001
28. (gdb) x/xw &f2
29. 0x80490a8 <f2>:        0x3dcccccd
30. (gdb)

复制代码

　　从上面的gdb命令结果可以看出，浮点数5被表示为 0x40a00000，二进制形式为( 0100 0000 1010 0000 ... 0000 0000)。红色数字为E，可以看出|E|=129>0, 则e=129-bias=129-127=2 ； 蓝色数字为M, 且|E|>0，说明是规格化数，则m=|1.M|=|1.01000..000|=1.25 ; 由n的计算公式可以求得 n=(-1)^0 * 1.25 * 2^2  = 5， 结果被验证了。
　　同样，你也可以验证一下十进制浮点数0.1的二进制形式是否正确，你会发现，0.1不能表示为有限个二进制位，因此在内存中的表示是舍入(rounding)以后的结果，即 0x3dcccccd, 十进制为0.100000001， 误差0.000000001由此产生了。
　　
[color="Blue"]七、未完成
　　关于浮点数，还有很多东西（比如舍入误差、除零异常等等）值得我们深入探讨，但已经无法在此继续。这篇文章的目的仅在初步解释IEEE标准754对浮点数的规定以及一些奇妙的地方。写这篇文章花掉了我整天的时间，但也使我彻底记住了以前让我胆怯的东西──最重要的是，希望这篇文章对大家有点用处，也算我为计算机科学基础理论版以及Linuxsir.org做的一点贡献。
　　

参考书目：
①: Randall Hyde, The Art of Assembly Language, Vol.1, 4.2.1
②: Randal E. Bryant, David R. O’Hallaron, Computer Systems A Programmer’s Perspective (Beta Draft), PartⅠ， Chapt.Ⅱ， 2.4
③:  Rechard Blum, Professional Assembly Language

youbest

先保存下来,再努力学习.

soloforce

Post by youbest
先保存下来,再努力学习.

还请youbest大大多多指教！

well

好贴!顶一个
这让我想起，在计算的时候需要注意：
1.避免大数“吃掉”小数
比如算 10^9+1=0.1*10^10 + 0.0000000001*10^10,在8位计算机中加号后面的表达式因为对阶而下溢为0
2.避免两个近似数相减
此时可以变减为其他运算，比如lnx1-lnx2=ln(x1/x2)
3.简化计算步骤，减少计算次数
可以避免误差的积累，比如算x^255，一般要算254次，但用秦九韶法可以大大减少运算次数
4.注意计算顺序
比如算I[n]=x^n/(x+5)在0到1上的积分，I[n]=1/n-5I[n-1], 如果这样算I[n]+5I[n-1]=1/n,那么I[n-1]前的系数5将造成误差以5倍递增，但如果改为： I[n-1]=-1/5I[n]+1/n, 那么。。。
5.避免两个大数相运算

DoDo

太棒了!
作为大家的一个练习, 转一段经典代码供大家阅读
这是 Carmack 在 Doom3 中使用的计算平方根的算法
[PHP]
float SquareRootFloat(float number) {
    long i;
    float x, y;
    const float f = 1.5F;
    x = number * 0.5F;
    y  = number;
    i  = * ( long * ) &y;
    i  = 0x5f3759df - ( i >> 1 );  //注意这一行
    y  = * ( float * ) &i;
    y  = y * ( f - ( x * y * y ) );
    y  = y * ( f - ( x * y * y ) );
    return number * y;
}
[/PHP]

DoDo

再转一段对它的分析

2. 发信人: coolfantasy (Cool), 信区: SoftDesign
3. 标  题: Re: 谁看得懂这段代码?
4. 发信站: 北邮人论坛 (Wed Jun 14 17:48:57 2006), 站内
6. 发信人: twosky (暗夜的飞鸟), 信区: Programming
7. 标  题: Re: 转篇文章《John Carmack密码：0x5f3759df》
8. 发信站: 水木社区 (Wed Jun 14 09:53:43 2006), 站内
10. zz  
12. http://bbs.gameres.com/showthread.asp?threadid=46513
14. 日前在书上看到一段使用多项式逼近计算平方根的代码，至今都没搞明白作者是怎样推算出那个公式的。但在尝试解决问题的过程中，学到了不少东西，于是便有了这篇心得，写出来和大家共享。其中有错漏的地方，还请大家多多指教。
16. 的确，正如许多人所说的那样，现在有有FPU，有3DNow，有SIMD，讨论软件算法好像不合时宜。关于sqrt的话题其实早在2003年便已在 GameDev.net上得到了广泛的讨论（可见我实在非常火星了，当然不排除还有其他尚在冥王星的人，嘿嘿）。而尝试探究该话题则完全是出于本人的兴趣和好奇心（换句话说就是无知）。
18. 我只是个beginner，所以这种大是大非的问题我也说不清楚（在GameDev.net上也有很多类似的争论）。但无论如何，Carmack在 DOOM3中还是使用了软件算法，而多知道一点数学知识对3D编程来说也只有好处没坏处。3D图形编程其实就是数学，数学，还是数学。
20. 文章原本是用HTML编排的，所以只截取了部分有比较有趣的东西放在这里。原文在我的个人主页上，同时也提供了2篇论文的下载：http://greatsorcerer.go2.icpcn.com/info/fastsqrt.html
22. =========================================================
24. 在3D图形编程中，经常要求平方根或平方根的倒数，例如：求向量的长度或将向量归一化。C数学函数库中的sqrt具有理想的精度，但对于3D游戏程式来说速度太慢。我们希望能够在保证足够的精度的同时，进一步提高速度。
26. Carmack在QUAKE3中使用了下面的算法，它第一次在公众场合出现的时候，几乎震住了所有的人。据说该算法其实并不是Carmack发明的，它真正的作者是Nvidia的Gary Tarolli（未经证实）。
27. －－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
28. //
29. // 计算参数x的平方根的倒数
30. //
31. float InvSqrt (float x)
32. {
33. float xhalf = 0.5f*x;
34. int i = *(int*)&x;
35. i = 0x5f3759df - (i >> 1); // 计算第一个近似根
36. x = *(float*)&i;
37. x = x*(1.5f - xhalf*x*x); // 牛顿迭代法
38. return x;
39. }
40. －－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
41. 该算法的本质其实就是牛顿迭代法（Newton-Raphson Method，简称NR），而NR的基础则是泰勒级数（Taylor Series）。NR是一种求方程的近似根的方法。首先要估计一个与方程的根比较靠近的数值，然后根据公式推算下一个更加近似的数值，不断重复直到可以获得满意的精度。其公式如下：
42. －－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
43. 函数：y=f(x)
44. 其一阶导数为：y'=f'(x)
45. 则方程：f(x)=0 的第n+1个近似根为
46. x[n+1] = x[n] - f(x[n]) / f'(x[n])
47. －－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
48. NR最关键的地方在于估计第一个近似根。如果该近似根与真根足够靠近的话，那么只需要少数几次迭代，就可以得到满意的解。
50. 现在回过头来看看如何利用牛顿法来解决我们的问题。求平方根的倒数，实际就是求方程1/(x^2)-a=0的解。将该方程按牛顿迭代法的公式展开为：
51. x[n+1]=1/2*x[n]*(3-a*x[n]*x[n])
52. 将1/2放到括号里面，就得到了上面那个函数的倒数第二行。
54. 接着，我们要设法估计第一个近似根。这也是上面的函数最神奇的地方。它通过某种方法算出了一个与真根非常接近的近似根，因此它只需要使用一次迭代过程就获得了较满意的解。它是怎样做到的呢？所有的奥妙就在于这一行：
55. i = 0x5f3759df - (i >> 1); // 计算第一个近似根
57. 超级莫名其妙的语句，不是吗？但仔细想一下的话，还是可以理解的。我们知道，IEEE标准下，float类型的数据在32位系统上是这样表示的（大体来说就是这样，但省略了很多细节，有兴趣可以GOOGLE）：
58. －－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
59. bits：31 30 ... 0
60. 31：符号位
61. 30-23：共8位，保存指数（E）
62. 22-0：共23位，保存尾数（M）
63. －－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
64. 所以，32位的浮点数用十进制实数表示就是：M*2^E。开根然后倒数就是：M^(-1/2)*2^(-E/2)。现在就十分清晰了。语句i> >1其工作就是将指数除以2，实现2^(E/2)的部分。而前面用一个常数减去它，目的就是得到M^(1/2)同时反转所有指数的符号。
66. 至于那个0x5f3759df，呃，我只能说，的确是一个超级的Magic Number。
68. 那个Magic Number是可以推导出来的，但我并不打算在这里讨论，因为实在太繁琐了。简单来说，其原理如下：因为IEEE的浮点数中，尾数M省略了最前面的1，所以实际的尾数是1+M。如果你在大学上数学课没有打瞌睡的话，那么当你看到(1+M)^(-1/2)这样的形式时，应该会马上联想的到它的泰勒级数展开，而该展开式的第一项就是常数。下面给出简单的推导过程：
69. －－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
70. 对于实数R>0，假设其在IEEE的浮点表示中，
71. 指数为E，尾数为M，则：
73. R^(-1/2)
74. = (1+M)^(-1/2) * 2^(-E/2)
76. 将(1+M)^(-1/2)按泰勒级数展开，取第一项，得：
78. 原式
79. = (1-M/2) * 2^(-E/2)
80. = 2^(-E/2) - (M/2) * 2^(-E/2)
82. 如果不考虑指数的符号的话，
83. (M/2)*2^(E/2)正是(R>>1)，
84. 而在IEEE表示中，指数的符号只需简单地加上一个偏移即可，
85. 而式子的前半部分刚好是个常数，所以原式可以转化为：
87. 原式 = C - (M/2)*2^(E/2) = C - (R>>1)，其中C为常数
89. 所以只需要解方程：
90. R^(-1/2)
91. = (1+M)^(-1/2) * 2^(-E/2)
92. = C - (R>>1)
93. 求出令到相对误差最小的C值就可以了
94. －－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
95. 上面的推导过程只是我个人的理解，并未得到证实。而Chris Lomont则在他的论文中详细讨论了最后那个方程的解法，并尝试在实际的机器上寻找最佳的常数C。有兴趣的朋友可以在文末找到他的论文的链接。
97. 所以，所谓的Magic Number，并不是从N元宇宙的某个星系由于时空扭曲而掉到地球上的，而是几百年前就有的数学理论。只要熟悉NR和泰勒级数，你我同样有能力作出类似的优化。
99. 在GameDev.net上有人做过测试，该函数的相对误差约为0.177585%，速度比C标准库的sqrt提高超过20%。如果增加一次迭代过程，相对误差可以降低到e-004 的级数，但速度也会降到和sqrt差不多。据说在DOOM3中，Carmack通过查找表进一步优化了该算法，精度近乎完美，而且速度也比原版提高了一截（正在努力弄源码，谁有发我一份）。
101. 值得注意的是，在Chris Lomont的演算中，理论上最优秀的常数（精度最高）是0x5f37642f，并且在实际测试中，如果只使用一次迭代的话，其效果也是最好的。但奇怪的是，经过两次NR后，在该常数下解的精度将降低得非常厉害（天知道是怎么回事！）。经过实际的测试，Chris Lomont认为，最优秀的常数是0x5f375a86。如果换成64位的double版本的话，算法还是一样的，而最优常数则为 0x5fe6ec85e7de30da（又一个令人冒汗的Magic Number - -b）。
103. 这个算法依赖于浮点数的内部表示和字节顺序，所以是不具移植性的。如果放到Mac上跑就会挂掉。如果想具备可移植性，还是乖乖用sqrt好了。但算法思想是通用的。大家可以尝试推算一下相应的平方根算法。
105. 下面给出Carmack在QUAKE3中使用的平方根算法。Carmack已经将QUAKE3的所有源代码捐给开源了，所以大家可以放心使用，不用担心会受到律师信。
106. －－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
107. //
108. // Carmack在QUAKE3中使用的计算平方根的函数
109. //
110. float CarmSqrt(float x){
111. union{
112. int intPart;
113. float floatPart;
114. } convertor;
115. union{
116. int intPart;
117. float floatPart;
118. } convertor2;
119. convertor.floatPart = x;
120. convertor2.floatPart = x;
121. convertor.intPart = 0x1FBCF800 + (convertor.intPart >> 1);
122. convertor2.intPart = 0x5f3759df - (convertor2.intPart >> 1);
123. return 0.5f*(convertor.floatPart + (x * convertor2.floatPart));
124. }

复制代码

另外 http://sd.csdn.net/n/20060607/91403.html 也提供了一些分析

2. John Carmack密码：0x5f3759df
4. 2006.06.07   
6. 有人在Quake III的源代码里面发现这么一段用来求平方根的代码:
8. /*
9. ================
10. SquareRootFloat
11. ================
12. */
13. float SquareRootFloat(float number) {
14.     long i;
15.     float x, y;
16.     const float f = 1.5F;
18.     x = number * 0.5F;
19.     y  = number;
20.     i  = * ( long * ) &y;
21.     i  = 0x5f3759df - ( i >> 1 );        //注意这一行
22.     y  = * ( float * ) &i;
23.     y  = y * ( f - ( x * y * y ) );
24.     y  = y * ( f - ( x * y * y ) );
25.     return number * y;
26. }
28. 0x5f3759df？ 这是个什么东西？ 学过数值分析就知道，算法里面求平方根一般采用的是无限逼近的方法，比如牛顿迭代法，抱歉当年我数值分析学的太烂，也讲不清楚。简单来说比如求5的平方根，选一个猜测值比如2，那么我们可以这么算
30.     5/2 = 2.5; 2.5+2/2 = 2.25; 5/2.25 = xxx; 2.25+xxx/2 = xxxx ...
32. 这样反复迭代下去，结果必定收敛于sqrt(5)，没错，一般的求平方根都是这么算的。而卡马克的不同之处在于，他选择了一个神秘的猜测值 0x5f3759df作为起始，使得整个逼近过程收敛速度暴涨，对于Quake III所要求的精度10的负三次方，只需要一次迭代就能够得到结果。
34. 好吧，如果这还不算牛b，接着看。
36. 普渡大学的数学家Chris Lomont看了以后觉得有趣，决定要研究一下卡马克弄出来的这个猜测值有什么奥秘。Lomont也是个牛人，在精心研究之后从理论上也推导出一个最佳猜测值，和卡马克的数字非常接近, 0x5f37642f。卡马克真牛，他是外星人吗？
38. 传奇并没有在这里结束。Lomont计算出结果以后非常满意，于是拿自己计算出的起始值和卡马克的神秘数字做比赛，看看谁的数字能够更快更精确的求得平方根。结果是卡马克赢了... 谁也不知道卡马克是怎么找到这个数字的。
40. 最后Lomont怒了，采用暴力方法一个数字一个数字试过来，终于找到一个比卡马克数字要好上那么一丁点的数字，虽然实际上这两个数字所产生的结果非常近似，这个暴力得出的数字是0x5f375a86。
42. Lomont为此写下一篇论文，"Fast Inverse Square Root"。
44. John Carmack， ID的无价之宝。
46. 来源blog：http://jan.yculblog.com/

复制代码

DoDo

其中提到的 "Fast Inverse Square Root" 一书的下载地址
http://www.math.purdue.edu/~clomont/Math/Papers/2003/InvSqrt.pdf

soloforce

不错！强烈建议DoDo新开一帖, 给我们介绍数值计算里头的神奇东东


ps:

2. float CarmSqrt(float x){
3. union{
4. int intPart;
5. float floatPart;
6. } convertor;
7. union{
8. int intPart;
9. float floatPart;
10. } convertor2;
11. convertor.floatPart = x;
12. convertor2.floatPart = x;
13. convertor.intPart = 0x1FBCF800 + (convertor.intPart >> 1);
14. convertor2.intPart = 0x5f3759df - (convertor2.intPart >> 1);
15. return 0.5f*(convertor.floatPart + (x * convertor2.floatPart));
16. }

复制代码

这个精确度很低阿

DoDo

不好意思, 我只是转帖, 我自己不懂什么的

xfliu

拜读大作，真是不错。不过有几点建议还请参考。

第二节表示形式中， 给的示意图中标有 最高位，最低位，略有歧义。
指数位、尾数位均有最高位和最低位。

另外，补充一点，0.1在rounding to infinity and rouding to near 模式下，二进制码为
0x3dcccccd，而在rounding to 0 和 rounding to negtive infinity模式下，二进制码为
0x3dcccccc.