Why can't we subtract from floating point maximum values?

Question

A few days ago, I was trying to subtract 10000 from std::numeric_limits<float>::max() and I just figured out that the value didn't change at all, no matter what value I was subtracting. In fact, it seems like all floating point types have this behavior.

For instance (on g++ and msvc), this one doesn't pass (good) :

int i = std::numeric_limits<int>::max();
assert(i == i - 10000); // Doesn't pass

But this one does (?) :

float f = std::numeric_limits<float>::max();
assert(f == f - 10000.f); // Pass

I even tried to assign the maximum value directly (in this case 3.40282e+38), but it doesn't seem to change anything. Also, it seems to do the exact same thing with any high enough values. Could someone explain to me why it does so? Thanks.

You can subtract from that value just fine, but subtracting 1 just isn't big enough to get to the next lower float. — user2357112, Nov 22 '17 at 00:27
An assertion occurs because the integer value is 10000 less than the original (i.e. different). But for the floating point value, even great subtraction doesn't seem to change a thing. — Jérémi Panneton, Nov 22 '17 at 00:29
Here I am subtracting 10000 and it doesn't change anything (I updated the question). — Jérémi Panneton, Nov 22 '17 at 00:30
*"no matter what value I was subtracting"* Nonsense. Try subtracting a value in the same order of magnitude. Of course a change in the 50th digit of a 16 digit number does not make a difference. — Baum mit Augen, Nov 22 '17 at 00:31
The max float value is about a `3` followed by 38 zeros. Your subtraction is like removing 2 grains of sand from the beach. Nobody will notice. — Bo Persson, Nov 22 '17 at 00:32
And `float`s typically have the equivalent of about 13 to 16 digits of decimal precision. — David Schwartz, Nov 22 '17 at 00:33
@JérémiPanneton the precision of a float is relative to its magnitude. The maximum float value (according to wikipedia is 3.402823 × 10^38). A float only has 23 bits it can use for precision, so if those 23 bits are used for the precision of such a large value, -10000 won't change the value of those precision bits. — thc, Nov 22 '17 at 00:33

SegFault · Accepted Answer · 2017-11-22T00:38:30.313

6

Floating point numbers are not precise like int. The amount you subtracted is way too small to make a difference in the significand and it just gets lost in the precision. std::numeric_limits<float>::max() is insanely large (3.402823e+38).

If you do:

float f = std::numeric_limits<float>::max();
assert(f == f - f/2.f);

I'm sure it will fail.

edited Nov 22 '17 at 00:38

answered Nov 22 '17 at 00:32

SegFault

2,526
4
21
41

score 1 · Answer 2 · answered Nov 22 '17 at 00:33

You are hitting the limits of IEEE_754 floating point representation. 10000.0 is so small compared to the maximum floating point number, that the value gets rounded to std::numeric_limits<float>::max()

Check the examples in this other answer (Is floating point math broken?) for additional detail.

Why can't we subtract from floating point maximum values?

2 Answers2