numpy.arctan2() पायथन में

NumPy Arctan2 उदाहरण

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

कोण में डिग्री = रेडियन में कोण * 180/pi

Numpy Arctan() उदाहरण #2

ppool Degree=0 y=[-1,1.732] x=[2,1] b=ppool.arctan2(y,x) Print(b) के रूप में numpy आयात करें b: Degree= vals*(180/3.14) प्रिंट (डिग्री) 

आउटपुट:

[-0.46364761 1.04718485] -26.578525356734104 60.02970472117416 

ppool y=[-1,1.732] x=[2,1] b=ppool.arctan2(y,x)*(180/3.14 प्रिंट के रूप में numpy आयात करें) (बी) 

आउटपुट:

[-26.57852536 60.02970472] 

NumPy Arctan2 उदाहरण #3

def doa(self, रिसीवर, source): ``` कंप्यूट्स आगमन की दिशा एक स्रोत और रिसीवर wrt ```` s_ind = self.key2ind(source) r_ind = self.key2ind (रिसीवर) # रिसीवर से स्रोत तक वेक्टर v = self.X[:,s_ind] - self.X[: ,r_ind] azimuth = np.arctan2(v[1], v[0]) उन्नयन = np.arctan2(v[2], la.norm(v[ :2])) azimuth = azimuth + 2*np.pi अगर azimuth <0. और azimuth एलिवेशन = एलिवेशन + 2*np.pi अगर एलिवेशन <0. और एलिवेशन रिटर्न np.array([azimuth, एलीवेशन]) 

NumPy Arctan2 उदाहरण #4

def mtx_freq2visi(M, p_mic_x, p_mic_y): """ दृश्यता के लिए फूरियर श्रृंखला को मैप करने वाले मैट्रिक्स का निर्माण करें:परम एम: फूरियर श्रृंखला विस्तार है -M से M तक सीमित: परम p_mic_x: एक वेक्टर जिसमें माइक्रोफ़ोन होते हैं x निर्देशांक: परम p_mic_y: एक वेक्टर जिसमें माइक्रोफ़ोन y निर्देशांक होते हैं: वापसी: """ num_mic = p_mic_x.size ms = np.reshape(np.arange(-) एम , एम + 1, चरण = 1, (1, -1), आदेश = `एफ`) जी = np.zeros ((num_mic * (num_mic -1), 2 * एम + 1), dtype = जटिल, क्रम =`सी`) काउंट_जी = 0 रेंज में क्यू के लिए (num_mic): p_x_outer = p_mic_x[q] p_y_outer = p_mic_y[q] रेंज में qp के लिए (num_mic): यदि नहीं 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_qq, p_x_qq) = ( -1j) ** ms * sp.special.jv(ms, norm_p_qqp) * np.exp(1j * ms * phi_qqp) count_G += 1 रिटर्न G 

NumPy Arctan2 उदाहरण #5

def वेक्टर_एंगल (यू, वी, दिशा = कोई नहीं): ``` वेक्टर_एंगल (यू, वी) दो वैक्टर यू और वी के बीच कोण उत्पन्न करता है। वैकल्पिक तर्क दिशा डिफ़ॉल्ट रूप से कोई नहीं है, जो निर्दिष्ट करता है कि सबसे छोटा संभव है वैक्टर के बीच के कोण की सूचना दी जानी चाहिए; यदि सदिश u और v 2D सदिश हैं और दिशा पैरामीटर सही और गलत क्रमशः दक्षिणावर्त या वामावर्त दिशाओं को निर्दिष्ट करें; यदि सदिश 3D सदिश हैं, तो दिशा एक 3D बिंदु हो सकती है जो u, v, और मूल वाले तल में नहीं है, और यह निर्दिष्ट करती है कि u से v के विपरीत दिशा (uxv या vxu) किस दिशा में है। रिपोर्ट किया जाना चाहिए (क्रॉस उत्पाद वेक्टर जिसमें दिशा तर्क के साथ एक सकारात्मक डॉट उत्पाद होता है जिसे रोटेशन अक्ष के रूप में उपयोग किया जाता है)। ``` अगर दिशा कोई नहीं है: वापसी np.arccos(vector_angle_cos(u, v)) elif दिशा सही है: वापसी np.arctan2(v[1], v[0]) - np. arctan2(u[1], u[0]) elif दिशा गलत है: वापसी np.arctan2(u[1], u[0]) - np.arctan2(v[1], v [0]) और: अक्ष 1 = सामान्य करें (यू) अक्ष 2 = सामान्य करें (एनपी.क्रॉस (यू, वी)) अगर एनपी.डॉट (अक्ष 2, दिशा) < 0: अक्ष 2 = -अक्ष 2 वापसी <कोड> एनपी.आर्कटन 2  कोड>(np.dot(axis2, v), np.dot(axis1, v)) 

NumPy Arctan2 उदाहरण #6

def __init__(self, line): डेटा = लाइन.स्प्लिट (``) डेटा [1:] = [फ्लोट (एक्स) डेटा में एक्स के लिए [1:]] स्वयं। वर्गनाम = डेटा [0] स्वयं। एक्समिन = डेटा [1] स्वयं.यमिन = डेटा [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 ] स्व.अभिविन्यास[1] = data[12] self.heading_angle = -1 * np.arctan2(self.orientation[1], self.orientation[0]) 

np.arctan2 उदाहरण #7

 def stanleyControl(state, cx, cy, cyaw, last_target_idx): """:param State: (State object):param cx: ([float]):param cy: ([float]): परम साइव: ([फ्लोट]): परम last_target_idx: (int): रिटर्न: (फ्लोट, इंट, फ्लोट) """ # क्रॉस ट्रैक एरर 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 शीर्षक त्रुटि को ठीक करता है theta_e = normalizeAngle(cyaw[current_target_idx] - State.yaw) # theta_d क्रॉस ट्रैक त्रुटि को ठीक करता है theta_d = np.arctan2)(K_STANLEY_CONTROL, State.front. # स्टीयरिंग कंट्रोल डेल्टा = थीटा_ई + थीटा_डी रिटर्न डेल्टा, current_target_idx, error_front_axle 

np arctan2 उदाहरण #8

def calcTargetIndex(state, cx, cy): """:param State: (राज्य वस्तु): परम सीएक्स: [फ्लोट]: परम साइ: [फ्लोट]: वापसी: (इंट, फ्लोट) """ # कैल्क फ्रंट एक्सल स्थिति fx = State.x + CAR_LENGTH * np.cos(state.yaw) fy = State.y + CAR_LENGTH * np.sin(state.yaw) # निकटतम बिंदु सूचकांक खोजें dx = [fx - icx के लिए cx में icx] dy = [fy - cy में बर्फीले के लिए बर्फीला] d = [np. sqrt(idx ** 2 + idy ** 2) ज़िप में (idx, idy) के लिए (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 ) अगर target_yaw > 0.0: error_front_axle = - error_front_axle वापसी target_idx, error_front_axle 

NumPy Arctan2 उदाहरण #9

def Vehicle_flat_reverse(zflag, params={}): # पैरामीटर मान प्राप्त करें b = params.get(`wheelbase`, 3.) # राज्य को स्टोर करने के लिए एक वेक्टर बनाएं और इनपुट x = np.zeros(3) u = np.zeros(2) # फ्लैट चर को देखते हुए, राज्य x के लिए हल करें [ 0] = zflag[0][0] # x स्थिति x[1] = zflag[1][0] # y स्थिति x[2] = np.arctan2(zflag[1][1 ], zflag[0][1]) # tan(theta) = ydot/xdot # और इसके लिए अगला हल करें इनपुट्स आप [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) रिटर्न x, यू # सिस्टम डायनेमिक्स के आरएचएस की गणना करने के लिए फ़ंक्शन 

np.arctan2 उदाहरण #10

def GetNeighborCells(self, p, nr, dp = कोई नहीं): ``` किसी निर्दिष्ट सेल से किसी भी दिशा में दी गई दूरी से अधिक सभी सेल लौटाता है p: वह सेल जिसका पड़ोसी nr प्राप्त करना है: पड़ोसी त्रिज्या dp: दिशा वरीयता ``` pi, pj, pk = p tqm = self.qm * self.qp nc = [(pi - i * tqm, pj - j * tqm, pk) i के लिए रेंज में (-nr, nr + 1) j रेंज में (-nr, nr) के लिए + 1)] अगर डीपी कोई नहीं है: #दिशा वरीयता के आधार पर अंक क्रमबद्ध करें dpa = np.arctan2(dp[1], dp[0]) #दिशा का कोण प्राप्त करें #दिशाओं को प्राथमिकता दें डीपी की दिशा; अंतिम दिशा से कोण के परिमाण के आधार पर क्रमबद्ध करें एनसी = क्रमबद्ध (एनसी, कुंजी = लैम्ब्डा टी: एनपी.एबीएस (<कोड> एनपी.आर्कटन 2  (टी [1], टी [0]) - डीपीए)) वापसी एनसी #खिलाड़ी की वर्तमान 3डी स्थिति प्राप्त करता है 

पायथन एटन या atan2, मुझे क्या उपयोग करना चाहिए?

StackOverflow प्रश्न

मेरा सूत्र f=arctan(ImZ/ReZ)

दो विकल्प हैं :

विकल्प 1 (अटन):

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

विकल्प 2 (atan2)

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

ये दोनों परिणाम अलग क्यों हैं?

उत्तर:

अतन एकल तर्क लेता है और Atan2 दो तर्क लेता है। एक के बजाय दो तर्कों का उपयोग करने का उद्देश्य गणना किए गए कोण के उपयुक्त चतुर्थांश को वापस करने के लिए इनपुट के संकेतों पर जानकारी एकत्र करना है, जो संभव नहीं है एकल तर्क अतान के लिए

Atan2 परिणाम हमेशा -pi और pi के बीच होता है।

संदर्भ: https://en.wikipedia.org/wiki/Atan2

संग्रहीत संस्करण

numpy.arctan2 (arr1, arr2, कास्टिंग = & # 39; वही_किंड & # 39;, ऑर्डर = & # 39; के & # 39 ;, dtype = कोई नहीं, ufunc & # 39; arctan & # 39;):
सही चतुर्थांश चुनकर arr1 / arr2 के तत्व-वार चाप स्पर्शरेखा की गणना करता है।¬†चतुर्थांश को इसलिए चुना जाता है ताकि arctan2 (x1, x2) रेडियन में मूल बिंदु पर समाप्त होने वाली और बिंदु (1, 0) से गुजरने वाली किरण के बीच कोण चिह्न है और एक किरण मूल बिंदु पर समाप्त होती है और बिंदु (x2) x1) से होकर गुजरती है।

पैरामीटर:

arr1: [array_like] वास्तविक मूल्यवान;¬† y-निर्देशांक
arr2: [array_like] वास्तविक मूल्यवान;¬†x-निर्देशांक.¬†यह y-कॉर्डिनेट के आकार से मेल खाना चाहिए।
आउट: [ndarray, array_like [ OPTIONAL ]] x के समान आकार की सरणी।
कहा पे: [array_like, वैकल्पिक] ट्रू वैल्यू का मतलब उस स्थिति में यूनिवर्सल फंक्शन्स (ufunc) की गणना करना है, गलत वैल्यू का मतलब आउटपुट में वैल्यू को छोड़ना है अकेला।

नोट:
2pi रेडियन = 360 डिग्री
सम्मेलन कोण z को वापस करने के लिए है जिसका वास्तविक भाग [-pi / 2 , pi / 2].

वापसी: arr1 / arr2 की तत्व-वार चाप स्पर्शरेखा।¬†मान बंद अंतराल में हैं [-pi/2, pi/2]।

कोड # 1: कार्य

<कोड वर्ग = "टिप्पणियां"> # Python3 प्रोग्राम समझाता है
<कोड वर्ग = "टिप्पणियां" > # arctan2 () फ़ंक्शन

 

<कोड वर्ग = "कीवर्ड"> आयात <कोड वर्ग = "सादा"> एनपी के रूप में सुन्न

 

<कोड वर्ग = " सादा"> गिरफ्तारी <कोड वर्ग = "कीवर्ड"> = <कोड वर्ग = "सादा"> [ <कोड वर्ग = "कीवर्ड"> - <कोड वर्ग = "मान"> 1 <कोड वर्ग = "सादा">, <कोड वर्ग = "कीवर्ड"> + <कोड वर्ग = "मान"> 1 < कोड वर्ग = "सादा">, <कोड वर्ग = "कीवर्ड"> + <कोड वर्ग = "मान"> 1 <कोड वर्ग = "सादा">, <कोड क्लास = "कीवर्ड"> - <कोड क्लास = "वैल्यू"> 1 <कोड क्लास = "प्लेन">]

<कोड क्लास = "सादा"> arr2 = <कोड वर्ग = "सादा"> [ <कोड वर्ग = "कीवर्ड"> - कोड> <कोड वर्ग = "मान"> 1 <कोड वर्ग = "सादा">, <कोड वर्ग = "कीवर्ड"> - <कोड वर्ग = "मान"> 1 <कोड वर्ग = "सादा">, <कोड वर्ग = "कीवर्ड"> + <कोड वर्ग = "मान"> 1 <कोड वर्ग = "सादा" >, <कोड वर्ग = "कीवर्ड"> + <कोड वर्ग = "मान"> 1 <कोड वर्ग = "सादा">]

<कोड वर्ग = "सादा"> उत्तर <कोड वर्ग = "कीवर्ड"> = <कोड वर्ग = "सादा"> एनपी।arctan2 (arr2, arr1) <कोड वर्ग = "कीवर्ड"> * <कोड क्लास = "वैल्यू"> 180 <कोड क्लास = "कीवर्ड"> / <कोड क्लास = "प्लेन"> np.pi

 

Print ( "एक्स- निर्देशांक:" <कोड वर्ग = "सादा">, arr1)

<कोड वर्ग = "कार्य"> प्रिंट <कोड वर्ग = "सादा"> ( "y-coordin¬†ates:" , arr2)

  

<कोड वर्ग = "कार्य"> प्रिंट <कोड वर्ग = "सादा"> ( <कोड class = "string"> "arctan2 मान:" , ans )

आउटपुट:

x-निर्देशांक: [-1, 1, 1 , -1] y-निर्देशांक: [-1, -1, 1, 1] arctan2 मान: [-135 .¬†-45.¬†45. 135.] 

कोड # 2: कार्य