ENH: Rename 'np.newiter' to 'np.nditer'

4 files changed, 292 insertions, 292 deletions

diff --git a/numpy/core/numeric.py b/numpy/core/numeric.py
index fa9f19165..187296efe 100644
--- a/numpy/core/numeric.py
+++ b/numpy/core/numeric.py
@@ -1,4 +1,4 @@
-__all__ = ['newaxis', 'ndarray', 'flatiter', 'newiter', 'nested_iters', 'ufunc',
+__all__ = ['newaxis', 'ndarray', 'flatiter', 'nditer', 'nested_iters', 'ufunc',
            'arange', 'array', 'zeros', 'count_nonzero', 'empty', 'broadcast',
            'dtype', 'fromstring', 'fromfile', 'frombuffer',
            'int_asbuffer', 'where', 'argwhere',
@@ -54,7 +54,7 @@ BUFSIZE = multiarray.BUFSIZE
 
 ndarray = multiarray.ndarray
 flatiter = multiarray.flatiter
-newiter = multiarray.newiter
+nditer = multiarray.nditer
 nested_iters = multiarray.nested_iters
 broadcast = multiarray.broadcast
 dtype = multiarray.dtype
diff --git a/numpy/core/src/multiarray/multiarraymodule.c b/numpy/core/src/multiarray/multiarraymodule.c
index d39fdb0a8..c964e2f02 100644
--- a/numpy/core/src/multiarray/multiarraymodule.c
+++ b/numpy/core/src/multiarray/multiarraymodule.c
@@ -3857,7 +3857,7 @@ PyMODINIT_FUNC initmultiarray(void) {
     Py_INCREF(&PyArrayIter_Type);
     PyDict_SetItemString(d, "flatiter", (PyObject *)&PyArrayIter_Type);
     Py_INCREF(&PyArrayMultiIter_Type);
-    PyDict_SetItemString(d, "newiter", (PyObject *)&NpyIter_Type);
+    PyDict_SetItemString(d, "nditer", (PyObject *)&NpyIter_Type);
     Py_INCREF(&NpyIter_Type);
     PyDict_SetItemString(d, "broadcast",
                          (PyObject *)&PyArrayMultiIter_Type);
diff --git a/numpy/core/src/multiarray/new_iterator_pywrap.c b/numpy/core/src/multiarray/new_iterator_pywrap.c
index a2af3030b..1f2adc535 100644
--- a/numpy/core/src/multiarray/new_iterator_pywrap.c
+++ b/numpy/core/src/multiarray/new_iterator_pywrap.c
@@ -2450,7 +2450,7 @@ NPY_NO_EXPORT PyTypeObject NpyIter_Type = {
     PyObject_HEAD_INIT(NULL)
     0,                                          /* ob_size */
 #endif
-    "numpy.newiter",                            /* tp_name */
+    "numpy.nditer",                             /* tp_name */
     sizeof(NewNpyArrayIterObject),              /* tp_basicsize */
     0,                                          /* tp_itemsize */
     /* methods */
diff --git a/numpy/core/tests/test_new_iterator.py b/numpy/core/tests/test_new_iterator.py
index 28cac8563..1c12f6b55 100644
--- a/numpy/core/tests/test_new_iterator.py
+++ b/numpy/core/tests/test_new_iterator.py
@@ -1,5 +1,5 @@
 import numpy as np
-from numpy import array, arange, newiter, all
+from numpy import array, arange, nditer, all
 from numpy.compat import asbytes
 from numpy.testing import *
 import sys, warnings
@@ -35,7 +35,7 @@ def test_iter_refcount():
     dt = np.dtype('f4').newbyteorder()
     rc_a = sys.getrefcount(a)
     rc_dt = sys.getrefcount(dt)
-    it = newiter(a, [],
+    it = nditer(a, [],
                 [['readwrite','updateifcopy']],
                 casting='unsafe',
                 op_dtypes=[dt])
@@ -51,7 +51,7 @@ def test_iter_refcount():
     dt = np.dtype('f4')
     rc_a = sys.getrefcount(a)
     rc_dt = sys.getrefcount(dt)
-    it = newiter(a, [],
+    it = nditer(a, [],
                 [['readwrite']],
                 op_dtypes=[dt])
     rc2_a = sys.getrefcount(a)
@@ -83,14 +83,14 @@ def test_iter_best_order():
 
             aview = a.reshape(shape)[dirs_index]
             # C-order
-            i = newiter(aview, [], [['readonly']])
+            i = nditer(aview, [], [['readonly']])
             assert_equal([x for x in i], a)
             # Fortran-order
-            i = newiter(aview.T, [], [['readonly']])
+            i = nditer(aview.T, [], [['readonly']])
             assert_equal([x for x in i], a)
             # Other order
             if len(shape) > 2:
-                i = newiter(aview.swapaxes(0,1), [], [['readonly']])
+                i = nditer(aview.swapaxes(0,1), [], [['readonly']])
                 assert_equal([x for x in i], a)
 
 def test_iter_c_order():
@@ -109,14 +109,14 @@ def test_iter_c_order():
 
             aview = a.reshape(shape)[dirs_index]
             # C-order
-            i = newiter(aview, order='C')
+            i = nditer(aview, order='C')
             assert_equal([x for x in i], aview.ravel(order='C'))
             # Fortran-order
-            i = newiter(aview.T, order='C')
+            i = nditer(aview.T, order='C')
             assert_equal([x for x in i], aview.T.ravel(order='C'))
             # Other order
             if len(shape) > 2:
-                i = newiter(aview.swapaxes(0,1), order='C')
+                i = nditer(aview.swapaxes(0,1), order='C')
                 assert_equal([x for x in i],
                                     aview.swapaxes(0,1).ravel(order='C'))
 
@@ -136,14 +136,14 @@ def test_iter_f_order():
 
             aview = a.reshape(shape)[dirs_index]
             # C-order
-            i = newiter(aview, order='F')
+            i = nditer(aview, order='F')
             assert_equal([x for x in i], aview.ravel(order='F'))
             # Fortran-order
-            i = newiter(aview.T, order='F')
+            i = nditer(aview.T, order='F')
             assert_equal([x for x in i], aview.T.ravel(order='F'))
             # Other order
             if len(shape) > 2:
-                i = newiter(aview.swapaxes(0,1), order='F')
+                i = nditer(aview.swapaxes(0,1), order='F')
                 assert_equal([x for x in i],
                                     aview.swapaxes(0,1).ravel(order='F'))
 
@@ -163,14 +163,14 @@ def test_iter_c_or_f_order():
 
             aview = a.reshape(shape)[dirs_index]
             # C-order
-            i = newiter(aview, order='A')
+            i = nditer(aview, order='A')
             assert_equal([x for x in i], aview.ravel(order='A'))
             # Fortran-order
-            i = newiter(aview.T, order='A')
+            i = nditer(aview.T, order='A')
             assert_equal([x for x in i], aview.T.ravel(order='A'))
             # Other order
             if len(shape) > 2:
-                i = newiter(aview.swapaxes(0,1), order='A')
+                i = nditer(aview.swapaxes(0,1), order='A')
                 assert_equal([x for x in i],
                                     aview.swapaxes(0,1).ravel(order='A'))
 
@@ -179,10 +179,10 @@ def test_iter_best_order_coords_1d():
 
     a = arange(4)
     # 1D order
-    i = newiter(a,['coords'],[['readonly']])
+    i = nditer(a,['coords'],[['readonly']])
     assert_equal(iter_coords(i), [(0,),(1,),(2,),(3,)])
     # 1D reversed order
-    i = newiter(a[::-1],['coords'],[['readonly']])
+    i = nditer(a[::-1],['coords'],[['readonly']])
     assert_equal(iter_coords(i), [(3,),(2,),(1,),(0,)])
 
 def test_iter_best_order_coords_2d():
@@ -190,25 +190,25 @@ def test_iter_best_order_coords_2d():
 
     a = arange(6)
     # 2D C-order
-    i = newiter(a.reshape(2,3),['coords'],[['readonly']])
+    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)])
     # 2D Fortran-order
-    i = newiter(a.reshape(2,3).copy(order='F'),['coords'],[['readonly']])
+    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)])
     # 2D reversed C-order
-    i = newiter(a.reshape(2,3)[::-1],['coords'],[['readonly']])
+    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 = newiter(a.reshape(2,3)[:,::-1],['coords'],[['readonly']])
+    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 = newiter(a.reshape(2,3)[::-1,::-1],['coords'],[['readonly']])
+    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)])
     # 2D reversed Fortran-order
-    i = newiter(a.reshape(2,3).copy(order='F')[::-1],['coords'],[['readonly']])
+    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 = newiter(a.reshape(2,3).copy(order='F')[:,::-1],
+    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)])
-    i = newiter(a.reshape(2,3).copy(order='F')[::-1,::-1],
+    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)])
 
@@ -217,40 +217,40 @@ def test_iter_best_order_coords_3d():
 
     a = arange(12)
     # 3D C-order
