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

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

• 0.1000000000000000055511151231257827021181583404541015625小数，或
• 0x1.999999999999ap-4在C99六进制记数法。

相反，有理数0.1，也就是1/10，可以写成

• 0.1小数，或
• 0x1.99999999999999...p-4在C99六进制表示法的模拟中，其中...表示9的无休止序列。

程序中的常数0.2和0.3也将是它们真实值的近似值。碰巧最接近double到0.2的数字大于有理数0.2，但最接近double到0.3的数字小于有理数0.3。0.1和0.2的总和最终大于有理数0.3，因此与代码中的常数不一致。

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

附注：所有位置（基数N）数系统都有精度问题

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

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

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

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

旁注：在编程中使用浮点数

在实践中，这个精度问题意味着您需要使用舍入函数将浮点数舍入到您感兴趣的小数位数，然后再显示它们。

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

做没有做if (x == y) { ... }

相反，做if (abs(x - y) < myToleranceValue) { ... }。

其中abs是绝对值。myToleranceValue需要为您的特定应用程序选择-它与您准备允许多少“摆动空间”以及您将比较的最大数字可能是什么（由于精度问题的损失）有很大关系。小心您选择的语言中的“epsilon”样式常量。这些是用作容差值的没有。

浮点舍入误差。由于缺少5的素数因子，0.1在2进制中不能像在10进制中那样准确地表示。就像1/3需要无限多的数字来表示小数，但在3进制中是“0.1”，0.1在2进制中需要无限多的数字，而在10进制中没有。计算机没有无限量的内存。

浮点舍入错误。从每个计算机科学家都应该知道的关于浮点运算的知识：

将无限多个实数压缩成有限个位需要近似表示。虽然有无限多个整数，但在大多数程序中，整数计算的结果可以存储在32位中。相比之下，给定任何固定数量的位，大多数使用实数的计算都会产生无法用那么多位准确表示的量。因此，浮点计算的结果通常必须四舍五入才能适应其有限表示。这种四舍五入误差是浮点计算的特征。

它被打破的方式与你在小学学习并每天使用的十进制（以10为基数）符号被打破的方式完全相同，只是以2为基数。

要理解，请考虑将1/3表示为十进制值。这是不可能做到的！在你写完小数点后的3之前，世界就会结束，所以我们会写到一些地方，并认为它足够准确。

同样，1/10（十进制0.1）不能精确地以2进制（二进制）表示为“十进制”值；小数点后的重复模式永远持续下去。该值不精确，因此您无法使用普通浮点方法对其进行精确的数学运算。就像基数10一样，还有其他值也会出现这个问题。

除了其他正确答案外，您可能还需要考虑缩放值以避免浮点运算出现问题。

例如：

var result = 1.0 + 2.0;     // result === 3.0 returns true

…而不是：

var result = 0.1 + 0.2;     // result === 0.3 returns false

表达式0.1 + 0.2 === 0.3在JavaScript中返回false，但幸运的是浮点数中的整数算术是精确的，因此可以通过缩放来避免十进制表示错误。

作为一个实际的例子，为了避免精度至关重要的浮点问题，建议¹将钱作为表示美分数的整数处理：2550美分而不是25.50美元。

¹道格拉斯·克罗克福德：JavaScript：好的部分：附录A-可怕的部分（第105页）。

我的解决方法：

function add(a, b, precision) {var x = Math.pow(10, precision || 2);return (Math.round(a * x) + Math.round(b * x)) / x;}

精度是指在加法过程中要保留在小数点后的位数。

你试过胶带解决方案吗？

尝试确定何时发生错误并用简短的if语句修复它们，这并不漂亮，但对于某些问题，这是唯一的解决方案，这是其中之一。

 if( (n * 0.1) < 100.0 ) { return n * 0.1 - 0.000000000000001 ;}else { return n * 0.1 + 0.000000000000001 ;}

