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

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

सिंटैक्स

numpy.arctan2(x1, x2, /, out=None, *, कहां=सही, कास्टिंग=`same_kind`, आदेश=`K`, dtype =कोई नहीं, सबोक=सत्य[, हस्ताक्षर, extobj]) = ufunc `arctan2`

पैरामीटर
X1 array_like, real-value

y-निर्देशांक.

x2 array_like, real-valued

x-निर्देशांक। अगर x1.shape != x2. आकार , उन्हें एक सामान्य आकार में प्रसारित किया जाना चाहिए (जो आउटपुट का आकार बन जाता है)।

बाहर ndarray, कोई नहीं, या ndarray और कोई नहीं का टपल, वैकल्पिक

एक स्थान जिसमें परिणाम संग्रहीत किया जाता है। यदि प्रदान किया गया है, तो इसका एक आकार होना चाहिए जिससे इनपुट प्रसारित हो। यदि प्रदान नहीं किया गया है या कोई नहीं, एक ताजा आवंटित सरणी वापस कर दी जाती है। एक टपल (केवल एक कीवर्ड तर्क के रूप में संभव) की लंबाई आउटपुट की संख्या के बराबर होनी चाहिए।

जहाँ array_like, वैकल्पिक

यह स्थिति इनपुट पर प्रसारित होती है। उन स्थानों पर जहां स्थिति सही है, out सरणी को ufunc परिणाम पर सेट किया जाएगा। कहीं और, out सरणी अपना मूल मान बनाए रखेगी। ध्यान दें कि यदि एक अप्रारंभीकृत out सरणी डिफ़ॉल्ट out=None< के माध्यम से बनाई गई है /span>, इसके भीतर के स्थान जहां स्थिति गलत है, प्रारंभ नहीं किया जाएगा।

**kwargs

अन्य केवल-कीवर्ड तर्कों के लिए, ufunc docs देखें। .

Returns
कोण ndarray

[-pi, pi]. यह एक अदिश है यदि x1 और x2 दोनों अदिश हैं।


हम NumPy arctan2 को कवर करेंगे। इसके साथ ही, एक बेहतर सामान्य समझ के लिए, हम इसके सिंटैक्स और पैरामीटर को भी देखेंगे। फिर, हम कुछ उदाहरणों के माध्यम से संपूर्ण सैद्धांतिक भाग के अनुप्रयोग को देखेंगे। लेकिन पहले, आइए इसकी परिभाषा के माध्यम से फ़ंक्शन का विश्लेषण करने का प्रयास करें। सबसे पहले, आर्कटन का अर्थ है एक तन समारोह का उलटा। अब NumPy arctan2 फ़ंक्शन हमें रेडियन में X1 और X2 के बीच आर्क टैन मान की गणना करने में मदद करता है। यहाँ, X1 और 2 पैरामीटर हैं जिन पर हम बाद में चर्चा करेंगे। जैसे-जैसे हम इस लेख के माध्यम से आगे बढ़ेंगे, आपके लिए चीजें स्पष्ट होती जाएंगी। इसके बाद, आइए इससे जुड़े वाक्य-विन्यास को देखें।
arr2 और क्वाड्रंट को सही तरीके से चुनता है। चतुर्थांश को इसलिए चुना जाता है ताकि arctan2(x1, x2) रेडियन में मूल बिंदु पर समाप्त होने वाली और बिंदु (1, 0) से गुजरने वाली किरण के बीच का हस्ताक्षरित कोण हो और किरण मूल बिंदु पर समाप्त होती है और बिंदु (x2, x1) से गुजरती है। Arctan2 एक 4-चतुर्थांश प्रतिलोम फलन है। इसे ध्यान में रखते हुए, यह 0 और 2pi के बीच का मान देता है। इस फ़ंक्शन की सीमा -180 से 180 डिग्री है। ये 2 प्रमुख बिंदु हैं जो Arctan2 को आर्कटिक विशेषताओं से अलग करते हैं।

आर्कटन और आर्कटन2 के बीच अंतर

इस खंड में हम 2 Numpy फ़ंक्शन के बीच अंतर पर चर्चा करेंगे।

< td>arctan एक 2 चतुर्थांश प्रतिलोम फलन है।
NumPy arctan< /td>NumPy arctan2
arctan2 एक 4 चतुर्थांश प्रतिलोम फलन है।
आर्कटन फलन की सीमा -90 से लेकर 90 डिग्री.आर्कटन2 की सीमा -180 से 180 डिग्री है।
यह फ़ंक्शन एकल सरणी को स्वीकार करता है।यह चर्चा के अनुसार फ़ंक्शन 2 इनपुट सरणियाँ लें।
अब हम NumPy arctan2 के सैद्धांतिक भाग के साथ समाप्त कर चुके हैं। यह खंड इस बात की पड़ताल करता है कि यह सुविधा कैसे काम करती है और यह हमें वह आउटपुट प्राप्त करने में कैसे मदद करती है जो हम चाहते हैं। हम एक प्राथमिक उदाहरण से शुरू करेंगे और धीरे-धीरे अधिक जटिल उदाहरण की ओर बढ़ेंगे।

NumPy Arctan2 उदाहरण

