浮动和双重比较最有效的方法是什么？

你写的代码有问题：

return (diff < EPSILON) && (-diff > EPSILON);

正确的代码是：

return (diff < EPSILON) && (diff > -EPSILON);

（......是的，这是不同的）

我想知道在某些情况下晶圆厂是否不会让你失去懒惰的评估。我会说这取决于编译器。您可能想尝试两者。如果它们平均相等，请使用 fabs 实施。

如果您有一些关于两个浮点数中的哪一个更可能比另一个更大的信息，您可以按照比较的顺序进行操作，以更好地利用惰性评估。

最后，通过内联这个函数，你可能会得到更好的结果。虽然不太可能改善...

编辑：OJ，感谢您更正您的代码。我相应地删除了我的评论

---

`return fabs(a - b) < EPSILON;

这很好，如果：

您输入的数量级变化不大

非常少量的相反符号可以被视为相等

但否则它会给你带来麻烦。双精度数字的分辨率约为小数点后 16 位。如果您要比较的两个数字的幅度大于 EPSILON*1.0E16，那么您不妨说：

return a==b;

我将研究另一种方法，假设您需要担心第一个问题并假设第二个问题对您的应用程序来说很好。解决方案类似于：

#define VERYSMALL  (1.0E-150)
#define EPSILON    (1.0E-8)
bool AreSame(double a, double b)
{
    double absDiff = fabs(a - b);
    if (absDiff < VERYSMALL)
    {
        return true;
    }

    double maxAbs  = max(fabs(a) - fabs(b));
    return (absDiff/maxAbs) < EPSILON;
}

这在计算上是昂贵的，但有时是需要的。这是我们在我公司必须做的，因为我们处理的是一个工程库，输入可能会有几十个数量级的变化。

无论如何，重点是这一点（并且几乎适用于所有编程问题）：评估您的需求，然后提出解决方案来满足您的需求——不要假设简单的答案就能满足您的需求。如果在您的评估之后您发现 fabs(a-b) < EPSILON 就足够了，那么完美 - 使用它！但也要注意它的缺点和其他可能的解决方案。

---

正如其他人指出的那样，对于远离 epsilon 值的值，使用固定指数 epsilon（例如 0.0000001）将毫无用处。例如，如果您的两个值是 10000.000977 和 10000，那么这两个数字之间没有 32 位浮点值 - 10000 和 10000.000977 在不逐位相同的情况下尽可能接近。在这里，小于 0.0009 的 epsilon 是没有意义的；您不妨使用直接相等运算符。

同样，当这两个值的大小接近 epsilon 时，相对误差会增长到 100%。

因此，尝试将诸如 0.00001 之类的定点数与浮点值（其中指数是任意的）混合是毫无意义的。只有当您可以确保操作数值位于一个狭窄的域内（即接近某个特定指数）并且您为该特定测试正确选择了一个 epsilon 值时，这才会起作用。如果你从空中拉出一个数字（“嘿！0.00001 很小，所以那一定很好！”），你注定会出现数字错误。我花了很多时间调试糟糕的数字代码，其中一些糟糕的 schmuck 会在随机 epsilon 值中折腾以使另一个测试用例工作。

如果您进行任何类型的数值编程并认为需要使用定点 epsilon，请阅读 BRUCE 关于比较浮点数的文章。

Comparing Floating Point Numbers

---

这是使用 std::numeric_limits::epsilon() 不是答案的证据——它对于大于 1 的值会失败：

我上面评论的证明：

#include <stdio.h>
#include <limits>

double ItoD (__int64 x) {
    // Return double from 64-bit hexadecimal representation.
    return *(reinterpret_cast<double*>(&x));
}

void test (__int64 ai, __int64 bi) {
    double a = ItoD(ai), b = ItoD(bi);
    bool close = std::fabs(a-b) < std::numeric_limits<double>::epsilon();
    printf ("%.16f and %.16f %s close.\n", a, b, close ? "are " : "are not");
}

int main()
{
    test (0x3fe0000000000000L,
          0x3fe0000000000001L);

    test (0x3ff0000000000000L,
          0x3ff0000000000001L);
}

运行产生以下输出：

0.5000000000000000 and 0.5000000000000001 are  close.
1.0000000000000000 and 1.0000000000000002 are not close.

请注意，在第二种情况下（一且仅大于一），两个输入值尽可能接近，但仍比较不接近。因此，对于大于 1.0 的值，您不妨只使用相等测试。比较浮点值时，固定的 epsilon 不会为您节省时间。

---

Qt 实现了两个函数，或许你可以借鉴一下：

static inline bool qFuzzyCompare(double p1, double p2)
{
    return (qAbs(p1 - p2) <= 0.000000000001 * qMin(qAbs(p1), qAbs(p2)));
}

static inline bool qFuzzyCompare(float p1, float p2)
{
    return (qAbs(p1 - p2) <= 0.00001f * qMin(qAbs(p1), qAbs(p2)));
}

您可能需要以下功能，因为

请注意，比较 p1 或 p2 为 0.0 的值将不起作用，比较其中一个值为 NaN 或无穷大的值也不起作用。如果其中一个值始终为 0.0，请改用 qFuzzyIsNull。如果其中一个值可能为 0.0，则一种解决方案是将两个值都加 1.0。

static inline bool qFuzzyIsNull(double d)
{
    return qAbs(d) <= 0.000000000001;
}

static inline bool qFuzzyIsNull(float f)
{
    return qAbs(f) <= 0.00001f;
}

---

不幸的是，即使您的“浪费”代码也不正确。 EPSILON 是可以添加到 1.0 并更改其值的最小值。值 1.0 非常重要——添加到 EPSILON 时较大的数字不会改变。现在，您可以将此值缩放到您要比较的数字，以判断它们是否不同。比较两个双精度的正确表达式是：

if (fabs(a - b) <= DBL_EPSILON * fmax(fabs(a), fabs(b)))
{
    // ...
}

这是最低限度的。不过，一般来说，您希望在计算中考虑噪声并忽略一些最低有效位，因此更现实的比较如下所示：

if (fabs(a - b) <= 16 * DBL_EPSILON * fmax(fabs(a), fabs(b)))
{
    // ...
}

如果比较性能对您非常重要并且您知道值的范围，那么您应该改用定点数。

---

浮点数的通用比较通常没有意义。如何比较实际上取决于手头的问题。在许多问题中，数字被充分离散化以允许在给定的容差范围内进行比较。不幸的是，同样有很多问题，这种技巧并没有真正奏效。例如，当您的观察非常接近障碍时，请考虑使用相关数字的 Heaviside（步进）函数（想到数字股票期权）。执行基于容差的比较不会有多大好处，因为它会有效地将问题从原来的障碍转移到两个新的障碍。同样，此类问题没有通用解决方案，特定解决方案可能需要更改数值方法以实现稳定性。

---

您必须对浮点比较进行此处理，因为浮点数不能像整数类型那样完美地比较。以下是各种比较运算符的函数。

浮点等于 (==)

我也更喜欢减法技术，而不是依赖 fabs() 或 abs()，但我必须在从 64 位 PC 到 ATMega328 微控制器 (Arduino) 的各种架构上快速分析它，才能真正看到它是否能起到很大的作用性能差异。

所以，让我们忘记所有这些绝对值的东西，只做一些减法和比较！

从 Microsoft's example here 修改：

/// @brief      See if two floating point numbers are approximately equal.
/// @param[in]  a        number 1
/// @param[in]  b        number 2
/// @param[in]  epsilon  A small value such that if the difference between the two numbers is
///                      smaller than this they can safely be considered to be equal.
/// @return     true if the two numbers are approximately equal, and false otherwise
bool is_float_eq(float a, float b, float epsilon) {
    return ((a - b) < epsilon) && ((b - a) < epsilon);
}
bool is_double_eq(double a, double b, double epsilon) {
    return ((a - b) < epsilon) && ((b - a) < epsilon);
}

示例用法：

constexpr float EPSILON = 0.0001; // 1e-4
is_float_eq(1.0001, 0.99998, EPSILON);

我不完全确定，但在我看来，对基于 epsilon 的方法的一些批评，如 this highly-upvoted answer 下面的评论中所述，可以通过使用变量 epsilon 来解决，根据浮点值进行缩放比较，像这样：

float a = 1.0001;
float b = 0.99998;
float epsilon = std::max(std::fabs(a), std::fabs(b)) * 1e-4;

is_float_eq(a, b, epsilon);

这样，epsilon 值随浮点值缩放，因此永远不会太小以至于变得微不足道。

为了完整起见，让我们添加其余部分：

大于 (>) 和小于 (<)：

/// @brief      See if floating point number `a` is > `b`
/// @param[in]  a        number 1
/// @param[in]  b        number 2
/// @param[in]  epsilon  a small value such that if `a` is > `b` by this amount, `a` is considered
///             to be definitively > `b`
/// @return     true if `a` is definitively > `b`, and false otherwise
bool is_float_gt(float a, float b, float epsilon) {
    return a > b + epsilon;
}
bool is_double_gt(double a, double b, double epsilon) {
    return a > b + epsilon;
}

/// @brief      See if floating point number `a` is < `b`
/// @param[in]  a        number 1
/// @param[in]  b        number 2
/// @param[in]  epsilon  a small value such that if `a` is < `b` by this amount, `a` is considered
///             to be definitively < `b`
/// @return     true if `a` is definitively < `b`, and false otherwise
bool is_float_lt(float a, float b, float epsilon) {
    return a < b - epsilon;
}
bool is_double_lt(double a, double b, double epsilon) {
    return a < b - epsilon;
}

大于或等于 (>=) 且小于或等于 (<=)

/// @brief      Returns true if `a` is definitively >= `b`, and false otherwise
bool is_float_ge(float a, float b, float epsilon) {
    return a > b - epsilon;
}
bool is_double_ge(double a, double b, double epsilon) {
    return a > b - epsilon;
}

/// @brief      Returns true if `a` is definitively <= `b`, and false otherwise
bool is_float_le(float a, float b, float epsilon) {
    return a < b + epsilon;
}
bool is_double_le(double a, double b, double epsilon) {
    return a < b + epsilon;
}

其他改进：

C++ 中 epsilon 的一个好的默认值是 std::numeric_limits::epsilon()，其计算结果为 0 或 FLT_EPSILON、DBL_EPSILON 或 LDBL_EPSILON。请参阅此处：https://en.cppreference.com/w/cpp/types/numeric_limits/epsilon。您还可以查看 FLT_EPSILON、DBL_EPSILON 和 LDBL_EPSILON 的 float.h 标头。请参阅 https://en.cppreference.com/w/cpp/header/cfloat 和 https://www.cplusplus.com/reference/cfloat/ 您可以改为模板函数，以处理所有浮点类型：float、double , 和 long double，通过模板内的 static_assert() 对这些类型进行类型检查。缩放 epsilon 值是一个好主意，以确保它适用于非常大和非常小的 a 和 b 值。本文推荐并解释：http://realtimecollisiondetection.net/blog/?p=89。因此，您应该通过等于 max(1.0, abs(a), abs(b)) 的缩放值来缩放 epsilon，正如那篇文章所解释的那样。否则，随着 a 和/或 b 幅度的增加，epsilon 最终将相对于那些值变得非常小，以至于它会丢失在浮点误差中。因此，我们将其缩放为像它们一样在数量级上变得更大。但是，使用 1.0 作为 epsilon 的最小允许比例因子还可以确保对于非常小的 a 和 b 值，epsilon 本身不会被缩放得太小，以至于它也会丢失在浮点错误中。因此，我们将最小比例因子限制为 1.0。如果您想将上述函数“封装”到一个类中，请不要。相反，如果您愿意，可以将它们包装在命名空间中以便命名它们。例如：如果将所有独立函数放入名为 float_comparison 的命名空间中，则可以像这样访问 is_eq() 函数，例如：float_comparison::is_eq(1.0, 1.5);。添加与零的比较也可能很好，而不仅仅是两个值之间的比较。因此，这里有一种更好的解决方案，其中包含上述改进： namespace float_comparison { /// 根据上面的解释，将 epsilon 值缩放为较大的 a 或 b， /// 但不小于 1.0 , 以确保 /// epsilon 永远不会因为 a 和/或 b /// 幅度的增加而出现浮点错误。模板 static constexpr T scale_epsilon(T a, T b, T epsilon = std::numeric_limits::epsilon()) noexcept { static_assert(std::is_floating_point_v, "浮点比较" "需要类型 float、double 或 long double。"); T 缩放因子； // a 或 b 为无穷大时的特殊情况 if (std::isinf(a) || std::isinf(b)) { scaling_factor = 0; } else { scaling_factor = std::max({(T)1.0, std::abs(a), std::abs(b)}); } T epsilon_scaled = scaling_factor * std::abs(epsilon);返回 epsilon_scaled; } // 比较两个值 /// 相等：如果 a 近似 == b，则返回 true，否则返回 false template static constexpr bool is_eq(T a, T b, T epsilon = std::numeric_limits ::epsilon()) noexcept { static_assert(std::is_floating_point_v, "浮点比较" "需要类型 float、double 或 long double。"); // 首先测试 `a == b` 以查看 a 和 b 是否都是无穷大 // 或 -infinity return a == b || std::abs(a - b) <= scale_epsilon(a, b, epsilon); } /* etc. etc.: is_eq() is_ne() is_lt() is_le() is_gt() is_ge() */ // 与零比较 /// 相等：如果 a 近似 == 0，则返回 true，否则返回 false否则 template static constexpr bool is_eq_zero(T a, T epsilon = std::numeric_limits::epsilon()) noexcept { static_assert(std::is_floating_point_v, "浮点比较" "需要类型float、double 或 long double。");返回 is_eq(a, (T)0.0, epsilon); } /* 等等等等： is_eq_zero() is_ne_zero() is_lt_zero() is_le_zero() is_gt_zero() is_ge_zero() */ } // 命名空间 float_comparison

也可以看看：

上面的一些函数的宏形式在我的仓库中：utilities.h。 2020 年 11 月 29 日更新：这是一项正在进行中的工作，准备好后我将把它作为一个单独的答案，但我已经在此文件中为 C 中的所有函数生成了一个更好的缩放 epsilon 版本这里: 实用程序.c。看一看。我现在需要做的补充阅读：Christer Ericson 重新审视了浮点容差。非常有用的文章！它讨论了缩放 epsilon 以确保它永远不会陷入浮点错误，即使对于非常大的 a 和/或 b 值也是如此！

---

我的课程基于以前发布的答案。与谷歌的代码非常相似，但我使用了一个将所有 NaN 值推到 0xFF000000 以上的偏差。这样可以更快地检查 NaN。

此代码旨在演示该概念，而不是通用解决方案。 Google 的代码已经展示了如何计算所有平台特定的值，我不想重复所有这些。我已经对此代码进行了有限的测试。

typedef unsigned int   U32;
//  Float           Memory          Bias (unsigned)
//  -----           ------          ---------------
//   NaN            0xFFFFFFFF      0xFF800001
//   NaN            0xFF800001      0xFFFFFFFF
//  -Infinity       0xFF800000      0x00000000 ---
//  -3.40282e+038   0xFF7FFFFF      0x00000001    |
//  -1.40130e-045   0x80000001      0x7F7FFFFF    |
//  -0.0            0x80000000      0x7F800000    |--- Valid <= 0xFF000000.
//   0.0            0x00000000      0x7F800000    |    NaN > 0xFF000000
//   1.40130e-045   0x00000001      0x7F800001    |
//   3.40282e+038   0x7F7FFFFF      0xFEFFFFFF    |
//   Infinity       0x7F800000      0xFF000000 ---
//   NaN            0x7F800001      0xFF000001
//   NaN            0x7FFFFFFF      0xFF7FFFFF
//
//   Either value of NaN returns false.
//   -Infinity and +Infinity are not "close".
//   -0 and +0 are equal.
//
class CompareFloat{
public:
    union{
        float     m_f32;
        U32       m_u32;
    };
    static bool   CompareFloat::IsClose( float A, float B, U32 unitsDelta = 4 )
                  {
                      U32    a = CompareFloat::GetBiased( A );
                      U32    b = CompareFloat::GetBiased( B );

                      if ( (a > 0xFF000000) || (b > 0xFF000000) )
                      {
                          return( false );
                      }
                      return( (static_cast<U32>(abs( a - b ))) < unitsDelta );
                  }
    protected:
    static U32    CompareFloat::GetBiased( float f )
                  {
                      U32    r = ((CompareFloat*)&f)->m_u32;

                      if ( r & 0x80000000 )
                      {
                          return( ~r - 0x007FFFFF );
                      }
                      return( r + 0x7F800000 );
                  }
};

---

我会非常警惕任何涉及浮点减法的答案（例如，fabs(ab) < epsilon）。首先，浮点数在更大的幅度和足够高的幅度（间距大于ε）处变得更加稀疏，您不妨只做a == b。其次，减去两个非常接近的浮点数（因为这些往往是，因为您正在寻找近似相等）正是您获得 catastrophic cancellation 的方式。

虽然不可移植，但我认为 grom 的答案在避免这些问题方面做得最好。

---

在数值软件中实际上存在您想要检查两个浮点数是否完全相等的情况。我在一个类似的问题上发布了这个

https://stackoverflow.com/a/10973098/1447411

所以你不能说“CompareDoubles1”通常是错误的。

---

从数量规模来看：

如果 epsilon 在某种物理意义上是数量大小（即相对值）的一小部分，并且 A 和 B 类型在同一意义上是可比较的，那么我认为以下是完全正确的：

#include <limits>
#include <iomanip>
#include <iostream>

#include <cmath>
#include <cstdlib>
#include <cassert>

template< typename A, typename B >
inline
bool close_enough(A const & a, B const & b,
                  typename std::common_type< A, B >::type const & epsilon)
{
    using std::isless;
    assert(isless(0, epsilon)); // epsilon is a part of the whole quantity
    assert(isless(epsilon, 1));
    using std::abs;
    auto const delta = abs(a - b);
    auto const x = abs(a);
    auto const y = abs(b);
    // comparable generally and |a - b| < eps * (|a| + |b|) / 2
    return isless(epsilon * y, x) && isless(epsilon * x, y) && isless((delta + delta) / (x + y), epsilon);
}

int main()
{
    std::cout << std::boolalpha << close_enough(0.9, 1.0, 0.1) << std::endl;
    std::cout << std::boolalpha << close_enough(1.0, 1.1, 0.1) << std::endl;
    std::cout << std::boolalpha << close_enough(1.1,    1.2,    0.01) << std::endl;
    std::cout << std::boolalpha << close_enough(1.0001, 1.0002, 0.01) << std::endl;
    std::cout << std::boolalpha << close_enough(1.0, 0.01, 0.1) << std::endl;
    return EXIT_SUCCESS;
}

---

我使用这段代码：

bool AlmostEqual(double v1, double v2)
    {
        return (std::fabs(v1 - v2) < std::fabs(std::min(v1, v2)) * std::numeric_limits<double>::epsilon());
    }

---

发现另一个有趣的实现：https://en.cppreference.com/w/cpp/types/numeric_limits/epsilon

#include <cmath>
#include <limits>
#include <iomanip>
#include <iostream>
#include <type_traits>
#include <algorithm>



template<class T>
typename std::enable_if<!std::numeric_limits<T>::is_integer, bool>::type
    almost_equal(T x, T y, int ulp)
{
    // the machine epsilon has to be scaled to the magnitude of the values used
    // and multiplied by the desired precision in ULPs (units in the last place)
    return std::fabs(x-y) <= std::numeric_limits<T>::epsilon() * std::fabs(x+y) * ulp
        // unless the result is subnormal
        || std::fabs(x-y) < std::numeric_limits<T>::min();
}

int main()
{
    double d1 = 0.2;
    double d2 = 1 / std::sqrt(5) / std::sqrt(5);
    std::cout << std::fixed << std::setprecision(20) 
        << "d1=" << d1 << "\nd2=" << d2 << '\n';

    if(d1 == d2)
        std::cout << "d1 == d2\n";
    else
        std::cout << "d1 != d2\n";

    if(almost_equal(d1, d2, 2))
        std::cout << "d1 almost equals d2\n";
    else
        std::cout << "d1 does not almost equal d2\n";
}

---

以更通用的方式：

template <typename T>
bool compareNumber(const T& a, const T& b) {
    return std::abs(a - b) < std::numeric_limits<T>::epsilon();
}

注意：正如@SirGuy 所指出的，这种方法是有缺陷的。我把这个答案留在这里作为一个例子，不要效仿。

---

我使用此代码。与上述答案不同，这允许人们给出代码注释中解释的 abs_relative_error。

第一个版本比较复数，因此可以用复平面中相同长度的两个“矢量”之间的角度来解释错误（这提供了一点见解）。然后从那里得出两个实数的正确公式。

https://github.com/CarloWood/ai-utils/blob/master/almost_equal.h

那么后者是

template<class T>
typename std::enable_if<std::is_floating_point<T>::value, bool>::type
   almost_equal(T x, T y, T const abs_relative_error)
{
  return 2 * std::abs(x - y) <= abs_relative_error * std::abs(x + y);
}

其中 abs_relative_error 基本上是（两倍）最接近文献中定义的绝对值：相对误差。但这只是名称的选择。

我认为在复平面中最清楚地看到了它的真正含义。如果 |x| = 1，并且 y 位于直径为 abs_relative_error 的 x 周围，则认为两者相等。

---

这取决于您希望比较的精确程度。如果您想比较完全相同的数字，那么只需使用 ==。 （除非您实际上想要完全相同的数字，否则您几乎永远不想这样做。）在任何体面的平台上，您还可以执行以下操作：

diff= a - b; return fabs(diff)<EPSILON;

因为 fabs 往往很快。相当快我的意思是它基本上是一个按位与，所以最好是快。

比较双精度和浮点数的整数技巧很好，但往往会使各种 CPU 管道更难以有效处理。由于使用堆栈作为经常使用的值的临时存储区域，现在在某些有序架构上肯定不会更快。 （为那些关心的人加载命中商店。）

---

/// testing whether two doubles are almost equal. We consider two doubles
/// equal if the difference is within the range [0, epsilon).
///
/// epsilon: a positive number (supposed to be small)
///
/// if either x or y is 0, then we are comparing the absolute difference to
/// epsilon.
/// if both x and y are non-zero, then we are comparing the relative difference
/// to epsilon.
bool almost_equal(double x, double y, double epsilon)
{
    double diff = x - y;
    if (x != 0 && y != 0){
        diff = diff/y; 
    }

    if (diff < epsilon && -1.0*diff < epsilon){
        return true;
    }
    return false;
}

我在我的小项目中使用了这个功能，它可以工作，但请注意以下几点：

双精度误差会给您带来惊喜。假设 epsilon = 1.0e-6，那么根据上面的代码，1.0 和 1.000001 不应该被认为是相等的，但是在我的机器上，函数认为它们是相等的，这是因为 1.000001 不能精确地转换为二进制格式，它可能是 1.0000009xxx。我用 1.0 和 1.0000011 测试它，这次我得到了预期的结果。

---

您不能将两个 double 与固定的 EPSILON 进行比较。根据 double 的值，EPSILON 会有所不同。

更好的双重比较是：

bool same(double a, double b)
{
  return std::nextafter(a, std::numeric_limits<double>::lowest()) <= b
    && std::nextafter(a, std::numeric_limits<double>::max()) >= b;
}

---

我的方法可能不正确但很有用

将浮点数转换为字符串，然后进行字符串比较

bool IsFlaotEqual(float a, float b, int decimal)
{
    TCHAR form[50] = _T("");
    _stprintf(form, _T("%%.%df"), decimal);


    TCHAR a1[30] = _T(""), a2[30] = _T("");
    _stprintf(a1, form, a);
    _stprintf(a2, form, b);

    if( _tcscmp(a1, a2) == 0 )
        return true;

    return false;

}

运算符重载也可以

---

我是为 java 写的，但也许你觉得它很有用。它使用 longs 而不是 doubles，但会处理 NaN、subnormals 等。

public static boolean equal(double a, double b) {
    final long fm = 0xFFFFFFFFFFFFFL;       // fraction mask
    final long sm = 0x8000000000000000L;    // sign mask
    final long cm = 0x8000000000000L;       // most significant decimal bit mask
    long c = Double.doubleToLongBits(a), d = Double.doubleToLongBits(b);        
    int ea = (int) (c >> 52 & 2047), eb = (int) (d >> 52 & 2047);
    if (ea == 2047 && (c & fm) != 0 || eb == 2047 && (d & fm) != 0) return false;   // NaN 
    if (c == d) return true;                            // identical - fast check
    if (ea == 0 && eb == 0) return true;                // ±0 or subnormals
    if ((c & sm) != (d & sm)) return false;             // different signs
    if (abs(ea - eb) > 1) return false;                 // b > 2*a or a > 2*b
    d <<= 12; c <<= 12;
    if (ea < eb) c = c >> 1 | sm;
    else if (ea > eb) d = d >> 1 | sm;
    c -= d;
    return c < 65536 && c > -65536;     // don't use abs(), because:
    // There is a posibility c=0x8000000000000000 which cannot be converted to positive
}
public static boolean zero(double a) { return (Double.doubleToLongBits(a) >> 52 & 2047) < 3; }

请记住，经过多次浮点运算后，数字可能与我们预期的大不相同。没有代码可以解决这个问题。

---

这是 lambda 的另一种解决方案：

#include <cmath>
#include <limits>

auto Compare = [](float a, float b, float epsilon = std::numeric_limits<float>::epsilon()){ return (std::fabs(a - b) <= epsilon); };

---