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

Parámetros

Valor de retorno

Si no ocurren errores, num multiplicado por 2 elevado a la potencia de exp ( num×2 exp
) es devuelto.

Si ocurre un error de rango debido a desbordamiento, ±HUGE_VAL , ±HUGE_VALF , o ±HUGE_VALL es devuelto.

Si ocurre un error de rango debido a desbordamiento inferior, se devuelve el resultado correcto (después del redondeo).

Manejo de errores

Los errores se reportan como se especifica en math_errhandling .

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

• A menos que ocurra un error de rango, FE_INEXACT nunca se activa (el resultado es exacto).
• A menos que ocurra un error de rango, el modo de redondeo actual se ignora.
• Si num es ±0, se devuelve sin modificaciones.
• Si num es ±∞, se devuelve sin modificaciones.
• Si exp es 0, entonces num se devuelve sin modificaciones.
• Si num es NaN, se devuelve NaN.

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 , puede utilizarse 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 utilizando operadores aritméticos.

Las sobrecargas adicionales no requieren ser proporcionadas exactamente como (A) . Solo necesitan ser suficientes para garantizar que para su argumento num de tipo entero, std :: ldexp ( num, exp ) tenga el mismo efecto que std :: ldexp ( static_cast < double > ( num ) , exp ) .

Para la exponenciación de 2 por un exponente de punto flotante, std::exp2 puede ser utilizado.

Ejemplo

#include <cerrno>
#include <cfenv>
#include <cmath>
#include <cstring>
#include <iostream>
// #pragma STDC FENV_ACCESS ON
int main()
{
    std::cout
        << "ldexp(5, 3) = 5 * 8 = " << std::ldexp(5, 3) << '\n'
        << "ldexp(7, -4) = 7 / 16 = " << std::ldexp(7, -4) << '\n'
        << "ldexp(1, -1074) = " << std::ldexp(1, -1074)
        << " (minimum positive subnormal float64_t)\n"
        << "ldexp(nextafter(1,0), 1024) = "
        << std::ldexp(std::nextafter(1,0), 1024)
        << " (largest finite float64_t)\n";
    // special values
    std::cout << "ldexp(-0, 10) = " << std::ldexp(-0.0, 10) << '\n'
              << "ldexp(-Inf, -1) = " << std::ldexp(-INFINITY, -1) << '\n';
    // error handling
    std::feclearexcept(FE_ALL_EXCEPT);
    errno = 0;
    const double inf = std::ldexp(1, 1024);
    const bool is_range_error = errno == ERANGE;
    std::cout << "ldexp(1, 1024) = " << inf << '\n';
    if (is_range_error)
        std::cout << "    errno == ERANGE: " << std::strerror(ERANGE) << '\n';
    if (std::fetestexcept(FE_OVERFLOW))
        std::cout << "    FE_OVERFLOW raised\n";
}

ldexp(5, 3) = 5 * 8 = 40
ldexp(7, -4) = 7 / 16 = 0.4375
ldexp(1, -1074) = 4.94066e-324 (minimum positive subnormal float64_t)
ldexp(nextafter(1,0), 1024) = 1.79769e+308 (largest finite float64_t)
ldexp(-0, 10) = -0
ldexp(-Inf, -1) = -inf
ldexp(1, 1024) = inf
    errno == ERANGE: Resultado numérico fuera de rango
    FE_OVERFLOW raised

Véase también