ppool y=[1,1] x=[1,1.732] print(ppool.arctan2(y,x)) [0.78539816 0.52361148] 
के रूप में numpy आयात करें ऊपर हम अपने arctan2 फ़ंक्शन का एक सरल उदाहरण देखते हैं। अब लाइन से लाइन चलते हैं और समझते हैं कि हमें परिणाम कैसे मिला। सबसे पहले, हमने NumPy फ़ंक्शन को आयात किया। फिर हमने सरणी के अपने 2 सेटों को परिभाषित किया। हमारे फ़ंक्शन के सिंटैक्स और प्रिंट स्टेटमेंट का उपयोग करके, हमें वह परिणाम मिलता है जो हम चाहते हैं। यहाँ दोनों मान रेडियन में दिए गए हैं। अब अगर आप कुछ हद तक रिजल्ट चेक करना चाहते हैं। ऐसा करने के लिए, हमें इस विशेष विधि का उपयोग करने की आवश्यकता है:
कोण में डिग्री = रेडियन में कोण * 180/pi

यदि हम अपने परिणामों पर गणना करते हैं, तो हमें 45 और 30 मिलते हैं - डिग्री उत्तर। यहां हमने पाई से 3.14 पर विचार किया। प्रतिक्रियाएं मेल खाती हैं और इसलिए परिणाम सत्यापित किया जाता है।

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 आयात करें) (बी) 
यहां आपको केवल सरणी से मान (180 / 3.14) या (180 / ppool.pi) को गुणा करना है। आप निश्चित रूप से लूप विधि के लिए इस विधि का उपयोग कर सकते हैं। लेकिन किसी भी तरह से, आपको वांछित आउटपुट मिलेगा जो एक डिग्री मान है।

आउटपुट:

[-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डी स्थिति प्राप्त करता है 
इस लेख में, हम NumPy के arctan2 को कवर करते हैं। इसके अलावा, हमने इसका सिंटैक्स और पैरामीटर भी देखा। बेहतर ढंग से समझने के लिए हमने कुछ उदाहरण देखे। अंत में, हम यह निष्कर्ष निकाल सकते हैं कि NumPy arctan2 एक ऐसा फ़ंक्शन है जो हमें 2 बिंदुओं के बीच के व्युत्क्रम टैन मान को खोजने में मदद करता है। डिफ़ॉल्ट रूप से यह रेडियन में मान लौटाता है, लेकिन हम ऊपर चर्चा की गई विधियों का उपयोग करके इसे डिग्री में बदल सकते हैं। हमें उम्मीद है कि इस लेख ने आपके सभी संदेहों को दूर कर दिया है। लेकिन यदि आपके कोई अनसुलझे प्रश्न हैं, तो बेझिझक उन्हें टिप्पणी अनुभाग में लिखें। इसे पढ़ने के बाद, क्यों न निम्नलिखित पहचान मैट्रिक्स के बारे में पढ़ा जाए।

पायथन एटन या 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 परिणाम प्रत्येक x,y के लिए

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: कार्य

<तालिका बॉर्डर = "0" सेलपैडिंग = "0" सेलस्पेसिंग = "0">

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

 

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

 

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

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

p> <कोड वर्ग = "अपरिभाषित रिक्त स्थान">¬†¬†

<कोड वर्ग = "सादा"> उत्तर <कोड वर्ग = "कीवर्ड"> = <कोड वर्ग = "सादा"> एनपी।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: कार्य

<टेबल बॉर्डर = "0" सेलपैडिंग = "0" सेलस्पेसिंग = "0">

# Python3 प्रोग्राम दिखा रहा है
# arctan2 () फ़ंक्शन

 

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

 

<कोड वर्ग = "सादा" "> a = np.arctan2 ([ 0. , 0. < /कोड> <कोड वर्ग = "सादा">, np.inf], [ <कोड वर्ग = "कीवर्ड"> + <कोड वर्ग = "मान"> 0. < कोड वर्ग = "सादा">, <कोड वर्ग = "कीवर्ड"> - <कोड वर्ग = "मान"> 0. <कोड वर्ग = "सादा">, एनपी। inf])

 

<कोड वर्ग = "सादा"> b <कोड वर्ग = "कीवर्ड"> = <कोड वर्ग =¬†"सादा"> np .arctan2 ([ 1. , <कोड वर्ग = "कीवर्ड"> - <कोड वर्ग = "मान"> 1. <कोड वर्ग = "सादा">], [ कोड> <कोड वर्ग = "मान"> 0. <कोड वर्ग = "सादा">, <कोड वर्ग = "मान"> 0. <कोड वर्ग = "सादा" >])

 

Print ( < कोड वर्ग = "स्ट्रिंग">" ए: " <कोड वर्ग = "सादा">, ए)

<कोड वर्ग = "अपरिभाषित रिक्त स्थान"> ¬† code>¬†

Print ( "b:" < /कोड> <कोड वर्ग = "सादा">, बी)

आउटपुट:

< पूर्व>ए: [0. 3.14159265 0.78539816] ख: [1.57079633 -1.57079633]

लिंक:
arctan2.html#numpy.arctan2>https://docs.scipy.org/doc/numpy-1.13.0/reference/g enerated / numpy.arctan2.html # numpy.arctan2
,