NumPy 1.14 - NpyIter

ऐरे इटरेटर एपीआई




numpy

ऐरे इटरेटर एपीआई

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

एरे इटरेटर

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

यह पृष्ठ पुनरावृत्ति के लिए API का दस्तावेज बनाता है। NpyIter का नाम NpyIter और फ़ंक्शन का नाम NpyIter_* रखा गया है।

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

सरल Iteration उदाहरण

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

npy_intp PyArray_CountNonzero(PyArrayObject* self)
{
    /* Nonzero boolean function */
    PyArray_NonzeroFunc* nonzero = PyArray_DESCR(self)->f->nonzero;

    NpyIter* iter;
    NpyIter_IterNextFunc *iternext;
    char** dataptr;
    npy_intp nonzero_count;
    npy_intp* strideptr,* innersizeptr;

    /* Handle zero-sized arrays specially */
    if (PyArray_SIZE(self) == 0) {
        return 0;
    }

    /*
     * Create and use an iterator to count the nonzeros.
     *   flag NPY_ITER_READONLY
     *     - The array is never written to.
     *   flag NPY_ITER_EXTERNAL_LOOP
     *     - Inner loop is done outside the iterator for efficiency.
     *   flag NPY_ITER_NPY_ITER_REFS_OK
     *     - Reference types are acceptable.
     *   order NPY_KEEPORDER
     *     - Visit elements in memory order, regardless of strides.
     *       This is good for performance when the specific order
     *       elements are visited is unimportant.
     *   casting NPY_NO_CASTING
     *     - No casting is required for this operation.
     */
    iter = NpyIter_New(self, NPY_ITER_READONLY|
                             NPY_ITER_EXTERNAL_LOOP|
                             NPY_ITER_REFS_OK,
                        NPY_KEEPORDER, NPY_NO_CASTING,
                        NULL);
    if (iter == NULL) {
        return -1;
    }

    /*
     * The iternext function gets stored in a local variable
     * so it can be called repeatedly in an efficient manner.
     */
    iternext = NpyIter_GetIterNext(iter, NULL);
    if (iternext == NULL) {
        NpyIter_Deallocate(iter);
        return -1;
    }
    /* The location of the data pointer which the iterator may update */
    dataptr = NpyIter_GetDataPtrArray(iter);
    /* The location of the stride which the iterator may update */
    strideptr = NpyIter_GetInnerStrideArray(iter);
    /* The location of the inner loop size which the iterator may update */
    innersizeptr = NpyIter_GetInnerLoopSizePtr(iter);

    nonzero_count = 0;
    do {
        /* Get the inner loop data/stride/count values */
        char* data = *dataptr;
        npy_intp stride = *strideptr;
        npy_intp count = *innersizeptr;

        /* This is a typical inner loop for NPY_ITER_EXTERNAL_LOOP */
        while (count--) {
            if (nonzero(data, self)) {
                ++nonzero_count;
            }
            data += stride;
        }

        /* Increment the iterator to the next inner loop */
    } while(iternext(iter));

    NpyIter_Deallocate(iter);

    return nonzero_count;
}

सरल मल्टी-इटरेशन उदाहरण

इटरेटर का उपयोग करके एक सरल कॉपी फ़ंक्शन है। order पैरामीटर का उपयोग आवंटित परिणाम के मेमोरी लेआउट को नियंत्रित करने के लिए किया जाता है, आमतौर पर NPY_KEEPORDER वांछित है।

PyObject *CopyArray(PyObject *arr, NPY_ORDER order)
{
    NpyIter *iter;
    NpyIter_IterNextFunc *iternext;
    PyObject *op[2], *ret;
    npy_uint32 flags;
    npy_uint32 op_flags[2];
    npy_intp itemsize, *innersizeptr, innerstride;
    char **dataptrarray;

    /*
     * No inner iteration - inner loop is handled by CopyArray code
     */
    flags = NPY_ITER_EXTERNAL_LOOP;
    /*
     * Tell the constructor to automatically allocate the output.
     * The data type of the output will match that of the input.
     */
    op[0] = arr;
    op[1] = NULL;
    op_flags[0] = NPY_ITER_READONLY;
    op_flags[1] = NPY_ITER_WRITEONLY | NPY_ITER_ALLOCATE;

    /* Construct the iterator */
    iter = NpyIter_MultiNew(2, op, flags, order, NPY_NO_CASTING,
                            op_flags, NULL);
    if (iter == NULL) {
        return NULL;
    }

    /*
     * Make a copy of the iternext function pointer and
     * a few other variables the inner loop needs.
     */
    iternext = NpyIter_GetIterNext(iter, NULL);
    innerstride = NpyIter_GetInnerStrideArray(iter)[0];
    itemsize = NpyIter_GetDescrArray(iter)[0]->elsize;
    /*
     * The inner loop size and data pointers may change during the
     * loop, so just cache the addresses.
     */
    innersizeptr = NpyIter_GetInnerLoopSizePtr(iter);
    dataptrarray = NpyIter_GetDataPtrArray(iter);

    /*
     * Note that because the iterator allocated the output,
     * it matches the iteration order and is packed tightly,
     * so we don't need to check it like the input.
     */
    if (innerstride == itemsize) {
        do {
            memcpy(dataptrarray[1], dataptrarray[0],
                                    itemsize * (*innersizeptr));
        } while (iternext(iter));
    } else {
        /* For efficiency, should specialize this based on item size... */
        npy_intp i;
        do {
            npy_intp size = *innersizeptr;
            char *src = dataptrarray[0], *dst = dataptrarray[1];
            for(i = 0; i < size; i++, src += innerstride, dst += itemsize) {
                memcpy(dst, src, itemsize);
            }
        } while (iternext(iter));
    }

    /* Get the result from the iterator object array */
    ret = NpyIter_GetOperandArray(iter)[1];
    Py_INCREF(ret);

    if (NpyIter_Deallocate(iter) != NPY_SUCCEED) {
        Py_DECREF(ret);
        return NULL;
    }

    return ret;
}

Iterator डेटा प्रकार

इटरेटर लेआउट एक आंतरिक विवरण है, और उपयोगकर्ता कोड केवल एक अधूरा संरचना देखता है।

NpyIter

यह पुनरावृत्ति के लिए एक अपारदर्शी सूचक प्रकार है। इसकी सामग्री तक पहुंच केवल itter API के माध्यम से की जा सकती है।

NpyIter_Type

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

NpyIter_IterNextFunc

यह NpyIter_GetIterNext द्वारा लौटाए गए पुनरावृति लूप के लिए एक फ़ंक्शन पॉइंटर है।

NpyIter_GetMultiIndexFunc

यह वर्तमान NpyIter_GetGetMultiIndex मल्टी-इंडेक्स प्राप्त करने के लिए एक फ़ंक्शन पॉइंटर है, जिसे NpyIter_GetGetMultiIndex द्वारा लौटाया गया है।

निर्माण और विनाश

NpyIter* NpyIter_New(PyArrayObject* op, npy_uint32 flags, NPY_ORDER order, NPY_CASTING casting, PyArray_Descr* dtype)

दी गई सुपीरियर एरे ऑब्जेक्ट op लिए एक पुनरावृत्त बनाता है।

झंडे में पारित किए जाने वाले flags NpyIter_MultiNew को छोड़कर NpyIter_MultiNew में प्रलेखित वैश्विक और प्रति-ऑपरेंड फ़्लैग का कोई भी संयोजन है।

कोई भी NPY_ORDER enum मान order करने के लिए पारित किया जा सकता है। कुशल पुनरावृत्ति के लिए, NPY_KEEPORDER सबसे अच्छा विकल्प है, और अन्य आदेश विशेष पुनरावृत्ति पैटर्न को लागू करते हैं।

