NumPy 1.14 - Universal functions (ufunc)

सार्वभौमिक कार्य (ufunc)




numpy

सार्वभौमिक कार्य (ufunc)

एक सार्वभौमिक फ़ंक्शन (या ufunc लिए ufunc ) एक फ़ंक्शन है जो तत्व-दर-तत्व फैशन में ndarrays पर कार्य करता है, सरणी प्रसारण , प्रकार कास्टिंग और कई अन्य मानक सुविधाओं का समर्थन करता है। यही है, एक ufunc एक फ़ंक्शन के लिए एक "सदिशीकृत" आवरण है जो एक निश्चित संख्या में विशिष्ट इनपुट लेता है और एक निश्चित संख्या में विशिष्ट आउटपुट उत्पन्न करता है।

NumPy में, सार्वभौमिक कार्य numpy.ufunc वर्ग के उदाहरण हैं। कई निर्मित कार्यों को संकलित सी कोड में लागू किया गया है। मूल ufuncs स्केलर पर काम करते हैं, लेकिन एक सामान्य प्रकार भी है जिसके लिए मूल तत्व उप-सरणियाँ (वैक्टर, मैट्रीस, आदि) हैं, और प्रसारण अन्य आयामों पर किया जाता है। एक कस्टम frompyfunc फैक्ट्री फ़ंक्शन का उपयोग करके कस्टम ufunc इंस्टेंस भी बना सकता है।

प्रसारण

प्रत्येक सार्वभौमिक फ़ंक्शन सरणी इनपुट लेता है और इनपुट पर कोर फ़ंक्शन तत्व-वार प्रदर्शन करके सरणी आउटपुट उत्पन्न करता है (जहां एक तत्व आम तौर पर एक स्केलर होता है, लेकिन सामान्यीकृत ufuncs के लिए एक वेक्टर या उच्च-क्रम उप-सरणी हो सकता है)। मानक प्रसारण नियमों को लागू किया जाता है ताकि इनपुट समान आकार साझा न कर सकें फिर भी उपयोगी रूप से संचालित हो सकें। प्रसारण को चार नियमों से समझा जा सकता है:

  1. ndim साथ सभी इनपुट सरणियाँ सबसे बड़े ndim के इनपुट ऐरे से ndim , उनके आकृतियों में 1 है।
  2. आउटपुट आकार के प्रत्येक आयाम में आकार उस आयाम में सभी इनपुट आकारों की अधिकतम है।
  3. एक इनपुट का उपयोग गणना में किया जा सकता है यदि किसी विशेष आयाम में इसका आकार या तो उस आयाम में आउटपुट आकार से मेल खाता है, या इसका मूल्य ठीक 1 है।
  4. यदि किसी इनपुट के आकार में 1 का आयाम है, तो उस आयाम में पहली डेटा प्रविष्टि का उपयोग उस आयाम के सभी गणनाओं के लिए किया जाएगा। दूसरे शब्दों में, ufunc की स्टेपिंग मशीनरी केवल उस आयाम के साथ कदम नहीं ufunc (उस आयाम के लिए स्ट्राइड 0 होगा)।

प्रसारण का उपयोग पूरे NumPy में किया जाता है ताकि यह तय किया जा सके कि असमान आकार के सरणियों को कैसे संभालना है; उदाहरण के लिए, ndarrays बीच सभी अंकगणितीय ऑपरेशन ( + , - , * ,…) ऑपरेशन से पहले सरणियों को प्रसारित करते हैं।

सरणियों के एक सेट को एक ही आकार में " प्रसारण योग्य " कहा जाता है यदि उपरोक्त नियम एक वैध परिणाम का उत्पादन करते हैं, अर्थात , निम्नलिखित में से एक है:

  1. सभी सरणियों का आकार बिल्कुल एक जैसा है।
  2. सरणियों में सभी समान आयाम हैं और प्रत्येक आयाम की लंबाई या तो एक सामान्य लंबाई या 1 है।
  3. जिन सरणियों में बहुत कम आयाम हैं, उनके आकार संपत्ति 2 को संतुष्ट करने के लिए लंबाई 1 के आयाम के साथ प्रचलित हो सकते हैं।

उदाहरण

यदि a.shape है (5,1), b.shape है (1,6), c.shape है (6,) और d.shape है () तो d एक अदिश राशि है, तो a , b , c , और सभी आयाम (5,6) के लिए प्रसारण योग्य हैं; तथा

  • एक (5,6) सरणी की तरह कार्य करता है, जहां a[:,0] को अन्य कॉलमों में प्रसारित किया जाता है,
  • b (5,6) सरणी की तरह कार्य करता है जहां b[0,:] को अन्य पंक्तियों में प्रसारित किया जाता है,
  • c एक (1,6) सरणी की तरह कार्य करता है और इसलिए एक (5,6) सरणी की तरह जहां c[:] को हर पंक्ति में प्रसारित किया जाता है और अंत में,
  • d (5,6) सरणी की तरह कार्य करता है जहां एकल मान दोहराया जाता है।

आउटपुट प्रकार निर्धारण

Ufunc का उत्पादन (और इसके तरीके) जरूरी नहीं कि एक ndarrays , यदि सभी इनपुट तर्क ndarrays नहीं हैं। वास्तव में, यदि कोई इनपुट एक __array_ufunc__ विधि को परिभाषित करता है, तो नियंत्रण पूरी तरह से उस फ़ंक्शन को पास किया जाएगा, अर्थात, ufunc overridden

यदि इनपुट में से कोई भी ufunc को ओवरराइड नहीं करता है, तो सभी आउटपुट सरणियों को __array_prepare__ और __array_wrap__ तरीकों के इनपुट ( ndarrays और स्केलर के अलावा) पास किया जाएगा, इसे परिभाषित करता है और सार्वभौमिक फ़ंक्शन के किसी भी अन्य इनपुट का उच्चतम __array_priority__ है। __array_priority__ का डिफ़ॉल्ट __array_priority__ 0.0 है, और उपप्रकार का डिफ़ॉल्ट __array_priority__ 1.0 है। मैट्रिक्स में __array_priority__ 10.0 के बराबर है।

