NumPy 1.14 - PyArray_Type

पायथन प्रकार और सी-संरचनाएं




numpy

पायथन प्रकार और सी-संरचनाएं

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

नए पायथन प्रकार परिभाषित

पायथन प्रकार सी कक्षाओं में C के कक्षाओं में कार्यात्मक समतुल्य हैं। एक नए पायथन प्रकार का निर्माण करके आप पायथन के लिए एक नई वस्तु उपलब्ध करते हैं। Ndarray ऑब्जेक्ट सी में परिभाषित नए प्रकार का एक उदाहरण है। नए प्रकार सी में दो बुनियादी चरणों द्वारा परिभाषित किए गए हैं:

  1. एक सी-संरचना बनाना (आमतौर पर Py{Name}Object ) Py{Name}Object दिया गया है जो कि बाइनरी है- जो PyObject संरचना के साथ ही संगत है लेकिन उस विशेष वस्तु के लिए आवश्यक अतिरिक्त जानकारी रखता है;
  2. प्रकार के लिए वांछित व्यवहार को लागू करने वाले फ़ंक्शन के लिए PyTypeObject तालिका ( PyObject संरचना के ob_type सदस्य द्वारा इंगित) को PyObject

विशेष विधि के नामों के बजाय जो पायथन कक्षाओं के लिए व्यवहार को परिभाषित करते हैं, "फ़ंक्शन टेबल" हैं जो उन कार्यों को इंगित करते हैं जो वांछित परिणाम लागू करते हैं। पायथन 2.2 के बाद से, PyTypeObject स्वयं गतिशील हो गया है जो C प्रकारों को C के अन्य C- प्रकारों से "उप-टाइप" किया जा सकता है और पायथन में उप-वर्गीकृत किया जा सकता है। बच्चे अपने माता-पिता से विशेषताओं और विधियों को प्राप्त करते हैं।

दो प्रमुख नए प्रकार हैं: PyArray_Type ( PyArray_Type ) और ufunc ( PyUFunc_Type )। अतिरिक्त प्रकार एक सहायक भूमिका निभाते हैं: PyArrayIter_Type , PyArrayMultiIter_Type और PyArrayDescr_Type PyArrayIter_Type एक PyArrayIter_Type लिए एक फ्लैट पुनरावर्तक के लिए प्रकार है (फ्लैट विशेषता प्राप्त करते समय दी गई वस्तु)। PyArrayMultiIter_Type broadcast () को कॉल करते समय दी गई ऑब्जेक्ट का प्रकार है। यह नेस्टेड दृश्यों के संग्रह पर पुनरावृति और प्रसारण को संभालता है। इसके अलावा, PyArrayDescr_Type डेटा-प्रकार-डिस्क्रिप्टर प्रकार है, जिसके उदाहरण डेटा का वर्णन करते हैं। अंत में, 21 नए स्केलर-एरे प्रकार हैं जो एरे के लिए उपलब्ध मूलभूत डेटा प्रकारों में से प्रत्येक के अनुरूप नए पायथन स्केलर हैं। एक अतिरिक्त 10 अन्य प्रकार स्थान धारक हैं जो सरणी स्केलरों को वास्तविक पायथन प्रकारों के पदानुक्रम में फिट होने की अनुमति देते हैं।

PyArray_Type

PyArray_Type

PyArray_Type का पायथन प्रकार PyArray_Type । C में, प्रत्येक PyArrayObject एक PyArrayObject संरचना का सूचक है। इस संरचना के ob_type सदस्य में PyArray_Type typeobject के लिए एक सूचक होता है।

PyArrayObject

PyArrayObject C- संरचना में किसी सरणी के लिए आवश्यक जानकारी शामिल है। एक ndarray के सभी उदाहरण (और इसके उपवर्ग) में यह संरचना होगी। भविष्य की संगतता के लिए, इन संरचना सदस्यों को आम तौर पर प्रदान किए गए मैक्रोज़ का उपयोग करके एक्सेस किया जाना चाहिए। यदि आपको एक छोटे नाम की आवश्यकता है, तो आप NPY_AO उपयोग कर सकते हैं जिसे NPY_AO बराबर परिभाषित किया गया है।

typedef struct PyArrayObject {
    PyObject_HEAD
    char *data;
    int nd;
    npy_intp *dimensions;
    npy_intp *strides;
    PyObject *base;
    PyArray_Descr *descr;
    int flags;
    PyObject *weakreflist;
} PyArrayObject;
char *PyArrayObject.data

सरणी के पहले तत्व के लिए एक सूचक। यह पॉइंटर (और सामान्य रूप से) सरणी के डेटा प्रकार के लिए फिर से तैयार किया जा सकता है।

int PyArrayObject.nd

इस सरणी के लिए आयामों की संख्या प्रदान करने वाला पूर्णांक। जब nd 0 होता है, तो सरणी को कभी-कभी रैंक-0 सरणी कहा जाता है। इस तरह के सरणियों में अपरिभाषित आयाम और तार होते हैं और इन्हें एक्सेस नहीं किया जा सकता है। NPY_MAXDIMS किसी भी सरणी के लिए सबसे बड़ी संख्या है।

npy_intp PyArrayObject.dimensions

एनडीआर के रूप में लंबे समय तक प्रत्येक आयाम में आकार प्रदान करने वाले पूर्णांक की एक सरणी \ geq 1. पूर्णांक हमेशा प्लेटफ़ॉर्म पर एक संकेतक रखने के लिए पर्याप्त बड़ा होता है, इसलिए आयाम का आकार केवल मेमोरी द्वारा सीमित होता है।

npy_intp *PyArrayObject.strides

प्रत्येक आयाम के लिए प्रदान करने वाले पूर्णांकों की एक सरणी उस आयाम में अगले तत्व को प्राप्त करने के लिए बाइट्स की संख्या को छोड़ देना चाहिए।

PyObject *PyArrayObject.base

