C++ – How to Subtract a Very Small Number from a Float in C++

c++

The smallest number that differentiates two float values is FLT_EPSILON, which is defined as:

#define FLT_EPSILON 1.19209290E-07F // decimal constant

(Yes I am aware of this: https://frama-c.com/2013/05/09/Definition-of-FLT_EPSILON.html)

However, upon subtracting a very small number (1e-12) from a zero, I would expect the resulting number to be zero, also considering it is less than half way mark of FLT_EPSILON.

However, the following program outputs:

Value of EPSILONF: -0.000000000001000

#include <stdio.h>
    
#define EPSILONF static_cast<float>(1e-12)
    
int main() {
    printf("Value of EPSILONF: %.15f\n", float(0.0f-EPSILONF));
    return 0;
}

What am I missing here?

Best Answer

The smallest number that differentiates two float values is FLT_EPSILON

What you are missing is that this isn't what FLT_EPSILON is. FLT_EPSILON is the difference between 1.0 and the next representable number greater than 1.0.

Once the absolute value gets close to 0 you get into the range of subnormal numbers (see page 19), where the differences between two consecutive representable numbers are significantly smaller than FLT_EPSILON.

The difference (effectively) between 0.0 and the next greatest representable number is FLT_MIN. For a 32-bit IEEE floating-point it's 2^-149.

Btw, for doubles, the constants are DBL_EPSILON and DBL_MIN.

Related Solutions

C++ Random Float Number Generation

rand() can be used to generate pseudo-random numbers in C++. In combination with RAND_MAX and a little math, you can generate random numbers in any arbitrary interval you choose. This is sufficient for learning purposes and toy programs. If you need truly random numbers with normal distribution, you'll need to employ a more advanced method.

This will generate a number from 0.0 to 1.0, inclusive.

float r = static_cast <float> (rand()) / static_cast <float> (RAND_MAX);

This will generate a number from 0.0 to some arbitrary float, X:

float r2 = static_cast <float> (rand()) / (static_cast <float> (RAND_MAX/X));

This will generate a number from some arbitrary LO to some arbitrary HI:

float r3 = LO + static_cast <float> (rand()) /( static_cast <float> (RAND_MAX/(HI-LO)));

Note that the rand() function will often not be sufficient if you need truly random numbers.

Before calling rand(), you must first "seed" the random number generator by calling srand(). This should be done once during your program's run -- not once every time you call rand(). This is often done like this:

srand (static_cast <unsigned> (time(0)));

In order to call rand or srand you must #include <cstdlib>.

In order to call time, you must #include <ctime>.

C++ Constructor Chaining – How to Call a Constructor from Another Constructor

C++11: Yes!

C++11 and onwards has this same feature (called delegating constructors).

The syntax is slightly different from C#:

class Foo {
public: 
  Foo(char x, int y) {}
  Foo(int y) : Foo('a', y) {}
};

C++03: No

Unfortunately, there's no way to do this in C++03, but there are two ways of simulating this:

You can combine two (or more) constructors via default parameters:

class Foo {
public:
  Foo(char x, int y=0);  // combines two constructors (char) and (char, int)
  // ...
};

Use an init method to share common code:

class Foo {
public:
  Foo(char x);
  Foo(char x, int y);
  // ...
private:
  void init(char x, int y);
};

Foo::Foo(char x)
{
  init(x, int(x) + 7);
  // ...
}

Foo::Foo(char x, int y)
{
  init(x, y);
  // ...
}

void Foo::init(char x, int y)
{
  // ...
}

See the C++FAQ entry for reference.

Best Answer

Related Solutions

C++ Random Float Number Generation

C++ Constructor Chaining – How to Call a Constructor from Another Constructor

Related Question