Floating-Point Number Classification Functions

ISO C99 defines macros that let you determine what sort of floating-point number a variable holds.

Macro: int fpclassify (float-type x)

This is a generic macro which works on all floating-point types and which returns a value of type int. The possible values are:

FP_NAN

The floating-point number x is "Not a Number" (see section Infinity and NaN)

FP_INFINITE

The value of x is either plus or minus infinity (see section Infinity and NaN)

FP_ZERO

The value of x is zero. In floating-point formats like IEEE 754, where zero can be signed, this value is also returned if x is negative zero.

FP_SUBNORMAL

Numbers whose absolute value is too small to be represented in the normal format are represented in an alternate, denormalized format (see section Floating Point Representation Concepts). This format is less precise but can represent values closer to zero. fpclassify returns this value for values of x in this alternate format.

FP_NORMAL

This value is returned for all other values of x. It indicates that there is nothing special about the number.

fpclassify is most useful if more than one property of a number must be tested. There are more specific macros which only test one property at a time. Generally these macros execute faster than fpclassify, since there is special hardware support for them. You should therefore use the specific macros whenever possible.

Macro: int isfinite (float-type x)

This macro returns a nonzero value if x is finite: not plus or minus infinity, and not NaN. It is equivalent to

(fpclassify (x) != FP_NAN && fpclassify (x) != FP_INFINITE)

isfinite is implemented as a macro which accepts any floating-point type.

Macro: int isnormal (float-type x)

This macro returns a nonzero value if x is finite and normalized. It is equivalent to

(fpclassify (x) == FP_NORMAL)

Macro: int isnan (float-type x)

This macro returns a nonzero value if x is NaN. It is equivalent to

(fpclassify (x) == FP_NAN)

Another set of floating-point classification functions was provided by BSD. The GNU C library also supports these functions; however, we recommend that you use the ISO C99 macros in new code. Those are standard and will be available more widely. Also, since they are macros, you do not have to worry about the type of their argument.

Function: int isinf (double x)

Function: int isinff (float x)

Function: int isinfl (long double x)

This function returns -1 if x represents negative infinity, 1 if x represents positive infinity, and 0 otherwise.

Function: int isnan (double x)

Function: int isnanf (float x)

Function: int isnanl (long double x)

This function returns a nonzero value if x is a "not a number" value, and zero otherwise.

Note: The isnan macro defined by ISO C99 overrides the BSD function. This is normally not a problem, because the two routines behave identically. However, if you really need to get the BSD function for some reason, you can write

(isnan) (x)

Function: int finite (double x)

Function: int finitef (float x)

Function: int finitel (long double x)

This function returns a nonzero value if x is finite or a "not a number" value, and zero otherwise.

Function: double infnan (int error)

This function is provided for compatibility with BSD. Its argument is an error code, EDOM or ERANGE; infnan returns the value that a math function would return if it set errno to that value. See section Error Reporting by Mathematical Functions. -ERANGE is also acceptable as an argument, and corresponds to -HUGE_VAL as a value.

In the BSD library, on certain machines, infnan raises a fatal signal in all cases. The GNU library does not do likewise, because that does not fit the ISO C specification.

Portability Note: The functions listed in this section are BSD extensions.

Go to the first, previous, next, last section, table of contents.