我在c#的一个科学模拟项目中遇到了同样的问题，我可以告诉你，如果你忽略蝴蝶效应，它会变成一条大肥龙，咬你一口

硬件设计师的视角

我认为我应该添加一个硬件设计师的观点，因为我设计和构建浮点硬件。知道错误的起源可能有助于理解软件中发生的事情，最终，我希望这有助于解释为什么浮点错误发生并似乎随着时间的推移而积累的原因。

1.概述

从工程的角度来看，大多数浮点运算都会有一些误差因素，因为进行浮点计算的硬件只需要在最后一个单元的误差小于一半。因此，许多硬件将停止在一个精度上，这对于单一操作来说只有在最后一个单元的误差小于一半时才是必要的，这在浮点除法中尤其有问题。构成单个操作的内容取决于该单元需要多少操作数。对于大多数，它是两个，但有些单元需要3个或更多操作数。因此，无法保证重复操作会导致理想的错误，因为错误会随着时间的推移而累积。

2.标准

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

在IEEE-754标准中，允许硬件设计人员使用任何错误/epsilon值，只要它小于最后一个单元的一半，并且一次操作的结果只需小于最后一个单元的一半。这解释了为什么当有重复操作时，错误会累加。对于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-bit），它将是除法器的基数大小，加上一些保护位k，其中k>=2。因此，例如，一次计算商的2位（基数4）的除法器的典型商选择表将是2+2= 4位（加上一些可选位）。

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

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

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

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

5.重复操作

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

请注意，默认舍入模式，舍入到最近的最后一位的偶数，保证一次操作的误差小于最后一个单位的一半。单独使用截断、舍入和舍入可能会导致误差大于最后一个单位的一半，但小于最后一个单位，因此不推荐使用这些模式，除非它们在Interval Arithmetic中使用。

6.摘要

简而言之，浮点运算误差的根本原因是硬件中的截断和除法情况下的倒数截断的组合。由于IEEE-754标准只要求单个操作的误差小于最后一个单位的一半，除非纠正，否则重复操作的浮点误差将加起来。

这些奇怪的数字出现是因为计算机使用二进制（基数2）数字系统进行计算，而我们使用十进制（基数10）。

大多数小数不能用二进制或十进制或两者都精确表示。结果-四舍五入（但精确）的数字结果。

已经发布了很多好的答案，但我想再添加一个。

不是所有的数字都可以用漂浮/双精度来表示例如，数字“0.2”将在IEEE754浮点标准中单精度表示为“0.200000003”。

在引擎盖下存储实数的模型将浮点数表示为

即使您可以轻松键入0.2，但对于使用“IEEE二进制浮点运算标准（ISO/IEEE Std 754-1985）”的带有FPU的计算机，FLT_RADIX和DBL_RADIX是2；而不是10。

因此，准确表示这些数字有点困难。即使您在没有任何中间计算的情况下显式指定此变量。

这里的大多数答案都用非常枯燥的技术术语来解决这个问题。我想用普通人可以理解的术语来解决这个问题。

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

比萨饼切割机有非常精细的运动，如果你从一个完整的比萨饼开始，然后将其减半，并继续每次将最小的切片减半，你可以在切片太小甚至无法实现其高精度能力之前进行减半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.200000000000000011102230246251565404236316680908203125=0.3000000000000000444089209850062616169452667236328125，而最接近0.3的数字实际上是0.299999999999999988897769753748434595763683319091796875。

P. S.一些编程语言还提供了可以切成精确的十分之一的披萨切割器。虽然这种披萨切割器并不常见，但如果您确实可以使用它，那么当能够获得十分之一或五分之一切片时，您应该使用它。

（最初发布在Quora上）

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

当使用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%）。

我的答案很长，所以我将其分为三个部分。由于问题是关于浮点数学的，我将重点放在机器的实际功能上。我还将其特定于双精度（64位），但该论点同样适用于任何浮点算术。

序言

IEEE 754双精度二进制浮点格式（binary64）数字表示形式为