सभी ufuncs आउटपुट तर्क भी ले सकते हैं। यदि आवश्यक हो, तो आउटपुट दिए गए आउटपुट एरे (ओं) के डेटा-प्रकार (ओं) पर कास्ट किया जाएगा। यदि आउटपुट के लिए __array__ पद्धति के साथ एक वर्ग का उपयोग किया जाता है, तो परिणाम __array__ द्वारा लौटाए गए ऑब्जेक्ट को लिखा जाएगा। फिर, यदि वर्ग में एक __array_prepare__ विधि है, तो इसे कहा जाता है ताकि मेटाडेटा को ufunc के संदर्भ के आधार पर निर्धारित किया जा सके (स्वयं ufunc से संबंधित संदर्भ, ufunc और ufunc डोमेन के लिए पारित तर्क।) सरणी। __array_prepare__ द्वारा लौटाए गए ऑब्जेक्ट को कम्प्यूटेशन के लिए ufunc पास किया जाता है। अंत में, यदि कक्षा में एक __array_wrap__ विधि भी है, तो लौटाए गए __array_wrap__ परिणाम को कॉल करने वाले को वापस नियंत्रण देने से ठीक पहले उस पद्धति में भेज दिया जाएगा।

आंतरिक बफर का उपयोग

आंतरिक रूप से, बफ़र्स का उपयोग गलत डेटा, स्वैप किए गए डेटा और डेटा के लिए किया जाता है जिसे एक डेटा प्रकार से दूसरे डेटा में परिवर्तित करना होता है। आंतरिक बफ़र्स का आकार प्रति-थ्रेड के आधार पर व्यवस्थित है। तक हो सकता है 2 (n _ {\ mathrm {निविदायें}} + n _ {\ mathrm {outputs}}) एक ufunc के सभी इनपुट और आउटपुट से डेटा को संभालने के लिए बनाए गए निर्दिष्ट आकार के बफ़र्स। एक बफर का डिफ़ॉल्ट आकार 10,000 तत्व है। जब भी बफर-आधारित गणना की आवश्यकता होगी, लेकिन सभी इनपुट सरणियां बफर आकार से छोटी होती हैं, उन गलत या गलत-टाइप किए गए सरणियों को गणना आय से पहले कॉपी किया जाएगा। इसलिए बफर के आकार को समायोजित करने की गति में परिवर्तन हो सकता है, जिस पर विभिन्न प्रकारों की ufunc गणना पूरी हो जाती है। फ़ंक्शन का उपयोग करके इस चर को सेट करने के लिए एक सरल इंटरफ़ेस सुलभ है

setbufsize (आकार) Ufuncs में प्रयुक्त बफर का आकार निर्धारित करें।

गलती संभालना

यूनिवर्सल फ़ंक्शन आपके हार्डवेयर में विशेष फ़्लोटिंग-पॉइंट स्टेटस रजिस्टरों (जैसे डिवाइड-बाय-जीरो) की यात्रा कर सकते हैं। यदि आपके प्लेटफ़ॉर्म पर उपलब्ध है, तो इन रजिस्टरों की गणना के दौरान नियमित रूप से जाँच की जाएगी। त्रुटि हैंडलिंग को प्रति-थ्रेड आधार पर नियंत्रित किया जाता है, और फ़ंक्शन का उपयोग करके कॉन्फ़िगर किया जा सकता है

seterr ([सभी, विभाजित, ओवर, अंडर, अमान्य]) सेट करें कि फ़्लोटिंग-पॉइंट एरर को कैसे हैंडल किया जाता है।
seterrcall (func) फ़्लोटिंग-पॉइंट त्रुटि कॉलबैक फ़ंक्शन या लॉग ऑब्जेक्ट सेट करें।

कास्टिंग नियम

ध्यान दें

NumPy 1.6.0 में, आउटपुट प्रकारों के निर्धारण के लिए तंत्र को एनकैप्सुलेट करने के लिए एक प्रकार का प्रचार एपीआई बनाया गया था। अधिक विवरण के लिए फ़ंक्शन result_type , promote_types और min_scalar_type देखें।

प्रत्येक ufunc के मूल में एक आयामी तार वाला लूप होता है जो एक विशिष्ट प्रकार के संयोजन के लिए वास्तविक कार्य को लागू करता है। जब एक ufunc बनाया जाता है, तो उसे आंतरिक छोरों की एक स्थिर सूची और प्रकार हस्ताक्षर की एक संबंधित सूची दी जाती है, जिस पर ufunc संचालित होता है। Ufunc मशीनरी इस सूची का उपयोग यह निर्धारित करने के लिए करती है कि किसी विशेष मामले के लिए किस आंतरिक लूप का उपयोग किया जाए। आप एक विशेष ufunc के लिए .types विशेषता का निरीक्षण कर सकते हैं कि किस प्रकार के संयोजनों में एक परिभाषित आंतरिक लूप है और वे किस प्रकार का उत्पादन करते हैं ( चरित्र कोड संक्षिप्तता के लिए उक्त आउटपुट में उपयोग किए जाते हैं)।

जब भी ufunc प्रदान किए गए इनपुट प्रकारों के लिए कोर लूप कार्यान्वयन नहीं करता है, तो एक या अधिक इनपुट पर कास्टिंग करना होगा। यदि इनपुट प्रकारों के लिए एक कार्यान्वयन नहीं पाया जा सकता है, तो एल्गोरिथ्म एक कार्यान्वयन के लिए एक प्रकार के हस्ताक्षर के साथ खोज करता है, जिसमें सभी इनपुट को "सुरक्षित रूप से" डाला जा सकता है। पहला यह जो इसकी आंतरिक सूची में पाता है उसे चुना और निष्पादित किया जाता है। , सभी आवश्यक प्रकार की कास्टिंग के बाद। याद रखें कि ufuncs के दौरान आंतरिक प्रतियां (यहां तक ​​कि कास्टिंग के लिए) एक आंतरिक बफर के आकार तक सीमित हैं (जो उपयोगकर्ता के निपटान योग्य है)।

