Namespaces
Variants

std:: pow (std::complex)

From cppreference.net
C++
Numerics library
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)
Определено в заголовке <complex>
(A)
template < class T1, class T2 >

std:: complex < /* общий-тип */ >

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 < /* общий-тип */ >

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 < /* общий-тип */ >

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 .
(since 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); // квадратный корень из -1
    std::cout << "-1^0.5 = " << std::pow(z2, 0.5) << '\n';
    std::complex<double> z3(-1.0, -0.0); // другая сторона разреза
    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)

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

комплексный квадратный корень в области правой полуплоскости
(шаблон функции)
(C++11) (C++11)
возводит число в заданную степень ( x y )
(функция)
применяет функцию std::pow к двум valarray или valarray и значению
(шаблон функции)
Документация C для cpow