summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--doc/release/1.6.0-notes.rst4
-rw-r--r--doc/source/reference/c-api.iterator.rst68
-rw-r--r--doc/source/reference/routines.indexing.rst2
-rw-r--r--numpy/add_newdocs.py26
-rw-r--r--numpy/core/code_generators/numpy_api.py8
-rw-r--r--numpy/core/include/numpy/ndarraytypes.h6
-rw-r--r--numpy/core/src/multiarray/item_selection.c24
-rw-r--r--numpy/core/src/multiarray/multiarraymodule.c2
-rw-r--r--numpy/core/src/multiarray/nditer.c.src318
-rw-r--r--numpy/core/src/multiarray/nditer_pywrap.c99
-rw-r--r--numpy/core/src/umath/ufunc_object.c12
-rw-r--r--numpy/core/tests/test_iterator.py164
-rw-r--r--numpy/lib/index_tricks.py4
-rw-r--r--numpy/lib/src/_compiled_base.c31
-rw-r--r--numpy/lib/tests/test_index_tricks.py44
15 files changed, 409 insertions, 403 deletions
diff --git a/doc/release/1.6.0-notes.rst b/doc/release/1.6.0-notes.rst
index 20ab3bf56..38b9df80b 100644
--- a/doc/release/1.6.0-notes.rst
+++ b/doc/release/1.6.0-notes.rst
@@ -76,8 +76,8 @@ mapping manually.
Other new functions
-------------------
-``numpy.ravel_coords`` : Converts a tuple of coordinate arrays into an array of
-flat indices, applying boundary modes to the coordinates.
+``numpy.ravel_multi_index`` : Converts a multi-index tuple into
+an array of flat indices, applying boundary modes to the indices.
``numpy.slogdet`` : Compute the sign and (natural) logarithm of the determinant
of an array.
diff --git a/doc/source/reference/c-api.iterator.rst b/doc/source/reference/c-api.iterator.rst
index b5c59a733..421678648 100644
--- a/doc/source/reference/c-api.iterator.rst
+++ b/doc/source/reference/c-api.iterator.rst
@@ -48,7 +48,7 @@ Here is a conversion table for which functions to use with the new iterator:
:cfunc:`PyArray_ITER_RESET` :cfunc:`NpyIter_Reset`
:cfunc:`PyArray_ITER_NEXT` Function pointer from :cfunc:`NpyIter_GetIterNext`
:cfunc:`PyArray_ITER_DATA` :cfunc:`NpyIter_GetDataPtrArray`
-:cfunc:`PyArray_ITER_GOTO` :cfunc:`NpyIter_GotoCoords`
+:cfunc:`PyArray_ITER_GOTO` :cfunc:`NpyIter_GotoMultiIndex`
:cfunc:`PyArray_ITER_GOTO1D` :cfunc:`NpyIter_GotoIndex` or
:cfunc:`NpyIter_GotoIterIndex`
:cfunc:`PyArray_ITER_NOTDONE` Return value of ``iternext`` function pointer
@@ -58,7 +58,7 @@ Here is a conversion table for which functions to use with the new iterator:
:cfunc:`PyArray_MultiIter_NEXT` Function pointer from :cfunc:`NpyIter_GetIterNext`
:cfunc:`PyArray_MultiIter_DATA` :cfunc:`NpyIter_GetDataPtrArray`
:cfunc:`PyArray_MultiIter_NEXTi` **NOT SUPPORTED** (always lock-step iteration)
-:cfunc:`PyArray_MultiIter_GOTO` :cfunc:`NpyIter_GotoCoords`
+:cfunc:`PyArray_MultiIter_GOTO` :cfunc:`NpyIter_GotoMultiIndex`
:cfunc:`PyArray_MultiIter_GOTO1D` :cfunc:`NpyIter_GotoIndex` or
:cfunc:`NpyIter_GotoIterIndex`
:cfunc:`PyArray_MultiIter_NOTDONE` Return value of ``iternext`` function pointer
@@ -267,10 +267,10 @@ an incomplete struct.
This is a function pointer for the iteration loop, returned by
:cfunc:`NpyIter_GetIterNext`.
-.. ctype:: NpyIter_GetCoordsFunc
+.. ctype:: NpyIter_GetMultiIndexFunc
- This is a function pointer for getting iterator coordinates, returned by
- :cfunc:`NpyIter_GetGetCoords`.
+ This is a function pointer for getting the current iterator multi-index,
+ returned by :cfunc:`NpyIter_GetGetMultiIndex`.
Construction and Destruction
----------------------------
@@ -360,9 +360,9 @@ Construction and Destruction
Causes the iterator to track a raveled flat index matching Fortran
order. This option cannot be used with :cdata:`NPY_ITER_C_INDEX`.
- .. cvar:: NPY_ITER_COORDS
+ .. cvar:: NPY_ITER_MULTI_INDEX
- Causes the iterator to track array coordinates.
+ Causes the iterator to track a multi-index.
This prevents the iterator from coalescing axes to
produce bigger inner loops.
@@ -372,7 +372,7 @@ Construction and Destruction
loop, requiring the user of the iterator to handle it.
This flag is incompatible with :cdata:`NPY_ITER_C_INDEX`,
- :cdata:`NPY_ITER_F_INDEX`, and :cdata:`NPY_ITER_COORDS`.
+ :cdata:`NPY_ITER_F_INDEX`, and :cdata:`NPY_ITER_MULTI_INDEX`.
.. cvar:: NPY_ITER_DONT_NEGATE_STRIDES
@@ -654,9 +654,9 @@ Construction and Destruction
.. cfunction:: int NpyIter_RemoveAxis(NpyIter* iter, int axis)``
Removes an axis from iteration. This requires that
- :cdata:`NPY_ITER_COORDS` was set for iterator creation, and does not work
- if buffering is enabled or an index is being tracked. This function
- also resets the iterator to its initial state.
+ :cdata:`NPY_ITER_MULTI_INDEX` was set for iterator creation, and does
+ not work if buffering is enabled or an index is being tracked. This
+ function also resets the iterator to its initial state.
This is useful for setting up an accumulation loop, for example.
The iterator can first be created with all the dimensions, including
@@ -671,10 +671,10 @@ Construction and Destruction
Returns ``NPY_SUCCEED`` or ``NPY_FAIL``.
-.. cfunction:: int NpyIter_RemoveCoords(NpyIter* iter)
+.. cfunction:: int NpyIter_RemoveMultiIndex(NpyIter* iter)
- If the iterator has coordinates, this strips support for them, and
- does further iterator optimizations that are possible if coordinates
+ If the iterator is tracking a multi-index, this strips support for them,
+ and does further iterator optimizations that are possible if multi-indices
are not needed. This function also resets the iterator to its initial
state.
@@ -682,17 +682,17 @@ Construction and Destruction
the iterator. Any cached functions or pointers from the iterator
must be retrieved again!
- After calling this function, :cfunc:`NpyIter_HasCoords`(iter) will
+ After calling this function, :cfunc:`NpyIter_HasMultiIndex`(iter) will
return false.
Returns ``NPY_SUCCEED`` or ``NPY_FAIL``.
.. cfunction:: int NpyIter_EnableExternalLoop(NpyIter* iter)
- If :cfunc:`NpyIter_RemoveCoords` was called, you may want to enable the
+ If :cfunc:`NpyIter_RemoveMultiIndex` was called, you may want to enable the
flag :cdata:`NPY_ITER_EXTERNAL_LOOP`. This flag is not permitted
- together with :cdata:`NPY_ITER_COORDS`, so this function is provided
- to enable the feature after :cfunc:`NpyIter_RemoveCoords` is called.
+ together with :cdata:`NPY_ITER_MULTI_INDEX`, so this function is provided
+ to enable the feature after :cfunc:`NpyIter_RemoveMultiIndex` is called.
This function also resets the iterator to its initial state.
**WARNING**: This function changes the internal logic of the iterator.
@@ -808,11 +808,11 @@ Construction and Destruction
} while (iternext2(iter2));
} while (iternext1(iter1));
-.. cfunction:: int NpyIter_GotoCoords(NpyIter* iter, npy_intp* coords)
+.. cfunction:: int NpyIter_GotoMultiIndex(NpyIter* iter, npy_intp* multi_index)
- Adjusts the iterator to point to the ``ndim`` coordinates
- pointed to by ``coords``. Returns an error if coordinates
- are not being tracked, the coordinates are out of bounds,
+ Adjusts the iterator to point to the ``ndim`` indices
+ pointed to by ``multi_index``. Returns an error if a multi-index
+ is not being tracked, the indices are out of bounds,
or inner loop iteration is disabled.
Returns ``NPY_SUCCEED`` or ``NPY_FAIL``.
@@ -867,10 +867,10 @@ Construction and Destruction
by the constructor flag :cdata:`NPY_ITER_EXTERNAL_LOOP` or
:cfunc:`NpyIter_EnableExternalLoop`.
-.. cfunction:: npy_bool NpyIter_HasCoords(NpyIter* iter)
+.. cfunction:: npy_bool NpyIter_HasMultiIndex(NpyIter* iter)
Returns 1 if the iterator was created with the
- :cdata:`NPY_ITER_COORDS` flag, 0 otherwise.
+ :cdata:`NPY_ITER_MULTI_INDEX` flag, 0 otherwise.
.. cfunction:: npy_bool NpyIter_HasIndex(NpyIter* iter)
@@ -901,8 +901,8 @@ Construction and Destruction
.. cfunction:: int NpyIter_GetNDim(NpyIter* iter)
- Returns the number of dimensions being iterated. If coordinates
- were not requested in the iterator constructor, this value
+ Returns the number of dimensions being iterated. If a multi-index
+ was not requested in the iterator constructor, this value
may be smaller than the number of dimensions in the original
objects.
@@ -913,7 +913,7 @@ Construction and Destruction
.. cfunction:: npy_intp* NpyIter_GetAxisStrideArray(NpyIter* iter, int axis)
Gets the array of strides for the specified axis. Requires that
- the iterator be tracking coordinates, and that buffering not
+ the iterator be tracking a multi-index, and that buffering not
be enabled.
This may be used when you want to match up operand axes in
@@ -927,7 +927,7 @@ Construction and Destruction
.. cfunction:: int NpyIter_GetShape(NpyIter* iter, npy_intp* outshape)
Returns the broadcast shape of the iterator in ``outshape``.
- This can only be called on an iterator which supports coordinates.
+ This can only be called on an iterator which is tracking a multi-index.
Returns ``NPY_SUCCEED`` or ``NPY_FAIL``.
@@ -976,7 +976,7 @@ Construction and Destruction
was passed for op_axes. This is for data packed contiguously,
but not necessarily in C or Fortran order. This should be used
together with :cfunc:`NpyIter_GetShape` and :cfunc:`NpyIter_GetNDim`
- with the flag :cdata:`NPY_ITER_COORDS` passed into the constructor.
+ with the flag :cdata:`NPY_ITER_MULTI_INDEX` passed into the constructor.
A use case for this function is to match the shape and layout of
the iterator and tack on one or more dimensions. For example,
@@ -986,7 +986,7 @@ Construction and Destruction
you do the same thing but add two dimensions, or take advantage of
the symmetry and pack it into 1 dimension with a particular encoding.
- This function may only be called if the iterator is tracking coordinates
+ This function may only be called if the iterator is tracking a multi-index
and if :cdata:`NPY_ITER_DONT_NEGATE_STRIDES` was used to prevent an axis
from being iterated in reverse order.
@@ -1097,11 +1097,11 @@ Functions For Iteration
}
} while (iternext());
-.. cfunction:: NpyIter_GetCoordsFunc *NpyIter_GetGetCoords(NpyIter* iter, char** errmsg)
+.. cfunction:: NpyIter_GetMultiIndexFunc *NpyIter_GetGetMultiIndex(NpyIter* iter, char** errmsg)
- Returns a function pointer for getting the coordinates
- of the iterator. Returns NULL if the iterator does not
- support coordinates. It is recommended that this function
+ Returns a function pointer for getting the current multi-index
+ of the iterator. Returns NULL if the iterator is not tracking
+ a multi-index. It is recommended that this function
pointer be cached in a local variable before the iteration
loop.
diff --git a/doc/source/reference/routines.indexing.rst b/doc/source/reference/routines.indexing.rst
index 98b7817b8..4a0ef840e 100644
--- a/doc/source/reference/routines.indexing.rst
+++ b/doc/source/reference/routines.indexing.rst
@@ -20,7 +20,7 @@ Generating index arrays
indices
ix_
ogrid
- ravel_coords
+ ravel_multi_index
unravel_index
diag_indices
diag_indices_from
diff --git a/numpy/add_newdocs.py b/numpy/add_newdocs.py
index c62fcd186..8499b3d9d 100644
--- a/numpy/add_newdocs.py
+++ b/numpy/add_newdocs.py
@@ -4429,19 +4429,19 @@ add_newdoc('numpy.lib._compiled_base', 'bincount',
""")
-add_newdoc('numpy.lib._compiled_base', 'ravel_coords',
+add_newdoc('numpy.lib._compiled_base', 'ravel_multi_index',
"""
- ravel_coords(coords, dims, mode='raise', order='C')
+ ravel_multi_index(multi_index, dims, mode='raise', order='C')
- Converts a tuple of coordinate arrays into an array of flat
- indices, applying boundary modes to the coordinates.
+ Converts a tuple of index arrays into an array of flat
+ indices, applying boundary modes to the multi-index.
Parameters
----------
- coords : tuple of array_like
+ multi_index : tuple of array_like
A tuple of integer arrays, one array for each dimension.
dims : tuple of ints
- The shape of array into which the indices from ``coords`` apply.
+ The shape of array into which the indices from ``multi_index`` apply.
mode : {'raise', 'wrap', 'clip'}, optional
Specifies how out-of-bounds indices are handled. Can specify
either one mode or a tuple of modes, one mode per index.
@@ -4453,7 +4453,7 @@ add_newdoc('numpy.lib._compiled_base', 'ravel_coords',
In 'clip' mode, a negative index which would normally
wrap will clip to 0 instead.
order : {'C', 'F'}, optional
- Determines whether the coords should be viewed as indexing in
+ Determines whether the multi-index should be viewed as indexing in
C (row-major) order or FORTRAN (column-major) order.
Returns
@@ -4473,16 +4473,16 @@ add_newdoc('numpy.lib._compiled_base', 'ravel_coords',
Examples
--------
>>> arr = np.array([[3,6,6],[4,5,1]])
- >>> np.ravel_coords(arr, (7,6))
+ >>> np.ravel_multi_index(arr, (7,6))
array([22, 41, 37])
- >>> np.ravel_coords(arr, (7,6), order='F')
+ >>> np.ravel_multi_index(arr, (7,6), order='F')
array([31, 41, 13])
- >>> np.ravel_coords(arr, (4,6), mode='clip')
+ >>> np.ravel_multi_index(arr, (4,6), mode='clip')
array([22, 23, 19])
- >>> np.ravel_coords(arr, (4,4), mode=('clip','wrap'))
+ >>> np.ravel_multi_index(arr, (4,4), mode=('clip','wrap'))
array([12, 13, 13])
- >>> np.ravel_coords((3,1,4,1), (6,7,8,9))
+ >>> np.ravel_multi_index((3,1,4,1), (6,7,8,9))
1621
""")
@@ -4515,7 +4515,7 @@ add_newdoc('numpy.lib._compiled_base', 'unravel_index',
See Also
--------
- ravel_coords
+ ravel_multi_index
Examples
--------
diff --git a/numpy/core/code_generators/numpy_api.py b/numpy/core/code_generators/numpy_api.py
index 4aef212bf..b314f9f84 100644
--- a/numpy/core/code_generators/numpy_api.py
+++ b/numpy/core/code_generators/numpy_api.py
@@ -277,11 +277,11 @@ multiarray_funcs_api = {
'NpyIter_GetIterIndexRange': 241,
'NpyIter_GetIterIndex': 242,
'NpyIter_GotoIterIndex': 243,
- 'NpyIter_HasCoords': 244,
+ 'NpyIter_HasMultiIndex': 244,
'NpyIter_GetShape': 245,
- 'NpyIter_GetGetCoords': 246,
- 'NpyIter_GotoCoords': 247,
- 'NpyIter_RemoveCoords': 248,
+ 'NpyIter_GetGetMultiIndex': 246,
+ 'NpyIter_GotoMultiIndex': 247,
+ 'NpyIter_RemoveMultiIndex': 248,
'NpyIter_HasIndex': 249,
'NpyIter_IsBuffered': 250,
'NpyIter_IsGrowInner': 251,
diff --git a/numpy/core/include/numpy/ndarraytypes.h b/numpy/core/include/numpy/ndarraytypes.h
index 26077ba59..4cd2de70e 100644
--- a/numpy/core/include/numpy/ndarraytypes.h
+++ b/numpy/core/include/numpy/ndarraytypes.h
@@ -868,7 +868,7 @@ typedef struct NpyIter_InternalOnly NpyIter;
/* Iterator function pointers that may be specialized */
typedef int (NpyIter_IterNextFunc)(NpyIter *iter);
-typedef void (NpyIter_GetCoordsFunc)(NpyIter *iter,
+typedef void (NpyIter_GetMultiIndexFunc)(NpyIter *iter,
npy_intp *outcoords);
/*** Global flags that may be passed to the iterator constructors ***/
@@ -877,8 +877,8 @@ typedef void (NpyIter_GetCoordsFunc)(NpyIter *iter,
#define NPY_ITER_C_INDEX 0x00000001
/* Track an index representing Fortran order */
#define NPY_ITER_F_INDEX 0x00000002
-/* Track coordinates */
-#define NPY_ITER_COORDS 0x00000004
+/* Track a multi-index */
+#define NPY_ITER_MULTI_INDEX 0x00000004
/* User code external to the iterator does the 1-dimensional innermost loop */
#define NPY_ITER_EXTERNAL_LOOP 0x00000008
/* Convert all the operands to a common data type */
diff --git a/numpy/core/src/multiarray/item_selection.c b/numpy/core/src/multiarray/item_selection.c
index 91d5f1f4e..3b3a0a5ae 100644
--- a/numpy/core/src/multiarray/item_selection.c
+++ b/numpy/core/src/multiarray/item_selection.c
@@ -1780,11 +1780,11 @@ PyArray_Nonzero(PyArrayObject *self)
char *data;
npy_intp stride, count;
npy_intp nonzero_count = PyArray_CountNonzero(self);
- npy_intp *coords;
+ npy_intp *multi_index;
NpyIter *iter;
NpyIter_IterNextFunc *iternext;
- NpyIter_GetCoordsFunc *getcoords;
+ NpyIter_GetMultiIndexFunc *get_multi_index;
char **dataptr;
npy_intp *innersizeptr;
@@ -1802,14 +1802,14 @@ PyArray_Nonzero(PyArrayObject *self)
if (ndim <= 1) {
npy_intp j;
- coords = (npy_intp *)PyArray_DATA(ret);
+ multi_index = (npy_intp *)PyArray_DATA(ret);
data = PyArray_BYTES(self);
stride = (ndim == 0) ? 0 : PyArray_STRIDE(self, 0);
count = (ndim == 0) ? 1 : PyArray_DIM(self, 0);
for (j = 0; j < count; ++j) {
if (nonzero(data, self)) {
- *coords++ = j;
+ *multi_index++ = j;
}
data += stride;
}
@@ -1817,9 +1817,9 @@ PyArray_Nonzero(PyArrayObject *self)
goto finish;
}
- /* Build an iterator with coordinates, in C order */
+ /* Build an iterator tracking a multi-index, in C order */
iter = NpyIter_New(self, NPY_ITER_READONLY|
- NPY_ITER_COORDS|
+ NPY_ITER_MULTI_INDEX|
NPY_ITER_ZEROSIZE_OK|
NPY_ITER_REFS_OK,
NPY_CORDER, NPY_NO_CASTING,
@@ -1838,8 +1838,8 @@ PyArray_Nonzero(PyArrayObject *self)
Py_DECREF(ret);
return NULL;
}
- getcoords = NpyIter_GetGetCoords(iter, NULL);
- if (getcoords == NULL) {
+ get_multi_index = NpyIter_GetGetMultiIndex(iter, NULL);
+ if (get_multi_index == NULL) {
NpyIter_Deallocate(iter);
Py_DECREF(ret);
return NULL;
@@ -1847,13 +1847,13 @@ PyArray_Nonzero(PyArrayObject *self)
dataptr = NpyIter_GetDataPtrArray(iter);
innersizeptr = NpyIter_GetInnerLoopSizePtr(iter);
- coords = (npy_intp *)PyArray_DATA(ret);
+ multi_index = (npy_intp *)PyArray_DATA(ret);
- /* Get the coordinates for each non-zero element */
+ /* Get the multi-index for each non-zero element */
do {
if (nonzero(*dataptr, self)) {
- getcoords(iter, coords);
- coords += ndim;
+ get_multi_index(iter, multi_index);
+ multi_index += ndim;
}
} while(iternext(iter));
}
diff --git a/numpy/core/src/multiarray/multiarraymodule.c b/numpy/core/src/multiarray/multiarraymodule.c
index db381cc84..ba31b0be7 100644
--- a/numpy/core/src/multiarray/multiarraymodule.c
+++ b/numpy/core/src/multiarray/multiarraymodule.c
@@ -1345,7 +1345,7 @@ PyArray_ClipmodeConverter(PyObject *object, NPY_CLIPMODE *val)
/*NUMPY_API
* Convert an object to an array of n NPY_CLIPMODE values.
* This is intended to be used in functions where a different mode
- * could be applied to each axis, like in ravel_coords.
+ * could be applied to each axis, like in ravel_multi_index.
*/
NPY_NO_EXPORT int
PyArray_ConvertClipmodeSequence(PyObject *object, NPY_CLIPMODE *modes, int n)
diff --git a/numpy/core/src/multiarray/nditer.c.src b/numpy/core/src/multiarray/nditer.c.src
index 648d32a33..e12767fbb 100644
--- a/numpy/core/src/multiarray/nditer.c.src
+++ b/numpy/core/src/multiarray/nditer.c.src
@@ -1,5 +1,5 @@
/*
- * This file implements the new, highly flexible iterator for NumPy.
+ * This file implements a highly flexible iterator for NumPy.
*
* Copyright (c) 2010-2011 by Mark Wiebe (mwwiebe@gmail.com)
* The Univerity of British Columbia
@@ -75,8 +75,8 @@
#define NPY_ITFLAG_NEGPERM 0x0002
/* The iterator is tracking an index */
#define NPY_ITFLAG_HASINDEX 0x0004
-/* The iterator is tracking coordinates */
-#define NPY_ITFLAG_HASCOORDS 0x0008
+/* The iterator is tracking a multi-index */
+#define NPY_ITFLAG_HASMULTIINDEX 0x0008
/* The iteration order was forced on construction */
#define NPY_ITFLAG_FORCEDORDER 0x0010
/* The inner loop is handled outside the iterator */
@@ -242,11 +242,11 @@ struct NpyIter_BD {
/* Internal-only AXISDATA MEMBER ACCESS. */
struct NpyIter_AD {
- npy_intp shape, coord;
+ npy_intp shape, index;
npy_intp ad_flexdata;
};
#define NAD_SHAPE(axisdata) ((axisdata)->shape)
-#define NAD_COORD(axisdata) ((axisdata)->coord)
+#define NAD_INDEX(axisdata) ((axisdata)->index)
#define NAD_STRIDES(axisdata) ( \
&(axisdata)->ad_flexdata + 0)
#define NAD_PTRS(axisdata) ((char **) \
@@ -259,7 +259,7 @@ struct NpyIter_AD {
#define NIT_AXISDATA_SIZEOF(itflags, ndim, niter) (( \
/* intp shape */ \
1 + \
- /* intp coord */ \
+ /* intp index */ \
1 + \
/* intp stride[niter+1] AND char* ptr[niter+1] */ \
2*((niter)+1) \
@@ -672,10 +672,10 @@ NpyIter_AdvancedNew(int niter, PyArrayObject **op_in, npy_uint32 flags,
NPY_IT_TIME_POINT(c_allocate_arrays);
/*
- * Finally, if coords weren't requested,
+ * Finally, if a multi-index wasn't requested,
* it may be possible to coalesce some axes together.
*/
- if (ndim > 1 && !(itflags&NPY_ITFLAG_HASCOORDS)) {
+ if (ndim > 1 && !(itflags&NPY_ITFLAG_HASMULTIINDEX)) {
npyiter_coalesce_axes(iter);
/*
* The operation may have changed the layout, so we have to
@@ -962,7 +962,7 @@ NpyIter_Deallocate(NpyIter *iter)
}
/*NUMPY_API
- * Removes an axis from iteration. This requires that NPY_ITER_COORDS
+ * Removes an axis from iteration. This requires that NPY_ITER_MULTI_INDEX
* was set for iterator creation, and does not work if buffering is
* enabled. This function also resets the iterator to its initial state.
*
@@ -983,10 +983,10 @@ NpyIter_RemoveAxis(NpyIter *iter, int axis)
npy_intp *baseoffsets = NIT_BASEOFFSETS(iter);
char **resetdataptr = NIT_RESETDATAPTR(iter);
- if (!(itflags&NPY_ITFLAG_HASCOORDS)) {
+ if (!(itflags&NPY_ITFLAG_HASMULTIINDEX)) {
PyErr_SetString(PyExc_RuntimeError,
"Iterator RemoveAxis may only be called "
- "if coordinates are being tracked");
+ "if a multi-index is being tracked");
return NPY_FAIL;
}
else if (itflags&NPY_ITFLAG_HASINDEX) {
@@ -1092,12 +1092,12 @@ NpyIter_RemoveAxis(NpyIter *iter, int axis)
}
/*NUMPY_API
- * Removes coords support from an iterator.
+ * Removes multi-index support from an iterator.
*
* Returns NPY_SUCCEED or NPY_FAIL.
*/
NPY_NO_EXPORT int
-NpyIter_RemoveCoords(NpyIter *iter)
+NpyIter_RemoveMultiIndex(NpyIter *iter)
{
npy_uint32 itflags;
@@ -1107,8 +1107,8 @@ NpyIter_RemoveCoords(NpyIter *iter)
}
itflags = NIT_ITFLAGS(iter);
- if (itflags&NPY_ITFLAG_HASCOORDS) {
- NIT_ITFLAGS(iter) = itflags & ~NPY_ITFLAG_HASCOORDS;
+ if (itflags&NPY_ITFLAG_HASMULTIINDEX) {
+ NIT_ITFLAGS(iter) = itflags & ~NPY_ITFLAG_HASMULTIINDEX;
npyiter_coalesce_axes(iter);
}
@@ -1126,10 +1126,10 @@ NpyIter_EnableExternalLoop(NpyIter *iter)
int niter = NIT_NITER(iter);
/* Check conditions under which this can be done */
- if (itflags&(NPY_ITFLAG_HASINDEX|NPY_ITFLAG_HASCOORDS)) {
+ if (itflags&(NPY_ITFLAG_HASINDEX|NPY_ITFLAG_HASMULTIINDEX)) {
PyErr_SetString(PyExc_ValueError,
"Iterator flag EXTERNAL_LOOP cannot be used "
- "if coords or an index is being tracked");
+ "if an index or multi-index is being tracked");
return NPY_FAIL;
}
if ((itflags&(NPY_ITFLAG_BUFFER|NPY_ITFLAG_RANGE|NPY_ITFLAG_EXLOOP))
@@ -1319,15 +1319,15 @@ NpyIter_ResetToIterIndexRange(NpyIter *iter,
}
/*NUMPY_API
- * Sets the iterator to the specified coordinates, which must have the
+ * Sets the iterator to the specified multi-index, which must have the
* correct number of entries for 'ndim'. It is only valid
- * when NPY_ITER_COORDS was passed to the constructor. This operation
- * fails if the coordinates are out of bounds.
+ * when NPY_ITER_MULTI_INDEX was passed to the constructor. This operation
+ * fails if the multi-index is out of bounds.
*
* Returns NPY_SUCCEED on success, NPY_FAIL on failure.
*/
NPY_NO_EXPORT int
-NpyIter_GotoCoords(NpyIter *iter, npy_intp *coords)
+NpyIter_GotoMultiIndex(NpyIter *iter, npy_intp *multi_index)
{
npy_uint32 itflags = NIT_ITFLAGS(iter);
int idim, ndim = NIT_NDIM(iter);
@@ -1338,23 +1338,23 @@ NpyIter_GotoCoords(NpyIter *iter, npy_intp *coords)
npy_intp sizeof_axisdata;
char *perm;
- if (!(itflags&NPY_ITFLAG_HASCOORDS)) {
+ if (!(itflags&NPY_ITFLAG_HASMULTIINDEX)) {
PyErr_SetString(PyExc_ValueError,
- "Cannot call GotoCoords on an iterator without "
- "requesting coordinates in the constructor");
+ "Cannot call GotoMultiIndex on an iterator without "
+ "requesting a multi-index in the constructor");
return NPY_FAIL;
}
if (itflags&NPY_ITFLAG_BUFFER) {
PyErr_SetString(PyExc_ValueError,
- "Cannot call GotoCoords on an iterator which "
+ "Cannot call GotoMultiIndex on an iterator which "
"is buffered");
return NPY_FAIL;
}
if (itflags&NPY_ITFLAG_EXLOOP) {
PyErr_SetString(PyExc_ValueError,
- "Cannot call GotoCoords on an iterator which "
+ "Cannot call GotoMultiIndex on an iterator which "
"has the flag EXTERNAL_LOOP");
return NPY_FAIL;
}
@@ -1363,7 +1363,7 @@ NpyIter_GotoCoords(NpyIter *iter, npy_intp *coords)
axisdata = NIT_AXISDATA(iter);
sizeof_axisdata = NIT_AXISDATA_SIZEOF(itflags, ndim, niter);
- /* Compute the iterindex corresponding to the coordinates */
+ /* Compute the iterindex corresponding to the multi-index */
iterindex = 0;
factor = 1;
for (idim = 0; idim < ndim; ++idim) {
@@ -1372,22 +1372,22 @@ NpyIter_GotoCoords(NpyIter *iter, npy_intp *coords)
shape = NAD_SHAPE(axisdata);
if (p < 0) {
- /* If the perm entry is negative, reverse the coordinate */
- i = shape - coords[ndim+p] - 1;
+ /* If the perm entry is negative, reverse the index */
+ i = shape - multi_index[ndim+p] - 1;
}
else {
- i = coords[ndim-p-1];
+ i = multi_index[ndim-p-1];
}
- /* Bounds-check this coordinate */
+ /* Bounds-check this index */
if (i >= 0 && i < shape) {
iterindex += factor * i;
factor *= shape;
}
else {
PyErr_SetString(PyExc_IndexError,
- "Iterator GotoCoords called with out-of-bounds "
- "coordinates.");
+ "Iterator GotoMultiIndex called with an out-of-bounds "
+ "multi-index");
return NPY_FAIL;
}
@@ -1396,8 +1396,8 @@ NpyIter_GotoCoords(NpyIter *iter, npy_intp *coords)
if (iterindex < NIT_ITERSTART(iter) || iterindex >= NIT_ITEREND(iter)) {
PyErr_SetString(PyExc_IndexError,
- "Iterator GotoCoords called with coordinates outside the "
- "iteration range.");
+ "Iterator GotoMultiIndex called with a multi-index outside the "
+ "restricted iteration range");
return NPY_FAIL;
}
@@ -1413,7 +1413,7 @@ NpyIter_GotoCoords(NpyIter *iter, npy_intp *coords)
* Returns NPY_SUCCEED on success, NPY_FAIL on failure.
*/
NPY_NO_EXPORT int
-NpyIter_GotoIndex(NpyIter *iter, npy_intp index)
+NpyIter_GotoIndex(NpyIter *iter, npy_intp flat_index)
{
npy_uint32 itflags = NIT_ITFLAGS(iter);
int idim, ndim = NIT_NDIM(iter);
@@ -1426,7 +1426,7 @@ NpyIter_GotoIndex(NpyIter *iter, npy_intp index)
if (!(itflags&NPY_ITFLAG_HASINDEX)) {
PyErr_SetString(PyExc_ValueError,
"Cannot call GotoIndex on an iterator without "
- "requesting an index in the constructor");
+ "requesting a C or Fortran index in the constructor");
return NPY_FAIL;
}
@@ -1444,17 +1444,17 @@ NpyIter_GotoIndex(NpyIter *iter, npy_intp index)
return NPY_FAIL;
}
- if (index < 0 || index >= NIT_ITERSIZE(iter)) {
+ if (flat_index < 0 || flat_index >= NIT_ITERSIZE(iter)) {
PyErr_SetString(PyExc_IndexError,
"Iterator GotoIndex called with an out-of-bounds "
- "index.");
+ "index");
return NPY_FAIL;
}
axisdata = NIT_AXISDATA(iter);
sizeof_axisdata = NIT_AXISDATA_SIZEOF(itflags, ndim, niter);
- /* Compute the iterindex corresponding to the index */
+ /* Compute the iterindex corresponding to the flat_index */
iterindex = 0;
factor = 1;
for (idim = 0; idim < ndim; ++idim) {
@@ -1463,15 +1463,15 @@ NpyIter_GotoIndex(NpyIter *iter, npy_intp index)
iterstride = NAD_STRIDES(axisdata)[niter];
shape = NAD_SHAPE(axisdata);
- /* Extract the coordinate from the index */
+ /* Extract the index from the flat_index */
if (iterstride == 0) {
i = 0;
}
else if (iterstride < 0) {
- i = shape - (index/(-iterstride))%shape - 1;
+ i = shape - (flat_index/(-iterstride))%shape - 1;
}
else {
- i = (index/iterstride)%shape;
+ i = (flat_index/iterstride)%shape;
}
/* Add its contribution to iterindex */
@@ -1485,7 +1485,7 @@ NpyIter_GotoIndex(NpyIter *iter, npy_intp index)
if (iterindex < NIT_ITERSTART(iter) || iterindex >= NIT_ITEREND(iter)) {
PyErr_SetString(PyExc_IndexError,
"Iterator GotoIndex called with an index outside the "
- "iteration range.");
+ "restricted iteration range.");
return NPY_FAIL;
}
@@ -1585,11 +1585,11 @@ NpyIter_GetIterIndex(NpyIter *iter)
axisdata = NIT_INDEX_AXISDATA(NIT_AXISDATA(iter), ndim-1);
for (idim = ndim-2; idim >= 0; --idim) {
- iterindex += NAD_COORD(axisdata);
+ iterindex += NAD_INDEX(axisdata);
NIT_ADVANCE_AXISDATA(axisdata, -1);
iterindex *= NAD_SHAPE(axisdata);
}
- iterindex += NAD_COORD(axisdata);
+ iterindex += NAD_INDEX(axisdata);
return iterindex;
}
@@ -1652,8 +1652,8 @@ npyiter_iternext_itflags@tag_itflags@_dims@tag_ndim@_iters@tag_niter@(
axisdata0 = NIT_AXISDATA(iter);
# if !(@const_itflags@&NPY_ITFLAG_EXLOOP)
- /* Increment coordinate 0 */
- NAD_COORD(axisdata0)++;
+ /* Increment index 0 */
+ NAD_INDEX(axisdata0)++;
/* Increment pointer 0 */
for (istrides = 0; istrides < nstrides; ++istrides) {
NAD_PTRS(axisdata0)[istrides] += NAD_STRIDES(axisdata0)[istrides];
@@ -1663,8 +1663,8 @@ npyiter_iternext_itflags@tag_itflags@_dims@tag_ndim@_iters@tag_niter@(
#if @const_ndim@ == 1
# if !(@const_itflags@&NPY_ITFLAG_EXLOOP)
- /* Finished when the coordinate equals the shape */
- return NAD_COORD(axisdata0) < NAD_SHAPE(axisdata0);
+ /* Finished when the index equals the shape */
+ return NAD_INDEX(axisdata0) < NAD_SHAPE(axisdata0);
# else
/* Get rid of unused variable warning */
istrides = 0;
@@ -1675,22 +1675,22 @@ npyiter_iternext_itflags@tag_itflags@_dims@tag_ndim@_iters@tag_niter@(
#else
# if !(@const_itflags@&NPY_ITFLAG_EXLOOP)
- if (NAD_COORD(axisdata0) < NAD_SHAPE(axisdata0)) {
+ if (NAD_INDEX(axisdata0) < NAD_SHAPE(axisdata0)) {
return 1;
}
# endif
axisdata1 = NIT_INDEX_AXISDATA(axisdata0, 1);
- /* Increment coordinate 1 */
- NAD_COORD(axisdata1)++;
+ /* Increment index 1 */
+ NAD_INDEX(axisdata1)++;
/* Increment pointer 1 */
for (istrides = 0; istrides < nstrides; ++istrides) {
NAD_PTRS(axisdata1)[istrides] += NAD_STRIDES(axisdata1)[istrides];
}
- if (NAD_COORD(axisdata1) < NAD_SHAPE(axisdata1)) {
- /* Reset the 1st coordinate to 0 */
- NAD_COORD(axisdata0) = 0;
+ if (NAD_INDEX(axisdata1) < NAD_SHAPE(axisdata1)) {
+ /* Reset the 1st index to 0 */
+ NAD_INDEX(axisdata0) = 0;
/* Reset the 1st pointer to the value of the 2nd */
for (istrides = 0; istrides < nstrides; ++istrides) {
NAD_PTRS(axisdata0)[istrides] = NAD_PTRS(axisdata1)[istrides];
@@ -1703,17 +1703,17 @@ npyiter_iternext_itflags@tag_itflags@_dims@tag_ndim@_iters@tag_niter@(
# else
axisdata2 = NIT_INDEX_AXISDATA(axisdata1, 1);
- /* Increment coordinate 2 */
- NAD_COORD(axisdata2)++;
+ /* Increment index 2 */
+ NAD_INDEX(axisdata2)++;
/* Increment pointer 2 */
for (istrides = 0; istrides < nstrides; ++istrides) {
NAD_PTRS(axisdata2)[istrides] += NAD_STRIDES(axisdata2)[istrides];
}
- if (NAD_COORD(axisdata2) < NAD_SHAPE(axisdata2)) {
- /* Reset the 1st and 2nd coordinates to 0 */
- NAD_COORD(axisdata0) = 0;
- NAD_COORD(axisdata1) = 0;
+ if (NAD_INDEX(axisdata2) < NAD_SHAPE(axisdata2)) {
+ /* Reset the 1st and 2nd indices to 0 */
+ NAD_INDEX(axisdata0) = 0;
+ NAD_INDEX(axisdata1) = 0;
/* Reset the 1st and 2nd pointers to the value of the 3nd */
for (istrides = 0; istrides < nstrides; ++istrides) {
NAD_PTRS(axisdata0)[istrides] = NAD_PTRS(axisdata2)[istrides];
@@ -1724,21 +1724,21 @@ npyiter_iternext_itflags@tag_itflags@_dims@tag_ndim@_iters@tag_niter@(
for (idim = 3; idim < ndim; ++idim) {
NIT_ADVANCE_AXISDATA(axisdata2, 1);
- /* Increment the coordinate */
- NAD_COORD(axisdata2)++;
+ /* Increment the index */
+ NAD_INDEX(axisdata2)++;
/* Increment the pointer */
for (istrides = 0; istrides < nstrides; ++istrides) {
NAD_PTRS(axisdata2)[istrides] += NAD_STRIDES(axisdata2)[istrides];
}
- if (NAD_COORD(axisdata2) < NAD_SHAPE(axisdata2)) {
- /* Reset the coordinates and pointers of all previous axisdatas */
+ if (NAD_INDEX(axisdata2) < NAD_SHAPE(axisdata2)) {
+ /* Reset the indices and pointers of all previous axisdatas */
axisdata1 = axisdata2;
do {
NIT_ADVANCE_AXISDATA(axisdata1, -1);
- /* Reset the coordinate to 0 */
- NAD_COORD(axisdata1) = 0;
+ /* Reset the index to 0 */
+ NAD_INDEX(axisdata1) = 0;
/* Reset the pointer to the updated value */
for (istrides = 0; istrides < nstrides; ++istrides) {
NAD_PTRS(axisdata1)[istrides] =
@@ -1793,7 +1793,7 @@ npyiter_buffered_reduce_iternext_iters@tag_niter@(NpyIter *iter)
/*
* If the iterator handles the inner loop, need to increment all
- * the coordinates and pointers
+ * the indices and pointers
*/
if (!(itflags&NPY_ITFLAG_EXLOOP)) {
/* Increment within the buffer */
@@ -1863,7 +1863,7 @@ npyiter_buffered_iternext(NpyIter *iter)
/*
* If the iterator handles the inner loop, need to increment all
- * the coordinates and pointers
+ * the indices and pointers
*/
if (!(itflags&NPY_ITFLAG_EXLOOP)) {
/* Increment within the buffer */
@@ -2033,7 +2033,7 @@ NpyIter_GetIterNext(NpyIter *iter, char **errmsg)
}
-/* SPECIALIZED getcoord functions */
+/* SPECIALIZED getindex functions */
/**begin repeat
* #const_itflags = 0,
@@ -2052,7 +2052,8 @@ NpyIter_GetIterNext(NpyIter *iter, char **errmsg)
* BUF, INDuBUF, IDPuBUF, INDuIDPuBUF, NEGPuBUF, INDuNEGPuBUF#
*/
static void
-npyiter_getcoord_itflags@tag_itflags@(NpyIter *iter, npy_intp *outcoord)
+npyiter_get_multi_index_itflags@tag_itflags@(
+ NpyIter *iter, npy_intp *out_multi_index)
{
const npy_uint32 itflags = @const_itflags@;
int idim, ndim = NIT_NDIM(iter);
@@ -2067,25 +2068,25 @@ npyiter_getcoord_itflags@tag_itflags@(NpyIter *iter, npy_intp *outcoord)
axisdata = NIT_AXISDATA(iter);
sizeof_axisdata = NIT_AXISDATA_SIZEOF(itflags, ndim, niter);
#if ((@const_itflags@)&NPY_ITFLAG_IDENTPERM)
- outcoord += ndim-1;
- for(idim = 0; idim < ndim; ++idim, --outcoord,
+ out_multi_index += ndim-1;
+ for(idim = 0; idim < ndim; ++idim, --out_multi_index,
NIT_ADVANCE_AXISDATA(axisdata, 1)) {
- *outcoord = NAD_COORD(axisdata);
+ *out_multi_index = NAD_INDEX(axisdata);
}
#elif !((@const_itflags@)&NPY_ITFLAG_NEGPERM)
for(idim = 0; idim < ndim; ++idim, NIT_ADVANCE_AXISDATA(axisdata, 1)) {
char p = perm[idim];
- outcoord[ndim-p-1] = NAD_COORD(axisdata);
+ out_multi_index[ndim-p-1] = NAD_INDEX(axisdata);
}
#else
for(idim = 0; idim < ndim; ++idim, NIT_ADVANCE_AXISDATA(axisdata, 1)) {
char p = perm[idim];
if (p < 0) {
- /* If the perm entry is negative, reverse the coordinate */
- outcoord[ndim+p] = NAD_SHAPE(axisdata) - NAD_COORD(axisdata) - 1;
+ /* If the perm entry is negative, reverse the index */
+ out_multi_index[ndim+p] = NAD_SHAPE(axisdata) - NAD_INDEX(axisdata) - 1;
}
else {
- outcoord[ndim-p-1] = NAD_COORD(axisdata);
+ out_multi_index[ndim-p-1] = NAD_INDEX(axisdata);
}
}
#endif /* not ident perm */
@@ -2093,43 +2094,43 @@ npyiter_getcoord_itflags@tag_itflags@(NpyIter *iter, npy_intp *outcoord)
/**end repeat**/
/*NUMPY_API
- * Compute a specialized getcoords function for the iterator
+ * Compute a specialized get_multi_index function for the iterator
*
* If errmsg is non-NULL, it should point to a variable which will
* receive the error message, and no Python exception will be set.
* This is so that the function can be called from code not holding
* the GIL.
*/
-NPY_NO_EXPORT NpyIter_GetCoordsFunc *
-NpyIter_GetGetCoords(NpyIter *iter, char **errmsg)
+NPY_NO_EXPORT NpyIter_GetMultiIndexFunc *
+NpyIter_GetGetMultiIndex(NpyIter *iter, char **errmsg)
{
npy_uint32 itflags = NIT_ITFLAGS(iter);
int ndim = NIT_NDIM(iter);
int niter = NIT_NITER(iter);
/* These flags must be correct */
- if ((itflags&(NPY_ITFLAG_HASCOORDS|NPY_ITFLAG_DELAYBUF)) !=
- NPY_ITFLAG_HASCOORDS) {
- if (!(itflags&NPY_ITFLAG_HASCOORDS)) {
+ if ((itflags&(NPY_ITFLAG_HASMULTIINDEX|NPY_ITFLAG_DELAYBUF)) !=
+ NPY_ITFLAG_HASMULTIINDEX) {
+ if (!(itflags&NPY_ITFLAG_HASMULTIINDEX)) {
if (errmsg == NULL) {
PyErr_SetString(PyExc_ValueError,
- "Cannot retrieve a GetCoords function for an iterator "
- "that doesn't track coordinates.");
+ "Cannot retrieve a GetMultiIndex function for an "
+ "iterator that doesn't track a multi-index.");
}
else {
- *errmsg = "Cannot retrieve a GetCoords function for an "
- "iterator that doesn't track coordinates.";
+ *errmsg = "Cannot retrieve a GetMultiIndex function for an "
+ "iterator that doesn't track a multi-index.";
}
return NULL;
}
else {
if (errmsg == NULL) {
PyErr_SetString(PyExc_ValueError,
- "Cannot retrieve a GetCoords function for an iterator "
- "that used DELAY_BUFALLOC before a Reset call");
+ "Cannot retrieve a GetMultiIndex function for an "
+ "iterator that used DELAY_BUFALLOC before a Reset call");
}
else {
- *errmsg = "Cannot retrieve a GetCoords function for an "
+ *errmsg = "Cannot retrieve a GetMultiIndex function for an "
"iterator that used DELAY_BUFALLOC before a "
"Reset call";
}
@@ -2139,7 +2140,7 @@ NpyIter_GetGetCoords(NpyIter *iter, char **errmsg)
/*
* Only these flags affect the iterator memory layout or
- * the getcoords behavior. IDENTPERM and NEGPERM are mutually
+ * the get_multi_index behavior. IDENTPERM and NEGPERM are mutually
* exclusive, so that reduces the number of cases slightly.
*/
itflags &= (NPY_ITFLAG_HASINDEX |
@@ -2165,18 +2166,18 @@ NpyIter_GetGetCoords(NpyIter *iter, char **errmsg)
* BUF, INDuBUF, IDPuBUF, INDuIDPuBUF, NEGPuBUF, INDuNEGPuBUF#
*/
case @const_itflags@:
- return npyiter_getcoord_itflags@tag_itflags@;
+ return npyiter_get_multi_index_itflags@tag_itflags@;
/**end repeat**/
}
/* The switch above should have caught all the possibilities. */
if (errmsg == NULL) {
PyErr_Format(PyExc_ValueError,
- "GetGetCoords internal iterator error - unexpected "
+ "GetGetMultiIndex internal iterator error - unexpected "
"itflags/ndim/niter combination (%04x/%d/%d)",
(int)itflags, (int)ndim, (int)niter);
}
else {
- *errmsg = "GetGetCoords internal iterator error - unexpected "
+ *errmsg = "GetGetMultiIndex internal iterator error - unexpected "
"itflags/ndim/niter combination";
}
return NULL;
@@ -2202,12 +2203,12 @@ NpyIter_HasExternalLoop(NpyIter *iter)
}
/*NUMPY_API
- * Whether the iterator is tracking coordinates
+ * Whether the iterator is tracking a multi-index
*/
NPY_NO_EXPORT npy_bool
-NpyIter_HasCoords(NpyIter *iter)
+NpyIter_HasMultiIndex(NpyIter *iter)
{
- return (NIT_ITFLAGS(iter)&NPY_ITFLAG_HASCOORDS) != 0;
+ return (NIT_ITFLAGS(iter)&NPY_ITFLAG_HASMULTIINDEX) != 0;
}
/*NUMPY_API
@@ -2335,15 +2336,15 @@ NpyIter_GetIterIndexRange(NpyIter *iter,
}
/*NUMPY_API
- * Gets the broadcast shape if coords are being tracked by the iterator,
+ * Gets the broadcast shape if a multi-index is being tracked by the iterator,
* otherwise gets the shape of the iteration as Fortran-order
- * (fastest-changing coordinate first).
+ * (fastest-changing index first).
*
- * The reason Fortran-order is returned when coords
- * are not enabled is that this is providing a direct view into how
+ * The reason Fortran-order is returned when a multi-index
+ * is not enabled is that this is providing a direct view into how
* the iterator traverses the n-dimensional space. The iterator organizes
- * its memory from fastest coordinate to slowest coordinate, and when
- * coords are enabled, it uses a permutation to recover the original
+ * its memory from fastest index to slowest index, and when
+ * a multi-index is enabled, it uses a permutation to recover the original
* order.
*
* Returns NPY_SUCCEED or NPY_FAIL.
@@ -2362,7 +2363,7 @@ NpyIter_GetShape(NpyIter *iter, npy_intp *outshape)
axisdata = NIT_AXISDATA(iter);
sizeof_axisdata = NIT_AXISDATA_SIZEOF(itflags, ndim, niter);
- if (itflags&NPY_ITFLAG_HASCOORDS) {
+ if (itflags&NPY_ITFLAG_HASMULTIINDEX) {
perm = NIT_PERM(iter);
for(idim = 0; idim < ndim; ++idim) {
char p = perm[idim];
@@ -2401,7 +2402,7 @@ NpyIter_GetShape(NpyIter *iter, npy_intp *outshape)
* you do the same thing but add two dimensions, or take advantage of
* the symmetry and pack it into 1 dimension with a particular encoding.
*
- * This function may only be called if the iterator is tracking coordinates
+ * This function may only be called if the iterator is tracking a multi-index
* and if NPY_ITER_DONT_NEGATE_STRIDES was used to prevent an axis from
* being iterated in reverse order.
*
@@ -2423,10 +2424,10 @@ NpyIter_CreateCompatibleStrides(NpyIter *iter,
NpyIter_AxisData *axisdata;
char *perm;
- if (!(itflags&NPY_ITFLAG_HASCOORDS)) {
+ if (!(itflags&NPY_ITFLAG_HASMULTIINDEX)) {
PyErr_SetString(PyExc_RuntimeError,
"Iterator CreateCompatibleStrides may only be called "
- "if coordinates are being tracked");
+ "if a multi-index is being tracked");
return NPY_FAIL;
}
@@ -2665,7 +2666,7 @@ NpyIter_GetInnerStrideArray(NpyIter *iter)
/*NUMPY_API
* Gets the array of strides for the specified axis.
- * If the iterator is tracking coordinates, gets the strides
+ * If the iterator is tracking a multi-index, gets the strides
* for the axis specified, otherwise gets the strides for
* the iteration axis as Fortran order (fastest-changing axis first).
*
@@ -2688,7 +2689,7 @@ NpyIter_GetAxisStrideArray(NpyIter *iter, int axis)
return NULL;
}
- if (itflags&NPY_ITFLAG_HASCOORDS) {
+ if (itflags&NPY_ITFLAG_HASMULTIINDEX) {
/* Reverse axis, since the iterator treats them that way */
axis = ndim-1-axis;
@@ -2818,7 +2819,7 @@ NpyIter_GetInnerLoopSizePtr(NpyIter *iter)
}
}
-/* Checks 'flags' for (C|F)_ORDER_INDEX, COORDS, and EXTERNAL_LOOP,
+/* Checks 'flags' for (C|F)_ORDER_INDEX, MULTI_INDEX, and EXTERNAL_LOOP,
* setting the appropriate internal flags in 'itflags'.
*
* Returns 1 on success, 0 on error.
@@ -2844,20 +2845,20 @@ npyiter_check_global_flags(npy_uint32 flags, npy_uint32* itflags)
}
(*itflags) |= NPY_ITFLAG_HASINDEX;
}
- /* Check if coordinates were requested */
- if (flags&NPY_ITER_COORDS) {
+ /* Check if a multi-index was requested */
+ if (flags&NPY_ITER_MULTI_INDEX) {
/*
* This flag primarily disables dimension manipulations that
- * would produce a different set of coordinates.
+ * would produce an incorrect multi-index.
*/
- (*itflags) |= NPY_ITFLAG_HASCOORDS;
+ (*itflags) |= NPY_ITFLAG_HASMULTIINDEX;
}
/* Check if the caller wants to handle inner iteration */
if (flags&NPY_ITER_EXTERNAL_LOOP) {
- if ((*itflags)&(NPY_ITFLAG_HASINDEX|NPY_ITFLAG_HASCOORDS)) {
+ if ((*itflags)&(NPY_ITFLAG_HASINDEX|NPY_ITFLAG_HASMULTIINDEX)) {
PyErr_SetString(PyExc_ValueError,
"Iterator flag EXTERNAL_LOOP cannot be used "
- "if coords or an index is being tracked");
+ "if an index or multi-index is being tracked");
return 0;
}
(*itflags) |= NPY_ITFLAG_EXLOOP;
@@ -3539,7 +3540,7 @@ npyiter_fill_axisdata(NpyIter *iter, npy_uint32 flags, char *op_itflags,
npy_intp *strides = NAD_STRIDES(axisdata);
NAD_SHAPE(axisdata) = bshape;
- NAD_COORD(axisdata) = 0;
+ NAD_INDEX(axisdata) = 0;
memcpy(NAD_PTRS(axisdata), op_dataptr, NPY_SIZEOF_INTP*niter);
for (iiter = 0; iiter < niter; ++iiter) {
@@ -4155,7 +4156,10 @@ npyiter_flip_negative_strides(NpyIter *iter)
/* Flip the stride */
strides[istrides] = -stride;
}
- /* Make the perm entry negative, so getcoords knows it's flipped */
+ /*
+ * Make the perm entry negative so get_multi_index
+ * knows it's flipped
+ */
NIT_PERM(iter)[idim] = -1-NIT_PERM(iter)[idim];
any_flipped = 1;
@@ -4320,17 +4324,17 @@ npyiter_find_best_axis_ordering(NpyIter *iter)
npy_intp i, size = sizeof_axisdata/NPY_SIZEOF_INTP;
NpyIter_AxisData *ad_i;
- /* Use the coord as a flag, set each to 1 */
+ /* Use the index as a flag, set each to 1 */
ad_i = axisdata;
for (idim = 0; idim < ndim; ++idim, NIT_ADVANCE_AXISDATA(ad_i, 1)) {
- NAD_COORD(ad_i) = 1;
+ NAD_INDEX(ad_i) = 1;
}
/* Apply the permutation by following the cycles */
for (idim = 0; idim < ndim; ++idim) {
ad_i = NIT_INDEX_AXISDATA(axisdata, idim);
/* If this axis hasn't been touched yet, process it */
- if (NAD_COORD(ad_i) == 1) {
+ if (NAD_INDEX(ad_i) == 1) {
char pidim = perm[idim], qidim;
npy_intp tmp;
NpyIter_AxisData *ad_p, *ad_q;
@@ -4356,11 +4360,11 @@ npyiter_find_best_axis_ordering(NpyIter *iter)
pidim = perm[idim];
while (pidim != idim) {
- NAD_COORD(NIT_INDEX_AXISDATA(axisdata, pidim)) = 0;
+ NAD_INDEX(NIT_INDEX_AXISDATA(axisdata, pidim)) = 0;
pidim = perm[(int)pidim];
}
}
- NAD_COORD(ad_i) = 0;
+ NAD_INDEX(ad_i) = 0;
}
}
/* Clear the identity perm flag */
@@ -4381,8 +4385,8 @@ npyiter_coalesce_axes(NpyIter *iter)
NpyIter_AxisData *ad_compress;
npy_intp new_ndim = 1;
- /* The HASCOORDS or IDENTPERM flags do not apply after coalescing */
- NIT_ITFLAGS(iter) &= ~(NPY_ITFLAG_IDENTPERM|NPY_ITFLAG_HASCOORDS);
+ /* The HASMULTIINDEX or IDENTPERM flags do not apply after coalescing */
+ NIT_ITFLAGS(iter) &= ~(NPY_ITFLAG_IDENTPERM|NPY_ITFLAG_HASMULTIINDEX);
axisdata = NIT_AXISDATA(iter);
ad_compress = axisdata;
@@ -5259,7 +5263,7 @@ npyiter_goto_iterindex(NpyIter *iter, npy_intp iterindex)
for (idim = 0; idim < ndim; ++idim) {
char **ptrs;
- NAD_COORD(axisdata) = 0;
+ NAD_INDEX(axisdata) = 0;
ptrs = NAD_PTRS(axisdata);
for (istrides = 0; istrides < nstrides; ++istrides) {
ptrs[istrides] = dataptr[istrides];
@@ -5270,21 +5274,21 @@ npyiter_goto_iterindex(NpyIter *iter, npy_intp iterindex)
}
else {
/*
- * Set the coordinates, from the fastest-changing to the
+ * Set the multi-index, from the fastest-changing to the
* slowest-changing.
*/
axisdata = NIT_AXISDATA(iter);
shape = NAD_SHAPE(axisdata);
i = iterindex;
iterindex /= shape;
- NAD_COORD(axisdata) = i - iterindex * shape;
+ NAD_INDEX(axisdata) = i - iterindex * shape;
for (idim = 0; idim < ndim-1; ++idim) {
NIT_ADVANCE_AXISDATA(axisdata, 1);
shape = NAD_SHAPE(axisdata);
i = iterindex;
iterindex /= shape;
- NAD_COORD(axisdata) = i - iterindex * shape;
+ NAD_INDEX(axisdata) = i - iterindex * shape;
}
dataptr = NIT_RESETDATAPTR(iter);
@@ -5301,7 +5305,7 @@ npyiter_goto_iterindex(NpyIter *iter, npy_intp iterindex)
strides = NAD_STRIDES(axisdata);
ptrs = NAD_PTRS(axisdata);
- i = NAD_COORD(axisdata);
+ i = NAD_INDEX(axisdata);
for (istrides = 0; istrides < nstrides; ++istrides) {
ptrs[istrides] = dataptr[istrides] + i*strides[istrides];
@@ -5316,7 +5320,7 @@ npyiter_goto_iterindex(NpyIter *iter, npy_intp iterindex)
/*
* This gets called after the the buffers have been exhausted, and
- * their data needs to be written back to the arrays. The coordinates
+ * their data needs to be written back to the arrays. The multi-index
* must be positioned for the beginning of the buffer.
*/
static void
@@ -5397,7 +5401,7 @@ npyiter_copy_from_buffers(NpyIter *iter)
op_transfersize = 1;
src_stride = 0;
dst_strides = &src_stride;
- dst_coords = &NAD_COORD(reduce_outeraxisdata);
+ dst_coords = &NAD_INDEX(reduce_outeraxisdata);
dst_shape = &NAD_SHAPE(reduce_outeraxisdata);
ndim_transfer = 1;
}
@@ -5406,7 +5410,7 @@ npyiter_copy_from_buffers(NpyIter *iter)
src_stride = reduce_outerstrides[iiter];
dst_strides =
&NAD_STRIDES(reduce_outeraxisdata)[iiter];
- dst_coords = &NAD_COORD(reduce_outeraxisdata);
+ dst_coords = &NAD_INDEX(reduce_outeraxisdata);
dst_shape = &NAD_SHAPE(reduce_outeraxisdata);
ndim_transfer = ndim - reduce_outerdim;
}
@@ -5416,7 +5420,7 @@ npyiter_copy_from_buffers(NpyIter *iter)
op_transfersize = NBF_SIZE(bufferdata);
src_stride = strides[iiter];
dst_strides = &ad_strides[iiter];
- dst_coords = &NAD_COORD(axisdata);
+ dst_coords = &NAD_INDEX(axisdata);
dst_shape = &NAD_SHAPE(axisdata);
ndim_transfer = reduce_outerdim ?
reduce_outerdim : 1;
@@ -5425,7 +5429,7 @@ npyiter_copy_from_buffers(NpyIter *iter)
op_transfersize = transfersize;
src_stride = strides[iiter];
dst_strides = &ad_strides[iiter];
- dst_coords = &NAD_COORD(axisdata);
+ dst_coords = &NAD_INDEX(axisdata);
dst_shape = &NAD_SHAPE(axisdata);
ndim_transfer = ndim;
}
@@ -5435,7 +5439,7 @@ npyiter_copy_from_buffers(NpyIter *iter)
op_transfersize = transfersize;
src_stride = strides[iiter];
dst_strides = &ad_strides[iiter];
- dst_coords = &NAD_COORD(axisdata);
+ dst_coords = &NAD_INDEX(axisdata);
dst_shape = &NAD_SHAPE(axisdata);
ndim_transfer = ndim;
}
@@ -5483,7 +5487,7 @@ npyiter_copy_from_buffers(NpyIter *iter)
}
/*
- * This gets called after the iterator has been positioned to coordinates
+ * This gets called after the iterator has been positioned to a multi-index
* for the start of a buffer. It decides which operands need a buffer,
* and copies the data into the buffers.
*/
@@ -5591,7 +5595,7 @@ npyiter_copy_to_buffers(NpyIter *iter, char **prev_dataptrs)
}
/* Calculate the maximum size if using a single stride and no buffers */
- singlestridesize = NAD_SHAPE(axisdata)-NAD_COORD(axisdata);
+ singlestridesize = NAD_SHAPE(axisdata)-NAD_INDEX(axisdata);
if (singlestridesize > iterend - iterindex) {
singlestridesize = iterend - iterindex;
}
@@ -5655,7 +5659,7 @@ npyiter_copy_to_buffers(NpyIter *iter, char **prev_dataptrs)
(reduce_outerdim == 1) &&
(transfersize/reduce_innersize <=
NAD_SHAPE(reduce_outeraxisdata) -
- NAD_COORD(reduce_outeraxisdata))) {
+ NAD_INDEX(reduce_outeraxisdata))) {
ptrs[iiter] = ad_ptrs[iiter];
reduce_outerptrs[iiter] = ptrs[iiter];
strides[iiter] = ad_strides[iiter];
@@ -5689,7 +5693,7 @@ npyiter_copy_to_buffers(NpyIter *iter, char **prev_dataptrs)
else if ((reduce_outerdim > 0) &&
(transfersize/reduce_innersize <=
NAD_SHAPE(reduce_outeraxisdata) -
- NAD_COORD(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];
@@ -5725,7 +5729,7 @@ npyiter_copy_to_buffers(NpyIter *iter, char **prev_dataptrs)
if ((reduce_outerdim > 0) &&
(transfersize/reduce_innersize <=
NAD_SHAPE(reduce_outeraxisdata) -
- NAD_COORD(reduce_outeraxisdata))) {
+ NAD_INDEX(reduce_outeraxisdata))) {
ptrs[iiter] = ad_ptrs[iiter];
strides[iiter] = ad_strides[iiter];
/* Outer reduce loop advances by one item */
@@ -5823,7 +5827,7 @@ npyiter_copy_to_buffers(NpyIter *iter, char **prev_dataptrs)
op_transfersize = 1;
dst_stride = 0;
src_strides = &dst_stride;
- src_coords = &NAD_COORD(reduce_outeraxisdata);
+ src_coords = &NAD_INDEX(reduce_outeraxisdata);
src_shape = &NAD_SHAPE(reduce_outeraxisdata);
ndim_transfer = 1;
@@ -5847,7 +5851,7 @@ npyiter_copy_to_buffers(NpyIter *iter, char **prev_dataptrs)
op_transfersize = NBF_REDUCE_OUTERSIZE(bufferdata);
dst_stride = reduce_outerstrides[iiter];
src_strides = &NAD_STRIDES(reduce_outeraxisdata)[iiter];
- src_coords = &NAD_COORD(reduce_outeraxisdata);
+ src_coords = &NAD_INDEX(reduce_outeraxisdata);
src_shape = &NAD_SHAPE(reduce_outeraxisdata);
ndim_transfer = ndim - reduce_outerdim;
}
@@ -5857,7 +5861,7 @@ npyiter_copy_to_buffers(NpyIter *iter, char **prev_dataptrs)
op_transfersize = NBF_SIZE(bufferdata);
dst_stride = strides[iiter];
src_strides = &ad_strides[iiter];
- src_coords = &NAD_COORD(axisdata);
+ src_coords = &NAD_INDEX(axisdata);
src_shape = &NAD_SHAPE(axisdata);
ndim_transfer = reduce_outerdim ? reduce_outerdim : 1;
}
@@ -5865,7 +5869,7 @@ npyiter_copy_to_buffers(NpyIter *iter, char **prev_dataptrs)
op_transfersize = transfersize;
dst_stride = strides[iiter];
src_strides = &ad_strides[iiter];
- src_coords = &NAD_COORD(axisdata);
+ src_coords = &NAD_INDEX(axisdata);
src_shape = &NAD_SHAPE(axisdata);
ndim_transfer = ndim;
}
@@ -5875,7 +5879,7 @@ npyiter_copy_to_buffers(NpyIter *iter, char **prev_dataptrs)
op_transfersize = transfersize;
dst_stride = strides[iiter];
src_strides = &ad_strides[iiter];
- src_coords = &NAD_COORD(axisdata);
+ src_coords = &NAD_INDEX(axisdata);
src_shape = &NAD_SHAPE(axisdata);
ndim_transfer = ndim;
}
@@ -6006,7 +6010,7 @@ npyiter_checkreducesize(NpyIter *iter, npy_intp count,
(strides[iiter] == 0);
}
shape = NAD_SHAPE(axisdata);
- coord = NAD_COORD(axisdata);
+ coord = NAD_INDEX(axisdata);
reducespace += (shape-coord-1);
factor = shape;
NIT_ADVANCE_AXISDATA(axisdata, 1);
@@ -6020,7 +6024,7 @@ npyiter_checkreducesize(NpyIter *iter, npy_intp count,
* If a reduce stride switched from zero to non-zero, or
* vice versa, that's the point where the data will stop
* being the same element or will repeat, and if the
- * buffer starts with all zero coordinates up to this
+ * buffer starts with an all zero multi-index up to this
* point, gives us the reduce_innersize.
*/
if((stride0op[iiter] && (strides[iiter] != 0)) ||
@@ -6057,7 +6061,7 @@ npyiter_checkreducesize(NpyIter *iter, npy_intp count,
}
shape = NAD_SHAPE(axisdata);
- coord = NAD_COORD(axisdata);
+ coord = NAD_INDEX(axisdata);
if (coord != 0) {
nonzerocoord = 1;
}
@@ -6097,7 +6101,7 @@ npyiter_checkreducesize(NpyIter *iter, npy_intp count,
(strides[iiter] == 0);
}
shape = NAD_SHAPE(axisdata);
- coord = NAD_COORD(axisdata);
+ coord = NAD_INDEX(axisdata);
reducespace += (shape-coord-1) * factor;
factor *= shape;
NIT_ADVANCE_AXISDATA(axisdata, 1);
@@ -6111,7 +6115,7 @@ npyiter_checkreducesize(NpyIter *iter, npy_intp count,
* If a reduce stride switched from zero to non-zero, or
* vice versa, that's the point where the data will stop
* being the same element or will repeat, and if the
- * buffer starts with all zero coordinates up to this
+ * buffer starts with an all zero multi-index up to this
* point, gives us the reduce_innersize.
*/
if((stride0op[iiter] && (strides[iiter] != 0)) ||
@@ -6133,7 +6137,7 @@ npyiter_checkreducesize(NpyIter *iter, npy_intp count,
}
shape = NAD_SHAPE(axisdata);
- coord = NAD_COORD(axisdata);
+ coord = NAD_INDEX(axisdata);
if (coord != 0) {
nonzerocoord = 1;
}
@@ -6173,8 +6177,8 @@ NpyIter_DebugPrint(NpyIter *iter)
printf("NEGPERM ");
if (itflags&NPY_ITFLAG_HASINDEX)
printf("HASINDEX ");
- if (itflags&NPY_ITFLAG_HASCOORDS)
- printf("HASCOORDS ");
+ if (itflags&NPY_ITFLAG_HASMULTIINDEX)
+ printf("HASMULTIINDEX ");
if (itflags&NPY_ITFLAG_FORCEDORDER)
printf("FORCEDORDER ");
if (itflags&NPY_ITFLAG_EXLOOP)
@@ -6352,7 +6356,7 @@ NpyIter_DebugPrint(NpyIter *iter)
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("| Coord: %d\n", (int)NAD_COORD(axisdata));
+ printf("| Index: %d\n", (int)NAD_INDEX(axisdata));
printf("| Strides: ");
for (iiter = 0; iiter < niter; ++iiter) {
printf("%d ", (int)NAD_STRIDES(axisdata)[iiter]);
diff --git a/numpy/core/src/multiarray/nditer_pywrap.c b/numpy/core/src/multiarray/nditer_pywrap.c
index d604d7889..3d13d9ec4 100644
--- a/numpy/core/src/multiarray/nditer_pywrap.c
+++ b/numpy/core/src/multiarray/nditer_pywrap.c
@@ -30,7 +30,7 @@ struct NewNpyArrayIterObject_tag {
NewNpyArrayIterObject *nested_child;
/* Cached values from the iterator */
NpyIter_IterNextFunc *iternext;
- NpyIter_GetCoordsFunc *getcoords;
+ NpyIter_GetMultiIndexFunc *get_multi_index;
char **dataptrs;
PyArray_Descr **dtypes;
PyArrayObject **operands;
@@ -43,13 +43,13 @@ void npyiter_cache_values(NewNpyArrayIterObject *self)
{
NpyIter *iter = self->iter;
- /* iternext and getcoords functions */
+ /* iternext and get_multi_index functions */
self->iternext = NpyIter_GetIterNext(iter, NULL);
- if (NpyIter_HasCoords(iter) && !NpyIter_HasDelayedBufAlloc(iter)) {
- self->getcoords = NpyIter_GetGetCoords(iter, NULL);
+ if (NpyIter_HasMultiIndex(iter) && !NpyIter_HasDelayedBufAlloc(iter)) {
+ self->get_multi_index = NpyIter_GetGetMultiIndex(iter, NULL);
}
else {
- self->getcoords = NULL;
+ self->get_multi_index = NULL;
}
/* Internal data pointers */
@@ -146,11 +146,6 @@ NpyIter_GlobalFlagsConverter(PyObject *flags_in, npy_uint32 *flags)
flag = NPY_ITER_C_INDEX;
}
break;
- case 's':
- if (strcmp(str, "coords") == 0) {
- flag = NPY_ITER_COORDS;
- }
- break;
case 'n':
if (strcmp(str, "common_dtype") == 0) {
flag = NPY_ITER_COMMON_DTYPE;
@@ -178,6 +173,11 @@ NpyIter_GlobalFlagsConverter(PyObject *flags_in, npy_uint32 *flags)
flag = NPY_ITER_GROWINNER;
}
break;
+ case 'm':
+ if (strcmp(str, "multi_index") == 0) {
+ flag = NPY_ITER_MULTI_INDEX;
+ }
+ break;
case 'r':
if (strcmp(str, "ranged") == 0) {
flag = NPY_ITER_RANGED;
@@ -1246,8 +1246,8 @@ npyiter_reset(NewNpyArrayIterObject *self)
self->finished = 0;
}
- if (self->getcoords == NULL && NpyIter_HasCoords(self->iter)) {
- self->getcoords = NpyIter_GetGetCoords(self->iter, NULL);
+ if (self->get_multi_index == NULL && NpyIter_HasMultiIndex(self->iter)) {
+ self->get_multi_index = NpyIter_GetGetMultiIndex(self->iter, NULL);
}
/* If there is nesting, the nested iterators should be reset */
@@ -1347,7 +1347,7 @@ npyiter_remove_axis(NewNpyArrayIterObject *self, PyObject *args)
}
static PyObject *
-npyiter_remove_coords(NewNpyArrayIterObject *self)
+npyiter_remove_multi_index(NewNpyArrayIterObject *self)
{
if (self->iter == NULL) {
PyErr_SetString(PyExc_ValueError,
@@ -1355,10 +1355,10 @@ npyiter_remove_coords(NewNpyArrayIterObject *self)
return NULL;
}
- NpyIter_RemoveCoords(self->iter);
- /* RemoveCoords invalidates cached values */
+ NpyIter_RemoveMultiIndex(self->iter);
+ /* RemoveMultiIndex invalidates cached values */
npyiter_cache_values(self);
- /* RemoveCoords also resets the iterator */
+ /* RemoveMultiIndex also resets the iterator */
if (NpyIter_GetIterSize(self->iter) == 0) {
self->started = 1;
self->finished = 1;
@@ -1566,10 +1566,10 @@ static PyObject *npyiter_shape_get(NewNpyArrayIterObject *self)
return NULL;
}
-static PyObject *npyiter_coords_get(NewNpyArrayIterObject *self)
+static PyObject *npyiter_multi_index_get(NewNpyArrayIterObject *self)
{
PyObject *ret;
- npy_intp idim, ndim, coords[NPY_MAXDIMS];
+ npy_intp idim, ndim, multi_index[NPY_MAXDIMS];
if (self->iter == NULL || self->finished) {
PyErr_SetString(PyExc_ValueError,
@@ -1577,20 +1577,20 @@ static PyObject *npyiter_coords_get(NewNpyArrayIterObject *self)
return NULL;
}
- if (self->getcoords != NULL) {
+ if (self->get_multi_index != NULL) {
ndim = NpyIter_GetNDim(self->iter);
- self->getcoords(self->iter, coords);
+ self->get_multi_index(self->iter, multi_index);
ret = PyTuple_New(ndim);
for (idim = 0; idim < ndim; ++idim) {
PyTuple_SET_ITEM(ret, idim,
- PyInt_FromLong(coords[idim]));
+ PyInt_FromLong(multi_index[idim]));
}
return ret;
}
else {
- if (!NpyIter_HasCoords(self->iter)) {
+ if (!NpyIter_HasMultiIndex(self->iter)) {
PyErr_SetString(PyExc_ValueError,
- "Iterator does not have coordinates");
+ "Iterator is not tracking a multi-index");
return NULL;
}
else if (NpyIter_HasDelayedBufAlloc(self->iter)) {
@@ -1607,9 +1607,9 @@ static PyObject *npyiter_coords_get(NewNpyArrayIterObject *self)
}
}
-static int npyiter_coords_set(NewNpyArrayIterObject *self, PyObject *value)
+static int npyiter_multi_index_set(NewNpyArrayIterObject *self, PyObject *value)
{
- npy_intp idim, ndim, coords[NPY_MAXDIMS];
+ npy_intp idim, ndim, multi_index[NPY_MAXDIMS];
if (self->iter == NULL) {
PyErr_SetString(PyExc_ValueError,
@@ -1619,30 +1619,30 @@ static int npyiter_coords_set(NewNpyArrayIterObject *self, PyObject *value)
if (value == NULL) {
PyErr_SetString(PyExc_ValueError,
- "Cannot delete coordinates");
+ "Cannot delete the multi_index");
return -1;
}
- if (NpyIter_HasCoords(self->iter)) {
+ if (NpyIter_HasMultiIndex(self->iter)) {
ndim = NpyIter_GetNDim(self->iter);
if (!PySequence_Check(value)) {
PyErr_SetString(PyExc_ValueError,
- "Coordinates must be set with a sequence");
+ "multi_index must be set with a sequence");
return -1;
}
if (PySequence_Size(value) != ndim) {
PyErr_SetString(PyExc_ValueError,
- "Wrong number of coordinates");
+ "Wrong number of indices");
return -1;
}
for (idim = 0; idim < ndim; ++idim) {
PyObject *v = PySequence_GetItem(value, idim);
- coords[idim] = PyInt_AsLong(v);
- if (coords[idim]==-1 && PyErr_Occurred()) {
+ multi_index[idim] = PyInt_AsLong(v);
+ if (multi_index[idim]==-1 && PyErr_Occurred()) {
return -1;
}
}
- if (NpyIter_GotoCoords(self->iter, coords) != NPY_SUCCEED) {
+ if (NpyIter_GotoMultiIndex(self->iter, multi_index) != NPY_SUCCEED) {
return -1;
}
self->started = 0;
@@ -1657,7 +1657,7 @@ static int npyiter_coords_set(NewNpyArrayIterObject *self, PyObject *value)
}
else {
PyErr_SetString(PyExc_ValueError,
- "Iterator does not have coordinates");
+ "Iterator is not tracking a multi-index");
return -1;
}
}
@@ -1829,8 +1829,8 @@ static int npyiter_iterrange_set(NewNpyArrayIterObject *self, PyObject *value)
self->started = self->finished = 1;
}
- if (self->getcoords == NULL && NpyIter_HasCoords(self->iter)) {
- self->getcoords = NpyIter_GetGetCoords(self->iter, NULL);
+ if (self->get_multi_index == NULL && NpyIter_HasMultiIndex(self->iter)) {
+ self->get_multi_index = NpyIter_GetGetMultiIndex(self->iter, NULL);
}
/* If there is nesting, the nested iterators should be reset */
@@ -1841,7 +1841,7 @@ static int npyiter_iterrange_set(NewNpyArrayIterObject *self, PyObject *value)
return 0;
}
-static PyObject *npyiter_hasdelayedbufalloc_get(NewNpyArrayIterObject *self)
+static PyObject *npyiter_has_delayed_bufalloc_get(NewNpyArrayIterObject *self)
{
if (self->iter == NULL) {
PyErr_SetString(PyExc_ValueError,
@@ -1873,7 +1873,7 @@ static PyObject *npyiter_iterationneedsapi_get(NewNpyArrayIterObject *self)
}
}
-static PyObject *npyiter_hascoords_get(NewNpyArrayIterObject *self)
+static PyObject *npyiter_has_multi_index_get(NewNpyArrayIterObject *self)
{
if (self->iter == NULL) {
PyErr_SetString(PyExc_ValueError,
@@ -1881,7 +1881,7 @@ static PyObject *npyiter_hascoords_get(NewNpyArrayIterObject *self)
return NULL;
}
- if (NpyIter_HasCoords(self->iter)) {
+ if (NpyIter_HasMultiIndex(self->iter)) {
Py_RETURN_TRUE;
}
else {
@@ -1889,7 +1889,7 @@ static PyObject *npyiter_hascoords_get(NewNpyArrayIterObject *self)
}
}
-static PyObject *npyiter_hasindex_get(NewNpyArrayIterObject *self)
+static PyObject *npyiter_has_index_get(NewNpyArrayIterObject *self)
{
if (self->iter == NULL) {
PyErr_SetString(PyExc_ValueError,
@@ -2336,7 +2336,8 @@ static PyMethodDef npyiter_methods[] = {
{"__copy__", (PyCFunction)npyiter_copy, METH_NOARGS, NULL},
{"iternext", (PyCFunction)npyiter_iternext, METH_NOARGS, NULL},
{"remove_axis", (PyCFunction)npyiter_remove_axis, METH_VARARGS, NULL},
- {"remove_coords", (PyCFunction)npyiter_remove_coords, METH_NOARGS, NULL},
+ {"remove_multi_index", (PyCFunction)npyiter_remove_multi_index,
+ METH_NOARGS, NULL},
{"enable_external_loop", (PyCFunction)npyiter_enable_external_loop,
METH_NOARGS, NULL},
{"debug_print", (PyCFunction)npyiter_debug_print, METH_NOARGS, NULL},
@@ -2354,9 +2355,9 @@ static PyGetSetDef npyiter_getsets[] = {
{"shape",
(getter)npyiter_shape_get,
NULL, NULL, NULL},
- {"coords",
- (getter)npyiter_coords_get,
- (setter)npyiter_coords_set,
+ {"multi_index",
+ (getter)npyiter_multi_index_get,
+ (setter)npyiter_multi_index_set,
NULL, NULL},
{"index",
(getter)npyiter_index_get,
@@ -2376,17 +2377,17 @@ static PyGetSetDef npyiter_getsets[] = {
{"itviews",
(getter)npyiter_itviews_get,
NULL, NULL, NULL},
- {"hasdelayedbufalloc",
- (getter)npyiter_hasdelayedbufalloc_get,
+ {"has_delayed_bufalloc",
+ (getter)npyiter_has_delayed_bufalloc_get,
NULL, NULL, NULL},
{"iterationneedsapi",
(getter)npyiter_iterationneedsapi_get,
NULL, NULL, NULL},
- {"hascoords",
- (getter)npyiter_hascoords_get,
+ {"has_multi_index",
+ (getter)npyiter_has_multi_index_get,
NULL, NULL, NULL},
- {"hasindex",
- (getter)npyiter_hasindex_get,
+ {"has_index",
+ (getter)npyiter_has_index_get,
NULL, NULL, NULL},
{"dtypes",
(getter)npyiter_dtypes_get,
diff --git a/numpy/core/src/umath/ufunc_object.c b/numpy/core/src/umath/ufunc_object.c
index e619da81d..1d53dd308 100644
--- a/numpy/core/src/umath/ufunc_object.c
+++ b/numpy/core/src/umath/ufunc_object.c
@@ -2305,7 +2305,7 @@ PyUFunc_GeneralizedFunction(PyUFuncObject *self,
}
/* Create the iterator */
- iter = NpyIter_AdvancedNew(niter, op, NPY_ITER_COORDS|
+ iter = NpyIter_AdvancedNew(niter, op, NPY_ITER_MULTI_INDEX|
NPY_ITER_REFS_OK|
NPY_ITER_REDUCE_OK,
order, NPY_UNSAFE_CASTING, op_flags,
@@ -2365,7 +2365,7 @@ PyUFunc_GeneralizedFunction(PyUFuncObject *self,
goto fail;
}
}
- if (NpyIter_RemoveCoords(iter) != NPY_SUCCEED) {
+ if (NpyIter_RemoveMultiIndex(iter) != NPY_SUCCEED) {
retval = -1;
goto fail;
}
@@ -2916,7 +2916,7 @@ PyUFunc_ReductionOp(PyUFuncObject *self, PyArrayObject *arr,
* so make a copy instead when necessary.
*/
ndim_iter = ndim;
- flags |= NPY_ITER_COORDS;
+ flags |= NPY_ITER_MULTI_INDEX;
/* Add some more flags */
op_flags[0] |= NPY_ITER_UPDATEIFCOPY|NPY_ITER_ALIGNED;
op_flags[1] |= NPY_ITER_COPY|NPY_ITER_ALIGNED;
@@ -2949,7 +2949,7 @@ PyUFunc_ReductionOp(PyUFuncObject *self, PyArrayObject *arr,
if (NpyIter_RemoveAxis(iter, axis) != NPY_SUCCEED) {
goto fail;
}
- if (NpyIter_RemoveCoords(iter) != NPY_SUCCEED) {
+ if (NpyIter_RemoveMultiIndex(iter) != NPY_SUCCEED) {
goto fail;
}
}
@@ -3535,7 +3535,7 @@ PyUFunc_Reduceat(PyUFuncObject *self, PyArrayObject *arr, PyArrayObject *ind,
if (need_outer_iterator) {
npy_uint32 flags = NPY_ITER_ZEROSIZE_OK|
NPY_ITER_REFS_OK|
- NPY_ITER_COORDS;
+ NPY_ITER_MULTI_INDEX;
/*
* The way reduceat is set up, we can't do buffering,
@@ -3570,7 +3570,7 @@ PyUFunc_Reduceat(PyUFuncObject *self, PyArrayObject *arr, PyArrayObject *ind,
if (NpyIter_RemoveAxis(iter, axis) != NPY_SUCCEED) {
goto fail;
}
- if (NpyIter_RemoveCoords(iter) != NPY_SUCCEED) {
+ if (NpyIter_RemoveMultiIndex(iter) != NPY_SUCCEED) {
goto fail;
}
diff --git a/numpy/core/tests/test_iterator.py b/numpy/core/tests/test_iterator.py
index 4b4aaecd9..e5a073e12 100644
--- a/numpy/core/tests/test_iterator.py
+++ b/numpy/core/tests/test_iterator.py
@@ -6,10 +6,10 @@ import sys, warnings
import warnings
-def iter_coords(i):
+def iter_multi_index(i):
ret = []
while not i.finished:
- ret.append(i.coords)
+ ret.append(i.multi_index)
i.iternext()
return ret
@@ -174,85 +174,85 @@ def test_iter_c_or_f_order():
assert_equal([x for x in i],
aview.swapaxes(0,1).ravel(order='A'))
-def test_iter_best_order_coords_1d():
- # The coords should be correct with any reordering
+def test_iter_best_order_multi_index_1d():
+ # The multi-indices should be correct with any reordering
a = arange(4)
# 1D order
- i = nditer(a,['coords'],[['readonly']])
- assert_equal(iter_coords(i), [(0,),(1,),(2,),(3,)])
+ i = nditer(a,['multi_index'],[['readonly']])
+ assert_equal(iter_multi_index(i), [(0,),(1,),(2,),(3,)])
# 1D reversed order
- i = nditer(a[::-1],['coords'],[['readonly']])
- assert_equal(iter_coords(i), [(3,),(2,),(1,),(0,)])
+ i = nditer(a[::-1],['multi_index'],[['readonly']])
+ assert_equal(iter_multi_index(i), [(3,),(2,),(1,),(0,)])
-def test_iter_best_order_coords_2d():
- # The coords should be correct with any reordering
+def test_iter_best_order_multi_index_2d():
+ # The multi-indices should be correct with any reordering
a = arange(6)
# 2D C-order
- i = nditer(a.reshape(2,3),['coords'],[['readonly']])
- assert_equal(iter_coords(i), [(0,0),(0,1),(0,2),(1,0),(1,1),(1,2)])
+ i = nditer(a.reshape(2,3),['multi_index'],[['readonly']])
+ assert_equal(iter_multi_index(i), [(0,0),(0,1),(0,2),(1,0),(1,1),(1,2)])
# 2D Fortran-order
- i = nditer(a.reshape(2,3).copy(order='F'),['coords'],[['readonly']])
- assert_equal(iter_coords(i), [(0,0),(1,0),(0,1),(1,1),(0,2),(1,2)])
+ i = nditer(a.reshape(2,3).copy(order='F'),['multi_index'],[['readonly']])
+ assert_equal(iter_multi_index(i), [(0,0),(1,0),(0,1),(1,1),(0,2),(1,2)])
# 2D reversed C-order
- i = nditer(a.reshape(2,3)[::-1],['coords'],[['readonly']])
- assert_equal(iter_coords(i), [(1,0),(1,1),(1,2),(0,0),(0,1),(0,2)])
- i = nditer(a.reshape(2,3)[:,::-1],['coords'],[['readonly']])
- assert_equal(iter_coords(i), [(0,2),(0,1),(0,0),(1,2),(1,1),(1,0)])
- i = nditer(a.reshape(2,3)[::-1,::-1],['coords'],[['readonly']])
- assert_equal(iter_coords(i), [(1,2),(1,1),(1,0),(0,2),(0,1),(0,0)])
+ i = nditer(a.reshape(2,3)[::-1],['multi_index'],[['readonly']])
+ assert_equal(iter_multi_index(i), [(1,0),(1,1),(1,2),(0,0),(0,1),(0,2)])
+ i = nditer(a.reshape(2,3)[:,::-1],['multi_index'],[['readonly']])
+ assert_equal(iter_multi_index(i), [(0,2),(0,1),(0,0),(1,2),(1,1),(1,0)])
+ i = nditer(a.reshape(2,3)[::-1,::-1],['multi_index'],[['readonly']])
+ assert_equal(iter_multi_index(i), [(1,2),(1,1),(1,0),(0,2),(0,1),(0,0)])
# 2D reversed Fortran-order
- i = nditer(a.reshape(2,3).copy(order='F')[::-1],['coords'],[['readonly']])
- assert_equal(iter_coords(i), [(1,0),(0,0),(1,1),(0,1),(1,2),(0,2)])
+ i = nditer(a.reshape(2,3).copy(order='F')[::-1],['multi_index'],[['readonly']])
+ assert_equal(iter_multi_index(i), [(1,0),(0,0),(1,1),(0,1),(1,2),(0,2)])
i = nditer(a.reshape(2,3).copy(order='F')[:,::-1],
- ['coords'],[['readonly']])
- assert_equal(iter_coords(i), [(0,2),(1,2),(0,1),(1,1),(0,0),(1,0)])
+ ['multi_index'],[['readonly']])
+ assert_equal(iter_multi_index(i), [(0,2),(1,2),(0,1),(1,1),(0,0),(1,0)])
i = nditer(a.reshape(2,3).copy(order='F')[::-1,::-1],
- ['coords'],[['readonly']])
- assert_equal(iter_coords(i), [(1,2),(0,2),(1,1),(0,1),(1,0),(0,0)])
+ ['multi_index'],[['readonly']])
+ assert_equal(iter_multi_index(i), [(1,2),(0,2),(1,1),(0,1),(1,0),(0,0)])
-def test_iter_best_order_coords_3d():
- # The coords should be correct with any reordering
+def test_iter_best_order_multi_index_3d():
+ # The multi-indices should be correct with any reordering
a = arange(12)
# 3D C-order
- i = nditer(a.reshape(2,3,2),['coords'],[['readonly']])
- assert_equal(iter_coords(i),
+ i = nditer(a.reshape(2,3,2),['multi_index'],[['readonly']])
+ assert_equal(iter_multi_index(i),
[(0,0,0),(0,0,1),(0,1,0),(0,1,1),(0,2,0),(0,2,1),
(1,0,0),(1,0,1),(1,1,0),(1,1,1),(1,2,0),(1,2,1)])
# 3D Fortran-order
- i = nditer(a.reshape(2,3,2).copy(order='F'),['coords'],[['readonly']])
- assert_equal(iter_coords(i),
+ i = nditer(a.reshape(2,3,2).copy(order='F'),['multi_index'],[['readonly']])
+ assert_equal(iter_multi_index(i),
[(0,0,0),(1,0,0),(0,1,0),(1,1,0),(0,2,0),(1,2,0),
(0,0,1),(1,0,1),(0,1,1),(1,1,1),(0,2,1),(1,2,1)])
# 3D reversed C-order
- i = nditer(a.reshape(2,3,2)[::-1],['coords'],[['readonly']])
- assert_equal(iter_coords(i),
+ i = nditer(a.reshape(2,3,2)[::-1],['multi_index'],[['readonly']])
+ assert_equal(iter_multi_index(i),
[(1,0,0),(1,0,1),(1,1,0),(1,1,1),(1,2,0),(1,2,1),
(0,0,0),(0,0,1),(0,1,0),(0,1,1),(0,2,0),(0,2,1)])
- i = nditer(a.reshape(2,3,2)[:,::-1],['coords'],[['readonly']])
- assert_equal(iter_coords(i),
+ i = nditer(a.reshape(2,3,2)[:,::-1],['multi_index'],[['readonly']])
+ assert_equal(iter_multi_index(i),
[(0,2,0),(0,2,1),(0,1,0),(0,1,1),(0,0,0),(0,0,1),
(1,2,0),(1,2,1),(1,1,0),(1,1,1),(1,0,0),(1,0,1)])
- i = nditer(a.reshape(2,3,2)[:,:,::-1],['coords'],[['readonly']])
- assert_equal(iter_coords(i),
+ i = nditer(a.reshape(2,3,2)[:,:,::-1],['multi_index'],[['readonly']])
+ assert_equal(iter_multi_index(i),
[(0,0,1),(0,0,0),(0,1,1),(0,1,0),(0,2,1),(0,2,0),
(1,0,1),(1,0,0),(1,1,1),(1,1,0),(1,2,1),(1,2,0)])
# 3D reversed Fortran-order
i = nditer(a.reshape(2,3,2).copy(order='F')[::-1],
- ['coords'],[['readonly']])
- assert_equal(iter_coords(i),
+ ['multi_index'],[['readonly']])
+ assert_equal(iter_multi_index(i),
[(1,0,0),(0,0,0),(1,1,0),(0,1,0),(1,2,0),(0,2,0),
(1,0,1),(0,0,1),(1,1,1),(0,1,1),(1,2,1),(0,2,1)])
i = nditer(a.reshape(2,3,2).copy(order='F')[:,::-1],
- ['coords'],[['readonly']])
- assert_equal(iter_coords(i),
+ ['multi_index'],[['readonly']])
+ assert_equal(iter_multi_index(i),
[(0,2,0),(1,2,0),(0,1,0),(1,1,0),(0,0,0),(1,0,0),
(0,2,1),(1,2,1),(0,1,1),(1,1,1),(0,0,1),(1,0,1)])
i = nditer(a.reshape(2,3,2).copy(order='F')[:,:,::-1],
- ['coords'],[['readonly']])
- assert_equal(iter_coords(i),
+ ['multi_index'],[['readonly']])
+ assert_equal(iter_multi_index(i),
[(0,0,1),(1,0,1),(0,1,1),(1,1,1),(0,2,1),(1,2,1),
(0,0,0),(1,0,0),(0,1,0),(1,1,0),(0,2,0),(1,2,0)])
@@ -467,9 +467,9 @@ def test_iter_no_inner_dim_coalescing():
def test_iter_dim_coalescing():
# Check that the correct number of dimensions are coalesced
- # Tracking coordinates disables coalescing
+ # Tracking a multi-index disables coalescing
a = arange(24).reshape(2,3,4)
- i = nditer(a, ['coords'], [['readonly']])
+ i = nditer(a, ['multi_index'], [['readonly']])
assert_equal(i.ndim, 3)
# A tracked index can allow coalescing if it's compatible with the array
@@ -504,69 +504,69 @@ def test_iter_broadcasting():
# Standard NumPy broadcasting rules
# 1D with scalar
- i = nditer([arange(6), np.int32(2)], ['coords'], [['readonly']]*2)
+ i = nditer([arange(6), np.int32(2)], ['multi_index'], [['readonly']]*2)
assert_equal(i.itersize, 6)
assert_equal(i.shape, (6,))
# 2D with scalar
i = nditer([arange(6).reshape(2,3), np.int32(2)],
- ['coords'], [['readonly']]*2)
+ ['multi_index'], [['readonly']]*2)
assert_equal(i.itersize, 6)
assert_equal(i.shape, (2,3))
# 2D with 1D
i = nditer([arange(6).reshape(2,3), arange(3)],
- ['coords'], [['readonly']]*2)
+ ['multi_index'], [['readonly']]*2)
assert_equal(i.itersize, 6)
assert_equal(i.shape, (2,3))
i = nditer([arange(2).reshape(2,1), arange(3)],
- ['coords'], [['readonly']]*2)
+ ['multi_index'], [['readonly']]*2)
assert_equal(i.itersize, 6)
assert_equal(i.shape, (2,3))
# 2D with 2D
i = nditer([arange(2).reshape(2,1), arange(3).reshape(1,3)],
- ['coords'], [['readonly']]*2)
+ ['multi_index'], [['readonly']]*2)
assert_equal(i.itersize, 6)
assert_equal(i.shape, (2,3))
# 3D with scalar
i = nditer([np.int32(2), arange(24).reshape(4,2,3)],
- ['coords'], [['readonly']]*2)
+ ['multi_index'], [['readonly']]*2)
assert_equal(i.itersize, 24)
assert_equal(i.shape, (4,2,3))
# 3D with 1D
i = nditer([arange(3), arange(24).reshape(4,2,3)],
- ['coords'], [['readonly']]*2)
+ ['multi_index'], [['readonly']]*2)
assert_equal(i.itersize, 24)
assert_equal(i.shape, (4,2,3))
i = nditer([arange(3), arange(8).reshape(4,2,1)],
- ['coords'], [['readonly']]*2)
+ ['multi_index'], [['readonly']]*2)
assert_equal(i.itersize, 24)
assert_equal(i.shape, (4,2,3))
# 3D with 2D
i = nditer([arange(6).reshape(2,3), arange(24).reshape(4,2,3)],
- ['coords'], [['readonly']]*2)
+ ['multi_index'], [['readonly']]*2)
assert_equal(i.itersize, 24)
assert_equal(i.shape, (4,2,3))
i = nditer([arange(2).reshape(2,1), arange(24).reshape(4,2,3)],
- ['coords'], [['readonly']]*2)
+ ['multi_index'], [['readonly']]*2)
assert_equal(i.itersize, 24)
assert_equal(i.shape, (4,2,3))
i = nditer([arange(3).reshape(1,3), arange(8).reshape(4,2,1)],
- ['coords'], [['readonly']]*2)
+ ['multi_index'], [['readonly']]*2)
assert_equal(i.itersize, 24)
assert_equal(i.shape, (4,2,3))
# 3D with 3D
i = nditer([arange(2).reshape(1,2,1), arange(3).reshape(1,1,3),
arange(4).reshape(4,1,1)],
- ['coords'], [['readonly']]*3)
+ ['multi_index'], [['readonly']]*3)
assert_equal(i.itersize, 24)
assert_equal(i.shape, (4,2,3))
i = nditer([arange(6).reshape(1,2,3), arange(4).reshape(4,1,1)],
- ['coords'], [['readonly']]*2)
+ ['multi_index'], [['readonly']]*2)
assert_equal(i.itersize, 24)
assert_equal(i.shape, (4,2,3))
i = nditer([arange(24).reshape(4,2,3), arange(12).reshape(4,1,3)],
- ['coords'], [['readonly']]*2)
+ ['multi_index'], [['readonly']]*2)
assert_equal(i.itersize, 24)
assert_equal(i.shape, (4,2,3))
@@ -681,9 +681,9 @@ def test_iter_flags_errors():
# Cannot track both a C and an F index
assert_raises(ValueError, nditer, a,
['c_index','f_index'], [['readonly']])
- # Inner iteration and coords/indices are incompatible
+ # Inner iteration and multi-indices/indices are incompatible
assert_raises(ValueError, nditer, a,
- ['external_loop','coords'], [['readonly']])
+ ['external_loop','multi_index'], [['readonly']])
assert_raises(ValueError, nditer, a,
['external_loop','c_index'], [['readonly']])
assert_raises(ValueError, nditer, a,
@@ -706,14 +706,14 @@ def test_iter_flags_errors():
assert_raises(ValueError, nditer, a, [], [['writeonly']])
assert_raises(ValueError, nditer, a, [], [['readwrite']])
a.flags.writeable = True
- # Coords available only with the coords flag
+ # Multi-indices available only with the multi_index flag
i = nditer(arange(6), [], [['readonly']])
- assert_raises(ValueError, lambda i:i.coords, i)
+ assert_raises(ValueError, lambda i:i.multi_index, i)
# Index available only with an index flag
assert_raises(ValueError, lambda i:i.index, i)
# GotoCoords and GotoIndex incompatible with buffering or no_inner
- def assign_coords(i):
- i.coords = (0,)
+ def assign_multi_index(i):
+ i.multi_index = (0,)
def assign_index(i):
i.index = 0
def assign_iterindex(i):
@@ -721,12 +721,12 @@ def test_iter_flags_errors():
def assign_iterrange(i):
i.iterrange = (0,1);
i = nditer(arange(6), ['external_loop'])
- assert_raises(ValueError, assign_coords, i)
+ assert_raises(ValueError, assign_multi_index, i)
assert_raises(ValueError, assign_index, i)
assert_raises(ValueError, assign_iterindex, i)
assert_raises(ValueError, assign_iterrange, i)
i = nditer(arange(6), ['buffered'])
- assert_raises(ValueError, assign_coords, i)
+ assert_raises(ValueError, assign_multi_index, i)
assert_raises(ValueError, assign_index, i)
assert_raises(ValueError, assign_iterrange, i)
# Can't iterate if size is zero
@@ -1126,14 +1126,14 @@ def test_iter_op_axes():
# Inner product-style broadcasting
a = arange(24).reshape(2,3,4)
b = arange(40).reshape(5,2,4)
- i = nditer([a,b], ['coords'], [['readonly']]*2,
+ i = nditer([a,b], ['multi_index'], [['readonly']]*2,
op_axes=[[0,1,-1,-1],[-1,-1,0,1]])
assert_equal(i.shape, (2,3,5,2))
# Matrix product-style broadcasting
a = arange(12).reshape(3,4)
b = arange(20).reshape(4,5)
- i = nditer([a,b], ['coords'], [['readonly']]*2,
+ i = nditer([a,b], ['multi_index'], [['readonly']]*2,
op_axes=[[0,-1],[-1,1]])
assert_equal(i.shape, (3,5))
@@ -1370,28 +1370,28 @@ def test_iter_allocate_output_errors():
def test_iter_remove_axis():
a = arange(24).reshape(2,3,4)
- i = nditer(a,['coords'])
+ i = nditer(a,['multi_index'])
i.remove_axis(1)
assert_equal([x for x in i], a[:,0,:].ravel())
a = a[::-1,:,:]
- i = nditer(a,['coords'])
+ i = nditer(a,['multi_index'])
i.remove_axis(0)
assert_equal([x for x in i], a[0,:,:].ravel())
-def test_iter_remove_coords_inner_loop():
- # Check that removing coords support works
+def test_iter_remove_multi_index_inner_loop():
+ # Check that removing multi-index support works
a = arange(24).reshape(2,3,4)
- i = nditer(a,['coords'])
+ i = nditer(a,['multi_index'])
assert_equal(i.ndim, 3)
assert_equal(i.shape, (2,3,4))
assert_equal(i.itviews[0].shape, (2,3,4))
- # Removing coords causes all dimensions to coalesce
+ # Removing the multi-index tracking causes all dimensions to coalesce
before = [x for x in i]
- i.remove_coords()
+ i.remove_multi_index()
after = [x for x in i]
assert_equal(before, after)
@@ -1534,12 +1534,12 @@ def test_iter_buffering_delayed_alloc():
a = np.arange(6)
b = np.arange(1, dtype='f4')
- i = nditer([a,b], ['buffered','delay_bufalloc','coords','reduce_ok'],
+ i = nditer([a,b], ['buffered','delay_bufalloc','multi_index','reduce_ok'],
['readwrite'],
casting='unsafe',
op_dtypes='f4')
- assert_(i.hasdelayedbufalloc)
- assert_raises(ValueError, lambda i:i.coords, i)
+ assert_(i.has_delayed_bufalloc)
+ assert_raises(ValueError, lambda i:i.multi_index, i)
assert_raises(ValueError, lambda i:i[0], i)
assert_raises(ValueError, lambda i:i[0:2], i)
def assign_iter(i):
@@ -1547,8 +1547,8 @@ def test_iter_buffering_delayed_alloc():
assert_raises(ValueError, assign_iter, i)
i.reset()
- assert_(not i.hasdelayedbufalloc)
- assert_equal(i.coords, (0,))
+ assert_(not i.has_delayed_bufalloc)
+ assert_equal(i.multi_index, (0,))
assert_equal(i[0], 0)
i[1] = 1
assert_equal(i[0:2], [0,1])
diff --git a/numpy/lib/index_tricks.py b/numpy/lib/index_tricks.py
index d1e925ead..69539d482 100644
--- a/numpy/lib/index_tricks.py
+++ b/numpy/lib/index_tricks.py
@@ -1,4 +1,4 @@
-__all__ = ['ravel_coords',
+__all__ = ['ravel_multi_index',
'unravel_index',
'mgrid',
'ogrid',
@@ -17,7 +17,7 @@ import math
import function_base
import numpy.matrixlib as matrix
from function_base import diff
-from numpy.lib._compiled_base import ravel_coords, unravel_index
+from numpy.lib._compiled_base import ravel_multi_index, unravel_index
makemat = matrix.matrix
def ix_(*args):
diff --git a/numpy/lib/src/_compiled_base.c b/numpy/lib/src/_compiled_base.c
index b81d2783a..066519bf1 100644
--- a/numpy/lib/src/_compiled_base.c
+++ b/numpy/lib/src/_compiled_base.c
@@ -614,7 +614,7 @@ static int sequence_to_arrays(PyObject *seq,
/* Inner loop for unravel_index */
static int
-ravel_coords_loop(int ravel_ndim, npy_intp *ravel_dims,
+ravel_multi_index_loop(int ravel_ndim, npy_intp *ravel_dims,
npy_intp *ravel_strides,
npy_intp count,
NPY_CLIPMODE *modes,
@@ -674,9 +674,9 @@ ravel_coords_loop(int ravel_ndim, npy_intp *ravel_dims,
return NPY_SUCCEED;
}
-/* ravel_coords implementation - see add_newdocs.py */
+/* ravel_multi_index implementation - see add_newdocs.py */
static PyObject *
-arr_ravel_coords(PyObject *self, PyObject *args, PyObject *kwds)
+arr_ravel_multi_index(PyObject *self, PyObject *args, PyObject *kwds)
{
int i, s;
PyObject *mode0=NULL, *coords0=NULL;
@@ -692,12 +692,13 @@ arr_ravel_coords(PyObject *self, PyObject *args, PyObject *kwds)
NpyIter *iter = NULL;
- char *kwlist[] = {"coords", "dims", "mode", "order", NULL};
+ char *kwlist[] = {"multi_index", "dims", "mode", "order", NULL};
memset(op, 0, sizeof(op));
dtype[0] = NULL;
- if(!PyArg_ParseTupleAndKeywords(args, kwds, "OO&|OO&:ravel_coords", kwlist,
+ if(!PyArg_ParseTupleAndKeywords(args, kwds,
+ "OO&|OO&:ravel_multi_index", kwlist,
&coords0,
PyArray_IntpConverter, &dimensions,
&mode0,
@@ -707,7 +708,7 @@ arr_ravel_coords(PyObject *self, PyObject *args, PyObject *kwds)
if (dimensions.len+1 > NPY_MAXARGS) {
PyErr_SetString(PyExc_ValueError,
- "too many dimensions passed to ravel_coords");
+ "too many dimensions passed to ravel_multi_index");
goto fail;
}
@@ -736,8 +737,8 @@ arr_ravel_coords(PyObject *self, PyObject *args, PyObject *kwds)
goto fail;
}
- /* Get the coords into op */
- if (sequence_to_arrays(coords0, op, dimensions.len, "coords") < 0) {
+ /* Get the multi_index into op */
+ if (sequence_to_arrays(coords0, op, dimensions.len, "multi_index") < 0) {
goto fail;
}
@@ -779,7 +780,7 @@ arr_ravel_coords(PyObject *self, PyObject *args, PyObject *kwds)
countptr = NpyIter_GetInnerLoopSizePtr(iter);
do {
- if (ravel_coords_loop(dimensions.len, dimensions.ptr,
+ if (ravel_multi_index_loop(dimensions.len, dimensions.ptr,
ravel_strides, *countptr, modes,
dataptr, strides) != NPY_SUCCEED) {
goto fail;
@@ -923,7 +924,7 @@ arr_unravel_index(PyObject *self, PyObject *args, PyObject *kwds)
NPY_ITER_BUFFERED|
NPY_ITER_ZEROSIZE_OK|
NPY_ITER_DONT_NEGATE_STRIDES|
- NPY_ITER_COORDS,
+ NPY_ITER_MULTI_INDEX,
NPY_KEEPORDER, NPY_SAME_KIND_CASTING,
dtype);
if (iter == NULL) {
@@ -932,7 +933,7 @@ arr_unravel_index(PyObject *self, PyObject *args, PyObject *kwds)
/*
* Create the return array with a layout compatible with the indices
- * and with a dimension added to the end for the coordinates
+ * and with a dimension added to the end for the multi-index
*/
ret_ndim = PyArray_NDIM(indices) + 1;
if (NpyIter_GetShape(iter, ret_dims) != NPY_SUCCEED) {
@@ -945,8 +946,8 @@ arr_unravel_index(PyObject *self, PyObject *args, PyObject *kwds)
}
ret_strides[ret_ndim-1] = sizeof(npy_intp);
- /* Remove the coords and inner loop */
- if (NpyIter_RemoveCoords(iter) != NPY_SUCCEED) {
+ /* Remove the multi-index and inner loop */
+ if (NpyIter_RemoveMultiIndex(iter) != NPY_SUCCEED) {
goto fail;
}
if (NpyIter_EnableExternalLoop(iter) != NPY_SUCCEED) {
@@ -1020,7 +1021,7 @@ arr_unravel_index(PyObject *self, PyObject *args, PyObject *kwds)
goto fail;
}
- /* Now make a tuple of views, one per coordinate */
+ /* Now make a tuple of views, one per index */
ret_tuple = PyTuple_New(dimensions.len);
if (ret_tuple == NULL) {
goto fail;
@@ -1411,7 +1412,7 @@ static struct PyMethodDef methods[] = {
METH_VARARGS | METH_KEYWORDS, NULL},
{"interp", (PyCFunction)arr_interp,
METH_VARARGS | METH_KEYWORDS, NULL},
- {"ravel_coords", (PyCFunction)arr_ravel_coords,
+ {"ravel_multi_index", (PyCFunction)arr_ravel_multi_index,
METH_VARARGS | METH_KEYWORDS, NULL},
{"unravel_index", (PyCFunction)arr_unravel_index,
METH_VARARGS | METH_KEYWORDS, NULL},
diff --git a/numpy/lib/tests/test_index_tricks.py b/numpy/lib/tests/test_index_tricks.py
index 40f75936e..8b42292a2 100644
--- a/numpy/lib/tests/test_index_tricks.py
+++ b/numpy/lib/tests/test_index_tricks.py
@@ -7,28 +7,28 @@ from numpy import ( array, ones, r_, mgrid, unravel_index, zeros, where,
class TestRavelUnravelIndex(TestCase):
def test_basic(self):
assert_equal(np.unravel_index(2,(2,2)), (1,0))
- assert_equal(np.ravel_coords((1,0),(2,2)), 2)
+ assert_equal(np.ravel_multi_index((1,0),(2,2)), 2)
assert_equal(np.unravel_index(254,(17,94)), (2,66))
- assert_equal(np.ravel_coords((2,66),(17,94)), 254)
+ assert_equal(np.ravel_multi_index((2,66),(17,94)), 254)
assert_raises(ValueError, np.unravel_index, -1, (2,2))
assert_raises(TypeError, np.unravel_index, 0.5, (2,2))
assert_raises(ValueError, np.unravel_index, 4, (2,2))
- assert_raises(ValueError, np.ravel_coords, (-3,1), (2,2))
- assert_raises(ValueError, np.ravel_coords, (2,1), (2,2))
- assert_raises(ValueError, np.ravel_coords, (0,-3), (2,2))
- assert_raises(ValueError, np.ravel_coords, (0,2), (2,2))
- assert_raises(TypeError, np.ravel_coords, (0.1,0.), (2,2))
+ assert_raises(ValueError, np.ravel_multi_index, (-3,1), (2,2))
+ assert_raises(ValueError, np.ravel_multi_index, (2,1), (2,2))
+ assert_raises(ValueError, np.ravel_multi_index, (0,-3), (2,2))
+ assert_raises(ValueError, np.ravel_multi_index, (0,2), (2,2))
+ assert_raises(TypeError, np.ravel_multi_index, (0.1,0.), (2,2))
assert_equal(np.unravel_index((2*3 + 1)*6 + 4, (4,3,6)), [2,1,4])
- assert_equal(np.ravel_coords([2,1,4], (4,3,6)), (2*3 + 1)*6 + 4)
+ assert_equal(np.ravel_multi_index([2,1,4], (4,3,6)), (2*3 + 1)*6 + 4)
arr = np.array([[3,6,6],[4,5,1]])
- assert_equal(np.ravel_coords(arr, (7,6)), [22,41,37])
- assert_equal(np.ravel_coords(arr, (7,6), order='F'), [31,41,13])
- assert_equal(np.ravel_coords(arr, (4,6), mode='clip'), [22,23,19])
- assert_equal(np.ravel_coords(arr, (4,4), mode=('clip','wrap')),
+ assert_equal(np.ravel_multi_index(arr, (7,6)), [22,41,37])
+ assert_equal(np.ravel_multi_index(arr, (7,6), order='F'), [31,41,13])
+ assert_equal(np.ravel_multi_index(arr, (4,6), mode='clip'), [22,23,19])
+ assert_equal(np.ravel_multi_index(arr, (4,4), mode=('clip','wrap')),
[12,13,13])
- assert_equal(np.ravel_coords((3,1,4,1), (6,7,8,9)), 1621)
+ assert_equal(np.ravel_multi_index((3,1,4,1), (6,7,8,9)), 1621)
assert_equal(np.unravel_index(np.array([22, 41, 37]), (7,6)),
[[3, 6, 6],[4, 5, 1]])
@@ -43,30 +43,30 @@ class TestRavelUnravelIndex(TestCase):
coords = np.array([[1,0,1,2,3,4],[1,6,1,3,2,0]], dtype=dtype)
shape = (5,8)
uncoords = 8*coords[0]+coords[1]
- assert_equal(np.ravel_coords(coords, shape), uncoords)
+ assert_equal(np.ravel_multi_index(coords, shape), uncoords)
assert_equal(coords, np.unravel_index(uncoords, shape))
uncoords = coords[0]+5*coords[1]
- assert_equal(np.ravel_coords(coords, shape, order='F'), uncoords)
+ assert_equal(np.ravel_multi_index(coords, shape, order='F'), uncoords)
assert_equal(coords, np.unravel_index(uncoords, shape, order='F'))
coords = np.array([[1,0,1,2,3,4],[1,6,1,3,2,0],[1,3,1,0,9,5]],
dtype=dtype)
shape = (5,8,10)
uncoords = 10*(8*coords[0]+coords[1])+coords[2]
- assert_equal(np.ravel_coords(coords, shape), uncoords)
+ assert_equal(np.ravel_multi_index(coords, shape), uncoords)
assert_equal(coords, np.unravel_index(uncoords, shape))
uncoords = coords[0]+5*(coords[1]+8*coords[2])
- assert_equal(np.ravel_coords(coords, shape, order='F'), uncoords)
+ assert_equal(np.ravel_multi_index(coords, shape, order='F'), uncoords)
assert_equal(coords, np.unravel_index(uncoords, shape, order='F'))
def test_clipmodes(self):
# Test clipmodes
- assert_equal(np.ravel_coords([5,1,-1,2], (4,3,7,12), mode='wrap'),
- np.ravel_coords([1,1,6,2], (4,3,7,12)))
- assert_equal(np.ravel_coords([5,1,-1,2], (4,3,7,12),
+ assert_equal(np.ravel_multi_index([5,1,-1,2], (4,3,7,12), mode='wrap'),
+ np.ravel_multi_index([1,1,6,2], (4,3,7,12)))
+ assert_equal(np.ravel_multi_index([5,1,-1,2], (4,3,7,12),
mode=('wrap','raise','clip','raise')),
- np.ravel_coords([1,1,0,2], (4,3,7,12)))
- assert_raises(ValueError, np.ravel_coords, [5,1,-1,2], (4,3,7,12))
+ np.ravel_multi_index([1,1,0,2], (4,3,7,12)))
+ assert_raises(ValueError, np.ravel_multi_index, [5,1,-1,2], (4,3,7,12))
class TestGrid(TestCase):
def test_basic(self):
View Lorry Controller Status