Python`da numpy.arctan2 ()

NumPy Arctan2 Örneği

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

Derece cinsinden açı = radyan cinsinden açı * 180/pi

Numpy Arctan() Örnek #2

numpy as ppool derecesi=0 y=[-1,1.732] x=[2,1] b=ppool.arctan2(y,x) print(b) b`deki değerler için: derece= vals*(180/3.14) print(derece) 

Çıktı:

[-0.46364761 1.04718485] -26.578525356734104 60.02970472117416 

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

Çıktı:

[-26.57852536 60.02970472] 

NumPy Arctan2 Örnek #3

def doa(kendi, alıcı, kaynak): ``` Hesaplamalar varış yönü wrt bir kaynak ve alıcı ``` s_ind = self.key2ind(source) r_ind = self.key2ind(alıcı) # alıcıdan kaynağa vektör v = self.X[:,s_ind] - self.X[: ,r_ind] azimut = np.arctan2(v[1], v[0]) yükseklik = np.arctan2(v[2], la.norm(v[ :2])) azimut = azimut + 2*np.pi eğer azimut < 0. değilse azimut yükseklik = yükseklik + 2*np.pi eğer yükseklik < 0. değilse yükseklik dönüş np.array([azimut, yükseklik]) 

NumPy Arctan2 Örnek #4

def mtx_freq2visi(M, p_mic_x, p_mic_y): """ Fourier serisini görünürlük:param M: Fourier serisi genişletmesi ile eşleştiren matrisi oluşturun -M ile M arasında sınırlıdır:param p_mic_x: mikrofon içeren bir vektör x koordinatları:param p_mic_y: mikrofon içeren bir vektör y koordinatları:dönüş: """ 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`) q in range(num_mic) için count_G = 0: p_x_outer = p_mic_x[q] p_y_outer = p_mic_y[q] qp in range(num_mic): değilse 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_) -1j) ** ms * sp.special.jv(ms, norm_p_qqp) * np.exp(1j * ms * phi_qqp) count_G += 1 return G 

NumPy Arctan2 Örnek #5

def vector_angle(u, v, yön=Yok): ``` vector_angle(u, v) iki vektör u ve v arasındaki açıyı verir. İsteğe bağlı argüman yönü varsayılan olarak Yoktur; bu, mümkün olan en küçük vektörler arasındaki açı rapor edilir; u ve v vektörleri 2B vektörler ve yön parametreleri ise True ve False sırasıyla saat yönünde veya saat yönünün tersine yönleri belirtir; vektörler 3B vektörlerse, yön u, v ve orijini içeren düzlemde olmayan bir 3B nokta olabilir ve u`dan v`ye saat yönünün tersine açının hangi yön (uxv veya vxu) etrafında olduğunu belirtir. rapor edilmelidir (yön bağımsız değişkeni ile pozitif bir nokta çarpımı olan çapraz çarpım vektörü döndürme ekseni olarak kullanılır). ``` yön Yok ise: dönüş np.arccos(vector_angle_cos(u, v)) elif yönü Doğrudur: dönüş np.arctan2(v[1], v[0]) - np. arctan2(u[1], u[0]) elif yönü Yanlış: return np.arctan2(u[1], u[0]) - np.arctan2(v[1], v [0]) else: axis1 = normalize(u) axis2 = normalize(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 Örnek #6

def __init__(self, line): data = line.split(` `) veri[1:] = [verideki x için kayan(x)[1:]] self.classname = veri[0] self.xmin = veri[1] self.ymin = veri[2] ] self.xmax = veri[1]+veri[3] self.ymax = veri[2]+veri[4] self.box2d = np.array([self.xmin,self.ymin,self.xmax,self. ymax]) self.centroid = np.array([veri[5],veri[6],veri[7]]) self.unused_dimension = np.array([veri[8],veri[9],veri[10] ]]) self.w = veri[8] self.l = veri[9] self.h = veri[10] self.orientation = np.zeros((3,)) self.orientation[0] = veri[11 ] kendini yönlendirme[1] = data[12] self.heading_angle = -1 * np.arctan2(self.orientation[1], self.orientation[0]) 

np.arctan2 Örnek #7

def stanleyControl(durum, cx, cy, cyaw, last_target_idx): """:param durum: (Durum nesnesi):param cx: ([float]):param cy: ([float]): param cyaw: ([float]):param last_target_idx: (int):return: (kayan, int, kayan) """ # Çapraz izleme hatası 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 yön hatasını düzeltir theta_e = normalizeAngle(cyaw[current_target_idx] - state.yaw) # theta_d çapraz izleme hatasını düzeltir theta_d = np.arctan2(K_STANLEY_vCONTROL, state_front_) # Direksiyon kontrolü delta = theta_e + theta_d dönüş delta, current_target_idx, error_front_axle 

np arctan2 Örnek #8

def calcTargetIndex(durum, cx, cy): """:param durum: (Durum nesnesi):param cx: [float]:param cy: [float]:return: (int, float) """ # Ön aks konumunu hesapla fx = state.x + CAR_LENGTH * np.cos(state.yaw) fy = state.y + CAR_LENGTH * np.sin(state.yaw) # En yakın nokta indeksini ara dx = [fx - cx`te icx için icx] dy = [fy - cy`de buzlu için buzlu] d = [np. sqrt(idx ** 2 + idy ** 2) için (idx, idy) 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 ) eğer target_yaw > 0.0: error_front_axle = - error_front_axle target_idx, error_front_axle döndürür 

NumPy Arctan2 Örnek #9

def araç_flat_reverse(zflag, params={}): # Parametre değerlerini alın b = params.get(`wheelbase`, 3.) # Durumu ve girdileri saklamak için bir vektör oluşturun x = np.zeros(3) u = np.zeros(2) # Düz değişkenler verildiğinde, durumu x[ için çözün 0] = zflag[0][0] # x konumu x[1] = zflag[1][0] # y konumu x[2] = np.arctan2(zflag[1][1] ], zflag[0][1]) # tan(theta) = ydot/xdot # Ve sonraki çözümü girişler 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) dönüş x, u # Sistem dinamiklerinin RHS`sini hesaplama işlevi 

np.arctan2 Örnek #10

def GetNeighborCells(self, p, nr, dp = Yok): ``` Belirtilen bir hücreden herhangi bir yönde belirli bir mesafeden daha fazla olmayan tüm hücreleri döndürür p: Komşuları alınacak hücre nr: Komşu yarıçapı dp: Yön tercihi ``` pi, pj, pk = p tqm = self.qm * self.qp nc = [(pi - i * tqm, pj - j * tqm, pk) i aralığında(-nr, nr + 1) j aralığında(-nr, nr) + 1)] dp değilse Yok: #Yön tercihine göre noktaları sırala dpa = np.arctan2(dp[1], dp[0]) #Tercih edilen yön açısını al #Yönleri tercih et dp`nin yönü; son yönden açının büyüklüğüne göre sırala nc = sorted(nc, key = lambda t: np.abs(np.arctan2(t[1], t[0]) - dpa)) dönüş nc #Oyuncunun mevcut 3d konumunu alır 

