std::arg(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 > T           arg( const std::complex<T>& z );	(1)
Zusätzliche Überladungen (seit C++11)
Definiert in der Header-Datei <complex>
	(A)
float       arg( float f ); double      arg( double f ); long double arg( long double f );			(bis C++23)
template< class FloatingPoint > Gleitkommazahl             arg( Gleitkommazahl f );			(seit C++23)
template< class Integer > double      arg( Ganzzahl i );		(B)

1) Berechnet den Phasenwinkel (in Radiant) der komplexen Zahl z.

A,B) Zusätzliche Überladungen sind für alle ganzzahligen und Gleitkommatypen vorhanden, die als komplexe Zahlen mit Null-Imaginärteil behandelt werden.

(seit C++11)

Parameter

z	-	komplexer Wert
f	-	Gleitkommawert
i	-	ganzzahliger Wert

Rückgabewert

1) std::atan2(std::imag(z), std::real(z)). Wenn keine Fehler auftreten, ist dies der Phasenwinkel von z im Intervall [−π; π].

A) Null, wenn f positiv oder +0 ist, π, wenn f negativ oder -0 ist, andernfalls NaN.

B) Null, wenn i nicht negativ ist, π, wenn es negativ ist.

Anmerkungen

Die zusätzlichen Überladungen müssen nicht exakt wie in (A,B) angegeben bereitgestellt werden. Sie müssen nur ausreichen, um sicherzustellen, dass für ihr Argument num

• Wenn num vom Typ Standard(bis C++23) Gleitkommazahl T ist, dann hat std::arg(num) denselben Effekt wie std::arg(std::complex<T>(num)).
• Andernfalls, wenn num einen Ganzzahltyp hat, dann hat std::arg(num) denselben Effekt wie std::arg(std::complex<double>(num)).

Beispiel

Führen Sie diesen Code aus

#include <complex>
#include <iostream>
 
int main() 
{
    std::complex<double> z1(1, 0);
    std::complex<double> z2(0, 0);
    std::complex<double> z3(0, 1);
    std::complex<double> z4(-1, 0);
    std::complex<double> z5(-1, -0.0);
    double f = 1.;
    int i = -1;
 
    std::cout << "phase angle of " << z1 << " is " << std::arg(z1) << '\n'
              << "phase angle of " << z2 << " is " << std::arg(z2) << '\n'
              << "phase angle of " << z3 << " is " << std::arg(z3) << '\n'
              << "phase angle of " << z4 << " is " << std::arg(z4) << '\n'
              << "phase angle of " << z5 << " is " << std::arg(z5) << " "
                 "(the other side of the cut)\n"
              << "phase angle of " << f << " is " << std::arg(f) << '\n'
              << "phase angle of " << i << " is " << std::arg(i) << '\n';
 
}

Ausgabe

phase angle of (1,0) is 0
phase angle of (0,0) is 0
phase angle of (0,1) is 1.5708
phase angle of (-1,0) is 3.14159
phase angle of (-1,-0) is -3.14159 (the other side of the cut)
phase angle of 1 is 0
phase angle of -1 is 3.14159

Siehe auch

abs(std::complex)	gibt den Betrag einer komplexen Zahl zurück (function template)
polar	konstruiert eine komplexe Zahl aus Betrag und Phasenwinkel (function template)
atan2atan2fatan2l (C++11)(C++11)	Arkustangens, verwendet Vorzeichen zur Bestimmung der Quadranten (Funktion)
atan2(std::valarray)	wendet die Funktion std::atan2 auf ein Valarray und einen Wert an (function template)
C-Dokumentation für carg