Smallest number added to FLT_MAX to cause overflow - c

Question

I need to find number which is a power of 2 that when added to FLT_MAX will cause overflow. However, when I printf very large power, like 2^300, inf still doesn't appear. Also, I thought that as FLT_MAX is the maximum floating point represented, adding 1 to it will cause overflow immediately.
#include <stdio.h>
#include <float.h>
int main(){
float f = FLT_MAX;
printf("%f", f + pow(2,300));
}
Any help would be appreciated. Thanks!

Answer 1

The answer is (FLT_MAX - nextafterf(FLT_MAX, 0))/2, that is, exactly 0x1p+103 or approximately 1.014120480e+31.
There is a mistake in the method you use to determine the answer : the standard function pow returns a double, and C's “usual arithmetic conversions” (C11 6.3.1.8:1) mean that the expression f + pow(2,300) is computed as a double. It is then printed as a double because of how arguments are passed to variadic functions.
This C program shows how you can arrive to the float value that, added to FLT_MAX with float addition, results in float infinity:
#include <stdio.h>
#include <float.h>
#include <math.h>
int main(){
float f = FLT_MAX;
printf("FLT_MAX: %a\n", f);
float b = nextafterf(f, 0);
printf("number before FLT_MAX: %a\n", b);
float d = f - b;
printf("difference: %a\n", d);
printf("FLT_MAX + d: %a\n", f + d);
printf("FLT_MAX + d/2: %a\n", f + d/2);
printf("FLT_MAX + nextafterf(d/2,0): %a\n", f + nextafterf(d/2,0));
float answer = d/2;
printf("answer: %a %.9e\n", answer, answer);
}
It prints:
FLT_MAX: 0x1.fffffep+127
number before FLT_MAX: 0x1.fffffcp+127
difference: 0x1p+104
FLT_MAX + d: inf
FLT_MAX + d/2: inf
FLT_MAX + nextafterf(d/2,0): 0x1.fffffep+127
answer: 0x1p+103 1.014120480e+31
It shows that if you take the difference between FLT_MAX and its lower neighbor (call this difference d), as you could expect, d added to FLT_MAX produces inf. But this is not the smallest float you can add to FLT_MAX to produce inf—there are smaller candidates. It is enough to add exactly half of d to FLT_MAX in order for the result to tound up to inf. If you add less than that, on the other hand, the result is rounded down to FLT_MAX.

Answer 2

This line is working with double not float.
printf("%f", f + pow(2,300));
To be working with float you need
printf("%f", f + powf(2,300));
and in this case the output is
inf
In the second case the float result is promoted to double in the call to printf, but it's too late, the value is already in an overflow representation.

Answer 3

//float=(-1) ^ s * 2 ^ (x - 127) * (1 + n * 2 ^ -23)
// s xxxxxxxx nnnnnnnnnnnnnnnnnnnnnnn
//FLT_MAX 3.402823466e+38F 2 ^ 128 0 11111110 11111111111111111111111
//FLT_MIN 1.175494351e-38F 2 ^ -126 0 00000001 00000000000000000000000
//FLT_TRUE_MIN 1.401298464e-45F 2 ^ -149 0 00000000 00000000000000000000001
//ONE 1f 2 ^ 0 0 01111111 00000000000000000000000
//INFINITY - 2 ^ 128+ 0 11111111 00000000000000000000000
union
{
float f;
int i;
}k,k2,k3;
k.i = 0b01111111011111111111111111111111; // 2^128 FLT_MAX
k2.i = 0b01110011000000000000000000000000; // 2^103
k3.f = k.f + k2.f; // 2^128+ INFINITY