Namespaces
Variants

std:: atan2, std:: atan2f, std:: atan2l

From cppreference.net
C++
Numerics library
Common mathematical functions
Nearest integer floating point operations
(C++11)
(C++11)
(C++11) (C++11) (C++11)
Floating point manipulation functions
(C++11) (C++11)
(C++11)
(C++11)
Classification and comparison
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
Types
(C++11)
(C++11)
(C++11)
Macro constants
Definiert im Header <cmath>
(1)
float atan2 ( float y, float x ) ;

double atan2 ( double y, double x ) ;

long double atan2 ( long double y, long double x ) ;
(bis C++23)
/*floating-point-type*/

atan2 ( /*floating-point-type*/ y,

/*floating-point-type*/ x ) ;
(seit C++23)
(constexpr seit C++26)
float atan2f ( float y, float x ) ;
(2) (seit C++11)
(constexpr seit C++26)
long double atan2l ( long double y, long double x ) ;
(3) (seit C++11)
(constexpr seit C++26)
SIMD-Überladung (seit C++26)
Definiert im Header <simd>
template < class V0, class V1 >

constexpr /*math-common-simd-t*/ < V0, V1 >

atan2 ( const V0 & v_y, const V1 & v_x ) ;
(S) (seit C++26)
Definiert im Header <cmath>
template < class Integer >
double atan2 ( Integer y, Integer x ) ;
(A) (constexpr seit C++26)
1-3) Berechnet den Arkustangens von y / x unter Verwendung der Vorzeichen der Argumente zur Bestimmung des korrekten Quadranten. Die Bibliothek stellt Überladungen von std::atan2 für alle cv-unqualifizierten Gleitkommatypen als Parametertyp bereit. (since C++23)
S) Die SIMD-Überladung führt eine elementweise std::atan2 -Operation auf v_y und v_x durch.
(Siehe math-common-simd-t für deren Definition.)
(seit C++26)
A) Zusätzliche Überladungen werden für alle Ganzzahltypen bereitgestellt, die als double behandelt werden.
(since C++11)

Inhaltsverzeichnis

Parameter

y, x - Gleitkomma- oder Ganzzahlwerte

Rückgabewert

If no errors occur, the arc tangent of y / x ( arctan(
y
x
) ) in the range [-π, +π] radians, is returned.
y Argument
Rückgabewert
math-atan2.png
x Argument

Wenn ein Domänenfehler auftritt, wird ein implementierungsdefinierter Wert zurückgegeben (NaN, sofern unterstützt).

Wenn ein Bereichsfehler aufgrund von Unterlauf auftritt, wird das korrekte Ergebnis (nach Rundung) zurückgegeben.

Fehlerbehandlung

Fehler werden gemeldet, wie in math_errhandling spezifiziert.

Ein Domänenfehler kann auftreten, wenn x und y beide null sind.

Wenn die Implementierung IEEE-Gleitkommaarithmetik (IEC 60559) unterstützt,

  • Wenn x und y beide null sind, tritt kein Domänenfehler auf.
  • Wenn x und y beide null sind, tritt auch kein Wertebereichsfehler auf.
  • Wenn y null ist, tritt kein Polstellenfehler auf.
  • Wenn y ±0 ist und x negativ oder -0 ist, wird ±π zurückgegeben.
  • Wenn y ±0 ist und x positiv oder +0 ist, wird ±0 zurückgegeben.
  • Wenn y ±∞ ist und x endlich ist, wird ±π/2 zurückgegeben.
  • Wenn y ±∞ ist und x -∞ ist, wird ±3π/4 zurückgegeben.
  • Wenn y ±∞ ist und x +∞ ist, wird ±π/4 zurückgegeben.
  • Wenn x ±0 ist und y negativ ist, wird -π/2 zurückgegeben.
  • Wenn x ±0 ist und y positiv ist, wird +π/2 zurückgegeben.
  • Wenn x -∞ ist und y endlich und positiv ist, wird +π zurückgegeben.
  • Wenn x -∞ ist und y endlich und negativ ist, wird -π zurückgegeben.
  • Wenn x +∞ ist und y endlich und positiv ist, wird +0 zurückgegeben.
  • Wenn x +∞ ist und y endlich und negativ ist, wird -0 zurückgegeben.
  • Wenn entweder x NaN oder y NaN ist, wird NaN zurückgegeben.

Hinweise

std :: atan2 ( y, x ) entspricht std:: arg ( std:: complex < std:: common_type_t < decltype ( x ) , decltype ( y ) >> ( x, y ) ) .

