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

#### 20.8.3 Rounding Functions

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 +&infin;.

`FP_INT_DOWNWARD`

Round toward -&infin;.

`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 (_FloatN x)
Function: _FloatNx ceilfNx (_FloatNx 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 (_FloatN x)
Function: _FloatNx floorfNx (_FloatNx 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 (_FloatN x)
Function: _FloatNx truncfNx (_FloatNx 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 (_FloatN x)
Function: _FloatNx rintfNx (_FloatNx 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 (_FloatN x)
Function: _FloatNx nearbyintfNx (_FloatNx 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 (_FloatN x)
Function: _FloatNx roundfNx (_FloatNx 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 (_FloatN x)
Function: _FloatNx roundevenfNx (_FloatNx 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 (_FloatN x)
Function: long int lrintfNx (_FloatNx 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 (_FloatN x)
Function: long long int llrintfNx (_FloatNx 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 (_FloatN x)
Function: long int lroundfNx (_FloatNx 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 (_FloatN x)
Function: long long int llroundfNx (_FloatNx 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 (_FloatN x, int round, unsigned int width)
Function: intmax_t fromfpfNx (_FloatNx 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 (_FloatN x, int round, unsigned int width)
Function: uintmax_t ufromfpfNx (_FloatNx 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 (_FloatN x, int round, unsigned int width)
Function: intmax_t fromfpxfNx (_FloatNx 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 (_FloatN x, int round, unsigned int width)
Function: uintmax_t ufromfpxfNx (_FloatNx 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 (_FloatN value, _FloatN *integer-part)
Function: _FloatNx modffNx (_FloatNx value, _FloatNx *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 `*integer-part`, and returns the fractional part. For example, `modf (2.5, &intpart)` returns `0.5` and stores `2.0` into `intpart`.

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