std::round, std::roundf, std::roundl, std::lround, std::lroundf, std::lroundl

[editar] Parámetros

[editar] Valor de retorno

Si no se producen errores, se devuelve el valor entero más cercano a arg, redondeando la mitad de los casos desde cero.

Valor de retorno

Argumento

Si se produce un error de dominio, se devuelve un valor definido por la implementación.

[editar] Manejo de errores

Los errores se informan como se especifica en math_errhandling.

Si el resultado de std::lround o std::llround está fuera del rango representable por el tipo de retorno, puede producirse 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::round:

• El modo de redondeo actual no tiene efecto.
• 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::lround y std::llround:

• Nunca se genera FE_INEXACT.
• El modo de redondeo actual no tiene efecto.
• 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

Se puede generar FE_INEXACT (pero no es obligatorio) por std::round al redondear un valor finito no entero.

Los valores de punto flotante representables más grandes son enteros exactos en todos los formatos de punto flotante estándar, por lo que std::round nunca se desborda por sí solo; sin embargo, el resultado puede desbordar cualquier tipo de entero (incluido std::intmax_t), cuando se almacena en una variable entera.

POSIX especifica que todos los casos donde std::lround o std::llround generen FE_INEXACT sean errores de dominio.

La versión double de std::round se comporta como si estuviera implementada de la siguiente manera:

#include <cmath>
#include <cfenv>
#pragma STDC FENV_ACCESS ON
double round(double x)
{
    std::fenv_t save_env;
    std::feholdexcept(&save_env);
    double result = std::rint(x);
    if (std::fetestexcept(FE_INEXACT)) {
        auto const save_round = std::fegetround();
        std::fesetround(FE_TOWARDZERO);
        result = std::rint(std::copysign(0.5 + std::fabs(x), x));
        std::fesetround(save_round);
    }
    std::feupdateenv(&save_env);
    return result;
}

[editar] Ejemplo

#include <iostream>
#include <cmath>
#include <cfenv>
#include <climits>
 
// #pragma STDC FENV_ACCESS ON
 
int main()
{
    // round
    std::cout << "round(+2.3) = " << std::round(2.3)
              << "  round(+2.5) = " << std::round(2.5)
              << "  round(+2.7) = " << std::round(2.7) << '\n'
              << "round(-2.3) = " << std::round(-2.3)
              << "  round(-2.5) = " << std::round(-2.5)
              << "  round(-2.7) = " << std::round(-2.7) << '\n';
 
    std::cout << "round(-0.0) = " << std::round(-0.0)  << '\n'
              << "round(-Inf) = " << std::round(-INFINITY) << '\n';
 
    // lround
    std::cout << "lround(+2.3) = " << std::lround(2.3)
              << "  lround(+2.5) = " << std::lround(2.5)
              << "  lround(+2.7) = " << std::lround(2.7) << '\n'
              << "lround(-2.3) = " << std::lround(-2.3)
              << "  lround(-2.5) = " << std::lround(-2.5)
              << "  lround(-2.7) = " << std::lround(-2.7) << '\n';
 
    std::cout << "lround(-0.0) = " << std::lround(-0.0)  << '\n'
              << "lround(-Inf) = " << std::lround(-INFINITY) << '\n';
 
    // manejo de errores
    std::feclearexcept(FE_ALL_EXCEPT);
    std::cout << "std::lround(LONG_MAX+1.5) = "
              << std::lround(LONG_MAX+1.5) << '\n';
    if (std::fetestexcept(FE_INVALID))
              std::cout << "    se generó FE_INVALID\n";
}

round(+2.3) = 2  round(+2.5) = 3  round(+2.7) = 3
round(-2.3) = -2  round(-2.5) = -3  round(-2.7) = -3
round(-0.0) = -0
round(-Inf) = -inf
lround(+2.3) = 2  lround(+2.5) = 3  lround(+2.7) = 3
lround(-2.3) = -2  lround(-2.5) = -3  lround(-2.7) = -3
lround(-0.0) = 0
lround(-Inf) = -9223372036854775808
std::lround(LONG_MAX+1.5) = -9223372036854775808
    se generó FE_INVALID

[editar] Véase también