std::ldexp, std::ldexpf, std::ldexpl

[editar] Parámetros

[editar] Valor de retorno

Si no se producen errores, se devuelve x multiplicado por 2 a la potencia exp (x×2exp
).

Si se produce un error de rango debido a desbordamiento, se devuelve ±HUGE_VAL, ±HUGE_VALF, o ±HUGE_VALL.

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

[editar] Manejo de errores

Los errores se informan como se especifica en math_errhandling.

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

• A menos que se produzca un error de rango, nunca se genera FE_INEXACT (el resultado es exacto).
• A menos que se produzca un error de rango, se ignora el modo de redondeo actual.
• Si x es +0, se devuelve +0.
• Si x es -0, se devuelve -0.
• Si x es +∞, se devuelve +∞.
• Si x es -∞, se devuelve -∞.
• Si exp es 0, entonces se devuelve x sin modificar.
• Si x es NaN, se devuelve NaN.

[editar] Notas

En sistemas binarios (donde FLT_RADIX es 2), std::ldexp es equivalente a std::scalbn.

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

En muchas implementaciones, std::ldexp es menos eficiente que la multiplicación o división por una potencia de dos usando operadores aritméticos.

[editar] Ejemplo

#include <iostream>
#include <cmath>
#include <cerrno>
#include <cstring>
#include <cfenv>
 
// #pragma STDC FENV_ACCESS ON
int main()
{
    std::cout << "ldexp(7, -4) = " << std::ldexp(7, -4) << '\n'
              << "ldexp(1, -1074) = " << std::ldexp(1, -1074)
              << " (double subnormal mínimo positivo)\n"
              << "ldexp(nextafter(1,0), 1024) = "
              << std::ldexp(std::nextafter(1,0), 1024)
              << " (double finito más grande)\n";
    // valores especiales
    std::cout << "ldexp(-0, 10) = " << std::ldexp(-0.0, 10) << '\n'
              << "ldexp(-Inf, -1) = " << std::ldexp(-INFINITY, -1) << '\n';
    // manejo de errores
    errno = 0;
    std::feclearexcept(FE_ALL_EXCEPT);
    std::cout << "ldexp(1, 1024) = " << std::ldexp(1, 1024) << '\n';
    if (errno == ERANGE)
        std::cout << "    errno == ERANGE: " << std::strerror(errno) << '\n';
    if (std::fetestexcept(FE_OVERFLOW))
        std::cout << "    Se generó FE_OVERFLOW\n";
}

ldexp(7, -4) = 0.4375
ldexp(1, -1074) = 4.94066e-324 (double subnormal mínimo positivo)
ldexp(nextafter(1,0), 1024) = 1.79769e+308 (double finito más grande)
ldexp(-0, 10) = -0
ldexp(-Inf, -1) = -inf
ldexp(1, 1024) = inf
    errno == ERANGE: Resultado numérico fuera de rango
    Se generó FE_OVERFLOW

[editar] Véase también