numpy.arctan2 () in Python

| | | | | | | | | | | | | | | | | | | |

Syntax

numpy.arctan2(x1, x2, /, out=None, *, where=True, casting=`same_kind`, order=`K`, dtype =None, subok=True[, signature, extobj]) = ufunc `arctan2`

Parameter
x1 array_like, reellwertig

y-Koordinaten.

x2 array_like, reellwertig

x-Koordinaten. Wenn x1.shape != x2. Form , müssen sie in eine gemeinsame Form übertragen werden können (die zur Form der Ausgabe wird).

out ndarray, None oder Tupel aus ndarray und None, optional

Ein Ort, an dem das Ergebnis gespeichert wird. Falls vorhanden, muss es eine Form haben, an die die Eingaben senden. Wenn nicht angegeben oder None, wird ein frisch zugewiesenes Array zurückgegeben. Ein Tupel (nur als Schlüsselwortargument möglich) muss eine Länge haben, die gleich der Anzahl der Ausgaben ist.

wobei array_like, optional

Diese Bedingung wird über die Eingabe übertragen. An Stellen, an denen die Bedingung wahr ist, wird das out-Array auf das ufunc-Ergebnis gesetzt. An anderer Stelle behält das Array out seinen ursprünglichen Wert. Beachten Sie, dass wenn ein nicht initialisiertes out-Array über den Standardwert out=None< erstellt wird /span>, Stellen darin, an denen die Bedingung False ist, bleiben nicht initialisiert.

**kwargs

Weitere Nur-Schlüsselwort-Argumente finden Sie in der ufunc-Dokumentation .

Gibt
angle ndarray

Array von Winkeln im Bogenmaß im Bereich [-pi, pi]. Dies ist ein Skalar, wenn sowohl x1 als auch x2 Skalare sind.


Wir werden NumPy arctan2 behandeln. Daneben werden wir uns zum besseren allgemeinen Verständnis auch dessen Syntax und Parameter ansehen. Dann werden wir die Anwendung des gesamten theoretischen Teils anhand einiger Beispiele sehen. Aber zuerst wollen wir versuchen, die Funktion durch ihre Definition zu analysieren. Erstens bedeutet arctan die Umkehrung einer tan-Funktion. Jetzt hilft uns die Funktion NumPy arctan2, den arctan-Wert zwischen X1 und X2 im Bogenmaß zu berechnen. Hier sind X1 und 2 Parameter, die wir später besprechen werden. Im Laufe dieses Artikels werden die Dinge für Sie klarer. Schauen wir uns als nächstes die damit verbundene Syntax an.
Die Methode numpy.arctan2() berechnet den elementweisen Arkustangens von arr1 / arr2 und wählt den Quadranten korrekt aus. Der Quadrant wird so gewählt, dass arctan2(x1, x2) der vorzeichenbehaftete Winkel im Bogenmaß zwischen dem Strahl ist, der am Ursprung endet und durch den Punkt (1, 0) verläuft, und dem Strahl endet am Ursprung und geht durch den Punkt (x2, x1).
Arctan2 ist eine 4-Quadranten-Umkehrfunktion. Unter Berücksichtigung dessen ergibt sich ein Wert zwischen 0 und 2pi. Der Bereich dieser Funktion beträgt -180 bis 180 Grad. Dies sind die 2 Hauptpunkte, die Arctan2 von Arctan-Funktionen unterscheiden.

Unterschied zwischen Arctan und Arctan2

In diesem Abschnitt besprechen wir den Unterschied zwischen 2 Numpy-Funktionen.

< td>arctan ist eine 2-Quadranten-Umkehrfunktion.
NumPy arctan< /td>NumPy arctan2
arctan2 ist eine 4-Quadranten-Umkehrfunktion.
Der Bereich der arctan-Funktion reicht von -90 bis 90 Grad.Der Bereich für arctan2 ist -180 bis 180 Grad.
Diese Funktion akzeptiert ein einzelnes Array.This Funktion wie besprochen nimmt 2 Input-Arrays.
Nun sind wir mit dem theoretischen Teil für NumPy arctan2 fertig. In diesem Abschnitt wird untersucht, wie diese Funktion funktioniert und wie sie uns hilft, die gewünschte Ausgabe zu erhalten. Wir beginnen mit einem einfachen Beispiel und gehen allmählich zu einem komplizierteren Beispiel über.