NPY_CASTING enum मानों में से कोई भी casting करने के लिए पारित किया जा सकता है। मानों में NPY_NO_CASTING , NPY_EQUIV_CASTING , NPY_SAFE_CASTING , NPY_SAME_KIND_CASTING और NPY_UNSAFE_CASTING । जातियों को होने देने के लिए, प्रतिलिपि बनाना या बफ़र करना भी सक्षम होना चाहिए।

यदि dtype NULL नहीं NULL , तो इसके लिए उस डेटा प्रकार की आवश्यकता होती है। यदि कॉपी करने की अनुमति है, तो यह डेटा कास्टेबल होने पर एक अस्थायी प्रतिलिपि बना देगा। यदि NPY_ITER_UPDATEIFCOPY सक्षम है, तो यह NPY_ITER_UPDATEIFCOPY विनाश पर अन्य कलाकारों के साथ डेटा की प्रतिलिपि भी बनाएगा।

त्रुटि होने पर NULL लौटाता है, अन्यथा आवंटित इट्रेटर लौटाता है।

पुराने पुनरावृत्ति के समान एक इटरेटर बनाने के लिए, यह काम करना चाहिए।

iter = NpyIter_New(op, NPY_ITER_READWRITE,
                    NPY_CORDER, NPY_NO_CASTING, NULL);

यदि आप संरेखित double कोड के साथ एक सरणी को संपादित करना चाहते हैं, लेकिन आदेश कोई फर्क नहीं पड़ता, तो आप इसका उपयोग करेंगे।

dtype = PyArray_DescrFromType(NPY_DOUBLE);
iter = NpyIter_New(op, NPY_ITER_READWRITE|
                    NPY_ITER_BUFFERED|
                    NPY_ITER_NBO|
                    NPY_ITER_ALIGNED,
                    NPY_KEEPORDER,
                    NPY_SAME_KIND_CASTING,
                    dtype);
Py_DECREF(dtype);
NpyIter* NpyIter_MultiNew(npy_intp nop, PyArrayObject** op, npy_uint32 flags, NPY_ORDER order, NPY_CASTING casting, npy_uint32* op_flags, PyArray_Descr** op_dtypes)

नियमित रूप से NumPy प्रसारण नियमों का उपयोग करते हुए, op में प्रदान की गई nop एरे वस्तुओं को प्रसारित करने के लिए एक पुनरावृत्त बनाता है।

कोई भी NPY_ORDER enum मान order करने के लिए पारित किया जा सकता है। कुशल पुनरावृत्ति के लिए, NPY_KEEPORDER सबसे अच्छा विकल्प है, और अन्य आदेश विशेष पुनरावृत्ति पैटर्न को लागू करते हैं। NPY_KEEPORDER का उपयोग करते NPY_KEEPORDER , यदि आप यह भी सुनिश्चित करना चाहते हैं कि पुनरावृत्ति अक्ष के साथ उलट न हो, तो आपको ध्वज NPY_ITER_DONT_NEGATE_STRIDES पास करना चाहिए।

NPY_CASTING enum मानों में से कोई भी casting करने के लिए पारित किया जा सकता है। मानों में NPY_NO_CASTING , NPY_EQUIV_CASTING , NPY_SAFE_CASTING , NPY_SAME_KIND_CASTING और NPY_UNSAFE_CASTING । जातियों को होने देने के लिए, प्रतिलिपि बनाना या बफ़र करना भी सक्षम होना चाहिए।

यदि op_dtypes NULL नहीं NULL , तो यह एक डेटा प्रकार या NULL को प्रत्येक op[i] लिए निर्दिष्ट करता है।

त्रुटि होने पर NULL लौटाता है, अन्यथा आवंटित इट्रेटर लौटाता है।

झंडे जो पूरे ध्वजवाहक पर लागू होते हैं, वे इस प्रकार हैं:

NPY_ITER_C_INDEX

C क्रम से मेल खाते हुए उठे हुए फ्लैट इंडेक्स को ट्रैक करने के लिए पुनरावृति का कारण बनता है। इस विकल्प का उपयोग NPY_ITER_F_INDEX साथ नहीं किया जा सकता है।

NPY_ITER_F_INDEX

फोरट्रान ऑर्डर से मेल खाते हुए एक उबड़-खाबड़ फ्लैट इंडेक्स को ट्रैक करने के लिए पुनरावृत्ति करने वाला। इस विकल्प का उपयोग NPY_ITER_C_INDEX साथ नहीं किया जा सकता है।

NPY_ITER_MULTI_INDEX

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

NPY_ITER_EXTERNAL_LOOP

योजक को लूप के पुनरावृत्ति को छोड़ने के लिए पुनरावृत्ति का कारण बनता है, जिससे इसे संभालने के लिए पुनरावृत्ति के उपयोगकर्ता की आवश्यकता होती है।

यह ध्वज NPY_ITER_C_INDEX , NPY_ITER_F_INDEX और NPY_ITER_MULTI_INDEX साथ असंगत है।

NPY_ITER_DONT_NEGATE_STRIDES

ऑर्डर पैरामीटर के लिए NPY_KEEPORDER निर्दिष्ट किए जाने पर यह केवल इटरेटर को प्रभावित करता है। डिफ़ॉल्ट रूप से NPY_KEEPORDER साथ, NPY_KEEPORDER उन NPY_KEEPORDER को उलट देता है, जिनमें नकारात्मक NPY_KEEPORDER होते हैं, ताकि मेमोरी आगे की दिशा में ट्रेस हो जाए। यह इस कदम को निष्क्रिय करता है। यदि आप अक्षों के अंतर्निहित मेमोरी-ऑर्डरिंग का उपयोग करना चाहते हैं, तो इस ध्वज का उपयोग करें, लेकिन एक अक्ष को उलट नहीं करना चाहते हैं। यह उदाहरण के लिए numpy.ravel(a, order='K') का व्यवहार है।

NPY_ITER_COMMON_DTYPE

Ufunc प्रकार के पदोन्नति नियमों के आधार पर गणना की गई, सभी ऑपरेंड को एक सामान्य डेटा प्रकार में परिवर्तित करने के लिए पुनरावृति का कारण बनता है। नकल या बफरिंग सक्षम होना चाहिए।

यदि सामान्य डेटा प्रकार समय से पहले जाना जाता है, तो इस ध्वज का उपयोग न करें। इसके बजाय, सभी ऑपरेंड के लिए अनुरोधित dtype सेट करें।

NPY_ITER_REFS_OK

इंगित करता है कि संदर्भ प्रकार (ऑब्जेक्ट सरणियों या ऑब्जेक्ट प्रकार से युक्त संरचित सरणियों) के साथ सरणियों को स्वीकार किया जा सकता है और इट्रेटर में उपयोग किया जा सकता है। यदि यह ध्वज सक्षम है, तो कॉल करने वाले को यह NpyIter_IterationNeedsAPI(iter) सुनिश्चित करना चाहिए कि NpyIter_IterationNeedsAPI(iter) सही है या नहीं, जिस स्थिति में वह पुनरावृत्ति के दौरान GIL जारी नहीं कर सकता है।

NPY_ITER_ZEROSIZE_OK

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

NPY_ITER_REDUCE_OK

शून्य से अधिक आयाम और एक से अधिक आकार के साथ आयाम के साथ लेखन योग्य संचालन की अनुमति देता है। ध्यान दें कि ऐसे ऑपरेंड को पढ़ना / लिखना होगा।

जब बफरिंग सक्षम होती है, तो यह एक विशेष बफरिंग मोड में भी बदल जाता है, जो लूप की लंबाई को कम कर देता है, क्योंकि मूल्यों को कम नहीं किया जाता है।

