numpy.arctan2 () in Python

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

Sintassi

numpy.arctan2(x1, x2, /, out=Nessuno, *, dove=Vero, casting=`stesso_tipo`, ordine=`K`, dtype =Nessuno, subok=True[, signature, extobj]) = ufunc `arctan2`

Parametri
x1 array_like, valore reale

y-coordinate.

x2 array_like, valore reale

x-coordinate. Se x1.shape != x2. shape , devono essere trasmessi in una forma comune (che diventa la forma dell`output).

out ndarray, None o tupla di ndarray e None, facoltativo

Una posizione in cui viene archiviato il risultato. Se fornito, deve avere una forma a cui gli input vengono trasmessi. Se non specificato o Nessuno, viene restituito un array appena allocato. Una tupla (possibile solo come argomento di una parola chiave) deve avere una lunghezza uguale al numero di output.

dove array_like, facoltativo

Questa condizione viene trasmessa sull`input. Nelle posizioni in cui la condizione è True, l`array out verrà impostato sul risultato ufunc. Altrove, l`array out manterrà il suo valore originale. Nota che se viene creato un array out non inizializzato tramite l`impostazione predefinita out=None, le posizioni al suo interno in cui la condizione è False rimarranno non inizializzate.

**kwargs

Per altri argomenti di sole parole chiave, vedere i documenti ufunc .

Resi
angolo ndarray

Matrice di angoli in radianti, nell`intervallo [-pi, pi]. Questo è uno scalare se sia x1 che x2 sono scalari.


Tratteremo NumPy arctan2. Insieme a ciò, per una migliore comprensione generale, esamineremo anche la sua sintassi e parametro. Vedremo poi l`applicazione di tutta la parte teorica attraverso alcuni esempi. Ma prima, proviamo ad analizzare la funzione attraverso la sua definizione. In primo luogo, arctan significa l`inverso di una funzione tan. Ora la funzione NumPy arctan2 ci aiuta a calcolare il valore di arco tan tra X1 e X2 in radianti. Qui, X1 e 2 sono parametri di cui parleremo più avanti. Man mano che avanziamo in questo articolo, le cose diventeranno più chiare per te. Quindi, diamo un`occhiata alla sintassi ad esso associata.
Il metodo numpy.arctan2() calcola l`arcotangente a livello di elemento di arr1 / arr2 e seleziona correttamente il quadrante. Il quadrante viene scelto in modo che arctan2(x1, x2) sia l`angolo con segno in radianti tra il raggio che termina all`origine e passante per il punto (1, 0) e il raggio che termina all`origine e passa per il punto (x2, x1).
Arctan2 è una funzione inversa a 4 quadranti. Tenendo conto di ciò, fornisce un valore compreso tra 0 e 2pi. L`intervallo di questa funzione è compreso tra -180 e 180 gradi. Questi sono i 2 punti chiave che distinguono Arctan2 dalle caratteristiche di arctan.

Differenza tra Arctan e Arctan2

In questa sezione discuteremo la differenza tra 2 funzioni Numpy.

< td>arctan è una funzione inversa a 2 quadranti.
NumPy arctan< /td>NumPy arctan2
arctan2 è una funzione inversa a 4 quadranti.
L`intervallo della funzione arctan va da -90 a 90 gradi.L`intervallo per arctan2 è compreso tra -180 e 180 gradi.
Questa funzione accetta un singolo array.Questo funzione come discusso prende 2 array di input.
Ora abbiamo finito con la parte teorica per NumPy arctan2. Questa sezione esplora come funziona questa funzione e come ci aiuta a ottenere l`output che desideriamo. Inizieremo con un esempio elementare e passeremo gradualmente a un esempio più complicato.

Esempio di NumPy Arctan2

import numpy as ppool y=[1,1] x=[1,1.732] print(ppool.arctan2(y,x)) [0.78539816 0.52361148] 
Sopra vediamo un semplice esempio della nostra funzione arctan2. Ora camminiamo riga per riga e capiamo come abbiamo ottenuto il risultato. Innanzitutto, abbiamo importato la funzione NumPy. Quindi abbiamo definito i nostri 2 insiemi dell`array. Usando la sintassi della nostra funzione e l`istruzione print, otteniamo il risultato che vogliamo. Qui entrambi i valori sono espressi in radianti. Ora se vuoi controllare il risultato in una certa misura. Per fare ciò, dobbiamo utilizzare questo metodo particolare:
Angolo in gradi = angolo in radianti * 180/pi

Se eseguiamo calcoli sui nostri risultati, otteniamo 45 e 30 -grado di risposta. Qui abbiamo considerato pi a 3.14. Le risposte corrispondono e quindi il risultato è verificato.

Numpy Arctan() Esempio #2

Ora supponiamo di voler ottenere anche i valori ‚Äã‚Äãin gradi. È un processo semplice e può essere eseguito con l`aiuto del ciclo for e della formula discussa sopra. Vediamo come:
importare numpy as 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(degree) 

Output:

[-0.46364761 1.04718485] -26.578525356734104 60.02970472117416 
Guarda come otteniamo i valori ‚Äã‚Äãin radianti e gradi. Tutti i passaggi sono simili al primo esempio. L`unica differenza è che abbiamo usato un "for loop". Se vuoi qualcosa di più semplice possiamo anche usare un altro metodo
import numpy as ppool y=[-1,1.732] x=[2,1] b=ppool.arctan2(y,x)*(180/3.14) print (b) 
Qui tutto ciò che devi fare è moltiplicare il valore (180 / 3.14) o (180 / ppool.pi) per l`array. Puoi sicuramente usare questo metodo sul metodo del ciclo for. Ma in entrambi i casi, otterrai l`output desiderato che è un valore in gradi.

Output:

[-26.57852536 60.02970472] 

NumPy Arctan2 Esempio #3

def doa(self, receiver, source): ``` Calcola la direzione di arrivo rispetto a una sorgente e un ricevitore ``` s_ind = self.key2ind(source) r_ind = self.key2ind(receiver) # vettore dal ricevitore alla sorgente v = self.X[:,s_ind] - self.X[: ,r_ind] azimuth = np.arctan2(v[1], v[0]) elevazione = np.arctan2(v[2], la.norm(v[ :2])) azimut = azimut + 2*np.pi se azimut < 0. else azimut elevazione = elevazione + 2*np.pi se elevazione < 0. else elevazione return np.array([azimuth, elevazione]) 

NumPy Arctan2 Esempio #4

def mtx_freq2visi(M, p_mic_x, p_mic_y): """ costruisci la matrice che mappa la serie di Fourier alla visibilità:param M: l`espansione della serie di Fourier è limitato da -M a M:param p_mic_x: un vettore che contiene le coordinate x dei microfoni:param p_mic_y: un vettore che contiene le coordinate y dei microfoni: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=complesso, order =`C`) count_G = 0 per q nell`intervallo(num_mic): p_x_outer = p_mic_x[q] p_y_outer = p_mic_y[q] per qp nell`intervallo(num_mic): se non 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 Esempio #5

