考虑以下代码：
0.1 + 0.2 == 0.3 -> false
0.1 + 0.2 -> 0.30000000000000004
为什么会出现这些错误？
当前回答
我刚刚看到了关于浮点数的有趣问题：
考虑以下结果：
error = (2**53+1) - int(float(2**53+1))
>>> (2**53+1) - int(float(2**53+1))
1
当2**53+1时，我们可以清楚地看到一个断点——直到2**53，所有的工作都正常。
>>> (2**53) - int(float(2**53))
0
发生这种情况的原因是双精度二进制：IEEE 754双精度二进制浮点格式：binary64
从维基百科的双精度浮点格式页面：
双精度二进制浮点是PC上常用的格式，因为它的范围比单精度浮点更广，尽管它的性能和带宽成本很高。与单精度浮点格式一样，与相同大小的整数格式相比，它缺少整数的精度。它通常简称为double。IEEE 754标准规定二进制64具有：符号位：1位指数：11位有效精度：53位（显式存储52位）具有给定偏置指数和52位分数的给定64位双精度数据假设的实际值为或
感谢@aguest向我指出了这一点。
其他回答
已经发布了很多好的答案，但我想再补充一个。
并非所有数字都可以通过浮点数/双精度表示例如，在IEEE754浮点标准中，数字“0.2”将以单精度表示为“0.200000003”。
用于在引擎盖下存储实数的模型将浮点数表示为
即使您可以轻松键入0.2，FLT_RADIX和DBL_RADIX都是2；对于使用“IEEE二进制浮点运算标准（ISO/IEC Std 754-1985）”的带有FPU的计算机，不是10。
所以准确地表示这些数字有点困难。即使在没有任何中间计算的情况下显式指定此变量。
你试过胶带解决方案了吗？
尝试确定错误发生的时间，并用简短的if语句修复它们，这并不漂亮，但对于某些问题，这是唯一的解决方案，这就是其中之一。
if( (n * 0.1) < 100.0 ) { return n * 0.1 - 0.000000000000001 ;}
else { return n * 0.1 + 0.000000000000001 ;}
我在c#的一个科学模拟项目中也遇到过同样的问题，我可以告诉你，如果你忽视蝴蝶效应，它会变成一条大胖龙，咬你一口**
我的答案很长，所以我把它分成了三部分。因为这个问题是关于浮点数学的，所以我把重点放在了机器的实际功能上。我还将其指定为双精度（64位），但该参数同样适用于任何浮点运算。
序言
IEEE 754双精度二进制浮点格式（binary64）数字表示以下形式的数字
值=（-1）^s*（1.m51m50…m2m1m0）2*2e-1023
64位：
第一位是符号位：如果数字为负，则为1，否则为0。接下来的11位是指数，偏移1023。换句话说，在从双精度数字中读取指数位之后，必须减去1023以获得2的幂。剩下的52位是有效位（或尾数）。在尾数中，“隐含”1。由于任何二进制值的最高有效位为1，因此总是省略2。
1-IEEE 754允许有符号零的概念-+0和-0被不同地对待：1/（+0）是正无穷大；1/（-0）是负无穷大。对于零值，尾数和指数位均为零。注意：零值（+0和-0）未明确归为非标准2。
2-非正规数的情况并非如此，其偏移指数为零（以及隐含的0）。非正规双精度数的范围为dmin≤|x|≤dmax，其中dmin（最小的可表示非零数）为2-1023-51（≈4.94*10-324），dmax（最大的非正规数，其尾数完全由1组成）为2-1023+1-21-23-51（≈2.225*10-308）。
将双精度数字转换为二进制
存在许多在线转换器来将双精度浮点数转换为二进制（例如，在binaryconvert.com），但这里有一些示例C#代码来获得双精度数字的IEEE 754表示（我用冒号（：）分隔这三个部分：
public static string BinaryRepresentation(double value)
{
long valueInLongType = BitConverter.DoubleToInt64Bits(value);
string bits = Convert.ToString(valueInLongType, 2);
string leadingZeros = new string('0', 64 - bits.Length);
string binaryRepresentation = leadingZeros + bits;
string sign = binaryRepresentation[0].ToString();
string exponent = binaryRepresentation.Substring(1, 11);
string mantissa = binaryRepresentation.Substring(12);
return string.Format("{0}:{1}:{2}", sign, exponent, mantissa);
}
开门见山：最初的问题
（对于TL；DR版本，跳到底部）
卡托·约翰斯顿（提问者）问为什么0.1+0.2！=0.3.
以二进制（用冒号分隔三个部分）编写，IEEE 754值表示为：
0.1 => 0:01111111011:1001100110011001100110011001100110011001100110011010
0.2 => 0:01111111100:1001100110011001100110011001100110011001100110011010
请注意，尾数由0011的重复数字组成。这是为什么计算有任何错误的关键-0.1、0.2和0.3不能用二进制精确地表示在有限数量的二进制位中，任何超过1/9、1/3或1/7的二进制位都可以用十进制数字精确地表示。
还要注意，我们可以将指数的幂减小52，并将二进制表示中的点向右移动52位（非常类似10-3*1.23==10-5*123）。这使我们能够将二进制表示表示为它以a*2p形式表示的精确值。其中“a”是整数。
将指数转换为十进制、删除偏移量并重新添加隐含的1（在方括号中）、0.1和0.2为：
0.1 => 2^-4 * [1].1001100110011001100110011001100110011001100110011010
0.2 => 2^-3 * [1].1001100110011001100110011001100110011001100110011010
or
0.1 => 2^-56 * 7205759403792794 = 0.1000000000000000055511151231257827021181583404541015625
0.2 => 2^-55 * 7205759403792794 = 0.200000000000000011102230246251565404236316680908203125
要添加两个数字，指数必须相同，即：
0.1 => 2^-3 * 0.1100110011001100110011001100110011001100110011001101(0)
0.2 => 2^-3 * 1.1001100110011001100110011001100110011001100110011010
sum = 2^-3 * 10.0110011001100110011001100110011001100110011001100111
or
0.1 => 2^-55 * 3602879701896397 = 0.1000000000000000055511151231257827021181583404541015625
0.2 => 2^-55 * 7205759403792794 = 0.200000000000000011102230246251565404236316680908203125
sum = 2^-55 * 10808639105689191 = 0.3000000000000000166533453693773481063544750213623046875
由于和的形式不是2n*1.｛bbb｝，我们将指数增加1，并移动小数（二进制）点以获得：
sum = 2^-2 * 1.0011001100110011001100110011001100110011001100110011(1)
= 2^-54 * 5404319552844595.5 = 0.3000000000000000166533453693773481063544750213623046875
现在尾数中有53位（第53位在上一行的方括号中）。IEEE 754的默认舍入模式是“舍入到最近”，即如果数字x介于两个值a和b之间，则选择最低有效位为零的值。
a = 2^-54 * 5404319552844595 = 0.299999999999999988897769753748434595763683319091796875
= 2^-2 * 1.0011001100110011001100110011001100110011001100110011
x = 2^-2 * 1.0011001100110011001100110011001100110011001100110011(1)
b = 2^-2 * 1.0011001100110011001100110011001100110011001100110100
= 2^-54 * 5404319552844596 = 0.3000000000000000444089209850062616169452667236328125
注意，a和b仅在最后一位不同。。。0011 + 1 = ...0100。在这种情况下，最低有效位为零的值为b，因此总和为：
sum = 2^-2 * 1.0011001100110011001100110011001100110011001100110100
= 2^-54 * 5404319552844596 = 0.3000000000000000444089209850062616169452667236328125
而0.3的二进制表示是：
0.3 => 2^-2 * 1.0011001100110011001100110011001100110011001100110011
= 2^-54 * 5404319552844595 = 0.299999999999999988897769753748434595763683319091796875
其仅与0.1和0.2之和的二进制表示相差2-54。
0.1和0.2的二进制表示是IEEE 754允许的数字的最精确表示。由于默认舍入模式，添加这些表示会导致一个仅在最低有效位不同的值。
TL；博士
将0.1+0.2写入IEEE 754二进制表示（用冒号分隔三个部分），并将其与0.3进行比较，这是（我将不同的位放在方括号中）：
0.1 + 0.2 => 0:01111111101:0011001100110011001100110011001100110011001100110[100]
0.3 => 0:01111111101:0011001100110011001100110011001100110011001100110[011]
转换回十进制，这些值为：
0.1 + 0.2 => 0.300000000000000044408920985006...
0.3 => 0.299999999999999988897769753748...
与原始值相比，差异正好为2-54，约为5.5511151231258×10-17（对于许多应用）。
比较浮点数的最后几位本来就很危险，任何读过著名的《每一位计算机科学家都应该知道的关于浮点运算》（该书涵盖了这个答案的所有主要部分）的人都会知道。
大多数计算器使用额外的保护数字来解决这个问题，这就是0.1+0.2如何给出0.3：最后几位是四舍五入的。
这里的大多数答案都用非常枯燥的技术术语来解决这个问题。我想用正常人能够理解的方式来解决这个问题。
想象一下，你正试图把披萨切成薄片。你有一个机器人披萨切割机，可以将披萨切成两半。它可以将整个披萨减半，也可以将现有的披萨减半，但无论如何，减半总是准确的。
那台披萨切割机动作非常精细，如果你从一整块披萨开始，然后将其减半，然后继续每次将最小的披萨片减半，你可以在披萨片太小甚至无法实现高精度功能之前，将其减半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上。）
我刚刚看到了关于浮点数的有趣问题：
考虑以下结果：
error = (2**53+1) - int(float(2**53+1))
>>> (2**53+1) - int(float(2**53+1))
1
当2**53+1时，我们可以清楚地看到一个断点——直到2**53，所有的工作都正常。
>>> (2**53) - int(float(2**53))
0
发生这种情况的原因是双精度二进制：IEEE 754双精度二进制浮点格式：binary64
从维基百科的双精度浮点格式页面：
双精度二进制浮点是PC上常用的格式，因为它的范围比单精度浮点更广，尽管它的性能和带宽成本很高。与单精度浮点格式一样，与相同大小的整数格式相比，它缺少整数的精度。它通常简称为double。IEEE 754标准规定二进制64具有：符号位：1位指数：11位有效精度：53位（显式存储52位）具有给定偏置指数和52位分数的给定64位双精度数据假设的实际值为或
感谢@aguest向我指出了这一点。
