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.
Also see this: http://www.gnu.org/s/hello/manual/libc/Infinity-and-NaN.html
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.
精彩评论