diff options
| -rw-r--r-- | doc/source/reference/c-api.iterator.rst | 48 | ||||
| -rw-r--r-- | numpy/add_newdocs.py | 2 | ||||
| -rw-r--r-- | numpy/core/code_generators/numpy_api.py | 2 | ||||
| -rw-r--r-- | numpy/core/src/multiarray/nditer.c.src | 1432 | ||||
| -rw-r--r-- | numpy/core/src/multiarray/nditer_pywrap.c | 322 | ||||
| -rw-r--r-- | numpy/core/src/umath/ufunc_object.c | 92 |
6 files changed, 949 insertions, 949 deletions
diff --git a/doc/source/reference/c-api.iterator.rst b/doc/source/reference/c-api.iterator.rst index 421678648..9e443f2cb 100644 --- a/doc/source/reference/c-api.iterator.rst +++ b/doc/source/reference/c-api.iterator.rst @@ -323,9 +323,9 @@ Construction and Destruction dtype); Py_DECREF(dtype); -.. cfunction:: NpyIter* NpyIter_MultiNew(npy_intp niter, PyArrayObject** op, npy_uint32 flags, NPY_ORDER order, NPY_CASTING casting, npy_uint32* op_flags, PyArray_Descr** op_dtypes) +.. cfunction:: 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) - Creates an iterator for broadcasting the ``niter`` array objects provided + Creates an iterator for broadcasting the ``nop`` array objects provided in ``op``, using regular NumPy broadcasting rules. Any of the :ctype:`NPY_ORDER` enum values may be passed to ``order``. For @@ -494,7 +494,7 @@ Construction and Destruction Then, call :cfunc:`NpyIter_Reset` to allocate and fill the buffers with their initial values. - Flags that may be passed in ``op_flags[i]``, where ``0 <= i < niter``: + Flags that may be passed in ``op_flags[i]``, where ``0 <= i < nop``: .. cvar:: NPY_ITER_READWRITE .. cvar:: NPY_ITER_READONLY @@ -579,7 +579,7 @@ Construction and Destruction Ensures that the input or output matches the iteration dimensions exactly. -.. cfunction:: NpyIter* NpyIter_AdvancedNew(npy_intp niter, 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) +.. cfunction:: 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) Extends :cfunc:`NpyIter_MultiNew` with several advanced options providing more control over broadcasting and buffering. @@ -592,7 +592,7 @@ Construction and Destruction If it is provided, ``op_axes`` and/or ``itershape`` must also be provided. The ``op_axes`` parameter let you control in detail how the axes of the operand arrays get matched together and iterated. - In ``op_axes``, you must provide an array of ``niter`` pointers + In ``op_axes``, you must provide an array of ``nop`` pointers to ``oa_ndim``-sized arrays of type ``npy_intp``. If an entry in ``op_axes`` is NULL, normal broadcasting rules will apply. In ``op_axes[j][i]`` is stored either a valid axis of ``op[j]``, or @@ -906,7 +906,7 @@ Construction and Destruction may be smaller than the number of dimensions in the original objects. -.. cfunction:: int NpyIter_GetNIter(NpyIter* iter) +.. cfunction:: int NpyIter_GetNOp(NpyIter* iter) Returns the number of operands in the iterator. @@ -933,7 +933,7 @@ Construction and Destruction .. cfunction:: PyArray_Descr** NpyIter_GetDescrArray(NpyIter* iter) - This gives back a pointer to the ``niter`` data type Descrs for + This gives back a pointer to the ``nop`` data type Descrs for the objects being iterated. The result points into ``iter``, so the caller does not gain any references to the Descrs. @@ -942,7 +942,7 @@ Construction and Destruction .. cfunction:: PyObject** NpyIter_GetOperandArray(NpyIter* iter) - This gives back a pointer to the ``niter`` operand PyObjects + This gives back a pointer to the ``nop`` operand PyObjects that are being iterated. The result points into ``iter``, so the caller does not gain any references to the PyObjects. @@ -961,12 +961,12 @@ Construction and Destruction .. cfunction:: void NpyIter_GetReadFlags(NpyIter* iter, char* outreadflags) - Fills ``niter`` flags. Sets ``outreadflags[i]`` to 1 if + Fills ``nop`` flags. Sets ``outreadflags[i]`` to 1 if ``op[i]`` can be read from, and to 0 if not. .. cfunction:: void NpyIter_GetWriteFlags(NpyIter* iter, char* outwriteflags) - Fills ``niter`` flags. Sets ``outwriteflags[i]`` to 1 if + Fills ``nop`` flags. Sets ``outwriteflags[i]`` to 1 if ``op[i]`` can be written to, and to 0 if not. .. cfunction:: int NpyIter_CreateCompatibleStrides(NpyIter* iter, npy_intp itemsize, npy_intp* outstrides) @@ -1021,7 +1021,7 @@ Functions For Iteration char** dataptr = NpyIter_GetDataPtrArray(iter); do { - /* use the addresses dataptr[0], ... dataptr[niter-1] */ + /* use the addresses dataptr[0], ... dataptr[nop-1] */ } while(iternext(iter)); When :cdata:`NPY_ITER_EXTERNAL_LOOP` is specified, the typical @@ -1033,14 +1033,14 @@ Functions For Iteration char** dataptr = NpyIter_GetDataPtrArray(iter); npy_intp* stride = NpyIter_GetInnerStrideArray(iter); npy_intp* size_ptr = NpyIter_GetInnerLoopSizePtr(iter), size; - npy_intp iiter, niter = NpyIter_GetNIter(iter); + npy_intp iop, nop = NpyIter_GetNOp(iter); do { size = *size_ptr; while (size--) { - /* use the addresses dataptr[0], ... dataptr[niter-1] */ - for (iiter = 0; iiter < niter; ++iiter) { - dataptr[iiter] += stride[iiter]; + /* use the addresses dataptr[0], ... dataptr[nop-1] */ + for (iop = 0; iop < nop; ++iop) { + dataptr[iop] += stride[iop]; } } } while (iternext()); @@ -1067,7 +1067,7 @@ Functions For Iteration char **dataptr = NpyIter_GetDataPtrArray(iter); npy_intp *stride = NpyIter_GetInnerStrideArray(iter); npy_intp *size_ptr = NpyIter_GetInnerLoopSizePtr(iter), size; - npy_intp i, iiter, niter = NpyIter_GetNIter(iter); + npy_intp i, iop, nop = NpyIter_GetNOp(iter); /* One loop with a fixed inner size */ size = *size_ptr; @@ -1077,9 +1077,9 @@ Functions For Iteration * which divides into FIXED_BUFFER_SIZE */ for (i = 0; i < FIXED_BUFFER_SIZE; ++i) { - /* use the addresses dataptr[0], ... dataptr[niter-1] */ - for (iiter = 0; iiter < niter; ++iiter) { - dataptr[iiter] += stride[iiter]; + /* use the addresses dataptr[0], ... dataptr[nop-1] */ + for (iop = 0; iop < nop; ++iop) { + dataptr[iop] += stride[iop]; } } iternext(); @@ -1090,9 +1090,9 @@ Functions For Iteration if (size > 0) do { size = *size_ptr; while (size--) { - /* use the addresses dataptr[0], ... dataptr[niter-1] */ - for (iiter = 0; iiter < niter; ++iiter) { - dataptr[iiter] += stride[iiter]; + /* use the addresses dataptr[0], ... dataptr[nop-1] */ + for (iop = 0; iop < nop; ++iop) { + dataptr[iop] += stride[iop]; } } } while (iternext()); @@ -1113,7 +1113,7 @@ Functions For Iteration .. cfunction:: char** NpyIter_GetDataPtrArray(NpyIter* iter) - This gives back a pointer to the ``niter`` data pointers. If + This gives back a pointer to the ``nop`` data pointers. If :cdata:`NPY_ITER_EXTERNAL_LOOP` was not specified, each data pointer points to the current data item of the iterator. If no inner iteration was specified, it points to the first data @@ -1147,7 +1147,7 @@ functions provide that information. .. cfunction:: npy_intp* NpyIter_GetInnerStrideArray(NpyIter* iter) - Returns a pointer to an array of the ``niter`` strides, + Returns a pointer to an array of the ``nop`` strides, one for each iterated object, to be used by the inner loop. This pointer may be cached before the iteration loop, calling diff --git a/numpy/add_newdocs.py b/numpy/add_newdocs.py index 414f6f7d1..a7e9ba229 100644 --- a/numpy/add_newdocs.py +++ b/numpy/add_newdocs.py @@ -266,7 +266,7 @@ add_newdoc('numpy.core', 'nditer', accessed and `has_multi_index` is False. ndim : int The iterator's dimension. - niter : int + nop : int The number of iterator operands. operands : tuple of operand(s) The array(s) to be iterated over. diff --git a/numpy/core/code_generators/numpy_api.py b/numpy/core/code_generators/numpy_api.py index b314f9f84..db2c368dd 100644 --- a/numpy/core/code_generators/numpy_api.py +++ b/numpy/core/code_generators/numpy_api.py @@ -271,7 +271,7 @@ multiarray_funcs_api = { 'NpyIter_ResetBasePointers': 235, 'NpyIter_ResetToIterIndexRange': 236, 'NpyIter_GetNDim': 237, - 'NpyIter_GetNIter': 238, + 'NpyIter_GetNOp': 238, 'NpyIter_GetIterNext': 239, 'NpyIter_GetIterSize': 240, 'NpyIter_GetIterIndexRange': 241, diff --git a/numpy/core/src/multiarray/nditer.c.src b/numpy/core/src/multiarray/nditer.c.src index e12767fbb..ab7cd4ef2 100644 --- a/numpy/core/src/multiarray/nditer.c.src +++ b/numpy/core/src/multiarray/nditer.c.src @@ -115,7 +115,7 @@ /* * The data layout of the iterator is fully specified by - * a triple (itflags, ndim, niter). These three variables + * a triple (itflags, ndim, nop). These three variables * are expected to exist in all functions calling these macros, * either as true variables initialized to the correct values * from the iterator, or as constants in the case of specialized @@ -125,7 +125,7 @@ struct NpyIter_InternalOnly { /* Initial fixed position data */ npy_uint32 itflags; - npy_uint16 ndim, niter; + npy_uint16 ndim, nop; npy_intp itersize, iterstart, iterend; /* iterindex is only used if RANGED or BUFFERED is set */ npy_intp iterindex; @@ -137,53 +137,53 @@ typedef struct NpyIter_AD NpyIter_AxisData; typedef struct NpyIter_BD NpyIter_BufferData; /* Byte sizes of the iterator members */ -#define NIT_PERM_SIZEOF(itflags, ndim, niter) \ +#define NIT_PERM_SIZEOF(itflags, ndim, nop) \ NPY_INTP_ALIGNED(NPY_MAXDIMS) -#define NIT_DTYPES_SIZEOF(itflags, ndim, niter) \ - ((NPY_SIZEOF_INTP)*(niter)) -#define NIT_RESETDATAPTR_SIZEOF(itflags, ndim, niter) \ - ((NPY_SIZEOF_INTP)*(niter+1)) -#define NIT_BASEOFFSETS_SIZEOF(itflags, ndim, niter) \ - ((NPY_SIZEOF_INTP)*(niter+1)) -#define NIT_OPERANDS_SIZEOF(itflags, ndim, niter) \ - ((NPY_SIZEOF_INTP)*(niter)) -#define NIT_OPITFLAGS_SIZEOF(itflags, ndim, niter) \ - (NPY_INTP_ALIGNED(niter)) -#define NIT_BUFFERDATA_SIZEOF(itflags, ndim, niter) \ - ((itflags&NPY_ITFLAG_BUFFER) ? ((NPY_SIZEOF_INTP)*(6 + 9*niter)) : 0) +#define NIT_DTYPES_SIZEOF(itflags, ndim, nop) \ + ((NPY_SIZEOF_INTP)*(nop)) +#define NIT_RESETDATAPTR_SIZEOF(itflags, ndim, nop) \ + ((NPY_SIZEOF_INTP)*(nop+1)) +#define NIT_BASEOFFSETS_SIZEOF(itflags, ndim, nop) \ + ((NPY_SIZEOF_INTP)*(nop+1)) +#define NIT_OPERANDS_SIZEOF(itflags, ndim, nop) \ + ((NPY_SIZEOF_INTP)*(nop)) +#define NIT_OPITFLAGS_SIZEOF(itflags, ndim, nop) \ + (NPY_INTP_ALIGNED(nop)) +#define NIT_BUFFERDATA_SIZEOF(itflags, ndim, nop) \ + ((itflags&NPY_ITFLAG_BUFFER) ? ((NPY_SIZEOF_INTP)*(6 + 9*nop)) : 0) /* Byte offsets of the iterator members starting from iter->iter_flexdata */ #define NIT_PERM_OFFSET() \ (0) -#define NIT_DTYPES_OFFSET(itflags, ndim, niter) \ +#define NIT_DTYPES_OFFSET(itflags, ndim, nop) \ (NIT_PERM_OFFSET() + \ - NIT_PERM_SIZEOF(itflags, ndim, niter)) -#define NIT_RESETDATAPTR_OFFSET(itflags, ndim, niter) \ - (NIT_DTYPES_OFFSET(itflags, ndim, niter) + \ - NIT_DTYPES_SIZEOF(itflags, ndim, niter)) -#define NIT_BASEOFFSETS_OFFSET(itflags, ndim, niter) \ - (NIT_RESETDATAPTR_OFFSET(itflags, ndim, niter) + \ - NIT_RESETDATAPTR_SIZEOF(itflags, ndim, niter)) -#define NIT_OPERANDS_OFFSET(itflags, ndim, niter) \ - (NIT_BASEOFFSETS_OFFSET(itflags, ndim, niter) + \ - NIT_BASEOFFSETS_SIZEOF(itflags, ndim, niter)) -#define NIT_OPITFLAGS_OFFSET(itflags, ndim, niter) \ - (NIT_OPERANDS_OFFSET(itflags, ndim, niter) + \ - NIT_OPERANDS_SIZEOF(itflags, ndim, niter)) -#define NIT_BUFFERDATA_OFFSET(itflags, ndim, niter) \ - (NIT_OPITFLAGS_OFFSET(itflags, ndim, niter) + \ - NIT_OPITFLAGS_SIZEOF(itflags, ndim, niter)) -#define NIT_AXISDATA_OFFSET(itflags, ndim, niter) \ - (NIT_BUFFERDATA_OFFSET(itflags, ndim, niter) + \ - NIT_BUFFERDATA_SIZEOF(itflags, ndim, niter)) + NIT_PERM_SIZEOF(itflags, ndim, nop)) +#define NIT_RESETDATAPTR_OFFSET(itflags, ndim, nop) \ + (NIT_DTYPES_OFFSET(itflags, ndim, nop) + \ + NIT_DTYPES_SIZEOF(itflags, ndim, nop)) +#define NIT_BASEOFFSETS_OFFSET(itflags, ndim, nop) \ + (NIT_RESETDATAPTR_OFFSET(itflags, ndim, nop) + \ + NIT_RESETDATAPTR_SIZEOF(itflags, ndim, nop)) +#define NIT_OPERANDS_OFFSET(itflags, ndim, nop) \ + (NIT_BASEOFFSETS_OFFSET(itflags, ndim, nop) + \ + NIT_BASEOFFSETS_SIZEOF(itflags, ndim, nop)) +#define NIT_OPITFLAGS_OFFSET(itflags, ndim, nop) \ + (NIT_OPERANDS_OFFSET(itflags, ndim, nop) + \ + NIT_OPERANDS_SIZEOF(itflags, ndim, nop)) +#define NIT_BUFFERDATA_OFFSET(itflags, ndim, nop) \ + (NIT_OPITFLAGS_OFFSET(itflags, ndim, nop) + \ + NIT_OPITFLAGS_SIZEOF(itflags, ndim, nop)) +#define NIT_AXISDATA_OFFSET(itflags, ndim, nop) \ + (NIT_BUFFERDATA_OFFSET(itflags, ndim, nop) + \ + NIT_BUFFERDATA_SIZEOF(itflags, ndim, nop)) /* Internal-only ITERATOR DATA MEMBER ACCESS */ #define NIT_ITFLAGS(iter) \ ((iter)->itflags) #define NIT_NDIM(iter) \ ((iter)->ndim) -#define NIT_NITER(iter) \ - ((iter)->niter) +#define NIT_NOP(iter) \ + ((iter)->nop) #define NIT_ITERSIZE(iter) \ (iter->itersize) #define NIT_ITERSTART(iter) \ @@ -195,19 +195,19 @@ typedef struct NpyIter_BD NpyIter_BufferData; #define NIT_PERM(iter) ((char*)( \ &(iter)->iter_flexdata + NIT_PERM_OFFSET())) #define NIT_DTYPES(iter) ((PyArray_Descr **)( \ - &(iter)->iter_flexdata + NIT_DTYPES_OFFSET(itflags, ndim, niter))) + &(iter)->iter_flexdata + NIT_DTYPES_OFFSET(itflags, ndim, nop))) #define NIT_RESETDATAPTR(iter) ((char **)( \ - &(iter)->iter_flexdata + NIT_RESETDATAPTR_OFFSET(itflags, ndim, niter))) + &(iter)->iter_flexdata + NIT_RESETDATAPTR_OFFSET(itflags, ndim, nop))) #define NIT_BASEOFFSETS(iter) ((npy_intp *)( \ - &(iter)->iter_flexdata + NIT_BASEOFFSETS_OFFSET(itflags, ndim, niter))) + &(iter)->iter_flexdata + NIT_BASEOFFSETS_OFFSET(itflags, ndim, nop))) #define NIT_OPERANDS(iter) ((PyArrayObject **)( \ - &(iter)->iter_flexdata + NIT_OPERANDS_OFFSET(itflags, ndim, niter))) + &(iter)->iter_flexdata + NIT_OPERANDS_OFFSET(itflags, ndim, nop))) #define NIT_OPITFLAGS(iter) ( \ - &(iter)->iter_flexdata + NIT_OPITFLAGS_OFFSET(itflags, ndim, niter)) + &(iter)->iter_flexdata + NIT_OPITFLAGS_OFFSET(itflags, ndim, nop)) #define NIT_BUFFERDATA(iter) ((NpyIter_BufferData *)( \ - &(iter)->iter_flexdata + NIT_BUFFERDATA_OFFSET(itflags, ndim, niter))) + &(iter)->iter_flexdata + NIT_BUFFERDATA_OFFSET(itflags, ndim, nop))) #define NIT_AXISDATA(iter) ((NpyIter_AxisData *)( \ - &(iter)->iter_flexdata + NIT_AXISDATA_OFFSET(itflags, ndim, niter))) + &(iter)->iter_flexdata + NIT_AXISDATA_OFFSET(itflags, ndim, nop))) /* Internal-only BUFFERDATA MEMBER ACCESS */ struct NpyIter_BD { @@ -224,21 +224,21 @@ struct NpyIter_BD { #define NBF_STRIDES(bufferdata) ( \ &(bufferdata)->bd_flexdata + 0) #define NBF_PTRS(bufferdata) ((char **) \ - (&(bufferdata)->bd_flexdata + 1*(niter))) + (&(bufferdata)->bd_flexdata + 1*(nop))) #define NBF_REDUCE_OUTERSTRIDES(bufferdata) ( \ - (&(bufferdata)->bd_flexdata + 2*(niter))) + (&(bufferdata)->bd_flexdata + 2*(nop))) #define NBF_REDUCE_OUTERPTRS(bufferdata) ((char **) \ - (&(bufferdata)->bd_flexdata + 3*(niter))) + (&(bufferdata)->bd_flexdata + 3*(nop))) #define NBF_READTRANSFERFN(bufferdata) ((PyArray_StridedTransferFn **) \ - (&(bufferdata)->bd_flexdata + 4*(niter))) + (&(bufferdata)->bd_flexdata + 4*(nop))) #define NBF_READTRANSFERDATA(bufferdata) ((void **) \ - (&(bufferdata)->bd_flexdata + 5*(niter))) + (&(bufferdata)->bd_flexdata + 5*(nop))) #define NBF_WRITETRANSFERFN(bufferdata) ((PyArray_StridedTransferFn **) \ - (&(bufferdata)->bd_flexdata + 6*(niter))) + (&(bufferdata)->bd_flexdata + 6*(nop))) #define NBF_WRITETRANSFERDATA(bufferdata) ((void **) \ - (&(bufferdata)->bd_flexdata + 7*(niter))) + (&(bufferdata)->bd_flexdata + 7*(nop))) #define NBF_BUFFERS(bufferdata) ((char **) \ - (&(bufferdata)->bd_flexdata + 8*(niter))) + (&(bufferdata)->bd_flexdata + 8*(nop))) /* Internal-only AXISDATA MEMBER ACCESS. */ struct NpyIter_AD { @@ -250,25 +250,25 @@ struct NpyIter_AD { #define NAD_STRIDES(axisdata) ( \ &(axisdata)->ad_flexdata + 0) #define NAD_PTRS(axisdata) ((char **) \ - &(axisdata)->ad_flexdata + 1*(niter+1)) + &(axisdata)->ad_flexdata + 1*(nop+1)) #define NAD_NSTRIDES() \ - ((niter) + ((itflags&NPY_ITFLAG_HASINDEX) ? 1 : 0)) + ((nop) + ((itflags&NPY_ITFLAG_HASINDEX) ? 1 : 0)) /* Size of one AXISDATA struct within the iterator */ -#define NIT_AXISDATA_SIZEOF(itflags, ndim, niter) (( \ +#define NIT_AXISDATA_SIZEOF(itflags, ndim, nop) (( \ /* intp shape */ \ 1 + \ /* intp index */ \ 1 + \ - /* intp stride[niter+1] AND char* ptr[niter+1] */ \ - 2*((niter)+1) \ + /* intp stride[nop+1] AND char* ptr[nop+1] */ \ + 2*((nop)+1) \ )*NPY_SIZEOF_INTP ) /* * Macro to advance an AXISDATA pointer by a specified count. * Requires that sizeof_axisdata be previously initialized - * to NIT_AXISDATA_SIZEOF(itflags, ndim, niter). + * to NIT_AXISDATA_SIZEOF(itflags, ndim, nop). */ #define NIT_INDEX_AXISDATA(axisdata, index) ((NpyIter_AxisData *) \ (((char *)(axisdata)) + (index)*sizeof_axisdata)) @@ -276,19 +276,19 @@ struct NpyIter_AD { axisdata = NIT_INDEX_AXISDATA(axisdata, count) /* Size of the whole iterator */ -#define NIT_SIZEOF_ITERATOR(itflags, ndim, niter) ( \ +#define NIT_SIZEOF_ITERATOR(itflags, ndim, nop) ( \ sizeof(struct NpyIter_InternalOnly) + \ - NIT_AXISDATA_OFFSET(itflags, ndim, niter) + \ - NIT_AXISDATA_SIZEOF(itflags, ndim, niter)*(ndim)) + NIT_AXISDATA_OFFSET(itflags, ndim, nop) + \ + NIT_AXISDATA_SIZEOF(itflags, ndim, nop)*(ndim)) /* Internal helper functions */ static int npyiter_check_global_flags(npy_uint32 flags, npy_uint32* itflags); static int -npyiter_check_op_axes(int niter, int oa_ndim, int **op_axes, +npyiter_check_op_axes(int nop, int oa_ndim, int **op_axes, npy_intp *itershape); static int -npyiter_calculate_ndim(int niter, PyArrayObject **op_in, +npyiter_calculate_ndim(int nop, PyArrayObject **op_in, int oa_ndim); static int npyiter_check_per_op_flags(npy_uint32 flags, char *op_itflags); @@ -300,7 +300,7 @@ npyiter_prepare_one_operand(PyArrayObject **op, npy_uint32 flags, npy_uint32 op_flags, char *op_itflags); static int -npyiter_prepare_operands(int niter, PyArrayObject **op_in, +npyiter_prepare_operands(int nop, PyArrayObject **op_in, PyArrayObject **op, char **op_dataptr, PyArray_Descr **op_request_dtypes, @@ -308,7 +308,7 @@ npyiter_prepare_operands(int niter, PyArrayObject **op_in, npy_uint32 flags, npy_uint32 *op_flags, char *op_itflags); static int -npyiter_check_casting(int niter, PyArrayObject **op, +npyiter_check_casting(int nop, PyArrayObject **op, PyArray_Descr **op_dtype, NPY_CASTING casting, char *op_itflags); @@ -319,7 +319,7 @@ npyiter_fill_axisdata(NpyIter *iter, npy_uint32 flags, char *op_itflags, npy_intp *itershape, int output_scalars); static void -npyiter_replace_axisdata(NpyIter *iter, int iiter, +npyiter_replace_axisdata(NpyIter *iter, int iop, PyArrayObject *op, int op_ndim, char *op_dataptr, int *op_axes); @@ -338,7 +338,7 @@ static void npyiter_coalesce_axes(NpyIter *iter); static PyArray_Descr * -npyiter_get_common_dtype(int niter, PyArrayObject **op, +npyiter_get_common_dtype(int nop, PyArrayObject **op, char *op_itflags, PyArray_Descr **op_dtype, PyArray_Descr **op_request_dtypes, int only_inputs, int output_scalars); @@ -355,7 +355,7 @@ npyiter_allocate_arrays(NpyIter *iter, npy_uint32 *op_flags, char *op_itflags, int **op_axes, int output_scalars); static void -npyiter_get_priority_subtype(int niter, PyArrayObject **op, +npyiter_get_priority_subtype(int nop, PyArrayObject **op, char *op_itflags, double *subtype_priority, PyTypeObject **subtype); @@ -378,7 +378,7 @@ npyiter_checkreducesize(NpyIter *iter, npy_intp count, * options for controlling the broadcasting, shape, and buffer size. */ NPY_NO_EXPORT NpyIter * -NpyIter_AdvancedNew(int niter, PyArrayObject **op_in, npy_uint32 flags, +NpyIter_AdvancedNew(int nop, PyArrayObject **op_in, npy_uint32 flags, NPY_ORDER order, NPY_CASTING casting, npy_uint32 *op_flags, PyArray_Descr **op_request_dtypes, @@ -387,7 +387,7 @@ NpyIter_AdvancedNew(int niter, PyArrayObject **op_in, npy_uint32 flags, { npy_uint32 itflags = NPY_ITFLAG_IDENTPERM; int idim, ndim; - int iiter; + int iop; /* The iterator being constructed */ NpyIter *iter; @@ -429,15 +429,15 @@ NpyIter_AdvancedNew(int niter, PyArrayObject **op_in, npy_uint32 flags, NPY_IT_TIME_POINT(c_start); - if (niter > NPY_MAXARGS) { + if (nop > NPY_MAXARGS) { PyErr_Format(PyExc_ValueError, "Cannot construct an iterator with more than %d operands " - "(%d were requested)", (int)NPY_MAXARGS, (int)niter); + "(%d were requested)", (int)NPY_MAXARGS, (int)nop); return NULL; } /* Error check 'oa_ndim' and 'op_axes', which must be used together */ - if (!npyiter_check_op_axes(niter, oa_ndim, op_axes, itershape)) { + if (!npyiter_check_op_axes(nop, oa_ndim, op_axes, itershape)) { return NULL; } @@ -451,7 +451,7 @@ NpyIter_AdvancedNew(int niter, PyArrayObject **op_in, npy_uint32 flags, NPY_IT_TIME_POINT(c_check_global_flags); /* Calculate how many dimensions the iterator should have */ - ndim = npyiter_calculate_ndim(niter, op_in, oa_ndim); + ndim = npyiter_calculate_ndim(nop, op_in, oa_ndim); /* If 'ndim' is zero, any outputs should be scalars */ if (ndim == 0) { @@ -463,16 +463,16 @@ NpyIter_AdvancedNew(int niter, PyArrayObject **op_in, npy_uint32 flags, /* Allocate memory for the iterator */ iter = (NpyIter*) - PyArray_malloc(NIT_SIZEOF_ITERATOR(itflags, ndim, niter)); + PyArray_malloc(NIT_SIZEOF_ITERATOR(itflags, ndim, nop)); NPY_IT_TIME_POINT(c_malloc); /* Fill in the basic data */ NIT_ITFLAGS(iter) = itflags; NIT_NDIM(iter) = ndim; - NIT_NITER(iter) = niter; + NIT_NOP(iter) = nop; NIT_ITERINDEX(iter) = 0; - memset(NIT_BASEOFFSETS(iter), 0, (niter+1)*NPY_SIZEOF_INTP); + memset(NIT_BASEOFFSETS(iter), 0, (nop+1)*NPY_SIZEOF_INTP); op = NIT_OPERANDS(iter); op_dtype = NIT_DTYPES(iter); @@ -480,7 +480,7 @@ NpyIter_AdvancedNew(int niter, PyArrayObject **op_in, npy_uint32 flags, op_dataptr = NIT_RESETDATAPTR(iter); /* Prepare all the operands */ - if (!npyiter_prepare_operands(niter, op_in, op, op_dataptr, + if (!npyiter_prepare_operands(nop, op_in, op, op_dataptr, op_request_dtypes, op_dtype, flags, op_flags, op_itflags)) { @@ -488,7 +488,7 @@ NpyIter_AdvancedNew(int niter, PyArrayObject **op_in, npy_uint32 flags, return NULL; } /* Set resetindex to zero as well (it's just after the resetdataptr) */ - op_dataptr[niter] = 0; + op_dataptr[nop] = 0; NPY_IT_TIME_POINT(c_prepare_operands); @@ -499,9 +499,9 @@ NpyIter_AdvancedNew(int niter, PyArrayObject **op_in, npy_uint32 flags, if (itflags&NPY_ITFLAG_BUFFER) { bufferdata = NIT_BUFFERDATA(iter); NBF_SIZE(bufferdata) = 0; - memset(NBF_BUFFERS(bufferdata), 0, niter*NPY_SIZEOF_INTP); - memset(NBF_READTRANSFERDATA(bufferdata), 0, niter*NPY_SIZEOF_INTP); - memset(NBF_WRITETRANSFERDATA(bufferdata), 0, niter*NPY_SIZEOF_INTP); + memset(NBF_BUFFERS(bufferdata), 0, nop*NPY_SIZEOF_INTP); + memset(NBF_READTRANSFERDATA(bufferdata), 0, nop*NPY_SIZEOF_INTP); + memset(NBF_WRITETRANSFERDATA(bufferdata), 0, nop*NPY_SIZEOF_INTP); } /* Fill in the AXISDATA arrays and set the ITERSIZE field */ @@ -554,19 +554,19 @@ NpyIter_AdvancedNew(int niter, PyArrayObject **op_in, npy_uint32 flags, NPY_IT_TIME_POINT(c_apply_forced_iteration_order); /* Set some flags for allocated outputs */ - for (iiter = 0; iiter < niter; ++iiter) { - if (op[iiter] == NULL) { + for (iop = 0; iop < nop; ++iop) { + if (op[iop] == NULL) { /* Flag this so later we can avoid flipping axes */ any_allocate = 1; /* If a subtype may be used, indicate so */ - if (!(op_flags[iiter]&NPY_ITER_NO_SUBTYPE)) { + if (!(op_flags[iop]&NPY_ITER_NO_SUBTYPE)) { need_subtype = 1; } /* * If the data type wasn't provided, will need to * calculate it. */ - if (op_dtype[iiter] == NULL) { + if (op_dtype[iop] == NULL) { any_missing_dtypes = 1; } } @@ -593,7 +593,7 @@ NpyIter_AdvancedNew(int niter, PyArrayObject **op_in, npy_uint32 flags, NPY_IT_TIME_POINT(c_find_best_axis_ordering); if (need_subtype) { - npyiter_get_priority_subtype(niter, op, op_itflags, + npyiter_get_priority_subtype(nop, op, op_itflags, &subtype_priority, &subtype); } @@ -610,7 +610,7 @@ NpyIter_AdvancedNew(int niter, PyArrayObject **op_in, npy_uint32 flags, op = NIT_OPERANDS(iter); op_dtype = NIT_DTYPES(iter); - dtype = npyiter_get_common_dtype(niter, op, + dtype = npyiter_get_common_dtype(nop, op, op_itflags, op_dtype, op_request_dtypes, only_inputs, @@ -622,21 +622,21 @@ NpyIter_AdvancedNew(int niter, PyArrayObject **op_in, npy_uint32 flags, if (flags&NPY_ITER_COMMON_DTYPE) { NPY_IT_DBG_PRINT("Iterator: Replacing all data types\n"); /* Replace all the data types */ - for (iiter = 0; iiter < niter; ++iiter) { - if (op_dtype[iiter] != dtype) { - Py_XDECREF(op_dtype[iiter]); + for (iop = 0; iop < nop; ++iop) { + if (op_dtype[iop] != dtype) { + Py_XDECREF(op_dtype[iop]); Py_INCREF(dtype); - op_dtype[iiter] = dtype; + op_dtype[iop] = dtype; } } } else { NPY_IT_DBG_PRINT("Iterator: Setting unset output data types\n"); /* Replace the NULL data types */ - for (iiter = 0; iiter < niter; ++iiter) { - if (op_dtype[iiter] == NULL) { + for (iop = 0; iop < nop; ++iop) { + if (op_dtype[iop] == NULL) { Py_INCREF(dtype); - op_dtype[iiter] = dtype; + op_dtype[iop] = dtype; } } } @@ -650,7 +650,7 @@ NpyIter_AdvancedNew(int niter, PyArrayObject **op_in, npy_uint32 flags, * to check that data type conversions are following the * casting rules. */ - if (!npyiter_check_casting(niter, op, op_dtype, casting, op_itflags)) { + if (!npyiter_check_casting(nop, op, op_dtype, casting, op_itflags)) { NpyIter_Deallocate(iter); return NULL; } @@ -712,8 +712,8 @@ NpyIter_AdvancedNew(int niter, PyArrayObject **op_in, npy_uint32 flags, * reference arrays and flag it if so. */ if (flags&NPY_ITER_REFS_OK) { - for (iiter = 0; iiter < niter; ++iiter) { - PyArray_Descr *rdt = op_dtype[iiter]; + for (iop = 0; iop < nop; ++iop) { + PyArray_Descr *rdt = op_dtype[iop]; if ((rdt->flags&(NPY_ITEM_REFCOUNT| NPY_ITEM_IS_POINTER| NPY_NEEDS_PYAPI)) != 0) { @@ -732,7 +732,7 @@ NpyIter_AdvancedNew(int niter, PyArrayObject **op_in, npy_uint32 flags, if (itflags&NPY_ITFLAG_DELAYBUF) { bufferdata = NIT_BUFFERDATA(iter); /* Make the data pointers NULL */ - memset(NBF_PTRS(bufferdata), 0, niter*NPY_SIZEOF_INTP); + memset(NBF_PTRS(bufferdata), 0, nop*NPY_SIZEOF_INTP); } else { /* Allocate the buffers */ @@ -777,12 +777,12 @@ NpyIter_AdvancedNew(int niter, PyArrayObject **op_in, npy_uint32 flags, * standard NumPy broadcasting rules and the default buffer size. */ NPY_NO_EXPORT NpyIter * -NpyIter_MultiNew(int niter, PyArrayObject **op_in, npy_uint32 flags, +NpyIter_MultiNew(int nop, PyArrayObject **op_in, npy_uint32 flags, NPY_ORDER order, NPY_CASTING casting, npy_uint32 *op_flags, PyArray_Descr **op_request_dtypes) { - return NpyIter_AdvancedNew(niter, op_in, flags, order, casting, + return NpyIter_AdvancedNew(nop, op_in, flags, order, casting, op_flags, op_request_dtypes, 0, NULL, NULL, 0); } @@ -812,7 +812,7 @@ NpyIter_Copy(NpyIter *iter) { npy_uint32 itflags = NIT_ITFLAGS(iter); int ndim = NIT_NDIM(iter); - int iiter, niter = NIT_NITER(iter); + int iop, nop = NIT_NOP(iter); int out_of_memory = 0; npy_intp size; @@ -821,7 +821,7 @@ NpyIter_Copy(NpyIter *iter) PyArray_Descr **dtypes; /* Allocate memory for the new iterator */ - size = NIT_SIZEOF_ITERATOR(itflags, ndim, niter); + size = NIT_SIZEOF_ITERATOR(itflags, ndim, nop); newiter = (NpyIter*)PyArray_malloc(size); /* Copy the raw values to the new iterator */ @@ -830,9 +830,9 @@ NpyIter_Copy(NpyIter *iter) /* Take ownership of references to the operands and dtypes */ objects = NIT_OPERANDS(newiter); dtypes = NIT_DTYPES(newiter); - for (iiter = 0; iiter < niter; ++iiter) { - Py_INCREF(objects[iiter]); - Py_INCREF(dtypes[iiter]); + for (iop = 0; iop < nop; ++iop) { + Py_INCREF(objects[iop]); + Py_INCREF(dtypes[iop]); } /* Allocate buffers and make copies of the transfer data if necessary */ @@ -848,41 +848,41 @@ NpyIter_Copy(NpyIter *iter) writetransferdata = NBF_WRITETRANSFERDATA(bufferdata); buffersize = NBF_BUFFERSIZE(bufferdata); - for (iiter = 0; iiter < niter; ++iiter) { - if (buffers[iiter] != NULL) { + for (iop = 0; iop < nop; ++iop) { + if (buffers[iop] != NULL) { if (out_of_memory) { - buffers[iiter] = NULL; + buffers[iop] = NULL; } else { - itemsize = dtypes[iiter]->elsize; - buffers[iiter] = PyArray_malloc(itemsize*buffersize); - if (buffers[iiter] == NULL) { + itemsize = dtypes[iop]->elsize; + buffers[iop] = PyArray_malloc(itemsize*buffersize); + if (buffers[iop] == NULL) { out_of_memory = 1; } } } - if (readtransferdata[iiter] != NULL) { + if (readtransferdata[iop] != NULL) { if (out_of_memory) { - readtransferdata[iiter] = NULL; + readtransferdata[iop] = NULL; } else { - readtransferdata[iiter] = - PyArray_CopyStridedTransferData(readtransferdata[iiter]); - if (readtransferdata[iiter] == NULL) { + readtransferdata[iop] = + PyArray_CopyStridedTransferData(readtransferdata[iop]); + if (readtransferdata[iop] == NULL) { out_of_memory = 1; } } } - if (writetransferdata[iiter] != NULL) { + if (writetransferdata[iop] != NULL) { if (out_of_memory) { - writetransferdata[iiter] = NULL; + writetransferdata[iop] = NULL; } else { - writetransferdata[iiter] = - PyArray_CopyStridedTransferData(writetransferdata[iiter]); - if (writetransferdata[iiter] == NULL) { + writetransferdata[iop] = + PyArray_CopyStridedTransferData(writetransferdata[iop]); + if (writetransferdata[iop] == NULL) { out_of_memory = 1; } } @@ -915,7 +915,7 @@ NpyIter_Deallocate(NpyIter *iter) { npy_uint32 itflags = NIT_ITFLAGS(iter); /*int ndim = NIT_NDIM(iter);*/ - int iiter, niter = NIT_NITER(iter); + int iop, nop = NIT_NOP(iter); PyArray_Descr **dtype = NIT_DTYPES(iter); PyArrayObject **object = NIT_OPERANDS(iter); @@ -928,21 +928,21 @@ NpyIter_Deallocate(NpyIter *iter) /* buffers */ buffers = NBF_BUFFERS(bufferdata); - for(iiter = 0; iiter < niter; ++iiter, ++buffers) { + for(iop = 0; iop < nop; ++iop, ++buffers) { if (*buffers) { PyArray_free(*buffers); } } /* read bufferdata */ transferdata = NBF_READTRANSFERDATA(bufferdata); - for(iiter = 0; iiter < niter; ++iiter, ++transferdata) { + for(iop = 0; iop < nop; ++iop, ++transferdata) { if (*transferdata) { PyArray_FreeStridedTransferData(*transferdata); } } /* write bufferdata */ transferdata = NBF_WRITETRANSFERDATA(bufferdata); - for(iiter = 0; iiter < niter; ++iiter, ++transferdata) { + for(iop = 0; iop < nop; ++iop, ++transferdata) { if (*transferdata) { PyArray_FreeStridedTransferData(*transferdata); } @@ -950,7 +950,7 @@ NpyIter_Deallocate(NpyIter *iter) } /* Deallocate all the dtypes and objects that were iterated */ - for(iiter = 0; iiter < niter; ++iiter, ++dtype, ++object) { + for(iop = 0; iop < nop; ++iop, ++dtype, ++object) { Py_XDECREF(*dtype); Py_XDECREF(*object); } @@ -973,12 +973,12 @@ NpyIter_RemoveAxis(NpyIter *iter, int axis) { npy_uint32 itflags = NIT_ITFLAGS(iter); int idim, ndim = NIT_NDIM(iter); - int iiter, niter = NIT_NITER(iter); + int iop, nop = NIT_NOP(iter); int xdim = 0; char *perm = NIT_PERM(iter); NpyIter_AxisData *axisdata_del = NIT_AXISDATA(iter), *axisdata; - npy_intp sizeof_axisdata = NIT_AXISDATA_SIZEOF(itflags, ndim, niter); + npy_intp sizeof_axisdata = NIT_AXISDATA_SIZEOF(itflags, ndim, nop); npy_intp *baseoffsets = NIT_BASEOFFSETS(iter); char **resetdataptr = NIT_RESETDATAPTR(iter); @@ -1028,10 +1028,10 @@ NpyIter_RemoveAxis(NpyIter *iter, int axis) * Adjust baseoffsets and resetbaseptr back to the start of * this axis. */ - for (iiter = 0; iiter < niter; ++iiter) { - offset = (shape-1)*strides[iiter]; - baseoffsets[iiter] += offset; - resetdataptr[iiter] += offset; + for (iop = 0; iop < nop; ++iop) { + offset = (shape-1)*strides[iop]; + baseoffsets[iop] += offset; + resetdataptr[iop] += offset; } break; } @@ -1082,8 +1082,8 @@ NpyIter_RemoveAxis(NpyIter *iter, int axis) else { npy_intp *strides = NAD_STRIDES(axisdata_del); NAD_SHAPE(axisdata_del) = 1; - for (iiter = 0; iiter < niter; ++iiter) { - strides[iiter] = 0; + for (iop = 0; iop < nop; ++iop) { + strides[iop] = 0; } NIT_ITFLAGS(iter) |= NPY_ITFLAG_ONEITERATION; } @@ -1123,7 +1123,7 @@ NpyIter_EnableExternalLoop(NpyIter *iter) { npy_uint32 itflags = NIT_ITFLAGS(iter); /*int ndim = NIT_NDIM(iter);*/ - int niter = NIT_NITER(iter); + int nop = NIT_NOP(iter); /* Check conditions under which this can be done */ if (itflags&(NPY_ITFLAG_HASINDEX|NPY_ITFLAG_HASMULTIINDEX)) { @@ -1173,7 +1173,7 @@ NpyIter_Reset(NpyIter *iter, char **errmsg) { npy_uint32 itflags = NIT_ITFLAGS(iter); /*int ndim = NIT_NDIM(iter);*/ - int niter = NIT_NITER(iter); + int nop = NIT_NOP(iter); if (itflags&NPY_ITFLAG_BUFFER) { NpyIter_BufferData *bufferdata; @@ -1225,7 +1225,7 @@ NpyIter_ResetBasePointers(NpyIter *iter, char **baseptrs, char **errmsg) { npy_uint32 itflags = NIT_ITFLAGS(iter); /*int ndim = NIT_NDIM(iter);*/ - int iiter, niter = NIT_NITER(iter); + int iop, nop = NIT_NOP(iter); char **resetdataptr = NIT_RESETDATAPTR(iter); npy_intp *baseoffsets = NIT_BASEOFFSETS(iter); @@ -1245,8 +1245,8 @@ NpyIter_ResetBasePointers(NpyIter *iter, char **baseptrs, char **errmsg) } /* The new data pointers for resetting */ - for (iiter = 0; iiter < niter; ++iiter) { - resetdataptr[iiter] = baseptrs[iiter] + baseoffsets[iiter]; + for (iop = 0; iop < nop; ++iop) { + resetdataptr[iop] = baseptrs[iop] + baseoffsets[iop]; } npyiter_goto_iterindex(iter, NIT_ITERSTART(iter)); @@ -1273,7 +1273,7 @@ NpyIter_ResetToIterIndexRange(NpyIter *iter, { npy_uint32 itflags = NIT_ITFLAGS(iter); /*int ndim = NIT_NDIM(iter);*/ - /*int niter = NIT_NITER(iter);*/ + /*int nop = NIT_NOP(iter);*/ if (!(itflags&NPY_ITFLAG_RANGE)) { if (errmsg == NULL) { @@ -1331,7 +1331,7 @@ NpyIter_GotoMultiIndex(NpyIter *iter, npy_intp *multi_index) { npy_uint32 itflags = NIT_ITFLAGS(iter); int idim, ndim = NIT_NDIM(iter); - int niter = NIT_NITER(iter); + int nop = NIT_NOP(iter); npy_intp iterindex, factor; NpyIter_AxisData *axisdata; @@ -1361,7 +1361,7 @@ NpyIter_GotoMultiIndex(NpyIter *iter, npy_intp *multi_index) perm = NIT_PERM(iter); axisdata = NIT_AXISDATA(iter); - sizeof_axisdata = NIT_AXISDATA_SIZEOF(itflags, ndim, niter); + sizeof_axisdata = NIT_AXISDATA_SIZEOF(itflags, ndim, nop); /* Compute the iterindex corresponding to the multi-index */ iterindex = 0; @@ -1417,7 +1417,7 @@ NpyIter_GotoIndex(NpyIter *iter, npy_intp flat_index) { npy_uint32 itflags = NIT_ITFLAGS(iter); int idim, ndim = NIT_NDIM(iter); - int niter = NIT_NITER(iter); + int nop = NIT_NOP(iter); npy_intp iterindex, factor; NpyIter_AxisData *axisdata; @@ -1452,7 +1452,7 @@ NpyIter_GotoIndex(NpyIter *iter, npy_intp flat_index) } axisdata = NIT_AXISDATA(iter); - sizeof_axisdata = NIT_AXISDATA_SIZEOF(itflags, ndim, niter); + sizeof_axisdata = NIT_AXISDATA_SIZEOF(itflags, ndim, nop); /* Compute the iterindex corresponding to the flat_index */ iterindex = 0; @@ -1460,7 +1460,7 @@ NpyIter_GotoIndex(NpyIter *iter, npy_intp flat_index) for (idim = 0; idim < ndim; ++idim) { npy_intp i, shape, iterstride; - iterstride = NAD_STRIDES(axisdata)[niter]; + iterstride = NAD_STRIDES(axisdata)[nop]; shape = NAD_SHAPE(axisdata); /* Extract the index from the flat_index */ @@ -1505,7 +1505,7 @@ NpyIter_GotoIterIndex(NpyIter *iter, npy_intp iterindex) { npy_uint32 itflags = NIT_ITFLAGS(iter); /*int ndim = NIT_NDIM(iter);*/ - int iiter, niter = NIT_NITER(iter); + int iop, nop = NIT_NOP(iter); if (itflags&NPY_ITFLAG_EXLOOP) { PyErr_SetString(PyExc_ValueError, @@ -1537,8 +1537,8 @@ NpyIter_GotoIterIndex(NpyIter *iter, npy_intp iterindex) ptrs = NBF_PTRS(bufferdata); delta = iterindex - NIT_ITERINDEX(iter); - for (iiter = 0; iiter < niter; ++iiter) { - ptrs[iiter] += delta * strides[iiter]; + for (iop = 0; iop < nop; ++iop) { + ptrs[iop] += delta * strides[iop]; } NIT_ITERINDEX(iter) = iterindex; @@ -1569,7 +1569,7 @@ NpyIter_GetIterIndex(NpyIter *iter) { npy_uint32 itflags = NIT_ITFLAGS(iter); int idim, ndim = NIT_NDIM(iter); - int niter = NIT_NITER(iter); + int nop = NIT_NOP(iter); /* iterindex is only used if NPY_ITER_RANGED or NPY_ITER_BUFFERED was set */ if (itflags&(NPY_ITFLAG_RANGE|NPY_ITFLAG_BUFFER)) { @@ -1581,7 +1581,7 @@ NpyIter_GetIterIndex(NpyIter *iter) npy_intp sizeof_axisdata; iterindex = 0; - sizeof_axisdata = NIT_AXISDATA_SIZEOF(itflags, ndim, niter); + sizeof_axisdata = NIT_AXISDATA_SIZEOF(itflags, ndim, nop); axisdata = NIT_INDEX_AXISDATA(NIT_AXISDATA(iter), ndim-1); for (idim = ndim-2; idim >= 0; --idim) { @@ -1610,23 +1610,23 @@ NpyIter_GetIterIndex(NpyIter *iter) * #tag_ndim = 1, 2, ANY# */ /**begin repeat2 - * #const_niter = 1, 2, NPY_MAXDIMS# - * #tag_niter = 1, 2, ANY# + * #const_nop = 1, 2, NPY_MAXDIMS# + * #tag_nop = 1, 2, ANY# */ -/* Specialized iternext (@const_itflags@,@tag_ndim@,@tag_niter@) */ +/* Specialized iternext (@const_itflags@,@tag_ndim@,@tag_nop@) */ static int -npyiter_iternext_itflags@tag_itflags@_dims@tag_ndim@_iters@tag_niter@( +npyiter_iternext_itflags@tag_itflags@_dims@tag_ndim@_iters@tag_nop@( NpyIter *iter) { const npy_uint32 itflags = @const_itflags@; #if @const_ndim@ >= NPY_MAXDIMS int idim, ndim = NIT_NDIM(iter); #endif -#if @const_niter@ < NPY_MAXDIMS - const int niter = @const_niter@; +#if @const_nop@ < NPY_MAXDIMS + const int nop = @const_nop@; #else - int niter = NIT_NITER(iter); + int nop = NIT_NOP(iter); #endif npy_intp istrides, nstrides, sizeof_axisdata; @@ -1648,7 +1648,7 @@ npyiter_iternext_itflags@tag_itflags@_dims@tag_ndim@_iters@tag_niter@( #endif nstrides = NAD_NSTRIDES(); - sizeof_axisdata = NIT_AXISDATA_SIZEOF(itflags, ndim, niter); + sizeof_axisdata = NIT_AXISDATA_SIZEOF(itflags, ndim, nop); axisdata0 = NIT_AXISDATA(iter); # if !(@const_itflags@&NPY_ITFLAG_EXLOOP) @@ -1763,8 +1763,8 @@ npyiter_iternext_itflags@tag_itflags@_dims@tag_ndim@_iters@tag_niter@( /**begin repeat - * #const_niter = 1, 2, 3, 4, NPY_MAXDIMS# - * #tag_niter = 1, 2, 3, 4, ANY# + * #const_nop = 1, 2, 3, 4, NPY_MAXDIMS# + * #tag_nop = 1, 2, 3, 4, ANY# */ /* @@ -1772,17 +1772,17 @@ npyiter_iternext_itflags@tag_itflags@_dims@tag_ndim@_iters@tag_niter@( * is done with a double loop to avoid frequent re-buffering. */ static int -npyiter_buffered_reduce_iternext_iters@tag_niter@(NpyIter *iter) +npyiter_buffered_reduce_iternext_iters@tag_nop@(NpyIter *iter) { npy_uint32 itflags = NIT_ITFLAGS(iter); /*int ndim = NIT_NDIM(iter);*/ -#if @const_niter@ >= NPY_MAXDIMS - int niter = NIT_NITER(iter); +#if @const_nop@ >= NPY_MAXDIMS + int nop = NIT_NOP(iter); #else - const int niter = @const_niter@; + const int nop = @const_nop@; #endif - int iiter; + int iop; NpyIter_AxisData *axisdata; NpyIter_BufferData *bufferdata = NIT_BUFFERDATA(iter); @@ -1801,8 +1801,8 @@ npyiter_buffered_reduce_iternext_iters@tag_niter@(NpyIter *iter) npy_intp *strides; strides = NBF_STRIDES(bufferdata); - for (iiter = 0; iiter < niter; ++iiter) { - ptrs[iiter] += strides[iiter]; + for (iop = 0; iop < nop; ++iop) { + ptrs[iop] += strides[iop]; } return 1; } @@ -1817,10 +1817,10 @@ npyiter_buffered_reduce_iternext_iters@tag_niter@(NpyIter *iter) if (++NBF_REDUCE_POS(bufferdata) < NBF_REDUCE_OUTERSIZE(bufferdata)) { npy_intp *reduce_outerstrides = NBF_REDUCE_OUTERSTRIDES(bufferdata); char **reduce_outerptrs = NBF_REDUCE_OUTERPTRS(bufferdata); - for (iiter = 0; iiter < niter; ++iiter) { - char *ptr = reduce_outerptrs[iiter] + reduce_outerstrides[iiter]; - ptrs[iiter] = ptr; - reduce_outerptrs[iiter] = ptr; + for (iop = 0; iop < nop; ++iop) { + char *ptr = reduce_outerptrs[iop] + reduce_outerstrides[iop]; + ptrs[iop] = ptr; + reduce_outerptrs[iop] = ptr; } NBF_BUFITEREND(bufferdata) = NIT_ITERINDEX(iter) + NBF_SIZE(bufferdata); return 1; @@ -1828,7 +1828,7 @@ npyiter_buffered_reduce_iternext_iters@tag_niter@(NpyIter *iter) /* Save the previously used data pointers */ axisdata = NIT_AXISDATA(iter); - memcpy(prev_dataptrs, NAD_PTRS(axisdata), NPY_SIZEOF_INTP*niter); + memcpy(prev_dataptrs, NAD_PTRS(axisdata), NPY_SIZEOF_INTP*nop); /* Write back to the arrays */ npyiter_copy_from_buffers(iter); @@ -1857,7 +1857,7 @@ npyiter_buffered_iternext(NpyIter *iter) { npy_uint32 itflags = NIT_ITFLAGS(iter); /*int ndim = NIT_NDIM(iter);*/ - int niter = NIT_NITER(iter); + int nop = NIT_NOP(iter); NpyIter_BufferData *bufferdata = NIT_BUFFERDATA(iter); @@ -1868,14 +1868,14 @@ npyiter_buffered_iternext(NpyIter *iter) if (!(itflags&NPY_ITFLAG_EXLOOP)) { /* Increment within the buffer */ if (++NIT_ITERINDEX(iter) < NBF_BUFITEREND(bufferdata)) { - int iiter; + int iop; npy_intp *strides; char **ptrs; strides = NBF_STRIDES(bufferdata); ptrs = NBF_PTRS(bufferdata); - for (iiter = 0; iiter < niter; ++iiter) { - ptrs[iiter] += strides[iiter]; + for (iop = 0; iop < nop; ++iop) { + ptrs[iop] += strides[iop]; } return 1; } @@ -1927,7 +1927,7 @@ NpyIter_GetIterNext(NpyIter *iter, char **errmsg) { npy_uint32 itflags = NIT_ITFLAGS(iter); int ndim = NIT_NDIM(iter); - int niter = NIT_NITER(iter); + int nop = NIT_NOP(iter); /* * When there is just one iteration and buffering is disabled @@ -1942,7 +1942,7 @@ NpyIter_GetIterNext(NpyIter *iter, char **errmsg) */ if (itflags&NPY_ITFLAG_BUFFER) { if (itflags&NPY_ITFLAG_REDUCE) { - switch (niter) { + switch (nop) { case 1: return &npyiter_buffered_reduce_iternext_iters1; case 2: @@ -1988,30 +1988,30 @@ NpyIter_GetIterNext(NpyIter *iter, char **errmsg) * #tag_ndim = 1, 2# */ case @const_ndim@: - switch (niter) { + switch (nop) { /**begin repeat2 - * #const_niter = 1, 2# - * #tag_niter = 1, 2# + * #const_nop = 1, 2# + * #tag_nop = 1, 2# */ - case @const_niter@: - return &npyiter_iternext_itflags@tag_itflags@_dims@tag_ndim@_iters@tag_niter@; + case @const_nop@: + return &npyiter_iternext_itflags@tag_itflags@_dims@tag_ndim@_iters@tag_nop@; /**end repeat2**/ - /* Not specialized on niter */ + /* Not specialized on nop */ default: return &npyiter_iternext_itflags@tag_itflags@_dims@tag_ndim@_itersANY; } /**end repeat1**/ /* Not specialized on ndim */ default: - switch (niter) { + switch (nop) { /**begin repeat1 - * #const_niter = 1, 2# - * #tag_niter = 1, 2# + * #const_nop = 1, 2# + * #tag_nop = 1, 2# */ - case @const_niter@: - return &npyiter_iternext_itflags@tag_itflags@_dimsANY_iters@tag_niter@; + case @const_nop@: + return &npyiter_iternext_itflags@tag_itflags@_dimsANY_iters@tag_nop@; /**end repeat1**/ - /* Not specialized on niter */ + /* Not specialized on nop */ default: return &npyiter_iternext_itflags@tag_itflags@_dimsANY_itersANY; } @@ -2022,12 +2022,12 @@ NpyIter_GetIterNext(NpyIter *iter, char **errmsg) if (errmsg == NULL) { PyErr_Format(PyExc_ValueError, "GetIterNext internal iterator error - unexpected " - "itflags/ndim/niter combination (%04x/%d/%d)", - (int)itflags, (int)ndim, (int)niter); + "itflags/ndim/nop combination (%04x/%d/%d)", + (int)itflags, (int)ndim, (int)nop); } else { *errmsg = "GetIterNext internal iterator error - unexpected " - "itflags/ndim/niter combination"; + "itflags/ndim/nop combination"; } return NULL; } @@ -2057,7 +2057,7 @@ npyiter_get_multi_index_itflags@tag_itflags@( { const npy_uint32 itflags = @const_itflags@; int idim, ndim = NIT_NDIM(iter); - int niter = NIT_NITER(iter); + int nop = NIT_NOP(iter); npy_intp sizeof_axisdata; NpyIter_AxisData *axisdata; @@ -2066,7 +2066,7 @@ npyiter_get_multi_index_itflags@tag_itflags@( #endif axisdata = NIT_AXISDATA(iter); - sizeof_axisdata = NIT_AXISDATA_SIZEOF(itflags, ndim, niter); + sizeof_axisdata = NIT_AXISDATA_SIZEOF(itflags, ndim, nop); #if ((@const_itflags@)&NPY_ITFLAG_IDENTPERM) out_multi_index += ndim-1; for(idim = 0; idim < ndim; ++idim, --out_multi_index, @@ -2106,7 +2106,7 @@ NpyIter_GetGetMultiIndex(NpyIter *iter, char **errmsg) { npy_uint32 itflags = NIT_ITFLAGS(iter); int ndim = NIT_NDIM(iter); - int niter = NIT_NITER(iter); + int nop = NIT_NOP(iter); /* These flags must be correct */ if ((itflags&(NPY_ITFLAG_HASMULTIINDEX|NPY_ITFLAG_DELAYBUF)) != @@ -2173,12 +2173,12 @@ NpyIter_GetGetMultiIndex(NpyIter *iter, char **errmsg) if (errmsg == NULL) { PyErr_Format(PyExc_ValueError, "GetGetMultiIndex internal iterator error - unexpected " - "itflags/ndim/niter combination (%04x/%d/%d)", - (int)itflags, (int)ndim, (int)niter); + "itflags/ndim/nop combination (%04x/%d/%d)", + (int)itflags, (int)ndim, (int)nop); } else { *errmsg = "GetGetMultiIndex internal iterator error - unexpected " - "itflags/ndim/niter combination"; + "itflags/ndim/nop combination"; } return NULL; @@ -2228,7 +2228,7 @@ NpyIter_RequiresBuffering(NpyIter *iter) { npy_uint32 itflags = NIT_ITFLAGS(iter); /*int ndim = NIT_NDIM(iter);*/ - int iiter, niter = NIT_NITER(iter); + int iop, nop = NIT_NOP(iter); char *op_itflags; @@ -2239,8 +2239,8 @@ NpyIter_RequiresBuffering(NpyIter *iter) op_itflags = NIT_OPITFLAGS(iter); /* If any operand requires a cast, buffering is mandatory */ - for (iiter = 0; iiter < niter; ++iiter) { - if (op_itflags[iiter]&NPY_OP_ITFLAG_CAST) { + for (iop = 0; iop < nop; ++iop) { + if (op_itflags[iop]&NPY_OP_ITFLAG_CAST) { return 1; } } @@ -2272,9 +2272,9 @@ NpyIter_GetNDim(NpyIter *iter) * Gets the number of operands being iterated */ NPY_NO_EXPORT int -NpyIter_GetNIter(NpyIter *iter) +NpyIter_GetNOp(NpyIter *iter) { - return NIT_NITER(iter); + return NIT_NOP(iter); } /*NUMPY_API @@ -2312,7 +2312,7 @@ NpyIter_GetBufferSize(NpyIter *iter) { npy_uint32 itflags = NIT_ITFLAGS(iter); /*int ndim = NIT_NDIM(iter);*/ - int niter = NIT_NITER(iter); + int nop = NIT_NOP(iter); if (itflags&NPY_ITFLAG_BUFFER) { NpyIter_BufferData *bufferdata = NIT_BUFFERDATA(iter); @@ -2354,14 +2354,14 @@ NpyIter_GetShape(NpyIter *iter, npy_intp *outshape) { npy_uint32 itflags = NIT_ITFLAGS(iter); int ndim = NIT_NDIM(iter); - int niter = NIT_NITER(iter); + int nop = NIT_NOP(iter); int idim, sizeof_axisdata; NpyIter_AxisData *axisdata; char *perm; axisdata = NIT_AXISDATA(iter); - sizeof_axisdata = NIT_AXISDATA_SIZEOF(itflags, ndim, niter); + sizeof_axisdata = NIT_AXISDATA_SIZEOF(itflags, ndim, nop); if (itflags&NPY_ITFLAG_HASMULTIINDEX) { perm = NIT_PERM(iter); @@ -2418,7 +2418,7 @@ NpyIter_CreateCompatibleStrides(NpyIter *iter, { npy_uint32 itflags = NIT_ITFLAGS(iter); int idim, ndim = NIT_NDIM(iter); - int niter = NIT_NITER(iter); + int nop = NIT_NOP(iter); npy_intp sizeof_axisdata; NpyIter_AxisData *axisdata; @@ -2432,7 +2432,7 @@ NpyIter_CreateCompatibleStrides(NpyIter *iter, } axisdata = NIT_AXISDATA(iter); - sizeof_axisdata = NIT_AXISDATA_SIZEOF(itflags, ndim, niter); + sizeof_axisdata = NIT_AXISDATA_SIZEOF(itflags, ndim, nop); perm = NIT_PERM(iter); for(idim = 0; idim < ndim; ++idim) { @@ -2465,7 +2465,7 @@ NpyIter_GetDataPtrArray(NpyIter *iter) { npy_uint32 itflags = NIT_ITFLAGS(iter); /*int ndim = NIT_NDIM(iter);*/ - int niter = NIT_NITER(iter); + int nop = NIT_NOP(iter); if (itflags&NPY_ITFLAG_BUFFER) { NpyIter_BufferData *bufferdata = NIT_BUFFERDATA(iter); @@ -2494,7 +2494,7 @@ NpyIter_GetInitialDataPtrArray(NpyIter *iter) { /*npy_uint32 itflags = NIT_ITFLAGS(iter);*/ /*int ndim = NIT_NDIM(iter);*/ - int niter = NIT_NITER(iter); + int nop = NIT_NOP(iter); return NIT_RESETDATAPTR(iter); } @@ -2507,7 +2507,7 @@ NpyIter_GetDescrArray(NpyIter *iter) { /*npy_uint32 itflags = NIT_ITFLAGS(iter);*/ /*int ndim = NIT_NDIM(iter);*/ - /*int niter = NIT_NITER(iter);*/ + /*int nop = NIT_NOP(iter);*/ return NIT_DTYPES(iter); } @@ -2520,7 +2520,7 @@ NpyIter_GetOperandArray(NpyIter *iter) { /*npy_uint32 itflags = NIT_ITFLAGS(iter);*/ /*int ndim = NIT_NDIM(iter);*/ - int niter = NIT_NITER(iter); + int nop = NIT_NOP(iter); return NIT_OPERANDS(iter); } @@ -2533,7 +2533,7 @@ NpyIter_GetIterView(NpyIter *iter, npy_intp i) { npy_uint32 itflags = NIT_ITFLAGS(iter); int idim, ndim = NIT_NDIM(iter); - int niter = NIT_NITER(iter); + int nop = NIT_NOP(iter); npy_intp shape[NPY_MAXDIMS], strides[NPY_MAXDIMS]; PyArrayObject *obj, *view; @@ -2543,7 +2543,7 @@ NpyIter_GetIterView(NpyIter *iter, npy_intp i) npy_intp sizeof_axisdata; int writeable; - if (i < 0 || i >= niter) { + if (i < 0 || i >= nop) { PyErr_SetString(PyExc_IndexError, "index provided for an iterator view was out of bounds"); return NULL; @@ -2561,7 +2561,7 @@ NpyIter_GetIterView(NpyIter *iter, npy_intp i) writeable = NIT_OPITFLAGS(iter)[i]&NPY_OP_ITFLAG_WRITE; dataptr = NIT_RESETDATAPTR(iter)[i]; axisdata = NIT_AXISDATA(iter); - sizeof_axisdata = NIT_AXISDATA_SIZEOF(itflags, ndim, niter); + sizeof_axisdata = NIT_AXISDATA_SIZEOF(itflags, ndim, nop); /* Retrieve the shape and strides from the axisdata */ for (idim = 0; idim < ndim; ++idim, NIT_ADVANCE_AXISDATA(axisdata, 1)) { @@ -2594,13 +2594,13 @@ NpyIter_GetIndexPtr(NpyIter *iter) { npy_uint32 itflags = NIT_ITFLAGS(iter); /*int ndim = NIT_NDIM(iter);*/ - int niter = NIT_NITER(iter); + int nop = NIT_NOP(iter); NpyIter_AxisData *axisdata = NIT_AXISDATA(iter); if (itflags&NPY_ITFLAG_HASINDEX) { /* The index is just after the data pointers */ - return (npy_intp*)NAD_PTRS(axisdata) + niter; + return (npy_intp*)NAD_PTRS(axisdata) + nop; } else { return NULL; @@ -2615,12 +2615,12 @@ NpyIter_GetReadFlags(NpyIter *iter, char *outreadflags) { /*npy_uint32 itflags = NIT_ITFLAGS(iter);*/ /*int ndim = NIT_NDIM(iter);*/ - int iiter, niter = NIT_NITER(iter); + int iop, nop = NIT_NOP(iter); char *op_itflags = NIT_OPITFLAGS(iter); - for (iiter = 0; iiter < niter; ++iiter) { - outreadflags[iiter] = (op_itflags[iiter]&NPY_OP_ITFLAG_READ) != 0; + for (iop = 0; iop < nop; ++iop) { + outreadflags[iop] = (op_itflags[iop]&NPY_OP_ITFLAG_READ) != 0; } } @@ -2632,12 +2632,12 @@ NpyIter_GetWriteFlags(NpyIter *iter, char *outwriteflags) { /*npy_uint32 itflags = NIT_ITFLAGS(iter);*/ /*int ndim = NIT_NDIM(iter);*/ - int iiter, niter = NIT_NITER(iter); + int iop, nop = NIT_NOP(iter); char *op_itflags = NIT_OPITFLAGS(iter); - for (iiter = 0; iiter < niter; ++iiter) { - outwriteflags[iiter] = (op_itflags[iiter]&NPY_OP_ITFLAG_WRITE) != 0; + for (iop = 0; iop < nop; ++iop) { + outwriteflags[iop] = (op_itflags[iop]&NPY_OP_ITFLAG_WRITE) != 0; } } @@ -2652,7 +2652,7 @@ NpyIter_GetInnerStrideArray(NpyIter *iter) { npy_uint32 itflags = NIT_ITFLAGS(iter); /*int ndim = NIT_NDIM(iter);*/ - int niter = NIT_NITER(iter); + int nop = NIT_NOP(iter); if (itflags&NPY_ITFLAG_BUFFER) { NpyIter_BufferData *data = NIT_BUFFERDATA(iter); @@ -2677,11 +2677,11 @@ NpyIter_GetAxisStrideArray(NpyIter *iter, int axis) { npy_uint32 itflags = NIT_ITFLAGS(iter); int idim, ndim = NIT_NDIM(iter); - int niter = NIT_NITER(iter); + int nop = NIT_NOP(iter); char *perm = NIT_PERM(iter); NpyIter_AxisData *axisdata = NIT_AXISDATA(iter); - npy_intp sizeof_axisdata = NIT_AXISDATA_SIZEOF(itflags, ndim, niter); + npy_intp sizeof_axisdata = NIT_AXISDATA_SIZEOF(itflags, ndim, nop); if (axis < 0 || axis >= ndim) { PyErr_SetString(PyExc_ValueError, @@ -2723,10 +2723,10 @@ NpyIter_GetInnerFixedStrideArray(NpyIter *iter, npy_intp *out_strides) { npy_uint32 itflags = NIT_ITFLAGS(iter); int ndim = NIT_NDIM(iter); - int iiter, niter = NIT_NITER(iter); + int iop, nop = NIT_NOP(iter); NpyIter_AxisData *axisdata0 = NIT_AXISDATA(iter); - npy_intp sizeof_axisdata = NIT_AXISDATA_SIZEOF(itflags, ndim, niter); + npy_intp sizeof_axisdata = NIT_AXISDATA_SIZEOF(itflags, ndim, nop); if (itflags&NPY_ITFLAG_BUFFER) { NpyIter_BufferData *data = NIT_BUFFERDATA(iter); @@ -2735,21 +2735,21 @@ NpyIter_GetInnerFixedStrideArray(NpyIter *iter, npy_intp *out_strides) *ad_strides = NAD_STRIDES(axisdata0); PyArray_Descr **dtypes = NIT_DTYPES(iter); - for (iiter = 0; iiter < niter; ++iiter) { - stride = strides[iiter]; + for (iop = 0; iop < nop; ++iop) { + stride = strides[iop]; /* * Operands which are always/never buffered have fixed strides, * and everything has fixed strides when ndim is 0 or 1 */ - if (ndim <= 1 || (op_itflags[iiter]& + if (ndim <= 1 || (op_itflags[iop]& (NPY_OP_ITFLAG_CAST|NPY_OP_ITFLAG_BUFNEVER))) { - out_strides[iiter] = stride; + out_strides[iop] = stride; } /* If it's a reduction, 0-stride inner loop may have fixed stride */ else if (stride == 0 && (itflags&NPY_ITFLAG_REDUCE)) { /* If it's a reduction operand, definitely fixed stride */ - if (op_itflags[iiter]&NPY_OP_ITFLAG_REDUCE) { - out_strides[iiter] = stride; + if (op_itflags[iop]&NPY_OP_ITFLAG_REDUCE) { + out_strides[iop] = stride; } /* * Otherwise it's a fixed stride if the stride is 0 @@ -2760,17 +2760,17 @@ NpyIter_GetInnerFixedStrideArray(NpyIter *iter, npy_intp *out_strides) int idim, reduce_outerdim = NBF_REDUCE_OUTERDIM(data); for (idim = 0; idim < reduce_outerdim; ++idim) { - if (NAD_STRIDES(axisdata)[iiter] != 0) { + if (NAD_STRIDES(axisdata)[iop] != 0) { break; } NIT_ADVANCE_AXISDATA(axisdata, 1); } /* If all the strides were 0, the stride won't change */ if (idim == reduce_outerdim) { - out_strides[iiter] = stride; + out_strides[iop] = stride; } else { - out_strides[iiter] = NPY_MAX_INTP; + out_strides[iop] = NPY_MAX_INTP; } } } @@ -2778,21 +2778,21 @@ NpyIter_GetInnerFixedStrideArray(NpyIter *iter, npy_intp *out_strides) * Inner loop contiguous array means its stride won't change when * switching between buffering and not buffering */ - else if (ad_strides[iiter] == dtypes[iiter]->elsize) { - out_strides[iiter] = ad_strides[iiter]; + else if (ad_strides[iop] == dtypes[iop]->elsize) { + out_strides[iop] = ad_strides[iop]; } /* * Otherwise the strides can change if the operand is sometimes * buffered, sometimes not. */ else { - out_strides[iiter] = NPY_MAX_INTP; + out_strides[iop] = NPY_MAX_INTP; } } } else { /* If there's no buffering, the strides are always fixed */ - memcpy(out_strides, NAD_STRIDES(axisdata0), niter*NPY_SIZEOF_INTP); + memcpy(out_strides, NAD_STRIDES(axisdata0), nop*NPY_SIZEOF_INTP); } } @@ -2807,7 +2807,7 @@ NpyIter_GetInnerLoopSizePtr(NpyIter *iter) { npy_uint32 itflags = NIT_ITFLAGS(iter); /*int ndim = NIT_NDIM(iter);*/ - int niter = NIT_NITER(iter); + int nop = NIT_NOP(iter); if (itflags&NPY_ITFLAG_BUFFER) { NpyIter_BufferData *data = NIT_BUFFERDATA(iter); @@ -2890,7 +2890,7 @@ npyiter_check_global_flags(npy_uint32 flags, npy_uint32* itflags) } static int -npyiter_calculate_ndim(int niter, PyArrayObject **op_in, +npyiter_calculate_ndim(int nop, PyArrayObject **op_in, int oa_ndim) { /* If 'op_axes' is being used, force 'ndim' */ @@ -2899,11 +2899,11 @@ npyiter_calculate_ndim(int niter, PyArrayObject **op_in, } /* Otherwise it's the maximum 'ndim' from the operands */ else { - int ndim = 0, iiter; + int ndim = 0, iop; - for (iiter = 0; iiter < niter; ++iiter) { - if (op_in[iiter] != NULL) { - int ondim = PyArray_NDIM(op_in[iiter]); + for (iop = 0; iop < nop; ++iop) { + if (op_in[iop] != NULL) { + int ondim = PyArray_NDIM(op_in[iop]); if (ondim > ndim) { ndim = ondim; } @@ -2916,11 +2916,11 @@ npyiter_calculate_ndim(int niter, PyArrayObject **op_in, } static int -npyiter_check_op_axes(int niter, int oa_ndim, int **op_axes, +npyiter_check_op_axes(int nop, int oa_ndim, int **op_axes, npy_intp *itershape) { char axes_dupcheck[NPY_MAXDIMS]; - int iiter, idim; + int iop, idim; if (oa_ndim == 0 && (op_axes != NULL || itershape != NULL)) { PyErr_Format(PyExc_ValueError, @@ -2944,8 +2944,8 @@ npyiter_check_op_axes(int niter, int oa_ndim, int **op_axes, } /* Check that there are no duplicates in op_axes */ - for (iiter = 0; iiter < niter; ++iiter) { - int *axes = op_axes[iiter]; + for (iop = 0; iop < nop; ++iop) { + int *axes = op_axes[iop]; if (axes != NULL) { memset(axes_dupcheck, 0, NPY_MAXDIMS); for (idim = 0; idim < oa_ndim; ++idim) { @@ -2956,14 +2956,14 @@ npyiter_check_op_axes(int niter, int oa_ndim, int **op_axes, "The 'op_axes' provided to the iterator " "constructor for operand %d " "contained invalid " - "values %d", (int)iiter, (int)i); + "values %d", (int)iop, (int)i); return 0; } else if(axes_dupcheck[i] == 1) { PyErr_Format(PyExc_ValueError, "The 'op_axes' provided to the iterator " "constructor for operand %d " "contained duplicate " - "value %d", (int)iiter, (int)i); + "value %d", (int)iop, (int)i); return 0; } else { @@ -3225,7 +3225,7 @@ npyiter_prepare_one_operand(PyArrayObject **op, * can replace the arrays if copying is necessary. */ static int -npyiter_prepare_operands(int niter, PyArrayObject **op_in, +npyiter_prepare_operands(int nop, PyArrayObject **op_in, PyArrayObject **op, char **op_dataptr, PyArray_Descr **op_request_dtypes, @@ -3233,16 +3233,16 @@ npyiter_prepare_operands(int niter, PyArrayObject **op_in, npy_uint32 flags, npy_uint32 *op_flags, char *op_itflags) { - int iiter, i; + int iop, i; - for (iiter = 0; iiter < niter; ++iiter) { - op[iiter] = op_in[iiter]; - Py_XINCREF(op[iiter]); - op_dtype[iiter] = NULL; + for (iop = 0; iop < nop; ++iop) { + op[iop] = op_in[iop]; + Py_XINCREF(op[iop]); + op_dtype[iop] = NULL; /* Check the readonly/writeonly flags, and fill in op_itflags */ - if (!npyiter_check_per_op_flags(op_flags[iiter], &op_itflags[iiter])) { - for (i = 0; i <= iiter; ++i) { + if (!npyiter_check_per_op_flags(op_flags[iop], &op_itflags[iop])) { + for (i = 0; i <= iop; ++i) { Py_XDECREF(op[i]); Py_XDECREF(op_dtype[i]); } @@ -3250,16 +3250,16 @@ npyiter_prepare_operands(int niter, PyArrayObject **op_in, } /* - * Prepare the operand. This produces an op_dtype[iiter] reference + * Prepare the operand. This produces an op_dtype[iop] reference * on success. */ - if (!npyiter_prepare_one_operand(&op[iiter], - &op_dataptr[iiter], - op_request_dtypes ? op_request_dtypes[iiter] : NULL, - &op_dtype[iiter], + if (!npyiter_prepare_one_operand(&op[iop], + &op_dataptr[iop], + op_request_dtypes ? op_request_dtypes[iop] : NULL, + &op_dtype[iop], flags, - op_flags[iiter], &op_itflags[iiter])) { - for (i = 0; i <= iiter; ++i) { + op_flags[iop], &op_itflags[iop])) { + for (i = 0; i <= iop; ++i) { Py_XDECREF(op[i]); Py_XDECREF(op_dtype[i]); } @@ -3271,14 +3271,14 @@ npyiter_prepare_operands(int niter, PyArrayObject **op_in, /* If all the operands were NULL, it's an error */ if (op[0] == NULL) { int all_null = 1; - for (iiter = 1; iiter < niter; ++iiter) { - if (op[iiter] != NULL) { + for (iop = 1; iop < nop; ++iop) { + if (op[iop] != NULL) { all_null = 0; break; } } if (all_null) { - for (i = 0; i < niter; ++i) { + for (i = 0; i < nop; ++i) { Py_XDECREF(op[i]); Py_XDECREF(op_dtype[i]); } @@ -3311,52 +3311,52 @@ npyiter_casting_to_string(NPY_CASTING casting) } static int -npyiter_check_casting(int niter, PyArrayObject **op, +npyiter_check_casting(int nop, PyArrayObject **op, PyArray_Descr **op_dtype, NPY_CASTING casting, char *op_itflags) { - int iiter; + int iop; - for(iiter = 0; iiter < niter; ++iiter) { + for(iop = 0; iop < nop; ++iop) { NPY_IT_DBG_PRINT1("Iterator: Checking casting for operand %d\n", - (int)iiter); + (int)iop); #if NPY_IT_DBG_TRACING printf("op: "); - if (op[iiter] != NULL) { - PyObject_Print((PyObject *)PyArray_DESCR(op[iiter]), stdout, 0); + if (op[iop] != NULL) { + PyObject_Print((PyObject *)PyArray_DESCR(op[iop]), stdout, 0); } else { printf("<null>"); } printf(", iter: "); - PyObject_Print((PyObject *)op_dtype[iiter], stdout, 0); + PyObject_Print((PyObject *)op_dtype[iop], stdout, 0); printf("\n"); #endif /* If the types aren't equivalent, a cast is necessary */ - if (op[iiter] != NULL && !PyArray_EquivTypes(PyArray_DESCR(op[iiter]), - op_dtype[iiter])) { + if (op[iop] != NULL && !PyArray_EquivTypes(PyArray_DESCR(op[iop]), + op_dtype[iop])) { /* Check read (op -> temp) casting */ - if ((op_itflags[iiter]&NPY_OP_ITFLAG_READ) && - !PyArray_CanCastArrayTo(op[iiter], - op_dtype[iiter], + if ((op_itflags[iop]&NPY_OP_ITFLAG_READ) && + !PyArray_CanCastArrayTo(op[iop], + op_dtype[iop], casting)) { PyErr_Format(PyExc_TypeError, "Iterator operand %d dtype could not be cast " "to the requested dtype, according to " - "the casting rule given, %s", (int)iiter, + "the casting rule given, %s", (int)iop, npyiter_casting_to_string(casting)); return 0; } /* Check write (temp -> op) casting */ - if ((op_itflags[iiter]&NPY_OP_ITFLAG_WRITE) && - !PyArray_CanCastTypeTo(op_dtype[iiter], - PyArray_DESCR(op[iiter]), + if ((op_itflags[iop]&NPY_OP_ITFLAG_WRITE) && + !PyArray_CanCastTypeTo(op_dtype[iop], + PyArray_DESCR(op[iop]), casting)) { PyErr_Format(PyExc_TypeError, "Iterator requested dtype could not be cast " "to the operand %d dtype, according to " - "the casting rule given, %s", (int)iiter, + "the casting rule given, %s", (int)iop, npyiter_casting_to_string(casting)); return 0; } @@ -3364,7 +3364,7 @@ npyiter_check_casting(int niter, PyArrayObject **op, NPY_IT_DBG_PRINT("Iterator: Setting NPY_OP_ITFLAG_CAST " "because the types aren't equivalent\n"); /* Indicate that this operand needs casting */ - op_itflags[iiter] |= NPY_OP_ITFLAG_CAST; + op_itflags[iop] |= NPY_OP_ITFLAG_CAST; } } @@ -3421,7 +3421,7 @@ npyiter_shape_string(npy_intp n, npy_intp *vals, char *ending) } /* - * Fills in the AXISDATA for the 'niter' operands, broadcasting + * Fills in the AXISDATA for the 'nop' operands, broadcasting * the dimensionas as necessary. Also fills * in the ITERSIZE data member. * @@ -3439,7 +3439,7 @@ npyiter_fill_axisdata(NpyIter *iter, npy_uint32 flags, char *op_itflags, { npy_uint32 itflags = NIT_ITFLAGS(iter); int idim, ndim = NIT_NDIM(iter); - int iiter, niter = NIT_NITER(iter); + int iop, nop = NIT_NOP(iter); int ondim; NpyIter_AxisData *axisdata; @@ -3462,16 +3462,16 @@ npyiter_fill_axisdata(NpyIter *iter, npy_uint32 flags, char *op_itflags, } } } - for (iiter = 0; iiter < niter; ++iiter) { - op_cur = op[iiter]; + for (iop = 0; iop < nop; ++iop) { + op_cur = op[iop]; if (op_cur != NULL) { npy_intp *shape = PyArray_DIMS(op_cur); ondim = PyArray_NDIM(op_cur); - if (op_axes == NULL || op_axes[iiter] == NULL) { + if (op_axes == NULL || op_axes[iop] == NULL) { /* * Possible if op_axes are being used, but - * op_axes[iiter] is NULL + * op_axes[iop] is NULL */ if (ondim > ndim) { PyErr_SetString(PyExc_ValueError, @@ -3491,7 +3491,7 @@ npyiter_fill_axisdata(NpyIter *iter, npy_uint32 flags, char *op_itflags, } } else { - int *axes = op_axes[iiter]; + int *axes = op_axes[iop]; for (idim = 0; idim < ndim; ++idim) { int i = axes[idim]; if (i >= 0) { @@ -3510,8 +3510,8 @@ npyiter_fill_axisdata(NpyIter *iter, npy_uint32 flags, char *op_itflags, "Iterator input op_axes[%d][%d] (==%d) " "is not a valid axis of op[%d], which " "has %d dimensions ", - (int)iiter, (int)(ndim-idim-1), (int)i, - (int)iiter, (int)ondim); + (int)iop, (int)(ndim-idim-1), (int)i, + (int)iop, (int)ondim); return 0; } } @@ -3532,7 +3532,7 @@ npyiter_fill_axisdata(NpyIter *iter, npy_uint32 flags, char *op_itflags, } axisdata = NIT_AXISDATA(iter); - sizeof_axisdata = NIT_AXISDATA_SIZEOF(itflags, ndim, niter); + sizeof_axisdata = NIT_AXISDATA_SIZEOF(itflags, ndim, nop); /* Now process the operands, filling in the axisdata */ for (idim = 0; idim < ndim; ++idim) { @@ -3541,39 +3541,39 @@ npyiter_fill_axisdata(NpyIter *iter, npy_uint32 flags, char *op_itflags, NAD_SHAPE(axisdata) = bshape; NAD_INDEX(axisdata) = 0; - memcpy(NAD_PTRS(axisdata), op_dataptr, NPY_SIZEOF_INTP*niter); + memcpy(NAD_PTRS(axisdata), op_dataptr, NPY_SIZEOF_INTP*nop); - for (iiter = 0; iiter < niter; ++iiter) { - op_cur = op[iiter]; + for (iop = 0; iop < nop; ++iop) { + op_cur = op[iop]; - if (op_axes == NULL || op_axes[iiter] == NULL) { + if (op_axes == NULL || op_axes[iop] == NULL) { if (op_cur == NULL) { - strides[iiter] = 0; + strides[iop] = 0; } else { ondim = PyArray_NDIM(op_cur); if (bshape == 1) { - strides[iiter] = 0; + strides[iop] = 0; if (idim >= ondim && !output_scalars && - (op_flags[iiter]&NPY_ITER_NO_BROADCAST)) { + (op_flags[iop]&NPY_ITER_NO_BROADCAST)) { goto operand_different_than_broadcast; } } else if (idim >= ondim || PyArray_DIM(op_cur, ondim-idim-1) == 1) { - strides[iiter] = 0; - if (op_flags[iiter]&NPY_ITER_NO_BROADCAST) { + strides[iop] = 0; + if (op_flags[iop]&NPY_ITER_NO_BROADCAST) { goto operand_different_than_broadcast; } /* If it's writeable, this means a reduction */ - if (op_itflags[iiter]&NPY_OP_ITFLAG_WRITE) { + if (op_itflags[iop]&NPY_OP_ITFLAG_WRITE) { if (!(flags&NPY_ITER_REDUCE_OK)) { PyErr_SetString(PyExc_ValueError, "output operand requires a reduction, but " "reduction is not enabled"); return 0; } - if (!(op_itflags[iiter]&NPY_OP_ITFLAG_READ)) { + if (!(op_itflags[iop]&NPY_OP_ITFLAG_READ)) { PyErr_SetString(PyExc_ValueError, "output operand requires a reduction, but " "is flagged as write-only, not " @@ -3581,35 +3581,35 @@ npyiter_fill_axisdata(NpyIter *iter, npy_uint32 flags, char *op_itflags, return 0; } NIT_ITFLAGS(iter) |= NPY_ITFLAG_REDUCE; - op_itflags[iiter] |= NPY_OP_ITFLAG_REDUCE; + op_itflags[iop] |= NPY_OP_ITFLAG_REDUCE; } } else { - strides[iiter] = PyArray_STRIDE(op_cur, ondim-idim-1); + strides[iop] = PyArray_STRIDE(op_cur, ondim-idim-1); } } } else { - int *axes = op_axes[iiter]; + int *axes = op_axes[iop]; int i = axes[ndim-idim-1]; if (i >= 0) { if (bshape == 1 || op_cur == NULL) { - strides[iiter] = 0; + strides[iop] = 0; } else if (PyArray_DIM(op_cur, i) == 1) { - strides[iiter] = 0; - if (op_flags[iiter]&NPY_ITER_NO_BROADCAST) { + strides[iop] = 0; + if (op_flags[iop]&NPY_ITER_NO_BROADCAST) { goto operand_different_than_broadcast; } /* If it's writeable, this means a reduction */ - if (op_itflags[iiter]&NPY_OP_ITFLAG_WRITE) { + if (op_itflags[iop]&NPY_OP_ITFLAG_WRITE) { if (!(flags&NPY_ITER_REDUCE_OK)) { PyErr_SetString(PyExc_ValueError, "output operand requires a reduction, but " "reduction is not enabled"); return 0; } - if (!(op_itflags[iiter]&NPY_OP_ITFLAG_READ)) { + if (!(op_itflags[iop]&NPY_OP_ITFLAG_READ)) { PyErr_SetString(PyExc_ValueError, "output operand requires a reduction, but " "is flagged as write-only, not " @@ -3617,27 +3617,27 @@ npyiter_fill_axisdata(NpyIter *iter, npy_uint32 flags, char *op_itflags, return 0; } NIT_ITFLAGS(iter) |= NPY_ITFLAG_REDUCE; - op_itflags[iiter] |= NPY_OP_ITFLAG_REDUCE; + op_itflags[iop] |= NPY_OP_ITFLAG_REDUCE; } } else { - strides[iiter] = PyArray_STRIDE(op_cur, i); + strides[iop] = PyArray_STRIDE(op_cur, i); } } else if (bshape == 1) { - strides[iiter] = 0; + strides[iop] = 0; } else { - strides[iiter] = 0; + strides[iop] = 0; /* If it's writeable, this means a reduction */ - if (op_itflags[iiter]&NPY_OP_ITFLAG_WRITE) { + if (op_itflags[iop]&NPY_OP_ITFLAG_WRITE) { if (!(flags&NPY_ITER_REDUCE_OK)) { PyErr_SetString(PyExc_ValueError, "output operand requires a reduction, but " "reduction is not enabled"); return 0; } - if (!(op_itflags[iiter]&NPY_OP_ITFLAG_READ)) { + if (!(op_itflags[iop]&NPY_OP_ITFLAG_READ)) { PyErr_SetString(PyExc_ValueError, "output operand requires a reduction, but " "is flagged as write-only, not " @@ -3645,7 +3645,7 @@ npyiter_fill_axisdata(NpyIter *iter, npy_uint32 flags, char *op_itflags, return 0; } NIT_ITFLAGS(iter) |= NPY_ITFLAG_REDUCE; - op_itflags[iiter] |= NPY_OP_ITFLAG_REDUCE; + op_itflags[iop] |= NPY_OP_ITFLAG_REDUCE; } } } @@ -3676,10 +3676,10 @@ broadcast_error: { if (errmsg == NULL) { return 0; } - for (iiter = 0; iiter < niter; ++iiter) { - if (op[iiter] != NULL) { - tmp = npyiter_shape_string(PyArray_NDIM(op[iiter]), - PyArray_DIMS(op[iiter]), + for (iop = 0; iop < nop; ++iop) { + if (op[iop] != NULL) { + tmp = npyiter_shape_string(PyArray_NDIM(op[iop]), + PyArray_DIMS(op[iop]), " "); if (tmp == NULL) { Py_DECREF(errmsg); @@ -3719,13 +3719,13 @@ broadcast_error: { errmsg = PyUString_FromString("operands could not be broadcast " "together with remapped shapes " "[original->remapped]: "); - for (iiter = 0; iiter < niter; ++iiter) { - if (op[iiter] != NULL) { - int *axes = op_axes[iiter]; + for (iop = 0; iop < nop; ++iop) { + if (op[iop] != NULL) { + int *axes = op_axes[iop]; tmpstr = (axes == NULL) ? " " : "->"; - tmp = npyiter_shape_string(PyArray_NDIM(op[iiter]), - PyArray_DIMS(op[iiter]), + tmp = npyiter_shape_string(PyArray_NDIM(op[iop]), + PyArray_DIMS(op[iop]), tmpstr); if (tmp == NULL) { return 0; @@ -3739,8 +3739,8 @@ broadcast_error: { for (idim = 0; idim < ndim; ++idim) { npy_intp i = axes[idim]; - if (i >= 0 && i < PyArray_NDIM(op[iiter])) { - remdims[idim] = PyArray_DIM(op[iiter], i); + if (i >= 0 && i < PyArray_NDIM(op[iop])) { + remdims[idim] = PyArray_DIM(op[iop], i); } else { remdims[idim] = -1; @@ -3790,7 +3790,7 @@ operand_different_than_broadcast: { PyObject *errmsg, *tmp; /* Start of error message */ - if (op_flags[iiter]&NPY_ITER_READONLY) { + if (op_flags[iop]&NPY_ITER_READONLY) { errmsg = PyUString_FromString("non-broadcastable operand " "with shape "); } @@ -3803,8 +3803,8 @@ operand_different_than_broadcast: { } /* Operand shape */ - tmp = npyiter_shape_string(PyArray_NDIM(op[iiter]), - PyArray_DIMS(op[iiter]), ""); + tmp = npyiter_shape_string(PyArray_NDIM(op[iop]), + PyArray_DIMS(op[iop]), ""); if (tmp == NULL) { return 0; } @@ -3813,14 +3813,14 @@ operand_different_than_broadcast: { return 0; } /* Remapped operand shape */ - if (op_axes != NULL && op_axes[iiter] != NULL) { - int *axes = op_axes[iiter]; + if (op_axes != NULL && op_axes[iop] != NULL) { + int *axes = op_axes[iop]; for (idim = 0; idim < ndim; ++idim) { npy_intp i = axes[ndim-idim-1]; - if (i >= 0 && i < PyArray_NDIM(op[iiter])) { - remdims[idim] = PyArray_DIM(op[iiter], i); + if (i >= 0 && i < PyArray_NDIM(op[iop])) { + remdims[idim] = PyArray_DIM(op[iop], i); } else { remdims[idim] = -1; @@ -3880,7 +3880,7 @@ operand_different_than_broadcast: { } /* - * Replaces the AXISDATA for the iiter'th operand, broadcasting + * Replaces the AXISDATA for the iop'th operand, broadcasting * the dimensions as necessary. Assumes the replacement array is * exactly the same shape as the original array used when * npy_fill_axisdata was called. @@ -3889,14 +3889,14 @@ operand_different_than_broadcast: { * array. */ static void -npyiter_replace_axisdata(NpyIter *iter, int iiter, +npyiter_replace_axisdata(NpyIter *iter, int iop, PyArrayObject *op, int op_ndim, char *op_dataptr, int *op_axes) { npy_uint32 itflags = NIT_ITFLAGS(iter); int idim, ndim = NIT_NDIM(iter); - int niter = NIT_NITER(iter); + int nop = NIT_NOP(iter); NpyIter_AxisData *axisdata0, *axisdata; npy_intp sizeof_axisdata; @@ -3905,7 +3905,7 @@ npyiter_replace_axisdata(NpyIter *iter, int iiter, perm = NIT_PERM(iter); axisdata0 = NIT_AXISDATA(iter); - sizeof_axisdata = NIT_AXISDATA_SIZEOF(itflags, ndim, niter); + sizeof_axisdata = NIT_AXISDATA_SIZEOF(itflags, ndim, nop); /* * Replace just the strides which were non-zero, and compute @@ -3934,11 +3934,11 @@ npyiter_replace_axisdata(NpyIter *iter, int iiter, npy_intp stride = PyArray_STRIDE(op, i); if (p < 0) { /* If the perm entry is negative, flip the axis */ - NAD_STRIDES(axisdata)[iiter] = -stride; + NAD_STRIDES(axisdata)[iop] = -stride; baseoffset += stride*(shape-1); } else { - NAD_STRIDES(axisdata)[iiter] = stride; + NAD_STRIDES(axisdata)[iop] = stride; } } } @@ -3965,11 +3965,11 @@ npyiter_replace_axisdata(NpyIter *iter, int iiter, npy_intp stride = PyArray_STRIDE(op, i); if (p < 0) { /* If the perm entry is negative, flip the axis */ - NAD_STRIDES(axisdata)[iiter] = -stride; + NAD_STRIDES(axisdata)[iop] = -stride; baseoffset += stride*(shape-1); } else { - NAD_STRIDES(axisdata)[iiter] = stride; + NAD_STRIDES(axisdata)[iop] = stride; } } } @@ -3979,11 +3979,11 @@ npyiter_replace_axisdata(NpyIter *iter, int iiter, op_dataptr += baseoffset; /* Now the base data pointer is calculated, set it everywhere it's needed */ - NIT_RESETDATAPTR(iter)[iiter] = op_dataptr; - NIT_BASEOFFSETS(iter)[iiter] = baseoffset; + NIT_RESETDATAPTR(iter)[iop] = op_dataptr; + NIT_BASEOFFSETS(iter)[iop] = baseoffset; axisdata = axisdata0; for (idim = 0; idim < ndim; ++idim, NIT_ADVANCE_AXISDATA(axisdata, 1)) { - NAD_PTRS(axisdata)[iiter] = op_dataptr; + NAD_PTRS(axisdata)[iop] = op_dataptr; } } @@ -3999,7 +3999,7 @@ npyiter_compute_index_strides(NpyIter *iter, npy_uint32 flags) { npy_uint32 itflags = NIT_ITFLAGS(iter); int idim, ndim = NIT_NDIM(iter); - int niter = NIT_NITER(iter); + int nop = NIT_NOP(iter); npy_intp indexstride; NpyIter_AxisData *axisdata; @@ -4013,42 +4013,42 @@ npyiter_compute_index_strides(NpyIter *iter, npy_uint32 flags) if (NIT_ITERSIZE(iter) == 1) { if (itflags&NPY_ITFLAG_HASINDEX) { axisdata = NIT_AXISDATA(iter); - NAD_PTRS(axisdata)[niter] = 0; + NAD_PTRS(axisdata)[nop] = 0; } return; } if (flags&NPY_ITER_C_INDEX) { - sizeof_axisdata = NIT_AXISDATA_SIZEOF(itflags, ndim, niter); + sizeof_axisdata = NIT_AXISDATA_SIZEOF(itflags, ndim, nop); axisdata = NIT_AXISDATA(iter); indexstride = 1; for(idim = 0; idim < ndim; ++idim, NIT_ADVANCE_AXISDATA(axisdata, 1)) { npy_intp shape = NAD_SHAPE(axisdata); if (shape == 1) { - NAD_STRIDES(axisdata)[niter] = 0; + NAD_STRIDES(axisdata)[nop] = 0; } else { - NAD_STRIDES(axisdata)[niter] = indexstride; + NAD_STRIDES(axisdata)[nop] = indexstride; } - NAD_PTRS(axisdata)[niter] = 0; + NAD_PTRS(axisdata)[nop] = 0; indexstride *= shape; } } else if (flags&NPY_ITER_F_INDEX) { - sizeof_axisdata = NIT_AXISDATA_SIZEOF(itflags, ndim, niter); + sizeof_axisdata = NIT_AXISDATA_SIZEOF(itflags, ndim, nop); axisdata = NIT_INDEX_AXISDATA(NIT_AXISDATA(iter), ndim-1); indexstride = 1; for(idim = 0; idim < ndim; ++idim, NIT_ADVANCE_AXISDATA(axisdata, -1)) { npy_intp shape = NAD_SHAPE(axisdata); if (shape == 1) { - NAD_STRIDES(axisdata)[niter] = 0; + NAD_STRIDES(axisdata)[nop] = 0; } else { - NAD_STRIDES(axisdata)[niter] = indexstride; + NAD_STRIDES(axisdata)[nop] = indexstride; } - NAD_PTRS(axisdata)[niter] = 0; + NAD_PTRS(axisdata)[nop] = 0; indexstride *= shape; } } @@ -4064,7 +4064,7 @@ npyiter_apply_forced_iteration_order(NpyIter *iter, NPY_ORDER order) { /*npy_uint32 itflags = NIT_ITFLAGS(iter);*/ int ndim = NIT_NDIM(iter); - int iiter, niter = NIT_NITER(iter); + int iop, nop = NIT_NOP(iter); switch (order) { case NPY_CORDER: @@ -4085,7 +4085,7 @@ npyiter_apply_forced_iteration_order(NpyIter *iter, NPY_ORDER order) int forder = 1; /* Check that all the array inputs are fortran order */ - for (iiter = 0; iiter < niter; ++iiter, ++op) { + for (iop = 0; iop < nop; ++iop, ++op) { if (*op && !PyArray_CHKFLAGS(*op, NPY_F_CONTIGUOUS)) { forder = 0; break; @@ -4115,12 +4115,12 @@ npyiter_flip_negative_strides(NpyIter *iter) { npy_uint32 itflags = NIT_ITFLAGS(iter); int idim, ndim = NIT_NDIM(iter); - int iiter, niter = NIT_NITER(iter); + int iop, nop = NIT_NOP(iter); npy_intp istrides, nstrides = NAD_NSTRIDES(); NpyIter_AxisData *axisdata, *axisdata0; npy_intp *baseoffsets; - npy_intp sizeof_axisdata = NIT_AXISDATA_SIZEOF(itflags, ndim, niter); + npy_intp sizeof_axisdata = NIT_AXISDATA_SIZEOF(itflags, ndim, nop); int any_flipped = 0; axisdata0 = axisdata = NIT_AXISDATA(iter); @@ -4133,11 +4133,11 @@ npyiter_flip_negative_strides(NpyIter *iter) * Check the signs of all the strides, excluding * the index stride at the end. */ - for (iiter = 0; iiter < niter; ++iiter) { - if (strides[iiter] < 0) { + for (iop = 0; iop < nop; ++iop) { + if (strides[iop] < 0) { any_negative = 1; } - else if (strides[iiter] != 0) { + else if (strides[iop] != 0) { break; } } @@ -4145,7 +4145,7 @@ npyiter_flip_negative_strides(NpyIter *iter) * If at least on stride is negative and none are positive, * flip all the strides for this dimension. */ - if (any_negative && iiter == niter) { + if (any_negative && iop == nop) { npy_intp shapem1 = NAD_SHAPE(axisdata) - 1; for (istrides = 0; istrides < nstrides; ++istrides) { @@ -4197,13 +4197,13 @@ npyiter_reverse_axis_ordering(NpyIter *iter) { npy_uint32 itflags = NIT_ITFLAGS(iter); int ndim = NIT_NDIM(iter); - int niter = NIT_NITER(iter); + int nop = NIT_NOP(iter); npy_intp i, temp, size; npy_intp *first, *last; char *perm; - size = NIT_AXISDATA_SIZEOF(itflags, ndim, niter)/NPY_SIZEOF_INTP; + size = NIT_AXISDATA_SIZEOF(itflags, ndim, nop)/NPY_SIZEOF_INTP; first = (npy_intp*)NIT_AXISDATA(iter); last = first + (ndim-1)*size; @@ -4237,13 +4237,13 @@ npyiter_find_best_axis_ordering(NpyIter *iter) { npy_uint32 itflags = NIT_ITFLAGS(iter); int idim, ndim = NIT_NDIM(iter); - int iiter, niter = NIT_NITER(iter); + int iop, nop = NIT_NOP(iter); npy_intp ax_i0, ax_i1, ax_ipos; char ax_j0, ax_j1; char *perm; NpyIter_AxisData *axisdata = NIT_AXISDATA(iter); - npy_intp sizeof_axisdata = NIT_AXISDATA_SIZEOF(itflags, ndim, niter); + npy_intp sizeof_axisdata = NIT_AXISDATA_SIZEOF(itflags, ndim, nop); int permuted = 0; perm = NIT_PERM(iter); @@ -4269,10 +4269,10 @@ npyiter_find_best_axis_ordering(NpyIter *iter) strides1 = NAD_STRIDES(NIT_INDEX_AXISDATA(axisdata, ax_j1)); - for (iiter = 0; iiter < niter; ++iiter) { - if (strides0[iiter] != 0 && strides1[iiter] != 0) { - if (intp_abs(strides1[iiter]) <= - intp_abs(strides0[iiter])) { + for (iop = 0; iop < nop; ++iop) { + if (strides0[iop] != 0 && strides1[iop] != 0) { + if (intp_abs(strides1[iop]) <= + intp_abs(strides0[iop])) { /* * Set swap even if it's not ambiguous already, * because in the case of conflicts between @@ -4377,11 +4377,11 @@ npyiter_coalesce_axes(NpyIter *iter) { npy_uint32 itflags = NIT_ITFLAGS(iter); int idim, ndim = NIT_NDIM(iter); - int niter = NIT_NITER(iter); + int nop = NIT_NOP(iter); npy_intp istrides, nstrides = NAD_NSTRIDES(); NpyIter_AxisData *axisdata = NIT_AXISDATA(iter); - npy_intp sizeof_axisdata = NIT_AXISDATA_SIZEOF(itflags, ndim, niter); + npy_intp sizeof_axisdata = NIT_AXISDATA_SIZEOF(itflags, ndim, nop); NpyIter_AxisData *ad_compress; npy_intp new_ndim = 1; @@ -4462,7 +4462,7 @@ npyiter_new_temp_array(NpyIter *iter, PyTypeObject *subtype, { npy_uint32 itflags = NIT_ITFLAGS(iter); int idim, ndim = NIT_NDIM(iter); - int niter = NIT_NITER(iter); + int nop = NIT_NOP(iter); char *perm = NIT_PERM(iter); npy_intp new_shape[NPY_MAXDIMS], strides[NPY_MAXDIMS], @@ -4493,7 +4493,7 @@ npyiter_new_temp_array(NpyIter *iter, PyTypeObject *subtype, } axisdata = NIT_AXISDATA(iter); - sizeof_axisdata = NIT_AXISDATA_SIZEOF(itflags, ndim, niter); + sizeof_axisdata = NIT_AXISDATA_SIZEOF(itflags, ndim, nop); memset(reversestride, 0, NPY_MAXDIMS); /* Initialize the strides to invalid values */ @@ -4560,8 +4560,8 @@ npyiter_new_temp_array(NpyIter *iter, PyTypeObject *subtype, return NULL; } - NPY_IT_DBG_PRINT("Iterator: Indicating that a reduction " - "is occurring\n"); + NPY_IT_DBG_PRINT("Iterator: Indicating that a " + "reduction is occurring\n"); /* Indicate that a reduction is occurring */ NIT_ITFLAGS(iter) |= NPY_ITFLAG_REDUCE; (*op_itflags) |= NPY_OP_ITFLAG_REDUCE; @@ -4734,7 +4734,7 @@ npyiter_allocate_arrays(NpyIter *iter, { npy_uint32 itflags = NIT_ITFLAGS(iter); int idim, ndim = NIT_NDIM(iter); - int iiter, niter = NIT_NITER(iter); + int iop, nop = NIT_NOP(iter); NpyIter_BufferData *bufferdata = NULL; PyArrayObject **op = NIT_OPERANDS(iter); @@ -4744,136 +4744,136 @@ npyiter_allocate_arrays(NpyIter *iter, } - for (iiter = 0; iiter < niter; ++iiter) { + for (iop = 0; iop < nop; ++iop) { /* NULL means an output the iterator should allocate */ - if (op[iiter] == NULL) { + if (op[iop] == NULL) { PyArrayObject *out; PyTypeObject *op_subtype; int ondim = output_scalars ? 0 : ndim; /* Check whether the subtype was disabled */ - op_subtype = (op_flags[iiter]&NPY_ITER_NO_SUBTYPE) ? + op_subtype = (op_flags[iop]&NPY_ITER_NO_SUBTYPE) ? &PyArray_Type : subtype; /* Allocate the output array */ out = npyiter_new_temp_array(iter, op_subtype, - flags, &op_itflags[iiter], + flags, &op_itflags[iop], ondim, NULL, - op_dtype[iiter], - op_axes ? op_axes[iiter] : NULL); + op_dtype[iop], + op_axes ? op_axes[iop] : NULL); if (out == NULL) { return 0; } - op[iiter] = out; + op[iop] = out; /* * Now we need to replace the pointers and strides with values * from the new array. */ - npyiter_replace_axisdata(iter, iiter, op[iiter], ondim, - PyArray_DATA(op[iiter]), op_axes ? op_axes[iiter] : NULL); + npyiter_replace_axisdata(iter, iop, op[iop], ondim, + PyArray_DATA(op[iop]), op_axes ? op_axes[iop] : NULL); /* New arrays are aligned and need no cast */ - op_itflags[iiter] |= NPY_OP_ITFLAG_ALIGNED; - op_itflags[iiter] &= ~NPY_OP_ITFLAG_CAST; + op_itflags[iop] |= NPY_OP_ITFLAG_ALIGNED; + op_itflags[iop] &= ~NPY_OP_ITFLAG_CAST; } /* * If casting is required, the operand is read-only, and * it's an array scalar, make a copy whether or not the * copy flag is enabled. */ - else if ((op_itflags[iiter]&(NPY_OP_ITFLAG_CAST| + else if ((op_itflags[iop]&(NPY_OP_ITFLAG_CAST| NPY_OP_ITFLAG_READ| NPY_OP_ITFLAG_WRITE)) == (NPY_OP_ITFLAG_CAST| NPY_OP_ITFLAG_READ) && - PyArray_NDIM(op[iiter]) == 0) { + PyArray_NDIM(op[iop]) == 0) { PyArrayObject *temp; - Py_INCREF(op_dtype[iiter]); + Py_INCREF(op_dtype[iop]); temp = (PyArrayObject *)PyArray_NewFromDescr( - &PyArray_Type, op_dtype[iiter], + &PyArray_Type, op_dtype[iop], 0, NULL, NULL, NULL, 0, NULL); if (temp == NULL) { return 0; } - if (PyArray_CopyInto(temp, op[iiter]) != 0) { + if (PyArray_CopyInto(temp, op[iop]) != 0) { Py_DECREF(temp); return 0; } - Py_DECREF(op[iiter]); - op[iiter] = temp; + Py_DECREF(op[iop]); + op[iop] = temp; /* * Now we need to replace the pointers and strides with values * from the temporary array. */ - npyiter_replace_axisdata(iter, iiter, op[iiter], 0, - PyArray_DATA(op[iiter]), NULL); + npyiter_replace_axisdata(iter, iop, op[iop], 0, + PyArray_DATA(op[iop]), NULL); /* * New arrays are aligned need no cast, and in the case * of scalars, always have stride 0 so never need buffering */ - op_itflags[iiter] |= (NPY_OP_ITFLAG_ALIGNED| + op_itflags[iop] |= (NPY_OP_ITFLAG_ALIGNED| NPY_OP_ITFLAG_BUFNEVER); - op_itflags[iiter] &= ~NPY_OP_ITFLAG_CAST; + op_itflags[iop] &= ~NPY_OP_ITFLAG_CAST; if (itflags&NPY_ITFLAG_BUFFER) { - NBF_STRIDES(bufferdata)[iiter] = 0; + NBF_STRIDES(bufferdata)[iop] = 0; } } /* If casting is required and permitted */ - else if ((op_itflags[iiter]&NPY_OP_ITFLAG_CAST) && - (op_flags[iiter]&(NPY_ITER_COPY|NPY_ITER_UPDATEIFCOPY))) { + else if ((op_itflags[iop]&NPY_OP_ITFLAG_CAST) && + (op_flags[iop]&(NPY_ITER_COPY|NPY_ITER_UPDATEIFCOPY))) { PyArrayObject *temp; - int ondim = PyArray_NDIM(op[iiter]); + int ondim = PyArray_NDIM(op[iop]); /* Allocate the temporary array, if possible */ temp = npyiter_new_temp_array(iter, &PyArray_Type, - flags, &op_itflags[iiter], + flags, &op_itflags[iop], ondim, - PyArray_DIMS(op[iiter]), - op_dtype[iiter], - op_axes ? op_axes[iiter] : NULL); + PyArray_DIMS(op[iop]), + op_dtype[iop], + op_axes ? op_axes[iop] : NULL); if (temp == NULL) { return 0; } /* If the data will be read, copy it into temp */ - if (op_itflags[iiter]&NPY_OP_ITFLAG_READ) { - if (PyArray_CopyInto(temp, op[iiter]) != 0) { + if (op_itflags[iop]&NPY_OP_ITFLAG_READ) { + if (PyArray_CopyInto(temp, op[iop]) != 0) { Py_DECREF(temp); return 0; } } /* If the data will be written to, set UPDATEIFCOPY */ - if (op_itflags[iiter]&NPY_OP_ITFLAG_WRITE) { + if (op_itflags[iop]&NPY_OP_ITFLAG_WRITE) { PyArray_FLAGS(temp) |= NPY_UPDATEIFCOPY; - PyArray_FLAGS(op[iiter]) &= ~NPY_WRITEABLE; - Py_INCREF(op[iiter]); - temp->base = (PyObject *)op[iiter]; + PyArray_FLAGS(op[iop]) &= ~NPY_WRITEABLE; + Py_INCREF(op[iop]); + temp->base = (PyObject *)op[iop]; } - Py_DECREF(op[iiter]); - op[iiter] = temp; + Py_DECREF(op[iop]); + op[iop] = temp; /* * Now we need to replace the pointers and strides with values * from the temporary array. */ - npyiter_replace_axisdata(iter, iiter, op[iiter], ondim, - PyArray_DATA(op[iiter]), op_axes ? op_axes[iiter] : NULL); + npyiter_replace_axisdata(iter, iop, op[iop], ondim, + PyArray_DATA(op[iop]), op_axes ? op_axes[iop] : NULL); /* The temporary copy is aligned and needs no cast */ - op_itflags[iiter] |= NPY_OP_ITFLAG_ALIGNED; - op_itflags[iiter] &= ~NPY_OP_ITFLAG_CAST; + op_itflags[iop] |= NPY_OP_ITFLAG_ALIGNED; + op_itflags[iop] &= ~NPY_OP_ITFLAG_CAST; } else { /* * Buffering must be enabled for casting/conversion if copy * wasn't specified. */ - if ((op_itflags[iiter]&NPY_OP_ITFLAG_CAST) && + if ((op_itflags[iop]&NPY_OP_ITFLAG_CAST) && !(itflags&NPY_ITFLAG_BUFFER)) { PyErr_SetString(PyExc_TypeError, "Iterator operand required copying or buffering, " @@ -4885,20 +4885,20 @@ npyiter_allocate_arrays(NpyIter *iter, * If the operand is aligned, any buffering can use aligned * optimizations. */ - if (PyArray_ISALIGNED(op[iiter])) { - op_itflags[iiter] |= NPY_OP_ITFLAG_ALIGNED; + if (PyArray_ISALIGNED(op[iop])) { + op_itflags[iop] |= NPY_OP_ITFLAG_ALIGNED; } } /* Here we can finally check for contiguous iteration */ - if (op_flags[iiter]&NPY_ITER_CONTIG) { + if (op_flags[iop]&NPY_ITER_CONTIG) { NpyIter_AxisData *axisdata = NIT_AXISDATA(iter); - npy_intp stride = NAD_STRIDES(axisdata)[iiter]; + npy_intp stride = NAD_STRIDES(axisdata)[iop]; - if (stride != op_dtype[iiter]->elsize) { + if (stride != op_dtype[iop]->elsize) { NPY_IT_DBG_PRINT("Iterator: Setting NPY_OP_ITFLAG_CAST " "because of NPY_ITER_CONTIG\n"); - op_itflags[iiter] |= NPY_OP_ITFLAG_CAST; + op_itflags[iop] |= NPY_OP_ITFLAG_CAST; if (!(itflags&NPY_ITFLAG_BUFFER)) { PyErr_SetString(PyExc_TypeError, "Iterator operand required buffering, " @@ -4914,21 +4914,21 @@ npyiter_allocate_arrays(NpyIter *iter, * the inner stride of this operand works for the whole * array, we can set NPY_OP_ITFLAG_BUFNEVER. */ - if ((itflags&NPY_ITFLAG_BUFFER) && !(op_itflags[iiter]&NPY_OP_ITFLAG_CAST)) { + if ((itflags&NPY_ITFLAG_BUFFER) && !(op_itflags[iop]&NPY_OP_ITFLAG_CAST)) { NpyIter_AxisData *axisdata = NIT_AXISDATA(iter); if (ndim == 1) { - op_itflags[iiter] |= NPY_OP_ITFLAG_BUFNEVER; - NBF_STRIDES(bufferdata)[iiter] = NAD_STRIDES(axisdata)[iiter]; + op_itflags[iop] |= NPY_OP_ITFLAG_BUFNEVER; + NBF_STRIDES(bufferdata)[iop] = NAD_STRIDES(axisdata)[iop]; } - else if (PyArray_NDIM(op[iiter]) > 0) { + else if (PyArray_NDIM(op[iop]) > 0) { npy_intp stride, shape, innerstride = 0, innershape; npy_intp sizeof_axisdata = - NIT_AXISDATA_SIZEOF(itflags, ndim, niter); + NIT_AXISDATA_SIZEOF(itflags, ndim, nop); /* Find stride of the first non-empty shape */ for (idim = 0; idim < ndim; ++idim) { innershape = NAD_SHAPE(axisdata); if (innershape != 1) { - innerstride = NAD_STRIDES(axisdata)[iiter]; + innerstride = NAD_STRIDES(axisdata)[iop]; break; } NIT_ADVANCE_AXISDATA(axisdata, 1); @@ -4937,7 +4937,7 @@ npyiter_allocate_arrays(NpyIter *iter, NIT_ADVANCE_AXISDATA(axisdata, 1); /* Check that everything could have coalesced together */ for (; idim < ndim; ++idim) { - stride = NAD_STRIDES(axisdata)[iiter]; + stride = NAD_STRIDES(axisdata)[iop]; shape = NAD_SHAPE(axisdata); if (shape != 1) { /* @@ -4959,8 +4959,8 @@ npyiter_allocate_arrays(NpyIter *iter, * dimension. */ if (idim == ndim) { - op_itflags[iiter] |= NPY_OP_ITFLAG_BUFNEVER; - NBF_STRIDES(bufferdata)[iiter] = innerstride; + op_itflags[iop] |= NPY_OP_ITFLAG_BUFNEVER; + NBF_STRIDES(bufferdata)[iop] = innerstride; } } } @@ -4975,19 +4975,19 @@ npyiter_allocate_arrays(NpyIter *iter, * subtype of the input array with highest priority. */ static void -npyiter_get_priority_subtype(int niter, PyArrayObject **op, +npyiter_get_priority_subtype(int nop, PyArrayObject **op, char *op_itflags, double *subtype_priority, PyTypeObject **subtype) { - int iiter; + int iop; - for (iiter = 0; iiter < niter; ++iiter) { - if (op[iiter] != NULL && op_itflags[iiter]&NPY_OP_ITFLAG_READ) { - double priority = PyArray_GetPriority((PyObject *)op[iiter], 0.0); + for (iop = 0; iop < nop; ++iop) { + if (op[iop] != NULL && op_itflags[iop]&NPY_OP_ITFLAG_READ) { + double priority = PyArray_GetPriority((PyObject *)op[iop], 0.0); if (priority > *subtype_priority) { *subtype_priority = priority; - *subtype = Py_TYPE(op[iiter]); + *subtype = Py_TYPE(op[iop]); } } } @@ -4999,12 +4999,12 @@ npyiter_get_priority_subtype(int niter, PyArrayObject **op, * are not read from out of the calculation. */ static PyArray_Descr * -npyiter_get_common_dtype(int niter, PyArrayObject **op, +npyiter_get_common_dtype(int nop, PyArrayObject **op, char *op_itflags, PyArray_Descr **op_dtype, PyArray_Descr **op_request_dtypes, int only_inputs, int output_scalars) { - int iiter; + int iop; npy_intp narrs = 0, ndtypes = 0; PyArrayObject *arrs[NPY_MAXARGS]; PyArray_Descr *dtypes[NPY_MAXARGS]; @@ -5012,18 +5012,18 @@ npyiter_get_common_dtype(int niter, PyArrayObject **op, NPY_IT_DBG_PRINT("Iterator: Getting a common data type from operands\n"); - for (iiter = 0; iiter < niter; ++iiter) { - if (op_dtype[iiter] != NULL && - (!only_inputs || (op_itflags[iiter]&NPY_OP_ITFLAG_READ))) { + for (iop = 0; iop < nop; ++iop) { + if (op_dtype[iop] != NULL && + (!only_inputs || (op_itflags[iop]&NPY_OP_ITFLAG_READ))) { /* If no dtype was requested and the op is a scalar, pass the op */ if ((op_request_dtypes == NULL || - op_request_dtypes[iiter] == NULL) && - PyArray_NDIM(op[iiter]) == 0) { - arrs[narrs++] = op[iiter]; + op_request_dtypes[iop] == NULL) && + PyArray_NDIM(op[iop]) == 0) { + arrs[narrs++] = op[iop]; } /* Otherwise just pass in the dtype */ else { - dtypes[ndtypes++] = op_dtype[iiter]; + dtypes[ndtypes++] = op_dtype[iop]; } } } @@ -5059,7 +5059,7 @@ npyiter_allocate_transfer_functions(NpyIter *iter) { npy_uint32 itflags = NIT_ITFLAGS(iter); /*int ndim = NIT_NDIM(iter);*/ - int iiter = 0, niter = NIT_NITER(iter); + int iop = 0, nop = NIT_NOP(iter); npy_intp i; char *op_itflags = NIT_OPITFLAGS(iter); @@ -5077,14 +5077,14 @@ npyiter_allocate_transfer_functions(NpyIter *iter) void *transferdata = NULL; int needs_api = 0; - for (iiter = 0; iiter < niter; ++iiter) { - char flags = op_itflags[iiter]; + for (iop = 0; iop < nop; ++iop) { + char flags = op_itflags[iop]; /* * Reduction operands may be buffered with a different stride, * so we must pass NPY_MAX_INTP to the transfer function factory. */ op_stride = (flags&NPY_OP_ITFLAG_REDUCE) ? NPY_MAX_INTP : - strides[iiter]; + strides[iop]; /* * If we have determined that a buffer may be needed, @@ -5096,40 +5096,40 @@ npyiter_allocate_transfer_functions(NpyIter *iter) if (PyArray_GetDTypeTransferFunction( (flags&NPY_OP_ITFLAG_ALIGNED) != 0, op_stride, - op_dtype[iiter]->elsize, - PyArray_DESCR(op[iiter]), - op_dtype[iiter], + op_dtype[iop]->elsize, + PyArray_DESCR(op[iop]), + op_dtype[iop], move_references, &stransfer, &transferdata, &needs_api) != NPY_SUCCEED) { goto fail; } - readtransferfn[iiter] = stransfer; - readtransferdata[iiter] = transferdata; + readtransferfn[iop] = stransfer; + readtransferdata[iop] = transferdata; } else { - readtransferfn[iiter] = NULL; + readtransferfn[iop] = NULL; } if (flags&NPY_OP_ITFLAG_WRITE) { int move_references = 1; if (PyArray_GetDTypeTransferFunction( (flags&NPY_OP_ITFLAG_ALIGNED) != 0, - op_dtype[iiter]->elsize, + op_dtype[iop]->elsize, op_stride, - op_dtype[iiter], - PyArray_DESCR(op[iiter]), + op_dtype[iop], + PyArray_DESCR(op[iop]), move_references, &stransfer, &transferdata, &needs_api) != NPY_SUCCEED) { goto fail; } - writetransferfn[iiter] = stransfer; - writetransferdata[iiter] = transferdata; + writetransferfn[iop] = stransfer; + writetransferdata[iop] = transferdata; } /* If no write back but there are references make a decref fn */ - else if (PyDataType_REFCHK(op_dtype[iiter])) { + else if (PyDataType_REFCHK(op_dtype[iop])) { /* * By passing NULL to dst_type and setting move_references * to 1, we get back a function that just decrements the @@ -5137,24 +5137,24 @@ npyiter_allocate_transfer_functions(NpyIter *iter) */ if (PyArray_GetDTypeTransferFunction( (flags&NPY_OP_ITFLAG_ALIGNED) != 0, - op_dtype[iiter]->elsize, 0, - op_dtype[iiter], NULL, + op_dtype[iop]->elsize, 0, + op_dtype[iop], NULL, 1, &stransfer, &transferdata, &needs_api) != NPY_SUCCEED) { goto fail; } - writetransferfn[iiter] = stransfer; - writetransferdata[iiter] = transferdata; + writetransferfn[iop] = stransfer; + writetransferdata[iop] = transferdata; } else { - writetransferfn[iiter] = NULL; + writetransferfn[iop] = NULL; } } else { - readtransferfn[iiter] = NULL; - writetransferfn[iiter] = NULL; + readtransferfn[iop] = NULL; + writetransferfn[iop] = NULL; } } @@ -5166,14 +5166,14 @@ npyiter_allocate_transfer_functions(NpyIter *iter) return 1; fail: - for (i = 0; i < iiter; ++i) { - if (readtransferdata[iiter] != NULL) { - PyArray_FreeStridedTransferData(readtransferdata[iiter]); - readtransferdata[iiter] = NULL; + for (i = 0; i < iop; ++i) { + if (readtransferdata[iop] != NULL) { + PyArray_FreeStridedTransferData(readtransferdata[iop]); + readtransferdata[iop] = NULL; } - if (writetransferdata[iiter] != NULL) { - PyArray_FreeStridedTransferData(writetransferdata[iiter]); - writetransferdata[iiter] = NULL; + if (writetransferdata[iop] != NULL) { + PyArray_FreeStridedTransferData(writetransferdata[iop]); + writetransferdata[iop] = NULL; } } return 0; @@ -5191,7 +5191,7 @@ npyiter_allocate_buffers(NpyIter *iter, char **errmsg) { /*npy_uint32 itflags = NIT_ITFLAGS(iter);*/ /*int ndim = NIT_NDIM(iter);*/ - int iiter = 0, niter = NIT_NITER(iter); + int iop = 0, nop = NIT_NOP(iter); npy_intp i; char *op_itflags = NIT_OPITFLAGS(iter); @@ -5200,15 +5200,15 @@ npyiter_allocate_buffers(NpyIter *iter, char **errmsg) npy_intp buffersize = NBF_BUFFERSIZE(bufferdata); char *buffer, **buffers = NBF_BUFFERS(bufferdata); - for (iiter = 0; iiter < niter; ++iiter) { - char flags = op_itflags[iiter]; + for (iop = 0; iop < nop; ++iop) { + char flags = op_itflags[iop]; /* * If we have determined that a buffer may be needed, * allocate one. */ if (!(flags&NPY_OP_ITFLAG_BUFNEVER)) { - npy_intp itemsize = op_dtype[iiter]->elsize; + npy_intp itemsize = op_dtype[iop]->elsize; buffer = PyArray_malloc(itemsize*buffersize); if (buffer == NULL) { if (errmsg == NULL) { @@ -5219,14 +5219,14 @@ npyiter_allocate_buffers(NpyIter *iter, char **errmsg) } goto fail; } - buffers[iiter] = buffer; + buffers[iop] = buffer; } } return 1; fail: - for (i = 0; i < iiter; ++i) { + for (i = 0; i < iop; ++i) { if (buffers[i] != NULL) { PyArray_free(buffers[i]); buffers[i] = NULL; @@ -5245,7 +5245,7 @@ npyiter_goto_iterindex(NpyIter *iter, npy_intp iterindex) { npy_uint32 itflags = NIT_ITFLAGS(iter); int idim, ndim = NIT_NDIM(iter); - int niter = NIT_NITER(iter); + int nop = NIT_NOP(iter); char **dataptr; NpyIter_AxisData *axisdata; @@ -5253,7 +5253,7 @@ npyiter_goto_iterindex(NpyIter *iter, npy_intp iterindex) npy_intp istrides, nstrides, i, shape; axisdata = NIT_AXISDATA(iter); - sizeof_axisdata = NIT_AXISDATA_SIZEOF(itflags, ndim, niter); + sizeof_axisdata = NIT_AXISDATA_SIZEOF(itflags, ndim, nop); nstrides = NAD_NSTRIDES(); NIT_ITERINDEX(iter) = iterindex; @@ -5328,7 +5328,7 @@ npyiter_copy_from_buffers(NpyIter *iter) { npy_uint32 itflags = NIT_ITFLAGS(iter); int ndim = NIT_NDIM(iter); - int iiter, niter = NIT_NITER(iter); + int iop, nop = NIT_NOP(iter); char *op_itflags = NIT_OPITFLAGS(iter); NpyIter_BufferData *bufferdata = NIT_BUFFERDATA(iter); @@ -5340,7 +5340,7 @@ npyiter_copy_from_buffers(NpyIter *iter) buffersize = NBF_BUFFERSIZE(bufferdata); npy_intp *strides = NBF_STRIDES(bufferdata), *ad_strides = NAD_STRIDES(axisdata); - npy_intp sizeof_axisdata = NIT_AXISDATA_SIZEOF(itflags, ndim, niter); + npy_intp sizeof_axisdata = NIT_AXISDATA_SIZEOF(itflags, ndim, nop); char **ptrs = NBF_PTRS(bufferdata), **ad_ptrs = NAD_PTRS(axisdata); char **buffers = NBF_BUFFERS(bufferdata); char *buffer; @@ -5352,7 +5352,7 @@ npyiter_copy_from_buffers(NpyIter *iter) PyArray_StridedTransferFn *stransfer = NULL; void *transferdata = NULL; - npy_intp axisdata_incr = NIT_AXISDATA_SIZEOF(itflags, ndim, niter) / + npy_intp axisdata_incr = NIT_AXISDATA_SIZEOF(itflags, ndim, nop) / NPY_SIZEOF_INTP; /* If we're past the end, nothing to copy */ @@ -5370,34 +5370,34 @@ npyiter_copy_from_buffers(NpyIter *iter) transfersize *= NBF_REDUCE_OUTERSIZE(bufferdata); } - for (iiter = 0; iiter < niter; ++iiter) { - stransfer = NBF_WRITETRANSFERFN(bufferdata)[iiter]; - transferdata = NBF_WRITETRANSFERDATA(bufferdata)[iiter]; - buffer = buffers[iiter]; + for (iop = 0; iop < nop; ++iop) { + stransfer = NBF_WRITETRANSFERFN(bufferdata)[iop]; + transferdata = NBF_WRITETRANSFERDATA(bufferdata)[iop]; + buffer = buffers[iop]; /* * Copy the data back to the arrays. If the type has refs, * this function moves them so the buffer's refs are released. */ - if ((stransfer != NULL) && (op_itflags[iiter]&NPY_OP_ITFLAG_WRITE)) { + if ((stransfer != NULL) && (op_itflags[iop]&NPY_OP_ITFLAG_WRITE)) { /* Copy back only if the pointer was pointing to the buffer */ - npy_intp delta = (ptrs[iiter] - buffer); - if (0 <= delta && delta <= buffersize*dtypes[iiter]->elsize) { + npy_intp delta = (ptrs[iop] - buffer); + if (0 <= delta && delta <= buffersize*dtypes[iop]->elsize) { npy_intp op_transfersize; npy_intp src_stride, *dst_strides, *dst_coords, *dst_shape; int ndim_transfer; NPY_IT_DBG_PRINT1("Iterator: Operand %d was buffered\n", - (int)iiter); + (int)iop); /* * If this operand is being reduced in the inner loop, * its buffering stride was set to zero, and just * one element was copied. */ - if (op_itflags[iiter]&NPY_OP_ITFLAG_REDUCE) { - if (strides[iiter] == 0) { - if (reduce_outerstrides[iiter] == 0) { + if (op_itflags[iop]&NPY_OP_ITFLAG_REDUCE) { + if (strides[iop] == 0) { + if (reduce_outerstrides[iop] == 0) { op_transfersize = 1; src_stride = 0; dst_strides = &src_stride; @@ -5407,19 +5407,19 @@ npyiter_copy_from_buffers(NpyIter *iter) } else { op_transfersize = NBF_REDUCE_OUTERSIZE(bufferdata); - src_stride = reduce_outerstrides[iiter]; + src_stride = reduce_outerstrides[iop]; dst_strides = - &NAD_STRIDES(reduce_outeraxisdata)[iiter]; + &NAD_STRIDES(reduce_outeraxisdata)[iop]; dst_coords = &NAD_INDEX(reduce_outeraxisdata); dst_shape = &NAD_SHAPE(reduce_outeraxisdata); ndim_transfer = ndim - reduce_outerdim; } } else { - if (reduce_outerstrides[iiter] == 0) { + if (reduce_outerstrides[iop] == 0) { op_transfersize = NBF_SIZE(bufferdata); - src_stride = strides[iiter]; - dst_strides = &ad_strides[iiter]; + src_stride = strides[iop]; + dst_strides = &ad_strides[iop]; dst_coords = &NAD_INDEX(axisdata); dst_shape = &NAD_SHAPE(axisdata); ndim_transfer = reduce_outerdim ? @@ -5427,8 +5427,8 @@ npyiter_copy_from_buffers(NpyIter *iter) } else { op_transfersize = transfersize; - src_stride = strides[iiter]; - dst_strides = &ad_strides[iiter]; + src_stride = strides[iop]; + dst_strides = &ad_strides[iop]; dst_coords = &NAD_INDEX(axisdata); dst_shape = &NAD_SHAPE(axisdata); ndim_transfer = ndim; @@ -5437,8 +5437,8 @@ npyiter_copy_from_buffers(NpyIter *iter) } else { op_transfersize = transfersize; - src_stride = strides[iiter]; - dst_strides = &ad_strides[iiter]; + src_stride = strides[iop]; + dst_strides = &ad_strides[iop]; dst_coords = &NAD_INDEX(axisdata); dst_shape = &NAD_SHAPE(axisdata); ndim_transfer = ndim; @@ -5446,14 +5446,14 @@ npyiter_copy_from_buffers(NpyIter *iter) NPY_IT_DBG_PRINT2("Iterator: Copying buffer to " "operand %d (%d items)\n", - (int)iiter, (int)op_transfersize); + (int)iop, (int)op_transfersize); PyArray_TransferStridedToNDim(ndim_transfer, - ad_ptrs[iiter], dst_strides, axisdata_incr, + ad_ptrs[iop], dst_strides, axisdata_incr, buffer, src_stride, dst_coords, axisdata_incr, dst_shape, axisdata_incr, - op_transfersize, dtypes[iiter]->elsize, + op_transfersize, dtypes[iop]->elsize, stransfer, transferdata); } @@ -5464,13 +5464,13 @@ npyiter_copy_from_buffers(NpyIter *iter) */ else if (stransfer != NULL) { /* Decrement refs only if the pointer was pointing to the buffer */ - npy_intp delta = (ptrs[iiter] - buffer); - if (0 <= delta && delta <= transfersize*dtypes[iiter]->elsize) { + npy_intp delta = (ptrs[iop] - buffer); + if (0 <= delta && delta <= transfersize*dtypes[iop]->elsize) { NPY_IT_DBG_PRINT1("Iterator: Freeing refs and zeroing buffer " - "of operand %d\n", (int)iiter); + "of operand %d\n", (int)iop); /* Decrement refs */ - stransfer(NULL, 0, buffer, dtypes[iiter]->elsize, - transfersize, dtypes[iiter]->elsize, + stransfer(NULL, 0, buffer, dtypes[iop]->elsize, + transfersize, dtypes[iop]->elsize, transferdata); /* * Zero out the memory for safety. For instance, @@ -5478,7 +5478,7 @@ npyiter_copy_from_buffers(NpyIter *iter) * array pointing into the buffer, it will get None * values for its references after this. */ - memset(buffer, 0, dtypes[iiter]->elsize*transfersize); + memset(buffer, 0, dtypes[iop]->elsize*transfersize); } } } @@ -5496,7 +5496,7 @@ npyiter_copy_to_buffers(NpyIter *iter, char **prev_dataptrs) { npy_uint32 itflags = NIT_ITFLAGS(iter); int ndim = NIT_NDIM(iter); - int iiter, niter = NIT_NITER(iter); + int iop, nop = NIT_NOP(iter); char *op_itflags = NIT_OPITFLAGS(iter); NpyIter_BufferData *bufferdata = NIT_BUFFERDATA(iter); @@ -5507,7 +5507,7 @@ npyiter_copy_to_buffers(NpyIter *iter, char **prev_dataptrs) PyArrayObject **operands = NIT_OPERANDS(iter); npy_intp *strides = NBF_STRIDES(bufferdata), *ad_strides = NAD_STRIDES(axisdata); - npy_intp sizeof_axisdata = NIT_AXISDATA_SIZEOF(itflags, ndim, niter); + npy_intp sizeof_axisdata = NIT_AXISDATA_SIZEOF(itflags, ndim, nop); char **ptrs = NBF_PTRS(bufferdata), **ad_ptrs = NAD_PTRS(axisdata); char **buffers = NBF_BUFFERS(bufferdata); npy_intp iterindex, iterend, transfersize, @@ -5527,7 +5527,7 @@ npyiter_copy_to_buffers(NpyIter *iter, char **prev_dataptrs) npy_bool reuse_reduce_loops = (prev_dataptrs != NULL) && ((itflags&NPY_ITFLAG_REUSE_REDUCE_LOOPS) != 0); - npy_intp axisdata_incr = NIT_AXISDATA_SIZEOF(itflags, ndim, niter) / + npy_intp axisdata_incr = NIT_AXISDATA_SIZEOF(itflags, ndim, nop) / NPY_SIZEOF_INTP; NPY_IT_DBG_PRINT("Iterator: Copying inputs to buffers\n"); @@ -5603,40 +5603,40 @@ npyiter_copy_to_buffers(NpyIter *iter, char **prev_dataptrs) is_onestride = 1; } - for (iiter = 0; iiter < niter; ++iiter) { + for (iop = 0; iop < nop; ++iop) { /* * If the buffer is write-only, these two are NULL, and the buffer * pointers will be set up but the read copy won't be done */ - stransfer = NBF_READTRANSFERFN(bufferdata)[iiter]; - transferdata = NBF_READTRANSFERDATA(bufferdata)[iiter]; - switch (op_itflags[iiter]& + stransfer = NBF_READTRANSFERFN(bufferdata)[iop]; + transferdata = NBF_READTRANSFERDATA(bufferdata)[iop]; + switch (op_itflags[iop]& (NPY_OP_ITFLAG_BUFNEVER| NPY_OP_ITFLAG_CAST| NPY_OP_ITFLAG_REDUCE)) { /* Never need to buffer this operand */ case NPY_OP_ITFLAG_BUFNEVER: - ptrs[iiter] = ad_ptrs[iiter]; + ptrs[iop] = ad_ptrs[iop]; if (itflags&NPY_ITFLAG_REDUCE) { - reduce_outerstrides[iiter] = reduce_innersize * - strides[iiter]; - reduce_outerptrs[iiter] = ptrs[iiter]; + reduce_outerstrides[iop] = reduce_innersize * + strides[iop]; + reduce_outerptrs[iop] = ptrs[iop]; } /* - * Should not adjust the stride - ad_strides[iiter] - * could be zero, but strides[iiter] was initialized + * Should not adjust the stride - ad_strides[iop] + * could be zero, but strides[iop] was initialized * to the first non-trivial stride. */ stransfer = NULL; break; /* Never need to buffer this operand */ case NPY_OP_ITFLAG_BUFNEVER|NPY_OP_ITFLAG_REDUCE: - ptrs[iiter] = ad_ptrs[iiter]; - reduce_outerptrs[iiter] = ptrs[iiter]; - reduce_outerstrides[iiter] = 0; + ptrs[iop] = ad_ptrs[iop]; + reduce_outerptrs[iop] = ptrs[iop]; + reduce_outerstrides[iop] = 0; /* - * Should not adjust the stride - ad_strides[iiter] - * could be zero, but strides[iiter] was initialized + * Should not adjust the stride - ad_strides[iop] + * could be zero, but strides[iop] was initialized * to the first non-trivial stride. */ stransfer = NULL; @@ -5650,8 +5650,8 @@ npyiter_copy_to_buffers(NpyIter *iter, char **prev_dataptrs) * already does that, no need to copy it. */ if (is_onestride) { - ptrs[iiter] = ad_ptrs[iiter]; - strides[iiter] = ad_strides[iiter]; + ptrs[iop] = ad_ptrs[iop]; + strides[iop] = ad_strides[iop]; stransfer = NULL; } /* If some other op is reduced, we have a double reduce loop */ @@ -5660,33 +5660,33 @@ npyiter_copy_to_buffers(NpyIter *iter, char **prev_dataptrs) (transfersize/reduce_innersize <= NAD_SHAPE(reduce_outeraxisdata) - NAD_INDEX(reduce_outeraxisdata))) { - ptrs[iiter] = ad_ptrs[iiter]; - reduce_outerptrs[iiter] = ptrs[iiter]; - strides[iiter] = ad_strides[iiter]; - reduce_outerstrides[iiter] = - NAD_STRIDES(reduce_outeraxisdata)[iiter]; + ptrs[iop] = ad_ptrs[iop]; + reduce_outerptrs[iop] = ptrs[iop]; + strides[iop] = ad_strides[iop]; + reduce_outerstrides[iop] = + NAD_STRIDES(reduce_outeraxisdata)[iop]; stransfer = NULL; } else { /* In this case, the buffer is being used */ - ptrs[iiter] = buffers[iiter]; - strides[iiter] = dtypes[iiter]->elsize; + ptrs[iop] = buffers[iop]; + strides[iop] = dtypes[iop]->elsize; if (itflags&NPY_ITFLAG_REDUCE) { - reduce_outerstrides[iiter] = reduce_innersize * - strides[iiter]; - reduce_outerptrs[iiter] = ptrs[iiter]; + reduce_outerstrides[iop] = reduce_innersize * + strides[iop]; + reduce_outerptrs[iop] = ptrs[iop]; } } break; /* Just a copy, but with a reduction */ case NPY_OP_ITFLAG_REDUCE: - if (ad_strides[iiter] == 0) { - strides[iiter] = 0; + if (ad_strides[iop] == 0) { + strides[iop] = 0; /* It's all in one stride in the inner loop dimension */ if (is_onestride) { - NPY_IT_DBG_PRINT1("reduce op %d all one stride\n", (int)iiter); - ptrs[iiter] = ad_ptrs[iiter]; - reduce_outerstrides[iiter] = 0; + NPY_IT_DBG_PRINT1("reduce op %d all one stride\n", (int)iop); + ptrs[iop] = ad_ptrs[iop]; + reduce_outerstrides[iop] = 0; stransfer = NULL; } /* It's all in one stride in the reduce outer loop */ @@ -5695,33 +5695,33 @@ npyiter_copy_to_buffers(NpyIter *iter, char **prev_dataptrs) NAD_SHAPE(reduce_outeraxisdata) - NAD_INDEX(reduce_outeraxisdata))) { NPY_IT_DBG_PRINT1("reduce op %d all one outer stride\n", - (int)iiter); - ptrs[iiter] = ad_ptrs[iiter]; + (int)iop); + ptrs[iop] = ad_ptrs[iop]; /* Outer reduce loop advances by one item */ - reduce_outerstrides[iiter] = - NAD_STRIDES(reduce_outeraxisdata)[iiter]; + reduce_outerstrides[iop] = + NAD_STRIDES(reduce_outeraxisdata)[iop]; stransfer = NULL; } /* In this case, the buffer is being used */ else { - NPY_IT_DBG_PRINT1("reduce op %d must buffer\n", (int)iiter); - ptrs[iiter] = buffers[iiter]; + NPY_IT_DBG_PRINT1("reduce op %d must buffer\n", (int)iop); + ptrs[iop] = buffers[iop]; /* Both outer and inner reduce loops have stride 0 */ - if (NAD_STRIDES(reduce_outeraxisdata)[iiter] == 0) { - reduce_outerstrides[iiter] = 0; + if (NAD_STRIDES(reduce_outeraxisdata)[iop] == 0) { + reduce_outerstrides[iop] = 0; } /* Outer reduce loop advances by one item */ else { - reduce_outerstrides[iiter] = dtypes[iiter]->elsize; + reduce_outerstrides[iop] = dtypes[iop]->elsize; } } } else if (is_onestride) { - NPY_IT_DBG_PRINT1("reduce op %d all one stride in dim 0\n", (int)iiter); - ptrs[iiter] = ad_ptrs[iiter]; - strides[iiter] = ad_strides[iiter]; - reduce_outerstrides[iiter] = 0; + NPY_IT_DBG_PRINT1("reduce op %d all one stride in dim 0\n", (int)iop); + ptrs[iop] = ad_ptrs[iop]; + strides[iop] = ad_strides[iop]; + reduce_outerstrides[iop] = 0; stransfer = NULL; } else { @@ -5730,82 +5730,82 @@ npyiter_copy_to_buffers(NpyIter *iter, char **prev_dataptrs) (transfersize/reduce_innersize <= NAD_SHAPE(reduce_outeraxisdata) - NAD_INDEX(reduce_outeraxisdata))) { - ptrs[iiter] = ad_ptrs[iiter]; - strides[iiter] = ad_strides[iiter]; + ptrs[iop] = ad_ptrs[iop]; + strides[iop] = ad_strides[iop]; /* Outer reduce loop advances by one item */ - reduce_outerstrides[iiter] = - NAD_STRIDES(reduce_outeraxisdata)[iiter]; + reduce_outerstrides[iop] = + NAD_STRIDES(reduce_outeraxisdata)[iop]; stransfer = NULL; } /* In this case, the buffer is being used */ else { - ptrs[iiter] = buffers[iiter]; - strides[iiter] = dtypes[iiter]->elsize; + ptrs[iop] = buffers[iop]; + strides[iop] = dtypes[iop]->elsize; - if (NAD_STRIDES(reduce_outeraxisdata)[iiter] == 0) { + if (NAD_STRIDES(reduce_outeraxisdata)[iop] == 0) { /* Reduction in outer reduce loop */ - reduce_outerstrides[iiter] = 0; + reduce_outerstrides[iop] = 0; } else { /* Advance to next items in outer reduce loop */ - reduce_outerstrides[iiter] = reduce_innersize * - dtypes[iiter]->elsize; + reduce_outerstrides[iop] = reduce_innersize * + dtypes[iop]->elsize; } } } - reduce_outerptrs[iiter] = ptrs[iiter]; + reduce_outerptrs[iop] = ptrs[iop]; break; default: /* In this case, the buffer is being used */ - if (!(op_itflags[iiter]&NPY_OP_ITFLAG_REDUCE)) { - ptrs[iiter] = buffers[iiter]; - strides[iiter] = dtypes[iiter]->elsize; + if (!(op_itflags[iop]&NPY_OP_ITFLAG_REDUCE)) { + ptrs[iop] = buffers[iop]; + strides[iop] = dtypes[iop]->elsize; if (itflags&NPY_ITFLAG_REDUCE) { - reduce_outerstrides[iiter] = reduce_innersize * - strides[iiter]; - reduce_outerptrs[iiter] = ptrs[iiter]; + reduce_outerstrides[iop] = reduce_innersize * + strides[iop]; + reduce_outerptrs[iop] = ptrs[iop]; } } /* The buffer is being used with reduction */ else { - ptrs[iiter] = buffers[iiter]; - if (ad_strides[iiter] == 0) { - NPY_IT_DBG_PRINT1("cast op %d has innermost stride 0\n", (int)iiter); - strides[iiter] = 0; + ptrs[iop] = buffers[iop]; + if (ad_strides[iop] == 0) { + NPY_IT_DBG_PRINT1("cast op %d has innermost stride 0\n", (int)iop); + strides[iop] = 0; /* Both outer and inner reduce loops have stride 0 */ - if (NAD_STRIDES(reduce_outeraxisdata)[iiter] == 0) { - NPY_IT_DBG_PRINT1("cast op %d has outermost stride 0\n", (int)iiter); - reduce_outerstrides[iiter] = 0; + if (NAD_STRIDES(reduce_outeraxisdata)[iop] == 0) { + NPY_IT_DBG_PRINT1("cast op %d has outermost stride 0\n", (int)iop); + reduce_outerstrides[iop] = 0; } /* Outer reduce loop advances by one item */ else { - NPY_IT_DBG_PRINT1("cast op %d has outermost stride !=0\n", (int)iiter); - reduce_outerstrides[iiter] = dtypes[iiter]->elsize; + NPY_IT_DBG_PRINT1("cast op %d has outermost stride !=0\n", (int)iop); + reduce_outerstrides[iop] = dtypes[iop]->elsize; } } else { - NPY_IT_DBG_PRINT1("cast op %d has innermost stride !=0\n", (int)iiter); - strides[iiter] = dtypes[iiter]->elsize; + NPY_IT_DBG_PRINT1("cast op %d has innermost stride !=0\n", (int)iop); + strides[iop] = dtypes[iop]->elsize; - if (NAD_STRIDES(reduce_outeraxisdata)[iiter] == 0) { - NPY_IT_DBG_PRINT1("cast op %d has outermost stride 0\n", (int)iiter); + if (NAD_STRIDES(reduce_outeraxisdata)[iop] == 0) { + NPY_IT_DBG_PRINT1("cast op %d has outermost stride 0\n", (int)iop); /* Reduction in outer reduce loop */ - reduce_outerstrides[iiter] = 0; + reduce_outerstrides[iop] = 0; } else { - NPY_IT_DBG_PRINT1("cast op %d has outermost stride !=0\n", (int)iiter); + NPY_IT_DBG_PRINT1("cast op %d has outermost stride !=0\n", (int)iop); /* Advance to next items in outer reduce loop */ - reduce_outerstrides[iiter] = reduce_innersize * - dtypes[iiter]->elsize; + reduce_outerstrides[iop] = reduce_innersize * + dtypes[iop]->elsize; } } - reduce_outerptrs[iiter] = ptrs[iiter]; + reduce_outerptrs[iop] = ptrs[iop]; } break; } if (stransfer != NULL) { - npy_intp src_itemsize = PyArray_DESCR(operands[iiter])->elsize; + npy_intp src_itemsize = PyArray_DESCR(operands[iop])->elsize; npy_intp op_transfersize; npy_intp dst_stride, *src_strides, *src_coords, *src_shape; @@ -5820,10 +5820,10 @@ npyiter_copy_to_buffers(NpyIter *iter, char **prev_dataptrs) * set its buffering stride to zero, and just copy * one element. */ - if (op_itflags[iiter]&NPY_OP_ITFLAG_REDUCE) { - if (ad_strides[iiter] == 0) { - strides[iiter] = 0; - if (reduce_outerstrides[iiter] == 0) { + if (op_itflags[iop]&NPY_OP_ITFLAG_REDUCE) { + if (ad_strides[iop] == 0) { + strides[iop] = 0; + if (reduce_outerstrides[iop] == 0) { op_transfersize = 1; dst_stride = 0; src_strides = &dst_stride; @@ -5839,36 +5839,36 @@ npyiter_copy_to_buffers(NpyIter *iter, char **prev_dataptrs) * intermediate calculation. */ if (prev_dataptrs && - prev_dataptrs[iiter] == ad_ptrs[iiter]) { + prev_dataptrs[iop] == ad_ptrs[iop]) { NPY_IT_DBG_PRINT1("Iterator: skipping operand %d" " copy because it's a 1-element reduce\n", - (int)iiter); + (int)iop); skip_transfer = 1; } } else { op_transfersize = NBF_REDUCE_OUTERSIZE(bufferdata); - dst_stride = reduce_outerstrides[iiter]; - src_strides = &NAD_STRIDES(reduce_outeraxisdata)[iiter]; + dst_stride = reduce_outerstrides[iop]; + src_strides = &NAD_STRIDES(reduce_outeraxisdata)[iop]; src_coords = &NAD_INDEX(reduce_outeraxisdata); src_shape = &NAD_SHAPE(reduce_outeraxisdata); ndim_transfer = ndim - reduce_outerdim; } } else { - if (reduce_outerstrides[iiter] == 0) { + if (reduce_outerstrides[iop] == 0) { op_transfersize = NBF_SIZE(bufferdata); - dst_stride = strides[iiter]; - src_strides = &ad_strides[iiter]; + dst_stride = strides[iop]; + src_strides = &ad_strides[iop]; src_coords = &NAD_INDEX(axisdata); src_shape = &NAD_SHAPE(axisdata); ndim_transfer = reduce_outerdim ? reduce_outerdim : 1; } else { op_transfersize = transfersize; - dst_stride = strides[iiter]; - src_strides = &ad_strides[iiter]; + dst_stride = strides[iop]; + src_strides = &ad_strides[iop]; src_coords = &NAD_INDEX(axisdata); src_shape = &NAD_SHAPE(axisdata); ndim_transfer = ndim; @@ -5877,8 +5877,8 @@ npyiter_copy_to_buffers(NpyIter *iter, char **prev_dataptrs) } else { op_transfersize = transfersize; - dst_stride = strides[iiter]; - src_strides = &ad_strides[iiter]; + dst_stride = strides[iop]; + src_strides = &ad_strides[iop]; src_coords = &NAD_INDEX(axisdata); src_shape = &NAD_SHAPE(axisdata); ndim_transfer = ndim; @@ -5889,19 +5889,19 @@ npyiter_copy_to_buffers(NpyIter *iter, char **prev_dataptrs) * and the source pointer for this data didn't change, * we don't have to copy the data again. */ - if (reuse_reduce_loops && prev_dataptrs[iiter] == ad_ptrs[iiter]) { + if (reuse_reduce_loops && prev_dataptrs[iop] == ad_ptrs[iop]) { NPY_IT_DBG_PRINT2("Iterator: skipping operands %d " "copy (%d items) because loops are reused and the data " "pointer didn't change\n", - (int)iiter, (int)op_transfersize); + (int)iop, (int)op_transfersize); skip_transfer = 1; } /* If the data type requires zero-inititialization */ - if (PyDataType_FLAGCHK(dtypes[iiter], NPY_NEEDS_INIT)) { + if (PyDataType_FLAGCHK(dtypes[iop], NPY_NEEDS_INIT)) { NPY_IT_DBG_PRINT("Iterator: Buffer requires init, " "memsetting to 0\n"); - memset(ptrs[iiter], 0, dtypes[iiter]->elsize*op_transfersize); + memset(ptrs[iop], 0, dtypes[iop]->elsize*op_transfersize); /* Can't skip the transfer in this case */ skip_transfer = 0; } @@ -5909,11 +5909,11 @@ npyiter_copy_to_buffers(NpyIter *iter, char **prev_dataptrs) if (!skip_transfer) { NPY_IT_DBG_PRINT2("Iterator: Copying operand %d to " "buffer (%d items)\n", - (int)iiter, (int)op_transfersize); + (int)iop, (int)op_transfersize); PyArray_TransferNDimToStrided(ndim_transfer, - ptrs[iiter], dst_stride, - ad_ptrs[iiter], src_strides, axisdata_incr, + ptrs[iop], dst_stride, + ad_ptrs[iop], src_strides, axisdata_incr, src_coords, axisdata_incr, src_shape, axisdata_incr, op_transfersize, src_itemsize, @@ -5921,13 +5921,13 @@ npyiter_copy_to_buffers(NpyIter *iter, char **prev_dataptrs) transferdata); } } - else if (ptrs[iiter] == buffers[iiter]) { + else if (ptrs[iop] == buffers[iop]) { /* If the data type requires zero-inititialization */ - if (PyDataType_FLAGCHK(dtypes[iiter], NPY_NEEDS_INIT)) { + if (PyDataType_FLAGCHK(dtypes[iop], NPY_NEEDS_INIT)) { NPY_IT_DBG_PRINT1("Iterator: Write-only buffer for " "operand %d requires init, " - "memsetting to 0\n", (int)iiter); - memset(ptrs[iiter], 0, dtypes[iiter]->elsize*transfersize); + "memsetting to 0\n", (int)iop); + memset(ptrs[iop], 0, dtypes[iop]->elsize*transfersize); } } @@ -5980,7 +5980,7 @@ npyiter_checkreducesize(NpyIter *iter, npy_intp count, { npy_uint32 itflags = NIT_ITFLAGS(iter); int idim, ndim = NIT_NDIM(iter); - int iiter, niter = NIT_NITER(iter); + int iop, nop = NIT_NOP(iter); NpyIter_AxisData *axisdata; npy_intp sizeof_axisdata; @@ -6000,14 +6000,14 @@ npyiter_checkreducesize(NpyIter *iter, npy_intp count, return count; } - sizeof_axisdata = NIT_AXISDATA_SIZEOF(itflags, ndim, niter); + sizeof_axisdata = NIT_AXISDATA_SIZEOF(itflags, ndim, nop); axisdata = NIT_AXISDATA(iter); /* Indicate which REDUCE operands have stride 0 in the inner loop */ strides = NAD_STRIDES(axisdata); - for (iiter = 0; iiter < niter; ++iiter) { - stride0op[iiter] = (op_itflags[iiter]&NPY_OP_ITFLAG_REDUCE) && - (strides[iiter] == 0); + for (iop = 0; iop < nop; ++iop) { + stride0op[iop] = (op_itflags[iop]&NPY_OP_ITFLAG_REDUCE) && + (strides[iop] == 0); } shape = NAD_SHAPE(axisdata); coord = NAD_INDEX(axisdata); @@ -6019,7 +6019,7 @@ npyiter_checkreducesize(NpyIter *iter, npy_intp count, for (idim = 1; idim < ndim && reducespace < count; ++idim, NIT_ADVANCE_AXISDATA(axisdata, 1)) { strides = NAD_STRIDES(axisdata); - for (iiter = 0; iiter < niter; ++iiter) { + for (iop = 0; iop < nop; ++iop) { /* * If a reduce stride switched from zero to non-zero, or * vice versa, that's the point where the data will stop @@ -6027,10 +6027,10 @@ npyiter_checkreducesize(NpyIter *iter, npy_intp count, * buffer starts with an all zero multi-index up to this * point, gives us the reduce_innersize. */ - if((stride0op[iiter] && (strides[iiter] != 0)) || - (!stride0op[iiter] && - (strides[iiter] == 0) && - (op_itflags[iiter]&NPY_OP_ITFLAG_REDUCE))) { + if((stride0op[iop] && (strides[iop] != 0)) || + (!stride0op[iop] && + (strides[iop] == 0) && + (op_itflags[iop]&NPY_OP_ITFLAG_REDUCE))) { NPY_IT_DBG_PRINT1("Iterator: Reduce operation limits " "buffer to %d\n", (int)reducespace); /* @@ -6056,7 +6056,7 @@ npyiter_checkreducesize(NpyIter *iter, npy_intp count, } } /* If we broke out of the loop early, we found reduce_innersize */ - if (iiter != niter) { + if (iop != nop) { break; } @@ -6096,9 +6096,9 @@ npyiter_checkreducesize(NpyIter *iter, npy_intp count, factor = 1; /* Indicate which REDUCE operands have stride 0 at the current level */ strides = NAD_STRIDES(axisdata); - for (iiter = 0; iiter < niter; ++iiter) { - stride0op[iiter] = (op_itflags[iiter]&NPY_OP_ITFLAG_REDUCE) && - (strides[iiter] == 0); + for (iop = 0; iop < nop; ++iop) { + stride0op[iop] = (op_itflags[iop]&NPY_OP_ITFLAG_REDUCE) && + (strides[iop] == 0); } shape = NAD_SHAPE(axisdata); coord = NAD_INDEX(axisdata); @@ -6110,7 +6110,7 @@ npyiter_checkreducesize(NpyIter *iter, npy_intp count, for (; idim < ndim && reducespace < count; ++idim, NIT_ADVANCE_AXISDATA(axisdata, 1)) { strides = NAD_STRIDES(axisdata); - for (iiter = 0; iiter < niter; ++iiter) { + for (iop = 0; iop < nop; ++iop) { /* * If a reduce stride switched from zero to non-zero, or * vice versa, that's the point where the data will stop @@ -6118,10 +6118,10 @@ npyiter_checkreducesize(NpyIter *iter, npy_intp count, * buffer starts with an all zero multi-index up to this * point, gives us the reduce_innersize. */ - if((stride0op[iiter] && (strides[iiter] != 0)) || - (!stride0op[iiter] && - (strides[iiter] == 0) && - (op_itflags[iiter]&NPY_OP_ITFLAG_REDUCE))) { + if((stride0op[iop] && (strides[iop] != 0)) || + (!stride0op[iop] && + (strides[iop] == 0) && + (op_itflags[iop]&NPY_OP_ITFLAG_REDUCE))) { NPY_IT_DBG_PRINT1("Iterator: Reduce operation limits " "buffer to %d\n", (int)reducespace); /* @@ -6161,7 +6161,7 @@ NpyIter_DebugPrint(NpyIter *iter) { npy_uint32 itflags = NIT_ITFLAGS(iter); int idim, ndim = NIT_NDIM(iter); - int iiter, niter = NIT_NITER(iter); + int iop, nop = NIT_NOP(iter); NpyIter_AxisData *axisdata; npy_intp sizeof_axisdata; @@ -6201,17 +6201,17 @@ NpyIter_DebugPrint(NpyIter *iter) printf("REUSE_REDUCE_LOOPS "); printf("\n"); printf("| NDim: %d\n", (int)ndim); - printf("| NIter: %d\n", (int)niter); + printf("| NOp: %d\n", (int)nop); printf("| IterSize: %d\n", (int)NIT_ITERSIZE(iter)); printf("| IterStart: %d\n", (int)NIT_ITERSTART(iter)); printf("| IterEnd: %d\n", (int)NIT_ITEREND(iter)); printf("| IterIndex: %d\n", (int)NIT_ITERINDEX(iter)); printf("| Iterator SizeOf: %d\n", - (int)NIT_SIZEOF_ITERATOR(itflags, ndim, niter)); + (int)NIT_SIZEOF_ITERATOR(itflags, ndim, nop)); printf("| BufferData SizeOf: %d\n", - (int)NIT_BUFFERDATA_SIZEOF(itflags, ndim, niter)); + (int)NIT_BUFFERDATA_SIZEOF(itflags, ndim, nop)); printf("| AxisData SizeOf: %d\n", - (int)NIT_AXISDATA_SIZEOF(itflags, ndim, niter)); + (int)NIT_AXISDATA_SIZEOF(itflags, ndim, nop)); printf("|\n"); printf("| Perm: "); @@ -6220,43 +6220,43 @@ NpyIter_DebugPrint(NpyIter *iter) } printf("\n"); printf("| DTypes: "); - for (iiter = 0; iiter < niter; ++iiter) { - printf("%p ", (void *)NIT_DTYPES(iter)[iiter]); + for (iop = 0; iop < nop; ++iop) { + printf("%p ", (void *)NIT_DTYPES(iter)[iop]); } printf("\n"); printf("| DTypes: "); - for (iiter = 0; iiter < niter; ++iiter) { - if (NIT_DTYPES(iter)[iiter] != NULL) - PyObject_Print((PyObject*)NIT_DTYPES(iter)[iiter], stdout, 0); + for (iop = 0; iop < nop; ++iop) { + if (NIT_DTYPES(iter)[iop] != NULL) + PyObject_Print((PyObject*)NIT_DTYPES(iter)[iop], stdout, 0); else printf("(nil) "); printf(" "); } printf("\n"); printf("| InitDataPtrs: "); - for (iiter = 0; iiter < niter; ++iiter) { - printf("%p ", (void *)NIT_RESETDATAPTR(iter)[iiter]); + for (iop = 0; iop < nop; ++iop) { + printf("%p ", (void *)NIT_RESETDATAPTR(iter)[iop]); } printf("\n"); printf("| BaseOffsets: "); - for (iiter = 0; iiter < niter; ++iiter) { - printf("%i ", (int)NIT_BASEOFFSETS(iter)[iiter]); + for (iop = 0; iop < nop; ++iop) { + printf("%i ", (int)NIT_BASEOFFSETS(iter)[iop]); } printf("\n"); if (itflags&NPY_ITFLAG_HASINDEX) { printf("| InitIndex: %d\n", - (int)(npy_intp)NIT_RESETDATAPTR(iter)[niter]); + (int)(npy_intp)NIT_RESETDATAPTR(iter)[nop]); } printf("| Operands: "); - for (iiter = 0; iiter < niter; ++iiter) { - printf("%p ", (void *)NIT_OPERANDS(iter)[iiter]); + for (iop = 0; iop < nop; ++iop) { + printf("%p ", (void *)NIT_OPERANDS(iter)[iop]); } printf("\n"); printf("| Operand DTypes: "); - for (iiter = 0; iiter < niter; ++iiter) { + for (iop = 0; iop < nop; ++iop) { PyArray_Descr *dtype; - if (NIT_OPERANDS(iter)[iiter] != NULL) { - dtype = PyArray_DESCR(NIT_OPERANDS(iter)[iiter]); + if (NIT_OPERANDS(iter)[iop] != NULL) { + dtype = PyArray_DESCR(NIT_OPERANDS(iter)[iop]); if (dtype != NULL) PyObject_Print((PyObject *)dtype, stdout, 0); else @@ -6269,19 +6269,19 @@ NpyIter_DebugPrint(NpyIter *iter) } printf("\n"); printf("| OpItFlags:\n"); - for (iiter = 0; iiter < niter; ++iiter) { - printf("| Flags[%d]: ", (int)iiter); - if ((NIT_OPITFLAGS(iter)[iiter])&NPY_OP_ITFLAG_READ) + for (iop = 0; iop < nop; ++iop) { + printf("| Flags[%d]: ", (int)iop); + if ((NIT_OPITFLAGS(iter)[iop])&NPY_OP_ITFLAG_READ) printf("READ "); - if ((NIT_OPITFLAGS(iter)[iiter])&NPY_OP_ITFLAG_WRITE) + if ((NIT_OPITFLAGS(iter)[iop])&NPY_OP_ITFLAG_WRITE) printf("WRITE "); - if ((NIT_OPITFLAGS(iter)[iiter])&NPY_OP_ITFLAG_CAST) + if ((NIT_OPITFLAGS(iter)[iop])&NPY_OP_ITFLAG_CAST) printf("CAST "); - if ((NIT_OPITFLAGS(iter)[iiter])&NPY_OP_ITFLAG_BUFNEVER) + if ((NIT_OPITFLAGS(iter)[iop])&NPY_OP_ITFLAG_BUFNEVER) printf("BUFNEVER "); - if ((NIT_OPITFLAGS(iter)[iiter])&NPY_OP_ITFLAG_ALIGNED) + if ((NIT_OPITFLAGS(iter)[iop])&NPY_OP_ITFLAG_ALIGNED) printf("ALIGNED "); - if ((NIT_OPITFLAGS(iter)[iiter])&NPY_OP_ITFLAG_REDUCE) + if ((NIT_OPITFLAGS(iter)[iop])&NPY_OP_ITFLAG_REDUCE) printf("REDUCE "); printf("\n"); } @@ -6302,77 +6302,77 @@ NpyIter_DebugPrint(NpyIter *iter) (int)NBF_REDUCE_OUTERDIM(bufferdata)); } printf("| Strides: "); - for (iiter = 0; iiter < niter; ++iiter) - printf("%d ", (int)NBF_STRIDES(bufferdata)[iiter]); + for (iop = 0; iop < nop; ++iop) + printf("%d ", (int)NBF_STRIDES(bufferdata)[iop]); printf("\n"); /* Print the fixed strides when there's no inner loop */ if (itflags&NPY_ITFLAG_EXLOOP) { npy_intp fixedstrides[NPY_MAXDIMS]; printf("| Fixed Strides: "); NpyIter_GetInnerFixedStrideArray(iter, fixedstrides); - for (iiter = 0; iiter < niter; ++iiter) - printf("%d ", (int)fixedstrides[iiter]); + for (iop = 0; iop < nop; ++iop) + printf("%d ", (int)fixedstrides[iop]); printf("\n"); } printf("| Ptrs: "); - for (iiter = 0; iiter < niter; ++iiter) - printf("%p ", (void *)NBF_PTRS(bufferdata)[iiter]); + for (iop = 0; iop < nop; ++iop) + printf("%p ", (void *)NBF_PTRS(bufferdata)[iop]); printf("\n"); if (itflags&NPY_ITFLAG_REDUCE) { printf("| REDUCE Outer Strides: "); - for (iiter = 0; iiter < niter; ++iiter) - printf("%d ", (int)NBF_REDUCE_OUTERSTRIDES(bufferdata)[iiter]); + for (iop = 0; iop < nop; ++iop) + printf("%d ", (int)NBF_REDUCE_OUTERSTRIDES(bufferdata)[iop]); printf("\n"); printf("| REDUCE Outer Ptrs: "); - for (iiter = 0; iiter < niter; ++iiter) - printf("%p ", (void *)NBF_REDUCE_OUTERPTRS(bufferdata)[iiter]); + for (iop = 0; iop < nop; ++iop) + printf("%p ", (void *)NBF_REDUCE_OUTERPTRS(bufferdata)[iop]); printf("\n"); } printf("| ReadTransferFn: "); - for (iiter = 0; iiter < niter; ++iiter) - printf("%p ", (void *)NBF_READTRANSFERFN(bufferdata)[iiter]); + for (iop = 0; iop < nop; ++iop) + printf("%p ", (void *)NBF_READTRANSFERFN(bufferdata)[iop]); printf("\n"); printf("| ReadTransferData: "); - for (iiter = 0; iiter < niter; ++iiter) - printf("%p ", (void *)NBF_READTRANSFERDATA(bufferdata)[iiter]); + for (iop = 0; iop < nop; ++iop) + printf("%p ", (void *)NBF_READTRANSFERDATA(bufferdata)[iop]); printf("\n"); printf("| WriteTransferFn: "); - for (iiter = 0; iiter < niter; ++iiter) - printf("%p ", (void *)NBF_WRITETRANSFERFN(bufferdata)[iiter]); + for (iop = 0; iop < nop; ++iop) + printf("%p ", (void *)NBF_WRITETRANSFERFN(bufferdata)[iop]); printf("\n"); printf("| WriteTransferData: "); - for (iiter = 0; iiter < niter; ++iiter) - printf("%p ", (void *)NBF_WRITETRANSFERDATA(bufferdata)[iiter]); + for (iop = 0; iop < nop; ++iop) + printf("%p ", (void *)NBF_WRITETRANSFERDATA(bufferdata)[iop]); printf("\n"); printf("| Buffers: "); - for (iiter = 0; iiter < niter; ++iiter) - printf("%p ", (void *)NBF_BUFFERS(bufferdata)[iiter]); + for (iop = 0; iop < nop; ++iop) + printf("%p ", (void *)NBF_BUFFERS(bufferdata)[iop]); printf("\n"); printf("|\n"); } axisdata = NIT_AXISDATA(iter); - sizeof_axisdata = NIT_AXISDATA_SIZEOF(itflags, ndim, niter); + sizeof_axisdata = NIT_AXISDATA_SIZEOF(itflags, ndim, nop); for (idim = 0; idim < ndim; ++idim, NIT_ADVANCE_AXISDATA(axisdata, 1)) { printf("| AxisData[%d]:\n", (int)idim); printf("| Shape: %d\n", (int)NAD_SHAPE(axisdata)); printf("| Index: %d\n", (int)NAD_INDEX(axisdata)); printf("| Strides: "); - for (iiter = 0; iiter < niter; ++iiter) { - printf("%d ", (int)NAD_STRIDES(axisdata)[iiter]); + for (iop = 0; iop < nop; ++iop) { + printf("%d ", (int)NAD_STRIDES(axisdata)[iop]); } printf("\n"); if (itflags&NPY_ITFLAG_HASINDEX) { - printf("| Index Stride: %d\n", (int)NAD_STRIDES(axisdata)[niter]); + printf("| Index Stride: %d\n", (int)NAD_STRIDES(axisdata)[nop]); } printf("| Ptrs: "); - for (iiter = 0; iiter < niter; ++iiter) { - printf("%p ", (void *)NAD_PTRS(axisdata)[iiter]); + for (iop = 0; iop < nop; ++iop) { + printf("%p ", (void *)NAD_PTRS(axisdata)[iop]); } printf("\n"); if (itflags&NPY_ITFLAG_HASINDEX) { printf("| Index Value: %d\n", - (int)((npy_intp*)NAD_PTRS(axisdata))[niter]); + (int)((npy_intp*)NAD_PTRS(axisdata))[nop]); } } diff --git a/numpy/core/src/multiarray/nditer_pywrap.c b/numpy/core/src/multiarray/nditer_pywrap.c index 3d13d9ec4..a0ddc2f5a 100644 --- a/numpy/core/src/multiarray/nditer_pywrap.c +++ b/numpy/core/src/multiarray/nditer_pywrap.c @@ -443,9 +443,9 @@ NpyIter_OpFlagsConverter(PyObject *op_flags_in, static int npyiter_convert_op_flags_array(PyObject *op_flags_in, - npy_uint32 *op_flags_array, npy_intp niter) + npy_uint32 *op_flags_array, npy_intp nop) { - npy_intp iiter; + npy_intp iop; if (!PyTuple_Check(op_flags_in) && !PyList_Check(op_flags_in)) { PyErr_SetString(PyExc_ValueError, @@ -453,22 +453,22 @@ npyiter_convert_op_flags_array(PyObject *op_flags_in, return 0; } - if (PySequence_Size(op_flags_in) != niter) { + if (PySequence_Size(op_flags_in) != nop) { goto try_single_flags; } - for (iiter = 0; iiter < niter; ++iiter) { - PyObject *f = PySequence_GetItem(op_flags_in, iiter); + for (iop = 0; iop < nop; ++iop) { + PyObject *f = PySequence_GetItem(op_flags_in, iop); if (f == NULL) { return 0; } /* If the first item is a string, try as one set of flags */ - if (iiter == 0 && (PyBytes_Check(f) || PyUnicode_Check(f))) { + if (iop == 0 && (PyBytes_Check(f) || PyUnicode_Check(f))) { Py_DECREF(f); goto try_single_flags; } if (NpyIter_OpFlagsConverter(f, - &op_flags_array[iiter]) != 1) { + &op_flags_array[iop]) != 1) { Py_DECREF(f); return 0; } @@ -484,8 +484,8 @@ try_single_flags: return 0; } - for (iiter = 1; iiter < niter; ++iiter) { - op_flags_array[iiter] = op_flags_array[0]; + for (iop = 1; iop < nop; ++iop) { + op_flags_array[iop] = op_flags_array[0]; } return 1; @@ -494,33 +494,33 @@ try_single_flags: static int npyiter_convert_dtypes(PyObject *op_dtypes_in, PyArray_Descr **op_dtypes, - npy_intp niter) + npy_intp nop) { - npy_intp iiter; + npy_intp iop; /* * If the input isn't a tuple of dtypes, try converting it as-is * to a dtype, and replicating to all operands. */ if ((!PyTuple_Check(op_dtypes_in) && !PyList_Check(op_dtypes_in)) || - PySequence_Size(op_dtypes_in) != niter) { + PySequence_Size(op_dtypes_in) != nop) { goto try_single_dtype; } - for (iiter = 0; iiter < niter; ++iiter) { - PyObject *dtype = PySequence_GetItem(op_dtypes_in, iiter); + for (iop = 0; iop < nop; ++iop) { + PyObject *dtype = PySequence_GetItem(op_dtypes_in, iop); if (dtype == NULL) { npy_intp i; - for (i = 0; i < iiter; ++i ) { + for (i = 0; i < iop; ++i ) { Py_XDECREF(op_dtypes[i]); } return 0; } /* Try converting the object to a descr */ - if (PyArray_DescrConverter2(dtype, &op_dtypes[iiter]) != 1) { + if (PyArray_DescrConverter2(dtype, &op_dtypes[iop]) != 1) { npy_intp i; - for (i = 0; i < iiter; ++i ) { + for (i = 0; i < iop; ++i ) { Py_XDECREF(op_dtypes[i]); } Py_DECREF(dtype); @@ -535,9 +535,9 @@ npyiter_convert_dtypes(PyObject *op_dtypes_in, try_single_dtype: if (PyArray_DescrConverter2(op_dtypes_in, &op_dtypes[0]) == 1) { - for (iiter = 1; iiter < niter; ++iiter) { - op_dtypes[iiter] = op_dtypes[0]; - Py_XINCREF(op_dtypes[iiter]); + for (iop = 1; iop < nop; ++iop) { + op_dtypes[iop] = op_dtypes[0]; + Py_XINCREF(op_dtypes[iop]); } return 1; } @@ -546,14 +546,14 @@ try_single_dtype: } static int -npyiter_convert_op_axes(PyObject *op_axes_in, npy_intp niter, +npyiter_convert_op_axes(PyObject *op_axes_in, npy_intp nop, int **op_axes, int *oa_ndim) { PyObject *a; - int iiter; + int iop; if ((!PyTuple_Check(op_axes_in) && !PyList_Check(op_axes_in)) || - PySequence_Size(op_axes_in) != niter) { + PySequence_Size(op_axes_in) != nop) { PyErr_SetString(PyExc_ValueError, "op_axes must be a tuple/list matching the number of ops"); return 0; @@ -562,14 +562,14 @@ npyiter_convert_op_axes(PyObject *op_axes_in, npy_intp niter, *oa_ndim = 0; /* Copy the tuples into op_axes */ - for (iiter = 0; iiter < niter; ++iiter) { + for (iop = 0; iop < nop; ++iop) { int idim; - a = PySequence_GetItem(op_axes_in, iiter); + a = PySequence_GetItem(op_axes_in, iop); if (a == NULL) { return 0; } if (a == Py_None) { - op_axes[iiter] = NULL; + op_axes[iop] = NULL; } else { if (!PyTuple_Check(a) && !PyList_Check(a)) { PyErr_SetString(PyExc_ValueError, @@ -605,11 +605,11 @@ npyiter_convert_op_axes(PyObject *op_axes_in, npy_intp niter, } /* numpy.newaxis is None */ if (v == Py_None) { - op_axes[iiter][idim] = -1; + op_axes[iop][idim] = -1; } else { - op_axes[iiter][idim] = PyInt_AsLong(v); - if (op_axes[iiter][idim]==-1 && + op_axes[iop][idim] = PyInt_AsLong(v); + if (op_axes[iop][idim]==-1 && PyErr_Occurred()) { Py_DECREF(a); Py_DECREF(v); @@ -634,34 +634,34 @@ npyiter_convert_op_axes(PyObject *op_axes_in, npy_intp niter, /* * Converts the operand array and op_flags array into the form NpyIter_AdvancedNew - * needs. Sets niter, and on success, each op[i] owns a reference + * needs. Sets nop, and on success, each op[i] owns a reference * to an array object. */ static int npyiter_convert_ops(PyObject *op_in, PyObject *op_flags_in, PyArrayObject **op, npy_uint32 *op_flags, - int *niter_out) + int *nop_out) { - int iiter, niter; + int iop, nop; - /* niter and op */ + /* nop and op */ if (PyTuple_Check(op_in) || PyList_Check(op_in)) { - niter = PySequence_Size(op_in); - if (niter == 0) { + nop = PySequence_Size(op_in); + if (nop == 0) { PyErr_SetString(PyExc_ValueError, "Must provide at least one operand"); return 0; } - if (niter > NPY_MAXARGS) { + if (nop > NPY_MAXARGS) { PyErr_SetString(PyExc_ValueError, "Too many operands"); return 0; } - for (iiter = 0; iiter < niter; ++iiter) { - PyObject *item = PySequence_GetItem(op_in, iiter); + for (iop = 0; iop < nop; ++iop) { + PyObject *item = PySequence_GetItem(op_in, iop); if (item == NULL) { npy_intp i; - for (i = 0; i < iiter; ++i) { + for (i = 0; i < iop; ++i) { Py_XDECREF(op[i]); } return 0; @@ -671,53 +671,53 @@ npyiter_convert_ops(PyObject *op_in, PyObject *op_flags_in, item = NULL; } /* This is converted to an array after op flags are retrieved */ - op[iiter] = (PyArrayObject *)item; + op[iop] = (PyArrayObject *)item; } } else { - niter = 1; + nop = 1; /* Is converted to an array after op flags are retrieved */ Py_INCREF(op_in); op[0] = (PyArrayObject *)op_in; } - *niter_out = niter; + *nop_out = nop; /* op_flags */ if (op_flags_in == NULL || op_flags_in == Py_None) { - for (iiter = 0; iiter < niter; ++iiter) { + for (iop = 0; iop < nop; ++iop) { /* * By default, make NULL operands writeonly and flagged for * allocation, and everything else readonly. To write * to a provided operand, you must specify the write flag manually. */ - if (op[iiter] == NULL) { - op_flags[iiter] = NPY_ITER_WRITEONLY | NPY_ITER_ALLOCATE; + if (op[iop] == NULL) { + op_flags[iop] = NPY_ITER_WRITEONLY | NPY_ITER_ALLOCATE; } else { - op_flags[iiter] = NPY_ITER_READONLY; + op_flags[iop] = NPY_ITER_READONLY; } } } else if (npyiter_convert_op_flags_array(op_flags_in, - op_flags, niter) != 1) { - for (iiter = 0; iiter < niter; ++iiter) { - Py_XDECREF(op[iiter]); + op_flags, nop) != 1) { + for (iop = 0; iop < nop; ++iop) { + Py_XDECREF(op[iop]); } - *niter_out = 0; + *nop_out = 0; return 0; } /* Now that we have the flags - convert all the ops to arrays */ - for (iiter = 0; iiter < niter; ++iiter) { - if (op[iiter] != NULL) { + for (iop = 0; iop < nop; ++iop) { + if (op[iop] != NULL) { PyArrayObject *ao; int fromanyflags = 0; - if (op_flags[iiter]&(NPY_ITER_READWRITE|NPY_ITER_WRITEONLY)) { + if (op_flags[iop]&(NPY_ITER_READWRITE|NPY_ITER_WRITEONLY)) { fromanyflags = NPY_UPDATEIFCOPY; } - ao = (PyArrayObject *)PyArray_FromAny((PyObject *)op[iiter], + ao = (PyArrayObject *)PyArray_FromAny((PyObject *)op[iop], NULL, 0, 0, fromanyflags, NULL); if (ao == NULL) { if (PyErr_Occurred() && @@ -727,14 +727,14 @@ npyiter_convert_ops(PyObject *op_in, PyObject *op_flags_in, "but is an object which cannot be written " "back to via UPDATEIFCOPY"); } - for (iiter = 0; iiter < niter; ++iiter) { - Py_DECREF(op[iiter]); + for (iop = 0; iop < nop; ++iop) { + Py_DECREF(op[iop]); } - *niter_out = 0; + *nop_out = 0; return 0; } - Py_DECREF(op[iiter]); - op[iiter] = ao; + Py_DECREF(op[iop]); + op[iop] = ao; } } @@ -752,7 +752,7 @@ npyiter_init(NewNpyArrayIterObject *self, PyObject *args, PyObject *kwds) PyObject *op_in = NULL, *op_flags_in = NULL, *op_dtypes_in = NULL, *op_axes_in = NULL; - int iiter, niter = 0; + int iop, nop = 0; PyArrayObject *op[NPY_MAXARGS]; npy_uint32 flags = 0; NPY_ORDER order = NPY_KEEPORDER; @@ -791,7 +791,7 @@ npyiter_init(NewNpyArrayIterObject *self, PyObject *args, PyObject *kwds) memset(op_request_dtypes, 0, sizeof(op_request_dtypes)); /* op and op_flags */ - if (npyiter_convert_ops(op_in, op_flags_in, op, op_flags, &niter) + if (npyiter_convert_ops(op_in, op_flags_in, op, op_flags, &nop) != 1) { goto fail; } @@ -799,18 +799,18 @@ npyiter_init(NewNpyArrayIterObject *self, PyObject *args, PyObject *kwds) /* op_request_dtypes */ if (op_dtypes_in != NULL && op_dtypes_in != Py_None && npyiter_convert_dtypes(op_dtypes_in, - op_request_dtypes, niter) != 1) { + op_request_dtypes, nop) != 1) { goto fail; } /* op_axes */ if (op_axes_in != NULL && op_axes_in != Py_None) { /* Initialize to point to the op_axes arrays */ - for (iiter = 0; iiter < niter; ++iiter) { - op_axes[iiter] = op_axes_arrays[iiter]; + for (iop = 0; iop < nop; ++iop) { + op_axes[iop] = op_axes_arrays[iop]; } - if (npyiter_convert_op_axes(op_axes_in, niter, + if (npyiter_convert_op_axes(op_axes_in, nop, op_axes, &oa_ndim) != 1) { goto fail; } @@ -833,7 +833,7 @@ npyiter_init(NewNpyArrayIterObject *self, PyObject *args, PyObject *kwds) itershape.ptr = NULL; } - self->iter = NpyIter_AdvancedNew(niter, op, flags, order, casting, op_flags, + self->iter = NpyIter_AdvancedNew(nop, op, flags, order, casting, op_flags, op_request_dtypes, oa_ndim, oa_ndim > 0 ? op_axes : NULL, itershape.ptr, @@ -860,9 +860,9 @@ npyiter_init(NewNpyArrayIterObject *self, PyObject *args, PyObject *kwds) } /* Release the references we got to the ops and dtypes */ - for (iiter = 0; iiter < niter; ++iiter) { - Py_XDECREF(op[iiter]); - Py_XDECREF(op_request_dtypes[iiter]); + for (iop = 0; iop < nop; ++iop) { + Py_XDECREF(op[iop]); + Py_XDECREF(op_request_dtypes[iop]); } return 0; @@ -871,9 +871,9 @@ fail: if (itershape.ptr != NULL) { PyDimMem_FREE(itershape.ptr); } - for (iiter = 0; iiter < niter; ++iiter) { - Py_XDECREF(op[iiter]); - Py_XDECREF(op_request_dtypes[iiter]); + for (iop = 0; iop < nop; ++iop) { + Py_XDECREF(op[iop]); + Py_XDECREF(op_request_dtypes[iop]); } return -1; } @@ -890,7 +890,7 @@ NpyIter_NestedIters(PyObject *NPY_UNUSED(self), PyObject *op_in = NULL, *axes_in = NULL, *op_flags_in = NULL, *op_dtypes_in = NULL; - int iiter, niter = 0, inest, nnest = 0; + int iop, nop = 0, inest, nnest = 0; PyArrayObject *op[NPY_MAXARGS]; npy_uint32 flags = 0, flags_inner = 0; NPY_ORDER order = NPY_KEEPORDER; @@ -986,20 +986,20 @@ NpyIter_NestedIters(PyObject *NPY_UNUSED(self), } /* op and op_flags */ - if (npyiter_convert_ops(op_in, op_flags_in, op, op_flags, &niter) + if (npyiter_convert_ops(op_in, op_flags_in, op, op_flags, &nop) != 1) { return NULL; } /* Set the dtypes to all NULL to start as well */ - memset(op_request_dtypes, 0, sizeof(op_request_dtypes[0])*niter); + memset(op_request_dtypes, 0, sizeof(op_request_dtypes[0])*nop); memset(op_request_dtypes_inner, 0, - sizeof(op_request_dtypes_inner[0])*niter); + sizeof(op_request_dtypes_inner[0])*nop); /* op_request_dtypes */ if (op_dtypes_in != NULL && op_dtypes_in != Py_None && npyiter_convert_dtypes(op_dtypes_in, - op_request_dtypes, niter) != 1) { + op_request_dtypes, nop) != 1) { goto fail; } @@ -1018,16 +1018,16 @@ NpyIter_NestedIters(PyObject *NPY_UNUSED(self), * to indicate exactly the allocated outputs. Also, separate * the inner loop flags. */ - for (iiter = 0; iiter < niter; ++iiter) { - if ((op_flags[iiter]&NPY_ITER_ALLOCATE) && op[iiter] != NULL) { - op_flags[iiter] &= ~NPY_ITER_ALLOCATE; + for (iop = 0; iop < nop; ++iop) { + if ((op_flags[iop]&NPY_ITER_ALLOCATE) && op[iop] != NULL) { + op_flags[iop] &= ~NPY_ITER_ALLOCATE; } /* * Clear any flags allowing copies or output allocation for * the inner loop. */ - op_flags_inner[iiter] = op_flags[iiter] & ~(NPY_ITER_COPY| + op_flags_inner[iop] = op_flags[iop] & ~(NPY_ITER_COPY| NPY_ITER_UPDATEIFCOPY| NPY_ITER_ALLOCATE); /* @@ -1036,12 +1036,12 @@ NpyIter_NestedIters(PyObject *NPY_UNUSED(self), * for the outer loops. */ if ((flags&(NPY_ITER_BUFFERED)) && - !(op_flags[iiter]&(NPY_ITER_COPY| + !(op_flags[iop]&(NPY_ITER_COPY| NPY_ITER_UPDATEIFCOPY| NPY_ITER_ALLOCATE))) { - op_flags[iiter] &= ~(NPY_ITER_NBO|NPY_ITER_ALIGNED|NPY_ITER_CONTIG); - op_request_dtypes_inner[iiter] = op_request_dtypes[iiter]; - op_request_dtypes[iiter] = NULL; + op_flags[iop] &= ~(NPY_ITER_NBO|NPY_ITER_ALIGNED|NPY_ITER_CONTIG); + op_request_dtypes_inner[iop] = op_request_dtypes[iop]; + op_request_dtypes[iop] = NULL; } } @@ -1052,33 +1052,33 @@ NpyIter_NestedIters(PyObject *NPY_UNUSED(self), for (inest = 0; inest < nnest; ++inest) { NewNpyArrayIterObject *iter; - int *op_axes_niter[NPY_MAXARGS]; + int *op_axes_nop[NPY_MAXARGS]; /* * All the operands' op_axes are the same, except for * allocated outputs. */ - for (iiter = 0; iiter < niter; ++iiter) { - if (op_flags[iiter]&NPY_ITER_ALLOCATE) { + for (iop = 0; iop < nop; ++iop) { + if (op_flags[iop]&NPY_ITER_ALLOCATE) { if (inest == 0) { - op_axes_niter[iiter] = NULL; + op_axes_nop[iop] = NULL; } else { - op_axes_niter[iiter] = negones; + op_axes_nop[iop] = negones; } } else { - op_axes_niter[iiter] = nested_op_axes[inest]; + op_axes_nop[iop] = nested_op_axes[inest]; } } /* printf("\n"); - for (iiter = 0; iiter < niter; ++iiter) { + for (iop = 0; iop < nop; ++iop) { npy_intp i; for (i = 0; i < nested_naxes[inest]; ++i) { - printf("%d ", (int)op_axes_niter[iiter][i]); + printf("%d ", (int)op_axes_nop[iop][i]); } printf("\n"); } @@ -1092,17 +1092,17 @@ NpyIter_NestedIters(PyObject *NPY_UNUSED(self), } if (inest < nnest-1) { - iter->iter = NpyIter_AdvancedNew(niter, op, flags, order, + iter->iter = NpyIter_AdvancedNew(nop, op, flags, order, casting, op_flags, op_request_dtypes, - nested_naxes[inest], op_axes_niter, + nested_naxes[inest], op_axes_nop, NULL, 0); } else { - iter->iter = NpyIter_AdvancedNew(niter, op, flags_inner, order, + iter->iter = NpyIter_AdvancedNew(nop, op, flags_inner, order, casting, op_flags_inner, op_request_dtypes_inner, - nested_naxes[inest], op_axes_niter, + nested_naxes[inest], op_axes_nop, NULL, buffersize); } @@ -1130,18 +1130,18 @@ NpyIter_NestedIters(PyObject *NPY_UNUSED(self), */ if (inest == 0) { PyArrayObject **operands = NpyIter_GetOperandArray(iter->iter); - for (iiter = 0; iiter < niter; ++iiter) { - if (op[iiter] != operands[iiter]) { - Py_XDECREF(op[iiter]); - op[iiter] = operands[iiter]; - Py_INCREF(op[iiter]); + for (iop = 0; iop < nop; ++iop) { + if (op[iop] != operands[iop]) { + Py_XDECREF(op[iop]); + op[iop] = operands[iop]; + Py_INCREF(op[iop]); } /* * Clear any flags allowing copies for * the rest of the iterators */ - op_flags[iiter] &= ~(NPY_ITER_COPY| + op_flags[iop] &= ~(NPY_ITER_COPY| NPY_ITER_UPDATEIFCOPY); } /* Clear the common dtype flag for the rest of the iterators */ @@ -1152,10 +1152,10 @@ NpyIter_NestedIters(PyObject *NPY_UNUSED(self), } /* Release our references to the ops and dtypes */ - for (iiter = 0; iiter < niter; ++iiter) { - Py_XDECREF(op[iiter]); - Py_XDECREF(op_request_dtypes[iiter]); - Py_XDECREF(op_request_dtypes_inner[iiter]); + for (iop = 0; iop < nop; ++iop) { + Py_XDECREF(op[iop]); + Py_XDECREF(op_request_dtypes[iop]); + Py_XDECREF(op_request_dtypes_inner[iop]); } /* Set up the nested child references */ @@ -1183,10 +1183,10 @@ NpyIter_NestedIters(PyObject *NPY_UNUSED(self), return ret; fail: - for (iiter = 0; iiter < niter; ++iiter) { - Py_XDECREF(op[iiter]); - Py_XDECREF(op_request_dtypes[iiter]); - Py_XDECREF(op_request_dtypes_inner[iiter]); + for (iop = 0; iop < nop; ++iop) { + Py_XDECREF(op[iop]); + Py_XDECREF(op_request_dtypes[iop]); + Py_XDECREF(op_request_dtypes_inner[iop]); } return NULL; } @@ -1416,7 +1416,7 @@ static PyObject *npyiter_value_get(NewNpyArrayIterObject *self) { PyObject *ret; - npy_intp iiter, niter; + npy_intp iop, nop; PyArray_Descr **dtypes; char **dataptrs; @@ -1426,26 +1426,26 @@ static PyObject *npyiter_value_get(NewNpyArrayIterObject *self) return NULL; } - niter = NpyIter_GetNIter(self->iter); + nop = NpyIter_GetNOp(self->iter); dtypes = self->dtypes; dataptrs = self->dataptrs; /* Return an array or tuple of arrays with the values */ - if (niter == 1) { + if (nop == 1) { ret = npyiter_seq_item(self, 0); } else { - ret = PyTuple_New(niter); + ret = PyTuple_New(nop); if (ret == NULL) { return NULL; } - for (iiter = 0; iiter < niter; ++iiter) { - PyObject *a = npyiter_seq_item(self, iiter); + for (iop = 0; iop < nop; ++iop) { + PyObject *a = npyiter_seq_item(self, iop); if (a == NULL) { Py_DECREF(ret); return NULL; } - PyTuple_SET_ITEM(ret, iiter, a); + PyTuple_SET_ITEM(ret, iop, a); } } @@ -1456,7 +1456,7 @@ static PyObject *npyiter_operands_get(NewNpyArrayIterObject *self) { PyObject *ret; - npy_intp iiter, niter; + npy_intp iop, nop; PyArrayObject **operands; if (self->iter == NULL) { @@ -1465,18 +1465,18 @@ static PyObject *npyiter_operands_get(NewNpyArrayIterObject *self) return NULL; } - niter = NpyIter_GetNIter(self->iter); + nop = NpyIter_GetNOp(self->iter); operands = self->operands; - ret = PyTuple_New(niter); + ret = PyTuple_New(nop); if (ret == NULL) { return NULL; } - for (iiter = 0; iiter < niter; ++iiter) { - PyObject *operand = (PyObject *)operands[iiter]; + for (iop = 0; iop < nop; ++iop) { + PyObject *operand = (PyObject *)operands[iop]; Py_INCREF(operand); - PyTuple_SET_ITEM(ret, iiter, operand); + PyTuple_SET_ITEM(ret, iop, operand); } return ret; @@ -1486,7 +1486,7 @@ static PyObject *npyiter_itviews_get(NewNpyArrayIterObject *self) { PyObject *ret; - npy_intp iiter, niter; + npy_intp iop, nop; if (self->iter == NULL) { PyErr_SetString(PyExc_ValueError, @@ -1494,20 +1494,20 @@ static PyObject *npyiter_itviews_get(NewNpyArrayIterObject *self) return NULL; } - niter = NpyIter_GetNIter(self->iter); + nop = NpyIter_GetNOp(self->iter); - ret = PyTuple_New(niter); + ret = PyTuple_New(nop); if (ret == NULL) { return NULL; } - for (iiter = 0; iiter < niter; ++iiter) { - PyArrayObject *view = NpyIter_GetIterView(self->iter, iiter); + for (iop = 0; iop < nop; ++iop) { + PyArrayObject *view = NpyIter_GetIterView(self->iter, iop); if (view == NULL) { Py_DECREF(ret); return NULL; } - PyTuple_SET_ITEM(ret, iiter, (PyObject *)view); + PyTuple_SET_ITEM(ret, iop, (PyObject *)view); } return ret; @@ -1909,7 +1909,7 @@ static PyObject *npyiter_dtypes_get(NewNpyArrayIterObject *self) { PyObject *ret; - npy_intp iiter, niter; + npy_intp iop, nop; PyArray_Descr **dtypes; if (self->iter == NULL) { @@ -1918,18 +1918,18 @@ static PyObject *npyiter_dtypes_get(NewNpyArrayIterObject *self) return NULL; } - niter = NpyIter_GetNIter(self->iter); + nop = NpyIter_GetNOp(self->iter); - ret = PyTuple_New(niter); + ret = PyTuple_New(nop); if (ret == NULL) { return NULL; } dtypes = self->dtypes; - for (iiter = 0; iiter < niter; ++iiter) { - PyArray_Descr *dtype = dtypes[iiter]; + for (iop = 0; iop < nop; ++iop) { + PyArray_Descr *dtype = dtypes[iop]; Py_INCREF(dtype); - PyTuple_SET_ITEM(ret, iiter, (PyObject *)dtype); + PyTuple_SET_ITEM(ret, iop, (PyObject *)dtype); } return ret; @@ -1946,7 +1946,7 @@ static PyObject *npyiter_ndim_get(NewNpyArrayIterObject *self) return PyInt_FromLong(NpyIter_GetNDim(self->iter)); } -static PyObject *npyiter_niter_get(NewNpyArrayIterObject *self) +static PyObject *npyiter_nop_get(NewNpyArrayIterObject *self) { if (self->iter == NULL) { PyErr_SetString(PyExc_ValueError, @@ -1954,7 +1954,7 @@ static PyObject *npyiter_niter_get(NewNpyArrayIterObject *self) return NULL; } - return PyInt_FromLong(NpyIter_GetNIter(self->iter)); + return PyInt_FromLong(NpyIter_GetNOp(self->iter)); } static PyObject *npyiter_itersize_get(NewNpyArrayIterObject *self) @@ -1985,7 +1985,7 @@ npyiter_seq_length(NewNpyArrayIterObject *self) return 0; } else { - return NpyIter_GetNIter(self->iter); + return NpyIter_GetNOp(self->iter); } } @@ -1995,7 +1995,7 @@ npyiter_seq_item(NewNpyArrayIterObject *self, Py_ssize_t i) PyObject *ret; npy_intp ret_ndim; - npy_intp niter, innerloopsize, innerstride; + npy_intp nop, innerloopsize, innerstride; char *dataptr; PyArray_Descr *dtype; @@ -2012,8 +2012,8 @@ npyiter_seq_item(NewNpyArrayIterObject *self, Py_ssize_t i) return NULL; } - niter = NpyIter_GetNIter(self->iter); - if (i < 0 || i >= niter) { + nop = NpyIter_GetNOp(self->iter); + if (i < 0 || i >= nop) { PyErr_Format(PyExc_IndexError, "Iterator operand index %d is out of bounds", (int)i); return NULL; @@ -2067,7 +2067,7 @@ npyiter_seq_slice(NewNpyArrayIterObject *self, Py_ssize_t ilow, Py_ssize_t ihigh) { PyObject *ret; - npy_intp niter; + npy_intp nop; Py_ssize_t i; if (self->iter == NULL || self->finished) { @@ -2083,18 +2083,18 @@ npyiter_seq_slice(NewNpyArrayIterObject *self, return NULL; } - niter = NpyIter_GetNIter(self->iter); + nop = NpyIter_GetNOp(self->iter); if (ilow < 0) { ilow = 0; } - else if (ilow >= niter) { - ilow = niter-1; + else if (ilow >= nop) { + ilow = nop-1; } if (ihigh < ilow) { ihigh = ilow; } - else if (ihigh > niter) { - ihigh = niter; + else if (ihigh > nop) { + ihigh = nop; } ret = PyTuple_New(ihigh-ilow); @@ -2116,7 +2116,7 @@ NPY_NO_EXPORT int npyiter_seq_ass_item(NewNpyArrayIterObject *self, Py_ssize_t i, PyObject *v) { - npy_intp niter, innerloopsize, innerstride; + npy_intp nop, innerloopsize, innerstride; char *dataptr; PyArray_Descr *dtype; PyArrayObject *tmp; @@ -2141,8 +2141,8 @@ npyiter_seq_ass_item(NewNpyArrayIterObject *self, Py_ssize_t i, PyObject *v) return -1; } - niter = NpyIter_GetNIter(self->iter); - if (i < 0 || i >= niter) { + nop = NpyIter_GetNOp(self->iter); + if (i < 0 || i >= nop) { PyErr_Format(PyExc_IndexError, "Iterator operand index %d is out of bounds", (int)i); return -1; @@ -2184,7 +2184,7 @@ static int npyiter_seq_ass_slice(NewNpyArrayIterObject *self, Py_ssize_t ilow, Py_ssize_t ihigh, PyObject *v) { - npy_intp niter; + npy_intp nop; Py_ssize_t i; if (v == NULL) { @@ -2206,18 +2206,18 @@ npyiter_seq_ass_slice(NewNpyArrayIterObject *self, Py_ssize_t ilow, return -1; } - niter = NpyIter_GetNIter(self->iter); + nop = NpyIter_GetNOp(self->iter); if (ilow < 0) { ilow = 0; } - else if (ilow >= niter) { - ilow = niter-1; + else if (ilow >= nop) { + ilow = nop-1; } if (ihigh < ilow) { ihigh = ilow; } - else if (ihigh > niter) { - ihigh = niter; + else if (ihigh > nop) { + ihigh = nop; } if (!PySequence_Check(v) || PySequence_Size(v) != ihigh-ilow) { @@ -2268,7 +2268,7 @@ npyiter_subscript(NewNpyArrayIterObject *self, PyObject *op) else if (PySlice_Check(op)) { Py_ssize_t istart = 0, iend = 0, istep = 0; if (PySlice_GetIndices((PySliceObject *)op, - NpyIter_GetNIter(self->iter), + NpyIter_GetNOp(self->iter), &istart, &iend, &istep) < 0) { return NULL; } @@ -2313,7 +2313,7 @@ npyiter_ass_subscript(NewNpyArrayIterObject *self, PyObject *op, else if (PySlice_Check(op)) { Py_ssize_t istart = 0, iend = 0, istep = 0; if (PySlice_GetIndices((PySliceObject *)op, - NpyIter_GetNIter(self->iter), + NpyIter_GetNOp(self->iter), &istart, &iend, &istep) < 0) { return -1; } @@ -2395,8 +2395,8 @@ static PyGetSetDef npyiter_getsets[] = { {"ndim", (getter)npyiter_ndim_get, NULL, NULL, NULL}, - {"niter", - (getter)npyiter_niter_get, + {"nop", + (getter)npyiter_nop_get, NULL, NULL, NULL}, {"itersize", (getter)npyiter_itersize_get, diff --git a/numpy/core/src/umath/ufunc_object.c b/numpy/core/src/umath/ufunc_object.c index 59722cef4..8f87e7bff 100644 --- a/numpy/core/src/umath/ufunc_object.c +++ b/numpy/core/src/umath/ufunc_object.c @@ -976,7 +976,7 @@ ufunc_loop_matches(PyUFuncObject *self, char *out_err_src_typecode, char *out_err_dst_typecode) { - npy_intp i, nin = self->nin, niter = nin + self->nout; + npy_intp i, nin = self->nin, nop = nin + self->nout; /* * First check if all the inputs can be safely cast @@ -1035,7 +1035,7 @@ ufunc_loop_matches(PyUFuncObject *self, * If all the inputs were ok, then check casting back to the * outputs. */ - for (i = nin; i < niter; ++i) { + for (i = nin; i < nop; ++i) { if (op[i] != NULL) { PyArray_Descr *tmp = PyArray_DescrFromType(types[i]); if (tmp == NULL) { @@ -1065,11 +1065,11 @@ set_ufunc_loop_data_types(PyUFuncObject *self, PyArrayObject **op, int *types, npy_intp buffersize, int *out_trivial_loop_ok) { - npy_intp i, nin = self->nin, niter = nin + self->nout; + npy_intp i, nin = self->nin, nop = nin + self->nout; *out_trivial_loop_ok = 1; /* Fill the dtypes array */ - for (i = 0; i < niter; ++i) { + for (i = 0; i < nop; ++i) { out_dtype[i] = PyArray_DescrFromType(types[i]); if (out_dtype[i] == NULL) { return -1; @@ -1203,7 +1203,7 @@ find_ufunc_specified_userloop(PyUFuncObject *self, void **out_innerloopdata, int *out_trivial_loop_ok) { - npy_intp i, j, nin = self->nin, niter = nin + self->nout; + npy_intp i, j, nin = self->nin, nop = nin + self->nout; PyUFunc_Loop1d *funcdata; /* Use this to try to avoid repeating the same userdef loop search */ @@ -1233,8 +1233,8 @@ find_ufunc_specified_userloop(PyUFuncObject *self, int *types = funcdata->arg_types; int matched = 1; - if (n_specified == niter) { - for (j = 0; j < niter; ++j) { + if (n_specified == nop) { + for (j = 0; j < nop; ++j) { if (types[j] != specified_types[j]) { matched = 0; break; @@ -1313,7 +1313,7 @@ find_best_ufunc_inner_loop(PyUFuncObject *self, void **out_innerloopdata, int *out_trivial_loop_ok) { - npy_intp i, j, nin = self->nin, niter = nin + self->nout; + npy_intp i, j, nin = self->nin, nop = nin + self->nout; int types[NPY_MAXARGS]; char *ufunc_name; int no_castable_output, all_inputs_scalar; @@ -1370,7 +1370,7 @@ find_best_ufunc_inner_loop(PyUFuncObject *self, char *orig_types = self->types + i*self->nargs; /* Copy the types into an int array for matching */ - for (j = 0; j < niter; ++j) { + for (j = 0; j < nop; ++j) { types[j] = orig_types[j]; } @@ -1448,7 +1448,7 @@ find_specified_ufunc_inner_loop(PyUFuncObject *self, void **out_innerloopdata, int *out_trivial_loop_ok) { - npy_intp i, j, n, nin = self->nin, niter = nin + self->nout; + npy_intp i, j, n, nin = self->nin, nop = nin + self->nout; int n_specified = 0; int specified_types[NPY_MAXARGS], types[NPY_MAXARGS]; char *ufunc_name; @@ -1470,10 +1470,10 @@ find_specified_ufunc_inner_loop(PyUFuncObject *self, /* Fill in specified_types from the tuple or string */ if (PyTuple_Check(type_tup)) { n = PyTuple_GET_SIZE(type_tup); - if (n != 1 && n != niter) { + if (n != 1 && n != nop) { PyErr_Format(PyExc_ValueError, "a type-tuple must be specified " \ - "of length 1 or %d for ufunc '%s'", (int)niter, + "of length 1 or %d for ufunc '%s'", (int)nop, self->name ? self->name : "(unknown)"); return -1; } @@ -1507,7 +1507,7 @@ find_specified_ufunc_inner_loop(PyUFuncObject *self, Py_XDECREF(str_obj); return -1; } - if (length != 1 && (length != niter + 2 || + if (length != 1 && (length != nop + 2 || str[nin] != '-' || str[nin+1] != '>')) { PyErr_Format(PyExc_ValueError, "a type-string for %s, " \ @@ -1534,9 +1534,9 @@ find_specified_ufunc_inner_loop(PyUFuncObject *self, } else { PyArray_Descr *dtype; - n_specified = (int)niter; + n_specified = (int)nop; - for (i = 0; i < niter; ++i) { + for (i = 0; i < nop; ++i) { npy_intp istr = i < nin ? i : i+2; dtype = PyArray_DescrFromType(str[istr]); @@ -1579,12 +1579,12 @@ find_specified_ufunc_inner_loop(PyUFuncObject *self, NPY_UF_DBG_PRINT1("Trying function loop %d\n", (int)i); /* Copy the types into an int array for matching */ - for (j = 0; j < niter; ++j) { + for (j = 0; j < nop; ++j) { types[j] = orig_types[j]; } - if (n_specified == niter) { - for (j = 0; j < niter; ++j) { + if (n_specified == nop) { + for (j = 0; j < nop; ++j) { if (types[j] != specified_types[j]) { matched = 0; break; @@ -1783,7 +1783,7 @@ iterator_loop(PyUFuncObject *self, void *innerloopdata) { npy_intp i, nin = self->nin, nout = self->nout; - npy_intp niter = nin + nout; + npy_intp nop = nin + nout; npy_uint32 op_flags[NPY_MAXARGS]; NpyIter *iter; char *baseptrs[NPY_MAXARGS]; @@ -1803,7 +1803,7 @@ iterator_loop(PyUFuncObject *self, op_flags[i] = NPY_ITER_READONLY| NPY_ITER_ALIGNED; } - for (i = nin; i < niter; ++i) { + for (i = nin; i < nop; ++i) { op_flags[i] = NPY_ITER_WRITEONLY| NPY_ITER_ALIGNED| NPY_ITER_ALLOCATE| @@ -1816,7 +1816,7 @@ iterator_loop(PyUFuncObject *self, * were already checked, we use the casting rule 'unsafe' which * is faster to calculate. */ - iter = NpyIter_AdvancedNew(niter, op, + iter = NpyIter_AdvancedNew(nop, op, NPY_ITER_EXTERNAL_LOOP| NPY_ITER_REFS_OK| NPY_ITER_ZEROSIZE_OK| @@ -1834,7 +1834,7 @@ iterator_loop(PyUFuncObject *self, /* Copy any allocated outputs */ op_it = NpyIter_GetOperandArray(iter); - for (i = nin; i < niter; ++i) { + for (i = nin; i < nop; ++i) { if (op[i] == NULL) { op[i] = op_it[i]; Py_INCREF(op[i]); @@ -1857,7 +1857,7 @@ iterator_loop(PyUFuncObject *self, for (i = 0; i < nin; ++i) { baseptrs[i] = PyArray_BYTES(op_it[i]); } - for (i = nin; i < niter; ++i) { + for (i = nin; i < nop; ++i) { baseptrs[i] = PyArray_BYTES(op[i]); } if (NpyIter_ResetBasePointers(iter, baseptrs, NULL) != NPY_SUCCEED) { @@ -2074,7 +2074,7 @@ PyUFunc_GeneralizedFunction(PyUFuncObject *self, PyArrayObject **op) { int nin, nout; - int i, idim, niter; + int i, idim, nop; char *ufunc_name; int retval = -1, any_object = 0, subok = 1; NPY_CASTING input_casting; @@ -2134,14 +2134,14 @@ PyUFunc_GeneralizedFunction(PyUFuncObject *self, nin = self->nin; nout = self->nout; - niter = nin + nout; + nop = nin + nout; ufunc_name = self->name ? self->name : "<unnamed ufunc>"; NPY_UF_DBG_PRINT1("\nEvaluating ufunc %s\n", ufunc_name); /* Initialize all the operands and dtypes to NULL */ - for (i = 0; i < niter; ++i) { + for (i = 0; i < nop; ++i) { op[i] = NULL; dtype[i] = NULL; arr_prep[i] = NULL; @@ -2176,7 +2176,7 @@ PyUFunc_GeneralizedFunction(PyUFuncObject *self, /* Fill in op_axes for all the operands */ core_dim_ixs_size = 0; core_dim_ixs = self->core_dim_ixs; - for (i = 0; i < niter; ++i) { + for (i = 0; i < nop; ++i) { int n; if (op[i]) { /* @@ -2281,7 +2281,7 @@ PyUFunc_GeneralizedFunction(PyUFuncObject *self, printf(" "); } printf("\noutput types:\n"); - for (i = nin; i < niter; ++i) { + for (i = nin; i < nop; ++i) { PyObject_Print((PyObject *)dtype[i], stdout, 0); printf(" "); } @@ -2318,7 +2318,7 @@ PyUFunc_GeneralizedFunction(PyUFuncObject *self, NPY_ITER_COPY| NPY_ITER_ALIGNED; } - for (i = nin; i < niter; ++i) { + for (i = nin; i < nop; ++i) { op_flags[i] = NPY_ITER_READWRITE| NPY_ITER_UPDATEIFCOPY| NPY_ITER_ALIGNED| @@ -2327,7 +2327,7 @@ PyUFunc_GeneralizedFunction(PyUFuncObject *self, } /* Create the iterator */ - iter = NpyIter_AdvancedNew(niter, op, NPY_ITER_MULTI_INDEX| + iter = NpyIter_AdvancedNew(nop, op, NPY_ITER_MULTI_INDEX| NPY_ITER_REFS_OK| NPY_ITER_REDUCE_OK, order, NPY_UNSAFE_CASTING, op_flags, @@ -2338,7 +2338,7 @@ PyUFunc_GeneralizedFunction(PyUFuncObject *self, } /* Fill in any allocated outputs */ - for (i = nin; i < niter; ++i) { + for (i = nin; i < nop; ++i) { if (op[i] == NULL) { op[i] = NpyIter_GetOperandArray(iter)[i]; Py_INCREF(op[i]); @@ -2350,10 +2350,10 @@ PyUFunc_GeneralizedFunction(PyUFuncObject *self, * buffering, the strides are fixed throughout the looping. */ inner_strides = (npy_intp *)_pya_malloc( - NPY_SIZEOF_INTP * (niter+core_dim_ixs_size)); - /* The strides after the first niter match core_dim_ixs */ + NPY_SIZEOF_INTP * (nop+core_dim_ixs_size)); + /* The strides after the first nop match core_dim_ixs */ core_dim_ixs = self->core_dim_ixs; - inner_strides_tmp = inner_strides + niter; + inner_strides_tmp = inner_strides + nop; for (idim = 0; idim < self->core_num_dim_ix; ++idim) { ax_strides_tmp[idim] = NpyIter_GetAxisStrideArray(iter, broadcast_ndim+idim); @@ -2362,7 +2362,7 @@ PyUFunc_GeneralizedFunction(PyUFuncObject *self, goto fail; } } - for (i = 0; i < niter; ++i) { + for (i = 0; i < nop; ++i) { for (idim = 0; idim < self->core_num_dims[i]; ++idim) { inner_strides_tmp[idim] = ax_strides_tmp[core_dim_ixs[idim]][i]; } @@ -2397,15 +2397,15 @@ PyUFunc_GeneralizedFunction(PyUFuncObject *self, } /* - * The first niter strides are for the inner loop (but only can + * The first nop strides are for the inner loop (but only can * copy them after removing the core axes */ memcpy(inner_strides, NpyIter_GetInnerStrideArray(iter), - NPY_SIZEOF_INTP * niter); + NPY_SIZEOF_INTP * nop); #if 0 printf("strides: "); - for (i = 0; i < niter+core_dim_ixs_size; ++i) { + for (i = 0; i < nop+core_dim_ixs_size; ++i) { printf("%d ", (int)inner_strides[i]); } printf("\n"); @@ -2448,7 +2448,7 @@ PyUFunc_GeneralizedFunction(PyUFuncObject *self, _pya_free(inner_strides); NpyIter_Deallocate(iter); /* The caller takes ownership of all the references in op */ - for (i = 0; i < niter; ++i) { + for (i = 0; i < nop; ++i) { Py_XDECREF(dtype[i]); Py_XDECREF(arr_prep[i]); } @@ -2468,7 +2468,7 @@ fail: if (iter != NULL) { NpyIter_Deallocate(iter); } - for (i = 0; i < niter; ++i) { + for (i = 0; i < nop; ++i) { Py_XDECREF(op[i]); op[i] = NULL; Py_XDECREF(dtype[i]); @@ -2492,7 +2492,7 @@ PyUFunc_GenericFunction(PyUFuncObject *self, PyArrayObject **op) { int nin, nout; - int i, niter; + int i, nop; char *ufunc_name; int retval = -1, any_object = 0, subok = 1; NPY_CASTING input_casting; @@ -2541,14 +2541,14 @@ PyUFunc_GenericFunction(PyUFuncObject *self, nin = self->nin; nout = self->nout; - niter = nin + nout; + nop = nin + nout; ufunc_name = self->name ? self->name : "<unnamed ufunc>"; NPY_UF_DBG_PRINT1("\nEvaluating ufunc %s\n", ufunc_name); /* Initialize all the operands and dtypes to NULL */ - for (i = 0; i < niter; ++i) { + for (i = 0; i < nop; ++i) { op[i] = NULL; dtype[i] = NULL; arr_prep[i] = NULL; @@ -2629,7 +2629,7 @@ PyUFunc_GenericFunction(PyUFuncObject *self, printf(" "); } printf("\noutput types:\n"); - for (i = nin; i < niter; ++i) { + for (i = nin; i < nop; ++i) { PyObject_Print((PyObject *)dtype[i], stdout, 0); printf(" "); } @@ -2678,7 +2678,7 @@ PyUFunc_GenericFunction(PyUFuncObject *self, } /* The caller takes ownership of all the references in op */ - for (i = 0; i < niter; ++i) { + for (i = 0; i < nop; ++i) { Py_XDECREF(dtype[i]); Py_XDECREF(arr_prep[i]); } @@ -2692,7 +2692,7 @@ PyUFunc_GenericFunction(PyUFuncObject *self, fail: NPY_UF_DBG_PRINT1("Returning failure code %d\n", retval); - for (i = 0; i < niter; ++i) { + for (i = 0; i < nop; ++i) { Py_XDECREF(op[i]); op[i] = NULL; Py_XDECREF(dtype[i]); |