22

I am using GCC 3.4 on Linux (AS 3) and trying to figure out to get DBL_EPSILON, or at least a decent approximation. How can I get it programmatically?

Ken Y-N
  • 14,644
  • 21
  • 71
  • 114
vehomzzz
  • 42,832
  • 72
  • 186
  • 216
  • Related http://stackoverflow.com/questions/1217284/whats-the-smallest-non-zero-positive-floating-point-number-in-perl/1217509#1217509 and – Sinan Ünür Oct 14 '09 at 17:34
  • One thing nobody talked about below and that is important: any definition of Epsilon's value is a bet that comes out of nowhere (or almost). I mean, this a reasonable value defined for resonable computations. The very nature of reals on computers is that they are not exact value (bin vs dec). So any computation widens the gap between the computed and the theoritical values. Epsilon is for this gap. If you really make a lot of computations, you might well end up with this gap being greater than the standard epsilon. Be always extremely careful with reals on computers. – Jacques Jun 07 '20 at 13:02

2 Answers2

39

In C++ it's std::numeric_limits<double>::epsilon().

sbi
  • 219,715
  • 46
  • 258
  • 445
  • 17
    The header file is – Jive Dadson Jul 20 '12 at 02:48
  • You're welcome. One more thing to be aware of is that it does not throw an exception if there is no epsilon. It just quietly returns zero. (At least on MSVC++ 2010) cout << std::numeric_limits::epsilon() << endl; – Jive Dadson Jul 23 '12 at 01:04
  • @JiveDadson epsilon for `int` does not make sense. I guess that's why you are expecting an exception? – wcochran Dec 20 '18 at 18:25
34

It should be in "float.h". That is portable, it's part of the C and C++ standards (albeit deprecated in C++ - use <cfloat> or sbi's answer for "guaranteed" forward compatibility).

If you don't have it, then since your doubles are IEEE 64-bit, you can just steal the value from someone else's float.h. Here's the first one I found:

http://opensource.apple.com/source/gcc/gcc-937.2/float.h

#define DBL_EPSILON 2.2204460492503131e-16

The value looks about right to me, but if you want to be sure on your compiler, you could check that (1.0 + DBL_EPSILON) != 1.0 && (1.0 + DBL_EPSILON/2) == 1.0

Edit: I'm not quite sure what you mean by "programmatically". It's a standard constant, you aren't supposed to calculate it, it's a property of the implementation given to you in a header file. But I guess you could do something like this. Again, assuming IEEE representation or something like it, so that DBL_EPSILON is bound to be whatever power of 0.5 represents a 1 in the last bit of precision of the representation of 1.0:

double getDblEpsilon(void) {
    double d = 1;
    while (1.0 + d/2 != 1.0) {
        d = d/2;
    }
    return d;
}

Beware that depending on compiler settings, intermediate results might have higher precision than double, in which case you'd get a smaller result for d than DBL_EPSILON. Check your compiler manual, or find a way to force the value of 1.0 + d/2 to be stored and reloaded to an actual double object before you compare it to 1.0. Very roughly speaking, on PCs it depends on whether your compiler uses the x86 FPU instructions (higher precision), or newer x64 floating point ops (double precision).

Steve Jessop
  • 273,490
  • 39
  • 460
  • 699