ENH: iter: Shorten flag NPY_ITER_C/F_ORDER_INDEX to NPY_ITER_C/F_INDEX

4 files changed, 61 insertions, 61 deletions

diff --git a/numpy/core/src/multiarray/new_iterator.c.src b/numpy/core/src/multiarray/new_iterator.c.src
index dd5bc9cc3..74163e628 100644
--- a/numpy/core/src/multiarray/new_iterator.c.src
+++ b/numpy/core/src/multiarray/new_iterator.c.src
@@ -1599,12 +1599,12 @@ npyiter_check_global_flags(npy_uint32 flags, npy_uint32* itflags)
     }
 
     /* Check for an index */
-    if (flags&(NPY_ITER_C_ORDER_INDEX | NPY_ITER_F_ORDER_INDEX)) {
-        if ((flags&(NPY_ITER_C_ORDER_INDEX | NPY_ITER_F_ORDER_INDEX)) ==
-                    (NPY_ITER_C_ORDER_INDEX | NPY_ITER_F_ORDER_INDEX)) {
+    if (flags&(NPY_ITER_C_INDEX | NPY_ITER_F_INDEX)) {
+        if ((flags&(NPY_ITER_C_INDEX | NPY_ITER_F_INDEX)) ==
+                    (NPY_ITER_C_INDEX | NPY_ITER_F_INDEX)) {
             PyErr_SetString(PyExc_ValueError,
-                    "Iterator flags C_ORDER_INDEX and "
-                    "F_ORDER_INDEX cannot both be specified");
+                    "Iterator flags C_INDEX and "
+                    "F_INDEX cannot both be specified");
             return 0;
         }
         (*itflags) |= NPY_ITFLAG_HASINDEX;
@@ -2492,7 +2492,7 @@ npyiter_compute_index_strides(NpyIter *iter, npy_uint32 flags)
         return;
     }
 
-    if (flags&NPY_ITER_C_ORDER_INDEX) {
+    if (flags&NPY_ITER_C_INDEX) {
         sizeof_axisdata = NIT_SIZEOF_AXISDATA(itflags, ndim, niter);
         axisdata = NIT_AXISDATA(iter);
         indexstride = 1;
@@ -2509,7 +2509,7 @@ npyiter_compute_index_strides(NpyIter *iter, npy_uint32 flags)
             indexstride *= shape;
         }
     }
-    else if (flags&NPY_ITER_F_ORDER_INDEX) {
+    else if (flags&NPY_ITER_F_INDEX) {
         sizeof_axisdata = NIT_SIZEOF_AXISDATA(itflags, ndim, niter);
         axisdata = NIT_INDEX_AXISDATA(NIT_AXISDATA(iter), ndim-1);
         indexstride = 1;
diff --git a/numpy/core/src/multiarray/new_iterator.h b/numpy/core/src/multiarray/new_iterator.h
index 70811e662..df0250d6f 100644
--- a/numpy/core/src/multiarray/new_iterator.h
+++ b/numpy/core/src/multiarray/new_iterator.h
@@ -107,9 +107,9 @@ NPY_NO_EXPORT void NpyIter_DebugPrint(NpyIter *iter);
 /*** Global flags that may be passed to the iterator constructors ***/
 
 /* Track an index representing C order */
-#define NPY_ITER_C_ORDER_INDEX              0x00000001
-/* Track an index representing F order */
-#define NPY_ITER_F_ORDER_INDEX              0x00000002
+#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
 /* Let the caller handle the inner loop of iteration */
diff --git a/numpy/core/src/multiarray/new_iterator_pywrap.c b/numpy/core/src/multiarray/new_iterator_pywrap.c
index fbc9f1b65..063a4fe86 100644
--- a/numpy/core/src/multiarray/new_iterator_pywrap.c
+++ b/numpy/core/src/multiarray/new_iterator_pywrap.c
@@ -124,8 +124,8 @@ NpyIter_GlobalFlagsConverter(PyObject *flags_in, npy_uint32 *flags)
             case 'c':
                 if (length >= 6) switch (str[5]) {
                     case 'e':
-                        if (strcmp(str, "c_order_index") == 0) {
-                            flag = NPY_ITER_C_ORDER_INDEX;
+                        if (strcmp(str, "c_index") == 0) {
+                            flag = NPY_ITER_C_INDEX;
                         }
                         break;
                     case 's':
@@ -141,8 +141,8 @@ NpyIter_GlobalFlagsConverter(PyObject *flags_in, npy_uint32 *flags)
                 }
                 break;
             case 'f':
-                if (strcmp(str, "f_order_index") == 0) {
-                    flag = NPY_ITER_F_ORDER_INDEX;
+                if (strcmp(str, "f_index") == 0) {
+                    flag = NPY_ITER_F_INDEX;
                 }
                 break;
             case 'n':
diff --git a/numpy/core/tests/test_new_iterator.py b/numpy/core/tests/test_new_iterator.py
index b77cd32b4..284b83ee4 100644
--- a/numpy/core/tests/test_new_iterator.py
+++ b/numpy/core/tests/test_new_iterator.py
@@ -231,10 +231,10 @@ def test_iter_best_order_c_index_1d():
 
     a = arange(4)
     # 1D order
-    i = newiter(a,['c_order_index'],[['readonly']])
+    i = newiter(a,['c_index'],[['readonly']])
     assert_equal(iter_indices(i), [0,1,2,3])
     # 1D reversed order
-    i = newiter(a[::-1],['c_order_index'],[['readonly']])
+    i = newiter(a[::-1],['c_index'],[['readonly']])
     assert_equal(iter_indices(i), [3,2,1,0])
 
 def test_iter_best_order_c_index_2d():
@@ -242,28 +242,28 @@ def test_iter_best_order_c_index_2d():
 
     a = arange(6)
     # 2D C-order
-    i = newiter(a.reshape(2,3),['c_order_index'],[['readonly']])
+    i = newiter(a.reshape(2,3),['c_index'],[['readonly']])
     assert_equal(iter_indices(i), [0,1,2,3,4,5])
     # 2D Fortran-order
     i = newiter(a.reshape(2,3).copy(order='F'),
-                                    ['c_order_index'],[['readonly']])
+                                    ['c_index'],[['readonly']])
     assert_equal(iter_indices(i), [0,3,1,4,2,5])
     # 2D reversed C-order
-    i = newiter(a.reshape(2,3)[::-1],['c_order_index'],[['readonly']])
+    i = newiter(a.reshape(2,3)[::-1],['c_index'],[['readonly']])
     assert_equal(iter_indices(i), [3,4,5,0,1,2])
-    i = newiter(a.reshape(2,3)[:,::-1],['c_order_index'],[['readonly']])
+    i = newiter(a.reshape(2,3)[:,::-1],['c_index'],[['readonly']])
     assert_equal(iter_indices(i), [2,1,0,5,4,3])
-    i = newiter(a.reshape(2,3)[::-1,::-1],['c_order_index'],[['readonly']])
+    i = newiter(a.reshape(2,3)[::-1,::-1],['c_index'],[['readonly']])
     assert_equal(iter_indices(i), [5,4,3,2,1,0])
     # 2D reversed Fortran-order
     i = newiter(a.reshape(2,3).copy(order='F')[::-1],
-                                    ['c_order_index'],[['readonly']])
+                                    ['c_index'],[['readonly']])
     assert_equal(iter_indices(i), [3,0,4,1,5,2])
     i = newiter(a.reshape(2,3).copy(order='F')[:,::-1],
-                                    ['c_order_index'],[['readonly']])
+                                    ['c_index'],[['readonly']])
     assert_equal(iter_indices(i), [2,5,1,4,0,3])
     i = newiter(a.reshape(2,3).copy(order='F')[::-1,::-1],
-                                    ['c_order_index'],[['readonly']])
+                                    ['c_index'],[['readonly']])
     assert_equal(iter_indices(i), [5,2,4,1,3,0])
 
 def test_iter_best_order_c_index_3d():
@@ -271,112 +271,112 @@ def test_iter_best_order_c_index_3d():
 
     a = arange(12)
     # 3D C-order
-    i = newiter(a.reshape(2,3,2),['c_order_index'],[['readonly']])
+    i = newiter(a.reshape(2,3,2),['c_index'],[['readonly']])
     assert_equal(iter_indices(i),
                             [0,1,2,3,4,5,6,7,8,9,10,11])
     # 3D Fortran-order
     i = newiter(a.reshape(2,3,2).copy(order='F'),
-                                    ['c_order_index'],[['readonly']])
+                                    ['c_index'],[['readonly']])
     assert_equal(iter_indices(i),
                             [0,6,2,8,4,10,1,7,3,9,5,11])
     # 3D reversed C-order
