深入浅出浮点数（转）

最新推荐文章于 2023-03-30 19:29:26 发布

metasearch

最新推荐文章于 2023-03-30 19:29:26 发布

阅读量1.3k

点赞数

分类专栏： C/C++ 文章标签： java 语言 signal 平台扩展 float

本文链接：https://blog.csdn.net/metasearch/article/details/2148210

版权

C/C++ 专栏收录该内容

190 篇文章 0 订阅

订阅专栏

深入浅出浮点数

Floating Point Number In a Nutshell

深入浅出浮点数

Stephen Suen

浮点数（Floating PointNumber）计算机系统中用于表达实数或者说小数的一种方式。由于其表达方式的原因，产生了围绕浮点数的许多常见问题。最典型的就是"为什么我的浮点运算的结果和想象的不同"，即浮点数精度损失问题。本文将回避关于浮点数枯燥的数值计算理论，基于Java平台的浮点数支持（当然，也适用于其它绝大部分编程语言），尽可能深入浅出的介绍浮点数的基本知识，和常见问题产生的原因。

本文的最新版本将发布在程序员咖啡馆网站上（建设中）。同时欢迎订阅我们的邮件组，以获得关于本文的正式发布及更新信息。

目录 1. 什么是浮点数 2. IEEE浮点数 3. 实数和浮点数之间的变换 4. 特殊值

4.1. NaN 4.2. 无穷 4.3. 有符号的零 4.4. 非规范化数

5. 参考资料

1. 什么是浮点数

在计算机系统的发展过程中，曾经提出过多种方法表达实数。典型的比如相对于浮点数的定点数（FixedPointNumber）。在这种表达方式中，小数点固定的位于实数所有数字中间的某个位置。货币的表达就可以使用这种方式，比如99.00 或者 00.99可以用于表达具有四位精度（Precision），小数点后有两位的货币值。由于小数点位置固定，所以可以直接用四位数值来表达相应的数值。SQL中的 NUMBER数据类型就是利用定点数来定义的。还有一种提议的表达方式为有理数表达方式，即用两个整数的比值来表达实数。

定点数表达法的缺点在于其形式过于僵硬，固定的小数点位置决定了固定位数的整数部分和小数部分，不利于同时表达特别大的数或者特别小的数。最终，绝大多数现代的计算机系统采纳了所谓的浮点数表达方式。这种表达方式利用科学计数法来表达实数，即用一个尾数（Mantissa），一个基数（Base），一个指数（Exponent）以及一个表示正负的符号来表达实数。比如123.45 用十进制科学计数法可以表达为 1.2345 × 10² ，其中1.2345 为尾数，10 为基数，2为指数。浮点数利用指数达到了浮动小数点的效果，从而可以灵活地表达更大范围的实数。

提示:尾数有时也称为有效数字（Significand）。尾数实际上是有效数字的非正式说法。

同样的数值可以有多种浮点数表达方式，比如上面例子中的 123.45可以表达为 12.345 × 10¹，0.12345 × 10³ 或者1.2345 ×10²。因为这种多样性，有必要对其加以规范化以达到统一表达的目标。规范的（Normalized）浮点数表达方式具有如下形式：

±d.dd...d × β^e , (0 ≤ d_i < β)

其中 d.dd...d 即尾数，β为基数，e为指数。尾数中数字的个数称为精度，在本文中用 p来表示。每个数字 d 介于 0 和基数之间，包括0。小数点左侧的数字不为 0。

基于规范表达的浮点数对应的具体值可由下面的表达式计算而得：

±(d ₀ + d₁β^-1 + ... + d_p-1β^-(p-1))β^e , (0 ≤ d_i < β)

对于十进制的浮点数，即基数 β 等于 10的浮点数而言，上面的表达式非常容易理解，也很直白。计算机内部的数值表达是基于二进制的。从上面的表达式，我们可以知道，二进制数同样可以有小数点，也同样具有类似于十进制的表达方式。只是此时β 等于 2，而每个数字 d 只能在 0 和 1之间取值。比如二进制数 1001.101 相当于 1 × 2 ³ + 0 ×2² + 0 × 2¹ + 1 × 2⁰ + 1 ×2^-1 + 0 × 2^-2 + 1 ×2^-3，对应于十进制的 9.625。其规范浮点数表达为 1.001101× 2³。

