std::scalbn, std::scalbnf, std::scalbnl, std::scalbln, std::scalblnf, std::scalblnl

[editar] Parámetros

[editar] Valor de retorno

Si no se producen errores, se devuelve x multiplicado por FLT_RADIX a la potencia arg (x×FLT_RADIXexp
).

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::scalbn es equivalente a std::ldexp.

Aunque std::scalbn y std::scalbln se especifican para realizar la operación de manera eficiente, en muchas implementaciones son menos eficientes que la multiplicación o división por una potencia de dos usando operadores aritméticos.

El nombre de la función significa "nueva scalb", donde scalb era una función no estándar más antigua cuyo segundo argumento tenía un tipo de punto flotante.

La función scalbln se proporciona porque el factor requerido para escalar desde el valor de punto flotante positivo más pequeño hasta el finito más grande puede ser mayor que 32767, el valor INT_MAX garantizado por el estándar. En particular, para long double de 80 bits, el factor es 32828.

La implementación de GNU no establece errno independientemente de math_errhandling.

[editar] Ejemplo

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

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

[editar] Véase también