std::pow(std::complex)

Определено в заголовочном файле `<complex>`
template< class T > std::complex<T> pow( const std::complex<T>& x, int y );	(1)	(до C++11)
template< class T > std::complex<T> pow( const std::complex<T>& x, const std::complex<T>& y );	(2)
template< class T > std::complex<T> pow( const std::complex<T>& x, const T& y );	(3)
template< class T > std::complex<T> pow( const T& x, const std::complex<T>& y );	(4)
Дополнительные перегрузки (начиная с C++11)
Определено в заголовочном файле `<complex>`
template< class T1, class T2 > std::complex</* common-type */> pow( const std::complex<T1>& x, const std::complex<T2>& y );	(A)	(до C++23)
template< class T1, class T2 > std::complex<std::common_type_t<T1, T2>> pow( const std::complex<T1>& x, const std::complex<T2>& y );	(A)		(начиная с C++23)
template< class T, class NonComplex > std::complex</* common-type */> pow( const std::complex<T>& x, const NonComplex& y );	(B)	(до C++23)
template< class T, class NonComplex > std::complex<std::common_type_t<T, NonComplex>> pow( const std::complex<T>& x, const NonComplex& y );	(B)		(начиная с C++23)
template< class T, class NonComplex > std::complex</* common-type */> pow( const NonComplex& x, const std::complex<T>& y );	(C)	(до C++23)
template< class T, class NonComplex > std::complex<std::common_type_t<T, NonComplex>> pow( const NonComplex& x, const std::complex<T>& y );	(C)		(начиная с C++23)

1-4) Вычисляет комплексное число x в степени комплексного числа y с разрезом ветвления вдоль отрицательной вещественной оси для первого аргумента. Аргументы, не являющиеся комплексными числами, рассматриваются как комплексные числа с положительной нулевой мнимой частью.

A-C) Предоставляются дополнительные перегрузки. NonComplex не является специализацией std::complex. (начиная с C++11)

Параметры

x	-	основание
y	-	показатель степени

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

1-4) Если ошибок не возникает, возвращается комплексная степень x^y.

Ошибки и особые случаи обрабатываются так, как если бы операция была реализована с помощью std::exp(y * std::log(x)).

Результат std::pow(0, 0) определяется реализацией.

A-C) То же, что и (2-4).

Примечания

Перегрузка (1) была предоставлена в C++98 для соответствия дополнительным перегрузкам (2) из std::pow. Эти перегрузки были удалены в результате принятия решения по вопросу LWG 550, а перегрузка (1) была удалена в результате принятия решения по вопросу LWG 844.

Дополнительные перегрузки не обязательно должны быть предоставлены точно в виде (A-C). Достаточно, чтобы они обеспечивали для первого аргумента base и второго аргумента exponent следующее:

Если base и/или exponent имеет тип std::complex<T>:

Если base и/или exponent имеет тип std::complex<longdouble> или longdouble, то std::pow(base, exponent) имеет тот же эффект, что и std::pow(std::complex<long double>(base),std::complex<long double>(exponent)).
В противном случае, если base и/или exponent имеет тип std::complex<double>, double или целочисленный тип, то std::pow(base, exponent) имеет тот же эффект, что и std::pow(std::complex<double>(base),std::complex<double>(exponent)).
В противном случае, если base и/или exponent имеет тип std::complex<float> или float, то std::pow(base, exponent) имеет тот же эффект, что и std::pow(std::complex<float>(base),std::complex<float>(exponent)).

(до C++23)

Если один аргумент имеет тип std::complex<T1>, а другой аргумент имеет тип T2 или std::complex<T2>, то std::pow(base, exponent) имеет тот же эффект, что и std::pow(std::complex<std::common_type_t<T1, T2>>(base), std::complex<std::common_type_t<T1, T2>>(exponent)).

Если std::common_type_t<T1,T2> некорректно сформирован, программа некорректна.

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

Пример

#include <complex>
#include <iostream>

int main()
{
    std::cout << std::fixed;
    
    std::complex<double> z(1.0, 2.0);
    std::cout << "(1,2)^2 = " << std::pow(z, 2) << '\n';
    
    std::complex<double> z2(-1.0, 0.0); // square root of -1
    std::cout << "-1^0.5 = " << std::pow(z2, 0.5) << '\n';
    
    std::complex<double> z3(-1.0, -0.0); // other side of the cut
    std::cout << "(-1,-0)^0.5 = " << std::pow(z3, 0.5) << '\n';
    
    std::complex<double> i(0.0, 1.0); // i^i = exp(-pi / 2)
    std::cout << "i^i = " << std::pow(i, i) << '\n';
}

Вывод:

(1,2)^2 = (-3.000000,4.000000)
-1^0.5 = (0.000000,1.000000)
(-1,-0)^0.5 = (0.000000,-1.000000)
i^i = (0.207880,0.000000)

См. также

sqrt(std::complex)	квадратный корень комплексного числа в правой полуплоскости (шаблон функции)
powpowfpowl (C++11)(C++11)	возводит число в заданную степень (\(\small{x^y}\)x^y) (функция)
pow(std::valarray)	применяет функцию `std::pow` к двум valarray или к valarray и значению (шаблон функции)
Документация по C для `cpow`

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