2. IEEE 浮点数

计算机中是用有限的连续字节保存浮点数的。保存这些浮点数当然必须有特定的格式，Java平台上的浮点数类型 float 和 double 采纳了 IEEE 754 标准中所定义的单精度 32位浮点数和双精度 64 位浮点数的格式。

注意: Java 平台还支持该标准定义的两种扩展格式，即float-extended-exponent 和 double-extended-exponent扩展格式。这里将不作介绍，有兴趣的读者可以参考相应的参考资料。

在 IEEE标准中，浮点数是将特定长度的连续字节的所有二进制位分割为特定宽度的符号域，指数域和尾数域三个域，其中保存的值分别用于表示给定二进制浮点数中的符号，指数和尾数。这样，通过尾数和可以调节的指数（所以称为"浮点"）就可以表达给定的数值了。具体的格式参见下面的图例：

在上面的图例中，第一个域为符号域。其中 0 表示数值为正数，而 1则表示负数。

第二个域为指数域，对应于我们之前介绍的二进制科学计数法中的指数部分。其中单精度数为8 位，双精度数为 11 位。以单精度数为例，8 位的指数为可以表达 0 到255 之间的 255个指数值。但是，指数可以为正数，也可以为负数。为了处理负指数的情况，实际的指数值按要求需要加上一个偏差（Bias）值作为保存在指数域中的值，单精度数的偏差值为 127，而双精度数的偏差值为1023。比如，单精度的实际指数值 0 在指数域中将保存为127；而保存在指数域中的 64 则表示实际的指数值 -63。偏差的引入使得对于单精度数，实际可以表达的指数值的范围就变成 -127到 128 之间（包含两端）。我们不久还将看到，实际的指数值-127（保存为全 0）以及 +128（保存为全1）保留用作特殊值的处理。这样，实际可以表达的有效指数范围就在 -127和 127 之间。在本文中，最小指数和最大指数分别用e_min 和e_max 来表达。

图例中的第三个域为尾数域，其中单精度数为 23 位长，双精度数为 52位长。除了我们将要讲到的某些特殊值外，IEEE标准要求浮点数必须是规范的。这意味着尾数的小数点左侧必须为1，因此我们在保存尾数的时候，可以省略小数点前面这个1，从而腾出一个二进制位来保存更多的尾数。这样我们实际上用 23位长的尾数域表达了 24 位的尾数。比如对于单精度数而言，二进制的1001.101（对应于十进制的 9.625）可以表达为 1.001101 ×2³，所以实际保存在尾数域中的值为00110100000000000000000，即去掉小数点左侧的 1，并用 0在右侧补齐。

值得注意的是，对于单精度数，由于我们只有 24位的指数（其中一位隐藏），所以可以表达的最大指数为 2²⁴ -1 = 16,777,215。特别的，16,777,216 是偶数，所以我们可以通过将它除以2 并相应地调整指数来保存这个数，这样 16,777,216同样可以被精确的保存。相反，数值 16,777,217则无法被精确的保存。由此，我们可以看到单精度的浮点数可以表达的十进制数值中，真正有效的数字不高于8 位。事实上，对相对误差的数值分析结果显示有效的精度大约为 7.22位。参考下面的示例：

        true value                stored value
        --------------------------------------
        16,777,215                1.6777215E7
        16,777,216                1.6777216E7
        16,777,217                1.6777216E7
        16,777,218                1.6777218E7
        16,777,219                1.677722E7
        16,777,220                1.677722E7
        16,777,221                1.677722E7
        16,777,222                1.6777222E7
        16,777,223                1.6777224E7
        16,777,224                1.6777224E7
        16,777,225                1.6777224E7
        --------------------------------------

根据标准要求，无法精确保存的值必须向最接近的可保存的值进行舍入。这有点像我们熟悉的十进制的四舍五入，即不足一半则舍，一半以上（包括一半）则进。不过对于二进制浮点数而言，还多一条规矩，就是当需要舍入的值刚好是一半时，不是简单地进，而是在前后两个等距接近的可保存的值中，取其中最后一位有效数字为零者。从上面的示例中可以看出，奇数都被舍入为偶数，且有舍有进。我们可以将这种舍入误差理解为"半位"的误差。所以，为了避免7.22 对很多人造成的困惑，有些文章经常以 7.5位来说明单精度浮点数的精度问题。