ध्यान दें कि यदि आप स्वचालित रूप से आवंटित आउटपुट पर कमी करना चाहते हैं, तो आपको इसका संदर्भ प्राप्त करने के लिए NpyIter_GetOperandArray का उपयोग करना होगा, फिर पुनरावृत्ति लूप करने से पहले प्रत्येक मान को कमी इकाई पर सेट करें। बफ़र कमी के मामले में, इसका मतलब है कि आपको ध्वज NPY_ITER_DELAY_BUFALLOC को भी निर्दिष्ट करना होगा, फिर बफ़र तैयार करने के लिए आवंटित ऑपरेंड को इनिशियलाइज़ करने के बाद NPY_ITER_DELAY_BUFALLOC रीसेट करें।

NPY_ITER_RANGED

पूर्ण iterindex रेंज [0, NpyIter_IterSize(iter)) की उप-श्रेणियों की पुनरावृत्ति के लिए समर्थन को सक्षम करता है। फ़ंक्शन का उपयोग करें NpyIter_ResetToIterIndexRange पुनरावृत्ति के लिए एक सीमा निर्दिष्ट करने के लिए।

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

NPY_ITER_BUFFERED

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

यदि NPY_ITER_EXTERNAL_LOOP साथ उपयोग किया जाता है, तो कॉल करने वाले के लिए आंतरिक लूप बफ़र किए बिना संभव से अधिक बड़ा हिस्सा प्राप्त कर सकता है, क्योंकि NPY_ITER_EXTERNAL_LOOP कैसे रखी गई हैं।

ध्यान दें कि यदि एक ऑपरेंड को झंडा NPY_ITER_COPY या NPY_ITER_UPDATEIFCOPY दिया जाता है, तो एक कॉपी बफरिंग को प्राथमिकता दी जाएगी। बफरिंग तब भी होगी जब सरणी को प्रसारित किया गया था ताकि तत्वों को निरंतर स्ट्राइड प्राप्त करने के लिए डुप्लिकेट करने की आवश्यकता हो।

सामान्य बफरिंग में, प्रत्येक आंतरिक लूप का आकार बफर आकार के बराबर होता है, या संभवतः बड़ा होता है अगर NPY_ITER_GROWINNER निर्दिष्ट किया जाता है। यदि NPY_ITER_REDUCE_OK सक्षम है और एक कमी होती है, तो आंतरिक छोरों में कमी की संरचना के आधार पर छोटे हो सकते हैं।

NPY_ITER_GROWINNER

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

NPY_ITER_DELAY_BUFALLOC

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

इस ध्वज का एक अन्य उपयोग कमी संचालन स्थापित करने के लिए है। इटरेटर बनाए जाने के बाद, और इटरेटर द्वारा एक कमी आउटपुट स्वचालित रूप से आवंटित किया जाता है (READWRITE एक्सेस का उपयोग करना सुनिश्चित करें), इसके मूल्य को कम करने की इकाई के लिए इनिशियलाइज़ किया जा सकता है। ऑब्जेक्ट प्राप्त करने के लिए NpyIter_GetOperandArray का उपयोग करें। फिर, अपने प्रारंभिक मूल्यों के साथ बफ़र्स को आवंटित करने और भरने के लिए NpyIter_Reset को कॉल करें।

NPY_ITER_COPY_IF_OVERLAP

यदि किसी भी लिखने वाले ऑपरेटर ने किसी भी रीड ऑपरेंड के साथ ओवरलैप किया है, तो अस्थायी प्रतियां बनाकर सभी ओवरलैप को समाप्त करें (यदि आवश्यक हो, तो लिखने के लिए UPDATEIFCOPY को सक्षम करना)। यदि किसी स्मृति पते में दोनों सरणियों के लिए डेटा सम्‍मिलित है तो ऑपरेंड की एक जोड़ी ओवरलैप होती है।

क्योंकि सटीक ओवरलैप डिटेक्शन में आयामों की संख्या में घातीय रनटाइम होता है, निर्णय हेरास्टिक के आधार पर किया जाता है, जिसमें झूठी सकारात्मक (असामान्य मामलों में अनावश्यक प्रतियां) हैं, लेकिन कोई गलत नकारात्मक नहीं है।

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

झंडे जो op_flags[i] में पारित किए जा सकते हैं, जहां 0 <= i < nop :

NPY_ITER_READWRITE
NPY_ITER_READONLY
NPY_ITER_WRITEONLY

यह इंगित करने के लिए कि इट्रेटर का उपयोगकर्ता कैसे पढ़ेगा या op[i] लिखेगा। वास्तव में इनमें से एक झंडे को प्रति संचालन के लिए निर्दिष्ट किया जाना चाहिए।

NPY_ITER_COPY

अगर यह डेटा प्रकार या संरेखण आवश्यकताओं को पूरा नहीं करता है, तो इसे निर्माणकर्ता झंडे और मापदंडों द्वारा निर्दिष्ट किए जाने पर op[i] की एक कॉपी की अनुमति दें।

NPY_ITER_UPDATEIFCOPY

ट्रिगर NPY_ITER_COPY , और जब एक सरणी ऑपरेंड को लिखने के लिए फ़्लैग किया जाता है और कॉपी किया जाता है, तो कॉपी में डेटा को कॉपी किया जाता है op[i] जब वह नष्ट हो जाता है।

अगर ऑपरेंड को राइट-ओनली के रूप में चिह्नित किया जाता है और एक कॉपी की आवश्यकता होती है, तो एक uninitialized अस्थायी सरणी बनाई जाएगी और फिर अनावश्यक कॉपी ऑपरेशन करने के बजाय विनाश पर वापस op[i] कॉपी की जाएगी।

NPY_ITER_NBO
NPY_ITER_ALIGNED
NPY_ITER_CONTIG

ऑप्टर op[i] लिए डेटा प्रदान करने के लिए पुनरावृति का कारण बनता है, जो कि मूल बाइट क्रम में है, dtype आवश्यकताओं, सन्निहित या किसी भी संयोजन के अनुसार संरेखित किया गया है।

डिफ़ॉल्ट रूप से, इट्रेटर प्रदान किए गए सरणियों में पॉइंटर्स का उत्पादन करता है, जो कि संरेखित या अनलाइन किया जा सकता है, और किसी भी बाइट ऑर्डर के साथ। यदि नकल या बफरिंग सक्षम नहीं है और ऑपरेंड डेटा बाधाओं को संतुष्ट नहीं करता है, तो एक त्रुटि उठाई जाएगी।

सन्निहित बाधा केवल आंतरिक लूप पर लागू होती है, क्रमिक आंतरिक छोरों में मनमाने ढंग से सूचक परिवर्तन हो सकते हैं।

यदि अनुरोधित डेटा प्रकार गैर-देशी बाइट क्रम में है, तो एनबीओ ध्वज इसे ओवरराइड करता है और अनुरोधित डेटा प्रकार देशी बाइट क्रम में परिवर्तित हो जाता है।

NPY_ITER_ALLOCATE

यह आउटपुट सरणियों के लिए है, और इसके लिए ध्वज NPY_ITER_WRITEONLY या NPY_ITER_READWRITE सेट होने की आवश्यकता है। यदि op[i] NULL है, तो अंतिम प्रसारण आयामों के साथ एक नया सरणी बनाता है, और itter के पुनरावृत्ति क्रम से मेल खाता एक लेआउट।

