std::modf, std::modff, std::modfl - cppreference.com

De cppreference.com

Definido en el archivo de encabezado `<cmath>`
`float modf ( float x, float* iptr );`	(1)	(constexpr since C++23)
`float modff( float x, float* iptr );`	(2)	(desde C++11) (constexpr since C++23)
`double modf ( double x, double* iptr );`	(3)	(constexpr since C++23)
`long double modf ( long double x, long double* iptr );`	(4)	(constexpr since C++23)
`long double modfl( long double x, long double* iptr );`	(5)	(desde C++11) (constexpr since C++23)

1-5) Descompone el valor de punto flotante dado x en sus partes entera y fraccionaria, cada uno con el mismo tipo y signo que x. La parte entera (en formato de punto flotante) se almacena en el objeto al que apunta iptr.

Parámetros

x	-	Valor de punto flotante.
iptr	-	Puntero al valor de punto flotante en el que almacenar la parte entera.

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

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.

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

Ejemplo

Compara diferentes funciones de descomposición de punto flotante.

#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';

}

Posible salida: