Sample output from feature test program: version 1.1
HP/Intel Itanium 2 (2CPUs, 1GHz, 8GB RAM, 36GB disk):
GNU/Linux 2.4.18-e.12smp [Red Hat Linux Advanced Server release 2.1AS
(Derry)]
Compiler = ecc -Kc++
Available standard predefined constant macros...
__bool_true_false_are_defined = 1
__DATE__ = "Apr 4 2003"
__FILE__ = "features.c"
__LINE__ = 179
__STDC__ = 1
__STDC_HOSTED__ = 1
__STDC_IEC_559__ = 1
__STDC_IEC_559_COMPLEX__ = 1
__STDC_ISO_10646__ = 200009
__STDC_VERSION__ = 199901
__TIME__ = "10:07:55"
Missing standard predefined constant macros...
__cplusplus
__func__
__STDC_CONSTANT_MACROS
__STDC_FORMAT_MACROS
__STDC_LIMIT_MACROS
Available standard header files...
<fenv.h>
<inttypes.h>
<math.h>
<signal.h>
<stdbool.h>
<stddef.h>
<stdint.h>
<stdio.h>
<stdlib.h>
<sys/types.h>
<time.h>
<unistd.h>
<wchar.h>
<wctype.h>
Missing standard header files...
Pointer sizes...
sizeof(char*) = 8
sizeof(void*) = 8
sizeof(void(*)(void)) = 8
Integer sizes...
sizeof(char) = 1
sizeof(short) = 2
sizeof(int) = 4
sizeof(long) = 8
sizeof(long long) = 8
Integer-like sizes...
sizeof(clock_t) = 8
sizeof(div_t) = 8
sizeof(fpos_t) = 16
sizeof(intmax_t) = 8
sizeof(ldiv_t) = 16
sizeof(off_t) = 8
sizeof(ptrdiff_t) = 8
sizeof(sig_atomic_t) = 4
sizeof(size_t) = 8
sizeof(time_t) = 8
sizeof(uintmax_t) = 8
sizeof(wchar_t) = 4
C++ 1998 integer-like sizes...
C99 integer-like sizes...
sizeof(fenv_t) = 8
sizeof(fexcept_t) = 8
sizeof(imaxdiv_t) = 16
sizeof(int8_t) = 1
sizeof(int_fast16_t) = 8
sizeof(int_fast32_t) = 8
sizeof(int_fast64_t) = 8
sizeof(int_fast8_t) = 1
sizeof(int_least16_t) = 2
sizeof(int_least32_t) = 4
sizeof(int_least64_t) = 8
sizeof(int_least8_t) = 1
sizeof(intptr_t) = 8
sizeof(mbstate_t) = 8
sizeof(ssize_t) = 8
sizeof(uint_fast16_t) = 8
sizeof(uint_fast32_t) = 8
sizeof(uint_fast64_t) = 8
sizeof(uint_fast8_t) = 1
sizeof(uint_least16_t) = 2
sizeof(uint_least32_t) = 4
sizeof(uint_least64_t) = 8
sizeof(uint_least8_t) = 1
sizeof(uintptr_t) = 8
sizeof(wchar_t) = 4
sizeof(wctrans_t) = 8
sizeof(wctype_t) = 8
sizeof(wint_t) = 4
sizeof(_Bool) = 1
Floating-point sizes...
sizeof(float) = 4
sizeof(double) = 8
sizeof(long double) = 16
Missing data types...
double_t
float_t
lldiv_t
nothrow_t
_Complex
_Imaginary
float limits:
smallest floating-point number: 1.40129846e-45 == 2^(-149) [IEEE 754 smallest 32-bit subnormal]
machine epsilon: 1.19209290e-07 == 2^(-23) [IEEE 754 32-bit conformant]
double limits:
smallest floating-point number: 4.94065646e-324 == 2^(-1074) [IEEE 754 smallest 64-bit subnormal]
machine epsilon: 2.22044605e-16 == 2^(-52) [IEEE 754 64-bit conformant]
long double limits:
smallest floating-point number: 0.00000000e+00 == 2^(-16445) [IEEE 754 smallest 80-bit subnormal]
machine epsilon: 1.08420217e-19 == 2^(-63) [IEEE 754 80-bit conformant]
long double appears to be 128-bit value stored in 128-bit (16-byte) field
======================================== inf
Test of Infinity handling in single-precision IEEE 754 arithmetic:
sizeof(float) = 4
NaN in hexadecimal = 0x7f800000
(Inf == Inf): OK
(Inf <= Inf): OK
(Inf >= Inf): OK
(Inf != 0.0): OK
(Inf > 0.0): OK
(Inf >= 0.0): OK
(0.0 != Inf): OK
(0.0 <= Inf): OK
(0.0 < Inf): OK
(-Inf == -Inf): OK
(-Inf <= -Inf): OK
(-Inf >= -Inf): OK
(-Inf != 0.0): OK
(-Inf <= 0.0): OK
(-Inf < 0.0): OK
(0.0 != -Inf): OK
(0.0 > -Inf): OK
(0.0 >= -Inf): OK
(0.0 == 1/Inf): OK
IsInf(Inf): OK
IsInf(Inf + Inf): OK
!IsNaN(Inf + Inf): OK
!IsNaN(Inf - Inf): WRONG
Test of Infinity handling in double-precision IEEE 754 arithmetic:
sizeof(double) = 8
NaN in hexadecimal = 0x_7ff00000_00000000 [little-endian storage order]
(Inf == Inf): OK
(Inf <= Inf): OK
(Inf >= Inf): OK
(Inf != 0.0): OK
(Inf > 0.0): OK
(Inf >= 0.0): OK
(0.0 != Inf): OK
(0.0 <= Inf): OK
(0.0 < Inf): OK
(-Inf == -Inf): OK
(-Inf <= -Inf): OK
(-Inf >= -Inf): OK
(-Inf != 0.0): OK
(-Inf <= 0.0): OK
(-Inf < 0.0): OK
(0.0 != -Inf): OK
(0.0 > -Inf): OK
(0.0 >= -Inf): OK
(0.0 == 1/Inf): OK
IsInf(Inf): OK
IsInf(Inf + Inf): OK
!IsNaN(Inf + Inf): OK
!IsNaN(Inf - Inf): WRONG
Test of Infinity handling in extended-precision IEEE 754 arithmetic:
sizeof(long double) = 16
NaN in hexadecimal = 0x_7fff8000_00000000_0000 [little-endian storage order]
(Inf == Inf): OK
(Inf <= Inf): OK
(Inf >= Inf): OK
(Inf != 0.0): OK
(Inf > 0.0): OK
(Inf >= 0.0): OK
(0.0 != Inf): OK
(0.0 <= Inf): OK
(0.0 < Inf): OK
(-Inf == -Inf): OK
(-Inf <= -Inf): OK
(-Inf >= -Inf): OK
(-Inf != 0.0): OK
(-Inf <= 0.0): OK
(-Inf < 0.0): OK
(0.0 != -Inf): OK
(0.0 > -Inf): OK
(0.0 >= -Inf): OK
(0.0 == 1/Inf): OK
IsInf(Inf): OK
IsInf(Inf + Inf): OK
!IsNaN(Inf + Inf): OK
IsNaN(Inf - Inf): OK
======================================== nan
Test of NaN handling in single-precision IEEE 754 arithmetic:
sizeof(float) = 4
NaN in hexadecimal = 0xffc00000
(NaN != NaN): OK
(NaN != 0.0): OK
(NaN > 0.0): WRONG
(NaN >= 0.0): WRONG
(0.0 != NaN): OK
(0.0 > NaN): WRONG
(0.0 >= NaN): WRONG
Test of NaN handling in double-precision IEEE 754 arithmetic:
sizeof(double) = 8
NaN in hexadecimal = 0x_fff80000_00000000 [little-endian storage order]
Test of NaN handling in extended-precision IEEE 754 arithmetic:
sizeof(long double) = 16
NaN in hexadecimal = 0x_ffffc000_00000000_0000 [little-endian storage order]
(NaN != NaN): OK
(NaN != 0.0): OK
(0.0 != NaN): OK
======================================== zero
Test of zero handling in single-precision IEEE 754 arithmetic:
sizeof(float) = 4
+zero is unsigned OK
-zero is signed OK
0 - 0 is unsigned OK
(-0) - (+0) is signed OK
(+1)*(0) is unsigned OK
(-1)*(0) is signed OK
Test of zero handling in double-precision IEEE 754 arithmetic:
sizeof(double) = 8
+zero is unsigned OK
-zero is signed OK
0 - 0 is unsigned OK
(-0) - (+0) is signed OK
(+1)*(0) is unsigned OK
(-1)*(0) is signed OK
Test of zero handling in extended-precision IEEE 754 arithmetic:
sizeof(long double) = 16
+zero is unsigned OK
-zero is unsigned WRONG
0 - 0 is unsigned OK
(-0) - (+0) is unsigned WRONG
(+1)*(0) is unsigned OK
(-1)*(0) is unsigned WRONG