The functions listed here perform operations such as rounding and
truncation of floating-point values. Some of these functions convert
floating point numbers to integer values. They are all declared in
`math.h`.

You can also convert floating-point numbers to integers simply by
casting them to `int`

. This discards the fractional part,
effectively rounding towards zero. However, this only works if the
result can actually be represented as an `int`

—for very large
numbers, this is impossible. The functions listed here return the
result as a `double`

instead to get around this problem.

The `fromfp`

functions use the following macros, from TS
18661-1:2014, to specify the direction of rounding. These correspond
to the rounding directions defined in IEEE 754-2008.

`FP_INT_UPWARD`

¶-
Round toward

*+∞*. `FP_INT_DOWNWARD`

¶-
Round toward

*-∞*. `FP_INT_TOWARDZERO`

¶-
Round toward zero.

`FP_INT_TONEARESTFROMZERO`

¶-
Round to nearest, ties round away from zero.

`FP_INT_TONEAREST`

¶-
Round to nearest, ties round to even.

- Function:
`double`

**ceil**`(double`

¶`x`) - Function:
`float`

**ceilf**`(float`

¶`x`) - Function:
`long double`

**ceill**`(long double`

¶`x`) - Function:
`_FloatN`

**ceilfN**`(_Float`

¶`N``x`) - Function:
`_FloatNx`

**ceilfNx**`(_Float`

¶`N`x`x`) -
Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

These functions round

`x`upwards to the nearest integer, returning that value as a`double`

. Thus,`ceil (1.5)`

is`2.0`

.

- Function:
`double`

**floor**`(double`

¶`x`) - Function:
`float`

**floorf**`(float`

¶`x`) - Function:
`long double`

**floorl**`(long double`

¶`x`) - Function:
`_FloatN`

**floorfN**`(_Float`

¶`N``x`) - Function:
`_FloatNx`

**floorfNx**`(_Float`

¶`N`x`x`) -
Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

These functions round

`x`downwards to the nearest integer, returning that value as a`double`

. Thus,`floor (1.5)`

is`1.0`

and`floor (-1.5)`

is`-2.0`

.

- Function:
`double`

**trunc**`(double`

¶`x`) - Function:
`float`

**truncf**`(float`

¶`x`) - Function:
`long double`

**truncl**`(long double`

¶`x`) - Function:
`_FloatN`

**truncfN**`(_Float`

¶`N``x`) - Function:
`_FloatNx`

**truncfNx**`(_Float`

¶`N`x`x`) -
Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

The

`trunc`

functions round`x`towards zero to the nearest integer (returned in floating-point format). Thus,`trunc (1.5)`

is`1.0`

and`trunc (-1.5)`

is`-1.0`

.

- Function:
`double`

**rint**`(double`

¶`x`) - Function:
`float`

**rintf**`(float`

¶`x`) - Function:
`long double`

**rintl**`(long double`

¶`x`) - Function:
`_FloatN`

**rintfN**`(_Float`

¶`N``x`) - Function:
`_FloatNx`

**rintfNx**`(_Float`

¶`N`x`x`) -
Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

These functions round

`x`to an integer value according to the current rounding mode. See Floating Point Parameters, for information about the various rounding modes. The default rounding mode is to round to the nearest integer; some machines support other modes, but round-to-nearest is always used unless you explicitly select another.If

`x`was not initially an integer, these functions raise the inexact exception.

- Function:
`double`

**nearbyint**`(double`

¶`x`) - Function:
`float`

**nearbyintf**`(float`

¶`x`) - Function:
`long double`

**nearbyintl**`(long double`

¶`x`) - Function:
`_FloatN`

**nearbyintfN**`(_Float`

¶`N``x`) - Function:
`_FloatNx`

**nearbyintfNx**`(_Float`

¶`N`x`x`) -
Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

These functions return the same value as the

`rint`

functions, but do not raise the inexact exception if`x`is not an integer.

- Function:
`double`

**round**`(double`

¶`x`) - Function:
`float`

**roundf**`(float`

¶`x`) - Function:
`long double`

**roundl**`(long double`

¶`x`) - Function:
`_FloatN`

**roundfN**`(_Float`

¶`N``x`) - Function:
`_FloatNx`

**roundfNx**`(_Float`

¶`N`x`x`) -
Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

These functions are similar to

`rint`

, but they round halfway cases away from zero instead of to the nearest integer (or other current rounding mode).

- Function:
`double`

**roundeven**`(double`

¶`x`) - Function:
`float`

**roundevenf**`(float`

¶`x`) - Function:
`long double`

**roundevenl**`(long double`

¶`x`) - Function:
`_FloatN`

**roundevenfN**`(_Float`

¶`N``x`) - Function:
`_FloatNx`

**roundevenfNx**`(_Float`

¶`N`x`x`) -
Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

These functions, from TS 18661-1:2014 and TS 18661-3:2015, are similar to

`round`

, but they round halfway cases to even instead of away from zero.

- Function:
`long int`

**lrint**`(double`

¶`x`) - Function:
`long int`

**lrintf**`(float`

¶`x`) - Function:
`long int`

**lrintl**`(long double`

¶`x`) - Function:
`long int`

**lrintfN**`(_Float`

¶`N``x`) - Function:
`long int`

**lrintfNx**`(_Float`

¶`N`x`x`) -
Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

These functions are just like

`rint`

, but they return a`long int`

