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.
- où 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 deArctan2 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.arr1/arr2et sélectionne correctement le quadrant. Le quadrant est choisi de sorte quearctan2(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).
Différence entre Arctan et Arctan2
Dans cette section, nous discuterons de la différence entre 2 fonctions Numpy.| 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 Arctan2import 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 #2Supposons 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.02970472117416Voyez 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 #3def 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 = NumPy Arctan2 Example #4def 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 = NumPy Arctan2 Example #5def 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 NumPy Arctan2 Example #6def __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 Exemple #7def 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 Exemple #8def 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( NumPy Arctan2 Example #9def 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 Exemple #10def 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 =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 StackOverflowMa formule f=arctan(ImZ/ReZ) Il y a deux options : Option 1 (atan) : Option 2 (atan2) 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
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;):
Code #1 : Travail
|