-    i = newiter(a.reshape(2,3,2),['coords'],[['readonly']])
+    i = nditer(a.reshape(2,3,2),['coords'],[['readonly']])
     assert_equal(iter_coords(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 = newiter(a.reshape(2,3,2).copy(order='F'),['coords'],[['readonly']])
+    i = nditer(a.reshape(2,3,2).copy(order='F'),['coords'],[['readonly']])
     assert_equal(iter_coords(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 = newiter(a.reshape(2,3,2)[::-1],['coords'],[['readonly']])
+    i = nditer(a.reshape(2,3,2)[::-1],['coords'],[['readonly']])
     assert_equal(iter_coords(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 = newiter(a.reshape(2,3,2)[:,::-1],['coords'],[['readonly']])
+    i = nditer(a.reshape(2,3,2)[:,::-1],['coords'],[['readonly']])
     assert_equal(iter_coords(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 = newiter(a.reshape(2,3,2)[:,:,::-1],['coords'],[['readonly']])
+    i = nditer(a.reshape(2,3,2)[:,:,::-1],['coords'],[['readonly']])
     assert_equal(iter_coords(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 = newiter(a.reshape(2,3,2).copy(order='F')[::-1],
+    i = nditer(a.reshape(2,3,2).copy(order='F')[::-1],
                                                     ['coords'],[['readonly']])
     assert_equal(iter_coords(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 = newiter(a.reshape(2,3,2).copy(order='F')[:,::-1],
+    i = nditer(a.reshape(2,3,2).copy(order='F')[:,::-1],
                                                     ['coords'],[['readonly']])
     assert_equal(iter_coords(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 = newiter(a.reshape(2,3,2).copy(order='F')[:,:,::-1],
+    i = nditer(a.reshape(2,3,2).copy(order='F')[:,:,::-1],
                                                     ['coords'],[['readonly']])
     assert_equal(iter_coords(i),
                             [(0,0,1),(1,0,1),(0,1,1),(1,1,1),(0,2,1),(1,2,1),
@@ -261,10 +261,10 @@ def test_iter_best_order_c_index_1d():
 
     a = arange(4)
     # 1D order
-    i = newiter(a,['c_index'],[['readonly']])
+    i = nditer(a,['c_index'],[['readonly']])
     assert_equal(iter_indices(i), [0,1,2,3])
     # 1D reversed order
-    i = newiter(a[::-1],['c_index'],[['readonly']])
+    i = nditer(a[::-1],['c_index'],[['readonly']])
     assert_equal(iter_indices(i), [3,2,1,0])
 
 def test_iter_best_order_c_index_2d():
@@ -272,27 +272,27 @@ def test_iter_best_order_c_index_2d():
 
     a = arange(6)
     # 2D C-order
-    i = newiter(a.reshape(2,3),['c_index'],[['readonly']])
+    i = nditer(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'),
+    i = nditer(a.reshape(2,3).copy(order='F'),
                                     ['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_index'],[['readonly']])
+    i = nditer(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_index'],[['readonly']])
+    i = nditer(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_index'],[['readonly']])
+    i = nditer(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],
+    i = nditer(a.reshape(2,3).copy(order='F')[::-1],
                                     ['c_index'],[['readonly']])
     assert_equal(iter_indices(i), [3,0,4,1,5,2])
-    i = newiter(a.reshape(2,3).copy(order='F')[:,::-1],
+    i = nditer(a.reshape(2,3).copy(order='F')[:,::-1],
                                     ['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],
+    i = nditer(a.reshape(2,3).copy(order='F')[::-1,::-1],
                                     ['c_index'],[['readonly']])
     assert_equal(iter_indices(i), [5,2,4,1,3,0])
 
@@ -301,34 +301,34 @@ def test_iter_best_order_c_index_3d():
 
     a = arange(12)
     # 3D C-order
-    i = newiter(a.reshape(2,3,2),['c_index'],[['readonly']])
+    i = nditer(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'),
+    i = nditer(a.reshape(2,3,2).copy(order='F'),
                                     ['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_index'],[['readonly']])
+    i = nditer(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_index'],[['readonly']])
+    i = nditer(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_index'],[['readonly']])
+    i = nditer(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],
+    i = nditer(a.reshape(2,3,2).copy(order='F')[::-1],
                                     ['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],
+    i = nditer(a.reshape(2,3,2).copy(order='F')[:,::-1],
                                     ['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],
+    i = nditer(a.reshape(2,3,2).copy(order='F')[:,:,::-1],
                                     ['c_index'],[['readonly']])
     assert_equal(iter_indices(i),
                             [1,7,3,9,5,11,0,6,2,8,4,10])
@@ -338,10 +338,10 @@ def test_iter_best_order_f_index_1d():
 
     a = arange(4)
     # 1D order
-    i = newiter(a,['f_index'],[['readonly']])
+    i = nditer(a,['f_index'],[['readonly']])
     assert_equal(iter_indices(i), [0,1,2,3])
     # 1D reversed order
-    i = newiter(a[::-1],['f_index'],[['readonly']])
+    i = nditer(a[::-1],['f_index'],[['readonly']])
     assert_equal(iter_indices(i), [3,2,1,0])
 
 def test_iter_best_order_f_index_2d():
@@ -349,27 +349,27 @@ def test_iter_best_order_f_index_2d():
 
     a = arange(6)
     # 2D C-order
-    i = newiter(a.reshape(2,3),['f_index'],[['readonly']])
+    i = nditer(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'),
+    i = nditer(a.reshape(2,3).copy(order='F'),
                                     ['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_index'],[['readonly']])
+    i = nditer(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_index'],[['readonly']])
+    i = nditer(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_index'],[['readonly']])
+    i = nditer(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],
+    i = nditer(a.reshape(2,3).copy(order='F')[::-1],
                                     ['f_index'],[['readonly']])
     assert_equal(iter_indices(i), [1,0,3,2,5,4])
-    i = newiter(a.reshape(2,3).copy(order='F')[:,::-1],
+    i = nditer(a.reshape(2,3).copy(order='F')[:,::-1],
                                     ['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],
+    i = nditer(a.reshape(2,3).copy(order='F')[::-1,::-1],
                                     ['f_index'],[['readonly']])
     assert_equal(iter_indices(i), [5,4,3,2,1,0])
 
@@ -378,34 +378,34 @@ def test_iter_best_order_f_index_3d():
 
     a = arange(12)
     # 3D C-order
-    i = newiter(a.reshape(2,3,2),['f_index'],[['readonly']])
+    i = nditer(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'),
+    i = nditer(a.reshape(2,3,2).copy(order='F'),
                                     ['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_index'],[['readonly']])
+    i = nditer(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_index'],[['readonly']])
+    i = nditer(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_index'],[['readonly']])
+    i = nditer(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],
+    i = nditer(a.reshape(2,3,2).copy(order='F')[::-1],
                                     ['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],
+    i = nditer(a.reshape(2,3,2).copy(order='F')[:,::-1],
                                     ['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],
+    i = nditer(a.reshape(2,3,2).copy(order='F')[:,:,::-1],
                                     ['f_index'],[['readonly']])
     assert_equal(iter_indices(i),
                             [6,7,8,9,10,11,0,1,2,3,4,5])
@@ -426,16 +426,16 @@ def test_iter_no_inner_full_coalesce():
 
             aview = a.reshape(shape)[dirs_index]
             # C-order
-            i = newiter(aview, ['no_inner_iteration'], [['readonly']])
+            i = nditer(aview, ['no_inner_iteration'], [['readonly']])
             assert_equal(i.ndim, 1)
             assert_equal(i[0].shape, (size,))
             # Fortran-order
-            i = newiter(aview.T, ['no_inner_iteration'], [['readonly']])
+            i = nditer(aview.T, ['no_inner_iteration'], [['readonly']])
             assert_equal(i.ndim, 1)
             assert_equal(i[0].shape, (size,))
             # Other order
             if len(shape) > 2:
-                i = newiter(aview.swapaxes(0,1),
+                i = nditer(aview.swapaxes(0,1),
                                     ['no_inner_iteration'], [['readonly']])
                 assert_equal(i.ndim, 1)
                 assert_equal(i[0].shape, (size,))
@@ -446,21 +446,21 @@ def test_iter_no_inner_dim_coalescing():
     # Skipping the last element in a dimension prevents coalescing
     # with the next-bigger dimension
     a = arange(24).reshape(2,3,4)[:,:,:-1]
-    i = newiter(a, ['no_inner_iteration'], [['readonly']])
+    i = nditer(a, ['no_inner_iteration'], [['readonly']])
     assert_equal(i.ndim, 2)
     assert_equal(i[0].shape, (3,))
     a = arange(24).reshape(2,3,4)[:,:-1,:]
-    i = newiter(a, ['no_inner_iteration'], [['readonly']])
+    i = nditer(a, ['no_inner_iteration'], [['readonly']])
     assert_equal(i.ndim, 2)
     assert_equal(i[0].shape, (8,))
     a = arange(24).reshape(2,3,4)[:-1,:,:]
-    i = newiter(a, ['no_inner_iteration'], [['readonly']])
+    i = nditer(a, ['no_inner_iteration'], [['readonly']])
     assert_equal(i.ndim, 1)
     assert_equal(i[0].shape, (12,))
     
     # Even with lots of 1-sized dimensions, should still coalesce
     a = arange(24).reshape(1,1,2,1,1,3,1,1,4,1,1)
-    i = newiter(a, ['no_inner_iteration'], [['readonly']])
+    i = nditer(a, ['no_inner_iteration'], [['readonly']])
     assert_equal(i.ndim, 1)
     assert_equal(i[0].shape, (24,))
 
@@ -469,103 +469,103 @@ def test_iter_dim_coalescing():
 
     # Tracking coordinates disables coalescing
     a = arange(24).reshape(2,3,4)
-    i = newiter(a, ['coords'], [['readonly']])
+    i = nditer(a, ['coords'], [['readonly']])
     assert_equal(i.ndim, 3)
 
     # A tracked index can allow coalescing if it's compatible with the array
     a3d = arange(24).reshape(2,3,4)
-    i = newiter(a3d, ['c_index'], [['readonly']])
+    i = nditer(a3d, ['c_index'], [['readonly']])
     assert_equal(i.ndim, 1)
-    i = newiter(a3d.swapaxes(0,1), ['c_index'], [['readonly']])
+    i = nditer(a3d.swapaxes(0,1), ['c_index'], [['readonly']])
     assert_equal(i.ndim, 3)
-    i = newiter(a3d.T, ['c_index'], [['readonly']])
+    i = nditer(a3d.T, ['c_index'], [['readonly']])
     assert_equal(i.ndim, 3)
-    i = newiter(a3d.T, ['f_index'], [['readonly']])
+    i = nditer(a3d.T, ['f_index'], [['readonly']])
     assert_equal(i.ndim, 1)
-    i = newiter(a3d.T.swapaxes(0,1), ['f_index'], [['readonly']])
+    i = nditer(a3d.T.swapaxes(0,1), ['f_index'], [['readonly']])
     assert_equal(i.ndim, 3)
 
     # When C or F order is forced, coalescing may still occur
     a3d = arange(24).reshape(2,3,4)
-    i = newiter(a3d, order='C')
+    i = nditer(a3d, order='C')
     assert_equal(i.ndim, 1)
-    i = newiter(a3d.T, order='C')
+    i = nditer(a3d.T, order='C')
     assert_equal(i.ndim, 3)
-    i = newiter(a3d, order='F')
+    i = nditer(a3d, order='F')
     assert_equal(i.ndim, 3)
-    i = newiter(a3d.T, order='F')
+    i = nditer(a3d.T, order='F')
     assert_equal(i.ndim, 1)
-    i = newiter(a3d, order='A')
+    i = nditer(a3d, order='A')
     assert_equal(i.ndim, 1)
-    i = newiter(a3d.T, order='A')
+    i = nditer(a3d.T, order='A')
     assert_equal(i.ndim, 1)
 
 def test_iter_broadcasting():
     # Standard NumPy broadcasting rules
 
     # 1D with scalar
-    i = newiter([arange(6), np.int32(2)], ['coords'], [['readonly']]*2)
+    i = nditer([arange(6), np.int32(2)], ['coords'], [['readonly']]*2)
     assert_equal(i.itersize, 6)
     assert_equal(i.shape, (6,))
 
     # 2D with scalar
-    i = newiter([arange(6).reshape(2,3), np.int32(2)],
+    i = nditer([arange(6).reshape(2,3), np.int32(2)],
                         ['coords'], [['readonly']]*2)
     assert_equal(i.itersize, 6)
     assert_equal(i.shape, (2,3))
     # 2D with 1D
-    i = newiter([arange(6).reshape(2,3), arange(3)],
+    i = nditer([arange(6).reshape(2,3), arange(3)],
                         ['coords'], [['readonly']]*2)
     assert_equal(i.itersize, 6)
     assert_equal(i.shape, (2,3))
-    i = newiter([arange(2).reshape(2,1), arange(3)],
+    i = nditer([arange(2).reshape(2,1), arange(3)],
                         ['coords'], [['readonly']]*2)
     assert_equal(i.itersize, 6)
     assert_equal(i.shape, (2,3))
     # 2D with 2D
-    i = newiter([arange(2).reshape(2,1), arange(3).reshape(1,3)],
+    i = nditer([arange(2).reshape(2,1), arange(3).reshape(1,3)],
                         ['coords'], [['readonly']]*2)
     assert_equal(i.itersize, 6)
     assert_equal(i.shape, (2,3))
 
     # 3D with scalar
-    i = newiter([np.int32(2), arange(24).reshape(4,2,3)],
+    i = nditer([np.int32(2), arange(24).reshape(4,2,3)],
                         ['coords'], [['readonly']]*2)
     assert_equal(i.itersize, 24)
     assert_equal(i.shape, (4,2,3))
     # 3D with 1D
-    i = newiter([arange(3), arange(24).reshape(4,2,3)],
+    i = nditer([arange(3), arange(24).reshape(4,2,3)],
                         ['coords'], [['readonly']]*2)
     assert_equal(i.itersize, 24)
     assert_equal(i.shape, (4,2,3))
-    i = newiter([arange(3), arange(8).reshape(4,2,1)],
+    i = nditer([arange(3), arange(8).reshape(4,2,1)],
                         ['coords'], [['readonly']]*2)
     assert_equal(i.itersize, 24)
     assert_equal(i.shape, (4,2,3))
     # 3D with 2D
-    i = newiter([arange(6).reshape(2,3), arange(24).reshape(4,2,3)],
+    i = nditer([arange(6).reshape(2,3), arange(24).reshape(4,2,3)],
                         ['coords'], [['readonly']]*2)
     assert_equal(i.itersize, 24)
     assert_equal(i.shape, (4,2,3))
-    i = newiter([arange(2).reshape(2,1), arange(24).reshape(4,2,3)],
+    i = nditer([arange(2).reshape(2,1), arange(24).reshape(4,2,3)],
                         ['coords'], [['readonly']]*2)
     assert_equal(i.itersize, 24)
     assert_equal(i.shape, (4,2,3))
-    i = newiter([arange(3).reshape(1,3), arange(8).reshape(4,2,1)],
+    i = nditer([arange(3).reshape(1,3), arange(8).reshape(4,2,1)],
                         ['coords'], [['readonly']]*2)
     assert_equal(i.itersize, 24)
     assert_equal(i.shape, (4,2,3))
     # 3D with 3D
-    i = newiter([arange(2).reshape(1,2,1), arange(3).reshape(1,1,3),
+    i = nditer([arange(2).reshape(1,2,1), arange(3).reshape(1,1,3),
                         arange(4).reshape(4,1,1)],
                         ['coords'], [['readonly']]*3)
     assert_equal(i.itersize, 24)
     assert_equal(i.shape, (4,2,3))
-    i = newiter([arange(6).reshape(1,2,3), arange(4).reshape(4,1,1)],
+    i = nditer([arange(6).reshape(1,2,3), arange(4).reshape(4,1,1)],
                         ['coords'], [['readonly']]*2)
     assert_equal(i.itersize, 24)
     assert_equal(i.shape, (4,2,3))
-    i = newiter([arange(24).reshape(4,2,3), arange(12).reshape(4,1,3)],
+    i = nditer([arange(24).reshape(4,2,3), arange(12).reshape(4,1,3)],
                         ['coords'], [['readonly']]*2)
     assert_equal(i.itersize, 24)
     assert_equal(i.shape, (4,2,3))
@@ -573,19 +573,19 @@ def test_iter_broadcasting():
 def test_iter_itershape():
     # Check that allocated outputs work with a specified shape
     a = np.arange(6, dtype='i2').reshape(2,3)
-    i = newiter([a, None], [], [['readonly'], ['writeonly','allocate']],
+    i = nditer([a, None], [], [['readonly'], ['writeonly','allocate']],
                             op_axes=[[0,1,None], None],
                             itershape=(-1,-1,4))
     assert_equal(i.operands[1].shape, (2,3,4))
     assert_equal(i.operands[1].strides, (24,8,2))
 
-    i = newiter([a.T, None], [], [['readonly'], ['writeonly','allocate']],
+    i = nditer([a.T, None], [], [['readonly'], ['writeonly','allocate']],
                             op_axes=[[0,1,None], None],
                             itershape=(-1,-1,4))
     assert_equal(i.operands[1].shape, (3,2,4))
     assert_equal(i.operands[1].strides, (8,24,2))
 
-    i = newiter([a.T, None], [], [['readonly'], ['writeonly','allocate']],
+    i = nditer([a.T, None], [], [['readonly'], ['writeonly','allocate']],
                             order='F',
                             op_axes=[[0,1,None], None],
                             itershape=(-1,-1,4))
@@ -594,7 +594,7 @@ def test_iter_itershape():
 
     # If we specify 1 in the itershape, it shouldn't allow broadcasting
     # of that dimension to a bigger value
-    assert_raises(ValueError, newiter, [a, None], [],
+    assert_raises(ValueError, nditer, [a, None], [],
                             [['readonly'], ['writeonly','allocate']],
                             op_axes=[[0,1,None], None],
                             itershape=(-1,1,4))
@@ -603,30 +603,30 @@ def test_iter_broadcasting_errors():
     # Check that errors are thrown for bad broadcasting shapes
 
     # 1D with 1D
-    assert_raises(ValueError, newiter, [arange(2), arange(3)],
+    assert_raises(ValueError, nditer, [arange(2), arange(3)],
                     [], [['readonly']]*2)
     # 2D with 1D
-    assert_raises(ValueError, newiter,
+    assert_raises(ValueError, nditer,
                     [arange(6).reshape(2,3), arange(2)],
                     [], [['readonly']]*2)
     # 2D with 2D
-    assert_raises(ValueError, newiter,
+    assert_raises(ValueError, nditer,
                     [arange(6).reshape(2,3), arange(9).reshape(3,3)],
                     [], [['readonly']]*2)
-    assert_raises(ValueError, newiter,
+    assert_raises(ValueError, nditer,
                     [arange(6).reshape(2,3), arange(4).reshape(2,2)],
                     [], [['readonly']]*2)
     # 3D with 3D
-    assert_raises(ValueError, newiter,
+    assert_raises(ValueError, nditer,
                     [arange(36).reshape(3,3,4), arange(24).reshape(2,3,4)],
                     [], [['readonly']]*2)
-    assert_raises(ValueError, newiter,
+    assert_raises(ValueError, nditer,
                     [arange(8).reshape(2,4,1), arange(24).reshape(2,3,4)],
                     [], [['readonly']]*2)
 
     # Verify that the error message mentions the right shapes
     try:
-        i = newiter([arange(2).reshape(1,2,1),
+        i = nditer([arange(2).reshape(1,2,1),
                      arange(3).reshape(1,3),
                      arange(6).reshape(2,3)],
                     [],
@@ -648,49 +648,49 @@ def test_iter_flags_errors():
     a = arange(6)
 
     # Not enough operands
-    assert_raises(ValueError, newiter, [], [], [])
+    assert_raises(ValueError, nditer, [], [], [])
     # Too many operands
-    assert_raises(ValueError, newiter, [a]*100, [], [['readonly']]*100)
+    assert_raises(ValueError, nditer, [a]*100, [], [['readonly']]*100)
     # Bad global flag
-    assert_raises(ValueError, newiter, [a], ['bad flag'], [['readonly']])
+    assert_raises(ValueError, nditer, [a], ['bad flag'], [['readonly']])
     # Bad op flag
-    assert_raises(ValueError, newiter, [a], [], [['readonly','bad flag']])
+    assert_raises(ValueError, nditer, [a], [], [['readonly','bad flag']])
     # Bad order parameter
-    assert_raises(ValueError, newiter, [a], [], [['readonly']], order='G')
+    assert_raises(ValueError, nditer, [a], [], [['readonly']], order='G')
     # Bad casting parameter
-    assert_raises(ValueError, newiter, [a], [], [['readonly']], casting='noon')
+    assert_raises(ValueError, nditer, [a], [], [['readonly']], casting='noon')
     # op_flags must match ops
-    assert_raises(ValueError, newiter, [a]*3, [], [['readonly']]*2)
+    assert_raises(ValueError, nditer, [a]*3, [], [['readonly']]*2)
     # Cannot track both a C and an F index
-    assert_raises(ValueError, newiter, a,
+    assert_raises(ValueError, nditer, a,
                 ['c_index','f_index'], [['readonly']])
     # Inner iteration and coords/indices are incompatible
-    assert_raises(ValueError, newiter, a,
+    assert_raises(ValueError, nditer, a,
                 ['no_inner_iteration','coords'], [['readonly']])
-    assert_raises(ValueError, newiter, a,
+    assert_raises(ValueError, nditer, a,
                 ['no_inner_iteration','c_index'], [['readonly']])
-    assert_raises(ValueError, newiter, a,
+    assert_raises(ValueError, nditer, a,
                 ['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']])
-    assert_raises(ValueError, newiter, a, [], [['readonly','readwrite']])
-    assert_raises(ValueError, newiter, a, [], [['writeonly','readwrite']])
-    assert_raises(ValueError, newiter, a,
+    assert_raises(ValueError, nditer, a, [], [[]])
+    assert_raises(ValueError, nditer, a, [], [['readonly','writeonly']])
+    assert_raises(ValueError, nditer, a, [], [['readonly','readwrite']])
+    assert_raises(ValueError, nditer, a, [], [['writeonly','readwrite']])
+    assert_raises(ValueError, nditer, a,
                 [], [['readonly','writeonly','readwrite']])
     # Python scalars are always readonly
-    assert_raises(TypeError, newiter, 1.5, [], [['writeonly']])
-    assert_raises(TypeError, newiter, 1.5, [], [['readwrite']])
+    assert_raises(TypeError, nditer, 1.5, [], [['writeonly']])
+    assert_raises(TypeError, nditer, 1.5, [], [['readwrite']])
     # Array scalars are always readonly
-    assert_raises(TypeError, newiter, np.int32(1), [], [['writeonly']])
-    assert_raises(TypeError, newiter, np.int32(1), [], [['readwrite']])
+    assert_raises(TypeError, nditer, np.int32(1), [], [['writeonly']])
+    assert_raises(TypeError, nditer, np.int32(1), [], [['readwrite']])
     # Check readonly array
     a.flags.writeable = False
-    assert_raises(ValueError, newiter, a, [], [['writeonly']])
-    assert_raises(ValueError, newiter, a, [], [['readwrite']])
+    assert_raises(ValueError, nditer, a, [], [['writeonly']])
+    assert_raises(ValueError, nditer, a, [], [['readwrite']])
     a.flags.writeable = True
     # Coords available only with the coords flag
-    i = newiter(arange(6), [], [['readonly']])
+    i = nditer(arange(6), [], [['readonly']])
     assert_raises(ValueError, lambda i:i.coords, i)
     # Index available only with an index flag
     assert_raises(ValueError, lambda i:i.index, i)
@@ -703,21 +703,21 @@ def test_iter_flags_errors():
         i.iterindex = 0;
     def assign_iterrange(i):
         i.iterrange = (0,1);
-    i = newiter(arange(6), ['no_inner_iteration'])
+    i = nditer(arange(6), ['no_inner_iteration'])
     assert_raises(ValueError, assign_coords, i)
     assert_raises(ValueError, assign_index, i)
     assert_raises(ValueError, assign_iterindex, i)
     assert_raises(ValueError, assign_iterrange, i)
-    i = newiter(arange(6), ['buffered'])
+    i = nditer(arange(6), ['buffered'])
     assert_raises(ValueError, assign_coords, i)
     assert_raises(ValueError, assign_index, i)
     assert_raises(ValueError, assign_iterrange, i)
     # Can't iterate if size is zero
-    assert_raises(ValueError, newiter, np.array([]))
+    assert_raises(ValueError, nditer, np.array([]))
 
 def test_iter_slice():
     a, b, c = np.arange(3), np.arange(3), np.arange(3.)
-    i = newiter([a,b,c], [], ['readwrite'])
+    i = nditer([a,b,c], [], ['readwrite'])
     i[0:2] = (3,3)
     assert_equal(a, [3,1,2])
     assert_equal(b, [3,1,2])
@@ -732,7 +732,7 @@ def test_iter_nbo_align_contig():
     a = np.arange(6, dtype='f4')
     au = a.byteswap().newbyteorder()
     assert_(a.dtype.byteorder != au.dtype.byteorder)
-    i = newiter(au, [], [['readwrite','updateifcopy']],
+    i = nditer(au, [], [['readwrite','updateifcopy']],
                         casting='equiv',
                         op_dtypes=[np.dtype('f4')])
     assert_equal(i.dtypes[0].byteorder, a.dtype.byteorder)
@@ -746,7 +746,7 @@ def test_iter_nbo_align_contig():
     a = np.arange(6, dtype='f4')
     au = a.byteswap().newbyteorder()
     assert_(a.dtype.byteorder != au.dtype.byteorder)
-    i = newiter(au, [], [['readwrite','updateifcopy','nbo']], casting='equiv')
+    i = nditer(au, [], [['readwrite','updateifcopy','nbo']], casting='equiv')
     assert_equal(i.dtypes[0].byteorder, a.dtype.byteorder)
     assert_equal(i.operands[0].dtype.byteorder, a.dtype.byteorder)
     assert_equal(i.operands[0], a)
@@ -760,11 +760,11 @@ def test_iter_nbo_align_contig():
     a[:] = np.arange(6, dtype='f4')
     assert_(not a.flags.aligned)
     # Without 'aligned', shouldn't copy
-    i = newiter(a, [], [['readonly']])
+    i = nditer(a, [], [['readonly']])
     assert_(not i.operands[0].flags.aligned)
     assert_equal(i.operands[0], a);
     # With 'aligned', should make a copy
-    i = newiter(a, [], [['readwrite','updateifcopy','aligned']])
+    i = nditer(a, [], [['readwrite','updateifcopy','aligned']])
     assert_(i.operands[0].flags.aligned)
     assert_equal(i.operands[0], a);
     i.operands[0][:] = 3
@@ -774,11 +774,11 @@ def test_iter_nbo_align_contig():
     # Discontiguous input
     a = arange(12)
     # If it is contiguous, shouldn't copy
-    i = newiter(a[:6], [], [['readonly']])
+    i = nditer(a[:6], [], [['readonly']])
     assert_(i.operands[0].flags.contiguous)
     assert_equal(i.operands[0], a[:6]);
     # If it isn't contiguous, should buffer
-    i = newiter(a[::2], ['buffered','no_inner_iteration'],
+    i = nditer(a[::2], ['buffered','no_inner_iteration'],
                         [['readonly','contig']],
                         buffersize=10)
     assert_(i[0].flags.contiguous)
@@ -789,13 +789,13 @@ def test_iter_array_cast():
 
     # No cast 'f4' -> 'f4'
     a = np.arange(6, dtype='f4').reshape(2,3)
-    i = newiter(a, [], [['readwrite']], op_dtypes=[np.dtype('f4')])
+    i = nditer(a, [], [['readwrite']], op_dtypes=[np.dtype('f4')])
     assert_equal(i.operands[0], a)
     assert_equal(i.operands[0].dtype, np.dtype('f4'))
 
     # Byte-order cast '<f4' -> '>f4'
     a = np.arange(6, dtype='<f4').reshape(2,3)
-    i = newiter(a, [], [['readwrite','updateifcopy']],
+    i = nditer(a, [], [['readwrite','updateifcopy']],
             casting='equiv',
             op_dtypes=[np.dtype('>f4')])
     assert_equal(i.operands[0], a)
@@ -803,7 +803,7 @@ def test_iter_array_cast():
 
     # Safe case 'f4' -> 'f8'
     a = np.arange(24, dtype='f4').reshape(2,3,4).swapaxes(1,2)
-    i = newiter(a, [], [['readonly','copy']],
+    i = nditer(a, [], [['readonly','copy']],
             casting='safe',
             op_dtypes=[np.dtype('f8')])
     assert_equal(i.operands[0], a)
@@ -811,7 +811,7 @@ def test_iter_array_cast():
     # The memory layout of the temporary should match a (a is (48,4,16))
     assert_equal(i.operands[0].strides, (96,8,32))
     a = a[::-1,:,::-1]
-    i = newiter(a, [], [['readonly','copy']],
+    i = nditer(a, [], [['readonly','copy']],
             casting='safe',
             op_dtypes=[np.dtype('f8')])
     assert_equal(i.operands[0], a)
@@ -820,7 +820,7 @@ def test_iter_array_cast():
 
     # Same-kind cast 'f8' -> 'f4' -> 'f8'
     a = np.arange(24, dtype='f8').reshape(2,3,4).T
-    i = newiter(a, [],
+    i = nditer(a, [],
             [['readwrite','updateifcopy']],
             casting='same_kind',
             op_dtypes=[np.dtype('f4')])
@@ -835,7 +835,7 @@ def test_iter_array_cast():
 
     # Unsafe cast 'f4' -> 'i4'
     a = np.arange(6, dtype='i4')[::-2]
-    i = newiter(a, [],
+    i = nditer(a, [],
             [['writeonly','updateifcopy']],
             casting='unsafe',
             op_dtypes=[np.dtype('f4')])
@@ -849,42 +849,42 @@ def test_iter_array_cast_errors():
     # Check that invalid casts are caught
 
     # Need to enable copying for casts to occur
-    assert_raises(TypeError, newiter, arange(2,dtype='f4'), [],
+    assert_raises(TypeError, nditer, arange(2,dtype='f4'), [],
                 [['readonly']], op_dtypes=[np.dtype('f8')])
     # Also need to allow casting for casts to occur
-    assert_raises(TypeError, newiter, arange(2,dtype='f4'), [],
+    assert_raises(TypeError, nditer, arange(2,dtype='f4'), [],
                 [['readonly','copy']], casting='no',
                 op_dtypes=[np.dtype('f8')])
-    assert_raises(TypeError, newiter, arange(2,dtype='f4'), [],
+    assert_raises(TypeError, nditer, arange(2,dtype='f4'), [],
                 [['readonly','copy']], casting='equiv',
                 op_dtypes=[np.dtype('f8')])
-    assert_raises(TypeError, newiter, arange(2,dtype='f8'), [],
+    assert_raises(TypeError, nditer, arange(2,dtype='f8'), [],
                 [['writeonly','updateifcopy']],
                 casting='no',
                 op_dtypes=[np.dtype('f4')])
-    assert_raises(TypeError, newiter, arange(2,dtype='f8'), [],
+    assert_raises(TypeError, nditer, arange(2,dtype='f8'), [],
                 [['writeonly','updateifcopy']],
                 casting='equiv',
                 op_dtypes=[np.dtype('f4')])
     # '<f4' -> '>f4' should not work with casting='no'
-    assert_raises(TypeError, newiter, arange(2,dtype='<f4'), [],
+    assert_raises(TypeError, nditer, arange(2,dtype='<f4'), [],
                 [['readonly','copy']], casting='no',
                 op_dtypes=[np.dtype('>f4')])
     # 'f4' -> 'f8' is a safe cast, but 'f8' -> 'f4' isn't
-    assert_raises(TypeError, newiter, arange(2,dtype='f4'), [],
+    assert_raises(TypeError, nditer, arange(2,dtype='f4'), [],
                 [['readwrite','updateifcopy']],
                 casting='safe',
                 op_dtypes=[np.dtype('f8')])
-    assert_raises(TypeError, newiter, arange(2,dtype='f8'), [],
+    assert_raises(TypeError, nditer, arange(2,dtype='f8'), [],
                 [['readwrite','updateifcopy']],
                 casting='safe',
                 op_dtypes=[np.dtype('f4')])
     # 'f4' -> 'i4' is neither a safe nor a same-kind cast
-    assert_raises(TypeError, newiter, arange(2,dtype='f4'), [],
+    assert_raises(TypeError, nditer, arange(2,dtype='f4'), [],
                 [['readonly','copy']],
                 casting='same_kind',
                 op_dtypes=[np.dtype('i4')])
-    assert_raises(TypeError, newiter, arange(2,dtype='i4'), [],
+    assert_raises(TypeError, nditer, arange(2,dtype='i4'), [],
                 [['writeonly','updateifcopy']],
                 casting='same_kind',
                 op_dtypes=[np.dtype('f4')])
@@ -893,13 +893,13 @@ def test_iter_scalar_cast():
     # Check that scalars are cast as requested
 
     # No cast 'f4' -> 'f4'
-    i = newiter(np.float32(2.5), [], [['readonly']],
+    i = nditer(np.float32(2.5), [], [['readonly']],
                     op_dtypes=[np.dtype('f4')])
     assert_equal(i.dtypes[0], np.dtype('f4'))
     assert_equal(i.value.dtype, np.dtype('f4'))
     assert_equal(i.value, 2.5)
     # Safe cast 'f4' -> 'f8'
-    i = newiter(np.float32(2.5), [],
+    i = nditer(np.float32(2.5), [],
                     [['readonly','copy']],
                     casting='safe',
                     op_dtypes=[np.dtype('f8')])
@@ -907,7 +907,7 @@ def test_iter_scalar_cast():
     assert_equal(i.value.dtype, np.dtype('f8'))
     assert_equal(i.value, 2.5)
     # Same-kind cast 'f8' -> 'f4'
-    i = newiter(np.float64(2.5), [],
+    i = nditer(np.float64(2.5), [],
                     [['readonly','copy']],
                     casting='same_kind',
                     op_dtypes=[np.dtype('f4')])
@@ -915,7 +915,7 @@ def test_iter_scalar_cast():
     assert_equal(i.value.dtype, np.dtype('f4'))
     assert_equal(i.value, 2.5)
     # Unsafe cast 'f8' -> 'i4'
-    i = newiter(np.float64(3.0), [],
+    i = nditer(np.float64(3.0), [],
                     [['readonly','copy']],
                     casting='unsafe',
                     op_dtypes=[np.dtype('i4')])
@@ -923,7 +923,7 @@ def test_iter_scalar_cast():
     assert_equal(i.value.dtype, np.dtype('i4'))
     assert_equal(i.value, 3)
     # Readonly scalars may be cast even without setting COPY or BUFFERED
-    i = newiter(3, [], [['readonly']], op_dtypes=[np.dtype('f8')])
+    i = nditer(3, [], [['readonly']], op_dtypes=[np.dtype('f8')])
     assert_equal(i[0].dtype, np.dtype('f8'))
     assert_equal(i[0], 3.)
 
@@ -931,17 +931,17 @@ def test_iter_scalar_cast_errors():
     # Check that invalid casts are caught
 
     # Need to allow copying/buffering for write casts of scalars to occur
-    assert_raises(TypeError, newiter, np.float32(2), [],
+    assert_raises(TypeError, nditer, np.float32(2), [],
                 [['readwrite']], op_dtypes=[np.dtype('f8')])
-    assert_raises(TypeError, newiter, 2.5, [],
+    assert_raises(TypeError, nditer, 2.5, [],
                 [['readwrite']], op_dtypes=[np.dtype('f4')])
     # 'f8' -> 'f4' isn't a safe cast if the value would overflow
-    assert_raises(TypeError, newiter, np.float64(1e60), [],
+    assert_raises(TypeError, nditer, np.float64(1e60), [],
                 [['readonly']],
                 casting='safe',
                 op_dtypes=[np.dtype('f4')])
     # 'f4' -> 'i4' is neither a safe nor a same-kind cast
-    assert_raises(TypeError, newiter, np.float32(2), [],
+    assert_raises(TypeError, nditer, np.float32(2), [],
                 [['readonly']],
                 casting='same_kind',
                 op_dtypes=[np.dtype('i4')])
@@ -954,16 +954,16 @@ def test_iter_object_arrays_basic():
     rc = sys.getrefcount(obj)
 
     # Need to allow references for object arrays
-    assert_raises(TypeError, newiter, a)
+    assert_raises(TypeError, nditer, a)
     assert_equal(sys.getrefcount(obj), rc)
 
-    i = newiter(a, ['refs_ok'], ['readonly'])
+    i = nditer(a, ['refs_ok'], ['readonly'])
     vals = [x[()] for x in i]
     assert_equal(np.array(vals, dtype='O'), a)
     vals, i, x = [None]*3
     assert_equal(sys.getrefcount(obj), rc)
 
-    i = newiter(a.reshape(2,2).T, ['refs_ok','buffered'],
+    i = nditer(a.reshape(2,2).T, ['refs_ok','buffered'],
                         ['readonly'], order='C')
     assert_(i.iterationneedsapi)
     vals = [x[()] for x in i]
@@ -971,7 +971,7 @@ def test_iter_object_arrays_basic():
     vals, i, x = [None]*3
     assert_equal(sys.getrefcount(obj), rc)
 
-    i = newiter(a.reshape(2,2).T, ['refs_ok','buffered'],
+    i = nditer(a.reshape(2,2).T, ['refs_ok','buffered'],
                         ['readwrite'], order='C')
     for x in i:
         x[...] = None
@@ -982,14 +982,14 @@ def test_iter_object_arrays_basic():
 def test_iter_object_arrays_conversions():
     # Conversions to/from objects
     a = np.arange(6, dtype='O')
-    i = newiter(a, ['refs_ok','buffered'], ['readwrite'],
+    i = nditer(a, ['refs_ok','buffered'], ['readwrite'],
                     casting='unsafe', op_dtypes='i4')
     for x in i:
         x[...] += 1
     assert_equal(a, np.arange(6)+1)
 
     a = np.arange(6, dtype='i4')
-    i = newiter(a, ['refs_ok','buffered'], ['readwrite'],
+    i = nditer(a, ['refs_ok','buffered'], ['readwrite'],
                     casting='unsafe', op_dtypes='O')
     for x in i:
         x[...] += 1
@@ -999,7 +999,7 @@ def test_iter_object_arrays_conversions():
     a = np.zeros((6,), dtype=[('p','i1'),('a','O')])
     a = a['a']
     a[:] = np.arange(6)
-    i = newiter(a, ['refs_ok','buffered'], ['readwrite'],
+    i = nditer(a, ['refs_ok','buffered'], ['readwrite'],
                     casting='unsafe', op_dtypes='i4')
     for x in i:
         x[...] += 1
@@ -1009,7 +1009,7 @@ def test_iter_object_arrays_conversions():
     a = np.zeros((6,), dtype=[('p','i1'),('a','i4')])
     a = a['a']
     a[:] = np.arange(6) + 98172488
-    i = newiter(a, ['refs_ok','buffered'], ['readwrite'],
+    i = nditer(a, ['refs_ok','buffered'], ['readwrite'],
                     casting='unsafe', op_dtypes='O')
     ob = i[0][()]
     rc = sys.getrefcount(ob)
@@ -1021,37 +1021,37 @@ def test_iter_object_arrays_conversions():
 def test_iter_common_dtype():
     # Check that the iterator finds a common data type correctly
 
-    i = newiter([array([3],dtype='f4'),array([0],dtype='f8')],
+    i = nditer([array([3],dtype='f4'),array([0],dtype='f8')],
                     ['common_dtype'],
                     [['readonly','copy']]*2,
                     casting='safe')
     assert_equal(i.dtypes[0], np.dtype('f8'));
     assert_equal(i.dtypes[1], np.dtype('f8'));
-    i = newiter([array([3],dtype='i4'),array([0],dtype='f4')],
+    i = nditer([array([3],dtype='i4'),array([0],dtype='f4')],
                     ['common_dtype'],
                     [['readonly','copy']]*2,
                     casting='safe')
     assert_equal(i.dtypes[0], np.dtype('f8'));
     assert_equal(i.dtypes[1], np.dtype('f8'));
-    i = newiter([array([3],dtype='f4'),array(0,dtype='f8')],
+    i = nditer([array([3],dtype='f4'),array(0,dtype='f8')],
                     ['common_dtype'],
                     [['readonly','copy']]*2,
                     casting='same_kind')
     assert_equal(i.dtypes[0], np.dtype('f4'));
     assert_equal(i.dtypes[1], np.dtype('f4'));
-    i = newiter([array([3],dtype='u4'),array(0,dtype='i4')],
+    i = nditer([array([3],dtype='u4'),array(0,dtype='i4')],
                     ['common_dtype'],
                     [['readonly','copy']]*2,
                     casting='safe')
     assert_equal(i.dtypes[0], np.dtype('u4'));
     assert_equal(i.dtypes[1], np.dtype('u4'));
-    i = newiter([array([3],dtype='u4'),array(-12,dtype='i4')],
+    i = nditer([array([3],dtype='u4'),array(-12,dtype='i4')],
                     ['common_dtype'],
                     [['readonly','copy']]*2,
                     casting='safe')
     assert_equal(i.dtypes[0], np.dtype('i8'));
     assert_equal(i.dtypes[1], np.dtype('i8'));
-    i = newiter([array([3],dtype='u4'),array(-12,dtype='i4'),
+    i = nditer([array([3],dtype='u4'),array(-12,dtype='i4'),
                  array([2j],dtype='c8'),array([9],dtype='f8')],
                     ['common_dtype'],
                     [['readonly','copy']]*4,
@@ -1063,7 +1063,7 @@ def test_iter_common_dtype():
     assert_equal(i.value, (3,-12,2j,9))
 
     # When allocating outputs, other outputs aren't factored in
-    i = newiter([array([3],dtype='i4'),None,array([2j],dtype='c16')], [],
+    i = nditer([array([3],dtype='i4'),None,array([2j],dtype='c16')], [],
                     [['readonly','copy'],
                      ['writeonly','allocate'],
                      ['writeonly']],
@@ -1072,7 +1072,7 @@ def test_iter_common_dtype():
     assert_equal(i.dtypes[1], np.dtype('i4'));
     assert_equal(i.dtypes[2], np.dtype('c16'));
     # But, if common data types are requested, they are
-    i = newiter([array([3],dtype='i4'),None,array([2j],dtype='c16')],
+    i = nditer([array([3],dtype='i4'),None,array([2j],dtype='c16')],
                     ['common_dtype'],
                     [['readonly','copy'],
                      ['writeonly','allocate'],
@@ -1087,36 +1087,36 @@ def test_iter_op_axes():
 
     # Reverse the axes
     a = arange(6).reshape(2,3)
-    i = newiter([a,a.T], [], [['readonly']]*2, op_axes=[[0,1],[1,0]])
+    i = nditer([a,a.T], [], [['readonly']]*2, op_axes=[[0,1],[1,0]])
     assert_(all([x==y for (x,y) in i]))
     a = arange(24).reshape(2,3,4)
-    i = newiter([a.T,a], [], [['readonly']]*2, op_axes=[[2,1,0],None])
+    i = nditer([a.T,a], [], [['readonly']]*2, op_axes=[[2,1,0],None])
     assert_(all([x==y for (x,y) in i]))
 
     # Broadcast 1D to any dimension
     a = arange(1,31).reshape(2,3,5)
     b = arange(1,3)
-    i = newiter([a,b], [], [['readonly']]*2, op_axes=[None,[0,-1,-1]])
+    i = nditer([a,b], [], [['readonly']]*2, op_axes=[None,[0,-1,-1]])
     assert_equal([x*y for (x,y) in i], (a*b.reshape(2,1,1)).ravel())
     b = arange(1,4)
-    i = newiter([a,b], [], [['readonly']]*2, op_axes=[None,[-1,0,-1]])
+    i = nditer([a,b], [], [['readonly']]*2, op_axes=[None,[-1,0,-1]])
     assert_equal([x*y for (x,y) in i], (a*b.reshape(1,3,1)).ravel())
     b = arange(1,6)
-    i = newiter([a,b], [], [['readonly']]*2,
+    i = nditer([a,b], [], [['readonly']]*2,
                             op_axes=[None,[np.newaxis,np.newaxis,0]])
     assert_equal([x*y for (x,y) in i], (a*b.reshape(1,1,5)).ravel())
 
     # Inner product-style broadcasting
     a = arange(24).reshape(2,3,4)
     b = arange(40).reshape(5,2,4)
-    i = newiter([a,b], ['coords'], [['readonly']]*2,
+    i = nditer([a,b], ['coords'], [['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 = newiter([a,b], ['coords'], [['readonly']]*2,
+    i = nditer([a,b], ['coords'], [['readonly']]*2,
                             op_axes=[[0,-1],[-1,1]])
     assert_equal(i.shape, (3,5))
 
@@ -1125,25 +1125,25 @@ def test_iter_op_axes_errors():
 
     # Wrong number of items in op_axes
     a = arange(6).reshape(2,3)
-    assert_raises(ValueError, newiter, [a,a], [], [['readonly']]*2,
+    assert_raises(ValueError, nditer, [a,a], [], [['readonly']]*2,
                                     op_axes=[[0],[1],[0]])
     # Out of bounds items in op_axes
-    assert_raises(ValueError, newiter, [a,a], [], [['readonly']]*2,
+    assert_raises(ValueError, nditer, [a,a], [], [['readonly']]*2,
                                     op_axes=[[2,1],[0,1]])
-    assert_raises(ValueError, newiter, [a,a], [], [['readonly']]*2,
+    assert_raises(ValueError, nditer, [a,a], [], [['readonly']]*2,
                                     op_axes=[[0,1],[2,-1]])
     # Duplicate items in op_axes
-    assert_raises(ValueError, newiter, [a,a], [], [['readonly']]*2,
+    assert_raises(ValueError, nditer, [a,a], [], [['readonly']]*2,
                                     op_axes=[[0,0],[0,1]])
-    assert_raises(ValueError, newiter, [a,a], [], [['readonly']]*2,
+    assert_raises(ValueError, nditer, [a,a], [], [['readonly']]*2,
                                     op_axes=[[0,1],[1,1]])
 
     # Different sized arrays in op_axes
-    assert_raises(ValueError, newiter, [a,a], [], [['readonly']]*2,
+    assert_raises(ValueError, nditer, [a,a], [], [['readonly']]*2,
                                     op_axes=[[0,1],[0,1,0]])
 
     # Non-broadcastable dimensions in the result
-    assert_raises(ValueError, newiter, [a,a], [], [['readonly']]*2,
+    assert_raises(ValueError, nditer, [a,a], [], [['readonly']]*2,
                                     op_axes=[[0,1],[1,0]])
 
 def test_iter_copy():
@@ -1151,7 +1151,7 @@ def test_iter_copy():
     a = arange(24).reshape(2,3,4)
 
     # Simple iterator
-    i = newiter(a)
+    i = nditer(a)
     j = i.copy()
     assert_equal([x[()] for x in i], [x[()] for x in j])
 
@@ -1160,7 +1160,7 @@ def test_iter_copy():
     assert_equal([x[()] for x in i], [x[()] for x in j])
 
     # Buffered iterator
-    i = newiter(a, ['buffered','ranged'], order='F', buffersize=3)
+    i = nditer(a, ['buffered','ranged'], order='F', buffersize=3)
     j = i.copy()
     assert_equal([x[()] for x in i], [x[()] for x in j])
 
@@ -1178,14 +1178,14 @@ def test_iter_copy():
     assert_equal([x[()] for x in i], [x[()] for x in j])
 
     # Casting iterator
-    i = newiter(a, ['buffered'], order='F', casting='unsafe',
+    i = nditer(a, ['buffered'], order='F', casting='unsafe',
                 op_dtypes='f8', buffersize=5)
     j = i.copy()
     i = None
     assert_equal([x[()] for x in j], a.ravel(order='F'))
 
     a = arange(24, dtype='<i4').reshape(2,3,4)
-    i = newiter(a, ['buffered'], order='F', casting='unsafe',
+    i = nditer(a, ['buffered'], order='F', casting='unsafe',
                 op_dtypes='>f8', buffersize=5)
     j = i.copy()
     i = None
@@ -1196,7 +1196,7 @@ def test_iter_allocate_output_simple():
 
     # Simple case
     a = arange(6)
-    i = newiter([a,None], [], [['readonly'],['writeonly','allocate']],
+    i = nditer([a,None], [], [['readonly'],['writeonly','allocate']],
                         op_dtypes=[None,np.dtype('f4')])
     assert_equal(i.operands[1].shape, a.shape)
     assert_equal(i.operands[1].dtype, np.dtype('f4'))
@@ -1205,7 +1205,7 @@ def test_iter_allocate_output_buffered_readwrite():
     # Allocated output with buffering + delay_bufalloc
 
     a = arange(6)
-    i = newiter([a,None], ['buffered','delay_bufalloc'],
+    i = nditer([a,None], ['buffered','delay_bufalloc'],
                         [['readonly'],['allocate','readwrite']])
     i.operands[1][:] = 1
     i.reset()
@@ -1218,21 +1218,21 @@ def test_iter_allocate_output_itorder():
 
     # C-order input, best iteration order
     a = arange(6, dtype='i4').reshape(2,3)
-    i = newiter([a,None], [], [['readonly'],['writeonly','allocate']],
+    i = nditer([a,None], [], [['readonly'],['writeonly','allocate']],
                         op_dtypes=[None,np.dtype('f4')])
     assert_equal(i.operands[1].shape, a.shape)
     assert_equal(i.operands[1].strides, a.strides)
     assert_equal(i.operands[1].dtype, np.dtype('f4'))
     # F-order input, best iteration order
     a = arange(24, dtype='i4').reshape(2,3,4).T
-    i = newiter([a,None], [], [['readonly'],['writeonly','allocate']],
+    i = nditer([a,None], [], [['readonly'],['writeonly','allocate']],
                         op_dtypes=[None,np.dtype('f4')])
     assert_equal(i.operands[1].shape, a.shape)
     assert_equal(i.operands[1].strides, a.strides)
     assert_equal(i.operands[1].dtype, np.dtype('f4'))
     # Non-contiguous input, C iteration order
     a = arange(24, dtype='i4').reshape(2,3,4).swapaxes(0,1)
-    i = newiter([a,None], [],
+    i = nditer([a,None], [],
                         [['readonly'],['writeonly','allocate']],
                         order='C',
                         op_dtypes=[None,np.dtype('f4')])
@@ -1244,7 +1244,7 @@ def test_iter_allocate_output_opaxes():
     # Specifing op_axes should work
 
     a = arange(24, dtype='i4').reshape(2,3,4)
-    i = newiter([None,a], [], [['writeonly','allocate'],['readonly']],
+    i = nditer([None,a], [], [['writeonly','allocate'],['readonly']],
                         op_dtypes=[np.dtype('u4'),None],
                         op_axes=[[1,2,0],None]);
     assert_equal(i.operands[0].shape, (4,2,3))
@@ -1254,19 +1254,19 @@ def test_iter_allocate_output_opaxes():
 def test_iter_allocate_output_types_promotion():
     # Check type promotion of automatic outputs
 
-    i = newiter([array([3],dtype='f4'),array([0],dtype='f8'),None], [],
+    i = nditer([array([3],dtype='f4'),array([0],dtype='f8'),None], [],
                     [['readonly']]*2+[['writeonly','allocate']])
     assert_equal(i.dtypes[2], np.dtype('f8'));
-    i = newiter([array([3],dtype='i4'),array([0],dtype='f4'),None], [],
+    i = nditer([array([3],dtype='i4'),array([0],dtype='f4'),None], [],
                     [['readonly']]*2+[['writeonly','allocate']])
     assert_equal(i.dtypes[2], np.dtype('f8'));
-    i = newiter([array([3],dtype='f4'),array(0,dtype='f8'),None], [],
+    i = nditer([array([3],dtype='f4'),array(0,dtype='f8'),None], [],
                     [['readonly']]*2+[['writeonly','allocate']])
     assert_equal(i.dtypes[2], np.dtype('f4'));
-    i = newiter([array([3],dtype='u4'),array(0,dtype='i4'),None], [],
+    i = nditer([array([3],dtype='u4'),array(0,dtype='i4'),None], [],
                     [['readonly']]*2+[['writeonly','allocate']])
     assert_equal(i.dtypes[2], np.dtype('u4'));
-    i = newiter([array([3],dtype='u4'),array(-12,dtype='i4'),None], [],
+    i = nditer([array([3],dtype='u4'),array(-12,dtype='i4'),None], [],
                     [['readonly']]*2+[['writeonly','allocate']])
     assert_equal(i.dtypes[2], np.dtype('i8'));
 
@@ -1275,11 +1275,11 @@ def test_iter_allocate_output_types_byte_order():
 
     # When there's just one input, the output type exactly matches
     a = array([3],dtype='u4').newbyteorder()
-    i = newiter([a,None], [],
+    i = nditer([a,None], [],
                     [['readonly'],['writeonly','allocate']])
     assert_equal(i.dtypes[0], i.dtypes[1]);
     # With two or more inputs, the output type is in native byte order
-    i = newiter([a,a,None], [],
+    i = nditer([a,a,None], [],
                     [['readonly'],['readonly'],['writeonly','allocate']])
     assert_(i.dtypes[0] != i.dtypes[2]);
     assert_equal(i.dtypes[0].newbyteorder('='), i.dtypes[2])
@@ -1287,7 +1287,7 @@ def test_iter_allocate_output_types_byte_order():
 def test_iter_allocate_output_types_scalar():
     # If the inputs are all scalars, the output should be a scalar
 
-    i = newiter([None,1,2.3,np.float32(12),np.complex128(3)],[],
+    i = nditer([None,1,2.3,np.float32(12),np.complex128(3)],[],
                 [['writeonly','allocate']] + [['readonly']]*4)
     assert_equal(i.operands[0].dtype, np.dtype('complex128'))
     assert_equal(i.operands[0].ndim, 0)
@@ -1298,7 +1298,7 @@ def test_iter_allocate_output_subtype():
     # matrix vs ndarray
     a = np.matrix([[1,2], [3,4]])
     b = np.arange(4).reshape(2,2).T
-    i = newiter([a,b,None], [],
+    i = nditer([a,b,None], [],
                     [['readonly'],['readonly'],['writeonly','allocate']])
     assert_equal(type(a), type(i.operands[2]))
     assert_(type(b) != type(i.operands[2]))
@@ -1306,10 +1306,10 @@ def test_iter_allocate_output_subtype():
 
     # matrix always wants things to be 2D
     b = np.arange(4).reshape(1,2,2)
-    assert_raises(RuntimeError, newiter, [a,b,None], [],
+    assert_raises(RuntimeError, nditer, [a,b,None], [],
                     [['readonly'],['readonly'],['writeonly','allocate']])
     # but if subtypes are disabled, the result can still work
-    i = newiter([a,b,None], [],
+    i = nditer([a,b,None], [],
             [['readonly'],['readonly'],['writeonly','allocate','no_subtype']])
     assert_equal(type(b), type(i.operands[2]))
     assert_(type(a) != type(i.operands[2]))
@@ -1320,32 +1320,32 @@ def test_iter_allocate_output_errors():
 
     # Need an input if no output data type is specified
     a = arange(6)
-    assert_raises(TypeError, newiter, [a,None], [],
+    assert_raises(TypeError, nditer, [a,None], [],
                         [['writeonly'],['writeonly','allocate']])
     # Allocated output should be flagged for writing
-    assert_raises(ValueError, newiter, [a,None], [],
+    assert_raises(ValueError, nditer, [a,None], [],
                         [['readonly'],['allocate','readonly']])
     # Allocated output can't have buffering without delayed bufalloc
-    assert_raises(ValueError, newiter, [a,None], ['buffered'],
+    assert_raises(ValueError, nditer, [a,None], ['buffered'],
                                             ['allocate','readwrite'])
     # Must specify at least one input
-    assert_raises(ValueError, newiter, [None,None], [],
+    assert_raises(ValueError, nditer, [None,None], [],
                         [['writeonly','allocate'],
                          ['writeonly','allocate']],
                         op_dtypes=[np.dtype('f4'),np.dtype('f4')])
     # If using op_axes, must specify all the axes
     a = arange(24, dtype='i4').reshape(2,3,4)
-    assert_raises(ValueError, newiter, [a,None], [],
+    assert_raises(ValueError, nditer, [a,None], [],
                         [['readonly'],['writeonly','allocate']],
                         op_dtypes=[None,np.dtype('f4')],
                         op_axes=[None,[0,np.newaxis,1]])
     # If using op_axes, the axes must be within bounds
-    assert_raises(ValueError, newiter, [a,None], [],
+    assert_raises(ValueError, nditer, [a,None], [],
                         [['readonly'],['writeonly','allocate']],
                         op_dtypes=[None,np.dtype('f4')],
                         op_axes=[None,[0,3,1]])
     # If using op_axes, there can't be duplicates
-    assert_raises(ValueError, newiter, [a,None], [],
+    assert_raises(ValueError, nditer, [a,None], [],
                         [['readonly'],['writeonly','allocate']],
                         op_dtypes=[None,np.dtype('f4')],
                         op_axes=[None,[0,2,1,0]])
@@ -1353,12 +1353,12 @@ def test_iter_allocate_output_errors():
 def test_iter_remove_axis():
     a = arange(24).reshape(2,3,4)
 
-    i = newiter(a,['coords'])
+    i = nditer(a,['coords'])
     i.remove_axis(1)
     assert_equal([x for x in i], a[:,0,:].ravel())
 
     a = a[::-1,:,:]
-    i = newiter(a,['coords'])
+    i = nditer(a,['coords'])
     i.remove_axis(0)
     assert_equal([x for x in i], a[0,:,:].ravel())
 
@@ -1367,7 +1367,7 @@ def test_iter_remove_coords_inner_loop():
 
     a = arange(24).reshape(2,3,4)
 
-    i = newiter(a,['coords'])
+    i = nditer(a,['coords'])
     assert_equal(i.ndim, 3)
     assert_equal(i.shape, (2,3,4))
     assert_equal(i.itviews[0].shape, (2,3,4))
@@ -1397,27 +1397,27 @@ def test_iter_iterindex():
     buffersize = 5
     a = arange(24).reshape(4,3,2)
     for flags in ([], ['buffered']):
-        i = newiter(a, flags, buffersize=buffersize)
+        i = nditer(a, flags, buffersize=buffersize)
         assert_equal(iter_iterindices(i), range(24))
         i.iterindex = 2
         assert_equal(iter_iterindices(i), range(2,24))
 
-        i = newiter(a, flags, order='F', buffersize=buffersize)
+        i = nditer(a, flags, order='F', buffersize=buffersize)
         assert_equal(iter_iterindices(i), range(24))
         i.iterindex = 5
         assert_equal(iter_iterindices(i), range(5,24))
 
-        i = newiter(a[::-1], flags, order='F', buffersize=buffersize)
+        i = nditer(a[::-1], flags, order='F', buffersize=buffersize)
         assert_equal(iter_iterindices(i), range(24))
         i.iterindex = 9
         assert_equal(iter_iterindices(i), range(9,24))
 
-        i = newiter(a[::-1,::-1], flags, order='C', buffersize=buffersize)
+        i = nditer(a[::-1,::-1], flags, order='C', buffersize=buffersize)
         assert_equal(iter_iterindices(i), range(24))
         i.iterindex = 13
         assert_equal(iter_iterindices(i), range(13,24))
 
-        i = newiter(a[::1,::-1], flags, buffersize=buffersize)
+        i = nditer(a[::1,::-1], flags, buffersize=buffersize)
         assert_equal(iter_iterindices(i), range(24))
         i.iterindex = 23
         assert_equal(iter_iterindices(i), range(23,24))
@@ -1432,7 +1432,7 @@ def test_iter_iterrange():
     a = arange(24, dtype='i4').reshape(4,3,2)
     a_fort = a.ravel(order='F')
 
-    i = newiter(a, ['ranged'], ['readonly'], order='F',
+    i = nditer(a, ['ranged'], ['readonly'], order='F',
                 buffersize=buffersize)
     assert_equal(i.iterrange, (0,24))
     assert_equal([x[()] for x in i], a_fort)
@@ -1441,7 +1441,7 @@ def test_iter_iterrange():
         assert_equal(i.iterrange, r)
         assert_equal([x[()] for x in i], a_fort[r[0]:r[1]])
 
-    i = newiter(a, ['ranged','buffered'], ['readonly'], order='F',
+    i = nditer(a, ['ranged','buffered'], ['readonly'], order='F',
                 op_dtypes='f8', buffersize=buffersize)
     assert_equal(i.iterrange, (0,24))
     assert_equal([x[()] for x in i], a_fort)
@@ -1456,7 +1456,7 @@ def test_iter_iterrange():
             val = np.concatenate((val, x))
         return val
 
-    i = newiter(a, ['ranged','buffered','no_inner_iteration'],
+    i = nditer(a, ['ranged','buffered','no_inner_iteration'],
                 ['readonly'], order='F',
                 op_dtypes='f8', buffersize=buffersize)
     assert_equal(i.iterrange, (0,24))
@@ -1484,7 +1484,7 @@ def test_iter_buffering():
     for a in arrays:
         for buffersize in (1,2,3,5,8,11,16,1024):
             vals = []
-            i = newiter(a, ['buffered','no_inner_iteration'],
+            i = nditer(a, ['buffered','no_inner_iteration'],
                            [['readonly','nbo','aligned']],
                            order='C',
                            casting='equiv',
@@ -1500,7 +1500,7 @@ def test_iter_write_buffering():
 
     # F-order swapped array
     a = np.arange(24).reshape(2,3,4).T.newbyteorder().byteswap()
-    i = newiter(a, ['buffered'],
+    i = nditer(a, ['buffered'],
                    [['readwrite','nbo','aligned']],
                    casting='equiv',
                    order='C',
@@ -1517,7 +1517,7 @@ def test_iter_buffering_delayed_alloc():
 
     a = np.arange(6)
     b = np.arange(1, dtype='f4')
-    i = newiter([a,b], ['buffered','delay_bufalloc','coords','reduce_ok'],
+    i = nditer([a,b], ['buffered','delay_bufalloc','coords','reduce_ok'],
                     ['readwrite'],
                     casting='unsafe',
                     op_dtypes='f4')
@@ -1541,7 +1541,7 @@ def test_iter_buffered_cast_simple():
     # Test that buffering can handle a simple cast
 
     a = np.arange(10, dtype='f4')
-    i = newiter(a, ['buffered','no_inner_iteration'],
+    i = nditer(a, ['buffered','no_inner_iteration'],
                    [['readwrite','nbo','aligned']],
                    casting='same_kind',
                    op_dtypes=[np.dtype('f8')],
@@ -1555,7 +1555,7 @@ def test_iter_buffered_cast_byteswapped():
     # Test that buffering can handle a cast which requires swap->cast->swap
 
     a = np.arange(10, dtype='f4').newbyteorder().byteswap()
-    i = newiter(a, ['buffered','no_inner_iteration'],
+    i = nditer(a, ['buffered','no_inner_iteration'],
                    [['readwrite','nbo','aligned']],
                    casting='same_kind',
                    op_dtypes=[np.dtype('f8').newbyteorder()],
@@ -1569,7 +1569,7 @@ def test_iter_buffered_cast_byteswapped():
         warnings.simplefilter("ignore", np.ComplexWarning)
 
         a = np.arange(10, dtype='f8').newbyteorder().byteswap()
-        i = newiter(a, ['buffered','no_inner_iteration'],
+        i = nditer(a, ['buffered','no_inner_iteration'],
                        [['readwrite','nbo','aligned']],
                        casting='unsafe',
                        op_dtypes=[np.dtype('c8').newbyteorder()],
@@ -1586,7 +1586,7 @@ def test_iter_buffered_cast_byteswapped_complex():
 
     a = np.arange(10, dtype='c8').newbyteorder().byteswap()
     a += 2j
-    i = newiter(a, ['buffered','no_inner_iteration'],
+    i = nditer(a, ['buffered','no_inner_iteration'],
                    [['readwrite','nbo','aligned']],
                    casting='same_kind',
                    op_dtypes=[np.dtype('c16')],
@@ -1597,7 +1597,7 @@ def test_iter_buffered_cast_byteswapped_complex():
 
     a = np.arange(10, dtype='c8')
     a += 2j
-    i = newiter(a, ['buffered','no_inner_iteration'],
+    i = nditer(a, ['buffered','no_inner_iteration'],
                    [['readwrite','nbo','aligned']],
                    casting='same_kind',
                    op_dtypes=[np.dtype('c16').newbyteorder()],
@@ -1608,7 +1608,7 @@ def test_iter_buffered_cast_byteswapped_complex():
 
     a = np.arange(10, dtype=np.clongdouble).newbyteorder().byteswap()
     a += 2j
-    i = newiter(a, ['buffered','no_inner_iteration'],
+    i = nditer(a, ['buffered','no_inner_iteration'],
                    [['readwrite','nbo','aligned']],
                    casting='same_kind',
                    op_dtypes=[np.dtype('c16')],
@@ -1618,7 +1618,7 @@ def test_iter_buffered_cast_byteswapped_complex():
     assert_equal(a, 2*np.arange(10, dtype=np.clongdouble) + 4j)
 
     a = np.arange(10, dtype=np.longdouble).newbyteorder().byteswap()
-    i = newiter(a, ['buffered','no_inner_iteration'],
+    i = nditer(a, ['buffered','no_inner_iteration'],
                    [['readwrite','nbo','aligned']],
                    casting='same_kind',
                    op_dtypes=[np.dtype('f4')],
@@ -1633,7 +1633,7 @@ def test_iter_buffered_cast_structured_type():
     # simple -> struct type (duplicates the value)
     sdt = [('a', 'f4'), ('b', 'i8'), ('c', 'c8', (2,3)), ('d', 'O')]
     a = np.arange(3, dtype='f4') + 0.5
-    i = newiter(a, ['buffered','refs_ok'], ['readonly'],
+    i = nditer(a, ['buffered','refs_ok'], ['readonly'],
                     casting='unsafe',
                     op_dtypes=sdt)
     vals = [np.array(x) for x in i]
@@ -1651,7 +1651,7 @@ def test_iter_buffered_cast_structured_type():
     sdt = [('a', 'f4'), ('b', 'i8'), ('c', 'c8', (2,3)), ('d', 'O')]
     a = np.arange(3, dtype='O') + 0.5
     rc = sys.getrefcount(a[0])
-    i = newiter(a, ['buffered','refs_ok'], ['readonly'],
+    i = nditer(a, ['buffered','refs_ok'], ['readonly'],
                     casting='unsafe',
                     op_dtypes=sdt)
     vals = [np.array(x) for x in i]
@@ -1670,7 +1670,7 @@ def test_iter_buffered_cast_structured_type():
     # struct type -> simple (takes the first value)
     sdt = [('a', 'f4'), ('b', 'i8'), ('d', 'O')]
     a = np.array([(5.5,7,'test'),(8,10,11)], dtype=sdt)
-    i = newiter(a, ['buffered','refs_ok'], ['readonly'],
+    i = nditer(a, ['buffered','refs_ok'], ['readonly'],
                     casting='unsafe',
                     op_dtypes='i4')
     assert_equal([x[()] for x in i], [5, 8])
@@ -1679,7 +1679,7 @@ def test_iter_buffered_cast_structured_type():
     sdt1 = [('a', 'f4'), ('b', 'i8'), ('d', 'O')]
     sdt2 = [('d', 'u2'), ('a', 'O'), ('b', 'f8')]
     a = np.array([(1,2,3),(4,5,6)], dtype=sdt1)
-    i = newiter(a, ['buffered','refs_ok'], ['readonly'],
+    i = nditer(a, ['buffered','refs_ok'], ['readonly'],
                     casting='unsafe',
                     op_dtypes=sdt2)
     assert_equal(i[0].dtype, np.dtype(sdt2))
@@ -1691,7 +1691,7 @@ def test_iter_buffered_cast_structured_type():
     sdt1 = [('a', 'f4'), ('b', 'i8'), ('d', 'O')]
     sdt2 = [('b', 'O'), ('a', 'f8')]
     a = np.array([(1,2,3),(4,5,6)], dtype=sdt1)
-    i = newiter(a, ['buffered','refs_ok'], ['readwrite'],
+    i = nditer(a, ['buffered','refs_ok'], ['readwrite'],
                     casting='unsafe',
                     op_dtypes=sdt2)
     assert_equal(i[0].dtype, np.dtype(sdt2))
@@ -1707,7 +1707,7 @@ def test_iter_buffered_cast_structured_type():
     sdt1 = [('a', 'f4'), ('b', 'i8'), ('d', [('a', 'i2'),('b','i4')])]
     sdt2 = [('b', 'O'), ('a', 'f8')]
     a = np.array([(1,2,(0,9)),(4,5,(20,21))], dtype=sdt1)
-    i = newiter(a, ['buffered','refs_ok'], ['readwrite'],
+    i = nditer(a, ['buffered','refs_ok'], ['readwrite'],
                     casting='unsafe',
                     op_dtypes=sdt2)
     assert_equal(i[0].dtype, np.dtype(sdt2))
@@ -1723,7 +1723,7 @@ def test_iter_buffered_cast_structured_type():
     sdt1 = [('a', 'f4'), ('b', 'i8'), ('d', [('a', 'i2'),('b','O')])]
     sdt2 = [('b', 'O'), ('a', 'f8')]
     a = np.array([(1,2,(0,9)),(4,5,(20,21))], dtype=sdt1)
-    i = newiter(a, ['buffered','refs_ok'], ['readwrite'],
+    i = nditer(a, ['buffered','refs_ok'], ['readwrite'],
                     casting='unsafe',
                     op_dtypes=sdt2)
     assert_equal(i[0].dtype, np.dtype(sdt2))
@@ -1739,7 +1739,7 @@ def test_iter_buffered_cast_structured_type():
     sdt1 = [('b', 'O'), ('a', 'f8')]
     sdt2 = [('a', 'f4'), ('b', 'i8'), ('d', [('a', 'i2'),('b','O')])]
     a = np.array([(1,2),(4,5)], dtype=sdt1)
-    i = newiter(a, ['buffered','refs_ok'], ['readwrite'],
+    i = nditer(a, ['buffered','refs_ok'], ['readwrite'],
                     casting='unsafe',
                     op_dtypes=sdt2)
     assert_equal(i[0].dtype, np.dtype(sdt2))
@@ -1760,7 +1760,7 @@ def test_iter_buffered_cast_subarray():
     sdt2 = [('a', 'f8', (3,2,2))]
     a = np.zeros((6,), dtype=sdt1)
     a['a'] = np.arange(6)
-    i = newiter(a, ['buffered','refs_ok'], ['readonly'],
+    i = nditer(a, ['buffered','refs_ok'], ['readonly'],
                     casting='unsafe',
                     op_dtypes=sdt2)
     assert_equal(i[0].dtype, np.dtype(sdt2))
@@ -1772,7 +1772,7 @@ def test_iter_buffered_cast_subarray():
     sdt2 = [('a', 'O', (3,2,2))]
     a = np.zeros((6,), dtype=sdt1)
     a['a'][:,0,0] = np.arange(6)
-    i = newiter(a, ['buffered','refs_ok'], ['readwrite'],
+    i = nditer(a, ['buffered','refs_ok'], ['readwrite'],
                     casting='unsafe',
                     op_dtypes=sdt2)
     assert_equal(i[0].dtype, np.dtype(sdt2))
@@ -1788,7 +1788,7 @@ def test_iter_buffered_cast_subarray():
     sdt2 = [('a', 'O', (1,))]
     a = np.zeros((6,), dtype=sdt1)
     a['a'][:,0,0,0] = np.arange(6)
-    i = newiter(a, ['buffered','refs_ok'], ['readwrite'],
+    i = nditer(a, ['buffered','refs_ok'], ['readwrite'],
                     casting='unsafe',
                     op_dtypes=sdt2)
     assert_equal(i[0].dtype, np.dtype(sdt2))
@@ -1804,7 +1804,7 @@ def test_iter_buffered_cast_subarray():
     sdt2 = [('a', 'O', (1,))]
     a = np.zeros((6,), dtype=sdt1)
     a['a'][:,0,0,0] = np.arange(6)
-    i = newiter(a, ['buffered','refs_ok'], ['readonly'],
+    i = nditer(a, ['buffered','refs_ok'], ['readonly'],
                     casting='unsafe',
                     op_dtypes=sdt2)
     assert_equal(i[0].dtype, np.dtype(sdt2))
@@ -1818,7 +1818,7 @@ def test_iter_buffered_cast_subarray():
     sdt2 = [('a', 'f4', (1,))]
     a = np.zeros((6,), dtype=sdt1)
     a['a'][:,0,0,0] = np.arange(6)
-    i = newiter(a, ['buffered','refs_ok'], ['readonly'],
+    i = nditer(a, ['buffered','refs_ok'], ['readonly'],
                     casting='unsafe',
                     op_dtypes=sdt2)
     assert_equal(i[0].dtype, np.dtype(sdt2))
@@ -1832,7 +1832,7 @@ def test_iter_buffered_cast_subarray():
     sdt2 = [('a', 'f4', (3,2,2))]
     a = np.zeros((6,), dtype=sdt1)
     a['a'] = np.arange(6*3*2*2).reshape(6,3,2,2)
-    i = newiter(a, ['buffered','refs_ok'], ['readonly'],
+    i = nditer(a, ['buffered','refs_ok'], ['readonly'],
                     casting='unsafe',
                     op_dtypes=sdt2)
     assert_equal(i[0].dtype, np.dtype(sdt2))
@@ -1846,7 +1846,7 @@ def test_iter_buffered_cast_subarray():
     sdt2 = [('a', 'f4', (2,))]
     a = np.zeros((6,), dtype=sdt1)
     a['a'] = np.arange(6*6).reshape(6,6)
-    i = newiter(a, ['buffered','refs_ok'], ['readonly'],
+    i = nditer(a, ['buffered','refs_ok'], ['readonly'],
                     casting='unsafe',
                     op_dtypes=sdt2)
     assert_equal(i[0].dtype, np.dtype(sdt2))
@@ -1860,7 +1860,7 @@ def test_iter_buffered_cast_subarray():
     sdt2 = [('a', 'f4', (6,))]
     a = np.zeros((6,), dtype=sdt1)
     a['a'] = np.arange(6*2).reshape(6,2)
-    i = newiter(a, ['buffered','refs_ok'], ['readonly'],
+    i = nditer(a, ['buffered','refs_ok'], ['readonly'],
                     casting='unsafe',
                     op_dtypes=sdt2)
     assert_equal(i[0].dtype, np.dtype(sdt2))
@@ -1875,7 +1875,7 @@ def test_iter_buffered_cast_subarray():
     sdt2 = [('a', 'f4', (2,2))]
     a = np.zeros((6,), dtype=sdt1)
     a['a'] = np.arange(6*2).reshape(6,2)
-    i = newiter(a, ['buffered','refs_ok'], ['readonly'],
+    i = nditer(a, ['buffered','refs_ok'], ['readonly'],
                     casting='unsafe',
                     op_dtypes=sdt2)
     assert_equal(i[0].dtype, np.dtype(sdt2))
@@ -1890,7 +1890,7 @@ def test_iter_buffered_cast_subarray():
     sdt2 = [('a', 'f4', (3,2))]
     a = np.zeros((6,), dtype=sdt1)
     a['a'] = np.arange(6*2).reshape(6,2,1)
-    i = newiter(a, ['buffered','refs_ok'], ['readonly'],
+    i = nditer(a, ['buffered','refs_ok'], ['readonly'],
                     casting='unsafe',
                     op_dtypes=sdt2)
     assert_equal(i[0].dtype, np.dtype(sdt2))
@@ -1906,7 +1906,7 @@ def test_iter_buffered_cast_subarray():
     sdt2 = [('a', 'f4', (3,2))]
     a = np.zeros((6,), dtype=sdt1)
     a['a'] = np.arange(6*2*3).reshape(6,2,3)
-    i = newiter(a, ['buffered','refs_ok'], ['readonly'],
+    i = nditer(a, ['buffered','refs_ok'], ['readonly'],
                     casting='unsafe',
                     op_dtypes=sdt2)
     assert_equal(i[0].dtype, np.dtype(sdt2))
@@ -1923,30 +1923,30 @@ def test_iter_buffering_badwriteback():
     # a needs write buffering, but had a broadcast dimension
     a = np.arange(6).reshape(2,3,1)
     b = np.arange(12).reshape(2,3,2)
-    assert_raises(ValueError,newiter,[a,b],
+    assert_raises(ValueError,nditer,[a,b],
                         ['buffered','no_inner_iteration'],
                         [['readwrite'],['writeonly']],
                         order='C')
 
     # But if a is readonly, it's fine
-    i = newiter([a,b],['buffered','no_inner_iteration'],
+    i = nditer([a,b],['buffered','no_inner_iteration'],
                         [['readonly'],['writeonly']],
                         order='C')
     
     # If a has just one element, it's fine too (constant 0 stride, a reduction)
     a = np.arange(1).reshape(1,1,1)
-    i = newiter([a,b],['buffered','no_inner_iteration','reduce_ok'],
+    i = nditer([a,b],['buffered','no_inner_iteration','reduce_ok'],
                         [['readwrite'],['writeonly']],
                         order='C')
 
     # check that it fails on other dimensions too
     a = np.arange(6).reshape(1,3,2)
-    assert_raises(ValueError,newiter,[a,b],
+    assert_raises(ValueError,nditer,[a,b],
                         ['buffered','no_inner_iteration'],
                         [['readwrite'],['writeonly']],
                         order='C')
     a = np.arange(4).reshape(2,1,2)
-    assert_raises(ValueError,newiter,[a,b],
+    assert_raises(ValueError,nditer,[a,b],
                         ['buffered','no_inner_iteration'],
                         [['readwrite'],['writeonly']],
                         order='C')
@@ -1955,24 +1955,24 @@ def test_iter_buffering_string():
     # Safe casting disallows shrinking strings
     a = np.array(['abc', 'a', 'abcd'], dtype=np.bytes_)
     assert_equal(a.dtype, np.dtype('S4'));
-    assert_raises(TypeError,newiter,a,['buffered'],['readonly'],
+    assert_raises(TypeError,nditer,a,['buffered'],['readonly'],
                     op_dtypes='S2')
-    i = newiter(a, ['buffered'], ['readonly'], op_dtypes='S6')
+    i = nditer(a, ['buffered'], ['readonly'], op_dtypes='S6')
     assert_equal(i[0], asbytes('abc'))
     assert_equal(i[0].dtype, np.dtype('S6'))
 
     a = np.array(['abc', 'a', 'abcd'], dtype=np.unicode)
     assert_equal(a.dtype, np.dtype('U4'));
-    assert_raises(TypeError,newiter,a,['buffered'],['readonly'],
+    assert_raises(TypeError,nditer,a,['buffered'],['readonly'],
                     op_dtypes='U2')
-    i = newiter(a, ['buffered'], ['readonly'], op_dtypes='U6')
+    i = nditer(a, ['buffered'], ['readonly'], op_dtypes='U6')
     assert_equal(i[0], u'abc')
     assert_equal(i[0].dtype, np.dtype('U6'))
 
 def test_iter_buffering_growinner():
     # Test that the inner loop grows when no buffering is needed
     a = np.arange(30)
-    i = newiter(a, ['buffered','growinner','no_inner_iteration'],
+    i = nditer(a, ['buffered','growinner','no_inner_iteration'],
                            buffersize=5)
     # Should end up with just one inner loop here
     assert_equal(i[0].size, a.size)
@@ -1983,11 +1983,11 @@ def test_iter_no_broadcast():
     b = np.arange(6).reshape(2,3,1)
     c = np.arange(12).reshape(3,4)
 
-    i = newiter([a,b,c], [],
+    i = nditer([a,b,c], [],
                     [['readonly','no_broadcast'],['readonly'],['readonly']])
-    assert_raises(ValueError, newiter, [a,b,c], [],
+    assert_raises(ValueError, nditer, [a,b,c], [],
                     [['readonly'],['readonly','no_broadcast'],['readonly']])
-    assert_raises(ValueError, newiter, [a,b,c], [],
+    assert_raises(ValueError, nditer, [a,b,c], [],
                     [['readonly'],['readonly'],['readonly','no_broadcast']])
 
 def test_iter_nested_iters_basic():
@@ -2160,12 +2160,12 @@ def test_iter_nested_iters_dtype_buffered():
 def test_iter_reduction_error():
     
     a = np.arange(6)
-    assert_raises(ValueError, newiter, [a,None], [],
+    assert_raises(ValueError, nditer, [a,None], [],
                     [['readonly'], ['readwrite','allocate']],
                     op_axes=[[0],[-1]])
 
     a = np.arange(6).reshape(2,3)
-    assert_raises(ValueError, newiter, [a,None], ['no_inner_iteration'],
+    assert_raises(ValueError, nditer, [a,None], ['no_inner_iteration'],
                     [['readonly'], ['readwrite','allocate']],
                     op_axes=[[0,1],[-1,-1]])
 
@@ -2173,7 +2173,7 @@ def test_iter_reduction():
     # Test doing reductions with the iterator
 
     a = np.arange(6)
-    i = newiter([a,None], ['reduce_ok'],
+    i = nditer([a,None], ['reduce_ok'],
                     [['readonly'], ['readwrite','allocate']],
                     op_axes=[[0],[-1]])
     # Need to initialize the output operand to the addition unit
@@ -2186,7 +2186,7 @@ def test_iter_reduction():
     assert_equal(i.operands[1], np.sum(a))
 
     a = np.arange(6).reshape(2,3)
-    i = newiter([a,None], ['reduce_ok','no_inner_iteration'],
+    i = nditer([a,None], ['reduce_ok','no_inner_iteration'],
                     [['readonly'], ['readwrite','allocate']],
                     op_axes=[[0,1],[-1,-1]])
     # Need to initialize the output operand to the addition unit
@@ -2207,7 +2207,7 @@ def test_iter_buffering_reduction():
 
     a = np.arange(6)
     b = np.array(0., dtype='f8').byteswap().newbyteorder()
-    i = newiter([a,b], ['reduce_ok', 'buffered'],
+    i = nditer([a,b], ['reduce_ok', 'buffered'],
                     [['readonly'], ['readwrite','nbo']],
                     op_axes=[[0],[-1]])
     assert_equal(i[1].dtype, np.dtype('f8'))
@@ -2220,7 +2220,7 @@ def test_iter_buffering_reduction():
 
     a = np.arange(6).reshape(2,3)
     b = np.array([0,0], dtype='f8').byteswap().newbyteorder()
-    i = newiter([a,b], ['reduce_ok','no_inner_iteration', 'buffered'],
+    i = nditer([a,b], ['reduce_ok','no_inner_iteration', 'buffered'],
                     [['readonly'], ['readwrite','nbo']],
                     op_axes=[[0,1],[0,-1]])
     # Reduction shape/strides for the output