std::exp2, std::exp2f, std::exp2l

Определено в заголовочном файле `<cmath>`
float exp2 ( float num ); double exp2 ( double num ); long double exp2 ( long double num );	(1)	(до C++23)
/floating-point-type/ exp2 ( /floating-point-type/ num );	(1)		(начиная с C++23) (constexpr начиная с C++26)
float exp2f( float num );	(2)	(начиная с C++11) (constexpr начиная с C++26)
long double exp2l( long double num );	(3)	(начиная с C++11) (constexpr начиная с C++26)
Перегрузка SIMD (начиная с C++26)
Определено в заголовочном файле `<simd>`
template< /math-floating-point/ V > constexpr /deduced-simd-t/<V> exp2 ( const V& v_num );	(S)	(начиная с C++26)
Дополнительные перегрузки (начиная с C++11)
Определено в заголовочном файле `<cmath>`
template< class Integer > double exp2 ( Integer num );	(A)	(constexpr начиная с C++26)

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

S) Перегрузка SIMD выполняет поэлементную операцию std::exp2 над v_num. (Определения см. в разделах math-floating-point и deduced-simd-t.) (начиная с C++26)

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

(начиная с C++11)

Параметры

num

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

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

Если ошибки не возникают, возвращается экспонента по основанию 2 от num (2^num).

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

Если возникает ошибка диапазона из-за потери значимости, возвращается правильный результат (после округления).

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

Об ошибках сообщается согласно math_errhandling.

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

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

Примечания

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

Для целочисленных показателей степени может быть предпочтительнее использовать std::ldexp.

Пример

#include <cerrno>
#include <cfenv>
#include <cmath>
#include <cstring>
#include <iostream>

// #pragma STDC FENV_ACCESS ON

int main()
{
    std::cout << "exp2(4) = " << std::exp2(4) << '\n'
              << "exp2(0.5) = " << std::exp2(0.5) << '\n'
              << "exp2(-4) = " << std::exp2(-4) << '\n';
    
    // special values
    std::cout << "exp2(-0) = " << std::exp2(-0.0) << '\n'
              << "exp2(-Inf) = " << std::exp2(-INFINITY) << '\n';
    
    // error handling
    errno = 0;
    std::feclearexcept(FE_ALL_EXCEPT);
    const double inf = std::exp2(1024);
    const bool is_range_error = errno == ERANGE;

    std::cout << "exp2(1024) = " << inf << '\n';
    if (is_range_error)
        std::cout << "    errno == ERANGE: " << std::strerror(ERANGE) << '\n';
    if (std::fetestexcept(FE_OVERFLOW))
        std::cout << "    FE_OVERFLOW raised\n";
}

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

exp2(4) = 16
exp2(0.5) = 1.41421
exp2(-4) = 0.0625
exp2(-0) = 1
exp2(-Inf) = 0
exp2(1024) = inf
    errno == ERANGE: Numerical result out of range
    FE_OVERFLOW raised

См. также

expexpfexpl (C++11)(C++11)	возвращает e в заданной степени (\({\small e^x}\)e^x) (функция)
expm1expm1fexpm1l (C++11)(C++11)(C++11)	возвращает e в заданной степени минус 1 (\({\small e^x-1}\)e^x-1) (функция)
ldexpldexpfldexpl (C++11)(C++11)	умножает число на 2 в целочисленной степени (функция)
log2log2flog2l (C++11)(C++11)(C++11)	логарифм заданного числа по основанию 2 (\({\small\log_{2}{x}}\)log₂(x)) (функция)
Документация по C для `exp2`

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