Next: Remainder Functions, Previous: Normalization Functions, Up: Arithmetic Functions [Contents][Index]

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`

.