value=（-1）^s*（1.m₅₁m₅₀… m₂m₁m）₂*2^e-1023

在64位：

• 第一位是符号位：1如果数字是负数，0否则¹。
• 接下来的11位是指数，即偏移乘1023。换句话说，在从双精度数字中读取指数位后，必须减去1023才能获得2的幂。
• 剩下的52位是意义（或尾数）。在尾数中，隐含的1.总是被省略²，因为任何二进制值的最高有效位是1。

¹-IEEE 754允许符号零的概念-+0和-0被区别对待：1 / (+0)是正无穷大；1 / (-0)是负无穷大。对于零值，尾数和指数位都是零。注意：零值（+0和-0）显式不归类为正态²。

²-正态数不是这种情况，它的偏移指数为零（隐含的0.）。正态双精度数的范围是d_分钟≤|x|≤d_最大值，其中d_分钟（最小的可表示非零数）是2^-1023-51（约4.94*10^-324），d_最大值（最大的正态数，尾数完全由1组成）是210-2^-1023-51（约2.225*1012）。

将双精度数转换为二进制数

许多在线转换器将双精度浮点数转换为二进制数（例如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);}

进入主题：最初的问题

（跳到底部太长别读）

卡托约翰斯顿（提问者）问为什么0.1+0.2！=0.3。

以二进制形式编写（冒号分隔三个部分），IEEE 754表示的值是：

0.1 => 0:01111111011:10011001100110011001100110011001100110011001100110100.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*2^p形式表示的确切值。其中'a'是整数。

将指数转换为十进制，删除偏移量并重新添加隐含的1（在方括号中），0.1和0.2是：

0.1 => 2^-4 * [1].10011001100110011001100110011001100110011001100110100.2 => 2^-3 * [1].1001100110011001100110011001100110011001100110011010or0.1 => 2^-56 * 7205759403792794 = 0.10000000000000000555111512312578270211815834045410156250.2 => 2^-55 * 7205759403792794 = 0.200000000000000011102230246251565404236316680908203125

要添加两个数字，指数需要相同，即：

0.1 => 2^-3 *  0.1100110011001100110011001100110011001100110011001101(0)0.2 => 2^-3 *  1.1001100110011001100110011001100110011001100110011010sum =  2^-3 * 10.0110011001100110011001100110011001100110011001100111or0.1 => 2^-55 * 3602879701896397  = 0.10000000000000000555111512312578270211815834045410156250.2 => 2^-55 * 7205759403792794  = 0.200000000000000011102230246251565404236316680908203125sum =  2^-55 * 10808639105689191 = 0.3000000000000000166533453693773481063544750213623046875

由于总和不是2ⁿ*1.{bbb}的形式，我们将指数增加1并移动小数点（二进制）以获得：

sum = 2^-2  * 1.0011001100110011001100110011001100110011001100110011(1)= 2^-54 * 5404319552844595.5 = 0.3000000000000000166533453693773481063544750213623046875

现在尾数中有53位（第53位在上面一行的方括号中）。IEEE 754的默认舍入方式是“圆到最近”-即如果数字x落在两个值一个和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

请注意，一个和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允许的数字的最准确表示。由于默认舍入模式，添加这些表示会导致仅在最低有效位上不同的值。

太长别读

在IEEE 754二进制表示中编写0.1 + 0.2（冒号分隔三个部分）并将其与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的方式：最后几个比特被舍入。

鉴于没有人提到这一点…

一些高级语言，如Python和Java提供了克服二进制浮点限制的工具。例如：

• Python的#0模块和Java的#1类，它们在内部用十进制表示法（与二进制表示法相反）表示数字。两者都有有限的精度，所以它们仍然容易出错，但是它们解决了二进制浮点运算的最常见问题。

  小数在处理金钱时非常好：10美分加20美分总是正好是30美分：

  >>> 0.1 + 0.2 == 0.3False>>> Decimal('0.1') + Decimal('0.2') == Decimal('0.3')True

  Python的decimal模块基于IEEE标准854-1987。

• Python的fractions模块和Apache Common的BigFraction类。两者都将有理数表示为(numerator, denominator)对，它们可能会给出比十进制浮点运算更准确的结果。

可以在数字计算机中实现的那种浮点数学必须使用实数的近似值和对它们的操作。（标准版本运行超过50页的留档，并有一个委员会来处理其勘误和进一步细化。）

这种近似是不同类型近似的混合，由于其偏离精确度的特定方式，每种近似都可以被忽略或仔细解释。它还涉及硬件和软件层面的许多明显的例外情况，大多数人假装没有注意到这些情况。

如果您需要无限精度（例如，使用数字π而不是其许多较短的替身之一），您应该编写或使用符号数学程序。

但是，如果您可以接受这样的想法，即有时浮点数学在值和逻辑上是模糊的，错误会迅速积累，并且您可以编写需求和测试来允许这一点，那么您的代码可以经常使用FPU中的内容。

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

由于这是一个与语言无关的问题，它需要与语言无关的工具，例如十进制到浮点转换器。

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

0.1转换为0.1000000000000000055511151231257827021181583404541015625，

0.2转换为0.200000000000000011102230246251565404236316680908203125，

0.3转换为0.299999999999999988897769753748434595763683319091796875

0.30000000000000004转换为0.3000000000000000444089209850062616169452667236328125。

手动或在十进制计算器（如全精度计算器）中添加前两个数字，显示实际输入的确切总和为0.3000000000000000166533453693773481063544750213623046875。

如果向下舍入到0.3的等效值，则舍入误差为0.0000000000000000277555756156289135105907917022705078125。向上舍入到0.30000000000000004的等效值，则舍入误差为0.0000000000000000277555756156289135105907917022705078125。

回到浮点转换器，0.30000000000000004的原始十六进制是3fd33333333334，它以偶数结尾，因此是正确的结果。

不，不能断，但大多数小数必须近似

总结

浮点算术是精确，不幸的是，它与我们通常的以10为基数的数字表示不匹配，所以事实证明我们经常给它输入与我们写的略有不同的输入。

即使是像0.01,0.02,0.03,0.04…0.24这样的简单数字也不能完全用二进制分数来表示。如果你把0.01，.02，.03………加起来，直到你达到0.25，你才能得到第一个可以在基数₂中表示的分数。如果你用FP尝试这样做，你的0.01会稍微偏离一点，所以把25个数字加起来到一个精确的0.25的唯一方法需要一长串因果关系，包括保护位和舍入。很难预测，所以我们举起手说"FP不精确"，，但事实并非如此。

我们不断地给FP硬件一些在基数10中看起来很简单但在基数2中是重复分数的东西。

这是怎么发生的？

当我们写小数时，每个分数（具体来说，每个终止小数）都是形式的有理数

a/（2ⁿ x 5^m）

在二进制中，我们只得到2ⁿ项，即：

a/2ⁿ

所以在十进制中，我们不能表示¹/₃。因为以10为基数包含2作为质因数，所以我们可以写成二进制分数还的每个数字都可以写成以10为基数的分数。然而，我们写成的以₁₀为基数的分数几乎没有任何东西可以用二进制表示。在0.01、0.02、0.03…0.99的范围内，只有三的数字可以用我们的FP格式表示：0.25、0.50和0.75，因为它们是1/4、1/2和3/4，所有具有质因数的数字只使用2ⁿ项。

在基数₁₀中，我们不能表示¹/₃。但是在二进制中，我们不能做¹/₁₀或¹/₃。

因此，虽然每个二进制小数都可以用十进制写成，但反之亦然。事实上，大多数十进制小数都以二进制形式重复。

处理它

开发人员通常被指示进行比较，更好的建议可能是四舍五入到整数值（在C库中：round（）和roundf（），即保持FP格式），然后进行比较。四舍五入到特定的十进制分数长度可以解决大多数输出问题。