std::rint, std::rintf, std::rintl, std::lrint, std::lrintf, std::lrintl
De cppreference.com
<tbody>
</tbody>
| Definido en el archivo de encabezado <cmath>
|
||
float rint ( float arg ); float rintf( float arg ); |
(1) | (desde C++11) |
double rint ( double arg ); |
(2) | (desde C++11) |
long double rint ( long double arg ); long double rintl( long double arg ); |
(3) | (desde C++11) |
double rint ( TipoEntero arg ); |
(4) | (desde C++11) |
long lrint ( float arg ); long lrintf( float arg ); |
(5) | (desde C++11) |
long lrint ( double arg ); |
(6) | (desde C++11) |
long lrint ( long double arg ); long lrintl( long double arg ); |
(7) | (desde C++11) |
long lrint ( TipoEntero arg ); |
(8) | (desde C++11) |
long long llrint ( float arg ); long long llrintf( float arg ); |
(9) | (desde C++11) |
long long llrint ( double arg ); |
(10) | (desde C++11) |
long long llrint ( long double arg ); long long llrintl( long double arg ); |
(11) | (desde C++11) |
long long llrint ( TipoEntero arg ); |
(12) | (desde C++11) |
1-3) Redondea el argumento de punto flotante
arg a un valor entero (en formato de punto flotante), usando el modo de redondeo actual.5-7, 9-11) Redondea el argumento de punto flotante
arg a un valor entero usando el modo de redondeo actual. 4,8,12) Un conjunto de sobrecargas o una plantilla de función que acepta un argumento de cualquier tipo entero. Equivalente a (2,6,10), respectivamente (el argumento se convierte a
double).Parámetros
| arg | - | Valor de punto flotante. |
Valor de retorno
Si no ocurren errores, se devuelve el entero más cercano a arg, de acuerdo al modo de redondeo actual.
Manejo de errores
Los errores se informan como se especifica en math_errhandling.
Si el resultado de std::lrint o std::llrint está fuera del rango representable por el tipo de retorno, puede ocurrir un error de dominio o un error de rango.
Si la implementación admite la aritmética de punto flotante IEEE (IEC 60559):
- Para la función
std::rint:
- Si
arges +∞, se devuelve +∞. - Si
arges -∞, se devuelve -∞. - Si
arges +0, se devuelve +0. - Si
arges -0, se devuelve -0. - Si
arges NaN, se devuelve NaN.
- Para las funciones
std::lrintystd::llrint:
- Si
arges +∞ o -∞, se genera FE_INVALID y se devuelve un valor definido por la implementación. - Si el resultado del redondeo está fuera del rango del tipo de retorno, se genera FE_INVALID y se devuelve un valor definido por la implementación.
- Si
arges NaN, se genera FE_INVALID y se devuelve un valor definido por la implementación.
Notas
POSIX especifica que todos los casos donde std::lrint o std::llrint generen FE_INEXACT sean errores de dominio.
Como se especifica en math_errhandling, se puede generar FE_INEXACT (pero no es obligatorio que lo sea en plataformas de punto flotante no IEEE) por std::rint al redondear un valor no entero finito.
La única diferencia entre std::rint y std::nearbyint es que std::nearbyint nunca genera FE_INEXACT.
Los valores de punto flotante representables más grandes son enteros exactos en todos los formatos de punto flotante estándar, así que std::rint nunca se desborda por sí misma; sin embargo, el resultado puede desbordar a cualquier tipo entero (incluyendo a std::intmax_t), cuando se almacena en una variable entera.
Si el modo de redondeo actual es:
- FE_DOWNWARD, entonces
std::rintes equivalente a std::floor; - FE_UPWARD, entonces
std::rintes equivalente a std::ceil; - FE_TOWARDZERO, entonces
std::rintes equivalente a std::trunc; - FE_TONEAREST, entonces
std::rintdifiere de std::round en que casos intermedios se redondean a par en lugar de lejos de cero.
Ejemplo
Ejecuta este código
#include <iostream>
#include <cmath>
#include <cfenv>
#include <climits>
int main()
{
#pragma STDC FENV_ACCESS ON
std::fesetround(FE_TONEAREST);
std::cout << "redondeando al más cercano (casos intermedios a par):\n"
<< "rint(+2.3) = " << std::rint(2.3)
<< " rint(+2.5) = " << std::rint(2.5)
<< " rint(+3.5) = " << std::rint(3.5) << '\n'
<< "rint(-2.3) = " << std::rint(-2.3)
<< " rint(-2.5) = " << std::rint(-2.5)
<< " rint(-3.5) = " << std::rint(-3.5) << '\n';
std::fesetround(FE_DOWNWARD);
std::cout << "redondeando hacia abajo:\n"
<< "rint(+2.3) = " << std::rint(2.3)
<< " rint(+2.5) = " << std::rint(2.5)
<< " rint(+3.5) = " << std::rint(3.5) << '\n'
<< "rint(-2.3) = " << std::rint(-2.3)
<< " rint(-2.5) = " << std::rint(-2.5)
<< " rint(-3.5) = " << std::rint(-3.5) << '\n'
<< "redondeando hacia abajo con lrint\n"
<< "lrint(+2.3) = " << std::lrint(2.3)
<< " lrint(+2.5) = " << std::lrint(2.5)
<< " lrint(+3.5) = " << std::lrint(3.5) << '\n'
<< "lrint(-2.3) = " << std::lrint(-2.3)
<< " lrint(-2.5) = " << std::lrint(-2.5)
<< " lrint(-3.5) = " << std::lrint(-3.5) << '\n';
std::cout << "lrint(-0.0) = " << std::lrint(-0.0) << '\n'
<< "lrint(-Inf) = " << std::lrint(-INFINITY) << '\n';
// control de errores
std::feclearexcept(FE_ALL_EXCEPT);
std::cout << "std::rint(0.1) = " << std::rint(.1) << '\n';
if (std::fetestexcept(FE_INEXACT))
std::cout << " Se generó FE_INEXACT\n";
std::feclearexcept(FE_ALL_EXCEPT);
std::cout << "std::lrint(LONG_MIN-2048.0) = "
<< std::lrint(LONG_MIN-2048.0) << '\n';
if (std::fetestexcept(FE_INVALID))
std::cout << " Se generó FE_INVALID\n";
}
Posible salida:
redondeando al más cercano (casos intermedios a par):
rint(+2.3) = 2 rint(+2.5) = 2 rint(+3.5) = 4
rint(-2.3) = -2 rint(-2.5) = -2 rint(-3.5) = -4
redondeando hacia abajo:
rint(+2.3) = 2 rint(+2.5) = 2 rint(+3.5) = 3
rint(-2.3) = -3 rint(-2.5) = -3 rint(-3.5) = -4
redondeando hacia abajo con 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
std::rint(0.1) = 0
Se generó FE_INEXACT
std::lrint(LONG_MIN-2048.0) = -9223372036854775808
Se generó FE_INVALID
Véase también
(C++11)(C++11)(C++11) |
Entero más cercano no mayor en magnitud que el valor dado (función) |
(C++11)(C++11)(C++11) |
Entero más cercano usando el modo de redondeo actual (función) |
(C++11)(C++11) |
Obtiene o establece la dirección redondeo (función) |
Documentación de C para rint
| |