numpy 1.9.2__zip → 1.10.0__zip

numpy-1.9.2/numpy/core/src/multiarray/nditer_pywrap.c

@@ -1,2492 +0,0 @@
-/*
- * This file implements the CPython wrapper of the new NumPy iterator.
- *
- * Copyright (c) 2010 by Mark Wiebe (mwwiebe@gmail.com)
- * The Univerity of British Columbia
- *
- * See LICENSE.txt for the license.
- */
-#define PY_SSIZE_T_CLEAN
-#include "Python.h"
-#include "structmember.h"
-
-#define NPY_NO_DEPRECATED_API NPY_API_VERSION
-#define _MULTIARRAYMODULE
-#include <numpy/arrayobject.h>
-#include "npy_config.h"
-#include "npy_pycompat.h"
-
-typedef struct NewNpyArrayIterObject_tag NewNpyArrayIterObject;
-
-struct NewNpyArrayIterObject_tag {
-    PyObject_HEAD
-    /* The iterator */
-    NpyIter *iter;
-    /* Flag indicating iteration started/stopped */
-    char started, finished;
-    /* Child to update for nested iteration */
-    NewNpyArrayIterObject *nested_child;
-    /* Cached values from the iterator */
-    NpyIter_IterNextFunc *iternext;
-    NpyIter_GetMultiIndexFunc *get_multi_index;
-    char **dataptrs;
-    PyArray_Descr **dtypes;
-    PyArrayObject **operands;
-    npy_intp *innerstrides, *innerloopsizeptr;
-    char readflags[NPY_MAXARGS];
-    char writeflags[NPY_MAXARGS];
-};
-
-static int npyiter_cache_values(NewNpyArrayIterObject *self)
-{
-    NpyIter *iter = self->iter;
-
-    /* iternext and get_multi_index functions */
-    self->iternext = NpyIter_GetIterNext(iter, NULL);
-    if (self->iternext == NULL) {
-        return -1;
-    }
-
-    if (NpyIter_HasMultiIndex(iter) && !NpyIter_HasDelayedBufAlloc(iter)) {
-        self->get_multi_index = NpyIter_GetGetMultiIndex(iter, NULL);
-    }
-    else {
-        self->get_multi_index = NULL;
-    }
-
-    /* Internal data pointers */
-    self->dataptrs = NpyIter_GetDataPtrArray(iter);
-    self->dtypes = NpyIter_GetDescrArray(iter);
-    self->operands = NpyIter_GetOperandArray(iter);
-
-    if (NpyIter_HasExternalLoop(iter)) {
-        self->innerstrides = NpyIter_GetInnerStrideArray(iter);
-        self->innerloopsizeptr = NpyIter_GetInnerLoopSizePtr(iter);
-    }
-    else {
-        self->innerstrides = NULL;
-        self->innerloopsizeptr = NULL;
-    }
-
-    /* The read/write settings */
-    NpyIter_GetReadFlags(iter, self->readflags);
-    NpyIter_GetWriteFlags(iter, self->writeflags);
-    return 0;
-}
-
-static PyObject *
-npyiter_new(PyTypeObject *subtype, PyObject *args, PyObject *kwds)
-{
-    NewNpyArrayIterObject *self;
-
-    self = (NewNpyArrayIterObject *)subtype->tp_alloc(subtype, 0);
-    if (self != NULL) {
-        self->iter = NULL;
-        self->nested_child = NULL;
-    }
-
-    return (PyObject *)self;
-}
-
-static int
-NpyIter_GlobalFlagsConverter(PyObject *flags_in, npy_uint32 *flags)
-{
-    npy_uint32 tmpflags = 0;
-    int iflags, nflags;
-
-    PyObject *f;
-    char *str = NULL;
-    Py_ssize_t length = 0;
-    npy_uint32 flag;
-
-    if (flags_in == NULL || flags_in == Py_None) {
-        return 1;
-    }
-
-    if (!PyTuple_Check(flags_in) && !PyList_Check(flags_in)) {
-        PyErr_SetString(PyExc_ValueError,
-                "Iterator global flags must be a list or tuple of strings");
-        return 0;
-    }
-
-    nflags = PySequence_Size(flags_in);
-
-    for (iflags = 0; iflags < nflags; ++iflags) {
-        f = PySequence_GetItem(flags_in, iflags);
-        if (f == NULL) {
-            return 0;
-        }
-
-        if (PyUnicode_Check(f)) {
-            /* accept unicode input */
-            PyObject *f_str;
-            f_str = PyUnicode_AsASCIIString(f);
-            if (f_str == NULL) {
-                Py_DECREF(f);
-                return 0;
-            }
-            Py_DECREF(f);
-            f = f_str;
-        }
-
-        if (PyBytes_AsStringAndSize(f, &str, &length) == -1) {
-            Py_DECREF(f);
-            return 0;
-        }
-        /* Use switch statements to quickly isolate the right flag */
-        flag = 0;
-        switch (str[0]) {
-            case 'b':
-                if (strcmp(str, "buffered") == 0) {
-                    flag = NPY_ITER_BUFFERED;
-                }
-                break;
-            case 'c':
-                if (length >= 6) switch (str[5]) {
-                    case 'e':
-                        if (strcmp(str, "c_index") == 0) {
-                            flag = NPY_ITER_C_INDEX;
-                        }
-                        break;
-                    case 'n':
-                        if (strcmp(str, "common_dtype") == 0) {
-                            flag = NPY_ITER_COMMON_DTYPE;
-                        }
-                        break;
-                }
-                break;
-            case 'd':
-                if (strcmp(str, "delay_bufalloc") == 0) {
-                    flag = NPY_ITER_DELAY_BUFALLOC;
-                }
-                break;
-            case 'e':
-                if (strcmp(str, "external_loop") == 0) {
-                    flag = NPY_ITER_EXTERNAL_LOOP;
-                }
-                break;
-            case 'f':
-                if (strcmp(str, "f_index") == 0) {
-                    flag = NPY_ITER_F_INDEX;
-                }
-                break;
-            case 'g':
-                /*
-                 * Documentation is grow_inner, but initial implementation
-                 * was growinner, so allowing for either.
-                 */
-                if (strcmp(str, "grow_inner") == 0 ||
-                            strcmp(str, "growinner") == 0) {
-                    flag = NPY_ITER_GROWINNER;
-                }
-                break;
-            case 'm':
-                if (strcmp(str, "multi_index") == 0) {
-                    flag = NPY_ITER_MULTI_INDEX;
-                }
-                break;
-            case 'r':
-                if (strcmp(str, "ranged") == 0) {
-                    flag = NPY_ITER_RANGED;
-                }
-                else if (strcmp(str, "refs_ok") == 0) {
-                    flag = NPY_ITER_REFS_OK;
-                }
-                else if (strcmp(str, "reduce_ok") == 0) {
-                    flag = NPY_ITER_REDUCE_OK;
-                }
-                break;
-            case 'z':
-                if (strcmp(str, "zerosize_ok") == 0) {
-                    flag = NPY_ITER_ZEROSIZE_OK;
-                }
-                break;
-        }
-        if (flag == 0) {
-            PyErr_Format(PyExc_ValueError,
-                    "Unexpected iterator global flag \"%s\"", str);
-            Py_DECREF(f);
-            return 0;
-        }
-        else {
-            tmpflags |= flag;
-        }
-        Py_DECREF(f);
-    }
-
-    *flags |= tmpflags;
-    return 1;
-}
-
-/* TODO: Use PyArray_OrderConverter once 'K' is added there */
-static int
-npyiter_order_converter(PyObject *order_in, NPY_ORDER *order)
-{
-    char *str = NULL;
-    Py_ssize_t length = 0;
-
-    if (PyUnicode_Check(order_in)) {
-        /* accept unicode input */
-        PyObject *str_obj;
-        int ret;
-        str_obj = PyUnicode_AsASCIIString(order_in);
-        if (str_obj == NULL) {
-            return 0;
-        }
-        ret = npyiter_order_converter(str_obj, order);
-        Py_DECREF(str_obj);
-        return ret;
-    }
-
-    if (PyBytes_AsStringAndSize(order_in, &str, &length) == -1) {
-        return 0;
-    }
-
-    if (length == 1) switch (str[0]) {
-        case 'C':
-            *order = NPY_CORDER;
-            return 1;
-        case 'F':
-            *order = NPY_FORTRANORDER;
-            return 1;
-        case 'A':
-            *order = NPY_ANYORDER;
-            return 1;
-        case 'K':
-            *order = NPY_KEEPORDER;
-            return 1;
-    }
-
-    PyErr_SetString(PyExc_ValueError,
-                    "order must be one of 'C', 'F', 'A', or 'K'");
-    return 0;
-}
-
-static int
-NpyIter_OpFlagsConverter(PyObject *op_flags_in,
-                         npy_uint32 *op_flags)
-{
-    int iflags, nflags;
-    npy_uint32 flag;
-
-    if (!PyTuple_Check(op_flags_in) && !PyList_Check(op_flags_in)) {
-        PyErr_SetString(PyExc_ValueError,
-                "op_flags must be a tuple or array of per-op flag-tuples");
-        return 0;
-    }
-
-    nflags = PySequence_Size(op_flags_in);
-
-    *op_flags = 0;
-    for (iflags = 0; iflags < nflags; ++iflags) {
-        PyObject *f;
-        char *str = NULL;
-        Py_ssize_t length = 0;
-
-        f = PySequence_GetItem(op_flags_in, iflags);
-        if (f == NULL) {
-            return 0;
-        }
-
-        if (PyUnicode_Check(f)) {
-            /* accept unicode input */
-            PyObject *f_str;
-            f_str = PyUnicode_AsASCIIString(f);
-            if (f_str == NULL) {
-                Py_DECREF(f);
-                return 0;
-            }
-            Py_DECREF(f);
-            f = f_str;
-        }
-
-        if (PyBytes_AsStringAndSize(f, &str, &length) == -1) {
-            Py_DECREF(f);
-            PyErr_SetString(PyExc_ValueError,
-                   "op_flags must be a tuple or array of per-op flag-tuples");
-            return 0;
-        }
-
-        /* Use switch statements to quickly isolate the right flag */
-        flag = 0;
-        switch (str[0]) {
-            case 'a':
-                if (length > 2) switch(str[2]) {
-                    case 'i':
-                        if (strcmp(str, "aligned") == 0) {
-                            flag = NPY_ITER_ALIGNED;
-                        }
-                        break;
-                    case 'l':
-                        if (strcmp(str, "allocate") == 0) {
-                            flag = NPY_ITER_ALLOCATE;
-                        }
-                        break;
-                    case 'r':
-                        if (strcmp(str, "arraymask") == 0) {
-                            flag = NPY_ITER_ARRAYMASK;
-                        }
-                        break;
-                }
-                break;
-            case 'c':
-                if (strcmp(str, "copy") == 0) {
-                    flag = NPY_ITER_COPY;
-                }
-                if (strcmp(str, "contig") == 0) {
-                    flag = NPY_ITER_CONTIG;
-                }
-                break;
-            case 'n':
-                switch (str[1]) {
-                    case 'b':
-                        if (strcmp(str, "nbo") == 0) {
-                            flag = NPY_ITER_NBO;
-                        }
-                        break;
-                    case 'o':
-                        if (strcmp(str, "no_subtype") == 0) {
-                            flag = NPY_ITER_NO_SUBTYPE;
-                        }
-                        else if (strcmp(str, "no_broadcast") == 0) {
-                            flag = NPY_ITER_NO_BROADCAST;
-                        }
-                        break;
-                }
-                break;
-            case 'r':
-                if (length > 4) switch (str[4]) {
-                    case 'o':
-                        if (strcmp(str, "readonly") == 0) {
-                            flag = NPY_ITER_READONLY;
-                        }
-                        break;
-                    case 'w':
-                        if (strcmp(str, "readwrite") == 0) {
-                            flag = NPY_ITER_READWRITE;
-                        }
-                        break;
-                }
-                break;
-            case 'u':
-                switch (str[1]) {
-                    case 'p':
-                        if (strcmp(str, "updateifcopy") == 0) {
-                            flag = NPY_ITER_UPDATEIFCOPY;
-                        }
-                        break;
-                }
-                break;
-            case 'v':
-                if (strcmp(str, "virtual") == 0) {
-                    flag = NPY_ITER_VIRTUAL;
-                }
-                break;
-            case 'w':
-                if (length > 5) switch (str[5]) {
-                    case 'o':
-                        if (strcmp(str, "writeonly") == 0) {
-                            flag = NPY_ITER_WRITEONLY;
-                        }
-                        break;
-                    case 'm':
-                        if (strcmp(str, "writemasked") == 0) {
-                            flag = NPY_ITER_WRITEMASKED;
-                        }
-                        break;
-                }
-                break;
-        }
-        if (flag == 0) {
-            PyErr_Format(PyExc_ValueError,
-                    "Unexpected per-op iterator flag \"%s\"", str);
-            Py_DECREF(f);
-            return 0;
-        }
-        else {
-            *op_flags |= flag;
-        }
-        Py_DECREF(f);
-    }
-
-    return 1;
-}
-
-static int
-npyiter_convert_op_flags_array(PyObject *op_flags_in,
-                         npy_uint32 *op_flags_array, npy_intp nop)
-{
-    npy_intp iop;
-
-    if (!PyTuple_Check(op_flags_in) && !PyList_Check(op_flags_in)) {
-        PyErr_SetString(PyExc_ValueError,
-                "op_flags must be a tuple or array of per-op flag-tuples");
-        return 0;
-    }
-
-    if (PySequence_Size(op_flags_in) != nop) {
-        goto try_single_flags;
-    }
-
-    for (iop = 0; iop < nop; ++iop) {
-        PyObject *f = PySequence_GetItem(op_flags_in, iop);
-        if (f == NULL) {
-            return 0;
-        }
-        /* If the first item is a string, try as one set of flags */
-        if (iop == 0 && (PyBytes_Check(f) || PyUnicode_Check(f))) {
-            Py_DECREF(f);
-            goto try_single_flags;
-        }
-        if (NpyIter_OpFlagsConverter(f,
-                        &op_flags_array[iop]) != 1) {
-            Py_DECREF(f);
-            return 0;
-        }
-
-        Py_DECREF(f);
-    }
-
-    return 1;
-
-try_single_flags:
-    if (NpyIter_OpFlagsConverter(op_flags_in,
-                        &op_flags_array[0]) != 1) {
-        return 0;
-    }
-
-    for (iop = 1; iop < nop; ++iop) {
-        op_flags_array[iop] = op_flags_array[0];
-    }
-
-    return 1;
-}
-
-static int
-npyiter_convert_dtypes(PyObject *op_dtypes_in,
-                        PyArray_Descr **op_dtypes,
-                        npy_intp nop)
-{
-    npy_intp iop;
-
-    /*
-     * If the input isn't a tuple of dtypes, try converting it as-is
-     * to a dtype, and replicating to all operands.
-     */
-    if ((!PyTuple_Check(op_dtypes_in) && !PyList_Check(op_dtypes_in)) ||
-                                    PySequence_Size(op_dtypes_in) != nop) {
-        goto try_single_dtype;
-    }
-
-    for (iop = 0; iop < nop; ++iop) {
-        PyObject *dtype = PySequence_GetItem(op_dtypes_in, iop);
-        if (dtype == NULL) {
-            npy_intp i;
-            for (i = 0; i < iop; ++i ) {
-                Py_XDECREF(op_dtypes[i]);
-            }
-            return 0;
-        }
-
-        /* Try converting the object to a descr */
-        if (PyArray_DescrConverter2(dtype, &op_dtypes[iop]) != 1) {
-            npy_intp i;
-            for (i = 0; i < iop; ++i ) {
-                Py_XDECREF(op_dtypes[i]);
-            }
-            Py_DECREF(dtype);
-            PyErr_Clear();
-            goto try_single_dtype;
-        }
-
-        Py_DECREF(dtype);
-    }
-
-    return 1;
-
-try_single_dtype:
-    if (PyArray_DescrConverter2(op_dtypes_in, &op_dtypes[0]) == 1) {
-        for (iop = 1; iop < nop; ++iop) {
-            op_dtypes[iop] = op_dtypes[0];
-            Py_XINCREF(op_dtypes[iop]);
-        }
-        return 1;
-    }
-
-    return 0;
-}
-
-static int
-npyiter_convert_op_axes(PyObject *op_axes_in, npy_intp nop,
-                        int **op_axes, int *oa_ndim)
-{
-    PyObject *a;
-    int iop;
-
-    if ((!PyTuple_Check(op_axes_in) && !PyList_Check(op_axes_in)) ||
-                                PySequence_Size(op_axes_in) != nop) {
-        PyErr_SetString(PyExc_ValueError,
-                "op_axes must be a tuple/list matching the number of ops");
-        return 0;
-    }
-
-    *oa_ndim = -1;
-
-    /* Copy the tuples into op_axes */
-    for (iop = 0; iop < nop; ++iop) {
-        int idim;
-        a = PySequence_GetItem(op_axes_in, iop);
-        if (a == NULL) {
-            return 0;
-        }
-        if (a == Py_None) {
-            op_axes[iop] = NULL;
-        } else {
-            if (!PyTuple_Check(a) && !PyList_Check(a)) {
-                PyErr_SetString(PyExc_ValueError,
-                        "Each entry of op_axes must be None "
-                        "or a tuple/list");
-                Py_DECREF(a);
-                return 0;
-            }
-            if (*oa_ndim == -1) {
-                *oa_ndim = PySequence_Size(a);
-                if (*oa_ndim > NPY_MAXDIMS) {
-                    PyErr_SetString(PyExc_ValueError,
-                            "Too many dimensions in op_axes");
-                    return 0;
-                }
-            }
-            if (PySequence_Size(a) != *oa_ndim) {
-                PyErr_SetString(PyExc_ValueError,
-                        "Each entry of op_axes must have the same size");
-                Py_DECREF(a);
-                return 0;
-            }
-            for (idim = 0; idim < *oa_ndim; ++idim) {
-                PyObject *v = PySequence_GetItem(a, idim);
-                if (v == NULL) {
-                    Py_DECREF(a);
-                    return 0;
-                }
-                /* numpy.newaxis is None */
-                if (v == Py_None) {
-                    op_axes[iop][idim] = -1;
-                }
-                else {
-                    op_axes[iop][idim] = PyArray_PyIntAsInt(v);
-                    if (op_axes[iop][idim]==-1 &&
-                                                PyErr_Occurred()) {
-                        Py_DECREF(a);
-                        Py_DECREF(v);
-                        return 0;
-                    }
-                }
-                Py_DECREF(v);
-            }
-            Py_DECREF(a);
-        }
-    }
-
-    if (*oa_ndim == -1) {
-        PyErr_SetString(PyExc_ValueError,
-                "If op_axes is provided, at least one list of axes "
-                "must be contained within it");
-        return 0;
-    }
-
-    return 1;
-}
-
-/*
- * Converts the operand array and op_flags array into the form
- * NpyIter_AdvancedNew needs.  Sets nop, and on success, each
- * op[i] owns a reference to an array object.
- */
-static int
-npyiter_convert_ops(PyObject *op_in, PyObject *op_flags_in,
-                    PyArrayObject **op, npy_uint32 *op_flags,
-                    int *nop_out)
-{
-    int iop, nop;
-
-    /* nop and op */
-    if (PyTuple_Check(op_in) || PyList_Check(op_in)) {
-        nop = PySequence_Size(op_in);
-        if (nop == 0) {
-            PyErr_SetString(PyExc_ValueError,
-                    "Must provide at least one operand");
-            return 0;
-        }
-        if (nop > NPY_MAXARGS) {
-            PyErr_SetString(PyExc_ValueError, "Too many operands");
-            return 0;
-        }
-
-        for (iop = 0; iop < nop; ++iop) {
-            PyObject *item = PySequence_GetItem(op_in, iop);
-            if (item == NULL) {
-                npy_intp i;
-                for (i = 0; i < iop; ++i) {
-                    Py_XDECREF(op[i]);
-                }
-                return 0;
-            }
-            else if (item == Py_None) {
-                Py_DECREF(item);
-                item = NULL;
-            }
-            /* This is converted to an array after op flags are retrieved */
-            op[iop] = (PyArrayObject *)item;
-        }
-    }
-    else {
-        nop = 1;
-        /* Is converted to an array after op flags are retrieved */
-        Py_INCREF(op_in);
-        op[0] = (PyArrayObject *)op_in;
-    }
-
-    *nop_out = nop;
-
-    /* op_flags */
-    if (op_flags_in == NULL || op_flags_in == Py_None) {
-        for (iop = 0; iop < nop; ++iop) {
-            /*
-             * By default, make NULL operands writeonly and flagged for
-             * allocation, and everything else readonly.  To write
-             * to a provided operand, you must specify the write flag manually.
-             */
-            if (op[iop] == NULL) {
-                op_flags[iop] = NPY_ITER_WRITEONLY | NPY_ITER_ALLOCATE;
-            }
-            else {
-                op_flags[iop] = NPY_ITER_READONLY;
-            }
-        }
-    }
-    else if (npyiter_convert_op_flags_array(op_flags_in,
-                                      op_flags, nop) != 1) {
-        for (iop = 0; iop < nop; ++iop) {
-            Py_XDECREF(op[iop]);
-        }
-        *nop_out = 0;
-        return 0;
-    }
-
-    /* Now that we have the flags - convert all the ops to arrays */
-    for (iop = 0; iop < nop; ++iop) {
-        if (op[iop] != NULL) {
-            PyArrayObject *ao;
-            int fromanyflags = 0;
-
-            if (op_flags[iop]&(NPY_ITER_READWRITE|NPY_ITER_WRITEONLY)) {
-                fromanyflags |= NPY_ARRAY_UPDATEIFCOPY;
-            }
-            ao = (PyArrayObject *)PyArray_FromAny((PyObject *)op[iop],
-                                            NULL, 0, 0, fromanyflags, NULL);
-            if (ao == NULL) {
-                if (PyErr_Occurred() &&
-                            PyErr_ExceptionMatches(PyExc_TypeError)) {
-                    PyErr_SetString(PyExc_TypeError,
-                            "Iterator operand is flagged as writeable, "
-                            "but is an object which cannot be written "
-                            "back to via UPDATEIFCOPY");
-                }
-                for (iop = 0; iop < nop; ++iop) {
-                    Py_DECREF(op[iop]);
-                }
-                *nop_out = 0;
-                return 0;
-            }
-            Py_DECREF(op[iop]);
-            op[iop] = ao;
-        }
-    }
-
-    return 1;
-}
-
-static int
-npyiter_init(NewNpyArrayIterObject *self, PyObject *args, PyObject *kwds)
-{
-    static char *kwlist[] = {"op", "flags", "op_flags", "op_dtypes",
-                             "order", "casting", "op_axes", "itershape",
-                             "buffersize",
-                             NULL};
-
-    PyObject *op_in = NULL, *op_flags_in = NULL,
-                *op_dtypes_in = NULL, *op_axes_in = NULL;
-
-    int iop, nop = 0;
-    PyArrayObject *op[NPY_MAXARGS];
-    npy_uint32 flags = 0;
-    NPY_ORDER order = NPY_KEEPORDER;
-    NPY_CASTING casting = NPY_SAFE_CASTING;
-    npy_uint32 op_flags[NPY_MAXARGS];
-    PyArray_Descr *op_request_dtypes[NPY_MAXARGS];
-    int oa_ndim = -1;
-    int op_axes_arrays[NPY_MAXARGS][NPY_MAXDIMS];
-    int *op_axes[NPY_MAXARGS];
-    PyArray_Dims itershape = {NULL, 0};
-    int buffersize = 0;
-
-    if (self->iter != NULL) {
-        PyErr_SetString(PyExc_ValueError,
-                "Iterator was already initialized");
-        return -1;
-    }
-
-    if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O&OOO&O&OO&i", kwlist,
-                    &op_in,
-                    NpyIter_GlobalFlagsConverter, &flags,
-                    &op_flags_in,
-                    &op_dtypes_in,
-                    npyiter_order_converter, &order,
-                    PyArray_CastingConverter, &casting,
-                    &op_axes_in,
-                    PyArray_IntpConverter, &itershape,
-                    &buffersize)) {
-        PyDimMem_FREE(itershape.ptr);
-        return -1;
-    }
-
-    /* Set the dtypes and ops to all NULL to start */
-    memset(op_request_dtypes, 0, sizeof(op_request_dtypes));
-
-    /* op and op_flags */
-    if (npyiter_convert_ops(op_in, op_flags_in, op, op_flags, &nop)
-                                                        != 1) {
-        goto fail;
-    }
-
-    /* op_request_dtypes */
-    if (op_dtypes_in != NULL && op_dtypes_in != Py_None &&
-            npyiter_convert_dtypes(op_dtypes_in,
-                                   op_request_dtypes, nop) != 1) {
-        goto fail;
-    }
-
-    /* op_axes */
-    if (op_axes_in != NULL && op_axes_in != Py_None) {
-        /* Initialize to point to the op_axes arrays */
-        for (iop = 0; iop < nop; ++iop) {
-            op_axes[iop] = op_axes_arrays[iop];
-        }
-
-        if (npyiter_convert_op_axes(op_axes_in, nop,
-                                    op_axes, &oa_ndim) != 1) {
-            goto fail;
-        }
-    }
-
-    if (itershape.len > 0) {
-        if (oa_ndim == -1) {
-            oa_ndim = itershape.len;
-            memset(op_axes, 0, sizeof(op_axes[0]) * nop);
-        }
-        else if (oa_ndim != itershape.len) {
-            PyErr_SetString(PyExc_ValueError,
-                        "'op_axes' and 'itershape' must have the same number "
-                        "of entries equal to the iterator ndim");
-            goto fail;
-        }
-    }
-    else if (itershape.ptr != NULL) {
-        PyDimMem_FREE(itershape.ptr);
-        itershape.ptr = NULL;
-    }
-
-    self->iter = NpyIter_AdvancedNew(nop, op, flags, order, casting, op_flags,
-                                  op_request_dtypes,
-                                  oa_ndim, oa_ndim >= 0 ? op_axes : NULL,
-                                  itershape.ptr,
-                                  buffersize);
-
-    if (self->iter == NULL) {
-        goto fail;
-    }
-
-    /* Cache some values for the member functions to use */
-    if (npyiter_cache_values(self) < 0) {
-        goto fail;
-    }
-
-    if (NpyIter_GetIterSize(self->iter) == 0) {
-        self->started = 1;
-        self->finished = 1;
-    }
-    else {
-        self->started = 0;
-        self->finished = 0;
-    }
-
-    PyDimMem_FREE(itershape.ptr);
-
-    /* Release the references we got to the ops and dtypes */
-    for (iop = 0; iop < nop; ++iop) {
-        Py_XDECREF(op[iop]);
-        Py_XDECREF(op_request_dtypes[iop]);
-    }
-
-    return 0;
-
-fail:
-    PyDimMem_FREE(itershape.ptr);
-    for (iop = 0; iop < nop; ++iop) {
-        Py_XDECREF(op[iop]);
-        Py_XDECREF(op_request_dtypes[iop]);
-    }
-    return -1;
-}
-
-NPY_NO_EXPORT PyObject *
-NpyIter_NestedIters(PyObject *NPY_UNUSED(self),
-                    PyObject *args, PyObject *kwds)
-{
-    static char *kwlist[] = {"op", "axes", "flags", "op_flags",
-                             "op_dtypes", "order",
-                             "casting", "buffersize",
-                             NULL};
-
-    PyObject *op_in = NULL, *axes_in = NULL,
-            *op_flags_in = NULL, *op_dtypes_in = NULL;
-
-    int iop, nop = 0, inest, nnest = 0;
-    PyArrayObject *op[NPY_MAXARGS];
-    npy_uint32 flags = 0, flags_inner;
-    NPY_ORDER order = NPY_KEEPORDER;
-    NPY_CASTING casting = NPY_SAFE_CASTING;
-    npy_uint32 op_flags[NPY_MAXARGS], op_flags_inner[NPY_MAXARGS];
-    PyArray_Descr *op_request_dtypes[NPY_MAXARGS],
-                  *op_request_dtypes_inner[NPY_MAXARGS];
-    int op_axes_data[NPY_MAXDIMS];
-    int *nested_op_axes[NPY_MAXDIMS];
-    int nested_naxes[NPY_MAXDIMS], iaxes, naxes;
-    int negones[NPY_MAXDIMS];
-    char used_axes[NPY_MAXDIMS];
-    int buffersize = 0;
-
-    PyObject *ret = NULL;
-
-    if (!PyArg_ParseTupleAndKeywords(args, kwds, "OO|O&OOO&O&i", kwlist,
-                    &op_in,
-                    &axes_in,
-                    NpyIter_GlobalFlagsConverter, &flags,
-                    &op_flags_in,
-                    &op_dtypes_in,
-                    npyiter_order_converter, &order,
-                    PyArray_CastingConverter, &casting,
-                    &buffersize)) {
-        return NULL;
-    }
-
-    /* axes */
-    if (!PyTuple_Check(axes_in) && !PyList_Check(axes_in)) {
-        PyErr_SetString(PyExc_ValueError,
-                "axes must be a tuple of axis arrays");
-        return NULL;
-    }
-    nnest = PySequence_Size(axes_in);
-    if (nnest < 2) {
-        PyErr_SetString(PyExc_ValueError,
-                "axes must have at least 2 entries for nested iteration");
-        return NULL;
-    }
-    naxes = 0;
-    memset(used_axes, 0, NPY_MAXDIMS);
-    for (inest = 0; inest < nnest; ++inest) {
-        PyObject *item = PySequence_GetItem(axes_in, inest);
-        npy_intp i;
-        if (item == NULL) {
-            return NULL;
-        }
-        if (!PyTuple_Check(item) && !PyList_Check(item)) {
-            PyErr_SetString(PyExc_ValueError,
-                    "Each item in axes must be a an integer tuple");
-            Py_DECREF(item);
-            return NULL;
-        }
-        nested_naxes[inest] = PySequence_Size(item);
-        if (naxes + nested_naxes[inest] > NPY_MAXDIMS) {
-            PyErr_SetString(PyExc_ValueError,
-                    "Too many axes given");
-            Py_DECREF(item);
-            return NULL;
-        }
-        for (i = 0; i < nested_naxes[inest]; ++i) {
-            PyObject *v = PySequence_GetItem(item, i);
-            npy_intp axis;
-            if (v == NULL) {
-                Py_DECREF(item);
-                return NULL;
-            }
-            axis = PyInt_AsLong(v);
-            Py_DECREF(v);
-            if (axis < 0 || axis >= NPY_MAXDIMS) {
-                PyErr_SetString(PyExc_ValueError,
-                        "An axis is out of bounds");
-                Py_DECREF(item);
-                return NULL;
-            }
-            /*
-             * This check is very important, without it out of bounds
-             * data accesses are possible.
-             */
-            if (used_axes[axis] != 0) {
-                PyErr_SetString(PyExc_ValueError,
-                        "An axis is used more than once");
-                Py_DECREF(item);
-                return NULL;
-            }
-            used_axes[axis] = 1;
-            op_axes_data[naxes+i] = axis;
-        }
-        nested_op_axes[inest] = &op_axes_data[naxes];
-        naxes += nested_naxes[inest];
-        Py_DECREF(item);
-    }
-
-    /* op and op_flags */
-    if (npyiter_convert_ops(op_in, op_flags_in, op, op_flags, &nop)
-                                                        != 1) {
-        return NULL;
-    }
-
-    /* Set the dtypes to all NULL to start as well */
-    memset(op_request_dtypes, 0, sizeof(op_request_dtypes[0])*nop);
-    memset(op_request_dtypes_inner, 0,
-                        sizeof(op_request_dtypes_inner[0])*nop);
-
-    /* op_request_dtypes */
-    if (op_dtypes_in != NULL && op_dtypes_in != Py_None &&
-            npyiter_convert_dtypes(op_dtypes_in,
-                                   op_request_dtypes, nop) != 1) {
-        goto fail;
-    }
-
-    ret = PyTuple_New(nnest);
-    if (ret == NULL) {
-        goto fail;
-    }
-
-    /* For broadcasting allocated arrays */
-    for (iaxes = 0; iaxes < naxes; ++iaxes) {
-        negones[iaxes] = -1;
-    }
-
-    /*
-     * Clear any unnecessary ALLOCATE flags, so we can use them
-     * to indicate exactly the allocated outputs.  Also, separate
-     * the inner loop flags.
-     */
-    for (iop = 0; iop < nop; ++iop) {
-        if ((op_flags[iop]&NPY_ITER_ALLOCATE) && op[iop] != NULL) {
-            op_flags[iop] &= ~NPY_ITER_ALLOCATE;
-        }
-
-        /*
-         * Clear any flags allowing copies or output allocation for
-         * the inner loop.
-         */
-        op_flags_inner[iop] = op_flags[iop] & ~(NPY_ITER_COPY|
-                             NPY_ITER_UPDATEIFCOPY|
-                             NPY_ITER_ALLOCATE);
-        /*
-         * If buffering is enabled and copying is not,
-         * clear the nbo_aligned flag and strip the data type
-         * for the outer loops.
-         */
-        if ((flags&(NPY_ITER_BUFFERED)) &&
-                !(op_flags[iop]&(NPY_ITER_COPY|
-                                   NPY_ITER_UPDATEIFCOPY|
-                                   NPY_ITER_ALLOCATE))) {
-            op_flags[iop] &= ~(NPY_ITER_NBO|NPY_ITER_ALIGNED|NPY_ITER_CONTIG);
-            op_request_dtypes_inner[iop] = op_request_dtypes[iop];
-            op_request_dtypes[iop] = NULL;
-        }
-    }
-
-    /* Only the inner loop gets the buffering and no inner flags */
-    flags_inner = flags&~NPY_ITER_COMMON_DTYPE;
-    flags &= ~(NPY_ITER_EXTERNAL_LOOP|
-                    NPY_ITER_BUFFERED);
-
-    for (inest = 0; inest < nnest; ++inest) {
-        NewNpyArrayIterObject *iter;
-        int *op_axes_nop[NPY_MAXARGS];
-
-        /*
-         * All the operands' op_axes are the same, except for
-         * allocated outputs.
-         */
-        for (iop = 0; iop < nop; ++iop) {
-            if (op_flags[iop]&NPY_ITER_ALLOCATE) {
-                if (inest == 0) {
-                    op_axes_nop[iop] = NULL;
-                }
-                else {
-                    op_axes_nop[iop] = negones;
-                }
-            }
-            else {
-                op_axes_nop[iop] = nested_op_axes[inest];
-            }
-        }
-
-        /*
-        printf("\n");
-        for (iop = 0; iop < nop; ++iop) {
-            npy_intp i;
-
-            for (i = 0; i < nested_naxes[inest]; ++i) {
-                printf("%d ", (int)op_axes_nop[iop][i]);
-            }
-            printf("\n");
-        }
-        */
-
-        /* Allocate the iterator */
-        iter = (NewNpyArrayIterObject *)npyiter_new(&NpyIter_Type, NULL, NULL);
-        if (iter == NULL) {
-            Py_DECREF(ret);
-            goto fail;
-        }
-
-        if (inest < nnest-1) {
-            iter->iter = NpyIter_AdvancedNew(nop, op, flags, order,
-                                casting, op_flags, op_request_dtypes,
-                                nested_naxes[inest], op_axes_nop,
-                                NULL,
-                                0);
-        }
-        else {
-            iter->iter = NpyIter_AdvancedNew(nop, op, flags_inner, order,
-                                casting, op_flags_inner,
-                                op_request_dtypes_inner,
-                                nested_naxes[inest], op_axes_nop,
-                                NULL,
-                                buffersize);
-        }
-
-        if (iter->iter == NULL) {
-            Py_DECREF(ret);
-            goto fail;
-        }
-
-        /* Cache some values for the member functions to use */
-        if (npyiter_cache_values(iter) < 0) {
-            Py_DECREF(ret);
-            goto fail;
-        }
-
-        if (NpyIter_GetIterSize(iter->iter) == 0) {
-            iter->started = 1;
-            iter->finished = 1;
-        }
-        else {
-            iter->started = 0;
-            iter->finished = 0;
-        }
-
-        /*
-         * If there are any allocated outputs or any copies were made,
-         * adjust op so that the other iterators use the same ones.
-         */
-        if (inest == 0) {
-            PyArrayObject **operands = NpyIter_GetOperandArray(iter->iter);
-            for (iop = 0; iop < nop; ++iop) {
-                if (op[iop] != operands[iop]) {
-                    Py_XDECREF(op[iop]);
-                    op[iop] = operands[iop];
-                    Py_INCREF(op[iop]);
-                }
-
-                /*
-                 * Clear any flags allowing copies for
-                 * the rest of the iterators
-                 */
-                op_flags[iop] &= ~(NPY_ITER_COPY|
-                                 NPY_ITER_UPDATEIFCOPY);
-            }
-            /* Clear the common dtype flag for the rest of the iterators */
-            flags &= ~NPY_ITER_COMMON_DTYPE;
-        }
-
-        PyTuple_SET_ITEM(ret, inest, (PyObject *)iter);
-    }
-
-    /* Release our references to the ops and dtypes */
-    for (iop = 0; iop < nop; ++iop) {
-        Py_XDECREF(op[iop]);
-        Py_XDECREF(op_request_dtypes[iop]);
-        Py_XDECREF(op_request_dtypes_inner[iop]);
-    }
-
-    /* Set up the nested child references */
-    for (inest = 0; inest < nnest-1; ++inest) {
-        NewNpyArrayIterObject *iter;
-        iter = (NewNpyArrayIterObject *)PyTuple_GET_ITEM(ret, inest);
-        /*
-         * Indicates which iterator to reset with new base pointers
-         * each iteration step.
-         */
-        iter->nested_child =
-                (NewNpyArrayIterObject *)PyTuple_GET_ITEM(ret, inest+1);
-        Py_INCREF(iter->nested_child);
-        /*
-         * Need to do a nested reset so all the iterators point
-         * at the right data
-         */
-        if (NpyIter_ResetBasePointers(iter->nested_child->iter,
-                                iter->dataptrs, NULL) != NPY_SUCCEED) {
-            Py_DECREF(ret);
-            return NULL;
-        }
-    }
-
-    return ret;
-
-fail:
-    for (iop = 0; iop < nop; ++iop) {
-        Py_XDECREF(op[iop]);
-        Py_XDECREF(op_request_dtypes[iop]);
-        Py_XDECREF(op_request_dtypes_inner[iop]);
-    }
-    return NULL;
-}
-
-static void
-npyiter_dealloc(NewNpyArrayIterObject *self)
-{
-    if (self->iter) {
-        NpyIter_Deallocate(self->iter);
-        self->iter = NULL;
-        Py_XDECREF(self->nested_child);
-        self->nested_child = NULL;
-    }
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-static int
-npyiter_resetbasepointers(NewNpyArrayIterObject *self)
-{
-    while (self->nested_child) {
-        if (NpyIter_ResetBasePointers(self->nested_child->iter,
-                                        self->dataptrs, NULL) != NPY_SUCCEED) {
-            return NPY_FAIL;
-        }
-        self = self->nested_child;
-        if (NpyIter_GetIterSize(self->iter) == 0) {
-            self->started = 1;
-            self->finished = 1;
-        }
-        else {
-            self->started = 0;
-            self->finished = 0;
-        }
-    }
-
-    return NPY_SUCCEED;
-}
-
-static PyObject *
-npyiter_reset(NewNpyArrayIterObject *self)
-{
-    if (self->iter == NULL) {
-        PyErr_SetString(PyExc_ValueError,
-                "Iterator is invalid");
-        return NULL;
-    }
-
-    if (NpyIter_Reset(self->iter, NULL) != NPY_SUCCEED) {
-        return NULL;
-    }
-    if (NpyIter_GetIterSize(self->iter) == 0) {
-        self->started = 1;
-        self->finished = 1;
-    }
-    else {
-        self->started = 0;
-        self->finished = 0;
-    }
-
-    if (self->get_multi_index == NULL && NpyIter_HasMultiIndex(self->iter)) {
-        self->get_multi_index = NpyIter_GetGetMultiIndex(self->iter, NULL);
-    }
-
-    /* If there is nesting, the nested iterators should be reset */
-    if (npyiter_resetbasepointers(self) != NPY_SUCCEED) {
-        return NULL;
-    }
-
-    Py_RETURN_NONE;
-}
-
-/*
- * Makes a copy of the iterator.  Note that the nesting is not
- * copied.
- */
-static PyObject *
-npyiter_copy(NewNpyArrayIterObject *self)
-{
-    NewNpyArrayIterObject *iter;
-
-    if (self->iter == NULL) {
-        PyErr_SetString(PyExc_ValueError,
-                "Iterator is invalid");
-        return NULL;
-    }
-
-    /* Allocate the iterator */
-    iter = (NewNpyArrayIterObject *)npyiter_new(&NpyIter_Type, NULL, NULL);
-    if (iter == NULL) {
-        return NULL;
-    }
-
-    /* Copy the C iterator */
-    iter->iter = NpyIter_Copy(self->iter);
-    if (iter->iter == NULL) {
-        Py_DECREF(iter);
-        return NULL;
-    }
-
-    /* Cache some values for the member functions to use */
-    if (npyiter_cache_values(iter) < 0) {
-        Py_DECREF(iter);
-        return NULL;
-    }
-
-    iter->started = self->started;
-    iter->finished = self->finished;
-
-    return (PyObject *)iter;
-}
-
-static PyObject *
-npyiter_iternext(NewNpyArrayIterObject *self)
-{
-    if (self->iter != NULL && self->iternext != NULL &&
-                        !self->finished && self->iternext(self->iter)) {
-        /* If there is nesting, the nested iterators should be reset */
-        if (npyiter_resetbasepointers(self) != NPY_SUCCEED) {
-            return NULL;
-        }
-
-        Py_RETURN_TRUE;
-    }
-    else {
-        self->finished = 1;
-        Py_RETURN_FALSE;
-    }
-}
-
-static PyObject *
-npyiter_remove_axis(NewNpyArrayIterObject *self, PyObject *args)
-{
-    int axis = 0;
-
-    if (self->iter == NULL) {
-        PyErr_SetString(PyExc_ValueError,
-                "Iterator is invalid");
-        return NULL;
-    }
-
-    if (!PyArg_ParseTuple(args, "i", &axis)) {
-        return NULL;
-    }
-
-    if (NpyIter_RemoveAxis(self->iter, axis) != NPY_SUCCEED) {
-        return NULL;
-    }
-    /* RemoveAxis invalidates cached values */
-    if (npyiter_cache_values(self) < 0) {
-        return NULL;
-    }
-    /* RemoveAxis also resets the iterator */
-    if (NpyIter_GetIterSize(self->iter) == 0) {
-        self->started = 1;
-        self->finished = 1;
-    }
-    else {
-        self->started = 0;
-        self->finished = 0;
-    }
-
-    Py_RETURN_NONE;
-}
-
-static PyObject *
-npyiter_remove_multi_index(NewNpyArrayIterObject *self)
-{
-    if (self->iter == NULL) {
-        PyErr_SetString(PyExc_ValueError,
-                "Iterator is invalid");
-        return NULL;
-    }
-
-    NpyIter_RemoveMultiIndex(self->iter);
-    /* RemoveMultiIndex invalidates cached values */
-    npyiter_cache_values(self);
-    /* RemoveMultiIndex also resets the iterator */
-    if (NpyIter_GetIterSize(self->iter) == 0) {
-        self->started = 1;
-        self->finished = 1;
-    }
-    else {
-        self->started = 0;
-        self->finished = 0;
-    }
-
-    Py_RETURN_NONE;
-}
-
-static PyObject *
-npyiter_enable_external_loop(NewNpyArrayIterObject *self)
-{
-    if (self->iter == NULL) {
-        PyErr_SetString(PyExc_ValueError,
-                "Iterator is invalid");
-        return NULL;
-    }
-
-    NpyIter_EnableExternalLoop(self->iter);
-    /* EnableExternalLoop invalidates cached values */
-    npyiter_cache_values(self);
-    /* EnableExternalLoop also resets the iterator */
-    if (NpyIter_GetIterSize(self->iter) == 0) {
-        self->started = 1;
-        self->finished = 1;
-    }
-    else {
-        self->started = 0;
-        self->finished = 0;
-    }
-
-    Py_RETURN_NONE;
-}
-
-static PyObject *
-npyiter_debug_print(NewNpyArrayIterObject *self)
-{
-    if (self->iter != NULL) {
-        NpyIter_DebugPrint(self->iter);
-    }
-    else {
-        printf("Iterator: (nil)\n");
-    }
-
-    Py_RETURN_NONE;
-}
-
-NPY_NO_EXPORT PyObject *
-npyiter_seq_item(NewNpyArrayIterObject *self, Py_ssize_t i);
-
-static PyObject *npyiter_value_get(NewNpyArrayIterObject *self)
-{
-    PyObject *ret;
-
-    npy_intp iop, nop;
-
-    if (self->iter == NULL || self->finished) {
-        PyErr_SetString(PyExc_ValueError,
-                "Iterator is past the end");
-        return NULL;
-    }
-
-    nop = NpyIter_GetNOp(self->iter);
-
-    /* Return an array  or tuple of arrays with the values */
-    if (nop == 1) {
-        ret = npyiter_seq_item(self, 0);
-    }
-    else {
-        ret = PyTuple_New(nop);
-        if (ret == NULL) {
-            return NULL;
-        }
-        for (iop = 0; iop < nop; ++iop) {
-            PyObject *a = npyiter_seq_item(self, iop);
-            if (a == NULL) {
-                Py_DECREF(ret);
-                return NULL;
-            }
-            PyTuple_SET_ITEM(ret, iop, a);
-        }
-    }
-
-    return ret;
-}
-
-static PyObject *npyiter_operands_get(NewNpyArrayIterObject *self)
-{
-    PyObject *ret;
-
-    npy_intp iop, nop;
-    PyArrayObject **operands;
-
-    if (self->iter == NULL) {
-        PyErr_SetString(PyExc_ValueError,
-                "Iterator is invalid");
-        return NULL;
-    }
-
-    nop = NpyIter_GetNOp(self->iter);
-    operands = self->operands;
-
-    ret = PyTuple_New(nop);
-    if (ret == NULL) {
-        return NULL;
-    }
-    for (iop = 0; iop < nop; ++iop) {
-        PyObject *operand = (PyObject *)operands[iop];
-
-        Py_INCREF(operand);
-        PyTuple_SET_ITEM(ret, iop, operand);
-    }
-
-    return ret;
-}
-
-static PyObject *npyiter_itviews_get(NewNpyArrayIterObject *self)
-{
-    PyObject *ret;
-
-    npy_intp iop, nop;
-
-    if (self->iter == NULL) {
-        PyErr_SetString(PyExc_ValueError,
-                "Iterator is invalid");
-        return NULL;
-    }
-
-    nop = NpyIter_GetNOp(self->iter);
-
-    ret = PyTuple_New(nop);
-    if (ret == NULL) {
-        return NULL;
-    }
-    for (iop = 0; iop < nop; ++iop) {
-        PyArrayObject *view = NpyIter_GetIterView(self->iter, iop);
-
-        if (view == NULL) {
-            Py_DECREF(ret);
-            return NULL;
-        }
-        PyTuple_SET_ITEM(ret, iop, (PyObject *)view);
-    }
-
-    return ret;
-}
-
-static PyObject *
-npyiter_next(NewNpyArrayIterObject *self)
-{
-    if (self->iter == NULL || self->iternext == NULL || self->finished) {
-        return NULL;
-    }
-
-    /*
-     * Use the started flag for the Python iteration protocol to work
-     * when buffering is enabled.
-     */
-    if (self->started) {
-        if (!self->iternext(self->iter)) {
-            self->finished = 1;
-            return NULL;
-        }
-
-        /* If there is nesting, the nested iterators should be reset */
-        if (npyiter_resetbasepointers(self) != NPY_SUCCEED) {
-            return NULL;
-        }
-    }
-    self->started = 1;
-
-    return npyiter_value_get(self);
-};
-
-static PyObject *npyiter_shape_get(NewNpyArrayIterObject *self)
-{
-    PyObject *ret;
-    npy_intp idim, ndim, shape[NPY_MAXDIMS];
-
-    if (self->iter == NULL || self->finished) {
-        PyErr_SetString(PyExc_ValueError,
-                "Iterator is past the end");
-        return NULL;
-    }
-
-    if (NpyIter_GetShape(self->iter, shape) == NPY_SUCCEED) {
-        ndim = NpyIter_GetNDim(self->iter);
-        ret = PyTuple_New(ndim);
-        if (ret != NULL) {
-            for (idim = 0; idim < ndim; ++idim) {
-                PyTuple_SET_ITEM(ret, idim,
-                        PyInt_FromLong(shape[idim]));
-            }
-            return ret;
-        }
-    }
-
-    return NULL;
-}
-
-static PyObject *npyiter_multi_index_get(NewNpyArrayIterObject *self)
-{
-    PyObject *ret;
-    npy_intp idim, ndim, multi_index[NPY_MAXDIMS];
-
-    if (self->iter == NULL || self->finished) {
-        PyErr_SetString(PyExc_ValueError,
-                "Iterator is past the end");
-        return NULL;
-    }
-
-    if (self->get_multi_index != NULL) {
-        ndim = NpyIter_GetNDim(self->iter);
-        self->get_multi_index(self->iter, multi_index);
-        ret = PyTuple_New(ndim);
-        if (ret == NULL) {
-            return NULL;
-        }
-        for (idim = 0; idim < ndim; ++idim) {
-            PyTuple_SET_ITEM(ret, idim,
-                    PyInt_FromLong(multi_index[idim]));
-        }
-        return ret;
-    }
-    else {
-        if (!NpyIter_HasMultiIndex(self->iter)) {
-            PyErr_SetString(PyExc_ValueError,
-                    "Iterator is not tracking a multi-index");
-            return NULL;
-        }
-        else if (NpyIter_HasDelayedBufAlloc(self->iter)) {
-            PyErr_SetString(PyExc_ValueError,
-                    "Iterator construction used delayed buffer allocation, "
-                    "and no reset has been done yet");
-            return NULL;
-        }
-        else {
-            PyErr_SetString(PyExc_ValueError,
-                    "Iterator is in an invalid state");
-            return NULL;
-        }
-    }
-}
-
-static int
-npyiter_multi_index_set(NewNpyArrayIterObject *self, PyObject *value)
-{
-    npy_intp idim, ndim, multi_index[NPY_MAXDIMS];
-
-    if (value == NULL) {
-        PyErr_SetString(PyExc_AttributeError,
-                "Cannot delete nditer multi_index");
-        return -1;
-    }
-    if (self->iter == NULL) {
-        PyErr_SetString(PyExc_ValueError,
-                "Iterator is invalid");
-        return -1;
-    }
-
-    if (NpyIter_HasMultiIndex(self->iter)) {
-        ndim = NpyIter_GetNDim(self->iter);
-        if (!PySequence_Check(value)) {
-            PyErr_SetString(PyExc_ValueError,
-                    "multi_index must be set with a sequence");
-            return -1;
-        }
-        if (PySequence_Size(value) != ndim) {
-            PyErr_SetString(PyExc_ValueError,
-                    "Wrong number of indices");
-            return -1;
-        }
-        for (idim = 0; idim < ndim; ++idim) {
-            PyObject *v = PySequence_GetItem(value, idim);
-            multi_index[idim] = PyInt_AsLong(v);
-            if (multi_index[idim]==-1 && PyErr_Occurred()) {
-                Py_XDECREF(v);
-                return -1;
-            }
-        }
-        if (NpyIter_GotoMultiIndex(self->iter, multi_index) != NPY_SUCCEED) {
-            return -1;
-        }
-        self->started = 0;
-        self->finished = 0;
-
-        /* If there is nesting, the nested iterators should be reset */
-        if (npyiter_resetbasepointers(self) != NPY_SUCCEED) {
-            return -1;
-        }
-
-        return 0;
-    }
-    else {
-        PyErr_SetString(PyExc_ValueError,
-                "Iterator is not tracking a multi-index");
-        return -1;
-    }
-}
-
-static PyObject *npyiter_index_get(NewNpyArrayIterObject *self)
-{
-    if (self->iter == NULL || self->finished) {
-        PyErr_SetString(PyExc_ValueError,
-                "Iterator is past the end");
-        return NULL;
-    }
-
-    if (NpyIter_HasIndex(self->iter)) {
-        npy_intp ind = *NpyIter_GetIndexPtr(self->iter);
-        return PyInt_FromLong(ind);
-    }
-    else {
-        PyErr_SetString(PyExc_ValueError,
-                "Iterator does not have an index");
-        return NULL;
-    }
-}
-
-static int npyiter_index_set(NewNpyArrayIterObject *self, PyObject *value)
-{
-    if (value == NULL) {
-        PyErr_SetString(PyExc_AttributeError,
-                "Cannot delete nditer index");
-        return -1;
-    }
-    if (self->iter == NULL) {
-        PyErr_SetString(PyExc_ValueError,
-                "Iterator is invalid");
-        return -1;
-    }
-
-    if (NpyIter_HasIndex(self->iter)) {
-        npy_intp ind;
-        ind = PyInt_AsLong(value);
-        if (ind==-1 && PyErr_Occurred()) {
-            return -1;
-        }
-        if (NpyIter_GotoIndex(self->iter, ind) != NPY_SUCCEED) {
-            return -1;
-        }
-        self->started = 0;
-        self->finished = 0;
-
-        /* If there is nesting, the nested iterators should be reset */
-        if (npyiter_resetbasepointers(self) != NPY_SUCCEED) {
-            return -1;
-        }
-
-        return 0;
-    }
-    else {
-        PyErr_SetString(PyExc_ValueError,
-                "Iterator does not have an index");
-        return -1;
-    }
-}
-
-static PyObject *npyiter_iterindex_get(NewNpyArrayIterObject *self)
-{
-    if (self->iter == NULL || self->finished) {
-        PyErr_SetString(PyExc_ValueError,
-                "Iterator is past the end");
-        return NULL;
-    }
-
-    return PyInt_FromLong(NpyIter_GetIterIndex(self->iter));
-}
-
-static int npyiter_iterindex_set(NewNpyArrayIterObject *self, PyObject *value)
-{
-    npy_intp iterindex;
-
-    if (value == NULL) {
-        PyErr_SetString(PyExc_AttributeError,
-                "Cannot delete nditer iterindex");
-        return -1;
-    }
-    if (self->iter == NULL) {
-        PyErr_SetString(PyExc_ValueError,
-                "Iterator is invalid");
-        return -1;
-    }
-
-    iterindex = PyInt_AsLong(value);
-    if (iterindex==-1 && PyErr_Occurred()) {
-        return -1;
-    }
-    if (NpyIter_GotoIterIndex(self->iter, iterindex) != NPY_SUCCEED) {
-        return -1;
-    }
-    self->started = 0;
-    self->finished = 0;
-
-    /* If there is nesting, the nested iterators should be reset */
-    if (npyiter_resetbasepointers(self) != NPY_SUCCEED) {
-        return -1;
-    }
-
-    return 0;
-}
-
-static PyObject *npyiter_iterrange_get(NewNpyArrayIterObject *self)
-{
-    npy_intp istart = 0, iend = 0;
-    PyObject *ret;
-
-    if (self->iter == NULL) {
-        PyErr_SetString(PyExc_ValueError,
-                "Iterator is invalid");
-        return NULL;
-    }
-
-    NpyIter_GetIterIndexRange(self->iter, &istart, &iend);
-
-    ret = PyTuple_New(2);
-    if (ret == NULL) {
-        return NULL;
-    }
-
-    PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(istart));
-    PyTuple_SET_ITEM(ret, 1, PyInt_FromLong(iend));
-
-    return ret;
-}
-
-static int npyiter_iterrange_set(NewNpyArrayIterObject *self, PyObject *value)
-{
-    npy_intp istart = 0, iend = 0;
-
-    if (value == NULL) {
-        PyErr_SetString(PyExc_AttributeError,
-                "Cannot delete nditer iterrange");
-        return -1;
-    }
-    if (self->iter == NULL) {
-        PyErr_SetString(PyExc_ValueError,
-                "Iterator is invalid");
-        return -1;
-    }
-
-    if (!PyArg_ParseTuple(value, "nn", &istart, &iend)) {
-        return -1;
-    }
-
-    if (NpyIter_ResetToIterIndexRange(self->iter, istart, iend, NULL)
-                                                    != NPY_SUCCEED) {
-        return -1;
-    }
-    if (istart < iend) {
-        self->started = self->finished = 0;
-    }
-    else {
-        self->started = self->finished = 1;
-    }
-
-    if (self->get_multi_index == NULL && NpyIter_HasMultiIndex(self->iter)) {
-        self->get_multi_index = NpyIter_GetGetMultiIndex(self->iter, NULL);
-    }
-
-    /* If there is nesting, the nested iterators should be reset */
-    if (npyiter_resetbasepointers(self) != NPY_SUCCEED) {
-        return -1;
-    }
-
-    return 0;
-}
-
-static PyObject *npyiter_has_delayed_bufalloc_get(NewNpyArrayIterObject *self)
-{
-    if (self->iter == NULL) {
-        PyErr_SetString(PyExc_ValueError,
-                "Iterator is invalid");
-        return NULL;
-    }
-
-    if (NpyIter_HasDelayedBufAlloc(self->iter)) {
-        Py_RETURN_TRUE;
-    }
-    else {
-        Py_RETURN_FALSE;
-    }
-}
-
-static PyObject *npyiter_iterationneedsapi_get(NewNpyArrayIterObject *self)
-{
-    if (self->iter == NULL) {
-        PyErr_SetString(PyExc_ValueError,
-                "Iterator is invalid");
-        return NULL;
-    }
-
-    if (NpyIter_IterationNeedsAPI(self->iter)) {
-        Py_RETURN_TRUE;
-    }
-    else {
-        Py_RETURN_FALSE;
-    }
-}
-
-static PyObject *npyiter_has_multi_index_get(NewNpyArrayIterObject *self)
-{
-    if (self->iter == NULL) {
-        PyErr_SetString(PyExc_ValueError,
-                "Iterator is invalid");
-        return NULL;
-    }
-
-    if (NpyIter_HasMultiIndex(self->iter)) {
-        Py_RETURN_TRUE;
-    }
-    else {
-        Py_RETURN_FALSE;
-    }
-}
-
-static PyObject *npyiter_has_index_get(NewNpyArrayIterObject *self)
-{
-    if (self->iter == NULL) {
-        PyErr_SetString(PyExc_ValueError,
-                "Iterator is invalid");
-        return NULL;
-    }
-
-    if (NpyIter_HasIndex(self->iter)) {
-        Py_RETURN_TRUE;
-    }
-    else {
-        Py_RETURN_FALSE;
-    }
-}
-
-static PyObject *npyiter_dtypes_get(NewNpyArrayIterObject *self)
-{
-    PyObject *ret;
-
-    npy_intp iop, nop;
-    PyArray_Descr **dtypes;
-
-    if (self->iter == NULL) {
-        PyErr_SetString(PyExc_ValueError,
-                "Iterator is invalid");
-        return NULL;
-    }
-
-    nop = NpyIter_GetNOp(self->iter);
-
-    ret = PyTuple_New(nop);
-    if (ret == NULL) {
-        return NULL;
-    }
-    dtypes = self->dtypes;
-    for (iop = 0; iop < nop; ++iop) {
-        PyArray_Descr *dtype = dtypes[iop];
-
-        Py_INCREF(dtype);
-        PyTuple_SET_ITEM(ret, iop, (PyObject *)dtype);
-    }
-
-    return ret;
-}
-
-static PyObject *npyiter_ndim_get(NewNpyArrayIterObject *self)
-{
-    if (self->iter == NULL) {
-        PyErr_SetString(PyExc_ValueError,
-                "Iterator is invalid");
-        return NULL;
-    }
-
-    return PyInt_FromLong(NpyIter_GetNDim(self->iter));
-}
-
-static PyObject *npyiter_nop_get(NewNpyArrayIterObject *self)
-{
-    if (self->iter == NULL) {
-        PyErr_SetString(PyExc_ValueError,
-                "Iterator is invalid");
-        return NULL;
-    }
-
-    return PyInt_FromLong(NpyIter_GetNOp(self->iter));
-}
-
-static PyObject *npyiter_itersize_get(NewNpyArrayIterObject *self)
-{
-    if (self->iter == NULL) {
-        PyErr_SetString(PyExc_ValueError,
-                "Iterator is invalid");
-        return NULL;
-    }
-
-    return PyInt_FromLong(NpyIter_GetIterSize(self->iter));
-}
-
-static PyObject *npyiter_finished_get(NewNpyArrayIterObject *self)
-{
-    if (self->iter == NULL || !self->finished) {
-        Py_RETURN_FALSE;
-    }
-    else {
-        Py_RETURN_TRUE;
-    }
-}
-
-NPY_NO_EXPORT Py_ssize_t
-npyiter_seq_length(NewNpyArrayIterObject *self)
-{
-    if (self->iter == NULL) {
-        return 0;
-    }
-    else {
-        return NpyIter_GetNOp(self->iter);
-    }
-}
-
-NPY_NO_EXPORT PyObject *
-npyiter_seq_item(NewNpyArrayIterObject *self, Py_ssize_t i)
-{
-    PyArrayObject *ret;
-
-    npy_intp ret_ndim;
-    npy_intp nop, innerloopsize, innerstride;
-    char *dataptr;
-    PyArray_Descr *dtype;
-    int has_external_loop;
-    Py_ssize_t i_orig = i;
-
-    if (self->iter == NULL || self->finished) {
-        PyErr_SetString(PyExc_ValueError,
-                "Iterator is past the end");
-        return NULL;
-    }
-
-    if (NpyIter_HasDelayedBufAlloc(self->iter)) {
-        PyErr_SetString(PyExc_ValueError,
-                "Iterator construction used delayed buffer allocation, "
-                "and no reset has been done yet");
-        return NULL;
-    }
-
-    nop = NpyIter_GetNOp(self->iter);
-
-    /* Negative indexing */
-    if (i < 0) {
-        i += nop;
-    }
-
-    if (i < 0 || i >= nop) {
-        PyErr_Format(PyExc_IndexError,
-                "Iterator operand index %d is out of bounds", (int)i_orig);
-        return NULL;
-    }
-
-#if 0
-    /*
-     * This check is disabled because it prevents things like
-     * np.add(it[0], it[1], it[2]), where it[2] is a write-only
-     * parameter.  When write-only, the value of it[i] is
-     * likely random junk, as if it were allocated with an
-     * np.empty(...) call.
-     */
-    if (!self->readflags[i]) {
-        PyErr_Format(PyExc_RuntimeError,
-                "Iterator operand %d is write-only", (int)i);
-        return NULL;
-    }
-#endif
-
-    dataptr = self->dataptrs[i];
-    dtype = self->dtypes[i];
-    has_external_loop = NpyIter_HasExternalLoop(self->iter);
-
-    if (has_external_loop) {
-        innerloopsize = *self->innerloopsizeptr;
-        innerstride = self->innerstrides[i];
-        ret_ndim = 1;
-    }
-    else {
-        innerloopsize = 1;
-        innerstride = 0;
-        /* If the iterator is going over every element, return array scalars */
-        ret_ndim = 0;
-    }
-
-    Py_INCREF(dtype);
-    ret = (PyArrayObject *)PyArray_NewFromDescr(&PyArray_Type, dtype,
-                        ret_ndim, &innerloopsize,
-                        &innerstride, dataptr,
-                        self->writeflags[i] ? NPY_ARRAY_WRITEABLE : 0, NULL);
-    if (ret == NULL) {
-        return NULL;
-    }
-    Py_INCREF(self);
-    if (PyArray_SetBaseObject(ret, (PyObject *)self) < 0) {
-        Py_XDECREF(ret);
-        return NULL;
-    }
-
-    PyArray_UpdateFlags(ret, NPY_ARRAY_UPDATE_ALL);
-
-    return (PyObject *)ret;
-}
-
-NPY_NO_EXPORT PyObject *
-npyiter_seq_slice(NewNpyArrayIterObject *self,
-                    Py_ssize_t ilow, Py_ssize_t ihigh)
-{
-    PyObject *ret;
-    npy_intp nop;
-    Py_ssize_t i;
-
-    if (self->iter == NULL || self->finished) {
-        PyErr_SetString(PyExc_ValueError,
-                "Iterator is past the end");
-        return NULL;
-    }
-
-    if (NpyIter_HasDelayedBufAlloc(self->iter)) {
-        PyErr_SetString(PyExc_ValueError,
-                "Iterator construction used delayed buffer allocation, "
-                "and no reset has been done yet");
-        return NULL;
-    }
-
-    nop = NpyIter_GetNOp(self->iter);
-    if (ilow < 0) {
-        ilow = 0;
-    }
-    else if (ilow >= nop) {
-        ilow = nop-1;
-    }
-    if (ihigh < ilow) {
-        ihigh = ilow;
-    }
-    else if (ihigh > nop) {
-        ihigh = nop;
-    }
-
-    ret = PyTuple_New(ihigh-ilow);
-    if (ret == NULL) {
-        return NULL;
-    }
-    for (i = ilow; i < ihigh ; ++i) {
-        PyObject *item = npyiter_seq_item(self, i);
-        if (item == NULL) {
-            Py_DECREF(ret);
-            return NULL;
-        }
-        PyTuple_SET_ITEM(ret, i-ilow, item);
-    }
-    return ret;
-}
-
-NPY_NO_EXPORT int
-npyiter_seq_ass_item(NewNpyArrayIterObject *self, Py_ssize_t i, PyObject *v)
-{
-
-    npy_intp nop, innerloopsize, innerstride;
-    char *dataptr;
-    PyArray_Descr *dtype;
-    PyArrayObject *tmp;
-    int ret, has_external_loop;
-    Py_ssize_t i_orig = i;
-
-
-    if (v == NULL) {
-        PyErr_SetString(PyExc_TypeError,
-                "Cannot delete iterator elements");
-        return -1;
-    }
-
-    if (self->iter == NULL || self->finished) {
-        PyErr_SetString(PyExc_ValueError,
-                "Iterator is past the end");
-        return -1;
-    }
-
-    if (NpyIter_HasDelayedBufAlloc(self->iter)) {
-        PyErr_SetString(PyExc_ValueError,
-                "Iterator construction used delayed buffer allocation, "
-                "and no reset has been done yet");
-        return -1;
-    }
-
-    nop = NpyIter_GetNOp(self->iter);
-
-    /* Negative indexing */
-    if (i < 0) {
-        i += nop;
-    }
-
-    if (i < 0 || i >= nop) {
-        PyErr_Format(PyExc_IndexError,
-                "Iterator operand index %d is out of bounds", (int)i_orig);
-        return -1;
-    }
-    if (!self->writeflags[i]) {
-        PyErr_Format(PyExc_RuntimeError,
-                "Iterator operand %d is not writeable", (int)i_orig);
-        return -1;
-    }
-
-    dataptr = self->dataptrs[i];
-    dtype = self->dtypes[i];
-    has_external_loop = NpyIter_HasExternalLoop(self->iter);
-
-    if (has_external_loop) {
-        innerloopsize = *self->innerloopsizeptr;
-        innerstride = self->innerstrides[i];
-    }
-    else {
-        innerloopsize = 1;
-        innerstride = 0;
-    }
-
-    /* TODO - there should be a better way than this... */
-    Py_INCREF(dtype);
-    tmp = (PyArrayObject *)PyArray_NewFromDescr(&PyArray_Type, dtype,
-                                1, &innerloopsize,
-                                &innerstride, dataptr,
-                                NPY_ARRAY_WRITEABLE, NULL);
-    if (tmp == NULL) {
-        return -1;
-    }
-
-    PyArray_UpdateFlags(tmp, NPY_ARRAY_UPDATE_ALL);
-
-    ret = PyArray_CopyObject(tmp, v);
-    Py_DECREF(tmp);
-    return ret;
-}
-
-static int
-npyiter_seq_ass_slice(NewNpyArrayIterObject *self, Py_ssize_t ilow,
-                Py_ssize_t ihigh, PyObject *v)
-{
-    npy_intp nop;
-    Py_ssize_t i;
-
-    if (v == NULL) {
-        PyErr_SetString(PyExc_TypeError,
-                "Cannot delete iterator elements");
-        return -1;
-    }
-
-    if (self->iter == NULL || self->finished) {
-        PyErr_SetString(PyExc_ValueError,
-                "Iterator is past the end");
-        return -1;
-    }
-
-    if (NpyIter_HasDelayedBufAlloc(self->iter)) {
-        PyErr_SetString(PyExc_ValueError,
-                "Iterator construction used delayed buffer allocation, "
-                "and no reset has been done yet");
-        return -1;
-    }
-
-    nop = NpyIter_GetNOp(self->iter);
-    if (ilow < 0) {
-        ilow = 0;
-    }
-    else if (ilow >= nop) {
-        ilow = nop-1;
-    }
-    if (ihigh < ilow) {
-        ihigh = ilow;
-    }
-    else if (ihigh > nop) {
-        ihigh = nop;
-    }
-
-    if (!PySequence_Check(v) || PySequence_Size(v) != ihigh-ilow) {
-        PyErr_SetString(PyExc_ValueError,
-                "Wrong size to assign to iterator slice");
-        return -1;
-    }
-
-    for (i = ilow; i < ihigh ; ++i) {
-        PyObject *item = PySequence_GetItem(v, i-ilow);
-        if (item == NULL) {
-            return -1;
-        }
-        if (npyiter_seq_ass_item(self, i, item) < 0) {
-            Py_DECREF(item);
-            return -1;
-        }
-        Py_DECREF(item);
-    }
-
-    return 0;
-}
-
-static PyObject *
-npyiter_subscript(NewNpyArrayIterObject *self, PyObject *op)
-{
-    if (self->iter == NULL || self->finished) {
-        PyErr_SetString(PyExc_ValueError,
-                "Iterator is past the end");
-        return NULL;
-    }
-
-    if (NpyIter_HasDelayedBufAlloc(self->iter)) {
-        PyErr_SetString(PyExc_ValueError,
-                "Iterator construction used delayed buffer allocation, "
-                "and no reset has been done yet");
-        return NULL;
-    }
-
-    if (PyInt_Check(op) || PyLong_Check(op) ||
-                    (PyIndex_Check(op) && !PySequence_Check(op))) {
-        npy_intp i = PyArray_PyIntAsIntp(op);
-        if (i == -1 && PyErr_Occurred()) {
-            return NULL;
-        }
-        return npyiter_seq_item(self, i);
-    }
-    else if (PySlice_Check(op)) {
-        Py_ssize_t istart = 0, iend = 0, istep = 0;
-        if (PySlice_GetIndices((PySliceObject *)op,
-                            NpyIter_GetNOp(self->iter),
-                            &istart, &iend, &istep) < 0) {
-            return NULL;
-        }
-        if (istep != 1) {
-            PyErr_SetString(PyExc_ValueError,
-                    "Iterator slicing only supports a step of 1");
-            return NULL;
-        }
-        return npyiter_seq_slice(self, istart, iend);
-    }
-
-    PyErr_SetString(PyExc_TypeError,
-            "invalid index type for iterator indexing");
-    return NULL;
-}
-
-static int
-npyiter_ass_subscript(NewNpyArrayIterObject *self, PyObject *op,
-                        PyObject *value)
-{
-    if (value == NULL) {
-        PyErr_SetString(PyExc_TypeError,
-                "Cannot delete iterator elements");
-        return -1;
-    }
-    if (self->iter == NULL || self->finished) {
-        PyErr_SetString(PyExc_ValueError,
-                "Iterator is past the end");
-        return -1;
-    }
-
-    if (NpyIter_HasDelayedBufAlloc(self->iter)) {
-        PyErr_SetString(PyExc_ValueError,
-                "Iterator construction used delayed buffer allocation, "
-                "and no reset has been done yet");
-        return -1;
-    }
-
-    if (PyInt_Check(op) || PyLong_Check(op) ||
-                    (PyIndex_Check(op) && !PySequence_Check(op))) {
-        npy_intp i = PyArray_PyIntAsIntp(op);
-        if (i == -1 && PyErr_Occurred()) {
-            return -1;
-        }
-        return npyiter_seq_ass_item(self, i, value);
-    }
-    else if (PySlice_Check(op)) {
-        Py_ssize_t istart = 0, iend = 0, istep = 0;
-        if (PySlice_GetIndices((PySliceObject *)op,
-                            NpyIter_GetNOp(self->iter),
-                            &istart, &iend, &istep) < 0) {
-            return -1;
-        }
-        if (istep != 1) {
-            PyErr_SetString(PyExc_ValueError,
-                    "Iterator slice assignment only supports a step of 1");
-            return -1;
-        }
-        return npyiter_seq_ass_slice(self, istart, iend, value);
-    }
-
-    PyErr_SetString(PyExc_TypeError,
-            "invalid index type for iterator indexing");
-    return -1;
-}
-
-static PyMethodDef npyiter_methods[] = {
-    {"reset",
-        (PyCFunction)npyiter_reset,
-        METH_NOARGS, NULL},
-    {"copy",
-        (PyCFunction)npyiter_copy,
-        METH_NOARGS, NULL},
-    {"__copy__",
-        (PyCFunction)npyiter_copy,
-        METH_NOARGS, NULL},
-    {"iternext",
-        (PyCFunction)npyiter_iternext,
-        METH_NOARGS, NULL},
-    {"remove_axis",
-        (PyCFunction)npyiter_remove_axis,
-        METH_VARARGS, NULL},
-    {"remove_multi_index",
-        (PyCFunction)npyiter_remove_multi_index,
-        METH_NOARGS, NULL},
-    {"enable_external_loop",
-        (PyCFunction)npyiter_enable_external_loop,
-        METH_NOARGS, NULL},
-    {"debug_print",
-        (PyCFunction)npyiter_debug_print,
-        METH_NOARGS, NULL},
-    {NULL, NULL, 0, NULL},
-};
-
-static PyMemberDef npyiter_members[] = {
-    {NULL, 0, 0, 0, NULL},
-};
-
-static PyGetSetDef npyiter_getsets[] = {
-    {"value",
-        (getter)npyiter_value_get,
-        NULL, NULL, NULL},
-    {"shape",
-        (getter)npyiter_shape_get,
-        NULL, NULL, NULL},
-    {"multi_index",
-        (getter)npyiter_multi_index_get,
-        (setter)npyiter_multi_index_set,
-        NULL, NULL},
-    {"index",
-        (getter)npyiter_index_get,
-        (setter)npyiter_index_set,
-        NULL, NULL},
-    {"iterindex",
-        (getter)npyiter_iterindex_get,
-        (setter)npyiter_iterindex_set,
-        NULL, NULL},
-    {"iterrange",
-        (getter)npyiter_iterrange_get,
-        (setter)npyiter_iterrange_set,
-        NULL, NULL},
-    {"operands",
-        (getter)npyiter_operands_get,
-        NULL, NULL, NULL},
-    {"itviews",
-        (getter)npyiter_itviews_get,
-        NULL, NULL, NULL},
-    {"has_delayed_bufalloc",
-        (getter)npyiter_has_delayed_bufalloc_get,
-        NULL, NULL, NULL},
-    {"iterationneedsapi",
-        (getter)npyiter_iterationneedsapi_get,
-        NULL, NULL, NULL},
-    {"has_multi_index",
-        (getter)npyiter_has_multi_index_get,
-        NULL, NULL, NULL},
-    {"has_index",
-        (getter)npyiter_has_index_get,
-        NULL, NULL, NULL},
-    {"dtypes",
-        (getter)npyiter_dtypes_get,
-        NULL, NULL, NULL},
-    {"ndim",
-        (getter)npyiter_ndim_get,
-        NULL, NULL, NULL},
-    {"nop",
-        (getter)npyiter_nop_get,
-        NULL, NULL, NULL},
-    {"itersize",
-        (getter)npyiter_itersize_get,
-        NULL, NULL, NULL},
-    {"finished",
-        (getter)npyiter_finished_get,
-        NULL, NULL, NULL},
-
-    {NULL, NULL, NULL, NULL, NULL}
-};
-
-NPY_NO_EXPORT PySequenceMethods npyiter_as_sequence = {
-    (lenfunc)npyiter_seq_length,            /*sq_length*/
-    (binaryfunc)NULL,                       /*sq_concat*/
-    (ssizeargfunc)NULL,                     /*sq_repeat*/
-    (ssizeargfunc)npyiter_seq_item,         /*sq_item*/
-    (ssizessizeargfunc)npyiter_seq_slice,   /*sq_slice*/
-    (ssizeobjargproc)npyiter_seq_ass_item,  /*sq_ass_item*/
-    (ssizessizeobjargproc)npyiter_seq_ass_slice,/*sq_ass_slice*/
-    (objobjproc)NULL,                       /*sq_contains */
-    (binaryfunc)NULL,                       /*sq_inplace_concat */
-    (ssizeargfunc)NULL,                     /*sq_inplace_repeat */
-};
-
-NPY_NO_EXPORT PyMappingMethods npyiter_as_mapping = {
-    (lenfunc)npyiter_seq_length,          /*mp_length*/
-    (binaryfunc)npyiter_subscript,        /*mp_subscript*/
-    (objobjargproc)npyiter_ass_subscript, /*mp_ass_subscript*/
-};
-
-NPY_NO_EXPORT PyTypeObject NpyIter_Type = {
-#if defined(NPY_PY3K)
-    PyVarObject_HEAD_INIT(NULL, 0)
-#else
-    PyObject_HEAD_INIT(NULL)
-    0,                                          /* ob_size */
-#endif
-    "numpy.nditer",                             /* tp_name */
-    sizeof(NewNpyArrayIterObject),              /* tp_basicsize */
-    0,                                          /* tp_itemsize */
-    /* methods */
-    (destructor)npyiter_dealloc,                /* tp_dealloc */
-    0,                                          /* tp_print */
-    0,                                          /* tp_getattr */
-    0,                                          /* tp_setattr */
-#if defined(NPY_PY3K)
-    0,                                          /* tp_reserved */
-#else
-    0,                                          /* tp_compare */
-#endif
-    0,                                          /* tp_repr */
-    0,                                          /* tp_as_number */
-    &npyiter_as_sequence,                       /* tp_as_sequence */
-    &npyiter_as_mapping,                        /* tp_as_mapping */
-    0,                                          /* tp_hash */
-    0,                                          /* tp_call */
-    0,                                          /* tp_str */
-    0,                                          /* tp_getattro */
-    0,                                          /* tp_setattro */
-    0,                                          /* tp_as_buffer */
-    Py_TPFLAGS_DEFAULT,                         /* tp_flags */
-    0,                                          /* tp_doc */
-    0,                                          /* tp_traverse */
-    0,                                          /* tp_clear */
-    0,                                          /* tp_richcompare */
-    0,                                          /* tp_weaklistoffset */
-    0,                                          /* tp_iter */
-    (iternextfunc)npyiter_next,                 /* tp_iternext */
-    npyiter_methods,                            /* tp_methods */
-    npyiter_members,                            /* tp_members */
-    npyiter_getsets,                            /* tp_getset */
-    0,                                          /* tp_base */
-    0,                                          /* tp_dict */
-    0,                                          /* tp_descr_get */
-    0,                                          /* tp_descr_set */
-    0,                                          /* tp_dictoffset */
-    (initproc)npyiter_init,                     /* tp_init */
-    0,                                          /* tp_alloc */
-    npyiter_new,                                /* tp_new */
-    0,                                          /* tp_free */
-    0,                                          /* tp_is_gc */
-    0,                                          /* tp_bases */
-    0,                                          /* tp_mro */
-    0,                                          /* tp_cache */
-    0,                                          /* tp_subclasses */
-    0,                                          /* tp_weaklist */
-    0,                                          /* tp_del */
-    0,                                          /* tp_version_tag */
-};