std::rint, std::rintf, std::rintl, std::lrint, std::lrintf, std::lrintl

[editar] Parámetros

[editar] Valor de retorno

Si no ocurren errores, se devuelve el entero más cercano a arg, de acuerdo al modo de redondeo actual.

[editar] 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 arg es +∞, se devuelve +∞.
• Si arg es -∞, se devuelve -∞.
• Si arg es +0, se devuelve +0.
• Si arg es -0, se devuelve -0.
• Si arg es NaN, se devuelve NaN.

Para las funciones std::lrint y std::llrint:

• Si arg es +∞ 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 arg es NaN, se genera FE_INVALID y se devuelve un valor definido por la implementación.

[editar] 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::rint es equivalente a std::floor;
• FE_UPWARD, entonces std::rint es equivalente a std::ceil;
• FE_TOWARDZERO, entonces std::rint es equivalente a std::trunc;
• FE_TONEAREST, entonces std::rint difiere de std::round en que casos intermedios se redondean a par en lugar de lejos de cero.

[editar] Ejemplo

#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";
}

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

[editar] Véase también