जब op[i] NULL होता है, तो अनुरोधित डेटा प्रकार op_dtypes[i] NULL भी हो सकता है, इस स्थिति में यह स्वचालित रूप से सरणियों के dtypes से उत्पन्न होता है, जिसे पठनीय के रूप में चिह्नित किया जाता है। Dtype जनरेट करने के नियम UFuncs के लिए समान हैं। विशेष नोट में चयनित dtype में बाइट ऑर्डर को संभाल रहा है। यदि वास्तव में एक इनपुट है, तो इनपुट का dtype उपयोग किया जाता है। अन्यथा, यदि एक से अधिक इनपुट dtypes को एक साथ जोड़ दिया जाता है, तो आउटपुट देशी बाइट क्रम में होगा।

इस ध्वज के साथ आवंटित किए जाने के बाद, कॉलर NpyIter_GetOperandArray को कॉल NpyIter_GetOperandArray और लौटे C सरणी में i-th ऑब्जेक्ट प्राप्त करके नए सरणी को पुनः प्राप्त कर सकता है। कॉल करने वाले को सरणी के संदर्भ का दावा करने के लिए उस पर Py_INCREF को कॉल करना होगा।

NPY_ITER_NO_SUBTYPE

NPY_ITER_ALLOCATE साथ उपयोग के लिए, यह ध्वज आउटपुट के लिए एक सरणी उपप्रकार आवंटित करने को अक्षम करता है, जिससे यह सीधा ndarray हो जाता है।

TODO: हो सकता है कि फंक्शन NpyIter_GetWrappedOutput को पेश NpyIter_GetWrappedOutput और इस झंडे को हटाना बेहतर होगा?

NPY_ITER_NO_BROADCAST

सुनिश्चित करता है कि इनपुट या आउटपुट वास्तव में पुनरावृत्ति आयामों से मेल खाते हैं।

NPY_ITER_ARRAYMASK

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

इंगित करता है कि यह ऑपरेंड उन तत्वों को चुनने के लिए उपयोग करने के लिए मास्क है जो उन ऑपरेंड को लिखते समय होते हैं जिनके पास NPY_ITER_WRITEMASKED ध्वज होता है। केवल एक ऑपरेंड के पास ही NPY_ITER_ARRAYMASK झंडा हो सकता है।

इस ध्वज के साथ एक ऑपरेंड का डेटा प्रकार या तो NPY_BOOL , NPY_MASK या एक NPY_MASK NPY_BOOL होना चाहिए, जिसके क्षेत्र सभी मान्य मास्क dtypes हैं। उत्तरार्द्ध मामले में, यह एक संरचित ऑपरेंड के साथ मेल खाना चाहिए, क्योंकि यह सरणी के प्रत्येक क्षेत्र के लिए एक मुखौटा निर्दिष्ट कर रहा है।

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

NPY_ITER_WRITEMASKED

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

इंगित करता है कि केवल उन तत्वों को जो ARRAYMASK ध्वज के साथ ऑपरेंड इंगित करता है, इसे पुनरावृत्ति द्वारा संशोधित किया जाना है। सामान्य तौर पर, पुनरावृत्त इसे लागू नहीं करता है, यह उस वादे का पालन करने के लिए पुनरावृत्ति करने वाले कोड पर निर्भर है। कोड यह NpyMask_IsExposed लिए NpyMask_IsExposed इनलाइन फ़ंक्शन का उपयोग कर सकता है कि क्या किसी विशेष तत्व पर मुखौटा लिखने की अनुमति देता है।

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

NPY_ITER_OVERLAP_ASSUME_ELEMENTWISE

मेमोरी ओवरलैप चेक में, मान लें कि NPY_ITER_OVERLAP_ASSUME_ELEMENTWISE सक्षम किए गए ऑपरेंड केवल NPY_ITER_OVERLAP_ASSUME_ELEMENTWISE क्रम में एक्सेस किए गए हैं।

यह डेटा आश्रितता के बारे में तर्क करने में सक्षम बनाता है, संभवतः अनावश्यक प्रतियों से परहेज करता है।

यह ध्वज केवल तभी प्रभावी होता है जब NPY_ITER_COPY_IF_OVERLAP पर सक्षम हो।

NpyIter* NpyIter_AdvancedNew(npy_intp nop, PyArrayObject** op, npy_uint32 flags, NPY_ORDER order, NPY_CASTING casting, npy_uint32* op_flags, PyArray_Descr** op_dtypes, int oa_ndim, int** op_axes, npy_intp* itershape, npy_intp buffersize)

प्रसारण और बफरिंग पर अधिक नियंत्रण प्रदान करने वाले कई उन्नत विकल्पों के साथ NpyIter_MultiNew विस्तार करता है।

यदि -1 / NULL मान oa_ndim , op_axes , itershape , और op_axes पास किए जाते हैं, तो यह NpyIter_MultiNew बराबर है।

पैरामीटर oa_ndim , जब शून्य या -1 नहीं है, तो उन आयामों की संख्या निर्दिष्ट करता है जिन्हें अनुकूलित प्रसारण के साथ पुनरावृत्त किया जाएगा। यदि यह प्रदान किया गया है, तो op_axes और itershape भी प्रदान किए जा सकते हैं। op_axes पैरामीटर आपको विस्तार से नियंत्रित करने देता है कि ऑपरेंड सरणियों के अक्ष एक साथ और पुनरावृत्त कैसे मिलते हैं। op_axes , आपको oa_ndim प्रकार के npy_intp सरणियों के लिए nop पॉइंटर्स की एक सरणी प्रदान करनी चाहिए। यदि op_axes में प्रविष्टि NULL है, तो सामान्य प्रसारण नियम लागू होंगे। op_axes[j][i] या तो op[j] , या -1 का एक वैध अक्ष जमा होता है, जिसका अर्थ है newaxis । प्रत्येक op_axes[j] सरणी के भीतर, कुल्हाड़ियों को दोहराया नहीं जा सकता है। निम्न उदाहरण है कि 3-डी सरणी, 2-डी सरणी, 1-डी सरणी और एक स्केलर पर सामान्य प्रसारण कैसे लागू होता है।

