GNU Info

(libc.info)Rounding Functions

---

Next: Remainder Functions Prev: Normalization Functions Up: Arithmetic Functions

---

Enter node , (file) or (file)node

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.

 - Function: double ceil (double X)
 - Function: float ceilf (float X)
 - Function: long double ceill (long double X)
     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)
     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)
     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)
     These functions round X to an integer value according to the
     current rounding mode.  Note: 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)
     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)
     These functions are similar to `rint', but they round halfway
     cases away from zero instead of to the nearest even integer.

 - Function: long int lrint (double X)
 - Function: long int lrintf (float X)
 - Function: long int lrintl (long double X)
     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)
     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)
     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)
     These functions are just like `round', but they return a `long
     long int' instead of a floating-point number.

 - 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)
     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'.