NumPy Arctan2 Beispiel

importiere numpy als ppool y=[1,1] x=[1,1.732] print(ppool.arctan2(y,x)) [0.78539816 0.52361148] 
Oben sehen wir ein einfaches Beispiel unserer arctan2-Funktion. Lassen Sie uns jetzt Zeile für Zeile gehen und verstehen, wie wir das Ergebnis erhalten haben. Zuerst haben wir die NumPy-Funktion importiert. Dann haben wir unsere 2 Sätze des Arrays definiert. Indem wir die Syntax unserer Funktion und die print-Anweisung verwenden, erhalten wir das gewünschte Ergebnis. Hier werden beide Werte im Bogenmaß angegeben. Nun, wenn Sie das Ergebnis einigermaßen überprüfen möchten. Dazu müssen wir diese spezielle Methode verwenden:
Winkel in Grad = Winkel im Bogenmaß * 180/pi

Wenn wir unsere Ergebnisse berechnen, erhalten wir 45 und 30 -Grad Antwort. Hier haben wir pi bis 3,14 betrachtet. Die Antworten stimmen überein und somit ist das Ergebnis verifiziert.

Numpy Arctan() Beispiel #2

Nehmen wir nun an, dass wir auch die Werte ‚Äã‚Äã in Grad erhalten möchten. Es ist ein einfacher Prozess und kann mit Hilfe der for-Schleife und der oben besprochenen Formel durchgeführt werden. Mal sehen wie:
importiere numpy als ppool degree=0 y=[-1,1.732] x=[2,1] b=ppool.arctan2(y,x) print(b) for vals in b: degree= vals*(180/3.14) print(grad) 

Ausgabe:

[-0.46364761 1.04718485] -26.578525356734104 60.02970472117416 
Sehen Sie, wie wir die Werte ‚Äã‚Äã im Bogenmaß erhalten und Grad. Alle Schritte sind ähnlich wie im ersten Beispiel. Der einzige Unterschied, wir haben eine "for-Schleife" verwendet. Wenn Sie etwas Einfacheres wollen, können wir auch eine andere Methode verwenden
import numpy as ppool y=[-1,1.732] x=[2,1] b=ppool.arctan2(y,x)*(180/3.14) print (b) 
Hier müssen Sie nur den Wert (180 / 3.14) oder (180 / ppool.pi) mit dem Array multiplizieren. Sie können diese Methode definitiv für die for-Schleife-Methode verwenden. Aber in jedem Fall erhalten Sie die gewünschte Ausgabe, die ein Gradwert ist.

Ausgabe:

[-26.57852536 60.02970472] 

NumPy Arctan2 Beispiel #3

def doa(self, receiver, source): ``` Berechnet die Richtung des Eintreffens von Quelle und Empfänger ``` s_ind = self.key2ind(source) r_ind = self.key2ind(receiver) # Vektor vom Empfänger zur Quelle v = self.X[:,s_ind] - self.X[: ,r_ind] Azimut = np.arctan2(v[1], v[0]) Elevation = np.arctan2(v[2], la.norm(v[ :2])) Azimut = Azimut + 2*np.pi wenn Azimut < 0. sonst Azimut Elevation = Elevation + 2*np.pi wenn Elevation < 0. sonst Elevation return np.array([Azimut, Elevation]) 

NumPy Arctan2 Beispiel #4

def mtx_freq2visi(M, p_mic_x, p_mic_y): """ bilde die Matrix, die die Fourier-Reihe auf die Sichtbarkeit abbildet:param M: die Fourier-Reihen-Erweiterung ist begrenzt von -M auf M:param p_mic_x: ein Vektor, der die x-Koordinaten von Mikrofonen enthält:param p_mic_y: ein Vektor, der die y-Koordinaten von Mikrofonen enthält:return: """ num_mic = p_mic_x.size ms = np.reshape(np.arange(- m , M + 1, step=1), (1, -1), order=`F`) G = np.zeros((num_mic * (num_mic - 1), 2 * M + 1), dtype=complex, order =`C`) count_G = 0 für q in range(num_mic): p_x_outer = p_mic_x[q] p_y_outer = p_mic_y[q] für qp in range(num_mic): wenn nicht q == qp: p_x_qqp = p_x_outer - p_mic_x[qp ] p_y_qqp = p_y_outer - p_mic_y[qp] norm_p_qqp = np. sqrt(p_x_qqp ** 2 + p_y_qqp ** 2) phi_qqp = np.arctan2(p_y_qqp, p_x_qqp) G[count_G,:] = ( -1j) ** ms * sp.special.jv(ms, norm_p_qqp) * np.exp(1j * ms * phi_qqp) count_G += 1 return G 

