这个问题的许多重复问题都是关于浮点舍入对特定数字的影响。在实践中，通过查看感兴趣的计算的确切结果而不是仅仅阅读它，更容易了解它的工作原理。一些语言提供了实现这一点的方法，例如在Java中将浮点或双精度转换为BigDecimal。

由于这是一个语言不可知的问题，因此需要语言不可知工具，例如十进制到浮点转换器。

将其应用于问题中的数字，视为双精度：

0.1转换为0.1000000000000000055511151231257827021181583404541015625，

0.2转换为0.200000000000000011102230246251565404236316680908203125，

0.3转换为0.299999999999999988897769753748434595763683319091796875，以及

0.300000000000000004转换为0.30000000000000000444089209850062616169452667236328125。

手动或在十进制计算器（如Full Precision calculator）中添加前两个数字，显示实际输入的精确和为0.30000000000000000166533453693773481063544750213623046875。

如果四舍五入到等于0.3，则舍入误差将为0.000000000000000027755575615628913510591702705078125。四舍五入等于0.300000000000000004也会产生舍入误差0.000000000000000027755575615628913510591702705078125。打成平手的规则适用。

返回浮点转换器，0.300000000000000004的原始十六进制是3fd333333333334，以偶数结尾，因此是正确的结果。

二进制浮点数学是这样的。在大多数编程语言中，它基于IEEE 754标准。问题的关键在于，数字以这种格式表示为整数乘以2的幂；分母不是2的幂的有理数（如0.1，即1/10）无法精确表示。

对于标准binary64格式的0.1，表示形式可以完全写为

0.1000000000000000055511151231257827021181583404541015625（十进制），或0x1.999999999999ap-4，采用C99六进制浮点数表示法。

相比之下，有理数0.1（1/10）可以完全写成

0.1（十进制），或0x1.999999999999999…p-4，类似于C99十六进制浮点数，其中。。。表示9的无限序列。

程序中的常数0.2和0.3也将近似于其真实值。恰好最接近0.2的两倍大于有理数0.2，但最接近0.3的两倍小于有理数0.3。0.1和0.2的和最终大于有理数0.3，因此与代码中的常数不一致。

浮点运算问题的一个相当全面的处理是每个计算机科学家都应该知道的浮点运算。有关更容易理解的解释，请参阅floatingpoint-gui.de。

边注：所有位置（以N为基数）数字系统都有精度问题

普通的十进制（以10为基数）数字也有同样的问题，这就是为什么像1/3这样的数字最终会变成0.33333333。。。

您刚刚偶然发现了一个数字（3/10），它很容易用十进制表示，但不适合二进制。它也是双向的（在某种程度上）：1/16在十进制中是一个丑陋的数字（0.0625），但在二进制中，它看起来和十进制中的第10000个一样整洁（0.0001）**-如果我们在日常生活中习惯使用基数为2的数字系统，你甚至会看着这个数字，本能地理解你可以通过将某个数字减半，一次又一次地减半来达到这个目的。

当然，这并不是浮点数在内存中的存储方式（它们使用了一种科学的表示法）。然而，它确实说明了一点，二进制浮点精度错误往往会出现，因为我们通常感兴趣的“真实世界”数字往往是十的幂，但这只是因为我们每天使用十进制数字系统。这也是为什么我们会说71%而不是“每7取5”（71%是一个近似值，因为5/7不能用任何小数精确表示）。

所以不：二进制浮点数并没有被破坏，它们只是碰巧和其他N进制一样不完美：）

边注：在编程中使用浮点

实际上，这种精度问题意味着在显示浮点数之前，需要使用舍入函数将浮点数舍入到您感兴趣的小数位数。

您还需要用允许一定公差的比较来替换相等测试，这意味着：

如果（x==y）｛…｝则不执行

相反，如果（abs（x-y）<myToleranceValue）｛…｝，则执行此操作。

其中abs是绝对值。需要为您的特定应用程序选择myToleranceValue，这与您准备允许多少“摆动空间”以及您将要比较的最大值（由于精度损失问题）有很大关系。当心您选择的语言中的“epsilon”样式常量。这些值可以用作公差值，但它们的有效性取决于您使用的数字的大小，因为使用大数字的计算可能会超过epsilon阈值。

硬件设计师的视角

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

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标准只要求单个操作的误差小于最后一位一个单位的一半，因此重复操作中的浮点误差将相加，除非得到纠正。

十进制数（如0.1、0.2和0.3）在二进制编码浮点类型中没有精确表示。0.1和0.2的近似值之和与0.3的近似值不同，因此，0.1+0.2==0.3的错误在这里可以更清楚地看到：

#include <stdio.h>

int main() {
    printf("0.1 + 0.2 == 0.3 is %s\n", 0.1 + 0.2 == 0.3 ? "true" : "false");
    printf("0.1 is %.23f\n", 0.1);
    printf("0.2 is %.23f\n", 0.2);
    printf("0.1 + 0.2 is %.23f\n", 0.1 + 0.2);
    printf("0.3 is %.23f\n", 0.3);
    printf("0.3 - (0.1 + 0.2) is %g\n", 0.3 - (0.1 + 0.2));
    return 0;
}

输出：

0.1 + 0.2 == 0.3 is false
0.1 is 0.10000000000000000555112
0.2 is 0.20000000000000001110223
0.1 + 0.2 is 0.30000000000000004440892
0.3 is 0.29999999999999998889777
0.3 - (0.1 + 0.2) is -5.55112e-17

为了更可靠地计算这些计算，您需要对浮点值使用基于十进制的表示。C标准没有默认指定此类类型，而是作为技术报告中描述的扩展。

_Decimal32、_Decimal64和_Decimal128类型可能在您的系统上可用（例如，GCC在选定的目标上支持它们，但Clang在OS X上不支持它们）。

存储在计算机中的浮点数由两部分组成，一部分是整数，另一部分是基数乘以整数部分的指数。

如果计算机在基数为10的情况下工作，则0.1将是1 x 10⁻¹，0.2将是2 x 10⁻¹，0.3将是3 x 10⁻¹. 整数运算简单而准确，所以加上0.1+0.2显然会得到0.3。

计算机通常不以10为基数工作，而是以2为基数工作。对于某些值，仍然可以得到精确的结果，例如0.5是1 x 2⁻¹和0.25是1 x 2⁻²，将它们相加，结果为3 x 2⁻²或0.75。确切地

问题是数字可以精确地以10为基数表示，但不能以2为基数。这些数字需要四舍五入到最接近的相等值。假设非常常见的IEEE 64位浮点格式，最接近0.1的数字是3602879701896397 x 2⁻⁵⁵, 最接近0.2的数字是7205759403792794 x 2⁻⁵⁵; 将它们相加，得到10808639105689191 x 2⁻⁵⁵, 或精确的十进制值0.30000000000000000444089209850062616169452667236328125。浮点数通常四舍五入以显示。

想象一下，以10为基数，例如8位数的精度工作。您检查是否

1/3 + 2 / 3 == 1

并了解到这返回错误。为什么？好吧，作为真实的数字

1/3=0.333….和2/3=0.666。。。。

在小数点后八位截断，我们得到

0.33333333 + 0.66666666 = 0.99999999

当然，这与1.00000000正好相差0.00000001。

具有固定位数的二进制数的情况完全类似。作为实数，我们有

1/10=0.0001100110011001100…（底座2）

and

1/5=0.00111001100110011001…（底座2）

如果我们把这些截成七位

0.0001100 + 0.0011001 = 0.0100101

而另一方面，

3/10=0.010011001100110011…（基数2）

被截断为七位的值为0.0100110，两者相差0.0000001。

确切的情况稍显微妙，因为这些数字通常以科学符号存储。因此，例如，我们可以将其存储为1.10011*2^-4，而不是将1/10存储为0.0001100，这取决于我们为指数和尾数分配了多少位。这会影响计算的精度位数。

结果是，由于这些舍入错误，您根本不想在浮点数上使用==。相反，您可以检查它们的差值的绝对值是否小于某个固定的小数字。