我认为这取决于你电脑的精度。 看一下这张表:你可以看到，如果用double表示，但你的精度更高，比较并不等于

someValue == 0.0

不管怎样，这是个好问题!

假设系统无法区分1.000000000000000000000和1.00000000000000001。这是1.0和1.0 + 1e-20。你认为在-1e-20和+1e-20之间还有一些值可以表示吗?

该测试当然与someValue == 0不同。浮点数的全部思想是存储一个指数和一个显著值。因此，它们表示具有一定数量的精度二进制有效位数的值(在IEEE双精度的情况下为53)。可表示值在0附近比在1附近密集得多。

为了使用更熟悉的十进制系统，假设您使用exponent存储一个“4位有效数字”的十进制值。那么下一个大于1的可表示值是1.001 * 10^0，是1.000 * 10^ 3。但是1.000 * 10^-4也是可以表示的，假设指数可以存储-4。你可以相信我的话，IEEE double可以存储小于的指数。

你不能仅仅从这段代码中判断用作为边界是否有意义，你需要看一下上下文。可能是对产生someValue的计算错误的合理估计，也可能不是。

你不能把这个应用到0，因为有尾数和指数部分。 由于指数可以存储很小的数，小于， 但是当你尝试做一些类似(1.0 -“非常小的数字”)的事情时，你会得到1.0。 Epsilon不是值的指示器，而是值精度的指示器，值精度是尾数。 它显示了我们可以存储多少个正确的十进制数字。

有些数字存在于0和之间，因为是1和下一个可以在1以上表示的最高数字之间的差值，而不是0和下一个可以在0以上表示的最高数字之间的差值(如果是这样的话，代码就做得很少):-

#include <limits>

int main ()
{
  struct Doubles
  {
      double one;
      double epsilon;
      double half_epsilon;
  } values;

  values.one = 1.0;
  values.epsilon = std::numeric_limits<double>::epsilon();
  values.half_epsilon = values.epsilon / 2.0;
}

使用调试器，在main结束时停止程序并查看结果，您将看到epsilon / 2不同于epsilon、0和1。

所以这个函数取正/-之间的值并使它们为零。

假设64位IEEE双精度，则有52位尾数和11位指数。让我们把它分解一下:

1.0000 00000000 00000000 00000000 00000000 00000000 00000000 × 2^0 = 1

大于1的最小可表示数:

1.0000 00000000 00000000 00000000 00000000 00000000 00000001 × 2^0 = 1 + 2^-52

因此:

epsilon = (1 + 2^-52) - 1 = 2^-52

在0和之间有数字吗?很多……例如，最小正可表示(正常)数为:

1.0000 00000000 00000000 00000000 00000000 00000000 00000000 × 2^-1022 = 2^-1022

事实上，在0和之间有(1022 - 52 + 1)×2^52 = 4372995238176751616个数字，这是所有正可表示数字的47%…

假设我们正在使用适合16位寄存器的玩具浮点数。有一个符号位，一个5位指数和一个10位尾数。

这个浮点数的值是尾数，解释为二进制十进制值，乘以2的指数次方。

在1附近，指数等于0。尾数中最小的数字是1024的1分之一。

接近1/2的指数是- 1，所以尾数最小的部分是一半大。如果是5位指数，它可以达到负16，此时尾数最小的部分值为3200万分之一。在- 16指数处，这个值大约是32k的1分之1，比我们上面计算的1附近更接近于0 !

这是一个玩具式的浮点模型，它不能反映真正的浮点系统的所有怪癖，但是它反映小于的值的能力与真正的浮点值相当相似。

可以用下面的程序输出一个数(1.0,0.0，…)的近似值(可能的最小差值)。输出如下: 0.0 = 4.940656e-324 1.0的是2.220446e-16 稍微思考一下就会明白，我们用来计算它的值的数字越小，指数就越小，因为指数可以调整到这个数字的大小。

#include <stdio.h>
#include <assert.h>
double getEps (double m) {
  double approx=1.0;
  double lastApprox=0.0;
  while (m+approx!=m) {
    lastApprox=approx;
    approx/=2.0;
  }
  assert (lastApprox!=0);
  return lastApprox;
}
int main () {
  printf ("epsilon for 0.0 is %e\n", getEps (0.0));
  printf ("epsilon for 1.0 is %e\n", getEps (1.0));
  return 0;
}

使用IEEE浮点，在最小的非零正数和最小的非零负数之间，存在两个值:正零和负零。测试一个值是否在最小的非零值之间等价于测试与零相等;然而，赋值可能会产生影响，因为它会将负0变为正0。

It would be conceivable that a floating-point format might have three values between the smallest finite positive and negative values: positive infinitesimal, unsigned zero, and negative infinitesimal. I am not familiar with any floating-point formats that in fact work that way, but such a behavior would be perfectly reasonable and arguably better than that of IEEE (perhaps not enough better to be worth adding extra hardware to support it, but mathematically 1/(1/INF), 1/(-1/INF), and 1/(1-1) should represent three distinct cases illustrating three different zeroes). I don't know whether any C standard would mandate that signed infinitesimals, if they exist, would have to compare equal to zero. If they do not, code like the above could usefully ensure that e.g. dividing a number repeatedly by two would eventually yield zero rather than being stuck on "infinitesimal".

Also, a good reason for having such a function is to remove "denormals" (those very small numbers that can no longer use the implied leading "1" and have a special FP representation). Why would you want to do this? Because some machines (in particular, some older Pentium 4s) get really, really slow when processing denormals. Others just get somewhat slower. If your application doesn't really need these very small numbers, flushing them to zero is a good solution. Good places to consider this are the last steps of any IIR filters or decay functions.

请参见:为什么将0.1f更改为0会使性能降低10倍?

和http://en.wikipedia.org/wiki/Denormal_number

X和X的下一个值之间的差值根据X而变化。 Epsilon()只是1和下一个1的值之间的差。 0和下一个0值之间的差不是()。

相反，你可以使用std::nextafter来比较双精度值和0，如下所示:

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

double someValue = ...
if (same (someValue, 0.0)) {
  someValue = 0.0;
}

“1和大于1的最小值之间的差值”意味着1 +“机器零”，这大约是10^-8或10^-16，这取决于你是否使用双变量的浮点数。你可以用1除以2，直到计算机看到1 = 1+1/2^p，如下所示:

#include <iostream>
#include "math.h"
using namespace std;

int main() {
    float a = 1;
    int n = 0;
    while(1+a != 1){
        a = a/2;
        n +=1;
    }
    cout << n-1 << endl << pow(2,-n);
    return 0;
}