numpy 浮点数的精度限制？

不要加 1，而是将分母加倍。您可以放心地假设它是某个二进制数。这里有一个简单的方法：

one = np.float64(1.0)
two = np.float64(2.0)
n = one
bits = 0
while one + n != one:
    bits += 1
    n /= two

你从开始，否则你会得到带你超过分辨率的位数。bits = 0

最后，你得到 ，这是 IEEE-754 编码的 64 位浮点数中的位数。bits = 53

这意味着，对于任何以有效的二进制科学记数法编码的数字，ULP（最小精度单位）约为 。具体来说，其中数字四舍五入到其最高位。您将无法解析浮点数中较小的相对变化。n * 2**-53n

奖励：为其他浮点类型运行上述代码可提供：

float16 (half):   11 bits
float32 (single): 24 bits
float64 (double): 53 bits
float96 (sometimes longdouble): 80 bits
float128 (when available): 113 bits

您可以修改上面的代码以适用于任何目标号码：

target = np.float16(0.0004883)
one = np.float16(1.0)
two = np.float16(2.0)
n = two**(np.floor(np.log2(target)) - one)
bits = 0
while target + n != target:
    bits += 1
    n /= two

结果 （ULP） 由下式给出，因为循环在失去分辨率后停止。这与我们开始的原因相同。在这种情况下：n * 2bits = 0

>>> n * two
5e-07

如果您预先知道尾数中的位数，则可以完全缩短计算。所以对于 ， where ， 你可以做float16bits = 11

>>> two**(np.floor(np.log2(target)) - np.float16(bits))
5e-07

在这里阅读更多内容：

• https://en.wikipedia.org/wiki/IEEE_754
• https://en.wikipedia.org/wiki/Unit_in_the_last_place

我的另一个答案提供了你实际提出的问题背后的理论，但需要一些不平凡的解释。这是缺少的步骤：

给定一些整数，你可以写成i

1 / i - 1 / (i + 1) =
(i + 1 - i) / (i * (i + 1)) =
1 / (i * (i + 1)) =
1 / (i**2 + i)

要找到在某些二进制表示中低于 ULP 的此类方法，您可以直接使用我的另一个答案。i1 / (i**2 + i)1 / i

的 ULP 由下式给出1 / i

ulp = 2**(floor(log2(1 / i)) - (bits + 1))

你可以尝试找到一个这样的i

1 / (i**2 + i) < 2**(floor(log2(1 / i)) - (bits + 1))
1 / (i**2 + i) < 2**floor(log2(1 / i)) / 2**(bits + 1)
2**(bits + 1) < (i**2 + i) * 2**floor(log2(1 / i))

It's not trivial as written because of the operation, and Wolfram Alpha runs out of time. Since I am cheap and don't want to buy Mathematica, let's just approximate:floor

2**(bits + 1) < (i**2 + i) * 2**floor(log2(1 / i))
2**(bits + 1) < (i**2 + i) / i
2**(bits + 1) < i + 1

You may be off by one or so, but you should see that around , the difference stops being resolvable. And indeed for the 11 bit mantissa of , we see:i = 2**(bits + 1) - 1float16

>>> np.float16(1 / (2**12 - 1)) - np.float16(1 / (2**12))
0.0

The actual number is a tiny bit less here (remember that approximation where we took away the ):floor

>>> np.float16(1 / (2**12 - 5)) - np.float16(1 / (2**12 - 4))
0.0
>>> np.float16(1 / (2**12 - 6)) - np.float16(1 / (2**12 - 5))
2.4e-07

As you noted in your comments, isi

>>> 2**12 - 6
4090

You can compute the exact values for all the other floating point types in a similar manner. But that is indeed left as an exercise for the reader.