ध्यान दें

NumPy में सार्वभौमिक कार्य मिश्रित प्रकार के हस्ताक्षर करने के लिए पर्याप्त लचीले हैं। इस प्रकार, उदाहरण के लिए, एक सार्वभौमिक फ़ंक्शन को परिभाषित किया जा सकता है जो फ्लोटिंग-पॉइंट और पूर्णांक मानों के साथ काम करता है। उदाहरण के लिए ldexp देखें।

उपरोक्त विवरण के द्वारा, कास्टिंग नियमों को अनिवार्य रूप से इस सवाल के द्वारा लागू किया जाता है कि डेटा प्रकार को किसी अन्य डेटा प्रकार के लिए "सुरक्षित रूप से" कैसे डाला जा सकता है। इस प्रश्न का उत्तर पायथन में एक फ़ंक्शन कॉल के साथ निर्धारित किया जा सकता है: can_cast(fromtype, totype) । नीचे दिया गया चित्र लेखक के 64-बिट सिस्टम पर 24 आंतरिक रूप से समर्थित प्रकारों के लिए इस कॉल के परिणाम दिखाता है। आप इस तालिका को चित्र में दिए गए कोड के साथ अपने सिस्टम के लिए जनरेट कर सकते हैं।

आकृति

32-बिट सिस्टम के लिए "सुरक्षित रूप से डाली जा सकने वाली" तालिका दिखाने वाला कोड खंड।

>>> def print_table(ntypes):
...     print 'X',
...     for char in ntypes: print char,
...     print
...     for row in ntypes:
...         print row,
...         for col in ntypes:
...             print int(np.can_cast(row, col)),
...         print
>>> print_table(np.typecodes['All'])
X ? b h i l q p B H I L Q P e f d g F D G S U V O M m
? 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
b 0 1 1 1 1 1 1 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 0 0
h 0 0 1 1 1 1 1 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 0 0
i 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 1 1 0 1 1 1 1 1 1 0 0
l 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 1 1 0 1 1 1 1 1 1 0 0
q 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 1 1 0 1 1 1 1 1 1 0 0
p 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 1 1 0 1 1 1 1 1 1 0 0
B 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0
H 0 0 0 1 1 1 1 0 1 1 1 1 1 0 1 1 1 1 1 1 1 1 1 1 0 0
I 0 0 0 0 1 1 1 0 0 1 1 1 1 0 0 1 1 0 1 1 1 1 1 1 0 0
L 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 1 1 0 1 1 1 1 1 1 0 0
Q 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 1 1 0 1 1 1 1 1 1 0 0
P 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 1 1 0 1 1 1 1 1 1 0 0
e 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 0 0
f 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 0 0
d 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 1 1 1 1 1 0 0
g 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 1 1 1 1 0 0
F 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 0 0
D 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0
G 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0
S 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0
U 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0
V 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0
O 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0
M 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0
m 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1

आपको यह ध्यान देना चाहिए कि पूर्णता के लिए तालिका में शामिल करते समय, 'S', 'U' और 'V' प्रकार को ufuncs द्वारा संचालित नहीं किया जा सकता है। इसके अलावा, ध्यान दें कि 32-बिट सिस्टम पर पूर्णांक प्रकार के अलग-अलग आकार हो सकते हैं, जिसके परिणामस्वरूप थोड़ा बदल दिया जाता है।

मिश्रित स्केलर-सरणी ऑपरेशन कास्टिंग नियमों के एक अलग सेट का उपयोग करते हैं जो यह सुनिश्चित करते हैं कि एक स्केलर एक सरणी को "upcast" नहीं कर सकता है जब तक कि स्केलर मौलिक रूप से भिन्न प्रकार का डेटा न हो ( अर्थात , डेटा-प्रकार की पदानुक्रम में एक अलग पदानुक्रम के तहत)। सरणी। यह नियम आपको अपने कोड में स्केलर स्थिरांक का उपयोग करने में सक्षम बनाता है (जो, पायथन प्रकारों के अनुसार, ufuncs के अनुसार व्याख्या की जाती है) इस बारे में चिंता किए बिना कि क्या अदिश स्थिरांक की सटीकता आपके बड़े (छोटे सटीक) सरणी पर अपक्षय का कारण बनेगी।

उफंक व्यवहार को ओवरराइड करना

कक्षाएं (ndarray उपवर्ग सहित) ओवरराइड कर सकती हैं कि कुछ विशेष तरीकों को परिभाषित करके उन पर ufuncs कैसे कार्य करते हैं। विवरण के लिए, मानक सरणी उपवर्ग देखें।

ufunc

वैकल्पिक कीवर्ड तर्क

सभी ufuncs वैकल्पिक खोजशब्द तर्क लेते हैं। इनमें से अधिकांश उन्नत उपयोग का प्रतिनिधित्व करते हैं और आमतौर पर उपयोग नहीं किया जाएगा।

बाहर

संस्करण 1.6 में नया।

पहला आउटपुट किसी भी स्थिति या कीवर्ड पैरामीटर के रूप में प्रदान किया जा सकता है। कीवर्ड 'आउट' तर्क स्थितीयों के साथ असंगत हैं।

संस्करण 1.10 में नया।

'आउट' कीवर्ड तर्क के प्रति आउटपुट एक प्रविष्टि के साथ टपल होने की उम्मीद है (जो कि ufunc द्वारा आवंटित किए जाने वाले सरणियों के लिए None हो सकता है)। एकल आउटपुट के साथ ufuncs के लिए, एकल सरणी (एकल सरणी रखने वाले टपल के बजाय) पास करना भी मान्य है।

एकाधिक आउटपुट के साथ ufunc के लिए 'आउट' कीवर्ड तर्क में एक एकल सरणी पासिंग को हटा दिया जाता है, और 1.10 में एक चेतावनी और भविष्य में रिलीज में एक त्रुटि बढ़ाएगा।