-    i = newiter(a.reshape(2,3,2)[::-1],['c_order_index'],[['readonly']])
+    i = newiter(a.reshape(2,3,2)[::-1],['c_index'],[['readonly']])
     assert_equal(iter_indices(i),
                             [6,7,8,9,10,11,0,1,2,3,4,5])
-    i = newiter(a.reshape(2,3,2)[:,::-1],['c_order_index'],[['readonly']])
+    i = newiter(a.reshape(2,3,2)[:,::-1],['c_index'],[['readonly']])
     assert_equal(iter_indices(i),
                             [4,5,2,3,0,1,10,11,8,9,6,7])
-    i = newiter(a.reshape(2,3,2)[:,:,::-1],['c_order_index'],[['readonly']])
+    i = newiter(a.reshape(2,3,2)[:,:,::-1],['c_index'],[['readonly']])
     assert_equal(iter_indices(i),
                             [1,0,3,2,5,4,7,6,9,8,11,10])
     # 3D reversed Fortran-order
     i = newiter(a.reshape(2,3,2).copy(order='F')[::-1],
-                                    ['c_order_index'],[['readonly']])
+                                    ['c_index'],[['readonly']])
     assert_equal(iter_indices(i),
                             [6,0,8,2,10,4,7,1,9,3,11,5])
     i = newiter(a.reshape(2,3,2).copy(order='F')[:,::-1],
-                                    ['c_order_index'],[['readonly']])
+                                    ['c_index'],[['readonly']])
     assert_equal(iter_indices(i),
                             [4,10,2,8,0,6,5,11,3,9,1,7])
     i = newiter(a.reshape(2,3,2).copy(order='F')[:,:,::-1],
-                                    ['c_order_index'],[['readonly']])
+                                    ['c_index'],[['readonly']])
     assert_equal(iter_indices(i),
                             [1,7,3,9,5,11,0,6,2,8,4,10])
 