提示: 这里采用的浮点数舍入规则有时被称为舍入到偶数（RoundtoEven）。相比简单地逢一半则进的舍入规则，舍入到偶数有助于从某些角度减小计算中产生的舍入误差累积问题。因此为IEEE 标准所采用。

3. 实数和浮点数之间的变换

现在我们已经明白了浮点数的 IEEE表达方式。我们来做些实数和浮点数之间的变换练习以加深理解。在这些练习中，你还会发现一些围绕浮点数运算的令人吃惊的事实。

首先我们来看看事情简单的一面，从浮点数变换到实数。理解了浮点数的格式，做这个练习并不难。假定我们有一个32 位的数据，用十六进制表示为0xC0B40000，并且我们知道它实际上是一个单精度的浮点数。为了得到该浮点数实际表达的实数，我们首先将它变换为二进制形式：

  C    0    B    4    0    0    0    0
1100 0000 1011 0100 0000 0000 0000 0000

接着按照浮点数的格式切分为相应的域：

1  10000001 01101000000000000000000

符号域 1 意味着负数；指数域为 129 意味着实际的指数为 2（减去偏差值 127）；尾数域为 01101 意味着实际的二进制尾数为 1.01101（加上隐含的小数点前面的 1）。所以，实际的实数为：

-1.01101 × 2²
-(2⁰ + 2^-2 + 2^-3 2^-5) × 2²
-5.625

从实数向浮点数变换稍微麻烦一点。假定我们需要将实数 -9.625表达为单精度的浮点数格式。方法是首先将它用二进制浮点数表达，然后变换为相应的浮点数格式。

首先，将小数点左侧的整数部分变换为其二进制形式，9的二进制性形式为 1001。处理小数部分的算法是将我们的小数部分乘以基数2，记录乘积结果的整数部分，接着将结果的小数部分继续乘以2，并不断继续该过程：

0.625 × 2 = 1.25        1
0.25  × 2 = 0.5         0
0.5   × 2 = 1           1
0

当最后的结果为零时，结束这个过程。这时右侧的一列数字就是我们所需的二进制小数部分，即0.101。这样，我们就得到了完整的二进制形式1001.101。用规范浮点数表达为 1.001101 × 2³。

因为是负数，所以符号域为 1。指数为 3，所以指数域为 3 + 127 =130，即二进制的 10000010。尾数省略掉小数点左侧的 1 之后为001101，右侧用零补齐。最终结果为：

1 10000010 00110100000000000000000

最后可以将浮点数形式表示为十六进制的数据如下：

1100 0001 0001 1010 0000 0000 0000 0000
  C    1    1    A    0    0    0    0

最终结果为 0xC11A0000。

很简单？等等！你可能已经注意到了，在上面这个我们有意选择的示例中，不断的将产生的小数部分乘以2 的过程掩盖了一个事实。该过程结束的标志是小数部分乘以 2 的结果为1，不难想象，很多小数根本不能经过有限次这样的过程而得到结果（比如最简单的0.1）。我们已经知道浮点数尾数域的位数是有限的，为此，浮点数的处理办法是持续该过程直到由此得到的尾数足以填满尾数域，之后对多余的位进行舍入。换句话说，除了我们之前讲到的精度问题之外，十进制到二进制的变换也并不能保证总是精确的，而只能是近似值。事实上，只有很少一部分十进制小数具有精确的二进制浮点数表达。再加上浮点数运算过程中的误差累积，结果是很多我们看来非常简单的十进制运算在计算机上却往往出人意料。这就是最常见的浮点运算的"不准确"问题。参见下面的 Java 示例：

System.out.print("34.6-34.0=" + (34.6f-34.0f));

这段代码的输出结果如下：

34.6-34.0=0.5999985

产生这个误差的原因是 34.6无法精确的表达为相应的浮点数，而只能保存为经过舍入的近似值。这个近似值与34.0 之间的运算自然无法产生精确的结果。

4. 特殊值

通过前面的介绍，你应该已经了解的浮点数的基本知识，这些知识对于一个不接触浮点数应用的人应该足够了。不过，如果你兴趣正浓，或者面对着一个棘手的浮点数应用，可以通过本节了解到关于浮点数的一些值得注意的特殊之处。

