32bit Floats - Integer Accuracy and Interesting Consequences

There are big misconceptions I've seen regarding the accuracy of floats.
One professor of mine even went as far as to say, the computer might not store "2" as "2.0", but rather "2.000019" if using floats.
This is not true.

32-bit floats can actually represent quite a large amount of integer values 100% accurately.

The exact integer-range a 32bit float can represent accurately is -16777216 to 16777216.
This means that it is roughly equivalent to a 25-bit signed integer, which has the range -16777216 to 16777215.

If you only care about positive values, then the float is equivalent to a 24-bit unsigned integer, which has the range 0 to 16777215.

I commonly see these values messed up, with people saying a float can only represent a 24-bit signed integer (which would be -8388608 to 8388607, which is wrong).

Below I made a test case to prove the floating point range by exhaustive search.

int testFloatRange(bool pos) {
    volatile int    i = 0;
    volatile float  f = 0.0f;
    volatile double d = 0.0;
    for (;;) {
        volatile double t = (double)(float)i;
        if ((double)f != d || (int)f != i || t != d) break;
        if (pos) { f++; d++; i++; }
        else     { f--; d--; i--; }
    }
    printf("%f != %d\n", f, i);
    return pos ? (i-1) : (i+1);
}

int _tmain(int argc, _TCHAR* argv[]) {
    int p = testFloatRange(1);
    int n = testFloatRange(0);
    printf("Positive Range = 0 to %d\n", p);
    printf("Negative Range = %d to 0\n", n);
    printf("Full Range = %d to %d\n", n, p);
}

Now its pretty interesting what happens once a 32-bit float reaches its limit of 16777216.
If you try to increase the float by 1 when it has this value, the float will actually stay the same. This means if you try to increment a float by 1 in a loop, you will never get past 16777216! It will just get stuck in an infinite loop.

Here is some proof of that:

int _tmain(int argc, _TCHAR* argv[]) {
    volatile float f = 0xffffff-100; 
    for( ; f < 0xffffff+100; f++) {
        printf("Value = %f, Binary Representation (0x%x)\n", f, (int&)f);
    }
}

The programs output is:

...
Value = 16777214.000000, Binary Representation (0x4b7ffffe)
Value = 16777215.000000, Binary Representation (0x4b7fffff)
Value = 16777216.000000, Binary Representation (0x4b800000)
Value = 16777216.000000, Binary Representation (0x4b800000)
... Keeps repeating the last line infinitely...

Admittingly, I didn't know this infinite looping behavior until I made the test-case. This is something you should definitely watch out for.

Oh and btw, you might be wondering why I was using "volatile float" in the above test-cases, instead of just "float". The "volatile" keyword is useful to use when we need to compare floats with their exact precision. I'll probably explain why in another article :)