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

Parámetros

Valor de retorno

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

Manejo de errores

Los errores se reportan 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 soporta aritmética de punto flotante IEEE (IEC 60559),

Para la función std::rint :

• Si num es ±∞, se devuelve sin modificación.
• Si num es ±0, se devuelve sin modificación.
• Si num es NaN, se devuelve NaN.

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

• Si num es ±∞, FE_INVALID se activa y se retorna un valor definido por la implementación.
• Si el resultado del redondeo está fuera del rango del tipo de retorno, FE_INVALID se activa y se retorna un valor definido por la implementación.
• Si num es NaN, FE_INVALID se activa y se retorna un valor definido por la implementación.

Notas

POSIX especifica que todos los casos donde std::lrint o std::llrint generan FE_INEXACT son errores de dominio.

Como se especifica en math_errhandling , FE_INEXACT puede ser (pero no está requerido en plataformas de punto flotante no IEEE) generado por std::rint al redondear un valor finito no entero.

La única diferencia entre std::rint y std::nearbyint es que std::nearbyint nunca genera FE_INEXACT .

Los valores de punto flotante más grandes representables son enteros exactos en todos los formatos estándar de punto flotante, por lo que std::rint nunca desborda por sí mismo; sin embargo, el resultado puede desbordar cualquier tipo entero (incluyendo 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 los casos intermedios se redondean al par más cercano en lugar de alejarse de cero.

Las sobrecargas adicionales no están obligadas a ser proporcionadas exactamente como (A-C) . Solo necesitan ser suficientes para garantizar que para su argumento num de tipo entero:

• std :: rint ( num ) tiene el mismo efecto que std :: rint ( static_cast < double > ( num ) ) .
• std :: lrint ( num ) tiene el mismo efecto que std :: lrint ( static_cast < double > ( num ) ) .
• std :: llrint ( num ) tiene el mismo efecto que std :: llrint ( static_cast < double > ( num ) ) .

Ejemplo

#include <cfenv>
#include <climits>
#include <cmath>
#include <iostream>
// #pragma STDC FENV_ACCESS ON
int main()
{
    std::fesetround(FE_TONEAREST);
    std::cout << "Redondeo al más cercano (casos intermedios hacia par):\n"
              << "  rint(+2.3) = " << std::rint(2.3) << '\n'
              << "  rint(+2.5) = " << std::rint(2.5) << '\n'
              << "  rint(+3.5) = " << std::rint(3.5) << '\n'
              << "  rint(-2.3) = " << std::rint(-2.3) << '\n'
              << "  rint(-2.5) = " << std::rint(-2.5) << '\n'
              << "  rint(-3.5) = " << std::rint(-3.5) << '\n';
    std::fesetround(FE_DOWNWARD);
    std::cout << "Redondeo hacia abajo:\n"
              << "  rint(+2.3) = " << std::rint(2.3) << '\n'
              << "  rint(+2.5) = " << std::rint(2.5) << '\n'
              << "  rint(+3.5) = " << std::rint(3.5) << '\n'
              << "  rint(-2.3) = " << std::rint(-2.3) << '\n'
              << "  rint(-2.5) = " << std::rint(-2.5) << '\n'
              << "  rint(-3.5) = " << std::rint(-3.5) << '\n'
              << "Redondeo hacia abajo con lrint:\n"
              << "  lrint(+2.3) = " << std::lrint(2.3) << '\n'
              << "  lrint(+2.5) = " << std::lrint(2.5) << '\n'
              << "  lrint(+3.5) = " << std::lrint(3.5) << '\n'
              << "  lrint(-2.3) = " << std::lrint(-2.3) << '\n'
              << "  lrint(-2.5) = " << std::lrint(-2.5) << '\n'
              << "  lrint(-3.5) = " << std::lrint(-3.5) << '\n'
              << "Valores especiales:\n"
              << "  lrint(-0.0) = " << std::lrint(-0.0) << '\n'
              << std::hex << std::showbase
              << "  lrint(-Inf) = " << std::lrint(-INFINITY) << '\n';
    // manejo de errores
    std::feclearexcept(FE_ALL_EXCEPT);
    std::cout << "std::rint(0.1) = " << std::rint(.1) << '\n';
    if (std::fetestexcept(FE_INEXACT))
        std::cout << "  FE_INEXACT fue activada\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";
}

Redondeo al más cercano (casos intermedios hacia 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
Redondeo hacia abajo:
  rint(+2.3) = 2
  rint(+2.5) = 2
  rint(+3.5) = 4
  rint(-2.3) = -2
  rint(-2.5) = -2
  rint(-3.5) = -4
Redondeo 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
Valores especiales:
  lrint(-0.0) = 0
  lrint(-Inf) = 0x8000000000000000
std::rint(0.1) = 0
std::lrint(LONG_MIN-2048.0) = 0x8000000000000000
  Se generó FE_INVALID

Véase también