std::fmod, std::fmodf, std::fmodl

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.

[editar] Parámetros

[editar] 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).

[editar] 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.

[editar] 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).

[editar] 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";
}

fmod(+5.1, +3.0) = 2.1
fmod(-5.1, +3.0) = -2.1
fmod(+5.1, -3.0) = 2.1
fmod(-5.1, -3.0) = -2.1
fmod(+0.0, 1.0) = 0
fmod(-0.0, 1.0) = -0
fmod(5.1, Inf) = 5.1
fmod(+5.1, 0) = -nan
    FE_INVALID generado

[editar] Véase también