两个数相等，是什么意思

答案：它们是邻居

0.3                精确值 = 0.29999999999999998⟨8897769753748434595763683319091796875⟩
0.1 + 0.2          精确值 = 0.3000000000000000⟨444089209850062616169452667236328125⟩

真值 3/10 落在这两个 double 中间。
0.3 是离它最近的那个（所以 0.3 存进去就是它）。
0.1+0.2 恰好被推到了另一边那一格。

两者相隔：1 格。中间没有任何 double。

这件事值得停一下，因为它把整个例子的调性都改了。「0.1+0.2 ≠ 0.3」这个著名的失败，其实是可能犯的最小的错误。它不是「浮点数很不准」的证据，它是「浮点数准到只能差一格」的证据。

第二问的答案更有意思：sum([0.1] * 10) === 1.0 是 true，一格都不差。十次抹零的方向有上有下，最后正好回到刻度上。而 0.1 + 0.2 这两次就没这个运气。

所以「什么时候相等」这件事，本质上没有规律可讲——它取决于每一步被抹到了哪一边。这就是为什么需要一个比较策略。

三种比较，三种失效

把这几对数放进去试：

中间两行就是绝对容差的两个失效方向。它们不是边角情况——只要你的程序处理的量跨越多个数量级（价格、距离、时间、损失值），就一定会同时踩到两头。

「隔几格」怎么算

IEEE 754 有一个非常漂亮的设计：把正 double 的位模式当成 64 位整数来读，顺序和数值顺序完全一致。于是「隔几格」就是两个整数相减。

const buf = new ArrayBuffer(8);
const f = new Float64Array(buf), u = new BigUint64Array(buf);

function ord(x) {                          // 把位模式映射成单调整数
  f[0] = x;
  const b = u[0];
  return (b & 0x8000000000000000n)          // 负数：翻转成对称的负整数
    ? 0x8000000000000000n - (b & 0x7fffffffffffffffn)
    : b;
}
function ulpsBetween(a, b) {
  const d = ord(a) - ord(b);
  return d < 0n ? -d : d;
}

ulpsBetween(0.1 + 0.2, 0.3)     // 1n
ulpsBetween(1e10, 1e10 + 1e-6)  // 1n

用它写断言，判据非常直观：「允许差 4 次舍入」就写 ulpsBetween(a,b) <= 4n。这个数字和量级无关，写一次就到处能用。

相等  ⇔  |a − b| ≤ max( rel_tol × max(|a|, |b|),  abs_tol )
                          └────────┬────────┘   └───┬───┘
                           管一般情况，量级无关     只管 0 附近

标准库的默认值，看清楚再用

numpy.isclose 那一行是真实世界里最常见的陷阱：它的默认 atol=1e-8 意味着，任何小于 10⁻⁸ 的两个数，在它眼里都相等。算概率、算梯度、算小残差时，这个默认值会让断言变成一句空话。np.testing.assert_allclose 的默认 atol 是 0，行为更合理——写测试时用后者。

什么时候 == 是对的

不要走到另一个极端。== 在这些场合完全正确，而且是唯一正确的写法：

• 整数在 2⁵³ 以内。3.0 === 3.0，Math.floor(x) === 0——精确，没有任何疑问。
• 和自己比、和刚存进去的常量比。没经过运算就没抹过零。
• 哨兵值。x === Infinity、x !== x（这是标准的 NaN 检测，因为 NaN !== NaN）。
• 循环终止在整数计数上。for (let i = 0; i !== n; i++) 安全；for (let x = 0; x !== 1; x += 0.1) 是死循环（因为累加十次不一定正好到 1——虽然上面看到 0.1×10 恰好等于 1，0.1×3 就不等于 0.3 了）。

另外两个位层的坑，顺手记下：

• -0.0 === 0.0 是 true，但它们的位模式不同（0x8000000000000000 vs 0x0）。Object.is(-0, 0) 是 false，1/-0 是 -Infinity。排序、去重、当 Map 的键时要小心。
• NaN !== NaN，所以 [NaN].includes(NaN) 是 true（用 SameValueZero）而 [NaN].indexOf(NaN) 是 -1（用 ===）。同一个数组，两个方法给出相反的答案。

import math, struct
def ulps(a, b):
    o = lambda x: (lambda u: u if u >= 0 else -0x8000000000000000 - u)(
        struct.unpack('<q', struct.pack('<d', x))[0])
    return abs(o(a) - o(b))

pairs = [(0.1 + 0.2, 0.3), (1e10, 1e10 + 1e-6), (1e-12, 5e-12),
         (1.0, 1.0 + 2**-52), (0.1 * 3, 0.3), (sum([0.1] * 10), 1.0)]
for a, b in pairs:
    print(f'{a!r:>24} vs {b!r:<22} 隔 {ulps(a,b):>18} 格  '
          f'|Δ|<1e-9? {abs(a-b) < 1e-9}')

import numpy as np
print('math.isclose(1e-12, 5e-12) =', math.isclose(1e-12, 5e-12))   # False  ✓
print('np.isclose  (1e-12, 5e-12) =', np.isclose(1e-12, 5e-12))     # True   ✗
print('math.isclose(0, 1e-300)    =', math.isclose(0, 1e-300))      # False

     0.30000000000000004 vs 0.3                    隔                  1 格  |Δ|<1e-9? True
           10000000000.0 vs 10000000000.000002     隔                  1 格  |Δ|<1e-9? False
                   1e-12 vs 5e-12                  隔  10245139294026372 格  |Δ|<1e-9? True
                     1.0 vs 1.0000000000000002     隔                  1 格  |Δ|<1e-9? True
     0.30000000000000004 vs 0.3                    隔                  1 格  |Δ|<1e-9? True
                     1.0 vs 1.0                    隔                  0 格  |Δ|<1e-9? True

这一章的一句话

绝对容差是一把固定长度的尺子，而浮点数轴的刻度横跨六百个数量级；要么用相对的尺子，要么直接数隔了几格。

卷 III 到此结束——四章，四次改写，每一次都是「同一个数学，换一条计算路径」。

卷 IV 换一个模式：不再一步算完，改成一步步逼近。这带来一个新的好处和一个新的麻烦。好处是牛顿法这样的算法能让正确位数每一步翻倍——从 0.5 位到 1.2 位到 2.8 位到 5.8 位到 11.9 位，五步撞上 double 的天花板，而二分法要走 52 步。麻烦是：既然是逼近，就得决定什么时候停——而停机判据是这本书里最容易写错的东西。