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

De cppreference.com

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 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.

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.

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

Posible salida: