1

我试图避免使用 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 溢出的地方）。

4

1 回答 1

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其他人评论中提到的。

于 2016-12-19T05:13:54.237 回答