NumPy 1.14 - int PyArray_NDIM()
एरे एपीआई

एरे एपीआई
सरणी संरचना और डेटा एक्सेस
ये मैक्रोज़ सभी
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 के साथ डेटा-टाइप डिस्क्रिप्टर निर्दिष्ट करें, जहाँ टाइप_नम एक बिलिन (या उपयोगकर्ता-परिभाषित) प्रकार से मेल खाती है। यदि प्रकार में हमेशा बाइट्स की समान संख्या होती है, तो आइटमाइज़ को अनदेखा किया जाता है। अन्यथा, आइटम इस सरणी के विशेष आकार को निर्दिष्ट करता है।
चेतावनी
यदि डेटा
PyArray_NewFromDescr
या
PyArray_New
को पास कर दिया जाता है, तो इस मेमोरी को तब तक नहीं हटाया जाना चाहिए, जब तक कि नया एरे डिलीट न हो जाए।
यदि यह डेटा किसी अन्य पायथन ऑब्जेक्ट से आया है, तो यह उस ऑब्जेक्ट पर
Py_INCREF
का उपयोग करके और उस ऑब्जेक्ट को इंगित करने के लिए नए सरणी के आधार सदस्य को सेट करके पूरा किया जा सकता है।
यदि स्ट्राइड्स पास हो जाते हैं, तो उन्हें आयाम, आइटम्स और सरणी के डेटा के अनुरूप होना चाहिए।
-
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_CARRAY
-
NPY_ARRAY_CARRAY_RO
-
NPY_ARRAY_FARRAY
-
NPY_ARRAY_FARRAY_RO
-
NPY_ARRAY_DEFAULT
-
NPY_ARRAY_IN_ARRAY
-
NPY_ARRAY_IN_FARRAY
-
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
-
डेटा क्षेत्र फ़ोर्ट्रान-शैली सन्निहित क्रम में है (पहला सूचकांक सबसे तेज़ बदलता है)।
ध्यान दें
Arrays सी-शैली और फोरट्रान-शैली दोनों एक साथ सन्निहित हो सकती है। यह 1-आयामी सरणियों के लिए स्पष्ट है, लेकिन उच्च आयामी सरणियों के लिए भी सच हो सकता है।
यहां तक कि सन्निहित सरणियों के लिए एक दिए गए आयाम के लिए एक स्ट्राइड
मनमाना
arr.strides[dim]
हो सकता
है
यदि
arr.shape[dim] == 1
या सरणी में कोई तत्व नहीं है
यह आमतौर पर यह
नहीं
रखता है कि
self.strides[-1] == self.itemsize
सी-शैली सन्निहित सरणियों के लिए
self.strides[0] == self.itemsize
।
itemsize
C API से किसी सरणी तक
पहुंचने का सही तरीका
है
PyArray_ITEMSIZE(arr)
।
यह भी देखें
-
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_CARRAY
-
NPY_ARRAY_CARRAY_RO
-
NPY_ARRAY_FARRAY
-
NPY_ARRAY_FARRAY_RO
-
NPY_ARRAY_DEFAULT
-
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 आवश्यक गणना प्रदर्शन से।
चेतावनी
PyArray_UpdateFlags
जब भी किसी सरणी के साथ छेड़छाड़ की जाती है
तो झंडे को अपडेट किया जाना (उपयोग करना
) मदद कर सकता है जो उन्हें बदलने का कारण बन सकता है।
NumPy में बाद की गणना जो इन झंडों की स्थिति पर निर्भर करती है, उन्हें अद्यतन करने के लिए गणना को नहीं दोहराती है।
ऐरे विधि वैकल्पिक एपीआई
रूपांतरण
-
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 के सभी आयामों के साथ स्वयं का एक नया दृश्य लौटाएं ।
चेतावनी
मैट्रिक्स ऑब्जेक्ट हमेशा 2-आयामी होते हैं।
इसलिए,
PyArray_Squeeze
मैट्रिक्स उप-वर्ग के सरणियों पर कोई प्रभाव नहीं पड़ता है।
-
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
। यदि एक टपल लौटाया जाता है (nd1), तो इसकी लंबाई nd है।
-
PyObject* PyArray_Compress(PyArrayObject* self, PyObject* condition, int axis, PyArrayObject* out)
-
ndarray.compress
( स्व , स्थिति , अक्ष ) के समतुल्य । सही होने वाली स्थिति के तत्वों के अनुरूप धुरी वाले तत्वों को लौटाएं ।
हिसाब
टिप
NPY_MAXDIMS
अक्ष में
पास होने के
लिए उसी प्रभाव को प्राप्त करने के लिए जिसे अक्ष में
पास
करके प्राप्त किया जाता
है
=
None
पायथन में (1-डी सरणी के रूप में सरणी का इलाज)।
-
PyObject* PyArray_ArgMax(PyArrayObject* self, int axis, PyArrayObject* out)
-
ndarray.argmax
( स्व , अक्ष ) के समतुल्य । अक्ष के साथ स्वयं के सबसे बड़े तत्व का सूचकांक लौटाएं ।
-
PyObject* PyArray_ArgMin(PyArrayObject* self, int axis, PyArrayObject* out)
-
ndarray.argmin
( स्व , अक्ष ) के समतुल्य । धुरी के साथ स्वयं के सबसे छोटे तत्व का सूचकांक लौटाएं ।
ध्यान दें
आउट तर्क निर्दिष्ट करता है कि परिणाम कहां रखा जाए।
यदि बाहर NULL है, तो आउटपुट ऐरे को बनाया जाता है, अन्यथा आउटपुट को बाहर रखा जाता है जो सही आकार और प्रकार होना चाहिए।
आउटपुट सरणी का एक नया संदर्भ हमेशा तब भी लौटाया जाता है जब बाहर NULL नहीं होता है।
रुटीन के कॉल करने वाले की जिम्मेदारी है
DECREF
कि यदि NULL या मेमोरी-लीक नहीं होगा।
-
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 के बजाय एक संख्यात्मक स्केलर लौटाता है।
ध्यान दें
Rtype तर्क निर्दिष्ट करता है कि डेटा-प्रकार में कमी खत्म होनी चाहिए।
यह महत्वपूर्ण है अगर आउटपुट को संभालने के लिए सरणी का डेटा-प्रकार "बड़ा" नहीं है।
डिफ़ॉल्ट रूप से, सभी पूर्णांक डेटा-प्रकार कम से कम
NPY_LONG
"ऐड" और "गुणा" ufuncs के लिए
बड़े होते हैं
(जो कि माध्य, सम, कमसुम, ठेस और cumprod कार्यों के लिए आधार बनाते हैं)।
-
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 होना चाहिए।
ध्यान दें
2-डी और 3-डी सरणियों के लिए सी-स्टाइल सरणी का अनुकरण पूरा नहीं हुआ है। उदाहरण के लिए, बिंदुओं के सिम्युलेटेड सरणियों को विशिष्ट, सांख्यिकीय रूप से परिभाषित 2-डी और 3-डी सरणियों की अपेक्षा करने वाले सबरूटीन्स को पारित नहीं किया जा सकता है। उन प्रकार के इनपुट की आवश्यकता वाले कार्यों को पास करने के लिए, आपको आवश्यक रूप से आवश्यक सरणी को परिभाषित करना चाहिए और डेटा को कॉपी करना होगा।
-
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 वापस करें।
ऑब्जेक्ट शब्दार्थ के साथ सहायक डेटा
संस्करण 1.7.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-डी संस्करण आमतौर पर गति के लिए अनुकूलित है और इस कारण से लूप को उस धुरी पर किया जाना चाहिए जिसके लिए बड़े स्ट्राइड जंप की आवश्यकता नहीं होगी।
पड़ोस का इटरेटर
संस्करण 1.4.0 में नया।
नेबरहुड पुनरावृत्तियों को इटर्चर ऑब्जेक्ट के उप-वर्ग होते हैं, और इसका उपयोग एक बिंदु के पड़ोस में किया जा सकता है। उदाहरण के लिए, आप एक 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
। नियम यह है कि एक ही प्रकार के स्केल को एक ही प्रकार के सरणियों में ले जाया जा सकता है। इस नियम का मतलब है कि उच्च परिशुद्धता वाले स्केल कभी भी एक ही प्रकार के कम-सटीक सरणियों का कारण नहीं बनेंगे।
डेटा-प्रकार के वर्णनकर्ता
चेतावनी
डेटा-प्रकार की वस्तुओं को संदर्भित होना चाहिए ताकि विभिन्न सी-एपीआई कॉल के डेटा-प्रकार के संदर्भ पर कार्रवाई के बारे में पता हो। मानक नियम यह है कि जब डेटा प्रकार की वस्तु वापस की जाती है तो यह एक नया संदर्भ होता है। PyArray_Descr ऑब्जेक्ट्स और रिटर्न ऐरे ले जाने वाले फ़ंक्शंस डेटा के संदर्भों को चोरी करते हैं, जब तक कि अन्यथा नोट न किया गया हो। इसलिए, आपको ऐसे फ़ंक्शन के इनपुट के रूप में उपयोग की जाने वाली किसी भी डेटा-टाइप ऑब्जेक्ट का संदर्भ होना चाहिए।
-
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 है, उसे डिफॉल्ट करता है।
-
यदि न तो परिभाषित किया गया है, तो C-API को घोषित किया गया है
एपीआई संस्करण की जाँच करना
क्योंकि अधिकांश प्लेटफार्मों पर सामान्य पुस्तकालयों की तरह अजगर एक्सटेंशन का उपयोग नहीं किया जाता है, कुछ त्रुटियों का निर्माण समय या यहां तक कि रनटाइम पर स्वचालित रूप से नहीं किया जा सकता है।
उदाहरण के लिए, यदि आप केवल 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
-
एक विशेष चर-प्रकार है जो मूल्यों पर ले जा सकते हैं
QUICKSORT , HEAPSORT , MERGESORTNPY_{KIND}
, जहां{KIND}
है-
NPY_NSORTS
-
की संख्या के रूप में परिभाषित किया गया।
-
-
NPY_SCALARKIND
-
एक विशेष चर प्रकार जो स्केलर-ज़बरदस्ती नियमों को निर्धारित करने में प्रतिष्ठित स्केलर्स की "प्रकार" की संख्या को दर्शाता है। यह चर उन मानों को ले सकता है
NOSCALAR , BOOL_SCALAR , INTPOS_SCALAR , INTNEG_SCALAR , FLOAT_SCALAR , COMPLEX_SCALAR , OBJECT_SCALARNPY_{KIND}
जहां{KIND}
हो सकते हैं-
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
-
किसी भी जाति को अनुमति दें, इससे कोई फर्क नहीं पड़ता कि किस प्रकार का डेटा हानि हो सकती है।
-
