Defined in header <math.h> | ||
---|---|---|
float rintf( float arg ); | (1) | (since C99) |
double rint( double arg ); | (2) | (since C99) |
long double rintl( long double arg ); | (3) | (since C99) |
Defined in header <tgmath.h> | ||
#define rint( arg ) | (4) | (since C99) |
Defined in header <math.h> | ||
long lrintf( float arg ); | (5) | (since C99) |
long lrint( double arg ); | (6) | (since C99) |
long lrintl( long double arg ); | (7) | (since C99) |
Defined in header <tgmath.h> | ||
#define lrint( arg ) | (8) | (since C99) |
Defined in header <math.h> | ||
long long llrintf( float arg ); | (9) | (since C99) |
long long llrint( double arg ); | (10) | (since C99) |
long long llrintl( long double arg ); | (11) | (since C99) |
Defined in header <tgmath.h> | ||
#define llrint( arg ) | (12) | (since C99) |
arg
to an integer value in floating-point format, using the current rounding mode.arg
to an integer value in integer format, using the current rounding mode.arg
has type long double
, rintl
, lrintl
, llrintl
is called. Otherwise, if arg
has integer type or the type double
, rint
, lrint
, llrint
is called. Otherwise, rintf
, lrintf
, llrintf
is called, respectively.arg | - | floating point value |
If no errors occur, the nearest integer value to arg
, according to the current rounding mode, is returned.
Errors are reported as specified in math_errhandling.
If the result of lrint
or llrint
is outside the range representable by the return type, a domain error or a range error may occur.
If the implementation supports IEEE floating-point arithmetic (IEC 60559), For the rint
function:
arg
is ±∞, it is returned, unmodified arg
is ±0, it is returned, unmodified arg
is NaN, NaN is returned lrint
and llrint
functions: arg
is ±∞, FE_INVALID
is raised and an implementation-defined value is returned FE_INVALID
is raised and an implementation-defined value is returned arg
is NaN, FE_INVALID
is raised and an implementation-defined value is returned POSIX specifies that all cases where lrint
or llrint
raise FE_INEXACT
are domain errors.
As specified in math_errhandling, FE_INEXACT
may be (but isn't required to be on non-IEEE floating-point platforms) raised by rint
when rounding a non-integer finite value.
The only difference between rint
and nearbyint
is that nearbyint
never raises FE_INEXACT
.
The largest representable floating-point values are exact integers in all standard floating-point formats, so rint
never overflows on its own; however the result may overflow any integer type (including intmax_t
), when stored in an integer variable.
If the current rounding mode is...
FE_DOWNWARD
, then rint
is equivalent to floor
. FE_UPWARD
, then rint
is equivalent to ceil
. FE_TOWARDZERO
, then rint
is equivalent to trunc
FE_TONEAREST
, then rint
differs from round
in that halfway cases are rounded to even rather than away from zero. #include <stdio.h> #include <math.h> #include <fenv.h> #include <limits.h> int main(void) { #pragma STDC FENV_ACCESS ON fesetround(FE_TONEAREST); printf("rounding to nearest (halfway cases to even):\n" "rint(+2.3) = %+.1f ", rint(2.3)); printf("rint(+2.5) = %+.1f ", rint(2.5)); printf("rint(+3.5) = %+.1f\n", rint(3.5)); printf("rint(-2.3) = %+.1f ", rint(-2.3)); printf("rint(-2.5) = %+.1f ", rint(-2.5)); printf("rint(-3.5) = %+.1f\n", rint(-3.5)); fesetround(FE_DOWNWARD); printf("rounding down: \nrint(+2.3) = %+.1f ", rint(2.3)); printf("rint(+2.5) = %+.1f ", rint(2.5)); printf("rint(+3.5) = %+.1f\n", rint(3.5)); printf("rint(-2.3) = %+.1f ", rint(-2.3)); printf("rint(-2.5) = %+.1f ", rint(-2.5)); printf("rint(-3.5) = %+.1f\n", rint(-3.5)); printf("rounding down with lrint: \nlrint(+2.3) = %ld ", lrint(2.3)); printf("lrint(+2.5) = %ld ", lrint(2.5)); printf("lrint(+3.5) = %ld\n", lrint(3.5)); printf("lrint(-2.3) = %ld ", lrint(-2.3)); printf("lrint(-2.5) = %ld ", lrint(-2.5)); printf("lrint(-3.5) = %ld\n", lrint(-3.5)); printf("lrint(-0.0) = %ld\n", lrint(-0.0)); printf("lrint(-Inf) = %ld\n", lrint(-INFINITY)); // FE_INVALID raised // error handling feclearexcept(FE_ALL_EXCEPT); printf("rint(1.1) = %.1f\n", rint(1.1)); if(fetestexcept(FE_INEXACT)) puts(" FE_INEXACT was raised"); feclearexcept(FE_ALL_EXCEPT); printf("lrint(LONG_MIN-2048.0) = %ld\n", lrint(LONG_MIN-2048.0)); if(fetestexcept(FE_INVALID)) puts(" FE_INVALID was raised"); }
Possible output:
rounding to nearest (halfway cases to even): rint(+2.3) = +2.0 rint(+2.5) = +2.0 rint(+3.5) = +4.0 rint(-2.3) = -2.0 rint(-2.5) = -2.0 rint(-3.5) = -4.0 rounding down: rint(+2.3) = +2.0 rint(+2.5) = +2.0 rint(+3.5) = +3.0 rint(-2.3) = -3.0 rint(-2.5) = -3.0 rint(-3.5) = -4.0 rounding down with lrint: lrint(+2.3) = 2 lrint(+2.5) = 2 lrint(+3.5) = 3 lrint(-2.3) = -3 lrint(-2.5) = -3 lrint(-3.5) = -4 lrint(-0.0) = 0 lrint(-Inf) = -9223372036854775808 rint(1.1) = 1.0 FE_INEXACT was raised lrint(LONG_MIN-2048.0) = -9223372036854775808 FE_INVALID was raised
(C99)(C99)(C99) | rounds to nearest integer not greater in magnitude than the given value (function) |
(C99)(C99)(C99) | rounds to an integer using current rounding mode (function) |
(C99)(C99) | gets or sets rounding direction (function) |
© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
http://en.cppreference.com/w/c/numeric/math/rint