numpy.arctan2() w Pythonie

Przykład NumPy Arctan2

import numpy jako ppool y=[1,1] x=[1,1.732] print(ppool.arctan2(y,x)) [0.78539816 0.52361148] 

Kąt w stopniach = kąt w radianach * 180/pi

Numpy Arctan() Przykład nr 2

importuj numpy jako 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(stopień) 

Wyjście:

[-0.46364761 1.04718485] -26.578525356734104 60.02970472117416 

import numpy jako ppool y=[-1,1.732] x=[2,1] b=ppool.arctan2(y,x)*(180/3.14) print (b) 

Wyjście:

[-26.57852536 60.02970472] 

NumPy Arctan2 Przykład #3

def doa(self, receiver, source): ``` Oblicza kierunek nadejścia do źródła i odbiornika ``` s_ind = self.key2ind(źródło) r_ind = self.key2ind(odbiorca) # wektor od odbiornika do źródła v = self.X[:,s_ind] - self.X[: ,r_ind] azymut = np.arctan2(v[1], v[0]) elewacja = np.arctan2(v[2], la.norm(v[ :2])) azymut = azymut + 2*np.pi jeśli azymut < 0. w przeciwnym razie elewacja azymut = elewacja + 2*np.pi jeśli elewacja < 0. else elewacja return np.array([azymut, elewacja]) 

NumPy Arctan2 Przykład #4