-def test_iter_best_order_f_order_index_1d():
+def test_iter_best_order_f_index_1d():
     # The Fortran index should be correct with any reordering
 
     a = arange(4)
     # 1D order
-    i = newiter(a,['f_order_index'],[['readonly']])
+    i = newiter(a,['f_index'],[['readonly']])
     assert_equal(iter_indices(i), [0,1,2,3])
     # 1D reversed order
-    i = newiter(a[::-1],['f_order_index'],[['readonly']])
+    i = newiter(a[::-1],['f_index'],[['readonly']])
     assert_equal(iter_indices(i), [3,2,1,0])
 
-def test_iter_best_order_f_order_index_2d():
+def test_iter_best_order_f_index_2d():
     # The Fortran index should be correct with any reordering
 
     a = arange(6)
     # 2D C-order
-    i = newiter(a.reshape(2,3),['f_order_index'],[['readonly']])
+    i = newiter(a.reshape(2,3),['f_index'],[['readonly']])
     assert_equal(iter_indices(i), [0,2,4,1,3,5])
     # 2D Fortran-order
     i = newiter(a.reshape(2,3).copy(order='F'),
-                                    ['f_order_index'],[['readonly']])
+                                    ['f_index'],[['readonly']])
     assert_equal(iter_indices(i), [0,1,2,3,4,5])
     # 2D reversed C-order
-    i = newiter(a.reshape(2,3)[::-1],['f_order_index'],[['readonly']])
+    i = newiter(a.reshape(2,3)[::-1],['f_index'],[['readonly']])
     assert_equal(iter_indices(i), [1,3,5,0,2,4])
-    i = newiter(a.reshape(2,3)[:,::-1],['f_order_index'],[['readonly']])
+    i = newiter(a.reshape(2,3)[:,::-1],['f_index'],[['readonly']])
     assert_equal(iter_indices(i), [4,2,0,5,3,1])
-    i = newiter(a.reshape(2,3)[::-1,::-1],['f_order_index'],[['readonly']])
+    i = newiter(a.reshape(2,3)[::-1,::-1],['f_index'],[['readonly']])
     assert_equal(iter_indices(i), [5,3,1,4,2,0])
     # 2D reversed Fortran-order
     i = newiter(a.reshape(2,3).copy(order='F')[::-1],
-                                    ['f_order_index'],[['readonly']])
+                                    ['f_index'],[['readonly']])
     assert_equal(iter_indices(i), [1,0,3,2,5,4])
     i = newiter(a.reshape(2,3).copy(order='F')[:,::-1],
-                                    ['f_order_index'],[['readonly']])
+                                    ['f_index'],[['readonly']])
     assert_equal(iter_indices(i), [4,5,2,3,0,1])
     i = newiter(a.reshape(2,3).copy(order='F')[::-1,::-1],
-                                    ['f_order_index'],[['readonly']])
+                                    ['f_index'],[['readonly']])
     assert_equal(iter_indices(i), [5,4,3,2,1,0])
 
-def test_iter_best_order_f_order_index_3d():
+def test_iter_best_order_f_index_3d():
     # The Fortran index should be correct with any reordering
 
     a = arange(12)
     # 3D C-order
