Ce que sont réellement atan, atan2 et atanh
Trois fonctions qui partagent un schéma de nommage, chacune inversant quelque chose de différent :
atan(ratio)inversetan. Donnez-lui un seul nombre, une pente ou un rapport , et elle retourne un angle, toujours compris entre -90° et 90°.atan2(dy, dx)retourne également un angle, mais à partir dedyetdxen tant que deux nombres distincts plutôt qu'un rapport déjà divisé. Ses réponses couvrent le cercle complet, de -180° à 180°, et pas seulement la moitié.atanh(x)ne concerne pas du tout les angles. Elle inverse , en reprenant un nombre déjà compressé dans(-1, 1)pour le déployer à nouveau vers n'importe quel nombre réel. La section digression vers la fin de cet article la traite séparément.
atan et atan2 partagent une racine commune et inversent toutes deux
une tangente ; atanh ne partage avec les deux autres que le schéma de
nommage.
L'intuition
« »
sonne comme une seule fonction, il est donc tentant de traiter atan,
atan2 et atanh comme des orthographes interchangeables de la même
idée. Elles ne le sont pas, et c'est surtout entre atan et atan2 que
cette hypothèse s'effondre :
tan(angle)ne dépend que du rapportdy / dx. Deux points opposés, comme(1, 1)et(-1, -1), produisent exactement le même rapport, parce que1 / 1et-1 / -1valent tous les deux1.atandoit retourner une seule réponse pour ce rapport. Elle choisit 45°, ce qui est correct pour(1, 1)et faux pour(-1, -1), qui se trouve en réalité à -135°.atan2existe précisément pour annuler cette perte d'information. Elle litdyetdxséparément, ce qui lui permet de vérifier le signe de chacun et de résoudre correctement les quatre quadrants.
L'exemple de glissement vers angle tiré de
systèmes de coordonnées écran s'appuyait
déjà sur atan2 pour exactement cette raison. Cet article s'en tient à
ce seul mécanisme assez longtemps pour voir pourquoi atan ne peut pas
faire le même travail, quelle que soit la façon dont l'entrée est
retravaillée.
- →Screen Coordinate Systems Aren't CartesianThe drag-to-angle case this post keeps coming back to: why atan2 is the inverse that survives a y-down screen's flipped rotation direction.
- →Polar to Cartesian: What cos and sin Are Actually ComputingThe forward direction atan2 undoes: turning an angle and radius into an (x, y) point in the first place.
Exemple concret : le même rapport, deux directions différentes
import kotlin.math.atan
import kotlin.math.atan2
val dy1 = 1.0; val dx1 = 1.0 // vers le bas et la droite (y augmente vers le bas sur l'écran)
val dy2 = -1.0; val dx2 = -1.0 // vers le haut et la gauche, la direction opposée
// Même rapport (1/1 == -1/-1), donc atan retourne le même angle pour les deux,
// même si les deux points sont orientés en sens opposés.
Math.toDegrees(atan(dy1 / dx1)) // 45.0
Math.toDegrees(atan(dy2 / dx2)) // 45.0 (faux, ce point est à -135°)
// atan2 voit dy et dx séparément plutôt qu'un rapport déjà divisé, ce qui
// lui permet de distinguer correctement les deux points.
Math.toDegrees(atan2(dy1, dx1)) // 45.0
Math.toDegrees(atan2(dy2, dx2)) // -135.0atan n'est pas en défaut ici. Elle répond à la seule question qu'on
lui a posée, « quel angle a cette tangente », et un seul rapport se
mappe réellement vers deux angles distants de 180°. atan2 répond à
une question différente : « quel angle mène à ce point (dx, dy) », et
celle-ci a une réponse unique pour chaque point sauf l'origine
elle-même.
atan(dy/dx): 0°
atan2(dy, dx): 0° — atan gives 0 degrees, atan2 gives the correct 0 degrees
Screen
drag the dot
Faites glisser le point à travers les quatre quadrants. atan2 suit
l'angle réel tout le long du parcours. atan revient systématiquement
à la même lecture chaque fois que le glissement traverse vers le point
miroir de l'autre côté du centre, parce que c'est la seule information
qu'elle reçoit jamais.
Le principe fondamental
atan2(dy, dx) est un inverse à deux arguments. Là où atan(ratio)
ne voit que l'information qui survit à une division, atan2 reçoit le
numérateur et le dénominateur avant toute division, ce qui lui permet
de retrouver le quadrant qu'un rapport à un seul argument avait déjà
éliminé.
Ce n'est pas une variante d'atan avec de meilleurs réglages par
défaut. Elle résout un problème strictement plus large : « dans quelle
direction se trouve ce point », et non « quel angle a cette tangente ».
Ailleurs : même principe fondamental, cadre différent
- JavaScript :
Math.atan2(y, x)prend les deux mêmes arguments dans le même ordre, pour la même raison, jusqu'au cas limite(0, 0)ci-dessous. - GLSL :
atan(y, x), la surcharge à deux arguments du même nom de fonction utilisé pour la version à un argument, couvre la plage complète de -π à π dans un fragment shader de la même façon, couramment utilisée pour transformer le décalage d'un fragment par rapport à un centre en un angle pour des formes procédurales. - Swift :
atan2(y, x), importée directement depuis la libm du C sans libellés d'arguments, est la même fonction sous le même nom, parce que les mathématiques sous-jacentes, et la raison pour laquelle un second argument est nécessaire, ne changent pas d'un langage à l'autre.
Cas limites
kotlin.math.atan2 sur Android délègue directement à la Math.atan2
de la JVM, elle hérite donc d'une réponse définie pour chaque entrée, y
compris la seule entrée pour laquelle « la direction vers ce point »
semble ne devoir avoir aucune réponse du tout : l'origine.
import kotlin.math.atan
import kotlin.math.atan2
val dy = 0.0
val dx = -0.0 // zéro négatif : une valeur Double distincte et valide
dy / dx // NaN (0/0 est indéterminé quels que soient les signes impliqués)
atan(dy / dx) // NaN, donc il n'y a aucun angle à lire
atan2(dy, dx) // ~3,14159 (π)atan2 ne divise jamais dy par dx, elle n'est donc jamais exposée
à la forme indéterminée 0/0. Elle lit directement le signe de chaque
zéro : dy positif, dx négatif se lit comme « pointant dans la
direction x négative », ce qui vaut π. Remettez dx à zéro positif
et atan2 retourne un zéro positif à la place, une réponse différente
pour une valeur Double (-0.0) que == traite comme égale à 0.0.
atan, travaillant à partir d'un rapport déjà réduit à NaN, n'a
aucune façon de distinguer ces cas.
Où atan2 apparaît ailleurs
Les molettes de glisser-pour-pivoter et la logique de direction
d'orientation, comme la
démo de glissement vers angle de
l'article compagnon sur les systèmes de coordonnées écran, ne sont que
deux entrées d'une liste bien plus longue. Chaque fois que vous avez
besoin de direction à partir d'une paire (dx, dy) plutôt que de
distance, atan2 est généralement le moyen d'y arriver.
Interface et interaction tactile :
- Molettes et cadrans de glisser-pour-pivoter (molettes de volume, roues de couleur, curseurs circulaires, sélecteurs de type horloge) : l'angle du centre au point de contact pilote la rotation.
- Menus radiaux/circulaires : déterminer dans quelle portion un appui a atterri, en calculant l'angle de l'appui par rapport au centre du menu.
- Classification de direction de balayage : répartir l'
atan2(dy, dx)d'un balayage en plages haut/bas/gauche/droite (ou à 8 directions). - Éléments qui suivent le pointeur : une flèche ou un indicateur qui pointe toujours vers le curseur, une mise en évidence radiale de sélection.
Mouvement et orientation :
- Direction face à partir d'un vecteur de vitesse : faire pivoter
un sprite/objet pour qu'il fasse face à sa direction de déplacement,
à l'aide de l'
atan2(dy, dx)de son déplacement par image. - Logique de « regard vers »/visée : rotation de tourelle, un ennemi fait face au joueur dans un jeu, une caméra fait face à une cible.
- Entrée manette/joystick : décomposer les coordonnées
(x, y)brutes d'un stick analogique en direction (angle) et magnitude (rayon) pour un déplacement à 8 directions ou la gestion de zones mortes. - Relèvement entre deux points :
atan2(y2 - y1, x2 - x1)pour la navigation/recherche de chemin ; la version cap GPS/boussole est la même idée appliquée sur une sphère.
Graphisme et visualisation de données :
- Géométrie d'arc et de camembert : calculer l'angle de début/fin d'un segment, ou, inversement, déterminer sur quelle tranche un clic a atterri.
- Conversion cartésien-vers-polaire en général : partout où vous
avez besoin de
(r, θ)à partir de(x, y)plutôt que l'inverse, le cas générique sous lequel tombent tous les éléments ci-dessus.
Traitement du signal et autres domaines :
- Argument d'un nombre complexe :
atan2(imaginaire, réel)donne l'angle de phase d'un nombre complexe. - Démodulation I/Q en traitement du signal : récupérer la phase à partir des composantes en phase/quadrature.
- Robotique : calculs de cap vers un point de passage à partir de la position actuelle et de la cible.
Un inverse différent : atanh
atan et atan2 annulent toutes deux une fonction qui produit des
angles. atanh annule plutôt tanh, la fonction de compression de
la section d'intuition ci-dessus, et le déploiement inverse a sa propre
forme : croissance lente près de zéro, puis une montée en flèche vers
l'infini à mesure que son entrée approche ±1, l'image miroir de la
vitesse à laquelle tanh s'aplatit aux mêmes bords.
Il n'y a ici aucun geste de glissement ni de rotation impliqué. C'est
la même idée de « fonction inverse » que pour atan2, appliquée à une
paire de fonctions complètement différente, et elle apparaît bien loin
du code d'interface Android, dans des endroits où une valeur est
naturellement bornée et où quelque chose en aval a besoin de la
débornée à nouveau.
atanh(x): 0.693
tanh(atanh(x)): 0.600 — atanh of 0.60 is 0.693, and tanh of that round-trips back to 0.600
x = 0.60
Un exemple concret : un coefficient de corrélation r se situe
toujours dans (-1, 1), ce qui rend malcommode l'application directe
d'un test de signification ordinaire, puisque ces tests supposent
quelque chose de plus proche d'une distribution normale. La
n'est autre que atanh(r) :
import kotlin.math.atanh
// r est borné dans (-1, 1) ; z ne l'est pas, c'est tout le propos.
fun fisherZ(r: Double): Double = atanh(r)
fisherZ(0.6) // 0.693
fisherZ(0.99) // 2.647 (proche du bord, donc z croît vite ici)kotlin.math.atanh est fournie dans la bibliothèque standard et
fonctionne bien sur Android, il y a simplement rarement une raison de
s'en servir dans du code d'interface, puisque le code d'interface est
généralement celui qui produit une valeur bornée (un alpha, une
fraction de progression), pas celui qui a besoin d'en annuler la
borne.
Modèle mental à retenir
Une fonction inverse ne peut retourner que ce que son entrée lui
permet de voir : atan voit un rapport effondré et doit deviner un
quadrant, atan2 voit deux nombres signés et n'a pas besoin de
deviner, et atanh voit une valeur bornée et la redéploie vers la
plage non bornée dont tanh l'avait compressée.



