numpy.arctan2() in Python

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

Syntaxis

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

Parameters
x1 array_like, reële waarde

y-coördinaten.

x2 array_like, reële waarde

x-coördinaten. Als x1.shape != x2. shape , moeten ze kunnen worden uitgezonden naar een gemeenschappelijke vorm (die de vorm van de uitvoer wordt).

out ndarray, None, of tuple van ndarray en None, optioneel

Een locatie waarin het resultaat wordt opgeslagen. Indien aanwezig, moet het een vorm hebben waarnaar de ingangen worden uitgezonden. Indien niet opgegeven of Geen, wordt een nieuw toegewezen array geretourneerd. Een tuple (alleen mogelijk als trefwoordargument) moet een lengte hebben die gelijk is aan het aantal outputs.

waar array_like, optioneel

Deze voorwaarde wordt uitgezonden via de invoer. Op locaties waar de voorwaarde True is, wordt de array out ingesteld op het ufunc-resultaat. Elders behoudt de array out zijn oorspronkelijke waarde. Merk op dat als een niet-geïnitialiseerde out-array wordt gemaakt via de standaard out=None, locaties daarbinnen waar de voorwaarde False is, blijven niet geïnitialiseerd.

**kwargs

Zie de ufunc docs voor andere argumenten die alleen voor zoekwoorden gelden. .

Retouren
hoek ndarray

Array van hoeken in radialen, in het bereik [-pi, pi]. Dit is een scalaire waarde als zowel x1 als x2 scalaire waarden zijn.

dd>

We zullen NumPy arctan2 behandelen. Daarnaast zullen we voor een beter algemeen begrip ook kijken naar de syntaxis en parameter. Vervolgens zullen we de toepassing van het hele theoretische deel zien aan de hand van enkele voorbeelden. Maar laten we eerst proberen de functie te analyseren aan de hand van zijn definitie. Ten eerste betekent arctan de inverse van een tan-functie. Nu helpt de functie NumPy arctan2 ons om de arc tan-waarde tussen X1 en X2 in radialen te berekenen. Hier zijn X1 en 2 parameters die we later zullen bespreken. Naarmate we verder komen in dit artikel, zullen dingen duidelijker voor je worden. Laten we vervolgens eens kijken naar de bijbehorende syntaxis.
De methode numpy.arctan2() berekent de elementgewijze arctangens van arr1 / arr2 en selecteert het kwadrant correct. Het kwadrant is zo gekozen dat arctan2(x1, x2) de getekende hoek in radialen is tussen de straal die eindigt bij de oorsprong en door punt (1, 0) gaat en de straal die eindigt bij de oorsprong en door punt (x2, x1) gaat.
Arctan2 is een inverse functie van 4 kwadranten. Hiermee rekening houdend, geeft het een waarde tussen 0 en 2pi. Het bereik van deze functie is -180 tot 180 graden. Dit zijn de 2 belangrijkste punten die Arctan2 onderscheiden van arctan-kenmerken.

Verschil tussen Arctan en Arctan2

In deze sectie zullen we het verschil tussen 2 Numpy-functies bespreken.

< td>arctan is een inverse functie van 2 kwadranten.
NumPy arctan< /td>NumPy arctan2
arctan2 is een inverse functie van 4 kwadranten.
Het bereik van de functie arctan loopt van -90 tot 90 graden.Het bereik voor arctan2 is -180 tot 180 graden.
Deze functie accepteert een enkele array.Dit functie zoals besproken, neem 2 invoerarrays.
Nu zijn we klaar met het theoretische gedeelte voor NumPy arctan2. In dit gedeelte wordt onderzocht hoe deze functie werkt en hoe deze ons helpt de gewenste uitvoer te krijgen. We beginnen met een elementair voorbeeld en gaan geleidelijk over naar een ingewikkelder voorbeeld.

NumPy Arctan2 Voorbeeld

