IEEE-754："smallest" 溢出条件
IEEE-754: "smallest" overflow condition
在我开始之前，先了解一些背景信息：
我是 运行 ARM7 微控制器 (LPC2294/01) 上的裸机应用程序，使用编译器标准数学库（符合 IEEE-754 标准）在 Keil uVision3 中编译。
问题：
我无法理解 2 个单精度浮点输入之和的 'overflow' 到底是什么。
最初，我的印象是，如果我试图将任何正值添加到可以用 IEEE-754 表示法表示的最大值，结果会产生溢出异常。
例如，假设我有：
a = 0x7f7fffff (ie. 3.4028235..E38);
b = 0x3f800000 (ie. 1.0)
我预计将这两个值相加会导致 IEEE-754 中定义的溢出。最初令我惊讶的是，结果只是返回了 'a' 的值，没有任何异常被标记。
然后我想，由于精度（或分辨率，如果你愿意的话）随着所表示的值的增加而降低，在这种情况下，值“1”可能由于其相对微不足道而被有效地向下舍入为 0 .
这就引出了一个问题： 在这种情况下，'b' 的最小值是多少会导致溢出异常？是否取决于IEEE-754的具体实现？
也许就像我不理解如何在这种特殊情况下确定最小 'significant' 精度一样简单，但是给出下面的代码，为什么第二个和会导致溢出而不是第一个？
static union sFloatConversion32
{
unsigned int unsigned32Value;
float floatValue;
} sFloatConversion32;
t_bool test_Float32_Addition(void)
{
float a;
float b;
float c;
sFloatConversion32.unsigned32Value = 0x7f7fffff;
a = sFloatConversion32.floatValue;
sFloatConversion32.unsigned32Value = 0x72ffffff;
b = sFloatConversion32.floatValue;
/* This sum returns (c = a) without overflow */
c = a + b;
sFloatConversion32.unsigned32Value = 0x73000000;
b = sFloatConversion32.floatValue;
/* This sum, however, causes an overflow exception */
c = a + b;
}
是否有可以应用的通用规则，以便可以提前知道（即不执行求和），给定两个浮点数，它们的总和将导致溢出，如 IEEE- 754?
运行这个程序够长了，看看会发生什么：
float x = 10000000.0f;
while(1)
{
printf("%f\n", x);
x += 1.0f;
}
我想它会回答你的问题。
当结果受格式范围影响时发生溢出。只要正常舍入将结果保持在有限范围内，就不会发生溢出，因为结果与指数无界时的结果相同——结果在考虑范围之前通过正常舍入减少了。所以没有因范围而出现异常。
当四舍五入后的结果不适合格式的有限范围时，则无法产生有限结果，从而产生溢出异常，产生无穷大。
在 IEEE 754 中，正常操作实际上有两个步骤：
- 计算准确的数学结果。
- 将精确的数学结果舍入到最接近的可表示值。
IEEE 754 定义当且仅当上述结果的幅度超过可表示的最大有限值时才会发生溢出。换句话说，溢出不会仅仅因为你超出了最大可表示值而发生，而是只有当你超出最大可表示值以至于正常的浮点运算方式不起作用时才会发生。
因此，如果您从最大可表示值开始并向其添加一个小数字，结果将简单地四舍五入到最大可表示值（当使用舍入到最近值时）。 IEEE 754 认为这是正常的——所有的算术运算都是四舍五入的，如果四舍五入使结果保持在界限内，那是正常的，没有例外。即使指数范围是无限的，正常的舍入也会产生相同的结果。由于这是不受限制范围影响的正常结果，因此没有发生异常。
仅当数学结果大到如果我们不受指数限制，四舍五入会产生下一个更高的数字时，才会发生溢出。 （但是，由于我们已经达到指数范围的极限，我们必须 return 无穷大。）
IEEE-754基本32位二进制浮点数的最大可表示值为2128−2104。此时，可表示数之间的步长以2104为单位。使用舍入到最近的规则，添加任何小于半步的数字，2103，将舍入到 2128−2 104，并没有发生溢出。如果您添加一个大于 2103 的数字，那么如果指数可以达到那么高，结果将四舍五入为 2128。相反，会产生无穷大并发生溢出异常。 （如果你恰好添加 2103，则使用平局规则。此规则表示选择具有偶数位的候选者。这将产生 2128, 所以它也溢出了。)
因此，对于最近舍入法，溢出发生在步骤的中点。使用其他舍入规则，溢出发生在不同的点。使用向无穷大舍入（向上舍入），添加任何正值，甚至 2−149，到 2128−2104 会导致溢出。向零舍入，将任何小于 2104 的值加到 2128−2104不会溢出。
Does it depend on the specific implementation of IEEE-754?
是的，并且当时启用了舍入模式。
考虑 x before max 和 FLT_MAX 之间的步骤。
float max = FLT_MAX;
float before_max = nextafterf(max, 0.0f);
float delta = max - before_max;
printf("max: %- 20a %.*g\n", max, FLT_DECIMAL_DIG, max);
printf("1st d: % -20a %.*g\n", delta, FLT_DECIMAL_DIG, delta);
// Typical output
max: 0x1.fffffep+127 3.40282347e+38
b4max: 0x1.fffffep+127 3.40282347e+38
1st d: 0x1p+104 2.02824096e+31
最大的 float 大约是 float 的两倍，最小的 float 具有相同的步骤或 ULP。想想这个较小的 float，它的所有显式精度位都被清除，而不是设置为 FLOAT_MAX。
float m0 = nextafterf(max/2, max);
printf("m0: %- 20a %.*g\n", m0, FLT_DECIMAL_DIG, m0);
// m0: 0x1p+127 1.70141183e+38
现在将其与 FLT_EPSILON 进行比较，从 1.0 到下一个更大的最小步长 float：
float eps = FLT_EPSILON;
printf("epsil: %- 20a %.*g\n", eps, FLT_DECIMAL_DIG, eps);
// Output
// epsil: 0x1p-23 1.1920929e-07
注意比率 delta/m0 是 FLT_EPSILON。
float r = delta1/m0;
printf("r: %- 20a %.*g\n", r, FLT_DECIMAL_DIG, r);
// r: 0x1p-23 1.1920929e-07
考虑典型的四舍五入模式，四舍五入到偶数。
现在让我们尝试将 1/2*delta1 添加到 FLOAT_MAX，然后尝试添加下一个更小的 float.
sum = max + delta1/2;
printf("sum: % -20a %.*g\n", sum, FLT_DECIMAL_DIG, sum);
sum = nextafterf(sum, 0);
printf("sum: % -20a %.*g\n", sum, FLT_DECIMAL_DIG, sum);
// sum: inf inf
// sum: 0x1.fffffep+127 3.40282347e+38
IEEE-754: “smallest” overflow condition
如果大约 FLT_MAX*1/2*1/2*FLOAT_EPSILON，我们可以看到最小的增量。
float small = FLT_MAX*0.25f*FLT_EPSILON;
printf("small: %- 20a %.*g\n", small, FLT_DECIMAL_DIG, small);
printf("sum: % -20a %.*g\n", max+small, FLT_DECIMAL_DIG, max+small);
small = nextafterf(small, max);
printf("sum: % -20a %.*g\n", max+small, FLT_DECIMAL_DIG, max+small);
// sum: 0x1.fffffep+127 3.40282347e+38
// sum: inf inf
考虑到 float 的各种可能编码，您的结果可能会有所不同，但这种方法给出了如何确定导致溢出的最小增量的想法。
在我开始之前，先了解一些背景信息：
我是 运行 ARM7 微控制器 (LPC2294/01) 上的裸机应用程序，使用编译器标准数学库（符合 IEEE-754 标准）在 Keil uVision3 中编译。
问题： 我无法理解 2 个单精度浮点输入之和的 'overflow' 到底是什么。
最初，我的印象是，如果我试图将任何正值添加到可以用 IEEE-754 表示法表示的最大值，结果会产生溢出异常。
例如，假设我有：
a = 0x7f7fffff (ie. 3.4028235..E38);
b = 0x3f800000 (ie. 1.0)
我预计将这两个值相加会导致 IEEE-754 中定义的溢出。最初令我惊讶的是，结果只是返回了 'a' 的值，没有任何异常被标记。
然后我想，由于精度（或分辨率，如果你愿意的话）随着所表示的值的增加而降低，在这种情况下，值“1”可能由于其相对微不足道而被有效地向下舍入为 0 .
这就引出了一个问题： 在这种情况下，'b' 的最小值是多少会导致溢出异常？是否取决于IEEE-754的具体实现？
也许就像我不理解如何在这种特殊情况下确定最小 'significant' 精度一样简单，但是给出下面的代码，为什么第二个和会导致溢出而不是第一个？
static union sFloatConversion32
{
unsigned int unsigned32Value;
float floatValue;
} sFloatConversion32;
t_bool test_Float32_Addition(void)
{
float a;
float b;
float c;
sFloatConversion32.unsigned32Value = 0x7f7fffff;
a = sFloatConversion32.floatValue;
sFloatConversion32.unsigned32Value = 0x72ffffff;
b = sFloatConversion32.floatValue;
/* This sum returns (c = a) without overflow */
c = a + b;
sFloatConversion32.unsigned32Value = 0x73000000;
b = sFloatConversion32.floatValue;
/* This sum, however, causes an overflow exception */
c = a + b;
}
是否有可以应用的通用规则，以便可以提前知道（即不执行求和），给定两个浮点数，它们的总和将导致溢出，如 IEEE- 754?
运行这个程序够长了，看看会发生什么：
float x = 10000000.0f;
while(1)
{
printf("%f\n", x);
x += 1.0f;
}
我想它会回答你的问题。
当结果受格式范围影响时发生溢出。只要正常舍入将结果保持在有限范围内，就不会发生溢出，因为结果与指数无界时的结果相同——结果在考虑范围之前通过正常舍入减少了。所以没有因范围而出现异常。
当四舍五入后的结果不适合格式的有限范围时，则无法产生有限结果，从而产生溢出异常，产生无穷大。
在 IEEE 754 中，正常操作实际上有两个步骤：
- 计算准确的数学结果。
- 将精确的数学结果舍入到最接近的可表示值。
IEEE 754 定义当且仅当上述结果的幅度超过可表示的最大有限值时才会发生溢出。换句话说，溢出不会仅仅因为你超出了最大可表示值而发生，而是只有当你超出最大可表示值以至于正常的浮点运算方式不起作用时才会发生。
因此，如果您从最大可表示值开始并向其添加一个小数字，结果将简单地四舍五入到最大可表示值（当使用舍入到最近值时）。 IEEE 754 认为这是正常的——所有的算术运算都是四舍五入的，如果四舍五入使结果保持在界限内，那是正常的，没有例外。即使指数范围是无限的，正常的舍入也会产生相同的结果。由于这是不受限制范围影响的正常结果，因此没有发生异常。
仅当数学结果大到如果我们不受指数限制，四舍五入会产生下一个更高的数字时，才会发生溢出。 （但是，由于我们已经达到指数范围的极限，我们必须 return 无穷大。）
IEEE-754基本32位二进制浮点数的最大可表示值为2128−2104。此时，可表示数之间的步长以2104为单位。使用舍入到最近的规则，添加任何小于半步的数字，2103，将舍入到 2128−2 104，并没有发生溢出。如果您添加一个大于 2103 的数字，那么如果指数可以达到那么高，结果将四舍五入为 2128。相反，会产生无穷大并发生溢出异常。 （如果你恰好添加 2103，则使用平局规则。此规则表示选择具有偶数位的候选者。这将产生 2128, 所以它也溢出了。)
因此，对于最近舍入法，溢出发生在步骤的中点。使用其他舍入规则，溢出发生在不同的点。使用向无穷大舍入（向上舍入），添加任何正值，甚至 2−149，到 2128−2104 会导致溢出。向零舍入，将任何小于 2104 的值加到 2128−2104不会溢出。
Does it depend on the specific implementation of IEEE-754?
是的，并且当时启用了舍入模式。
考虑 x before max 和 FLT_MAX 之间的步骤。
float max = FLT_MAX;
float before_max = nextafterf(max, 0.0f);
float delta = max - before_max;
printf("max: %- 20a %.*g\n", max, FLT_DECIMAL_DIG, max);
printf("1st d: % -20a %.*g\n", delta, FLT_DECIMAL_DIG, delta);
// Typical output
max: 0x1.fffffep+127 3.40282347e+38
b4max: 0x1.fffffep+127 3.40282347e+38
1st d: 0x1p+104 2.02824096e+31
最大的 float 大约是 float 的两倍，最小的 float 具有相同的步骤或 ULP。想想这个较小的 float，它的所有显式精度位都被清除，而不是设置为 FLOAT_MAX。
float m0 = nextafterf(max/2, max);
printf("m0: %- 20a %.*g\n", m0, FLT_DECIMAL_DIG, m0);
// m0: 0x1p+127 1.70141183e+38
现在将其与 FLT_EPSILON 进行比较，从 1.0 到下一个更大的最小步长 float：
float eps = FLT_EPSILON;
printf("epsil: %- 20a %.*g\n", eps, FLT_DECIMAL_DIG, eps);
// Output
// epsil: 0x1p-23 1.1920929e-07
注意比率 delta/m0 是 FLT_EPSILON。
float r = delta1/m0;
printf("r: %- 20a %.*g\n", r, FLT_DECIMAL_DIG, r);
// r: 0x1p-23 1.1920929e-07
考虑典型的四舍五入模式，四舍五入到偶数。
现在让我们尝试将 1/2*delta1 添加到 FLOAT_MAX，然后尝试添加下一个更小的 float.
sum = max + delta1/2;
printf("sum: % -20a %.*g\n", sum, FLT_DECIMAL_DIG, sum);
sum = nextafterf(sum, 0);
printf("sum: % -20a %.*g\n", sum, FLT_DECIMAL_DIG, sum);
// sum: inf inf
// sum: 0x1.fffffep+127 3.40282347e+38
IEEE-754: “smallest” overflow condition
如果大约 FLT_MAX*1/2*1/2*FLOAT_EPSILON，我们可以看到最小的增量。
float small = FLT_MAX*0.25f*FLT_EPSILON;
printf("small: %- 20a %.*g\n", small, FLT_DECIMAL_DIG, small);
printf("sum: % -20a %.*g\n", max+small, FLT_DECIMAL_DIG, max+small);
small = nextafterf(small, max);
printf("sum: % -20a %.*g\n", max+small, FLT_DECIMAL_DIG, max+small);
// sum: 0x1.fffffep+127 3.40282347e+38
// sum: inf inf
考虑到 float 的各种可能编码，您的结果可能会有所不同，但这种方法给出了如何确定导致溢出的最小增量的想法。