How to generate NaN, -Infinity and +Infinity in ANSI C?

I use ANSI C89 (not C++), and I want to generate NaN, -Infinity and +Infinity.

Is there any standard way (eg. standard macro)? Or is there any platform and compiler independent way to generate these numbers?

float f = 0.0 / 0.0; // Is f ALWAYS in any platform is NaN?

There is in C99, but not in previous standards AFAIK.

In C99, you'll have NAN and INFINITY macros.

From "Mathematics <math.h>" (§7.12) section

The macro INFINITY expands to a constant expression of type float representing positive or unsigned infinity, if available; ...

If you're stuck with ANSI C89, you're out of luck. See C-FAQ 14.9.

I don't know if this is standard or portable, but here's a start:

jcomeau@intrepid:/tmp$ cat test.c; make test; ./test
#include <stdio.h>
int main() {
 printf("%f\n", 1.0 / 0);
 printf("%f\n", -1.0 / 0);
 printf("%f\n", 0.0 / 0);
 return 0;
}
cc     test.c   -o test
test.c: In function ‘main’:
test.c:3: warning: division by zero
test.c:4: warning: division by zero
test.c:5: warning: division by zero
inf
-inf
-nan

Strangely enough, I can't get positive NaN using this naive approach.

If you use an old compiler where INFINITY does not exists you can also use the macro HUGE_VAL instead, also defined in the <math.h> library.

HUGE_VAL should be available in C89/C90 standard (ISO/IEC 9899:1990).

References: http://en.cppreference.com/w/c/numeric/math/HUGE_VAL

There is an actual way to create infinity and negative infinity. Based on the IEEE 754 standard, which C89 follows, infinity is defined as a floating point number containing all zeroes in the mantissa (first twenty-three bits), and all ones in the exponent (next eight bits). nan is defined as any number with all ones in the exponent, and anything but all zeroes in the mantissa (because that's infinity). The difficult part is generating this number, but this can be accomplished with the following code:

unsigned int p = 0x7F800000; // 0xFF << 23
unsigned int n = 0xFF800000; // 0xFF8 << 20
unsigned int pnan = 0x7F800001; // or anything above this up to 0x7FFFFFFF
unsigned int nnan = 0xFF800001; // or anything above this up to 0xFFFFFFFF

float positiveInfinity = *(float *)&p;
float negativeInfinity = *(float *)&n;
float positiveNaN = *(float *)&pnan;
float negativeNaN = *(float *)&nnan;

However, simply casting an unsigned to a float would result in the compiler creating a float of the same value. So, what we have to do is force the compiler to read the memory as a float, which gives us the desired result.