importeer numpy als ppool y=[1,1] x=[1,1.732] print(ppool.arctan2(y,x)) [0.78539816 0.52361148] 
Hierboven zien we een eenvoudig voorbeeld van onze arctan2-functie. Laten we nu regel voor regel lopen en begrijpen hoe we aan het resultaat zijn gekomen. Eerst hebben we de NumPy-functie geïmporteerd. Vervolgens hebben we onze 2 sets van de array gedefinieerd. Door de syntaxis van onze functie en het printstatement te gebruiken, krijgen we het gewenste resultaat. Hier worden beide waarden ‚Äã‚Äã gegeven in radialen. Nu als u het resultaat tot op zekere hoogte wilt controleren. Om dit te doen, moeten we deze specifieke methode gebruiken:
Hoek in graden = hoek in radiaal * 180/pi

Als we berekeningen maken op onze resultaten, krijgen we een 45 en 30 -graad antwoord. Hier beschouwden we pi tot 3.14. De antwoorden komen overeen en daarom wordt het resultaat geverifieerd.

Numpy Arctan() Voorbeeld #2

Stel nu dat we ook de waarden ‚Äã‚Äãin graden willen verkrijgen. Het is een eenvoudig proces en kan worden gedaan met behulp van de for-lus en de hierboven besproken formule. Laten we eens kijken hoe:
numpy importeren als ppool degree=0 y=[-1,1.732] x=[2,1] b=ppool.arctan2(y,x) print(b) voor vals in b: degree= vals*(180/3.14) print(graden) 

Uitvoer:

[-0.46364761 1.04718485] -26.578525356734104 60.02970472117416 
Kijk hoe we de waarden ‚Äã‚Äãin radialen krijgen en graden. Alle stappen zijn vergelijkbaar met het eerste voorbeeld. Het enige verschil dat we een "for loop" gebruikten. Als je iets eenvoudiger wilt, kunnen we ook een andere methode gebruiken
import numpy als ppool y=[-1,1.732] x=[2,1] b=ppool.arctan2(y,x)*(180/3.14) print (b) 
Hier hoef je alleen de waarde (180 / 3.14) of (180 / ppool.pi) te vermenigvuldigen met de array. Je kunt deze methode zeker gebruiken op de for loop-methode. Maar hoe dan ook, u krijgt de gewenste uitvoer, wat een graadwaarde is.

Uitvoer:

[-26.57852536 60.02970472] 

NumPy Arctan2 Voorbeeld #3

def doa(self, receiver, source): ``` Berekent de richting van aankomst tov een bron en ontvanger ``` s_ind = self.key2ind(source) r_ind = self.key2ind(receiver) # vector from receiver to source v = self.X[:,s_ind] - self.X[: ,r_ind] azimuth = np.arctan2(v[1], v[0]) hoogte = np.arctan2(v[2], la.norm(v[ :2])) azimut = azimut + 2*np.pi als azimut < 0. else azimut hoogte = hoogte + 2*np.pi als hoogte < 0. else hoogte return np.array([azimut, hoogte]) 

NumPy Arctan2 Voorbeeld #4

def mtx_freq2visi(M, p_mic_x, p_mic_y): """ bouw de matrix die de Fourier-reeks toewijst aan de zichtbaarheid:param M: de uitbreiding van de Fourier-reeks is beperkt van -M tot M:param p_mic_x: een vector die microfoons x coördinaten bevat:param p_mic_y: een vector die microfoons y-coördinaten bevat:return: """ num_mic = p_mic_x.size ms = np.reshape(np.arange(- m , M + 1, stap=1), (1, -1), order=`F`) G = np.zeros((num_mic * (num_mic - 1), 2 * M + 1), dtype=complex, order =`C`) count_G = 0 voor q in bereik (num_mic): p_x_outer = p_mic_x[q] p_y_outer = p_mic_y[q] voor qp in bereik (num_mic): zo niet 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_qqqp, p_x_qqp) -1j) ** ms * sp.special.jv(ms, norm_p_qqp) * np.exp(1j * ms * phi_qqp) count_G += 1 return G 

