Merge branch 'replace-old-defines'

* replace-old-defines:
  DOC: clarify numpy version for removal, document sed script better.
  STY: Fix up the 2.0 (1.7) release notes.
  DEP: Deprecate the old_defines.h header and the macros therein.
  UPDATE: Replace macros in old_defines.h by new.
  DOC: numpybook - Replace macro names in old_defines.h with new.
  DOC: Replace references to macros in old_defines with new.
  STY: Replace more found macros in old_defines.h with new.
  ENH: Add sed script that replaces macros in old_defines.h.
  STY: f2py - replace macros in old_defines.h with new.
  STY: linalg - replace macros in old_defines.h with new.
  STY: fft - replace macros in old_defines.h with new.
  STY: lib/src - replace macros in old_defines.h with new.
  STY: core/src - replace macros in old_defines.h with new versions.

49 files changed, 600 insertions, 590 deletions

diff --git a/numpy/core/blasdot/_dotblas.c b/numpy/core/blasdot/_dotblas.c
index 35db1bf1c..23eb33436 100644
--- a/numpy/core/blasdot/_dotblas.c
+++ b/numpy/core/blasdot/_dotblas.c
@@ -17,7 +17,7 @@ static char module_doc[] =
 #define Py_SIZE(o)    (((PyVarObject*)(o))->ob_size)
 #endif
 
-static PyArray_DotFunc *oldFunctions[PyArray_NTYPES];
+static PyArray_DotFunc *oldFunctions[NPY_NTYPES];
 
 static void
 FLOAT_dot(void *a, npy_intp stridea, void *b, npy_intp strideb, void *res,
@@ -32,7 +32,7 @@ FLOAT_dot(void *a, npy_intp stridea, void *b, npy_intp strideb, void *res,
             *((float *)res) = cblas_sdot((int)n, (float *)a, na, (float *)b, nb);
 
     else
-            oldFunctions[PyArray_FLOAT](a, stridea, b, strideb, res, n, tmp);
+            oldFunctions[NPY_FLOAT](a, stridea, b, strideb, res, n, tmp);
 }
 
 static void
@@ -47,7 +47,7 @@ DOUBLE_dot(void *a, npy_intp stridea, void *b, npy_intp strideb, void *res,
         (na >= 0) && (nb >= 0))
             *((double *)res) = cblas_ddot((int)n, (double *)a, na, (double *)b, nb);
     else
-            oldFunctions[PyArray_DOUBLE](a, stridea, b, strideb, res, n, tmp);
+            oldFunctions[NPY_DOUBLE](a, stridea, b, strideb, res, n, tmp);
 }
 
 static void
@@ -63,7 +63,7 @@ CFLOAT_dot(void *a, npy_intp stridea, void *b, npy_intp strideb, void *res,
         (na >= 0) && (nb >= 0))
             cblas_cdotu_sub((int)n, (float *)a, na, (float *)b, nb, (float *)res);
     else
-            oldFunctions[PyArray_CFLOAT](a, stridea, b, strideb, res, n, tmp);
+            oldFunctions[NPY_CFLOAT](a, stridea, b, strideb, res, n, tmp);
 }
 
 static void
@@ -78,7 +78,7 @@ CDOUBLE_dot(void *a, npy_intp stridea, void *b, npy_intp strideb, void *res,
         (na >= 0) && (nb >= 0))
             cblas_zdotu_sub((int)n, (double *)a, na, (double *)b, nb, (double *)res);
     else
-            oldFunctions[PyArray_CDOUBLE](a, stridea, b, strideb, res, n, tmp);
+            oldFunctions[NPY_CDOUBLE](a, stridea, b, strideb, res, n, tmp);
 }
 
 
