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

Parámetros

Valor de retorno

Si no ocurren errores, num multiplicado por FLT_RADIX elevado a la potencia de exp ( num×FLT_RADIX 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::scalbn es equivalente a std::ldexp .

Aunque std::scalbn y std::scalbln están especificados 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 utilizando operadores aritméticos.

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

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

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

Las sobrecargas adicionales no están obligadas a proporcionarse exactamente como (A,B) . Solo necesitan ser suficientes para garantizar que para su argumento num de tipo entero:

• std :: scalbn ( num, exp ) tiene el mismo efecto que std :: scalbn ( static_cast < double > ( num ) , exp ) .
• std :: scalbln ( num, exp ) tiene el mismo efecto que std :: scalbln ( static_cast < double > ( num ) , exp ) .

Ejemplo

#include <cerrno>
#include <cfenv>
#include <cmath>
#include <cstring>
#include <iostream>
// #pragma STDC FENV_ACCESS ON
int main()
{
    std::cout << "scalbn(7, -4) = " << std::scalbn(7, -4) << '\n'
              << "scalbn(1, -1074) = " << std::scalbn(1, -1074)
              << " (subnormal doble positivo mínimo)\n"
              << "scalbn(nextafter(1,0), 1024) = "
              << std::scalbn(std::nextafter(1,0), 1024)
              << " (doble 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 << "    FE_OVERFLOW activada\n";
}

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

Véase también