std::pow, std::powf, std::powl

float       pow ( float base, float exp );
double      pow ( double base, double exp );
long double pow ( long double base, long double exp );

/* floating-point-type */
            pow ( /* floating-point-type */ base,
                  /* floating-point-type */ exp )

float       pow ( float base, int exp );
double      pow ( double base, int exp );
long double pow ( long double base, int exp );

float       powf( float base, float exp );

long double powl( long double base, long double exp );

template< class Arithmetic1, class Arithmetic2 >
/* common-floating-point-type */
            pow ( Arithmetic1 base, Arithmetic2 exp );

Параметры

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

Если ошибок не возникает, возвращается base в степени exp (base^exp).

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

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

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

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

Ошибки обрабатываются согласно math_errhandling.

Если base является конечным отрицательным числом, а exp — конечным нецелым числом, возникает ошибка области определения и может возникнуть ошибка диапазона.

Если base равен нулю и exp равен нулю, может возникнуть ошибка области определения.

Если base равен нулю и exp отрицателен, может возникнуть ошибка области определения или ошибка полюса.

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

• pow(+0, exp), где exp — отрицательное нечётное целое число, возвращает +∞ и вызывает FE_DIVBYZERO.
• pow(-0, exp), где exp — отрицательное нечётное целое число, возвращает -∞ и вызывает FE_DIVBYZERO.
• pow(±0, exp), где exp является отрицательным конечным числом и чётным целым числом или нецелым числом, возвращает +∞ и вызывает FE_DIVBYZERO.
• pow(±0, -∞) возвращает +∞ и может вызвать FE_DIVBYZERO.
• pow(+0, exp), где exp — положительное нечётное целое число, возвращает +0.
• pow(-0, exp), где exp — положительное нечётное целое число, возвращает -0.
• pow(±0, exp), где exp является положительным нецелым числом или положительным чётным целым числом, возвращает +0.
• pow(-1, ±∞) возвращает 1.
• pow(+1, exp) возвращает 1 для любого exp, даже если exp — NaN.
• pow(base, ±0) возвращает 1 для любого base, даже если base — NaN.
• pow(base, exp) возвращает NaN и вызывает FE_INVALID, если base является конечным отрицательным числом, а exp — конечным нецелым числом.
• pow(base, -∞) возвращает +∞ для любого |base| < 1.
• pow(base, -∞) возвращает +0 для любого |base| > 1.
• pow(base, +∞) возвращает +0 для любого |base| < 1.
• pow(base, +∞) возвращает +∞ для любого |base| > 1.
• pow(-∞, exp) возвращает -0, если exp — отрицательное нечётное целое число.
• pow(-∞, exp) возвращает +0, если exp — отрицательное нецелое число или отрицательное чётное целое число.
• pow(-∞, exp) возвращает -∞, если exp — положительное нечётное целое число.
• pow(-∞, exp) возвращает +∞, если exp — положительное нецелое число или положительное чётное целое число.
• pow(+∞, exp) возвращает +0 для любого отрицательного exp.
• pow(+∞, exp) возвращает +∞ для любого положительного exp.
• за исключением случаев, указанных выше, если какой-либо аргумент является NaN, возвращается NaN.

Примечания

В C++98 были добавлены перегрузки, в которых exp имеет тип int, в дополнение к функциям C pow(), а возвращаемый тип std::pow(float,int) был float. Однако дополнительные перегрузки, введённые в C++11, указывают, что std::pow(float,int) должен возвращать double. Для разрешения этого конфликта был поднят вопрос LWG issue 550; его решение заключалось в удалении дополнительных перегрузок exp с аргументом типа int.

Хотя с помощью std::pow нельзя извлечь корень из отрицательного числа, std::cbrt предусмотрена для распространённого случая, когда exp равно 1/3.

Дополнительные перегрузки не обязаны в точности соответствовать варианту (A). Они должны лишь обеспечивать, чтобы для первого аргумента num1 и второго аргумента num2:

Пример

#include <cerrno>
#include <cfenv>
#include <cmath>
#include <cstring>
#include <iostream>
// #pragma STDC FENV_ACCESS ON

int main()
{
    // typical usage
    std::cout << "pow(2, 10) = " << std::pow(2, 10) << '\n'
              << "pow(2, 0.5) = " << std::pow(2, 0.5) << '\n'
              << "pow(-2, -3) = " << std::pow(-2, -3) << '\n';
    
    // special values
    std::cout << "pow(-1, NAN) = " << std::pow(-1, NAN) << '\n'
              << "pow(+1, NAN) = " << std::pow(+1, NAN) << '\n'
              << "pow(INFINITY, 2) = " << std::pow(INFINITY, 2) << '\n'
              << "pow(INFINITY, -1) = " << std::pow(INFINITY, -1) << '\n';
    
    // error handling
    errno = 0;
    std::feclearexcept(FE_ALL_EXCEPT);
    
    std::cout << "pow(-1, 1/3) = " << std::pow(-1, 1.0 / 3) << '\n';
    if (errno == EDOM)
        std::cout << "    errno == EDOM " << std::strerror(errno) << '\n';
    if (std::fetestexcept(FE_INVALID))
        std::cout << "    FE_INVALID raised\n";

    std::feclearexcept(FE_ALL_EXCEPT);
    
    std::cout << "pow(-0, -3) = " << std::pow(-0.0, -3) << '\n';
    if (std::fetestexcept(FE_DIVBYZERO))
        std::cout << "    FE_DIVBYZERO raised\n";
}

pow(2, 10) = 1024
pow(2, 0.5) = 1.41421
pow(-2, -3) = -0.125
pow(-1, NAN) = nan
pow(+1, NAN) = 1
pow(INFINITY, 2) = inf
pow(INFINITY, -1) = 0
pow(-1, 1/3) = -nan
    errno == EDOM Numerical argument out of domain
    FE_INVALID raised
pow(-0, -3) = -inf
    FE_DIVBYZERO raised

См. также