std:: logb, std:: logbf, std:: logbl

Formalmente, el exponente no sesgado es la parte entera con signo de log r |num| (devuelto por esta función como un valor de punto flotante), para num distinto de cero, donde r es std:: numeric_limits < T > :: radix y T es el tipo de punto flotante de num . Si num es subnormal, se trata como si estuviera normalizado.

Parámetros

Valor de retorno

Si no ocurren errores, el exponente imparcial de num se devuelve como un valor de punto flotante con signo.

Si ocurre un error de dominio, se devuelve un valor definido por la implementación.

Si ocurre un error de polo, -HUGE_VAL , -HUGE_VALF , o -HUGE_VALL es devuelto.

Manejo de errores

Los errores se reportan como se especifica en math_errhandling .

Puede ocurrir un error de dominio o rango si num es cero.

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

• Si num es ±0, se retorna -∞ y FE_DIVBYZERO se activa.
• Si num es ±∞, se retorna +∞.
• Si num es NaN, se retorna NaN.
• En todos los demás casos, el resultado es exacto ( FE_INEXACT nunca se activa) y el modo de redondeo actual se ignora.

Notas

POSIX requiere que ocurra un error de polo si num es ±0.

El valor del exponente devuelto por std::logb siempre es 1 menos que el exponente devuelto por std::frexp debido a los diferentes requisitos de normalización: para el exponente e devuelto por std::logb , |num*r -e
| está entre 1 y r (típicamente entre 1 y 2 ), pero para el exponente e devuelto por std::frexp , |num*2 -e
| está entre 0.5 y 1 .

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 :: logb ( num ) tenga el mismo efecto que std :: logb ( static_cast < double > ( num ) ) .

Ejemplo

#include <cfenv>
#include <cmath>
#include <iostream>
#include <limits>
// #pragma STDC FENV_ACCESS ON
int main()
{
    double f = 123.45;
    std::cout << "Given the number " << f << " or " << std::hexfloat
              << f << std::defaultfloat << " in hex,\n";
    double f3;
    double f2 = std::modf(f, &f3);
    std::cout << "modf() makes " << f3 << " + " << f2 << '\n';
    int i;
    f2 = std::frexp(f, &i);
    std::cout << "frexp() makes " << f2 << " * 2^" << i << '\n';
    i = std::ilogb(f);
    std::cout << "logb()/ilogb() make " << f / std::scalbn(1.0, i) << " * "
              << std::numeric_limits<double>::radix
              << "^" << std::ilogb(f) << '\n';
    // error handling
    std::feclearexcept(FE_ALL_EXCEPT);
    std::cout << "logb(0) = " << std::logb(0) << '\n';
    if (std::fetestexcept(FE_DIVBYZERO))
        std::cout << "    FE_DIVBYZERO raised\n";
}

Given the number 123.45 or 0x1.edccccccccccdp+6 in hex,
modf() makes 123 + 0.45
frexp() makes 0.964453 * 2^7
logb()/ilogb() make 1.92891 * 2^6
logb(0) = -Inf
    FE_DIVBYZERO raised

Véase también