9

比较 IEEE 浮点数和双精度数是否相等的最佳方法是什么？我听说过几种方法，但我想看看社区的想法。

4

15 回答 15

7

我认为最好的方法是比较ULPs。

bool is_nan(float f)
{
    return (*reinterpret_cast<unsigned __int32*>(&f) & 0x7f800000) == 0x7f800000 && (*reinterpret_cast<unsigned __int32*>(&f) & 0x007fffff) != 0;
}

bool is_finite(float f)
{
    return (*reinterpret_cast<unsigned __int32*>(&f) & 0x7f800000) != 0x7f800000;
}

// if this symbol is defined, NaNs are never equal to anything (as is normal in IEEE floating point)
// if this symbol is not defined, NaNs are hugely different from regular numbers, but might be equal to each other
#define UNEQUAL_NANS 1
// if this symbol is defined, infinites are never equal to finite numbers (as they're unimaginably greater)
// if this symbol is not defined, infinities are 1 ULP away from +/- FLT_MAX
#define INFINITE_INFINITIES 1

// test whether two IEEE floats are within a specified number of representable values of each other
// This depends on the fact that IEEE floats are properly ordered when treated as signed magnitude integers
bool equal_float(float lhs, float rhs, unsigned __int32 max_ulp_difference)
{
#ifdef UNEQUAL_NANS
    if(is_nan(lhs) || is_nan(rhs))
    {
        return false;
    }
#endif
#ifdef INFINITE_INFINITIES
    if((is_finite(lhs) && !is_finite(rhs)) || (!is_finite(lhs) && is_finite(rhs)))
    {
        return false;
    }
#endif
    signed __int32 left(*reinterpret_cast<signed __int32*>(&lhs));
    // transform signed magnitude ints into 2s complement signed ints
    if(left < 0)
    {
        left = 0x80000000 - left;
    }
    signed __int32 right(*reinterpret_cast<signed __int32*>(&rhs));
    // transform signed magnitude ints into 2s complement signed ints
    if(right < 0)
    {
        right = 0x80000000 - right;
    }
    if(static_cast<unsigned __int32>(std::abs(left - right)) <= max_ulp_difference)
    {
        return true;
    }
    return false;
}

类似的技术可用于双打。诀窍是转换浮点数，以便它们是有序的（就像整数一样），然后看看它们有多么不同。

我不知道为什么这个该死的东西把我的下划线搞砸了。编辑：哦，也许这只是预览的产物。那没关系。

于 2008-08-21T21:53:18.350 回答
3

我正在使用的当前版本是这个

bool is_equals(float A, float B,
               float maxRelativeError, float maxAbsoluteError)
{

  if (fabs(A - B) < maxAbsoluteError)
    return true;

  float relativeError;
  if (fabs(B) > fabs(A))
    relativeError = fabs((A - B) / B);
  else
    relativeError = fabs((A - B) / A);

  if (relativeError <= maxRelativeError)
    return true;

  return false;
}

这似乎通过结合相对和绝对容错来解决大多数问题。ULP 方法更好吗？如果是这样，为什么？

于 2008-08-21T22:00:37.397 回答
1

@DrPizza：我不是性能专家，但我希望定点运算比浮点运算更快（在大多数情况下）。

这取决于你对他们做什么。与 IEEE 浮点数具有相同范围的定点类型会慢很多倍（并且大很多倍）。

适合花车的东西：

3D 图形、物理/工程、模拟、气候模拟....

于 2008-08-21T22:57:00.147 回答
1

在数值软件中，您经常想要测试两个浮点数是否完全相等。LAPACK 充满了此类情况的示例。当然，最常见的情况是您要测试浮点数是否等于“零”、“一”、“二”、“半”。如果有人感兴趣，我可以选择一些算法并更详细地介绍。

同样在 BLAS 中，您经常想要检查浮点数是否正好是零或一。例如，例程 dgemv 可以计算以下形式的操作

  • y = beta*y + alpha*A*x
  • y = beta*y + alpha*A^T*x
  • y = beta*y + alpha*A^H*x

因此，如果 beta 等于 One，则您有一个“加号分配”，而对于 beta 等于 0，您有一个“简单分配”。因此，如果您对这些（常见）情况进行特殊处理，您当然可以降低计算成本。

当然，您可以设计 BLAS 例程以避免精确比较（例如使用一些标志）。然而，LAPACK 充满了不可能的例子。

PS：

  • 在很多情况下，您不希望检查“完全相等”。对于许多人来说，这甚至可能是他们唯一需要处理的情况。我想指出的是，还有其他情况。

  • 尽管 LAPACK 是用 Fortran 编写的，但如果您将其他编程语言用于数值软件，则逻辑是相同的。

于 2012-06-10T23:11:55.690 回答
0

哦，亲爱的上帝，除非您在 P6 或更早版本上运行，否则请不要将浮点位解释为整数。

于 2008-08-21T21:54:28.050 回答
0

哦，亲爱的上帝，除非您在 P6 或更早版本上运行，否则请不要将浮点位解释为整数。