कहा पे

संस्करण 1.7 में नया।

एक बूलियन सरणी को स्वीकार करता है जिसे ऑपरेंड के साथ एक साथ प्रसारित किया जाता है। सत्य के मान उस स्थिति में ufunc की गणना करने के लिए संकेत देते हैं, गलत के मान अकेले उत्पादन में मूल्य छोड़ने का संकेत देते हैं। यह तर्क सामान्यीकृत ufuncs के लिए उपयोग नहीं किया जा सकता है क्योंकि वे गैर-स्केलर इनपुट लेते हैं।

ढलाई

संस्करण 1.6 में नया।

'नहीं', 'इक्विव', 'सेफ', 'समान_हिन्द' या 'असुरक्षित' हो सकता है। पैरामीटर मानों के स्पष्टीकरण के लिए can_cast देखें।

किस प्रकार की कास्टिंग की अनुमति है इसके लिए एक नीति प्रदान करता है। NumPy के पिछले संस्करणों के साथ अनुकूलता के लिए, यह संख्या <1.7 के लिए 'असुरक्षित' के लिए डिफ़ॉल्ट है। सुपीरियर 1.7 में 'same_kind' के लिए एक संक्रमण शुरू किया गया था, जहाँ ufuncs कॉल के लिए एक डिप्रेक्शन वर्जन का उत्पादन करते हैं, जिन्हें 'असुरक्षित' नियमों के तहत अनुमति दी जाती है, लेकिन 'same_kind' नियमों के तहत नहीं। संख्या 1.10 और उसके बाद, डिफ़ॉल्ट 'same_kind' है।

क्रम

संस्करण 1.6 में नया।

आउटपुट सरणी के गणना पुनरावृत्ति क्रम / मेमोरी लेआउट को निर्दिष्ट करता है। 'के' की कमी। 'C' का मतलब है कि आउटपुट C-contiguous होना चाहिए, 'F' का मतलब F-contiguous, 'A' का मतलब F-contiguous है अगर इनपुट F-contiguous है और C-contiguous नहीं है, तो C-contiguous अन्यथा, और 'K' 'के रूप में संभव के रूप में बारीकी से आदानों के तत्व आदेश से मेल खाने का मतलब है।

dtype

संस्करण 1.6 में नया।

गणना और आउटपुट सरणियों के dtype को ओवरराइड करता है। हस्ताक्षर के समान।

subok

संस्करण 1.6 में नया।

सत्य की अवहेलना। यदि गलत पर सेट किया जाता है, तो आउटपुट हमेशा एक सख्त सरणी होगा, उप-प्रकार नहीं।

हस्ताक्षर

या तो एक डेटा-प्रकार, डेटा-प्रकार का एक टपल, या एक विशेष हस्ताक्षर स्ट्रिंग एक ufunc के इनपुट और आउटपुट प्रकार को दर्शाता है। यह तर्क आपको अंतर्निहित गणना में उपयोग करने के लिए 1-डी लूप के लिए एक विशिष्ट हस्ताक्षर प्रदान करने की अनुमति देता है। यदि निर्दिष्ट लूप ufunc के लिए मौजूद नहीं है, तो एक TypeError उठाया जाता है। आम तौर पर, एक उपयुक्त लूप इनपुट प्रकारों की तुलना करके स्वचालित रूप से पाया जाता है जो उपलब्ध है और डेटा-प्रकारों के साथ एक लूप की खोज कर रहा है जिसमें सभी इनपुट सुरक्षित रूप से डाले जा सकते हैं। यह कीवर्ड तर्क आपको उस खोज को बायपास करने देता है और एक विशेष लूप का चयन करता है। उपलब्ध हस्ताक्षर की एक सूची ufunc ऑब्जेक्ट के प्रकार विशेषता द्वारा प्रदान की जाती है। पीछे की संगतता के लिए इस तर्क को सिग के रूप में भी प्रदान किया जा सकता है, हालांकि लंबे रूप को प्राथमिकता दी जाती है। ध्यान दें कि यह सामान्यीकृत ufunc हस्ताक्षर के साथ भ्रमित नहीं होना चाहिए जो कि ufunc ऑब्जेक्ट के हस्ताक्षर विशेषता में संग्रहीत है।

extobj

लंबाई 1, 2, या 3 की सूची में ufunc बफर-आकार, त्रुटि मोड पूर्णांक और त्रुटि कॉल-बैक फ़ंक्शन निर्दिष्ट करता है। आम तौर पर, इन मूल्यों को एक थ्रेड-विशिष्ट शब्दकोश में देखा जाता है। यहां से गुजरते हुए उन परिधियों को देखा जाता है जो त्रुटि मोड के लिए प्रदान किए गए निम्न-स्तरीय विनिर्देश का उपयोग करते हैं। यह उपयोगी हो सकता है, उदाहरण के लिए, एक लूप में छोटे सरणियों पर कई ufunc कॉल की आवश्यकता के लिए अनुकूलन के रूप में।

गुण

कुछ सूचनात्मक विशेषताएं हैं जो सार्वभौमिक कार्यों के अधिकारी हैं। कोई भी विशेषता निर्धारित नहीं की जा सकती है।

__doc__ प्रत्येक ufunc के लिए एक docstring। डॉक्स्ट्रिंग का पहला भाग डायनामिक रूप से आउटपुट की संख्या, नाम और इनपुट की संख्या से उत्पन्न होता है। डॉकस्ट्रिंग का दूसरा भाग निर्माण समय पर प्रदान किया जाता है और यूफंसी के साथ संग्रहीत किया जाता है।
__name__ Ufunc का नाम।
ufunc.nin इनपुट्स की संख्या।
ufunc.nout आउटपुट की संख्या।
ufunc.nargs तर्कों की संख्या।
ufunc.ntypes प्रकार की संख्या।
.types प्रकारों के समूहित इनपुट-> आउटपुट के साथ एक सूची लौटाता है।
ufunc.identity पहचान मूल्य।
ufunc.signature मुख्य तत्वों की परिभाषा एक सामान्यीकृत ufunc पर संचालित होती है।