instead of a floating-point number.

- Function:
`long long int`

**llrint**`(double`

¶`x`) - Function:
`long long int`

**llrintf**`(float`

¶`x`) - Function:
`long long int`

**llrintl**`(long double`

¶`x`) - Function:
`long long int`

**llrintfN**`(_Float`

¶`N``x`) - Function:
`long long int`

**llrintfNx**`(_Float`

¶`N`x`x`) -
Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

These functions are just like

`rint`

, but they return a`long long int`

instead of a floating-point number.

- Function:
`long int`

**lround**`(double`

¶`x`) - Function:
`long int`

**lroundf**`(float`

¶`x`) - Function:
`long int`

**lroundl**`(long double`

¶`x`) - Function:
`long int`

**lroundfN**`(_Float`

¶`N``x`) - Function:
`long int`

**lroundfNx**`(_Float`

¶`N`x`x`) -
Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

These functions are just like

`round`

, but they return a`long int`

instead of a floating-point number.

- Function:
`long long int`

**llround**`(double`

¶`x`) - Function:
`long long int`

**llroundf**`(float`

¶`x`) - Function:
`long long int`

**llroundl**`(long double`

¶`x`) - Function:
`long long int`

**llroundfN**`(_Float`

¶`N``x`) - Function:
`long long int`

**llroundfNx**`(_Float`

¶`N`x`x`) -
Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

These functions are just like

`round`

, but they return a`long long int`

instead of a floating-point number.

- Function:
`intmax_t`

**fromfp**`(double`

¶`x`, int`round`, unsigned int`width`) - Function:
`intmax_t`

**fromfpf**`(float`

¶`x`, int`round`, unsigned int`width`) - Function:
`intmax_t`

**fromfpl**`(long double`

¶`x`, int`round`, unsigned int`width`) - Function:
`intmax_t`

**fromfpfN**`(_Float`

¶`N``x`, int`round`, unsigned int`width`) - Function:
`intmax_t`

**fromfpfNx**`(_Float`

¶`N`x`x`, int`round`, unsigned int`width`) - Function:
`uintmax_t`

**ufromfp**`(double`

¶`x`, int`round`, unsigned int`width`) - Function:
`uintmax_t`

**ufromfpf**`(float`

¶`x`, int`round`, unsigned int`width`) - Function:
`uintmax_t`

**ufromfpl**`(long double`

¶`x`, int`round`, unsigned int`width`) - Function:
`uintmax_t`

**ufromfpfN**`(_Float`

¶`N``x`, int`round`, unsigned int`width`) - Function:
`uintmax_t`

**ufromfpfNx**`(_Float`

¶`N`x`x`, int`round`, unsigned int`width`) - Function:
`intmax_t`

**fromfpx**`(double`

¶`x`, int`round`, unsigned int`width`) - Function:
`intmax_t`

**fromfpxf**`(float`

¶`x`, int`round`, unsigned int`width`) - Function:
`intmax_t`

**fromfpxl**`(long double`

¶`x`, int`round`, unsigned int`width`) - Function:
`intmax_t`

**fromfpxfN**`(_Float`

¶`N``x`, int`round`, unsigned int`width`) - Function:
`intmax_t`

**fromfpxfNx**`(_Float`

¶`N`x`x`, int`round`, unsigned int`width`) - Function:
`uintmax_t`

**ufromfpx**`(double`

¶`x`, int`round`, unsigned int`width`) - Function:
`uintmax_t`

**ufromfpxf**`(float`

¶`x`, int`round`, unsigned int`width`) - Function:
`uintmax_t`

**ufromfpxl**`(long double`

¶`x`, int`round`, unsigned int`width`) - Function:
`uintmax_t`

**ufromfpxfN**`(_Float`

¶`N``x`, int`round`, unsigned int`width`) - Function:
`uintmax_t`

**ufromfpxfNx**`(_Float`

¶`N`x`x`, int`round`, unsigned int`width`) -
Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

These functions, from TS 18661-1:2014 and TS 18661-3:2015, convert a floating-point number to an integer according to the rounding direction

`round`(one of the`FP_INT_*`

macros). If the integer is outside the range of a signed or unsigned (depending on the return type of the function) type of width`width`bits (or outside the range of the return type, if`width`is larger), or if`x`is infinite or NaN, or if`width`is zero, a domain error occurs and an unspecified value is returned. The functions with an ‘`x`’ in their names raise the inexact exception when a domain error does not occur and the argument is not an integer; the other functions do not raise the inexact exception.

- Function:
`double`

**modf**`(double`

¶`value`, double *`integer-part`) - Function:
`float`

**modff**`(float`

¶`value`, float *`integer-part`) - Function:
`long double`

**modfl**`(long double`

¶`value`, long double *`integer-part`) - Function:
`_FloatN`

**modffN**`(_Float`

¶`N``value`, _Float`N`*`integer-part`) - Function:
`_FloatNx`

**modffNx**`(_Float`

¶`N`x`value`, _Float`N`x *`integer-part`) -
Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

These functions break the argument

`value`into an integer part and a fractional part (between`-1`

and`1`

, exclusive). Their sum equals`value`. Each of the parts has the same sign as`value`, and the integer part is always rounded toward zero.`modf`

stores the integer part in`*`

, and returns the fractional part. For example,`integer-part``modf (2.5, &intpart)`

returns`0.5`

and stores`2.0`

into`intpart`

.