एरे एपीआई

सरणी संरचना और डेटा एक्सेस

ये मैक्रोज़ सभी PyArrayObject संरचना सदस्यों तक PyArrayObject हैं। इनपुट तर्क, PyObject * , कोई भी PyObject * हो सकता है जो सीधे PyArrayObject ( PyArrayObject कोई भी उदाहरण और इसके उप-प्रकार) के रूप में व्याख्या करने PyArray_Type ।

int PyArray_NDIM(PyArrayObject *arr)

सरणी में आयामों की संख्या।

npy_intp *PyArray_DIMS(PyArrayObject *arr)

सरणी के आयाम / आकार के लिए एक सूचक लौटाता है। तत्वों की संख्या सरणी के आयामों की संख्या से मेल खाती है।

npy_intp *PyArray_SHAPE(PyArrayObject *arr)

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

PyArray_DIMS का एक पर्यायवाची, जिसका नाम पायथन के भीतर 'आकार' के उपयोग के अनुरूप है।

void *PyArray_DATA(PyArrayObject *arr)

char *PyArray_BYTES(PyArrayObject *arr)

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

npy_intp *PyArray_STRIDES(PyArrayObject* arr)

सरणी के स्ट्राइड के लिए एक पॉइंटर लौटाता है। तत्वों की संख्या सरणी के आयामों की संख्या से मेल खाती है।

npy_intp PyArray_DIM(PyArrayObject* arr, int n)

N में आकार वापस करें आयाम।

npy_intp PyArray_STRIDE(PyArrayObject* arr, int n)

एन में स्ट्राइड लौटें आयाम।

PyObject *PyArray_BASE(PyArrayObject* arr)

यह सरणी का आधार ऑब्जेक्ट देता है। ज्यादातर मामलों में, इसका मतलब यह है कि जिस ऑब्जेक्ट की मेमोरी सरणी है वह इंगित करता है।

यदि आप C API का उपयोग करके एक सरणी का निर्माण कर रहे हैं, और अपनी स्वयं की मेमोरी को निर्दिष्ट कर रहे हैं, तो आपको आधार का उपयोग मेमोरी के स्वामित्व वाले ऑब्जेक्ट को सेट करने के लिए PyArray_SetBaseObject फ़ंक्शन का उपयोग करना चाहिए।

यदि (पदावनत) NPY_ARRAY_UPDATEIFCOPY या NPY_ARRAY_WRITEBACKIFCOPY झंडे सेट किए गए हैं, तो इसका एक अलग अर्थ है, जिसका आधार वह सरणी है जिसमें कॉपी रिज़ॉल्यूशन पर वर्तमान सरणी कॉपी की जाएगी। दो कार्यों के लिए आधार संपत्ति का यह ओवरलोडिंग भविष्य के NumPy संस्करण में बदलने की संभावना है।

PyArray_Descr *PyArray_DESCR(PyArrayObject* arr)

सरणी के dtype गुण के लिए एक उधार संदर्भ देता है।

PyArray_Descr *PyArray_DTYPE(PyArrayObject* arr)

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

PyArray_DESCR का एक पर्यायवाची, जिसका नाम पायथन के भीतर 'dtype' के उपयोग के अनुरूप है।

void PyArray_ENABLEFLAGS(PyArrayObject* arr, int flags)

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

निर्दिष्ट सरणी ध्वज सक्षम करता है। यह फ़ंक्शन कोई सत्यापन नहीं करता है, और मानता है कि आप जानते हैं कि आप क्या कर रहे हैं।

void PyArray_CLEARFLAGS(PyArrayObject* arr, int flags)

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

निर्दिष्ट सरणी झंडे को साफ करता है। यह फ़ंक्शन कोई सत्यापन नहीं करता है, और मानता है कि आप जानते हैं कि आप क्या कर रहे हैं।

int PyArray_FLAGS(PyArrayObject* arr)

npy_intp PyArray_ITEMSIZE(PyArrayObject* arr)

इस ऐरे के तत्वों के लिए आइटमाइज करें।

ध्यान दें कि, पुराने API में जो संस्करण 1.7 में पदावनत किया गया था, इस फ़ंक्शन का रिटर्न प्रकार int ।

int PyArray_TYPE(PyArrayObject* arr)

इस सरणी के तत्वों के लिए (बिल्टइन) टाइप करें।

PyObject *PyArray_GETITEM(PyArrayObject* arr, void* itemptr)

आइटमपार्ट द्वारा बताए गए स्थान पर ndarray, गिरफ्तारी से एक पायथन ऑब्जेक्ट प्राप्त करें। वापसी विफलता पर।

int PyArray_SETITEM(PyArrayObject* arr, void* itemptr, PyObject* obj)

Obj में कनवर्ट करें और इसे ndarray में रखें, गिरफ्तारी, आइटम द्वारा इंगित स्थान पर। रिटर्न -1 अगर कोई त्रुटि होती है या 0 सफलता पर।

npy_intp PyArray_SIZE(PyArrayObject* arr)

सरणी का कुल आकार (तत्वों की संख्या में) लौटाता है।

npy_intp PyArray_Size(PyArrayObject* obj)

रिटर्न 0 अगर obj ndarray का उप-वर्ग नहीं है। अन्यथा, सरणी में तत्वों की कुल संख्या लौटाता है। PyArray_SIZE ( obj ) का सुरक्षित संस्करण।

npy_intp PyArray_NBYTES(PyArrayObject* arr)

सरणी द्वारा खपत बाइट्स की कुल संख्या लौटाता है।

डेटा प्राप्त करना

ये फ़ंक्शन और मैक्रोज़ सी से ndarray के तत्वों तक आसान पहुंच प्रदान करते हैं। ये सभी सरणियों के लिए काम करते हैं। सरणी में डेटा का उपयोग करते समय आपको ध्यान रखने की आवश्यकता हो सकती है, हालांकि, अगर यह मशीन बाइट-ऑर्डर में नहीं है, गलत है, या लेखन योग्य नहीं है। दूसरे शब्दों में, झंडे की स्थिति का सम्मान करना सुनिश्चित करें जब तक कि आप नहीं जानते कि आप क्या कर रहे हैं, या पहले एक सरणी की गारंटी दी है जो कि PyArray_FromAny योग्य, संरेखित है, और PyArray_FromAny का उपयोग करके मशीन बाइट-ऑर्डर में है। यदि आप सभी प्रकार के सरणियों को संभालना चाहते हैं, तो प्रत्येक प्रकार के लिए कॉपीराइट कार्य दुर्व्यवहार करने वाले सरणियों को संभालने के लिए उपयोगी है। कुछ प्लेटफ़ॉर्म (उदाहरण के लिए सोलारिस) गलत डेटा को पसंद नहीं करते हैं और यदि आप एक ग़लत संकेत देते हैं तो यह क्रैश हो जाएगा। अन्य प्लेटफ़ॉर्म (जैसे x86 लिनक्स) केवल गलत डेटा के साथ अधिक धीरे-धीरे काम करेगा।

void* PyArray_GetPtr(PyArrayObject* aobj, npy_intp* ind)

सी-सरणी, इंड (जो कि कम से कम aobj -> nd आकार में होना चाहिए) द्वारा दिए गए एन-डायमेंशनल इंडेक्स पर ndarray , aobj के डेटा के लिए एक पॉइंटर लौटाएं। आप ndarray के डेटा प्रकार में दिए गए पॉइंटर को टाइप करना चाहते हैं।

void* PyArray_GETPTR1(PyArrayObject* obj, npy_intp i)

void* PyArray_GETPTR2(PyArrayObject* obj, npy_intp i, npy_intp j)

void* PyArray_GETPTR3(PyArrayObject* obj, npy_intp i, npy_intp j, npy_intp k)

void* PyArray_GETPTR4(PyArrayObject* obj, npy_intp i, npy_intp j, npy_intp k, npy_intp l)

Ndarray, obj में दिए गए निर्देशांक पर तत्व के लिए त्वरित, इनलाइन एक्सेस, जिसमें क्रमशः 1, 2, 3 या 4 आयाम होना चाहिए (यह चेक नहीं किया गया है)। इसी i , j , k , और l निर्देशांक किसी भी पूर्णांक हो सकते हैं लेकिन npy_intp रूप में व्याख्या की npy_intp । आप ndarray के डेटा प्रकार में दिए गए पॉइंटर को टाइप करना चाहते हैं।

सरणियाँ बनाना

शुरुवात से

PyObject* PyArray_NewFromDescr(PyTypeObject* subtype, PyArray_Descr* descr, int nd, npy_intp* dims, npy_intp* strides, void* data, int flags, PyObject* obj)

यह फ़ंक्शन descr का संदर्भ चुराता है।

यह मुख्य सरणी निर्माण फ़ंक्शन है। इस लचीले फ़ंक्शन के साथ अधिकांश नए सरणियाँ बनाई जाती हैं।

लौटी हुई वस्तु पायथन-प्रकार के उपप्रकार की एक वस्तु है, जो PyArray_Type उपप्रकार होना चाहिए। सरणी में nd आयाम हैं, जिन्हें dims द्वारा वर्णित किया गया है। नए एरे का डेटा-टाइप डिस्क्रिप्टर descr है ।

यदि उप-प्रकार आधार PyArray_Type बजाय एक सरणी उपवर्ग का है, तो उप-वर्ग की __array_finalize__ विधि को पास करने के लिए obj ऑब्जेक्ट है।

यदि डेटा NULL , तो नई मेमोरी को आबंटित किया जाएगा और फ़ोर्ट्रान-शैली सन्निहित सरणी को इंगित करने के लिए झंडे को गैर-शून्य किया जा सकता है। यदि डेटा NULL नहीं NULL , तो यह सरणी के लिए उपयोग की जाने वाली मेमोरी को इंगित करने के लिए माना जाता है और फ़्लैग तर्क को सरणी के लिए नए फ़्लैग के रूप में उपयोग किया जाता है ( NPY_OWNDATA , NPY_ARRAY_WRITEBACKIFCOPY और NPY_ARRAY_UPDATEIFCOPY फ़्लैग को छोड़कर) रीसेट हो)।

इसके अलावा, यदि डेटा गैर-पूर्ण है, तो स्ट्राइड भी प्रदान किया जा सकता है। यदि स्ट्राइड्स NULL , तो NPY_ARRAY_F_CONTIGUOUS की गणना C-style contiguous (डिफॉल्ट) या फ़ोर्ट्रान-स्टाइल NPY_ARRAY_F_CONTIGUOUS जाती है ( झंडे डेटा के लिए NPY_ARRAY_F_CONTIGUOUS = NULL या NPY_ARRAY_F_CONTIGUOUS और NPY_ARRAY_F_CONTIGUOUS नॉन- NPY_ARRAY_F_CONTIGUOUS डेटा है )। किसी भी प्रदान की गई डैमेज और स्ट्राइड्स को नए आबंटित आयामों में कॉपी किया जाता है और नए एरे ऑब्जेक्ट के लिए एरोइड्स को कवर किया जाता है।

PyObject* PyArray_NewLikeArray(PyArrayObject* prototype, NPY_ORDER order, PyArray_Descr* descr, int subok)

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

यह फ़ंक्शन यदि NULL नहीं है तो descr का संदर्भ चुराता है।

यह सरणी निर्माण दिनचर्या मौजूदा सरणी के आकार और मेमोरी लेआउट से मेल खाते नए लेआउट के सुविधाजनक निर्माण के लिए अनुमति देती है, संभवतः लेआउट और / या डेटा प्रकार को बदल सकती है।

जब आदेश NPY_ANYORDER , तो परिणाम आदेश NPY_FORTRANORDER यदि प्रोटोटाइप एक फोरट्रान सरणी है, तो NPY_CORDER अन्यथा। जब ऑर्डर NPY_KEEPORDER , तो परिणाम ऑर्डर प्रोटोटाइप से मेल खाता है, भले ही प्रोटोटाइप के अक्ष C या फोरट्रान ऑर्डर में न हों।

यदि descr NULL है, तो डेटा प्रकार के प्रोटोटाइप का उपयोग किया जाता है।

यदि सबोक 1 है, तो नया बनाया गया सरणी नए सरणी बनाने के लिए उप-प्रकार के प्रोटोटाइप का उपयोग करेगा, अन्यथा यह एक बेस-क्लास सरणी बनाएगा।

PyObject* PyArray_New(PyTypeObject* subtype, int nd, npy_intp* dims, int type_num, npy_intp* strides, void* data, int itemsize, int flags, PyObject* obj)

यह PyArray_NewFromDescr (…) के समान है, सिवाय इसके कि आप type_num और dataize के साथ डेटा-टाइप डिस्क्रिप्टर निर्दिष्ट करें, जहाँ टाइप_नम एक बिलिन (या उपयोगकर्ता-परिभाषित) प्रकार से मेल खाती है। यदि प्रकार में हमेशा बाइट्स की समान संख्या होती है, तो आइटमाइज़ को अनदेखा किया जाता है। अन्यथा, आइटम इस सरणी के विशेष आकार को निर्दिष्ट करता है।

PyObject* PyArray_SimpleNew(int nd, npy_intp* dims, int typenum)

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

PyObject* PyArray_SimpleNewFromData(int nd, npy_intp* dims, int typenum, void* data)

दिए गए पॉइंटर द्वारा इंगित डेटा के चारों ओर एक सरणी आवरण बनाएं। एरे झंडे में एक डिफ़ॉल्ट होगा कि डेटा क्षेत्र अच्छी तरह से व्यवहार किया गया है और सी-शैली सन्निहित है। सरणी का आकार लंबाई nd के dims सी-सरणी द्वारा दिया गया है। सरणी का डेटा-प्रकार टाइपेनम द्वारा इंगित किया गया है ।

PyObject* PyArray_SimpleNewFromDescr(int nd, npy_intp* dims, PyArray_Descr* descr)

यह फ़ंक्शन यदि NULL नहीं है तो descr का संदर्भ चुराता है।

Nd और dims द्वारा निर्धारित आकृति के प्रदान किए गए डेटा-प्रकार के विवरणक, descr के साथ एक नया सरणी बनाएं।

PyArray_FILLWBYTE(PyObject* obj, int val)

Obj -which द्वारा इंगित सरणी को भरें (उप का) ndarray - वैल की सामग्री (बाइट के रूप में मूल्यांकन) के साथ होना चाहिए। इस मैक्रो को मेमसेट कहा जाता है, इसलिए obj को सन्निहित होना चाहिए।

PyObject* PyArray_Zeros(int nd, npy_intp* dims, PyArray_Descr* dtype, int fortran)

Dtype द्वारा दिए गए आकार और डेटा प्रकार द्वारा दिए गए आकार के साथ एक नया nd -dimensional अरै का निर्माण करें। यदि फोरट्रान गैर-शून्य है, तो एक फोरट्रान-ऑर्डर सरणी बनाई जाती है, अन्यथा सी-ऑर्डर सरणी बनाई जाती है। स्मृति को शून्य से भरें (या यदि dtype NPY_OBJECT से मेल खाती है तो 0 ऑब्जेक्ट)।

PyObject* PyArray_ZEROS(int nd, npy_intp* dims, int type_num, int fortran)

PyArray_Zeros का मैक्रो रूप जो डेटा-टाइप ऑब्जेक्ट के बजाय एक प्रकार-संख्या लेता है।

PyObject* PyArray_Empty(int nd, npy_intp* dims, PyArray_Descr* dtype, int fortran)

Dtype द्वारा दिए गए आकार और डेटा प्रकार द्वारा दिए गए आकार के साथ एक नया nd -dimensional अरै का निर्माण करें। यदि फोरट्रान गैर-शून्य है, तो एक फोरट्रान-ऑर्डर सरणी बनाई जाती है, अन्यथा सी-ऑर्डर सरणी बनाई जाती है। जब तक डेटा प्रकार NPY_OBJECT से NPY_OBJECT नहीं होता है, तब तक सरणी NPY_OBJECT , जिस स्थिति में सरणी Py_None से भरी Py_None ।

PyObject* PyArray_EMPTY(int nd, npy_intp* dims, int typenum, int fortran)

PyArray_Empty का मैक्रो रूप जो डेटा-टाइप ऑब्जेक्ट के बजाय टाइप-नंबर, टाइपेनम लेता है।

PyObject* PyArray_Arange(double start, double stop, double step, int typenum)

डेटा-टाइप, टाइपेनम की एक नई 1-आयामी सरणी का निर्माण करें, जो शुरू से लेकर चरण की वृद्धि में बंद (अनन्य) तक होती है। व्यवस्था के समतुल्य ( प्रारंभ , रोक , कदम , dtype)।

PyObject* PyArray_ArangeObj(PyObject* start, PyObject* stop, PyObject* step, PyArray_Descr* descr)

descr द्वारा निर्धारित डेटा-प्रकार के एक नए 1-आयामी सरणी का निर्माण करें, जो कि step वेतन वृद्धि में start से लेकर (अनन्य) तक होता है। व्यवस्था के समतुल्य ( start , stop , step , typenum )।

int PyArray_SetBaseObject(PyArrayObject* arr, PyObject* obj)

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

यह फ़ंक्शन obj संदर्भ चुराता है और इसे obj की आधार संपत्ति के रूप में सेट करता है।

यदि आप पैरामीटर के रूप में अपने स्वयं के मेमोरी बफर में पास करके एक सरणी का निर्माण करते हैं, तो आपको मेमोरी बफर के जीवनकाल को सुनिश्चित करने के लिए सरणी के base गुण को सेट करने की आवश्यकता है।

रिटर्न वैल्यू 0 सफलता पर, -1 असफलता पर है।

यदि प्रदान की गई वस्तु एक सरणी है, तो यह फ़ंक्शन base पॉइंटर्स की श्रृंखला का पता लगाता है ताकि प्रत्येक सरणी सीधे मेमोरी के मालिक को इंगित करे। एक बार आधार सेट हो जाने के बाद, इसे दूसरे मूल्य में नहीं बदला जा सकता है।

अन्य वस्तुओं से

PyObject* PyArray_FromAny(PyObject* op, PyArray_Descr* dtype, int min_depth, int max_depth, int requirements, PyObject* context)

यह किसी भी नेस्टेड अनुक्रम से एक सरणी प्राप्त करने के लिए इस्तेमाल किया जाने वाला मुख्य कार्य है, या ऑब्जेक्ट जो सरणी इंटरफ़ेस, ऑप को उजागर करता है। पैरामीटर आवश्यक dtype के विनिर्देश, न्यूनतम ( min_depth ) और स्वीकार्य अधिकतम और अधिकतम ( max_depth ) आयामों की संख्या और सरणी के लिए अन्य आवश्यकताओं की अनुमति देते हैं। Dtype तर्क को वांछित डेटा-प्रकार (आवश्यक बाइटऑर्डर सहित) को इंगित करने वाला PyArray_Descr संरचना होना चाहिए। Dtype तर्क NULL हो सकता है, यह दर्शाता है कि कोई भी डेटा-प्रकार (और बाइटऑर्डर) स्वीकार्य है। जब तक NPY_ARRAY_FORCECAST flags में मौजूद है, तब तक यह कॉल एक त्रुटि उत्पन्न करेगा यदि डेटा प्रकार को ऑब्जेक्ट से सुरक्षित रूप से प्राप्त नहीं किया जा सकता है। यदि आप dtype के लिए NULL का उपयोग करना चाहते हैं और यह सुनिश्चित करना चाहते हैं कि सरणी नॉटवर्ड की गई है, तो PyArray_CheckFromAny उपयोग PyArray_CheckFromAny । या तो गहराई मापदंडों के लिए 0 का मान पैरामीटर को अनदेखा करने का कारण बनता है। आवश्यकताओं के तर्क प्राप्त करने के लिए निम्न में से कोई भी फ़्लैग फ़्लैग ( जैसे का उपयोग करना) जोड़ा जा सकता है। यदि आपका कोड सामान्य संभाल सकता है ( उदाहरण के लिए तार, बाइट-स्वैड, या अनलॉन्ड एरेज़) तो आवश्यकताएं 0. हो सकती हैं। इसके अलावा, यदि ऑप पहले से कोई सरणी नहीं है (या सरणी इंटरफ़ेस को उजागर नहीं करता है), तो एक नया सरणी बनाया जाएगा (और अनुक्रम प्रोटोकॉल का उपयोग कर से भरा)। नए सरणी में इसके झंडे सदस्य के रूप में NPY_ARRAY_DEFAULT होगा। संदर्भ तर्क op की __array__ विधि के लिए दिया जाता है और इसका उपयोग केवल तब किया जाता है जब सरणी उस तरह से __array__ जाती है। लगभग हमेशा यह पैरामीटर NULL होता NULL ।

1.6 और इससे पहले के NumPy के संस्करणों में, निम्न झंडों में _ARRAY_ मैक्रो नेमस्पेस नहीं था। स्थिर नामों का वह रूप 1.7 में पदावनत है।

NPY_ARRAY_C_CONTIGUOUS

सुनिश्चित करें कि लौटाया गया सरणी C- शैली सन्निहित है

NPY_ARRAY_F_CONTIGUOUS

सुनिश्चित करें कि लौटा हुआ सरणी फोरट्रान-शैली सन्निहित है।

NPY_ARRAY_ALIGNED

सुनिश्चित करें कि लौटाया गया सरणी अपने डेटा प्रकार के लिए उचित सीमाओं पर संरेखित है। एक संरेखित सरणी में डेटा पॉइंटर-डिस्क्रिप्टर के लिए संरेखण कारक के कई के रूप में डेटा पॉइंटर और हर स्ट्राइड फैक्टर होता है।

NPY_ARRAY_WRITEABLE

सुनिश्चित करें कि दिए गए सरणी को लिखा जा सकता है।

NPY_ARRAY_ENSURECOPY

सुनिश्चित करें कि एक प्रति सेशन से बना है। यदि यह ध्वज मौजूद नहीं है, तो डेटा को कॉपी नहीं किया जाता है यदि इसे टाला जा सकता है।

NPY_ARRAY_ENSUREARRAY

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

NPY_ARRAY_FORCECAST

अगर यह सुरक्षित रूप से नहीं किया जा सकता है, भले ही उत्पादन प्रकार के लिए एक कलाकार को मजबूर करें। इस झंडे के बिना, एक डेटा कास्ट तभी होगा जब इसे सुरक्षित रूप से किया जा सकता है, अन्यथा एक त्रुटि उठाई जाती है।

NPY_ARRAY_WRITEBACKIFCOPY

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

NPY_ARRAY_UPDATEIFCOPY