नोट : NumPy से पहले 1.8 oa_ndim == 0` was used for signalling that that ``op_axes और itershape अप्रयुक्त हैं। यह पदावनत है और इसे -1 से बदला जाना चाहिए। इस मामले के लिए NpyIter_MultiNew का उपयोग करके बेहतर पिछड़ी संगतता प्राप्त की जा सकती है।

int oa_ndim = 3;               /* # iteration axes */
int op0_axes[] = {0, 1, 2};    /* 3-D operand */
int op1_axes[] = {-1, 0, 1};   /* 2-D operand */
int op2_axes[] = {-1, -1, 0};  /* 1-D operand */
int op3_axes[] = {-1, -1, -1}  /* 0-D (scalar) operand */
int* op_axes[] = {op0_axes, op1_axes, op2_axes, op3_axes};

itershape पैरामीटर आपको पुनरावृति को एक विशिष्ट पुनरावृत्ति आकार के लिए बाध्य करने की अनुमति देता है। यह लंबाई oa_ndim की एक सरणी है। जब कोई प्रविष्टि नकारात्मक होती है, तो इसका मान ऑपरेंड्स से निर्धारित होता है। यह पैरामीटर स्वचालित रूप से आबंटित आउटपुट को अतिरिक्त आयाम प्राप्त करने की अनुमति देता है जो किसी इनपुट के किसी भी आयाम से मेल नहीं खाता है।

यदि buffersize शून्य है, तो डिफ़ॉल्ट बफ़र आकार का उपयोग किया जाता है, अन्यथा यह निर्दिष्ट करता है कि बफ़र का उपयोग कितना बड़ा है। बफ़र जो 2 की शक्तियाँ हैं जैसे 4096 या 8192 की सिफारिश की जाती है।

त्रुटि होने पर NULL लौटाता है, अन्यथा आवंटित इट्रेटर लौटाता है।

NpyIter* NpyIter_Copy(NpyIter* iter)

दिए गए पुनरावृत्ति की एक प्रति बनाता है। यह फ़ंक्शन मुख्य रूप से डेटा के बहु-थ्रेडेड पुनरावृत्ति को सक्षम करने के लिए प्रदान किया जाता है।

TODO : इसे बहुस्तरीय पुनरावृत्ति के बारे में एक अनुभाग में ले जाएँ।

बहुस्तरीय पुनरावृत्ति के लिए अनुशंसित दृष्टिकोण पहले झंडे के साथ एक NPY_ITER_EXTERNAL_LOOP , NPY_ITER_RANGED , NPY_ITER_BUFFERED , NPY_ITER_DELAY_BUFALLOC और संभवतः NPY_ITER_GROWINNER । प्रत्येक थ्रेड के लिए इस इटरेटर की एक प्रति बनाएँ (पहले इटरेटर के लिए माइनस एक)। फिर, पुनरावृत्ति सूचकांक सीमा [0, NpyIter_GetIterSize(iter)) और इसे कार्यों में विभाजित करें, उदाहरण के लिए एक TBB समानांतर_प्राय लूप का उपयोग करके। जब किसी थ्रेड को निष्पादित करने के लिए कोई कार्य मिलता है, तो यह NpyIter_ResetToIterIndexRange कॉल NpyIter_ResetToIterIndexRange और पूरी सीमा पर पुनरावृति करके NpyIter_ResetToIterIndexRange की अपनी प्रतिलिपि का उपयोग करता है।

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

int NpyIter_RemoveAxis(NpyIter* iter, int axis)``

पुनरावृत्ति से एक अक्ष निकालता है। इसके लिए आवश्यक है कि NPY_ITER_MULTI_INDEX को NPY_ITER_MULTI_INDEX निर्माण के लिए सेट किया गया था, और बफरिंग सक्षम होने या इंडेक्स ट्रैक होने पर काम नहीं करता है। यह फ़ंक्शन इटेटर को अपनी प्रारंभिक स्थिति में भी रीसेट करता है।

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

चेतावनी : यह फ़ंक्शन इट्रेटर के आंतरिक मेमोरी लेआउट को बदल सकता है। पुनरावृत्त से किसी भी कैश्ड फ़ंक्शन या पॉइंटर्स को फिर से प्राप्त किया जाना चाहिए! पुनरावृत्त रेंज को भी रीसेट किया जाएगा।

NPY_SUCCEED या NPY_FAIL

int NpyIter_RemoveMultiIndex(NpyIter* iter)

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

चेतावनी : यह फ़ंक्शन इट्रेटर के आंतरिक मेमोरी लेआउट को बदल सकता है। पुनरावृत्त से किसी भी कैश्ड फ़ंक्शन या पॉइंटर्स को फिर से प्राप्त किया जाना चाहिए!

इस फ़ंक्शन को कॉल करने के बाद, NpyIter_HasMultiIndex(iter) गलत वापस आ जाएगी।

NPY_SUCCEED या NPY_FAIL

int NpyIter_EnableExternalLoop(NpyIter* iter)

यदि NpyIter_RemoveMultiIndex को कॉल किया गया था, तो आप ध्वज को NPY_ITER_EXTERNAL_LOOP सक्षम करना चाह सकते हैं। इस झंडे को NPY_ITER_MULTI_INDEX साथ अनुमति नहीं है, इसलिए NpyIter_RemoveMultiIndex को कॉल करने के बाद इस फ़ंक्शन को सक्षम करने के लिए यह फ़ंक्शन प्रदान किया गया है। यह फ़ंक्शन इटेटर को अपनी प्रारंभिक स्थिति में भी रीसेट करता है।

चेतावनी : यह फ़ंक्शन इट्रेटर के आंतरिक तर्क को बदलता है। पुनरावृत्त से किसी भी कैश्ड फ़ंक्शन या पॉइंटर्स को फिर से प्राप्त किया जाना चाहिए!

NPY_SUCCEED या NPY_FAIL

int NpyIter_Deallocate(NpyIter* iter)

Itter वस्तु को हटाता है। इसके अतिरिक्त, जहाँ आवश्यक हो, UPDATEIFCOPY व्यवहार को ट्रिगर करते हुए बनाई गई किसी भी प्रतिलिपि को मुक्त करता है।

NPY_SUCCEED या NPY_FAIL

int NpyIter_Reset(NpyIter* iter, char** errmsg)

पुनरावृत्ति सीमा की शुरुआत में, इट्रेटर को उसकी प्रारंभिक स्थिति में रीसेट करता है।

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

int NpyIter_ResetToIterIndexRange(NpyIter* iter, npy_intp istart, npy_intp iend, char** errmsg)

iterindex को रीसेट करता है और इसे iterindex सीमा [istart, iend) तक सीमित करता है। मल्टी-थ्रेडेड पुनरावृत्ति के लिए इसका उपयोग करने के तरीके की व्याख्या के लिए NpyIter_Copy देखें। इसके लिए यह आवश्यक है कि ध्वज NPY_ITER_RANGED को NPY_ITER_RANGED को दिया गया था।

यदि आप एक ही समय में iterindex रेंज और बेस पॉइंटर्स दोनों को रीसेट करना चाहते हैं, तो आप अतिरिक्त बफर कॉपी करने से बचने के लिए निम्नलिखित कर सकते हैं (जब आप इस कोड को कॉपी करते हैं तो रिटर्न कोड त्रुटि जांच जोड़ना सुनिश्चित करें)।

/* Set to a trivial empty range */
NpyIter_ResetToIterIndexRange(iter, 0, 0);
/* Set the base pointers */
NpyIter_ResetBasePointers(iter, baseptrs);
/* Set to the desired range */
NpyIter_ResetToIterIndexRange(iter, istart, iend);

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

int NpyIter_ResetBasePointers(NpyIter *iter, char** baseptrs, char** errmsg)

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

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

TODO : नेस्टेड पुनरावृत्तियों पर एक विशेष खंड में निम्नलिखित को स्थानांतरित करें।

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

चेतावनी : नेस्टेड पुनरावृत्ति के लिए पुनरावृत्तियों का निर्माण करते समय, कोड को विभिन्न पुनरावृत्तियों में एक से अधिक बार आयाम का उपयोग नहीं करना चाहिए। यदि ऐसा किया जाता है, तो नेस्टेड पुनरावृति पुनरावृत्ति के दौरान आउट-ऑफ-बाउंड्स पॉइंटर्स का उत्पादन करेगा।

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

नेस्टेड पुनरावृत्तियों का उपयोग करने के लिए पैटर्न निम्नानुसार है।

NpyIter *iter1, *iter1;
NpyIter_IterNextFunc *iternext1, *iternext2;
char **dataptrs1;

/*
 * With the exact same operands, no copies allowed, and
 * no axis in op_axes used both in iter1 and iter2.
 * Buffering may be enabled for iter2, but not for iter1.
 */
iter1 = ...; iter2 = ...;

iternext1 = NpyIter_GetIterNext(iter1);
iternext2 = NpyIter_GetIterNext(iter2);
dataptrs1 = NpyIter_GetDataPtrArray(iter1);

do {
    NpyIter_ResetBasePointers(iter2, dataptrs1);
    do {
        /* Use the iter2 values */
    } while (iternext2(iter2));
} while (iternext1(iter1));
int NpyIter_GotoMultiIndex(NpyIter* iter, npy_intp* multi_index)

ndim द्वारा इंगित ndim सूचकांकों को इंगित करने के लिए ndim समायोजित करता है। यदि कोई मल्टी-इंडेक्स ट्रैक नहीं किया जा रहा है, तो त्रुटि वापस आ जाती है, सूचक सीमा से बाहर हो जाते हैं, या आंतरिक लूप पुनरावृत्ति अक्षम हो जाती है।

NPY_SUCCEED या NPY_FAIL

int NpyIter_GotoIndex(NpyIter* iter, npy_intp index)

निर्दिष्ट index को इंगित करने के लिए पुनरावृत्ति समायोजित करता है। यदि NPY_ITER_C_INDEX को ध्वज NPY_ITER_C_INDEX साथ बनाया गया था, तो index C-ऑर्डर इंडेक्स है, और यदि NPY_ITER_F_INDEX का निर्माण ध्वज NPY_ITER_F_INDEX साथ किया गया था, तो index फोरट्रान-ऑर्डर इंडेक्स है। एक त्रुटि लौटाता है यदि कोई सूचकांक ट्रैक नहीं किया जा रहा है, तो सूचकांक सीमा से बाहर है, या आंतरिक लूप पुनरावृत्ति अक्षम है।

NPY_SUCCEED या NPY_FAIL

npy_intp NpyIter_GetIterSize(NpyIter* iter)

लौटाने वाले तत्वों की संख्या देता है। यह आकार में सभी आयामों का उत्पाद है। जब एक मल्टी इंडेक्स को ट्रैक किया जा रहा है (और NpyIter_RemoveAxis कहा जा सकता है) आकार का -1 हो सकता है ताकि यह इंगित किया जा सके कि NpyIter_RemoveAxis बहुत बड़ा है। ऐसा NpyIter_RemoveAxis अमान्य है, लेकिन NpyIter_RemoveAxis कहा जाता है के बाद मान्य हो NpyIter_RemoveAxis है। इस मामले की जाँच करना आवश्यक नहीं है।

npy_intp NpyIter_GetIterIndex(NpyIter* iter)

पुनरावृति के पुनरावृत्ति को प्राप्त करता है, जो एक सूचकांक है जो पुनरावृति के पुनरावृत्ति क्रम से मेल खाता है।

void NpyIter_GetIterIndexRange(NpyIter* iter, npy_intp* istart, npy_intp* iend)

iterindex सब-रेंज हो जाता है जो iterindex जा रहा है। यदि NPY_ITER_RANGED निर्दिष्ट नहीं किया गया था, तो यह हमेशा सीमा [0, NpyIter_IterSize(iter))

int NpyIter_GotoIterIndex(NpyIter* iter, npy_intp iterindex)

निर्दिष्ट iterindex को इंगित करने के लिए iterindex करता है। IterIndex एक सूचकांक है जो पुनरावृत्ति क्रम से मेल खाता है। यदि iterindex सीमा से बाहर है, तो त्रुटि iterindex है, बफरिंग सक्षम है, या आंतरिक लूप पुनरावृत्ति अक्षम है।

NPY_SUCCEED या NPY_FAIL

npy_bool NpyIter_HasDelayedBufAlloc(NpyIter* iter)

1 लौटाता है यदि ध्वज NPY_ITER_DELAY_BUFALLOC को NPY_ITER_DELAY_BUFALLOC को पास किया गया था, और रीसेट कार्यों में से एक पर कोई कॉल अभी तक नहीं किया गया है, अन्यथा 0।

npy_bool NpyIter_HasExternalLoop(NpyIter* iter)

1 लौटाता है अगर कॉलर को आंतरिक-सबसे 1-आयामी लूप को संभालने की आवश्यकता होती है, या 0 अगर इटरेटर सभी लूपिंग को संभालता है। इसे कंस्ट्रक्टर फ्लैग NPY_ITER_EXTERNAL_LOOP या NpyIter_EnableExternalLoop द्वारा नियंत्रित किया NpyIter_EnableExternalLoop

npy_bool NpyIter_HasMultiIndex(NpyIter* iter)

यदि 1 NPY_ITER_MULTI_INDEX ध्वज के साथ इट्रेटर बनाया गया था, तो रिटर्न 0 अन्यथा।

npy_bool NpyIter_HasIndex(NpyIter* iter)

यदि 1 NPY_ITER_C_INDEX या NPY_ITER_F_INDEX ध्वज के साथ इट्रेटर बनाया गया था, तो रिटर्न 0 अन्यथा।

npy_bool NpyIter_RequiresBuffering(NpyIter* iter)

यदि रिटर्न को 1 की आवश्यकता होती है तो 1 रिटर्न देता है, जो तब होता है जब एक ऑपरेंड को रूपांतरण या संरेखण की आवश्यकता होती है और इसलिए इसे सीधे उपयोग नहीं किया जा सकता।

npy_bool NpyIter_IsBuffered(NpyIter* iter)

यदि 1 NPY_ITER_BUFFERED ध्वज के साथ इट्रेटर बनाया गया था, तो रिटर्न 0 अन्यथा।

npy_bool NpyIter_IsGrowInner(NpyIter* iter)

यदि 1 NPY_ITER_GROWINNER ध्वज के साथ इट्रेटर बनाया गया था, तो रिटर्न 0 अन्यथा।

npy_intp NpyIter_GetBufferSize(NpyIter* iter)

यदि पुनरावर्तक बफ़र किया गया है, तो उपयोग किए जा रहे बफ़र का आकार लौटाता है, अन्यथा 0 देता है।

int NpyIter_GetNDim(NpyIter* iter)

पुनरावृत्त होने वाले आयामों की संख्या लौटाता है। यदि पुनरावृत्ति निर्माणकर्ता में बहु-सूचकांक का अनुरोध नहीं किया गया था, तो यह मान मूल वस्तुओं में आयामों की संख्या से छोटा हो सकता है।

int NpyIter_GetNOp(NpyIter* iter)

पुनरावृत्तियों में ऑपरेंड की संख्या लौटाता है।

जब NPY_ITER_USE_MASKNA एक ऑपरेंड पर उपयोग किया जाता है, तो उस ऑपरेंड के NA मास्क को ट्रैक करने के लिए पुनरावृति में ऑपरेंड सूची के अंत में एक नया ऑपरेंड जोड़ा जाता है। इस प्रकार, यह निर्माण ऑपरेंड की संख्या के बराबर होता है और साथ ही उन ऑपरेंडों की संख्या भी होती है जिनके लिए ध्वज NPY_ITER_USE_MASKNA निर्दिष्ट किया गया था।

int NpyIter_GetFirstMaskNAOp(NpyIter* iter)

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

सरणी में पहले NA मास्क ऑपरैंड के सूचकांक को लौटाता है। यह मान कंस्ट्रक्टर में पारित ऑपरेंड की संख्या के बराबर है।

npy_intp* NpyIter_GetAxisStrideArray(NpyIter* iter, int axis)

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

इसका उपयोग तब किया जा सकता है जब आप कुछ फैशन में ऑपरेंड कुल्हाड़ियों से मेल खाना चाहते हैं, फिर NpyIter_RemoveAxis मैन्युअल रूप से उनके प्रसंस्करण को संभालने के लिए उन्हें हटा दें । कुल्हाड़ियों को हटाने से पहले इस फ़ंक्शन को कॉल करके, आप मैनुअल प्रोसेसिंग के लिए स्ट्राइड प्राप्त कर सकते हैं।

रिटर्न NULL त्रुटि पर।

int NpyIter_GetShape(NpyIter* iter, npy_intp* outshape)

में पुनरावृत्ति का प्रसारण आकार देता है outshape । इसे केवल एक पुनरावृत्त पर बुलाया जा सकता है जो मल्टी-इंडेक्स पर नज़र रख रहा है।

लौटाता है NPY_SUCCEED या NPY_FAIL

PyArray_Descr** NpyIter_GetDescrArray(NpyIter* iter)

यह nop ऑब्जेक्ट्स को पुनरावृत्त होने के लिए डेटा प्रकार Descrs के लिए एक पॉइंटर वापस देता है । परिणाम इंगित करता है iter , इसलिए कॉल करने वाले को Descrs का कोई संदर्भ नहीं मिलता है।

इस सूचक को पुनरावृत्ति लूप से पहले कैश किया जा सकता है, कॉलिंग iternext इसे नहीं बदलेगी।

PyObject** NpyIter_GetOperandArray(NpyIter* iter)

यह nop ऑपरेटर्स PyObjects को एक पॉइंटर वापस देता है जो इसकी पुनरावृत्ति कर रहा है। परिणाम में इंगित करता है iter , इसलिए कॉलर PyObjects के लिए कोई संदर्भ प्राप्त नहीं करता है।

npy_int8* NpyIter_GetMaskNAIndexArray(NpyIter* iter)

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

यह nop सूचकांकों को एक सूचक देता है जो निर्माण संचालकों NPY_ITER_USE_MASKNA को उनके संबंधित NA नकाब संचालकों को चिह्नित करता है और इसके विपरीत। उन ऑपरेंड्स के लिए, जिन्हें ध्वजांकित नहीं किया गया था NPY_ITER_USE_MASKNA , इस सरणी में नकारात्मक मान हैं।

PyObject* NpyIter_GetIterView(NpyIter* iter, npy_intp i)

यह एक नए ndarray दृश्य का संदर्भ देता है, जो कि सरणी में i-th ऑब्जेक्ट में एक दृश्य है NpyIter_GetOperandArray , जिसके आयाम और तार आंतरिक अनुकूलित पुनरावृत्ति पैटर्न से मेल खाते हैं। इस दृश्य का C- क्रम पुनरावृत्ति पुनरावृत्ति क्रम क्रम के बराबर है।

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

void NpyIter_GetReadFlags(NpyIter* iter, char* outreadflags)

nop झंडे भरते हैं । outreadflags[i] 1 से सेट अगर op[i] से पढ़ा जा सकता है, और 0 नहीं तो।

void NpyIter_GetWriteFlags(NpyIter* iter, char* outwriteflags)

nop झंडे भरते हैं । outwriteflags[i] 1 के लिए सेट अगर op[i] लिखा जा सकता है, और 0 को अगर नहीं।

int NpyIter_CreateCompatibleStrides(NpyIter* iter, npy_intp itemsize, npy_intp* outstrides)

स्ट्राइड्स के एक सेट का निर्माण करता है जो NPY_ITER_ALLOCATE फ्लैग का उपयोग करके बनाए गए आउटपुट सरणी के स्ट्रेट्स के समान होता है, जहां NULL को op_axes के लिए पास किया गया था। यह आकस्मिक रूप से पैक किए गए डेटा के लिए है, लेकिन सी या फोरट्रान क्रम में जरूरी नहीं है। यह कंस्ट्रक्टर में पारित किए गए ध्वज के साथ NpyIter_GetShape और NpyIter_GetNDim साथ में इस्तेमाल किया जाना चाहिए NPY_ITER_MULTI_INDEX

इस फ़ंक्शन के लिए एक उपयोग का मामला पुनरावृति के आकार और लेआउट से मेल खाता है और एक या अधिक आयामों से निपटना है। उदाहरण के लिए, संख्यात्मक ढाल के लिए इनपुट मूल्य के लिए वेक्टर प्रति उत्पन्न करने के लिए, आप ndim में पास होते हैं * आइटम के लिए आइटमाइज़ करते हैं, फिर आकार ndim के साथ अंत में एक और आयाम जोड़ते हैं और आइटम को स्ट्राइड करते हैं। हेसियन मैट्रिक्स करने के लिए, आप एक ही काम करते हैं लेकिन दो आयाम जोड़ते हैं, या समरूपता का लाभ उठाते हैं और इसे एक विशेष एन्कोडिंग के साथ 1 आयाम में पैक करते हैं।

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

यदि इस विधि के साथ एक सरणी बनाई गई है, तो बस प्रत्येक पुनरावृत्ति के लिए 'आइटमाइज़' जोड़ने से पुनरावृत्त मिलान करने वाले नए सरणी को पार कर जाएगा।

लौटाता है NPY_SUCCEED या NPY_FAIL

npy_bool NpyIter_IsFirstVisit(NpyIter* iter, int iop)

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

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

यह फ़ंक्शन केवल EXTERNAL_LOOP मोड में उपयोग किए जाने का इरादा रखता है, और उस मोड के सक्षम नहीं होने पर कुछ गलत उत्तर देगा।

यदि यह फ़ंक्शन सही हो जाता है, तो कॉलर को ऑपरेंड के आंतरिक लूप को भी जांचना चाहिए, क्योंकि यदि वह स्ट्राइड 0 है, तो पहली बार बाहरी अंतर के पहले तत्व का दौरा किया जा रहा है।

चेतावनी : प्रदर्शन कारणों से, 'iop' सीमा-जाँच नहीं है, यह पुष्टि नहीं की गई है कि 'iop' वास्तव में एक कमी ऑपरेंड है, और यह पुष्टि नहीं की गई है कि EXTERNAL_LOOP मोड सक्षम है। ये चेक कॉल करने वाले की जिम्मेदारी है, और किसी भी आंतरिक छोरों के बाहर किया जाना चाहिए।

Iteration के लिए कार्य

NpyIter_IterNextFunc* NpyIter_GetIterNext(NpyIter* iter, char** errmsg)

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

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

विशिष्ट लूपिंग निर्माण इस प्रकार है।

NpyIter_IterNextFunc *iternext = NpyIter_GetIterNext(iter, NULL);
char** dataptr = NpyIter_GetDataPtrArray(iter);

do {
    /* use the addresses dataptr[0], ... dataptr[nop-1] */
} while(iternext(iter));

जब NPY_ITER_EXTERNAL_LOOP निर्दिष्ट किया जाता है, तो विशिष्ट आंतरिक लूप निर्माण निम्नानुसार होता है।

NpyIter_IterNextFunc *iternext = NpyIter_GetIterNext(iter, NULL);
char** dataptr = NpyIter_GetDataPtrArray(iter);
npy_intp* stride = NpyIter_GetInnerStrideArray(iter);
npy_intp* size_ptr = NpyIter_GetInnerLoopSizePtr(iter), size;
npy_intp iop, nop = NpyIter_GetNOp(iter);

do {
    size = *size_ptr;
    while (size--) {
        /* use the addresses dataptr[0], ... dataptr[nop-1] */
        for (iop = 0; iop < nop; ++iop) {
            dataptr[iop] += stride[iop];
        }
    }
} while (iternext());

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

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

/* The constructor should have buffersize passed as this value */
#define FIXED_BUFFER_SIZE 1024

NpyIter_IterNextFunc *iternext = NpyIter_GetIterNext(iter, NULL);
char **dataptr = NpyIter_GetDataPtrArray(iter);
npy_intp *stride = NpyIter_GetInnerStrideArray(iter);
npy_intp *size_ptr = NpyIter_GetInnerLoopSizePtr(iter), size;
npy_intp i, iop, nop = NpyIter_GetNOp(iter);

/* One loop with a fixed inner size */
size = *size_ptr;
while (size == FIXED_BUFFER_SIZE) {
    /*
     * This loop could be manually unrolled by a factor
     * which divides into FIXED_BUFFER_SIZE
     */
    for (i = 0; i < FIXED_BUFFER_SIZE; ++i) {
        /* use the addresses dataptr[0], ... dataptr[nop-1] */
        for (iop = 0; iop < nop; ++iop) {
            dataptr[iop] += stride[iop];
        }
    }
    iternext();
    size = *size_ptr;
}

/* Finish-up loop with variable inner size */
if (size > 0) do {
    size = *size_ptr;
    while (size--) {
        /* use the addresses dataptr[0], ... dataptr[nop-1] */
        for (iop = 0; iop < nop; ++iop) {
            dataptr[iop] += stride[iop];
        }
    }
} while (iternext());
NpyIter_GetMultiIndexFunc *NpyIter_GetGetMultiIndex(NpyIter* iter, char** errmsg)

इट्रेटर के वर्तमान मल्टी-इंडेक्स प्राप्त करने के लिए एक फ़ंक्शन पॉइंटर लौटाता है। यदि पूरा मल्टी-इंडेक्स ट्रैक नहीं कर रहा है तो NULL लौटाता है। यह अनुशंसा की जाती है कि इस फ़ंक्शन पॉइंटर को पुनरावृति लूप से पहले एक स्थानीय चर में कैश किया जाए।

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

char** NpyIter_GetDataPtrArray(NpyIter* iter)

यह nop डेटा पॉइंटर्स को एक पॉइंटर वापस देता है । यदि NPY_ITER_EXTERNAL_LOOP निर्दिष्ट नहीं किया गया था, तो प्रत्येक डेटा पॉइंटर इटरेटर के वर्तमान डेटा आइटम को इंगित करता है। यदि कोई आंतरिक पुनरावृत्ति निर्दिष्ट नहीं किया गया था, तो यह आंतरिक लूप के पहले डेटा आइटम को इंगित करता है।

इस सूचक को पुनरावृत्ति लूप से पहले कैश किया जा सकता है, कॉलिंग iternext इसे नहीं बदलेगी। पायथन जीआईएल को पकड़े बिना इस समारोह को सुरक्षित रूप से बुलाया जा सकता है।

char** NpyIter_GetInitialDataPtrArray(NpyIter* iter)

डेटा इंडेक्स की सरणी को सीधे एरेंस इंडेक्स 0 के अनुरूप एरेज़ (बफ़र्स में कभी नहीं) में रखा जाता है।

ये पॉइंटर्स द्वारा स्वीकार किए गए पॉइंटर्स से अलग हैं NpyIter_ResetBasePointers , क्योंकि कुछ अक्षों के साथ दिशा उलट गई हो सकती है।

पायथन जीआईएल को पकड़े बिना इस समारोह को सुरक्षित रूप से बुलाया जा सकता है।

npy_intp* NpyIter_GetIndexPtr(NpyIter* iter)

यह इंडेक्स को ट्रैक किए जा रहे पॉइंटर को वापस देता है, या यदि कोई इंडेक्स ट्रैक नहीं किया जा रहा है तो NULL। यह केवल उपयोग करने योग्य है यदि झंडे में से एक NPY_ITER_C_INDEX या NPY_ITER_F_INDEX निर्माण के दौरान निर्दिष्ट किया गया था।

जब ध्वज NPY_ITER_EXTERNAL_LOOP का उपयोग किया जाता है, तो कोड को आंतरिक लूप करने के लिए मापदंडों को जानने की आवश्यकता होती है। ये फ़ंक्शन उस जानकारी को प्रदान करते हैं।

npy_intp* NpyIter_GetInnerStrideArray(NpyIter* iter)

आवृत्तियों की एक सरणी के लिए एक सूचक लौटाता है nop , प्रत्येक पुनरावृत्त वस्तु के लिए, आंतरिक लूप द्वारा उपयोग किया जाता है।

इस सूचक को पुनरावृत्ति लूप से पहले कैश किया जा सकता है, कॉलिंग iternext इसे नहीं बदलेगी। पायथन जीआईएल को पकड़े बिना इस समारोह को सुरक्षित रूप से बुलाया जा सकता है।

चेतावनी : जबकि पॉइंटर को कैश किया जा सकता है, अगर इट्रीटर को बफर किया जाता है, तो इसके मान बदल सकते हैं।

npy_intp* NpyIter_GetInnerLoopSizePtr(NpyIter* iter)

आंतरिक लूप निष्पादित करना चाहिए पुनरावृत्तियों की संख्या के लिए एक सूचक लौटाता है।

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

void NpyIter_GetInnerFixedStrideArray(NpyIter* iter, npy_intp* out_strides)

एक ऐसा स्ट्रैड हो जाता है जो तय हो जाता है, या पूरे पुनरावृत्ति के दौरान नहीं बदलेगा। जो परिवर्तन हो सकते हैं, उनके लिए NPY_MAX_INTP मान को स्ट्राइड में रखा गया है।

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

पायथन जीआईएल को पकड़े बिना इस समारोह को सुरक्षित रूप से बुलाया जा सकता है।

पिछले NumPy Iterators से परिवर्तित

पुराने पुनरावृत्ति API में PyArrayIter_Check, PyArray_Iter * और PyArray_ITER_ * जैसे कार्य शामिल हैं। मल्टी-इटरेटर सरणी में PyArray_MultiIter *, PyArray_Broadcast, और PyArray_RemoveSmallest शामिल हैं। नया पुनरावृत् त डिजाइन इस सभी कार्यक्षमता को एक एकल ऑब्जेक्ट और संबद्ध एपीआई के साथ बदल देता है। नए एपीआई का एक लक्ष्य यह है कि मौजूदा itter के सभी उपयोग महत्वपूर्ण प्रयास के बिना नए itter के साथ बदली जा सकें। 1.6 में, इसका प्रमुख अपवाद पड़ोस का पुनरावृत्त है, जिसमें इस पुनरावृत्ति में संगत विशेषताएं नहीं हैं।

यहां एक रूपांतरण तालिका दी गई है, जिसके लिए नए पुनरावृत्तिकर्ता के साथ कार्य करना है:

Iterator कार्य
PyArray_IterNew NpyIter_New
PyArray_IterAllButAxis NpyIter_New + axes पैरामीटर या Iterator ध्वज NPY_ITER_EXTERNAL_LOOP
PyArray_BroadcastToShape समर्थित नहीं है (इसके बजाय कई ऑपरेंड के लिए समर्थन का उपयोग करें)
PyArrayIter_Check इसे पायथन एक्सपोजर में जोड़ना होगा
PyArray_ITER_RESET NpyIter_Reset
PyArray_ITER_NEXT से फ़ंक्शन सूचक NpyIter_GetIterNext
PyArray_ITER_DATA NpyIter_GetDataPtrArray
PyArray_ITER_GOTO NpyIter_GotoMultiIndex
PyArray_ITER_GOTO1D NpyIter_GotoIndex या NpyIter_GotoIterIndex
PyArray_ITER_NOTDONE iternext फ़ंक्शन पॉइंटर का मान लौटाएं
मल्टी-इटरेटर फ़ंक्शंस
PyArray_MultiIterNew NpyIter_MultiNew
PyArray_MultiIter_RESET NpyIter_Reset
PyArray_MultiIter_NEXT से फ़ंक्शन सूचक NpyIter_GetIterNext
PyArray_MultiIter_DATA NpyIter_GetDataPtrArray
PyArray_MultiIter_NEXTi समर्थित नहीं है (हमेशा लॉक-स्टेप पुनरावृति)
PyArray_MultiIter_GOTO NpyIter_GotoMultiIndex
PyArray_MultiIter_GOTO1D NpyIter_GotoIndex या NpyIter_GotoIterIndex
PyArray_MultiIter_NOTDONE iternext फ़ंक्शन पॉइंटर का मान लौटाएं
PyArray_Broadcast ने संभाला NpyIter_MultiNew
PyArray_RemoveSmallest इटरेटर ध्वज NPY_ITER_EXTERNAL_LOOP
अन्य कार्य
PyArray_ConvertToCommonType इटरेटर ध्वज NPY_ITER_COMMON_DTYPE

Original text