Recomposed
Canvas

atan, atan2 et atanh : trois inverses différents, un nom source de confusion

Oct 9, 2026 · 7 min read

atan, atan2 et atanh : trois inverses différents, un nom source de confusion

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) inverse tan. 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 de dy et dx en 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 rapport dy / dx. Deux points opposés, comme (1, 1) et (-1, -1), produisent exactement le même rapport, parce que 1 / 1 et -1 / -1 valent tous les deux 1.
  • atan doit 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°.
  • atan2 existe précisément pour annuler cette perte d'information. Elle lit dy et dx sé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.

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.0

atan 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.

Keep reading

Related reads

Recevez les nouveaux articles par e-mail