NumPy Arctan2 Voorbeeld #5

def vector_angle(u, v, direction=None): ``` vector_angle(u, v) geeft de hoek tussen de twee vectoren u en v. De optionele argumentrichting is standaard None, wat aangeeft dat de kleinst mogelijke hoek tussen de vectoren worden gerapporteerd; als de vectoren u en v 2D-vectoren zijn en richtingsparameters True en False specificeren respectievelijk de richtingen met de klok mee of tegen de klok in; als de vectoren 3D-vectoren zijn, dan kan de richting een 3D-punt zijn dat zich niet in het vlak bevindt dat u, v en de oorsprong bevat, en het specificeert rond welke richting (uxv of vxu) de hoek tegen de klok in van u naar v moet worden gerapporteerd (de uitwendige productvector met een positief puntproduct met het richtingsargument wordt gebruikt als de rotatie-as). ``` als richting Geen is: retourneer np.arccos(vector_angle_cos(u, v)) elif richting is Waar: retourneer np.arctan2(v[1], v[0]) - np. arctan2(u[1], u[0]) elif-richting is onwaar: return np.arctan2(u[1], u[0]) - np.arctan2(v[1], v [0]) else: axis1 = normaliseren(u) axis2 = normaliseren(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 Voorbeeld #6

def __init__(self, line): data = line.split(` `) data[1:] = [float(x) voor 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 ]]) zelf.w = data[8] zelf.l = data[9] zelf.h = data[10] zelf.oriëntatie = np.nullen((3,)) zelf.oriëntatie[0] = data[11 ] zelf.oriëntatie[1] = data[12] self.heading_angle = -1 * np.arctan2(self.orientation[1], self.orientation[0]) 

np.arctan2 Voorbeeld #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) """ # Cross track-fout 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 corrigeert de kopfout theta_e = normalizeAngle(cyaw[current_target_idx] - state.yaw) # theta_d corrigeert de cross track-fout 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 Voorbeeld #8

def calcTargetIndex(state, cx, cy): """:param state: (Status object):param cx: [float]:param cy: [float]:return: (int, float) """ # Calc vooraspositie fx = state.x + CAR_LENGTH * np.cos(state.yaw) fy = state.y + CAR_LENGTH * np.sin(state.yaw) # Zoek dichtstbijzijnde puntindex dx = [fx - icx voor icx in cx] dy = [fy - ijzig voor ijzig in cy] d = [np. sqrt(idx ** 2 + idy ** 2) voor (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 Voorbeeld #9

def vehicle_flat_reverse(zflag, params={}): # Haal de parameterwaarden b = params.get(`wheelbase`, 3.) # Maak een vector om de toestand en invoer op te slaan x = np.zeros(3) u = np.zeros(2) # Los, gegeven de vlakke variabelen, de toestand x[ op 0] = zflag[0][0] # x positie x[1] = zflag[1][0] # y positie x[2] = np.arctan2(zflag[1][1 ], zflag[0][1]) # tan(theta) = ydot/xdot # En los vervolgens op voor de ingangen 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 # Functie om de RHS van de systeemdynamiek te berekenen 

np.arctan2 Voorbeeld #10

def GetNeighborCells(self, p, nr, dp = Geen): ``` Retourneert alle cellen niet meer dan een bepaalde afstand in elke richting vanaf een gespecificeerde cel p: De cel waarvan de buren moeten worden verkregen nr: Buurstraal dp: Richtingvoorkeur ``` pi, pj, pk = p tqm = zelf.qm * zelf.qp nc = [(pi - i * tqm, pj - j * tqm, pk) voor i binnen bereik(-nr, nr + 1) voor j binnen bereik(-nr, nr + 1)] als dp niet Geen is: #Sorteer punten op basis van richtingvoorkeur dpa = np.arctan2(dp[1], dp[0]) #Krijg voorkeurshoek #Voorkeur richtingen in de richting van dp; sorteer op basis van de grootte van de hoek vanuit de laatste richting nc = gesorteerd(nc, key = lambda t: np.abs(np.arctan2(t[1], t[0]) - dpa)) return nc #Krijgt de huidige 3D-positie van de speler 
In dit artikel behandelen we NumPy`s arctan2. Daarnaast hebben we ook de syntaxis en parameters ervan gezien. Voor een beter begrip hebben we enkele voorbeelden gezien. Uiteindelijk kunnen we concluderen dat NumPy arctan2 een functie is dat deze functie ons helpt om de inverse tan-waarde tussen 2 punten te vinden. Standaard retourneert het de waarde in radialen, maar we kunnen het converteren naar graden met behulp van de hierboven besproken methoden. We hopen dat dit artikel al uw twijfels heeft weggenomen. Maar als u nog onopgeloste vragen heeft, kunt u deze opschrijven in het opmerkingengedeelte. Na dat gelezen te hebben, waarom leest u dan niet over de volgende identiteitsmatrix.

Python atan of atan2, wat moet ik gebruiken?

StackOverflow-vraag

Mijn formule f=arctan(ImZ/ReZ)

Er zijn twee opties :

Optie 1 (atan):

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

Optie 2 (atan2)

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

Waarom zijn deze twee resultaten verschillend?

Antwoord:

Atan neemt één argument en Atan2 neemt twee argumenten. Het doel van het gebruik van twee argumenten in plaats van één is om informatie te verzamelen over de tekens van de invoer om het juiste kwadrant van de berekende hoek te retourneren, wat niet mogelijk is voor het enkelvoudige argument Atan

atan2 resultaten voor elke x,y

Atan2 resultaat ligt altijd tussen -pi en pi.

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

Gearchiveerde versie

numpy.arctan2 (arr1, arr2, gieten = & # 39; same_kind & # 39 ;, order = & # 39; K & # 39 ;, dtype = Geen, ufunc & # 39; arctan & # 39;):
Berekent de elementgewijze arctangens van arr1 / arr2 door het juiste kwadrant te kiezen. Het kwadrant is zo gekozen dat arctan2 (x1, x2) is het hoekteken in radialen tussen een straal die eindigt bij de oorsprong en door punt (1, 0) gaat en een straal die eindigt bij de oorsprong en door punt (x2) x1) gaat.

Parameters:

arr1: [array_like] echte waarde;¬† y-coördinaten
arr2: [array_like] echte waarde;¬†x-coördinaten.¬†Het moet overeenkomen met de vorm van de y-coördinaten.
out: [ndarray, array_like [OPTIONEEL ]] array met dezelfde vorm als x .
waarbij: [array_like, optional] True value betekent om de universele functies (ufunc) op die positie te berekenen, False value betekent dat de waarde in de uitvoer blijft staan alleen.

Opmerking:
2pi Radialen = 360 graden
De conventie is om de hoek z terug te geven waarvan het reële deel in [-pi / 2 , pi / 2].

Return: Elementgewijze boogtangens van arr1 / arr2. De waarden ​​zijn in het gesloten interval [-pi / 2, pi / 2].

Code #1: Werk

# Python3-programma met uitleg
# arctan2 () functie

 

import numpy als np

 

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

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

  

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

 

print ( "x- coördinaten:" , arr1)

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

  

print ( "arctan2 waarden:" , ans )

Uitvoer:

x-coördinaten: [-1, 1, 1 , -1] y-coördinaten: [-1, -1, 1, 1] arctan2 waarden: [-135 .¬†-45.¬†45. 135.] 

Code #2: Werk

# Python3-programma toont
# arctan2 () functies

 

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 )

Uitvoer:

< voor>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