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>`
	(A)
template< class T1, class T2 > std::complex</* common-type */> pow( const std::complex<T1>& x, const std::complex<T2>& y );		(до 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 );		(с C++23)
	(B)
template< class T, class NonComplex > std::complex</* common-type */> pow( const std::complex<T>& x, const NonComplex& y );		(до C++23)
template< class T, class NonComplex > std::complex<std::common_type_t<T, NonComplex>> pow( const std::complex<T>& x, const NonComplex& y );		(с C++23)
	(C)
template< class T, class NonComplex > std::complex</* common-type */> pow( const NonComplex& x, const std::complex<T>& y );		(до 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++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 issue 550, а перегрузка (1) — решением LWG issue 844.

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

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

Если base и/или exponent имеет тип std::complex<long double> или long double, то 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/w/cpp/numeric/complex/pow