使用具有整数表示和 ULP 的混叠正确比较双精度

Question

我试图避免在比较浮点类型时使用 epsilon 比较。我能想到的最佳解决方案使用了 ULP 的差异(最后是单位)，尽管本文使用整数表示有一个更好的解决方案(///表示我自己的评论)：

/* See
https://randomascii.wordpress.com/2012/01/11/tricks-with-the-floating-point-format/
for the potential portability problems with the union and bit-fields below.
*/
#include <stdint.h> // For int32_t, etc.
union Float_t
{
Float_t(float num = 0.0f) : f(num) {}
// Portable extraction of components.
bool Negative() const { return i < 0; }
int32_t RawMantissa() const { return i & ((1 << 23) - 1); }
int32_t RawExponent() const { return (i >> 23) & 0xFF; }
int32_t i; /// Perhaps overflow when using doubles?
float f;
#ifdef _DEBUG
struct
{   // Bitfields for exploration. Do not use in production code.
uint32_t mantissa : 23; /// 52 for double?
uint32_t exponent : 8; /// 11 for double?
uint32_t sign : 1;
} parts;
#endif
};
bool AlmostEqualUlps(float A, float B, int maxUlpsDiff)
{
Float_t uA(A);
Float_t uB(B);
// Different signs means they do not match.
if (uA.Negative() != uB.Negative())
{
// Check for equality to make sure +0==-0
if (A == B)
return true;
return false;
}
// Find the difference in ULPs.
int ulpsDiff = abs(uA.i - uB.i);
if (ulpsDiff <= maxUlpsDiff)
return true;
return false;
}

但是，我似乎无法以支持双精度的方式重新格式化代码。我什至阅读了解释，在这里找到。

有谁知道解决这个问题的最佳方法是什么？

---

在任何人决定将其标记为重复之前：不要，因为唯一类似的问题是针对javascript的，而C++答案是：

bool IsAlmostEqual(double A, double B)
{
//http://www.cygnus-software.com/papers/comparingfloats/comparingfloats.htm
long long aInt = reinterpret_cast<long long&>(A);
if (aInt < 0) aInt = -9223372036854775808LL - aInt;
long long bInt = reinterpret_cast<long long&>(B);
if (bInt < 0) bInt = -9223372036854775808LL - bInt;
return (std::abs(aInt - bInt) <= 10000);
}

它不使用 ULP，而是某种绑定，我根本不确定-9223372036854775808LL - aInt是什么(也许 int64 溢出的地方)。

Answer 1

我认为你的代码根本不起作用。下面只是一个会出错的例子。(这不是答案，但解释太长，不适合评论)

int main()
{
Float_t x;
Float_t y;
x.i = 0x7F800000;
y.i = 0x7F7FFFFF;
AlmostEqualUlps(x.f, y.f, 1); // return true
}

然而，x.f实际上是无穷大，y.f是FLT_MAX。任何定义的差异都是无限的。除非这是您的预期行为，否则请考虑有限数和无穷大几乎相等。您对 ULP 的实现完全不合时宜。事实上，对于上面的两个数字，ULP甚至没有很好的定义。

另一个例子是0x7F800000(或任何接近此的数字，取决于您的maxULP)和0x7F800001(NaN)。与上面的例子不同，甚至没有论据认为它们应该被视为"几乎相等"。

另一方面，你拒绝任何具有不同符号的对，因为不够接近，而实际上-FLT_MIN和FLT_MIN之间有很多次正态，人们可能认为这是"几乎相等的"。例如，0x80000001 和 0x1相差 2ULP，但如果在函数中将maxULP设置为 2，它将返回 false。

如果您可以排除不正常，虚幻，NaN，那么要处理双倍，您只需要将uint32_t替换为其他人评论中提到的uint64_t。