def vector_angle(u, v, direction=None): ``` vector_angle(u, v) restituisce l`angolo tra i due vettori u e v. L`argomento opzionale direction è di default Nessuno, che specifica che il più piccolo possibile essere riportato l`angolo tra i vettori; se i vettori u e v sono vettori 2D e i parametri di direzione True e False specificano rispettivamente le direzioni in senso orario o antiorario; se i vettori sono vettori 3D, la direzione può essere un punto 3D che non si trova nel piano contenente u, v e l`origine, e specifica attorno a quale direzione (uxv o vxu) l`angolo antiorario da u a v dovrebbe essere riportato (il vettore prodotto incrociato che ha un prodotto scalare positivo con l`argomento direzione viene utilizzato come asse di rotazione). ``` if direction is None: return np.arccos(vector_angle_cos(u, v)) elif direction is True: return np.arctan2(v[1], v[0]) - np. arctan2(u[1], u[0]) la direzione elif è Falsa: return np.arctan2(u[1], u[0]) - np.arctan2(v[1], v [0]) else: asse1 = normalizzazione(u) asse2 = normalizzazione(np.cross(u, v)) if np.dot(asse2, direzione) < 0: asse2 = -asse2 return np.arctan2(np.dot(axis2, v), np.dot(axis1, v)) 

NumPy Arctan2 Esempio #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 = data[1]+data[3] self.ymax = data[2]+data[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 ] auto.orientamento[1] = data[12] self.heading_angle = -1 * np.arctan2(self.orientation[1], self.orientation[0]) 

np.arctan2 Esempio #7

def stanleyControl(state, cx, cy, cyaw, last_target_idx): """:param state: (Stato oggetto):param cx: ([float]):param cy: ([float]): param cyaw: ([float]):param last_target_idx: (int):return: (float, int, float) """ # Errore di cross track 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 corregge l`errore di intestazione theta_e = normalizeAngle(cyaw[current_target_idx] - state.yaw) # theta_d corregge l`errore di cross track theta_d = np.arctan2(K_STANLEY_CONTROL * error_front_axle, state.v) # Controllo dello sterzo delta = theta_e + theta_d return delta, current_target_idx, error_front_axle 

np arctan2 Esempio #8

def calcTargetIndex(state, cx, cy): """:param state: (Stato oggetto):param cx: [float]:param cy: [float]:return: (int, float) """ # Calc posizione assale anteriore fx = state.x + CAR_LENGTH * np.cos(state.yaw) fy = state.y + CAR_LENGTH * np.sin(state.yaw) # Cerca l`indice del punto più vicino dx = [fx - icx for icx in cx] dy = [fy - icy for icy in cy] d = [np. sqrt(idx ** 2 + idy ** 2) for (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 Esempio #9

def vehicle_flat_reverse(zflag, params={}): # Ottieni i valori dei parametri b = params.get(`wheelbase`, 3.) # Crea un vettore per memorizzare lo stato e gli input x = np.zeros(3) u = np.zeros(2) # Date le variabili flat, risolvere lo stato x[ 0] = zflag[0][0] # x posizione x[1] = zflag[1][0] # y posizione x[2] = np.arctan2(zflag[1][1 ], zflag[0][1]) # tan(theta) = ydot/xdot # E poi risolvi per gli ingressi 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 # Funzione per calcolare la RHS della dinamica del sistema 

np.arctan2 Esempio #10

def GetNeighborCells(self, p, nr, dp = Nessuno): ``` Restituisce tutte le celle non più di una data distanza in qualsiasi direzione da una cella specificata p: La cella di cui ottenere i vicini nr: Raggio vicino dp: Preferenza di direzione ``` pi, pj, pk = p tqm = self.qm * self.qp nc = [(pi - i * tqm, pj - j * tqm, pk) for i in range(-nr, nr + 1) for j in range(-nr, nr + 1)] se dp non è Nessuno: #Ordina i punti in base alla preferenza di direzione dpa = np.arctan2(dp[1], dp[0]) #Ottieni l`angolo di direzione preferito #Preferisci le direzioni in la direzione di dp; ordina in base all`ampiezza dell`angolo dall`ultima direzione nc = sorted(nc, key = lambda t: np.abs(np.arctan2(t[1], t[0]) - dpa)) return nc #Ottiene l`attuale posizione 3d del giocatore 
In questo articolo, trattiamo arctan2 di NumPy. Inoltre, abbiamo visto anche la sua sintassi e parametri. Per una migliore comprensione, abbiamo visto alcuni esempi. Alla fine, possiamo concludere che NumPy arctan2 è una funzione che questa funzione ci aiuta a trovare il valore tan inverso tra 2 punti. Di default restituisce il valore in radianti, ma possiamo convertirlo in gradi usando i metodi discussi sopra. Speriamo che questo articolo abbia chiarito tutti i tuoi dubbi. Ma nel caso in cui tu abbia domande irrisolte, sentiti libero di scriverle nella sezione commenti. Dopo averlo letto, perché non leggere la seguente matrice di identità.

Python atan o atan2, cosa dovrei usare?

Domanda StackOverflow

La mia formula f=arctan(ImZ/ReZ)

Ci sono due opzioni :

Opzione 1 (atan):

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

Opzione 2 (atan2)

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

Perché questi due risultati sono diversi?

Risposta:

Atan prende un singolo argomento e Atan2 prende due argomenti. Lo scopo di usare due argomenti invece di uno è raccogliere informazioni sui segni degli input in modo da restituire il quadrante appropriato dell`angolo calcolato, cosa che non è possibile per il singolo argomento Atan

atan2 risultati per ogni x,y

Il risultato di Atan2 è sempre compreso tra -pi e pi.

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

Versione archiviata

numpy.arctan2 (arr1, arr2, casting = & # 39; stesso_tipo & # 39 ;, ordine = & # 39; K & # 39 ;, dtype = Nessuno, ufunc & # 39; arctan & # 39;):
Calcola l`arcotangente in termini di elemento di arr1 / arr2 scegliendo il quadrante corretto.¬†Il quadrante è scelto in modo che arctan2 (x1, x2) è il segno dell`angolo in radianti tra un raggio che termina all`origine e passante per il punto (1, 0) e un raggio che termina all`origine e passante per il punto (x2) x1).

Parametri:

arr1: [array_like] valore reale;  Coordinate y
arr2: [array_like] valore reale; coordinate x. Deve corrispondere alla forma delle coordinate y.
fuori: [ndarray, array_like [ FACOLTATIVO ]] array della stessa forma di x .
dove: [array_like, facoltativo] True value significa calcolare le funzioni universali (ufunc) in quella posizione, False value significa lasciare il valore nell`output da solo.

Nota:
2pi radianti = 360 gradi
La convenzione consiste nel restituire l`angolo z la cui parte reale si trova in [-pi / 2 , pi / 2].

Ritorno: Arco tangente per elemento di arr1 / arr2. I valori ​​sono nell`intervallo chiuso [-pi / 2, pi / 2].

Codice n. 1: lavoro

# Spiegazione del programma Python3
# funzione arctan2 ()

 

import numpy as np

 

arr1 = [ - 1 , + 1 < classe codice = "semplice">, + 1 , - 1 ]

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

  

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

 

print ( "x- coordinates:" , arr1)

print ( "y-coordin ates: " , arr2)

  

print ( "arctan2 valori:" , ans )

Output:

coordinate x: [-1, 1, 1 , -1] Coordinate y: [-1, -1, 1, 1] arctan2 valori: [-135 . -45. 45. 135.] 

Codice n. 2: lavoro

# Programma Python3 che mostra
# arctan2 () funzioni

 

import numpy come 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 )

Output:

a: [0. 3.14159265 0.78539816] b: [1.57079633 -1.57079633] 

Collegamenti:
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