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

Параметры

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

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

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

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

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

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

Ошибки сообщаются, как указано в 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 550 была поднята для решения этого конфликта, и решением стало удаление дополнительных перегрузок с int exp .

Хотя 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()
{
    // типичное использование
    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';
    // специальные значения
    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';
    // обработка ошибок
    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

Смотрите также