std::pow(std::complex)

 

C++

Compiler-Unterstützung

Freestanding und gehostet

Sprache

Standardbibliothek

Header der Standardbibliothek

Benannte Anforderungen

Feature-Test-Makros (C++20)

Bibliothek für Sprachunterstützung

Konzepte-Bibliothek (C++20)

Diagnostik-Bibliothek

Speicherverwaltungsbibliothek

Metaprogrammierungsbibliothek (C++11)

Allgemeine Dienstprogramme-Bibliothek

Container-Bibliothek

Iterator-Bibliothek

Ranges-Bibliothek (C++20)

Algorithmen-Bibliothek

Bibliothek für Zeichenketten

Textverarbeitungsbibliothek

Numerik-Bibliothek

Datums- und Zeitbibliothek

Ein-/Ausgabe-Bibliothek

Dateisystembibliothek (C++17)

Unterstützung für nebenläufige Programmierung (C++11)

Ausführungssteuerungsbibliothek (C++26)

Technische Spezifikationen

Symbolverzeichnis

Externe Bibliotheken

 

Numerik-Bibliothek

Allgemeine mathematische Funktionen
Mathematische Spezialfunktionen (C++17)
Mathematische Konstanten (C++20)
Grundlegende lineare Algebra-Algorithmen (C++26)
Datenparallele Typen (SIMD) (C++26)
Gleitkomma-Umgebung (C++11)
Komplexe Zahlen
Numerische Arrays (valarray)
Pseudozufallszahlengenerierung
Bit-Manipulation (C++20)
Faktoroperationen
gcd (C++17)	lcm (C++17)
Interpolationen
midpoint (C++20)	lerp (C++20)
Sättigungsarithmetik
add_sat (C++26) sub_sat (C++26) saturate_cast (C++26)	mul_sat (C++26) div_sat (C++26)
Generische numerische Operationen
iota (C++11) ranges::iota (C++23) accumulate inner_product adjacent_difference    partial_sum	reduce (C++17) transform_reduce (C++17) inclusive_scan (C++17) exclusive_scan (C++17) transform_inclusive_scan (C++17) transform_exclusive_scan (C++17)

 

std::complex

Memberfunktionen
complex::complex complex::operator= complex::real complex::imag	complex::operator+=complex::operator-=complex::operator*=complex::operator/=
Nicht-Member-Funktionen
operator+operator- operator+operator-operator*operator/ operator==operator!= (bis C++20)   operator<<operator>> get(std::complex) (C++26)	real imag abs arg norm conj proj (C++11) polar operator""ioperator""ifoperator""il (C++14)(C++14)(C++14)
Exponentialfunktionen
log   log10   exp
Potenzfunktionen
pow   sqrt
Trigonometrische Funktionen
sin   cos tan asin (C++11) acos (C++11) atan (C++11)
Hyperbolische Funktionen
sinh   cosh tanh asinh (C++11) acosh (C++11) atanh (C++11)
Hilfstypen
tuple_size<std::complex> (C++26)
tuple_element<std::complex> (C++26)

 

Definiert in der Header-Datei <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)
Zusätzliche Überladungen (seit C++11)
Definiert in der Header-Datei <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 Potenz x hoch eine komplexe Potenz y mit einem Schnitt 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.

(seit C++11)

Parameter

x	-	base
y	-	exponent

Rückgabewert

1-4) Wenn keine Fehler auftreten, wird die komplexe Potenz xy
zurückgegeben.

Fehler und Sonderfälle werden so behandelt, als ob die Operation durch std::exp(y * std::log(x)) implementiert wäre.

Das Ergebnis von std::pow(0, 0) ist implementierungsabhängig.

A-C) Gleiches wie (2-4).

Anmerkungen

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

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

Wenn base und/oder exponent den Typ std::complex<T> haben Wenn base und/oder exponent den Typ std::complex<long double> oder long double haben, hat std::pow(base, exponent) den gleichen Effekt wie std::pow(std::complex<long double>(base),          std::complex<long double>(exponent)). Andernfalls, wenn base und/oder exponent den Typ std::complex<double>, double oder einen ganzzahligen Typ haben, hat std::pow(base, exponent) den gleichen Effekt wie std::pow(std::complex<double>(base),          std::complex<double>(exponent)). Andernfalls, wenn base und/oder exponent den Typ std::complex<float> oder float haben, hat std::pow(base, exponent) den gleichen Effekt wie std::pow(std::complex<float>(base),          std::complex<float>(exponent)).

(bis C++23)

Wenn ein Argument vom Typ std::complex<T1> und das andere Argument vom Typ T2 oder std::complex<T2> ist, hat std::pow(base, exponent) den gleichen Effekt 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, ist das Programm fehlerhaft.

(seit C++23)

Beispiel

Führen Sie diesen Code aus

#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';
}

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

sqrt(std::complex)	komplexe Quadratwurzel im Bereich der rechten Halbebene (function template)
powpowfpowl (C++11)(C++11)	erhöht eine Zahl zur gegebenen Potenz (\(\small{x^y}\)xy) (Funktion)
pow(std::valarray)	wendet die Funktion std::pow auf zwei Valarrays oder ein Valarray und einen Wert an (function template)
C-Dokumentation für cpow