@@ -97,20 +97,20 @@ dotblas_alterdot(PyObject *NPY_UNUSED(dummy), PyObject *args)
     /* Replace the dot functions to the ones using blas */
 
     if (!altered) {
-        descr = PyArray_DescrFromType(PyArray_FLOAT);
-        oldFunctions[PyArray_FLOAT] = descr->f->dotfunc;
+        descr = PyArray_DescrFromType(NPY_FLOAT);
+        oldFunctions[NPY_FLOAT] = descr->f->dotfunc;
         descr->f->dotfunc = (PyArray_DotFunc *)FLOAT_dot;
 
-        descr = PyArray_DescrFromType(PyArray_DOUBLE);
-        oldFunctions[PyArray_DOUBLE] = descr->f->dotfunc;
+        descr = PyArray_DescrFromType(NPY_DOUBLE);
+        oldFunctions[NPY_DOUBLE] = descr->f->dotfunc;
         descr->f->dotfunc = (PyArray_DotFunc *)DOUBLE_dot;
 
-        descr = PyArray_DescrFromType(PyArray_CFLOAT);
-        oldFunctions[PyArray_CFLOAT] = descr->f->dotfunc;
+        descr = PyArray_DescrFromType(NPY_CFLOAT);
+        oldFunctions[NPY_CFLOAT] = descr->f->dotfunc;
         descr->f->dotfunc = (PyArray_DotFunc *)CFLOAT_dot;
 
-        descr = PyArray_DescrFromType(PyArray_CDOUBLE);
-        oldFunctions[PyArray_CDOUBLE] = descr->f->dotfunc;
+        descr = PyArray_DescrFromType(NPY_CDOUBLE);
+        oldFunctions[NPY_CDOUBLE] = descr->f->dotfunc;
         descr->f->dotfunc = (PyArray_DotFunc *)CDOUBLE_dot;
 
         altered = NPY_TRUE;
@@ -131,24 +131,24 @@ dotblas_restoredot(PyObject *NPY_UNUSED(dummy), PyObject *args)
     if (!PyArg_ParseTuple(args, "")) return NULL;
 
     if (altered) {
-        descr = PyArray_DescrFromType(PyArray_FLOAT);
-        descr->f->dotfunc = oldFunctions[PyArray_FLOAT];
-        oldFunctions[PyArray_FLOAT] = NULL;
+        descr = PyArray_DescrFromType(NPY_FLOAT);
+        descr->f->dotfunc = oldFunctions[NPY_FLOAT];
+        oldFunctions[NPY_FLOAT] = NULL;
         Py_XDECREF(descr);
 
-        descr = PyArray_DescrFromType(PyArray_DOUBLE);
-        descr->f->dotfunc = oldFunctions[PyArray_DOUBLE];
-        oldFunctions[PyArray_DOUBLE] = NULL;
+        descr = PyArray_DescrFromType(NPY_DOUBLE);
+        descr->f->dotfunc = oldFunctions[NPY_DOUBLE];
+        oldFunctions[NPY_DOUBLE] = NULL;
         Py_XDECREF(descr);
 
-        descr = PyArray_DescrFromType(PyArray_CFLOAT);
-        descr->f->dotfunc = oldFunctions[PyArray_CFLOAT];
-        oldFunctions[PyArray_CFLOAT] = NULL;
+        descr = PyArray_DescrFromType(NPY_CFLOAT);
+        descr->f->dotfunc = oldFunctions[NPY_CFLOAT];
+        oldFunctions[NPY_CFLOAT] = NULL;
         Py_XDECREF(descr);
 
-        descr = PyArray_DescrFromType(PyArray_CDOUBLE);
-        descr->f->dotfunc = oldFunctions[PyArray_CDOUBLE];
-        oldFunctions[PyArray_CDOUBLE] = NULL;
+        descr = PyArray_DescrFromType(NPY_CDOUBLE);
+        descr->f->dotfunc = oldFunctions[NPY_CDOUBLE];
+        oldFunctions[NPY_CDOUBLE] = NULL;
         Py_XDECREF(descr);
 
         altered = NPY_FALSE;
@@ -249,8 +249,8 @@ dotblas_matrixproduct(PyObject *NPY_UNUSED(dummy), PyObject *args, PyObject* kwa
     typenum = PyArray_ObjectType(op2, typenum);
 
     /* This function doesn't handle other types */
-    if ((typenum != PyArray_DOUBLE && typenum != PyArray_CDOUBLE &&
-         typenum != PyArray_FLOAT && typenum != PyArray_CFLOAT)) {
+    if ((typenum != NPY_DOUBLE && typenum != NPY_CDOUBLE &&
+         typenum != NPY_FLOAT && typenum != NPY_CFLOAT)) {
         return PyArray_Return((PyArrayObject *)PyArray_MatrixProduct2(
                                                     (PyObject *)op1,
                                                     (PyObject *)op2,
@@ -296,7 +296,7 @@ dotblas_matrixproduct(PyObject *NPY_UNUSED(dummy), PyObject *args, PyObject* kwa
     }
 
     if (_bad_strides(ap1)) {
-            op1 = PyArray_NewCopy(ap1, PyArray_ANYORDER);
+            op1 = PyArray_NewCopy(ap1, NPY_ANYORDER);
             Py_DECREF(ap1);
             ap1 = (PyArrayObject *)op1;
             if (ap1 == NULL) {
@@ -304,7 +304,7 @@ dotblas_matrixproduct(PyObject *NPY_UNUSED(dummy), PyObject *args, PyObject* kwa
             }
     }
     if (_bad_strides(ap2)) {
-            op2 = PyArray_NewCopy(ap2, PyArray_ANYORDER);
+            op2 = PyArray_NewCopy(ap2, NPY_ANYORDER);
             Py_DECREF(ap2);
             ap2 = (PyArrayObject *)op2;
             if (ap2 == NULL) {
@@ -475,7 +475,7 @@ dotblas_matrixproduct(PyObject *NPY_UNUSED(dummy), PyObject *args, PyObject* kwa
          */
         NPY_BEGIN_ALLOW_THREADS;
 
-        if (typenum == PyArray_DOUBLE) {
+        if (typenum == NPY_DOUBLE) {
             if (l == 1) {
                 *((double *)ret->data) = *((double *)ap2->data) *
                     *((double *)ap1->data);
@@ -505,7 +505,7 @@ dotblas_matrixproduct(PyObject *NPY_UNUSED(dummy), PyObject *args, PyObject* kwa
                 }
             }
         }
-        else if (typenum == PyArray_CDOUBLE) {
+        else if (typenum == NPY_CDOUBLE) {
             if (l == 1) {
                 npy_cdouble *ptr1, *ptr2, *res;
 
@@ -540,7 +540,7 @@ dotblas_matrixproduct(PyObject *NPY_UNUSED(dummy), PyObject *args, PyObject* kwa
                 }
             }
         }
-        else if (typenum == PyArray_FLOAT) {
+        else if (typenum == NPY_FLOAT) {
             if (l == 1) {
                 *((float *)ret->data) = *((float *)ap2->data) *
                     *((float *)ap1->data);
@@ -570,7 +570,7 @@ dotblas_matrixproduct(PyObject *NPY_UNUSED(dummy), PyObject *args, PyObject* kwa
                 }
             }
         }
-        else if (typenum == PyArray_CFLOAT) {
+        else if (typenum == NPY_CFLOAT) {
             if (l == 1) {
                 npy_cfloat *ptr1, *ptr2, *res;
 
@@ -620,21 +620,21 @@ dotblas_matrixproduct(PyObject *NPY_UNUSED(dummy), PyObject *args, PyObject* kwa
         }
 
         /* Dot product between two vectors -- Level 1 BLAS */
-        if (typenum == PyArray_DOUBLE) {
+        if (typenum == NPY_DOUBLE) {
             double result = cblas_ddot(l, (double *)ap1->data, ap1s,
                                        (double *)ap2->data, ap2s);
             *((double *)ret->data) = result;
         }
-        else if (typenum == PyArray_FLOAT) {
+        else if (typenum == NPY_FLOAT) {
             float result = cblas_sdot(l, (float *)ap1->data, ap1s,
                                       (float *)ap2->data, ap2s);
             *((float *)ret->data) = result;
         }
-        else if (typenum == PyArray_CDOUBLE) {
+        else if (typenum == NPY_CDOUBLE) {
             cblas_zdotu_sub(l, (double *)ap1->data, ap1s,
                             (double *)ap2->data, ap2s, (double *)ret->data);
         }
-        else if (typenum == PyArray_CFLOAT) {
+        else if (typenum == NPY_CFLOAT) {
             cblas_cdotu_sub(l, (float *)ap1->data, ap1s,
                             (float *)ap2->data, ap2s, (float *)ret->data);
         }
@@ -665,26 +665,26 @@ dotblas_matrixproduct(PyObject *NPY_UNUSED(dummy), PyObject *args, PyObject* kwa
             lda = (ap1->dimensions[0] > 1 ? ap1->dimensions[0] : 1);
         }
         ap2s = ap2->strides[0] / ap2->descr->elsize;
-        if (typenum == PyArray_DOUBLE) {
+        if (typenum == NPY_DOUBLE) {
             cblas_dgemv(Order, CblasNoTrans,
                         ap1->dimensions[0], ap1->dimensions[1],
                         1.0, (double *)ap1->data, lda,
                         (double *)ap2->data, ap2s, 0.0, (double *)ret->data, 1);
         }
-        else if (typenum == PyArray_FLOAT) {
+        else if (typenum == NPY_FLOAT) {
             cblas_sgemv(Order, CblasNoTrans,
                         ap1->dimensions[0], ap1->dimensions[1],
                         1.0, (float *)ap1->data, lda,
                         (float *)ap2->data, ap2s, 0.0, (float *)ret->data, 1);
         }
-        else if (typenum == PyArray_CDOUBLE) {
+        else if (typenum == NPY_CDOUBLE) {
             cblas_zgemv(Order,
                         CblasNoTrans,  ap1->dimensions[0], ap1->dimensions[1],
                         oneD, (double *)ap1->data, lda,
                         (double *)ap2->data, ap2s, zeroD,
                         (double *)ret->data, 1);
         }
-        else if (typenum == PyArray_CFLOAT) {
+        else if (typenum == NPY_CFLOAT) {
             cblas_cgemv(Order,
                         CblasNoTrans,  ap1->dimensions[0], ap1->dimensions[1],
                         oneF, (float *)ap1->data, lda,
@@ -722,25 +722,25 @@ dotblas_matrixproduct(PyObject *NPY_UNUSED(dummy), PyObject *args, PyObject* kwa
         else {
             ap1s = ap1->strides[0] / ap1->descr->elsize;
         }
-        if (typenum == PyArray_DOUBLE) {
+        if (typenum == NPY_DOUBLE) {
             cblas_dgemv(Order,
                         CblasTrans,  ap2->dimensions[0], ap2->dimensions[1],
                         1.0, (double *)ap2->data, lda,
                         (double *)ap1->data, ap1s, 0.0, (double *)ret->data, 1);
         }
-        else if (typenum == PyArray_FLOAT) {
+        else if (typenum == NPY_FLOAT) {
             cblas_sgemv(Order,
                         CblasTrans,  ap2->dimensions[0], ap2->dimensions[1],
                         1.0, (float *)ap2->data, lda,
                         (float *)ap1->data, ap1s, 0.0, (float *)ret->data, 1);
         }
-        else if (typenum == PyArray_CDOUBLE) {
+        else if (typenum == NPY_CDOUBLE) {
             cblas_zgemv(Order,
                         CblasTrans,  ap2->dimensions[0], ap2->dimensions[1],
                         oneD, (double *)ap2->data, lda,
                         (double *)ap1->data, ap1s, zeroD, (double *)ret->data, 1);
         }
-        else if (typenum == PyArray_CFLOAT) {
+        else if (typenum == NPY_CFLOAT) {
             cblas_cgemv(Order,
                         CblasTrans,  ap2->dimensions[0], ap2->dimensions[1],
                         oneF, (float *)ap2->data, lda,
@@ -794,28 +794,28 @@ dotblas_matrixproduct(PyObject *NPY_UNUSED(dummy), PyObject *args, PyObject* kwa
         lda = (ap1->dimensions[1] > 1 ? ap1->dimensions[1] : 1);
         ldb = (ap2->dimensions[1] > 1 ? ap2->dimensions[1] : 1);
         ldc = (ret->dimensions[1] > 1 ? ret->dimensions[1] : 1);
-        if (typenum == PyArray_DOUBLE) {
+        if (typenum == NPY_DOUBLE) {
             cblas_dgemm(Order, Trans1, Trans2,
                         L, N, M,
                         1.0, (double *)ap1->data, lda,
                         (double *)ap2->data, ldb,
                         0.0, (double *)ret->data, ldc);
         }
-        else if (typenum == PyArray_FLOAT) {
+        else if (typenum == NPY_FLOAT) {
             cblas_sgemm(Order, Trans1, Trans2,
                         L, N, M,
                         1.0, (float *)ap1->data, lda,
                         (float *)ap2->data, ldb,
                         0.0, (float *)ret->data, ldc);
         }
-        else if (typenum == PyArray_CDOUBLE) {
+        else if (typenum == NPY_CDOUBLE) {
             cblas_zgemm(Order, Trans1, Trans2,
                         L, N, M,
                         oneD, (double *)ap1->data, lda,
                         (double *)ap2->data, ldb,
                         zeroD, (double *)ret->data, ldc);
         }
-        else if (typenum == PyArray_CFLOAT) {
+        else if (typenum == NPY_CFLOAT) {
             cblas_cgemm(Order, Trans1, Trans2,
                         L, N, M,
                         oneF, (float *)ap1->data, lda,
@@ -875,8 +875,8 @@ dotblas_innerproduct(PyObject *NPY_UNUSED(dummy), PyObject *args)
     typenum = PyArray_ObjectType(op2, typenum);
 
     /* This function doesn't handle other types */
-    if ((typenum != PyArray_DOUBLE && typenum != PyArray_CDOUBLE &&
-         typenum != PyArray_FLOAT && typenum != PyArray_CFLOAT)) {
+    if ((typenum != NPY_DOUBLE && typenum != NPY_CDOUBLE &&
+         typenum != NPY_FLOAT && typenum != NPY_CFLOAT)) {
             return PyArray_Return((PyArrayObject *)PyArray_InnerProduct(op1, op2));
     }
 
@@ -952,40 +952,40 @@ dotblas_innerproduct(PyObject *NPY_UNUSED(dummy), PyObject *args)
 
     if (ap2->nd == 0) {
         /* Multiplication by a scalar -- Level 1 BLAS */
-        if (typenum == PyArray_DOUBLE) {
+        if (typenum == NPY_DOUBLE) {
             cblas_daxpy(l, *((double *)ap2->data), (double *)ap1->data, 1,
                         (double *)ret->data, 1);
         }
-        else if (typenum == PyArray_CDOUBLE) {
+        else if (typenum == NPY_CDOUBLE) {
             cblas_zaxpy(l, (double *)ap2->data, (double *)ap1->data, 1,
                         (double *)ret->data, 1);
         }
-        else if (typenum == PyArray_FLOAT) {
+        else if (typenum == NPY_FLOAT) {
             cblas_saxpy(l, *((float *)ap2->data), (float *)ap1->data, 1,
                         (float *)ret->data, 1);
         }
-        else if (typenum == PyArray_CFLOAT) {
+        else if (typenum == NPY_CFLOAT) {
             cblas_caxpy(l, (float *)ap2->data, (float *)ap1->data, 1,
                         (float *)ret->data, 1);
         }
     }
     else if (ap1->nd == 1 && ap2->nd == 1) {
         /* Dot product between two vectors -- Level 1 BLAS */
-        if (typenum == PyArray_DOUBLE) {
+        if (typenum == NPY_DOUBLE) {
             double result = cblas_ddot(l, (double *)ap1->data, 1,
                                        (double *)ap2->data, 1);
             *((double *)ret->data) = result;
         }
-        else if (typenum == PyArray_CDOUBLE) {
+        else if (typenum == NPY_CDOUBLE) {
             cblas_zdotu_sub(l, (double *)ap1->data, 1,
                             (double *)ap2->data, 1, (double *)ret->data);
         }
-        else if (typenum == PyArray_FLOAT) {
+        else if (typenum == NPY_FLOAT) {
             float result = cblas_sdot(l, (float *)ap1->data, 1,
                                       (float *)ap2->data, 1);
             *((float *)ret->data) = result;
         }
-        else if (typenum == PyArray_CFLOAT) {
+        else if (typenum == NPY_CFLOAT) {
             cblas_cdotu_sub(l, (float *)ap1->data, 1,
                             (float *)ap2->data, 1, (float *)ret->data);
         }
@@ -993,25 +993,25 @@ dotblas_innerproduct(PyObject *NPY_UNUSED(dummy), PyObject *args)
     else if (ap1->nd == 2 && ap2->nd == 1) {
         /* Matrix-vector multiplication -- Level 2 BLAS */
         lda = (ap1->dimensions[1] > 1 ? ap1->dimensions[1] : 1);
-        if (typenum == PyArray_DOUBLE) {
+        if (typenum == NPY_DOUBLE) {
             cblas_dgemv(CblasRowMajor,
                         CblasNoTrans,  ap1->dimensions[0], ap1->dimensions[1],
                         1.0, (double *)ap1->data, lda,
                         (double *)ap2->data, 1, 0.0, (double *)ret->data, 1);
         }
-        else if (typenum == PyArray_CDOUBLE) {
+        else if (typenum == NPY_CDOUBLE) {
             cblas_zgemv(CblasRowMajor,
                         CblasNoTrans,  ap1->dimensions[0], ap1->dimensions[1],
                         oneD, (double *)ap1->data, lda,
                         (double *)ap2->data, 1, zeroD, (double *)ret->data, 1);
         }
-        else if (typenum == PyArray_FLOAT) {
+        else if (typenum == NPY_FLOAT) {
             cblas_sgemv(CblasRowMajor,
                         CblasNoTrans,  ap1->dimensions[0], ap1->dimensions[1],
                         1.0, (float *)ap1->data, lda,
                         (float *)ap2->data, 1, 0.0, (float *)ret->data, 1);
         }
-        else if (typenum == PyArray_CFLOAT) {
+        else if (typenum == NPY_CFLOAT) {
             cblas_cgemv(CblasRowMajor,
                         CblasNoTrans,  ap1->dimensions[0], ap1->dimensions[1],
                         oneF, (float *)ap1->data, lda,
@@ -1021,25 +1021,25 @@ dotblas_innerproduct(PyObject *NPY_UNUSED(dummy), PyObject *args)
     else if (ap1->nd == 1 && ap2->nd == 2) {
         /* Vector matrix multiplication -- Level 2 BLAS */
         lda = (ap2->dimensions[1] > 1 ? ap2->dimensions[1] : 1);
-        if (typenum == PyArray_DOUBLE) {
+        if (typenum == NPY_DOUBLE) {
             cblas_dgemv(CblasRowMajor,
                         CblasNoTrans,  ap2->dimensions[0], ap2->dimensions[1],
                         1.0, (double *)ap2->data, lda,
                         (double *)ap1->data, 1, 0.0, (double *)ret->data, 1);
         }
-        else if (typenum == PyArray_CDOUBLE) {
+        else if (typenum == NPY_CDOUBLE) {
             cblas_zgemv(CblasRowMajor,
                         CblasNoTrans,  ap2->dimensions[0], ap2->dimensions[1],
                         oneD, (double *)ap2->data, lda,
                         (double *)ap1->data, 1, zeroD, (double *)ret->data, 1);
         }
-        else if (typenum == PyArray_FLOAT) {
+        else if (typenum == NPY_FLOAT) {
             cblas_sgemv(CblasRowMajor,
                         CblasNoTrans,  ap2->dimensions[0], ap2->dimensions[1],
                         1.0, (float *)ap2->data, lda,
                         (float *)ap1->data, 1, 0.0, (float *)ret->data, 1);
         }
-        else if (typenum == PyArray_CFLOAT) {
+        else if (typenum == NPY_CFLOAT) {
             cblas_cgemv(CblasRowMajor,
                         CblasNoTrans,  ap2->dimensions[0], ap2->dimensions[1],
                         oneF, (float *)ap2->data, lda,
@@ -1051,28 +1051,28 @@ dotblas_innerproduct(PyObject *NPY_UNUSED(dummy), PyObject *args)
         lda = (ap1->dimensions[1] > 1 ? ap1->dimensions[1] : 1);
         ldb = (ap2->dimensions[1] > 1 ? ap2->dimensions[1] : 1);
         ldc = (ret->dimensions[1] > 1 ? ret->dimensions[1] : 1);
-        if (typenum == PyArray_DOUBLE) {
+        if (typenum == NPY_DOUBLE) {
             cblas_dgemm(CblasRowMajor, CblasNoTrans, CblasTrans,
                         ap1->dimensions[0], ap2->dimensions[0], ap1->dimensions[1],
                         1.0, (double *)ap1->data, lda,
                         (double *)ap2->data, ldb,
                         0.0, (double *)ret->data, ldc);
         }
-        else if (typenum == PyArray_FLOAT) {
+        else if (typenum == NPY_FLOAT) {
             cblas_sgemm(CblasRowMajor, CblasNoTrans, CblasTrans,
                         ap1->dimensions[0], ap2->dimensions[0], ap1->dimensions[1],
                         1.0, (float *)ap1->data, lda,
                         (float *)ap2->data, ldb,
                         0.0, (float *)ret->data, ldc);
         }
-        else if (typenum == PyArray_CDOUBLE) {
+        else if (typenum == NPY_CDOUBLE) {
             cblas_zgemm(CblasRowMajor, CblasNoTrans, CblasTrans,
                         ap1->dimensions[0], ap2->dimensions[0], ap1->dimensions[1],
                         oneD, (double *)ap1->data, lda,
                         (double *)ap2->data, ldb,
                         zeroD, (double *)ret->data, ldc);
         }
-        else if (typenum == PyArray_CFLOAT) {
+        else if (typenum == NPY_CFLOAT) {
             cblas_cgemm(CblasRowMajor, CblasNoTrans, CblasTrans,
                         ap1->dimensions[0], ap2->dimensions[0], ap1->dimensions[1],
                         oneF, (float *)ap1->data, lda,
@@ -1133,8 +1133,8 @@ static PyObject *dotblas_vdot(PyObject *NPY_UNUSED(dummy), PyObject *args) {
     Py_DECREF(ap2);
     ap2 = (PyArrayObject *)op2;
 
-    if (typenum != PyArray_FLOAT && typenum != PyArray_DOUBLE &&
-        typenum != PyArray_CFLOAT && typenum != PyArray_CDOUBLE) {
+    if (typenum != NPY_FLOAT && typenum != NPY_DOUBLE &&
+        typenum != NPY_CFLOAT && typenum != NPY_CDOUBLE) {
         if (!altered) {
             /* need to alter dot product */
             PyObject *tmp1, *tmp2;
@@ -1168,19 +1168,19 @@ static PyObject *dotblas_vdot(PyObject *NPY_UNUSED(dummy), PyObject *args) {
     NPY_BEGIN_ALLOW_THREADS
 
     /* Dot product between two vectors -- Level 1 BLAS */
-    if (typenum == PyArray_DOUBLE) {
+    if (typenum == NPY_DOUBLE) {
         *((double *)ret->data) = cblas_ddot(l, (double *)ap1->data, 1,
                                             (double *)ap2->data, 1);
     }
-    else if (typenum == PyArray_FLOAT) {
+    else if (typenum == NPY_FLOAT) {
         *((float *)ret->data) = cblas_sdot(l, (float *)ap1->data, 1,
                                            (float *)ap2->data, 1);
     }
-    else if (typenum == PyArray_CDOUBLE) {
+    else if (typenum == NPY_CDOUBLE) {
         cblas_zdotc_sub(l, (double *)ap1->data, 1,
                         (double *)ap2->data, 1, (double *)ret->data);
     }
-    else if (typenum == PyArray_CFLOAT) {
+    else if (typenum == NPY_CFLOAT) {
         cblas_cdotc_sub(l, (float *)ap1->data, 1,
                         (float *)ap2->data, 1, (float *)ret->data);
     }
@@ -1244,7 +1244,7 @@ PyMODINIT_FUNC init_dotblas(void)
     import_array();
 
     /* Initialise the array of dot functions */
-    for (i = 0; i < PyArray_NTYPES; i++)
+    for (i = 0; i < NPY_NTYPES; i++)
         oldFunctions[i] = NULL;
 
     /* alterdot at load */
diff --git a/numpy/core/code_generators/generate_umath.py b/numpy/core/code_generators/generate_umath.py
index 052947e37..7e8ed1d2b 100644
--- a/numpy/core/code_generators/generate_umath.py
+++ b/numpy/core/code_generators/generate_umath.py
@@ -884,7 +884,7 @@ def make_arrays(funcdict):
                 funclist.append('%s_%s' % (tname, name))
 
             for x in t.in_ + t.out:
-                siglist.append('PyArray_%s' % (english_upper(chartoname[x]),))
+                siglist.append('NPY_%s' % (english_upper(chartoname[x]),))
 
             k += 1
 
diff --git a/numpy/core/include/numpy/ndarrayobject.h b/numpy/core/include/numpy/ndarrayobject.h
index 03dfcd9cd..74943d535 100644
--- a/numpy/core/include/numpy/ndarrayobject.h
+++ b/numpy/core/include/numpy/ndarrayobject.h
@@ -214,7 +214,6 @@ PyArray_XDECREF_ERR(PyArrayObject *arr)
         PyArray_FromDimsAndDataAndDescr(nd, d, PyArray_DescrFromType(type),   \
                                         data)
 
-#include "old_defines.h"
 
 /*
    Check to see if this key in the dictionary is the "title"
diff --git a/numpy/core/include/numpy/npy_deprecated_api.h b/numpy/core/include/numpy/npy_deprecated_api.h
index a268f504a..29bdd95c4 100644
--- a/numpy/core/include/numpy/npy_deprecated_api.h
+++ b/numpy/core/include/numpy/npy_deprecated_api.h
@@ -95,4 +95,11 @@
  */
 #define FORTRAN_IF PyArray_FORTRAN_IF
 
+/*
+ * The macros in old_defines.h are Deprecated as of NumPy 1.7 and will be
+ * removed in the next major release.
+ */
+#include "old_defines.h"
+
+
 #endif
diff --git a/numpy/core/include/numpy/old_defines.h b/numpy/core/include/numpy/old_defines.h
index 1607313b7..444fdc33b 100644
--- a/numpy/core/include/numpy/old_defines.h
+++ b/numpy/core/include/numpy/old_defines.h
@@ -1,3 +1,8 @@
+/* This header is deprecated as of NumPy 1.7 */
+#ifdef NPY_NO_DEPRECATED_API
+#error The header "old_defines.h" is deprecated as of NumPy 1.7.
+#endif
+
 #define NDARRAY_VERSION NPY_VERSION
 
 #define PyArray_MIN_BUFSIZE NPY_MIN_BUFSIZE
diff --git a/numpy/core/include/numpy/oldnumeric.h b/numpy/core/include/numpy/oldnumeric.h
index 51dba29cd..748f06da3 100644
--- a/numpy/core/include/numpy/oldnumeric.h
+++ b/numpy/core/include/numpy/oldnumeric.h
@@ -6,7 +6,7 @@
 #endif
 
 #define PyArray_UNSIGNED_TYPES
-#define PyArray_SBYTE PyArray_BYTE
+#define PyArray_SBYTE NPY_BYTE
 #define PyArray_CopyArray PyArray_CopyInto
 #define _PyArray_multiply_list PyArray_MultiplyIntList
 #define PyArray_ISSPACESAVER(m) NPY_FALSE
diff --git a/numpy/core/setup.py b/numpy/core/setup.py
index e8f40e806..05872a552 100644
--- a/numpy/core/setup.py
+++ b/numpy/core/setup.py
@@ -733,7 +733,6 @@ def configuration(parent_package='',top_path=None):
             join('include', 'numpy', 'arrayobject.h'),
             join('include', 'numpy', '_neighborhood_iterator_imp.h'),
             join('include', 'numpy', 'npy_endian.h'),
-            join('include', 'numpy', 'old_defines.h'),
             join('include', 'numpy', 'arrayscalars.h'),
             join('include', 'numpy', 'noprefix.h'),
             join('include', 'numpy', 'npy_interrupt.h'),
diff --git a/numpy/core/src/multiarray/arrayobject.c b/numpy/core/src/multiarray/arrayobject.c
index 5ca5d22f0..202ff6813 100644
--- a/numpy/core/src/multiarray/arrayobject.c
+++ b/numpy/core/src/multiarray/arrayobject.c
@@ -157,7 +157,7 @@ PyArray_CopyObject(PyArrayObject *dest, PyObject *src_object)
      * Special code to mimic Numeric behavior for
      * character arrays.
      */
-    if (PyArray_DESCR(dest)->type == PyArray_CHARLTR &&
+    if (PyArray_DESCR(dest)->type == NPY_CHARLTR &&
                                 PyArray_NDIM(dest) > 0 &&
                                 PyString_Check(src_object)) {
         npy_intp n_new, n_old;
@@ -325,7 +325,7 @@ PyArray_CopyObject(PyArrayObject *dest, PyObject *src_object)
 /*
   Given a string return the type-number for
   the data-type with that string as the type-object name.
-  Returns PyArray_NOTYPE without setting an error if no type can be
+  Returns NPY_NOTYPE without setting an error if no type can be
   found.  Only works for user-defined data-types.
 */
 
@@ -343,7 +343,7 @@ PyArray_TypeNumFromName(char *str)
             return descr->type_num;
         }
     }
-    return PyArray_NOTYPE;
+    return NPY_NOTYPE;
 }
 
 /*********************** end C-API functions **********************/
@@ -676,7 +676,7 @@ array_str(PyArrayObject *self)
 NPY_NO_EXPORT int
 PyArray_CompareUCS4(npy_ucs4 *s1, npy_ucs4 *s2, size_t len)
 {
-    PyArray_UCS4 c1, c2;
+    npy_ucs4 c1, c2;
     while(len-- > 0) {
         c1 = *s1++;
         c2 = *s2++;
@@ -712,21 +712,21 @@ PyArray_CompareString(char *s1, char *s2, size_t len)
    If they are NULL terminated, then stop comparison.
 */
 static int
-_myunincmp(PyArray_UCS4 *s1, PyArray_UCS4 *s2, int len1, int len2)
+_myunincmp(npy_ucs4 *s1, npy_ucs4 *s2, int len1, int len2)
 {
-    PyArray_UCS4 *sptr;
-    PyArray_UCS4 *s1t=s1, *s2t=s2;
+    npy_ucs4 *sptr;
+    npy_ucs4 *s1t=s1, *s2t=s2;
     int val;
     npy_intp size;
     int diff;
 
-    if ((npy_intp)s1 % sizeof(PyArray_UCS4) != 0) {
-        size = len1*sizeof(PyArray_UCS4);
+    if ((npy_intp)s1 % sizeof(npy_ucs4) != 0) {
+        size = len1*sizeof(npy_ucs4);
         s1t = malloc(size);
         memcpy(s1t, s1, size);
     }
-    if ((npy_intp)s2 % sizeof(PyArray_UCS4) != 0) {
-        size = len2*sizeof(PyArray_UCS4);
+    if ((npy_intp)s2 % sizeof(npy_ucs4) != 0) {
+        size = len2*sizeof(npy_ucs4);
         s2t = malloc(size);
         memcpy(s2t, s2, size);
     }
@@ -825,11 +825,11 @@ static void _rstripw(char *s, int n)
     }
 }
 
-static void _unistripw(PyArray_UCS4 *s, int n)
+static void _unistripw(npy_ucs4 *s, int n)
 {
     int i;
     for (i = n - 1; i >= 1; i--) { /* Never strip to length 0. */
-        PyArray_UCS4 c = s[i];
+        npy_ucs4 c = s[i];
         if (!c || isspace(c)) {
             s[i] = 0;
         }
@@ -866,22 +866,22 @@ _char_release(char *ptr, int nc)
 static char *
 _uni_copy_n_strip(char *original, char *temp, int nc)
 {
-    if (nc*sizeof(PyArray_UCS4) > SMALL_STRING) {
-        temp = malloc(nc*sizeof(PyArray_UCS4));
+    if (nc*sizeof(npy_ucs4) > SMALL_STRING) {
+        temp = malloc(nc*sizeof(npy_ucs4));
         if (!temp) {
             PyErr_NoMemory();
             return NULL;
         }
     }
-    memcpy(temp, original, nc*sizeof(PyArray_UCS4));
-    _unistripw((PyArray_UCS4 *)temp, nc);
+    memcpy(temp, original, nc*sizeof(npy_ucs4));
+    _unistripw((npy_ucs4 *)temp, nc);
     return temp;
 }
 
 static void
 _uni_release(char *ptr, int nc)
 {
-    if (nc*sizeof(PyArray_UCS4) > SMALL_STRING) {
+    if (nc*sizeof(npy_ucs4) > SMALL_STRING) {
         free(ptr);
     }
 }
@@ -1025,8 +1025,8 @@ _strings_richcompare(PyArrayObject *self, PyArrayObject *other, int cmp_op,
         return Py_NotImplemented;
 #else
         PyObject *new;
-        if (PyArray_TYPE(self) == PyArray_STRING &&
-            PyArray_DESCR(other)->type_num == PyArray_UNICODE) {
+        if (PyArray_TYPE(self) == NPY_STRING &&
+            PyArray_DESCR(other)->type_num == NPY_UNICODE) {
             PyArray_Descr* unicode = PyArray_DescrNew(PyArray_DESCR(other));
             unicode->elsize = PyArray_DESCR(self)->elsize << 2;
             new = PyArray_FromAny((PyObject *)self, unicode,
@@ -1037,8 +1037,8 @@ _strings_richcompare(PyArrayObject *self, PyArrayObject *other, int cmp_op,
             Py_INCREF(other);
             self = (PyArrayObject *)new;
         }
-        else if (PyArray_TYPE(self) == PyArray_UNICODE &&
-                 PyArray_DESCR(other)->type_num == PyArray_STRING) {
+        else if (PyArray_TYPE(self) == NPY_UNICODE &&
+                 PyArray_DESCR(other)->type_num == NPY_STRING) {
             PyArray_Descr* unicode = PyArray_DescrNew(PyArray_DESCR(self));
             unicode->elsize = PyArray_DESCR(other)->elsize << 2;
             new = PyArray_FromAny((PyObject *)other, unicode,
@@ -1071,7 +1071,7 @@ _strings_richcompare(PyArrayObject *self, PyArrayObject *other, int cmp_op,
     }
 
     result = (PyArrayObject *)PyArray_NewFromDescr(&PyArray_Type,
-                                  PyArray_DescrFromType(PyArray_BOOL),
+                                  PyArray_DescrFromType(NPY_BOOL),
                                   mit->nd,
                                   mit->dimensions,
                                   NULL, NULL, 0,
@@ -1166,7 +1166,7 @@ _void_compare(PyArrayObject *self, PyArrayObject *other, int cmp_op)
                            sizeof(intp)*result_ndim);
                     dimensions[result_ndim] = -1;
                     temp2 = PyArray_Newshape((PyArrayObject *)temp,
-                                             &newdims, PyArray_ANYORDER);
+                                             &newdims, NPY_ANYORDER);
                     if (temp2 == NULL) {
                         Py_DECREF(temp);
                         Py_XDECREF(res);
@@ -1178,7 +1178,7 @@ _void_compare(PyArrayObject *self, PyArrayObject *other, int cmp_op)
                 /* Reduce the extra dimension of `temp` using `op` */
                 temp2 = PyArray_GenericReduceFunction((PyArrayObject *)temp,
                                                       op, result_ndim,
-                                                      PyArray_BOOL, NULL);
+                                                      NPY_BOOL, NULL);
                 if (temp2 == NULL) {
                     Py_DECREF(temp);
                     Py_XDECREF(res);
@@ -1354,11 +1354,11 @@ array_richcompare(PyArrayObject *self, PyObject *other, int cmp_op)
     }
     if (result == Py_NotImplemented) {
         /* Try to handle string comparisons */
-        if (PyArray_TYPE(self) == PyArray_OBJECT) {
+        if (PyArray_TYPE(self) == NPY_OBJECT) {
             return result;
         }
         array_other = (PyArrayObject *)PyArray_FromObject(other,
-                                                    PyArray_NOTYPE, 0, 0);
+                                                    NPY_NOTYPE, 0, 0);
         if (PyArray_ISSTRING(self) && PyArray_ISSTRING(array_other)) {
             Py_DECREF(result);
             result = _strings_richcompare(self, (PyArrayObject *)
diff --git a/numpy/core/src/multiarray/arraytypes.c.src b/numpy/core/src/multiarray/arraytypes.c.src
index 3225965ef..1d81be8a8 100644
--- a/numpy/core/src/multiarray/arraytypes.c.src
+++ b/numpy/core/src/multiarray/arraytypes.c.src
@@ -306,9 +306,9 @@ static PyObject *
 UNICODE_getitem(char *ip, PyArrayObject *ap)
 {
     intp elsize = PyArray_DESCR(ap)->elsize;
-    intp mysize = elsize/sizeof(PyArray_UCS4);
+    intp mysize = elsize/sizeof(npy_ucs4);
     int alloc = 0;
-    PyArray_UCS4 *buffer = NULL;
+    npy_ucs4 *buffer = NULL;
     PyUnicodeObject *obj;
     intp i;
 
@@ -321,11 +321,11 @@ UNICODE_getitem(char *ip, PyArrayObject *ap)
         alloc = 1;
         memcpy(buffer, ip, elsize);
         if (!PyArray_ISNOTSWAPPED(ap)) {
-            byte_swap_vector(buffer, mysize, sizeof(PyArray_UCS4));
+            byte_swap_vector(buffer, mysize, sizeof(npy_ucs4));
         }
     }
     else {
-        buffer = (PyArray_UCS4 *)ip;
+        buffer = (npy_ucs4 *)ip;
     }
     for (i = mysize; i > 0 && buffer[--i] == 0; mysize = i);
 
@@ -418,7 +418,7 @@ UNICODE_setitem(PyObject *op, char *ov, PyArrayObject *ap)
     else {
         buffer = ov;
     }
-    datalen = PyUCS2Buffer_AsUCS4(ptr, (PyArray_UCS4 *)buffer,
+    datalen = PyUCS2Buffer_AsUCS4(ptr, (npy_ucs4 *)buffer,
             datalen >> 1, PyArray_DESCR(ap)->elsize >> 2);
     datalen <<= 2;
     if (!PyArray_ISALIGNED(ap)) {
@@ -804,7 +804,7 @@ VOID_setitem(PyObject *op, char *ip, PyArrayObject *ap)
         if (res == -1) {
             goto fail;
         }
-        memcpy(ip, buffer, NPY_MIN(buflen, itemsize));
+        memcpy(ip, buffer, PyArray_MIN(buflen, itemsize));
         if (itemsize > buflen) {
             memset(ip + buflen, 0, itemsize - buflen);
         }
@@ -2176,7 +2176,7 @@ STRING_nonzero (char *ip, PyArrayObject *ap)
 #endif
 
 static Bool
-UNICODE_nonzero (PyArray_UCS4 *ip, PyArrayObject *ap)
+UNICODE_nonzero (npy_ucs4 *ip, PyArrayObject *ap)
 {
     int len = PyArray_DESCR(ap)->elsize >> 2;
     int i;
@@ -2192,7 +2192,7 @@ UNICODE_nonzero (PyArray_UCS4 *ip, PyArrayObject *ap)
         if (!PyArray_ISNOTSWAPPED(ap)) {
             byte_swap_vector(buffer, len, 4);
         }
-        ip = (PyArray_UCS4 *)buffer;
+        ip = (npy_ucs4 *)buffer;
     }
 
     for (i = 0; i < len; i++) {
@@ -2504,7 +2504,7 @@ STRING_compare(char *ip1, char *ip2, PyArrayObject *ap)
 /* unicode type */
 
 static int
-UNICODE_compare(PyArray_UCS4 *ip1, PyArray_UCS4 *ip2,
+UNICODE_compare(npy_ucs4 *ip1, npy_ucs4 *ip2,
                 PyArrayObject *ap)
 {
     int itemsize = PyArray_DESCR(ap)->elsize;
@@ -2513,8 +2513,8 @@ UNICODE_compare(PyArray_UCS4 *ip1, PyArray_UCS4 *ip2,
         return 0;
     }
     while (itemsize-- > 0) {
-        PyArray_UCS4 c1 = *ip1++;
-        PyArray_UCS4 c2 = *ip2++;
+        npy_ucs4 c1 = *ip1++;
+        npy_ucs4 c2 = *ip2++;
         if (c1 != c2) {
             return (c1 < c2) ? -1 : 1;
         }
@@ -2795,7 +2795,7 @@ OBJECT_argmax(PyObject **ip, intp n, intp *max_ind, PyArrayObject *NPY_UNUSED(ai
 /**begin repeat
  *
  * #fname = STRING, UNICODE#
- * #type = char, PyArray_UCS4#
+ * #type = char, npy_ucs4#
  */
 static int
 @fname@_argmax(@type@ *ip, intp n, intp *max_ind, PyArrayObject *aip)
@@ -2851,7 +2851,7 @@ OBJECT_argmin(PyObject **ip, intp n, intp *min_ind, PyArrayObject *NPY_UNUSED(ai
 /**begin repeat
  *
  * #fname = STRING, UNICODE#
- * #type = char, PyArray_UCS4#
+ * #type = char, npy_ucs4#
  */
 static int
 @fname@_argmin(@type@ *ip, intp n, intp *min_ind, PyArrayObject *aip)
@@ -3475,7 +3475,7 @@ static int
  * #from = VOID, STRING, UNICODE#
  * #suff = void, string, unicode#
  * #sort = 0, 1, 1#
- * #align = char, char, PyArray_UCS4#
+ * #align = char, char, npy_ucs4#
  * #NAME = Void, String, Unicode#
  * #endian = |, |, =#
 */
@@ -3550,11 +3550,11 @@ static PyArray_ArrFuncs _Py@NAME@_ArrFuncs = {
 static PyArray_Descr @from@_Descr = {
     PyObject_HEAD_INIT(&PyArrayDescr_Type)
     &Py@NAME@ArrType_Type,
-    PyArray_@from@LTR,
-    PyArray_@from@LTR,
+    NPY_@from@LTR,
+    NPY_@from@LTR,
     '@endian@',
     0,
-    PyArray_@from@,
+    NPY_@from@,
     0,
     _ALIGN(@align@),
     NULL,
@@ -3659,11 +3659,11 @@ static PyArray_ArrFuncs _Py@NAME@_ArrFuncs = {
 NPY_NO_EXPORT PyArray_Descr @from@_Descr = {
     PyObject_HEAD_INIT(&PyArrayDescr_Type)
     &Py@NAME@ArrType_Type,
-    PyArray_@kind@LTR,
-    PyArray_@from@LTR,
+    NPY_@kind@LTR,
+    NPY_@from@LTR,
     '@endian@',
     @isobject@,
-    PyArray_@from@,
+    NPY_@from@,
     @num@*sizeof(@fromtyp@),
     _ALIGN(@fromtyp@),
     NULL,
@@ -3900,8 +3900,8 @@ set_typeinfo(PyObject *dict)
 #else
             s = Py_BuildValue("ciii@cx@@cn@O",
 #endif
-                PyArray_@name@LTR,
-                PyArray_@name@,
+                NPY_@name@LTR,
+                NPY_@name@,
                 BITSOF_@uname@,
                 _ALIGN(@type@),
                 @max@,
@@ -3922,11 +3922,11 @@ set_typeinfo(PyObject *dict)
  */
     PyDict_SetItemString(infodict, "@name@",
 #if defined(NPY_PY3K)
-            s = Py_BuildValue("CiiiO", PyArray_@name@LTR,
+            s = Py_BuildValue("CiiiO", NPY_@name@LTR,
 #else
-            s = Py_BuildValue("ciiiO", PyArray_@name@LTR,
+            s = Py_BuildValue("ciiiO", NPY_@name@LTR,
 #endif
-                PyArray_@name@,
+                NPY_@name@,
                 BITSOF_@name@,
                 _ALIGN(@type@),
                 (PyObject *) &Py@Name@ArrType_Type));
@@ -3935,55 +3935,55 @@ set_typeinfo(PyObject *dict)
 
     PyDict_SetItemString(infodict, "OBJECT",
 #if defined(NPY_PY3K)
-            s = Py_BuildValue("CiiiO", PyArray_OBJECTLTR,
+            s = Py_BuildValue("CiiiO", NPY_OBJECTLTR,
 #else
-            s = Py_BuildValue("ciiiO", PyArray_OBJECTLTR,
+            s = Py_BuildValue("ciiiO", NPY_OBJECTLTR,
 #endif
-                PyArray_OBJECT,
+                NPY_OBJECT,
                 sizeof(PyObject *) * CHAR_BIT,
                 _ALIGN(PyObject *),
                 (PyObject *) &PyObjectArrType_Type));
     Py_DECREF(s);
     PyDict_SetItemString(infodict, "STRING",
 #if defined(NPY_PY3K)
-            s = Py_BuildValue("CiiiO", PyArray_STRINGLTR,
+            s = Py_BuildValue("CiiiO", NPY_STRINGLTR,
 #else
-            s = Py_BuildValue("ciiiO", PyArray_STRINGLTR,
+            s = Py_BuildValue("ciiiO", NPY_STRINGLTR,
 #endif
-                PyArray_STRING,
+                NPY_STRING,
                 0,
                 _ALIGN(char),
                 (PyObject *) &PyStringArrType_Type));
     Py_DECREF(s);
     PyDict_SetItemString(infodict, "UNICODE",
 #if defined(NPY_PY3K)
-            s = Py_BuildValue("CiiiO", PyArray_UNICODELTR,
+            s = Py_BuildValue("CiiiO", NPY_UNICODELTR,
 #else
-            s = Py_BuildValue("ciiiO", PyArray_UNICODELTR,
+            s = Py_BuildValue("ciiiO", NPY_UNICODELTR,
 #endif
-                PyArray_UNICODE,
+                NPY_UNICODE,
                 0,
-                _ALIGN(PyArray_UCS4),
+                _ALIGN(npy_ucs4),
                 (PyObject *) &PyUnicodeArrType_Type));
     Py_DECREF(s);
     PyDict_SetItemString(infodict, "VOID",
 #if defined(NPY_PY3K)
-            s = Py_BuildValue("CiiiO", PyArray_VOIDLTR,
+            s = Py_BuildValue("CiiiO", NPY_VOIDLTR,
 #else
-            s = Py_BuildValue("ciiiO", PyArray_VOIDLTR,
+            s = Py_BuildValue("ciiiO", NPY_VOIDLTR,
 #endif
-                PyArray_VOID,
+                NPY_VOID,
                 0,
                 _ALIGN(char),
                 (PyObject *) &PyVoidArrType_Type));
     Py_DECREF(s);
     PyDict_SetItemString(infodict, "DATETIME",
 #if defined(NPY_PY3K)
-            s = Py_BuildValue("CiiiNNO", PyArray_DATETIMELTR,
+            s = Py_BuildValue("CiiiNNO", NPY_DATETIMELTR,
 #else
-            s = Py_BuildValue("ciiiNNO", PyArray_DATETIMELTR,
+            s = Py_BuildValue("ciiiNNO", NPY_DATETIMELTR,
 #endif
-                PyArray_DATETIME,
+                NPY_DATETIME,
                 sizeof(npy_datetime) * CHAR_BIT,
                 _ALIGN(npy_datetime),
                 MyPyLong_FromInt64(MAX_DATETIME),
@@ -3992,11 +3992,11 @@ set_typeinfo(PyObject *dict)
     Py_DECREF(s);
     PyDict_SetItemString(infodict, "TIMEDELTA",
 #if defined(NPY_PY3K)
-            s = Py_BuildValue("CiiiNNO", PyArray_TIMEDELTALTR,
+            s = Py_BuildValue("CiiiNNO", NPY_TIMEDELTALTR,
 #else
-            s = Py_BuildValue("ciiiNNO",PyArray_TIMEDELTALTR,
+            s = Py_BuildValue("ciiiNNO",NPY_TIMEDELTALTR,
 #endif
-                PyArray_TIMEDELTA,
+                NPY_TIMEDELTA,
                 sizeof(npy_timedelta) * CHAR_BIT,
                 _ALIGN(npy_timedelta),
                 MyPyLong_FromInt64(MAX_TIMEDELTA),
diff --git a/numpy/core/src/multiarray/buffer.c b/numpy/core/src/multiarray/buffer.c
index de283604b..11bf711f1 100644
--- a/numpy/core/src/multiarray/buffer.c
+++ b/numpy/core/src/multiarray/buffer.c
@@ -762,7 +762,7 @@ _descriptor_from_pep3118_format(char *s)
     PyObject *_numpy_internal;
 
     if (s == NULL) {
-        return PyArray_DescrNewFromType(PyArray_BYTE);
+        return PyArray_DescrNewFromType(NPY_BYTE);
     }
 
     /* Strip whitespace, except from field names */
diff --git a/numpy/core/src/multiarray/calculation.c b/numpy/core/src/multiarray/calculation.c
index eea59f24a..b993ea3ec 100644
--- a/numpy/core/src/multiarray/calculation.c
+++ b/numpy/core/src/multiarray/calculation.c
@@ -101,7 +101,7 @@ PyArray_ArgMax(PyArrayObject *op, int axis, PyArrayObject *out)
 
     if (!out) {
         rp = (PyArrayObject *)PyArray_New(Py_TYPE(ap), PyArray_NDIM(ap)-1,
-                                          PyArray_DIMS(ap), PyArray_INTP,
+                                          PyArray_DIMS(ap), NPY_INTP,
                                           NULL, NULL, 0, 0,
                                           (PyObject *)ap);
         if (rp == NULL) {
@@ -115,7 +115,7 @@ PyArray_ArgMax(PyArrayObject *op, int axis, PyArrayObject *out)
                     "invalid shape for output array.");
         }
         rp = (PyArrayObject *)PyArray_FromArray(out,
-                              PyArray_DescrFromType(PyArray_INTP),
+                              PyArray_DescrFromType(NPY_INTP),
                               NPY_ARRAY_CARRAY | NPY_ARRAY_UPDATEIFCOPY);
         if (rp == NULL) {
             goto fail;
@@ -214,7 +214,7 @@ PyArray_ArgMin(PyArrayObject *op, int axis, PyArrayObject *out)
 
     if (!out) {
         rp = (PyArrayObject *)PyArray_New(Py_TYPE(ap), PyArray_NDIM(ap)-1,
-                                          PyArray_DIMS(ap), PyArray_INTP,
+                                          PyArray_DIMS(ap), NPY_INTP,
                                           NULL, NULL, 0, 0,
                                           (PyObject *)ap);
         if (rp == NULL) {
@@ -228,7 +228,7 @@ PyArray_ArgMin(PyArrayObject *op, int axis, PyArrayObject *out)
                     "invalid shape for output array.");
         }
         rp = (PyArrayObject *)PyArray_FromArray(out,
-                              PyArray_DescrFromType(PyArray_INTP),
+                              PyArray_DescrFromType(NPY_INTP),
                               NPY_ARRAY_CARRAY | NPY_ARRAY_UPDATEIFCOPY);
         if (rp == NULL) {
             goto fail;
@@ -795,7 +795,7 @@ PyArray_Any(PyArrayObject *self, int axis, PyArrayObject *out)
     }
     ret = PyArray_GenericReduceFunction((PyArrayObject *)arr,
                                         n_ops.logical_or, axis,
-                                        PyArray_BOOL, out);
+                                        NPY_BOOL, out);
     Py_DECREF(arr);
     return ret;
 }
@@ -814,7 +814,7 @@ PyArray_All(PyArrayObject *self, int axis, PyArrayObject *out)
     }
     ret = PyArray_GenericReduceFunction((PyArrayObject *)arr,
                                         n_ops.logical_and, axis,
-                                        PyArray_BOOL, out);
+                                        NPY_BOOL, out);
     Py_DECREF(arr);
     return ret;
 }
diff --git a/numpy/core/src/multiarray/common.c b/numpy/core/src/multiarray/common.c
index 1eceeae1a..1d3948bf6 100644
--- a/numpy/core/src/multiarray/common.c
+++ b/numpy/core/src/multiarray/common.c
@@ -19,27 +19,27 @@ NPY_NO_EXPORT PyArray_Descr *
 _array_find_python_scalar_type(PyObject *op)
 {
     if (PyFloat_Check(op)) {
-        return PyArray_DescrFromType(PyArray_DOUBLE);
+        return PyArray_DescrFromType(NPY_DOUBLE);
     }
     else if (PyComplex_Check(op)) {
-        return PyArray_DescrFromType(PyArray_CDOUBLE);
+        return PyArray_DescrFromType(NPY_CDOUBLE);
     }
     else if (PyInt_Check(op)) {
         /* bools are a subclass of int */
         if (PyBool_Check(op)) {
-            return PyArray_DescrFromType(PyArray_BOOL);
+            return PyArray_DescrFromType(NPY_BOOL);
         }
         else {
-            return  PyArray_DescrFromType(PyArray_LONG);
+            return  PyArray_DescrFromType(NPY_LONG);
         }
     }
     else if (PyLong_Check(op)) {
         /* if integer can fit into a longlong then return that*/
         if ((PyLong_AsLongLong(op) == -1) && PyErr_Occurred()) {
             PyErr_Clear();
-            return PyArray_DescrFromType(PyArray_OBJECT);
+            return PyArray_DescrFromType(NPY_OBJECT);
         }
-        return PyArray_DescrFromType(PyArray_LONGLONG);
+        return PyArray_DescrFromType(NPY_LONGLONG);
     }
     return NULL;
 }
diff --git a/numpy/core/src/multiarray/conversion_utils.c b/numpy/core/src/multiarray/conversion_utils.c
index 7823b6960..68d6e75fb 100644
--- a/numpy/core/src/multiarray/conversion_utils.c
+++ b/numpy/core/src/multiarray/conversion_utils.c
@@ -379,7 +379,7 @@ PyArray_ByteorderConverter(PyObject *obj, char *endian)
         obj = tmp = PyUnicode_AsASCIIString(obj);
     }
 
-    *endian = PyArray_SWAP;
+    *endian = NPY_SWAP;
     str = PyBytes_AsString(obj);
     if (!str) {
         Py_XDECREF(tmp);
@@ -392,22 +392,22 @@ PyArray_ByteorderConverter(PyObject *obj, char *endian)
         return PY_FAIL;
     }
     *endian = str[0];
-    if (str[0] != PyArray_BIG && str[0] != PyArray_LITTLE
-        && str[0] != PyArray_NATIVE && str[0] != PyArray_IGNORE) {
+    if (str[0] != NPY_BIG && str[0] != NPY_LITTLE
+        && str[0] != NPY_NATIVE && str[0] != NPY_IGNORE) {
         if (str[0] == 'b' || str[0] == 'B') {
-            *endian = PyArray_BIG;
+            *endian = NPY_BIG;
         }
         else if (str[0] == 'l' || str[0] == 'L') {
-            *endian = PyArray_LITTLE;
+            *endian = NPY_LITTLE;
         }
         else if (str[0] == 'n' || str[0] == 'N') {
-            *endian = PyArray_NATIVE;
+            *endian = NPY_NATIVE;
         }
         else if (str[0] == 'i' || str[0] == 'I') {
-            *endian = PyArray_IGNORE;
+            *endian = NPY_IGNORE;
         }
         else if (str[0] == 's' || str[0] == 'S') {
-            *endian = PyArray_SWAP;
+            *endian = NPY_SWAP;
         }
         else {
             PyErr_Format(PyExc_ValueError,
@@ -434,7 +434,7 @@ PyArray_SortkindConverter(PyObject *obj, NPY_SORTKIND *sortkind)
         obj = tmp = PyUnicode_AsASCIIString(obj);
     }
 
-    *sortkind = PyArray_QUICKSORT;
+    *sortkind = NPY_QUICKSORT;
     str = PyBytes_AsString(obj);
     if (!str) {
         Py_XDECREF(tmp);
@@ -447,13 +447,13 @@ PyArray_SortkindConverter(PyObject *obj, NPY_SORTKIND *sortkind)
         return PY_FAIL;
     }
     if (str[0] == 'q' || str[0] == 'Q') {
-        *sortkind = PyArray_QUICKSORT;
+        *sortkind = NPY_QUICKSORT;
     }
     else if (str[0] == 'h' || str[0] == 'H') {
-        *sortkind = PyArray_HEAPSORT;
+        *sortkind = NPY_HEAPSORT;
     }
     else if (str[0] == 'm' || str[0] == 'M') {
-        *sortkind = PyArray_MERGESORT;
+        *sortkind = NPY_MERGESORT;
     }
     else {
         PyErr_Format(PyExc_ValueError,
@@ -1030,7 +1030,7 @@ PyArray_TypestrConvert(int itemsize, int gentype)
                 case 8:
                     newtype = NPY_INT64;
                     break;
-#ifdef PyArray_INT128
+#ifdef NPY_INT128
                 case 16:
                     newtype = NPY_INT128;
                     break;
@@ -1052,7 +1052,7 @@ PyArray_TypestrConvert(int itemsize, int gentype)
                 case 8:
                     newtype = NPY_UINT64;
                     break;
-#ifdef PyArray_INT128
+#ifdef NPY_INT128
                 case 16:
                     newtype = NPY_UINT128;
                     break;
@@ -1071,17 +1071,17 @@ PyArray_TypestrConvert(int itemsize, int gentype)
                 case 8:
                     newtype = NPY_FLOAT64;
                     break;
-#ifdef PyArray_FLOAT80
+#ifdef NPY_FLOAT80
                 case 10:
                     newtype = NPY_FLOAT80;
                     break;
 #endif
-#ifdef PyArray_FLOAT96
+#ifdef NPY_FLOAT96
                 case 12:
                     newtype = NPY_FLOAT96;
                     break;
 #endif
-#ifdef PyArray_FLOAT128
+#ifdef NPY_FLOAT128
                 case 16:
                     newtype = NPY_FLOAT128;
                     break;
@@ -1097,17 +1097,17 @@ PyArray_TypestrConvert(int itemsize, int gentype)
                 case 16:
                     newtype = NPY_COMPLEX128;
                     break;
-#ifdef PyArray_FLOAT80
+#ifdef NPY_FLOAT80
                 case 20:
                     newtype = NPY_COMPLEX160;
                     break;
 #endif
-#ifdef PyArray_FLOAT96
+#ifdef NPY_FLOAT96
                 case 24:
                     newtype = NPY_COMPLEX192;
                     break;
 #endif
-#ifdef PyArray_FLOAT128
+#ifdef NPY_FLOAT128
                 case 32:
                     newtype = NPY_COMPLEX256;
                     break;
diff --git a/numpy/core/src/multiarray/convert.c b/numpy/core/src/multiarray/convert.c
index 555256c63..e55f33140 100644
--- a/numpy/core/src/multiarray/convert.c
+++ b/numpy/core/src/multiarray/convert.c
@@ -257,7 +257,7 @@ PyArray_ToString(PyArrayObject *self, NPY_ORDER order)
     if (order == NPY_ANYORDER)
         order = PyArray_ISFORTRAN(self);
 
-    /*        if (PyArray_TYPE(self) == PyArray_OBJECT) {
+    /*        if (PyArray_TYPE(self) == NPY_OBJECT) {
               PyErr_SetString(PyExc_ValueError, "a string for the data" \
               "in an object array is not appropriate");
               return NULL;
diff --git a/numpy/core/src/multiarray/convert_datatype.c b/numpy/core/src/multiarray/convert_datatype.c
index d519efe69..88463c6b5 100644
--- a/numpy/core/src/multiarray/convert_datatype.c
+++ b/numpy/core/src/multiarray/convert_datatype.c
@@ -287,7 +287,7 @@ PyArray_AdaptFlexibleDType(PyObject *data_obj, PyArray_Descr *data_dtype,
 /*
  * Must be broadcastable.
  * This code is very similar to PyArray_CopyInto/PyArray_MoveInto
- * except casting is done --- PyArray_BUFSIZE is used
+ * except casting is done --- NPY_BUFSIZE is used
  * as the size of the casting buffer.
  */
 
@@ -352,7 +352,7 @@ PyArray_CanCastSafely(int fromtype, int totype)
 
     from = PyArray_DescrFromType(fromtype);
     /*
-     * cancastto is a PyArray_NOTYPE terminated C-int-array of types that
+     * cancastto is a NPY_NOTYPE terminated C-int-array of types that
      * the data-type can be cast to safely.
      */
     if (from->f->cancastto) {
@@ -734,7 +734,7 @@ PyArray_CanCastScalar(PyTypeObject *from, PyTypeObject *to)
 
     fromtype = _typenum_fromtypeobj((PyObject *)from, 0);
     totype = _typenum_fromtypeobj((PyObject *)to, 0);
-    if (fromtype == PyArray_NOTYPE || totype == PyArray_NOTYPE) {
+    if (fromtype == NPY_NOTYPE || totype == NPY_NOTYPE) {
         return FALSE;
     }
     return (npy_bool) PyArray_CanCastSafely(fromtype, totype);
diff --git a/numpy/core/src/multiarray/ctors.c b/numpy/core/src/multiarray/ctors.c
index a24767faa..fec6e63c1 100644
--- a/numpy/core/src/multiarray/ctors.c
+++ b/numpy/core/src/multiarray/ctors.c
@@ -918,7 +918,7 @@ PyArray_NewFromDescr(PyTypeObject *subtype, PyArray_Descr *descr, int nd,
             sd = descr->elsize = 1;
         }
         else {
-            sd = descr->elsize = sizeof(PyArray_UCS4);
+            sd = descr->elsize = sizeof(npy_ucs4);
         }
     }
 
@@ -1273,7 +1273,7 @@ _array_from_buffer_3118(PyObject *obj, PyObject **out)
         }
     }
     else {
-        descr = PyArray_DescrNewFromType(PyArray_STRING);
+        descr = PyArray_DescrNewFromType(NPY_STRING);
         descr->elsize = view->itemsize;
     }
 
@@ -2142,7 +2142,7 @@ PyArray_FromStructInterface(PyObject *input)
     PyArrayInterface *inter;
     PyObject *attr;
     PyArrayObject *ret;
-    char endian = PyArray_NATBYTE;
+    char endian = NPY_NATBYTE;
 
     attr = PyObject_GetAttrString(input, "__array_struct__");
     if (attr == NULL) {
@@ -3288,7 +3288,7 @@ PyArray_ArangeObj(PyObject *start, PyObject *stop, PyObject *step, PyArray_Descr
      * order version.  And then swap on the way out.
      */
     if (!PyArray_ISNBO(dtype->byteorder)) {
-        native = PyArray_DescrNewByteorder(dtype, PyArray_NATBYTE);
+        native = PyArray_DescrNewByteorder(dtype, NPY_NATBYTE);
         swap = 1;
     }
     else {
@@ -3470,7 +3470,7 @@ array_from_text(PyArray_Descr *dtype, npy_intp num, char *sep, size_t *nread,
         }
     }
     if (num < 0) {
-        tmp = PyDataMem_RENEW(PyArray_DATA(r), NPY_MAX(*nread,1)*dtype->elsize);
+        tmp = PyDataMem_RENEW(PyArray_DATA(r), PyArray_MAX(*nread,1)*dtype->elsize);
         if (tmp == NULL) {
             err = 1;
         }
@@ -3549,7 +3549,7 @@ PyArray_FromFile(FILE *fp, PyArray_Descr *dtype, npy_intp num, char *sep)
     }
     if (((npy_intp) nread) < num) {
         /* Realloc memory for smaller number of elements */
-        const size_t nsize = NPY_MAX(nread,1)*PyArray_DESCR(ret)->elsize;
+        const size_t nsize = PyArray_MAX(nread,1)*PyArray_DESCR(ret)->elsize;
         char *tmp;
 
         if((tmp = PyDataMem_RENEW(PyArray_DATA(ret), nsize)) == NULL) {
diff --git a/numpy/core/src/multiarray/descriptor.c b/numpy/core/src/multiarray/descriptor.c
index 7e7daa724..16aab402a 100644
--- a/numpy/core/src/multiarray/descriptor.c
+++ b/numpy/core/src/multiarray/descriptor.c
@@ -227,7 +227,7 @@ _convert_from_tuple(PyObject *obj)
             goto fail;
         }
         PyArray_DESCR_REPLACE(type);
-        if (type->type_num == PyArray_UNICODE) {
+        if (type->type_num == NPY_UNICODE) {
             type->elsize = itemsize << 2;
         }
         else {
@@ -244,7 +244,7 @@ _convert_from_tuple(PyObject *obj)
     else {
         /*
          * interpret next item as shape (if it's a tuple)
-         * and reset the type to PyArray_VOID with
+         * and reset the type to NPY_VOID with
          * a new fields attribute.
          */
         PyArray_Dims shape = {NULL, -1};
@@ -268,7 +268,7 @@ _convert_from_tuple(PyObject *obj)
             PyDimMem_FREE(shape.ptr);
             return type;
         }
-        newdescr = PyArray_DescrNewFromType(PyArray_VOID);
+        newdescr = PyArray_DescrNewFromType(NPY_VOID);
         if (newdescr == NULL) {
             PyDimMem_FREE(shape.ptr);
             goto fail;
@@ -471,7 +471,7 @@ _convert_from_array_descr(PyObject *obj, int align)
         totalsize = NPY_NEXT_ALIGNED_OFFSET(totalsize, maxalign);
     }
 
-    new = PyArray_DescrNewFromType(PyArray_VOID);
+    new = PyArray_DescrNewFromType(NPY_VOID);
     if (new == NULL) {
         Py_XDECREF(fields);
         Py_XDECREF(nameslist);
@@ -565,7 +565,7 @@ _convert_from_list(PyObject *obj, int align)
         PyTuple_SET_ITEM(nameslist, i, key);
         totalsize += conv->elsize;
     }
-    new = PyArray_DescrNewFromType(PyArray_VOID);
+    new = PyArray_DescrNewFromType(NPY_VOID);
     new->fields = fields;
     new->names = nameslist;
     new->flags = dtypeflags;
@@ -1142,7 +1142,7 @@ PyArray_DescrConverter2(PyObject *obj, PyArray_Descr **at)
 NPY_NO_EXPORT int
 PyArray_DescrConverter(PyObject *obj, PyArray_Descr **at)
 {
-    int check_num = PyArray_NOTYPE + 10;
+    int check_num = NPY_NOTYPE + 10;
     PyObject *item;
     int elsize = 0;
     char endian = '=';
@@ -1376,7 +1376,7 @@ PyArray_DescrConverter(PyObject *obj, PyArray_Descr **at)
     }
 
 finish:
-    if ((check_num == PyArray_NOTYPE + 10)
+    if ((check_num == NPY_NOTYPE + 10)
         || (*at = PyArray_DescrFromType(check_num)) == NULL) {
         PyErr_Clear();
         /* Now check to see if the object is registered in typeDict */
@@ -1552,7 +1552,7 @@ arraydescr_protocol_typestr_get(PyArray_Descr *self)
             endian = '>';
         }
     }
-    if (self->type_num == PyArray_UNICODE) {
+    if (self->type_num == NPY_UNICODE) {
         size >>= 2;
     }
 
@@ -2100,14 +2100,14 @@ arraydescr_reduce(PyArray_Descr *self, PyObject *NPY_UNUSED(args))
     }
     PyTuple_SET_ITEM(ret, 0, obj);
     if (PyTypeNum_ISUSERDEF(self->type_num)
-            || ((self->type_num == PyArray_VOID
+            || ((self->type_num == NPY_VOID
                     && self->typeobj != &PyVoidArrType_Type))) {
         obj = (PyObject *)self->typeobj;
         Py_INCREF(obj);
     }
     else {
         elsize = self->elsize;
-        if (self->type_num == PyArray_UNICODE) {
+        if (self->type_num == NPY_UNICODE) {
             elsize >>= 2;
         }
         obj = PyUString_FromFormat("%c%d",self->kind, elsize);
@@ -2193,11 +2193,11 @@ static int
 _descr_find_object(PyArray_Descr *self)
 {
     if (self->flags
-            || self->type_num == PyArray_OBJECT
+            || self->type_num == NPY_OBJECT
             || self->kind == 'O') {
         return NPY_OBJECT_DTYPE_FLAGS;
     }
-    if (PyDescr_HASFIELDS(self)) {
+    if (PyDataType_HASFIELDS(self)) {
         PyObject *key, *value, *title = NULL;
         PyArray_Descr *new;
         int offset;
@@ -2483,7 +2483,7 @@ arraydescr_setstate(PyArray_Descr *self, PyObject *args)
  * naming).  If itemsize is given it must be >= size computed from fields
  *
  * The .fields attribute must return a convertible dictionary if present.
- * Result inherits from PyArray_VOID.
+ * Result inherits from NPY_VOID.
 */
 NPY_NO_EXPORT int
 PyArray_DescrAlignConverter(PyObject *obj, PyArray_Descr **at)
@@ -2580,18 +2580,18 @@ PyArray_DescrNewByteorder(PyArray_Descr *self, char newendian)
 
     new = PyArray_DescrNew(self);
     endian = new->byteorder;
-    if (endian != PyArray_IGNORE) {
-        if (newendian == PyArray_SWAP) {
+    if (endian != NPY_IGNORE) {
+        if (newendian == NPY_SWAP) {
             /* swap byteorder */
             if PyArray_ISNBO(endian) {
-                endian = PyArray_OPPBYTE;
+                endian = NPY_OPPBYTE;
             }
             else {
-                endian = PyArray_NATBYTE;
+                endian = NPY_NATBYTE;
             }
             new->byteorder = endian;
         }
-        else if (newendian != PyArray_IGNORE) {
+        else if (newendian != NPY_IGNORE) {
             new->byteorder = newendian;
         }
     }
@@ -2649,7 +2649,7 @@ PyArray_DescrNewByteorder(PyArray_Descr *self, char newendian)
 static PyObject *
 arraydescr_newbyteorder(PyArray_Descr *self, PyObject *args)
 {
-    char endian=PyArray_SWAP;
+    char endian=NPY_SWAP;
 
     if (!PyArg_ParseTuple(args, "|O&", PyArray_ByteorderConverter,
                 &endian)) {
diff --git a/numpy/core/src/multiarray/dtype_transfer.c b/numpy/core/src/multiarray/dtype_transfer.c
index 943859ae5..8bc6c42a6 100644
--- a/numpy/core/src/multiarray/dtype_transfer.c
+++ b/numpy/core/src/multiarray/dtype_transfer.c
@@ -2509,7 +2509,7 @@ get_fields_transfer_function(int aligned,
     _single_field_transfer *fields;
 
     /* Copy the src value to all the fields of dst */
-    if (!PyDescr_HASFIELDS(src_dtype)) {
+    if (!PyDataType_HASFIELDS(src_dtype)) {
         names = dst_dtype->names;
         names_size = PyTuple_GET_SIZE(dst_dtype->names);
 
@@ -2582,7 +2582,7 @@ get_fields_transfer_function(int aligned,
         return NPY_SUCCEED;
     }
     /* Copy the value of the first field to dst */
-    else if (!PyDescr_HASFIELDS(dst_dtype)) {
+    else if (!PyDataType_HASFIELDS(dst_dtype)) {
         names = src_dtype->names;
         names_size = PyTuple_GET_SIZE(src_dtype->names);
 
diff --git a/numpy/core/src/multiarray/getset.c b/numpy/core/src/multiarray/getset.c
index 0031b6ece..8dddb592f 100644
--- a/numpy/core/src/multiarray/getset.c
+++ b/numpy/core/src/multiarray/getset.c
@@ -156,10 +156,10 @@ static PyObject *
 array_priority_get(PyArrayObject *self)
 {
     if (PyArray_CheckExact(self)) {
-        return PyFloat_FromDouble(PyArray_PRIORITY);
+        return PyFloat_FromDouble(NPY_PRIORITY);
     }
     else {
-        return PyFloat_FromDouble(PyArray_SUBTYPE_PRIORITY);
+        return PyFloat_FromDouble(NPY_PRIORITY);
     }
 }
 
@@ -601,14 +601,14 @@ _get_part(PyArrayObject *self, int imag)
     int offset;
 
     switch (PyArray_DESCR(self)->type_num) {
-        case PyArray_CFLOAT:
-            float_type_num = PyArray_FLOAT;
+        case NPY_CFLOAT:
+            float_type_num = NPY_FLOAT;
             break;
-        case PyArray_CDOUBLE:
-            float_type_num = PyArray_DOUBLE;
+        case NPY_CDOUBLE:
+            float_type_num = NPY_DOUBLE;
             break;
-        case PyArray_CLONGDOUBLE:
-            float_type_num = PyArray_LONGDOUBLE;
+        case NPY_CLONGDOUBLE:
+            float_type_num = NPY_LONGDOUBLE;
             break;
         default:
             PyErr_Format(PyExc_ValueError,
diff --git a/numpy/core/src/multiarray/item_selection.c b/numpy/core/src/multiarray/item_selection.c
index 8058a9959..4aa52d230 100644
--- a/numpy/core/src/multiarray/item_selection.c
+++ b/numpy/core/src/multiarray/item_selection.c
@@ -1125,7 +1125,7 @@ PyArray_Sort(PyArrayObject *op, int axis, NPY_SORTKIND which)
     if (PyArray_DESCR(op)->f->sort[which] != NULL) {
         return _new_sort(op, axis, which);
     }
-    if ((which != PyArray_QUICKSORT)
+    if ((which != NPY_QUICKSORT)
         || PyArray_DESCR(op)->f->compare == NULL) {
         PyErr_SetString(PyExc_TypeError,
                         "desired sort not supported for this type");
@@ -1221,7 +1221,7 @@ PyArray_ArgSort(PyArrayObject *op, int axis, NPY_SORTKIND which)
         return (PyObject *)ret;
     }
 
-    if ((which != PyArray_QUICKSORT) || PyArray_DESCR(op2)->f->compare == NULL) {
+    if ((which != NPY_QUICKSORT) || PyArray_DESCR(op2)->f->compare == NULL) {
         PyErr_SetString(PyExc_TypeError,
                         "requested sort not available for type");
         Py_DECREF(op2);
@@ -1232,7 +1232,7 @@ PyArray_ArgSort(PyArrayObject *op, int axis, NPY_SORTKIND which)
     /* ap will contain the reference to op2 */
     SWAPAXES(ap, op2);
     op = (PyArrayObject *)PyArray_ContiguousFromAny((PyObject *)ap,
-                                                    PyArray_NOTYPE,
+                                                    NPY_NOTYPE,
                                                     1, 0);
     Py_DECREF(ap);
     if (op == NULL) {
@@ -1340,7 +1340,7 @@ PyArray_LexSort(PyObject *sort_keys, int axis)
                 goto fail;
             }
         }
-        if (!PyArray_DESCR(mps[i])->f->argsort[PyArray_MERGESORT]) {
+        if (!PyArray_DESCR(mps[i])->f->argsort[NPY_MERGESORT]) {
             PyErr_Format(PyExc_TypeError,
                          "merge sort not available for item %d", i);
             goto fail;
@@ -1428,7 +1428,7 @@ PyArray_LexSort(PyObject *sort_keys, int axis)
             for (j = 0; j < n; j++) {
                 elsize = PyArray_DESCR(mps[j])->elsize;
                 astride = PyArray_STRIDES(mps[j])[axis];
-                argsort = PyArray_DESCR(mps[j])->f->argsort[PyArray_MERGESORT];
+                argsort = PyArray_DESCR(mps[j])->f->argsort[NPY_MERGESORT];
                 _unaligned_strided_byte_copy(valbuffer, (intp) elsize,
                                              its[j]->dataptr, astride, N, elsize);
                 if (swaps[j]) {
@@ -1457,7 +1457,7 @@ PyArray_LexSort(PyObject *sort_keys, int axis)
                 *iptr++ = i;
             }
             for (j = 0; j < n; j++) {
-                argsort = PyArray_DESCR(mps[j])->f->argsort[PyArray_MERGESORT];
+                argsort = PyArray_DESCR(mps[j])->f->argsort[NPY_MERGESORT];
                 if (argsort(its[j]->dataptr, (intp *)rit->dataptr,
                             N, mps[j]) < 0) {
                     goto fail;
diff --git a/numpy/core/src/multiarray/iterators.c b/numpy/core/src/multiarray/iterators.c
index e359b26a6..4347b9aee 100644
--- a/numpy/core/src/multiarray/iterators.c
+++ b/numpy/core/src/multiarray/iterators.c
@@ -882,7 +882,7 @@ iter_subscript(PyArrayIterObject *self, PyObject *ind)
     }
 
     /* convert to INTP array if Integer array scalar or List */
-    indtype = PyArray_DescrFromType(PyArray_INTP);
+    indtype = PyArray_DescrFromType(NPY_INTP);
     if (PyArray_IsScalar(ind, Integer) || PyList_Check(ind)) {
         Py_INCREF(indtype);
         obj = PyArray_FromAny(ind, indtype, 0, 0, NPY_ARRAY_FORCECAST, NULL);
@@ -1145,7 +1145,7 @@ iter_ass_subscript(PyArrayIterObject *self, PyObject *ind, PyObject *val)
     }
 
     /* convert to INTP array if Integer array scalar or List */
-    indtype = PyArray_DescrFromType(PyArray_INTP);
+    indtype = PyArray_DescrFromType(NPY_INTP);
     if (PyList_Check(ind)) {
         Py_INCREF(indtype);
         obj = PyArray_FromAny(ind, indtype, 0, 0, NPY_ARRAY_FORCECAST, NULL);
@@ -1157,7 +1157,7 @@ iter_ass_subscript(PyArrayIterObject *self, PyObject *ind, PyObject *val)
 
     if (obj != NULL && PyArray_Check(obj)) {
         /* Check for Boolean object */
-        if (PyArray_TYPE((PyArrayObject *)obj)==PyArray_BOOL) {
+        if (PyArray_TYPE((PyArrayObject *)obj)==NPY_BOOL) {
             if (iter_ass_sub_Bool(self, (PyArrayObject *)obj,
                                   val_it, swap) < 0) {
                 goto finish;
diff --git a/numpy/core/src/multiarray/mapping.c b/numpy/core/src/multiarray/mapping.c
index ed03105d5..15952fe93 100644
--- a/numpy/core/src/multiarray/mapping.c
+++ b/numpy/core/src/multiarray/mapping.c
@@ -242,7 +242,7 @@ _swap_axes(PyArrayMapIterObject *mit, PyArrayObject **ret, int getmap)
         for (i = 0; i < mit->nd-PyArray_NDIM(arr); i++) {
             permute.ptr[i] = 1;
         }
-        new = PyArray_Newshape(arr, &permute, PyArray_ANYORDER);
+        new = PyArray_Newshape(arr, &permute, NPY_ANYORDER);
         Py_DECREF(arr);
         *ret = (PyArrayObject *)new;
         if (new == NULL) {
@@ -1928,7 +1928,7 @@ _nonzero_indices(PyObject *myBool, PyArrayIterObject **iters)
     /* create count-sized index arrays for each dimension */
     for (j = 0; j < nd; j++) {
         new = (PyArrayObject *)PyArray_New(&PyArray_Type, 1, &count,
-                                           PyArray_INTP, NULL, NULL,
+                                           NPY_INTP, NULL, NULL,
                                            0, 0, NULL);
         if (new == NULL) {
             goto fail;
@@ -2000,7 +2000,7 @@ _convert_obj(PyObject *obj, PyArrayIterObject **iter)
         return _nonzero_indices(obj, iter);
     }
     else {
-        indtype = PyArray_DescrFromType(PyArray_INTP);
+        indtype = PyArray_DescrFromType(NPY_INTP);
         arr = PyArray_FromAny(obj, indtype, 0, 0, NPY_ARRAY_FORCECAST, NULL);
         if (arr == NULL) {
             return -1;
diff --git a/numpy/core/src/multiarray/methods.c b/numpy/core/src/multiarray/methods.c
index 8e01bc1c9..24af4db5b 100644
--- a/numpy/core/src/multiarray/methods.c
+++ b/numpy/core/src/multiarray/methods.c
@@ -176,7 +176,7 @@ array_reshape(PyArrayObject *self, PyObject *args, PyObject *kwds)
     static char *keywords[] = {"order", NULL};
     PyArray_Dims newshape;
     PyObject *ret;
-    PyArray_ORDER order = NPY_CORDER;
+    NPY_ORDER order = NPY_CORDER;
     Py_ssize_t n = PyTuple_Size(args);
 
     if (!NpyArg_ParseKeywords(kwds, "|O&", keywords,
@@ -1107,7 +1107,7 @@ array_getarray(PyArrayObject *self, PyObject *args)
 static PyObject *
 array_copy(PyArrayObject *self, PyObject *args, PyObject *kwds)
 {
-    PyArray_ORDER order = NPY_CORDER;
+    NPY_ORDER order = NPY_CORDER;
     PyObject *maskna_in = Py_None;
     int maskna = -1;
     static char *kwlist[] = {"order", "maskna", NULL};
@@ -1247,7 +1247,7 @@ array_sort(PyArrayObject *self, PyObject *args, PyObject *kwds)
 {
     int axis=-1;
     int val;
-    PyArray_SORTKIND sortkind = PyArray_QUICKSORT;
+    NPY_SORTKIND sortkind = NPY_QUICKSORT;
     PyObject *order = NULL;
     PyArray_Descr *saved = NULL;
     PyArray_Descr *newd;
@@ -1303,7 +1303,7 @@ static PyObject *
 array_argsort(PyArrayObject *self, PyObject *args, PyObject *kwds)
 {
     int axis = -1;
-    PyArray_SORTKIND sortkind = PyArray_QUICKSORT;
+    NPY_SORTKIND sortkind = NPY_QUICKSORT;
     PyObject *order = NULL, *res;
     PyArray_Descr *newd, *saved=NULL;
     static char *kwlist[] = {"axis", "kind", "order", NULL};
@@ -1371,7 +1371,7 @@ _deepcopy_call(char *iptr, char *optr, PyArray_Descr *dtype,
     if (!PyDataType_REFCHK(dtype)) {
         return;
     }
-    else if (PyDescr_HASFIELDS(dtype)) {
+    else if (PyDataType_HASFIELDS(dtype)) {
         PyObject *key, *value, *title = NULL;
         PyArray_Descr *new;
         int offset;
@@ -1737,11 +1737,11 @@ array_setstate(PyArrayObject *self, PyObject *args)
                 }
                 else {
                     fa->descr = PyArray_DescrNew(typecode);
-                    if (PyArray_DESCR(self)->byteorder == PyArray_BIG) {
-                        PyArray_DESCR(self)->byteorder = PyArray_LITTLE;
+                    if (PyArray_DESCR(self)->byteorder == NPY_BIG) {
+                        PyArray_DESCR(self)->byteorder = NPY_LITTLE;
                     }
-                    else if (PyArray_DESCR(self)->byteorder == PyArray_LITTLE) {
-                        PyArray_DESCR(self)->byteorder = PyArray_BIG;
+                    else if (PyArray_DESCR(self)->byteorder == NPY_LITTLE) {
+                        PyArray_DESCR(self)->byteorder = NPY_BIG;
                     }
                 }
                 Py_DECREF(typecode);
@@ -1900,7 +1900,7 @@ array_transpose(PyArrayObject *self, PyObject *args)
     return ret;
 }
 
-#define _CHKTYPENUM(typ) ((typ) ? (typ)->type_num : PyArray_NOTYPE)
+#define _CHKTYPENUM(typ) ((typ) ? (typ)->type_num : NPY_NOTYPE)
 
 static PyObject *
 array_mean(PyArrayObject *self, PyObject *args, PyObject *kwds)
@@ -2185,7 +2185,7 @@ array_diagonal(PyArrayObject *self, PyObject *args, PyObject *kwds)
 static PyObject *
 array_flatten(PyArrayObject *self, PyObject *args, PyObject *kwds)
 {
-    PyArray_ORDER order = NPY_CORDER;
+    NPY_ORDER order = NPY_CORDER;
     static char *kwlist[] = {"order", NULL};
 
     if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O&", kwlist,
@@ -2199,7 +2199,7 @@ array_flatten(PyArrayObject *self, PyObject *args, PyObject *kwds)
 static PyObject *
 array_ravel(PyArrayObject *self, PyObject *args, PyObject *kwds)
 {
-    PyArray_ORDER order = NPY_CORDER;
+    NPY_ORDER order = NPY_CORDER;
     static char *kwlist[] = {"order", NULL};
 
     if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O&", kwlist,
@@ -2301,7 +2301,7 @@ array_setflags(PyArrayObject *self, PyObject *args, PyObject *kwds)
 static PyObject *
 array_newbyteorder(PyArrayObject *self, PyObject *args)
 {
-    char endian = PyArray_SWAP;
+    char endian = NPY_SWAP;
     PyArray_Descr *new;
 
     if (!PyArg_ParseTuple(args, "|O&", PyArray_ByteorderConverter,
diff --git a/numpy/core/src/multiarray/multiarraymodule.c b/numpy/core/src/multiarray/multiarraymodule.c
index d06e782a1..fff1c5ce3 100644
--- a/numpy/core/src/multiarray/multiarraymodule.c
+++ b/numpy/core/src/multiarray/multiarraymodule.c
@@ -662,9 +662,9 @@ _signbit_set(PyArrayObject *arr)
     byteorder = PyArray_DESCR(arr)->byteorder;
     ptr = PyArray_DATA(arr);
     if (elsize > 1 &&
-        (byteorder == PyArray_LITTLE ||
-         (byteorder == PyArray_NATIVE &&
-          PyArray_ISNBO(PyArray_LITTLE)))) {
+        (byteorder == NPY_LITTLE ||
+         (byteorder == NPY_NATIVE &&
+          PyArray_ISNBO(NPY_LITTLE)))) {
         ptr += elsize - 1;
     }
     return ((*ptr & bitmask) != 0);
@@ -684,14 +684,14 @@ _signbit_set(PyArrayObject *arr)
 NPY_NO_EXPORT NPY_SCALARKIND
 PyArray_ScalarKind(int typenum, PyArrayObject **arr)
 {
-    NPY_SCALARKIND ret = PyArray_NOSCALAR;
+    NPY_SCALARKIND ret = NPY_NOSCALAR;
 
     if ((unsigned int)typenum < NPY_NTYPES) {
         ret = _npy_scalar_kinds_table[typenum];
         /* Signed integer types are INTNEG in the table */
-        if (ret == PyArray_INTNEG_SCALAR) {
+        if (ret == NPY_INTNEG_SCALAR) {
             if (!arr || !_signbit_set(*arr)) {
-                ret = PyArray_INTPOS_SCALAR;
+                ret = NPY_INTPOS_SCALAR;
             }
         }
     } else if (PyTypeNum_ISUSERDEF(typenum)) {
@@ -719,13 +719,13 @@ PyArray_CanCoerceScalar(int thistype, int neededtype,
     int *castlist;
 
     /* If 'thistype' is not a scalar, it must be safely castable */
-    if (scalar == PyArray_NOSCALAR) {
+    if (scalar == NPY_NOSCALAR) {
         return PyArray_CanCastSafely(thistype, neededtype);
     }
     if ((unsigned int)neededtype < NPY_NTYPES) {
         NPY_SCALARKIND neededscalar;
 
-        if (scalar == PyArray_OBJECT_SCALAR) {
+        if (scalar == NPY_OBJECT_SCALAR) {
             return PyArray_CanCastSafely(thistype, neededtype);
         }
 
@@ -754,7 +754,7 @@ PyArray_CanCoerceScalar(int thistype, int neededtype,
     from = PyArray_DescrFromType(thistype);
     if (from->f->cancastscalarkindto
         && (castlist = from->f->cancastscalarkindto[scalar])) {
-        while (*castlist != PyArray_NOTYPE) {
+        while (*castlist != NPY_NOTYPE) {
             if (*castlist++ == neededtype) {
                 Py_DECREF(from);
                 return 1;
diff --git a/numpy/core/src/multiarray/number.c b/numpy/core/src/multiarray/number.c
index a1caa849a..a4e42ead0 100644
--- a/numpy/core/src/multiarray/number.c
+++ b/numpy/core/src/multiarray/number.c
@@ -140,9 +140,9 @@ static PyObject *
 _get_keywords(int rtype, PyArrayObject *out)
 {
     PyObject *kwds = NULL;
-    if (rtype != PyArray_NOTYPE || out != NULL) {
+    if (rtype != NPY_NOTYPE || out != NULL) {
         kwds = PyDict_New();
-        if (rtype != PyArray_NOTYPE) {
+        if (rtype != NPY_NOTYPE) {
             PyArray_Descr *descr;
             descr = PyArray_DescrFromType(rtype);
             if (descr) {
diff --git a/numpy/core/src/multiarray/refcount.c b/numpy/core/src/multiarray/refcount.c
index 409d4d30f..9e5bd888e 100644
--- a/numpy/core/src/multiarray/refcount.c
+++ b/numpy/core/src/multiarray/refcount.c
@@ -1,5 +1,5 @@
 /*
- * This module corresponds to the `Special functions for PyArray_OBJECT`
+ * This module corresponds to the `Special functions for NPY_OBJECT`
  * section in the numpy reference for C-API.
  */
 
@@ -31,11 +31,11 @@ PyArray_Item_INCREF(char *data, PyArray_Descr *descr)
     if (!PyDataType_REFCHK(descr)) {
         return;
     }
-    if (descr->type_num == PyArray_OBJECT) {
+    if (descr->type_num == NPY_OBJECT) {
         NPY_COPY_PYOBJECT_PTR(&temp, data);
         Py_XINCREF(temp);
     }
-    else if (PyDescr_HASFIELDS(descr)) {
+    else if (PyDataType_HASFIELDS(descr)) {
         PyObject *key, *value, *title = NULL;
         PyArray_Descr *new;
         int offset;
@@ -67,11 +67,11 @@ PyArray_Item_XDECREF(char *data, PyArray_Descr *descr)
         return;
     }
 
-    if (descr->type_num == PyArray_OBJECT) {
+    if (descr->type_num == NPY_OBJECT) {
         NPY_COPY_PYOBJECT_PTR(&temp, data);
         Py_XDECREF(temp);
     }
-    else if PyDescr_HASFIELDS(descr) {
+    else if PyDataType_HASFIELDS(descr) {
             PyObject *key, *value, *title = NULL;
             PyArray_Descr *new;
             int offset;
@@ -107,7 +107,7 @@ PyArray_INCREF(PyArrayObject *mp)
     if (!PyDataType_REFCHK(PyArray_DESCR(mp))) {
         return 0;
     }
-    if (PyArray_DESCR(mp)->type_num != PyArray_OBJECT) {
+    if (PyArray_DESCR(mp)->type_num != NPY_OBJECT) {
         it = (PyArrayIterObject *)PyArray_IterNew((PyObject *)mp);
         if (it == NULL) {
             return -1;
@@ -165,7 +165,7 @@ PyArray_XDECREF(PyArrayObject *mp)
     if (!PyDataType_REFCHK(PyArray_DESCR(mp))) {
         return 0;
     }
-    if (PyArray_DESCR(mp)->type_num != PyArray_OBJECT) {
+    if (PyArray_DESCR(mp)->type_num != NPY_OBJECT) {
         it = (PyArrayIterObject *)PyArray_IterNew((PyObject *)mp);
         if (it == NULL) {
             return -1;
@@ -214,7 +214,7 @@ PyArray_FillObjectArray(PyArrayObject *arr, PyObject *obj)
 {
     intp i,n;
     n = PyArray_SIZE(arr);
-    if (PyArray_DESCR(arr)->type_num == PyArray_OBJECT) {
+    if (PyArray_DESCR(arr)->type_num == NPY_OBJECT) {
         PyObject **optr;
         optr = (PyObject **)(PyArray_DATA(arr));
         n = PyArray_SIZE(arr);
@@ -259,7 +259,7 @@ _fillobject(char *optr, PyObject *obj, PyArray_Descr *dtype)
             Py_XDECREF(arr);
         }
     }
-    else if (PyDescr_HASFIELDS(dtype)) {
+    else if (PyDataType_HASFIELDS(dtype)) {
         PyObject *key, *value, *title = NULL;
         PyArray_Descr *new;
         int offset;
diff --git a/numpy/core/src/multiarray/scalarapi.c b/numpy/core/src/multiarray/scalarapi.c
index 0ee4a3b09..0cee4b2ea 100644
--- a/numpy/core/src/multiarray/scalarapi.c
+++ b/numpy/core/src/multiarray/scalarapi.c
@@ -27,7 +27,7 @@ _descr_from_subtype(PyObject *type)
     PyObject *mro;
     mro = ((PyTypeObject *)type)->tp_mro;
     if (PyTuple_GET_SIZE(mro) < 2) {
-        return PyArray_DescrFromType(PyArray_OBJECT);
+        return PyArray_DescrFromType(NPY_OBJECT);
     }
     return PyArray_DescrFromTypeObject(PyTuple_GET_ITEM(mro, 1));
 }
@@ -277,7 +277,7 @@ PyArray_FromScalar(PyObject *scalar, PyArray_Descr *outcode)
 
     /* convert to 0-dim array of scalar typecode */
     typecode = PyArray_DescrFromScalar(scalar);
-    if ((typecode->type_num == PyArray_VOID) &&
+    if ((typecode->type_num == NPY_VOID) &&
             !(((PyVoidScalarObject *)scalar)->flags & NPY_ARRAY_OWNDATA) &&
             outcode == NULL) {
         r = (PyArrayObject *)PyArray_NewFromDescr(&PyArray_Type,
@@ -316,9 +316,9 @@ PyArray_FromScalar(PyObject *scalar, PyArray_Descr *outcode)
     memptr = scalar_value(scalar, typecode);
 
 #ifndef Py_UNICODE_WIDE
-    if (typecode->type_num == PyArray_UNICODE) {
+    if (typecode->type_num == NPY_UNICODE) {
         PyUCS2Buffer_AsUCS4((Py_UNICODE *)memptr,
-                (PyArray_UCS4 *)PyArray_DATA(r),
+                (npy_ucs4 *)PyArray_DATA(r),
                 PyUnicode_GET_SIZE(scalar),
                 PyArray_ITEMSIZE(r) >> 2);
     }
@@ -454,7 +454,7 @@ PyArray_DescrFromTypeObject(PyObject *type)
         typenum = NPY_VOID;
     }
 
-    if (typenum != PyArray_NOTYPE) {
+    if (typenum != NPY_NOTYPE) {
         return PyArray_DescrFromType(typenum);
     }
 
@@ -538,13 +538,13 @@ PyArray_DescrFromScalar(PyObject *sc)
 
         dt_data = _pya_malloc(sizeof(PyArray_DatetimeMetaData));
         if (PyArray_IsScalar(sc, Datetime)) {
-            descr = PyArray_DescrNewFromType(PyArray_DATETIME);
+            descr = PyArray_DescrNewFromType(NPY_DATETIME);
             memcpy(dt_data, &((PyDatetimeScalarObject *)sc)->obmeta,
                    sizeof(PyArray_DatetimeMetaData));
         }
         else {
             /* Timedelta */
-            descr = PyArray_DescrNewFromType(PyArray_TIMEDELTA);
+            descr = PyArray_DescrNewFromType(NPY_TIMEDELTA);
             memcpy(dt_data, &((PyTimedeltaScalarObject *)sc)->obmeta,
                    sizeof(PyArray_DatetimeMetaData));
         }
@@ -572,10 +572,10 @@ PyArray_DescrFromScalar(PyObject *sc)
     if (descr->elsize == 0) {
         PyArray_DESCR_REPLACE(descr);
         type_num = descr->type_num;
-        if (type_num == PyArray_STRING) {
+        if (type_num == NPY_STRING) {
             descr->elsize = PyString_GET_SIZE(sc);
         }
-        else if (type_num == PyArray_UNICODE) {
+        else if (type_num == NPY_UNICODE) {
             descr->elsize = PyUnicode_GET_DATA_SIZE(sc);
 #ifndef Py_UNICODE_WIDE
             descr->elsize <<= 1;
@@ -636,7 +636,7 @@ PyArray_Scalar(void *data, PyArray_Descr *descr, PyObject *base)
     int swap;
 
     type_num = descr->type_num;
-    if (type_num == PyArray_BOOL) {
+    if (type_num == NPY_BOOL) {
         PyArrayScalar_RETURN_BOOL_FROM_LONG(*(Bool*)data);
     }
     else if (PyDataType_FLAGCHK(descr, NPY_USE_GETITEM)) {
@@ -654,7 +654,7 @@ PyArray_Scalar(void *data, PyArray_Descr *descr, PyObject *base)
         while(itemsize && *dptr-- == 0) {
             itemsize--;
         }
-        if (type_num == PyArray_UNICODE && itemsize) {
+        if (type_num == NPY_UNICODE && itemsize) {
             /*
              * make sure itemsize is a multiple of 4
              * so round up to nearest multiple
@@ -689,7 +689,7 @@ PyArray_Scalar(void *data, PyArray_Descr *descr, PyObject *base)
                sizeof(PyArray_DatetimeMetaData));
     }
     if (PyTypeNum_ISFLEXIBLE(type_num)) {
-        if (type_num == PyArray_STRING) {
+        if (type_num == NPY_STRING) {
             destptr = PyString_AS_STRING(obj);
             ((PyStringObject *)obj)->ob_shash = -1;
 #if !defined(NPY_PY3K)
@@ -698,7 +698,7 @@ PyArray_Scalar(void *data, PyArray_Descr *descr, PyObject *base)
             memcpy(destptr, data, itemsize);
             return obj;
         }
-        else if (type_num == PyArray_UNICODE) {
+        else if (type_num == NPY_UNICODE) {
             PyUnicodeObject *uni = (PyUnicodeObject*)obj;
             size_t length = itemsize >> 2;
 #ifndef Py_UNICODE_WIDE
@@ -746,7 +746,7 @@ PyArray_Scalar(void *data, PyArray_Descr *descr, PyObject *base)
              * Now convert from the data-buffer
              */
             length = PyUCS2Buffer_FromUCS4(uni->str,
-                    (PyArray_UCS4 *)buffer, itemsize >> 2);
+                    (npy_ucs4 *)buffer, itemsize >> 2);
             if (alloc) {
                 _pya_free(buffer);
             }
diff --git a/numpy/core/src/multiarray/scalartypes.c.src b/numpy/core/src/multiarray/scalartypes.c.src
index 7f95d7c02..dc9facfc4 100644
--- a/numpy/core/src/multiarray/scalartypes.c.src
+++ b/numpy/core/src/multiarray/scalartypes.c.src
@@ -1220,16 +1220,16 @@ static PyArray_Descr *
 _realdescr_fromcomplexscalar(PyObject *self, int *typenum)
 {
     if (PyArray_IsScalar(self, CDouble)) {
-        *typenum = PyArray_CDOUBLE;
-        return PyArray_DescrFromType(PyArray_DOUBLE);
+        *typenum = NPY_CDOUBLE;
+        return PyArray_DescrFromType(NPY_DOUBLE);
     }
     if (PyArray_IsScalar(self, CFloat)) {
-        *typenum = PyArray_CFLOAT;
-        return PyArray_DescrFromType(PyArray_FLOAT);
+        *typenum = NPY_CFLOAT;
+        return PyArray_DescrFromType(NPY_FLOAT);
     }
     if (PyArray_IsScalar(self, CLongDouble)) {
-        *typenum = PyArray_CLONGDOUBLE;
-        return PyArray_DescrFromType(PyArray_LONGDOUBLE);
+        *typenum = NPY_CLONGDOUBLE;
+        return PyArray_DescrFromType(NPY_LONGDOUBLE);
     }
     return NULL;
 }
@@ -1281,7 +1281,7 @@ gentype_imag_get(PyObject *self)
         if (ret == NULL) {
             PyErr_Clear();
             obj = PyInt_FromLong(0);
-            newtype = PyArray_DescrFromType(PyArray_OBJECT);
+            newtype = PyArray_DescrFromType(NPY_OBJECT);
             ret = PyArray_Scalar((char *)&obj, newtype, NULL);
             Py_DECREF(newtype);
             Py_DECREF(obj);
@@ -1624,7 +1624,7 @@ voidtype_setfield(PyVoidScalarObject *self, PyObject *args, PyObject *kwds)
 
     dptr = self->obval + offset;
 
-    if (typecode->type_num == PyArray_OBJECT) {
+    if (typecode->type_num == NPY_OBJECT) {
         PyObject *temp;
         Py_INCREF(value);
         NPY_COPY_PYOBJECT_PTR(&temp, dptr);
@@ -1709,7 +1709,7 @@ gentype_reduce(PyObject *self, PyObject *NPY_UNUSED(args))
             }
             alloc = 1;
             newlen = PyUCS2Buffer_AsUCS4((Py_UNICODE *)buffer,
-                    (PyArray_UCS4 *)tmp,
+                    (npy_ucs4 *)tmp,
                     buflen / 2, buflen / 2);
             buflen = newlen*4;
             buffer = tmp;
@@ -2051,7 +2051,7 @@ voidtype_item(PyVoidScalarObject *self, Py_ssize_t n)
     intp m;
     PyObject *flist=NULL, *fieldinfo;
 
-    if (!(PyDescr_HASFIELDS(self->descr))) {
+    if (!(PyDataType_HASFIELDS(self->descr))) {
         PyErr_SetString(PyExc_IndexError,
                 "can't index void scalar without fields");
         return NULL;
@@ -2078,7 +2078,7 @@ voidtype_subscript(PyVoidScalarObject *self, PyObject *ind)
     intp n;
     PyObject *fieldinfo;
 
-    if (!(PyDescr_HASFIELDS(self->descr))) {
+    if (!(PyDataType_HASFIELDS(self->descr))) {
         PyErr_SetString(PyExc_IndexError,
                 "can't index void scalar without fields");
         return NULL;
@@ -2116,7 +2116,7 @@ voidtype_ass_item(PyVoidScalarObject *self, Py_ssize_t n, PyObject *val)
     PyObject *flist=NULL, *fieldinfo, *newtup;
     PyObject *res;
 
-    if (!(PyDescr_HASFIELDS(self->descr))) {
+    if (!(PyDataType_HASFIELDS(self->descr))) {
         PyErr_SetString(PyExc_IndexError,
                 "can't index void scalar without fields");
         return -1;
@@ -2156,7 +2156,7 @@ voidtype_ass_subscript(PyVoidScalarObject *self, PyObject *ind, PyObject *val)
     PyObject *fieldinfo, *newtup;
     PyObject *res;
 
-    if (!PyDescr_HASFIELDS(self->descr)) {
+    if (!PyDataType_HASFIELDS(self->descr)) {
         PyErr_SetString(PyExc_IndexError,
                 "can't index void scalar without fields");
         return -1;
@@ -2549,7 +2549,7 @@ finish:
         return NULL;
     }
     /* typecode will be NULL */
-    typecode = PyArray_DescrFromType(PyArray_@TYPE@);
+    typecode = PyArray_DescrFromType(NPY_@TYPE@);
     dest = scalar_value(obj, typecode);
     src = scalar_value(robj, typecode);
     Py_DECREF(typecode);
@@ -2840,7 +2840,7 @@ void_arrtype_new(PyTypeObject *type, PyObject *args, PyObject *NPY_UNUSED(kwds))
         ((PyVoidScalarObject *)ret)->obval = destptr;
         Py_SIZE((PyVoidScalarObject *)ret) = (int) memu;
         ((PyVoidScalarObject *)ret)->descr =
-            PyArray_DescrNewFromType(PyArray_VOID);
+            PyArray_DescrNewFromType(NPY_VOID);
         ((PyVoidScalarObject *)ret)->descr->elsize = (int) memu;
         ((PyVoidScalarObject *)ret)->flags = NPY_ARRAY_BEHAVED |
                                              NPY_ARRAY_OWNDATA;
@@ -2849,7 +2849,7 @@ void_arrtype_new(PyTypeObject *type, PyObject *args, PyObject *NPY_UNUSED(kwds))
         return ret;
     }
 
-    arr = PyArray_FROM_OTF(obj, PyArray_VOID, NPY_ARRAY_FORCECAST);
+    arr = PyArray_FROM_OTF(obj, NPY_VOID, NPY_ARRAY_FORCECAST);
     return PyArray_Return((PyArrayObject *)arr);
 }
 
@@ -3701,7 +3701,7 @@ initialize_casting_tables(void)
     _npy_smallest_type_of_kind_table[NPY_OBJECT_SCALAR] = NPY_OBJECT;
 
     /* Default for built-in types is object scalar */
-    memset(_npy_scalar_kinds_table, PyArray_OBJECT_SCALAR,
+    memset(_npy_scalar_kinds_table, NPY_OBJECT_SCALAR,
                                         sizeof(_npy_scalar_kinds_table));
     /* Default for next largest type is -1, signalling no bigger */
     memset(_npy_next_larger_type_table, -1,
@@ -3719,7 +3719,7 @@ initialize_casting_tables(void)
  * #SCKIND = BOOL, (INTNEG, INTPOS)*5, FLOAT*4,
  *           COMPLEX*3#
  */
-    _npy_scalar_kinds_table[NPY_@NAME@] = PyArray_@SCKIND@_SCALAR;
+    _npy_scalar_kinds_table[NPY_@NAME@] = NPY_@SCKIND@_SCALAR;
     _npy_next_larger_type_table[NPY_@NAME@] = @BIGGERTYPE@;
 /**end repeat**/
 
@@ -4165,9 +4165,9 @@ _typenum_fromtypeobj(PyObject *type, int user)
 {
     int typenum, i;
 
-    typenum = PyArray_NOTYPE;
+    typenum = NPY_NOTYPE;
     i = 0;
-    while(i < PyArray_NTYPES) {
+    while(i < NPY_NTYPES) {
         if (type == (PyObject *)typeobjects[i]) {
             typenum = i;
             break;
@@ -4180,9 +4180,9 @@ _typenum_fromtypeobj(PyObject *type, int user)
     }
     /* Search any registered types */
     i = 0;
-    while (i < PyArray_NUMUSERTYPES) {
+    while (i < NPY_NUMUSERTYPES) {
         if (type == (PyObject *)(userdescrs[i]->typeobj)) {
-            typenum = i + PyArray_USERDEF;
+            typenum = i + NPY_USERDEF;
             break;
         }
         i++;
diff --git a/numpy/core/src/multiarray/shape.c b/numpy/core/src/multiarray/shape.c
index 1c5dc590f..611071cc0 100644
--- a/numpy/core/src/multiarray/shape.c
+++ b/numpy/core/src/multiarray/shape.c
@@ -379,7 +379,7 @@ PyArray_Reshape(PyArrayObject *self, PyObject *shape)
     if (!PyArray_IntpConverter(shape, &newdims)) {
         return NULL;
     }
-    ret = PyArray_Newshape(self, &newdims, PyArray_CORDER);
+    ret = PyArray_Newshape(self, &newdims, NPY_CORDER);
     PyDimMem_FREE(newdims.ptr);
     return ret;
 }
@@ -433,7 +433,7 @@ _putzero(char *optr, PyObject *zero, PyArray_Descr *dtype)
     if (!PyDataType_FLAGCHK(dtype, NPY_ITEM_REFCOUNT)) {
         memset(optr, 0, dtype->elsize);
     }
-    else if (PyDescr_HASFIELDS(dtype)) {
+    else if (PyDataType_HASFIELDS(dtype)) {
         PyObject *key, *value, *title = NULL;
         PyArray_Descr *new;
         int offset;
diff --git a/numpy/core/src/multiarray/ucsnarrow.c b/numpy/core/src/multiarray/ucsnarrow.c
index e405a2dbb..689b53d69 100644
--- a/numpy/core/src/multiarray/ucsnarrow.c
+++ b/numpy/core/src/multiarray/ucsnarrow.c
@@ -29,11 +29,11 @@
    values above 0xffff are converted to surrogate pairs.
 */
 NPY_NO_EXPORT int
-PyUCS2Buffer_FromUCS4(Py_UNICODE *ucs2, PyArray_UCS4 *ucs4, int ucs4length)
+PyUCS2Buffer_FromUCS4(Py_UNICODE *ucs2, npy_ucs4 *ucs4, int ucs4length)
 {
     int i;
     int numucs2 = 0;
-    PyArray_UCS4 chr;
+    npy_ucs4 chr;
     for (i=0; i<ucs4length; i++) {
         chr = *ucs4++;
         if (chr > 0xffff) {
@@ -61,10 +61,10 @@ PyUCS2Buffer_FromUCS4(Py_UNICODE *ucs2, PyArray_UCS4 *ucs4, int ucs4length)
 */
 
 NPY_NO_EXPORT int
-PyUCS2Buffer_AsUCS4(Py_UNICODE *ucs2, PyArray_UCS4 *ucs4, int ucs2len, int ucs4len)
+PyUCS2Buffer_AsUCS4(Py_UNICODE *ucs2, npy_ucs4 *ucs4, int ucs2len, int ucs4len)
 {
     int i;
-    PyArray_UCS4 chr;
+    npy_ucs4 chr;
     Py_UNICODE ch;
     int numchars=0;
 
@@ -72,12 +72,12 @@ PyUCS2Buffer_AsUCS4(Py_UNICODE *ucs2, PyArray_UCS4 *ucs4, int ucs2len, int ucs4l
         ch = *ucs2++;
         if (ch >= 0xd800 && ch <= 0xdfff) {
             /* surrogate pair */
-            chr = ((PyArray_UCS4)(ch-0xd800)) << 10;
+            chr = ((npy_ucs4)(ch-0xd800)) << 10;
             chr += *ucs2++ + 0x2400;  /* -0xdc00 + 0x10000 */
             i++;
         }
         else {
-            chr = (PyArray_UCS4) ch;
+            chr = (npy_ucs4) ch;
         }
         *ucs4++ = chr;
         numchars++;
diff --git a/numpy/core/src/multiarray/ucsnarrow.h b/numpy/core/src/multiarray/ucsnarrow.h
index 4b0e0c111..6ef645ba0 100644
--- a/numpy/core/src/multiarray/ucsnarrow.h
+++ b/numpy/core/src/multiarray/ucsnarrow.h
@@ -7,10 +7,10 @@ int int int;
 #endif
 
 NPY_NO_EXPORT int
-PyUCS2Buffer_FromUCS4(Py_UNICODE *ucs2, PyArray_UCS4 *ucs4, int ucs4length);
+PyUCS2Buffer_FromUCS4(Py_UNICODE *ucs2, npy_ucs4 *ucs4, int ucs4length);
 
 NPY_NO_EXPORT int
-PyUCS2Buffer_AsUCS4(Py_UNICODE *ucs2, PyArray_UCS4 *ucs4, int ucs2len, int ucs4len);
+PyUCS2Buffer_AsUCS4(Py_UNICODE *ucs2, npy_ucs4 *ucs4, int ucs2len, int ucs4len);
 
 NPY_NO_EXPORT PyObject *
 MyPyUnicode_New(int length);
diff --git a/numpy/core/src/multiarray/usertypes.c b/numpy/core/src/multiarray/usertypes.c
index 61df37b16..49f9618ed 100644
--- a/numpy/core/src/multiarray/usertypes.c
+++ b/numpy/core/src/multiarray/usertypes.c
@@ -47,12 +47,12 @@ _append_new(int *types, int insert)
     int n = 0;
     int *newtypes;
 
-    while (types[n] != PyArray_NOTYPE) {
+    while (types[n] != NPY_NOTYPE) {
         n++;
     }
     newtypes = (int *)realloc(types, (n + 2)*sizeof(int));
     newtypes[n] = insert;
-    newtypes[n + 1] = PyArray_NOTYPE;
+    newtypes[n + 1] = NPY_NOTYPE;
     return newtypes;
 }
 
@@ -111,7 +111,7 @@ PyArray_InitArrFuncs(PyArray_ArrFuncs *f)
     f->nonzero = NULL;
     f->fill = NULL;
     f->fillwithscalar = NULL;
-    for(i = 0; i < PyArray_NSORTS; i++) {
+    for(i = 0; i < NPY_NSORTS; i++) {
         f->sort[i] = NULL;
         f->argsort[i] = NULL;
     }
@@ -122,7 +122,7 @@ PyArray_InitArrFuncs(PyArray_ArrFuncs *f)
 }
 
 /*
-  returns typenum to associate with this type >=PyArray_USERDEF.
+  returns typenum to associate with this type >=NPY_USERDEF.
   needs the userdecrs table and PyArray_NUMUSER variables
   defined in arraytypes.inc
 */
@@ -145,7 +145,7 @@ PyArray_RegisterDataType(PyArray_Descr *descr)
             return descr->type_num;
         }
     }
-    typenum = PyArray_USERDEF + NPY_NUMUSERTYPES;
+    typenum = NPY_USERDEF + NPY_NUMUSERTYPES;
     descr->type_num = typenum;
     if (descr->elsize == 0) {
         PyErr_SetString(PyExc_ValueError, "cannot register a" \
@@ -240,7 +240,7 @@ PyArray_RegisterCanCast(PyArray_Descr *descr, int totype,
         return -1;
     }
 
-    if (scalar == PyArray_NOSCALAR) {
+    if (scalar == NPY_NOSCALAR) {
         /*
          * register with cancastto
          * These lists won't be freed once created
@@ -248,7 +248,7 @@ PyArray_RegisterCanCast(PyArray_Descr *descr, int totype,
          */
         if (descr->f->cancastto == NULL) {
             descr->f->cancastto = (int *)malloc(1*sizeof(int));
-            descr->f->cancastto[0] = PyArray_NOTYPE;
+            descr->f->cancastto[0] = NPY_NOTYPE;
         }
         descr->f->cancastto = _append_new(descr->f->cancastto,
                                           totype);
@@ -258,8 +258,8 @@ PyArray_RegisterCanCast(PyArray_Descr *descr, int totype,
         if (descr->f->cancastscalarkindto == NULL) {
             int i;
             descr->f->cancastscalarkindto =
-                (int **)malloc(PyArray_NSCALARKINDS* sizeof(int*));
-            for (i = 0; i < PyArray_NSCALARKINDS; i++) {
+                (int **)malloc(NPY_NSCALARKINDS* sizeof(int*));
+            for (i = 0; i < NPY_NSCALARKINDS; i++) {
                 descr->f->cancastscalarkindto[i] = NULL;
             }
         }
@@ -267,7 +267,7 @@ PyArray_RegisterCanCast(PyArray_Descr *descr, int totype,
             descr->f->cancastscalarkindto[scalar] =
                 (int *)malloc(1*sizeof(int));
             descr->f->cancastscalarkindto[scalar][0] =
-                PyArray_NOTYPE;
+                NPY_NOTYPE;
         }
         descr->f->cancastscalarkindto[scalar] =
             _append_new(descr->f->cancastscalarkindto[scalar], totype);
diff --git a/numpy/core/src/scalarmathmodule.c.src b/numpy/core/src/scalarmathmodule.c.src
index 6f18b043a..24f5ebfe8 100644
--- a/numpy/core/src/scalarmathmodule.c.src
+++ b/numpy/core/src/scalarmathmodule.c.src
@@ -600,8 +600,8 @@ _@name@_convert_to_ctype(PyObject *a, npy_@name@ *arg1)
             return -1;
         }
         descr1 = PyArray_DescrFromTypeObject((PyObject *)Py_TYPE(a));
-        if (PyArray_CanCastSafely(descr1->type_num, PyArray_@NAME@)) {
-            PyArray_CastScalarDirect(a, descr1, arg1, PyArray_@NAME@);
+        if (PyArray_CanCastSafely(descr1->type_num, NPY_@NAME@)) {
+            PyArray_CastScalarDirect(a, descr1, arg1, NPY_@NAME@);
             Py_DECREF(descr1);
             return 0;
         }
@@ -610,8 +610,8 @@ _@name@_convert_to_ctype(PyObject *a, npy_@name@ *arg1)
             return -1;
         }
     }
-    else if (PyArray_GetPriority(a, PyArray_SUBTYPE_PRIORITY) >
-            PyArray_SUBTYPE_PRIORITY) {
+    else if (PyArray_GetPriority(a, NPY_PRIORITY) >
+            NPY_PRIORITY) {
         return -2;
     }
     else if ((temp = PyArray_ScalarFromObject(a)) != NULL) {
@@ -1360,7 +1360,7 @@ get_functions(void)
 
     i = 0;
     j = 0;
-    while(signatures[i] != PyArray_FLOAT) {i+=3; j++;}
+    while(signatures[i] != NPY_FLOAT) {i+=3; j++;}
     _basic_half_pow = funcdata[j-1];
     _basic_float_pow = funcdata[j];
     _basic_double_pow = funcdata[j+1];
@@ -1377,7 +1377,7 @@ get_functions(void)
     signatures = ((PyUFuncObject *)obj)->types;
     i = 0;
     j = 0;
-    while(signatures[i] != PyArray_FLOAT) {i+=2; j++;}
+    while(signatures[i] != NPY_FLOAT) {i+=2; j++;}
     _basic_half_floor = funcdata[j-1];
     _basic_float_floor = funcdata[j];
     _basic_double_floor = funcdata[j+1];
@@ -1391,7 +1391,7 @@ get_functions(void)
     signatures = ((PyUFuncObject *)obj)->types;
     i = 0;
     j = 0;
-    while(signatures[i] != PyArray_FLOAT) {i+=2; j++;}
+    while(signatures[i] != NPY_FLOAT) {i+=2; j++;}
     _basic_half_sqrt = funcdata[j-1];
     _basic_float_sqrt = funcdata[j];
     _basic_double_sqrt = funcdata[j+1];
@@ -1405,7 +1405,7 @@ get_functions(void)
     signatures = ((PyUFuncObject *)obj)->types;
     i = 0;
     j = 0;
-    while(signatures[i] != PyArray_FLOAT) {i+=3; j++;}
+    while(signatures[i] != NPY_FLOAT) {i+=3; j++;}
     _basic_half_fmod = funcdata[j-1];
     _basic_float_fmod = funcdata[j];
     _basic_double_fmod = funcdata[j+1];
diff --git a/numpy/core/src/umath/ufunc_object.c b/numpy/core/src/umath/ufunc_object.c
index d87433341..0c7f6b3db 100644
--- a/numpy/core/src/umath/ufunc_object.c
+++ b/numpy/core/src/umath/ufunc_object.c
@@ -279,10 +279,10 @@ _find_array_prepare(PyObject *args, PyObject *kwds,
         prep = preps[0];
         if (np > 1) {
             double maxpriority = PyArray_GetPriority(with_prep[0],
-                        PyArray_SUBTYPE_PRIORITY);
+                        NPY_PRIORITY);
             for (i = 1; i < np; ++i) {
                 double priority = PyArray_GetPriority(with_prep[i],
-                            PyArray_SUBTYPE_PRIORITY);
+                            NPY_PRIORITY);
                 if (priority > maxpriority) {
                     maxpriority = priority;
                     Py_DECREF(prep);
@@ -386,14 +386,14 @@ _extract_pyvals(PyObject *ref, char *name, int *bufsize,
     if ((*bufsize == -1) && PyErr_Occurred()) {
         return -1;
     }
-    if ((*bufsize < PyArray_MIN_BUFSIZE)
-        || (*bufsize > PyArray_MAX_BUFSIZE)
+    if ((*bufsize < NPY_MIN_BUFSIZE)
+        || (*bufsize > NPY_MAX_BUFSIZE)
         || (*bufsize % 16 != 0)) {
         PyErr_Format(PyExc_ValueError,
                      "buffer size (%d) is not in range "
                      "(%"INTP_FMT" - %"INTP_FMT") or not a multiple of 16",
-                     *bufsize, (intp) PyArray_MIN_BUFSIZE,
-                     (intp) PyArray_MAX_BUFSIZE);
+                     *bufsize, (intp) NPY_MIN_BUFSIZE,
+                     (intp) NPY_MAX_BUFSIZE);
         return -1;
     }
 
@@ -459,7 +459,7 @@ PyUFunc_GetPyValues(char *name, int *bufsize, int *errmask, PyObject **errobj)
     if (ref == NULL) {
         *errmask = UFUNC_ERR_DEFAULT;
         *errobj = Py_BuildValue("NO", PyBytes_FromString(name), Py_None);
-        *bufsize = PyArray_BUFSIZE;
+        *bufsize = NPY_BUFSIZE;
         return 0;
     }
     return _extract_pyvals(ref, name, bufsize, errmask, errobj);
@@ -3677,7 +3677,7 @@ PyUFunc_GenericReduction(PyUFuncObject *ufunc, PyObject *args,
 
     if (operation == UFUNC_REDUCEAT) {
         PyArray_Descr *indtype;
-        indtype = PyArray_DescrFromType(PyArray_INTP);
+        indtype = PyArray_DescrFromType(NPY_INTP);
         if (!PyArg_ParseTupleAndKeywords(args, kwds, "OO|OO&O&i", kwlist2,
                                         &op,
                                         &obj_ind,
@@ -4003,10 +4003,10 @@ _find_array_wrap(PyObject *args, PyObject *kwds,
         wrap = wraps[0];
         if (np > 1) {
             double maxpriority = PyArray_GetPriority(with_wrap[0],
-                        PyArray_SUBTYPE_PRIORITY);
+                        NPY_PRIORITY);
             for (i = 1; i < np; ++i) {
                 double priority = PyArray_GetPriority(with_wrap[i],
-                            PyArray_SUBTYPE_PRIORITY);
+                            NPY_PRIORITY);
                 if (priority > maxpriority) {
                     maxpriority = priority;
                     Py_DECREF(wrap);
@@ -4221,7 +4221,7 @@ ufunc_geterr(PyObject *NPY_UNUSED(dummy), PyObject *args)
     if (res == NULL) {
         return NULL;
     }
-    PyList_SET_ITEM(res, 0, PyInt_FromLong(PyArray_BUFSIZE));
+    PyList_SET_ITEM(res, 0, PyInt_FromLong(NPY_BUFSIZE));
     PyList_SET_ITEM(res, 1, PyInt_FromLong(UFUNC_ERR_DEFAULT));
     PyList_SET_ITEM(res, 2, Py_None); Py_INCREF(Py_None);
     return res;
@@ -4248,7 +4248,7 @@ ufunc_update_use_defaults(void)
         Py_XDECREF(errobj);
         return -1;
     }
-    if ((errmask != UFUNC_ERR_DEFAULT) || (bufsize != PyArray_BUFSIZE)
+    if ((errmask != UFUNC_ERR_DEFAULT) || (bufsize != NPY_BUFSIZE)
             || (PyTuple_GET_ITEM(errobj, 1) != Py_None)) {
         PyUFunc_NUM_NODEFAULTS += 1;
     }
@@ -4507,7 +4507,7 @@ PyUFunc_RegisterLoopForType(PyUFuncObject *ufunc,
     int *newtypes=NULL;
 
     descr=PyArray_DescrFromType(usertype);
-    if ((usertype < PyArray_USERDEF) || (descr==NULL)) {
+    if ((usertype < NPY_USERDEF) || (descr==NULL)) {
         PyErr_SetString(PyExc_TypeError, "unknown user-defined type");
         return -1;
     }
@@ -4688,7 +4688,7 @@ ufunc_outer(PyUFuncObject *ufunc, PyObject *args, PyObject *kwds)
     if (tmp == NULL) {
         return NULL;
     }
-    ap1 = (PyArrayObject *) PyArray_FromObject(tmp, PyArray_NOTYPE, 0, 0);
+    ap1 = (PyArrayObject *) PyArray_FromObject(tmp, NPY_NOTYPE, 0, 0);
     Py_DECREF(tmp);
     if (ap1 == NULL) {
         return NULL;
@@ -4697,7 +4697,7 @@ ufunc_outer(PyUFuncObject *ufunc, PyObject *args, PyObject *kwds)
     if (tmp == NULL) {
         return NULL;
     }
-    ap2 = (PyArrayObject *)PyArray_FromObject(tmp, PyArray_NOTYPE, 0, 0);
+    ap2 = (PyArrayObject *)PyArray_FromObject(tmp, NPY_NOTYPE, 0, 0);
     Py_DECREF(tmp);
     if (ap2 == NULL) {
         Py_DECREF(ap1);
diff --git a/numpy/core/src/umath/umath_tests.c.src b/numpy/core/src/umath/umath_tests.c.src
index cb1d541f5..3234f8bb1 100644
--- a/numpy/core/src/umath/umath_tests.c.src
+++ b/numpy/core/src/umath/umath_tests.c.src
@@ -200,13 +200,13 @@ defdict = {
 
 static PyUFuncGenericFunction inner1d_functions[] = { LONG_inner1d, DOUBLE_inner1d };
 static void * inner1d_data[] = { (void *)NULL, (void *)NULL };
-static char inner1d_signatures[] = { PyArray_LONG, PyArray_LONG, PyArray_LONG, PyArray_DOUBLE, PyArray_DOUBLE, PyArray_DOUBLE };
+static char inner1d_signatures[] = { NPY_LONG, NPY_LONG, NPY_LONG, NPY_DOUBLE, NPY_DOUBLE, NPY_DOUBLE };
 static PyUFuncGenericFunction innerwt_functions[] = { LONG_innerwt, DOUBLE_innerwt };
 static void * innerwt_data[] = { (void *)NULL, (void *)NULL };
-static char innerwt_signatures[] = { PyArray_LONG, PyArray_LONG, PyArray_LONG, PyArray_LONG, PyArray_DOUBLE, PyArray_DOUBLE, PyArray_DOUBLE, PyArray_DOUBLE };
+static char innerwt_signatures[] = { NPY_LONG, NPY_LONG, NPY_LONG, NPY_LONG, NPY_DOUBLE, NPY_DOUBLE, NPY_DOUBLE, NPY_DOUBLE };
 static PyUFuncGenericFunction matrix_multiply_functions[] = { LONG_matrix_multiply, FLOAT_matrix_multiply, DOUBLE_matrix_multiply };
 static void *matrix_multiply_data[] = { (void *)NULL, (void *)NULL, (void *)NULL };
-static char matrix_multiply_signatures[] = { PyArray_LONG, PyArray_LONG, PyArray_LONG,  PyArray_FLOAT, PyArray_FLOAT, PyArray_FLOAT,  PyArray_DOUBLE, PyArray_DOUBLE, PyArray_DOUBLE };
+static char matrix_multiply_signatures[] = { NPY_LONG, NPY_LONG, NPY_LONG,  NPY_FLOAT, NPY_FLOAT, NPY_FLOAT,  NPY_DOUBLE, NPY_DOUBLE, NPY_DOUBLE };
 
 static void
 addUfuncs(PyObject *dictionary) {
diff --git a/numpy/core/src/umath/umathmodule.c.src b/numpy/core/src/umath/umathmodule.c.src
index 9843b0eba..bd3907731 100644
--- a/numpy/core/src/umath/umathmodule.c.src
+++ b/numpy/core/src/umath/umathmodule.c.src
@@ -174,7 +174,7 @@ ufunc_frompyfunc(PyObject *NPY_UNUSED(dummy), PyObject *args, PyObject *NPY_UNUS
     self->data[0] = (void *)fdata;
     self->types = (char *)self->data + sizeof(void *);
     for (i = 0; i < self->nargs; i++) {
-        self->types[i] = PyArray_OBJECT;
+        self->types[i] = NPY_OBJECT;
     }
     str = self->types + offset[1];
     memcpy(str, fname, fname_len);
@@ -213,12 +213,12 @@ static void * blank6_data[] = { (void *)NULL, (void *)NULL, (void *)NULL,
                                 (void *)NULL, (void *)NULL, (void *)NULL};
 static char frexp_signatures[] = {
 #ifdef HAVE_FREXPF
-    PyArray_HALF, PyArray_HALF, PyArray_INT,
-    PyArray_FLOAT, PyArray_FLOAT, PyArray_INT,
+    NPY_HALF, NPY_HALF, NPY_INT,
+    NPY_FLOAT, NPY_FLOAT, NPY_INT,
 #endif
-    PyArray_DOUBLE, PyArray_DOUBLE, PyArray_INT
+    NPY_DOUBLE, NPY_DOUBLE, NPY_INT
 #ifdef HAVE_FREXPL
-    ,PyArray_LONGDOUBLE, PyArray_LONGDOUBLE, PyArray_INT
+    ,NPY_LONGDOUBLE, NPY_LONGDOUBLE, NPY_INT
 #endif
 };
 
@@ -246,16 +246,16 @@ static PyUFuncGenericFunction ldexp_functions[] = {
 
 static char ldexp_signatures[] = {
 #ifdef HAVE_LDEXPF
-    PyArray_HALF, PyArray_INT, PyArray_HALF,
-    PyArray_FLOAT, PyArray_INT, PyArray_FLOAT,
-    PyArray_HALF, PyArray_LONG, PyArray_HALF,
-    PyArray_FLOAT, PyArray_LONG, PyArray_FLOAT,
+    NPY_HALF, NPY_INT, NPY_HALF,
+    NPY_FLOAT, NPY_INT, NPY_FLOAT,
+    NPY_HALF, NPY_LONG, NPY_HALF,
+    NPY_FLOAT, NPY_LONG, NPY_FLOAT,
 #endif
-    PyArray_DOUBLE, PyArray_INT, PyArray_DOUBLE,
-    PyArray_DOUBLE, PyArray_LONG, PyArray_DOUBLE
+    NPY_DOUBLE, NPY_INT, NPY_DOUBLE,
+    NPY_DOUBLE, NPY_LONG, NPY_DOUBLE
 #ifdef HAVE_LDEXPL
-    ,PyArray_LONGDOUBLE, PyArray_INT, PyArray_LONGDOUBLE
-    ,PyArray_LONGDOUBLE, PyArray_LONG, PyArray_LONGDOUBLE
+    ,NPY_LONGDOUBLE, NPY_INT, NPY_LONGDOUBLE
+    ,NPY_LONGDOUBLE, NPY_LONG, NPY_LONGDOUBLE
 #endif
 };
 
@@ -410,7 +410,7 @@ PyMODINIT_FUNC initumath(void)
 
 #undef ADDCONST
 #undef ADDSCONST
-    PyModule_AddIntConstant(m, "UFUNC_BUFSIZE_DEFAULT", (long)PyArray_BUFSIZE);
+    PyModule_AddIntConstant(m, "UFUNC_BUFSIZE_DEFAULT", (long)NPY_BUFSIZE);
 
     PyModule_AddObject(m, "PINF", PyFloat_FromDouble(NPY_INFINITY));
     PyModule_AddObject(m, "NINF", PyFloat_FromDouble(-NPY_INFINITY));
diff --git a/numpy/f2py/capi_maps.py b/numpy/f2py/capi_maps.py
index beff1e212..7fd1179c3 100644
--- a/numpy/f2py/capi_maps.py
+++ b/numpy/f2py/capi_maps.py
@@ -49,45 +49,45 @@ c2py_map={'double':'float',
           'complex_long_double':'complex',          # forced casting
           'string':'string',
           }
-c2capi_map={'double':'PyArray_DOUBLE',
-            'float':'PyArray_FLOAT',
-            'long_double':'PyArray_DOUBLE',           # forced casting
-            'char':'PyArray_CHAR',
-            'unsigned_char':'PyArray_UBYTE',
-            'signed_char':'PyArray_SBYTE',
-            'short':'PyArray_SHORT',
-            'unsigned_short':'PyArray_USHORT',
-            'int':'PyArray_INT',
-            'unsigned':'PyArray_UINT',
-            'long':'PyArray_LONG',
-            'long_long':'PyArray_LONG',                # forced casting
-            'complex_float':'PyArray_CFLOAT',
-            'complex_double':'PyArray_CDOUBLE',
-            'complex_long_double':'PyArray_CDOUBLE',   # forced casting
-            'string':'PyArray_CHAR'}
+c2capi_map={'double':'NPY_DOUBLE',
+            'float':'NPY_FLOAT',
+            'long_double':'NPY_DOUBLE',           # forced casting
+            'char':'NPY_CHAR',
+            'unsigned_char':'NPY_UBYTE',
+            'signed_char':'NPY_BYTE',
+            'short':'NPY_SHORT',
+            'unsigned_short':'NPY_USHORT',
+            'int':'NPY_INT',
+            'unsigned':'NPY_UINT',
+            'long':'NPY_LONG',
+            'long_long':'NPY_LONG',                # forced casting
+            'complex_float':'NPY_CFLOAT',
+            'complex_double':'NPY_CDOUBLE',
+            'complex_long_double':'NPY_CDOUBLE',   # forced casting
+            'string':'NPY_CHAR'}
 
 #These new maps aren't used anyhere yet, but should be by default
 #  unless building numeric or numarray extensions.
 if using_newcore:
-    c2capi_map={'double':'PyArray_DOUBLE',
-            'float':'PyArray_FLOAT',
-            'long_double':'PyArray_LONGDOUBLE',
-            'char':'PyArray_BYTE',
-            'unsigned_char':'PyArray_UBYTE',
-            'signed_char':'PyArray_BYTE',
-            'short':'PyArray_SHORT',
-            'unsigned_short':'PyArray_USHORT',
-            'int':'PyArray_INT',
-            'unsigned':'PyArray_UINT',
-            'long':'PyArray_LONG',
-            'unsigned_long':'PyArray_ULONG',
-            'long_long':'PyArray_LONGLONG',
-            'unsigned_long_long':'Pyarray_ULONGLONG',
-            'complex_float':'PyArray_CFLOAT',
-            'complex_double':'PyArray_CDOUBLE',
-            'complex_long_double':'PyArray_CDOUBLE',
-            'string':'PyArray_CHAR', # f2py 2e is not ready for PyArray_STRING (must set itemisize etc)
-            #'string':'PyArray_STRING'
+    c2capi_map={'double':'NPY_DOUBLE',
+            'float':'NPY_FLOAT',
+            'long_double':'NPY_LONGDOUBLE',
+            'char':'NPY_BYTE',
+            'unsigned_char':'NPY_UBYTE',
+            'signed_char':'NPY_BYTE',
+            'short':'NPY_SHORT',
+            'unsigned_short':'NPY_USHORT',
+            'int':'NPY_INT',
+            'unsigned':'NPY_UINT',
+            'long':'NPY_LONG',
+            'unsigned_long':'NPY_ULONG',
+            'long_long':'NPY_LONGLONG',
+            'unsigned_long_long':'NPY_ULONGLONG',
+            'complex_float':'NPY_CFLOAT',
+            'complex_double':'NPY_CDOUBLE',
+            'complex_long_double':'NPY_CDOUBLE',
+            'string':'NPY_CHAR', # f2py 2e is not ready for NPY_STRING (must set itemisize etc)
+            #'string':'NPY_STRING'
 
                 }
 c2pycode_map={'double':'d',
diff --git a/numpy/f2py/cfuncs.py b/numpy/f2py/cfuncs.py
index 9410a9f27..4956e5740 100644
--- a/numpy/f2py/cfuncs.py
+++ b/numpy/f2py/cfuncs.py
@@ -316,9 +316,9 @@ cppmacros['pyobj_from_string1size']='#define pyobj_from_string1size(v,len) (PySt
 needs['TRYPYARRAYTEMPLATE']=['PRINTPYOBJERR']
 cppmacros['TRYPYARRAYTEMPLATE']="""\
 /* New SciPy */
-#define TRYPYARRAYTEMPLATECHAR case PyArray_STRING: *(char *)(arr->data)=*v; break;
-#define TRYPYARRAYTEMPLATELONG case PyArray_LONG: *(long *)(arr->data)=*v; break;
-#define TRYPYARRAYTEMPLATEOBJECT case PyArray_OBJECT: (arr->descr->f->setitem)(pyobj_from_ ## ctype ## 1(*v),arr->data); break;
+#define TRYPYARRAYTEMPLATECHAR case NPY_STRING: *(char *)(arr->data)=*v; break;
+#define TRYPYARRAYTEMPLATELONG case NPY_LONG: *(long *)(arr->data)=*v; break;
+#define TRYPYARRAYTEMPLATEOBJECT case NPY_OBJECT: (arr->descr->f->setitem)(pyobj_from_ ## ctype ## 1(*v),arr->data); break;
 
 #define TRYPYARRAYTEMPLATE(ctype,typecode) \\
         PyArrayObject *arr = NULL;\\
@@ -327,24 +327,24 @@ cppmacros['TRYPYARRAYTEMPLATE']="""\
         if (!(arr=(PyArrayObject *)obj)) {fprintf(stderr,\"TRYPYARRAYTEMPLATE:\");PRINTPYOBJERR(obj);return 0;}\\
         if (arr->descr->type==typecode)  {*(ctype *)(arr->data)=*v; return 1;}\\
         switch (arr->descr->type_num) {\\
-                case PyArray_DOUBLE: *(double *)(arr->data)=*v; break;\\
-                case PyArray_INT: *(int *)(arr->data)=*v; break;\\
-                case PyArray_LONG: *(long *)(arr->data)=*v; break;\\
-                case PyArray_FLOAT: *(float *)(arr->data)=*v; break;\\
-                case PyArray_CDOUBLE: *(double *)(arr->data)=*v; break;\\
-                case PyArray_CFLOAT: *(float *)(arr->data)=*v; break;\\
-                case PyArray_BOOL: *(npy_bool *)(arr->data)=(*v!=0); break;\\
-                case PyArray_UBYTE: *(unsigned char *)(arr->data)=*v; break;\\
-                case PyArray_BYTE: *(signed char *)(arr->data)=*v; break;\\
-                case PyArray_SHORT: *(short *)(arr->data)=*v; break;\\
-                case PyArray_USHORT: *(npy_ushort *)(arr->data)=*v; break;\\
-                case PyArray_UINT: *(npy_uint *)(arr->data)=*v; break;\\
-                case PyArray_ULONG: *(npy_ulong *)(arr->data)=*v; break;\\
-                case PyArray_LONGLONG: *(npy_longlong *)(arr->data)=*v; break;\\
-                case PyArray_ULONGLONG: *(npy_ulonglong *)(arr->data)=*v; break;\\
-                case PyArray_LONGDOUBLE: *(npy_longdouble *)(arr->data)=*v; break;\\
-                case PyArray_CLONGDOUBLE: *(npy_longdouble *)(arr->data)=*v; break;\\
-                case PyArray_OBJECT: (arr->descr->f->setitem)(pyobj_from_ ## ctype ## 1(*v),arr->data, arr); break;\\
+                case NPY_DOUBLE: *(double *)(arr->data)=*v; break;\\
+                case NPY_INT: *(int *)(arr->data)=*v; break;\\
+                case NPY_LONG: *(long *)(arr->data)=*v; break;\\
+                case NPY_FLOAT: *(float *)(arr->data)=*v; break;\\
+                case NPY_CDOUBLE: *(double *)(arr->data)=*v; break;\\
+                case NPY_CFLOAT: *(float *)(arr->data)=*v; break;\\
+                case NPY_BOOL: *(npy_bool *)(arr->data)=(*v!=0); break;\\
+                case NPY_UBYTE: *(unsigned char *)(arr->data)=*v; break;\\
+                case NPY_BYTE: *(signed char *)(arr->data)=*v; break;\\
+                case NPY_SHORT: *(short *)(arr->data)=*v; break;\\
+                case NPY_USHORT: *(npy_ushort *)(arr->data)=*v; break;\\
+                case NPY_UINT: *(npy_uint *)(arr->data)=*v; break;\\
+                case NPY_ULONG: *(npy_ulong *)(arr->data)=*v; break;\\
+                case NPY_LONGLONG: *(npy_longlong *)(arr->data)=*v; break;\\
+                case NPY_ULONGLONG: *(npy_ulonglong *)(arr->data)=*v; break;\\
+                case NPY_LONGDOUBLE: *(npy_longdouble *)(arr->data)=*v; break;\\
+                case NPY_CLONGDOUBLE: *(npy_longdouble *)(arr->data)=*v; break;\\
+                case NPY_OBJECT: (arr->descr->f->setitem)(pyobj_from_ ## ctype ## 1(*v),arr->data, arr); break;\\
         default: return -2;\\
         };\\
         return 1
@@ -352,7 +352,7 @@ cppmacros['TRYPYARRAYTEMPLATE']="""\
 
 needs['TRYCOMPLEXPYARRAYTEMPLATE']=['PRINTPYOBJERR']
 cppmacros['TRYCOMPLEXPYARRAYTEMPLATE']="""\
-#define TRYCOMPLEXPYARRAYTEMPLATEOBJECT case PyArray_OBJECT: (arr->descr->f->setitem)(pyobj_from_complex_ ## ctype ## 1((*v)),arr->data, arr); break;
+#define TRYCOMPLEXPYARRAYTEMPLATEOBJECT case NPY_OBJECT: (arr->descr->f->setitem)(pyobj_from_complex_ ## ctype ## 1((*v)),arr->data, arr); break;
 #define TRYCOMPLEXPYARRAYTEMPLATE(ctype,typecode)\\
         PyArrayObject *arr = NULL;\\
         if (!obj) return -2;\\
@@ -364,24 +364,24 @@ cppmacros['TRYCOMPLEXPYARRAYTEMPLATE']="""\
             return 1;\\
         }\\
         switch (arr->descr->type_num) {\\
-                case PyArray_CDOUBLE: *(double *)(arr->data)=(*v).r;*(double *)(arr->data+sizeof(double))=(*v).i;break;\\
-                case PyArray_CFLOAT: *(float *)(arr->data)=(*v).r;*(float *)(arr->data+sizeof(float))=(*v).i;break;\\
-                case PyArray_DOUBLE: *(double *)(arr->data)=(*v).r; break;\\
-                case PyArray_LONG: *(long *)(arr->data)=(*v).r; break;\\
-                case PyArray_FLOAT: *(float *)(arr->data)=(*v).r; break;\\
-                case PyArray_INT: *(int *)(arr->data)=(*v).r; break;\\
-                case PyArray_SHORT: *(short *)(arr->data)=(*v).r; break;\\
-                case PyArray_UBYTE: *(unsigned char *)(arr->data)=(*v).r; break;\\
-                case PyArray_BYTE: *(signed char *)(arr->data)=(*v).r; break;\\
-                case PyArray_BOOL: *(npy_bool *)(arr->data)=((*v).r!=0 && (*v).i!=0); break;\\
-                case PyArray_USHORT: *(npy_ushort *)(arr->data)=(*v).r; break;\\
-                case PyArray_UINT: *(npy_uint *)(arr->data)=(*v).r; break;\\
-                case PyArray_ULONG: *(npy_ulong *)(arr->data)=(*v).r; break;\\
-                case PyArray_LONGLONG: *(npy_longlong *)(arr->data)=(*v).r; break;\\
-                case PyArray_ULONGLONG: *(npy_ulonglong *)(arr->data)=(*v).r; break;\\
-                case PyArray_LONGDOUBLE: *(npy_longdouble *)(arr->data)=(*v).r; break;\\
-                case PyArray_CLONGDOUBLE: *(npy_longdouble *)(arr->data)=(*v).r;*(npy_longdouble *)(arr->data+sizeof(npy_longdouble))=(*v).i;break;\\
-                case PyArray_OBJECT: (arr->descr->f->setitem)(pyobj_from_complex_ ## ctype ## 1((*v)),arr->data, arr); break;\\
+                case NPY_CDOUBLE: *(double *)(arr->data)=(*v).r;*(double *)(arr->data+sizeof(double))=(*v).i;break;\\
+                case NPY_CFLOAT: *(float *)(arr->data)=(*v).r;*(float *)(arr->data+sizeof(float))=(*v).i;break;\\
+                case NPY_DOUBLE: *(double *)(arr->data)=(*v).r; break;\\
+                case NPY_LONG: *(long *)(arr->data)=(*v).r; break;\\
+                case NPY_FLOAT: *(float *)(arr->data)=(*v).r; break;\\
+                case NPY_INT: *(int *)(arr->data)=(*v).r; break;\\
+                case NPY_SHORT: *(short *)(arr->data)=(*v).r; break;\\
+                case NPY_UBYTE: *(unsigned char *)(arr->data)=(*v).r; break;\\
+                case NPY_BYTE: *(signed char *)(arr->data)=(*v).r; break;\\
+                case NPY_BOOL: *(npy_bool *)(arr->data)=((*v).r!=0 && (*v).i!=0); break;\\
+                case NPY_USHORT: *(npy_ushort *)(arr->data)=(*v).r; break;\\
+                case NPY_UINT: *(npy_uint *)(arr->data)=(*v).r; break;\\
+                case NPY_ULONG: *(npy_ulong *)(arr->data)=(*v).r; break;\\
+                case NPY_LONGLONG: *(npy_longlong *)(arr->data)=(*v).r; break;\\
+                case NPY_ULONGLONG: *(npy_ulonglong *)(arr->data)=(*v).r; break;\\
+                case NPY_LONGDOUBLE: *(npy_longdouble *)(arr->data)=(*v).r; break;\\
+                case NPY_CLONGDOUBLE: *(npy_longdouble *)(arr->data)=(*v).r;*(npy_longdouble *)(arr->data+sizeof(npy_longdouble))=(*v).i;break;\\
+                case NPY_OBJECT: (arr->descr->f->setitem)(pyobj_from_complex_ ## ctype ## 1((*v)),arr->data, arr); break;\\
                 default: return -2;\\
         };\\
         return -1;
@@ -391,7 +391,7 @@ cppmacros['TRYCOMPLEXPYARRAYTEMPLATE']="""\
 ## \tif (PyArray_Check(obj)) arr = (PyArrayObject *)obj;\\
 ## \telse arr = (PyArrayObject *)PyArray_ContiguousFromObject(obj,typenum,0,0);\\
 ## \tif (arr) {\\
-## \t\tif (arr->descr->type_num==PyArray_OBJECT) {\\
+## \t\tif (arr->descr->type_num==NPY_OBJECT) {\\
 ## \t\t\tif (!ctype ## _from_pyobj(v,(arr->descr->getitem)(arr->data),\"\"))\\
 ## \t\t\tgoto capi_fail;\\
 ## \t\t} else {\\
@@ -407,7 +407,7 @@ cppmacros['TRYCOMPLEXPYARRAYTEMPLATE']="""\
 ## \tif (PyArray_Check(obj)) arr = (PyArrayObject *)obj;\\
 ## \telse arr = (PyArrayObject *)PyArray_ContiguousFromObject(obj,typenum,0,0);\\
 ## \tif (arr) {\\
-## \t\tif (arr->descr->type_num==PyArray_OBJECT) {\\
+## \t\tif (arr->descr->type_num==NPY_OBJECT) {\\
 ## \t\t\tif (!ctype ## _from_pyobj(v,(arr->descr->getitem)(arr->data),\"\"))\\
 ## \t\t\tgoto capi_fail;\\
 ## \t\t} else {\\
@@ -812,7 +812,7 @@ static int long_double_from_pyobj(long_double* v,PyObject *obj,const char *errme
 \t\t\tPyArray_ScalarAsCtype(obj, v);
 \t\t\treturn 1;
 \t\t}
-\t\telse if (PyArray_Check(obj) && PyArray_TYPE(obj)==PyArray_LONGDOUBLE) {
+\t\telse if (PyArray_Check(obj) && PyArray_TYPE(obj)==NPY_LONGDOUBLE) {
 \t\t\t(*v) = *((npy_longdouble *)PyArray_DATA(obj));
 \t\t\treturn 1;
 \t\t}
@@ -885,7 +885,7 @@ static int complex_long_double_from_pyobj(complex_long_double* v,PyObject *obj,c
 \t\t\tPyArray_ScalarAsCtype(obj, v);
 \t\t\treturn 1;
 \t\t}
-\t\telse if (PyArray_Check(obj) && PyArray_TYPE(obj)==PyArray_CLONGDOUBLE) {
+\t\telse if (PyArray_Check(obj) && PyArray_TYPE(obj)==NPY_CLONGDOUBLE) {
 \t\t\t(*v).r = ((npy_clongdouble *)PyArray_DATA(obj))->real;
 \t\t\t(*v).i = ((npy_clongdouble *)PyArray_DATA(obj))->imag;
 \t\t\treturn 1;
@@ -929,10 +929,10 @@ static int complex_double_from_pyobj(complex_double* v,PyObject *obj,const char
 \tif (PyArray_CheckScalar(obj)) { /* 0-dim array or still array scalar */
 \t\tPyObject *arr;
 \t\tif (PyArray_Check(obj)) {
-\t\t\tarr = PyArray_Cast((PyArrayObject *)obj, PyArray_CDOUBLE);
+\t\t\tarr = PyArray_Cast((PyArrayObject *)obj, NPY_CDOUBLE);
 \t\t}
 \t\telse {
-\t\t\tarr = PyArray_FromScalar(obj, PyArray_DescrFromType(PyArray_CDOUBLE));
+\t\t\tarr = PyArray_FromScalar(obj, PyArray_DescrFromType(NPY_CDOUBLE));
 \t\t}
 \t\tif (arr==NULL) return 0;
 \t\t(*v).r = ((npy_cdouble *)PyArray_DATA(arr))->real;
@@ -1121,7 +1121,7 @@ def buildcfuncs():
         cppmacros[m]='#define %s(v) (PyArray_SimpleNewFromData(0,NULL,%s,(char *)v))'%(m,c2capi_map[k])
     k='string'
     m='pyarr_from_p_%s1'%k
-    cppmacros[m]='#define %s(v,dims) (PyArray_SimpleNewFromData(1,dims,PyArray_CHAR,(char *)v))'%(m)
+    cppmacros[m]='#define %s(v,dims) (PyArray_SimpleNewFromData(1,dims,NPY_CHAR,(char *)v))'%(m)
 
 
 ############ Auxiliary functions for sorting needs ###################
diff --git a/numpy/f2py/doc/fortranobject.tex b/numpy/f2py/doc/fortranobject.tex
index dbb244cdd..88a56835e 100644
--- a/numpy/f2py/doc/fortranobject.tex
+++ b/numpy/f2py/doc/fortranobject.tex
@@ -77,7 +77,7 @@ typedef struct {
   int rank;                  /* array rank, 0 for scalar, max is F2PY_MAX_DIMS,
                                 || rank=-1 for Fortran routine */
   struct {int d[F2PY_MAX_DIMS];} dims;  /* dimensions of the array, || not used */
-  int type;                  /* PyArray_<type> || not used */
+  int type;                  /* NPY_<type> || not used */
   char *data;                /* pointer to array || Fortran routine */
   void (*func)();            /* initialization function for
                                 allocatable arrays:
@@ -182,7 +182,7 @@ In order to access the variable \texttt{i} from Python,
 \texttt{PyFortranObject} is defined as follows:
 \begin{verbatim}
 static FortranDataDef f2py_bar_def[] = {
-  {"i",0,{-1},PyArray_INT},
+  {"i",0,{-1},NPY_INT},
   {NULL}
 };
 static void f2py_setup_bar(char *i) {
@@ -328,7 +328,7 @@ end module fun
 Then
 \begin{verbatim}
 static FortranDataDef f2py_fun_def[] = {
-  {"i",0,{-1},PyArray_INT},
+  {"i",0,{-1},NPY_INT},
   {NULL}
 };
 static void f2py_setup_fun(char *i) {
@@ -370,7 +370,7 @@ end module fun
 Then
 \begin{verbatim}
 static FortranDataDef f2py_fun_def[] = {
-  {"r",1,{-1},PyArray_FLOAT},
+  {"r",1,{-1},NPY_FLOAT},
   {NULL}
 };
 static void f2py_setup_fun(void (*r)()) {
diff --git a/numpy/f2py/docs/HISTORY.txt b/numpy/f2py/docs/HISTORY.txt
index 72b683eb0..077189ee2 100644
--- a/numpy/f2py/docs/HISTORY.txt
+++ b/numpy/f2py/docs/HISTORY.txt
@@ -491,7 +491,7 @@ Release 2.35.229-1505
 
   - Fixed reference counting bug that appeared when constructing extra
     argument list to callback functions.
-  - Added ``PyArray_LONG != PyArray_INT`` test.
+  - Added ``NPY_LONG != NPY_INT`` test.
 
 * f2py2e.py
 
diff --git a/numpy/f2py/src/fortranobject.c b/numpy/f2py/src/fortranobject.c
index ff80fa7e5..f5e2c6244 100644
--- a/numpy/f2py/src/fortranobject.c
+++ b/numpy/f2py/src/fortranobject.c
@@ -51,10 +51,10 @@ PyFortranObject_New(FortranDataDef* defs, f2py_void_func init) {
             PyDict_SetItemString(fp->dict,fp->defs[i].name,v);
         } else
             if ((fp->defs[i].data)!=NULL) { /* Is Fortran variable or array (not allocatable) */
-                if (fp->defs[i].type == PyArray_STRING) {
+                if (fp->defs[i].type == NPY_STRING) {
                     int n = fp->defs[i].rank-1;
                     v = PyArray_New(&PyArray_Type, n, fp->defs[i].dims.d,
-                                    PyArray_STRING, NULL, fp->defs[i].data, fp->defs[i].dims.d[n],
+                                    NPY_STRING, NULL, fp->defs[i].data, fp->defs[i].dims.d[n],
                                     NPY_FARRAY, NULL);
                 }
                 else {
diff --git a/numpy/f2py/src/test/foomodule.c b/numpy/f2py/src/test/foomodule.c
index ed839b3d5..10f02f42b 100644
--- a/numpy/f2py/src/test/foomodule.c
+++ b/numpy/f2py/src/test/foomodule.c
@@ -63,10 +63,10 @@ static PyObject *mod_init(PyObject *capi_self, PyObject *capi_args,
 
 /* F90 module */
 static FortranDataDef f2py_mod_def[] = {
-    {"a",0, {}, PyArray_INT},
-    {"b",0, {}, PyArray_DOUBLE},
-    {"c",1, {3}, PyArray_DOUBLE},
-    {"d",1, {-1}, PyArray_DOUBLE},
+    {"a",0, {}, NPY_INT},
+    {"b",0, {}, NPY_DOUBLE},
+    {"c",1, {3}, NPY_DOUBLE},
+    {"d",1, {-1}, NPY_DOUBLE},
     {"init",-1,{},0,NULL,(void *)mod_init},
     {NULL}
 };
@@ -84,9 +84,9 @@ extern void F_FUNC(f2pyinitmod,F2PYINITMOD)();
 
 /* COMMON block */
 static FortranDataDef f2py_foodata_def[] = {
-    {"a",0, {}, PyArray_INT},
-    {"b",0, {}, PyArray_DOUBLE},
-    {"c",1, {3}, PyArray_DOUBLE},
+    {"a",0, {}, NPY_INT},
+    {"b",0, {}, NPY_DOUBLE},
+    {"c",1, {3}, NPY_DOUBLE},
     {NULL}
 };
 static void f2py_setup_foodata(char *a,char *b,char *c) {
diff --git a/numpy/f2py/tests/src/array_from_pyobj/wrapmodule.c b/numpy/f2py/tests/src/array_from_pyobj/wrapmodule.c
index 73aa40862..e75a667eb 100644
--- a/numpy/f2py/tests/src/array_from_pyobj/wrapmodule.c
+++ b/numpy/f2py/tests/src/array_from_pyobj/wrapmodule.c
@@ -163,32 +163,32 @@ PyMODINIT_FUNC inittest_array_from_pyobj_ext(void) {
   PyDict_SetItemString(d, "F2PY_INTENT_C", PyInt_FromLong(F2PY_INTENT_C));
   PyDict_SetItemString(d, "F2PY_OPTIONAL", PyInt_FromLong(F2PY_OPTIONAL));
   PyDict_SetItemString(d, "F2PY_INTENT_INPLACE", PyInt_FromLong(F2PY_INTENT_INPLACE));
-  PyDict_SetItemString(d, "PyArray_BOOL", PyInt_FromLong(PyArray_BOOL));
-  PyDict_SetItemString(d, "PyArray_BYTE", PyInt_FromLong(PyArray_BYTE));
-  PyDict_SetItemString(d, "PyArray_UBYTE", PyInt_FromLong(PyArray_UBYTE));
-  PyDict_SetItemString(d, "PyArray_SHORT", PyInt_FromLong(PyArray_SHORT));
-  PyDict_SetItemString(d, "PyArray_USHORT", PyInt_FromLong(PyArray_USHORT));
-  PyDict_SetItemString(d, "PyArray_INT", PyInt_FromLong(PyArray_INT));
-  PyDict_SetItemString(d, "PyArray_UINT", PyInt_FromLong(PyArray_UINT));
-  PyDict_SetItemString(d, "PyArray_INTP", PyInt_FromLong(PyArray_INTP));
-  PyDict_SetItemString(d, "PyArray_UINTP", PyInt_FromLong(PyArray_UINTP));
-  PyDict_SetItemString(d, "PyArray_LONG", PyInt_FromLong(PyArray_LONG));
-  PyDict_SetItemString(d, "PyArray_ULONG", PyInt_FromLong(PyArray_ULONG));
-  PyDict_SetItemString(d, "PyArray_LONGLONG", PyInt_FromLong(PyArray_LONGLONG));
-  PyDict_SetItemString(d, "PyArray_ULONGLONG", PyInt_FromLong(PyArray_ULONGLONG));
-  PyDict_SetItemString(d, "PyArray_FLOAT", PyInt_FromLong(PyArray_FLOAT));
-  PyDict_SetItemString(d, "PyArray_DOUBLE", PyInt_FromLong(PyArray_DOUBLE));
-  PyDict_SetItemString(d, "PyArray_LONGDOUBLE", PyInt_FromLong(PyArray_LONGDOUBLE));
-  PyDict_SetItemString(d, "PyArray_CFLOAT", PyInt_FromLong(PyArray_CFLOAT));
-  PyDict_SetItemString(d, "PyArray_CDOUBLE", PyInt_FromLong(PyArray_CDOUBLE));
-  PyDict_SetItemString(d, "PyArray_CLONGDOUBLE", PyInt_FromLong(PyArray_CLONGDOUBLE));
-  PyDict_SetItemString(d, "PyArray_OBJECT", PyInt_FromLong(PyArray_OBJECT));
-  PyDict_SetItemString(d, "PyArray_STRING", PyInt_FromLong(PyArray_STRING));
-  PyDict_SetItemString(d, "PyArray_UNICODE", PyInt_FromLong(PyArray_UNICODE));
-  PyDict_SetItemString(d, "PyArray_VOID", PyInt_FromLong(PyArray_VOID));
-  PyDict_SetItemString(d, "PyArray_NTYPES", PyInt_FromLong(PyArray_NTYPES));
-  PyDict_SetItemString(d, "PyArray_NOTYPE", PyInt_FromLong(PyArray_NOTYPE));
-  PyDict_SetItemString(d, "PyArray_UDERDEF", PyInt_FromLong(PyArray_USERDEF));
+  PyDict_SetItemString(d, "NPY_BOOL", PyInt_FromLong(NPY_BOOL));
+  PyDict_SetItemString(d, "NPY_BYTE", PyInt_FromLong(NPY_BYTE));
+  PyDict_SetItemString(d, "NPY_UBYTE", PyInt_FromLong(NPY_UBYTE));
+  PyDict_SetItemString(d, "NPY_SHORT", PyInt_FromLong(NPY_SHORT));
+  PyDict_SetItemString(d, "NPY_USHORT", PyInt_FromLong(NPY_USHORT));
+  PyDict_SetItemString(d, "NPY_INT", PyInt_FromLong(NPY_INT));
+  PyDict_SetItemString(d, "NPY_UINT", PyInt_FromLong(NPY_UINT));
+  PyDict_SetItemString(d, "NPY_INTP", PyInt_FromLong(NPY_INTP));
+  PyDict_SetItemString(d, "NPY_UINTP", PyInt_FromLong(NPY_UINTP));
+  PyDict_SetItemString(d, "NPY_LONG", PyInt_FromLong(NPY_LONG));
+  PyDict_SetItemString(d, "NPY_ULONG", PyInt_FromLong(NPY_ULONG));
+  PyDict_SetItemString(d, "NPY_LONGLONG", PyInt_FromLong(NPY_LONGLONG));
+  PyDict_SetItemString(d, "NPY_ULONGLONG", PyInt_FromLong(NPY_ULONGLONG));
+  PyDict_SetItemString(d, "NPY_FLOAT", PyInt_FromLong(NPY_FLOAT));
+  PyDict_SetItemString(d, "NPY_DOUBLE", PyInt_FromLong(NPY_DOUBLE));
+  PyDict_SetItemString(d, "NPY_LONGDOUBLE", PyInt_FromLong(NPY_LONGDOUBLE));
+  PyDict_SetItemString(d, "NPY_CFLOAT", PyInt_FromLong(NPY_CFLOAT));
+  PyDict_SetItemString(d, "NPY_CDOUBLE", PyInt_FromLong(NPY_CDOUBLE));
+  PyDict_SetItemString(d, "NPY_CLONGDOUBLE", PyInt_FromLong(NPY_CLONGDOUBLE));
+  PyDict_SetItemString(d, "NPY_OBJECT", PyInt_FromLong(NPY_OBJECT));
+  PyDict_SetItemString(d, "NPY_STRING", PyInt_FromLong(NPY_STRING));
+  PyDict_SetItemString(d, "NPY_UNICODE", PyInt_FromLong(NPY_UNICODE));
+  PyDict_SetItemString(d, "NPY_VOID", PyInt_FromLong(NPY_VOID));
+  PyDict_SetItemString(d, "NPY_NTYPES", PyInt_FromLong(NPY_NTYPES));
+  PyDict_SetItemString(d, "NPY_NOTYPE", PyInt_FromLong(NPY_NOTYPE));
+  PyDict_SetItemString(d, "NPY_USERDEF", PyInt_FromLong(NPY_USERDEF));
 
   PyDict_SetItemString(d, "CONTIGUOUS", PyInt_FromLong(NPY_CONTIGUOUS));
   PyDict_SetItemString(d, "FORTRAN", PyInt_FromLong(NPY_FORTRAN));
diff --git a/numpy/f2py/tests/test_array_from_pyobj.py b/numpy/f2py/tests/test_array_from_pyobj.py
index e760e8e4e..be85a308a 100644
--- a/numpy/f2py/tests/test_array_from_pyobj.py
+++ b/numpy/f2py/tests/test_array_from_pyobj.py
@@ -129,7 +129,7 @@ class Type(object):
 
     def _init(self,name):
         self.NAME = name.upper()
-        self.type_num = getattr(wrap,'PyArray_'+self.NAME)
+        self.type_num = getattr(wrap,'NPY_'+self.NAME)
         assert_equal(self.type_num,typeinfo[self.NAME][1])
         self.dtype = typeinfo[self.NAME][-1]
         self.elsize = typeinfo[self.NAME][2] / 8
diff --git a/numpy/fft/fftpack_litemodule.c b/numpy/fft/fftpack_litemodule.c
index 21343574d..6fc2e967c 100644
--- a/numpy/fft/fftpack_litemodule.c
+++ b/numpy/fft/fftpack_litemodule.c
@@ -22,11 +22,11 @@ fftpack_cfftf(PyObject *NPY_UNUSED(self), PyObject *args)
         return NULL;
     }
     data = (PyArrayObject *)PyArray_CopyFromObject(op1,
-            PyArray_CDOUBLE, 1, 0);
+            NPY_CDOUBLE, 1, 0);
     if (data == NULL) {
         return NULL;
     }
-    descr = PyArray_DescrFromType(PyArray_DOUBLE);
+    descr = PyArray_DescrFromType(NPY_DOUBLE);
     if (PyArray_AsCArray(&op2, (void *)&wsave, &nsave, 1, descr) == -1) {
         goto fail;
     }
@@ -73,11 +73,11 @@ fftpack_cfftb(PyObject *NPY_UNUSED(self), PyObject *args)
         return NULL;
     }
     data = (PyArrayObject *)PyArray_CopyFromObject(op1,
-            PyArray_CDOUBLE, 1, 0);
+            NPY_CDOUBLE, 1, 0);
     if (data == NULL) {
         return NULL;
     }
-    descr = PyArray_DescrFromType(PyArray_DOUBLE);
+    descr = PyArray_DescrFromType(NPY_DOUBLE);
     if (PyArray_AsCArray(&op2, (void *)&wsave, &nsave, 1, descr) == -1) {
         goto fail;
     }
@@ -123,7 +123,7 @@ fftpack_cffti(PyObject *NPY_UNUSED(self), PyObject *args)
     /*Magic size needed by cffti*/
     dim = 4*n + 15;
     /*Create a 1 dimensional array of dimensions of type double*/
-    op = (PyArrayObject *)PyArray_SimpleNew(1, &dim, PyArray_DOUBLE);
+    op = (PyArrayObject *)PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
     if (op == NULL) {
         return NULL;
     }
@@ -151,18 +151,18 @@ fftpack_rfftf(PyObject *NPY_UNUSED(self), PyObject *args)
         return NULL;
     }
     data = (PyArrayObject *)PyArray_ContiguousFromObject(op1,
-            PyArray_DOUBLE, 1, 0);
+            NPY_DOUBLE, 1, 0);
     if (data == NULL) {
         return NULL;
     }
     npts = data->dimensions[data->nd-1];
     data->dimensions[data->nd - 1] = npts/2 + 1;
     ret = (PyArrayObject *)PyArray_Zeros(data->nd, data->dimensions,
-            PyArray_DescrFromType(PyArray_CDOUBLE), 0);
+            PyArray_DescrFromType(NPY_CDOUBLE), 0);
     data->dimensions[data->nd - 1] = npts;
     rstep = (ret->dimensions[ret->nd - 1])*2;
 
-    descr = PyArray_DescrFromType(PyArray_DOUBLE);
+    descr = PyArray_DescrFromType(NPY_DOUBLE);
     if (PyArray_AsCArray(&op2, (void *)&wsave, &nsave, 1, descr) == -1) {
         goto fail;
     }
@@ -217,15 +217,15 @@ fftpack_rfftb(PyObject *NPY_UNUSED(self), PyObject *args)
         return NULL;
     }
     data = (PyArrayObject *)PyArray_ContiguousFromObject(op1,
-            PyArray_CDOUBLE, 1, 0);
+            NPY_CDOUBLE, 1, 0);
     if (data == NULL) {
         return NULL;
     }
     npts = data->dimensions[data->nd - 1];
     ret = (PyArrayObject *)PyArray_Zeros(data->nd, data->dimensions,
-            PyArray_DescrFromType(PyArray_DOUBLE), 0);
+            PyArray_DescrFromType(NPY_DOUBLE), 0);
 
-    descr = PyArray_DescrFromType(PyArray_DOUBLE);
+    descr = PyArray_DescrFromType(NPY_DOUBLE);
     if (PyArray_AsCArray(&op2, (void *)&wsave, &nsave, 1, descr) == -1) {
         goto fail;
     }
@@ -277,7 +277,7 @@ fftpack_rffti(PyObject *NPY_UNUSED(self), PyObject *args)
   /*Magic size needed by rffti*/
   dim = 2*n + 15;
   /*Create a 1 dimensional array of dimensions of type double*/
-  op = (PyArrayObject *)PyArray_SimpleNew(1, &dim, PyArray_DOUBLE);
+  op = (PyArrayObject *)PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
   if (op == NULL) {
       return NULL;
   }
diff --git a/numpy/lib/src/_compiled_base.c b/numpy/lib/src/_compiled_base.c
index e4513d512..536b048f5 100644
--- a/numpy/lib/src/_compiled_base.c
+++ b/numpy/lib/src/_compiled_base.c
@@ -754,7 +754,7 @@ arr_ravel_multi_index(PyObject *self, PyObject *args, PyObject *kwds)
     PyArrayObject *ret = NULL;
     PyArray_Dims dimensions={0,0};
     npy_intp ravel_strides[NPY_MAXDIMS];
-    PyArray_ORDER order = NPY_CORDER;
+    NPY_ORDER order = NPY_CORDER;
     NPY_CLIPMODE modes[NPY_MAXDIMS];
 
     PyArrayObject *op[NPY_MAXARGS];
@@ -962,7 +962,7 @@ arr_unravel_index(PyObject *self, PyObject *args, PyObject *kwds)
     PyArrayObject *indices = NULL;
     PyArray_Descr *dtype = NULL;
     PyArray_Dims dimensions={0,0};
-    PyArray_ORDER order = PyArray_CORDER;
+    NPY_ORDER order = NPY_CORDER;
     npy_intp unravel_size;
 
     NpyIter *iter = NULL;
diff --git a/numpy/linalg/lapack_litemodule.c b/numpy/linalg/lapack_litemodule.c
index 869e55595..e83d0f228 100644
--- a/numpy/linalg/lapack_litemodule.c
+++ b/numpy/linalg/lapack_litemodule.c
@@ -156,12 +156,12 @@ lapack_lite_dgeev(PyObject *NPY_UNUSED(self), PyObject *args)
                          &jobvl,&jobvr,&n,&a,&lda,&wr,&wi,&vl,&ldvl,
                          &vr,&ldvr,&work,&lwork,&info));
 
-    TRY(check_object(a,PyArray_DOUBLE,"a","PyArray_DOUBLE","dgeev"));
-    TRY(check_object(wr,PyArray_DOUBLE,"wr","PyArray_DOUBLE","dgeev"));
-    TRY(check_object(wi,PyArray_DOUBLE,"wi","PyArray_DOUBLE","dgeev"));
-    TRY(check_object(vl,PyArray_DOUBLE,"vl","PyArray_DOUBLE","dgeev"));
-    TRY(check_object(vr,PyArray_DOUBLE,"vr","PyArray_DOUBLE","dgeev"));
-    TRY(check_object(work,PyArray_DOUBLE,"work","PyArray_DOUBLE","dgeev"));
+    TRY(check_object(a,NPY_DOUBLE,"a","NPY_DOUBLE","dgeev"));
+    TRY(check_object(wr,NPY_DOUBLE,"wr","NPY_DOUBLE","dgeev"));
+    TRY(check_object(wi,NPY_DOUBLE,"wi","NPY_DOUBLE","dgeev"));
+    TRY(check_object(vl,NPY_DOUBLE,"vl","NPY_DOUBLE","dgeev"));
+    TRY(check_object(vr,NPY_DOUBLE,"vr","NPY_DOUBLE","dgeev"));
+    TRY(check_object(work,NPY_DOUBLE,"work","NPY_DOUBLE","dgeev"));
 
     lapack_lite_status__ = \
             FNAME(dgeev)(&jobvl,&jobvr,&n,DDATA(a),&lda,DDATA(wr),DDATA(wi),
@@ -242,10 +242,10 @@ lapack_lite_dsyevd(PyObject *NPY_UNUSED(self), PyObject *args)
                          &jobz,&uplo,&n,&a,&lda,&w,&work,&lwork,
                          &iwork,&liwork,&info));
 
-    TRY(check_object(a,PyArray_DOUBLE,"a","PyArray_DOUBLE","dsyevd"));
-    TRY(check_object(w,PyArray_DOUBLE,"w","PyArray_DOUBLE","dsyevd"));
-    TRY(check_object(work,PyArray_DOUBLE,"work","PyArray_DOUBLE","dsyevd"));
-    TRY(check_object(iwork,PyArray_INT,"iwork","PyArray_INT","dsyevd"));
+    TRY(check_object(a,NPY_DOUBLE,"a","NPY_DOUBLE","dsyevd"));
+    TRY(check_object(w,NPY_DOUBLE,"w","NPY_DOUBLE","dsyevd"));
+    TRY(check_object(work,NPY_DOUBLE,"work","NPY_DOUBLE","dsyevd"));
+    TRY(check_object(iwork,NPY_INT,"iwork","NPY_INT","dsyevd"));
 
     lapack_lite_status__ = \
             FNAME(dsyevd)(&jobz,&uplo,&n,DDATA(a),&lda,DDATA(w),DDATA(work),
@@ -328,11 +328,11 @@ lapack_lite_zheevd(PyObject *NPY_UNUSED(self), PyObject *args)
                          &jobz,&uplo,&n,&a,&lda,&w,&work,&lwork,&rwork,
                          &lrwork,&iwork,&liwork,&info));
 
-    TRY(check_object(a,PyArray_CDOUBLE,"a","PyArray_CDOUBLE","zheevd"));
-    TRY(check_object(w,PyArray_DOUBLE,"w","PyArray_DOUBLE","zheevd"));
-    TRY(check_object(work,PyArray_CDOUBLE,"work","PyArray_CDOUBLE","zheevd"));
-    TRY(check_object(w,PyArray_DOUBLE,"rwork","PyArray_DOUBLE","zheevd"));
-    TRY(check_object(iwork,PyArray_INT,"iwork","PyArray_INT","zheevd"));
+    TRY(check_object(a,NPY_CDOUBLE,"a","NPY_CDOUBLE","zheevd"));
+    TRY(check_object(w,NPY_DOUBLE,"w","NPY_DOUBLE","zheevd"));
+    TRY(check_object(work,NPY_CDOUBLE,"work","NPY_CDOUBLE","zheevd"));
+    TRY(check_object(w,NPY_DOUBLE,"rwork","NPY_DOUBLE","zheevd"));
+    TRY(check_object(iwork,NPY_INT,"iwork","NPY_INT","zheevd"));
 
     lapack_lite_status__ = \
     FNAME(zheevd)(&jobz,&uplo,&n,ZDATA(a),&lda,DDATA(w),ZDATA(work),
@@ -366,11 +366,11 @@ lapack_lite_dgelsd(PyObject *NPY_UNUSED(self), PyObject *args)
                          &m,&n,&nrhs,&a,&lda,&b,&ldb,&s,&rcond,
                          &rank,&work,&lwork,&iwork,&info));
 
-    TRY(check_object(a,PyArray_DOUBLE,"a","PyArray_DOUBLE","dgelsd"));
-    TRY(check_object(b,PyArray_DOUBLE,"b","PyArray_DOUBLE","dgelsd"));
-    TRY(check_object(s,PyArray_DOUBLE,"s","PyArray_DOUBLE","dgelsd"));
-    TRY(check_object(work,PyArray_DOUBLE,"work","PyArray_DOUBLE","dgelsd"));
-    TRY(check_object(iwork,PyArray_INT,"iwork","PyArray_INT","dgelsd"));
+    TRY(check_object(a,NPY_DOUBLE,"a","NPY_DOUBLE","dgelsd"));
+    TRY(check_object(b,NPY_DOUBLE,"b","NPY_DOUBLE","dgelsd"));
+    TRY(check_object(s,NPY_DOUBLE,"s","NPY_DOUBLE","dgelsd"));
+    TRY(check_object(work,NPY_DOUBLE,"work","NPY_DOUBLE","dgelsd"));
+    TRY(check_object(iwork,NPY_INT,"iwork","NPY_INT","dgelsd"));
 
     lapack_lite_status__ = \
             FNAME(dgelsd)(&m,&n,&nrhs,DDATA(a),&lda,DDATA(b),&ldb,
@@ -397,9 +397,9 @@ lapack_lite_dgesv(PyObject *NPY_UNUSED(self), PyObject *args)
     int info;
     TRY(PyArg_ParseTuple(args,"iiOiOOii",&n,&nrhs,&a,&lda,&ipiv,&b,&ldb,&info));
 
-    TRY(check_object(a,PyArray_DOUBLE,"a","PyArray_DOUBLE","dgesv"));
-    TRY(check_object(ipiv,PyArray_INT,"ipiv","PyArray_INT","dgesv"));
-    TRY(check_object(b,PyArray_DOUBLE,"b","PyArray_DOUBLE","dgesv"));
+    TRY(check_object(a,NPY_DOUBLE,"a","NPY_DOUBLE","dgesv"));
+    TRY(check_object(ipiv,NPY_INT,"ipiv","NPY_INT","dgesv"));
+    TRY(check_object(b,NPY_DOUBLE,"b","NPY_DOUBLE","dgesv"));
 
     lapack_lite_status__ = \
     FNAME(dgesv)(&n,&nrhs,DDATA(a),&lda,IDATA(ipiv),DDATA(b),&ldb,&info);
@@ -431,12 +431,12 @@ lapack_lite_dgesdd(PyObject *NPY_UNUSED(self), PyObject *args)
                          &jobz,&m,&n,&a,&lda,&s,&u,&ldu,&vt,&ldvt,
                          &work,&lwork,&iwork,&info));
 
-    TRY(check_object(a,PyArray_DOUBLE,"a","PyArray_DOUBLE","dgesdd"));
-    TRY(check_object(s,PyArray_DOUBLE,"s","PyArray_DOUBLE","dgesdd"));
-    TRY(check_object(u,PyArray_DOUBLE,"u","PyArray_DOUBLE","dgesdd"));
-    TRY(check_object(vt,PyArray_DOUBLE,"vt","PyArray_DOUBLE","dgesdd"));
-    TRY(check_object(work,PyArray_DOUBLE,"work","PyArray_DOUBLE","dgesdd"));
-    TRY(check_object(iwork,PyArray_INT,"iwork","PyArray_INT","dgesdd"));
+    TRY(check_object(a,NPY_DOUBLE,"a","NPY_DOUBLE","dgesdd"));
+    TRY(check_object(s,NPY_DOUBLE,"s","NPY_DOUBLE","dgesdd"));
+    TRY(check_object(u,NPY_DOUBLE,"u","NPY_DOUBLE","dgesdd"));
+    TRY(check_object(vt,NPY_DOUBLE,"vt","NPY_DOUBLE","dgesdd"));
+    TRY(check_object(work,NPY_DOUBLE,"work","NPY_DOUBLE","dgesdd"));
+    TRY(check_object(iwork,NPY_INT,"iwork","NPY_INT","dgesdd"));
 
     lapack_lite_status__ = \
             FNAME(dgesdd)(&jobz,&m,&n,DDATA(a),&lda,DDATA(s),DDATA(u),&ldu,
@@ -487,8 +487,8 @@ lapack_lite_dgetrf(PyObject *NPY_UNUSED(self), PyObject *args)
     int info;
     TRY(PyArg_ParseTuple(args,"iiOiOi",&m,&n,&a,&lda,&ipiv,&info));
 
-    TRY(check_object(a,PyArray_DOUBLE,"a","PyArray_DOUBLE","dgetrf"));
-    TRY(check_object(ipiv,PyArray_INT,"ipiv","PyArray_INT","dgetrf"));
+    TRY(check_object(a,NPY_DOUBLE,"a","NPY_DOUBLE","dgetrf"));
+    TRY(check_object(ipiv,NPY_INT,"ipiv","NPY_INT","dgetrf"));
 
     lapack_lite_status__ = \
             FNAME(dgetrf)(&m,&n,DDATA(a),&lda,IDATA(ipiv),&info);
@@ -508,7 +508,7 @@ lapack_lite_dpotrf(PyObject *NPY_UNUSED(self), PyObject *args)
     int info;
 
     TRY(PyArg_ParseTuple(args,"ciOii",&uplo,&n,&a,&lda,&info));
-    TRY(check_object(a,PyArray_DOUBLE,"a","PyArray_DOUBLE","dpotrf"));
+    TRY(check_object(a,NPY_DOUBLE,"a","NPY_DOUBLE","dpotrf"));
 
     lapack_lite_status__ = \
             FNAME(dpotrf)(&uplo,&n,DDATA(a),&lda,&info);
@@ -529,9 +529,9 @@ lapack_lite_dgeqrf(PyObject *NPY_UNUSED(self), PyObject *args)
         TRY(PyArg_ParseTuple(args,"iiOiOOii",&m,&n,&a,&lda,&tau,&work,&lwork,&info));
 
         /* check objects and convert to right storage order */
-        TRY(check_object(a,PyArray_DOUBLE,"a","PyArray_DOUBLE","dgeqrf"));
-        TRY(check_object(tau,PyArray_DOUBLE,"tau","PyArray_DOUBLE","dgeqrf"));
-        TRY(check_object(work,PyArray_DOUBLE,"work","PyArray_DOUBLE","dgeqrf"));
+        TRY(check_object(a,NPY_DOUBLE,"a","NPY_DOUBLE","dgeqrf"));
+        TRY(check_object(tau,NPY_DOUBLE,"tau","NPY_DOUBLE","dgeqrf"));
+        TRY(check_object(work,NPY_DOUBLE,"work","NPY_DOUBLE","dgeqrf"));
 
         lapack_lite_status__ = \
                 FNAME(dgeqrf)(&m, &n, DDATA(a), &lda, DDATA(tau),
@@ -553,9 +553,9 @@ lapack_lite_dorgqr(PyObject *NPY_UNUSED(self), PyObject *args)
         int info;
 
         TRY(PyArg_ParseTuple(args,"iiiOiOOii",  &m, &n, &k, &a, &lda, &tau, &work, &lwork, &info));
-        TRY(check_object(a,PyArray_DOUBLE,"a","PyArray_DOUBLE","dorgqr"));
-        TRY(check_object(tau,PyArray_DOUBLE,"tau","PyArray_DOUBLE","dorgqr"));
-        TRY(check_object(work,PyArray_DOUBLE,"work","PyArray_DOUBLE","dorgqr"));
+        TRY(check_object(a,NPY_DOUBLE,"a","NPY_DOUBLE","dorgqr"));
+        TRY(check_object(tau,NPY_DOUBLE,"tau","NPY_DOUBLE","dorgqr"));
+        TRY(check_object(work,NPY_DOUBLE,"work","NPY_DOUBLE","dorgqr"));
         lapack_lite_status__ = \
         FNAME(dorgqr)(&m, &n, &k, DDATA(a), &lda, DDATA(tau), DDATA(work), &lwork, &info);
 
@@ -586,12 +586,12 @@ lapack_lite_zgeev(PyObject *NPY_UNUSED(self), PyObject *args)
                          &jobvl,&jobvr,&n,&a,&lda,&w,&vl,&ldvl,
                          &vr,&ldvr,&work,&lwork,&rwork,&info));
 
-    TRY(check_object(a,PyArray_CDOUBLE,"a","PyArray_CDOUBLE","zgeev"));
-    TRY(check_object(w,PyArray_CDOUBLE,"w","PyArray_CDOUBLE","zgeev"));
-    TRY(check_object(vl,PyArray_CDOUBLE,"vl","PyArray_CDOUBLE","zgeev"));
-    TRY(check_object(vr,PyArray_CDOUBLE,"vr","PyArray_CDOUBLE","zgeev"));
-    TRY(check_object(work,PyArray_CDOUBLE,"work","PyArray_CDOUBLE","zgeev"));
-    TRY(check_object(rwork,PyArray_DOUBLE,"rwork","PyArray_DOUBLE","zgeev"));
+    TRY(check_object(a,NPY_CDOUBLE,"a","NPY_CDOUBLE","zgeev"));
+    TRY(check_object(w,NPY_CDOUBLE,"w","NPY_CDOUBLE","zgeev"));
+    TRY(check_object(vl,NPY_CDOUBLE,"vl","NPY_CDOUBLE","zgeev"));
+    TRY(check_object(vr,NPY_CDOUBLE,"vr","NPY_CDOUBLE","zgeev"));
+    TRY(check_object(work,NPY_CDOUBLE,"work","NPY_CDOUBLE","zgeev"));
+    TRY(check_object(rwork,NPY_DOUBLE,"rwork","NPY_DOUBLE","zgeev"));
 
     lapack_lite_status__ = \
             FNAME(zgeev)(&jobvl,&jobvr,&n,ZDATA(a),&lda,ZDATA(w),ZDATA(vl),
@@ -627,12 +627,12 @@ lapack_lite_zgelsd(PyObject *NPY_UNUSED(self), PyObject *args)
                          &m,&n,&nrhs,&a,&lda,&b,&ldb,&s,&rcond,
                          &rank,&work,&lwork,&rwork,&iwork,&info));
 
-    TRY(check_object(a,PyArray_CDOUBLE,"a","PyArray_CDOUBLE","zgelsd"));
-    TRY(check_object(b,PyArray_CDOUBLE,"b","PyArray_CDOUBLE","zgelsd"));
-    TRY(check_object(s,PyArray_DOUBLE,"s","PyArray_DOUBLE","zgelsd"));
-    TRY(check_object(work,PyArray_CDOUBLE,"work","PyArray_CDOUBLE","zgelsd"));
-    TRY(check_object(rwork,PyArray_DOUBLE,"rwork","PyArray_DOUBLE","zgelsd"));
-    TRY(check_object(iwork,PyArray_INT,"iwork","PyArray_INT","zgelsd"));
+    TRY(check_object(a,NPY_CDOUBLE,"a","NPY_CDOUBLE","zgelsd"));
+    TRY(check_object(b,NPY_CDOUBLE,"b","NPY_CDOUBLE","zgelsd"));
+    TRY(check_object(s,NPY_DOUBLE,"s","NPY_DOUBLE","zgelsd"));
+    TRY(check_object(work,NPY_CDOUBLE,"work","NPY_CDOUBLE","zgelsd"));
+    TRY(check_object(rwork,NPY_DOUBLE,"rwork","NPY_DOUBLE","zgelsd"));
+    TRY(check_object(iwork,NPY_INT,"iwork","NPY_INT","zgelsd"));
 
     lapack_lite_status__ = \
     FNAME(zgelsd)(&m,&n,&nrhs,ZDATA(a),&lda,ZDATA(b),&ldb,DDATA(s),&rcond,
@@ -657,9 +657,9 @@ lapack_lite_zgesv(PyObject *NPY_UNUSED(self), PyObject *args)
     int info;
     TRY(PyArg_ParseTuple(args,"iiOiOOii",&n,&nrhs,&a,&lda,&ipiv,&b,&ldb,&info));
 
-    TRY(check_object(a,PyArray_CDOUBLE,"a","PyArray_CDOUBLE","zgesv"));
-    TRY(check_object(ipiv,PyArray_INT,"ipiv","PyArray_INT","zgesv"));
-    TRY(check_object(b,PyArray_CDOUBLE,"b","PyArray_CDOUBLE","zgesv"));
+    TRY(check_object(a,NPY_CDOUBLE,"a","NPY_CDOUBLE","zgesv"));
+    TRY(check_object(ipiv,NPY_INT,"ipiv","NPY_INT","zgesv"));
+    TRY(check_object(b,NPY_CDOUBLE,"b","NPY_CDOUBLE","zgesv"));
 
     lapack_lite_status__ = \
     FNAME(zgesv)(&n,&nrhs,ZDATA(a),&lda,IDATA(ipiv),ZDATA(b),&ldb,&info);
@@ -692,13 +692,13 @@ lapack_lite_zgesdd(PyObject *NPY_UNUSED(self), PyObject *args)
                          &jobz,&m,&n,&a,&lda,&s,&u,&ldu,
                          &vt,&ldvt,&work,&lwork,&rwork,&iwork,&info));
 
-    TRY(check_object(a,PyArray_CDOUBLE,"a","PyArray_CDOUBLE","zgesdd"));
-    TRY(check_object(s,PyArray_DOUBLE,"s","PyArray_DOUBLE","zgesdd"));
-    TRY(check_object(u,PyArray_CDOUBLE,"u","PyArray_CDOUBLE","zgesdd"));
-    TRY(check_object(vt,PyArray_CDOUBLE,"vt","PyArray_CDOUBLE","zgesdd"));
-    TRY(check_object(work,PyArray_CDOUBLE,"work","PyArray_CDOUBLE","zgesdd"));
-    TRY(check_object(rwork,PyArray_DOUBLE,"rwork","PyArray_DOUBLE","zgesdd"));
-    TRY(check_object(iwork,PyArray_INT,"iwork","PyArray_INT","zgesdd"));
+    TRY(check_object(a,NPY_CDOUBLE,"a","NPY_CDOUBLE","zgesdd"));
+    TRY(check_object(s,NPY_DOUBLE,"s","NPY_DOUBLE","zgesdd"));
+    TRY(check_object(u,NPY_CDOUBLE,"u","NPY_CDOUBLE","zgesdd"));
+    TRY(check_object(vt,NPY_CDOUBLE,"vt","NPY_CDOUBLE","zgesdd"));
+    TRY(check_object(work,NPY_CDOUBLE,"work","NPY_CDOUBLE","zgesdd"));
+    TRY(check_object(rwork,NPY_DOUBLE,"rwork","NPY_DOUBLE","zgesdd"));
+    TRY(check_object(iwork,NPY_INT,"iwork","NPY_INT","zgesdd"));
 
     lapack_lite_status__ = \
     FNAME(zgesdd)(&jobz,&m,&n,ZDATA(a),&lda,DDATA(s),ZDATA(u),&ldu,
@@ -723,8 +723,8 @@ lapack_lite_zgetrf(PyObject *NPY_UNUSED(self), PyObject *args)
     int info;
     TRY(PyArg_ParseTuple(args,"iiOiOi",&m,&n,&a,&lda,&ipiv,&info));
 
-    TRY(check_object(a,PyArray_CDOUBLE,"a","PyArray_CDOUBLE","zgetrf"));
-    TRY(check_object(ipiv,PyArray_INT,"ipiv","PyArray_INT","zgetrf"));
+    TRY(check_object(a,NPY_CDOUBLE,"a","NPY_CDOUBLE","zgetrf"));
+    TRY(check_object(ipiv,NPY_INT,"ipiv","NPY_INT","zgetrf"));
 
     lapack_lite_status__ = \
     FNAME(zgetrf)(&m,&n,ZDATA(a),&lda,IDATA(ipiv),&info);
@@ -744,7 +744,7 @@ lapack_lite_zpotrf(PyObject *NPY_UNUSED(self), PyObject *args)
     int info;
 
     TRY(PyArg_ParseTuple(args,"ciOii",&uplo,&n,&a,&lda,&info));
-    TRY(check_object(a,PyArray_CDOUBLE,"a","PyArray_CDOUBLE","zpotrf"));
+    TRY(check_object(a,NPY_CDOUBLE,"a","NPY_CDOUBLE","zpotrf"));
     lapack_lite_status__ = \
     FNAME(zpotrf)(&uplo,&n,ZDATA(a),&lda,&info);
 
@@ -764,9 +764,9 @@ lapack_lite_zgeqrf(PyObject *NPY_UNUSED(self), PyObject *args)
         TRY(PyArg_ParseTuple(args,"iiOiOOii",&m,&n,&a,&lda,&tau,&work,&lwork,&info));
 
 /* check objects and convert to right storage order */
-        TRY(check_object(a,PyArray_CDOUBLE,"a","PyArray_CDOUBLE","zgeqrf"));
-        TRY(check_object(tau,PyArray_CDOUBLE,"tau","PyArray_CDOUBLE","zgeqrf"));
-        TRY(check_object(work,PyArray_CDOUBLE,"work","PyArray_CDOUBLE","zgeqrf"));
+        TRY(check_object(a,NPY_CDOUBLE,"a","NPY_CDOUBLE","zgeqrf"));
+        TRY(check_object(tau,NPY_CDOUBLE,"tau","NPY_CDOUBLE","zgeqrf"));
+        TRY(check_object(work,NPY_CDOUBLE,"work","NPY_CDOUBLE","zgeqrf"));
 
         lapack_lite_status__ = \
         FNAME(zgeqrf)(&m, &n, ZDATA(a), &lda, ZDATA(tau), ZDATA(work), &lwork, &info);
@@ -785,9 +785,9 @@ lapack_lite_zungqr(PyObject *NPY_UNUSED(self), PyObject *args)
         int info;
 
         TRY(PyArg_ParseTuple(args,"iiiOiOOii",  &m, &n, &k, &a, &lda, &tau, &work, &lwork, &info));
-        TRY(check_object(a,PyArray_CDOUBLE,"a","PyArray_CDOUBLE","zungqr"));
-        TRY(check_object(tau,PyArray_CDOUBLE,"tau","PyArray_CDOUBLE","zungqr"));
-        TRY(check_object(work,PyArray_CDOUBLE,"work","PyArray_CDOUBLE","zungqr"));
+        TRY(check_object(a,NPY_CDOUBLE,"a","NPY_CDOUBLE","zungqr"));
+        TRY(check_object(tau,NPY_CDOUBLE,"tau","NPY_CDOUBLE","zungqr"));
+        TRY(check_object(work,NPY_CDOUBLE,"work","NPY_CDOUBLE","zungqr"));
 
 
         lapack_lite_status__ = \
diff --git a/numpy/numarray/_capi.c b/numpy/numarray/_capi.c
index deb2cd478..7b866a8be 100644
--- a/numpy/numarray/_capi.c
+++ b/numpy/numarray/_capi.c
@@ -2828,7 +2828,7 @@ NA_NewAllFromBuffer(int ndim, maybelong *shape, NumarrayType type,
 
     if (byteorder != NA_ByteOrder()) {
         PyArray_Descr *temp;
-        temp = PyArray_DescrNewByteorder(dtype, PyArray_SWAP);
+        temp = PyArray_DescrNewByteorder(dtype, NPY_SWAP);
         Py_DECREF(dtype);
         if (temp == NULL) return NULL;
         dtype = temp;
@@ -2856,7 +2856,7 @@ NA_NewAllFromBuffer(int ndim, maybelong *shape, NumarrayType type,
         newdims.len = ndim;
         newdims.ptr = shape;
         newself = (PyArrayObject *)\
-                  PyArray_Newshape(self, &newdims, PyArray_CORDER);
+                  PyArray_Newshape(self, &newdims, NPY_CORDER);
         Py_DECREF(self);
         self = newself;
     }
diff --git a/numpy/numarray/include/numpy/arraybase.h b/numpy/numarray/include/numpy/arraybase.h
index 32f9948f4..02430b08a 100644
--- a/numpy/numarray/include/numpy/arraybase.h
+++ b/numpy/numarray/include/numpy/arraybase.h
@@ -20,22 +20,22 @@ typedef npy_float64 Float64;
 
 typedef enum
 {
-  tAny=-1,
-  tBool=PyArray_BOOL,
-  tInt8=PyArray_INT8,
-  tUInt8=PyArray_UINT8,
-  tInt16=PyArray_INT16,
-  tUInt16=PyArray_UINT16,
-  tInt32=PyArray_INT32,
-  tUInt32=PyArray_UINT32,
-  tInt64=PyArray_INT64,
-  tUInt64=PyArray_UINT64,
-  tFloat32=PyArray_FLOAT32,
-  tFloat64=PyArray_FLOAT64,
-  tComplex32=PyArray_COMPLEX64,
-  tComplex64=PyArray_COMPLEX128,
-  tObject=PyArray_OBJECT,        /* placeholder... does nothing */
-  tMaxType=PyArray_NTYPES,
+  tAny = -1,
+  tBool = NPY_BOOL,
+  tInt8 = NPY_INT8,
+  tUInt8 = NPY_UINT8,
+  tInt16 = NPY_INT16,
+  tUInt16 = NPY_UINT16,
+  tInt32 = NPY_INT32,
+  tUInt32 = NPY_UINT32,
+  tInt64 = NPY_INT64,
+  tUInt64 = NPY_UINT64,
+  tFloat32 = NPY_FLOAT32,
+  tFloat64 = NPY_FLOAT64,
+  tComplex32 = NPY_COMPLEX64,
+  tComplex64 = NPY_COMPLEX128,
+  tObject = NPY_OBJECT,        /* placeholder... does nothing */
+  tMaxType = NPY_NTYPES,
   tDefault = tFloat64,
 #if NPY_BITSOF_LONG == 64
   tLong = tInt64,