POSIX spezifiziert , dass im Fall eines Underflows der Wert y / x zurückgegeben wird, und falls dies nicht unterstützt wird, ein implementierungsdefinierter Wert nicht größer als DBL_MIN , FLT_MIN und LDBL_MIN zurückgegeben wird.

Die zusätzlichen Überladungen müssen nicht exakt wie (A) bereitgestellt werden. Sie müssen lediglich sicherstellen, dass für ihr erstes Argument num1 und zweites Argument num2 :

  • Falls num1 oder num2 den Typ long double besitzt, dann hat std :: atan2 ( num1, num2 ) denselben Effekt wie std :: atan2 ( static_cast < long double > ( num1 ) ,
    static_cast < long double > ( num2 ) )     .
  • Andernfalls, falls num1 und/oder num2 den Typ double oder einen Ganzzahltyp besitzt, dann hat std :: atan2 ( num1, num2 ) denselben Effekt wie std :: atan2 ( static_cast < double > ( num1 ) ,
    static_cast < double > ( num2 ) )     .
  • Andernfalls, falls num1 oder num2 den Typ float besitzt, dann hat std :: atan2 ( num1, num2 ) denselben Effekt wie std :: atan2 ( static_cast < float > ( num1 ) ,
    static_cast < float > ( num2 ) )     .
(bis C++23)

Falls num1 und num2 arithmetische Typen besitzen, dann hat std :: atan2 ( num1, num2 ) denselben Effekt wie std :: atan2 ( static_cast < /*common-floating-point-type*/ > ( num1 ) ,
static_cast < /*common-floating-point-type*/ > ( num2 ) ) , wobei /*common-floating-point-type*/ der Gleitkommatyp mit dem höchsten Gleitkomma-Konvertierungsrang und der höchsten Gleitkomma-Konvertierungsunterrang zwischen den Typen von num1 und num2 ist; Argumente von Ganzzahltyp werden als mit demselben Gleitkomma-Konvertierungsrang wie double betrachtet.

Falls kein solcher Gleitkommatyp mit dem höchsten Rang und Unterrang existiert, dann führt die Überladungsauflösung nicht zu einem verwendbaren Kandidaten aus den bereitgestellten Überladungen.

(seit C++23)

Beispiel

Diesen Code ausführen 
#include <cmath>
#include <iostream>
void print_coordinates(int x, int y)
{
    std::cout << std::showpos
              << "(x:" << x << ", y:" << y << ") cartesian is "
              << "(r:" << std::hypot(x, y)
              << ", phi:" << std::atan2(y, x) << ") polar\n";
}
int main()
{
    // normale Verwendung: die Vorzeichen der beiden Argumente bestimmen den Quadranten
    print_coordinates(+1, +1); // atan2( 1,  1) =  +pi/4, Quadrant I
    print_coordinates(-1, +1); // atan2( 1, -1) = +3pi/4, Quadrant II
    print_coordinates(-1, -1); // atan2(-1, -1) = -3pi/4, Quadrant III
    print_coordinates(+1, -1); // atan2(-1,  1) =  -pi/4, Quadrant IV
    // spezielle Werte
    std::cout << std::noshowpos
              << "atan2(0, 0) = " << atan2(0, 0) << '\n'
              << "atan2(0,-0) = " << atan2(0, -0.0) << '\n'
              << "atan2(7, 0) = " << atan2(7, 0) << '\n'
              << "atan2(7,-0) = " << atan2(7, -0.0) << '\n';
}

Ausgabe: 

(x:+1, y:+1) cartesian is (r:1.41421, phi:0.785398) polar
(x:-1, y:+1) cartesian is (r:1.41421, phi:2.35619) polar
(x:-1, y:-1) cartesian is (r:1.41421, phi:-2.35619) polar
(x:+1, y:-1) cartesian is (r:1.41421, phi:-0.785398) polar
atan2(0, 0) = 0
atan2(0,-0) = 3.14159
atan2(7, 0) = 1.5708
atan2(7,-0) = 1.5708

Siehe auch

(C++11) (C++11)
berechnet den Arkussinus ( arcsin(x) )
(Funktion)
(C++11) (C++11)
berechnet den Arkuskosinus ( arccos(x) )
(Funktion)
(C++11) (C++11)
berechnet den Arkustangens ( arctan(x) )
(Funktion)
gibt den Phasenwinkel zurück
(Funktionstemplate)
wendet die Funktion std::atan2 auf ein valarray und einen Wert an
(Funktionstemplate)
C-Dokumentation für atan2