NumPy Arctan2 Beispiel #5

def vector_angle(u, v, direction=None): ``` vector_angle(u, v) liefert den Winkel zwischen den beiden Vektoren u und v. Das optionale Argument direction ist standardmäßig None, was den kleinstmöglichen Wert angibt Winkel zwischen den Vektoren gemeldet werden; wenn die Vektoren u und v 2D-Vektoren sind und die Richtungsparameter True und False die Richtung im Uhrzeigersinn bzw. gegen den Uhrzeigersinn angeben; Wenn die Vektoren 3D-Vektoren sind, kann die Richtung ein 3D-Punkt sein, der nicht in der Ebene liegt, die u, v und den Ursprung enthält, und er gibt an, um welche Richtung (uxv oder vxu) der Winkel gegen den Uhrzeigersinn von u nach v verläuft gemeldet werden soll (der Kreuzproduktvektor, der ein positives Skalarprodukt mit dem Richtungsargument hat, wird als Rotationsachse verwendet). ``` wenn Richtung None ist: gebe np.arccos(vector_angle_cos(u, v)) zurück, wenn Richtung True ist: gebe np.arctan2(v[1], v[0]) - np zurück. arctan2(u[1], u[0]) elif direction is False: return np.arctan2(u[1], u[0]) - np.arctan2(v[1], v [0]) else: axis1 = normalize(u) axis2 = normalize(np.cross(u, v)) if np.dot(axis2, direction) < 0: axis2 = -axis2 return np.arctan2(np.dot(axis2, v), np.dot(axis1, v)) 

NumPy Arctan2 Beispiel #6

def __init__(self, line): data = line.split(` `) data[1:] = [float(x) for x in data[1:]] self.classname = data[0] self.xmin = data[1] self.ymin = data[2 ] self.xmax = daten[1]+daten[3] self.ymax = daten[2]+daten[4] self.box2d = np.array([self.xmin,self.ymin,self.xmax,self. ymax]) self.centroid = np.array([data[5],data[6],data[7]]) self.unused_dimension = np.array([data[8],data[9],data[10 ]]) self.w = data[8] self.l = data[9] self.h = data[10] self.orientation = np.zeros((3,)) self.orientation[0] = data[11 ] Selbstorientierung[1] = data[12] self.heading_angle = -1 * np.arctan2(self.orientation[1], self.orientation[0]) 

np.arctan2 Beispiel #7

def stanleyControl(state, cx, cy, cyaw, last_target_idx): """:param state: (State object):param cx: ([float]):param cy: ([float]): param cyaw: ([float]):param last_target_idx: (int):return: (float, int, float) """ # Kursversatzfehler current_target_idx, error_front_axle = calcTargetIndex(state, cx, cy) if last_target_idx >= current_target_idx: current_target_idx = last_target_idx # theta_e korrigiert den Kursfehler theta_e = normalizeAngle(cyaw[current_target_idx] - state.yaw) # theta_d korrigiert den Kursversatz theta_d = np.arctan2(K_STANLEY_CONTROL * error_front_axle, state.v) # Delta der Lenksteuerung = theta_e + theta_d return delta, current_target_idx, error_front_axle 

np arctan2 Example #8