即使它导致它通过内存从向量寄存器复制到整数寄存器，即使它停止了管道，这也是我遇到的最好的方法，因为它提供了最强大的比较，即使在面对浮点错误。

即这是一个值得付出的代价。

于 2008-08-21T21:59:00.253 回答
0

这是我遇到的最好的方法，因为即使面对浮点错误，它也能提供最可靠的比较。

如果你有浮点错误，你会遇到比这更多的问题。虽然我想这取决于个人观点。

于 2008-08-21T22:05:05.497 回答
0

这似乎通过结合相对和绝对容错来解决大多数问题。ULP 方法更好吗？如果是这样，为什么？

ULP 是两个浮点数之间“距离”的直接度量。这意味着它们不需要你想出相对和绝对误差值，你也不必确保这些值“大约正确”。使用 ULP，您可以直接表达您希望数字有多接近，并且相同的阈值对于小值和大值同样适用。

于 2008-08-21T22:07:11.700 回答
0

如果你有浮点错误，你会遇到比这更多的问题。虽然我想这取决于个人观点。

即使我们进行数值分析以最大限度地减少误差的累积，我们也无法消除它，我们可能会得到应该相同（如果我们用实数计算）但不同的结果（因为我们不能用实数计算）。

于 2008-08-21T22:09:05.957 回答
0

如果您正在寻找两个相同的浮点数，那么我认为它们应该相同。如果您面临浮点舍入问题，也许定点表示更适合您的问题。

于 2008-08-21T22:09:43.053 回答
0

如果您正在寻找两个相同的浮点数，那么我认为它们应该相同。如果您面临浮点舍入问题，也许定点表示更适合您的问题。

也许我们无法承受这种方法会造成的范围或性能损失。

于 2008-08-21T22:11:27.837 回答
0

如果您正在寻找两个相同的浮点数，那么我认为它们应该相同。如果您面临浮点舍入问题，也许定点表示更适合您的问题。

也许我应该更好地解释这个问题。在 C++ 中，以下代码：

#include <iostream>

using namespace std;


int main()
{
  float a = 1.0;
  float b = 0.0;

  for(int i=0;i<10;++i)
  {
    b+=0.1;
  }

  if(a != b)
  {
    cout << "Something is wrong" << endl;
  }

  return 1;
}

打印短语“Something is wrong”。你说应该吗？

于 2008-08-21T22:20:37.300 回答
0

@DrPizza：我不是性能专家，但我希望定点运算比浮点运算更快（在大多数情况下）。

@Craig H：当然。我完全可以打印它。如果 a 或 b 存钱，那么它们应该以固定点表示。我正在努力想一个真实世界的例子，其中这种逻辑应该与浮点数结合。适合花车的东西：

  • 权重
  • 排名
  • 距离
  • 真实世界的价值（比如来自 ADC）

对于所有这些事情，要么您进行数字化，然后简单地将结果呈现给用户以供人工解释，要么您做出比较陈述（即使这样的陈述是，“这个东西在这个另一个东西的 0.001 范围内”）。像我这样的比较陈述仅在算法的上下文中有用：“在 0.001 以内”部分取决于您要问的物理问题。那是我的 0.02。还是我应该说 2/100？

于 2008-08-21T22:51:20.487 回答
0

这取决于你对他们做什么。与 IEEE 浮点数具有相同范围的定点类型会慢很多倍（并且大很多倍）。

好的，但是如果我想要一个无限小的位分辨率，那么它又回到了我原来的观点：== 和 != 在这样的问题的上下文中没有任何意义。

一个 int 可以让我表达 ~10^9 值（无论范围如何），这对于我关心其中两个相等的任何情况似乎都足够了。如果这还不够，请使用 64 位操作系统，您将获得大约 10^19 个不同的值。

我可以在 int 中表示 0 到 10^200 （例如）范围内的值，它只是受到影响的位分辨率（分辨率会大于 1，但是，同样，没有应用程序也有这种范围作为那种决议）。

总而言之，我认为在所有情况下，一个代表一个连续的值，在这种情况下 != 和 == 是不相关的，或者一个代表一组固定的值，可以映射到一个 int （或另一个固定的-精度类型）。

于 2008-08-21T23:27:11.883 回答
0

一个 int 可以让我表达 ~10^9 值（无论范围如何），这对于我关心其中两个相等的任何情况似乎都足够了。如果这还不够，请使用 64 位操作系统，您将获得大约 10^19 个不同的值。

我实际上已经达到了这个极限......我试图在模拟中兼顾 ps 时间和时钟周期时间，您可以轻松达到 10^10 个周期。不管我做什么，我很快就超出了 64 位整数的微小范围...... 10^19 并不像你想象的那么多，现在给我 128 位计算！

浮点数使我能够解决数学问题，因为值在低端溢出了很多零。所以你基本上有一个小数点在数字中浮动而没有精度损失（与64位整数相比，我希望浮点尾数中允许的不同值的数量更有限，但迫切需要这个范围！ ）。

然后将事物转换回整数进行比较等。

烦人，最后我放弃了整个尝试，只依靠浮点数和 < 和 > 来完成工作。不完美，但适用于设想的用例。

于 2008-10-09T14:07:07.227 回答