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

From cppreference.net

Défini dans l'en-tête `<cmath>`
	(1)
float atan2 ( float y, float x ) ; double atan2 ( double y, double x ) ; long double atan2 ( long double y, long double x ) ;			(jusqu'à C++23)
/floating-point-type/ atan2 ( /floating-point-type/ y, /floating-point-type/ x ) ;			(depuis C++23) (constexpr depuis C++26)
float atan2f ( float y, float x ) ;		(2)	(depuis C++11) (constexpr depuis C++26)
long double atan2l ( long double y, long double x ) ;		(3)	(depuis C++11) (constexpr depuis C++26)
Surcharge SIMD (depuis C++26)
Défini dans l'en-tête `<simd>`
template < class V0, class V1 > constexpr /math-common-simd-t/ < V0, V1 > atan2 ( const V0 & v_y, const V1 & v_x ) ;		(S)	(depuis C++26)
Surcharges supplémentaires (depuis C++11)
Défini dans l'en-tête `<cmath>`
template < class Integer > double atan2 ( Integer y, Integer x ) ;		(A)	(constexpr depuis C++26)

1-3) Calcule l'arc tangente de y / x en utilisant les signes des arguments pour déterminer le quadrant correct. La bibliothèque fournit des surcharges de


          std::atan2

pour tous les types à virgule flottante non qualifiés cv comme type des paramètres. (depuis C++23)

S) La surcharge SIMD effectue un calcul


           std::atan2

élément par élément sur v_y et v_x .

(Voir math-common-simd-t pour sa définition.)

(depuis C++26)

A) Des surcharges supplémentaires sont fournies pour tous les types entiers, qui sont traités comme double .

(depuis C++11)

Table des matières

Paramètres

y, x

valeurs à virgule flottante ou entières

Valeur de retour

If no errors occur, the arc tangent of y / x (

arctan(y x)

) in the range

[-π, +π]

radians, is returned.

y argument

Valeur de retour

$math-atan2.png$

x argument

Si une erreur de domaine se produit, une valeur définie par l'implémentation est retournée (NaN là où supporté).

Si une erreur de plage se produit en raison d'un dépassement inférieur, le résultat correct (après arrondi) est retourné.

Gestion des erreurs

Les erreurs sont signalées comme spécifié dans math_errhandling .

Une erreur de domaine peut survenir si x et y sont tous deux nuls.

Si l'implémentation prend en charge l'arithmétique à virgule flottante IEEE (IEC 60559),

Si x et y sont tous deux nuls, une erreur de domaine ne se produit pas .
Si x et y sont tous deux nuls, une erreur de plage ne se produit pas non plus.
Si y est nul, une erreur de pôle ne se produit pas.
Si y est ±0 et x est négatif ou -0, ±π est retourné.
Si y est ±0 et x est positif ou +0, ±0 est retourné.
Si y est ±∞ et x est fini, ±π/2 est retourné.
Si y est ±∞ et x est -∞, ±3π/4 est retourné.
Si y est ±∞ et x est +∞, ±π/4 est retourné.
Si x est ±0 et y est négatif, -π/2 est retourné.
Si x est ±0 et y est positif, +π/2 est retourné.
Si x est -∞ et y est fini et positif, +π est retourné.
Si x est -∞ et y est fini et négatif, -π est retourné.
Si x est +∞ et y est fini et positif, +0 est retourné.
Si x est +∞ et y est fini et négatif, -0 est retourné.
Si l'un des deux, x est NaN ou y est NaN, NaN est retourné.

Notes

std :: atan2 ( y, x ) est équivalent à std:: arg ( std:: complex < std:: common_type_t < decltype ( x ) , decltype ( y ) >> ( x, y ) ) .

POSIX spécifie qu'en cas de dépassement inférieur, la valeur y / x est retournée, et si cela n'est pas pris en charge, une valeur définie par l'implémentation n'excédant pas DBL_MIN , FLT_MIN , et LDBL_MIN est retournée.

Les surcharges supplémentaires ne sont pas tenues d'être fournies exactement comme (A) . Elles doivent seulement être suffisantes pour garantir que pour leur premier argument num1 et second argument num2 :

Si num1 ou num2 a le type long double , alors std :: atan2 ( num1, num2 ) a le même effet que std :: atan2 ( static_cast < long double > ( num1 ) ,
static_cast < long double > ( num2 ) ) .
Sinon, si num1 et/ou num2 a le type double ou un type entier, alors std :: atan2 ( num1, num2 ) a le même effet que std :: atan2 ( static_cast < double > ( num1 ) ,
static_cast < double > ( num2 ) ) .
Sinon, si num1 ou num2 a le type float , alors std :: atan2 ( num1, num2 ) a le même effet que std :: atan2 ( static_cast < float > ( num1 ) ,
static_cast < float > ( num2 ) ) .

(jusqu'en C++23)

Si num1 et num2 ont des types arithmétiques, alors std :: atan2 ( num1, num2 ) a le même effet que std :: atan2 ( static_cast < /*common-floating-point-type*/ > ( num1 ) ,
static_cast < /*common-floating-point-type*/ > ( num2 ) ) , où /*common-floating-point-type*/ est le type à virgule flottante ayant le plus grand rang de conversion en virgule flottante et la plus grande sous-catégorie de conversion en virgule flottante entre les types de num1 et num2 , les arguments de type entier sont considérés comme ayant le même rang de conversion en virgule flottante que double .

Si aucun tel type à virgule flottante avec le plus grand rang et la plus grande sous-catégorie n'existe, alors la résolution de surcharge ne résulte pas en un candidat utilisable parmi les surcharges fournies.

(depuis C++23)

Exemple

Exécuter ce code

#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()
{
    // utilisation normale : les signes des deux arguments déterminent le quadrant
    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
    // valeurs spéciales
    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';
}

Sortie :

(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

Voir aussi

asin asinf asinl (C++11) (C++11)	calcule l'arc sinus ( $arcsin(x)$ ) (fonction)
acos acosf acosl (C++11) (C++11)	calcule l'arc cosinus ( $arccos(x)$ ) (fonction)
atan atanf atanl (C++11) (C++11)	calcule l'arc tangente ( $arctan(x)$ ) (fonction)
arg	retourne l'angle de phase (fonction template)
atan2 (std::valarray)	applique la fonction std::atan2 à un valarray et une valeur (fonction template)
Documentation C pour atan2

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Diagnostics library
Memory management library
Metaprogramming library (C++11)
General utilities library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Strings library
Text processing library
Numerics library
Date and time library
Input/output library
Filesystem library (C++17)
Concurrency support library (C++11)
Execution control library (C++26)
Technical specifications
Symbols index
External libraries

cppreference.net

Namespaces

Variants

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

Table des matières

Paramètres

Valeur de retour

Gestion des erreurs

Notes

Exemple

Voir aussi