Put multiarray modul sources into separate directory.

1 files changed, 0 insertions, 807 deletions

diff --git a/numpy/core/src/arraynumber.c b/numpy/core/src/arraynumber.c
deleted file mode 100644
index aa3e250cb..000000000
--- a/numpy/core/src/arraynumber.c
+++ /dev/null
@@ -1,807 +0,0 @@
-#define PY_SSIZE_T_CLEAN
-#include <Python.h>
-#include "structmember.h"
-
-/*#include <stdio.h>*/
-#define _MULTIARRAYMODULE
-#define NPY_NO_PREFIX
-#include "numpy/arrayobject.h"
-
-#include "arrayobject.h"
-#include "arraynumber.h"
-
-/*************************************************************************
- ****************   Implement Number Protocol ****************************
- *************************************************************************/
-
-NPY_NO_EXPORT NumericOps n_ops; /* NB: static objects initialized to zero */
-
-/* Dictionary can contain any of the numeric operations, by name.
-   Those not present will not be changed
-*/
-
-#define SET(op)   temp=PyDict_GetItemString(dict, #op); \
-    if (temp != NULL) {                                 \
-        if (!(PyCallable_Check(temp))) return -1;       \
-        Py_XDECREF(n_ops.op);                           \
-        n_ops.op = temp;                                \
-    }
-
-
-/*NUMPY_API
-  Set internal structure with number functions that all arrays will use
-*/
-NPY_NO_EXPORT int
-PyArray_SetNumericOps(PyObject *dict)
-{
-    PyObject *temp = NULL;
-    SET(add);
-    SET(subtract);
-    SET(multiply);
-    SET(divide);
-    SET(remainder);
-    SET(power);
-    SET(square);
-    SET(reciprocal);
-    SET(ones_like);
-    SET(sqrt);
-    SET(negative);
-    SET(absolute);
-    SET(invert);
-    SET(left_shift);
-    SET(right_shift);
-    SET(bitwise_and);
-    SET(bitwise_or);
-    SET(bitwise_xor);
-    SET(less);
-    SET(less_equal);
-    SET(equal);
-    SET(not_equal);
-    SET(greater);
-    SET(greater_equal);
-    SET(floor_divide);
-    SET(true_divide);
-    SET(logical_or);
-    SET(logical_and);
-    SET(floor);
-    SET(ceil);
-    SET(maximum);
-    SET(minimum);
-    SET(rint);
-    SET(conjugate);
-    return 0;
-}
-
-#define GET(op) if (n_ops.op &&                                         \
-                    (PyDict_SetItemString(dict, #op, n_ops.op)==-1))    \
-        goto fail;
-
-/*NUMPY_API
-  Get dictionary showing number functions that all arrays will use
-*/
-NPY_NO_EXPORT PyObject *
-PyArray_GetNumericOps(void)
-{
-    PyObject *dict;
-    if ((dict = PyDict_New())==NULL)
-        return NULL;
-    GET(add);
-    GET(subtract);
-    GET(multiply);
-    GET(divide);
-    GET(remainder);
-    GET(power);
-    GET(square);
-    GET(reciprocal);
-    GET(ones_like);
-    GET(sqrt);
-    GET(negative);
-    GET(absolute);
-    GET(invert);
-    GET(left_shift);
-    GET(right_shift);
-    GET(bitwise_and);
-    GET(bitwise_or);
-    GET(bitwise_xor);
-    GET(less);
-    GET(less_equal);
-    GET(equal);
-    GET(not_equal);
-    GET(greater);
-    GET(greater_equal);
-    GET(floor_divide);
-    GET(true_divide);
-    GET(logical_or);
-    GET(logical_and);
-    GET(floor);
-    GET(ceil);
-    GET(maximum);
-    GET(minimum);
-    GET(rint);
-    GET(conjugate);
-    return dict;
-
- fail:
-    Py_DECREF(dict);
-    return NULL;
-}
-
-static PyObject *
-_get_keywords(int rtype, PyArrayObject *out)
-{
-    PyObject *kwds = NULL;
-    if (rtype != PyArray_NOTYPE || out != NULL) {
-        kwds = PyDict_New();
-        if (rtype != PyArray_NOTYPE) {
-            PyArray_Descr *descr;
-            descr = PyArray_DescrFromType(rtype);
-            if (descr) {
-                PyDict_SetItemString(kwds, "dtype", (PyObject *)descr);
-                Py_DECREF(descr);
-            }
-        }
-        if (out != NULL) {
-            PyDict_SetItemString(kwds, "out", (PyObject *)out);
-        }
-    }
-    return kwds;
-}
-
-NPY_NO_EXPORT PyObject *
-PyArray_GenericReduceFunction(PyArrayObject *m1, PyObject *op, int axis,
-                              int rtype, PyArrayObject *out)
-{
-    PyObject *args, *ret = NULL, *meth;
-    PyObject *kwds;
-    if (op == NULL) {
-        Py_INCREF(Py_NotImplemented);
-        return Py_NotImplemented;
-    }
-    args = Py_BuildValue("(Oi)", m1, axis);
-    kwds = _get_keywords(rtype, out);
-    meth = PyObject_GetAttrString(op, "reduce");
-    if (meth && PyCallable_Check(meth)) {
-        ret = PyObject_Call(meth, args, kwds);
-    }
-    Py_DECREF(args);
-    Py_DECREF(meth);
-    Py_XDECREF(kwds);
-    return ret;
-}
-
-
-NPY_NO_EXPORT PyObject *
-PyArray_GenericAccumulateFunction(PyArrayObject *m1, PyObject *op, int axis,
-                                  int rtype, PyArrayObject *out)
-{
-    PyObject *args, *ret = NULL, *meth;
-    PyObject *kwds;
-    if (op == NULL) {
-        Py_INCREF(Py_NotImplemented);
-        return Py_NotImplemented;
-    }
-    args = Py_BuildValue("(Oi)", m1, axis);
-    kwds = _get_keywords(rtype, out);
-    meth = PyObject_GetAttrString(op, "accumulate");
-    if (meth && PyCallable_Check(meth)) {
-        ret = PyObject_Call(meth, args, kwds);
-    }
-    Py_DECREF(args);
-    Py_DECREF(meth);
-    Py_XDECREF(kwds);
-    return ret;
-}
-
-
-NPY_NO_EXPORT PyObject *
-PyArray_GenericBinaryFunction(PyArrayObject *m1, PyObject *m2, PyObject *op)
-{
-    if (op == NULL) {
-        Py_INCREF(Py_NotImplemented);
-        return Py_NotImplemented;
-    }
-    return PyObject_CallFunction(op, "OO", m1, m2);
-}
-
-NPY_NO_EXPORT PyObject *
-PyArray_GenericUnaryFunction(PyArrayObject *m1, PyObject *op)
-{
-    if (op == NULL) {
-        Py_INCREF(Py_NotImplemented);
-        return Py_NotImplemented;
-    }
-    return PyObject_CallFunction(op, "(O)", m1);
-}
-
-static PyObject *
-PyArray_GenericInplaceBinaryFunction(PyArrayObject *m1,
-                                     PyObject *m2, PyObject *op)
-{
-    if (op == NULL) {
-        Py_INCREF(Py_NotImplemented);
-        return Py_NotImplemented;
-    }
-    return PyObject_CallFunction(op, "OOO", m1, m2, m1);
-}
-
-static PyObject *
-PyArray_GenericInplaceUnaryFunction(PyArrayObject *m1, PyObject *op)
-{
-    if (op == NULL) {
-        Py_INCREF(Py_NotImplemented);
-        return Py_NotImplemented;
-    }
-    return PyObject_CallFunction(op, "OO", m1, m1);
-}
-
-static PyObject *
-array_add(PyArrayObject *m1, PyObject *m2)
-{
-    return PyArray_GenericBinaryFunction(m1, m2, n_ops.add);
-}
-
-static PyObject *
-array_subtract(PyArrayObject *m1, PyObject *m2)
-{
-    return PyArray_GenericBinaryFunction(m1, m2, n_ops.subtract);
-}
-
-static PyObject *
-array_multiply(PyArrayObject *m1, PyObject *m2)
-{
-    return PyArray_GenericBinaryFunction(m1, m2, n_ops.multiply);
-}
-
-static PyObject *
-array_divide(PyArrayObject *m1, PyObject *m2)
-{
-    return PyArray_GenericBinaryFunction(m1, m2, n_ops.divide);
-}
-
-static PyObject *
-array_remainder(PyArrayObject *m1, PyObject *m2)
-{
-    return PyArray_GenericBinaryFunction(m1, m2, n_ops.remainder);
-}
-
-static int
-array_power_is_scalar(PyObject *o2, double* exp)
-{
-    PyObject *temp;
-    const int optimize_fpexps = 1;
-
-    if (PyInt_Check(o2)) {
-        *exp = (double)PyInt_AsLong(o2);
-        return 1;
-    }
-    if (optimize_fpexps && PyFloat_Check(o2)) {
-        *exp = PyFloat_AsDouble(o2);
-        return 1;
-    }
-    if ((PyArray_IsZeroDim(o2) &&
-         ((PyArray_ISINTEGER(o2) ||
-           (optimize_fpexps && PyArray_ISFLOAT(o2))))) ||
-        PyArray_IsScalar(o2, Integer) ||
-        (optimize_fpexps && PyArray_IsScalar(o2, Floating))) {
-        temp = o2->ob_type->tp_as_number->nb_float(o2);
-        if (temp != NULL) {
-            *exp = PyFloat_AsDouble(o2);
-            Py_DECREF(temp);
-            return 1;
-        }
-    }
-#if (PY_VERSION_HEX >= 0x02050000)
-    if (PyIndex_Check(o2)) {
-        PyObject* value = PyNumber_Index(o2);
-        Py_ssize_t val;
-        if (value==NULL) {
-            if (PyErr_Occurred()) {
-                PyErr_Clear();
-            }
-            return 0;
-        }
-        val = PyInt_AsSsize_t(value);
-        if (val == -1 && PyErr_Occurred()) {
-            PyErr_Clear();
-            return 0;
-        }
-        *exp = (double) val;
-        return 1;
-    }
-#endif
-    return 0;
-}
-
-/* optimize float array or complex array to a scalar power */
-static PyObject *
-fast_scalar_power(PyArrayObject *a1, PyObject *o2, int inplace)
-{
-    double exp;
-
-    if (PyArray_Check(a1) && array_power_is_scalar(o2, &exp)) {
-        PyObject *fastop = NULL;
-        if (PyArray_ISFLOAT(a1) || PyArray_ISCOMPLEX(a1)) {
-            if (exp == 1.0) {
-                /* we have to do this one special, as the
-                   "copy" method of array objects isn't set
-                   up early enough to be added
-                   by PyArray_SetNumericOps.
-                */
-                if (inplace) {
-                    Py_INCREF(a1);
-                    return (PyObject *)a1;
-                } else {
-                    return PyArray_Copy(a1);
-                }
-            }
-            else if (exp == -1.0) {
-                fastop = n_ops.reciprocal;
-            }
-            else if (exp ==  0.0) {
-                fastop = n_ops.ones_like;
-            }
-            else if (exp ==  0.5) {
-                fastop = n_ops.sqrt;
-            }
-            else if (exp ==  2.0) {
-                fastop = n_ops.square;
-            }
-            else {
-                return NULL;
-            }
-
-            if (inplace) {
-                return PyArray_GenericInplaceUnaryFunction(a1, fastop);
-            } else {
-                return PyArray_GenericUnaryFunction(a1, fastop);
-            }
-        }
-        else if (exp==2.0) {
-            fastop = n_ops.multiply;
-            if (inplace) {
-                return PyArray_GenericInplaceBinaryFunction
-                    (a1, (PyObject *)a1, fastop);
-            }
-            else {
-                return PyArray_GenericBinaryFunction
-                    (a1, (PyObject *)a1, fastop);
-            }
-        }
-    }
-    return NULL;
-}
-
-static PyObject *
-array_power(PyArrayObject *a1, PyObject *o2, PyObject *NPY_UNUSED(modulo))
-{
-    /* modulo is ignored! */
-    PyObject *value;
-    value = fast_scalar_power(a1, o2, 0);
-    if (!value) {
-        value = PyArray_GenericBinaryFunction(a1, o2, n_ops.power);
-    }
-    return value;
-}
-
-
-static PyObject *
-array_negative(PyArrayObject *m1)
-{
-    return PyArray_GenericUnaryFunction(m1, n_ops.negative);
-}
-
-static PyObject *
-array_absolute(PyArrayObject *m1)
-{
-    return PyArray_GenericUnaryFunction(m1, n_ops.absolute);
-}
-
-static PyObject *
-array_invert(PyArrayObject *m1)
-{
-    return PyArray_GenericUnaryFunction(m1, n_ops.invert);
-}
-
-static PyObject *
-array_left_shift(PyArrayObject *m1, PyObject *m2)
-{
-    return PyArray_GenericBinaryFunction(m1, m2, n_ops.left_shift);
-}
-
-static PyObject *
-array_right_shift(PyArrayObject *m1, PyObject *m2)
-{
-    return PyArray_GenericBinaryFunction(m1, m2, n_ops.right_shift);
-}
-
-static PyObject *
-array_bitwise_and(PyArrayObject *m1, PyObject *m2)
-{
-    return PyArray_GenericBinaryFunction(m1, m2, n_ops.bitwise_and);
-}
-
-static PyObject *
-array_bitwise_or(PyArrayObject *m1, PyObject *m2)
-{
-    return PyArray_GenericBinaryFunction(m1, m2, n_ops.bitwise_or);
-}
-
-static PyObject *
-array_bitwise_xor(PyArrayObject *m1, PyObject *m2)
-{
-    return PyArray_GenericBinaryFunction(m1, m2, n_ops.bitwise_xor);
-}
-
-static PyObject *
-array_inplace_add(PyArrayObject *m1, PyObject *m2)
-{
-    return PyArray_GenericInplaceBinaryFunction(m1, m2, n_ops.add);
-}
-
-static PyObject *
-array_inplace_subtract(PyArrayObject *m1, PyObject *m2)
-{
-    return PyArray_GenericInplaceBinaryFunction(m1, m2, n_ops.subtract);
-}
-
-static PyObject *
-array_inplace_multiply(PyArrayObject *m1, PyObject *m2)
-{
-    return PyArray_GenericInplaceBinaryFunction(m1, m2, n_ops.multiply);
-}
-
-static PyObject *
-array_inplace_divide(PyArrayObject *m1, PyObject *m2)
-{
-    return PyArray_GenericInplaceBinaryFunction(m1, m2, n_ops.divide);
-}
-
-static PyObject *
-array_inplace_remainder(PyArrayObject *m1, PyObject *m2)
-{
-    return PyArray_GenericInplaceBinaryFunction(m1, m2, n_ops.remainder);
-}
-
-static PyObject *
-array_inplace_power(PyArrayObject *a1, PyObject *o2, PyObject *NPY_UNUSED(modulo))
-{
-    /* modulo is ignored! */
-    PyObject *value;
-    value = fast_scalar_power(a1, o2, 1);
-    if (!value) {
-        value = PyArray_GenericInplaceBinaryFunction(a1, o2, n_ops.power);
-    }
-    return value;
-}
-
-static PyObject *
-array_inplace_left_shift(PyArrayObject *m1, PyObject *m2)
-{
-    return PyArray_GenericInplaceBinaryFunction(m1, m2, n_ops.left_shift);
-}
-
-static PyObject *
-array_inplace_right_shift(PyArrayObject *m1, PyObject *m2)
-{
-    return PyArray_GenericInplaceBinaryFunction(m1, m2, n_ops.right_shift);
-}
-
-static PyObject *
-array_inplace_bitwise_and(PyArrayObject *m1, PyObject *m2)
-{
-    return PyArray_GenericInplaceBinaryFunction(m1, m2, n_ops.bitwise_and);
-}
-
-static PyObject *
-array_inplace_bitwise_or(PyArrayObject *m1, PyObject *m2)
-{
-    return PyArray_GenericInplaceBinaryFunction(m1, m2, n_ops.bitwise_or);
-}
-
-static PyObject *
-array_inplace_bitwise_xor(PyArrayObject *m1, PyObject *m2)
-{
-    return PyArray_GenericInplaceBinaryFunction(m1, m2, n_ops.bitwise_xor);
-}
-
-static PyObject *
-array_floor_divide(PyArrayObject *m1, PyObject *m2)
-{
-    return PyArray_GenericBinaryFunction(m1, m2, n_ops.floor_divide);
-}
-
-static PyObject *
-array_true_divide(PyArrayObject *m1, PyObject *m2)
-{
-    return PyArray_GenericBinaryFunction(m1, m2, n_ops.true_divide);
-}
-
-static PyObject *
-array_inplace_floor_divide(PyArrayObject *m1, PyObject *m2)
-{
-    return PyArray_GenericInplaceBinaryFunction(m1, m2,
-                                                n_ops.floor_divide);
-}
-
-static PyObject *
-array_inplace_true_divide(PyArrayObject *m1, PyObject *m2)
-{
-    return PyArray_GenericInplaceBinaryFunction(m1, m2,
-                                                n_ops.true_divide);
-}
-
-/* Array evaluates as "TRUE" if any of the elements are non-zero*/
-NPY_NO_EXPORT int
-array_any_nonzero(PyArrayObject *mp)
-{
-    intp index;
-    PyArrayIterObject *it;
-    Bool anyTRUE = FALSE;
-
-    it = (PyArrayIterObject *)PyArray_IterNew((PyObject *)mp);
-    if (it == NULL) {
-        return anyTRUE;
-    }
-    index = it->size;
-    while(index--) {
-        if (mp->descr->f->nonzero(it->dataptr, mp)) {
-            anyTRUE = TRUE;
-            break;
-        }
-        PyArray_ITER_NEXT(it);
-    }
-    Py_DECREF(it);
-    return anyTRUE;
-}
-
-static int
-_array_nonzero(PyArrayObject *mp)
-{
-    intp n;
-
-    n = PyArray_SIZE(mp);
-    if (n == 1) {
-        return mp->descr->f->nonzero(mp->data, mp);
-    }
-    else if (n == 0) {
-        return 0;
-    }
-    else {
-        PyErr_SetString(PyExc_ValueError,
-                        "The truth value of an array " \
-                        "with more than one element is ambiguous. " \
-                        "Use a.any() or a.all()");
-        return -1;
-    }
-}
-
-
-
-static PyObject *
-array_divmod(PyArrayObject *op1, PyObject *op2)
-{
-    PyObject *divp, *modp, *result;
-
-    divp = array_floor_divide(op1, op2);
-    if (divp == NULL) {
-        return NULL;
-    }
-    modp = array_remainder(op1, op2);
-    if (modp == NULL) {
-        Py_DECREF(divp);
-        return NULL;
-    }
-    result = Py_BuildValue("OO", divp, modp);
-    Py_DECREF(divp);
-    Py_DECREF(modp);
-    return result;
-}
-
-
-NPY_NO_EXPORT PyObject *
-array_int(PyArrayObject *v)
-{
-    PyObject *pv, *pv2;
-    if (PyArray_SIZE(v) != 1) {
-        PyErr_SetString(PyExc_TypeError, "only length-1 arrays can be"\
-                        " converted to Python scalars");
-        return NULL;
-    }
-    pv = v->descr->f->getitem(v->data, v);
-    if (pv == NULL) {
-        return NULL;
-    }
-    if (pv->ob_type->tp_as_number == 0) {
-        PyErr_SetString(PyExc_TypeError, "cannot convert to an int; "\
-                        "scalar object is not a number");
-        Py_DECREF(pv);
-        return NULL;
-    }
-    if (pv->ob_type->tp_as_number->nb_int == 0) {
-        PyErr_SetString(PyExc_TypeError, "don't know how to convert "\
-                        "scalar number to int");
-        Py_DECREF(pv);
-        return NULL;
-    }
-
-    pv2 = pv->ob_type->tp_as_number->nb_int(pv);
-    Py_DECREF(pv);
-    return pv2;
-}
-
-static PyObject *
-array_float(PyArrayObject *v)
-{
-    PyObject *pv, *pv2;
-    if (PyArray_SIZE(v) != 1) {
-        PyErr_SetString(PyExc_TypeError, "only length-1 arrays can "\
-                        "be converted to Python scalars");
-        return NULL;
-    }
-    pv = v->descr->f->getitem(v->data, v);
-    if (pv == NULL) {
-        return NULL;
-    }
-    if (pv->ob_type->tp_as_number == 0) {
-        PyErr_SetString(PyExc_TypeError, "cannot convert to a "\
-                        "float; scalar object is not a number");
-        Py_DECREF(pv);
-        return NULL;
-    }
-    if (pv->ob_type->tp_as_number->nb_float == 0) {
-        PyErr_SetString(PyExc_TypeError, "don't know how to convert "\
-                        "scalar number to float");
-        Py_DECREF(pv);
-        return NULL;
-    }
-    pv2 = pv->ob_type->tp_as_number->nb_float(pv);
-    Py_DECREF(pv);
-    return pv2;
-}
-
-static PyObject *
-array_long(PyArrayObject *v)
-{
-    PyObject *pv, *pv2;
-    if (PyArray_SIZE(v) != 1) {
-        PyErr_SetString(PyExc_TypeError, "only length-1 arrays can "\
-                        "be converted to Python scalars");
-        return NULL;
-    }
-    pv = v->descr->f->getitem(v->data, v);
-    if (pv->ob_type->tp_as_number == 0) {
-        PyErr_SetString(PyExc_TypeError, "cannot convert to an int; "\
-                        "scalar object is not a number");
-        return NULL;
-    }
-    if (pv->ob_type->tp_as_number->nb_long == 0) {
-        PyErr_SetString(PyExc_TypeError, "don't know how to convert "\
-                        "scalar number to long");
-        return NULL;
-    }
-    pv2 = pv->ob_type->tp_as_number->nb_long(pv);
-    Py_DECREF(pv);
-    return pv2;
-}
-
-static PyObject *
-array_oct(PyArrayObject *v)
-{
-    PyObject *pv, *pv2;
-    if (PyArray_SIZE(v) != 1) {
-        PyErr_SetString(PyExc_TypeError, "only length-1 arrays can "\
-                        "be converted to Python scalars");
-        return NULL;
-    }
-    pv = v->descr->f->getitem(v->data, v);
-    if (pv->ob_type->tp_as_number == 0) {
-        PyErr_SetString(PyExc_TypeError, "cannot convert to an int; "\
-                        "scalar object is not a number");
-        return NULL;
-    }
-    if (pv->ob_type->tp_as_number->nb_oct == 0) {
-        PyErr_SetString(PyExc_TypeError, "don't know how to convert "\
-                        "scalar number to oct");
-        return NULL;
-    }
-    pv2 = pv->ob_type->tp_as_number->nb_oct(pv);
-    Py_DECREF(pv);
-    return pv2;
-}
-
-static PyObject *
-array_hex(PyArrayObject *v)
-{
-    PyObject *pv, *pv2;
-    if (PyArray_SIZE(v) != 1) {
-        PyErr_SetString(PyExc_TypeError, "only length-1 arrays can "\
-                        "be converted to Python scalars");
-        return NULL;
-    }
-    pv = v->descr->f->getitem(v->data, v);
-    if (pv->ob_type->tp_as_number == 0) {
-        PyErr_SetString(PyExc_TypeError, "cannot convert to an int; "\
-                        "scalar object is not a number");
-        return NULL;
-    }
-    if (pv->ob_type->tp_as_number->nb_hex == 0) {
-        PyErr_SetString(PyExc_TypeError, "don't know how to convert "\
-                        "scalar number to hex");
-        return NULL;
-    }
-    pv2 = pv->ob_type->tp_as_number->nb_hex(pv);
-    Py_DECREF(pv);
-    return pv2;
-}
-
-static PyObject *
-_array_copy_nice(PyArrayObject *self)
-{
-    return PyArray_Return((PyArrayObject *) PyArray_Copy(self));
-}
-
-#if PY_VERSION_HEX >= 0x02050000
-static PyObject *
-array_index(PyArrayObject *v)
-{
-    if (!PyArray_ISINTEGER(v) || PyArray_SIZE(v) != 1) {
-        PyErr_SetString(PyExc_TypeError, "only integer arrays with "     \
-                        "one element can be converted to an index");
-        return NULL;
-    }
-    return v->descr->f->getitem(v->data, v);
-}
-#endif
-
-
-NPY_NO_EXPORT PyNumberMethods array_as_number = {
-    (binaryfunc)array_add,                      /*nb_add*/
-    (binaryfunc)array_subtract,                 /*nb_subtract*/
-    (binaryfunc)array_multiply,                 /*nb_multiply*/
-    (binaryfunc)array_divide,                   /*nb_divide*/
-    (binaryfunc)array_remainder,                /*nb_remainder*/
-    (binaryfunc)array_divmod,                   /*nb_divmod*/
-    (ternaryfunc)array_power,                   /*nb_power*/
-    (unaryfunc)array_negative,                  /*nb_neg*/
-    (unaryfunc)_array_copy_nice,                /*nb_pos*/
-    (unaryfunc)array_absolute,                  /*(unaryfunc)array_abs,*/
-    (inquiry)_array_nonzero,                    /*nb_nonzero*/
-    (unaryfunc)array_invert,                    /*nb_invert*/
-    (binaryfunc)array_left_shift,               /*nb_lshift*/
-    (binaryfunc)array_right_shift,              /*nb_rshift*/
-    (binaryfunc)array_bitwise_and,              /*nb_and*/
-    (binaryfunc)array_bitwise_xor,              /*nb_xor*/
-    (binaryfunc)array_bitwise_or,               /*nb_or*/
-    0,                                          /*nb_coerce*/
-    (unaryfunc)array_int,                       /*nb_int*/
-    (unaryfunc)array_long,                      /*nb_long*/
-    (unaryfunc)array_float,                     /*nb_float*/
-    (unaryfunc)array_oct,                       /*nb_oct*/
-    (unaryfunc)array_hex,                       /*nb_hex*/
-
-    /*
-     * This code adds augmented assignment functionality
-     * that was made available in Python 2.0
-     */
-    (binaryfunc)array_inplace_add,              /*inplace_add*/
-    (binaryfunc)array_inplace_subtract,         /*inplace_subtract*/
-    (binaryfunc)array_inplace_multiply,         /*inplace_multiply*/
-    (binaryfunc)array_inplace_divide,           /*inplace_divide*/
-    (binaryfunc)array_inplace_remainder,        /*inplace_remainder*/
-    (ternaryfunc)array_inplace_power,           /*inplace_power*/
-    (binaryfunc)array_inplace_left_shift,       /*inplace_lshift*/
-    (binaryfunc)array_inplace_right_shift,      /*inplace_rshift*/
-    (binaryfunc)array_inplace_bitwise_and,      /*inplace_and*/
-    (binaryfunc)array_inplace_bitwise_xor,      /*inplace_xor*/
-    (binaryfunc)array_inplace_bitwise_or,       /*inplace_or*/
-
-    (binaryfunc)array_floor_divide,             /*nb_floor_divide*/
-    (binaryfunc)array_true_divide,              /*nb_true_divide*/
-    (binaryfunc)array_inplace_floor_divide,     /*nb_inplace_floor_divide*/
-    (binaryfunc)array_inplace_true_divide,      /*nb_inplace_true_divide*/
-
-#if PY_VERSION_HEX >= 0x02050000
-    (unaryfunc)array_index,                     /* nb_index */
-#endif
-
-};