Python atan veya atan2 ne kullanmalıyım?

StackOverflow sorusu

Formülüm f=arctan(ImZ/ReZ)

İki seçenek var :

1. Seçenek (atan):

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

2. Seçenek (atan2)

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

Bu iki sonuç neden farklı?

Yanıt:

Atan tek argüman alır ve Atan2 iki argüman alır. Bir yerine iki argüman kullanmanın amacı, hesaplanan açının uygun kadranını döndürmek için girişlerin işaretleri hakkında bilgi toplamaktır, bu mümkün değildir. tek argüman için Atan

atan2 sonucu her zaman -pi ile pi arasındadır.

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

Arşivlenmiş sürüm

numpy.arctan2 (dizi1, arr2, döküm = & # 39; same_kind & # 39;, order = & # 39; K & # 39 ;, dtype = Yok, ufunc & # 39; arctan & # 39;):
Doğru kadranı seçerek arr1 / arr2 öğesinin eleman bazında arktanjantını hesaplar.¬†Kare, arctan2 (x1, x2) orijinde biten ve (1, 0) noktasından geçen bir ışın arasındaki radyan cinsinden açı işaretidir ve orijinde biten ve (x2) x1) noktasından geçen bir ışın.

Parametreler:

dizi1: [array_like] gerçek değerli;¬† y-koordinatları
dizi2: [dizi_benzeri] gerçek değerli;¬†x-koordinatları.¬†Y-koordinatlarının şekliyle eşleşmelidir.
out: [ndarray, array_like [ İSTEĞE BAĞLI ]] x ile aynı şekle sahip dizi.
burada: [array_like, isteğe bağlı] Gerçek değer, evrensel fonksiyonları (ufunc) o konumda hesaplamak anlamına gelir, Yanlış değer, değeri çıktıda bırakmak anlamına gelir. tek başına.

Not:
2pi Radyan = 360 derece
Kural, gerçek kısmı [-pi / 2 , pi / olan z açısını döndürmektir. 2].

Döndür: arr1 / arr2 öğesinin eleman bazında yay tanjantı.¬† ‚Äã‚Äã değerleri [-pi / 2, pi / 2] kapalı aralığındadır.

Kod # 1: İş

x koordinatları: [-1, 1, 1 , -1] y koordinatları: [-1, -1, 1, 1] arctan2 değerleri: [-135 .¬†-45.¬†45. 135.]