-    i = newiter(a.reshape(2,3,2),['f_order_index'],[['readonly']])
+    i = newiter(a.reshape(2,3,2),['f_index'],[['readonly']])
     assert_equal(iter_indices(i),
                             [0,6,2,8,4,10,1,7,3,9,5,11])
     # 3D Fortran-order
     i = newiter(a.reshape(2,3,2).copy(order='F'),
-                                    ['f_order_index'],[['readonly']])
+                                    ['f_index'],[['readonly']])
     assert_equal(iter_indices(i),
                             [0,1,2,3,4,5,6,7,8,9,10,11])
     # 3D reversed C-order
-    i = newiter(a.reshape(2,3,2)[::-1],['f_order_index'],[['readonly']])
+    i = newiter(a.reshape(2,3,2)[::-1],['f_index'],[['readonly']])
     assert_equal(iter_indices(i),
                             [1,7,3,9,5,11,0,6,2,8,4,10])
-    i = newiter(a.reshape(2,3,2)[:,::-1],['f_order_index'],[['readonly']])
+    i = newiter(a.reshape(2,3,2)[:,::-1],['f_index'],[['readonly']])
     assert_equal(iter_indices(i),
                             [4,10,2,8,0,6,5,11,3,9,1,7])
-    i = newiter(a.reshape(2,3,2)[:,:,::-1],['f_order_index'],[['readonly']])
+    i = newiter(a.reshape(2,3,2)[:,:,::-1],['f_index'],[['readonly']])
     assert_equal(iter_indices(i),
                             [6,0,8,2,10,4,7,1,9,3,11,5])
     # 3D reversed Fortran-order
     i = newiter(a.reshape(2,3,2).copy(order='F')[::-1],
-                                    ['f_order_index'],[['readonly']])
+                                    ['f_index'],[['readonly']])
     assert_equal(iter_indices(i),
                             [1,0,3,2,5,4,7,6,9,8,11,10])
     i = newiter(a.reshape(2,3,2).copy(order='F')[:,::-1],
-                                    ['f_order_index'],[['readonly']])
+                                    ['f_index'],[['readonly']])
     assert_equal(iter_indices(i),
                             [4,5,2,3,0,1,10,11,8,9,6,7])
     i = newiter(a.reshape(2,3,2).copy(order='F')[:,:,::-1],
-                                    ['f_order_index'],[['readonly']])
+                                    ['f_index'],[['readonly']])
     assert_equal(iter_indices(i),
                             [6,7,8,9,10,11,0,1,2,3,4,5])
 
@@ -444,15 +444,15 @@ def test_iter_dim_coalescing():
 
     # A tracked index can allow coalescing if it's compatible with the array
     a3d = arange(24).reshape(2,3,4)
-    i = newiter(a3d, ['c_order_index'], [['readonly']])
+    i = newiter(a3d, ['c_index'], [['readonly']])
     assert_equal(i.ndim, 1)
-    i = newiter(a3d.swapaxes(0,1), ['c_order_index'], [['readonly']])
+    i = newiter(a3d.swapaxes(0,1), ['c_index'], [['readonly']])
     assert_equal(i.ndim, 3)
-    i = newiter(a3d.T, ['c_order_index'], [['readonly']])
+    i = newiter(a3d.T, ['c_index'], [['readonly']])
     assert_equal(i.ndim, 3)
-    i = newiter(a3d.T, ['f_order_index'], [['readonly']])
+    i = newiter(a3d.T, ['f_index'], [['readonly']])
     assert_equal(i.ndim, 1)
-    i = newiter(a3d.T.swapaxes(0,1), ['f_order_index'], [['readonly']])
+    i = newiter(a3d.T.swapaxes(0,1), ['f_index'], [['readonly']])
     assert_equal(i.ndim, 3)
 
     # When C or F order is forced, coalescing may still occur
@@ -579,14 +579,14 @@ def test_iter_flags_errors():
     assert_raises(ValueError, newiter, [a]*3, [], [['readonly']]*2)
     # Cannot track both a C and an F index
     assert_raises(ValueError, newiter, a,
-                ['c_order_index','f_order_index'], [['readonly']])
+                ['c_index','f_index'], [['readonly']])
     # Inner iteration and coords/indices are incompatible
     assert_raises(ValueError, newiter, a,
                 ['no_inner_iteration','coords'], [['readonly']])
     assert_raises(ValueError, newiter, a,
-                ['no_inner_iteration','c_order_index'], [['readonly']])
+                ['no_inner_iteration','c_index'], [['readonly']])
     assert_raises(ValueError, newiter, a,
-                ['no_inner_iteration','f_order_index'], [['readonly']])
+                ['no_inner_iteration','f_index'], [['readonly']])
     # Must specify exactly one of readwrite/readonly/writeonly per operand
     assert_raises(ValueError, newiter, a, [], [[]])
     assert_raises(ValueError, newiter, a, [], [['readonly','writeonly']])