पदावनत। NPY_ARRAY_WRITEBACKIFCOPY उपयोग करें, जो समान है। यह ध्वज "स्वचालित रूप से" डेटा को कॉपी करता है जब लौटे हुए सरणी को हटा दिया जाता है, जो सभी अजगर कार्यान्वयन में समर्थित नहीं है।

NPY_ARRAY_BEHAVED

NPY_ARRAY_ALIGNED | NPY_ARRAY_WRITEABLE

NPY_ARRAY_CARRAY

NPY_ARRAY_C_CONTIGUOUS | NPY_ARRAY_BEHAVED

NPY_ARRAY_CARRAY_RO

NPY_ARRAY_C_CONTIGUOUS | NPY_ARRAY_ALIGNED

NPY_ARRAY_FARRAY

NPY_ARRAY_F_CONTIGUOUS | NPY_ARRAY_BEHAVED

NPY_ARRAY_FARRAY_RO

NPY_ARRAY_F_CONTIGUOUS | NPY_ARRAY_ALIGNED

NPY_ARRAY_DEFAULT

NPY_ARRAY_CARRAY

NPY_ARRAY_IN_ARRAY

NPY_ARRAY_C_CONTIGUOUS | NPY_ARRAY_ALIGNED

NPY_ARRAY_IN_FARRAY

NPY_ARRAY_F_CONTIGUOUS | NPY_ARRAY_ALIGNED

NPY_OUT_ARRAY

NPY_ARRAY_C_CONTIGUOUS | NPY_ARRAY_WRITEABLE | NPY_ARRAY_ALIGNED

NPY_ARRAY_OUT_FARRAY

NPY_ARRAY_F_CONTIGUOUS | NPY_ARRAY_WRITEABLE | NPY_ARRAY_ALIGNED

NPY_ARRAY_INOUT_ARRAY

NPY_ARRAY_C_CONTIGUOUS | NPY_ARRAY_WRITEABLE | NPY_ARRAY_ALIGNED | NPY_ARRAY_WRITEBACKIFCOPY | NPY_ARRAY_UPDATEIFCOPY

NPY_ARRAY_INOUT_FARRAY

NPY_ARRAY_F_CONTIGUOUS | NPY_ARRAY_WRITEABLE | NPY_ARRAY_ALIGNED | NPY_ARRAY_WRITEBACKIFCOPY | NPY_ARRAY_UPDATEIFCOPY

int PyArray_GetArrayParamsFromObject(PyObject* op, PyArray_Descr* requested_dtype, npy_bool writeable, PyArray_Descr** out_dtype, int* out_ndim, npy_intp* out_dims, PyArrayObject** out_arr, PyObject* context)

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

एक मनमानी PyObject * को एक NumPy सरणी में देखने / परिवर्तित करने के लिए सरणी मापदंडों को पुनर्प्राप्त करता है। यह वास्तव में एक सरणी में परिवर्तित किए बिना पायथन सूची-ऑफ-सूचियों के "जन्मजात प्रकार और आकार" की अनुमति देता है। PyArray_FromAny इस फ़ंक्शन को इसके इनपुट का विश्लेषण करने के लिए कहता है।

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

यदि 'सेशन' में मान लिखना है, तो बूलियन को 'राइट करने योग्य' पर सेट करें। यह 'ऑप' स्केलर, सूचियों की सूची या अन्य गैर-लेखन योग्य 'ऑप' होने पर एक त्रुटि उत्पन्न करता है। यह NPY_ARRAY_WRITEABLE से गुजरने के लिए NPY_ARRAY_WRITEABLE से भिन्न होता है, जहां लेखनीय सरणी इनपुट की एक प्रति हो सकती है।

जब सफलता (0 रिटर्न वैल्यू) वापस आ जाती है, तो या तो out_arr को एक गैर-NULL PyArrayObject से भर दिया जाता है और बाकी पैरामीटर अछूते रहते हैं, या out_arr को NULL से भर दिया जाता है, और बाकी के मापदंडों को भर दिया जाता है।

विशिष्ट उपयोग:

PyArrayObject *arr = NULL;
PyArray_Descr *dtype = NULL;
int ndim = 0;
npy_intp dims[NPY_MAXDIMS];

if (PyArray_GetArrayParamsFromObject(op, NULL, 1, &dtype,
                                    &ndim, &dims, &arr, NULL) < 0) {
    return NULL;
}
if (arr == NULL) {
    ... validate/change dtype, validate flags, ndim, etc ...
    // Could make custom strides here too
    arr = PyArray_NewFromDescr(&PyArray_Type, dtype, ndim,
                                dims, NULL,
                                fortran ? NPY_ARRAY_F_CONTIGUOUS : 0,
                                NULL);
    if (arr == NULL) {
        return NULL;
    }
    if (PyArray_CopyObject(arr, op) < 0) {
        Py_DECREF(arr);
        return NULL;
    }
}
else {
    ... in this case the other parameters weren't filled, just
        validate and possibly copy arr itself ...
}
... use arr ...

PyObject* PyArray_CheckFromAny(PyObject* op, PyArray_Descr* dtype, int min_depth, int max_depth, int requirements, PyObject* context)

आवश्यकताओं के अलावा लगभग PyArray_FromAny (…) में NPY_ARRAY_NOTSWAPPED ( NPY_ARRAY_NOTSWAPPED में विनिर्देश को ओवर- राइड करना ) और NPY_ARRAY_ELEMENTSTRIDES शामिल हो सकते हैं, जो इंगित करता है कि सरणी को इस अर्थ में संरेखित किया जाना चाहिए कि NPY_ARRAY_ELEMENTSTRIDES तत्व आकार के गुणक हैं।

1.6 और इससे पहले के NumPy के संस्करणों में, निम्न झंडों में _ARRAY_ मैक्रो नेमस्पेस नहीं था। स्थिर नामों का वह रूप 1.7 में पदावनत है।

NPY_ARRAY_NOTSWAPPED

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

NPY_ARRAY_BEHAVED_NS

NPY_ARRAY_ALIGNED | NPY_ARRAY_WRITEABLE | NPY_ARRAY_NOTSWAPPED

NPY_ARRAY_ELEMENTSTRIDES

सुनिश्चित करें कि दिए गए सरणी में स्ट्राइड्स हैं जो तत्व आकार के गुणक हैं।

PyObject* PyArray_FromArray(PyArrayObject* op, PyArray_Descr* newtype, int requirements)

PyArray_FromAny का विशेष मामला जब ऑप पहले से ही एक सरणी है, लेकिन इसे एक विशिष्ट न्यूटाइप (बाइट-ऑर्डर सहित) या कुछ आवश्यकताओं की आवश्यकता है ।

PyObject* PyArray_FromStructInterface(PyObject* op)

पायथन ऑब्जेक्ट से एक __array_struct__ ऑब्जेक्ट __array_struct__ जो __array_struct__ विशेषता को उजागर करता है और सरणी इंटरफ़ेस प्रोटोकॉल का पालन करता है। यदि ऑब्जेक्ट में यह विशेषता नहीं है, तो Py_NotImplemented लिए उधार लिया गया संदर्भ वापस आ जाता है।

PyObject* PyArray_FromInterface(PyObject* op)

पायथन ऑब्जेक्ट से एक __array_interface__ ऑब्जेक्ट __array_interface__ जो __array_interface__ विशेषता को सरणी इंटरफ़ेस प्रोटोकॉल का अनुसरण करता है। यदि ऑब्जेक्ट में यह विशेषता नहीं है, तो Py_NotImplemented लिए उधार लिया गया संदर्भ वापस आ जाता है।

PyObject* PyArray_FromArrayAttr(PyObject* op, PyArray_Descr* dtype, PyObject* context)

पायथन ऑब्जेक्ट से एक __array__ ऑब्जेक्ट __array__ जो __array__ विधि को उजागर करता है। __array__ पद्धति में 0, 1, या 2 तर्क ([dtype, reference]) ले सकते हैं जहां संदर्भ का उपयोग __array__ विधि से __array__ करने के लिए किया जाता है, जहां से (वर्तमान में केवल ufuncs में उपयोग किया जाता है)।

PyObject* PyArray_ContiguousFromAny(PyObject* op, int typenum, int min_depth, int max_depth)

यह फ़ंक्शन किसी भी नेस्टेड सीक्वेंस या एरे इंटरफ़ेस एक्सपोर्टिंग ऑब्जेक्ट ऑब्जेक्ट, सेशन , इन (नॉन- फ़्लेक्सिबल ) प्रकार के एनुमरेटेड टाइपेनम द्वारा दिया गया है, न्यूनतम गहराई min_depth का , और अधिकतम गहराई max_depth का एक (C-style) रिटर्न और व्यवहार किया हुआ फ़ंक्शन ऐरे । PyArray_FromAny पर सेट की गई आवश्यकताओं के साथ PyArray_FromAny लिए कॉल करने के लिए और टाइप करने के लिए सेट किए गए प्रकार तर्क के टाइप_num सदस्य।

PyObject *PyArray_FromObject(PyObject *op, int typenum, int min_depth, int max_depth)

संरेखित टाइपेनम द्वारा दिए गए प्रकार के किसी भी नेस्टेड अनुक्रम या सरणी-इंटरफ़ेस निर्यात वस्तु, सेशन से एक संरेखित और मूल-बाइटऑर्डर सरणी में लौटें। सरणी में न्यूनतम आयामों की संख्या न्यूनतम हो सकती है जबकि min_depth द्वारा अधिकतम max_depth है। यह PyArray_FromAny आवश्यकताओं के साथ PyArray_FromAny लिए एक कॉल के बराबर है।

PyObject* PyArray_EnsureArray(PyObject* op)

यह फ़ंक्शन op संदर्भ को चुराता है और यह सुनिश्चित करता है कि op एक बेस-क्लास ndarray है। यह विशेष मामलों को PyArray_FromAny करता है, लेकिन अन्यथा PyArray_FromAny ( op , NULL, 0, 0, NPY_ARRAY_ENSUREARRAY , NULL) को NPY_ARRAY_ENSUREARRAY ।

PyObject* PyArray_FromString(char* string, npy_intp slen, PyArray_Descr* dtype, npy_intp num, char* sep)

लंबाई के आधार पर बाइनरी या ASCII) टेक्स्ट string के एकल प्रकार के एक आयामी आयाम का निर्माण slen । सरणी से डेटा-प्रकार का निर्माण dtype द्वारा दिया गया है। यदि संख्या -1 है, तो पूरे स्ट्रिंग को कॉपी करें और उचित आकार का सरणी लौटाएं, अन्यथा, स्ट्रिंग से कॉपी करने के लिए आइटम की संख्या है। अगर sep NULL (या "") है, तो स्ट्रिंग को बाइनरी डेटा के बाइट्स के रूप में व्याख्या करें, अन्यथा sep द्वारा अलग किए गए सब-स्ट्रिंग्स को डेटा-टाइप dtype आइटम में dtype । कुछ डेटा-प्रकार पाठ मोड में पढ़ने योग्य नहीं हो सकते हैं और यदि ऐसा होता है तो त्रुटि उठाई जाएगी। सभी त्रुटियां NULL को लौटाती हैं।

PyObject* PyArray_FromFile(FILE* fp, PyArray_Descr* dtype, npy_intp num, char* sep)

बाइनरी या टेक्स्ट फ़ाइल से एकल प्रकार के एक आयामी आयाम का निर्माण। ओपन फाइल पॉइंटर fp , जिस प्रकार का डेटा बनाया जाना है वह dtype द्वारा दिया गया है। यह फ़ाइल में डेटा से मेल खाना चाहिए। यदि num -1 है, तो फ़ाइल के अंत तक पढ़ें और उचित आकार का सरणी लौटाएं, अन्यथा, num पढ़ने के लिए मदों की संख्या है। अगर sep NULL (या "") है, तो बाइनरी मोड में फाइल से पढ़ें, अन्यथा आइटम सेपरेटर प्रदान करने वाले sep से फाइल को टेक्स्ट मोड में पढ़ें। कुछ सरणी प्रकार को पाठ मोड में नहीं पढ़ा जा सकता है जिसमें कोई त्रुटि होती है।

PyObject* PyArray_FromBuffer(PyObject* buf, PyArray_Descr* dtype, npy_intp count, npy_intp offset)

किसी ऑब्जेक्ट, buf से एकल प्रकार के एक आयामी आयाम का निर्माण करें, जो एकल प्रोटोकॉल (एकल-खंड) बफर प्रोटोकॉल का निर्यात करता है (या इसमें एक विशेषता __buffer__ है जो बफर प्रोटोकॉल को निर्यात करने वाली वस्तु लौटाता है)। एक लेखनीय बफर को पहले पढ़ने की कोशिश की जाएगी, उसके बाद केवल बफर। दिए गए सरणी का NPY_ARRAY_WRITEABLE ध्वज प्रतिबिंबित करेगा कि कौन सा सफल था। डेटा को ऑब्जेक्ट के लिए स्मृति स्थान की शुरुआत से offset बाइट्स पर शुरू करने के लिए माना जाता है। बफ़र में डेटा का प्रकार, डेटा टाइप डिस्क्रिप्टर, dtype. आधार पर व्याख्या किया जाएगा dtype. यदि count नकारात्मक है, तो यह बफर के आकार से निर्धारित किया जाएगा और अनुरोधित आइटम, अन्यथा, count दर्शाती है कि कितने तत्वों को बफर से परिवर्तित किया जाना चाहिए।

int PyArray_CopyInto(PyArrayObject* dest, PyArrayObject* src)

स्रोत सरणी से प्रतिलिपि करें, src , गंतव्य सरणी में, यदि आवश्यक हो, तो डेटा-प्रकार के रूपांतरण का प्रदर्शन dest । यदि कोई त्रुटि होती है -1 (अन्यथा 0)। src का आकार dest के आकार के लिए प्रसारित होना चाहिए। भाग्य और src के डेटा क्षेत्रों को ओवरलैप नहीं करना चाहिए।

int PyArray_MoveInto(PyArrayObject* dest, PyArrayObject* src)

स्रोत सरणी से डेटा स्थानांतरित dest , यदि आवश्यक हो, तो डेटा प्रकार के रूपांतरण का प्रदर्शन करते हुए, dest सरणी में, src । यदि कोई त्रुटि होती है -1 (अन्यथा 0)। src का आकार dest के आकार के लिए प्रसारित होना चाहिए। भाग्य और src के डेटा क्षेत्र ओवरलैप हो सकते हैं।

PyArrayObject* PyArray_GETCONTIGUOUS(PyObject* op)

यदि op पहले से ही (C-style) सन्निहित और अच्छी तरह से व्यवहार किया गया है, तो बस एक संदर्भ लौटाएं, अन्यथा सरणी की एक (सन्निहित और अच्छी तरह से व्यवहार वाली) प्रति वापस कर दें। पैरामीटर ऑप को ndarray का सब-क्लास (उप-वर्ग) होना चाहिए और उसके लिए कोई जाँच नहीं की जाती है।

PyObject* PyArray_FROM_O(PyObject* obj)

obj को ndarray में बदलें। तर्क किसी भी नेस्टेड अनुक्रम या ऑब्जेक्ट हो सकता है जो सरणी इंटरफ़ेस को निर्यात करता है। यह अन्य तर्कों के लिए NULL , 0, 0, 0 का उपयोग करके PyArray_FromAny का एक स्थूल रूप है। इस मैक्रो का उपयोग करने के लिए आपका कोड किसी भी डेटा-प्रकार के डिस्क्रिप्टर और डेटा-फ़्लैग के किसी भी संयोजन को संभालने में सक्षम होना चाहिए।

PyObject* PyArray_FROM_OF(PyObject* obj, int requirements)

PyArray_FROM_O समान इसके अलावा आवश्यकताओं का एक तर्क हो सकता है जिससे संकेत मिलता है कि परिणामी सरणी में गुण होने चाहिए। उपलब्ध आवश्यकताओं कि लागू किया जा सकता हैं NPY_ARRAY_C_CONTIGUOUS , NPY_ARRAY_F_CONTIGUOUS , NPY_ARRAY_ALIGNED , NPY_ARRAY_WRITEABLE , NPY_ARRAY_NOTSWAPPED , NPY_ARRAY_ENSURECOPY , NPY_ARRAY_WRITEBACKIFCOPY , NPY_ARRAY_UPDATEIFCOPY , NPY_ARRAY_FORCECAST , और NPY_ARRAY_ENSUREARRAY । झंडे के मानक संयोजनों का भी उपयोग किया जा सकता है:

PyObject* PyArray_FROM_OT(PyObject* obj, int typenum)

PyArray_FROM_O को छोड़कर यह PyArray_FROM_O का एक तर्क ले सकता है जो टाइप किए गए नंबर को दिए गए सरणी को निर्दिष्ट करता है।

PyObject* PyArray_FROM_OTF(PyObject* obj, int typenum, int requirements)

PyArray_FROM_OF और PyArray_FROM_OT का संयोजन दोनों टाइपेनम और एक झंडे का तर्क प्रदान करने की अनुमति देता है ..

PyObject* PyArray_FROMANY(PyObject* obj, int typenum, int min, int max, int requirements)

डेटा टाइप के अलावा PyArray_FromAny समान एक टाइपेनम्बर का उपयोग करके निर्दिष्ट किया गया है। PyArray_DescrFromType ( टाइपेनम ) सीधे PyArray_FromAny को पास किया जाता है। यह मैक्रो NPY_ARRAY_DEFAULT को आवश्यकताओं में जोड़ता है यदि NPY_ARRAY_ENSURECOPY आवश्यकताओं के रूप में पारित किया जाता है।

PyObject *PyArray_CheckAxis(PyObject* obj, int* axis, int requirements)

फ़ंक्शंस = कीवर्ड को लेने वाले फ़ंक्शंस और तरीकों की कार्यक्षमता को इनकैप्सुलेट करें और एक्सिस तर्क के रूप में किसी के साथ ठीक से काम न करें। इनपुट सरणी obj , जबकि *axis एक परिवर्तित पूर्णांक है (ताकि> = MAXDIMS कोई भी मान नहीं है), और requirements obj के आवश्यक गुण प्रदान करती हैं। आउटपुट इनपुट का एक परिवर्तित संस्करण है, ताकि आवश्यकताएं पूरी हों और जरूरत पड़ने पर एक चपटा हो। आउटपुट पर *axis नकारात्मक मान परिवर्तित होते हैं और नए मान की जाँच की जाती है ताकि obj के आकार के साथ स्थिरता सुनिश्चित की जा सके।

प्रकारों से निपटना

अजगर प्रकार की सामान्य जांच

PyArray_Check(op)

सही साबित होता है अगर op एक पायथन ऑब्जेक्ट है जिसका प्रकार PyArray_Type का उप-प्रकार है।

PyArray_CheckExact(op)

सही का मूल्यांकन करता है यदि op एक Python ऑब्जेक्ट है जो PyArray_Type साथ है।

PyArray_HasArrayInterface(op, out)

अगर op सरणी इंटरफ़ेस के किसी भी भाग को लागू करता है, तो out में इंटरफ़ेस का उपयोग करके नए बनाए गए ndarray का एक नया संदर्भ होगा या यदि रूपांतरण के दौरान कोई त्रुटि होती NULL तो इसमें NULL होगा। अन्यथा, बाहर Py_NotImplemented लिए एक उधार संदर्भ होगा और कोई भी त्रुटि स्थिति सेट नहीं है।

PyArray_HasArrayInterfaceType(op, type, context, out)

अगर op सरणी इंटरफ़ेस के किसी भी भाग को लागू करता है, तो out में इंटरफ़ेस का उपयोग करके नए बनाए गए ndarray का एक नया संदर्भ होगा या यदि रूपांतरण के दौरान कोई त्रुटि होती NULL तो इसमें NULL होगा। अन्यथा, बाहर Py_NotImplemented के लिए एक उधार संदर्भ होगा और कोई भी त्रुटि स्थिति सेट नहीं है। यह संस्करण सरणी इंटरफ़ेस के उस भाग में प्रकार और संदर्भ को सेट करने की अनुमति देता है जो __array__ विशेषता को __array__ है।

PyArray_IsZeroDim(op)

सत्य का मूल्यांकन करता है यदि op एक उदाहरण है ( PyArray_Type का) और (0 का उपवर्ग)।

PyArray_IsScalar(op, cls)

सच का मूल्यांकन करता है अगर op Py{cls}ArrType_Type का एक उदाहरण है।

PyArray_CheckScalar(op)

यह सच है कि अगर ऑप एक सरणी स्केलर ( PyGenericArr_Type उप-प्रकार का PyGenericArr_Type ) है, या (जिसका उप-वर्ग) PyArray_Type जिसका आयाम 0 है, सही है।

PyArray_IsPythonNumber(op)

सच का मूल्यांकन करता है अगर ऑप एक बिलियन न्यूमेरिक प्रकार का उदाहरण है (इंट, फ्लोट, कॉम्प्लेक्स, लॉन्ग, बूल)

PyArray_IsPythonScalar(op)

यह सच है कि यदि ऑप एक अंतर्निहित पाइथन स्केलर ऑब्जेक्ट (इंट, फ्लोट, कॉम्प्लेक्स, स्ट्रै, यूनिकोड, लॉन्ग, बूल) है।

PyArray_IsAnyScalar(op)

यह सच है कि यदि op या तो Python scalar object है ( PyArray_IsPythonScalar देखें) या एक array scalar (एक उप-प्रकार का PyGenericArr_Type का PyGenericArr_Type )।

PyArray_CheckAnyScalar(op)

सही साबित होता है अगर ऑप एक पायथन स्केलर ऑब्जेक्ट है ( PyArray_IsPythonScalar देखें), एक सरणी स्केलर ( PyGenericArr_Type का उप-प्रकार का एक उदाहरण) या PyGenericArr_Type की उप-प्रकार की PyArray_Type जिसका आयाम 0 है।

डेटा-प्रकार की जाँच

टाइपेनम मैक्रोज़ के लिए, तर्क एक पूर्णांक डेटा डेटा प्रकार का प्रतिनिधित्व करने वाला पूर्णांक है। सरणी प्रकार की जाँच करने के लिए मैक्रोज़ का तर्क एक PyObject * होना चाहिए जिसे सीधे PyArrayObject रूप में व्याख्या किया जा सकता है।

PyTypeNum_ISUNSIGNED(num)

PyDataType_ISUNSIGNED(descr)

PyArray_ISUNSIGNED(obj)

प्रकार एक अहस्ताक्षरित पूर्णांक का प्रतिनिधित्व करता है।

