std::log2, std::log2f, std::log2l

Определено в заголовке `<cmath>`
	(1)
float log2 ( float num ); double log2 ( double num ); long double log2 ( long double num );		(до C++23)
/* floating-point-type / log2 ( / floating-point-type */ num );		(с C++23) (constexpr с C++26)
float log2f( float num );	(2)	(с C++11) (constexpr с C++26)
long double log2l( long double num );	(3)	(с C++11) (constexpr с C++26)
Дополнительные перегрузки (с C++11)
Определено в заголовке `<cmath>`
template< class Integer > double log2 ( Integer num );	(A)	(constexpr с C++26)

1-3) Вычисляет двоичный (по основанию 2) логарифм num. Библиотека предоставляет перегрузки std::log2 для всех типов с плавающей точкой без квалификаторов cv, как тип параметра.(с C++23)

A) Дополнительные перегрузки предоставляются для всех целочисленных типов, которые обрабатываются как double.

(с C++11)

Параметры

num

значение с плавающей точкой или целое число

Возвращаемое значение

Если ошибки не произошли, возвращается двоичный логарифм num (log₂(num) или lb(num)).

Если произошла ошибка области значений, возвращается значение, определённое реализацией (NaN, где поддерживается).

Если произошла ошибка полюса, возвращается -HUGE_VAL, -HUGE_VALF, или -HUGE_VALL.

Обработка ошибок

Ошибки сообщаются, как указано в math_errhandling.

Ошибка области значений происходит, если num меньше нуля.

Ошибка полюса может произойти, если num равно нулю.

Если реализация поддерживает арифметику с плавающей точкой IEEE (IEC 60559),

Если аргумент равен ±0, возвращается -∞, и поднимается FE_DIVBYZERO.
Если аргумент равен 1, возвращается +0.
Если аргумент отрицателен, возвращается NaN и поднимается FE_INVALID.
Если аргумент равен +∞, возвращается +∞.
Если аргумент равен NaN, возвращается NaN.

Примечания

Для целочисленного num, двоичный логарифм можно интерпретировать как индекс (с нуля) старшего бита 1 в вводе.

Дополнительные перегрузки не обязаны предоставляться точно, как (A). Они должны быть достаточными для того, чтобы для их аргумента num целочисленного типа, std::log2(num) имело тот же эффект, что и std::log2(static_cast<double>(num)).

Пример

#include <cerrno>
#include <cfenv>
#include <cmath>
#include <cstring>
#include <iostream>
// #pragma STDC FENV_ACCESS ON
 
int main()
{
    std::cout << "log2(65536) = " << std::log2(65536) << '\n'
              << "log2(0.125) = " << std::log2(0.125) << '\n'
              << "log2(0x020f) = " << std::log2(0x020f)
              << " (highest set bit is in position 9)\n"
              << "base-5 logarithm of 125 = "
              << std::log2(125) / std::log2(5) << '\n';
 
    // special values
    std::cout << "log2(1) = " << std::log2(1) << '\n'
              << "log2(+Inf) = " << std::log2(INFINITY) << '\n';
 
    // error handling
    errno = 0;
    std::feclearexcept(FE_ALL_EXCEPT);
 
    std::cout << "log2(0) = " << std::log2(0) << '\n';
 
    if (errno == ERANGE)
        std::cout << "    errno == ERANGE: " << std::strerror(errno) << '\n';
    if (std::fetestexcept(FE_DIVBYZERO))
        std::cout << "    FE_DIVBYZERO raised\n";
}

Возможный вывод:

log2(65536) = 16
log2(0.125) = -3
log2(0x020f) = 9.04166 (highest set bit is in position 9)
base-5 logarithm of 125 = 3
log2(1) = 0
log2(+Inf) = inf
log2(0) = -inf
    errno == ERANGE: Numerical result out of range
    FE_DIVBYZERO raised

См. также

loglogflogl (C++11)(C++11)	вычисляет натуральный (по основанию e) логарифм (\({\small\ln{x}}\)ln(x)) (функция)
log10log10flog10l (C++11)(C++11)	вычисляет десятичный (по основанию 10) логарифм (\({\small\log_{10}{x}}\)log₁₀(x)) (функция)
log1plog1pflog1pl (C++11)(C++11)(C++11)	натуральный логарифм (по основанию e) от 1 плюс данное число (\({\small\ln{(1+x)}}\)ln(1+x)) (функция)
exp2exp2fexp2l (C++11)(C++11)(C++11)	возвращает 2 в степени данного показателя (\({\small 2^x}\)2^x) (функция)
Документация C для `log2`

© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/w/cpp/numeric/math/log2