def mtx_freq2visi(M, p_mic_x, p_mic_y): """ zbuduj macierz, która odwzorowuje szereg Fouriera na widzialność:param M: rozwinięcie szeregu Fouriera jest ograniczone od -M do M:param p_mic_x: wektor zawierający mikrofony x coordinates:param p_mic_y: wektor zawierający mikrofony y coordinate: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 dla q w zakresie(num_mic): p_x_outer = p_mic_x[q] p_y_outer = p_mic_y[q] dla qp w zakresie(num_mic): jeśli nie 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_q_qp,] G -1j) ** ms * sp.special.jv(ms, norm_p_qqp) * np.exp(1j * ms * phi_qqp) count_G += 1 return G 

NumPy Arctan2 Przykład #5

def vector_angle(u, v, direction=None): ``` vector_angle(u, v) zwraca kąt między dwoma wektorami u i v. Opcjonalnym argumentem kierunku jest domyślnie None, co określa najmniejszy możliwy należy podać kąt między wektorami; jeśli wektory u i v są wektorami 2D, a parametry kierunku Prawda i Fałsz określają odpowiednio kierunek zgodny lub przeciwny do ruchu wskazówek zegara; jeśli wektory są wektorami 3D, to kierunek może być punktem 3D, który nie znajduje się na płaszczyźnie zawierającej u, v i początek i określa, wokół którego kierunku (uxv lub vxu) kąt przeciwny do ruchu wskazówek zegara od u do v należy zgłosić (wektor iloczynu krzyżowego, który ma dodatni iloczyn skalarny z argumentem kierunku jest używany jako oś obrotu). ``` jeśli kierunek to Brak: return np.arccos(vector_angle_cos(u, v)) kierunek elif to True: return np.arctan2(v[1], v[0]) - np. arctan2(u[1], u[0]) kierunek elif to False: return np.arctan2(u[1], u[0]) - np.arctan2(v[1], v [0]) else: oś1 = normalize(u) oś2 = normalize(np.cross(u, v)) if np.dot(oś2, kierunek) < 0: oś2 = -oś2 return np.arctan2(np.dot(oś2, v), np.dot(oś1, v)) 

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 = dane[1]+dane[3] self.ymax = dane[2]+dane[4] self.box2d = np.array([self.xmin,self.ymin,self.xmax,self. ymax]) self.centroid = np. tablica([dane[5],dane[6],dane[7]]) self.unused_dimension = np.array([dane[8],dane[9],dane[10 ]]) self.w = dane[8] self.l = dane[9] self.h = dane[10] self.orientation = np.zeros((3,)) self.orientation[0] = data[11 ] samo.orientacja[1] = data[12] self.heading_angle = -1 * np.arctan2(self.orientation[1], self.orientation[0]) 

def stanleyControl(state, cx, cy, cyaw, last_target_idx): """:param state: (obiekt stanu):param cx: ([float]):param cy: ([float]): param cyaw: ([float]):param last_target_idx: (int):return: (float, int, float) """ # Błąd śledzenia 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 koryguje błąd nagłówka theta_e = normalizeAngle(cyaw[current_target_idx] - state.yaw) # theta_d koryguje błąd cross track theta_d = np.arctan2(K_STANLEY_CONTROL * error_front_axle, # delta kontroli sterowania = theta_e + theta_d delta powrotu, current_target_idx, error_front_axle 

def calcTargetIndex(state, cx, cy): """:param state: (obiekt stanu):param cx: [zmiennoprzecinkowa]:param cy: [zmiennoprzecinkowa]:zwrot: (int, float) """ # Oblicz położenie przedniej osi fx = state.x + CAR_LENGTH * np.cos(state.yaw) fy = state.y + CAR_LENGTH * np.sin(state.yaw) # Wyszukaj indeks najbliższego punktu dx = [fx - icx dla icx w cx] dy = [fy - icy dla icy w cy] d = [np. sqrt(idx ** 2 + idy ** 2) for (idx, idy) w 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 

def vehicle_flat_reverse(zflag, params={}): # Pobierz wartości parametrów b = params.get(`rozstaw osi`, 3.) # Utwórz wektor do przechowywania stanu i danych wejściowych x = np.zeros(3) u = np.zeros(2) # Biorąc pod uwagę płaskie zmienne, znajdź stan x[ 0] = zflag[0][0] # x pozycja x[1] = zflag[1][0] # y pozycja x[2] = np.arctan2(zflag[1][1 ], zflag[0][1]) # tan(theta) = ydot/xdot # A następnie rozwiąż dla wejścia 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 # Funkcja obliczania RHS dynamiki systemu 

np.arctan2 Przykład #10

def GetNeighborCells(self, p, nr, dp = Brak): ``` Zwraca wszystkie komórki nie większe niż podana odległość w dowolnym kierunku od określonej komórki p: Komórka, z której mają zostać pobrane sąsiedzi nr: Promień sąsiada dp: Preferencja kierunku ``` pi, pj, pk = p tqm = self.qm * self.qp nc = [(pi - i * tqm, pj - j * tqm, pk) dla i w przedziale(-nr, nr + 1) dla j w przedziale(-nr, nr + 1)] jeśli dp nie jest Brak: #Sortuj punkty na podstawie preferencji kierunku dpa = np.arctan2(dp[1], dp[0]) #Uzyskaj preferowany kąt kierunku #Preferuj kierunki w kierunek dp; sortuj na podstawie wielkości kąta od ostatniego kierunku nc = sorted(nc, key = lambda t: np.abs(np.arctan2(t[1], t[0]) - dpa)) return nc #Pobiera aktualną pozycję 3D gracza 

Python atan czy atan2, czego mam użyć?

Pytanie StackOverflow

Moja formuła f=arctan(ImZ/ReZ)

Są dwie opcje :

Opcja 1 (atan):

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

Opcja 2 (atan2)

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

Dlaczego te dwa wyniki są różne?

Odpowiedź:

Atan przyjmuje jeden argument, a Atan2 dwa argumenty. Celem użycia dwóch argumentów zamiast jednego jest zebranie informacji o znakach wejść w celu zwrócenia odpowiedniej ćwiartki obliczonego kąta, co nie jest możliwe dla jednoargumentowego Atana

Wynik Atan2 jest zawsze pomiędzy -pi i pi.

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

Wersja zarchiwizowana

numpy.arctan2 (arr1, arr2, rzutowanie = & # 39; same_rodzaj & # 39 ;, kolejność = & # 39; K & # 39 ;, dtype = Brak, ufunc & # 39; arctan & # 39;):
Oblicza arcus tangens elementu arr1 / arr2 przez wybranie właściwego kwadrantu.¬†Kwadrant jest tak wybrany, że arctan2 (x1, x2) to znak kąta w radianach między promieniem kończącym się w punkcie początkowym i przechodzącym przez punkt (1, 0) i promień kończący się na początku i przechodzący przez punkt (x2) x1).

Parametry:

arr1: [array_like] rzeczywista wartość;¬† Współrzędne y
arr2: [tablica_podobna] wartość rzeczywista;¬†współrzędne-x.¬†Musi odpowiadać kształtowi współrzędnych y.
out: [ndarray, array_like [ OPCJONALNIE ]] tablica o takim samym kształcie jak x .
gdzie: [tablica_podobna, opcjonalna] Prawdziwa wartość oznacza obliczenie funkcji uniwersalnych (ufunc) na tej pozycji, Fałszywa wartość oznacza pozostawienie wartości na wyjściu sam.

Uwaga:
2pi Radiany = 360 stopni
Konwencją jest zwrócenie kąta z, którego część rzeczywista leży w [-pi / 2 , pi / 2].

Zwrot: tangens łuku elementu przy arr1 / przyp2.¬†Wartości „Ęã‚Ęãsą w przedziale domkniętym [-pi/2, pi/2].

Kod nr 1: Praca

współrzędne x: [-1, 1, 1 , -1] współrzędne y: [-1, -1, 1, 1] arctan2 wartości: [-135 .¬†-45.¬†45. 135.] 

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