浮点舍入错误。由于缺少5的素因子，0.1在基-2中不能像在基-10中那样精确地表示。正如1/3以十进制表示需要无限位数，但以3为基数表示为“0.1”，0.1以2为基数表示，而以10为基数不表示。计算机没有无限的内存。

一些统计数据与这个著名的双精度问题有关。

当使用0.1（从0.1到100）的步长将所有值（a+b）相加时，精度误差的概率约为15%。请注意，该错误可能会导致稍大或稍小的值。以下是一些示例：

0.1 + 0.2 = 0.30000000000000004 (BIGGER)
0.1 + 0.7 = 0.7999999999999999 (SMALLER)
...
1.7 + 1.9 = 3.5999999999999996 (SMALLER)
1.7 + 2.2 = 3.9000000000000004 (BIGGER)
...
3.2 + 3.6 = 6.800000000000001 (BIGGER)
3.2 + 4.4 = 7.6000000000000005 (BIGGER)

当使用0.1（从100到0.1）的步长减去所有值（a-b，其中a>b）时，我们有大约34%的精度误差。以下是一些示例：

0.6 - 0.2 = 0.39999999999999997 (SMALLER)
0.5 - 0.4 = 0.09999999999999998 (SMALLER)
...
2.1 - 0.2 = 1.9000000000000001 (BIGGER)
2.0 - 1.9 = 0.10000000000000009 (BIGGER)
...
100 - 99.9 = 0.09999999999999432 (SMALLER)
100 - 99.8 = 0.20000000000000284 (BIGGER)

*15%和34%确实是巨大的，所以当精度非常重要时，请始终使用BigDecimal。使用2个十进制数字（步骤0.01），情况会进一步恶化（18%和36%）。

这里的大多数答案都用非常枯燥的技术术语来解决这个问题。我想用正常人能够理解的方式来解决这个问题。

想象一下，你正试图把披萨切成薄片。你有一个机器人披萨切割机，可以将披萨切成两半。它可以将整个披萨减半，也可以将现有的披萨减半，但无论如何，减半总是准确的。

那台披萨切割机动作非常精细，如果你从一整块披萨开始，然后将其减半，然后继续每次将最小的披萨片减半，你可以在披萨片太小甚至无法实现高精度功能之前，将其减半53次。此时，您不能再将非常薄的切片减半，但必须按原样包含或排除它。

现在，你如何将所有的切片以这样一种方式分割，使其达到披萨的十分之一（0.1）或五分之一（0.2）？真的想一想，试着解决它。如果你手边有一个神话般的精密披萨切割机，你甚至可以尝试使用真正的披萨

当然，大多数有经验的程序员都知道真正的答案，那就是，无论你切得多细，都无法用这些切片拼凑出十分之一或五分之一的披萨。你可以做一个非常好的近似值，如果你把0.1的近似值和0.2的近似值相加，你会得到非常好的0.3的近似值。

对于双精度数字（允许您将披萨减半53次的精度），小于或大于0.1的数字分别为0.09999999999999999167332731531132594682276248931884765625和0.1000000000000000055511151231257827021181583404541015625。后者比前者更接近0.1，因此，如果输入值为0.1，数字解析器将倾向于后者。

（这两个数字之间的区别是“最小切片”，我们必须决定是否包含，这会引入向上的偏差，或者排除，这会带来向下的偏差。最小切片的技术术语是ulp。）

在0.2的情况下，数字都是相同的，只是放大了2倍。同样，我们赞成略高于0.2的值。

注意，在这两种情况下，0.1和0.2的近似值都有轻微的向上偏差。如果我们加上足够多的这些偏差，它们会将数字推离我们想要的越来越远，事实上，在0.1+0.2的情况下，偏差足够高，从而导致的数字不再是最接近0.3的数字。

特别是，0.1+0.2实际上是0.1000000000000000055511151231257827021181583404541015625+0.0200000000000000011102230246251565404236316680908203125=0.30000000000000000444089209850062616169452667236328125，而最接近0.3的数字实际上是0.29999999999988897769753748434595763683319091796875。

另外，一些编程语言还提供了披萨切割机，可以将披萨切成十分之一。虽然这种披萨切刀并不常见，但如果你有机会切到一个，那么你应该在切到十分之一或五分之一的披萨片非常重要的时候使用它。

（最初发布在Quora上。）

为了好玩，我按照标准C99的定义玩了浮点数的表示，并编写了下面的代码。

代码以3个独立的组打印浮点的二进制表示

SIGN EXPONENT FRACTION

然后，它打印一个和，当以足够的精度求和时，它将显示硬件中真正存在的值。

