std::frexp, std::frexpf, std::frexpl

[editar] Parámetros

[editar] Valor de retorno

Si arg es cero, devuelve cero y almacena cero en *exp.

De lo contrario (si arg no es cero), si no se producen errores, devuelve el valor x en el rango (-1;-0.5], [0.5; 1) y almacena un valor entero en *exp tal que x×2(*exp)
== arg.

Si el valor a almacenar en *exp está fuera del rango de int, el comportamiento no está especificado.

[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 arg es +0, se devuelve +0 y se almacena 0 en *exp.
• Si arg es -0, se devuelve -0 y se almacena 0 en *exp.
• Si arg es +∞, se devuelve +∞, y se almacena un valor no especificado en *exp.
• Si arg es -∞, se devuelve -∞, y se almacena un valor no especificado en *exp.
• Si arg es NaN, se devuelve NaN, y se almacena un valor no especificado en *exp.
• No se generan excepciones de punto flotante.
• Si FLT_RADIX es 2 (o una potencia de 2), el valor devuelto es exacto, se ignora el modo de redondeo actual.

[editar] Notas

En sistemas binarios (donde FLT_RADIX es 2), frexp puede implementarse como

{
    *exp = (value == 0) ? 0 : (int)(1 + std::logb(value));
    return std::scalbn(value, -(*exp));
}

La función std::frexp, junto con su dual std::ldexp, se puede usar para manipular la representación de un número de punto flotante sin manipulaciones directas de bits.

[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';
}

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

[editar] Véase también