std::logb, std::logbf, std::logbl - cppreference.com

De cppreference.com

Definido en el archivo de encabezado `<cmath>`
`float logb ( float arg );`	(1)	(desde C++11) (constexpr since C++23)
`float logbf( float arg );`	(2)	(desde C++11) (constexpr since C++23)
`double logb ( double arg );`	(3)	(desde C++11) (constexpr since C++23)
`long double logb ( long double arg );`	(4)	(desde C++11) (constexpr since C++23)
`long double logbl( long double arg );`	(5)	(desde C++11) (constexpr since C++23)
`double logb ( TipoEntero arg );`	(6)	(desde C++11) (constexpr since C++23)

1-5) Extrae el valor del exponente imparcial independiente de la base del argumento de punto flotante arg, y lo devuelve como un valor de punto flotante.

6) Un conjunto de sobrecargas o una plantilla de función que acepta un argumento de cualquier tipo entero. Equivalente a (3) (el argumento se convierte a double).

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

Parámetros

arg

Valor de punto flotante.

Valor de retorno

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

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

Si se produce un error de polo, se devuelve HUGE_VAL, -HUGE_VALF, o -HUGE_VALL.

Manejo de errores

Los errores se informan como se especifica en math_errhandling.

Puede producirse un error de dominio o un error de rango si arg es cero.

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

Si arg es +0, se devuelve -∞ y se genera FE_DIVBYZERO.
Si arg es -0, se devuelve -∞ y se genera FE_DIVBYZERO.
Si arg es +∞, se devuelve +∞.
Si arg es -∞, se devuelve +∞.
Si arg es NaN, se devuelve NaN.
En todos los otros casos, el resultado es exacto (nunca se genera FE_INEXACT) y se ignora el modo de redondeo actual

Notas

POSIX requiere que se produzca un error de polo si arg es +0 o -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, |arg*r-e
| está entre 1 y r (típicamente entre 1 y 2), pero para el exponente e devuelto por std::frexp, |arg*2-e
| está entre 0.5 y 1.

Ejemplo

Compara diferentes funciones de descomposición de punto flotante.

#include <iostream>
#include <cmath>
#include <limits>
#include <cfenv>
#pragma STDC FENV_ACCESS ON
int main()
{
    double f = 123.45;
    std::cout << "Dado el número " << f << "o" << std::hexfloat
              << f << std::defaultfloat << " en hexadecimal,\n";

    double f3;
    double f2 = std::modf(f, &f3);
    std::cout << "modf() genera " << f3 << " + " << f2 << '\n';

    int i;
    f2 = std::frexp(f, &i);
    std::cout << "frexp() genera " << f2 << " * 2^" << i << '\n';

    i = std::ilogb(f);
    std::cout << "logb()/ilogb() genera " << f/std::scalbn(1.0, i) << " * "
              << std::numeric_limits<double>::radix
              << "^" << std::ilogb(f) << '\n';

    // manejo de errores
    std::feclearexcept(FE_ALL_EXCEPT);
    std::cout << "logb(0) = " << std::logb(0) << '\n';
    if (std::fetestexcept(FE_DIVBYZERO))
        std::cout << "    Se generó FE_DIVBYZERO\n";
}

Posible salida: