numpy.arctan2() en Python

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

Syntaxe

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

Paramètres
x1 array_like, à valeur réelle

y-coordinates.

x2 array_like, à valeur réelle

x. Si x1.shape != x2. shape , ils doivent pouvoir être diffusés dans une forme commune (qui devient la forme de la sortie).

out ndarray, Aucun, ou tuple de ndarray et Aucun, facultatif

Un emplacement dans lequel le résultat est stocké. S`il est fourni, il doit avoir une forme à laquelle les entrées sont diffusées. Si non fourni ou None, un tableau fraîchement alloué est renvoyé. Un tuple (possible uniquement en tant qu`argument de mot-clé) doit avoir une longueur égale au nombre de sorties.

array_like, facultatif

Cette condition est diffusée sur l`entrée. Aux emplacements où la condition est vraie, le tableau out sera défini sur le résultat ufunc. Ailleurs, le tableau out conservera sa valeur d`origine. Notez que si un tableau out non initialisé est créé via le out=None, les emplacements où la condition est False resteront non initialisés.

**kwargs

Pour d`autres arguments de mots clés uniquement, consultez la documentation ufunc .

Rends
angle ndarray

Tableau d`angles en radians, dans la plage [-pi, pi]. Il s`agit d`un scalaire si x1 et x2 sont des scalaires.


Nous couvrirons NumPy arctan2. Parallèlement à cela, pour une meilleure compréhension générale, nous examinerons également sa syntaxe et ses paramètres. Ensuite, nous verrons l`application de toute la partie théorique à travers quelques exemples. Mais d`abord, essayons d`analyser la fonction à travers sa définition. Premièrement, arctan signifie l`inverse d`une fonction tan. Maintenant, la fonction NumPy arctan2 nous aide à calculer la valeur d`arc tan entre X1 et X2 en radians. Ici, X1 et 2 sont des paramètres dont nous parlerons plus tard. Au fur et à mesure que nous progressons dans cet article, les choses deviendront plus claires pour vous. Ensuite, regardons la syntaxe qui lui est associée.
La méthode numpy.arctan2() calcule l`arctangente élément par élément de arr1 / arr2 et sélectionne correctement le quadrant. Le quadrant est choisi de sorte que arctan2(x1, x2) soit l`angle signé en radians entre le rayon se terminant à l`origine et passant par le point (1, 0) et le rayon se terminant à l`origine et passant par le point (x2, x1).
Arctan2 est une fonction inverse à 4 quadrants. En tenant compte de cela, cela donne une valeur comprise entre 0 et 2pi. La plage de cette fonction est de -180 à 180 degrés. Ce sont les 2 points clés qui distinguent Arctan2 des fonctionnalités arctan.

Différence entre Arctan et Arctan2

Dans cette section, nous discuterons de la différence entre 2 fonctions Numpy.

< td>arctan est une fonction inverse à 2 quadrants.
NumPy arctan< /td>NumPy arctan2
arctan2 est une fonction inverse à 4 quadrants.
La plage de la fonction arctan est de -90 à 90 degrés.La plage pour arctan2 est de -180 à 180 degrés.
Cette fonction accepte un seul tableau.Cette fonction comme discuté prendre 2 tableaux d`entrée.
Nous avons maintenant terminé avec la partie théorique pour NumPy arctan2. Cette section explore le fonctionnement de cette fonctionnalité et comment elle nous aide à obtenir le résultat souhaité. Nous allons commencer par un exemple élémentaire et passer progressivement à un exemple plus compliqué.

Exemple NumPy Arctan2

import numpy as ppool y=[1,1] x=[1,1.732] print(ppool.arctan2(y,x)) [0.78539816 0.52361148] 
Ci-dessus, nous voyons un exemple simple de notre fonction arctan2. Maintenant, marchons ligne par ligne et comprenons comment nous avons obtenu le résultat. Tout d`abord, nous avons importé la fonction NumPy. Ensuite, nous avons défini nos 2 ensembles du tableau. En utilisant la syntaxe de notre fonction et l`instruction print, nous obtenons le résultat souhaité. Ici, les deux valeurs ‚Äã‚Äãsont données en radians. Maintenant, si vous voulez vérifier le résultat dans une certaine mesure. Pour ce faire, nous devons utiliser cette méthode particulière :
Angle en degré = angle en radian * 180/pi

Si nous faisons des calculs sur nos résultats, nous obtenons un 45 et un 30 -réponse degré. Ici, nous avons considéré pi à 3,14. Les réponses correspondent et donc le résultat est vérifié.

Numpy Arctan() Example #2

Supposons maintenant que nous voulions également obtenir les valeurs ‚Äã‚Äãen degrés. C`est un processus simple et peut être fait à l`aide de la boucle for et de la formule décrite ci-dessus. Voyons comment :
import 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) 

Sortie :

[-0.46364761 1.04718485] -26.578525356734104 60.02970472117416 
Voyez comment nous obtenons les valeurs ‚Äã‚Äãen radians et degrés. Toutes les étapes sont similaires au premier exemple. La seule différence, nous avons utilisé une "boucle for". Si vous voulez quelque chose de plus simple, nous pouvons également utiliser une autre méthode
import numpy as ppool y=[-1,1.732] x=[2,1] b=ppool.arctan2(y,x)*(180/3.14) print (b) 
Ici, tout ce que vous avez à faire est de multiplier la valeur (180/3.14) ou (180/ppool.pi) par le tableau. Vous pouvez certainement utiliser cette méthode sur la méthode de la boucle for. Mais dans tous les cas, vous obtiendrez la sortie souhaitée qui est une valeur en degrés.

Sortie :

[-26.57852536 60.02970472] 

NumPy Arctan2 Example #3

def doa(self, receiver, source): ``` Calcule la direction d`arrivée par rapport à une source et un récepteur ``` s_ind = self.key2ind(source) r_ind = self.key2ind(receiver) # vecteur du récepteur à la source v = self.X[:,s_ind] - self.X[: ,r_ind] azimut = np.arctan2(v[1], v[0]) élévation = np.arctan2(v[2], la.norm(v[ :2])) azimut = azimut + 2*np.pi si azimut < 0. sinon azimut élévation = élévation + 2*np.pi si élévation < 0. sinon élévation return np.array([azimut, élévation]) 

NumPy Arctan2 Example #4

def mtx_freq2visi(M, p_mic_x, p_mic_y): """ construit la matrice qui fait correspondre la série de Fourier à la visibilité:param M : l`expansion de la série de Fourier est limité de -M à M:param p_mic_x : un vecteur contenant les coordonnées x des microphones :param p_mic_y : un vecteur contenant les coordonnées y des microphones :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 pour q dans range(num_mic) : p_x_outer = p_mic_x[q] p_y_outer = p_mic_y[q] pour qp dans range(num_mic) : sinon 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 Example #5

def vector_angle(u, v, direction=None) : ``` vector_angle(u, v) donne l`angle entre les deux vecteurs u et v. L`argument optionnel direction est par défaut None, ce qui spécifie que le plus petit possible l`angle entre les vecteurs doit être signalé ; si les vecteurs u et v sont des vecteurs 2D et que les paramètres de direction True et False spécifient respectivement le sens horaire ou anti-horaire ; si les vecteurs sont des vecteurs 3D, alors la direction peut être un point 3D qui n`est pas dans le plan contenant u, v et l`origine, et il spécifie autour de quelle direction (uxv ou vxu) l`angle dans le sens antihoraire de u à v doit être signalé (le vecteur de produit croisé qui a un produit scalaire positif avec l`argument de direction est utilisé comme axe de rotation). ``` si la direction est None : renvoie np.arccos(vector_angle_cos(u, v)) elif direction est True : renvoie np.arctan2(v[1], v[0]) - np. arctan2(u[1], u[0]) elif direction est False : return np.arctan2(u[1], u[0]) - np.arctan2(v[1], v [0]) sinon : axe1 = normaliser(u) axe2 = normaliser(np.cross(u, v)) si np.dot(axe2, direction) < 0 : axe2 = -axis2 return np.arctan2(np.dot(axis2, v), np.dot(axis1, v)) 

NumPy Arctan2 Example #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.orientation[1] = data[12] self.heading_angle = -1 * np.arctan2(self.orientation[1], self.orientation[0]) 

np.arctan2 Exemple #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) """ # Erreur de piste croisée 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 corrige l`erreur de cap theta_e = normalizeAngle(cyaw[current_target_idx] - state.yaw) # theta_d corrige l`erreur de route transversale theta_d = np.arctan2(K_STANLEY_CONTROL * error_front_axle, state.v) # Steering control delta = theta_e + theta_d return delta, current_target_idx, error_front_axle 

np arctan2 Exemple #8

def calcTargetIndex(state, cx, cy): """:param state : (Objet d`état):param cx: [float]:param cy: [float]:return : (int, float) """ # Calculer la position de l`essieu avant fx = state.x + CAR_LENGTH * np.cos(state.yaw) fy = state.y + CAR_LENGTH * np.sin(state.yaw) # Rechercher l`index du point le plus proche dx = [fx - icx pour icx dans cx] dy = [fy - icy pour icy dans cy] d = [np. sqrt(idx ** 2 + idy ** 2) pour (idx, idy) dans 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={}) : # Récupère les valeurs des paramètres b = params.get(`wheelbase`, 3.) # Créer un vecteur pour stocker l`état et les entrées x = np.zeros(3) u = np.zeros(2) # Étant donné les variables plates, résoudre pour l`état x[ 0] = zflag[0][0] # position x x[1] = zflag[1][0] # position y x[2] = np.arctan2(zflag[1][1 ], zflag[0][1]) # tan(theta) = ydot/xdot # Et ensuite résoudre pour les entrées 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 # Fonction pour calculer le RHS de la dynamique du système 

np.arctan2 Exemple #10

def GetNeighborCells(self, p, nr, dp = Aucun) : ``` Renvoie toutes les cellules pas plus qu`une distance donnée dans n`importe quelle direction à partir d`une cellule spécifiée p : La cellule dont obtenir les voisins nr : Rayon du voisin dp : Préférence de direction ``` 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)] si dp n`est pas None : #Trier les points en fonction de la préférence de direction dpa = np.arctan2(dp[1], dp[0]) #Obtenir l`angle de direction préféré #Préférer les directions dans la direction de dp; tri basé sur l`amplitude de l`angle à partir de la dernière direction nc = sorted(nc, key = lambda t : np.abs(np.arctan2(t[1], t[0]) - dpa)) return nc #Obtient la position 3d actuelle du joueur 
Dans cet article, nous couvrons arctan2 de NumPy. De plus, nous avons également vu sa syntaxe et ses paramètres. Pour mieux comprendre, nous avons vu quelques exemples. Au final, nous pouvons conclure que NumPy arctan2 est une fonction que cette fonction nous aide à trouver la valeur tan inverse entre 2 points. Par défaut, il renvoie la valeur en radians, mais nous pouvons la convertir en degrés en utilisant les méthodes décrites ci-dessus. Nous espérons que cet article a clarifié tous vos doutes. Mais au cas où vous auriez des questions non résolues, n`hésitez pas à les écrire dans la section des commentaires. Après avoir lu cela, pourquoi ne pas lire la matrice d`identité suivante.

Python atan ou atan2, que dois-je utiliser ?

Question StackOverflow

Ma formule f=arctan(ImZ/ReZ)

Il y a deux options :

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 

Pourquoi ces deux résultats sont-ils différents ?

Réponse :

Atan prend un seul argument et Atan2 prend deux arguments. Le but d`utiliser deux arguments au lieu d`un est de recueillir des informations sur les signes des entrées afin de renvoyer le quadrant approprié de l`angle calculé, ce qui n`est pas possible pour l`Atan à argument unique

résultats atan2 pour chaque x,y

Le résultat Atan2 est toujours compris entre -pi et pi.

Référence : https://en.wikipedia.org/wiki/Atan2

Version archivée

numpy.arctan2 (arr1, arr2, casting = & # 39; même_type & # 39;, ordre = & # 39; K & # 39 ;, dtype = Aucun, ufunc & # 39 ; arctan & # 39;):
Calcule l`arctangente par élément de arr1 / arr2 en choisissant le bon quadrant.¬†Le quadrant est choisi de sorte que arctan2 (x1, x2) est le signe de l`angle en radians entre un rayon se terminant à l`origine et passant par le point (1, 0) et un rayon se terminant à l`origine et passant par le point (x2) x1).

Paramètres :

arr1 : [array_like] valeur réelle ;¬† coordonnées y
arr2 : [array_like] valeur réelle ;¬†coordonnées x.¬†Elle doit correspondre à la forme des coordonnées y.
out : [ndarray, array_like [ OPTIONAL ]] tableau de même forme que x .
où : [tableau_like, facultatif] La valeur vraie signifie qu`il faut calculer les fonctions universelles (ufunc) à cette position, la valeur fausse signifie qu`il faut laisser la valeur dans la sortie seule.

Remarque :
2pi Radians = 360 degrés
La convention est de renvoyer l`angle z dont la partie réelle se situe dans [-pi / 2 , pi / 2].

Retour : Arc tangente élément par élément de arr1 / arr2.¬†Les valeurs ‚Äã‚Äãsont dans l`intervalle fermé [-pi / 2, pi / 2].

Code #1 : Travail

# Programme Python3 expliquant
# arctan2 () fonction

 

import numpy as np

 

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

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

  

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

 

print ( "x- coordonnées :" , arr1)

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

  

print ( "arctan2 valeurs :" , ans )

Sortie :

Coordonnées x : [-1, 1, 1 , -1] coordonnées y : [-1, -1, 1, 1] arctan2 valeurs : [-135 .¬†-45.¬†45. 135.] 

Code #2 : Travail

# Programme Python3 affichant
# fonctions arctan2 ()

 

import numpy as np

 

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

 

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

 

print ( " a : " , a)

  

print ( "b:" , b )

Sortie :

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

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