因此，当你写float x=999…时，编译器会将该数字转换为函数xx打印的位表示，这样函数yy打印的和就等于给定的数字。

事实上，这个总数只是一个近似值。对于数字999999999，编译器将在浮点的位表示中插入数字1000000000

代码之后，我附加了一个控制台会话，在该会话中，我计算硬件中真正存在的两个常量（减去PI和999999999）的项和，并由编译器插入其中。

#include <stdio.h>
#include <limits.h>

void
xx(float *x)
{
    unsigned char i = sizeof(*x)*CHAR_BIT-1;
    do {
        switch (i) {
        case 31:
             printf("sign:");
             break;
        case 30:
             printf("exponent:");
             break;
        case 23:
             printf("fraction:");
             break;

        }
        char b=(*(unsigned long long*)x&((unsigned long long)1<<i))!=0;
        printf("%d ", b);
    } while (i--);
    printf("\n");
}

void
yy(float a)
{
    int sign=!(*(unsigned long long*)&a&((unsigned long long)1<<31));
    int fraction = ((1<<23)-1)&(*(int*)&a);
    int exponent = (255&((*(int*)&a)>>23))-127;

    printf(sign?"positive" " ( 1+":"negative" " ( 1+");
    unsigned int i = 1<<22;
    unsigned int j = 1;
    do {
        char b=(fraction&i)!=0;
        b&&(printf("1/(%d) %c", 1<<j, (fraction&(i-1))?'+':')' ), 0);
    } while (j++, i>>=1);

    printf("*2^%d", exponent);
    printf("\n");
}

void
main()
{
    float x=-3.14;
    float y=999999999;
    printf("%lu\n", sizeof(x));
    xx(&x);
    xx(&y);
    yy(x);
    yy(y);
}

这里是一个控制台会话，我在其中计算硬件中存在的浮点值的实际值。我使用bc打印主程序输出的项的总和。可以将该和插入python-repl或类似的内容中。

-- .../terra1/stub
@ qemacs f.c
-- .../terra1/stub
@ gcc f.c
-- .../terra1/stub
@ ./a.out
sign:1 exponent:1 0 0 0 0 0 0 fraction:0 1 0 0 1 0 0 0 1 1 1 1 0 1 0 1 1 1 0 0 0 0 1 1
sign:0 exponent:1 0 0 1 1 1 0 fraction:0 1 1 0 1 1 1 0 0 1 1 0 1 0 1 1 0 0 1 0 1 0 0 0
negative ( 1+1/(2) +1/(16) +1/(256) +1/(512) +1/(1024) +1/(2048) +1/(8192) +1/(32768) +1/(65536) +1/(131072) +1/(4194304) +1/(8388608) )*2^1
positive ( 1+1/(2) +1/(4) +1/(16) +1/(32) +1/(64) +1/(512) +1/(1024) +1/(4096) +1/(16384) +1/(32768) +1/(262144) +1/(1048576) )*2^29
-- .../terra1/stub
@ bc
scale=15
( 1+1/(2) +1/(4) +1/(16) +1/(32) +1/(64) +1/(512) +1/(1024) +1/(4096) +1/(16384) +1/(32768) +1/(262144) +1/(1048576) )*2^29
999999999.999999446351872

就是这样。999999999的值实际上是

999999999.999999446351872

您也可以通过bc检查-3.14也受到干扰。不要忘记在bc中设置比例因子。

显示的金额是硬件内部的金额。通过计算它获得的值取决于设置的比例。我确实将比例因子设置为15。数学上，以无限的精度，它似乎是1000000000。

硬件设计师的视角

我认为，既然我设计并构建了浮点硬件，我就应该添加一个硬件设计师的视角。了解错误的来源可能有助于了解软件中发生的情况，最终，我希望这有助于解释为什么浮点错误会发生并似乎会随着时间累积的原因。

1.概述

从工程角度来看，大多数浮点运算都会有一些误差，因为进行浮点运算的硬件只需要在最后一个位置的误差小于一个单位的一半。因此，许多硬件将停止在一个精度上，该精度只需要在单个操作的最后位置产生小于一个单位的一半的误差，这在浮点除法中尤其有问题。什么构成一个操作取决于该单元需要多少个操作数。大多数情况下，它是两个，但有些单位需要3个或更多操作数。因此，不能保证重复操作会导致期望的错误，因为错误会随着时间的推移而增加。

2.标准

大多数处理器遵循IEEE-754标准，但有些处理器使用非规范化或不同的标准例如，IEEE-754中存在一种非规范化模式，该模式允许以精度为代价表示非常小的浮点数。然而，下面将介绍IEEE-754的标准化模式，这是典型的操作模式。

