std::fmod, std::fmodf, std::fmodl - cppreference.com

Definido en el archivo de encabezado `<cmath>`
`float fmod ( float x, float y );`	(1)	(constexpr since C++23)
`float fmodf( float x, float y );`	(2)	(desde C++11) (constexpr since C++23)
`double fmod ( double x, double y );`	(3)	(constexpr since C++23)
`long double fmod ( long double x, long double y );`	(4)	(constexpr since C++23)
`long double fmodl( long double x, long double y );`	(5)	(desde C++11) (constexpr since C++23)
`Promovido fmod ( Aritmético1 x, Aritmético2 y );`	(6)	(desde C++11) (constexpr since C++23)

1-6) Calcula el resto de punto flotante de la operación de división x/y.

6) Un conjunto de sobrecargas o una plantilla de función para todas las combinaciones de argumentos de tipo aritmético que no están cubiertas por (1-5). Si cualquier argumento tiene tipo entero, se convierte a double. Si cualquier otro argumento es long double, entonces el tipo de retorno es long double; de lo contrario, es double.

El resto de punto flotante de la operación de división x/y calculado por esta función es exactamente el valor x - n*y, donde n es x/y con su parte fraccionaria truncada.

El valor devuelto tiene el mismo signo que x y es menor que y en magnitud.

Parámetros

x, y

Valores de punto flotante.

Valor de retorno

Si tuvo éxito, devuelve el resto de punto flotante de la división x/y como se definió anteriormente.

Si se produce un error de dominio, se devuelve un valor definido por la implementación (NaN donde se dé apoyo).

Si se produce un error de rango debido a subdesbordamiento, se devuelve el resultado correcto (después del redondeo).

Manejo de errores

Los errores se informan como se especifica en math_errhandling.

Se puede producir un error de dominio si y es cero.

Si la implementación admite la aritmética de punto flotante IEEE (IEC 60559):

Si x es +0 o -0 e y no es cero, se devuelve +0 o -0, respectivamente.
Si x es +∞ o -∞ e y no es NaN, se devuelve NaN y se genera FE_INVALID.
Si y es + o -0 y x no es NaN, se devuelve NaN y se genera FE_INVALID.
Si y es +∞ o -∞ y x es finita, se devuelve x.
Si cualquiera de los argumentos es NaN, se devuelve NaN.

Notas

POSIX requiere que ocurra un error de dominio si x es infinito o y es cero.

std::fmod, pero no std::remainder, es útil para envolver de manera simple (quiet) tipos de punto flotante a tipos enteros sin signo: (0.0 <= (y = std::fmod( std::rint(x), 65536.0 )) ? y : 65536.0 + y) está en el rango [-0.0 .. 65535.0], que corresponde a unsigned short, pero std::remainder(std::rint(x), 65536.0 está en el rango [-32767.0, +32768.0], que está fuera del rango de signed short.

La versión double de fmod se comporta como si se implementara de la siguiente manera:

double fmod(double x, double y)
{
#pragma STDC FENV_ACCESS ON
    double result = std::remainder(std::fabs(x), (y = std::fabs(y)));
    if (std::signbit(result)) result += y;
    return std::copysign(result, x);
}

La expresión x - trunc(x/y)*y puede no ser igual a fmod(x,y) cuando el redondeo de x/y para inicializar el argumento de trunc pierde demasiada precisión (ejemplo: x = 30.508474576271183309, y = 6.1016949152542370172).

Ejemplo

#include <iostream>
#include <cmath>
#include <cfenv>

// #pragma STDC FENV_ACCESS ON
int main()
{
    std::cout << "fmod(+5.1, +3.0) = " << std::fmod(5.1,3) << '\n'
              << "fmod(-5.1, +3.0) = " << std::fmod(-5.1,3) << '\n'
              << "fmod(+5.1, -3.0) = " << std::fmod(5.1,-3) << '\n'
              << "fmod(-5.1, -3.0) = " << std::fmod(-5.1,-3) << '\n';

    // valores especiales
    std::cout << "fmod(+0.0, 1.0) = " << std::fmod(0, 1) << '\n'
              << "fmod(-0.0, 1.0) = " << std::fmod(-0.0, 1) << '\n'
              << "fmod(5.1, Inf) = " << std::fmod(5.1, INFINITY) << '\n';

    // manejo de errores
    std::feclearexcept(FE_ALL_EXCEPT);
    std::cout << "fmod(+5.1, 0) = " << std::fmod(5.1, 0) << '\n';
    if(std::fetestexcept(FE_INVALID))
        std::cout << "    FE_INVALID generado\n";
}

Posible salida: