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`) 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`) 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`) 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`) 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`) 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`) 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`) Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

These functions, from TS 18661-1:2014, 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`) 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`) 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`) 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`) 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:
*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:
*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:
*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`) Preliminary: | MT-Safe | AS-Safe | AC-Safe | See POSIX Safety Concepts.

These functions, from TS 18661-1:2014, 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`) 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`

.