在IEEE-754标准中，硬件设计者可以使用误差/ε的任何值，只要它在最后一个位置小于一个单位的一半，并且一次操作的结果只需要在最后一位小于一个单元的一半。这解释了为什么当重复操作时，错误会增加。对于IEEE-754双精度，这是第54位，因为53位用于表示浮点数的数字部分（标准化），也称为尾数（例如5.3e5中的5.3）。下一节将更详细地介绍各种浮点操作的硬件错误原因。

3.除法舍入误差的原因

浮点除法误差的主要原因是用于计算商的除法算法。大多数计算机系统使用逆函数的乘法来计算除法，主要是Z=X/Y，Z=X*（1/Y）。迭代地计算除法，即每个周期计算商的一些比特，直到达到所需的精度，对于IEEE-754来说，这是最后一位误差小于一个单位的任何值。Y（1/Y）的倒数表在慢除法中被称为商选择表（QST），商选择表的位大小通常是基数的宽度，或每次迭代中计算的商的位数，加上几个保护位。对于IEEE-754标准，双精度（64位），它将是除法器基数的大小，加上几个保护位k，其中k>=2。因此，例如，一次计算2位商（基数4）的除法器的典型商选择表将是2+2=4位（加上几个可选位）。

3.1除法舍入误差：倒数近似

商选择表中的倒数取决于除法：慢除法如SRT除法，或快除法如Goldschmidt除法；根据除法算法修改每个条目，以尝试产生最小的可能误差。然而，在任何情况下，所有的倒数都是实际倒数的近似值，并引入了一些误差因素。慢除法和快除法都迭代地计算商，即每一步计算商的一些位数，然后从被除数中减去结果，除法器重复这些步骤，直到误差小于最后一个单位的一半。慢除法计算每一步的商的固定位数，通常构建成本较低，而快除法计算每步的位数可变，构建成本通常较高。除法中最重要的部分是，它们大多依赖于通过倒数的近似值进行重复乘法，因此容易出错。

4.其他操作中的舍入错误：截断

所有操作中舍入误差的另一个原因是IEEE-754允许的最终答案的不同截断模式。有截断、向零舍入、向最接近（默认）舍入、向下舍入和向上舍入。所有方法都会在单个操作的最后位置引入小于一个单位的误差元素。随着时间的推移和重复操作，截断也会累积地增加结果误差。这种截断误差在涉及某种形式的重复乘法的求幂运算中尤其有问题。

5.重复操作

由于执行浮点计算的硬件只需要在单个操作的最后一个位置产生误差小于一个单位的一半的结果，因此如果不注意，误差将随着重复操作而增加。这就是为什么在需要有界误差的计算中，数学家使用诸如在IEEE-754的最后一位使用舍入到最接近的偶数位的方法，因为随着时间的推移，误差更可能相互抵消，而区间算术结合了IEEE754舍入模式的变化来预测舍入误差，并对其进行校正。由于与其他舍入模式相比，其相对误差较低，因此舍入到最近的偶数位（最后一位）是IEEE-754的默认舍入模式。

请注意，默认舍入模式（舍入到最后一位最接近的偶数位）保证一次操作的误差小于最后一位单位的一半。仅使用截断、向上舍入和向下舍入可能会导致误差大于最后一位一个单位的一半，但小于最后一位的一个单位，因此不建议使用这些模式，除非它们用于区间算术。

6.总结

简而言之，浮点运算中出现错误的根本原因是硬件中的截断和除法中倒数的截断。由于IEEE-754标准只要求单个操作的误差小于最后一位一个单位的一半，因此重复操作中的浮点误差将相加，除非得到纠正。

浮点数的陷阱是它们看起来像十进制，但它们是二进制的。

2的唯一素因子是2，而10的素因子为2和5。这样做的结果是，每一个可以完全写成二进制分数的数字也可以完全写成十进制分数，但只有一部分可以写成十进制分数的数字可以写成二进制分数。

浮点数本质上是一个有效位数有限的二进制分数。如果你超过这些有效数字，那么结果将被四舍五入。

当您在代码中键入文字或调用函数将浮点数解析为字符串时，它需要一个十进制数，并将该十进制数的二进制近似值存储在变量中。

当您打印浮点数或调用函数将浮点数转换为字符串时，它将打印浮点数的十进制近似值。可以将二进制数字精确地转换为十进制，但在转换为字符串*时，我所知道的任何语言都不会默认这样做。一些语言使用固定数量的有效数字，其他语言使用最短的字符串，该字符串将“往返”返回到相同的浮点值。

*Python在将浮点数转换为“decimal.decimal”时确实会进行精确的转换。这是我所知道的获得浮点数的精确十进制等效值的最简单方法。