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

 

C++

Apoyo de compiladores

Implementaciones independientes y albergadas

Lenguaje

Biblioteca estándar

Encabezados de la biblioteca estándar

Requisitos denominados

Macros de prueba de característica (C++20)

Biblioteca de apoyo del lenguaje

Biblioteca de conceptos (C++20)

Biblioteca de diagnósticos

Biblioteca de gestión de memoria

Biblioteca de metaprogramación (C++11)

Biblioteca de servicios generales

Biblioteca de contenedores

Biblioteca de iteradores

Biblioteca de rangos (C++20)

Biblioteca de algoritmos

Biblioteca de cadenas

Biblioteca de procesamiento de texto

Biblioteca numérica

Biblioteca de fecha y hora

Biblioteca de entrada/salida

Biblioteca del sistema de archivos (C++17)

Biblioteca de apoyo de concurrencia (C++11)

Biblioteca de apoyo de ejecución (C++26)

Especificaciones técnicas

Índice de símbolos

Bibliotecas externas

 

Biblioteca numérica

Funciones matemáticas comunes
Funciones matemáticas especiales (C++17)
Constantes matemáticas (C++20)
Algoritmos básicos de álgebra lineal (C++26)
Entorno de punto flotante (C++11)
Números complejos
Arrays numéricos
Generación de números pseudoaleatorios
Operaciones de factores
gcd (C++17)
lcm (C++17)
Interpolaciones
midpoint (C++20)
lerp (C++20)
Saturación aritmética
add_sat (C++26) sub_sat (C++26) saturate_cast (C++26)	mul_sat (C++26) div_sat (C++26)
Operaciones numéricas genéricas
iota (C++11)
ranges::iota (C++23)
accumulate
inner_product
adjacent_difference
partial_sum
reduce (C++17)
transform_reduce (C++17)
inclusive_scan (C++17)
exclusive_scan (C++17)
transform_inclusive_scan (C++17)
transform_exclusive_scan (C++17)
Operaciones de bits
bit_cast (C++20)
byteswap (C++23)
has_single_bit (C++20)
bit_ceil (C++20)
bit_floor (C++20)
bit_width (C++20)
rotl (C++20)
rotr (C++20)
countl_zero (C++20)
countl_one (C++20)
countr_zero (C++20)
countr_one (C++20)
popcount (C++20)
endian (C++20)

 

Funciones matemáticas comunes

Funciones
Operaciones básicas
abs(int)labsllabsimaxabs (C++11) abs(float)fabs divldivlldivimaxdiv (C++11) fmod	remainder (C++11) remquo (C++11) fma (C++11) fmax (C++11) fmin (C++11) fdim (C++11) nannanfnanl (C++11)(C++11)(C++11)
Funciones exponenciales
exp exp2 (C++11) expm1 (C++11)	log log10 log1p (C++11) log2 (C++11)
Funciones de potencias
sqrt cbrt (C++11)	hypot (C++11) pow
Funciones trigonométricas e hiperbólicas
sin cos tan asin acos atan atan2	sinh cosh tanh asinh (C++11) acosh (C++11) atanh (C++11)

Funciones de error y gamma
erf (C++11) erfc (C++11)	lgamma (C++11) tgamma (C++11)
Operaciones de punto flotante del entero más cercano
ceil floor roundlroundllround (C++11)(C++11)(C++11)	trunc (C++11) nearbyint (C++11) rintlrintllrint (C++11)(C++11)(C++11)
Funciones de manipulación de punto flotante
ldexp scalbnscalbln (C++11)(C++11) ilogb (C++11) logb (C++11)	frexp modf nextafternexttoward (C++11)(C++11) copysign (C++11)
Clasificación/comparación
fpclassify (C++11) isfinite (C++11) isinf (C++11) isnan (C++11) isnormal (C++11) signbit (C++11)	isgreater (C++11) isgreaterequal (C++11) isless (C++11) islessequal (C++11) islessgreater (C++11) isunordered (C++11)
Constantes de macro
HUGE_VALFHUGE_VALHUGE_VALL (C++11)(C++11) INFINITY (C++11) NAN (C++11) math_errhandlingMATH_ERRNOMATH_ERREXCEPT (C++11)	FP_NORMALFP_SUBNORMALFP_ZEROFP_INFINITEFP_NAN (C++11)(C++11)(C++11)(C++11)(C++11)

 

<tbody> </tbody>

Definido en el archivo de encabezado <cmath>
float round ( float arg );	(1)	(desde C++11) (constexpr since C++23)
float roundf( float arg );	(2)	(desde C++11) (constexpr since C++23)
double round ( double arg );	(3)	(desde C++11) (constexpr since C++23)
long double round ( long double arg );	(4)	(desde C++11) (constexpr since C++23)
long double roundl( long double arg );	(5)	(desde C++11) (constexpr since C++23)
double round ( TipoEntero arg );	(6)	(desde C++11) (constexpr since C++23)
long lround ( float arg );	(7)	(desde C++11) (constexpr since C++23)
long lroundf( float arg );	(8)	(desde C++11) (constexpr since C++23)
long lround ( double arg );	(9)	(desde C++11) (constexpr since C++23)
long lround ( long double arg );	(10)	(desde C++11) (constexpr since C++23)
long lroundl( long double arg );	(11)	(desde C++11) (constexpr since C++23)
long lround ( TipoEntero arg );	(12)	(desde C++11) (constexpr since C++23)
long long llround ( float arg );	(13)	(desde C++11) (constexpr since C++23)
long long llroundf( float arg );	(14)	(desde C++11) (constexpr since C++23)
long long llround ( double arg );	(15)	(desde C++11) (constexpr since C++23)
long long llround ( long double arg );	(16)	(desde C++11) (constexpr since C++23)
long long llroundl( long double arg );	(17)	(desde C++11) (constexpr since C++23)
long long llround ( TipoEntero arg );	(18)	(desde C++11) (constexpr since C++23)

1-5) Calcula el valor entero más cercano a arg (en formato de punto flotante), redondeando la mitad de los casos desde cero, independientemente del modo de redondeo actual.

7-11,13-17) Calcula el valor entero más cercano a arg (en formato de entero), redondeando la mitad de los casos desde cero, independientemente del modo de redondeo actual.

6,12,18) Un conjunto de sobrecargas o una plantilla de función que acepta un argumento de cualquier tipo entero. Equivalente a (3), (9), o (15), respectivamente (el argumento se convierte a double).

Parámetros

arg

-

Valor de punto flotante.

Valor de retorno

See More

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.

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.

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

Ejemplo

Ejecuta este código

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

Posible salida:

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

Véase también

floorfloorffloorl (C++11)(C++11)	Entero más cercano no mayor que el valor dado (función)
ceilceilfceill (C++11)(C++11)	Entero más cercano entero no menor que el valor dado. (función)
trunctruncftruncl (C++11)(C++11)(C++11)	Entero más cercano no mayor en magnitud que el valor dado (función)
Documentación de C para round