使用別名與整數表示和ULP正確比較雙打

Question

我試圖避免比較浮點類型的epsilon比較。我可以拿出最好的解決方案應用於ULPS（單位在最後的地方）的區別，雖然this article不得不使用整數表示一個更好的解決方案（///表明我自己的看法）：

/* 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; 
} 

不過，我可以似乎不會以支持雙打的方式重新格式化代碼。我甚至讀到了解釋，found here。

有誰知道什麼是解決這個問題的最好方法？

---

在任何人決定，以紀念這是一個重複：不這樣做，因爲只有相似的問題是爲那些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如其他人的評論中所述。