我们已经知道，指数域实际可以表达的指数值的范围为 -127 到 128之间（包含两端）。其中，值 -127（保存为全 0）以及 +128（保存为全1）保留用作特殊值的处理。本节将详细 IEEE标准中所定义的这些特殊值。

浮点数中的特殊值主要用于特殊情况或者错误的处理。比如在程序对一个负数进行开平方时，一个特殊的返回值将用于标记这种错误，该值为NaN（Not aNumber）。没有这样的特殊值，对于此类错误只能粗暴地终止计算。除了NaN 之外，IEEE 标准还定义了 ±0，±∞ 以及非规范化数（DenormalizedNumber）。

对于单精度浮点数，所有这些特殊值都由保留的特殊指数值 -127 和 128来编码。如果我们分别用 e_min 和e_max来表达其它常规指数值范围的边界，即 -126 和127，则保留的特殊指数值可以分别表达为e_min - 1 和e_max + 1; 。基于这个表达方式，IEEE标准的特殊值如下所示：

其中 f表示尾数中的小数点右侧的（Fraction）部分。第一行即我们之前介绍的普通的规范化浮点数。随后我们将分别对余下的特殊值加以介绍。

4.1. NaN

NaN 用于处理计算中出现的错误情况，比如 0.0 除以 0.0或者求负数的平方根。由上面的表中可以看出，对于单精度浮点数，NaN表示为指数为 e_max + 1 =128（指数域全为 1），且尾数域不等于零的浮点数。IEEE标准没有要求具体的尾数域，所以 NaN实际上不是一个，而是一族。不同的实现可以自由选择尾数域的值来表达NaN，比如 Java 中的常量 Float.NaN的浮点数可能表达为01111111110000000000000000000000，其中尾数域的第一位为 1，其余均为0（不计隐藏的一位），但这取决系统的硬件架构。Java中甚至允许程序员自己构造具有特定位模式的 NaN 值（通过 Float.intBitsToFloat()方法）。比如，程序员可以利用这种定制的 NaN值中的特定位模式来表达某些诊断信息。

定制的 NaN 值，可以通过 Float.isNaN()方法判定其为 NaN，但是它和 Float.NaN 常量却不相等。实际上，所有的NaN 值都是无序的。数值比较操作符 <，<=，> 和 >=在任一操作数为 NaN 时均返回 false。等于操作符 == 在任一操作数为 NaN 时均返回false，即使是两个具有相同位模式的 NaN也一样。而操作符 != 则当任一操作数为 NaN 时返回 true。这个规则的一个有趣的结果是 x!=x 当 x 为 NaN 时竟然为真。

可以产生 NaN 的操作如下所示：

此外，任何有 NaN 作为操作数的操作也将产生 NaN。用特殊的 NaN来表达上述运算错误的意义在于避免了因这些错误而导致运算的不必要的终止。比如，如果一个被循环调用的浮点运算方法，可能由于输入的参数问题而导致发生这些错误，NaN 使得即使某次循环发生了这样的错误，也可以简单地继续执行循环以进行那些没有错误的运算。你可能想到，既然Java有异常处理机制，也许可以通过捕获并忽略异常达到相同的效果。但是，要知道，IEEE标准不是仅仅为 Java而制定的，各种语言处理异常的机制不尽相同，这将使得代码的迁移变得更加困难。何况，不是所有语言都有类似的异常或者信号（Signal）处理机制。

注意: Java 中，不同于浮点数的处理，整数的 0 除以 0 将抛出java.lang.ArithmeticException 异常。

4.2. 无穷

和 NaN 一样，特殊值无穷（Infinity）的指数部分同样为e_max + 1 =128，不过无穷的尾数域必须为零。无穷用于表达计算中产生的上溢（Overflow）问题。比如两个极大的数相乘时，尽管两个操作数本身可以用保存为浮点数，但其结果可能大到无法保存为浮点数，而必须进行舍入。根据 IEEE标准，此时不是将结果舍入为可以保存的最大的浮点数（因为这个数可能离实际的结果相差太远而毫无意义），而是将其舍入为无穷。对于负数结果也是如此，只不过此时舍入为负无穷，也就是说符号域为 1 的无穷。有了 NaN的经验我们不难理解，特殊值无穷使得计算中发生的上溢错误不必以终止运算为结果。

