Quelle est la différence entre atan et atan2 en C++?

Des mathématiques scolaires, nous savons que la tangente a la définition

tan(α) = sin(α) / cos(α)

Et nous différencions quatre quadrants en fonction de l'angle que nous fournissons aux fonctions. Le signe de l'sin, cos et tan ont la relation suivante (où nous négligeons les multiples exacts de π/2):

  Quadrant    Angle              sin   cos   tan
-------------------------------------------------
  I           0    < α < π/2      +     +     +
  II          π/2  < α < π        +     -     -
  III         π    < α < 3π/2     -     -     +
  IV          3π/2 < α < 2π       -     +     -

Étant donné que la valeur de tan(α) est positive, nous ne pouvons pas distinguer, si l'angle était du Premier ou du troisième quadrant et s'il est négatif, il pourrait provenir du deuxième ou quatrième quadrant. Ainsi, par convention, atan() renvoie un angle à partir du Premier ou du quatrième quadrant (c'est-à-dire -π/2 <= atan() <= π/2), quelle que soit l'entrée d'origine de la tangente.

Pour récupérer l'information complète, nous ne devons pas utiliser le résultat de la division {[11] } mais nous devons regarder les valeurs du sinus et du cosinus séparément. Et c'est ce que fait atan2(). Il prend les deux, les sin(α) et cos(α) et résout les quatre quadrants en ajoutant π au résultat de atan() chaque fois que le le cosinus est négatif.

Remarque: la fonction atan2(y, x) prend en fait un argument y et un argument x, qui est la projection d'un vecteur de longueur v et d'angle α sur les axes y et x, c'est-à-dire

y = v * sin(α)
x = v * cos(α)

Qui donne la relation

y/x = tan(α)

Conclusion: {[22] } est retenu certaines informations et ne peut que supposer que l'entrée provient de quadrants I ou IV. en revanche, atan2(y,x) obtient toutes les données et peut donc résoudre l'angle correct.

Autre chose à mentionner est que atan2 est plus stable lors du calcul des tangentes à l'aide d'une expression comme atan(y / x) et x est 0 ou proche de 0.

Les valeurs réelles sont en radians, mais de les interpréter en degrés, ce sera:

• atan = donne une valeur d'angle entre -90 et 90
• atan2 = donne une valeur d'angle entre -180 et 180

Pour mon travail qui implique le calcul de différents angles tels que le cap et le roulement dans la navigation, atan2 dans la plupart des cas fait le travail.

Atan (x) renvoie la valeur principale de l'arc tangent de x, exprimée en radians.

Atan2 (y,x) renvoie la valeur principale de l'arc tangent de y / x, exprimée en radians.

Notez qu'en raison de l'ambiguïté du signe, une fonction ne peut pas déterminer avec certitude dans quel quadrant l'angle ne tombe que par sa valeur tangente (atan seul). Vous pouvez utiliser atan2 si vous devez déterminer le quadrant.

Je suppose que la question principale essaie de comprendre: "quand devrais-je utiliser l'un ou l'autre", ou "lequel devrais-je utiliser", ou "est-ce que J'utilise le bon"?

Je suppose que le point important est qu'atan n'était destiné qu'à alimenter des valeurs positives dans une courbe de direction vers le haut comme pour les vecteurs temps-distance. Cero est toujours en bas à gauche, et thigs ne peut monter et à droite, juste plus lentement ou plus vite. atan ne renvoie pas de nombres négatifs, donc vous ne pouvez pas tracer les choses dans les 4 directions sur un écran juste en ajoutant / soustrayant son résultat.

Atan2 est destiné à ce que l'origine soit au milieu, et les choses peuvent reculer ou descendre. C'est ce que vous utiliseriez dans une représentation d'écran, car peu importe la direction que vous voulez que la courbe aille. Donc, atan2 peut vous donner des nombres négatifs, parce que son cero est au centre, et son résultat est quelque chose que vous pouvez utiliser pour tracer les choses dans 4 directions.

Avec atan2 vous pouvez déterminer le quadrant comme indiqué ici.

Vous pouvez utiliser atan2 si vous en avez besoin déterminer le quadrant.

Considérons un triangle rectangle. Nous étiquetons l'hypoténuse r, le côté horizontal y et le côté vertical X. l'angle d'intérêt @ est l'angle entre x et R.

C++ atan2(y, x) nous donnera la valeur de l'angle @ en radians. atan est utilisé si nous connaissons ou sommes intéressés par y / x Pas Y et x individuellement. Donc, si p = y / x ensuite, pour obtenir @ nous utiliserions atan (p).

Vous ne pouvez pas utiliser atan2 pour déterminer le quadrant, vous ne pouvez utiliser atan2 que si vous connaissez déjà Quel quadrant votre dans! En particulier, X positif et y impliquent le premier quadrant, y positif et x négatif, le second et ainsi de suite. atan ou atan2 eux-mêmes renvoient simplement un nombre positif ou négatif, rien de plus.

Mehrwolf ci-dessous est correct, mais voici une heuristique qui peut aider:

Si vous travaillez dans un système de coordonnées à 2 dimensions, ce qui est souvent le cas pour la programmation de la tangente inverse, vous devez utiliser définitivement use atan2. Il donnera la gamme complète d'angles 2 pi et prendra soin des zéros dans la coordonnée x pour vous.

Une autre façon de dire ceci est qu'atan(y/x) est pratiquement toujours faux. N'utilisez atan que si l'argument ne peut pas être considéré comme y / x.

atan2(y,x) est généralement utilisé si vous souhaitez convertir des coordonnées cartésiennes en coordonnées polaires. Il vous donnera l'angle, tandis que sqrt(x*x+y*y) ou, si disponible, hypot(y,x) vous donnera la taille.

atan(x) est tout simplement l'inverse de la tan. Dans l'ennuyeux cas, vous devez utiliser atan(y/x) parce que votre système ne fournit pas de atan2, vous auriez à faire des vérifications supplémentaires pour les signes de x et y, et x=0, afin d'obtenir le bon angle.

Note: atan2(y,x) est défini pour toutes les valeurs réelles de y et x, sauf pour le cas où les deux arguments sont nuls.

Dans atan2, la sortie est: -pi atan2(y,x) pi
et dans atan, la sortie est: -pi/2 atan(y/x) pi/2 //il dose PAS considérer le trimestre.
Si vous souhaitez obtenir l'orientation entre les 0 et 2*pi (tels que la haute-école de mathématiques), nous avons besoin d'utiliser la atan2 et pour les valeurs négatives ajouter le 2*pi pour obtenir le résultat final entre 0 et 2*pi.
Voici le code source Java pour l'expliquer clairement:

System.out.println(Math.atan2(1,1)); //pi/4 in the 1st quarter
System.out.println(Math.atan2(1,-1)); //(pi/4)+(pi/2)=3*(pi/4) in the 2nd quarter

System.out.println(Math.atan2(-1,-1 ));//-3*(pi/4) and it is less than 0.
System.out.println(Math.atan2(-1,-1)+2*Math.PI); //5(pi/4) in the 3rd quarter

System.out.println(Math.atan2(-1,1 ));//-pi/4 and it is less than 0.
System.out.println(Math.atan2(-1,1)+2*Math.PI); //7*(pi/4) in the 4th quarter

System.out.println(Math.atan(1 ));//pi/4
System.out.println(Math.atan(-1 ));//-pi/4