PyTypeNum_ISSIGNED(num)

PyDataType_ISSIGNED(descr)

PyArray_ISSIGNED(obj)

प्रकार एक हस्ताक्षरित पूर्णांक का प्रतिनिधित्व करता है।

PyTypeNum_ISINTEGER(num)

PyDataType_ISINTEGER(descr)

PyArray_ISINTEGER(obj)

प्रकार किसी भी पूर्णांक का प्रतिनिधित्व करता है।

PyTypeNum_ISFLOAT(num)

PyDataType_ISFLOAT(descr)

PyArray_ISFLOAT(obj)

प्रकार किसी भी फ्लोटिंग पॉइंट संख्या का प्रतिनिधित्व करता है।

PyTypeNum_ISCOMPLEX(num)

PyDataType_ISCOMPLEX(descr)

PyArray_ISCOMPLEX(obj)

प्रकार किसी भी जटिल फ़्लोटिंग पॉइंट संख्या का प्रतिनिधित्व करता है।

PyTypeNum_ISNUMBER(num)

PyDataType_ISNUMBER(descr)

PyArray_ISNUMBER(obj)

प्रकार किसी भी पूर्णांक, फ्लोटिंग पॉइंट या कॉम्प्लेक्स फ़्लोटिंग पॉइंट संख्या का प्रतिनिधित्व करता है।

PyTypeNum_ISSTRING(num)

PyDataType_ISSTRING(descr)

PyArray_ISSTRING(obj)

प्रकार एक स्ट्रिंग डेटा प्रकार का प्रतिनिधित्व करता है।

PyTypeNum_ISPYTHON(num)

PyDataType_ISPYTHON(descr)

PyArray_ISPYTHON(obj)

प्रकार मानक पायथन स्केलर (बूल, इंट, फ्लोट या कॉम्प्लेक्स) में से एक के अनुरूप एक एन्यूमरेटेड प्रकार का प्रतिनिधित्व करता है।

PyTypeNum_ISFLEXIBLE(num)

PyDataType_ISFLEXIBLE(descr)

PyArray_ISFLEXIBLE(obj)

प्रकार लचीला सरणी प्रकारों में से एक ( NPY_STRING , NPY_UNICODE , या NPY_VOID ) का NPY_VOID ।

PyDataType_ISUNSIZED(descr):

प्रकार में कोई आकार जानकारी संलग्न नहीं है, और इसका आकार बदला जा सकता है। केवल लचीला dtypes पर बुलाया जाना चाहिए। किसी सरणी से जुड़े प्रकार हमेशा आकार के होते हैं, इसलिए इस मैक्रो का सरणी रूप मौजूद नहीं है।

PyTypeNum_ISUSERDEF(num)

PyDataType_ISUSERDEF(descr)

PyArray_ISUSERDEF(obj)

प्रकार उपयोगकर्ता-परिभाषित प्रकार का प्रतिनिधित्व करता है।

PyTypeNum_ISEXTENDED(num)

PyDataType_ISEXTENDED(descr)

PyArray_ISEXTENDED(obj)

प्रकार या तो लचीला है या उपयोगकर्ता-परिभाषित है।

PyTypeNum_ISOBJECT(num)

PyDataType_ISOBJECT(descr)

PyArray_ISOBJECT(obj)

प्रकार ऑब्जेक्ट डेटा प्रकार का प्रतिनिधित्व करता है।

PyTypeNum_ISBOOL(num)

PyDataType_ISBOOL(descr)

PyArray_ISBOOL(obj)

प्रकार बूलियन डेटा प्रकार का प्रतिनिधित्व करता है।

PyDataType_HASFIELDS(descr)

PyArray_HASFIELDS(obj)

प्रकार में इसके साथ जुड़े फ़ील्ड हैं।

PyArray_ISNOTSWAPPED(m)

सही आंकलन करता है यदि सरणी के डेटा प्रकार के विवरण के अनुसार ndarray m का डेटा क्षेत्र मशीन बाइट क्रम में है।

PyArray_ISBYTESWAPPED(m)

सही आंकलन करता है यदि ndarray m का डेटा क्षेत्र एरे के डेटा-टाइप डिस्क्रिप्टर के अनुसार मशीन बाइट-ऑर्डर में नहीं है।

Bool PyArray_EquivTypes(PyArray_Descr* type1, PyArray_Descr* type2)

यदि NPY_TRUE तो टाइप 1 और टाइप 2 वास्तव में इस प्लेटफॉर्म के लिए समकक्ष प्रकारों का प्रतिनिधित्व करते हैं (प्रत्येक प्रकार के फोरट्रान सदस्य को अनदेखा किया जाता है)। उदाहरण के लिए, 32-बिट प्लेटफॉर्म पर NPY_LONG और NPY_INT बराबर हैं। अन्यथा NPY_FALSE ।

Bool PyArray_EquivArrTypes(PyArrayObject* a1, PyArrayObject * a2)

यदि NPY_TRUE वापस NPY_TRUE तो a1 और a2 इस प्लेटफ़ॉर्म के लिए बराबर प्रकारों के साथ सरणियाँ हैं।

Bool PyArray_EquivTypenums(int typenum1, int typenum2)

PyArray_EquivTypes (…) का विशेष मामला जो लचीले डेटा प्रकारों को स्वीकार नहीं करता है लेकिन कॉल करने में आसान हो सकता है।

int PyArray_EquivByteorders({byteorder} b1, {byteorder} b2)

सही है अगर बाइटऑर्डर वर्ण ( NPY_LITTLE , NPY_BIG , NPY_NATIVE , NPY_IGNORE ) या तो मूल बाइट क्रम के उनके विनिर्देशन के बराबर या बराबर हैं। इस प्रकार, एक छोटे-एंडियन मशीन पर NPY_LITTLE और NPY_NATIVE समान हैं जहां वे एक बड़े-एंडियन मशीन के बराबर नहीं हैं।

डेटा प्रकार परिवर्तित करना

PyObject* PyArray_Cast(PyArrayObject* arr, int typenum)

मुख्य रूप से न्यूमेरिक सी-एपीआई के लिए पीछे की संगतता के लिए और गैर-लचीले प्रकारों के लिए सरल कलाकारों के लिए। गिरफ्तारी के तत्वों के साथ डेटा-टाइप टाइपेनम के लिए एक नई सरणी ऑब्जेक्ट लौटाएं जो कि एन्यूमरेटेड प्रकारों में से एक होना चाहिए और एक लचीला प्रकार नहीं होना चाहिए।

PyObject* PyArray_CastToType(PyArrayObject* arr, PyArray_Descr* type, int fortran)

निर्दिष्ट के रूप में गिरफ्तारी के तत्वों को निर्दिष्ट करते हुए, निर्दिष्ट प्रकार का एक नया सरणी लौटाएं। फोरट्रान तर्क आउटपुट सरणी के आदेश को निर्दिष्ट करता है।

int PyArray_CastTo(PyArrayObject* out, PyArrayObject* in)

1.6 के रूप में, यह फ़ंक्शन केवल PyArray_CopyInto कॉल PyArray_CopyInto , जो कास्टिंग को संभालता है।

सरणी के तत्वों को सरणी से बाहर में डाली। आउटपुट सरणी लेखन योग्य होनी चाहिए, इनपुट एरे में तत्वों की संख्या का पूर्णांक-एक से अधिक होना चाहिए (एक से अधिक कॉपी बाहर रखी जा सकती हैं), और एक डेटा प्रकार होता है जो बिलियन प्रकारों में से एक होता है। सफलता मिलने पर 0 और यदि कोई त्रुटि होती है तो -1।

PyArray_VectorUnaryFunc* PyArray_GetCastFunc(PyArray_Descr* from, int totype)

दिए गए डिस्क्रिप्टर से बिलिन टाइप नंबर तक डालने के लिए निम्न-स्तरीय कास्टिंग फ़ंक्शन को वापस करें। यदि कोई कास्टिंग फ़ंक्शन मौजूद नहीं है तो NULL लौटें और एक त्रुटि सेट करें। इस फ़ंक्शन का उपयोग करने के बजाय -> f-> कास्ट से सीधे एक्सेस के बजाय, डिस्क्रिप् ट कास्टिंग डिक्शनरी में जोड़े गए किसी भी उपयोगकर्ता-परिभाषित कास्टिंग फ़ंक्शन का समर्थन करने की अनुमति देगा।

int PyArray_CanCastSafely(int fromtype, int totype)

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

int PyArray_CanCastTo(PyArray_Descr* fromtype, PyArray_Descr* totype)

PyArray_CanCastTypeTo इस फ़ंक्शन को NumPy 1.6 और बाद में PyArray_CanCastTypeTo करता है।

PyArray_CanCastTypeTo (fromtype, totype, NPY_SAFE_CASTING) के बराबर।

int PyArray_CanCastTypeTo(PyArray_Descr* fromtype, PyArray_Descr* totype, NPY_CASTING casting)

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

गैर-शून्य लौटाता है, यदि डेटा प्रकार का एक प्रकार fortype (जिसमें लचीले प्रकार शामिल हो सकते हैं) को कास्टिंग नियम के अनुसार डेटा प्रकार totype (जिसमें लचीले प्रकार शामिल कर सकते हैं) की एक सरणी में सुरक्षित रूप से डाला जा सकता है। NPY_SAFE_CASTING साथ सरल प्रकारों के लिए, यह मूल रूप से PyArray_CanCastSafely आसपास एक आवरण है, लेकिन लचीले प्रकार जैसे स्ट्रिंग्स या यूनिकोड के लिए, यह उनके आकार को ध्यान में रखते हुए परिणाम उत्पन्न करता है। पूर्णांक और फ्लोट प्रकार केवल एक स्ट्रिंग या यूनिकोड प्रकार के लिए डाले जा सकते हैं, NPY_SAFE_CASTING यदि स्ट्रिंग या यूनिकोड प्रकार पूर्ण रूप से डाली जाने वाली पूर्णांक / फ्लोट प्रकार का अधिकतम मान रखने के लिए पर्याप्त है।

int PyArray_CanCastArrayTo(PyArrayObject* arr, PyArray_Descr* totype, NPY_CASTING casting)

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

रिटर्न गैर शून्य अगर आगमन के लिए डाली जा सकती है totype में दी गई कास्टिंग नियम के अनुसार कास्टिंग । यदि आगमन एक सरणी अदिश है, अपने मूल्य को ध्यान में रखा जाता है, और जब मूल्य अतिप्रवाह नहीं होगा या जब एक छोटे प्रकार में परिवर्तित करने के लिए एक पूर्णांक छोटा किया जा गैर शून्य भी दिया जाता है।

यह लगभग PyArray_CanCastTypeTo (PyArray_MinScalarType (arr), totype, कास्टिंग) के परिणाम के समान है, लेकिन यह भी उत्पन्न होने वाले एक विशेष मामले को संभालता है क्योंकि uint मानों का सेट समान मानों के समान प्रकारों के लिए अंतर मानों का उपसमूह नहीं है। बिट्स।

PyArray_Descr* PyArray_MinScalarType(PyArrayObject* arr)

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

यदि गिरफ्तारी एक सरणी है, तो इसके डेटा प्रकार के विवरणक को लौटाता है, लेकिन यदि गिरफ्तार एक सरणी स्केलर है (0 आयाम), तो यह डेटा प्रकार के सबसे छोटे आकार को खोजता है, जिसमें मूल्य को अतिप्रवाह या पूर्णांक के बिना किसी पूर्णांक में परिवर्तित किया जा सकता है।

यह फ़ंक्शन फ्लोट करने या बूलियन को कुछ भी करने के लिए जटिल को समर्पित नहीं करेगा, लेकिन एक हस्ताक्षरित पूर्णांक को एक अहस्ताक्षरित पूर्णांक के लिए आवंटित करेगा जब स्केलर मान सकारात्मक होगा।

PyArray_Descr* PyArray_PromoteTypes(PyArray_Descr* type1, PyArray_Descr* type2)

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

ढूँढता सबसे छोटा आकार और प्रकार के डेटा प्रकार को जो type1 और type2 सुरक्षित रूप से परिवर्तित किया जा सकता है। यह फ़ंक्शन सममित और साहचर्य है। स्ट्रिंग या यूनिकोड में परिवर्तित इनपुट प्रकारों के अधिकतम मूल्य को संग्रहीत करने के लिए एक स्ट्रिंग या यूनिकोड परिणाम उचित आकार होगा।

PyArray_Descr* PyArray_ResultType(npy_intp narrs, PyArrayObject**arrs, npy_intp ndtypes, PyArray_Descr**dtypes)

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

यह सभी इनपुट्स पर टाइप प्रमोशन लागू करता है, स्कैल्पर्स और सरणियों के संयोजन के लिए NumPy नियमों का उपयोग करके, ऑपरेंड के सेट के आउटपुट प्रकार को निर्धारित करने के लिए। यह एक ही परिणाम प्रकार है जो ufuncs का उत्पादन करता है। विशिष्ट एल्गोरिथ्म का उपयोग निम्नानुसार है।

श्रेणियाँ पहले जाँच के द्वारा निर्धारित की जाती हैं कि कौन सी बूलियन, पूर्णांक (int / uint), या फ्लोटिंग पॉइंट (फ्लोट / कॉम्प्लेक्स) की अधिकतम सरणियाँ और स्केल हैं।

यदि केवल स्केलर हैं या स्केलर्स की अधिकतम श्रेणी सरणियों की अधिकतम श्रेणी से अधिक है, तो डेटा प्रकारों को PyArray_PromoteTypes रिटर्न मान के उत्पादन के साथ जोड़ा जाता है।

अन्यथा, PyArray_MinScalarType को प्रत्येक एरे पर कहा जाता है, और परिणामी डेटा प्रकारों को PyArray_PromoteTypes रिटर्न वैल्यू बनाने के लिए संयुक्त किया जाता है।

अंतर मूल्यों का सेट बिट्स की समान संख्या के साथ प्रकार के लिए यूइंट मूल्यों का एक सबसेट नहीं है, कुछ परिलक्षित नहीं होता है PyArray_MinScalarType , लेकिन PyArray_ResultType में एक विशेष मामले के रूप में संभाला जाता है।

int PyArray_ObjectType(PyObject* op, int mintype)

इस समारोह के द्वारा PyArray_MinScalarType और / या सुपरप्रेस्ड है PyArray_ResultType ।

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

void PyArray_ArrayType(PyObject* op, PyArray_Descr* mintype, PyArray_Descr* outtype)

इस समारोह के द्वारा superceded है PyArray_ResultType ।

यह फ़ंक्शन समान रूप से PyArray_ObjectType (…) काम करता है, सिवाय इसके कि यह लचीली सरणियों को संभालता है। Mintype तर्क एक itemsize सदस्य हो सकता है और outtype तर्क एक itemsize सदस्य कम से कम के रूप में वस्तु के आधार पर बड़ा लेकिन शायद बड़ा होगा सेशन ।

PyArrayObject** PyArray_ConvertToCommonType(PyObject* op, int* n)

NpyIter 1.6 में पेश किए गए NPY_ITER_COMMON_DTYPE पुनरावृत्ति द्वारा मोटे तौर पर प्रदान की जाने वाली कार्यक्षमता ध्वज के साथ या सभी ऑपरेंड के लिए समान dtype पैरामीटर के साथ है।

अजगर वस्तुओं में निहित एक दृश्य कन्वर्ट सेशन ndarrays एक ही डेटा प्रकार के होने प्रत्येक की एक सरणी के लिए। टाइपमेनम्बर के आधार पर प्रकार का चयन किया जाता है (बड़ी प्रकार की संख्या को एक छोटे से अधिक चुना जाता है) उन वस्तुओं की अनदेखी करना जो केवल स्केलर हैं। अनुक्रम की लंबाई n में वापस आ गई है , और बिंदुओं की एक n -length सरणी PyArrayObject रिटर्न मान है (या NULL यदि कोई त्रुटि होती है)। लौटे हुए सरणी को इस रूटीन (उपयोग करने वाले PyDataMem_FREE ) के कॉलर द्वारा मुक्त किया जाना चाहिए और इसमें सभी सरणी ऑब्जेक्ट्स DECREF d या मेमोरी-रिसाव होगा। नीचे दिया गया उदाहरण टेम्पलेट-कोड आमतौर पर उपयोग दिखाता है:

mps = PyArray_ConvertToCommonType(obj, &n);
if (mps==NULL) return NULL;
{code}
<before return>
for (i=0; i<n; i++) Py_DECREF(mps[i]);
PyDataMem_FREE(mps);
{return}

char* PyArray_Zero(PyArrayObject* arr)

आकार के नव निर्मित स्मृति के लिए एक सूचक आगमन -> itemsize कि उस प्रकार के लिए 0 के प्रतिनिधित्व रखती है। लौटे हुए पॉइंटर, रिट , का उपयोग करके मुक्त किया जाना चाहिए PyDataMem_FREE (रिट) जब इसकी आवश्यकता नहीं है।

char* PyArray_One(PyArrayObject* arr)

आकार के नव निर्मित स्मृति के लिए एक सूचक आगमन -> itemsize कि उस प्रकार के लिए 1 के प्रतिनिधित्व रखती है। लौटे हुए पॉइंटर, रिट , का उपयोग करके मुक्त किया जाना चाहिए PyDataMem_FREE (रिट) जब इसकी आवश्यकता नहीं है।

int PyArray_ValidType(int typenum)

NPY_TRUE यदि टाइपेनम एक वैध प्रकार-संख्या (अंतर्निहित या उपयोगकर्ता-परिभाषित या वर्ण कोड) का प्रतिनिधित्व करता है, तो वापस लौटाता है । अन्यथा, यह फ़ंक्शन देता है NPY_FALSE ।

नए डेटा प्रकार

void PyArray_InitArrFuncs(PyArray_ArrFuncs* f)

सभी फ़ंक्शन पॉइंटर्स और सदस्यों को प्रारंभ करें NULL ।

int PyArray_RegisterDataType(PyArray_Descr* dtype)

सरणियों के लिए नए उपयोगकर्ता-परिभाषित डेटा प्रकार के रूप में डेटा-प्रकार पंजीकृत करें। प्रकार में इसकी अधिकांश प्रविष्टियाँ भरी जानी चाहिए। यह हमेशा जाँची नहीं जाती है और त्रुटियां segfaults उत्पन्न कर सकती हैं। विशेष रूप से, dtype संरचना के टाइपबॉज सदस्य को एक पायथन प्रकार से भरा होना चाहिए जिसमें एक निश्चित आकार का तत्व-आकार होता है जो dtype के elsize सदस्य से मेल खाता है । साथ ही f सदस्य के पास आवश्यक कार्य होने चाहिए: नॉनज़ेरो, कॉप्सवाप, कॉप्सवापैन, गेटिटेम, सेटीमेटम और कास्ट (कुछ कलाकारों के कार्य हो सकते हैं NULL यदि कोई समर्थन नहीं है)। भ्रम से बचने के लिए, आपको एक अद्वितीय वर्ण टाइपबॉक्‍स चुनना चाहिए लेकिन यह लागू नहीं है और आंतरिक रूप से निर्भर नहीं है।

उपयोगकर्ता-परिभाषित प्रकार की संख्या को लौटाया जाता है जो विशिष्ट प्रकार की पहचान करता है। नई संरचना के लिए एक पॉइंटर को PyArray_DescrFromType दिए गए प्रकार की संख्या का उपयोग करके प्राप्त किया जा सकता है । यदि कोई त्रुटि होती है, तो -1 दिया जाता है। यदि यह dtype पहले से ही पंजीकृत है (केवल पॉइंटर के पते से जांचा गया है), तो पहले से असाइन किए गए टाइप-नंबर को वापस करें।

int PyArray_RegisterCastFunc(PyArray_Descr* descr, int totype, PyArray_VectorUnaryFunc* castfunc)

एक निम्न स्तर के कास्टिंग समारोह, रजिस्टर castfunc , डेटा प्रकार, से परिवर्तित करने के लिए descr , दिए गए डेटा प्रकार संख्या, के लिए totype । कोई भी पुराना कास्टिंग फंक्शन ओवर-लिखित है। A 0 को सफलता या -1 असफलता पर लौटाया जाता है ।

int PyArray_RegisterCanCast(PyArray_Descr* descr, int totype, NPY_SCALARKIND scalar)

दिए गए स्केलर प्रकार के डेटा-टाइप ऑब्जेक्ट, descr से कास्टेबल के रूप में डेटा-टाइप नंबर, टोटाइप को पंजीकृत करें । का प्रयोग करें अदिश = रजिस्टर करने के लिए है कि डेटा प्रकार की एक सरणी descr एक डेटा प्रकार जिसका TYPE_NUMBER है सुरक्षित रूप से डाली जा सकती है totype । NPY_NOSCALAR

NPY_OBJECT के लिए विशेष कार्य

int PyArray_INCREF(PyArrayObject* op)

एक सरणी, ऑप के लिए उपयोग किया जाता है, जिसमें किसी भी पायथन ऑब्जेक्ट्स होते हैं। यह डेटा प्रकार के अनुसार सरणी में हर वस्तु के संदर्भ गिनती वृद्धि कर देता है सेशन । यदि कोई त्रुटि होती है, तो ए -1 लौटा दिया जाता है, अन्यथा 0 लौटाया जाता है।

void PyArray_Item_INCREF(char* ptr, PyArray_Descr* dtype)

डेटा-प्रकार dtype के अनुसार स्थान ptr पर सभी ऑब्जेक्ट्स को INCREF करने के लिए एक फ़ंक्शन । यदि ptr किसी भी ऑफसेट पर एक ऑब्जेक्ट के साथ एक संरचित प्रकार की शुरुआत है, तो यह (पुनरावर्ती) संरचित प्रकार में सभी ऑब्जेक्ट-जैसी वस्तुओं की संदर्भ गणना बढ़ाएगा।

int PyArray_XDECREF(PyArrayObject* op)

एक सरणी, ऑप के लिए उपयोग किया जाता है, जिसमें किसी भी पायथन ऑब्जेक्ट्स होते हैं। यह डेटा- ऑप के प्रकार के अनुसार सरणी में प्रत्येक ऑब्जेक्ट की संदर्भ संख्या को घटाता है । यदि कोई त्रुटि होती है तो सामान्य रिटर्न मान 0. ए -1 है।

void PyArray_Item_XDECREF(char* ptr, PyArray_Descr* dtype)