def calcTargetIndex(state, cx, cy): """:param state: (Zustandsobjekt):param cx: [float]:param cy: [float]:return: (int, float) """ # Vorderachsposition berechnen fx = state.x + CAR_LENGTH * np.cos(state.yaw) fy = state.y + CAR_LENGTH * np.sin(state.yaw) # Index des nächsten Punktes suchen dx = [fx - icx für icx in cx] dy = [fy - icy für icy in cy] d = [np. sqrt(idx ** 2 + idy ** 2) für (idx, idy) in zip(dx, dy)] error_front_axle = min(d) target_idx = d.index(error_front_axle) target_yaw = normalizeAngle(np.arctan2(fy - cy[target_idx], fx - cx[target_idx]) - state.yaw ) if target_yaw > 0.0: error_front_axle = - error_front_axle return target_idx, error_front_axle 

NumPy Arctan2 Example #9

def vehicle_flat_reverse(zflag, params={}): # Erhalte die Parameterwerte b = params.get(`wheelbase`, 3.) # Erstellen Sie einen Vektor zum Speichern des Zustands und der Eingaben x = np.zeros(3) u = np.zeros(2) # Lösen Sie bei gegebenen flachen Variablen nach dem Zustand x[ 0] = zflag[0][0] # x-Position x[1] = zflag[1][0] # y-Position x[2] = np.arctan2(zflag[1][1 ], zflag[0][1]) # tan(theta) = ydot/xdot # Und als nächstes auflösen nach die Eingänge u[0] = zflag[0][1] * np.cos(x[2]) + zflag[1][1] * np.sin(x[2]) thdot_v = zflag[1][2]. ] * np.cos(x[2]) - zflag[0][2] * np.sin(x[2]) u[1] = np.arctan2(thdot_v, u[0 ]**2 / b) return x, u # Funktion zur Berechnung der RHS der Systemdynamik 

np.arctan2 Beispiel #10

def GetNeighborCells(self, p, nr, dp = None): ``` Gibt alle Zellen zurück, die nicht mehr als einen gegebenen Abstand in beliebiger Richtung von einer angegebenen Zelle entfernt sind p: Die Zelle, deren Nachbarn abgerufen werden sollen nr: Nachbarradius dp: Richtungspräferenz ``` pi, pj, pk = p tqm = self.qm * self.qp nc = [(pi - i * tqm, pj - j * tqm, pk) für i in range(-nr, nr + 1) für j in range(-nr, nr + 1)] wenn dp nicht None ist: #Punkte basierend auf Richtungspräferenz sortieren dpa = np.arctan2(dp[1], dp[0]) #Bevorzugter Richtungswinkel erhalten #Richtungen bevorzugen in die Richtung von dp; sortieren basierend auf der Größe des Winkels von der letzten Richtung nc = sorted(nc, key = lambda t: np.abs(np.arctan2(t[1], t[0]) - dpa)) return nc # Ruft die aktuelle 3D-Position des Spielers ab 
In diesem Artikel behandeln wir arctan2 von NumPy. Darüber hinaus haben wir auch seine Syntax und Parameter gesehen. Zum besseren Verständnis haben wir einige Beispiele gesehen. Am Ende können wir schlussfolgern, dass NumPy arctan2 eine Funktion ist, die uns hilft, den inversen tan-Wert zwischen 2 Punkten zu finden. Standardmäßig gibt es den Wert in Bogenmaß zurück, aber wir können ihn mit den oben beschriebenen Methoden in Grad umwandeln. Wir hoffen, dass dieser Artikel all Ihre Zweifel ausgeräumt hat. Falls Sie jedoch ungelöste Fragen haben, können Sie diese gerne in den Kommentarbereich schreiben. Nachdem Sie das gelesen haben, warum lesen Sie nicht über die folgende Identitätsmatrix.

Python atan oder atan2, was soll ich verwenden?

StackOverflow-Frage

Meine Formel f=arctan(ImZ/ReZ)

Es gibt zwei Möglichkeiten :

Option 1 (atan):

ImZ=-4.593172163003 ImR=-4.297336384845 >>> z=y/x >>> f1=math.atan(z) >>> f1 0.8186613519278327 

Option 2 (atan2)

>>> f=math.atan2(y,x) >>> f -2.3229313016619604 

Warum unterscheiden sich diese beiden Ergebnisse?

Antwort:

Atan nimmt ein einzelnes Argument und Atan2 zwei Argumente. Der Zweck der Verwendung von zwei Argumenten anstelle von einem besteht darin, Informationen über die Vorzeichen der Eingaben zu sammeln, um den richtigen Quadranten des berechneten Winkels zurückzugeben, was nicht möglich ist für das einzelne Argument Atan

