Namespaces
Variants

std:: pow (std::complex)

From cppreference.net
C++
Numerics library
std::complex
(Anmerkung: Der bereitgestellte HTML-Code enthält keinen übersetzbaren Text, da alle Tags leer sind oder nur Klassenattribute enthalten. Gemäß den Anforderungen wurden HTML-Tags und Attribute nicht übersetzt.)
Definiert in Header <complex>
template < class T >
std:: complex < T > pow ( const std:: complex < T > & x, int y ) ;
(1) (bis 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)
Definiert in Header <complex>
(A)
template < class T1, class T2 >

std:: complex < /* gemeinsamer Typ */ >

pow ( const std:: complex < T1 > & x, const std:: complex < T2 > & y ) ;
(bis 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 ) ;
(seit C++23)
(B)
template < class T, class NonComplex >

std:: complex < /* gemeinsamer Typ */ >

pow ( const std:: complex < T > & x, const NonComplex & y ) ;
(bis C++23)
template < class T, class NonComplex >

std:: complex < std:: common_type_t < T, NonComplex >>

pow ( const std:: complex < T > & x, const NonComplex & y ) ;
(seit C++23)
(C)
template < class T, class NonComplex >

std:: complex < /* gemeinsamer Typ */ >

pow ( const NonComplex & x, const std:: complex < T > & y ) ;
(bis C++23)
template < class T, class NonComplex >

std:: complex < std:: common_type_t < T, NonComplex >>

pow ( const NonComplex & x, const std:: complex < T > & y ) ;
(seit C++23)
1-4) Berechnet die komplexe Zahl x hoch einer komplexen Potenz y mit einem Verzweigungsschnitt entlang der negativen reellen Achse für das erste Argument. Nicht-komplexe Argumente werden als komplexe Zahlen mit positiver Null-Imaginärkomponente behandelt.
A-C) Zusätzliche Überladungen werden bereitgestellt. NonComplex ist keine Spezialisierung von std::complex .
(since C++11)

Inhaltsverzeichnis

Parameter

x - Basis
y - Exponent

Rückgabewert

1-4) Falls keine Fehler auftreten, wird die komplexe Potenz x y
zurückgegeben.
Fehler und Sonderfälle werden behandelt, als ob die Operation durch std:: exp ( y * std:: log ( x ) ) implementiert wäre.
Das Ergebnis von std:: pow ( 0 , 0 ) ist implementierungsdefiniert.
A-C) Gleich wie (2-4) .

Hinweise

Überladung (1) wurde in C++98 bereitgestellt, um die zusätzlichen Überladungen (2) von std::pow abzudecken. Diese Überladungen wurden durch die Lösung von LWG Issue 550 entfernt, und Überladung (1) wurde durch die Lösung von LWG Issue 844 entfernt.

Die zusätzlichen Überladungen müssen nicht exakt als (A-C) bereitgestellt werden. Sie müssen lediglich ausreichen, um sicherzustellen, dass für ihr erstes Argument base und zweites Argument exponent :

Falls base und/oder exponent den Typ std:: complex < T > haben:

  • Falls base und/oder exponent den Typ std:: complex < long double > oder long double haben, dann hat std::pow(base, exponent) denselben Effekt wie std::pow ( std:: complex < long double > ( base ) ,
    std:: complex < long double > ( exponent ) )     .
  • Andernfalls, falls base und/oder exponent den Typ std:: complex < double > , double oder einen Ganzzahltyp haben, dann hat std::pow(base, exponent) denselben Effekt wie std::pow ( std:: complex < double > ( base ) ,
    std:: complex < double > ( exponent ) )     .
  • Andernfalls, falls base und/oder exponent den Typ std:: complex < float > oder float haben, dann hat std::pow(base, exponent) denselben Effekt wie std::pow ( std:: complex < float > ( base ) ,
    std:: complex < float > ( exponent ) )     .
(bis C++23)

Wenn ein Argument den Typ std:: complex < T1 > hat und das andere Argument den Typ T2 oder std:: complex < T2 > hat, dann hat std::pow(base, exponent) dieselbe Wirkung wie std::pow ( std:: complex < std:: common_type_t < T1, T2 >> ( base ) ,
std:: complex < std:: common_type_t < T1, T2 >> ( exponent ) ) .

Wenn std:: common_type_t < T1, T2 > nicht wohlgeformt ist, dann ist das Programm fehlerhaft.

(seit C++23)

Beispiel

Diesen Code ausführen 
#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); // Quadratwurzel von -1
    std::cout << "-1^0.5 = " << std::pow(z2, 0.5) << '\n';
    std::complex<double> z3(-1.0, -0.0); // andere Seite des Schnitts
    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';
}

Ausgabe: 

(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)

Siehe auch

Komplexe Quadratwurzel im Bereich der rechten Halbebene
(Funktions-Template)
(C++11) (C++11)
Potenziert eine Zahl mit dem gegebenen Exponenten ( x y )
(Funktion)
Wendet die Funktion std::pow auf zwei Valarrays oder ein Valarray und einen Wert an
(Funktions-Template)
C-Dokumentation für cpow