डेटा-प्रकार, dtype में दर्ज किए गए स्थान ptr पर सभी ऑब्जेक्ट जैसी वस्तुओं को XDECREF करने के लिए एक फ़ंक्शन । यह पुनरावर्ती रूप से कार्य करता है ताकि यदि स्वयं में डेटा-प्रकार वाले फ़ील्ड हों जिसमें ऑब्जेक्ट-जैसी आइटम हों, तो सभी ऑब्जेक्ट-जैसे फ़ील्ड XDECREF होंगे । dtype 'd

void PyArray_FillObjectArray(PyArrayObject* arr, PyObject* obj)

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

int PyArray_SetUpdateIfCopyBase(PyArrayObject* arr, PyArrayObject* base)

पूर्वधारणा: (हालांकि संभवतः अलग-अलग प्रगति, आदेश आदि के साथ) की arr एक प्रति है base । UPDATEIFCOPY ध्वज सेट करें और arr->base ताकि जब arr यह नष्ट हो जाए, तो यह किसी भी परिवर्तन को वापस कर देगा base । तैयार, का उपयोग करें PyArray_SetWritebackIfCopyBase` ।

सफलता के लिए 0, असफलता के लिए -1 देता है।

int PyArray_SetWritebackIfCopyBase(PyArrayObject* arr, PyArrayObject* base)

पूर्वधारणा: (हालांकि संभवतः अलग-अलग प्रगति, आदेश, आदि के साथ) की arr एक प्रति है base । NPY_ARRAY_WRITEBACKIFCOPY ध्वज को सेट करता है arr->base , और पूरी तरह base से सेट करता है। कॉल करने PyArray_ResolveWritebackIfCopy से पहले कॉल करें Py_DECREF` किसी भी परिवर्तन को वापस कॉपी करें base और READONLY ध्वज को रीसेट करें।

सफलता के लिए 0, असफलता के लिए -1 देता है।

झंडे लहराए

संरचना की flags विशेषता में PyArrayObject सरणी द्वारा उपयोग की गई मेमोरी (डेटा सदस्य द्वारा इंगित) के बारे में महत्वपूर्ण जानकारी है। इस ध्वज जानकारी को सटीक या अजीब परिणाम रखा जाना चाहिए और यहां तक ​​कि सीगफॉल्ट भी हो सकता है।

6 (बाइनरी) झंडे हैं जो डेटा बफर द्वारा उपयोग किए जाने वाले मेमोरी क्षेत्र का वर्णन करते हैं। ये स्थिरांक arrayobject.h ध्वज की बिट-स्थिति को परिभाषित और निर्धारित करते हैं। पायथन इन झंडों को प्राप्त करने के लिए एक अच्छी विशेषता-आधारित इंटरफ़ेस के साथ-साथ शब्दकोश-जैसा इंटरफ़ेस भी उजागर करता है (और, यदि उपयुक्त हो, सेटिंग)।

सभी प्रकार के मेमोरी क्षेत्रों को इन झंडों की आवश्यकता होती है, एक ndarray द्वारा इंगित किया जा सकता है। यदि आपको PyArrayObject सी-कोड में मनमानी मिलती है , तो आपको उन झंडों के बारे में पता होना चाहिए जो सेट हैं। यदि आपको एक निश्चित प्रकार के सरणी (जैसे NPY_ARRAY_C_CONTIGUOUS और NPY_ARRAY_BEHAVED ) की गारंटी देने की आवश्यकता है , तो इन आवश्यकताओं को PyArray_FromAny फ़ंक्शन में पास करें।

बेसिक एरे फ्लैग्स

एक ndarray में एक डेटा सेगमेंट हो सकता है जो कि अच्छी तरह से व्यवहार की गई स्मृति का एक सरल सन्निहित हिस्सा नहीं है जिसे आप हेरफेर कर सकते हैं। इसे शब्द सीमाओं (कुछ प्लेटफार्मों पर बहुत महत्वपूर्ण) के साथ संरेखित नहीं किया जा सकता है। मशीन द्वारा पहचानने की तुलना में इसका डेटा एक अलग बाइट-ऑर्डर में हो सकता है। यह लेखनीय नहीं हो सकता है। यह फ़ोर्टन-सन्निहित आदेश में हो सकता है। सरणी के झंडे का उपयोग यह इंगित करने के लिए किया जाता है कि किसी सरणी से जुड़े डेटा के बारे में क्या कहा जा सकता है।

1.6 और इससे पहले के NumPy के संस्करणों में, निम्न झंडों में _ARRAY_ मैक्रो नेमस्पेस नहीं था। स्थिर नामों का वह रूप 1.7 में पदावनत है।

NPY_ARRAY_C_CONTIGUOUS

डेटा क्षेत्र सी-शैली सन्निहित क्रम में है (अंतिम सूचकांक सबसे तेज़ बदलता है)।

NPY_ARRAY_F_CONTIGUOUS

डेटा क्षेत्र फ़ोर्ट्रान-शैली सन्निहित क्रम में है (पहला सूचकांक सबसे तेज़ बदलता है)।

NPY_ARRAY_OWNDATA

डेटा क्षेत्र इस सरणी के स्वामित्व में है।

NPY_ARRAY_ALIGNED

डेटा क्षेत्र और सभी सरणी तत्व उचित रूप से संरेखित किए जाते हैं।

NPY_ARRAY_WRITEABLE

डेटा क्षेत्र को लिखा जा सकता है।

ध्यान दें कि उपर्युक्त 3 झंडे परिभाषित किए गए हैं ताकि एक नए, सुव्यवस्थित सरणी में इन झंडों को सही रूप में परिभाषित किया जाए।

NPY_ARRAY_WRITEBACKIFCOPY

डेटा क्षेत्र एक (अच्छी तरह से व्यवहार किया गया) प्रतिलिपि का प्रतिनिधित्व करता है जिसकी जानकारी को मूल में वापस स्थानांतरित किया जाना चाहिए जब PyArray_ResolveWritebackIfCopy इसे कहा जाता है।

यह एक विशेष ध्वज है जिसे सेट किया जाता है यदि यह सरणी बनाई गई प्रतिलिपि का प्रतिनिधित्व करती है क्योंकि एक उपयोगकर्ता को कुछ झंडे की आवश्यकता होती है PyArray_FromAny और एक प्रतिलिपि को किसी अन्य सरणी से बनाना पड़ता है (और उपयोगकर्ता इस ध्वज को ऐसी स्थिति में सेट करने के लिए कहता है)। आधार विशेषता तब "दुर्व्यवहार" सरणी (जो read_only सेट है) को इंगित करती है। : c: func`PyArray_ResolveWritebackIfCopy 'इसकी सामग्री को "दुर्व्यवहार" सरणी (यदि आवश्यक हो तो कास्टिंग) को कॉपी करेगा और "दुर्व्यवस्थित" सरणी को रीसेट करेगा NPY_ARRAY_WRITEABLE । यदि "दुर्व्यवहार" सरणी के NPY_ARRAY_WRITEABLE साथ शुरू नहीं करना था , तो PyArray_FromAny एक त्रुटि वापस आ NPY_ARRAY_WRITEBACKIFCOPY जाएगी क्योंकि संभव नहीं था।

NPY_ARRAY_UPDATEIFCOPY

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

PyArray_UpdateFlags (obj, झंडे) अद्यतन करेगा obj->flags के लिए flags जो कोई भी हो सकता NPY_ARRAY_C_CONTIGUOUS , NPY_ARRAY_F_CONTIGUOUS , NPY_ARRAY_ALIGNED , या NPY_ARRAY_WRITEABLE ।

सरणी के झंडे के संयोजन

NPY_ARRAY_BEHAVED

NPY_ARRAY_ALIGNED | NPY_ARRAY_WRITEABLE

NPY_ARRAY_CARRAY

NPY_ARRAY_C_CONTIGUOUS | NPY_ARRAY_BEHAVED

NPY_ARRAY_CARRAY_RO

NPY_ARRAY_C_CONTIGUOUS | NPY_ARRAY_ALIGNED

NPY_ARRAY_FARRAY

NPY_ARRAY_F_CONTIGUOUS | NPY_ARRAY_BEHAVED

NPY_ARRAY_FARRAY_RO

NPY_ARRAY_F_CONTIGUOUS | NPY_ARRAY_ALIGNED

NPY_ARRAY_DEFAULT

NPY_ARRAY_CARRAY

NPY_ARRAY_UPDATE_ALL

NPY_ARRAY_C_CONTIGUOUS | NPY_ARRAY_F_CONTIGUOUS | NPY_ARRAY_ALIGNED

झंडे जैसा स्थिरांक

PyArray_FromAny नए सरणी के वांछित गुणों को निर्दिष्ट करने के लिए (और इसके स्थूल रूपों में) इन स्थिरांक का उपयोग किया जाता है ।

NPY_ARRAY_FORCECAST

वांछित प्रकार के लिए कास्ट, भले ही यह जानकारी खोने के बिना नहीं किया जा सकता है।

NPY_ARRAY_ENSURECOPY

सुनिश्चित करें कि परिणामी सरणी मूल की एक प्रति है।

NPY_ARRAY_ENSUREARRAY

सुनिश्चित करें कि परिणामी वस्तु एक वास्तविक ndarray है, न कि एक उप-वर्ग।

NPY_ARRAY_NOTSWAPPED

केवल PyArray_CheckFromAny डेटा-टाइप ऑब्जेक्ट के बाइटऑर्डर को ओवर-राइड करने के लिए उपयोग किया जाता है।

NPY_ARRAY_BEHAVED_NS

NPY_ARRAY_ALIGNED | NPY_ARRAY_WRITEABLE | NPY_ARRAY_NOTSWAPPED

ध्वज की जाँच

इन सभी मैक्रोज़ के लिए गिरफ्तारी (उपवर्ग) का एक उदाहरण होना चाहिए PyArray_Type , लेकिन कोई जाँच नहीं की जाती है।

PyArray_CHKFLAGS(arr, flags)

पहला पैरामीटर, गिरफ्तार, एक ndarray या उपवर्ग होना चाहिए। पैरामीटर, झंडे :, एक सरणी हो सकता है संभव झंडे के बिटवाइज़ संयोजन से मिलकर एक पूर्णांक होनी चाहिए NPY_ARRAY_C_CONTIGUOUS , NPY_ARRAY_F_CONTIGUOUS , NPY_ARRAY_OWNDATA , NPY_ARRAY_ALIGNED , NPY_ARRAY_WRITEABLE , NPY_ARRAY_WRITEBACKIFCOPY , NPY_ARRAY_UPDATEIFCOPY ।

PyArray_IS_C_CONTIGUOUS(arr)

सच का मूल्यांकन करता है, तो आगमन सी शैली सटा हुआ है।

PyArray_IS_F_CONTIGUOUS(arr)

सही साबित होता है अगर गिरफ्तारी फोरट्रान-शैली सन्निहित है।

PyArray_ISFORTRAN(arr)

यह सच है कि अगर गिरफ्तारी फोरट्रान शैली की है और सी-शैली के सन्निहित नहीं है। PyArray_IS_F_CONTIGUOUS फोरट्रान-शैली की आकस्मिकता के परीक्षण का सही तरीका है।

PyArray_ISWRITEABLE(arr)

सही पता चलता है कि गिरफ्तारी के डेटा क्षेत्र को लिखा जा सकता है

PyArray_ISALIGNED(arr)

सही पता चलता है अगर गिरफ्तारी के डेटा क्षेत्र को मशीन पर ठीक से संरेखित किया गया है।

PyArray_ISBEHAVED(arr)

यह सच है कि अगर गिरफ्तारी का डेटा क्षेत्र गठबंधन और लिखने योग्य है और मशीन बाइट-ऑर्डर में है तो इसके विवरण के अनुसार।

PyArray_ISBEHAVED_RO(arr)

सही पता चलता है अगर गिरफ्तारी का डेटा क्षेत्र गठबंधन और मशीन बाइट-ऑर्डर में है।

PyArray_ISCARRAY(arr)

अगर डेटा का गिरफ्तारी क्षेत्र सी-शैली सन्निहित है, और PyArray_ISBEHAVED ( गिरफ्तारी ) सही है, तो मूल्यांकन सही है।

PyArray_ISFARRAY(arr)

यदि डेटा का गिरफ्तारी क्षेत्र फोरट्रान-शैली सन्निहित है और PyArray_ISBEHAVED ( गिरफ्तार ) सत्य है, तो यह सही है।

PyArray_ISCARRAY_RO(arr)

यह सच है कि गिरफ्तारी का डेटा क्षेत्र सी-शैली सन्निहित, संरेखित और मशीन बाइट-ऑर्डर में है।

PyArray_ISFARRAY_RO(arr)

यह सच है कि अगर गिरफ्तारी का डेटा क्षेत्र फोरट्रान-शैली सन्निहित, संरेखित और मशीन बाइट-ऑर्डर में है ।

PyArray_ISONESEGMENT(arr)

यह सच है कि अगर गिरफ्तारी के डेटा क्षेत्र में एकल (सी-शैली या फोरट्रान-शैली) सन्निहित खंड होते हैं।

void PyArray_UpdateFlags(PyArrayObject* arr, int flagmask)

NPY_ARRAY_C_CONTIGUOUS , NPY_ARRAY_ALIGNED , और NPY_ARRAY_F_CONTIGUOUS सरणी झंडे सरणी वस्तु से ही "गणना" जा सकता है। यह नियमित अपडेट से एक या इन झंडे के अधिक आगमन के रूप में विनिर्दिष्ट flagmask आवश्यक गणना प्रदर्शन से।

ऐरे विधि वैकल्पिक एपीआई

रूपांतरण

PyObject* PyArray_GetField(PyArrayObject* self, PyArray_Descr* dtype, int offset)

ndarray.getfield ( स्वयं , dtype , ऑफ़सेट ) के बराबर । बाइट्स में एक निर्दिष्ट ऑफसेट में वर्तमान सरणी में डेटा का उपयोग करके दिए गए dtype का एक नया सरणी लौटाएं । ऑफसेट के साथ साथ नए सरणी प्रकार के itemsize से कम होना चाहिए आत्म -> descr-> elsize या कोई त्रुटि उठाया है। मूल सरणी के रूप में समान आकार और स्ट्राइड्स का उपयोग किया जाता है। इसलिए, इस फ़ंक्शन में संरचित सरणी से फ़ील्ड को वापस करने का प्रभाव होता है। लेकिन, इसका उपयोग किसी भी प्रकार के प्रकार से विशिष्ट बाइट्स या बाइट्स के समूहों का चयन करने के लिए भी किया जा सकता है।

int PyArray_SetField(PyArrayObject* self, PyArray_Descr* dtype, int offset, PyObject* val)

ndarray.setfield ( स्वयं , वैल , dtype , ऑफसेट ) के बराबर । बाइट में ऑफसेट पर दिए गए फ़ील्ड को सेट करें और वैल को दिए गए dtype के । ऑफसेट प्लस dtype -> elsize से कम होना चाहिए आत्म -> descr-> elsize या कोई त्रुटि उठाया है। अन्यथा, घाटी तर्क को एक सरणी में बदल दिया जाता है और इंगित किए गए फ़ील्ड में कॉपी किया जाता है। यदि आवश्यक हो, के तत्वों वैल गंतव्य सरणी को भरने के लिए बार-बार कर रहे हैं, लेकिन, गंतव्य में तत्वों की संख्या में तत्वों की संख्या के एक पूर्णांक गुणांक होना चाहिए वैल ।

PyObject* PyArray_Byteswap(PyArrayObject* self, Bool inplace)

समतुल्य ndarray.byteswap ( स्वयं , inplace )। एक सरणी लौटाएं जिसका डेटा क्षेत्र बाइट्सवैप्ड है। यदि inplace गैर-शून्य है, तो byteswap inplace करते हैं और स्वयं के लिए एक संदर्भ लौट आते हैं। अन्यथा, एक बाइटस्वर्ड कॉपी बनाएं और स्वयं को अपरिवर्तित छोड़ दें।

PyObject* PyArray_NewCopy(PyArrayObject* old, NPY_ORDER order)

ndarray.copy ( स्वयं , फोरट्रान ) के बराबर । पुराने सरणी की एक प्रति बनाएँ । लौटाया गया सरणी हमेशा संरेखित होता है और पुराने सरणी के समान डेटा की व्याख्या करने योग्य होता है। यदि आदेश है NPY_CORDER , तो एक सी-शैली सन्निहित सरणी वापस आ जाती है। यदि आदेश है NPY_FORTRANORDER , तो एक फोरट्रान-शैली सन्निहित सरणी वापस आ जाती है। यदि आदेश है NPY_ANYORDER , तो लौटाया गया सरणी फोरट्रान-शैली सन्निहित है यदि पुराना है; अन्यथा, यह सी-शैली सन्निहित है।

PyObject* PyArray_ToList(PyArrayObject* self)

ndarray.tolist ( स्व ) के समकक्ष । स्व से एक नेस्टेड पायथन सूची लौटाएं ।

PyObject* PyArray_ToString(PyArrayObject* self, NPY_ORDER order)

ndarray.tobytes ( स्वयं , आदेश ) के बराबर । पायथन स्ट्रिंग में इस सरणी के बाइट्स को वापस करें।

PyObject* PyArray_ToFile(PyArrayObject* self, FILE* fp, char* sep, char* format)

सी-शैली सन्निहित फैशन में फ़ाइल पॉइंटर fp के लिए स्वयं की सामग्री लिखें । द्विआधारी बाइट के रूप में डेटा लिखें यदि सितम्बर स्ट्रिंग "" या है । अन्यथा, सेपर स्ट्रिंग के रूप में आइटम सेपरेटर के रूप में स्वयं की सामग्री को टेक्स्ट के रूप में लिखें । प्रत्येक आइटम को फ़ाइल में प्रिंट किया जाएगा। यदि प्रारूप स्ट्रिंग नहीं है या "" नहीं है, तो यह एक पायथन प्रिंट स्टेटमेंट प्रारूप है जिसमें दिखाया गया है कि आइटम कैसे लिखे जाने हैं। NULL NULL

int PyArray_Dump(PyObject* self, PyObject* file, int protocol)

दी गई फ़ाइल के लिए स्वयं में ऑब्जेक्ट को चुनें (या तो एक स्ट्रिंग या पायथन फ़ाइल ऑब्जेक्ट)। यदि फ़ाइल एक पायथन स्ट्रिंग है, तो इसे एक फ़ाइल का नाम माना जाता है, जिसे तब बाइनरी मोड में खोला जाता है। दिए गए प्रोटोकॉल का उपयोग किया जाता है (यदि प्रोटोकॉल नकारात्मक है, या उच्चतम उपलब्ध उपयोग किया जाता है)। यह cPickle.dump ( स्वयं , फ़ाइल , प्रोटोकॉल ) के आसपास एक साधारण आवरण है ।

PyObject* PyArray_Dumps(PyObject* self, int protocol)

एक पायथन स्ट्रिंग के लिए स्वयं में ऑब्जेक्ट को अचार करें और इसे वापस करें। दिए गए अचार प्रोटोकॉल का उपयोग करें (या यदि प्रोटोकॉल नकारात्मक है तो सबसे अधिक उपलब्ध है)।

int PyArray_FillWithScalar(PyArrayObject* arr, PyObject* obj)

दिए गए स्केलर ऑब्जेक्ट, obj के साथ एरे, अरे को भरें । ऑब्जेक्ट को पहले गिरफ्तारी के डेटा प्रकार में परिवर्तित किया जाता है , और फिर हर स्थान पर कॉपी किया जाता है। यदि कोई त्रुटि होती है, तो ए -1 लौटा दिया जाता है, अन्यथा 0 लौटाया जाता है।

PyObject* PyArray_View(PyArrayObject* self, PyArray_Descr* dtype, PyTypeObject *ptype)

ndarray.view ( स्वयं , dtype ) के समतुल्य । संभवतः एक अलग डेटा-प्रकार, dtype और अलग-अलग सरणी सबक्लास ptype के रूप में सरणी स्वयं का एक नया दृश्य लौटाएं ।

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

आकार में हेरफेर

PyObject* PyArray_Newshape(PyArrayObject* self, PyArray_Dims* newshape, NPY_ORDER order)

परिणाम एक नया सरणी ( संभव के रूप में स्वयं के रूप में एक ही स्मृति स्थान की ओर इशारा करते हुए ) होगा, लेकिन न्यूज़हैप द्वारा दिए गए आकार का होना । यदि नया आकार स्वयं के तारों के साथ संगत नहीं है , तो नए निर्दिष्ट आकार के साथ सरणी की एक प्रति वापस कर दी जाएगी।

PyObject* PyArray_Reshape(PyArrayObject* self, PyObject* shape)

समतुल्य ndarray.reshape ( स्व , आकृति ) जहाँ आकृति एक क्रम है। में कनवर्ट आकार एक करने के लिए PyArray_Dims संरचना और कॉल PyArray_Newshape आंतरिक रूप से। बैक-वार्ड संगतता के लिए - अनुशंसित नहीं है

PyObject* PyArray_Squeeze(PyArrayObject* self)

ndarray.squeeze ( स्व ) के समकक्ष । आकृति से हटाए गए लंबाई 1 के सभी आयामों के साथ स्वयं का एक नया दृश्य लौटाएं ।

PyObject* PyArray_SwapAxes(PyArrayObject* self, int a1, int a2)

समतुल्य ndarray.swapaxes ( स्वयं , a1 , a2 )। दिया गया सरणी दिए गए अक्षों, a1 और a2 के साथ स्व में डेटा का एक नया दृश्य है, जिसे स्वैप किया गया है।

PyObject* PyArray_Resize(PyArrayObject* self, PyArray_Dims* newshape, int refcheck, NPY_ORDER fortran)

समतुल्य ndarray.resize ( स्वयं , न्यूज़हैप , रीफ़ेकिट = रीचेक , ऑर्डर = फोरट्रान)। यह फ़ंक्शन केवल एकल-खंड एरेज़ पर काम करता है। यह स्व- अस्वस्थता के आकार को बदलता है और स्वयं के लिए मेमोरी को फिर से विभाजित करेगा यदि न्यूज़हैप में तत्वों की कुल संख्या है तो पुराने आकार। यदि पुनः आबंटन के लिए आवश्यक है, तो स्वयं अपने डेटा का स्वामी होना चाहिए, है स्वयं - , है स्वयं - , और (0 जब तक refcheck है) किसी भी अन्य सरणी द्वारा संदर्भित किया। Fortran तर्क हो सकता है , या >base==NULL >weakrefs==NULL NPY_ANYORDER NPY_CORDER NPY_FORTRANORDER । इसका वर्तमान में कोई प्रभाव नहीं है। आखिरकार इसका उपयोग यह निर्धारित करने के लिए किया जा सकता है कि अलग-अलग आयाम वाले सरणी का निर्माण करते समय रिसाइज़ ऑपरेशन को डेटा को कैसे देखना चाहिए। सफलता पर कोई भी नहीं लौटाता है और त्रुटि पर पूर्ण है।

PyObject* PyArray_Transpose(PyArrayObject* self, PyArray_Dims* permute)

ndarray.transpose ( स्वयं , परमिट ) के बराबर । डेटा संरचना परमिट के अनुसार ndarray ऑब्जेक्ट स्वयं के कुल्हाड़ियों को अनुमति दें और परिणाम लौटाएं । यदि परमिट है NULL , तो परिणामी सरणी में इसके अक्षों को उलट दिया गया है। उदाहरण के लिए यदि स्व का आकार है , और परमिट .ptr है (0,2,1) परिणाम का आकार है यदि परमिट है NULL , तो परिणाम का आकार है

PyObject* PyArray_Flatten(PyArrayObject* self, NPY_ORDER order)

ndarray.flatten ( स्वयं , आदेश ) के बराबर । सरणी की 1-डी प्रति लौटाएं। यदि आदेश है NPY_FORTRANORDER तो तत्वों को फोरट्रान क्रम में स्कैन किया जाता है (पहला-आयाम सबसे तेजी से बदलता है)। यदि आदेश है NPY_CORDER , तो self सी-ऑर्डर में तत्वों को स्कैन किया जाता है (अंतिम आयाम सबसे तेजी से बदलता है)। यदि आदेश NPY_ANYORDER , तो PyArray_ISFORTRAN ( स्व ) के परिणाम का उपयोग यह निर्धारित करने के लिए किया जाता है कि किस क्रम को समतल करना है।

PyObject* PyArray_Ravel(PyArrayObject* self, NPY_ORDER order)

स्व .ravel ( आदेश ) के बराबर । यदि ऑर्डर 0 है और स्वयं सी-शैली सन्निहित है, तो सिवाय मूल कार्यक्षमता PyArray_Flatten ( स्व - आदेश ) के , आकृति बदल दी जाती है, लेकिन कोई प्रतिलिपि नहीं की जाती है।

आइटम चयन और हेरफेर

PyObject* PyArray_TakeFrom(PyArrayObject* self, PyObject* indices, int axis, PyArrayObject* ret, NPY_CLIPMODE clipmode)

के बराबर ndarray.take ( स्वयं , सूचकांक , अक्ष , सेवानिवृत्त , clipmode ) को छोड़कर अक्ष = अजगर में कोई भी सेटिंग के द्वारा प्राप्त किया जाता है धुरी = NPY_MAXDIMS सी में स्वयं से आइटम पूर्णांक मान ने संकेत दिया निकालें सूचकांक दिया साथ अक्ष। क्लिपमोड तर्क यह संकेत दे सकता है NPY_RAISE , NPY_WRAP या NPY_CLIP यह इंगित करने के लिए कि आउट-ऑफ-बाउंड सूचकांकों के साथ क्या करना है। सेवानिवृत्त तर्क नहीं बल्कि आंतरिक रूप से बनाई गई एक की तुलना में एक आउटपुट सरणी निर्दिष्ट कर सकते हैं।

PyObject* PyArray_PutTo(PyArrayObject* self, PyObject* values, PyObject* indices, NPY_CLIPMODE clipmode)

के बराबर स्वयं .put ( मूल्यों , सूचकांक , clipmode )। रखो मूल्यों में स्वयं इसी (चपटा) में सूचकांक । यदि मान बहुत छोटा है, तो इसे आवश्यकतानुसार दोहराया जाएगा।

PyObject* PyArray_PutMask(PyArrayObject* self, PyObject* values, PyObject* mask)

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

PyObject* PyArray_Repeat(PyArrayObject* self, PyObject* op, int axis)

ndarray.repeat ( स्व , ऑप , अक्ष ) के समतुल्य । के तत्वों को कॉपी स्वयं , सेशन दिया साथ बार अक्ष । या तो op एक अदिश पूर्णांक है या लंबाई स्वयं का एक अनुक्रम है -> आयाम [ अक्ष ] यह दर्शाता है कि अक्ष के साथ प्रत्येक आइटम को कितनी बार दोहराना है।

PyObject* PyArray_Choose(PyArrayObject* self, PyObject* op, PyArrayObject* ret, NPY_CLIPMODE clipmode)

के बराबर ndarray.choose ( स्वयं , सेशन , सेवानिवृत्त , clipmode )। स्वयं में पूर्णांक मानों के आधार पर ऑप में सरणियों के अनुक्रम से तत्वों का चयन करके एक नई सरणी बनाएं । सभी सरणियों को एक ही आकार में प्रसारित किया जाना चाहिए और स्वयं में प्रविष्टियां 0 और लेन ( ओपी ) के बीच होनी चाहिए । आउटपुट को तब तक रेट में रखा जाता है जब तक कि वह उस स्थिति में न हो, जब कोई नया आउटपुट बनता है। Clipmode तर्क के लिए जब में प्रविष्टियों व्यवहार निर्धारित करता है आत्म 0 और लेन (के बीच नहीं हैं सेशन )। NULL

NPY_RAISE

एक ValueError बढ़ाएं;

NPY_WRAP

<लेन (जोड़कर 0 मूल्यों लपेट सेशन = लेन () और मूल्यों> सेशन लेन (घटाकर) सेशन ) जब तक वे रेंज में हैं,

NPY_CLIP

सभी मानों को इस क्षेत्र से जोड़ दिया जाता है [0, len ( op ))।

PyObject* PyArray_Sort(PyArrayObject* self, int axis)

ndarray.sort ( स्व , अक्ष ) के समतुल्य । अक्ष के साथ क्रमबद्ध स्व के आइटम के साथ एक सरणी लौटें ।

PyObject* PyArray_ArgSort(PyArrayObject* self, int axis)

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

PyObject* PyArray_LexSort(PyObject* sort_keys, int axis)

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

अगर ये सरणियाँ एक संरचित सरणी में एकत्र की जाती हैं, तो PyArray_Sort (…) का उपयोग सीधे सरणी को क्रमबद्ध करने के लिए भी किया जा सकता है।

PyObject* PyArray_SearchSorted(PyArrayObject* self, PyObject* values, NPY_SEARCHSIDE side, PyObject* perm)

ndarray.searchsorted ( स्वयं , मूल्य , पक्ष , परमिट ) के समकक्ष । स्व मान लेना आरोही क्रम में 1-d सरणी है, तो आउटपुट सूचकांकों का एक सरणी है जो मानों के समान आकार है, जैसे कि यदि मूल्यों में तत्वों को सूचकांकों से पहले डाला गया था, तो स्वयं का क्रम संरक्षित होगा। स्वयं को आरोही क्रम में है या नहीं, इसकी कोई जाँच नहीं की जाती है।

पक्ष तर्क इंगित करता सूचकांक लौटे कि क्या पहले उपयुक्त स्थान का ही रहेगा (यदि NPY_SEARCHLEFT ) या पिछले की (यदि NPY_SEARCHRIGHT )।

सॉर्टर तर्क, अगर नहीं NULL , पूर्णांक सूचकांक के एक 1 डी सरणी के रूप में ही लंबाई होना चाहिए स्वयं यह है कि यह आरोही क्रम में क्रमबद्ध करता है। यह आमतौर पर PyArray_ArgSort आवश्यक प्रविष्टि बिंदुओं को खोजने के लिए (…) बाइनरी खोज के लिए एक कॉल का परिणाम है ।

int PyArray_Partition(PyArrayObject *self, PyArrayObject * ktharray, int axis, NPY_SELECTKIND which)

ndarray.partition ( स्वयं , ktharray , अक्ष , तरह ) के बराबर । सरणी को विभाजित करता है ताकि ktharray द्वारा अनुक्रमित तत्व के मान उन स्थितियों में हों, यदि सरणी पूरी तरह से सॉर्ट की जाती है और सभी तत्वों को kth से पहले छोटा कर देता है और सभी तत्व kth तत्व के बराबर या अधिक हो जाते हैं। विभाजनों के भीतर सभी तत्वों का क्रम अपरिभाषित है। यदि स्व -> डिस्क्रर परिभाषित क्षेत्रों के साथ एक डेटा-प्रकार है, फिर क्रम क्रम निर्धारित करने के लिए स्व-> डिस्क्र्र-> नामों का उपयोग किया जाता है। एक तुलना जहां पहला फ़ील्ड बराबर है, दूसरा फ़ील्ड और इतने पर उपयोग करेगा। संरचित सरणी के क्रम को बदलने के लिए, नामों के एक अलग क्रम के साथ एक नया डेटा-प्रकार बनाएं और उस नए डेटा-प्रकार के साथ सरणी का एक दृश्य बनाएं। सफलता पर शून्य और -1 असफलता पर देता है।

PyObject* PyArray_ArgPartition(PyArrayObject *op, PyArrayObject * ktharray, int axis, NPY_SELECTKIND which)

ndarray.argpartition ( स्वयं , ktharray , अक्ष , तरह ) के बराबर । ऐसे सूचकांकों की एक सरणी लौटाएं जो दिए गए इन सूचकांकों का चयन स्वयं axis का एक विभाजित संस्करण लौटाएगा ।

PyObject* PyArray_Diagonal(PyArrayObject* self, int offset, int axis1, int axis2)

के बराबर ndarray.diagonal ( स्वयं , ऑफसेट , axis1 , Axis2 )। लौटें ऑफसेट 2-डी द्वारा परिभाषित सरणियों के विकर्ण axis1 और Axis2 ।

npy_intp PyArray_CountNonzero(PyArrayObject* self)

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

सरणी ऑब्जेक्ट स्वयं में गैर-शून्य तत्वों की संख्या की गणना करता है ।

PyObject* PyArray_Nonzero(PyArrayObject* self)

ndarray.nonzero ( स्व ) के समकक्ष । इंडेक्स सरणियों का एक टपल लौटाता है जो स्वयं के तत्वों का चयन करता है जो नॉनज़रो हैं। यदि (nd = PyArray_NDIM ( self )) == 1 है, तो एक एकल सूचकांक सरणी वापस आ जाती है। सूचकांक सरणियों में डेटा प्रकार होता है NPY_INTP । यदि एक टपल लौटाया जाता है (nd 1), तो इसकी लंबाई nd है।

PyObject* PyArray_Compress(PyArrayObject* self, PyObject* condition, int axis, PyArrayObject* out)

ndarray.compress ( स्व , स्थिति , अक्ष ) के समतुल्य । सही होने वाली स्थिति के तत्वों के अनुरूप धुरी वाले तत्वों को लौटाएं ।

हिसाब

PyObject* PyArray_ArgMax(PyArrayObject* self, int axis, PyArrayObject* out)

ndarray.argmax ( स्व , अक्ष ) के समतुल्य । अक्ष के साथ स्वयं के सबसे बड़े तत्व का सूचकांक लौटाएं ।

PyObject* PyArray_ArgMin(PyArrayObject* self, int axis, PyArrayObject* out)

ndarray.argmin ( स्व , अक्ष ) के समतुल्य । धुरी के साथ स्वयं के सबसे छोटे तत्व का सूचकांक लौटाएं ।

PyObject* PyArray_Max(PyArrayObject* self, int axis, PyArrayObject* out)

ndarray.max ( स्व , अक्ष ) के समतुल्य । दिए गए अक्ष के साथ स्वयं का सबसे बड़ा तत्व लौटाता है । जब परिणाम एक एकल तत्व होता है, तो एक ndarray के बजाय एक संख्यात्मक स्केलर लौटाता है।

PyObject* PyArray_Min(PyArrayObject* self, int axis, PyArrayObject* out)

ndarray.min ( स्व , अक्ष ) के समतुल्य । दिए गए अक्ष के साथ स्वयं का सबसे छोटा तत्व लौटाएं । जब परिणाम एक एकल तत्व होता है, तो एक ndarray के बजाय एक संख्यात्मक स्केलर लौटाता है।

PyObject* PyArray_Ptp(PyArrayObject* self, int axis, PyArrayObject* out)

ndarray.ptp ( स्व , अक्ष ) के समतुल्य । के सबसे बड़े तत्व के बीच का अंतर लौटें स्वयं के साथ धुरी और सबसे छोटी तत्व स्वयं के साथ धुरी । जब परिणाम एक एकल तत्व होता है, तो एक ndarray के बजाय एक संख्यात्मक स्केलर लौटाता है।

PyObject* PyArray_Mean(PyArrayObject* self, int axis, int rtype, PyArrayObject* out)

ndarray.mean ( स्वयं , अक्ष , rtype ) के समतुल्य । दिए गए अक्ष के साथ तत्वों का मतलब देता है , गणना करने के लिए डेटा प्रकार के रूप में गणना प्रकार rtype का उपयोग करके । डिफ़ॉल्ट योग व्यवहार rtype का उपयोग करके प्राप्त NPY_NOTYPE किया जाता है ।

PyObject* PyArray_Trace(PyArrayObject* self, int offset, int axis1, int axis2, int rtype, PyArrayObject* out)

के बराबर ndarray.trace ( स्वयं , ऑफसेट , axis1 , Axis2 , rtype )। योग (का उपयोग कर लौटें rtype योग के डेटा प्रकार के रूप में) से अधिक की भरपाई 2-डी द्वारा परिभाषित सरणियों के विकर्ण तत्वों axis1 और Axis2 चर। एक सकारात्मक ऑफसेट मुख्य विकर्ण के ऊपर विकर्ण चुनता है। एक नकारात्मक ऑफसेट मुख्य विकर्ण के नीचे विकर्णों का चयन करता है।

PyObject* PyArray_Clip(PyArrayObject* self, PyObject* min, PyObject* max)

ndarray.clip ( स्वयं , न्यूनतम , अधिकतम ) के बराबर । एक सरणी, क्लिप स्वयं , ताकि से भी बड़ा महत्व देता है अधिकतम करने के लिए निर्धारित किया जाता है अधिकतम और कम से कम महत्व देता है मिनट के लिए निर्धारित कर रहे हैं के लिए न्यूनतम ।

PyObject* PyArray_Conjugate(PyArrayObject* self)

ndarray.conjugate ( स्व ) के समकक्ष । स्व के जटिल संयुग्म को लौटाएं । यदि आत्म जटिल डेटा प्रकार का नहीं है, तो एक संदर्भ के साथ स्व वापस लौटें ।

PyObject* PyArray_Round(PyArrayObject* self, int decimals, PyArrayObject* out)

समतुल्य ndarray.round ( स्व , दशमलव , आउट )। सरणी को निकटतम दशमलव स्थान पर राउंड वाले तत्वों के साथ लौटाता है। दशमलव स्थान को अंक के रूप में परिभाषित किया जाता है ताकि नकारात्मक दशमलव 10 के निकटतम, 100, आदि के लिए गोलाई का कारण बनता है। यदि बाहर है NULL , तो आउटपुट सरणी बनाई जाती है, अन्यथा आउटपुट को बाहर रखा जाता है जो सही आकार और प्रकार होना चाहिए।

PyObject* PyArray_Std(PyArrayObject* self, int axis, int rtype, PyArrayObject* out)

ndarray.std ( स्वयं , अक्ष , rtype ) के समतुल्य । डेटा प्रकार rtype में परिवर्तित धुरी के साथ डेटा का उपयोग करके मानक विचलन लौटें ।

PyObject* PyArray_Sum(PyArrayObject* self, int axis, int rtype, PyArrayObject* out)

ndarray.sum ( स्वयं , अक्ष , rtype ) के समतुल्य । अक्ष के साथ स्वयं में तत्वों की 1-डी वेक्टर राशि लौटाएं । डेटा को डेटा टाइप rtype में परिवर्तित करने के बाद योग करें ।

PyObject* PyArray_CumSum(PyArrayObject* self, int axis, int rtype, PyArrayObject* out)

ndarray.cumsum ( स्वयं , अक्ष , rtype ) के समतुल्य । अक्ष के साथ स्वयं में तत्वों की संचयी 1-डी रकम लौटाएं । डेटा को डेटा टाइप rtype में परिवर्तित करने के बाद योग करें ।

PyObject* PyArray_Prod(PyArrayObject* self, int axis, int rtype, PyArrayObject* out)

ndarray.prod ( स्वयं , अक्ष , rtype ) के समतुल्य । अक्ष के साथ स्वयं में तत्वों के 1-घ उत्पादों को लौटाएं । डेटा को डेटा प्रकार rtype में परिवर्तित करने के बाद उत्पाद का प्रदर्शन करें ।

PyObject* PyArray_CumProd(PyArrayObject* self, int axis, int rtype, PyArrayObject* out)

ndarray.cumprod ( स्वयं , अक्ष , rtype ) के समतुल्य । तत्वों के self साथ 1-डी संचयी उत्पाद लौटाएं axis । डेटा को डेटा प्रकार में परिवर्तित करने के बाद उत्पाद का प्रदर्शन करें rtype ।

PyObject* PyArray_All(PyArrayObject* self, int axis, PyArrayObject* out)

ndarray.all ( स्व , अक्ष ) के समतुल्य । self परिभाषित किए axis गए प्रत्येक 1-डी उप-सरणी के लिए ट्रू तत्वों के साथ एक सरणी लौटें जिसमें सभी तत्व सत्य हैं।

PyObject* PyArray_Any(PyArrayObject* self, int axis, PyArrayObject* out)

ndarray.any ( स्व , अक्ष ) के समतुल्य । के हर 1-डी उप सरणी के लिए यह सच है तत्वों के साथ एक सरणी लौटें स्वयं द्वारा परिभाषित अक्ष , जिसमें से कोई भी तत्व यह सच है।

कार्य

ऐरे कार्य

int PyArray_AsCArray(PyObject** op, void* ptr, npy_intp* dims, int nd, int typenum, int itemsize)

कभी-कभी यह बहु-आयामी सरणी को सी-स्टाइल मल्टी-आयामी सरणी के रूप में एक्सेस करने के लिए उपयोगी होता है ताकि एल्गोरिदम को सी के [i] [जे] [के] सिंटैक्स का उपयोग करके लागू किया जा सके। यह रूटीन एक पॉइंटर, पीटीआर लौटाता है , जो 1-, 2- और 3-डी ndarrays के लिए इस तरह के सी-स्टाइल सरणी का अनुकरण करता है।

पैरामीटर:

op - किसी पायथन ऑब्जेक्ट का पता। इस पायथन ऑब्जेक्ट को पिछले दो तर्कों द्वारा निर्दिष्ट दिए गए डेटा प्रकार के समतुल्य व्यवहार, सी-शैली सन्निहित, ndarray के साथ बदल दिया जाएगा। सुनिश्चित करें कि इनपुट ऑब्जेक्ट के लिए इस तरह से एक संदर्भ चोरी करना उचित है। ptr - 1-d के लिए a (ctype *, 2-d या ctype *** के लिए 3-d) चर के लिए पता जहाँ ctype डेटा प्रकार के लिए बराबर C-प्रकार है। वापसी पर, ptr को 1-डी, 2-डी या 3-डी सरणी के रूप में संबोधित किया जाएगा। dims - एक आउटपुट सरणी जिसमें सरणी ऑब्जेक्ट का आकार होता है। यह एरे किसी भी लूपिंग पर सीमाएं देता है जो जगह लेगा। nd - सरणी की आयाम (1, 2, या 3)। टाइपेनम - सरणी का अपेक्षित डेटा प्रकार। itemize - यह तर्क केवल तब आवश्यक है जब टाइपेनम एक लचीली सरणी का प्रतिनिधित्व करता है। अन्यथा यह 0 होना चाहिए।

int PyArray_Free(PyObject* op, void* ptr)

उन्हीं वस्तुओं और स्मृति स्थानों से बुलाया जाना चाहिए जो PyArray_AsCArray (…) से लौटे हैं । यह फ़ंक्शन स्मृति को साफ़ करता है जो अन्यथा लीक हो जाएगा।

PyObject* PyArray_Concatenate(PyObject* obj, int axis)

में वस्तुओं के अनुक्रम में शामिल हों obj साथ एक साथ धुरी एक भी सरणी में। यदि आयाम या प्रकार संगत नहीं हैं तो त्रुटि उठाई जाती है।

PyObject* PyArray_InnerProduct(PyObject* obj1, PyObject* obj2)

Obj1 और obj2 के अंतिम आयामों पर एक उत्पाद-राशि की गणना करें । न तो सरणी संयुग्मित है।

PyObject* PyArray_MatrixProduct(PyObject* obj1, PyObject* obj)

Obj1 के अंतिम आयाम और obj2 के दूसरे-से-अंतिम आयाम पर एक उत्पाद-राशि की गणना करें । 2-डी सरणियों के लिए यह एक मैट्रिक्स-उत्पाद है। न तो सरणी संयुग्मित है।

PyObject* PyArray_MatrixProduct2(PyObject* obj1, PyObject* obj, PyArrayObject* out)

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

PyArray_MatrixProduct के समान, लेकिन परिणाम को बाहर में संग्रहीत करें । आउटपुट सरणी में सही आकार, प्रकार होना चाहिए, और C-contiguous होना चाहिए, या एक अपवाद उठाया गया है।

PyObject* PyArray_EinsteinSum(char* subscripts, npy_intp nop, PyArrayObject** op_in, PyArray_Descr* dtype, NPY_ORDER order, NPY_CASTING casting, PyArrayObject* out)

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

प्रदान किए गए सरणी ऑपरेंड्स में आइंस्टीन सम्‍मिलन सम्‍मेलन लागू करता है, एक नया एरे लौटाता है या परिणाम को बाहर रखता है । में स्ट्रिंग सबस्क्रिप्ट सूचकांक पत्र की एक अल्पविराम से अलग सूची है। ऑपरेंड की संख्या में है nop , और op_in उन ऑपरेंड युक्त एक सरणी है। आउटपुट के डेटा प्रकार को dtype के साथ मजबूर किया जा सकता है , आउटपुट ऑर्डर को ऑर्डर ( NPY_KEEPORDER अनुशंसित) के साथ मजबूर किया जा सकता है, और जब dtype निर्दिष्ट किया जाता है, तो कास्टिंग यह इंगित करती है कि डेटा रूपांतरण कितना अनुमत होना चाहिए।

देखें einsum अधिक जानकारी के लिए कार्य करते हैं।

PyObject* PyArray_CopyAndTranspose(PyObject * op)

एक विशेष प्रतिलिपि और हस्तांतरण फ़ंक्शन जो केवल 2-डी सरणियों के लिए काम करता है। लौटी हुई सरणी सेशन की ट्रांसपोज़्ड कॉपी है ।

PyObject* PyArray_Correlate(PyObject* op1, PyObject* op2, int mode)

1-डी सरणियों के 1-घ सहसंबंध की गणना OP1 और op2 । सहसंबंध गुणा करके प्रत्येक उत्पादन बिंदु पर गणना की जाती है OP1 के लिए स्थानांतरित कर दिया संस्करण द्वारा op2 और परिणाम संक्षेप। पारी का एक परिणाम के रूप में, जरूरत के परिभाषित सीमा के बाहर के मान OP1 और op2 शून्य के रूप में व्याख्या कर रहे हैं। मोड यह निर्धारित करता है कि कितने शिफ्ट्स को वापस लौटना है: 0 - केवल उन पारियों को लौटाएं जिन्हें शून्य मान लेने की आवश्यकता नहीं थी; 1 - एक ऑब्जेक्ट जो कि op1 के समान आकार है , 2 लौटाएं - 2 सभी संभव बदलाव लौटाएं (किसी भी ओवरलैप को स्वीकार किया जाता है)।

टिप्पणियाँ

यह सामान्य सहसंबंध की गणना नहीं करता है: यदि op2 op1 से बड़ा है, तो तर्क की अदला-बदली की जाती है, और जटिल सरणियों के लिए संयुग्म कभी नहीं लिया जाता है। सामान्य सिग्नल प्रोसेसिंग सहसंबंध के लिए PyArray_Correlate2 देखें।

PyObject* PyArray_Correlate2(PyObject* op1, PyObject* op2, int mode)

PyArray_Correlate का अपडेट किया गया संस्करण, जो 1d सरणियों के लिए सहसंबंध की सामान्य परिभाषा का उपयोग करता है। सहसंबंध गुणा करके प्रत्येक उत्पादन बिंदु पर गणना की जाती है OP1 के लिए स्थानांतरित कर दिया संस्करण द्वारा op2 और परिणाम संक्षेप। पारी का एक परिणाम के रूप में, जरूरत के परिभाषित सीमा के बाहर के मान OP1 और op2 शून्य के रूप में व्याख्या कर रहे हैं। मोड यह निर्धारित करता है कि कितने शिफ्ट्स को वापस लौटना है: 0 - केवल उन पारियों को लौटाएं जिन्हें शून्य मान लेने की आवश्यकता नहीं थी; 1 - एक ऑब्जेक्ट जो कि op1 के समान आकार है , 2 लौटाएं - 2 सभी संभव बदलाव लौटाएं (किसी भी ओवरलैप को स्वीकार किया जाता है)।

टिप्पणियाँ

गणना z इस प्रकार है:

z[k] = sum_n op1[n] * conj(op2[n+k])

PyObject* PyArray_Where(PyObject* condition, PyObject* x, PyObject* y)

यदि दोनों हैं x और y हैं NULL , तो वापस PyArray_Nonzero ( स्थिति )। अन्यथा, x और y दोनों को दिया जाना चाहिए और लौटाई गई वस्तु को स्थिति की तरह आकार दिया गया है और इसमें x और y के तत्व हैं जहां स्थिति क्रमशः सत्य या गलत है।

अन्य कार्य

Bool PyArray_CheckStrides(int elsize, int nd, npy_intp numbytes, npy_intp* dims, npy_intp* newstrides)

निर्धारित करें कि क्या newstrides आकार और तत्व-आकार, elsize के साथ nd -dimensional सरणी की स्मृति के अनुरूप एक सुसंगत सरणी है । Newstrides सरणी देखने के लिए कि प्रत्येक दिशा में बाइट्स की प्रदान की संख्या से कूद पहले से कहीं अधिक कूद मतलब होगा चेक किया गया है numbytes जो उपलब्ध स्मृति खंड के ग्रहण आकार है। यदि numbytes 0 है, तो एक समान numbytes संभालने गणना की जाती है nd , धुंधली हो जाती है , और elsize एक एकल खंड सरणी का संदर्भ लें। वापसी अगर newstrides स्वीकार्य है, अन्यथा वापस लौटें । dims NPY_TRUE NPY_FALSE

npy_intp PyArray_MultiplyList(npy_intp* seq, int n)

int PyArray_MultiplyIntList(int* seq, int n)

ये दोनों दिनचर्या पूर्णांक के n -length सरणी, seq , और परिणाम को वापस करते हैं। कोई अतिप्रवाह जाँच नहीं की जाती है।

int PyArray_CompareLists(npy_intp* l1, npy_intp* l2, int n)

पूर्णांक के दो n -length सरणियों, l1 , और l2 को देखते हुए , यदि सूची समान हैं, तो 1 लौटें; अन्यथा, 0 वापस करें।

ऑब्जेक्ट शब्दार्थ के साथ सहायक डेटा

NpyAuxData

अधिक जटिल dtypes के साथ काम करते समय, जो अन्य dtypes से बना होता है, जैसे कि संरचना dtype, आंतरिक लूप बनाते हैं जो dtypes को हेरफेर करने के लिए अतिरिक्त डेटा के साथ ले जाने की आवश्यकता होती है। NumPy इस विचार को एक संरचना के माध्यम से समर्थन करता है NpyAuxData , कुछ सम्मेलनों को अनिवार्य करता है ताकि ऐसा करना संभव हो सके।

सी को परिभाषित करना NpyAuxData सी + + में एक कक्षा को परिभाषित करने के समान है, लेकिन एपीआई में सी के बाद से ऑब्जेक्ट शब्दार्थ को मैन्युअल रूप से ट्रैक करना होगा। यहां एक फ़ंक्शन के लिए एक उदाहरण है जो एक तत्व कापियर फ़ंक्शन का उपयोग करके एक तत्व के रूप में दोगुना हो जाता है:

typedef struct {
    NpyAuxData base;
    ElementCopier_Func *func;
    NpyAuxData *funcdata;
} eldoubler_aux_data;

void free_element_doubler_aux_data(NpyAuxData *data)
{
    eldoubler_aux_data *d = (eldoubler_aux_data *)data;
    /* Free the memory owned by this auxdata */
    NPY_AUXDATA_FREE(d->funcdata);
    PyArray_free(d);
}

NpyAuxData *clone_element_doubler_aux_data(NpyAuxData *data)
{
    eldoubler_aux_data *ret = PyArray_malloc(sizeof(eldoubler_aux_data));
    if (ret == NULL) {
        return NULL;
    }

    /* Raw copy of all data */
    memcpy(ret, data, sizeof(eldoubler_aux_data));

    /* Fix up the owned auxdata so we have our own copy */
    ret->funcdata = NPY_AUXDATA_CLONE(ret->funcdata);
    if (ret->funcdata == NULL) {
        PyArray_free(ret);
        return NULL;
    }

    return (NpyAuxData *)ret;
}

NpyAuxData *create_element_doubler_aux_data(
                            ElementCopier_Func *func,
                            NpyAuxData *funcdata)
{
    eldoubler_aux_data *ret = PyArray_malloc(sizeof(eldoubler_aux_data));
    if (ret == NULL) {
        PyErr_NoMemory();
        return NULL;
    }
    memset(&ret, 0, sizeof(eldoubler_aux_data));
    ret->base->free = &free_element_doubler_aux_data;
    ret->base->clone = &clone_element_doubler_aux_data;
    ret->func = func;
    ret->funcdata = funcdata;

    return (NpyAuxData *)ret;
}

NpyAuxData_FreeFunc

NpyAuxData मुक्त फ़ंक्शन के लिए फ़ंक्शन पॉइंटर प्रकार।

NpyAuxData_CloneFunc

NpyAuxData क्लोन फ़ंक्शन के लिए फ़ंक्शन पॉइंटर प्रकार। इन कार्यों को कभी भी त्रुटि पर अजगर अपवाद सेट नहीं करना चाहिए, क्योंकि उन्हें बहु-थ्रेडेड संदर्भ से बुलाया जा सकता है।

NPY_AUXDATA_FREE(auxdata)

एक मैक्रो जो ऑक्सटाडा के निशुल्क फ़ंक्शन को उचित रूप से कहता है, अगर ऑक्टाटा NULL है तो कुछ भी नहीं करता है।

NPY_AUXDATA_CLONE(auxdata)

एक मैक्रो जो औक्साटा के क्लोन फ़ंक्शन को उचित रूप से कहता है, सहायक डेटा की एक गहरी प्रतिलिपि लौटाता है।

ऐरे इटरेटर

NumPy 1.6.0 के रूप में, इन सरणी iterators, नई सरणी इटरेटर द्वारा superceded कर रहे हैं NpyIter ।

एक सरणी पुनरावृत्त एक एन-आयामी सरणी के तत्वों को जल्दी और कुशलता से एक्सेस करने का एक सरल तरीका है। खंड 2 एक सरणी पर लूपिंग के लिए इस उपयोगी दृष्टिकोण का अधिक विवरण और उदाहरण प्रदान करता है।

PyObject* PyArray_IterNew(PyObject* arr)

सरणी से एक सरणी पुनरावृत्त वस्तु लौटें, गिरफ्तार करें । यह गिरफ्तारी के बराबर है । सपाट । सरणी इट्रेटर ऑब्जेक्ट सी-शैली सन्निहित फैशन में एन-आयामी गैर-सन्निहित सरणी पर लूप करना आसान बनाता है।

PyObject* PyArray_IterAllButAxis(PyObject* arr, int *axis)

एक सरणी पुनरावर्तक लौटें जो सभी अक्षों पर पुनरावृति करेगा, लेकिन जो * अक्ष में प्रदान किया गया है । लौटाए गए इटेरेटर का उपयोग नहीं किया जा सकता है PyArray_ITER_GOTO1D । इस इटरेटर का उपयोग कुछ ऐसा लिखने के लिए किया जा सकता है जो कि यूफंक्स करता है जिसमें सबसे बड़ी धुरी पर लूप एक अलग उप-दिनचर्या द्वारा किया जाता है। यदि * अक्ष ऋणात्मक है, तो * धुरी को सबसे छोटी तार वाली धुरी पर सेट किया जाएगा और उस अक्ष का उपयोग किया जाएगा।

PyObject *PyArray_BroadcastToShape(PyObject* arr, npy_intp *dimensions, int nd)

एक सरणी पुनरावृत्ति लौटाएं जो आयाम और nd द्वारा प्रदान की गई आकृति की एक सरणी के रूप में पुनरावृति के लिए प्रसारित होती है ।

int PyArrayIter_Check(PyObject* op)

यह सच है कि यदि ऑप एक एरे इटरेटर है (या एरे इट्रेटर टाइप के सबक्लास का उदाहरण)।

void PyArray_ITER_RESET(PyObject* iterator)

सरणी की शुरुआत के लिए एक पुनरावृत्ति रीसेट करें ।

void PyArray_ITER_NEXT(PyObject* iterator)

सूचकांक Incremement और की dataptr सदस्यों इटरेटर सरणी के अगले तत्व को इंगित करने के लिए। यदि सरणी (C- शैली) सन्निहित नहीं है, तो एन-आयामी निर्देशांक सरणी भी बढ़ाएँ।

void *PyArray_ITER_DATA(PyObject* iterator)

सरणी के वर्तमान तत्व के लिए एक सूचक।

void PyArray_ITER_GOTO(PyObject* iterator, npy_intp* destination)

सेट iterator सूचकांक, dataptr और सरणी एन आयामी सी सरणी, ने संकेत दिया में स्थान के लिए सदस्यों का समन्वय करता है गंतव्य है, जो आकार में कम से कम होनी चाहिए इटरेटर -> nd_m1 + 1।

PyArray_ITER_GOTO1D(PyObject* iterator, npy_intp index)

सेट इटरेटर सरणी पूर्णांक ने संकेत में सूचकांक और dataptr स्थान पर सूचकांक जो सी स्टाइल चपटी सरणी में एक तत्व को इंगित करता है।

int PyArray_ITER_NOTDONE(PyObject* iterator)

TRUE का मूल्यांकन तब तक किया जाता है जब तक कि सभी तत्वों के माध्यम से इट्रेटर लूप न हो जाए, अन्यथा यह FALSE का मूल्यांकन करता है।

प्रसारण (बहु-पुनरावृत्तियों)

PyObject* PyArray_MultiIterNew(int num, ...)

प्रसारण के लिए एक सरलीकृत इंटरफ़ेस। यह फ़ंक्शन प्रसारण करने के लिए सरणियों की संख्या लेता है और फिर संख्या अतिरिक्त ( PyObject * ) तर्क देता है। इन तर्कों को सरणियों में परिवर्तित किया जाता है और पुनरावृत्तियां बनाई जाती हैं। PyArray_Broadcast तब परिणामी मल्टी-इटरेटर ऑब्जेक्ट पर कॉल किया जाता है। परिणामी, प्रसारित मल्टी-इटरेटर ऑब्जेक्ट फिर वापस आ जाता है। एक प्रसारण ऑपरेशन तब एक लूप का उपयोग करके और PyArray_MultiIter_NEXT (..) किया जा सकता है

void PyArray_MultiIter_RESET(PyObject* multi)

सभी पुनरावृत्तियों को एक मल्टी-इटर्मीटर ऑब्जेक्ट, मल्टी में शुरुआत में रीसेट करें ।

void PyArray_MultiIter_NEXT(PyObject* multi)

बहु-वस्तु-वस्तु में प्रत्येक पुनरावृत्त को आगे , बहु को उसके अगले (प्रसारित) तत्व में।

void *PyArray_MultiIter_DATA(PyObject* multi, int i)

बहु-वस्तु वस्तु में i पुनरावृत्ति का डेटा-पॉइंटर लौटाएं ।

void PyArray_MultiIter_NEXTi(PyObject* multi, int i)

केवल का सूचक अग्रिम मैं iterator।

void PyArray_MultiIter_GOTO(PyObject* multi, npy_intp* destination)

प्रत्येक पुनरावर्तक को बहु-पुनरावृत्तीय वस्तु में बहु , एडवांस दिए गए -dimensional गंतव्य जहां प्रसारण सरणी में आयामों की संख्या है।

void PyArray_MultiIter_GOTO1D(PyObject* multi, npy_intp index)

इंडेक्स के संबंधित स्थान को चपटा प्रसारण वाले सरणी में मल्टी-इट्रोमेट ऑब्जेक्ट, मल्टी में प्रत्येक इटरेटर को एडवांस करें ।

int PyArray_MultiIter_NOTDONE(PyObject* multi)

TRUE का मूल्यांकन तब तक किया जाता है जब तक कि मल्टी-इटरेटर ने सभी तत्वों (प्रसारित परिणाम) के माध्यम से लूप नहीं किया हो, अन्यथा यह FALSE का मूल्यांकन करता है।

int PyArray_Broadcast(PyArrayMultiIterObject* mit)

यह फ़ंक्शन प्रसारण नियमों को ध्वस्त करता है। Mit कंटेनर पहले से ही सभी सरणियों प्रसारित करने की आवश्यकता है के लिए iterators शामिल करना चाहिए। वापसी पर, इन पुनरावृत्तियों को समायोजित किया जाएगा ताकि एक साथ प्रत्येक पर पुनरावृत्ति प्रसारण को पूरा करे। यदि कोई त्रुटि होती है तो एक ऋणात्मक संख्या वापस आ जाती है।

int PyArray_RemoveSmallest(PyArrayMultiIterObject* mit)

यह फ़ंक्शन एक मल्टी-इटरेटर ऑब्जेक्ट लेता है जिसे पहले "ब्रॉडकास्ट" किया गया है, प्रसारण परिणाम में सबसे छोटे "स्ट्राइड्स का योग" के साथ आयाम पाता है और सभी पुनरावृत्तियों को एडाप्ट करता है ताकि उस आयाम पर पुनरावृति न हो (प्रभावी रूप से उन्हें बनाकर लंबाई -1 उस आयाम में)। जब तक mit -> nd 0 नहीं है, तब तक इसी आयाम को लौटाया जाता है। यह फ़ंक्शन ufunc जैसी दिनचर्या के निर्माण के लिए उपयोगी है जो अपने इनपुट को सही ढंग से प्रसारित करता है और फिर रूट के 1-डी संस्करण को इनर-लूप के रूप में कॉल करता है। यह 1-डी संस्करण आमतौर पर गति के लिए अनुकूलित है और इस कारण से लूप को उस धुरी पर किया जाना चाहिए जिसके लिए बड़े स्ट्राइड जंप की आवश्यकता नहीं होगी।

पड़ोस का इटरेटर

नेबरहुड पुनरावृत्तियों को इटर्चर ऑब्जेक्ट के उप-वर्ग होते हैं, और इसका उपयोग एक बिंदु के पड़ोस में किया जा सकता है। उदाहरण के लिए, आप एक 3D छवि के प्रत्येक स्वर पर पुनरावृति करना चाह सकते हैं, और प्रत्येक ऐसे स्वर के लिए, किसी हाइपरक्यूब पर पुनरावृति कर सकते हैं। नेबरहुड इटरेटर स्वचालित रूप से सीमाओं को संभालता है, इस प्रकार इस तरह के कोड को मैन्युअल ओवरहेड हैंडलिंग की तुलना में थोड़ा सा ओवरहेड की कीमत पर लिखना आसान होता है।

PyObject* PyArray_NeighborhoodIterNew(PyArrayIterObject* iter, npy_intp bounds, int mode, PyArrayObject* fill_value)

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

सीमा तर्क होने की उम्मीद है एक (2 * iter-> ao-> nd) इस तरह के रेंज बाउंड के रूप में सरणियों, [2 * मैं] -> सीमा [2 * i + 1] रेंज जहां आयाम के लिए चलने के लिए परिभाषित करता है मैं (दोनों सीमाएँ चलने वाले निर्देशांक में शामिल हैं)। सीमा को प्रत्येक आयाम के लिए आदेश दिया जाना चाहिए (सीमा [2 * i] <= सीमा [2 * i + 1])।

मोड में से एक होना चाहिए:

• NPY_NEIGHBORHOOD_ITER_ZERO_PADDING: शून्य गद्दी। बाहर सीमा मान 0 होगा।
• NPY_NEIGHBORHOOD_ITER_ONE_PADDING: एक गद्दी, बाहरी सीमा मान 1 होगा।
• NPY_NEIGHBORHOOD_ITER_CONSTANT_PADDING: लगातार पैडिंग। बाहरी सीमा मान fill_value में पहले आइटम के समान होंगे।
• NPY_NEIGHBORHOOD_ITER_MIRROR_PADDING: दर्पण पैडिंग। बाहरी सीमा मान ऐसे होंगे जैसे कि सरणी आइटम मिरर किए गए थे। उदाहरण के लिए, सरणी के लिए [1, 2, 3, 4], x [-2] 2 होगा, x [-2] 1 होगा, x [4] 4 होगा, x [5] 1 होगा आदि…
• NPY_NEIGHBORHOOD_ITER_CIRCULAR_PADDING: परिपत्र पैडिंग। बाहरी सीमा मान ऐसे होंगे जैसे कि सरणी दोहराई गई थी। उदाहरण के लिए, सरणी के लिए [1, 2, 3, 4], x [-2] 3 होगा, x [-2] 4 होगा, x [4] 1 होगा, x [5] 2 होगा आदि…

यदि मोड निरंतर फिलिंग है (NPY_NEIGHBORHOOD_ITER_CONSTANT_PADDING), fill_value को एक एरे ऑब्जेक्ट को इंगित करना चाहिए जो फिलिंग वैल्यू रखता है (यदि एरे में एक से अधिक आइटम हैं तो पहला आइटम फिलिंग वैल्यू होगा) अन्य मामलों के लिए, fill_value NULL हो सकता है।

• पुनरावृत्त iter के लिए एक संदर्भ रखता है
• विफलता पर वापसी (जिस स्थिति में पुनरावृत्ति की गिनती नहीं बदली जाती है)
• iter ही नेबरहुड इटरेटर हो सकता है: यह .eg स्वचालित सीमाओं से निपटने के लिए उपयोगी हो सकता है
• इस फ़ंक्शन द्वारा लौटाए गए ऑब्जेक्ट को सामान्य पुनरावृत्त के रूप में उपयोग करने के लिए सुरक्षित होना चाहिए
• यदि पुनरावृति की स्थिति को बदल दिया जाता है, तो PyArrayNeighborhoodIter_Next के लिए किसी भी बाद की कॉल अपरिभाषित व्यवहार है, और PyArrayNeighborhoodIter_Reset को कॉल करना होगा।

PyArrayIterObject \*iter;
PyArrayNeighborhoodIterObject \*neigh_iter;
iter = PyArray_IterNew(x);

//For a 3x3 kernel
bounds = {-1, 1, -1, 1};
neigh_iter = (PyArrayNeighborhoodIterObject*)PyArrayNeighborhoodIter_New(
     iter, bounds, NPY_NEIGHBORHOOD_ITER_ZERO_PADDING, NULL);

for(i = 0; i < iter->size; ++i) {
     for (j = 0; j < neigh_iter->size; ++j) {
             // Walk around the item currently pointed by iter->dataptr
             PyArrayNeighborhoodIter_Next(neigh_iter);
     }

     // Move to the next point of iter
     PyArrayIter_Next(iter);
     PyArrayNeighborhoodIter_Reset(neigh_iter);
}

int PyArrayNeighborhoodIter_Reset(PyArrayNeighborhoodIterObject* iter)

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

int PyArrayNeighborhoodIter_Next(PyArrayNeighborhoodIterObject* iter)

इस कॉल के बाद, iter-> dataptr पड़ोस के अगले बिंदु पर इंगित करता है। पड़ोस के हर बिंदु पर जाने के बाद इस फ़ंक्शन को कॉल करना अपरिभाषित है।

स्केल स्कार्स

PyObject* PyArray_Return(PyArrayObject* arr)

इस समारोह के लिए एक संदर्भ चुरा आगमन ।

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

PyObject* PyArray_Scalar(void* data, PyArray_Descr* dtype, PyObject* itemsize)

दिए गए प्रगणित टाइपेनम की एक सरणी स्केलर ऑब्जेक्ट लौटाएं और डेटा द्वारा बताई गई मेमोरी से कॉपी करके आइटम करें । यदि स्वैप नॉनवेज है तो यह फ़ंक्शन डेटा-टाइप के लिए उपयुक्त होने पर डेटा को बाइट्सबाय करेगा क्योंकि सरणी स्केलर हमेशा सही मशीन-बाइट क्रम में होते हैं।

PyObject* PyArray_ToScalar(void* data, PyArrayObject* arr)

प्रकार की एक सरणी अदिश वस्तु लौटें और itemsize सरणी वस्तु ने संकेत दिया आगमन की नकल की स्मृति द्वारा की ओर इशारा किया डेटा और गमागमन अगर में डेटा आगमन मशीन बाइट-क्रम में नहीं है।

PyObject* PyArray_FromScalar(PyObject* scalar, PyArray_Descr* outcode)

स्केलर से आउटकोड द्वारा निर्धारित प्रकार के 0-आयामी सरणी को लौटाएं जो एक सरणी-स्केलर ऑब्जेक्ट होना चाहिए। यदि आउटकोड NULL है, तो स्केलर से प्रकार निर्धारित किया जाता है ।

void PyArray_ScalarAsCtype(PyObject* scalar, void* ctypeptr)

किसी सरणी स्केलर में वास्तविक मान के लिए एक पॉइंटरप्रेटर में पॉइंटर पर लौटें । कोई त्रुटि जाँच नहीं है ताकि स्केलर एक सरणी-स्केलर ऑब्जेक्ट होना चाहिए, और ctypeptr में सही प्रकार रखने के लिए पर्याप्त स्थान होना चाहिए। लचीले आकार के प्रकारों के लिए, डेटा के लिए एक सूचक को ctypeptr की मेमोरी में कॉपी किया जाता है , अन्य सभी प्रकारों के लिए, वास्तविक डेटा को ctypeptr द्वारा इंगित पते में कॉपी किया जाता है ।

void PyArray_CastScalarToCtype(PyObject* scalar, void* ctypeptr, PyArray_Descr* outcode)

डेटा (ने संकेत दिया डेटा प्रकार के लिए डाली लौटें outcode सरणी-अदिश, से) अदिश , में स्मृति द्वारा की ओर इशारा किया ctypeptr (जो इतना बड़ा भेजे स्मृति को संभालने के लिए होना चाहिए)।

PyObject* PyArray_TypeObjectFromType(int type)

एक टाइप-संख्या, प्रकार से एक अदिश प्रकार-वस्तु लौटाता है । समतुल्य PyArray_DescrFromType ( प्रकार ) के लिए -> संदर्भ गिनती और त्रुटि-जाँच को छोड़कर टाइपबॉज। सफलता या NULL विफलता पर टाइपोबॉज का एक नया संदर्भ देता है ।

NPY_SCALARKIND PyArray_ScalarKind(int typenum, PyArrayObject** arr)

PyArray_MinScalarType NumPy 1.6.0 में पेश किए गए एक वैकल्पिक तंत्र के लिए फ़ंक्शन देखें ।

द्वारा प्रतिनिधित्व अदिश की तरह लौटें typenum और में सरणी * आगमन (यदि आगमन नहीं है NULL )। सरणी को रैंक -० माना जाता है और केवल तभी उपयोग किया जाता है यदि टाइपेनम एक हस्ताक्षरित पूर्णांक का प्रतिनिधित्व करता है। यदि गिरफ्तारी नहीं हुई है NULL और पहला तत्व नकारात्मक है तो NPY_INTNEG_SCALAR वापस लौटा दिया जाता है, अन्यथा NPY_INTPOS_SCALAR वापस कर दिया जाता है। संभावित वापसी मान हैं NPY_{kind}_SCALAR जहां {kind} हो सकता है INTPOS , INTNEG , फ्लोट , परिसर , BOOL , या वस्तु । NPY_NOSCALAR एक एन्युमरेटेड वैल्यू NPY_SCALARKIND वैरिएबल भी ले सकता है।

int PyArray_CanCoerceScalar(char thistype, char neededtype, NPY_SCALARKIND scalar)

PyArray_ResultType NumPy प्रकार के प्रचार के विवरण के लिए फ़ंक्शन देखें , NumPy 1.6.0 में अपडेट किया गया।

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

डेटा-प्रकार के वर्णनकर्ता

int PyArray_DescrCheck(PyObject* obj)

के रूप में सच का मूल्यांकन करता है, तो obj एक डेटा प्रकार वस्तु है ( PyArray_Descr )।

PyArray_Descr* PyArray_DescrNew(PyArray_Descr* obj)

Obj से कॉपी की गई एक नई डेटा-टाइप ऑब्जेक्ट लौटाएं (फ़ील्ड संदर्भ को बस अपडेट किया जाता है ताकि नई ऑब्जेक्ट उसी फ़ील्ड डिक्शनरी को इंगित करे यदि कोई हो)।

PyArray_Descr* PyArray_DescrNewFromType(int typenum)

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

PyArray_Descr* PyArray_DescrNewByteorder(PyArray_Descr* obj, char newendian)

न्यूएन्डियन के अनुसार बाइटऑर्डर के साथ एक नया डेटा-टाइप ऑब्जेक्ट बनाएं । सभी संदर्भित डेटा-टाइप ऑब्जेक्ट्स (उप-प्रकार में और डेटा-प्रकार ऑब्जेक्ट के फ़ील्ड सदस्य) भी बदल दिए जाते हैं (पुनरावर्ती)। यदि एक बाइटऑर्डर का NPY_IGNORE सामना किया जाता है तो इसे अकेला छोड़ दिया जाता है। यदि न्यूएन्डियन है NPY_SWAP , तो सभी बाइट-ऑर्डर स्वैप किए जाते हैं। अन्य मान्य न्यूएंडियन मान हैं NPY_NATIVE , NPY_LITTLE और NPY_BIG जो सभी लौटाए गए डेटा-टाइप किए गए डिस्क्रिप्टर का कारण बनते हैं (और यह सब डेटा टाइप डिस्क्रिप्टर का संदर्भ होता है) इसी बाइट को क्रम में रखते हैं।

PyArray_Descr* PyArray_DescrFromObject(PyObject* op, PyArray_Descr* mintype)

ऑब्जेक्ट ऑप (जो "नेस्टेड" अनुक्रम ऑब्जेक्ट होना चाहिए) और न्यूनतम डेटा-टाइप डिस्क्रिप्टर मिनीटेप (जो हो सकता है NULL ) से एक उपयुक्त डेटा-टाइप ऑब्जेक्ट निर्धारित करें । सरणी ( op ) .dtype के समान व्यवहार में । इस फ़ंक्शन को भ्रमित न करें PyArray_DescrConverter । यह फ़ंक्शन अनिवार्य रूप से (नेस्टेड) ​​अनुक्रम में सभी ऑब्जेक्ट्स को देखता है और इसे खोजने वाले तत्वों से डेटा-प्रकार निर्धारित करता है।

PyArray_Descr* PyArray_DescrFromScalar(PyObject* scalar)

सरणी-स्केलर ऑब्जेक्ट से डेटा-प्रकार ऑब्जेक्ट लौटाएं। यह सुनिश्चित करने के लिए कोई जाँच नहीं की जाती है कि स्केलर एक सरणी स्केलर है। यदि कोई उपयुक्त डेटा-प्रकार निर्धारित नहीं किया जा सकता है, तो एक डेटा-प्रकार NPY_OBJECT डिफ़ॉल्ट रूप से वापस आ जाता है।

PyArray_Descr* PyArray_DescrFromType(int typenum)

टाइप करने के लिए इसी डेटा-टाइप ऑब्जेक्ट देता है । Typenum प्रगणित प्रकारों में से एक, प्रगणित प्रकारों में से एक है, या एक उपयोगकर्ता परिभाषित प्रकार के लिए एक चरित्र कोड हो सकता है।

int PyArray_DescrConverter(PyObject* obj, PyArray_Descr** dtype)

किसी भी संगत पायथन ऑब्जेक्ट, obj को डेटा टाइप ऑब्जेक्ट में dtype में कनवर्ट करें । बड़ी संख्या में पायथन ऑब्जेक्ट को डेटा-टाइप ऑब्जेक्ट में परिवर्तित किया जा सकता है। संपूर्ण विवरण के लिए डेटा प्रकार ऑब्जेक्ट (dtype) देखें । कनवर्टर का यह संस्करण किसी भी ऑब्जेक्ट को NPY_DEFAULT_TYPE डेटा-टाइप ऑब्जेक्ट में कनवर्ट नहीं करता है । इस फ़ंक्शन का उपयोग PyArg_ParseTuple प्रसंस्करण में "O &" वर्ण कोड के साथ किया जा सकता है ।

int PyArray_DescrConverter2(PyObject* obj, PyArray_Descr** dtype)

किसी भी संगत पायथन ऑब्जेक्ट, obj को डेटा टाइप ऑब्जेक्ट में dtype में कनवर्ट करें । कनवर्टर का यह संस्करण किसी भी ऑब्जेक्ट को परिवर्तित नहीं करता है ताकि लौटा हुआ डेटा-प्रकार है NULL । इस फ़ंक्शन का उपयोग PyArg_ParseTuple प्रसंस्करण में "O &" वर्ण के साथ भी किया जा सकता है।

int Pyarray_DescrAlignConverter(PyObject* obj, PyArray_Descr** dtype)

जैसा PyArray_DescrConverter छोड़कर यह शब्द-सीमाओं पर सी struct की तरह वस्तुओं संरेखित करता है संकलक के रूप में होगा।

int Pyarray_DescrAlignConverter2(PyObject* obj, PyArray_Descr** dtype)

जैसा PyArray_DescrConverter2 छोड़कर यह शब्द-सीमाओं पर सी struct की तरह वस्तुओं संरेखित करता है संकलक के रूप में होगा।

PyObject *PyArray_FieldNames(PyObject* dict)

खेतों शब्दकोश, ले लो dict इस तरह के एक डेटा प्रकार वस्तु से जुड़ी एक के रूप में, और इस तरह के रूप में के नाम क्षेत्र में संग्रहीत किया जाता है फ़ील्ड नाम के एक आदेश दिया-सूची का निर्माण PyArray_Descr वस्तु।

रूपांतरण उपयोगिताएँ

के साथ प्रयोग के लिए PyArg_ParseTuple

इन सभी फ़ंक्शंस का उपयोग PyArg_ParseTuple (…) “O &” प्रारूप के साथ किया जा सकता है जो किसी भी पायथन ऑब्जेक्ट को आवश्यक C- ऑब्जेक्ट में स्वचालित रूप से परिवर्तित करने के लिए निर्दिष्ट करता है। ये सभी कार्य NPY_SUCCEED सफल होने पर वापस आते हैं और NPY_FAIL यदि नहीं तो। इन सभी फ़ंक्शन का पहला तर्क पायथन ऑब्जेक्ट है। दूसरा तर्क पायथन ऑब्जेक्ट को कन्वर्ट करने के लिए सी-टाइप का पता है।

int PyArray_Converter(PyObject* obj, PyObject** address)

किसी भी पायथन ऑब्जेक्ट को a में कनवर्ट करें PyArrayObject । यदि PyArray_Check ( obj ) TRUE है तो इसकी संदर्भ संख्या बढ़ाई जाती है और पते में एक संदर्भ दिया जाता है । यदि ओब्ज एक ऐरे नहीं है, तो इसका उपयोग करके ऐरे में बदलें PyArray_FromAny । कोई फर्क नहीं पड़ता कि क्या लौटा है, आपको इस रूटीन द्वारा दिए गए ऑब्जेक्ट को पते में वापस करना होगा जब आप इसके साथ काम करते हैं

int PyArray_OutputConverter(PyObject* obj, PyArrayObject** address)

यह फ़ंक्शन के लिए दिए गए आउटपुट सरणियों के लिए एक डिफ़ॉल्ट कनवर्टर है। यदि obj है Py_None या NULL है, तो * पता होगा NULL लेकिन कॉल सफल होगा। यदि PyArray_Check ( obj ) TRUE है, तो यह उसके संदर्भ गणना को बढ़ाए बिना * पते में वापस कर दिया जाता है ।

int PyArray_IntpConverter(PyObject* obj, PyArray_Dims* seq)

किसी भी पायथन सीक्वेंस को परिवर्तित करें, ओजे , NPY_MAXDIMS सी-सरणी से छोटा है npy_intp । पायथन ऑब्जेक्ट भी एक ही संख्या हो सकती है। Seq चर एक संरचना के सदस्यों के साथ ptr और लेन करने के लिए एक सूचक है। सफल वापसी पर, seq -> ptr में मेमोरी के लिए एक पॉइंटर होता है जिसे PyDimMem_FREE मेमोरी लीक से बचने के लिए, कॉल करके, मुक्त किया जाना चाहिए । स्मृति आकार पर प्रतिबंध इस कनवर्टर को सरणी आकृतियों के रूप में व्याख्या किए जाने वाले अनुक्रमों के लिए आसानी से उपयोग करने की अनुमति देता है।

int PyArray_BufferConverter(PyObject* obj, PyArray_Chunk* buf)

किसी भी पायथन ऑब्जेक्ट को कनवर्ट करें, ओब्ज , (सिंगल-सेगमेंट) बफर इंटरफ़ेस के साथ सदस्यों के साथ एक चर के लिए जो ऑब्जेक्ट को उसकी मेमोरी के उपयोग का विस्तार करता है। Buf चर आधार, ptr, लेन, और झंडे के सदस्यों के साथ एक संरचना करने के लिए एक सूचक है। यह PyArray_Chunk संरचना पाइथन की बफर ऑब्जेक्ट (32-बिट प्लेटफॉर्म पर अपने लेयन सदस्य के माध्यम से और 64-बिट प्लेटफ़ॉर्म पर इसके पीटीआर सदस्य के माध्यम से या पायथन 2.5 में) बाइनरी संगत है। वापसी पर, बेस सदस्य को obj पर सेट किया जाता है (या इसका आधार अगर obj पहले से ही किसी अन्य ऑब्जेक्ट की ओर इशारा करते हुए बफर ऑब्जेक्ट है)। यदि आपको मेमोरी को होल्ड करने की आवश्यकता है, तो आधार सदस्य को INCREF करना सुनिश्चित करें। मेमोरी का हिस्सा बफ़ द्वारा इंगित किया गया है -> ptr सदस्य और लंबाई बफ़ है -> लेन। के झंडे सदस्य buf है NPY_BEHAVED_RO साथ NPY_ARRAY_WRITEABLE ध्वज सेट करता है, तो obj राईट योग्य बफर इंटरफ़ेस है।

int PyArray_AxisConverter(PyObject * obj, int* axis)

एक पूर्णांक अक्ष लेने वाले कार्यों के लिए उचित मान के लिए एक अक्ष तर्क का प्रतिनिधित्व करते हुए एक पायथन ऑब्जेक्ट, obj , को रूपांतरित करें । विशेष रूप से, यदि ओबज कोई भी नहीं है, तो अक्ष को सेट किया जाता है NPY_MAXDIMS जिसे सी-एपीआई फ़ंक्शन द्वारा सही ढंग से व्याख्या की जाती है जो अक्ष तर्क लेती है।

int PyArray_BoolConverter(PyObject* obj, Bool* value)

किसी भी पायथन ऑब्जेक्ट को ओब्जर्व करें , NPY_TRUE या NPY_FALSE परिणाम को वैल्यू में रखें ।

int PyArray_ByteorderConverter(PyObject* obj, char* endian)

पाइथन स्ट्रिंग को संबंधित बाइट-ऑर्डर वर्ण में परिवर्तित करें: '>', '<', 's', '=', या '' '।

int PyArray_SortkindConverter(PyObject* obj, NPY_SORTKIND* sort)

पायथन स्ट्रिंग्स को एक में परिवर्तित करें NPY_QUICKSORT ('q' या 'Q' से NPY_HEAPSORT शुरू होता है ), ('h' या 'H' से NPY_MERGESORT शुरू होता है ), या ('m' या 'M' से शुरू होता है)।

int PyArray_SearchsideConverter(PyObject* obj, NPY_SEARCHSIDE* side)

पायथन स्ट्रिंग्स को एक में परिवर्तित करें NPY_SEARCHLEFT ('एल' या 'एल' से NPY_SEARCHRIGHT शुरू होता है ), या ('आर' या 'आर' से शुरू होता है)।

int PyArray_OrderConverter(PyObject* obj, NPY_ORDER* order)

अजगर तार 'सी' कन्वर्ट, 'एफ', 'ए', और में 'के' NPY_ORDER गणन NPY_CORDER , NPY_FORTRANORDER , NPY_ANYORDER , और NPY_KEEPORDER ।

int PyArray_CastingConverter(PyObject* obj, NPY_CASTING* casting)

कन्वर्ट अजगर तार 'नहीं', 'समतुल्य', 'सुरक्षित', 'same_kind', और में 'असुरक्षित' NPY_CASTING गणन NPY_NO_CASTING , NPY_EQUIV_CASTING , NPY_SAFE_CASTING , NPY_SAME_KIND_CASTING , और NPY_UNSAFE_CASTING ।

int PyArray_ClipmodeConverter(PyObject* object, NPY_CLIPMODE* val)

में अजगर तार 'क्लिप', 'रैप', और 'बढ़ाने' कन्वर्ट NPY_CLIPMODE गणन NPY_CLIP , NPY_WRAP और NPY_RAISE ।

int PyArray_ConvertClipmodeSequence(PyObject* object, NPY_CLIPMODE* modes, int n)

NPY_CLIPMODE मूल्यों के सी सरणी में क्लिपमोड्स या एकल क्लिपमोड के अनुक्रम को परिवर्तित करता है। इस फ़ंक्शन को कॉल करने से पहले क्लिपमोड्स n की संख्या ज्ञात होनी चाहिए। यह फ़ंक्शन प्रत्येक आयाम के लिए फ़ंक्शन को एक अलग क्लिपमोड की अनुमति देने में मदद करने के लिए प्रदान किया जाता है।

अन्य रूपांतरण

int PyArray_PyIntAsInt(PyObject* op)

पायथन ऑब्जेक्ट्स के सभी प्रकार (एरे और सरणी स्केलर्स सहित) को मानक पूर्णांक में बदलें। त्रुटि पर, -1 लौटा दिया जाता है और एक अपवाद सेट होता है। आपको उपयोगी मैक्रो मिल सकता है:

#define error_converting(x) (((x) == -1) && PyErr_Occurred()

npy_intp PyArray_PyIntAsIntp(PyObject* op)

(प्लेटफ़ॉर्म-पॉइंटर-आकार) पूर्णांक के सभी प्रकार के पायथन ऑब्जेक्ट्स (सरणियों और सरणी स्केलरों सहित) को कनवर्ट करें। त्रुटि पर, -1 लौटा दिया जाता है और एक अपवाद सेट होता है।

int PyArray_IntpFromSequence(PyObject* seq, npy_intp* vals, int maxvals)

कन्वर्ट किसी भी अजगर अनुक्रम (या एक अजगर संख्या) के रूप में पास seq (तक) के लिए maxvals सूचक आकार पूर्णांकों और उन्हें रखते हैं Vals सरणी। अनुक्रम छोटा हो सकता है फिर परिवर्तित वस्तुओं की संख्या के रूप में अधिकतम अंतराल ।

int PyArray_TypestrConvert(int itemsize, int gentype)

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

कई तरह का

एपीआई आयात कर रहा है

किसी अन्य एक्सटेंशन मॉड्यूल से C-API का उपयोग करने के लिए, import_array फ़ंक्शन को बुलाया जाना चाहिए। यदि विस्तार मॉड्यूल एकल .सी फ़ाइल में स्व-सम्‍मिलित है, तो वह सब कुछ किया जाना चाहिए। यदि, हालांकि, विस्तार मॉड्यूल में कई फाइलें शामिल हैं जहां C-API की आवश्यकता है तो कुछ अतिरिक्त कदम उठाए जाने चाहिए।

void import_array(void)

इस फ़ंक्शन को एक मॉड्यूल के आरंभीकरण अनुभाग में बुलाया जाना चाहिए जो सी-एपीआई का उपयोग करेगा। यह मॉड्यूल को आयात करता है जहां फ़ंक्शन-पॉइंटर टेबल संग्रहीत होती है और इसके लिए सही चर इंगित करता है।

PY_ARRAY_UNIQUE_SYMBOL

NO_IMPORT_ARRAY

इन #defines का उपयोग करके आप एकल एक्सटेंशन मॉड्यूल के लिए कई फ़ाइलों में C-API का उपयोग कर सकते हैं। प्रत्येक फ़ाइल में आपको PY_ARRAY_UNIQUE_SYMBOL सी-एपीआई ( जैसे myextension_ARRAY_API) को धारण करने वाले कुछ नाम को परिभाषित करना होगा । यह numpy / arrayobject.h फ़ाइल को शामिल करने से पहले किया जाना चाहिए । मॉड्यूल इनिशियलाइज़ेशन रूटीन में आप कॉल करते हैं import_array । इसके अलावा, जिन फाइलों में मॉड्यूल इनिशियलाइज़ेशन सब_रूटीन नहीं होता है, उन्हें NO_IMPORT_ARRAY पहले से ही numpy / arrayobject.h को शामिल करना चाहिए।

मान लीजिए कि मेरे पास दो फाइलें coolmodule.c और coolhelper.c हैं जिन्हें संकलित करने और एकल एक्सटेंशन मॉड्यूल में लिंक करने की आवश्यकता है। मान लीजिए कि coolmodule.c में आवश्यक initcool मॉड्यूल आरंभीकरण फ़ंक्शन (import_array () फ़ंक्शन कहा जाता है) के साथ है। फिर, coolmodule.c सबसे ऊपर होगा:

#define PY_ARRAY_UNIQUE_SYMBOL cool_ARRAY_API
#include numpy/arrayobject.h

दूसरी ओर, coolhelper.c सबसे ऊपर होगा:

#define NO_IMPORT_ARRAY
#define PY_ARRAY_UNIQUE_SYMBOL cool_ARRAY_API
#include numpy/arrayobject.h

जब तक आप यह सुनिश्चित कर लें कि NO_IMPORT_ARRAY #Dfined है उस फ़ाइल को खोलने से पहले आप सामान्य दो अंतिम पंक्तियों को एक्सटेंशन-लोकल हेडर फ़ाइल में डाल सकते हैं।

आंतरिक रूप से, ये # कार्य इस प्रकार हैं:

• यदि न तो परिभाषित किया गया है, तो C-API को घोषित किया गया है static void** , इसलिए यह केवल संकलन इकाई के भीतर दिखाई देता है जो #includes numpy / arrayobject.h है।
• यदि # PY_ARRAY_UNIQUE_SYMBOL निर्धारित है, लेकिन NO_IMPORT_ARRAY नहीं है, तो सी-एपीआई को घोषित किया जाता है void** , ताकि यह अन्य संकलन इकाइयों को भी दिखाई दे।
• अगर NO_IMPORT_ARRAY #Dfined है, चाहे PY_ARRAY_UNIQUE_SYMBOL वह सी-एपीआई घोषित किया गया है extern void** , तो यह एक और अनिवार्य इकाई में परिभाषित होने की उम्मीद है।
• जब भी PY_ARRAY_UNIQUE_SYMBOL #defined होता है, तो यह C-API रखने वाले वैरिएबल के नाम को भी बदल देता है, जो कि जिस PyArray_API भी मैक्रो #defined है, उसे डिफॉल्ट करता है।

एपीआई संस्करण की जाँच करना

क्योंकि अधिकांश प्लेटफार्मों पर सामान्य पुस्तकालयों की तरह अजगर एक्सटेंशन का उपयोग नहीं किया जाता है, कुछ त्रुटियों का निर्माण समय या यहां तक ​​कि रनटाइम पर स्वचालित रूप से नहीं किया जा सकता है। उदाहरण के लिए, यदि आप केवल numpy> = 1.3.0 के लिए उपलब्ध फ़ंक्शन का उपयोग करके एक्सटेंशन बनाते हैं, और आप एक्सटेंशन को बाद में numpy 1.2 के साथ आयात करते हैं, तो आपको आयात त्रुटि नहीं मिलेगी (लेकिन फ़ंक्शन को कॉल करते समय लगभग निश्चित रूप से एक विभाजन दोष) । यही कारण है कि सुन्न संस्करणों के लिए जांच करने के लिए कई कार्य प्रदान किए जाते हैं। मैक्रोज़ NPY_VERSION और NPY_FEATURE_VERSION एक्सटेंशन के निर्माण के लिए उपयोग किए जाने वाले संख्यात्मक संस्करण से मेल खाती है, जबकि संस्करण PyArray_GetNDArrayCVersion और PyArray_GetNDArrayCFeatureVersion फ़ंक्शन द्वारा लौटाए गए रनटाइम के खसरे संस्करण से मेल खाते हैं।

एबीआई और एपीआई कॉम्पिटिशन के नियमों को संक्षेप में प्रस्तुत किया जा सकता है:

• जब भी NPY_VERSION ! = PyArray_GetNDArrayCVersion, विस्तार को फिर से शुरू किया जाना चाहिए (ABI असंगति)।
• NPY_VERSION == PyArray_GetNDArrayCVersion और NPY_FEATURE_VERSION <= PyArray_GetNDArrayCFeatureVersion का अर्थ है पिछड़े संगत परिवर्तन।

ABI की असंगति स्वचालित रूप से हर सुन्न के संस्करण में पाई जाती है। एपीआई असंगतता का पता लगाने के लिए 1.4.0 अंकों में जोड़ा गया था। यदि आप एक एक्सटेंशन बाइनरी के साथ कई अलग-अलग सुन्न संस्करणों का समर्थन करना चाहते हैं, तो आपको अपना विस्तार संभव के रूप में सबसे कम NPY_FEATURE_VERSION के साथ बनाना होगा।

unsigned int PyArray_GetNDArrayCVersion(void)

यह सिर्फ मान लौटाता है NPY_VERSION । NPY_VERSION जब भी एबीआई स्तर पर एक पिछड़े असंगत परिवर्तन होता है। क्योंकि यह C-API में है, हालांकि, इस फ़ंक्शन के आउटपुट की तुलना वर्तमान हेडर में परिभाषित मूल्य से की जाती है, यदि C-API बदल गया है, तो इस तरह से टेस्ट मॉड्यूल के पुन: संकलन की आवश्यकता होती है जो C का उपयोग करता है -API। यह फ़ंक्शन में स्वचालित रूप से जाँच की जाती है import_array ।

unsigned int PyArray_GetNDArrayCFeatureVersion(void)

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

यह सिर्फ मान लौटाता है NPY_FEATURE_VERSION । NPY_FEATURE_VERSION जब भी एपीआई बदलता है (जैसे एक फ़ंक्शन जोड़ा जाता है)। एक बदले हुए मूल्य को हमेशा एक recompile की आवश्यकता नहीं होती है।

आंतरिक लचीलापन

int PyArray_SetNumericOps(PyObject* dict)

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

जोड़ने , घटाना , गुणा , विभाजन , शेष , शक्ति , वर्ग , पारस्परिक , ones_like , sqrt , नकारात्मक , सकारात्मक , पूर्ण , की विपरीत , left_shift , right_shift , bitwise_and , bitwise_xor , bitwise_or , कम , less_equal , बराबर , not_equal , अधिक से अधिक , greater_equal , floor_divide , true_divide , logical_or , logical_and , फर्श , प्लस्तर लगाना , अधिकतम , न्यूनतम , प्रिंट करें ।

इन कार्यों को यहां शामिल किया गया है क्योंकि वे सरणी ऑब्जेक्ट के तरीकों में कम से कम एक बार उपयोग किए जाते हैं। फ़ंक्शन -1 लौटता है (पायथन त्रुटि को सेट किए बिना) यदि निर्दिष्ट वस्तुओं में से एक को कॉल करने योग्य नहीं है।

PyObject* PyArray_GetNumericOps(void)

एक पायथन डिक्शनरी लौटाएं जिसमें कॉलिबल पायथन ऑब्जेक्ट्स आंतरिक आंतरिक ऑपरेशन टेबल में संग्रहीत हैं। इस डिक्शनरी की चाबियां स्पष्टीकरण के लिए दी गई हैं PyArray_SetNumericOps ।

void PyArray_SetStringFunction(PyObject* op, int repr)

यह फ़ंक्शन आपको सरणी ऑब्जेक्ट के tp_str और tp_repr तरीकों को किसी भी पायथन फ़ंक्शन में बदलने की अनुमति देता है। इस प्रकार आप बदल सकते हैं कि जब स्ट्रिंग (गिरफ्तारी) या रीप्र (गिरफ्तारी) पायथॉन से होती है तो सभी सरणियों के लिए क्या होता है। कहे जाने वाले फ़ंक्शन को op के रूप में पास किया जाता है । यदि repr नॉन-जीरो है, तो इस फ़ंक्शन को repr (arr) के जवाब में कहा जाएगा, अन्यथा str (arr) के जवाब में फ़ंक्शन को कॉल किया जाएगा। ऑप कॉल करने योग्य है या नहीं इसकी कोई जांच नहीं की जाती है। Op करने के लिए पास किया गया कॉल करने योग्य सरणी तर्क की अपेक्षा करनी चाहिए और मुद्रित होने के लिए एक स्ट्रिंग लौटना चाहिए।

स्मृति प्रबंधन

char* PyDataMem_NEW(size_t nbytes)

PyDataMem_FREE(char* ptr)

char* PyDataMem_RENEW(void * ptr, size_t newbytes)

मैक्रो को आवंटित, मुफ्त और वास्तविक मेमोरी को आवंटित करना है। इन मैक्रोज़ का उपयोग आंतरिक रूप से एरेज़ बनाने के लिए किया जाता है।

npy_intp* PyDimMem_NEW(nd)

PyDimMem_FREE(npy_intp* ptr)

npy_intp* PyDimMem_RENEW(npy_intp* ptr, npy_intp newnd)

मैक्रोज़ को आवंटित करने, मुक्त करने और वास्तविक आयाम और मेमोरी को स्ट्राइड करने के लिए।

PyArray_malloc(nbytes)

PyArray_free(ptr)

PyArray_realloc(ptr, nbytes)

ये मैक्रोज़ विभिन्न मेमोरी एलोकेटर्स का उपयोग करते हैं, जो निरंतर पर निर्भर करता है NPY_USE_PYMEM । सिस्टम मॉलोक का उपयोग तब किया जाता है जब NPY_USE_PYMEM 0 होता है, यदि NPY_USE_PYMEM 1 है, तो पायथन मेमोरी एलोकेटर का उपयोग किया जाता है।

int PyArray_ResolveWritebackIfCopy(PyArrayObject* obj)

अगर obj.flags है NPY_ARRAY_WRITEBACKIFCOPY या (बहिष्कृत) NPY_ARRAY_UPDATEIFCOPY , इस समारोह प्रतियां obj->data करने के लिए obj->base->data , को साफ करता है झंडे, DECREF रों obj->base और यह लिखने योग्य बनाता है, और सेट obj->base शून्य पर। यह इसके विपरीत है PyArray_SetWritebackIfCopyBase । आमतौर पर इसे एक बार कहा जाता है जब आप obj पहले के साथ समाप्त हो जाते हैं Py_DECREF(obj) । इसे कई बार या NULL इनपुट के साथ कहा जा सकता है ।

रिटर्न 0 अगर कुछ नहीं किया गया था, -1 त्रुटि पर, और 1 अगर कार्रवाई की गई थी।

थ्रेडिंग सपोर्ट

यदि NPY_ALLOW_THREADS एक्सटेंशन मॉड्यूल के संकलन के दौरान True का मूल्यांकन किया जाता है तो ये मैक्रो केवल सार्थक हैं । अन्यथा, ये मैक्रोज़ व्हॉट्सएप के बराबर हैं। पायथन प्रत्येक पायथन प्रक्रिया के लिए एक एकल ग्लोबल इंटरप्रेटर लॉक (GIL) का उपयोग करता है ताकि एक समय में केवल एक ही धागा निष्पादित हो सके (यहां तक ​​कि मल्टी-सीपीयू मशीनों पर भी)। जब एक संकलित फ़ंक्शन को कॉल किया जाता है, जो गणना करने में समय ले सकता है (और अपडेट किए गए वैश्विक चर जैसे अन्य थ्रेड के लिए साइड-इफेक्ट नहीं है), तो जीआईएल को जारी किया जाना चाहिए ताकि अन्य पायथन थ्रेड चल सकें, जबकि समय लेने वाली गणना की जाती है । यह मैक्रोज़ के दो समूहों का उपयोग करके पूरा किया जा सकता है। आमतौर पर, यदि किसी समूह में एक मैक्रो का उपयोग कोड ब्लॉक में किया जाता है, तो उन सभी को एक ही कोड ब्लॉक में उपयोग किया जाना चाहिए। वर्तमान में, NPY_ALLOW_THREADS अजगर को परिभाषित किया गया है WITH_THREADS स्थिरांक जब तक पर्यावरण चर NPY_NOSMP सेट नहीं किया जाता है जिस स्थिति NPY_ALLOW_THREADS में 0 को परिभाषित किया जाता है।

समूह 1

इस समूह का उपयोग कॉल कोड के लिए किया जाता है, जिसमें कुछ समय लग सकता है, लेकिन कोई पायथन सी-एपीआई कॉल का उपयोग नहीं करता है। इस प्रकार, जीआईएल को अपनी गणना के दौरान जारी किया जाना चाहिए।

NPY_BEGIN_ALLOW_THREADS

के बराबर Py_BEGIN_ALLOW_THREADS इसे इस्तेमाल करता है सिवाय NPY_ALLOW_THREADS निर्धारित करने के लिए करता है, तो सफेद-अंतरिक्ष या नहीं के साथ बदल दिया मैक्रो।

NPY_END_ALLOW_THREADS

के बराबर Py_END_ALLOW_THREADS इसे इस्तेमाल करता है सिवाय NPY_ALLOW_THREADS निर्धारित करने के लिए करता है, तो सफेद-अंतरिक्ष या नहीं के साथ बदल दिया मैक्रो।

NPY_BEGIN_THREADS_DEF

चर घोषणा क्षेत्र में रखें। यह मैक्रो पायथन राज्य के भंडारण के लिए आवश्यक चर सेट करता है।

NPY_BEGIN_THREADS

कोड से ठीक पहले रखें जिसे पायथन इंटरप्रिटर (कोई पायथन सी-एपीआई कॉल नहीं) की आवश्यकता नहीं है। यह मैक्रो पाइथन राज्य को बचाता है और जीआईएल को मुक्त करता है।

NPY_END_THREADS

कोड के ठीक बाद रखें जिसे पायथन इंटरप्रेटर की आवश्यकता नहीं है। यह मैक्रो जीआईएल का अधिग्रहण करता है और बचाया चर से पायथन राज्य को पुनर्स्थापित करता है।

NPY_BEGIN_THREADS_DESCR(PyArray_Descr *dtype)

केवल GIL को जारी करने के लिए उपयोगी है यदि dtype में मनमानी पायथन ऑब्जेक्ट्स नहीं हैं, जो लूप के निष्पादन के दौरान Python दुभाषिया की आवश्यकता हो सकती है। के बराबर

NPY_END_THREADS_DESCR(PyArray_Descr *dtype)

इस मैक्रो के BEGIN फॉर्म का उपयोग करके उन स्थितियों में जीआईएल को फिर से हासिल करने के लिए उपयोगी।

NPY_BEGIN_THREADS_THRESHOLDED(int loop_size)

GIL को जारी करने के लिए उपयोगी है यदि loop_size एक न्यूनतम सीमा से अधिक है, वर्तमान में 500 पर सेट है NPY_END_THREADS । GIL को वापस पाने के लिए मिलान के साथ मिलान किया जाना चाहिए ।

समूह 2

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

NPY_ALLOW_C_API_DEF

आवश्यक चर सेट करने के लिए चर घोषणा क्षेत्र में रखें।

NPY_ALLOW_C_API

कोड से पहले रखें जिसे पायथन सी-एपीआई को कॉल करने की आवश्यकता है (जब यह ज्ञात हो कि जीआईएल पहले ही जारी हो चुका है)।

NPY_DISABLE_C_API

कोड के बाद रखें जिसे पायथन सी-एपीआई को कॉल करना होगा (जीआईएल को फिर से जारी करने के लिए)।

प्राथमिकता

NPY_PRIORITY

सरणियों के लिए डिफ़ॉल्ट प्राथमिकता।

NPY_SUBTYPE_PRIORITY

डिफ़ॉल्ट उप-प्रकार प्राथमिकता।

NPY_SCALAR_PRIORITY

डिफ़ॉल्ट स्केलर प्राथमिकता (बहुत छोटी)

double PyArray_GetPriority(PyObject* obj, double def)

यदि नाम का कोई गुण मौजूद नहीं है, तो obj या def की __array_priority__ विशेषता (एक डबल में परिवर्तित) लौटें । फास्ट लुकअप जो कि टाइप के ऑब्जेक्ट के लिए विशेषता लुकअप से बचते हैं, प्रदान किए जाते हैं । PyArray_Type

डिफ़ॉल्ट बफ़र्स

NPY_BUFSIZE

उपयोगकर्ता-सेटल करने योग्य आंतरिक बफ़र्स का डिफ़ॉल्ट आकार।

NPY_MIN_BUFSIZE

उपयोगकर्ता के सबसे छोटे आकार के आंतरिक बफ़र्स।

NPY_MAX_BUFSIZE

सबसे बड़े आकार के उपयोगकर्ता के लिए अनुमति दी बफ़र्स।

अन्य स्थिरांक

NPY_NUM_FLOATTYPE

फ्लोटिंग-पॉइंट प्रकारों की संख्या

NPY_MAXDIMS

सरणियों में अधिकतम आयामों की अनुमति है।

NPY_VERSION

Ndarray ऑब्जेक्ट का मौजूदा संस्करण (यह देखने के लिए जांचें कि क्या यह चर संख्यात्मक / arrayobject.h हेडर का उपयोग करने की गारंटी देने के लिए परिभाषित किया गया है)।

NPY_FALSE

बूल के साथ उपयोग के लिए 0 के रूप में परिभाषित।

NPY_TRUE

बूल के साथ उपयोग के लिए 1 के रूप में परिभाषित।

NPY_FAIL

विफल कनवर्टर फ़ंक्शंस का रिटर्न मान जिसे "ओ एंड" सिंटैक्स-इन PyArg_ParseTuple -फ़ंक्शंस का उपयोग करके कहा जाता है।

NPY_SUCCEED

सफल कनवर्टर फ़ंक्शंस का रिटर्न मान जिसे "O &" सिंटैक्स-इन PyArg_ParseTuple -फ़ंक्शंस का उपयोग करके कहा जाता है।

विविध मैक्रों

PyArray_SAMESHAPE(a1, a2)

सही के रूप में मूल्यांकन अगर a1 और a2 एक ही आकार है।

PyArray_MAX(a, b)

अधिकतम a और b लौटाता है । यदि ( ए ) या ( बी ) वे भाव हैं जिनका दो बार मूल्यांकन किया जाता है।

PyArray_MIN(a, b)

की न्यूनतम रिटर्न एक और ख । यदि ( ए ) या ( बी ) वे भाव हैं जिनका दो बार मूल्यांकन किया जाता है।

PyArray_CLT(a, b)

PyArray_CGT(a, b)

PyArray_CLE(a, b)

PyArray_CGE(a, b)

PyArray_CEQ(a, b)

PyArray_CNE(a, b)

NumPy के आदेश की परिभाषा का उपयोग करते हुए दो जटिल संख्याओं (एक वास्तविक और कल्पना सदस्य के साथ संरचनाएं) के बीच जटिल तुलनाओं को लागू किया जाता है जो कि समसामयिक है: वास्तविक भागों की तुलना पहले और फिर जटिल भागों की तुलना करना।

PyArray_REFCOUNT(PyObject* op)

किसी भी पायथन ऑब्जेक्ट की संदर्भ संख्या लौटाता है।

PyArray_DiscardWritebackIfCopy(PyObject* obj)

NPY_ARRAY_WRITEBACKIFCOPY और हटाए गए NPY_ARRAY_UPDATEIFCOPY ध्वज को रीसेट करें । NPY_ARRAY_WRITEABLE आधार ऑब्जेक्ट पर ध्वज को रीसेट करता है । यह आधार वस्तु के लिए लंबित परिवर्तनों को भी बताता है। जब राइटबैक शब्दार्थ का उपयोग किया जाता है तो यह एक त्रुटि स्थिति से उबरने के लिए उपयोगी है।

PyArray_XDECREF_ERR(PyObject* obj)

1.14 में पदावनत, PyArray_DiscardWritebackIfCopy इसके बाद उपयोग करें Py_XDECREF

DECREF की एक सरणी वस्तु जिसमें मूल सरणी में वापस कॉपी की जाने वाली सामग्री के बिना (पदावनत) NPY_ARRAY_UPDATEIFCOPY या NPY_ARRAY_WRITEBACKIFCOPY ध्वज सेट हो सकता है। NPY_ARRAY_WRITEABLE आधार ऑब्जेक्ट पर ध्वज को रीसेट करता है । यह एक त्रुटि स्थिति से उबरने के लिए उपयोगी है जब राइटबैक शब्दार्थ का उपयोग किया जाता है, लेकिन गलत परिणाम देगा।

प्रगणित प्रकार

NPY_SORTKIND

एक विशेष चर-प्रकार है जो मूल्यों पर ले जा सकते हैं NPY_{KIND} , जहां {KIND} है

QUICKSORT , HEAPSORT , MERGESORT

NPY_NSORTS

की संख्या के रूप में परिभाषित किया गया।

NPY_SCALARKIND

एक विशेष चर प्रकार जो स्केलर-ज़बरदस्ती नियमों को निर्धारित करने में प्रतिष्ठित स्केलर्स की "प्रकार" की संख्या को दर्शाता है। यह चर उन मानों को ले सकता है NPY_{KIND} जहां {KIND} हो सकते हैं

NOSCALAR , BOOL_SCALAR , INTPOS_SCALAR , INTNEG_SCALAR , FLOAT_SCALAR , COMPLEX_SCALAR , OBJECT_SCALAR

NPY_NSCALARKINDS

अदिश प्रकारों की संख्या को परिभाषित करना (शामिल नहीं NPY_NOSCALAR )।

NPY_ORDER

तत्व क्रम को इंगित करने वाला एक गणन प्रकार जिसे किसी सरणी में व्याख्या किया जाना चाहिए। जब ​​एक नया सरणी बनाया जाता है, तो आमतौर पर केवल NPY_CORDER और NPY_FORTRANORDER का उपयोग किया जाता है, जबकि जब एक या अधिक इनपुट प्रदान किए जाते हैं, तो क्रम उनके आधार पर हो सकता है।

NPY_ANYORDER

फोरट्रान आदेश यदि सभी इनपुट फोर्ट्रान, सी अन्यथा हैं।

NPY_CORDER

C आदेश।

NPY_FORTRANORDER

फोरट्रान आदेश।

NPY_KEEPORDER

जितना संभव हो उतना इनपुट के आदेश के करीब एक ऑर्डर, भले ही इनपुट न तो सी और न ही फोरट्रान ऑर्डर में हो।

NPY_CLIPMODE

एक प्रकार का चर, जो उस प्रकार की कतरन को दर्शाता है जिसे कुछ कार्यों में लागू किया जाना चाहिए।

NPY_RAISE

अधिकांश परिचालनों के लिए डिफ़ॉल्ट, यदि कोई सूचकांक सीमा से बाहर है, तो अपवाद को उठाता है।

NPY_CLIP

यदि यह सीमा से बाहर है, तो एक इंडेक्स को मान्य सीमा में सूचीबद्ध करता है।

NPY_WRAP

यदि यह सीमा से बाहर है, तो एक सूचकांक को वैध सीमा तक लपेटता है।

NPY_CASTING

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

एक गणना प्रकार यह दर्शाता है कि डेटा रूपांतरण कैसे होने चाहिए। यह NumPy 1.6 में जोड़े गए इट्रेटर द्वारा उपयोग किया जाता है, और इसे भविष्य के संस्करण में अधिक व्यापक रूप से उपयोग करने का इरादा है।

NPY_NO_CASTING

केवल समान प्रकारों की अनुमति दें।

NPY_EQUIV_CASTING

बाइट स्वैपिंग से जुड़े समान और कास्ट की अनुमति दें।

NPY_SAFE_CASTING

केवल उन जातियों को अनुमति दें, जो मूल्यों को गोल, छंटनी या अन्यथा परिवर्तित नहीं होने देंगी।

NPY_SAME_KIND_CASTING

किसी भी सुरक्षित कास्ट की अनुमति दें, और उसी प्रकार के बीच कास्ट करें। उदाहरण के लिए, इस नियम के साथ float64 -> float32 की अनुमति है।

NPY_UNSAFE_CASTING

किसी भी जाति को अनुमति दें, इससे कोई फर्क नहीं पड़ता कि किस प्रकार का डेटा हानि हो सकती है।