std::modf, std::modff, std::modfl

[editar] Parámetros

[editar] Valor de retorno

Si no se producen errores, se devuelve la parte fraccionaria de x con el mismo signo que x. La parte entera se pone en el valor al que apunta iptr.

La suma del valor devuelto y el valor almacenado en *iptr da x (permitiendo el redondeo).

[editar] Manejo de errores

Esta función no está sujeta a ningún error especificado en math_errhandling.

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

• Si x es +0, se devuelve +0, y se almacena +0 en *iptr.
• Si x es -0, se devuelve -0, y se almacena -0 en *iptr.
• Si x es +∞, se devuelve +∞, y se almacena +∞ en *iptr.
• Si x es -∞, se devuelve -∞, y se almacena -∞ en *iptr.
• Si x es NaN, se devuelve NaN, y NaN se almacena en *iptr.
• El valor devuelto es exacto, se ignora el modo de redondeo actual.

[editar] Notas

Esta función se comporta como si se implementara de la siguiente manera:

double modf(double x, double* iptr)
{
#pragma STDC FENV_ACCESS ON
    int save_round = std::fegetround();
    std::fesetround(FE_TOWARDZERO);
    *iptr = std::nearbyint(x);
    std::fesetround(save_round);
    return std::copysign(std::isinf(x) ? 0.0 : x - (*iptr), x);
}

[editar] Ejemplo

#include <iostream>
#include <cmath>
#include <limits>
 
int main()
{
    double f = 123.45;
    std::cout << "Dado el número " << f << " o " << std::hexfloat
              << f << std::defaultfloat << " en hexadecimal,\n";
 
    double f3;
    double f2 = std::modf(f, &f3);
    std::cout << "modf() genera " << f3 << " + " << f2 << '\n';
 
    int i;
    f2 = std::frexp(f, &i);
    std::cout << "frexp() genera " << f2 << " * 2^" << i << '\n';
 
    i = std::ilogb(f);
    std::cout << "logb()/ilogb() genera " << f/std::scalbn(1.0, i) << " * "
              << std::numeric_limits<double>::radix
              << "^" << std::ilogb(f) << '\n';
 
    // valores especiales
    f2 = std::modf(-0.0, &f3);
    std::cout << "modf(-0) genera " << f3 << " + " << f2 << '\n';
    f2 = std::modf(-INFINITY, &f3);
    std::cout << "modf(-Inf) genera " << f3 << " + " << f2 << '\n';
 
}

Dado el número 123.45 o 0x1.edccccccccccdp+6 en hexadecimal,
modf() genera 123 + 0.45
frexp() genera 0.964453 * 2^7
logb()/ilogb() genera 1.92891 * 2^6
modf(-0) genera -0 + -0
modf(-Inf) genera -inf + -0

[editar] Véase también