इस सदस्य का उपयोग किसी अन्य पायथन ऑब्जेक्ट के लिए एक पॉइंटर रखने के लिए किया जाता है जो इस सरणी से संबंधित है। दो उपयोग के मामले हैं: 1) यदि इस सरणी की अपनी स्मृति नहीं है, तो पायथन ऑब्जेक्ट का आधार बिंदु जो इसका मालिक है (शायद दूसरी सरणी ऑब्जेक्ट), 2) यदि इस सरणी में (पदावनत) NPY_ARRAY_UPDATEIFCOPY या: c: है डेटा: NPY_ARRAY_WRITEBACKIFCOPY`: ध्वज सेट, फिर यह सरणी "दुर्व्यवहार" सरणी की एक कार्यशील प्रति है। जब PyArray_ResolveWritebackIfCopy कहा जाता है, तो आधार द्वारा इंगित की गई सरणी इस सरणी की सामग्री के साथ अपडेट की जाएगी।

PyArray_Descr *PyArrayObject.descr

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

int PyArrayObject.flags

यह दर्शाता है कि डेटा द्वारा बताई गई मेमोरी की व्याख्या कैसे की जाती है। संभावित झंडे NPY_ARRAY_C_CONTIGUOUS , NPY_ARRAY_F_CONTIGUOUS , NPY_ARRAY_OWNDATA , NPY_ARRAY_ALIGNED , NPY_ARRAY_WRITEABLE , NPY_ARRAY_WRITEBACKIFCOPY

PyObject *PyArrayObject.weakreflist

यह सदस्य सरणी वस्तुओं को कमजोर संदर्भ (कमजोर मॉड्यूल का उपयोग करके) की अनुमति देता है।

PyArrayDescr_Type

PyArrayDescr_Type

PyArrayDescr_Type बिल्ट-इन प्रकार का डेटा-टाइप-डिस्क्रिप्टर ऑब्जेक्ट है जिसका उपयोग यह वर्णन करने के लिए किया जाता है कि सरणी को शामिल करने वाले बाइट्स की व्याख्या कैसे की जाए। अंतर्निहित डेटा प्रकारों के लिए 21 सांख्यिकीय रूप से परिभाषित PyArray_Descr ऑब्जेक्ट हैं। जबकि ये संदर्भ गिनती में भाग लेते हैं, उनकी संदर्भ संख्या कभी शून्य तक नहीं पहुंचनी चाहिए। उपयोगकर्ता द्वारा परिभाषित PyArray_Descr वस्तुओं की एक गतिशील तालिका भी है जिसे बनाए रखा जाता है। डेटा-टाइप-डिस्क्रिप्टर ऑब्जेक्ट "पंजीकृत" होने के बाद, इसे कभी भी निपटाया नहीं जाना चाहिए। फ़ंक्शन PyArray_DescrFromType (…) का उपयोग किसी Enumerated प्रकार-संख्या (या तो अंतर्निहित या उपयोगकर्ता-निर्धारित) से PyArray_Descr ऑब्जेक्ट को प्राप्त करने के लिए किया जा सकता है।

PyArray_Descr

PyArray_Descr के दिल में स्थित PyArray_Descr संरचना का प्रारूप है

typedef struct {
    PyObject_HEAD
    PyTypeObject *typeobj;
    char kind;
    char type;
    char byteorder;
    char unused;
    int flags;
    int type_num;
    int elsize;
    int alignment;
    PyArray_ArrayDescr *subarray;
    PyObject *fields;
    PyArray_ArrFuncs *f;
} PyArray_Descr;
PyTypeObject *PyArray_Descr.typeobj

इस प्रकार के तत्वों के लिए एक टाइपोबाइट के लिए पॉइंटर, जो संबंधित पायथन प्रकार है। बिलिन प्रकारों के लिए, यह संबंधित सरणी स्केलर को इंगित करता है। उपयोगकर्ता-परिभाषित प्रकारों के लिए, यह उपयोगकर्ता-परिभाषित टाइपोबॉज़ को इंगित करना चाहिए। यह टाइपोबोक या तो सरणी स्केलर से इनहेरिट कर सकता है या नहीं। यदि यह सरणी NPY_USE_GETITEM से विरासत में नहीं मिलता है, तो NPY_USE_GETITEM और NPY_USE_SETITEM झंडे को सदस्य समूह में सेट किया जाना चाहिए।

char PyArray_Descr.kind

एक वर्ण कोड जो सरणी के प्रकार को दर्शाता है (सरणी इंटरफ़ेस टाइपस्ट्रिंग नोटेशन का उपयोग करके)। एक 'बी' बूलियन का प्रतिनिधित्व करता है, एक 'i' हस्ताक्षरित पूर्णांक का प्रतिनिधित्व करता है, एक 'u' अहस्ताक्षरित पूर्णांक का प्रतिनिधित्व करता है, 'f' फ्लोटिंग पॉइंट का प्रतिनिधित्व करता है, 'c' जटिल फ्लोटिंग पॉइंट का प्रतिनिधित्व करता है, 'S' 8-बिट शून्य-टर्मिनेटेड बाइट्स का प्रतिनिधित्व करता है, 'U' 32-बिट / वर्ण यूनिकोड स्ट्रिंग का प्रतिनिधित्व करता है, और 'V' मनमाना प्रतिनिधित्व करता है।

char PyArray_Descr.type

एक पारंपरिक वर्ण कोड जो डेटा प्रकार को दर्शाता है।

char PyArray_Descr.byteorder

बाइट-ऑर्डर को इंगित करने वाला एक चरित्र: '>' (बड़ा-एंडियन), '<' (छोटा- एंडियन), '=' (मूल), '| (अप्रासंगिक, उपेक्षा)। सभी अंतर्निहित डेटा-प्रकारों में बाइटऑर्डर '=' होता है।

int PyArray_Descr.flags

डेटा-प्रकार बिट-फ़्लैग जो निर्धारित करता है कि डेटा-प्रकार व्यवहार की तरह ऑब्जेक्ट-सरणी प्रदर्शित करता है। इस सदस्य में प्रत्येक बिट एक ध्वज है जिसे नाम दिया गया है:

NPY_ITEM_REFCOUNT
NPY_ITEM_HASOBJECT

इंगित करता है कि इस डेटा-प्रकार के आइटम को संदर्भित गणना ( Py_INCREF और Py_DECREF का उपयोग करके) किया जाना चाहिए।

NPY_LIST_PICKLE

इस डेटा-प्रकार के सरणियों को अचार बनाने से पहले एक सूची में परिवर्तित किया जाना चाहिए।

NPY_ITEM_IS_POINTER

आइटम किसी अन्य डेटा-प्रकार के लिए एक संकेतक है

NPY_NEEDS_INIT

इस डेटा-प्रकार के लिए मेमोरी को इनिशियलाइज़ किया जाना चाहिए (सेट पर 0)।

NPY_NEEDS_PYAPI

इस डेटा-प्रकार को इंगित करता है कि एक्सेस के दौरान पायथन सी-एपीआई की आवश्यकता होती है (ताकि सरणी पहुँच की आवश्यकता होने पर GIL को न छोड़ें)।

NPY_USE_GETITEM

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

NPY_USE_SETITEM

सरणी स्केलर से 0-d सरणी बनाते समय, सरणी स्केलर से मानक प्रतिलिपि के बजाय f->setitem उपयोग करें। यदि आप डेटा प्रकार के साथ जाने के लिए किसी सरणी स्केलर को परिभाषित नहीं करते हैं तो इसका उपयोग करना चाहिए।

NPY_FROM_FIELDS

यदि ये बिट्स डेटा-प्रकार के किसी भी क्षेत्र में सेट किए गए हैं, तो बिट्स को मूल डेटा-प्रकार के लिए विरासत में मिला है। वर्तमान में ( NPY_NEEDS_INIT | NPY_LIST_PICKLE | NPY_ITEM_REFCOUNT | NPY_NEEDS_PYAPI )

NPY_OBJECT_DTYPE_FLAGS

ऑब्जेक्ट डेटा-प्रकार के लिए सेट बिट्स: ( NPY_LIST_PICKLE | NPY_USE_GETITEM | NPY_ITEM_IS_POINTER | NPY_REFCOUNT | NPY_NEEDS_INIT NPY_NEEDS_PYAPI )।

PyDataType_FLAGCHK(PyArray_Descr *dtype, int flags)

यदि दिए गए सभी झंडे डेटा-प्रकार ऑब्जेक्ट के लिए सेट किए गए हैं, तो सही लौटें।

PyDataType_REFCHK(PyArray_Descr *dtype)

PyDataType_FLAGCHK ( dtype , NPY_ITEM_REFCOUNT ) के बराबर।

int PyArray_Descr.type_num

एक संख्या जो विशिष्ट रूप से डेटा प्रकार की पहचान करती है। नए डेटा-प्रकारों के लिए, यह संख्या तब असाइन की जाती है जब डेटा-प्रकार पंजीकृत होता है।

int PyArray_Descr.elsize

डेटा प्रकारों के लिए जो हमेशा समान आकार (जैसे लंबे) होते हैं, यह डेटा प्रकार का आकार रखता है। लचीले डेटा प्रकारों के लिए जहां विभिन्न सरणियों में एक अलग तत्व हो सकता है, यह 0 होना चाहिए।

int PyArray_Descr.alignment

इस डेटा प्रकार के लिए संरेखण जानकारी प्रदान करने वाली एक संख्या। विशेष रूप से, यह दिखाता है कि 2-तत्व संरचना (जिसका पहला तत्व एक offsetof(struct {char c; type v;}, v) ) की शुरुआत से कितनी दूर है, संकलक इस प्रकार के एक आइटम को offsetof(struct {char c; type v;}, v) : offsetof(struct {char c; type v;}, v)

PyArray_ArrayDescr *PyArray_Descr.subarray

यदि यह गैर- NULL , तो यह डेटा-टाइप डिस्क्रिप्टर किसी अन्य डेटा-टाइप डिस्क्रिप्टर का C-style contiguous array है। दूसरे शब्दों में, प्रत्येक तत्व जो इस डिस्क्रिप्टर का वर्णन करता है, वह वास्तव में कुछ अन्य बेस डिस्क्रिप्टर का एक सरणी है। यह किसी अन्य डेटा-प्रकार के डिस्क्रिप्टर में फ़ील्ड के लिए डेटा-टाइप डिस्क्रिप्टर के रूप में सबसे अधिक उपयोगी है। फ़ील्ड सदस्य NULL होना चाहिए यदि यह गैर- NULL (आधार डिस्क्रिप्टर के फ़ील्ड सदस्य गैर- NULL हालांकि हो सकते हैं)। PyArray_ArrayDescr संरचना का उपयोग करके परिभाषित किया गया है

typedef struct {
    PyArray_Descr *base;
    PyObject *shape;
} PyArray_ArrayDescr;

इस संरचना के तत्व हैं:

PyArray_Descr *PyArray_ArrayDescr.base

आधार-प्रकार का डेटा-टाइप-डिस्क्रिप्टर ऑब्जेक्ट।

PyObject *PyArray_ArrayDescr.shape

पायथन टुप के रूप में उप-सरणी का आकार (हमेशा सी-शैली सन्निहित)।

PyObject *PyArray_Descr.fields

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

PyArray_ArrFuncs *PyArray_Descr.f

संरचना वाले फ़ंक्शन के लिए एक सूचक जो आंतरिक विशेषताओं को लागू करने के लिए प्रकार की आवश्यकता होती है। ये फ़ंक्शन बाद में वर्णित सार्वभौमिक फ़ंक्शन (ufuncs) के समान नहीं हैं। उनके हस्ताक्षर मनमाने ढंग से भिन्न हो सकते हैं।

PyArray_ArrFuncs

आंतरिक सुविधाओं को लागू करने वाले कार्य। इन सभी फ़ंक्शन पॉइंटर्स को किसी दिए गए प्रकार के लिए परिभाषित नहीं किया जाना चाहिए। आवश्यक सदस्य copyswap , copyswapn , setitem , getitem , getitem और cast । इन्हें गैर-पूर्ण माना जाता NULL और NULL प्रविष्टियों के कारण प्रोग्राम क्रैश हो जाएगा। अन्य कार्य NULL हो सकते हैं जिसका अर्थ केवल उस डेटा-प्रकार के लिए कम की गई कार्यक्षमता होगी। (इसके अलावा, नॉनज़रो फ़ंक्शन डिफ़ॉल्ट फ़ंक्शन के साथ भरा होगा यदि यह उपयोगकर्ता-निर्धारित डेटा-प्रकार को पंजीकृत करते समय NULL )।

typedef struct {
    PyArray_VectorUnaryFunc *cast[NPY_NTYPES];
    PyArray_GetItemFunc *getitem;
    PyArray_SetItemFunc *setitem;
    PyArray_CopySwapNFunc *copyswapn;
    PyArray_CopySwapFunc *copyswap;
    PyArray_CompareFunc *compare;
    PyArray_ArgFunc *argmax;
    PyArray_DotFunc *dotfunc;
    PyArray_ScanFunc *scanfunc;
    PyArray_FromStrFunc *fromstr;
    PyArray_NonzeroFunc *nonzero;
    PyArray_FillFunc *fill;
    PyArray_FillWithScalarFunc *fillwithscalar;
    PyArray_SortFunc *sort[NPY_NSORTS];
    PyArray_ArgSortFunc *argsort[NPY_NSORTS];
    PyObject *castdict;
    PyArray_ScalarKindFunc *scalarkind;
    int **cancastscalarkindto;
    int *cancastto;
    PyArray_FastClipFunc *fastclip;
    PyArray_FastPutmaskFunc *fastputmask;
    PyArray_FastTakeFunc *fasttake;
    PyArray_ArgFunc *argmin;
} PyArray_ArrFuncs;

एक व्यवहार खंड की अवधारणा का उपयोग फ़ंक्शन पॉइंटर्स के विवरण में किया जाता है। एक व्यवहार खंड एक है जो संरेखित है और डेटा-प्रकार के लिए देशी मशीन बाइट-ऑर्डर में है। copyswap , copyswap , copyswapn , getitem और setitem फ़ंक्शंस गलत व्यवहार वाले सरणियों से निपट सकते हैं (और चाहिए)। अन्य कार्यों में व्यवहारिक मेमोरी सेगमेंट की आवश्यकता होती है।

void cast(void *from, void *to, npy_intp n, void *fromarr, void *toarr)

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

PyObject *getitem(void *data, void *arr)

किसी फ़ंक्शन के लिए एक संकेतक जो डेटा द्वारा इंगित सरणी ऑब्जेक्ट अरेस्ट के एकल तत्व से एक मानक पायथन ऑब्जेक्ट लौटाता है। यह फ़ंक्शन सही तरीके से "दुर्व्यवहार" (गुमराह और / या अदला-बदली) सरणियों से निपटने में सक्षम होना चाहिए।

int setitem(PyObject *item, void *data, void *arr)

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

void copyswapn(void *dest, npy_intp dstride, void *src, npy_intp sstride, npy_intp n, int swap, void *arr)
void copyswap(void *dest, void *src, int swap, void *arr)

ये सदस्य संकेत देने के लिए src से डेटा को कॉपी और स्वैप करने के लिए कार्य करने के लिए दोनों संकेत हैं। NPY_STRING का मूल्य केवल लचीले ( NPY_STRING , NPY_UNICODE , और NPY_VOID ) सरणियों के लिए उपयोग किया जाता है (और arr->descr->elsize से प्राप्त होता है)। दूसरा फ़ंक्शन एक एकल मान की प्रतिलिपि बनाता है, जबकि पहले दिए गए स्ट्रिप्स के साथ n मानों पर लूप करता है। ये कार्य गलत src डेटा से निपट सकते हैं। यदि src NULL है तो कोई कॉपी नहीं की जाती है। यदि स्वैप 0 है, तो कोई बाइट्सवापिंग नहीं होती है। यह माना जाता है कि भाग्य और src ओवरलैप नहीं है। यदि वे ओवरलैप करते हैं, तो memmove (…) का उपयोग करें और उसके बाद पहले से copyswap(n) src साथ copyswap(n)

int compare(const void* d1, const void* d2, void* arr)

किसी फ़ंक्शन के लिए एक पॉइंटर, जो सरणी के दो तत्वों की तुलना करता है, arr , d1 और d1 द्वारा इंगित किया गया। इस फ़ंक्शन को व्यवहार करने की आवश्यकता है (संरेखित और स्वैप नहीं) सरणियाँ। रिटर्न मान 1 है अगर * d1 > * d2 , 0 अगर * d1 == * d2 , और -1 अगर * d1 <* d2 । सरणी ऑब्जेक्ट अरैस्ट का उपयोग लचीली सरणियों के लिए आइटम्स और फ़ील्ड जानकारी प्राप्त करने के लिए किया जाता है।

int argmax(void* data, npy_intp n, npy_intp* max_ind, void* arr)

किसी फ़ंक्शन का एक संकेतक जो data द्वारा इंगित किए गए तत्व पर शुरुआत में n तत्वों में सबसे बड़े n तत्वों का सूचकांक प्राप्त करता है। इस फ़ंक्शन के लिए आवश्यक है कि मेमोरी सेगमेंट सन्निहित और व्यवहार किया जाए। वापसी मान हमेशा 0. होता है। सबसे बड़े तत्व का सूचकांक max_ind में max_ind

void dotfunc(void* ip1, npy_intp is1, void* ip2, npy_intp is2, void* op, npy_intp n, void* arr)

एक फ़ंक्शन के लिए एक पॉइंटर जो दो n -length अनुक्रमों को एक साथ गुणा करता है, उन्हें जोड़ता है, और परिणाम को गिरफ्तारी से इंगित तत्व में रखता है। दो क्रमों की शुरुआत ip1 और ip2 द्वारा ip1 ip2 । प्रत्येक अनुक्रम में अगले तत्व को प्राप्त करने के लिए क्रमशः is1 और is2 बाइट्स की एक कूद की आवश्यकता होती है। इस फ़ंक्शन के लिए व्यवहार की आवश्यकता होती है (हालांकि आवश्यक रूप से सन्निहित नहीं) स्मृति।

int scanfunc(FILE* fd, void* ip, void* sep, void* arr)

किसी फ़ंक्शन के लिए एक संकेतक जो स्कैन (स्कैनफ़ शैली) फ़ाइल डिस्क्रिप्टर fd से संबंधित प्रकार के एक तत्व को ip द्वारा इंगित सरणी मेमोरी में स्कैन करता है। सरणी को व्यवहार माना जाता है। यदि sep NULL नहीं है, तो लौटने से पहले फ़ाइल से एक विभाजक स्ट्रिंग भी स्कैन किया जाता है। अंतिम तर्क arr में स्कैन किए जाने वाला सरणी है। स्कैन सफल होने पर एक 0 लौटाया जाता है। एक नकारात्मक संख्या कुछ गलत होने का संकेत देती है: -1 का मतलब है कि विभाजक स्ट्रिंग को स्कैन करने से पहले फ़ाइल का अंत तक पहुंच गया था, -4 का अर्थ है कि तत्व के स्कैन होने से पहले फ़ाइल का अंत तक पहुंच गया था, और -3 का अर्थ है कि तत्व हो सकता है प्रारूप स्ट्रिंग से व्याख्या नहीं की जाएगी। एक व्यवहार किया सरणी की आवश्यकता है।

int fromstr(char* str, void* ip, char** endptr, void* arr)

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

Bool nonzero(void* data, void* arr)

किसी फ़ंक्शन का पॉइंटर जो TRUE लौटाता है यदि data द्वारा इंगित किया गया arr का आइटम नॉनज़रो है। यह फ़ंक्शन दुर्भावनापूर्ण सरणियों से निपट सकता है।

void fill(void* data, npy_intp length, void* arr)

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

void fillwithscalar(void* buffer, npy_intp length, void* value, void* arr)

एक फ़ंक्शन के लिए एक संकेतक जो किसी एकल स्केलर value साथ दिए गए length एक सन्निहित buffer को भरता है जिसका पता दिया गया है। अंतिम तर्क वह सरणी है जिसे चर-लंबाई सरणियों के लिए आइटम प्राप्त करने की आवश्यकता होती है।

int sort(void* start, npy_intp length, void* arr)

एक विशेष सॉर्टिंग एल्गोरिदम के लिए फ़ंक्शन पॉइंटर्स की एक सरणी। एक विशेष सॉर्टिंग एल्गोरिथ्म एक कुंजी (अब तक NPY_QUICKSORT , NPY_HEAPSORT , और NPY_MERGESORT परिभाषित हैं) का उपयोग करके प्राप्त किया जाता है। इन प्रकारों को सन्निहित और संरेखित आंकड़ों के आधार पर किया जाता है।

int argsort(void* start, npy_intp* result, npy_intp length, void *arr)

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

PyObject *castdict

उपयोगकर्ता-परिभाषित डेटा-प्रकारों के लिए या तो NULL या एक शब्दकोश जिसमें निम्न-स्तरीय कास्टिंग फ़ंक्शंस हैं। प्रत्येक फ़ंक्शन को PyCObject * में लपेटा जाता है और डेटा-प्रकार संख्या द्वारा PyCObject * किया जाता है।

NPY_SCALARKIND scalarkind(PyArrayObject* arr)

यह निर्धारित करने के लिए एक फ़ंक्शन कि इस प्रकार के स्केलर्स की व्याख्या कैसे की जानी चाहिए। तर्क NULL या 0-आयामी सरणी है जिसमें डेटा (यदि स्केलर के प्रकार को निर्धारित करने के लिए आवश्यक है)। वापसी मान NPY_SCALARKIND प्रकार का होना चाहिए।

int **cancastscalarkindto

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

int *cancastto

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

void fastclip(void *in, npy_intp n_in, void *min, void *max, void *out)

एक फ़ंक्शन जो n_in आइटम को in से पढ़ता in , और रीड वैल्यू को out लिखने के लिए लिखता है यदि यह min और max द्वारा n_in सीमा के भीतर है, या यदि बाहर है तो संबंधित सीमा। मेमोरी सेगमेंट संक्रामक और व्यवहारिक होना चाहिए, और या तो min या max NULL हो सकता NULL , लेकिन दोनों नहीं।

void fastputmask(void *in, void *mask, npy_intp n_in, void *values, npy_intp nv)

एक फ़ंक्शन जो सूचक को n_in आइटमों की एक सरणी in ले जाता है, n_in बूलियन मानों की एक सरणी के लिए एक पॉइंटर mask , और nv आइटमों की एक सरणी के लिए एक पॉइंटर n_in । जहां मूल्य nv < n_in शून्य nv < n_in हो in वहां वैल्यू से आइटम की नकल गैर-शून्य, टाइलिंग nv < n_in । सभी सरणियों को सन्निहित और व्यवहार किया जाना चाहिए।

void fasttake(void *dest, void *src, npy_intp *indarray, npy_intp nindarray, npy_intp n_outer, npy_intp m_middle, npy_intp nelem, NPY_CLIPMODE clipmode)

एक फ़ंक्शन जो एक सूचक को एक सी सन्निहित, व्यवहार वाले खंड में ले जाता है (n_outer, nindarray, nelem) आकृति के 3-आयामी सरणी (n_outer, nindarray, nelem) रूप में व्याख्या किया जाता है, एक सन्निहित के लिए सूचक सूचक, m_middle पूर्णांक सूचकांकों का सूचक खंड, और सूचक dest C सन्निहित, व्यवहार वाले खंड में, आकृति के 3-आयामी सरणी (n_outer, m_middle, nelem) रूप में व्याख्या की गई है। दूसरे आयाम के साथ सूचकांक में सूचकांक का उपयोग src को अनुक्रमित करने के लिए किया जाता है, और nelem आइटमों के संबंधित भाग को nelem कॉपी किया जाता है। clipmode (जो मानों पर ले जा सकता है NPY_RAISE , NPY_WRAP या NPY_CLIP ) यह निर्धारित करता है कि कैसे 0 से छोटे या nindarray से बड़े nindarray को संभाला जाएगा।

int argmin(void* data, npy_intp n, npy_intp* min_ind, void* arr)

किसी फ़ंक्शन के लिए एक संकेतक जो data द्वारा इंगित किए गए तत्व पर शुरुआत में n तत्वों में सबसे छोटे तत्वों के सूचकांक को पुनः प्राप्त करता है। इस फ़ंक्शन के लिए आवश्यक है कि मेमोरी सेगमेंट सन्निहित और व्यवहार किया जाए। वापसी मान हमेशा 0. होता है। सबसे छोटे तत्व का सूचकांक min_ind में वापस आ जाता है।

PyArray_Type टाइपबॉजेक्ट tp_as_number, tp_as_fterence, tp_as_mapping, और tp_as_buffs इंटरफ़ेस सहित पायथन ऑब्जेक्ट्स की कई विशेषताओं को कार्यान्वित करता है। तरीकों (tp_methods) और गुणों (tp_getset) के लिए नई शैली विशेषता लुकअप के साथ समृद्ध तुलना (tp_richcompare) का भी उपयोग किया जाता है। PyArray_Type को उप-टाइप भी किया जा सकता है।

टिप

Tp_as_number तरीके ऑपरेशन को संभालने के लिए जो भी फ़ंक्शन पंजीकृत किया गया है उसे कॉल करने के लिए एक सामान्य दृष्टिकोण का उपयोग करते हैं। फ़ंक्शन PyNumeric_SetOps (..) का उपयोग विशेष गणितीय कार्यों (सभी सरणियों के लिए) को संभालने के लिए फ़ंक्शन को पंजीकृत करने के लिए किया जा सकता है। जब umath मॉड्यूल आयात किया जाता है, तो यह सभी सरणियों के लिए संख्यात्मक संचालन को संबंधित ufuncs पर सेट करता है। Tp_str और tp_repr तरीकों को PyString_SetStringFunction (…) का उपयोग करके भी बदला जा सकता है।

PyUFunc_Type

PyUFunc_Type

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

PyUFuncObject

Ufunc का मूल PyUFuncObject है जिसमें अंतर्निहित C- कोड लूप को कॉल करने के लिए आवश्यक सभी जानकारी होती है जो वास्तविक कार्य करते हैं। इसकी निम्न संरचना है:

typedef struct {
    PyObject_HEAD
    int nin;
    int nout;
    int nargs;
    int identity;
    PyUFuncGenericFunction *functions;
    void **data;
    int ntypes;
    int reserved1;
    const char *name;
    char *types;
    const char *doc;
    void *ptr;
    PyObject *obj;
    PyObject *userloops;
    npy_uint32 *op_flags;
    npy_uint32 *iter_flags;
} PyUFuncObject;
int PyUFuncObject.nin

इनपुट तर्कों की संख्या।

int PyUFuncObject.nout

आउटपुट तर्कों की संख्या।

int PyUFuncObject.nargs

तर्कों की कुल संख्या ( नौ + nout )। यह NPY_MAXARGS से कम होना चाहिए।

int PyUFuncObject.identity

या तो PyUFunc_One , PyUFunc_Zero , PyUFunc_None या PyUFunc_AllOnes इस ऑपरेशन की पहचान को इंगित करने के लिए। इसका उपयोग केवल खाली सरणी पर कम करने जैसी कॉल के लिए किया जाता है।

void PyUFuncObject.functions(char** args, npy_intp* dims,
npy_intp* steps, void* extradata)

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

void **PyUFuncObject.data

यदि अतिरिक्त डेटा की आवश्यकता नहीं NULL तो अतिरिक्त डेटा को 1-डी वेक्टर लूप या NULL भेजा जाएगा। यह C-array फ़ंक्शन सरणी के समान आकार ( यानी ntypes) होना चाहिए। NULL का उपयोग किया जाता है यदि extra_data की आवश्यकता नहीं है। UFuncs के लिए कई C-API कॉल सिर्फ 1-d वेक्टर लूप हैं जो कॉल करने के लिए वास्तविक फ़ंक्शन के लिए एक पॉइंटर प्राप्त करने के लिए इस अतिरिक्त डेटा का उपयोग करते हैं।

int PyUFuncObject.ntypes

Ufunc के लिए समर्थित डेटा प्रकारों की संख्या। यह संख्या निर्दिष्ट करती है कि कितने अलग-अलग 1-डी लूप (अंतर्निहित डेटा प्रकार) उपलब्ध हैं।

char *PyUFuncObject.name

Ufunc के लिए एक स्ट्रिंग नाम। यह ufdcs की __doc__ विशेषता बनाने के लिए गतिशील रूप से उपयोग किया जाता है।

char *PyUFuncObject.types

की सरणी nargs \ n ntypes 8-बिट type_numbers जिसमें समर्थित (बिलिन) डेटा प्रकारों में से प्रत्येक के लिए फ़ंक्शन के प्रकार के हस्ताक्षर होते हैं। प्रत्येक ntypes फ़ंक्शंस के लिए, इस एरे में टाइप नंबरों के संबंधित सेट से पता चलता है कि 1-डी वेक्टर लूप में आर्ग्स तर्क की व्याख्या कैसे की जानी चाहिए। इन प्रकार की संख्याओं को एक ही प्रकार का नहीं होना चाहिए और मिश्रित-प्रकार के ufuncs समर्थित हैं।

char *PyUFuncObject.doc

Ufunc के लिए प्रलेखन। फ़ंक्शन हस्ताक्षर नहीं होना चाहिए क्योंकि यह गतिशील रूप से उत्पन्न होता है जब __doc__ को पुनर्प्राप्त किया जाता है।

void *PyUFuncObject.ptr

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

PyObject *PyUFuncObject.obj

अजगर के कार्यों से गतिशील रूप से निर्मित ufuncs के लिए, यह सदस्य अंतर्निहित पायथन फ़ंक्शन का संदर्भ रखता है।

PyObject *PyUFuncObject.userloops

उपयोगकर्ता द्वारा परिभाषित 1-डी वेक्टर लूप्स (COBject ptrs के रूप में संग्रहीत) का एक शब्दकोश उपयोगकर्ता-परिभाषित प्रकारों के लिए। उपयोगकर्ता द्वारा परिभाषित किसी भी प्रकार के लिए एक लूप पंजीकृत किया जा सकता है। यह प्रकार संख्या द्वारा पुनर्प्राप्त किया जाता है। उपयोगकर्ता परिभाषित प्रकार संख्या हमेशा NPY_USERDEF से बड़ी होती है।

npy_uint32 PyUFuncObject.op_flags

प्रत्येक ufunc ऑपरेंड के लिए डिफ़ॉल्ट ऑपरेंड फ्लैग को ओवरराइड करें।

npy_uint32 PyUFuncObject.iter_flags

Ufunc के लिए डिफ़ॉल्ट nditer झंडे को ओवरराइड करें।

PyArrayIter_Type

PyArrayIter_Type

यह एक पुनरावृत्त वस्तु है जो एन-आयामी सरणी पर लूप करना आसान बनाता है। यह एक ndarray के सपाट विशेषता से लौटी वस्तु है। यह एन-आयामी सरणी पर लूप करने के लिए कार्यान्वयन इंटर्नल्स में बड़े पैमाने पर उपयोग किया जाता है। Tp_as_mapping इंटरफ़ेस लागू किया गया है ताकि इट्रेटर ऑब्जेक्ट को अनुक्रमित किया जा सके (1-d इंडेक्सिंग का उपयोग करके), और कुछ विधियों को tp_methods तालिका के माध्यम से कार्यान्वित किया जाता है। यह ऑब्जेक्ट अगली विधि को लागू करता है और कहीं भी इस्तेमाल किया जा सकता है एक पायथन में इस्तेमाल किया जा सकता है।

PyArrayIterObject

PyArrayIter_Type ऑब्जेक्ट के अनुरूप C-संरचना PyArrayIterObject PyArrayIterObject का उपयोग एन-आयामी सरणी में एक पॉइंटर का ट्रैक रखने के लिए किया जाता है। इसमें संबंधित जानकारी होती है जिसका उपयोग सरणी के माध्यम से जल्दी से मार्च करने के लिए किया जाता है। पॉइंटर को तीन मूल तरीकों से समायोजित किया जा सकता है: 1) सी-स्टाइल सन्निहित फैशन में सरणी में "अगला" स्थिति के लिए अग्रिम, 2) सरणी में एक मनमाना एन-आयामी समन्वय के लिए अग्रिम, और 3) एक के लिए अग्रिम मनमाने ढंग से एक आयामी सूचकांक सरणी में। इन गणनाओं में PyArrayIterObject संरचना के सदस्यों का उपयोग किया जाता है। इटरेटर ऑब्जेक्ट्स अपने स्वयं के आयाम रखते हैं और एक ऐरे के बारे में जानकारी स्ट्राइड करते हैं। इसे "प्रसारण", या केवल विशिष्ट आयामों पर लूप के लिए आवश्यकतानुसार समायोजित किया जा सकता है।

typedef struct {
    PyObject_HEAD
    int   nd_m1;
    npy_intp  index;
    npy_intp  size;
    npy_intp  coordinates[NPY_MAXDIMS];
    npy_intp  dims_m1[NPY_MAXDIMS];
    npy_intp  strides[NPY_MAXDIMS];
    npy_intp  backstrides[NPY_MAXDIMS];
    npy_intp  factors[NPY_MAXDIMS];
    PyArrayObject *ao;
    char  *dataptr;
    Bool  contiguous;
} PyArrayIterObject;
int PyArrayIterObject.nd_m1

N-1 कहा पे एन अंतर्निहित सरणी में आयामों की संख्या है।

npy_intp PyArrayIterObject.index

सरणी में वर्तमान 1-डी सूचकांक।

npy_intp PyArrayIterObject.size

अंतर्निहित सरणी का कुल आकार।

npy_intp *PyArrayIterObject.coordinates

एक एन सरणी में -Dimensional सूचकांक।

npy_intp *PyArrayIterObject.dims_m1

प्रत्येक आयाम में ऐरे माइनस 1 का आकार।

npy_intp *PyArrayIterObject.strides

सरणी के तार। प्रत्येक आयाम में अगले तत्व पर जाने के लिए कितने बाइट्स की आवश्यकता होती है।

npy_intp *PyArrayIterObject.backstrides

एक आयाम के अंत से अपनी शुरुआत तक वापस जाने के लिए कितने बाइट्स की आवश्यकता होती है। ध्यान दें कि backstrides[k] == strides[k] * dims_m1[k] , लेकिन इसे यहाँ अनुकूलन के रूप में संग्रहीत किया जाता है।

npy_intp *PyArrayIterObject.factors

इस सरणी का उपयोग 1-डी इंडेक्स से एनडी इंडेक्स की गणना करने में किया जाता है। इसमें आयामों के आवश्यक उत्पाद शामिल हैं।

PyArrayObject *PyArrayIterObject.ao

एक अंतर्निहित ndarray के लिए सूचक इस पुनरावृत्ति का प्रतिनिधित्व करने के लिए बनाया गया था।

char *PyArrayIterObject.dataptr

यह सदस्य सूचकांक द्वारा इंगित ndarray में एक तत्व को इंगित करता है।

Bool PyArrayIterObject.contiguous

यह ध्वज सत्य है यदि अंतर्निहित सरणी NPY_ARRAY_C_CONTIGUOUS । इसका उपयोग जब संभव हो तो गणना को सरल बनाने के लिए किया जाता है।

सी-लेवल पर एरे इटरेटर का उपयोग कैसे करें, बाद के सेक्शन में अधिक पूरी तरह से समझाया गया है। आमतौर पर, आपको PyArray_ITER_NEXT ऑब्जेक्ट की आंतरिक संरचना के साथ खुद को चिंता करने की ज़रूरत नहीं है, और मैक्रोज़ PyArray_ITER_NEXT (it), PyArray_ITER_GOTO (it, dest), या PyArray_ITER_GOTO1D (यह, इंडेक्स) के उपयोग के साथ इसके साथ बातचीत करें। इन सभी मैक्रोज़ को तर्क की आवश्यकता है कि यह PyArrayIterObject

PyArrayMultiIter_Type

PyArrayMultiIter_Type

यह प्रकार एक पुनरावृत्ति प्रदान करता है जो प्रसारण की अवधारणा को घेरता है। यह अनुमति देता है एन प्रसारण को एक साथ प्रसारित किया जाता है ताकि लूप सी-स्टाइल सन्निहित फैशन में प्रसारित सरणी पर आगे बढ़े। संबंधित सी-संरचना PyArrayMultiIterObject जिसका मेमोरी लेआउट PyArray_Broadcast (obj) फ़ंक्शन में पारित किसी भी ऑब्जेक्ट, obj को शुरू करना चाहिए। सरणी पुनरावृत्तियों को समायोजित करके प्रसारण किया जाता है ताकि प्रत्येक पुनरावृत्त प्रसारित आकार और आकार का प्रतिनिधित्व करे, लेकिन इसके स्ट्रिंग्स को समायोजित किया गया है ताकि सरणी से सही तत्व प्रत्येक पुनरावृत्ति में उपयोग किया जाए।

PyArrayMultiIterObject
typedef struct {
    PyObject_HEAD
    int numiter;
    npy_intp size;
    npy_intp index;
    int nd;
    npy_intp dimensions[NPY_MAXDIMS];
    PyArrayIterObject *iters[NPY_MAXDIMS];
} PyArrayMultiIterObject;
int PyArrayMultiIterObject.numiter

एक ही आकार में प्रसारित होने वाले सरणियों की संख्या।

npy_intp PyArrayMultiIterObject.size

कुल प्रसारित आकार।

npy_intp PyArrayMultiIterObject.index

प्रसारित परिणाम में वर्तमान (1-डी) सूचकांक।

int PyArrayMultiIterObject.nd

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

npy_intp *PyArrayMultiIterObject.dimensions

प्रसारित परिणाम का आकार (केवल nd स्लॉट का उपयोग किया जाता है)।

PyArrayIterObject **PyArrayMultiIterObject.iters

इटरेटर ऑब्जेक्ट्स की एक सरणी जो एरियर्स को एक साथ प्रसारित करने के लिए रखती है। वापसी पर, पुनरावृत्तियों को प्रसारण के लिए समायोजित किया जाता है।

PyArrayNeighborhoodIter_Type

PyArrayNeighborhoodIter_Type

यह एक पुनरावृत्त वस्तु है जो एन-आयामी पड़ोस पर लूप करना आसान बनाता है।

PyArrayNeighborhoodIterObject

PyArrayNeighborhoodIter_Type ऑब्जेक्ट के अनुरूप C-संरचना PyArrayNeighborhoodIterObject

PyArrayFlags_Type

PyArrayFlags_Type

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

ScalarArrayTypes

प्रत्येक अलग-अलग अंतर्निहित डेटा प्रकारों के लिए एक पायथन प्रकार है जो कि सरणी में मौजूद हो सकता है। इनमें से अधिकांश सी में संबंधित डेटा प्रकार के आसपास सरल आवरण हैं। इन प्रकारों के लिए सी-नाम Py{TYPE}ArrType_Type {TYPE} हो सकता है

बूल , बाइट , शॉर्ट , इंट , लॉन्ग , लॉन्गॉन्ग , यूबाइट , यूएसहॉर्ट , यूओंग , उलॉन्ग , उलॉन्गॉन्ग , हॉफ , फ्लोट , डबल , लॉन्गड डबल , सीफ्लोट , सीडी डबल , क्लॉन्गडबल , स्ट्रिंग , यूनिकोड , शून्य और ऑब्जेक्ट

ये प्रकार नाम C-API का हिस्सा हैं और इसलिए इसे विस्तार C-code में बनाया जा सकता है। एक PyIntpArrType_Type और एक PyUIntpArrType_Type पूर्णांक प्रकारों के लिए सरल विकल्प भी हैं जो प्लेटफ़ॉर्म पर एक पॉइंटर पकड़ सकते हैं। इन स्केलर ऑब्जेक्ट्स की संरचना सी-कोड के संपर्क में नहीं है। फ़ंक्शन PyArray_ScalarAsCtype (..) का उपयोग सरणी स्केलर से C- प्रकार मान निकालने के लिए किया जा सकता है और फ़ंक्शन PyArray_Scalar (…) का उपयोग C-मान से सरणी स्केलर बनाने के लिए किया जा सकता है।

अन्य C- संरचनाएं

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

PyArray_Dims

PyArray_Dims

यह संरचना बहुत उपयोगी है जब आकार और / या सूचनाओं की व्याख्या की जानी चाहिए। संरचना है:

typedef struct {
    npy_intp *ptr;
    int len;
} PyArray_Dims;

इस संरचना के सदस्य हैं

npy_intp *PyArray_Dims.ptr

( npy_intp ) पूर्णांक की सूची के लिए एक सूचक जो आमतौर पर सरणी आकार या सरणी स्ट्राइड का प्रतिनिधित्व करता है।

int PyArray_Dims.len

पूर्णांकों की सूची की लंबाई। यह ptr [0] से ptr [len-1] तक पहुँचने के लिए सुरक्षित माना जाता है ।

PyArray_Chunk

PyArray_Chunk

यह पाइथर सदस्य के लिए पाइथन में बफर ऑब्जेक्ट संरचना के बराबर है। 32-बिट प्लेटफार्मों पर ( यानी अगर NPY_SIZEOF_INT == NPY_SIZEOF_INTP ), लेन सदस्य भी बफर वस्तु के एक बराबर सदस्य मेल खाता है। स्मृति के सामान्य एकल-खंड वाले हिस्से का प्रतिनिधित्व करना उपयोगी है।

typedef struct {
    PyObject_HEAD
    PyObject *base;
    void *ptr;
    npy_intp len;
    int flags;
} PyArray_Chunk;

सदस्य हैं

PyObject *PyArray_Chunk.base

पायथन ऑब्जेक्ट मेमोरी का यह हिस्सा आता है। जरूरत है ताकि स्मृति का सही हिसाब लगाया जा सके।

void *PyArray_Chunk.ptr

मेमोरी के सिंगल-सेगमेंट चंक की शुरुआत के लिए एक सूचक।

npy_intp PyArray_Chunk.len

बाइट्स में खंड की लंबाई।

int PyArray_Chunk.flags

कोई भी डेटा फ़्लैग ( उदाहरण NPY_ARRAY_WRITEABLE ) जिसका उपयोग मेमोरी की व्याख्या करने के लिए किया जाना चाहिए।

PyArrayInterface

यह भी देखें

ऐरे इंटरफ़ेस

PyArrayInterface

PyArrayInterface ताकि NumPy और अन्य विस्तार मॉड्यूल तेजी से सरणी इंटरफ़ेस प्रोटोकॉल का उपयोग कर सकते संरचना परिभाषित किया गया है। __array_struct__ रैपिड ऐरे इंटरफेस प्रोटोकॉल का समर्थन करने वाली एक वस्तु की विधि को उस एरे को लौटना चाहिए PyCObject जिसमें PyArrayInterface व्यूह के प्रासंगिक विवरण के साथ संरचना में सूचक हो । नया एरे निर्मित होने के बाद, विशेषता DECREF 'd' होनी चाहिए जो PyArrayInterface संरचना को मुक्त करेगी । INCREF ऑब्जेक्ट को याद रखें (जिसकी __array_struct__ विशेषता पुनर्प्राप्त की गई थी) और नए के आधार सदस्य को PyArrayObject इसी ऑब्जेक्ट पर इंगित करें । इस तरह एरे के लिए मेमोरी को सही तरीके से मैनेज किया जाएगा।

typedef struct {
    int two;
    int nd;
    char typekind;
    int itemsize;
    int flags;
    npy_intp *shape;
    npy_intp *strides;
    void *data;
    PyObject *descr;
} PyArrayInterface;
int PyArrayInterface.two

पूर्णांक 2 एक पवित्रता जाँच के रूप में।

int PyArrayInterface.nd

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

char PyArrayInterface.typekind

'T' -> बिटफ़ील्ड, 'b' -> बूलियन, 'i' -> हस्ताक्षरित पूर्णांक, 'u' -> अहस्ताक्षरित पूर्णांक, 'f -> फ्लोटिंग पॉइंट, 'c' -> कॉम्प्लेक्स फ्लोटिंग पॉइंट, 'O' -> ऑब्जेक्ट, 'S' -> (बाइट-) स्ट्रिंग, 'U' -> यूनिकोड, 'V' -> शून्य।

int PyArrayInterface.itemsize

सरणी में प्रत्येक आइटम बाइट्स की संख्या की आवश्यकता होती है।

int PyArrayInterface.flags

बिट्स NPY_ARRAY_C_CONTIGUOUS (1), NPY_ARRAY_F_CONTIGUOUS (2), NPY_ARRAY_ALIGNED (0x100), NPY_ARRAY_NOTSWAPPED (0x200), या NPY_ARRAY_WRITEABLE (0x400) में से कोई भी डेटा के बारे में कुछ इंगित करता है। NPY_ARRAY_ALIGNED , NPY_ARRAY_C_CONTIGUOUS , और NPY_ARRAY_F_CONTIGUOUS झंडे वास्तव में अन्य पैरामीटर से निर्धारित किया जा सकता है। ध्वज NPY_ARR_HAS_DESCR (0x800) संस्करण 3 सरणी इंटरफ़ेस का उपभोग करने वाली वस्तुओं को इंगित करने के लिए भी सेट किया जा सकता है कि संरचना का अवर सदस्य मौजूद है (यह सरणी इंटरफ़ेस के संस्करण 2 का उपभोग करने वाली वस्तुओं द्वारा अनदेखा किया जाएगा)।

npy_intp *PyArrayInterface.shape

एक सरणी जिसमें प्रत्येक आयाम में सरणी का आकार होता है।

npy_intp *PyArrayInterface.strides

प्रत्येक आयाम में अगले तत्व को प्राप्त करने के लिए कूदने के लिए बाइट्स की संख्या वाला एक सरणी।

void *PyArrayInterface.data

सरणी के पहले तत्व के लिए एक सूचक ।

PyObject *PyArrayInterface.descr

अधिक विस्तार में डेटा-प्रकार का वर्णन करते हुए पायथन ऑब्जेक्ट ( डीस्क कुंजी के समान __array_interface__ )। यह तब हो सकता है NULL जब टाइपकाइंड और आइटम पर्याप्त जानकारी प्रदान करते हैं। यह फ़ील्ड को नजरअंदाज कर दिया जब तक है ARR_HAS_DESCR ध्वज में पर है झंडे

आंतरिक रूप से उपयोग की जाने वाली संरचनाएं

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

PyUFuncLoopObject

सी-संरचना के लिए एक ढीला आवरण जिसमें लूपिंग के लिए आवश्यक जानकारी होती है। यह उपयोगी है अगर आप ufunc लूपिंग कोड को समझने की कोशिश कर रहे हैं। PyUFuncLoopObject जुड़े सी संरचना है। इसे ufuncobject.h हेडर में परिभाषित किया गया है ।

PyUFuncReduceObject

सी-संरचना के लिए एक ढीला आवरण जिसमें ufuncs के कम-जैसे तरीकों के लिए आवश्यक जानकारी शामिल है। यह उपयोगी है यदि आप कोड को कम करने, संचय करने और कम करने की कोशिश कर रहे हैं। PyUFuncReduceObject जुड़े सी संरचना है। इसे ufuncobject.h हेडर में परिभाषित किया गया है ।

PyUFunc_Loop1d

सी-स्ट्रक्चर्स की एक साधारण लिंक्ड-लिस्ट जिसमें उपयोगकर्ता द्वारा परिभाषित डेटा-प्रकार के हर परिभाषित हस्ताक्षर के लिए ufunc के लिए 1-डी लूप को परिभाषित करने की आवश्यकता होती है।

PyArrayMapIter_Type

इस पायथन प्रकार के साथ उन्नत अनुक्रमण को नियंत्रित किया जाता है। यह सी-संरचना के चारों ओर एक ढीला आवरण है जिसमें उन्नत सरणी अनुक्रमण के लिए आवश्यक चर हैं। PyArrayMapIterObject यदि आप उन्नत-इंडेक्स मैपिंग कोड को समझने की कोशिश कर रहे हैं तो संबंधित सी-संरचना, उपयोगी है। इसे arrayobject.h हेडर में परिभाषित किया गया है । यह प्रकार पायथन के संपर्क में नहीं है और इसे सी-संरचना से बदला जा सकता है। एक पायथन प्रकार के रूप में यह संदर्भ-गिने स्मृति प्रबंधन का लाभ उठाता है।

Original text