atan2-Ergebnisse für jedes x,y

Atan2-Ergebnis liegt immer zwischen -pi und pi.

Referenz: https://en.wikipedia.org/wiki/Atan2

Archivierte Version

numpy.arctan2 (arr1, arr2, Casting = & # 39; gleiche_Art & # 39 ;, Reihenfolge = & # 39; K & # 39;, dtype = None, ufunc & # 39; arctan & # 39;):
Berechnet den elementweisen Arkustangens von arr1 / arr2 durch Wahl des richtigen Quadranten.¬†Der Quadrant wird so gewählt, dass arctan2 (x1, x2) ist das Winkelzeichen im Bogenmaß zwischen einem Strahl, der am Ursprung endet und durch Punkt (1, 0) verläuft, und ein Strahl, der am Ursprung endet und durch den Punkt (x2) x1 geht).

Parameter:

arr1: [array_like] echter Wert;  y-Koordinaten
arr2: [array_like] realer Wert; ¬†x-Koordinaten.¬†Es muss mit der Form der y-Koordinaten übereinstimmen.
out: [ndarray, array_like [ OPTIONAL ]] Array mit derselben Form wie x .
wobei: [array_like, optional] Wahrer Wert bedeutet, dass die universellen Funktionen (ufunc) an dieser Position berechnet werden, Falscher Wert bedeutet, dass der Wert in der Ausgabe belassen wird allein.

Hinweis:
2pi Radian = 360 Grad
Die Konvention besteht darin, den Winkel z zurückzugeben, dessen Realteil in [-pi / 2 , pi / liegt 2].

Rückgabe: Elementweiser Arkustangens von arr1 / arr2.¬†Die Werte ‚Äã‚Äãliegen im geschlossenen Intervall [-pi / 2, pi / 2].

Code #1: Arbeit

# Python3-Programm erklärt
# arctan2 () Funktion

 

import numpy as np

 

arr1 = [ - 1 , + 1 , + 1 , - 1 ]

arr2 = [ - 1 , - 1 , + 1 , + 1 ]

  

ans = np.arctan2 (arr2, arr1) * 180 / np.pi

 

print ( "x- Koordinaten:" , arr1)

print ( "y-koordinaten: " , arr2)

  

print ( "arctan2 values:" , ans )

Ausgabe:

x-Koordinaten: [-1, 1, 1 , -1] y-Koordinaten: [-1, -1, 1, 1] arctan2 Werte: [-135 . -45. 45. 135.] 

Code # 2: Arbeit

# Python3-Programm zeigt
# arctan2 () Funktionen

 

import numpy as np

 

a = np.arctan2 ([ 0. , 0. , np.inf ], [ + 0. , - 0. , np. inf])

 

b = np .arctan2 ([ 1. , - 1. ], [ 0. , 0. ])

 

print ( " a: " , a)

  

print ( "b:" , b )

Ausgabe:

< vor>a: [0. 3.14159265 0.78539816] b: [1.57079633 -1.57079633]

Links:
arctan2.html#numpy.arctan2>https://docs.scipy.org/doc/numpy-1.13.0/reference/g enerated / numpy.arctan2.html # numpy.arctan2
,

Shop

Learn programming in R: courses

$

Best Python online courses for 2022

$

Best laptop for Fortnite

$

Best laptop for Excel

$

Best laptop for Solidworks

$

Best laptop for Roblox

$

Best computer for crypto mining

$

Best laptop for Sims 4

$

Latest questions

NUMPYNUMPY

psycopg2: insert multiple rows with one query

12 answers

NUMPYNUMPY

How to convert Nonetype to int or string?

12 answers

NUMPYNUMPY

How to specify multiple return types using type-hints

12 answers

NUMPYNUMPY

Javascript Error: IPython is not defined in JupyterLab

12 answers


Wiki

Python OpenCV | cv2.putText () method

numpy.arctan2 () in Python

Python | os.path.realpath () method

Python OpenCV | cv2.circle () method

Python OpenCV cv2.cvtColor () method

Python - Move item to the end of the list

time.perf_counter () function in Python

Check if one list is a subset of another in Python

Python os.path.join () method