तरीके

सभी ufuncs के चार तरीके हैं। हालाँकि, ये विधियाँ केवल स्केलर ufuncs पर समझ में आती हैं जो दो इनपुट तर्क लेती हैं और एक आउटपुट तर्क लौटाती हैं। अन्य ufuncs पर इन विधियों को कॉल करने का प्रयास करने से ValueError कारण होगा। कम करने वाली विधियाँ सभी अक्ष कीवर्ड, एक dtype कीवर्ड और एक आउट कीवर्ड लेती हैं , और सरणियों में सभी का आयाम होना चाहिए> = 1. अक्ष कीवर्ड उस सरणी के अक्ष को निर्दिष्ट करता है जिस पर कमी घटित होगी (नकारात्मक के साथ) मान पीछे की ओर गिनती)। आम तौर पर, यह एक पूर्णांक होता है, हालांकि ufunc.reduce , यह एक अक्ष का टपल भी हो सकता है, जो एक बार में कई अक्षों को कम कर सकता है, या None , सभी अक्षों को कम करने के लिए None Dtype कीवर्ड आपको एक बहुत ही सामान्य समस्या को प्रबंधित करने की अनुमति देता है जो कि ufunc.reduce का उपयोग करते समय उत्पन्न होती है। कभी-कभी आपके पास एक निश्चित डेटा प्रकार की एक सरणी हो सकती है और इसके सभी तत्वों को जोड़ना चाहते हैं, लेकिन परिणाम सरणी के डेटा प्रकार में फिट नहीं होता है। यह आमतौर पर तब होता है जब आपके पास एकल-बाइट पूर्णांकों की एक सरणी होती है। Dtype कीवर्ड आपको उस डेटा प्रकार को बदलने की अनुमति देता है जिस पर कटौती होती है (और इसलिए आउटपुट का प्रकार)। इस प्रकार, आप यह सुनिश्चित कर सकते हैं कि आउटपुट एक डेटा प्रकार है जिसमें सटीक रूप से बड़े पैमाने पर आपके आउटपुट को संभालना है। कम प्रकार को बदलने की जिम्मेदारी ज्यादातर आप पर है। एक अपवाद है: यदि "ऐड" या "गुणा" ऑपरेशन में कमी के लिए कोई dtype नहीं दिया गया है, तो यदि इनपुट प्रकार एक पूर्णांक (या बूलियन) डेटा-प्रकार और int_ डेटा प्रकार के आकार से छोटा है, तो यह आंतरिक रूप से int_ (या uint ) डेटा-प्रकार तक पहुंच जाएगा। अंत में, आउट कीवर्ड आपको आउटपुट सरणी प्रदान करने की अनुमति देता है (एकल-आउटपुट ufuncs के लिए, जो वर्तमान में केवल समर्थित हैं। भविष्य के विस्तार के लिए, हालांकि, एकल तर्क के साथ एक टपल पास किया जा सकता है)। यदि दिया जाता है, तो dtype तर्क को अनदेखा कर दिया जाता है।

Ufuncs में एक पांचवीं विधि भी होती है जो फैंसी अनुक्रमण का उपयोग करके स्थान संचालन की अनुमति देती है। कोई भी बफ़रिंग का उपयोग उन आयामों पर नहीं किया जाता है जहाँ फैंसी इंडेक्सिंग का उपयोग किया जाता है, इसलिए फैंसी इंडेक्स किसी आइटम को एक से अधिक बार सूचीबद्ध कर सकता है और उस आइटम के लिए पिछले ऑपरेशन के परिणाम पर ऑपरेशन किया जाएगा।

ufunc.reduce ([, अक्ष, dtype, आउट, कीपडीम्स]) एक धुरी के साथ ufunc लगाने से एक के एक आयाम को कम करता है।
ufunc.accumulate (सरणी [, अक्ष, dtype, आउट]) ऑपरेटर को सभी तत्वों पर लागू करने के परिणाम को संचित करें।
ufunc.reduceat (ए, सूचकांक [, अक्ष, dtype, आउट]) एक अक्ष पर निर्दिष्ट स्लाइस के साथ एक (स्थानीय) कम करता है।
ufunc.outer (A, B, ** kwargs) A में B और ए में B साथ सभी जोड़े (ए, बी) के लिए ufunc op लागू करें।
ufunc.at (ए, सूचकांक [, बी]) 'सूचकांकों' द्वारा निर्दिष्ट तत्वों के लिए ऑपरेंड 'ए' पर जगह के संचालन में असंबद्ध प्रदर्शन करता है।

चेतावनी

डेटा-प्रकार के साथ एक सरणी पर एक कम-जैसे ऑपरेशन जिसमें रेंज "बहुत छोटा" है, जिसके परिणामस्वरूप परिणाम को चुपचाप लपेट दिया जाएगा। डेटा-प्रकार का आकार बढ़ाने के लिए dtype का उपयोग करना चाहिए, जिस पर कमी होती है।

उपलब्ध ufuncs