无穷和除 NaN以外的其它浮点数一样是有序的，从小到大依次为负无穷，负的有穷非零值，正负零（随后介绍），正的有穷非零值以及正无穷。除NaN以外的任何非零值除以零，结果都将是无穷，而符号则由作为除数的零的符号决定。

回顾我们对 NaN 的介绍，当零除以零时得到的结果不是无穷而是 NaN。原因不难理解，当除数和被除数都逼近于零时，其商可能为任何值，所以IEEE 标准决定此时用 NaN 作为商比较合适。

4.3. 有符号的零

因为 IEEE 标准的浮点数格式中，小数点左侧的 1是隐藏的，而零显然需要尾数必须是零。所以，零也就无法直接用这种格式表达而只能特殊处理。

实际上，零保存为尾数域为全为 0，指数域为e_min - 1 =-127，也就是说指数域也全为0。考虑到符号域的作用，所以存在着两个零，即 +0 和-0。不同于正负无穷之间是有序的，IEEE 标准规定正负零是相等的。

零有正负之分，的确非常容易让人困惑。这一点是基于数值分析的多种考虑，经利弊权衡后形成的结果。有符号的零可以避免运算中，特别是涉及无穷的运算中，符号信息的丢失。举例而言，如果零无符号，则等式 1/(1/x)= x 当x = ±∞ 时不再成立。原因是如果零无符号，1和正负无穷的比值为同一个零，然后 1 与 0的比值为正无穷，符号没有了。解决这个问题，除非无穷也没有符号。但是无穷的符号表达了上溢发生在数轴的哪一侧，这个信息显然是不能不要的。零有符号也造成了其它问题，比如当 x=y 时，等式1/x = 1/y 在 x 和 y 分别为 +0 和-0时，两端分别为正无穷和负无穷而不再成立。当然，解决这个问题的另一个思路是和无穷一样，规定零也是有序的。但是，如果零是有序的，则即使if (x==0) 这样简单的判断也由于 x 可能是±0 而变得不确定了。两害取其轻者，零还是无序的好。

4.4. 非规范化数

我们来考察浮点数的一个特殊情况。选择两个绝对值极小的浮点数，以单精度的二进制浮点数为例，比如1.001 × 2^-125 和 1.0001 × 2^-125这两个数（分别对应于十进制的 2.6448623 × 10^-38 和2.4979255 × 10^-38）。显然，他们都是普通的浮点数（指数为 -125，大于允许的最小值-126；尾数更没问题），按照 IEEE 754 可以分别保存为00000001000100000000000000000000（0x1100000）和00000001000010000000000000000000（0x1080000）。

现在我们看看这两个浮点数的差值。不难得出，该差值为 0.0001 ×2^-125，表达为规范浮点数则为 1.0 ×2^-129。问题在于其指数大于允许的最小指数值，所以无法保存为规范浮点数。最终，只能近似为零（FlushtoZero）。这中特殊情况意味着下面本来十分可靠的代码也可能出现问题：

if (x != y) {
  z = 1 / (x -y);
}

正如我们精心选择的两个浮点数展现的问题一样，即使 x 不等于 y，x和 y 的差值仍然可能绝对值过小，而近似为零，导致除以 0的情况发生。

为了解决此类问题，IEEE标准中引入了非规范（Denormalized）浮点数。规定当浮点数的指数为允许的最小指数值，即e_min时，尾数不必是规范化的。比如上面例子中的差值可以表达为非规范的浮点数0.001 × 2^-126，其中指数 -126 等于e_min。注意，这里规定的是"不必"，这也就意味着"可以"。当浮点数实际的指数为e_min，且指数域也为e_min时，该浮点数仍是规范的，也就是说，保存时隐含着一个隐藏的尾数位。为了保存非规范浮点数，IEEE标准采用了类似处理特殊值零时所采用的办法，即用特殊的指数域值e_min - 1加以标记，当然，此时的尾数域不能为零。这样，例子中的差值可以保存为00000000000100000000000000000000（0x100000），没有隐含的尾数位。

有了非规范浮点数，去掉了隐含的尾数位的制约，可以保存绝对值更小的浮点数。而且，也由于不再受到隐含尾数域的制约，上述关于极小差值的问题也不存在了，因为所有可以保存的浮点数之间的差值同样可以保存。