Next: FP Comparison Functions, Previous: Remainder Functions, Up: Arithmetic Functions

There are some operations that are too complicated or expensive to perform by hand on floating-point numbers. ISO C99 defines functions to do these operations, which mostly involve changing single bits.

— Function: double **copysign** (`double x, double y`)

— Function: floatcopysignf(float x, float y)

— Function: long doublecopysignl(long double x, long double y)

These functions return

xbut with the sign ofy. They work even ifxoryare NaN or zero. Both of these can carry a sign (although not all implementations support it) and this is one of the few operations that can tell the difference.

`copysign`

never raises an exception.This function is defined in IEC 559 (and the appendix with recommended functions in IEEE 754/IEEE 854).

— Function: int **signbit** (*float-type*` x`)

`signbit`

is a generic macro which can work on all floating-point types. It returns a nonzero value if the value ofxhas its sign bit set.This is not the same as

`x < 0.0`

, because IEEE 754 floating point allows zero to be signed. The comparison`-0.0 < 0.0`

is false, but`signbit (-0.0)`

will return a nonzero value.

— Function: double **nextafter** (`double x, double y`)

— Function: floatnextafterf(float x, float y)

— Function: long doublenextafterl(long double x, long double y)

The

`nextafter`

function returns the next representable neighbor ofxin the direction towardsy. The size of the step betweenxand the result depends on the type of the result. Ifx=ythe function simply returnsy. If either value is`NaN`

,`NaN`

is returned. Otherwise a value corresponding to the value of the least significant bit in the mantissa is added or subtracted, depending on the direction.`nextafter`

will signal overflow or underflow if the result goes outside of the range of normalized numbers.This function is defined in IEC 559 (and the appendix with recommended functions in IEEE 754/IEEE 854).

— Function: double **nexttoward** (`double x, long double y`)

— Function: floatnexttowardf(float x, long double y)

— Function: long doublenexttowardl(long double x, long double y)

These functions are identical to the corresponding versions of

`nextafter`

except that their second argument is a`long double`

.

— Function: double **nan** (`const char *tagp`)

— Function: floatnanf(const char *tagp)

— Function: long doublenanl(const char *tagp)

The

`nan`

function returns a representation of NaN, provided that NaN is supported by the target platform.`nan ("`

n-char-sequence`")`

is equivalent to`strtod ("NAN(`

n-char-sequence`)")`

.The argument

tagpis used in an unspecified manner. On IEEE 754 systems, there are many representations of NaN, andtagpselects one. On other systems it may do nothing.