वर्तमान में एक या अधिक प्रकारों पर 60 से अधिक सार्वभौमिक कार्य परिभाषित किए numpy हैं, जो विभिन्न प्रकार के संचालन को कवर करते हैं। जब प्रासंगिक infix संकेतन का उपयोग किया जाता है ( उदाहरण के लिए , add(a, b) आंतरिक रूप से कहा जाता है जब a + b लिखा जाता है और a या b एक ndarray होता है तो इनमें से कुछ ufuncs को स्वचालित रूप से सरणियों पर कहा जाता है। फिर भी, आप अपनी पसंद के ऑब्जेक्ट (या ऑब्जेक्ट्स) में आउटपुट (s) रखने के लिए वैकल्पिक आउटपुट तर्क (ओं) का उपयोग करने के लिए ufunc कॉल का उपयोग करना चाह सकते हैं।

याद रखें कि प्रत्येक ufunc तत्व-दर-तत्व को संचालित करता है। इसलिए, प्रत्येक स्केलर ufunc को वर्णित किया जाएगा जैसे कि स्केलर आउटपुट के सेट को वापस करने के लिए स्केलर इनपुट के एक सेट पर अभिनय करना।

ध्यान दें

यदि आप वैकल्पिक आउटपुट तर्क का उपयोग करते हैं तब भी ufunc अपना आउटपुट लौटाता है।

मठ संचालन

add (X1, x2, / [, आउट, जहां, कास्टिंग, ऑर्डर,…]) तत्व-वार जोड़ें।
subtract (X1, x2, / [, बाहर, जहां, कास्टिंग,…]) तर्क-वितर्क, तत्व-वार।
multiply (X1, x2, / [, आउट, जहां, कास्टिंग,…]) तत्व-वार बहुगुणित।
divide (X1, x2, / [, आउट, जहां, कास्टिंग,…]) तत्व-वार, इनपुट्स का एक सही विभाजन लौटाता है।
logaddexp (X1, x2, / [, आउट, जहां, कास्टिंग,…]) इनपुट्स के घातांक के योग का लघुगणक।
logaddexp2 (X1, x2, / [, आउट, जहां, कास्टिंग,…]) बेस -2 में आदानों के घातांक के योग का लघुगणक।
true_divide (X1, x2, / [, out, where,…]) तत्व-वार, इनपुट्स का एक सही विभाजन लौटाता है।
floor_divide (X1, x2, / [, आउट, जहां,…]) इनपुट के विभाजन के बराबर सबसे बड़ा पूर्णांक लौटाएँ।
negative (x, / [, बाहर, जहां, कास्टिंग, ऑर्डर,…]) संख्यात्मक नकारात्मक, तत्व-वार।
positive (एक्स, / [, बाहर, जहां, कास्टिंग, ऑर्डर,…]) संख्यात्मक सकारात्मक, तत्व-वार।
power (X1, x2, / [, आउट, जहां, कास्टिंग,…]) पहले सरणी तत्वों को दूसरे सरणी से तत्वों के लिए उठाया गया, तत्व-वार।
remainder (X1, x2, / [, बाहर, जहां, कास्टिंग, ...]) वापसी तत्व-वार शेष विभाजन।
mod (X1, x2, / [, आउट, जहां, कास्टिंग, ऑर्डर,…]) वापसी तत्व-वार शेष विभाजन।
fmod (X1, x2, / [, आउट, जहां, कास्टिंग,…]) विभाजन के तत्व-वार शेष को लौटाएं।
divmod (X1, x2 [, out1, out2], / [[, out,…]) तत्व-वार भागफल लौटाएँ और एक साथ शेष रहें।
absolute (एक्स, / [, बाहर, जहां, कास्टिंग, ऑर्डर,…]) निरपेक्ष मूल्य तत्व-वार की गणना करें।
fabs (एक्स, / [, आउट, जहां, कास्टिंग, ऑर्डर,…]) तत्व-वार पूर्ण मूल्यों की गणना करें।
rint (एक्स, / [, आउट, जहां, कास्टिंग, ऑर्डर,…]) निकटतम पूर्णांक के लिए सरणी के गोल तत्व।
sign (x, / [, आउट, जहां, कास्टिंग, ऑर्डर,…]) एक संख्या के संकेत का एक तत्व-वार संकेत लौटाता है।
heaviside (X1, x2, / [, आउट, जहां, कास्टिंग,…]) हीविसाइड चरण फ़ंक्शन की गणना करें।
conj (एक्स, / [, बाहर, जहां, कास्टिंग, ऑर्डर,…]) जटिल संयुग्म, तत्व-वार लौटें।
exp (x, / [, आउट, जहां, कास्टिंग, ऑर्डर,…]) इनपुट सरणी में सभी तत्वों के घातांक की गणना करें।
exp2 (x, / [, आउट, जहां, कास्टिंग, ऑर्डर,…]) इनपुट सरणी में सभी 2**p लिए 2**p गणना करें।
log (x, / [, आउट, जहां, कास्टिंग, ऑर्डर,…]) प्राकृतिक लघुगणक, तत्व-वार।
log2 (x, / [, आउट, जहां, कास्टिंग, ऑर्डर,…]) बेस -2 लघुगणक x
log10 (x, / [, आउट, जहां, कास्टिंग, ऑर्डर,…]) तत्व-वार, इनपुट सरणी के आधार 10 लघुगणक को लौटाएं।
expm1 (एक्स, / [, आउट, जहां, कास्टिंग, ऑर्डर,…]) सरणी में सभी तत्वों के लिए exp(x) - 1 गणना करें।
log1p (x, / [, आउट, जहां, कास्टिंग, ऑर्डर,…]) एक से अधिक इनपुट सरणी, तत्व-वार का प्राकृतिक लघुगणक लौटाएं।
sqrt (x, / [, आउट, जहां, कास्टिंग, ऑर्डर,…]) तत्व-वार के एक वर्ग के सकारात्मक वर्ग-मूल को लौटाएं।
square (x, / [, बाहर, जहां, कास्टिंग, ऑर्डर,…]) इनपुट के तत्व-वार वर्ग को लौटाएं।
cbrt (x, / [, आउट, जहां, कास्टिंग, ऑर्डर,…]) तत्व-वार, किसी सरणी के घन-मूल को लौटाएँ।
reciprocal (x, / [, बाहर, जहां, कास्टिंग,…]) तत्व-वार तर्क की पारस्परिक वापसी करें।

टिप

वैकल्पिक आउटपुट तर्कों का उपयोग आपको बड़ी गणनाओं के लिए मेमोरी को बचाने में मदद करने के लिए किया जा सकता है। यदि आपकी सरणियाँ बड़ी हैं, तो जटिल अभिव्यक्ति निर्माण के कारण और (बाद में) अस्थायी गणना स्थानों को नष्ट करने के लिए बिल्कुल आवश्यक से अधिक समय ले सकती हैं। उदाहरण के लिए, अभिव्यक्ति G = a * b + c t1 = A * B; G = T1 + C; del t1 बराबर है t1 = A * B; G = T1 + C; del t1 t1 = A * B; G = T1 + C; del t1 t1 = A * B; G = T1 + C; del t1 । इसे G = A * B; add(G, C, G) रूप में अधिक तेज़ी से निष्पादित किया जाएगा G = A * B; add(G, C, G) G = A * B; add(G, C, G) जो G = A * B; G += C G = A * B; G += C

त्रिकोणमितीय फलन

जब एक कोण के लिए बुलाया जाता है तो सभी त्रिकोणमितीय फ़ंक्शन रेडियन का उपयोग करते हैं। रेडियन के लिए डिग्री का अनुपात है 180 ^ {\ circ} / \ pi।

sin (एक्स, / [, बाहर, जहां, कास्टिंग, ऑर्डर,…]) त्रिकोणमितीय साइन, तत्व-वार।
cos (x, / [, out, where, कास्टिंग, ऑर्डर,…]) कोसिन तत्व-वार।
tan (एक्स, / [, आउट, जहां, कास्टिंग, ऑर्डर,…]) संगति तत्व-वार।
arcsin (x, / [, आउट, जहां, कास्टिंग, ऑर्डर,…]) उलटा साइन, तत्व-वार।
arccos (एक्स, / [, आउट, जहां, कास्टिंग, ऑर्डर,…]) त्रिकोणमितीय व्युत्क्रम कोसाइन, तत्व-वार।
arctan (x, / [, आउट, जहां, कास्टिंग, ऑर्डर,…]) त्रिकोणमितीय व्युत्क्रम स्पर्शरेखा, तत्व-वार।
arctan2 (X1, x2, / [, आउट, जहां, कास्टिंग,…]) चतुर्थांश को सही ढंग से चुनने के लिए ए 1 x1/x2 तत्व-वार चाप स्पर्शरेखा।
hypot (एक्स 1, एक्स 2, / [, आउट, जहां, कास्टिंग,…]) एक सही त्रिकोण के "पैर" को देखते हुए, इसके कर्ण को लौटाएं।
sinh (एक्स, / [, आउट, जहां, कास्टिंग, ऑर्डर,…]) अतिशयोक्तिपूर्ण साइन, तत्व-वार।
cosh (x, / [, आउट, जहां, कास्टिंग, ऑर्डर,…]) अतिशयोक्तिपूर्ण कोसाइन, तत्व-वार।
tanh (एक्स, / [, आउट, जहां, कास्टिंग, ऑर्डर,…]) हाइपरबोलिक स्पर्शरेखा तत्व-वार की गणना करें।
arcsinh (एक्स, / [, आउट, जहां, कास्टिंग, ऑर्डर,…]) उलटा हाइपरबोलिक साइन तत्व-वार।
arccosh (एक्स, / [, आउट, जहां, कास्टिंग, ऑर्डर,…]) तत्व-वार अतिशयोक्तिपूर्ण कोस।
arctanh (x, / [, आउट, जहां, कास्टिंग, ऑर्डर,…]) उलटा स्पर्शशील तत्व-वार।
deg2rad (x, / [, बाहर, जहां, कास्टिंग, ऑर्डर,…]) कोणों को डिग्री से रेडियन में बदलें।
rad2deg (x, / [, आउट, जहां, कास्टिंग, ऑर्डर,…]) रेडियन से कोणों को डिग्री में बदलें।

बिट-ट्विडलिंग फ़ंक्शन

इन फ़ंक्शन को सभी पूर्णांक तर्कों की आवश्यकता होती है और वे उन तर्कों के बिट-पैटर्न में हेरफेर करते हैं।

bitwise_and (X1, x2, / [, आउट, जहां,…]) तत्व-वार के दो-बिट और वार की गणना करें।
bitwise_or (X1, x2, / [, आउट, जहां, कास्टिंग,…]) तत्व-वार के बिट-वार या दो सरणियों की गणना करें।
bitwise_xor (X1, x2, / [, आउट, जहां,…]) तत्व-वार दो सरणियों के बिट-वार XOR की गणना करें।
invert (एक्स, / [, बाहर, जहां, कास्टिंग, ऑर्डर,…]) बिट-वार उलटा, या बिट-वार नहीं, तत्व-वार की गणना करें।
left_shift (X1, x2, / [, आउट, जहां, कास्टिंग,…]) एक पूर्णांक के बिट्स को बाईं ओर शिफ्ट करें।
right_shift (X1, x2, / [, out, where,…]) पूर्णांक के बिट्स को दाईं ओर शिफ्ट करें।

तुलना कार्य

greater (X1, x2, / [, आउट, जहां, कास्टिंग,…]) (X1> x2) तत्व-वार का सत्य मान लौटाएं।
greater_equal (X1, x2, / [, बाहर, जहां,…)) तत्व-वार (X1> = x2) का सत्य मान लौटाएं।
less (X1, x2, / [, आउट, जहां, कास्टिंग,…]) (X1 <x2) तत्व-वार का सत्य मान लौटाएं।
less_equal (X1, x2, / [, आउट, जहां, कास्टिंग,…]) तत्व-वार (X1 = <x2) का सत्य मान लौटाएँ।
not_equal (X1, x2, / [, आउट, जहां, कास्टिंग,…]) वापसी (X1! = X2) तत्व-वार।
equal (X1, x2, / [, आउट, जहां, कास्टिंग,…]) वापसी (X1 == x2) तत्व-वार।

चेतावनी

पाइथन कीवर्ड का उपयोग न करें और or तार्किक सरणी अभिव्यक्तियों को संयोजित करने के लिए। ये कीवर्ड पूरे एरे के सत्य मूल्य (तत्व-दर-तत्व के रूप में आपकी अपेक्षा के अनुसार) का परीक्षण करेंगे। बिटवाइज ऑपरेटरों और का उपयोग करें | बजाय।

logical_and (एक्स 1, एक्स 2, / [, आउट, जहां,…]) X1 और x2 तत्व-वार के सत्य मान की गणना करें।
logical_or (X1, x2, / [, आउट, जहां, कास्टिंग,…]) X1 या x2 तत्व-वार के सत्य मान की गणना करें।
logical_xor (X1, x2, / [, आउट, जहां,…]) तत्व-वार, X1 XOR x2 के सत्य मूल्य की गणना करें।
logical_not (x, / [, बाहर, जहां, कास्टिंग, ...]) नहीं x- वार के सत्य मान की गणना करें।

चेतावनी

बिट-वार ऑपरेटरों और | तत्व-दर-तत्व सरणी तुलना करने के लिए उचित तरीका है। सुनिश्चित करें कि आप ऑपरेटर की पूर्वता को समझते हैं: (a > 2) & (a < 5) उचित वाक्यविन्यास है क्योंकि a > 2 & a < 5 इस तथ्य के कारण त्रुटि होगी कि 2 & a का पहले मूल्यांकन किया गया है।

maximum (X1, x2, / [, आउट, जहां, कास्टिंग,…]) सरणी तत्वों के तत्व-वार अधिकतम।

टिप

पायथन फ़ंक्शन max() एक-आयामी सरणी पर अधिकतम मिलेगा, लेकिन यह धीमी अनुक्रम इंटरफ़ेस का उपयोग करके ऐसा करेगा। अधिकतम ufunc की कम विधि बहुत तेज है। इसके अलावा, max() विधि उन उत्तरों को नहीं देगी जिनके लिए आप एक से अधिक आयाम वाले सरणियों की अपेक्षा कर सकते हैं। न्यूनतम की कम विधि आपको किसी सरणी पर कुल न्यूनतम गणना करने की अनुमति देती है।

minimum (X1, x2, / [, आउट, जहां, कास्टिंग,…]) सरणी तत्वों का तत्व-वार न्यूनतम।

चेतावनी

maximum(a, b) का व्यवहार maximum(a, b) की तुलना में अलग है। एक ufunc के रूप में, maximum(a, b) a और b तत्व-दर-तत्व की तुलना a और परिणाम के प्रत्येक तत्व को चुनता है कि दो सरणियों में किस तत्व के अनुसार बड़ा है। इसके विपरीत, max(a, b) वस्तुओं को पूरी तरह से और b रूप में मानता है, a > b कुल (सत्य) सत्य मूल्य को देखता है और इसका उपयोग या तो a या b (पूरे के रूप में) वापस करने के लिए करता है। minimum(a, b) और min(a, b) बीच एक समान अंतर मौजूद है।

fmax (X1, x2, / [, आउट, जहां, कास्टिंग,…]) सरणी तत्वों के तत्व-वार अधिकतम।
fmin (X1, x2, / [, आउट, जहां, कास्टिंग,…]) सरणी तत्वों का तत्व-वार न्यूनतम।

अस्थायी कार्य

याद रखें कि ये सभी फ़ंक्शंस, एरे आउटपुट पर एक एलीमेंट पर एलीमेंट-बाय-एलिमेंट काम करते हैं। विवरण केवल एक ही ऑपरेशन का विवरण देता है।

isfinite (x, / [, आउट, जहां, कास्टिंग, ऑर्डर,…]) परिमितता के लिए तत्व-वार परीक्षण (न कि अनंतता और न संख्या नहीं)।
isinf (x, / [, आउट, जहां, कास्टिंग, ऑर्डर,…]) सकारात्मक या नकारात्मक अनंत के लिए तत्व-वार का परीक्षण करें।
isnan (एक्स, / [, आउट, जहां, कास्टिंग, ऑर्डर,…]) NaN के लिए तत्व-वार का परीक्षण करें और एक बूलियन सरणी के रूप में वापस लौटें।
isnat (x, / [, आउट, जहां, कास्टिंग, ऑर्डर,…]) NaT (एक समय नहीं) के लिए तत्व-वार का परीक्षण करें और एक बूलियन सरणी के रूप में परिणाम लौटाएं।
fabs (एक्स, / [, आउट, जहां, कास्टिंग, ऑर्डर,…]) तत्व-वार पूर्ण मूल्यों की गणना करें।
signbit (x, / [, आउट, जहां, कास्टिंग, ऑर्डर,…]) तत्व-वार लौटाता है सत्य जहां साइनबिट सेट किया गया है (शून्य से कम)।
copysign (X1, x2, / [, बाहर, जहां, कास्टिंग,…]) तत्व-वार X2 के संकेत को X2 में बदलें।
nextafter (X1, x2, / [, आउट, जहां, कास्टिंग,…]) तत्व-वार X2 की ओर X1 के बाद अगला फ़्लोटिंग-पॉइंट मान लौटाएँ।
spacing (x, / [, बाहर, जहां, कास्टिंग, ऑर्डर,…]) X और निकटतम सन्निकट संख्या के बीच की दूरी वापस करें।
modf (x [, out1, out2], / [[, out, where,…]] तत्व-वार के एक अंश के भिन्नात्मक और अभिन्न अंग लौटें।
ldexp (X1, x2, / [, आउट, जहां, कास्टिंग,…]) रिटर्न एक्स 1 * 2 ** एक्स 2, तत्व-वार।
frexp (x [, out1, out2], / [[, out, where,…]] मंटिसा और ट्वोस एक्सपोनेंट में एक्स के तत्वों का विघटन करें।
fmod (X1, x2, / [, आउट, जहां, कास्टिंग,…]) विभाजन के तत्व-वार शेष को लौटाएं।
floor (एक्स, / [, बाहर, जहां, कास्टिंग, ऑर्डर,…]) तत्व-वार, इनपुट के फ़र्श पर लौटें।
ceil (एक्स, / [, बाहर, जहां, कास्टिंग, ऑर्डर,…]) तत्व-वार, इनपुट की छत लौटाएं।
trunc (एक्स, / [, आउट, जहां, कास्टिंग, ऑर्डर,…]) तत्व-वार, इनपुट का छोटा मान लौटाएं।