diff --git a/README.rst b/README.rst
index b16576b61f..02ddd2bfcf 100644
--- a/README.rst
+++ b/README.rst
@@ -46,17 +46,17 @@ Bottleneck is fast::
 
     >>> arr = np.random.rand(100, 100)    
     >>> timeit np.nanmax(arr)
-    10000 loops, best of 3: 93.9 us per loop
+    10000 loops, best of 3: 91.5 us per loop
     >>> timeit bn.nanmax(arr)
-    100000 loops, best of 3: 14.3 us per loop
+    100000 loops, best of 3: 13.3 us per loop
 
 Let's not forget to add some NaNs::
 
     >>> arr[arr > 0.5] = np.nan
     >>> timeit np.nanmax(arr)
-    10000 loops, best of 3: 139 us per loop
+    10000 loops, best of 3: 140 us per loop
     >>> timeit bn.nanmax(arr)
-    100000 loops, best of 3: 14.3 us per loop
+    100000 loops, best of 3: 13.2 us per loop
 
 Bottleneck comes with a benchmark suite. To run the benchmark::
     
@@ -71,21 +71,21 @@ Bottleneck comes with a benchmark suite. To run the benchmark::
 
                      no NaN   no NaN     no NaN     NaN      NaN        NaN
                     (10,10) (100,100) (1000,1000) (10,10) (100,100) (1000,1000)
-    median            6.59    13.83       7.22      5.83     3.50       2.83
-    nanmedian       160.86   135.68       8.27    163.28   179.70       8.05
-    nansum            7.51     5.85       1.71      7.56     6.74       1.70
-    nanmax            8.40     5.89       1.67      8.66     9.37       1.68
-    nanmean          16.02    13.48       2.98     16.77    27.22       4.97
-    nanstd           20.37     9.33       2.62     21.01    17.10       3.64
-    nanargmax         7.79     5.72       2.57      7.78     8.43       2.76
-    move_sum          7.82     7.86      14.41      7.82     8.20      13.95
-    move_nansum      18.89    18.73      29.44     18.31    23.83      29.83
-    move_mean         7.14     4.17      14.47      7.17     8.13      14.28
-    move_nanmean     22.34    11.56      29.87     22.77    14.09      30.91
-    move_std         12.26     3.31      22.94     14.45    19.95      29.92
-    move_nanstd      25.12     6.14      34.99     27.98     6.97      36.13
-    move_max          3.07     3.64       9.33      3.64     5.44      11.76
-    move_nanmax      16.04     6.28      19.38     16.72    14.56      27.44
+    median            9.71    13.75       7.24      8.23     3.67       2.82
+    nanmedian       238.04   128.73       8.11    247.20   174.31       8.02
+    nansum           13.40     6.50       1.70     13.34     7.43       1.69
+    nanmax           13.08     6.35       1.67     14.08    10.42       1.69
+    nanmean          23.88    13.87       2.97     24.78    28.81       4.95
+    nanstd           33.04     9.75       2.62     33.33    17.96       3.66
+    nanargmax        12.10     5.85       2.59     12.48     9.02       2.79
+    move_sum         11.95     8.27      14.53     11.73     8.63      14.11
+    move_nansum      31.44    20.06      29.41     30.16    25.53      29.80
+    move_mean        10.99     4.28      14.46     10.94     8.45      14.26
+    move_nanmean     32.77    11.76      29.87     33.38    14.43      30.80
+    move_std         17.28     3.33      22.95     21.63    20.66      29.86
+    move_nanstd      34.08     6.18      35.02     39.70     7.01      36.18
+    move_max          4.21     3.64       9.36      4.89     6.07      11.81
+    move_nanmax      22.19     6.28      19.66     24.07    14.71      27.19
 
     Reference functions:
     median          np.median
diff --git a/RELEASE.rst b/RELEASE.rst
index a06d62fe4d..7f7840def0 100644
--- a/RELEASE.rst
+++ b/RELEASE.rst
@@ -11,11 +11,12 @@ Bottleneck 0.3.0
 
 *Release date: Not yet released, in development*
 
-The third release of Bottleneck is faster and contains 10 new function.
+The third release of Bottleneck is twice as fast for small input arrays and
+contains 10 new functions.
 
 **Faster**
 
-- All functions are faster (less overhead in high-level functions) 
+- All functions are faster (less overhead in selector functions) 
 
 **New functions**
 
diff --git a/bottleneck/src/func/func_header.pyx b/bottleneck/src/func/func_header.pyx
index b1d13860c7..e270a28b22 100644
--- a/bottleneck/src/func/func_header.pyx
+++ b/bottleneck/src/func/func_header.pyx
@@ -5,7 +5,8 @@ from numpy cimport NPY_INT32 as NPY_int32
 from numpy cimport NPY_INT64 as NPY_int64
 from numpy cimport NPY_FLOAT32 as NPY_float32
 from numpy cimport NPY_FLOAT64 as NPY_float64
-from numpy cimport PyArray_EMPTY, import_array
+from numpy cimport (PyArray_EMPTY, PyArray_TYPE, PyArray_NDIM,
+                    PyArray_SIZE, import_array)
 import_array()
 import bottleneck as bn
 
@@ -28,8 +29,10 @@ float64 = np.dtype(np.float64)
 
 if np.int_ == np.int32:
     NPINT = 'int32'
+    NPY_int_ = NPY_int32
 elif np.int_ == np.int64:
     NPINT = 'int64'
+    NPY_int_ = NPY_int64
 else:
     raise RuntimeError('Expecting default NumPy int to be 32 or 64 bit.')
 
diff --git a/bottleneck/src/func/median.pyx b/bottleneck/src/func/median.pyx
index 30f7564f4f..7667041a9c 100644
--- a/bottleneck/src/func/median.pyx
+++ b/bottleneck/src/func/median.pyx
@@ -116,8 +116,8 @@ def median_selector(arr, axis):
     else:    
         a = np.array(arr, copy=False)
     cdef tuple key
-    cdef int ndim = a.ndim
-    cdef np.dtype dtype = a.dtype
+    cdef int ndim = PyArray_NDIM(a)
+    cdef int dtype = PyArray_TYPE(a)
     if axis is not None:
         if axis < 0:
             axis += ndim
@@ -134,7 +134,7 @@ def median_selector(arr, axis):
         try:
             func = median_slow_dict[axis]
         except KeyError:
-            tup = (str(ndim), str(dtype), str(axis))
+            tup = (str(ndim), str(a.dtype), str(axis))
             raise TypeError, "Unsupported ndim/dtype/axis (%s/%s/%s)." % tup
     return func, a
 
@@ -1175,30 +1175,30 @@ def median_3d_float64_axis2(np.ndarray[np.float64_t, ndim=3] a):
     return y
 
 cdef dict median_dict = {}
-median_dict[(1, int32, 0)] = median_1d_int32_axis0
-median_dict[(1, int64, 0)] = median_1d_int64_axis0
-median_dict[(2, int32, 0)] = median_2d_int32_axis0
-median_dict[(2, int32, 1)] = median_2d_int32_axis1
-median_dict[(2, int64, 0)] = median_2d_int64_axis0
-median_dict[(2, int64, 1)] = median_2d_int64_axis1
-median_dict[(3, int32, 0)] = median_3d_int32_axis0
-median_dict[(3, int32, 1)] = median_3d_int32_axis1
-median_dict[(3, int32, 2)] = median_3d_int32_axis2
-median_dict[(3, int64, 0)] = median_3d_int64_axis0
-median_dict[(3, int64, 1)] = median_3d_int64_axis1
-median_dict[(3, int64, 2)] = median_3d_int64_axis2
-median_dict[(1, float32, 0)] = median_1d_float32_axis0
-median_dict[(1, float64, 0)] = median_1d_float64_axis0
-median_dict[(2, float32, 0)] = median_2d_float32_axis0
-median_dict[(2, float32, 1)] = median_2d_float32_axis1
-median_dict[(2, float64, 0)] = median_2d_float64_axis0
-median_dict[(2, float64, 1)] = median_2d_float64_axis1
-median_dict[(3, float32, 0)] = median_3d_float32_axis0
-median_dict[(3, float32, 1)] = median_3d_float32_axis1
-median_dict[(3, float32, 2)] = median_3d_float32_axis2
-median_dict[(3, float64, 0)] = median_3d_float64_axis0
-median_dict[(3, float64, 1)] = median_3d_float64_axis1
-median_dict[(3, float64, 2)] = median_3d_float64_axis2
+median_dict[(1, NPY_int32, 0)] = median_1d_int32_axis0
+median_dict[(1, NPY_int64, 0)] = median_1d_int64_axis0
+median_dict[(2, NPY_int32, 0)] = median_2d_int32_axis0
+median_dict[(2, NPY_int32, 1)] = median_2d_int32_axis1
+median_dict[(2, NPY_int64, 0)] = median_2d_int64_axis0
+median_dict[(2, NPY_int64, 1)] = median_2d_int64_axis1
+median_dict[(3, NPY_int32, 0)] = median_3d_int32_axis0
+median_dict[(3, NPY_int32, 1)] = median_3d_int32_axis1
+median_dict[(3, NPY_int32, 2)] = median_3d_int32_axis2
+median_dict[(3, NPY_int64, 0)] = median_3d_int64_axis0
+median_dict[(3, NPY_int64, 1)] = median_3d_int64_axis1
+median_dict[(3, NPY_int64, 2)] = median_3d_int64_axis2
+median_dict[(1, NPY_float32, 0)] = median_1d_float32_axis0
+median_dict[(1, NPY_float64, 0)] = median_1d_float64_axis0
+median_dict[(2, NPY_float32, 0)] = median_2d_float32_axis0
+median_dict[(2, NPY_float32, 1)] = median_2d_float32_axis1
+median_dict[(2, NPY_float64, 0)] = median_2d_float64_axis0
+median_dict[(2, NPY_float64, 1)] = median_2d_float64_axis1
+median_dict[(3, NPY_float32, 0)] = median_3d_float32_axis0
+median_dict[(3, NPY_float32, 1)] = median_3d_float32_axis1
+median_dict[(3, NPY_float32, 2)] = median_3d_float32_axis2
+median_dict[(3, NPY_float64, 0)] = median_3d_float64_axis0
+median_dict[(3, NPY_float64, 1)] = median_3d_float64_axis1
+median_dict[(3, NPY_float64, 2)] = median_3d_float64_axis2
 
 cdef dict median_slow_dict = {}
 median_slow_dict[0] = median_slow_axis0
diff --git a/bottleneck/src/func/nanargmax.pyx b/bottleneck/src/func/nanargmax.pyx
index eb4635dae8..da7fcdf7bf 100644
--- a/bottleneck/src/func/nanargmax.pyx
+++ b/bottleneck/src/func/nanargmax.pyx
@@ -95,9 +95,9 @@ def nanargmax_selector(arr, axis):
         a = arr
     else:    
         a = np.array(arr, copy=False)
-    cdef int ndim = a.ndim
-    cdef np.dtype dtype = a.dtype
-    cdef int size = a.size
+    cdef int ndim = PyArray_NDIM(a)
+    cdef int dtype = PyArray_TYPE(a)
+    cdef int size = PyArray_SIZE(a)
     if size == 0:
         msg = "numpy.nanargmax() raises on size=0; so Bottleneck does too." 
         raise ValueError, msg
@@ -117,7 +117,7 @@ def nanargmax_selector(arr, axis):
         try:
             func = nanargmax_slow_dict[axis]
         except KeyError:
-            tup = (str(ndim), str(dtype), str(axis))
+            tup = (str(ndim), str(a.dtype), str(axis))
             raise TypeError, "Unsupported ndim/dtype/axis (%s/%s/%s)." % tup
     return func, a
 
@@ -732,30 +732,30 @@ def nanargmax_3d_float64_axis2(np.ndarray[np.float64_t, ndim=3] a):
     return y
 
 cdef dict nanargmax_dict = {}
-nanargmax_dict[(1, int32, 0)] = nanargmax_1d_int32_axis0
-nanargmax_dict[(1, int64, 0)] = nanargmax_1d_int64_axis0
-nanargmax_dict[(2, int32, 0)] = nanargmax_2d_int32_axis0
-nanargmax_dict[(2, int32, 1)] = nanargmax_2d_int32_axis1
-nanargmax_dict[(2, int64, 0)] = nanargmax_2d_int64_axis0
-nanargmax_dict[(2, int64, 1)] = nanargmax_2d_int64_axis1
-nanargmax_dict[(3, int32, 0)] = nanargmax_3d_int32_axis0
-nanargmax_dict[(3, int32, 1)] = nanargmax_3d_int32_axis1
-nanargmax_dict[(3, int32, 2)] = nanargmax_3d_int32_axis2
-nanargmax_dict[(3, int64, 0)] = nanargmax_3d_int64_axis0
-nanargmax_dict[(3, int64, 1)] = nanargmax_3d_int64_axis1
-nanargmax_dict[(3, int64, 2)] = nanargmax_3d_int64_axis2
-nanargmax_dict[(1, float32, 0)] = nanargmax_1d_float32_axis0
-nanargmax_dict[(1, float64, 0)] = nanargmax_1d_float64_axis0
-nanargmax_dict[(2, float32, 0)] = nanargmax_2d_float32_axis0
-nanargmax_dict[(2, float32, 1)] = nanargmax_2d_float32_axis1
-nanargmax_dict[(2, float64, 0)] = nanargmax_2d_float64_axis0
-nanargmax_dict[(2, float64, 1)] = nanargmax_2d_float64_axis1
-nanargmax_dict[(3, float32, 0)] = nanargmax_3d_float32_axis0
-nanargmax_dict[(3, float32, 1)] = nanargmax_3d_float32_axis1
-nanargmax_dict[(3, float32, 2)] = nanargmax_3d_float32_axis2
-nanargmax_dict[(3, float64, 0)] = nanargmax_3d_float64_axis0
-nanargmax_dict[(3, float64, 1)] = nanargmax_3d_float64_axis1
-nanargmax_dict[(3, float64, 2)] = nanargmax_3d_float64_axis2
+nanargmax_dict[(1, NPY_int32, 0)] = nanargmax_1d_int32_axis0
+nanargmax_dict[(1, NPY_int64, 0)] = nanargmax_1d_int64_axis0
+nanargmax_dict[(2, NPY_int32, 0)] = nanargmax_2d_int32_axis0
+nanargmax_dict[(2, NPY_int32, 1)] = nanargmax_2d_int32_axis1
+nanargmax_dict[(2, NPY_int64, 0)] = nanargmax_2d_int64_axis0
+nanargmax_dict[(2, NPY_int64, 1)] = nanargmax_2d_int64_axis1
+nanargmax_dict[(3, NPY_int32, 0)] = nanargmax_3d_int32_axis0
+nanargmax_dict[(3, NPY_int32, 1)] = nanargmax_3d_int32_axis1
+nanargmax_dict[(3, NPY_int32, 2)] = nanargmax_3d_int32_axis2
+nanargmax_dict[(3, NPY_int64, 0)] = nanargmax_3d_int64_axis0
+nanargmax_dict[(3, NPY_int64, 1)] = nanargmax_3d_int64_axis1
+nanargmax_dict[(3, NPY_int64, 2)] = nanargmax_3d_int64_axis2
+nanargmax_dict[(1, NPY_float32, 0)] = nanargmax_1d_float32_axis0
+nanargmax_dict[(1, NPY_float64, 0)] = nanargmax_1d_float64_axis0
+nanargmax_dict[(2, NPY_float32, 0)] = nanargmax_2d_float32_axis0
+nanargmax_dict[(2, NPY_float32, 1)] = nanargmax_2d_float32_axis1
+nanargmax_dict[(2, NPY_float64, 0)] = nanargmax_2d_float64_axis0
+nanargmax_dict[(2, NPY_float64, 1)] = nanargmax_2d_float64_axis1
+nanargmax_dict[(3, NPY_float32, 0)] = nanargmax_3d_float32_axis0
+nanargmax_dict[(3, NPY_float32, 1)] = nanargmax_3d_float32_axis1
+nanargmax_dict[(3, NPY_float32, 2)] = nanargmax_3d_float32_axis2
+nanargmax_dict[(3, NPY_float64, 0)] = nanargmax_3d_float64_axis0
+nanargmax_dict[(3, NPY_float64, 1)] = nanargmax_3d_float64_axis1
+nanargmax_dict[(3, NPY_float64, 2)] = nanargmax_3d_float64_axis2
 
 cdef dict nanargmax_slow_dict = {}
 nanargmax_slow_dict[0] = nanargmax_slow_axis0
diff --git a/bottleneck/src/func/nanargmin.pyx b/bottleneck/src/func/nanargmin.pyx
index ec589729c0..ca0d871d87 100644
--- a/bottleneck/src/func/nanargmin.pyx
+++ b/bottleneck/src/func/nanargmin.pyx
@@ -95,9 +95,9 @@ def nanargmin_selector(arr, axis):
         a = arr
     else:    
         a = np.array(arr, copy=False)
-    cdef int ndim = a.ndim
-    cdef np.dtype dtype = a.dtype
-    cdef int size = a.size
+    cdef int ndim = PyArray_NDIM(a)
+    cdef int dtype = PyArray_TYPE(a)
+    cdef int size = PyArray_SIZE(a)
     if size == 0:
         msg = "numpy.nanargmin() raises on size=0; so Bottleneck does too." 
         raise ValueError, msg
@@ -117,7 +117,7 @@ def nanargmin_selector(arr, axis):
         try:
             func = nanargmin_slow_dict[axis]
         except KeyError:
-            tup = (str(ndim), str(dtype), str(axis))
+            tup = (str(ndim), str(a.dtype), str(axis))
             raise TypeError, "Unsupported ndim/dtype/axis (%s/%s/%s)." % tup
     return func, a
 
@@ -732,30 +732,30 @@ def nanargmin_3d_float64_axis2(np.ndarray[np.float64_t, ndim=3] a):
     return y
 
 cdef dict nanargmin_dict = {}
-nanargmin_dict[(1, int32, 0)] = nanargmin_1d_int32_axis0
-nanargmin_dict[(1, int64, 0)] = nanargmin_1d_int64_axis0
-nanargmin_dict[(2, int32, 0)] = nanargmin_2d_int32_axis0
-nanargmin_dict[(2, int32, 1)] = nanargmin_2d_int32_axis1
-nanargmin_dict[(2, int64, 0)] = nanargmin_2d_int64_axis0
-nanargmin_dict[(2, int64, 1)] = nanargmin_2d_int64_axis1
-nanargmin_dict[(3, int32, 0)] = nanargmin_3d_int32_axis0
-nanargmin_dict[(3, int32, 1)] = nanargmin_3d_int32_axis1
-nanargmin_dict[(3, int32, 2)] = nanargmin_3d_int32_axis2
-nanargmin_dict[(3, int64, 0)] = nanargmin_3d_int64_axis0
-nanargmin_dict[(3, int64, 1)] = nanargmin_3d_int64_axis1
-nanargmin_dict[(3, int64, 2)] = nanargmin_3d_int64_axis2
-nanargmin_dict[(1, float32, 0)] = nanargmin_1d_float32_axis0
-nanargmin_dict[(1, float64, 0)] = nanargmin_1d_float64_axis0
-nanargmin_dict[(2, float32, 0)] = nanargmin_2d_float32_axis0
-nanargmin_dict[(2, float32, 1)] = nanargmin_2d_float32_axis1
-nanargmin_dict[(2, float64, 0)] = nanargmin_2d_float64_axis0
-nanargmin_dict[(2, float64, 1)] = nanargmin_2d_float64_axis1
-nanargmin_dict[(3, float32, 0)] = nanargmin_3d_float32_axis0
-nanargmin_dict[(3, float32, 1)] = nanargmin_3d_float32_axis1
-nanargmin_dict[(3, float32, 2)] = nanargmin_3d_float32_axis2
-nanargmin_dict[(3, float64, 0)] = nanargmin_3d_float64_axis0
-nanargmin_dict[(3, float64, 1)] = nanargmin_3d_float64_axis1
-nanargmin_dict[(3, float64, 2)] = nanargmin_3d_float64_axis2
+nanargmin_dict[(1, NPY_int32, 0)] = nanargmin_1d_int32_axis0
+nanargmin_dict[(1, NPY_int64, 0)] = nanargmin_1d_int64_axis0
+nanargmin_dict[(2, NPY_int32, 0)] = nanargmin_2d_int32_axis0
+nanargmin_dict[(2, NPY_int32, 1)] = nanargmin_2d_int32_axis1
+nanargmin_dict[(2, NPY_int64, 0)] = nanargmin_2d_int64_axis0
+nanargmin_dict[(2, NPY_int64, 1)] = nanargmin_2d_int64_axis1
+nanargmin_dict[(3, NPY_int32, 0)] = nanargmin_3d_int32_axis0
+nanargmin_dict[(3, NPY_int32, 1)] = nanargmin_3d_int32_axis1
+nanargmin_dict[(3, NPY_int32, 2)] = nanargmin_3d_int32_axis2
+nanargmin_dict[(3, NPY_int64, 0)] = nanargmin_3d_int64_axis0
+nanargmin_dict[(3, NPY_int64, 1)] = nanargmin_3d_int64_axis1
+nanargmin_dict[(3, NPY_int64, 2)] = nanargmin_3d_int64_axis2
+nanargmin_dict[(1, NPY_float32, 0)] = nanargmin_1d_float32_axis0
+nanargmin_dict[(1, NPY_float64, 0)] = nanargmin_1d_float64_axis0
+nanargmin_dict[(2, NPY_float32, 0)] = nanargmin_2d_float32_axis0
+nanargmin_dict[(2, NPY_float32, 1)] = nanargmin_2d_float32_axis1
+nanargmin_dict[(2, NPY_float64, 0)] = nanargmin_2d_float64_axis0
+nanargmin_dict[(2, NPY_float64, 1)] = nanargmin_2d_float64_axis1
+nanargmin_dict[(3, NPY_float32, 0)] = nanargmin_3d_float32_axis0
+nanargmin_dict[(3, NPY_float32, 1)] = nanargmin_3d_float32_axis1
+nanargmin_dict[(3, NPY_float32, 2)] = nanargmin_3d_float32_axis2
+nanargmin_dict[(3, NPY_float64, 0)] = nanargmin_3d_float64_axis0
+nanargmin_dict[(3, NPY_float64, 1)] = nanargmin_3d_float64_axis1
+nanargmin_dict[(3, NPY_float64, 2)] = nanargmin_3d_float64_axis2
 
 cdef dict nanargmin_slow_dict = {}
 nanargmin_slow_dict[0] = nanargmin_slow_axis0
diff --git a/bottleneck/src/func/nanmax.pyx b/bottleneck/src/func/nanmax.pyx
index ef865bb8ba..2a938cfedb 100644
--- a/bottleneck/src/func/nanmax.pyx
+++ b/bottleneck/src/func/nanmax.pyx
@@ -96,9 +96,9 @@ def nanmax_selector(arr, axis):
         a = arr
     else:    
         a = np.array(arr, copy=False)
-    cdef int ndim = a.ndim
-    cdef np.dtype dtype = a.dtype
-    cdef int size = a.size
+    cdef int ndim = PyArray_NDIM(a)
+    cdef int dtype = PyArray_TYPE(a)
+    cdef int size = PyArray_SIZE(a)
     if size == 0:
         msg = "numpy.nanmax() raises on size=0 input; so Bottleneck does too." 
         raise ValueError, msg
@@ -114,7 +114,7 @@ def nanmax_selector(arr, axis):
         try:
             func = nanmax_slow_dict[axis]
         except KeyError:
-            tup = (str(ndim), str(dtype), str(axis))
+            tup = (str(ndim), str(a.dtype), str(axis))
             raise TypeError, "Unsupported ndim/dtype/axis (%s/%s/%s)." % tup
     return func, a
 
@@ -841,42 +841,42 @@ def nanmax_3d_int64_axisNone(np.ndarray[np.int64_t, ndim=3] a):
     return np.int64(amax)
 
 cdef dict nanmax_dict = {}
-nanmax_dict[(2, int32, 0)] = nanmax_2d_int32_axis0
-nanmax_dict[(2, int32, 1)] = nanmax_2d_int32_axis1
-nanmax_dict[(2, int64, 0)] = nanmax_2d_int64_axis0
-nanmax_dict[(2, int64, 1)] = nanmax_2d_int64_axis1
-nanmax_dict[(3, int32, 0)] = nanmax_3d_int32_axis0
-nanmax_dict[(3, int32, 1)] = nanmax_3d_int32_axis1
-nanmax_dict[(3, int32, 2)] = nanmax_3d_int32_axis2
-nanmax_dict[(3, int64, 0)] = nanmax_3d_int64_axis0
-nanmax_dict[(3, int64, 1)] = nanmax_3d_int64_axis1
-nanmax_dict[(3, int64, 2)] = nanmax_3d_int64_axis2
-nanmax_dict[(1, float32, 0)] = nanmax_1d_float32_axisNone
-nanmax_dict[(1, float32, None)] = nanmax_1d_float32_axisNone
-nanmax_dict[(1, float64, 0)] = nanmax_1d_float64_axisNone
-nanmax_dict[(1, float64, None)] = nanmax_1d_float64_axisNone
-nanmax_dict[(2, float32, None)] = nanmax_2d_float32_axisNone
-nanmax_dict[(2, float64, None)] = nanmax_2d_float64_axisNone
-nanmax_dict[(3, float32, None)] = nanmax_3d_float32_axisNone
-nanmax_dict[(3, float64, None)] = nanmax_3d_float64_axisNone
-nanmax_dict[(2, float32, 0)] = nanmax_2d_float32_axis0
-nanmax_dict[(2, float32, 1)] = nanmax_2d_float32_axis1
-nanmax_dict[(2, float64, 0)] = nanmax_2d_float64_axis0
-nanmax_dict[(2, float64, 1)] = nanmax_2d_float64_axis1
-nanmax_dict[(3, float32, 0)] = nanmax_3d_float32_axis0
-nanmax_dict[(3, float32, 1)] = nanmax_3d_float32_axis1
-nanmax_dict[(3, float32, 2)] = nanmax_3d_float32_axis2
-nanmax_dict[(3, float64, 0)] = nanmax_3d_float64_axis0
-nanmax_dict[(3, float64, 1)] = nanmax_3d_float64_axis1
-nanmax_dict[(3, float64, 2)] = nanmax_3d_float64_axis2
-nanmax_dict[(1, int32, 0)] = nanmax_1d_int32_axisNone
-nanmax_dict[(1, int32, None)] = nanmax_1d_int32_axisNone
-nanmax_dict[(1, int64, 0)] = nanmax_1d_int64_axisNone
-nanmax_dict[(1, int64, None)] = nanmax_1d_int64_axisNone
-nanmax_dict[(2, int32, None)] = nanmax_2d_int32_axisNone
-nanmax_dict[(2, int64, None)] = nanmax_2d_int64_axisNone
-nanmax_dict[(3, int32, None)] = nanmax_3d_int32_axisNone
-nanmax_dict[(3, int64, None)] = nanmax_3d_int64_axisNone
+nanmax_dict[(2, NPY_int32, 0)] = nanmax_2d_int32_axis0
+nanmax_dict[(2, NPY_int32, 1)] = nanmax_2d_int32_axis1
+nanmax_dict[(2, NPY_int64, 0)] = nanmax_2d_int64_axis0
+nanmax_dict[(2, NPY_int64, 1)] = nanmax_2d_int64_axis1
+nanmax_dict[(3, NPY_int32, 0)] = nanmax_3d_int32_axis0
+nanmax_dict[(3, NPY_int32, 1)] = nanmax_3d_int32_axis1
+nanmax_dict[(3, NPY_int32, 2)] = nanmax_3d_int32_axis2
+nanmax_dict[(3, NPY_int64, 0)] = nanmax_3d_int64_axis0
+nanmax_dict[(3, NPY_int64, 1)] = nanmax_3d_int64_axis1
+nanmax_dict[(3, NPY_int64, 2)] = nanmax_3d_int64_axis2
+nanmax_dict[(1, NPY_float32, 0)] = nanmax_1d_float32_axisNone
+nanmax_dict[(1, NPY_float32, None)] = nanmax_1d_float32_axisNone
+nanmax_dict[(1, NPY_float64, 0)] = nanmax_1d_float64_axisNone
+nanmax_dict[(1, NPY_float64, None)] = nanmax_1d_float64_axisNone
+nanmax_dict[(2, NPY_float32, None)] = nanmax_2d_float32_axisNone
+nanmax_dict[(2, NPY_float64, None)] = nanmax_2d_float64_axisNone
+nanmax_dict[(3, NPY_float32, None)] = nanmax_3d_float32_axisNone
+nanmax_dict[(3, NPY_float64, None)] = nanmax_3d_float64_axisNone
+nanmax_dict[(2, NPY_float32, 0)] = nanmax_2d_float32_axis0
+nanmax_dict[(2, NPY_float32, 1)] = nanmax_2d_float32_axis1
+nanmax_dict[(2, NPY_float64, 0)] = nanmax_2d_float64_axis0
+nanmax_dict[(2, NPY_float64, 1)] = nanmax_2d_float64_axis1
+nanmax_dict[(3, NPY_float32, 0)] = nanmax_3d_float32_axis0
+nanmax_dict[(3, NPY_float32, 1)] = nanmax_3d_float32_axis1
+nanmax_dict[(3, NPY_float32, 2)] = nanmax_3d_float32_axis2
+nanmax_dict[(3, NPY_float64, 0)] = nanmax_3d_float64_axis0
+nanmax_dict[(3, NPY_float64, 1)] = nanmax_3d_float64_axis1
+nanmax_dict[(3, NPY_float64, 2)] = nanmax_3d_float64_axis2
+nanmax_dict[(1, NPY_int32, 0)] = nanmax_1d_int32_axisNone
+nanmax_dict[(1, NPY_int32, None)] = nanmax_1d_int32_axisNone
+nanmax_dict[(1, NPY_int64, 0)] = nanmax_1d_int64_axisNone
+nanmax_dict[(1, NPY_int64, None)] = nanmax_1d_int64_axisNone
+nanmax_dict[(2, NPY_int32, None)] = nanmax_2d_int32_axisNone
+nanmax_dict[(2, NPY_int64, None)] = nanmax_2d_int64_axisNone
+nanmax_dict[(3, NPY_int32, None)] = nanmax_3d_int32_axisNone
+nanmax_dict[(3, NPY_int64, None)] = nanmax_3d_int64_axisNone
 
 cdef dict nanmax_slow_dict = {}
 nanmax_slow_dict[0] = nanmax_slow_axis0
diff --git a/bottleneck/src/func/nanmean.pyx b/bottleneck/src/func/nanmean.pyx
index 200ba28b09..1f64215372 100644
--- a/bottleneck/src/func/nanmean.pyx
+++ b/bottleneck/src/func/nanmean.pyx
@@ -115,8 +115,8 @@ def nanmean_selector(arr, axis):
         a = arr
     else:    
         a = np.array(arr, copy=False)
-    cdef int ndim = a.ndim
-    cdef np.dtype dtype = a.dtype
+    cdef int ndim = PyArray_NDIM(a)
+    cdef int dtype = PyArray_TYPE(a)
     if (axis < 0) and (axis is not None):
         axis += ndim
     cdef tuple key = (ndim, dtype, axis)
@@ -129,7 +129,7 @@ def nanmean_selector(arr, axis):
         try:
             func = nanmean_slow_dict[axis]
         except KeyError:
-            tup = (str(ndim), str(dtype), str(axis))
+            tup = (str(ndim), str(a.dtype), str(axis))
             raise TypeError, "Unsupported ndim/dtype/axis (%s/%s/%s)." % tup
     return func, a
 
@@ -808,42 +808,42 @@ def nanmean_3d_int64_axisNone(np.ndarray[np.int64_t, ndim=3] a):
     return np.float64(asum / size)
 
 cdef dict nanmean_dict = {}
-nanmean_dict[(2, int32, 0)] = nanmean_2d_int32_axis0
-nanmean_dict[(2, int32, 1)] = nanmean_2d_int32_axis1
-nanmean_dict[(2, int64, 0)] = nanmean_2d_int64_axis0
-nanmean_dict[(2, int64, 1)] = nanmean_2d_int64_axis1
-nanmean_dict[(3, int32, 0)] = nanmean_3d_int32_axis0
-nanmean_dict[(3, int32, 1)] = nanmean_3d_int32_axis1
-nanmean_dict[(3, int32, 2)] = nanmean_3d_int32_axis2
-nanmean_dict[(3, int64, 0)] = nanmean_3d_int64_axis0
-nanmean_dict[(3, int64, 1)] = nanmean_3d_int64_axis1
-nanmean_dict[(3, int64, 2)] = nanmean_3d_int64_axis2
-nanmean_dict[(1, float32, 0)] = nanmean_1d_float32_axisNone
-nanmean_dict[(1, float32, None)] = nanmean_1d_float32_axisNone
-nanmean_dict[(1, float64, 0)] = nanmean_1d_float64_axisNone
-nanmean_dict[(1, float64, None)] = nanmean_1d_float64_axisNone
-nanmean_dict[(2, float32, None)] = nanmean_2d_float32_axisNone
-nanmean_dict[(2, float64, None)] = nanmean_2d_float64_axisNone
-nanmean_dict[(3, float32, None)] = nanmean_3d_float32_axisNone
-nanmean_dict[(3, float64, None)] = nanmean_3d_float64_axisNone
-nanmean_dict[(2, float32, 0)] = nanmean_2d_float32_axis0
-nanmean_dict[(2, float32, 1)] = nanmean_2d_float32_axis1
-nanmean_dict[(2, float64, 0)] = nanmean_2d_float64_axis0
-nanmean_dict[(2, float64, 1)] = nanmean_2d_float64_axis1
-nanmean_dict[(3, float32, 0)] = nanmean_3d_float32_axis0
-nanmean_dict[(3, float32, 1)] = nanmean_3d_float32_axis1
-nanmean_dict[(3, float32, 2)] = nanmean_3d_float32_axis2
-nanmean_dict[(3, float64, 0)] = nanmean_3d_float64_axis0
-nanmean_dict[(3, float64, 1)] = nanmean_3d_float64_axis1
-nanmean_dict[(3, float64, 2)] = nanmean_3d_float64_axis2
-nanmean_dict[(1, int32, 0)] = nanmean_1d_int32_axisNone
-nanmean_dict[(1, int32, None)] = nanmean_1d_int32_axisNone
-nanmean_dict[(1, int64, 0)] = nanmean_1d_int64_axisNone
-nanmean_dict[(1, int64, None)] = nanmean_1d_int64_axisNone
-nanmean_dict[(2, int32, None)] = nanmean_2d_int32_axisNone
-nanmean_dict[(2, int64, None)] = nanmean_2d_int64_axisNone
-nanmean_dict[(3, int32, None)] = nanmean_3d_int32_axisNone
-nanmean_dict[(3, int64, None)] = nanmean_3d_int64_axisNone
+nanmean_dict[(2, NPY_int32, 0)] = nanmean_2d_int32_axis0
+nanmean_dict[(2, NPY_int32, 1)] = nanmean_2d_int32_axis1
+nanmean_dict[(2, NPY_int64, 0)] = nanmean_2d_int64_axis0
+nanmean_dict[(2, NPY_int64, 1)] = nanmean_2d_int64_axis1
+nanmean_dict[(3, NPY_int32, 0)] = nanmean_3d_int32_axis0
+nanmean_dict[(3, NPY_int32, 1)] = nanmean_3d_int32_axis1
+nanmean_dict[(3, NPY_int32, 2)] = nanmean_3d_int32_axis2
+nanmean_dict[(3, NPY_int64, 0)] = nanmean_3d_int64_axis0
+nanmean_dict[(3, NPY_int64, 1)] = nanmean_3d_int64_axis1
+nanmean_dict[(3, NPY_int64, 2)] = nanmean_3d_int64_axis2
+nanmean_dict[(1, NPY_float32, 0)] = nanmean_1d_float32_axisNone
+nanmean_dict[(1, NPY_float32, None)] = nanmean_1d_float32_axisNone
+nanmean_dict[(1, NPY_float64, 0)] = nanmean_1d_float64_axisNone
+nanmean_dict[(1, NPY_float64, None)] = nanmean_1d_float64_axisNone
+nanmean_dict[(2, NPY_float32, None)] = nanmean_2d_float32_axisNone
+nanmean_dict[(2, NPY_float64, None)] = nanmean_2d_float64_axisNone
+nanmean_dict[(3, NPY_float32, None)] = nanmean_3d_float32_axisNone
+nanmean_dict[(3, NPY_float64, None)] = nanmean_3d_float64_axisNone
+nanmean_dict[(2, NPY_float32, 0)] = nanmean_2d_float32_axis0
+nanmean_dict[(2, NPY_float32, 1)] = nanmean_2d_float32_axis1
+nanmean_dict[(2, NPY_float64, 0)] = nanmean_2d_float64_axis0
+nanmean_dict[(2, NPY_float64, 1)] = nanmean_2d_float64_axis1
+nanmean_dict[(3, NPY_float32, 0)] = nanmean_3d_float32_axis0
+nanmean_dict[(3, NPY_float32, 1)] = nanmean_3d_float32_axis1
+nanmean_dict[(3, NPY_float32, 2)] = nanmean_3d_float32_axis2
+nanmean_dict[(3, NPY_float64, 0)] = nanmean_3d_float64_axis0
+nanmean_dict[(3, NPY_float64, 1)] = nanmean_3d_float64_axis1
+nanmean_dict[(3, NPY_float64, 2)] = nanmean_3d_float64_axis2
+nanmean_dict[(1, NPY_int32, 0)] = nanmean_1d_int32_axisNone
+nanmean_dict[(1, NPY_int32, None)] = nanmean_1d_int32_axisNone
+nanmean_dict[(1, NPY_int64, 0)] = nanmean_1d_int64_axisNone
+nanmean_dict[(1, NPY_int64, None)] = nanmean_1d_int64_axisNone
+nanmean_dict[(2, NPY_int32, None)] = nanmean_2d_int32_axisNone
+nanmean_dict[(2, NPY_int64, None)] = nanmean_2d_int64_axisNone
+nanmean_dict[(3, NPY_int32, None)] = nanmean_3d_int32_axisNone
+nanmean_dict[(3, NPY_int64, None)] = nanmean_3d_int64_axisNone
 
 cdef dict nanmean_slow_dict = {}
 nanmean_slow_dict[0] = nanmean_slow_axis0
diff --git a/bottleneck/src/func/nanmedian.pyx b/bottleneck/src/func/nanmedian.pyx
index 6c82de2afe..42942b11ed 100644
--- a/bottleneck/src/func/nanmedian.pyx
+++ b/bottleneck/src/func/nanmedian.pyx
@@ -111,8 +111,8 @@ def nanmedian_selector(arr, axis):
     else:    
         a = np.array(arr, copy=False)
     cdef tuple key
-    cdef int ndim = a.ndim
-    cdef np.dtype dtype = a.dtype
+    cdef int ndim = PyArray_NDIM(a)
+    cdef int dtype = PyArray_TYPE(a)
     if axis is not None:
         if axis < 0:
             axis += ndim
@@ -129,7 +129,7 @@ def nanmedian_selector(arr, axis):
         try:
             func = nanmedian_slow_dict[axis]
         except KeyError:
-            tup = (str(ndim), str(dtype), str(axis))
+            tup = (str(ndim), str(a.dtype), str(axis))
             raise TypeError, "Unsupported ndim/dtype/axis (%s/%s/%s)." % tup
     return func, a
 
@@ -916,30 +916,30 @@ def nanmedian_3d_float64_axis2(np.ndarray[np.float64_t, ndim=3] a):
     return y
 
 cdef dict nanmedian_dict = {}
-nanmedian_dict[(1, int32, 0)] = median_1d_int32_axis0
-nanmedian_dict[(1, int64, 0)] = median_1d_int64_axis0
-nanmedian_dict[(2, int32, 0)] = median_2d_int32_axis0
-nanmedian_dict[(2, int32, 1)] = median_2d_int32_axis1
-nanmedian_dict[(2, int64, 0)] = median_2d_int64_axis0
-nanmedian_dict[(2, int64, 1)] = median_2d_int64_axis1
-nanmedian_dict[(3, int32, 0)] = median_3d_int32_axis0
-nanmedian_dict[(3, int32, 1)] = median_3d_int32_axis1
-nanmedian_dict[(3, int32, 2)] = median_3d_int32_axis2
-nanmedian_dict[(3, int64, 0)] = median_3d_int64_axis0
-nanmedian_dict[(3, int64, 1)] = median_3d_int64_axis1
-nanmedian_dict[(3, int64, 2)] = median_3d_int64_axis2
-nanmedian_dict[(1, float32, 0)] = nanmedian_1d_float32_axis0
-nanmedian_dict[(1, float64, 0)] = nanmedian_1d_float64_axis0
-nanmedian_dict[(2, float32, 0)] = nanmedian_2d_float32_axis0
-nanmedian_dict[(2, float32, 1)] = nanmedian_2d_float32_axis1
-nanmedian_dict[(2, float64, 0)] = nanmedian_2d_float64_axis0
-nanmedian_dict[(2, float64, 1)] = nanmedian_2d_float64_axis1
-nanmedian_dict[(3, float32, 0)] = nanmedian_3d_float32_axis0
-nanmedian_dict[(3, float32, 1)] = nanmedian_3d_float32_axis1
-nanmedian_dict[(3, float32, 2)] = nanmedian_3d_float32_axis2
-nanmedian_dict[(3, float64, 0)] = nanmedian_3d_float64_axis0
-nanmedian_dict[(3, float64, 1)] = nanmedian_3d_float64_axis1
-nanmedian_dict[(3, float64, 2)] = nanmedian_3d_float64_axis2
+nanmedian_dict[(1, NPY_int32, 0)] = median_1d_int32_axis0
+nanmedian_dict[(1, NPY_int64, 0)] = median_1d_int64_axis0
+nanmedian_dict[(2, NPY_int32, 0)] = median_2d_int32_axis0
+nanmedian_dict[(2, NPY_int32, 1)] = median_2d_int32_axis1
+nanmedian_dict[(2, NPY_int64, 0)] = median_2d_int64_axis0
+nanmedian_dict[(2, NPY_int64, 1)] = median_2d_int64_axis1
+nanmedian_dict[(3, NPY_int32, 0)] = median_3d_int32_axis0
+nanmedian_dict[(3, NPY_int32, 1)] = median_3d_int32_axis1
+nanmedian_dict[(3, NPY_int32, 2)] = median_3d_int32_axis2
+nanmedian_dict[(3, NPY_int64, 0)] = median_3d_int64_axis0
+nanmedian_dict[(3, NPY_int64, 1)] = median_3d_int64_axis1
+nanmedian_dict[(3, NPY_int64, 2)] = median_3d_int64_axis2
+nanmedian_dict[(1, NPY_float32, 0)] = nanmedian_1d_float32_axis0
+nanmedian_dict[(1, NPY_float64, 0)] = nanmedian_1d_float64_axis0
+nanmedian_dict[(2, NPY_float32, 0)] = nanmedian_2d_float32_axis0
+nanmedian_dict[(2, NPY_float32, 1)] = nanmedian_2d_float32_axis1
+nanmedian_dict[(2, NPY_float64, 0)] = nanmedian_2d_float64_axis0
+nanmedian_dict[(2, NPY_float64, 1)] = nanmedian_2d_float64_axis1
+nanmedian_dict[(3, NPY_float32, 0)] = nanmedian_3d_float32_axis0
+nanmedian_dict[(3, NPY_float32, 1)] = nanmedian_3d_float32_axis1
+nanmedian_dict[(3, NPY_float32, 2)] = nanmedian_3d_float32_axis2
+nanmedian_dict[(3, NPY_float64, 0)] = nanmedian_3d_float64_axis0
+nanmedian_dict[(3, NPY_float64, 1)] = nanmedian_3d_float64_axis1
+nanmedian_dict[(3, NPY_float64, 2)] = nanmedian_3d_float64_axis2
 
 cdef dict nanmedian_slow_dict = {}
 nanmedian_slow_dict[0] = nanmedian_slow_axis0
diff --git a/bottleneck/src/func/nanmin.pyx b/bottleneck/src/func/nanmin.pyx
index 28952cb9ad..74d03a03b6 100644
--- a/bottleneck/src/func/nanmin.pyx
+++ b/bottleneck/src/func/nanmin.pyx
@@ -96,9 +96,9 @@ def nanmin_selector(arr, axis):
         a = arr
     else:    
         a = np.array(arr, copy=False)
-    cdef int ndim = a.ndim
-    cdef np.dtype dtype = a.dtype
-    cdef int size = a.size
+    cdef int ndim = PyArray_NDIM(a)
+    cdef int dtype = PyArray_TYPE(a)
+    cdef int size = PyArray_SIZE(a)
     if size == 0:
         msg = "numpy.nanmin() raises on size=0 input; so Bottleneck does too." 
         raise ValueError, msg
@@ -114,7 +114,7 @@ def nanmin_selector(arr, axis):
         try:
             func = nanmin_slow_dict[axis]
         except KeyError:
-            tup = (str(ndim), str(dtype), str(axis))
+            tup = (str(ndim), str(a.dtype), str(axis))
             raise TypeError, "Unsupported ndim/dtype/axis (%s/%s/%s)." % tup
     return func, a
 
@@ -841,42 +841,42 @@ def nanmin_3d_int64_axisNone(np.ndarray[np.int64_t, ndim=3] a):
     return np.int64(amin)
 
 cdef dict nanmin_dict = {}
-nanmin_dict[(2, int32, 0)] = nanmin_2d_int32_axis0
-nanmin_dict[(2, int32, 1)] = nanmin_2d_int32_axis1
-nanmin_dict[(2, int64, 0)] = nanmin_2d_int64_axis0
-nanmin_dict[(2, int64, 1)] = nanmin_2d_int64_axis1
-nanmin_dict[(3, int32, 0)] = nanmin_3d_int32_axis0
-nanmin_dict[(3, int32, 1)] = nanmin_3d_int32_axis1
-nanmin_dict[(3, int32, 2)] = nanmin_3d_int32_axis2
-nanmin_dict[(3, int64, 0)] = nanmin_3d_int64_axis0
-nanmin_dict[(3, int64, 1)] = nanmin_3d_int64_axis1
-nanmin_dict[(3, int64, 2)] = nanmin_3d_int64_axis2
-nanmin_dict[(1, float32, 0)] = nanmin_1d_float32_axisNone
-nanmin_dict[(1, float32, None)] = nanmin_1d_float32_axisNone
-nanmin_dict[(1, float64, 0)] = nanmin_1d_float64_axisNone
-nanmin_dict[(1, float64, None)] = nanmin_1d_float64_axisNone
-nanmin_dict[(2, float32, None)] = nanmin_2d_float32_axisNone
-nanmin_dict[(2, float64, None)] = nanmin_2d_float64_axisNone
-nanmin_dict[(3, float32, None)] = nanmin_3d_float32_axisNone
-nanmin_dict[(3, float64, None)] = nanmin_3d_float64_axisNone
-nanmin_dict[(2, float32, 0)] = nanmin_2d_float32_axis0
-nanmin_dict[(2, float32, 1)] = nanmin_2d_float32_axis1
-nanmin_dict[(2, float64, 0)] = nanmin_2d_float64_axis0
-nanmin_dict[(2, float64, 1)] = nanmin_2d_float64_axis1
-nanmin_dict[(3, float32, 0)] = nanmin_3d_float32_axis0
-nanmin_dict[(3, float32, 1)] = nanmin_3d_float32_axis1
-nanmin_dict[(3, float32, 2)] = nanmin_3d_float32_axis2
-nanmin_dict[(3, float64, 0)] = nanmin_3d_float64_axis0
-nanmin_dict[(3, float64, 1)] = nanmin_3d_float64_axis1
-nanmin_dict[(3, float64, 2)] = nanmin_3d_float64_axis2
-nanmin_dict[(1, int32, 0)] = nanmin_1d_int32_axisNone
-nanmin_dict[(1, int32, None)] = nanmin_1d_int32_axisNone
-nanmin_dict[(1, int64, 0)] = nanmin_1d_int64_axisNone
-nanmin_dict[(1, int64, None)] = nanmin_1d_int64_axisNone
-nanmin_dict[(2, int32, None)] = nanmin_2d_int32_axisNone
-nanmin_dict[(2, int64, None)] = nanmin_2d_int64_axisNone
-nanmin_dict[(3, int32, None)] = nanmin_3d_int32_axisNone
-nanmin_dict[(3, int64, None)] = nanmin_3d_int64_axisNone
+nanmin_dict[(2, NPY_int32, 0)] = nanmin_2d_int32_axis0
+nanmin_dict[(2, NPY_int32, 1)] = nanmin_2d_int32_axis1
+nanmin_dict[(2, NPY_int64, 0)] = nanmin_2d_int64_axis0
+nanmin_dict[(2, NPY_int64, 1)] = nanmin_2d_int64_axis1
+nanmin_dict[(3, NPY_int32, 0)] = nanmin_3d_int32_axis0
+nanmin_dict[(3, NPY_int32, 1)] = nanmin_3d_int32_axis1
+nanmin_dict[(3, NPY_int32, 2)] = nanmin_3d_int32_axis2
+nanmin_dict[(3, NPY_int64, 0)] = nanmin_3d_int64_axis0
+nanmin_dict[(3, NPY_int64, 1)] = nanmin_3d_int64_axis1
+nanmin_dict[(3, NPY_int64, 2)] = nanmin_3d_int64_axis2
+nanmin_dict[(1, NPY_float32, 0)] = nanmin_1d_float32_axisNone
+nanmin_dict[(1, NPY_float32, None)] = nanmin_1d_float32_axisNone
+nanmin_dict[(1, NPY_float64, 0)] = nanmin_1d_float64_axisNone
+nanmin_dict[(1, NPY_float64, None)] = nanmin_1d_float64_axisNone
+nanmin_dict[(2, NPY_float32, None)] = nanmin_2d_float32_axisNone
+nanmin_dict[(2, NPY_float64, None)] = nanmin_2d_float64_axisNone
+nanmin_dict[(3, NPY_float32, None)] = nanmin_3d_float32_axisNone
+nanmin_dict[(3, NPY_float64, None)] = nanmin_3d_float64_axisNone
+nanmin_dict[(2, NPY_float32, 0)] = nanmin_2d_float32_axis0
+nanmin_dict[(2, NPY_float32, 1)] = nanmin_2d_float32_axis1
+nanmin_dict[(2, NPY_float64, 0)] = nanmin_2d_float64_axis0
+nanmin_dict[(2, NPY_float64, 1)] = nanmin_2d_float64_axis1
+nanmin_dict[(3, NPY_float32, 0)] = nanmin_3d_float32_axis0
+nanmin_dict[(3, NPY_float32, 1)] = nanmin_3d_float32_axis1
+nanmin_dict[(3, NPY_float32, 2)] = nanmin_3d_float32_axis2
+nanmin_dict[(3, NPY_float64, 0)] = nanmin_3d_float64_axis0
+nanmin_dict[(3, NPY_float64, 1)] = nanmin_3d_float64_axis1
+nanmin_dict[(3, NPY_float64, 2)] = nanmin_3d_float64_axis2
+nanmin_dict[(1, NPY_int32, 0)] = nanmin_1d_int32_axisNone
+nanmin_dict[(1, NPY_int32, None)] = nanmin_1d_int32_axisNone
+nanmin_dict[(1, NPY_int64, 0)] = nanmin_1d_int64_axisNone
+nanmin_dict[(1, NPY_int64, None)] = nanmin_1d_int64_axisNone
+nanmin_dict[(2, NPY_int32, None)] = nanmin_2d_int32_axisNone
+nanmin_dict[(2, NPY_int64, None)] = nanmin_2d_int64_axisNone
+nanmin_dict[(3, NPY_int32, None)] = nanmin_3d_int32_axisNone
+nanmin_dict[(3, NPY_int64, None)] = nanmin_3d_int64_axisNone
 
 cdef dict nanmin_slow_dict = {}
 nanmin_slow_dict[0] = nanmin_slow_axis0
diff --git a/bottleneck/src/func/nanstd.pyx b/bottleneck/src/func/nanstd.pyx
index f54f858cd2..60a46f6f10 100644
--- a/bottleneck/src/func/nanstd.pyx
+++ b/bottleneck/src/func/nanstd.pyx
@@ -128,8 +128,8 @@ def nanstd_selector(arr, axis):
         a = arr
     else:    
         a = np.array(arr, copy=False)
-    cdef int ndim = a.ndim
-    cdef np.dtype dtype = a.dtype
+    cdef int ndim = PyArray_NDIM(a)
+    cdef int dtype = PyArray_TYPE(a)
     if (axis < 0) and (axis is not None):
         axis += ndim
     cdef tuple key = (ndim, dtype, axis)
@@ -142,7 +142,7 @@ def nanstd_selector(arr, axis):
         try:
             func = nanstd_slow_dict[axis]
         except KeyError:
-            tup = (str(ndim), str(dtype), str(axis))
+            tup = (str(ndim), str(a.dtype), str(axis))
             raise TypeError, "Unsupported ndim/dtype/axis (%s/%s/%s)." % tup
     return func, a
 
@@ -1047,42 +1047,42 @@ def nanstd_3d_int64_axisNone(np.ndarray[np.int64_t, ndim=3] a, int ddof):
     return np.float64(sqrt(asum / (size - ddof))) 
 
 cdef dict nanstd_dict = {}
-nanstd_dict[(2, int32, 0)] = nanstd_2d_int32_axis0
-nanstd_dict[(2, int32, 1)] = nanstd_2d_int32_axis1
-nanstd_dict[(2, int64, 0)] = nanstd_2d_int64_axis0
-nanstd_dict[(2, int64, 1)] = nanstd_2d_int64_axis1
-nanstd_dict[(3, int32, 0)] = nanstd_3d_int32_axis0
-nanstd_dict[(3, int32, 1)] = nanstd_3d_int32_axis1
-nanstd_dict[(3, int32, 2)] = nanstd_3d_int32_axis2
-nanstd_dict[(3, int64, 0)] = nanstd_3d_int64_axis0
-nanstd_dict[(3, int64, 1)] = nanstd_3d_int64_axis1
-nanstd_dict[(3, int64, 2)] = nanstd_3d_int64_axis2
-nanstd_dict[(1, float32, 0)] = nanstd_1d_float32_axisNone
-nanstd_dict[(1, float32, None)] = nanstd_1d_float32_axisNone
-nanstd_dict[(1, float64, 0)] = nanstd_1d_float64_axisNone
-nanstd_dict[(1, float64, None)] = nanstd_1d_float64_axisNone
-nanstd_dict[(2, float32, None)] = nanstd_2d_float32_axisNone
-nanstd_dict[(2, float64, None)] = nanstd_2d_float64_axisNone
-nanstd_dict[(3, float32, None)] = nanstd_3d_float32_axisNone
-nanstd_dict[(3, float64, None)] = nanstd_3d_float64_axisNone
-nanstd_dict[(2, float32, 0)] = nanstd_2d_float32_axis0
-nanstd_dict[(2, float32, 1)] = nanstd_2d_float32_axis1
-nanstd_dict[(2, float64, 0)] = nanstd_2d_float64_axis0
-nanstd_dict[(2, float64, 1)] = nanstd_2d_float64_axis1
-nanstd_dict[(3, float32, 0)] = nanstd_3d_float32_axis0
-nanstd_dict[(3, float32, 1)] = nanstd_3d_float32_axis1
-nanstd_dict[(3, float32, 2)] = nanstd_3d_float32_axis2
-nanstd_dict[(3, float64, 0)] = nanstd_3d_float64_axis0
-nanstd_dict[(3, float64, 1)] = nanstd_3d_float64_axis1
-nanstd_dict[(3, float64, 2)] = nanstd_3d_float64_axis2
-nanstd_dict[(1, int32, 0)] = nanstd_1d_int32_axisNone
-nanstd_dict[(1, int32, None)] = nanstd_1d_int32_axisNone
-nanstd_dict[(1, int64, 0)] = nanstd_1d_int64_axisNone
-nanstd_dict[(1, int64, None)] = nanstd_1d_int64_axisNone
-nanstd_dict[(2, int32, None)] = nanstd_2d_int32_axisNone
-nanstd_dict[(2, int64, None)] = nanstd_2d_int64_axisNone
-nanstd_dict[(3, int32, None)] = nanstd_3d_int32_axisNone
-nanstd_dict[(3, int64, None)] = nanstd_3d_int64_axisNone
+nanstd_dict[(2, NPY_int32, 0)] = nanstd_2d_int32_axis0
+nanstd_dict[(2, NPY_int32, 1)] = nanstd_2d_int32_axis1
+nanstd_dict[(2, NPY_int64, 0)] = nanstd_2d_int64_axis0
+nanstd_dict[(2, NPY_int64, 1)] = nanstd_2d_int64_axis1
+nanstd_dict[(3, NPY_int32, 0)] = nanstd_3d_int32_axis0
+nanstd_dict[(3, NPY_int32, 1)] = nanstd_3d_int32_axis1
+nanstd_dict[(3, NPY_int32, 2)] = nanstd_3d_int32_axis2
+nanstd_dict[(3, NPY_int64, 0)] = nanstd_3d_int64_axis0
+nanstd_dict[(3, NPY_int64, 1)] = nanstd_3d_int64_axis1
+nanstd_dict[(3, NPY_int64, 2)] = nanstd_3d_int64_axis2
+nanstd_dict[(1, NPY_float32, 0)] = nanstd_1d_float32_axisNone
+nanstd_dict[(1, NPY_float32, None)] = nanstd_1d_float32_axisNone
+nanstd_dict[(1, NPY_float64, 0)] = nanstd_1d_float64_axisNone
+nanstd_dict[(1, NPY_float64, None)] = nanstd_1d_float64_axisNone
+nanstd_dict[(2, NPY_float32, None)] = nanstd_2d_float32_axisNone
+nanstd_dict[(2, NPY_float64, None)] = nanstd_2d_float64_axisNone
+nanstd_dict[(3, NPY_float32, None)] = nanstd_3d_float32_axisNone
+nanstd_dict[(3, NPY_float64, None)] = nanstd_3d_float64_axisNone
+nanstd_dict[(2, NPY_float32, 0)] = nanstd_2d_float32_axis0
+nanstd_dict[(2, NPY_float32, 1)] = nanstd_2d_float32_axis1
+nanstd_dict[(2, NPY_float64, 0)] = nanstd_2d_float64_axis0
+nanstd_dict[(2, NPY_float64, 1)] = nanstd_2d_float64_axis1
+nanstd_dict[(3, NPY_float32, 0)] = nanstd_3d_float32_axis0
+nanstd_dict[(3, NPY_float32, 1)] = nanstd_3d_float32_axis1
+nanstd_dict[(3, NPY_float32, 2)] = nanstd_3d_float32_axis2
+nanstd_dict[(3, NPY_float64, 0)] = nanstd_3d_float64_axis0
+nanstd_dict[(3, NPY_float64, 1)] = nanstd_3d_float64_axis1
+nanstd_dict[(3, NPY_float64, 2)] = nanstd_3d_float64_axis2
+nanstd_dict[(1, NPY_int32, 0)] = nanstd_1d_int32_axisNone
+nanstd_dict[(1, NPY_int32, None)] = nanstd_1d_int32_axisNone
+nanstd_dict[(1, NPY_int64, 0)] = nanstd_1d_int64_axisNone
+nanstd_dict[(1, NPY_int64, None)] = nanstd_1d_int64_axisNone
+nanstd_dict[(2, NPY_int32, None)] = nanstd_2d_int32_axisNone
+nanstd_dict[(2, NPY_int64, None)] = nanstd_2d_int64_axisNone
+nanstd_dict[(3, NPY_int32, None)] = nanstd_3d_int32_axisNone
+nanstd_dict[(3, NPY_int64, None)] = nanstd_3d_int64_axisNone
 
 cdef dict nanstd_slow_dict = {}
 nanstd_slow_dict[0] = nanstd_slow_axis0
diff --git a/bottleneck/src/func/nansum.pyx b/bottleneck/src/func/nansum.pyx
index b7d8d8a3a3..74e61871ab 100644
--- a/bottleneck/src/func/nansum.pyx
+++ b/bottleneck/src/func/nansum.pyx
@@ -111,11 +111,11 @@ def nansum_selector(arr, axis):
         a = arr
     else:    
         a = np.array(arr, copy=False)
-    cdef int ndim = a.ndim
-    cdef np.dtype dtype = a.dtype
-    if dtype < np.int_:
+    cdef int ndim = PyArray_NDIM(a)
+    cdef int dtype = PyArray_TYPE(a)
+    if dtype < NPY_int_:
         a = a.astype(np.int_)
-        dtype = a.dtype
+        dtype = PyArray_TYPE(a)
     if (axis < 0) and (axis is not None):
         axis += ndim
     cdef tuple key = (ndim, dtype, axis)
@@ -128,7 +128,7 @@ def nansum_selector(arr, axis):
         try:
             func = nansum_slow_dict[axis]
         except KeyError:
-            tup = (str(ndim), str(dtype), str(axis))
+            tup = (str(ndim), str(a.dtype), str(axis))
             raise TypeError, "Unsupported ndim/dtype/axis (%s/%s/%s)." % tup
     return func, a
 
@@ -807,42 +807,42 @@ def nansum_3d_int64_axisNone(np.ndarray[np.int64_t, ndim=3] a):
     return np.int64(asum)
 
 cdef dict nansum_dict = {}
-nansum_dict[(2, int32, 0)] = nansum_2d_int32_axis0
-nansum_dict[(2, int32, 1)] = nansum_2d_int32_axis1
-nansum_dict[(2, int64, 0)] = nansum_2d_int64_axis0
-nansum_dict[(2, int64, 1)] = nansum_2d_int64_axis1
-nansum_dict[(3, int32, 0)] = nansum_3d_int32_axis0
-nansum_dict[(3, int32, 1)] = nansum_3d_int32_axis1
-nansum_dict[(3, int32, 2)] = nansum_3d_int32_axis2
-nansum_dict[(3, int64, 0)] = nansum_3d_int64_axis0
-nansum_dict[(3, int64, 1)] = nansum_3d_int64_axis1
-nansum_dict[(3, int64, 2)] = nansum_3d_int64_axis2
-nansum_dict[(1, float32, 0)] = nansum_1d_float32_axisNone
-nansum_dict[(1, float32, None)] = nansum_1d_float32_axisNone
-nansum_dict[(1, float64, 0)] = nansum_1d_float64_axisNone
-nansum_dict[(1, float64, None)] = nansum_1d_float64_axisNone
-nansum_dict[(2, float32, None)] = nansum_2d_float32_axisNone
-nansum_dict[(2, float64, None)] = nansum_2d_float64_axisNone
-nansum_dict[(3, float32, None)] = nansum_3d_float32_axisNone
-nansum_dict[(3, float64, None)] = nansum_3d_float64_axisNone
-nansum_dict[(2, float32, 0)] = nansum_2d_float32_axis0
-nansum_dict[(2, float32, 1)] = nansum_2d_float32_axis1
-nansum_dict[(2, float64, 0)] = nansum_2d_float64_axis0
-nansum_dict[(2, float64, 1)] = nansum_2d_float64_axis1
-nansum_dict[(3, float32, 0)] = nansum_3d_float32_axis0
-nansum_dict[(3, float32, 1)] = nansum_3d_float32_axis1
-nansum_dict[(3, float32, 2)] = nansum_3d_float32_axis2
-nansum_dict[(3, float64, 0)] = nansum_3d_float64_axis0
-nansum_dict[(3, float64, 1)] = nansum_3d_float64_axis1
-nansum_dict[(3, float64, 2)] = nansum_3d_float64_axis2
-nansum_dict[(1, int32, 0)] = nansum_1d_int32_axisNone
-nansum_dict[(1, int32, None)] = nansum_1d_int32_axisNone
-nansum_dict[(1, int64, 0)] = nansum_1d_int64_axisNone
-nansum_dict[(1, int64, None)] = nansum_1d_int64_axisNone
-nansum_dict[(2, int32, None)] = nansum_2d_int32_axisNone
-nansum_dict[(2, int64, None)] = nansum_2d_int64_axisNone
-nansum_dict[(3, int32, None)] = nansum_3d_int32_axisNone
-nansum_dict[(3, int64, None)] = nansum_3d_int64_axisNone
+nansum_dict[(2, NPY_int32, 0)] = nansum_2d_int32_axis0
+nansum_dict[(2, NPY_int32, 1)] = nansum_2d_int32_axis1
+nansum_dict[(2, NPY_int64, 0)] = nansum_2d_int64_axis0
+nansum_dict[(2, NPY_int64, 1)] = nansum_2d_int64_axis1
+nansum_dict[(3, NPY_int32, 0)] = nansum_3d_int32_axis0
+nansum_dict[(3, NPY_int32, 1)] = nansum_3d_int32_axis1
+nansum_dict[(3, NPY_int32, 2)] = nansum_3d_int32_axis2
+nansum_dict[(3, NPY_int64, 0)] = nansum_3d_int64_axis0
+nansum_dict[(3, NPY_int64, 1)] = nansum_3d_int64_axis1
+nansum_dict[(3, NPY_int64, 2)] = nansum_3d_int64_axis2
+nansum_dict[(1, NPY_float32, 0)] = nansum_1d_float32_axisNone
+nansum_dict[(1, NPY_float32, None)] = nansum_1d_float32_axisNone
+nansum_dict[(1, NPY_float64, 0)] = nansum_1d_float64_axisNone
+nansum_dict[(1, NPY_float64, None)] = nansum_1d_float64_axisNone
+nansum_dict[(2, NPY_float32, None)] = nansum_2d_float32_axisNone
+nansum_dict[(2, NPY_float64, None)] = nansum_2d_float64_axisNone
+nansum_dict[(3, NPY_float32, None)] = nansum_3d_float32_axisNone
+nansum_dict[(3, NPY_float64, None)] = nansum_3d_float64_axisNone
+nansum_dict[(2, NPY_float32, 0)] = nansum_2d_float32_axis0
+nansum_dict[(2, NPY_float32, 1)] = nansum_2d_float32_axis1
+nansum_dict[(2, NPY_float64, 0)] = nansum_2d_float64_axis0
+nansum_dict[(2, NPY_float64, 1)] = nansum_2d_float64_axis1
+nansum_dict[(3, NPY_float32, 0)] = nansum_3d_float32_axis0
+nansum_dict[(3, NPY_float32, 1)] = nansum_3d_float32_axis1
+nansum_dict[(3, NPY_float32, 2)] = nansum_3d_float32_axis2
+nansum_dict[(3, NPY_float64, 0)] = nansum_3d_float64_axis0
+nansum_dict[(3, NPY_float64, 1)] = nansum_3d_float64_axis1
+nansum_dict[(3, NPY_float64, 2)] = nansum_3d_float64_axis2
+nansum_dict[(1, NPY_int32, 0)] = nansum_1d_int32_axisNone
+nansum_dict[(1, NPY_int32, None)] = nansum_1d_int32_axisNone
+nansum_dict[(1, NPY_int64, 0)] = nansum_1d_int64_axisNone
+nansum_dict[(1, NPY_int64, None)] = nansum_1d_int64_axisNone
+nansum_dict[(2, NPY_int32, None)] = nansum_2d_int32_axisNone
+nansum_dict[(2, NPY_int64, None)] = nansum_2d_int64_axisNone
+nansum_dict[(3, NPY_int32, None)] = nansum_3d_int32_axisNone
+nansum_dict[(3, NPY_int64, None)] = nansum_3d_int64_axisNone
 
 cdef dict nansum_slow_dict = {}
 nansum_slow_dict[0] = nansum_slow_axis0
diff --git a/bottleneck/src/func/nanvar.pyx b/bottleneck/src/func/nanvar.pyx
index 1edebd8069..603662a461 100644
--- a/bottleneck/src/func/nanvar.pyx
+++ b/bottleneck/src/func/nanvar.pyx
@@ -127,8 +127,8 @@ def nanvar_selector(arr, axis):
         a = arr
     else:    
         a = np.array(arr, copy=False)
-    cdef int ndim = a.ndim
-    cdef np.dtype dtype = a.dtype
+    cdef int ndim = PyArray_NDIM(a)
+    cdef int dtype = PyArray_TYPE(a)
     if (axis < 0) and (axis is not None):
         axis += ndim
     cdef tuple key = (ndim, dtype, axis)
@@ -141,7 +141,7 @@ def nanvar_selector(arr, axis):
         try:
             func = nanvar_slow_dict[axis]
         except KeyError:
-            tup = (str(ndim), str(dtype), str(axis))
+            tup = (str(ndim), str(a.dtype), str(axis))
             raise TypeError, "Unsupported ndim/dtype/axis (%s/%s/%s)." % tup
     return func, a
 
@@ -1046,42 +1046,42 @@ def nanvar_3d_int64_axisNone(np.ndarray[np.int64_t, ndim=3] a, int ddof):
     return np.float64(asum / (size - ddof)) 
 
 cdef dict nanvar_dict = {}
-nanvar_dict[(2, int32, 0)] = nanvar_2d_int32_axis0
-nanvar_dict[(2, int32, 1)] = nanvar_2d_int32_axis1
-nanvar_dict[(2, int64, 0)] = nanvar_2d_int64_axis0
-nanvar_dict[(2, int64, 1)] = nanvar_2d_int64_axis1
-nanvar_dict[(3, int32, 0)] = nanvar_3d_int32_axis0
-nanvar_dict[(3, int32, 1)] = nanvar_3d_int32_axis1
-nanvar_dict[(3, int32, 2)] = nanvar_3d_int32_axis2
-nanvar_dict[(3, int64, 0)] = nanvar_3d_int64_axis0
-nanvar_dict[(3, int64, 1)] = nanvar_3d_int64_axis1
-nanvar_dict[(3, int64, 2)] = nanvar_3d_int64_axis2
-nanvar_dict[(1, float32, 0)] = nanvar_1d_float32_axisNone
-nanvar_dict[(1, float32, None)] = nanvar_1d_float32_axisNone
-nanvar_dict[(1, float64, 0)] = nanvar_1d_float64_axisNone
-nanvar_dict[(1, float64, None)] = nanvar_1d_float64_axisNone
-nanvar_dict[(2, float32, None)] = nanvar_2d_float32_axisNone
-nanvar_dict[(2, float64, None)] = nanvar_2d_float64_axisNone
-nanvar_dict[(3, float32, None)] = nanvar_3d_float32_axisNone
-nanvar_dict[(3, float64, None)] = nanvar_3d_float64_axisNone
-nanvar_dict[(2, float32, 0)] = nanvar_2d_float32_axis0
-nanvar_dict[(2, float32, 1)] = nanvar_2d_float32_axis1
-nanvar_dict[(2, float64, 0)] = nanvar_2d_float64_axis0
-nanvar_dict[(2, float64, 1)] = nanvar_2d_float64_axis1
-nanvar_dict[(3, float32, 0)] = nanvar_3d_float32_axis0
-nanvar_dict[(3, float32, 1)] = nanvar_3d_float32_axis1
-nanvar_dict[(3, float32, 2)] = nanvar_3d_float32_axis2
-nanvar_dict[(3, float64, 0)] = nanvar_3d_float64_axis0
-nanvar_dict[(3, float64, 1)] = nanvar_3d_float64_axis1
-nanvar_dict[(3, float64, 2)] = nanvar_3d_float64_axis2
-nanvar_dict[(1, int32, 0)] = nanvar_1d_int32_axisNone
-nanvar_dict[(1, int32, None)] = nanvar_1d_int32_axisNone
-nanvar_dict[(1, int64, 0)] = nanvar_1d_int64_axisNone
-nanvar_dict[(1, int64, None)] = nanvar_1d_int64_axisNone
-nanvar_dict[(2, int32, None)] = nanvar_2d_int32_axisNone
-nanvar_dict[(2, int64, None)] = nanvar_2d_int64_axisNone
-nanvar_dict[(3, int32, None)] = nanvar_3d_int32_axisNone
-nanvar_dict[(3, int64, None)] = nanvar_3d_int64_axisNone
+nanvar_dict[(2, NPY_int32, 0)] = nanvar_2d_int32_axis0
+nanvar_dict[(2, NPY_int32, 1)] = nanvar_2d_int32_axis1
+nanvar_dict[(2, NPY_int64, 0)] = nanvar_2d_int64_axis0
+nanvar_dict[(2, NPY_int64, 1)] = nanvar_2d_int64_axis1
+nanvar_dict[(3, NPY_int32, 0)] = nanvar_3d_int32_axis0
+nanvar_dict[(3, NPY_int32, 1)] = nanvar_3d_int32_axis1
+nanvar_dict[(3, NPY_int32, 2)] = nanvar_3d_int32_axis2
+nanvar_dict[(3, NPY_int64, 0)] = nanvar_3d_int64_axis0
+nanvar_dict[(3, NPY_int64, 1)] = nanvar_3d_int64_axis1
+nanvar_dict[(3, NPY_int64, 2)] = nanvar_3d_int64_axis2
+nanvar_dict[(1, NPY_float32, 0)] = nanvar_1d_float32_axisNone
+nanvar_dict[(1, NPY_float32, None)] = nanvar_1d_float32_axisNone
+nanvar_dict[(1, NPY_float64, 0)] = nanvar_1d_float64_axisNone
+nanvar_dict[(1, NPY_float64, None)] = nanvar_1d_float64_axisNone
+nanvar_dict[(2, NPY_float32, None)] = nanvar_2d_float32_axisNone
+nanvar_dict[(2, NPY_float64, None)] = nanvar_2d_float64_axisNone
+nanvar_dict[(3, NPY_float32, None)] = nanvar_3d_float32_axisNone
+nanvar_dict[(3, NPY_float64, None)] = nanvar_3d_float64_axisNone
+nanvar_dict[(2, NPY_float32, 0)] = nanvar_2d_float32_axis0
+nanvar_dict[(2, NPY_float32, 1)] = nanvar_2d_float32_axis1
+nanvar_dict[(2, NPY_float64, 0)] = nanvar_2d_float64_axis0
+nanvar_dict[(2, NPY_float64, 1)] = nanvar_2d_float64_axis1
+nanvar_dict[(3, NPY_float32, 0)] = nanvar_3d_float32_axis0
+nanvar_dict[(3, NPY_float32, 1)] = nanvar_3d_float32_axis1
+nanvar_dict[(3, NPY_float32, 2)] = nanvar_3d_float32_axis2
+nanvar_dict[(3, NPY_float64, 0)] = nanvar_3d_float64_axis0
+nanvar_dict[(3, NPY_float64, 1)] = nanvar_3d_float64_axis1
+nanvar_dict[(3, NPY_float64, 2)] = nanvar_3d_float64_axis2
+nanvar_dict[(1, NPY_int32, 0)] = nanvar_1d_int32_axisNone
+nanvar_dict[(1, NPY_int32, None)] = nanvar_1d_int32_axisNone
+nanvar_dict[(1, NPY_int64, 0)] = nanvar_1d_int64_axisNone
+nanvar_dict[(1, NPY_int64, None)] = nanvar_1d_int64_axisNone
+nanvar_dict[(2, NPY_int32, None)] = nanvar_2d_int32_axisNone
+nanvar_dict[(2, NPY_int64, None)] = nanvar_2d_int64_axisNone
+nanvar_dict[(3, NPY_int32, None)] = nanvar_3d_int32_axisNone
+nanvar_dict[(3, NPY_int64, None)] = nanvar_3d_int64_axisNone
 
 cdef dict nanvar_slow_dict = {}
 nanvar_slow_dict[0] = nanvar_slow_axis0
diff --git a/bottleneck/src/group/group_header.pyx b/bottleneck/src/group/group_header.pyx
index 58423bfd77..0dfa6ca787 100644
--- a/bottleneck/src/group/group_header.pyx
+++ b/bottleneck/src/group/group_header.pyx
@@ -5,7 +5,7 @@ from numpy cimport NPY_INT32 as NPY_int32
 from numpy cimport NPY_INT64 as NPY_int64
 from numpy cimport NPY_FLOAT32 as NPY_float32
 from numpy cimport NPY_FLOAT64 as NPY_float64
-from numpy cimport PyArray_EMPTY, import_array
+from numpy cimport PyArray_EMPTY, PyArray_TYPE, PyArray_NDIM, import_array
 import_array()
 import bottleneck as bn
 
diff --git a/bottleneck/src/group/group_nanmean.pyx b/bottleneck/src/group/group_nanmean.pyx
index da490747b3..2203f713f3 100644
--- a/bottleneck/src/group/group_nanmean.pyx
+++ b/bottleneck/src/group/group_nanmean.pyx
@@ -160,8 +160,8 @@ def group_nanmean_selector(arr, label, order=None, int axis=0):
         a = arr
     else:    
         a = np.array(arr, copy=False)
-    cdef int ndim = a.ndim
-    cdef np.dtype dtype = a.dtype
+    cdef int ndim = PyArray_NDIM(a)
+    cdef int dtype = PyArray_TYPE(a)
     if axis < 0:
        axis += ndim
     cdef int narr = a.shape[axis], nlabel = len(label)
@@ -175,7 +175,7 @@ def group_nanmean_selector(arr, label, order=None, int axis=0):
     except KeyError:
         if (axis < 0) or (axis >= ndim):
             raise ValueError("axis(=%d) out of bounds" % axis)
-        tup = (str(ndim), str(dtype))
+        tup = (str(ndim), str(a.dtype))
         raise TypeError("Unsupported ndim/dtype (%s/%s)." % tup)
     label_dict, order = group_mapper(label, order)
     return func, a, label_dict, order
@@ -887,27 +887,27 @@ def group_nanmean_3d_float64_axis2(np.ndarray[np.float64_t, ndim=3] a,
     return y, order 
 
 cdef dict group_nanmean_dict = {}
-group_nanmean_dict[(1, int32, 0)] = group_nanmean_1d_int32_axis0
-group_nanmean_dict[(1, int64, 0)] = group_nanmean_1d_int64_axis0
-group_nanmean_dict[(2, int32, 0)] = group_nanmean_2d_int32_axis0
-group_nanmean_dict[(2, int32, 1)] = group_nanmean_2d_int32_axis1
-group_nanmean_dict[(2, int64, 0)] = group_nanmean_2d_int64_axis0
-group_nanmean_dict[(2, int64, 1)] = group_nanmean_2d_int64_axis1
-group_nanmean_dict[(3, int32, 0)] = group_nanmean_3d_int32_axis0
-group_nanmean_dict[(3, int32, 1)] = group_nanmean_3d_int32_axis1
-group_nanmean_dict[(3, int32, 2)] = group_nanmean_3d_int32_axis2
-group_nanmean_dict[(3, int64, 0)] = group_nanmean_3d_int64_axis0
-group_nanmean_dict[(3, int64, 1)] = group_nanmean_3d_int64_axis1
-group_nanmean_dict[(3, int64, 2)] = group_nanmean_3d_int64_axis2
-group_nanmean_dict[(1, float32, 0)] = group_nanmean_1d_float32_axis0
-group_nanmean_dict[(1, float64, 0)] = group_nanmean_1d_float64_axis0
-group_nanmean_dict[(2, float32, 0)] = group_nanmean_2d_float32_axis0
-group_nanmean_dict[(2, float32, 1)] = group_nanmean_2d_float32_axis1
-group_nanmean_dict[(2, float64, 0)] = group_nanmean_2d_float64_axis0
-group_nanmean_dict[(2, float64, 1)] = group_nanmean_2d_float64_axis1
-group_nanmean_dict[(3, float32, 0)] = group_nanmean_3d_float32_axis0
-group_nanmean_dict[(3, float32, 1)] = group_nanmean_3d_float32_axis1
-group_nanmean_dict[(3, float32, 2)] = group_nanmean_3d_float32_axis2
-group_nanmean_dict[(3, float64, 0)] = group_nanmean_3d_float64_axis0
-group_nanmean_dict[(3, float64, 1)] = group_nanmean_3d_float64_axis1
-group_nanmean_dict[(3, float64, 2)] = group_nanmean_3d_float64_axis2
\ No newline at end of file
+group_nanmean_dict[(1, NPY_int32, 0)] = group_nanmean_1d_int32_axis0
+group_nanmean_dict[(1, NPY_int64, 0)] = group_nanmean_1d_int64_axis0
+group_nanmean_dict[(2, NPY_int32, 0)] = group_nanmean_2d_int32_axis0
+group_nanmean_dict[(2, NPY_int32, 1)] = group_nanmean_2d_int32_axis1
+group_nanmean_dict[(2, NPY_int64, 0)] = group_nanmean_2d_int64_axis0
+group_nanmean_dict[(2, NPY_int64, 1)] = group_nanmean_2d_int64_axis1
+group_nanmean_dict[(3, NPY_int32, 0)] = group_nanmean_3d_int32_axis0
+group_nanmean_dict[(3, NPY_int32, 1)] = group_nanmean_3d_int32_axis1
+group_nanmean_dict[(3, NPY_int32, 2)] = group_nanmean_3d_int32_axis2
+group_nanmean_dict[(3, NPY_int64, 0)] = group_nanmean_3d_int64_axis0
+group_nanmean_dict[(3, NPY_int64, 1)] = group_nanmean_3d_int64_axis1
+group_nanmean_dict[(3, NPY_int64, 2)] = group_nanmean_3d_int64_axis2
+group_nanmean_dict[(1, NPY_float32, 0)] = group_nanmean_1d_float32_axis0
+group_nanmean_dict[(1, NPY_float64, 0)] = group_nanmean_1d_float64_axis0
+group_nanmean_dict[(2, NPY_float32, 0)] = group_nanmean_2d_float32_axis0
+group_nanmean_dict[(2, NPY_float32, 1)] = group_nanmean_2d_float32_axis1
+group_nanmean_dict[(2, NPY_float64, 0)] = group_nanmean_2d_float64_axis0
+group_nanmean_dict[(2, NPY_float64, 1)] = group_nanmean_2d_float64_axis1
+group_nanmean_dict[(3, NPY_float32, 0)] = group_nanmean_3d_float32_axis0
+group_nanmean_dict[(3, NPY_float32, 1)] = group_nanmean_3d_float32_axis1
+group_nanmean_dict[(3, NPY_float32, 2)] = group_nanmean_3d_float32_axis2
+group_nanmean_dict[(3, NPY_float64, 0)] = group_nanmean_3d_float64_axis0
+group_nanmean_dict[(3, NPY_float64, 1)] = group_nanmean_3d_float64_axis1
+group_nanmean_dict[(3, NPY_float64, 2)] = group_nanmean_3d_float64_axis2
\ No newline at end of file
diff --git a/bottleneck/src/move/move_header.pyx b/bottleneck/src/move/move_header.pyx
index 83039abce4..5964e0e931 100644
--- a/bottleneck/src/move/move_header.pyx
+++ b/bottleneck/src/move/move_header.pyx
@@ -6,7 +6,7 @@ from numpy cimport NPY_INT32 as NPY_int32
 from numpy cimport NPY_INT64 as NPY_int64
 from numpy cimport NPY_FLOAT32 as NPY_float32
 from numpy cimport NPY_FLOAT64 as NPY_float64
-from numpy cimport PyArray_EMPTY, import_array
+from numpy cimport PyArray_EMPTY, PyArray_TYPE, PyArray_NDIM, import_array
 import_array()
 import bottleneck as bn
 
@@ -28,4 +28,9 @@ float64 = np.dtype(np.float64)
 cdef extern from "math.h":
     double sqrt(double x)
 
+if np.int_ == np.int32:
+    NPY_int_ = NPY_int32
+elif np.int_ == np.int64:
+    NPY_int_ = NPY_int64
+
 MOVE_WINDOW_ERR_MSG = "Moving window (=%d) must between 1 and %d, inclusive"    
diff --git a/bottleneck/src/move/move_max.pyx b/bottleneck/src/move/move_max.pyx
index 5d069b7bb0..db3604ce39 100644
--- a/bottleneck/src/move/move_max.pyx
+++ b/bottleneck/src/move/move_max.pyx
@@ -98,8 +98,8 @@ def move_max_selector(arr, int axis):
         a = arr
     else:    
         a = np.array(arr, copy=False)
-    cdef np.dtype dtype = a.dtype
-    cdef int ndim = a.ndim
+    cdef int ndim = PyArray_NDIM(a)
+    cdef int dtype = PyArray_TYPE(a)
     if axis < 0:
         axis += ndim
     cdef tuple key = (ndim, dtype, axis)
@@ -111,7 +111,7 @@ def move_max_selector(arr, int axis):
         try:
             func = move_max_slow_dict[axis]
         except KeyError:
-            tup = (str(ndim), str(dtype), str(axis))
+            tup = (str(ndim), str(a.dtype), str(axis))
             raise TypeError, "Unsupported ndim/dtype/axis (%s/%s/%s)." % tup
     return func, a
 
@@ -1864,30 +1864,30 @@ def move_max_3d_float64_axis2(np.ndarray[np.float64_t, ndim=3] a, int window):
     return y
 
 cdef dict move_max_dict = {}
-move_max_dict[(1, int32, 0)] = move_max_1d_int32_axis0
-move_max_dict[(1, int64, 0)] = move_max_1d_int64_axis0
-move_max_dict[(2, int32, 0)] = move_max_2d_int32_axis0
-move_max_dict[(2, int32, 1)] = move_max_2d_int32_axis1
-move_max_dict[(2, int64, 0)] = move_max_2d_int64_axis0
-move_max_dict[(2, int64, 1)] = move_max_2d_int64_axis1
-move_max_dict[(3, int32, 0)] = move_max_3d_int32_axis0
-move_max_dict[(3, int32, 1)] = move_max_3d_int32_axis1
-move_max_dict[(3, int32, 2)] = move_max_3d_int32_axis2
-move_max_dict[(3, int64, 0)] = move_max_3d_int64_axis0
-move_max_dict[(3, int64, 1)] = move_max_3d_int64_axis1
-move_max_dict[(3, int64, 2)] = move_max_3d_int64_axis2
-move_max_dict[(1, float32, 0)] = move_max_1d_float32_axis0
-move_max_dict[(1, float64, 0)] = move_max_1d_float64_axis0
-move_max_dict[(2, float32, 0)] = move_max_2d_float32_axis0
-move_max_dict[(2, float32, 1)] = move_max_2d_float32_axis1
-move_max_dict[(2, float64, 0)] = move_max_2d_float64_axis0
-move_max_dict[(2, float64, 1)] = move_max_2d_float64_axis1
-move_max_dict[(3, float32, 0)] = move_max_3d_float32_axis0
-move_max_dict[(3, float32, 1)] = move_max_3d_float32_axis1
-move_max_dict[(3, float32, 2)] = move_max_3d_float32_axis2
-move_max_dict[(3, float64, 0)] = move_max_3d_float64_axis0
-move_max_dict[(3, float64, 1)] = move_max_3d_float64_axis1
-move_max_dict[(3, float64, 2)] = move_max_3d_float64_axis2
+move_max_dict[(1, NPY_int32, 0)] = move_max_1d_int32_axis0
+move_max_dict[(1, NPY_int64, 0)] = move_max_1d_int64_axis0
+move_max_dict[(2, NPY_int32, 0)] = move_max_2d_int32_axis0
+move_max_dict[(2, NPY_int32, 1)] = move_max_2d_int32_axis1
+move_max_dict[(2, NPY_int64, 0)] = move_max_2d_int64_axis0
+move_max_dict[(2, NPY_int64, 1)] = move_max_2d_int64_axis1
+move_max_dict[(3, NPY_int32, 0)] = move_max_3d_int32_axis0
+move_max_dict[(3, NPY_int32, 1)] = move_max_3d_int32_axis1
+move_max_dict[(3, NPY_int32, 2)] = move_max_3d_int32_axis2
+move_max_dict[(3, NPY_int64, 0)] = move_max_3d_int64_axis0
+move_max_dict[(3, NPY_int64, 1)] = move_max_3d_int64_axis1
+move_max_dict[(3, NPY_int64, 2)] = move_max_3d_int64_axis2
+move_max_dict[(1, NPY_float32, 0)] = move_max_1d_float32_axis0
+move_max_dict[(1, NPY_float64, 0)] = move_max_1d_float64_axis0
+move_max_dict[(2, NPY_float32, 0)] = move_max_2d_float32_axis0
+move_max_dict[(2, NPY_float32, 1)] = move_max_2d_float32_axis1
+move_max_dict[(2, NPY_float64, 0)] = move_max_2d_float64_axis0
+move_max_dict[(2, NPY_float64, 1)] = move_max_2d_float64_axis1
+move_max_dict[(3, NPY_float32, 0)] = move_max_3d_float32_axis0
+move_max_dict[(3, NPY_float32, 1)] = move_max_3d_float32_axis1
+move_max_dict[(3, NPY_float32, 2)] = move_max_3d_float32_axis2
+move_max_dict[(3, NPY_float64, 0)] = move_max_3d_float64_axis0
+move_max_dict[(3, NPY_float64, 1)] = move_max_3d_float64_axis1
+move_max_dict[(3, NPY_float64, 2)] = move_max_3d_float64_axis2
 
 cdef dict move_max_slow_dict = {}
 move_max_slow_dict[0] = move_max_slow_axis0
diff --git a/bottleneck/src/move/move_mean.pyx b/bottleneck/src/move/move_mean.pyx
index ca198d2678..44baa8544d 100644
--- a/bottleneck/src/move/move_mean.pyx
+++ b/bottleneck/src/move/move_mean.pyx
@@ -86,8 +86,8 @@ def move_mean_selector(arr, int axis):
         a = arr
     else:    
         a = np.array(arr, copy=False)
-    cdef np.dtype dtype = a.dtype
-    cdef int ndim = a.ndim
+    cdef int ndim = PyArray_NDIM(a)
+    cdef int dtype = PyArray_TYPE(a)
     if axis < 0:
         axis += ndim
     cdef tuple key = (ndim, dtype, axis)
@@ -99,7 +99,7 @@ def move_mean_selector(arr, int axis):
         try:
             func = move_mean_slow_dict[axis]
         except KeyError:
-            tup = (str(ndim), str(dtype), str(axis))
+            tup = (str(ndim), str(a.dtype), str(axis))
             raise TypeError, "Unsupported ndim/dtype/axis (%s/%s/%s)." % tup
     return func, a
 
@@ -1098,30 +1098,30 @@ def move_mean_3d_float64_axis2(np.ndarray[np.float64_t, ndim=3] a,
     return y
 
 cdef dict move_mean_dict = {}
-move_mean_dict[(1, int32, 0)] = move_mean_1d_int32_axis0
-move_mean_dict[(1, int64, 0)] = move_mean_1d_int64_axis0
-move_mean_dict[(2, int32, 0)] = move_mean_2d_int32_axis0
-move_mean_dict[(2, int32, 1)] = move_mean_2d_int32_axis1
-move_mean_dict[(2, int64, 0)] = move_mean_2d_int64_axis0
-move_mean_dict[(2, int64, 1)] = move_mean_2d_int64_axis1
-move_mean_dict[(3, int32, 0)] = move_mean_3d_int32_axis0
-move_mean_dict[(3, int32, 1)] = move_mean_3d_int32_axis1
-move_mean_dict[(3, int32, 2)] = move_mean_3d_int32_axis2
-move_mean_dict[(3, int64, 0)] = move_mean_3d_int64_axis0
-move_mean_dict[(3, int64, 1)] = move_mean_3d_int64_axis1
-move_mean_dict[(3, int64, 2)] = move_mean_3d_int64_axis2
-move_mean_dict[(1, float32, 0)] = move_mean_1d_float32_axis0
-move_mean_dict[(1, float64, 0)] = move_mean_1d_float64_axis0
-move_mean_dict[(2, float32, 0)] = move_mean_2d_float32_axis0
-move_mean_dict[(2, float32, 1)] = move_mean_2d_float32_axis1
-move_mean_dict[(2, float64, 0)] = move_mean_2d_float64_axis0
-move_mean_dict[(2, float64, 1)] = move_mean_2d_float64_axis1
-move_mean_dict[(3, float32, 0)] = move_mean_3d_float32_axis0
-move_mean_dict[(3, float32, 1)] = move_mean_3d_float32_axis1
-move_mean_dict[(3, float32, 2)] = move_mean_3d_float32_axis2
-move_mean_dict[(3, float64, 0)] = move_mean_3d_float64_axis0
-move_mean_dict[(3, float64, 1)] = move_mean_3d_float64_axis1
-move_mean_dict[(3, float64, 2)] = move_mean_3d_float64_axis2
+move_mean_dict[(1, NPY_int32, 0)] = move_mean_1d_int32_axis0
+move_mean_dict[(1, NPY_int64, 0)] = move_mean_1d_int64_axis0
+move_mean_dict[(2, NPY_int32, 0)] = move_mean_2d_int32_axis0
+move_mean_dict[(2, NPY_int32, 1)] = move_mean_2d_int32_axis1
+move_mean_dict[(2, NPY_int64, 0)] = move_mean_2d_int64_axis0
+move_mean_dict[(2, NPY_int64, 1)] = move_mean_2d_int64_axis1
+move_mean_dict[(3, NPY_int32, 0)] = move_mean_3d_int32_axis0
+move_mean_dict[(3, NPY_int32, 1)] = move_mean_3d_int32_axis1
+move_mean_dict[(3, NPY_int32, 2)] = move_mean_3d_int32_axis2
+move_mean_dict[(3, NPY_int64, 0)] = move_mean_3d_int64_axis0
+move_mean_dict[(3, NPY_int64, 1)] = move_mean_3d_int64_axis1
+move_mean_dict[(3, NPY_int64, 2)] = move_mean_3d_int64_axis2
+move_mean_dict[(1, NPY_float32, 0)] = move_mean_1d_float32_axis0
+move_mean_dict[(1, NPY_float64, 0)] = move_mean_1d_float64_axis0
+move_mean_dict[(2, NPY_float32, 0)] = move_mean_2d_float32_axis0
+move_mean_dict[(2, NPY_float32, 1)] = move_mean_2d_float32_axis1
+move_mean_dict[(2, NPY_float64, 0)] = move_mean_2d_float64_axis0
+move_mean_dict[(2, NPY_float64, 1)] = move_mean_2d_float64_axis1
+move_mean_dict[(3, NPY_float32, 0)] = move_mean_3d_float32_axis0
+move_mean_dict[(3, NPY_float32, 1)] = move_mean_3d_float32_axis1
+move_mean_dict[(3, NPY_float32, 2)] = move_mean_3d_float32_axis2
+move_mean_dict[(3, NPY_float64, 0)] = move_mean_3d_float64_axis0
+move_mean_dict[(3, NPY_float64, 1)] = move_mean_3d_float64_axis1
+move_mean_dict[(3, NPY_float64, 2)] = move_mean_3d_float64_axis2
 
 cdef dict move_mean_slow_dict = {}
 move_mean_slow_dict[0] = move_mean_slow_axis0
diff --git a/bottleneck/src/move/move_min.pyx b/bottleneck/src/move/move_min.pyx
index 1ea8d58508..2c42794429 100644
--- a/bottleneck/src/move/move_min.pyx
+++ b/bottleneck/src/move/move_min.pyx
@@ -98,8 +98,8 @@ def move_min_selector(arr, int axis):
         a = arr
     else:    
         a = np.array(arr, copy=False)
-    cdef np.dtype dtype = a.dtype
-    cdef int ndim = a.ndim
+    cdef int ndim = PyArray_NDIM(a)
+    cdef int dtype = PyArray_TYPE(a)
     if axis < 0:
         axis += ndim
     cdef tuple key = (ndim, dtype, axis)
@@ -111,7 +111,7 @@ def move_min_selector(arr, int axis):
         try:
             func = move_min_slow_dict[axis]
         except KeyError:
-            tup = (str(ndim), str(dtype), str(axis))
+            tup = (str(ndim), str(a.dtype), str(axis))
             raise TypeError, "Unsupported ndim/dtype/axis (%s/%s/%s)." % tup
     return func, a
 
@@ -1864,30 +1864,30 @@ def move_min_3d_float64_axis2(np.ndarray[np.float64_t, ndim=3] a, int window):
     return y
 
 cdef dict move_min_dict = {}
-move_min_dict[(1, int32, 0)] = move_min_1d_int32_axis0
-move_min_dict[(1, int64, 0)] = move_min_1d_int64_axis0
-move_min_dict[(2, int32, 0)] = move_min_2d_int32_axis0
-move_min_dict[(2, int32, 1)] = move_min_2d_int32_axis1
-move_min_dict[(2, int64, 0)] = move_min_2d_int64_axis0
-move_min_dict[(2, int64, 1)] = move_min_2d_int64_axis1
-move_min_dict[(3, int32, 0)] = move_min_3d_int32_axis0
-move_min_dict[(3, int32, 1)] = move_min_3d_int32_axis1
-move_min_dict[(3, int32, 2)] = move_min_3d_int32_axis2
-move_min_dict[(3, int64, 0)] = move_min_3d_int64_axis0
-move_min_dict[(3, int64, 1)] = move_min_3d_int64_axis1
-move_min_dict[(3, int64, 2)] = move_min_3d_int64_axis2
-move_min_dict[(1, float32, 0)] = move_min_1d_float32_axis0
-move_min_dict[(1, float64, 0)] = move_min_1d_float64_axis0
-move_min_dict[(2, float32, 0)] = move_min_2d_float32_axis0
-move_min_dict[(2, float32, 1)] = move_min_2d_float32_axis1
-move_min_dict[(2, float64, 0)] = move_min_2d_float64_axis0
-move_min_dict[(2, float64, 1)] = move_min_2d_float64_axis1
-move_min_dict[(3, float32, 0)] = move_min_3d_float32_axis0
-move_min_dict[(3, float32, 1)] = move_min_3d_float32_axis1
-move_min_dict[(3, float32, 2)] = move_min_3d_float32_axis2
-move_min_dict[(3, float64, 0)] = move_min_3d_float64_axis0
-move_min_dict[(3, float64, 1)] = move_min_3d_float64_axis1
-move_min_dict[(3, float64, 2)] = move_min_3d_float64_axis2
+move_min_dict[(1, NPY_int32, 0)] = move_min_1d_int32_axis0
+move_min_dict[(1, NPY_int64, 0)] = move_min_1d_int64_axis0
+move_min_dict[(2, NPY_int32, 0)] = move_min_2d_int32_axis0
+move_min_dict[(2, NPY_int32, 1)] = move_min_2d_int32_axis1
+move_min_dict[(2, NPY_int64, 0)] = move_min_2d_int64_axis0
+move_min_dict[(2, NPY_int64, 1)] = move_min_2d_int64_axis1
+move_min_dict[(3, NPY_int32, 0)] = move_min_3d_int32_axis0
+move_min_dict[(3, NPY_int32, 1)] = move_min_3d_int32_axis1
+move_min_dict[(3, NPY_int32, 2)] = move_min_3d_int32_axis2
+move_min_dict[(3, NPY_int64, 0)] = move_min_3d_int64_axis0
+move_min_dict[(3, NPY_int64, 1)] = move_min_3d_int64_axis1
+move_min_dict[(3, NPY_int64, 2)] = move_min_3d_int64_axis2
+move_min_dict[(1, NPY_float32, 0)] = move_min_1d_float32_axis0
+move_min_dict[(1, NPY_float64, 0)] = move_min_1d_float64_axis0
+move_min_dict[(2, NPY_float32, 0)] = move_min_2d_float32_axis0
+move_min_dict[(2, NPY_float32, 1)] = move_min_2d_float32_axis1
+move_min_dict[(2, NPY_float64, 0)] = move_min_2d_float64_axis0
+move_min_dict[(2, NPY_float64, 1)] = move_min_2d_float64_axis1
+move_min_dict[(3, NPY_float32, 0)] = move_min_3d_float32_axis0
+move_min_dict[(3, NPY_float32, 1)] = move_min_3d_float32_axis1
+move_min_dict[(3, NPY_float32, 2)] = move_min_3d_float32_axis2
+move_min_dict[(3, NPY_float64, 0)] = move_min_3d_float64_axis0
+move_min_dict[(3, NPY_float64, 1)] = move_min_3d_float64_axis1
+move_min_dict[(3, NPY_float64, 2)] = move_min_3d_float64_axis2
 
 cdef dict move_min_slow_dict = {}
 move_min_slow_dict[0] = move_min_slow_axis0
diff --git a/bottleneck/src/move/move_nanmax.pyx b/bottleneck/src/move/move_nanmax.pyx
index a6960e56fe..304ba0499c 100644
--- a/bottleneck/src/move/move_nanmax.pyx
+++ b/bottleneck/src/move/move_nanmax.pyx
@@ -98,8 +98,8 @@ def move_nanmax_selector(arr, int axis):
         a = arr
     else:    
         a = np.array(arr, copy=False)
-    cdef np.dtype dtype = a.dtype
-    cdef int ndim = a.ndim
+    cdef int ndim = PyArray_NDIM(a)
+    cdef int dtype = PyArray_TYPE(a)
     if axis < 0:
         axis += ndim
     cdef tuple key = (ndim, dtype, axis)
@@ -111,7 +111,7 @@ def move_nanmax_selector(arr, int axis):
         try:
             func = move_nanmax_slow_dict[axis]
         except KeyError:
-            tup = (str(ndim), str(dtype), str(axis))
+            tup = (str(ndim), str(a.dtype), str(axis))
             raise TypeError, "Unsupported ndim/dtype/axis (%s/%s/%s)." % tup
     return func, a
 
@@ -990,30 +990,30 @@ def move_nanmax_3d_float64_axis2(np.ndarray[np.float64_t, ndim=3] a, int window)
     return y
 
 cdef dict move_nanmax_dict = {}
-move_nanmax_dict[(1, int32, 0)] = move_max_1d_int32_axis0
-move_nanmax_dict[(1, int64, 0)] = move_max_1d_int64_axis0
-move_nanmax_dict[(2, int32, 0)] = move_max_2d_int32_axis0
-move_nanmax_dict[(2, int32, 1)] = move_max_2d_int32_axis1
-move_nanmax_dict[(2, int64, 0)] = move_max_2d_int64_axis0
-move_nanmax_dict[(2, int64, 1)] = move_max_2d_int64_axis1
-move_nanmax_dict[(3, int32, 0)] = move_max_3d_int32_axis0
-move_nanmax_dict[(3, int32, 1)] = move_max_3d_int32_axis1
-move_nanmax_dict[(3, int32, 2)] = move_max_3d_int32_axis2
-move_nanmax_dict[(3, int64, 0)] = move_max_3d_int64_axis0
-move_nanmax_dict[(3, int64, 1)] = move_max_3d_int64_axis1
-move_nanmax_dict[(3, int64, 2)] = move_max_3d_int64_axis2
-move_nanmax_dict[(1, float32, 0)] = move_nanmax_1d_float32_axis0
-move_nanmax_dict[(1, float64, 0)] = move_nanmax_1d_float64_axis0
-move_nanmax_dict[(2, float32, 0)] = move_nanmax_2d_float32_axis0
-move_nanmax_dict[(2, float32, 1)] = move_nanmax_2d_float32_axis1
-move_nanmax_dict[(2, float64, 0)] = move_nanmax_2d_float64_axis0
-move_nanmax_dict[(2, float64, 1)] = move_nanmax_2d_float64_axis1
-move_nanmax_dict[(3, float32, 0)] = move_nanmax_3d_float32_axis0
-move_nanmax_dict[(3, float32, 1)] = move_nanmax_3d_float32_axis1
-move_nanmax_dict[(3, float32, 2)] = move_nanmax_3d_float32_axis2
-move_nanmax_dict[(3, float64, 0)] = move_nanmax_3d_float64_axis0
-move_nanmax_dict[(3, float64, 1)] = move_nanmax_3d_float64_axis1
-move_nanmax_dict[(3, float64, 2)] = move_nanmax_3d_float64_axis2
+move_nanmax_dict[(1, NPY_int32, 0)] = move_max_1d_int32_axis0
+move_nanmax_dict[(1, NPY_int64, 0)] = move_max_1d_int64_axis0
+move_nanmax_dict[(2, NPY_int32, 0)] = move_max_2d_int32_axis0
+move_nanmax_dict[(2, NPY_int32, 1)] = move_max_2d_int32_axis1
+move_nanmax_dict[(2, NPY_int64, 0)] = move_max_2d_int64_axis0
+move_nanmax_dict[(2, NPY_int64, 1)] = move_max_2d_int64_axis1
+move_nanmax_dict[(3, NPY_int32, 0)] = move_max_3d_int32_axis0
+move_nanmax_dict[(3, NPY_int32, 1)] = move_max_3d_int32_axis1
+move_nanmax_dict[(3, NPY_int32, 2)] = move_max_3d_int32_axis2
+move_nanmax_dict[(3, NPY_int64, 0)] = move_max_3d_int64_axis0
+move_nanmax_dict[(3, NPY_int64, 1)] = move_max_3d_int64_axis1
+move_nanmax_dict[(3, NPY_int64, 2)] = move_max_3d_int64_axis2
+move_nanmax_dict[(1, NPY_float32, 0)] = move_nanmax_1d_float32_axis0
+move_nanmax_dict[(1, NPY_float64, 0)] = move_nanmax_1d_float64_axis0
+move_nanmax_dict[(2, NPY_float32, 0)] = move_nanmax_2d_float32_axis0
+move_nanmax_dict[(2, NPY_float32, 1)] = move_nanmax_2d_float32_axis1
+move_nanmax_dict[(2, NPY_float64, 0)] = move_nanmax_2d_float64_axis0
+move_nanmax_dict[(2, NPY_float64, 1)] = move_nanmax_2d_float64_axis1
+move_nanmax_dict[(3, NPY_float32, 0)] = move_nanmax_3d_float32_axis0
+move_nanmax_dict[(3, NPY_float32, 1)] = move_nanmax_3d_float32_axis1
+move_nanmax_dict[(3, NPY_float32, 2)] = move_nanmax_3d_float32_axis2
+move_nanmax_dict[(3, NPY_float64, 0)] = move_nanmax_3d_float64_axis0
+move_nanmax_dict[(3, NPY_float64, 1)] = move_nanmax_3d_float64_axis1
+move_nanmax_dict[(3, NPY_float64, 2)] = move_nanmax_3d_float64_axis2
 
 cdef dict move_nanmax_slow_dict = {}
 move_nanmax_slow_dict[0] = move_nanmax_slow_axis0
diff --git a/bottleneck/src/move/move_nanmean.pyx b/bottleneck/src/move/move_nanmean.pyx
index 75dea5b633..dee0728c80 100644
--- a/bottleneck/src/move/move_nanmean.pyx
+++ b/bottleneck/src/move/move_nanmean.pyx
@@ -86,8 +86,8 @@ def move_nanmean_selector(arr, int axis):
         a = arr
     else:    
         a = np.array(arr, copy=False)
-    cdef np.dtype dtype = a.dtype
-    cdef int ndim = a.ndim
+    cdef int ndim = PyArray_NDIM(a)
+    cdef int dtype = PyArray_TYPE(a)
     if axis < 0:
         axis += ndim
     cdef tuple key = (ndim, dtype, axis)
@@ -99,7 +99,7 @@ def move_nanmean_selector(arr, int axis):
         try:
             func = move_nanmean_slow_dict[axis]
         except KeyError:
-            tup = (str(ndim), str(dtype), str(axis))
+            tup = (str(ndim), str(a.dtype), str(axis))
             raise TypeError, "Unsupported ndim/dtype/axis (%s/%s/%s)." % tup
     return func, a
 
@@ -708,30 +708,30 @@ def move_nanmean_3d_float64_axis2(np.ndarray[np.float64_t, ndim=3] a,
     return y
 
 cdef dict move_nanmean_dict = {}
-move_nanmean_dict[(1, int32, 0)] = move_mean_1d_int32_axis0
-move_nanmean_dict[(1, int64, 0)] = move_mean_1d_int64_axis0
-move_nanmean_dict[(2, int32, 0)] = move_mean_2d_int32_axis0
-move_nanmean_dict[(2, int32, 1)] = move_mean_2d_int32_axis1
-move_nanmean_dict[(2, int64, 0)] = move_mean_2d_int64_axis0
-move_nanmean_dict[(2, int64, 1)] = move_mean_2d_int64_axis1
-move_nanmean_dict[(3, int32, 0)] = move_mean_3d_int32_axis0
-move_nanmean_dict[(3, int32, 1)] = move_mean_3d_int32_axis1
-move_nanmean_dict[(3, int32, 2)] = move_mean_3d_int32_axis2
-move_nanmean_dict[(3, int64, 0)] = move_mean_3d_int64_axis0
-move_nanmean_dict[(3, int64, 1)] = move_mean_3d_int64_axis1
-move_nanmean_dict[(3, int64, 2)] = move_mean_3d_int64_axis2
-move_nanmean_dict[(1, float32, 0)] = move_nanmean_1d_float32_axis0
-move_nanmean_dict[(1, float64, 0)] = move_nanmean_1d_float64_axis0
-move_nanmean_dict[(2, float32, 0)] = move_nanmean_2d_float32_axis0
-move_nanmean_dict[(2, float32, 1)] = move_nanmean_2d_float32_axis1
-move_nanmean_dict[(2, float64, 0)] = move_nanmean_2d_float64_axis0
-move_nanmean_dict[(2, float64, 1)] = move_nanmean_2d_float64_axis1
-move_nanmean_dict[(3, float32, 0)] = move_nanmean_3d_float32_axis0
-move_nanmean_dict[(3, float32, 1)] = move_nanmean_3d_float32_axis1
-move_nanmean_dict[(3, float32, 2)] = move_nanmean_3d_float32_axis2
-move_nanmean_dict[(3, float64, 0)] = move_nanmean_3d_float64_axis0
-move_nanmean_dict[(3, float64, 1)] = move_nanmean_3d_float64_axis1
-move_nanmean_dict[(3, float64, 2)] = move_nanmean_3d_float64_axis2
+move_nanmean_dict[(1, NPY_int32, 0)] = move_mean_1d_int32_axis0
+move_nanmean_dict[(1, NPY_int64, 0)] = move_mean_1d_int64_axis0
+move_nanmean_dict[(2, NPY_int32, 0)] = move_mean_2d_int32_axis0
+move_nanmean_dict[(2, NPY_int32, 1)] = move_mean_2d_int32_axis1
+move_nanmean_dict[(2, NPY_int64, 0)] = move_mean_2d_int64_axis0
+move_nanmean_dict[(2, NPY_int64, 1)] = move_mean_2d_int64_axis1
+move_nanmean_dict[(3, NPY_int32, 0)] = move_mean_3d_int32_axis0
+move_nanmean_dict[(3, NPY_int32, 1)] = move_mean_3d_int32_axis1
+move_nanmean_dict[(3, NPY_int32, 2)] = move_mean_3d_int32_axis2
+move_nanmean_dict[(3, NPY_int64, 0)] = move_mean_3d_int64_axis0
+move_nanmean_dict[(3, NPY_int64, 1)] = move_mean_3d_int64_axis1
+move_nanmean_dict[(3, NPY_int64, 2)] = move_mean_3d_int64_axis2
+move_nanmean_dict[(1, NPY_float32, 0)] = move_nanmean_1d_float32_axis0
+move_nanmean_dict[(1, NPY_float64, 0)] = move_nanmean_1d_float64_axis0
+move_nanmean_dict[(2, NPY_float32, 0)] = move_nanmean_2d_float32_axis0
+move_nanmean_dict[(2, NPY_float32, 1)] = move_nanmean_2d_float32_axis1
+move_nanmean_dict[(2, NPY_float64, 0)] = move_nanmean_2d_float64_axis0
+move_nanmean_dict[(2, NPY_float64, 1)] = move_nanmean_2d_float64_axis1
+move_nanmean_dict[(3, NPY_float32, 0)] = move_nanmean_3d_float32_axis0
+move_nanmean_dict[(3, NPY_float32, 1)] = move_nanmean_3d_float32_axis1
+move_nanmean_dict[(3, NPY_float32, 2)] = move_nanmean_3d_float32_axis2
+move_nanmean_dict[(3, NPY_float64, 0)] = move_nanmean_3d_float64_axis0
+move_nanmean_dict[(3, NPY_float64, 1)] = move_nanmean_3d_float64_axis1
+move_nanmean_dict[(3, NPY_float64, 2)] = move_nanmean_3d_float64_axis2
 
 cdef dict move_nanmean_slow_dict = {}
 move_nanmean_slow_dict[0] = move_nanmean_slow_axis0
diff --git a/bottleneck/src/move/move_nanmin.pyx b/bottleneck/src/move/move_nanmin.pyx
index 36234298d0..60924bd919 100644
--- a/bottleneck/src/move/move_nanmin.pyx
+++ b/bottleneck/src/move/move_nanmin.pyx
@@ -98,8 +98,8 @@ def move_nanmin_selector(arr, int axis):
         a = arr
     else:    
         a = np.array(arr, copy=False)
-    cdef np.dtype dtype = a.dtype
-    cdef int ndim = a.ndim
+    cdef int ndim = PyArray_NDIM(a)
+    cdef int dtype = PyArray_TYPE(a)
     if axis < 0:
         axis += ndim
     cdef tuple key = (ndim, dtype, axis)
@@ -111,7 +111,7 @@ def move_nanmin_selector(arr, int axis):
         try:
             func = move_nanmin_slow_dict[axis]
         except KeyError:
-            tup = (str(ndim), str(dtype), str(axis))
+            tup = (str(ndim), str(a.dtype), str(axis))
             raise TypeError, "Unsupported ndim/dtype/axis (%s/%s/%s)." % tup
     return func, a
 
@@ -990,30 +990,30 @@ def move_nanmin_3d_float64_axis2(np.ndarray[np.float64_t, ndim=3] a, int window)
     return y
 
 cdef dict move_nanmin_dict = {}
-move_nanmin_dict[(1, int32, 0)] = move_min_1d_int32_axis0
-move_nanmin_dict[(1, int64, 0)] = move_min_1d_int64_axis0
-move_nanmin_dict[(2, int32, 0)] = move_min_2d_int32_axis0
-move_nanmin_dict[(2, int32, 1)] = move_min_2d_int32_axis1
-move_nanmin_dict[(2, int64, 0)] = move_min_2d_int64_axis0
-move_nanmin_dict[(2, int64, 1)] = move_min_2d_int64_axis1
-move_nanmin_dict[(3, int32, 0)] = move_min_3d_int32_axis0
-move_nanmin_dict[(3, int32, 1)] = move_min_3d_int32_axis1
-move_nanmin_dict[(3, int32, 2)] = move_min_3d_int32_axis2
-move_nanmin_dict[(3, int64, 0)] = move_min_3d_int64_axis0
-move_nanmin_dict[(3, int64, 1)] = move_min_3d_int64_axis1
-move_nanmin_dict[(3, int64, 2)] = move_min_3d_int64_axis2
-move_nanmin_dict[(1, float32, 0)] = move_nanmin_1d_float32_axis0
-move_nanmin_dict[(1, float64, 0)] = move_nanmin_1d_float64_axis0
-move_nanmin_dict[(2, float32, 0)] = move_nanmin_2d_float32_axis0
-move_nanmin_dict[(2, float32, 1)] = move_nanmin_2d_float32_axis1
-move_nanmin_dict[(2, float64, 0)] = move_nanmin_2d_float64_axis0
-move_nanmin_dict[(2, float64, 1)] = move_nanmin_2d_float64_axis1
-move_nanmin_dict[(3, float32, 0)] = move_nanmin_3d_float32_axis0
-move_nanmin_dict[(3, float32, 1)] = move_nanmin_3d_float32_axis1
-move_nanmin_dict[(3, float32, 2)] = move_nanmin_3d_float32_axis2
-move_nanmin_dict[(3, float64, 0)] = move_nanmin_3d_float64_axis0
-move_nanmin_dict[(3, float64, 1)] = move_nanmin_3d_float64_axis1
-move_nanmin_dict[(3, float64, 2)] = move_nanmin_3d_float64_axis2
+move_nanmin_dict[(1, NPY_int32, 0)] = move_min_1d_int32_axis0
+move_nanmin_dict[(1, NPY_int64, 0)] = move_min_1d_int64_axis0
+move_nanmin_dict[(2, NPY_int32, 0)] = move_min_2d_int32_axis0
+move_nanmin_dict[(2, NPY_int32, 1)] = move_min_2d_int32_axis1
+move_nanmin_dict[(2, NPY_int64, 0)] = move_min_2d_int64_axis0
+move_nanmin_dict[(2, NPY_int64, 1)] = move_min_2d_int64_axis1
+move_nanmin_dict[(3, NPY_int32, 0)] = move_min_3d_int32_axis0
+move_nanmin_dict[(3, NPY_int32, 1)] = move_min_3d_int32_axis1
+move_nanmin_dict[(3, NPY_int32, 2)] = move_min_3d_int32_axis2
+move_nanmin_dict[(3, NPY_int64, 0)] = move_min_3d_int64_axis0
+move_nanmin_dict[(3, NPY_int64, 1)] = move_min_3d_int64_axis1
+move_nanmin_dict[(3, NPY_int64, 2)] = move_min_3d_int64_axis2
+move_nanmin_dict[(1, NPY_float32, 0)] = move_nanmin_1d_float32_axis0
+move_nanmin_dict[(1, NPY_float64, 0)] = move_nanmin_1d_float64_axis0
+move_nanmin_dict[(2, NPY_float32, 0)] = move_nanmin_2d_float32_axis0
+move_nanmin_dict[(2, NPY_float32, 1)] = move_nanmin_2d_float32_axis1
+move_nanmin_dict[(2, NPY_float64, 0)] = move_nanmin_2d_float64_axis0
+move_nanmin_dict[(2, NPY_float64, 1)] = move_nanmin_2d_float64_axis1
+move_nanmin_dict[(3, NPY_float32, 0)] = move_nanmin_3d_float32_axis0
+move_nanmin_dict[(3, NPY_float32, 1)] = move_nanmin_3d_float32_axis1
+move_nanmin_dict[(3, NPY_float32, 2)] = move_nanmin_3d_float32_axis2
+move_nanmin_dict[(3, NPY_float64, 0)] = move_nanmin_3d_float64_axis0
+move_nanmin_dict[(3, NPY_float64, 1)] = move_nanmin_3d_float64_axis1
+move_nanmin_dict[(3, NPY_float64, 2)] = move_nanmin_3d_float64_axis2
 
 cdef dict move_nanmin_slow_dict = {}
 move_nanmin_slow_dict[0] = move_nanmin_slow_axis0
diff --git a/bottleneck/src/move/move_nanstd.pyx b/bottleneck/src/move/move_nanstd.pyx
index d257d6619f..1280a41811 100644
--- a/bottleneck/src/move/move_nanstd.pyx
+++ b/bottleneck/src/move/move_nanstd.pyx
@@ -102,8 +102,8 @@ def move_nanstd_selector(arr, int axis):
         a = arr
     else:    
         a = np.array(arr, copy=False)
-    cdef np.dtype dtype = a.dtype
-    cdef int ndim = a.ndim
+    cdef int ndim = PyArray_NDIM(a)
+    cdef int dtype = PyArray_TYPE(a)
     if axis < 0:
         axis += ndim
     cdef tuple key = (ndim, dtype, axis)
@@ -115,7 +115,7 @@ def move_nanstd_selector(arr, int axis):
         try:
             func = move_nanstd_slow_dict[axis]
         except KeyError:
-            tup = (str(ndim), str(dtype), str(axis))
+            tup = (str(ndim), str(a.dtype), str(axis))
             raise TypeError, "Unsupported ndim/dtype/axis (%s/%s/%s)." % tup
     return func, a
 
@@ -782,30 +782,30 @@ def move_nanstd_3d_float64_axis2(np.ndarray[np.float64_t, ndim=3] a,
     return y
 
 cdef dict move_nanstd_dict = {}
-move_nanstd_dict[(1, int32, 0)] = move_std_1d_int32_axis0
-move_nanstd_dict[(1, int64, 0)] = move_std_1d_int64_axis0
-move_nanstd_dict[(2, int32, 0)] = move_std_2d_int32_axis0
-move_nanstd_dict[(2, int32, 1)] = move_std_2d_int32_axis1
-move_nanstd_dict[(2, int64, 0)] = move_std_2d_int64_axis0
-move_nanstd_dict[(2, int64, 1)] = move_std_2d_int64_axis1
-move_nanstd_dict[(3, int32, 0)] = move_std_3d_int32_axis0
-move_nanstd_dict[(3, int32, 1)] = move_std_3d_int32_axis1
-move_nanstd_dict[(3, int32, 2)] = move_std_3d_int32_axis2
-move_nanstd_dict[(3, int64, 0)] = move_std_3d_int64_axis0
-move_nanstd_dict[(3, int64, 1)] = move_std_3d_int64_axis1
-move_nanstd_dict[(3, int64, 2)] = move_std_3d_int64_axis2
-move_nanstd_dict[(1, float32, 0)] = move_nanstd_1d_float32_axis0
-move_nanstd_dict[(1, float64, 0)] = move_nanstd_1d_float64_axis0
-move_nanstd_dict[(2, float32, 0)] = move_nanstd_2d_float32_axis0
-move_nanstd_dict[(2, float32, 1)] = move_nanstd_2d_float32_axis1
-move_nanstd_dict[(2, float64, 0)] = move_nanstd_2d_float64_axis0
-move_nanstd_dict[(2, float64, 1)] = move_nanstd_2d_float64_axis1
-move_nanstd_dict[(3, float32, 0)] = move_nanstd_3d_float32_axis0
-move_nanstd_dict[(3, float32, 1)] = move_nanstd_3d_float32_axis1
-move_nanstd_dict[(3, float32, 2)] = move_nanstd_3d_float32_axis2
-move_nanstd_dict[(3, float64, 0)] = move_nanstd_3d_float64_axis0
-move_nanstd_dict[(3, float64, 1)] = move_nanstd_3d_float64_axis1
-move_nanstd_dict[(3, float64, 2)] = move_nanstd_3d_float64_axis2
+move_nanstd_dict[(1, NPY_int32, 0)] = move_std_1d_int32_axis0
+move_nanstd_dict[(1, NPY_int64, 0)] = move_std_1d_int64_axis0
+move_nanstd_dict[(2, NPY_int32, 0)] = move_std_2d_int32_axis0
+move_nanstd_dict[(2, NPY_int32, 1)] = move_std_2d_int32_axis1
+move_nanstd_dict[(2, NPY_int64, 0)] = move_std_2d_int64_axis0
+move_nanstd_dict[(2, NPY_int64, 1)] = move_std_2d_int64_axis1
+move_nanstd_dict[(3, NPY_int32, 0)] = move_std_3d_int32_axis0
+move_nanstd_dict[(3, NPY_int32, 1)] = move_std_3d_int32_axis1
+move_nanstd_dict[(3, NPY_int32, 2)] = move_std_3d_int32_axis2
+move_nanstd_dict[(3, NPY_int64, 0)] = move_std_3d_int64_axis0
+move_nanstd_dict[(3, NPY_int64, 1)] = move_std_3d_int64_axis1
+move_nanstd_dict[(3, NPY_int64, 2)] = move_std_3d_int64_axis2
+move_nanstd_dict[(1, NPY_float32, 0)] = move_nanstd_1d_float32_axis0
+move_nanstd_dict[(1, NPY_float64, 0)] = move_nanstd_1d_float64_axis0
+move_nanstd_dict[(2, NPY_float32, 0)] = move_nanstd_2d_float32_axis0
+move_nanstd_dict[(2, NPY_float32, 1)] = move_nanstd_2d_float32_axis1
+move_nanstd_dict[(2, NPY_float64, 0)] = move_nanstd_2d_float64_axis0
+move_nanstd_dict[(2, NPY_float64, 1)] = move_nanstd_2d_float64_axis1
+move_nanstd_dict[(3, NPY_float32, 0)] = move_nanstd_3d_float32_axis0
+move_nanstd_dict[(3, NPY_float32, 1)] = move_nanstd_3d_float32_axis1
+move_nanstd_dict[(3, NPY_float32, 2)] = move_nanstd_3d_float32_axis2
+move_nanstd_dict[(3, NPY_float64, 0)] = move_nanstd_3d_float64_axis0
+move_nanstd_dict[(3, NPY_float64, 1)] = move_nanstd_3d_float64_axis1
+move_nanstd_dict[(3, NPY_float64, 2)] = move_nanstd_3d_float64_axis2
 
 cdef dict move_nanstd_slow_dict = {}
 move_nanstd_slow_dict[0] = move_nanstd_slow_axis0
diff --git a/bottleneck/src/move/move_nansum.pyx b/bottleneck/src/move/move_nansum.pyx
index b5d1e21c5b..c0e986d85f 100644
--- a/bottleneck/src/move/move_nansum.pyx
+++ b/bottleneck/src/move/move_nansum.pyx
@@ -86,11 +86,11 @@ def move_nansum_selector(arr, int axis):
         a = arr
     else:    
         a = np.array(arr, copy=False)
-    cdef int ndim = a.ndim
-    cdef np.dtype dtype = a.dtype
-    if dtype < np.int_:
+    cdef int ndim = PyArray_NDIM(a)
+    cdef int dtype = PyArray_TYPE(a)
+    if dtype < NPY_int_:
         a = a.astype(np.int_)
-        dtype = a.dtype
+        dtype = PyArray_TYPE(a)
     if axis < 0:
         axis += ndim
     cdef tuple key = (ndim, dtype, axis)
@@ -102,7 +102,7 @@ def move_nansum_selector(arr, int axis):
         try:
             func = move_nansum_slow_dict[axis]
         except KeyError:
-            tup = (str(ndim), str(dtype), str(axis))
+            tup = (str(ndim), str(a.dtype), str(axis))
             raise TypeError, "Unsupported ndim/dtype/axis (%s/%s/%s)." % tup
     return func, a
 
@@ -711,30 +711,30 @@ def move_nansum_3d_float64_axis2(np.ndarray[np.float64_t, ndim=3] a,
     return y
 
 cdef dict move_nansum_dict = {}
-move_nansum_dict[(1, int32, 0)] = move_sum_1d_int32_axis0
-move_nansum_dict[(1, int64, 0)] = move_sum_1d_int64_axis0
-move_nansum_dict[(2, int32, 0)] = move_sum_2d_int32_axis0
-move_nansum_dict[(2, int32, 1)] = move_sum_2d_int32_axis1
-move_nansum_dict[(2, int64, 0)] = move_sum_2d_int64_axis0
-move_nansum_dict[(2, int64, 1)] = move_sum_2d_int64_axis1
-move_nansum_dict[(3, int32, 0)] = move_sum_3d_int32_axis0
-move_nansum_dict[(3, int32, 1)] = move_sum_3d_int32_axis1
-move_nansum_dict[(3, int32, 2)] = move_sum_3d_int32_axis2
-move_nansum_dict[(3, int64, 0)] = move_sum_3d_int64_axis0
-move_nansum_dict[(3, int64, 1)] = move_sum_3d_int64_axis1
-move_nansum_dict[(3, int64, 2)] = move_sum_3d_int64_axis2
-move_nansum_dict[(1, float32, 0)] = move_nansum_1d_float32_axis0
-move_nansum_dict[(1, float64, 0)] = move_nansum_1d_float64_axis0
-move_nansum_dict[(2, float32, 0)] = move_nansum_2d_float32_axis0
-move_nansum_dict[(2, float32, 1)] = move_nansum_2d_float32_axis1
-move_nansum_dict[(2, float64, 0)] = move_nansum_2d_float64_axis0
-move_nansum_dict[(2, float64, 1)] = move_nansum_2d_float64_axis1
-move_nansum_dict[(3, float32, 0)] = move_nansum_3d_float32_axis0
-move_nansum_dict[(3, float32, 1)] = move_nansum_3d_float32_axis1
-move_nansum_dict[(3, float32, 2)] = move_nansum_3d_float32_axis2
-move_nansum_dict[(3, float64, 0)] = move_nansum_3d_float64_axis0
-move_nansum_dict[(3, float64, 1)] = move_nansum_3d_float64_axis1
-move_nansum_dict[(3, float64, 2)] = move_nansum_3d_float64_axis2
+move_nansum_dict[(1, NPY_int32, 0)] = move_sum_1d_int32_axis0
+move_nansum_dict[(1, NPY_int64, 0)] = move_sum_1d_int64_axis0
+move_nansum_dict[(2, NPY_int32, 0)] = move_sum_2d_int32_axis0
+move_nansum_dict[(2, NPY_int32, 1)] = move_sum_2d_int32_axis1
+move_nansum_dict[(2, NPY_int64, 0)] = move_sum_2d_int64_axis0
+move_nansum_dict[(2, NPY_int64, 1)] = move_sum_2d_int64_axis1
+move_nansum_dict[(3, NPY_int32, 0)] = move_sum_3d_int32_axis0
+move_nansum_dict[(3, NPY_int32, 1)] = move_sum_3d_int32_axis1
+move_nansum_dict[(3, NPY_int32, 2)] = move_sum_3d_int32_axis2
+move_nansum_dict[(3, NPY_int64, 0)] = move_sum_3d_int64_axis0
+move_nansum_dict[(3, NPY_int64, 1)] = move_sum_3d_int64_axis1
+move_nansum_dict[(3, NPY_int64, 2)] = move_sum_3d_int64_axis2
+move_nansum_dict[(1, NPY_float32, 0)] = move_nansum_1d_float32_axis0
+move_nansum_dict[(1, NPY_float64, 0)] = move_nansum_1d_float64_axis0
+move_nansum_dict[(2, NPY_float32, 0)] = move_nansum_2d_float32_axis0
+move_nansum_dict[(2, NPY_float32, 1)] = move_nansum_2d_float32_axis1
+move_nansum_dict[(2, NPY_float64, 0)] = move_nansum_2d_float64_axis0
+move_nansum_dict[(2, NPY_float64, 1)] = move_nansum_2d_float64_axis1
+move_nansum_dict[(3, NPY_float32, 0)] = move_nansum_3d_float32_axis0
+move_nansum_dict[(3, NPY_float32, 1)] = move_nansum_3d_float32_axis1
+move_nansum_dict[(3, NPY_float32, 2)] = move_nansum_3d_float32_axis2
+move_nansum_dict[(3, NPY_float64, 0)] = move_nansum_3d_float64_axis0
+move_nansum_dict[(3, NPY_float64, 1)] = move_nansum_3d_float64_axis1
+move_nansum_dict[(3, NPY_float64, 2)] = move_nansum_3d_float64_axis2
 
 cdef dict move_nansum_slow_dict = {}
 move_nansum_slow_dict[0] = move_nansum_slow_axis0
diff --git a/bottleneck/src/move/move_std.pyx b/bottleneck/src/move/move_std.pyx
index 66554b7d0c..bd80b30e31 100644
--- a/bottleneck/src/move/move_std.pyx
+++ b/bottleneck/src/move/move_std.pyx
@@ -102,8 +102,8 @@ def move_std_selector(arr, int axis):
         a = arr
     else:    
         a = np.array(arr, copy=False)
-    cdef np.dtype dtype = a.dtype
-    cdef int ndim = a.ndim
+    cdef int ndim = PyArray_NDIM(a)
+    cdef int dtype = PyArray_TYPE(a)
     if axis < 0:
         axis += ndim
     cdef tuple key = (ndim, dtype, axis)
@@ -115,7 +115,7 @@ def move_std_selector(arr, int axis):
         try:
             func = move_std_slow_dict[axis]
         except KeyError:
-            tup = (str(ndim), str(dtype), str(axis))
+            tup = (str(ndim), str(a.dtype), str(axis))
             raise TypeError, "Unsupported ndim/dtype/axis (%s/%s/%s)." % tup
     return func, a
 
@@ -1290,30 +1290,30 @@ def move_std_3d_float64_axis2(np.ndarray[np.float64_t, ndim=3] a,
     return y
 
 cdef dict move_std_dict = {}
-move_std_dict[(1, int32, 0)] = move_std_1d_int32_axis0
-move_std_dict[(1, int64, 0)] = move_std_1d_int64_axis0
-move_std_dict[(2, int32, 0)] = move_std_2d_int32_axis0
-move_std_dict[(2, int32, 1)] = move_std_2d_int32_axis1
-move_std_dict[(2, int64, 0)] = move_std_2d_int64_axis0
-move_std_dict[(2, int64, 1)] = move_std_2d_int64_axis1
-move_std_dict[(3, int32, 0)] = move_std_3d_int32_axis0
-move_std_dict[(3, int32, 1)] = move_std_3d_int32_axis1
-move_std_dict[(3, int32, 2)] = move_std_3d_int32_axis2
-move_std_dict[(3, int64, 0)] = move_std_3d_int64_axis0
-move_std_dict[(3, int64, 1)] = move_std_3d_int64_axis1
-move_std_dict[(3, int64, 2)] = move_std_3d_int64_axis2
-move_std_dict[(1, float32, 0)] = move_std_1d_float32_axis0
-move_std_dict[(1, float64, 0)] = move_std_1d_float64_axis0
-move_std_dict[(2, float32, 0)] = move_std_2d_float32_axis0
-move_std_dict[(2, float32, 1)] = move_std_2d_float32_axis1
-move_std_dict[(2, float64, 0)] = move_std_2d_float64_axis0
-move_std_dict[(2, float64, 1)] = move_std_2d_float64_axis1
-move_std_dict[(3, float32, 0)] = move_std_3d_float32_axis0
-move_std_dict[(3, float32, 1)] = move_std_3d_float32_axis1
-move_std_dict[(3, float32, 2)] = move_std_3d_float32_axis2
-move_std_dict[(3, float64, 0)] = move_std_3d_float64_axis0
-move_std_dict[(3, float64, 1)] = move_std_3d_float64_axis1
-move_std_dict[(3, float64, 2)] = move_std_3d_float64_axis2
+move_std_dict[(1, NPY_int32, 0)] = move_std_1d_int32_axis0
+move_std_dict[(1, NPY_int64, 0)] = move_std_1d_int64_axis0
+move_std_dict[(2, NPY_int32, 0)] = move_std_2d_int32_axis0
+move_std_dict[(2, NPY_int32, 1)] = move_std_2d_int32_axis1
+move_std_dict[(2, NPY_int64, 0)] = move_std_2d_int64_axis0
+move_std_dict[(2, NPY_int64, 1)] = move_std_2d_int64_axis1
+move_std_dict[(3, NPY_int32, 0)] = move_std_3d_int32_axis0
+move_std_dict[(3, NPY_int32, 1)] = move_std_3d_int32_axis1
+move_std_dict[(3, NPY_int32, 2)] = move_std_3d_int32_axis2
+move_std_dict[(3, NPY_int64, 0)] = move_std_3d_int64_axis0
+move_std_dict[(3, NPY_int64, 1)] = move_std_3d_int64_axis1
+move_std_dict[(3, NPY_int64, 2)] = move_std_3d_int64_axis2
+move_std_dict[(1, NPY_float32, 0)] = move_std_1d_float32_axis0
+move_std_dict[(1, NPY_float64, 0)] = move_std_1d_float64_axis0
+move_std_dict[(2, NPY_float32, 0)] = move_std_2d_float32_axis0
+move_std_dict[(2, NPY_float32, 1)] = move_std_2d_float32_axis1
+move_std_dict[(2, NPY_float64, 0)] = move_std_2d_float64_axis0
+move_std_dict[(2, NPY_float64, 1)] = move_std_2d_float64_axis1
+move_std_dict[(3, NPY_float32, 0)] = move_std_3d_float32_axis0
+move_std_dict[(3, NPY_float32, 1)] = move_std_3d_float32_axis1
+move_std_dict[(3, NPY_float32, 2)] = move_std_3d_float32_axis2
+move_std_dict[(3, NPY_float64, 0)] = move_std_3d_float64_axis0
+move_std_dict[(3, NPY_float64, 1)] = move_std_3d_float64_axis1
+move_std_dict[(3, NPY_float64, 2)] = move_std_3d_float64_axis2
 
 cdef dict move_std_slow_dict = {}
 move_std_slow_dict[0] = move_std_slow_axis0
diff --git a/bottleneck/src/move/move_sum.pyx b/bottleneck/src/move/move_sum.pyx
index 9ee1cbcbd0..4b0b746d19 100644
--- a/bottleneck/src/move/move_sum.pyx
+++ b/bottleneck/src/move/move_sum.pyx
@@ -86,11 +86,11 @@ def move_sum_selector(arr, int axis):
         a = arr
     else:    
         a = np.array(arr, copy=False)
-    cdef int ndim = a.ndim
-    cdef np.dtype dtype = a.dtype
-    if dtype < np.int_:
+    cdef int ndim = PyArray_NDIM(a)
+    cdef int dtype = PyArray_TYPE(a)
+    if dtype < NPY_int_:
         a = a.astype(np.int_)
-        dtype = a.dtype
+        dtype = PyArray_TYPE(a)
     if axis < 0:
         axis += ndim
     cdef tuple key = (ndim, dtype, axis)
@@ -102,7 +102,7 @@ def move_sum_selector(arr, int axis):
         try:
             func = move_sum_slow_dict[axis]
         except KeyError:
-            tup = (str(ndim), str(dtype), str(axis))
+            tup = (str(ndim), str(a.dtype), str(axis))
             raise TypeError, "Unsupported ndim/dtype/axis (%s/%s/%s)." % tup
     return func, a
 
@@ -1101,30 +1101,30 @@ def move_sum_3d_float64_axis2(np.ndarray[np.float64_t, ndim=3] a,
     return y
 
 cdef dict move_sum_dict = {}
-move_sum_dict[(1, int32, 0)] = move_sum_1d_int32_axis0
-move_sum_dict[(1, int64, 0)] = move_sum_1d_int64_axis0
-move_sum_dict[(2, int32, 0)] = move_sum_2d_int32_axis0
-move_sum_dict[(2, int32, 1)] = move_sum_2d_int32_axis1
-move_sum_dict[(2, int64, 0)] = move_sum_2d_int64_axis0
-move_sum_dict[(2, int64, 1)] = move_sum_2d_int64_axis1
-move_sum_dict[(3, int32, 0)] = move_sum_3d_int32_axis0
-move_sum_dict[(3, int32, 1)] = move_sum_3d_int32_axis1
-move_sum_dict[(3, int32, 2)] = move_sum_3d_int32_axis2
-move_sum_dict[(3, int64, 0)] = move_sum_3d_int64_axis0
-move_sum_dict[(3, int64, 1)] = move_sum_3d_int64_axis1
-move_sum_dict[(3, int64, 2)] = move_sum_3d_int64_axis2
-move_sum_dict[(1, float32, 0)] = move_sum_1d_float32_axis0
-move_sum_dict[(1, float64, 0)] = move_sum_1d_float64_axis0
-move_sum_dict[(2, float32, 0)] = move_sum_2d_float32_axis0
-move_sum_dict[(2, float32, 1)] = move_sum_2d_float32_axis1
-move_sum_dict[(2, float64, 0)] = move_sum_2d_float64_axis0
-move_sum_dict[(2, float64, 1)] = move_sum_2d_float64_axis1
-move_sum_dict[(3, float32, 0)] = move_sum_3d_float32_axis0
-move_sum_dict[(3, float32, 1)] = move_sum_3d_float32_axis1
-move_sum_dict[(3, float32, 2)] = move_sum_3d_float32_axis2
-move_sum_dict[(3, float64, 0)] = move_sum_3d_float64_axis0
-move_sum_dict[(3, float64, 1)] = move_sum_3d_float64_axis1
-move_sum_dict[(3, float64, 2)] = move_sum_3d_float64_axis2
+move_sum_dict[(1, NPY_int32, 0)] = move_sum_1d_int32_axis0
+move_sum_dict[(1, NPY_int64, 0)] = move_sum_1d_int64_axis0
+move_sum_dict[(2, NPY_int32, 0)] = move_sum_2d_int32_axis0
+move_sum_dict[(2, NPY_int32, 1)] = move_sum_2d_int32_axis1
+move_sum_dict[(2, NPY_int64, 0)] = move_sum_2d_int64_axis0
+move_sum_dict[(2, NPY_int64, 1)] = move_sum_2d_int64_axis1
+move_sum_dict[(3, NPY_int32, 0)] = move_sum_3d_int32_axis0
+move_sum_dict[(3, NPY_int32, 1)] = move_sum_3d_int32_axis1
+move_sum_dict[(3, NPY_int32, 2)] = move_sum_3d_int32_axis2
+move_sum_dict[(3, NPY_int64, 0)] = move_sum_3d_int64_axis0
+move_sum_dict[(3, NPY_int64, 1)] = move_sum_3d_int64_axis1
+move_sum_dict[(3, NPY_int64, 2)] = move_sum_3d_int64_axis2
+move_sum_dict[(1, NPY_float32, 0)] = move_sum_1d_float32_axis0
+move_sum_dict[(1, NPY_float64, 0)] = move_sum_1d_float64_axis0
+move_sum_dict[(2, NPY_float32, 0)] = move_sum_2d_float32_axis0
+move_sum_dict[(2, NPY_float32, 1)] = move_sum_2d_float32_axis1
+move_sum_dict[(2, NPY_float64, 0)] = move_sum_2d_float64_axis0
+move_sum_dict[(2, NPY_float64, 1)] = move_sum_2d_float64_axis1
+move_sum_dict[(3, NPY_float32, 0)] = move_sum_3d_float32_axis0
+move_sum_dict[(3, NPY_float32, 1)] = move_sum_3d_float32_axis1
+move_sum_dict[(3, NPY_float32, 2)] = move_sum_3d_float32_axis2
+move_sum_dict[(3, NPY_float64, 0)] = move_sum_3d_float64_axis0
+move_sum_dict[(3, NPY_float64, 1)] = move_sum_3d_float64_axis1
+move_sum_dict[(3, NPY_float64, 2)] = move_sum_3d_float64_axis2
 
 cdef dict move_sum_slow_dict = {}
 move_sum_slow_dict[0] = move_sum_slow_axis0
diff --git a/bottleneck/src/template/func/median.py b/bottleneck/src/template/func/median.py
index a71885e05c..f9dec047d5 100644
--- a/bottleneck/src/template/func/median.py
+++ b/bottleneck/src/template/func/median.py
@@ -277,8 +277,8 @@ def median_selector(arr, axis):
     else:    
         a = np.array(arr, copy=False)
     cdef tuple key
-    cdef int ndim = a.ndim
-    cdef np.dtype dtype = a.dtype
+    cdef int ndim = PyArray_NDIM(a)
+    cdef int dtype = PyArray_TYPE(a)
     if axis is not None:
         if axis < 0:
             axis += ndim
@@ -295,7 +295,7 @@ def median_selector(arr, axis):
         try:
             func = median_slow_dict[axis]
         except KeyError:
-            tup = (str(ndim), str(dtype), str(axis))
+            tup = (str(ndim), str(a.dtype), str(axis))
             raise TypeError, "Unsupported ndim/dtype/axis (%s/%s/%s)." % tup
     return func, a
 '''   
diff --git a/bottleneck/src/template/func/nanargmax.py b/bottleneck/src/template/func/nanargmax.py
index 490e358d6a..4e2986db2a 100644
--- a/bottleneck/src/template/func/nanargmax.py
+++ b/bottleneck/src/template/func/nanargmax.py
@@ -235,9 +235,9 @@ def nanargmax_selector(arr, axis):
         a = arr
     else:    
         a = np.array(arr, copy=False)
-    cdef int ndim = a.ndim
-    cdef np.dtype dtype = a.dtype
-    cdef int size = a.size
+    cdef int ndim = PyArray_NDIM(a)
+    cdef int dtype = PyArray_TYPE(a)
+    cdef int size = PyArray_SIZE(a)
     if size == 0:
         msg = "numpy.nanargmax() raises on size=0; so Bottleneck does too." 
         raise ValueError, msg
@@ -257,7 +257,7 @@ def nanargmax_selector(arr, axis):
         try:
             func = nanargmax_slow_dict[axis]
         except KeyError:
-            tup = (str(ndim), str(dtype), str(axis))
+            tup = (str(ndim), str(a.dtype), str(axis))
             raise TypeError, "Unsupported ndim/dtype/axis (%s/%s/%s)." % tup
     return func, a
 '''
diff --git a/bottleneck/src/template/func/nanargmin.py b/bottleneck/src/template/func/nanargmin.py
index e1618a66c2..a456881677 100644
--- a/bottleneck/src/template/func/nanargmin.py
+++ b/bottleneck/src/template/func/nanargmin.py
@@ -235,9 +235,9 @@ def nanargmin_selector(arr, axis):
         a = arr
     else:    
         a = np.array(arr, copy=False)
-    cdef int ndim = a.ndim
-    cdef np.dtype dtype = a.dtype
-    cdef int size = a.size
+    cdef int ndim = PyArray_NDIM(a)
+    cdef int dtype = PyArray_TYPE(a)
+    cdef int size = PyArray_SIZE(a)
     if size == 0:
         msg = "numpy.nanargmin() raises on size=0; so Bottleneck does too." 
         raise ValueError, msg
@@ -257,7 +257,7 @@ def nanargmin_selector(arr, axis):
         try:
             func = nanargmin_slow_dict[axis]
         except KeyError:
-            tup = (str(ndim), str(dtype), str(axis))
+            tup = (str(ndim), str(a.dtype), str(axis))
             raise TypeError, "Unsupported ndim/dtype/axis (%s/%s/%s)." % tup
     return func, a
 '''
diff --git a/bottleneck/src/template/func/nanmax.py b/bottleneck/src/template/func/nanmax.py
index 19508c706a..07132ffce2 100644
--- a/bottleneck/src/template/func/nanmax.py
+++ b/bottleneck/src/template/func/nanmax.py
@@ -293,9 +293,9 @@ def nanmax_selector(arr, axis):
         a = arr
     else:    
         a = np.array(arr, copy=False)
-    cdef int ndim = a.ndim
-    cdef np.dtype dtype = a.dtype
-    cdef int size = a.size
+    cdef int ndim = PyArray_NDIM(a)
+    cdef int dtype = PyArray_TYPE(a)
+    cdef int size = PyArray_SIZE(a)
     if size == 0:
         msg = "numpy.nanmax() raises on size=0 input; so Bottleneck does too." 
         raise ValueError, msg
@@ -311,7 +311,7 @@ def nanmax_selector(arr, axis):
         try:
             func = nanmax_slow_dict[axis]
         except KeyError:
-            tup = (str(ndim), str(dtype), str(axis))
+            tup = (str(ndim), str(a.dtype), str(axis))
             raise TypeError, "Unsupported ndim/dtype/axis (%s/%s/%s)." % tup
     return func, a
 '''
diff --git a/bottleneck/src/template/func/nanmean.py b/bottleneck/src/template/func/nanmean.py
index 58827c3a53..552fff0f81 100644
--- a/bottleneck/src/template/func/nanmean.py
+++ b/bottleneck/src/template/func/nanmean.py
@@ -300,8 +300,8 @@ def nanmean_selector(arr, axis):
         a = arr
     else:    
         a = np.array(arr, copy=False)
-    cdef int ndim = a.ndim
-    cdef np.dtype dtype = a.dtype
+    cdef int ndim = PyArray_NDIM(a)
+    cdef int dtype = PyArray_TYPE(a)
     if (axis < 0) and (axis is not None):
         axis += ndim
     cdef tuple key = (ndim, dtype, axis)
@@ -314,7 +314,7 @@ def nanmean_selector(arr, axis):
         try:
             func = nanmean_slow_dict[axis]
         except KeyError:
-            tup = (str(ndim), str(dtype), str(axis))
+            tup = (str(ndim), str(a.dtype), str(axis))
             raise TypeError, "Unsupported ndim/dtype/axis (%s/%s/%s)." % tup
     return func, a
 '''   
diff --git a/bottleneck/src/template/func/nanmedian.py b/bottleneck/src/template/func/nanmedian.py
index 2d1bdbdcb1..685bda86fb 100644
--- a/bottleneck/src/template/func/nanmedian.py
+++ b/bottleneck/src/template/func/nanmedian.py
@@ -334,8 +334,8 @@ def nanmedian_selector(arr, axis):
     else:    
         a = np.array(arr, copy=False)
     cdef tuple key
-    cdef int ndim = a.ndim
-    cdef np.dtype dtype = a.dtype
+    cdef int ndim = PyArray_NDIM(a)
+    cdef int dtype = PyArray_TYPE(a)
     if axis is not None:
         if axis < 0:
             axis += ndim
@@ -352,7 +352,7 @@ def nanmedian_selector(arr, axis):
         try:
             func = nanmedian_slow_dict[axis]
         except KeyError:
-            tup = (str(ndim), str(dtype), str(axis))
+            tup = (str(ndim), str(a.dtype), str(axis))
             raise TypeError, "Unsupported ndim/dtype/axis (%s/%s/%s)." % tup
     return func, a
 '''   
diff --git a/bottleneck/src/template/func/nanmin.py b/bottleneck/src/template/func/nanmin.py
index d90d67a39a..f1373face5 100644
--- a/bottleneck/src/template/func/nanmin.py
+++ b/bottleneck/src/template/func/nanmin.py
@@ -293,9 +293,9 @@ def nanmin_selector(arr, axis):
         a = arr
     else:    
         a = np.array(arr, copy=False)
-    cdef int ndim = a.ndim
-    cdef np.dtype dtype = a.dtype
-    cdef int size = a.size
+    cdef int ndim = PyArray_NDIM(a)
+    cdef int dtype = PyArray_TYPE(a)
+    cdef int size = PyArray_SIZE(a)
     if size == 0:
         msg = "numpy.nanmin() raises on size=0 input; so Bottleneck does too." 
         raise ValueError, msg
@@ -311,7 +311,7 @@ def nanmin_selector(arr, axis):
         try:
             func = nanmin_slow_dict[axis]
         except KeyError:
-            tup = (str(ndim), str(dtype), str(axis))
+            tup = (str(ndim), str(a.dtype), str(axis))
             raise TypeError, "Unsupported ndim/dtype/axis (%s/%s/%s)." % tup
     return func, a
 '''   
diff --git a/bottleneck/src/template/func/nanstd.py b/bottleneck/src/template/func/nanstd.py
index 5608b3f2fd..781e53db0c 100644
--- a/bottleneck/src/template/func/nanstd.py
+++ b/bottleneck/src/template/func/nanstd.py
@@ -389,8 +389,8 @@ def nanstd_selector(arr, axis):
         a = arr
     else:    
         a = np.array(arr, copy=False)
-    cdef int ndim = a.ndim
-    cdef np.dtype dtype = a.dtype
+    cdef int ndim = PyArray_NDIM(a)
+    cdef int dtype = PyArray_TYPE(a)
     if (axis < 0) and (axis is not None):
         axis += ndim
     cdef tuple key = (ndim, dtype, axis)
@@ -403,7 +403,7 @@ def nanstd_selector(arr, axis):
         try:
             func = nanstd_slow_dict[axis]
         except KeyError:
-            tup = (str(ndim), str(dtype), str(axis))
+            tup = (str(ndim), str(a.dtype), str(axis))
             raise TypeError, "Unsupported ndim/dtype/axis (%s/%s/%s)." % tup
     return func, a
 '''   
diff --git a/bottleneck/src/template/func/nansum.py b/bottleneck/src/template/func/nansum.py
index d781f02659..695f67d108 100644
--- a/bottleneck/src/template/func/nansum.py
+++ b/bottleneck/src/template/func/nansum.py
@@ -296,11 +296,11 @@ def nansum_selector(arr, axis):
         a = arr
     else:    
         a = np.array(arr, copy=False)
-    cdef int ndim = a.ndim
-    cdef np.dtype dtype = a.dtype
-    if dtype < np.int_:
+    cdef int ndim = PyArray_NDIM(a)
+    cdef int dtype = PyArray_TYPE(a)
+    if dtype < NPY_int_:
         a = a.astype(np.int_)
-        dtype = a.dtype
+        dtype = PyArray_TYPE(a)
     if (axis < 0) and (axis is not None):
         axis += ndim
     cdef tuple key = (ndim, dtype, axis)
@@ -313,7 +313,7 @@ def nansum_selector(arr, axis):
         try:
             func = nansum_slow_dict[axis]
         except KeyError:
-            tup = (str(ndim), str(dtype), str(axis))
+            tup = (str(ndim), str(a.dtype), str(axis))
             raise TypeError, "Unsupported ndim/dtype/axis (%s/%s/%s)." % tup
     return func, a
 '''   
diff --git a/bottleneck/src/template/func/nanvar.py b/bottleneck/src/template/func/nanvar.py
index 17099f3c65..fb323cf141 100644
--- a/bottleneck/src/template/func/nanvar.py
+++ b/bottleneck/src/template/func/nanvar.py
@@ -388,8 +388,8 @@ def nanvar_selector(arr, axis):
         a = arr
     else:    
         a = np.array(arr, copy=False)
-    cdef int ndim = a.ndim
-    cdef np.dtype dtype = a.dtype
+    cdef int ndim = PyArray_NDIM(a)
+    cdef int dtype = PyArray_TYPE(a)
     if (axis < 0) and (axis is not None):
         axis += ndim
     cdef tuple key = (ndim, dtype, axis)
@@ -402,7 +402,7 @@ def nanvar_selector(arr, axis):
         try:
             func = nanvar_slow_dict[axis]
         except KeyError:
-            tup = (str(ndim), str(dtype), str(axis))
+            tup = (str(ndim), str(a.dtype), str(axis))
             raise TypeError, "Unsupported ndim/dtype/axis (%s/%s/%s)." % tup
     return func, a
 '''   
diff --git a/bottleneck/src/template/group/group_nanmean.py b/bottleneck/src/template/group/group_nanmean.py
index e4b444b082..192936a531 100644
--- a/bottleneck/src/template/group/group_nanmean.py
+++ b/bottleneck/src/template/group/group_nanmean.py
@@ -324,8 +324,8 @@ def group_nanmean_selector(arr, label, order=None, int axis=0):
         a = arr
     else:    
         a = np.array(arr, copy=False)
-    cdef int ndim = a.ndim
-    cdef np.dtype dtype = a.dtype
+    cdef int ndim = PyArray_NDIM(a)
+    cdef int dtype = PyArray_TYPE(a)
     if axis < 0:
        axis += ndim
     cdef int narr = a.shape[axis], nlabel = len(label)
@@ -339,7 +339,7 @@ def group_nanmean_selector(arr, label, order=None, int axis=0):
     except KeyError:
         if (axis < 0) or (axis >= ndim):
             raise ValueError("axis(=%d) out of bounds" % axis)
-        tup = (str(ndim), str(dtype))
+        tup = (str(ndim), str(a.dtype))
         raise TypeError("Unsupported ndim/dtype (%s/%s)." % tup)
     label_dict, order = group_mapper(label, order)
     return func, a, label_dict, order
diff --git a/bottleneck/src/template/move/move_max.py b/bottleneck/src/template/move/move_max.py
index 4cb597720e..0e1b3527e6 100644
--- a/bottleneck/src/template/move/move_max.py
+++ b/bottleneck/src/template/move/move_max.py
@@ -332,8 +332,8 @@ def move_max_selector(arr, int axis):
         a = arr
     else:    
         a = np.array(arr, copy=False)
-    cdef np.dtype dtype = a.dtype
-    cdef int ndim = a.ndim
+    cdef int ndim = PyArray_NDIM(a)
+    cdef int dtype = PyArray_TYPE(a)
     if axis < 0:
         axis += ndim
     cdef tuple key = (ndim, dtype, axis)
@@ -345,7 +345,7 @@ def move_max_selector(arr, int axis):
         try:
             func = move_max_slow_dict[axis]
         except KeyError:
-            tup = (str(ndim), str(dtype), str(axis))
+            tup = (str(ndim), str(a.dtype), str(axis))
             raise TypeError, "Unsupported ndim/dtype/axis (%s/%s/%s)." % tup
     return func, a
 '''   
diff --git a/bottleneck/src/template/move/move_mean.py b/bottleneck/src/template/move/move_mean.py
index 769c696c99..c4fb0409f3 100644
--- a/bottleneck/src/template/move/move_mean.py
+++ b/bottleneck/src/template/move/move_mean.py
@@ -319,8 +319,8 @@ def move_mean_selector(arr, int axis):
         a = arr
     else:    
         a = np.array(arr, copy=False)
-    cdef np.dtype dtype = a.dtype
-    cdef int ndim = a.ndim
+    cdef int ndim = PyArray_NDIM(a)
+    cdef int dtype = PyArray_TYPE(a)
     if axis < 0:
         axis += ndim
     cdef tuple key = (ndim, dtype, axis)
@@ -332,7 +332,7 @@ def move_mean_selector(arr, int axis):
         try:
             func = move_mean_slow_dict[axis]
         except KeyError:
-            tup = (str(ndim), str(dtype), str(axis))
+            tup = (str(ndim), str(a.dtype), str(axis))
             raise TypeError, "Unsupported ndim/dtype/axis (%s/%s/%s)." % tup
     return func, a
 '''   
diff --git a/bottleneck/src/template/move/move_min.py b/bottleneck/src/template/move/move_min.py
index 30c9cd7c88..fbbb13fcc6 100644
--- a/bottleneck/src/template/move/move_min.py
+++ b/bottleneck/src/template/move/move_min.py
@@ -332,8 +332,8 @@ def move_min_selector(arr, int axis):
         a = arr
     else:    
         a = np.array(arr, copy=False)
-    cdef np.dtype dtype = a.dtype
-    cdef int ndim = a.ndim
+    cdef int ndim = PyArray_NDIM(a)
+    cdef int dtype = PyArray_TYPE(a)
     if axis < 0:
         axis += ndim
     cdef tuple key = (ndim, dtype, axis)
@@ -345,7 +345,7 @@ def move_min_selector(arr, int axis):
         try:
             func = move_min_slow_dict[axis]
         except KeyError:
-            tup = (str(ndim), str(dtype), str(axis))
+            tup = (str(ndim), str(a.dtype), str(axis))
             raise TypeError, "Unsupported ndim/dtype/axis (%s/%s/%s)." % tup
     return func, a
 '''   
diff --git a/bottleneck/src/template/move/move_nanmax.py b/bottleneck/src/template/move/move_nanmax.py
index a666dfdbff..c0d17f3ebf 100644
--- a/bottleneck/src/template/move/move_nanmax.py
+++ b/bottleneck/src/template/move/move_nanmax.py
@@ -331,8 +331,8 @@ def move_nanmax_selector(arr, int axis):
         a = arr
     else:    
         a = np.array(arr, copy=False)
-    cdef np.dtype dtype = a.dtype
-    cdef int ndim = a.ndim
+    cdef int ndim = PyArray_NDIM(a)
+    cdef int dtype = PyArray_TYPE(a)
     if axis < 0:
         axis += ndim
     cdef tuple key = (ndim, dtype, axis)
@@ -344,7 +344,7 @@ def move_nanmax_selector(arr, int axis):
         try:
             func = move_nanmax_slow_dict[axis]
         except KeyError:
-            tup = (str(ndim), str(dtype), str(axis))
+            tup = (str(ndim), str(a.dtype), str(axis))
             raise TypeError, "Unsupported ndim/dtype/axis (%s/%s/%s)." % tup
     return func, a
 '''   
diff --git a/bottleneck/src/template/move/move_nanmean.py b/bottleneck/src/template/move/move_nanmean.py
index 623780f268..efedda0f1b 100644
--- a/bottleneck/src/template/move/move_nanmean.py
+++ b/bottleneck/src/template/move/move_nanmean.py
@@ -256,8 +256,8 @@ def move_nanmean_selector(arr, int axis):
         a = arr
     else:    
         a = np.array(arr, copy=False)
-    cdef np.dtype dtype = a.dtype
-    cdef int ndim = a.ndim
+    cdef int ndim = PyArray_NDIM(a)
+    cdef int dtype = PyArray_TYPE(a)
     if axis < 0:
         axis += ndim
     cdef tuple key = (ndim, dtype, axis)
@@ -269,7 +269,7 @@ def move_nanmean_selector(arr, int axis):
         try:
             func = move_nanmean_slow_dict[axis]
         except KeyError:
-            tup = (str(ndim), str(dtype), str(axis))
+            tup = (str(ndim), str(a.dtype), str(axis))
             raise TypeError, "Unsupported ndim/dtype/axis (%s/%s/%s)." % tup
     return func, a
 '''   
diff --git a/bottleneck/src/template/move/move_nanmin.py b/bottleneck/src/template/move/move_nanmin.py
index a55eaeb0ca..7a5ef4317f 100644
--- a/bottleneck/src/template/move/move_nanmin.py
+++ b/bottleneck/src/template/move/move_nanmin.py
@@ -331,8 +331,8 @@ def move_nanmin_selector(arr, int axis):
         a = arr
     else:    
         a = np.array(arr, copy=False)
-    cdef np.dtype dtype = a.dtype
-    cdef int ndim = a.ndim
+    cdef int ndim = PyArray_NDIM(a)
+    cdef int dtype = PyArray_TYPE(a)
     if axis < 0:
         axis += ndim
     cdef tuple key = (ndim, dtype, axis)
@@ -344,7 +344,7 @@ def move_nanmin_selector(arr, int axis):
         try:
             func = move_nanmin_slow_dict[axis]
         except KeyError:
-            tup = (str(ndim), str(dtype), str(axis))
+            tup = (str(ndim), str(a.dtype), str(axis))
             raise TypeError, "Unsupported ndim/dtype/axis (%s/%s/%s)." % tup
     return func, a
 '''   
diff --git a/bottleneck/src/template/move/move_nanstd.py b/bottleneck/src/template/move/move_nanstd.py
index d1a2171149..0b0790e963 100644
--- a/bottleneck/src/template/move/move_nanstd.py
+++ b/bottleneck/src/template/move/move_nanstd.py
@@ -289,8 +289,8 @@ def move_nanstd_selector(arr, int axis):
         a = arr
     else:    
         a = np.array(arr, copy=False)
-    cdef np.dtype dtype = a.dtype
-    cdef int ndim = a.ndim
+    cdef int ndim = PyArray_NDIM(a)
+    cdef int dtype = PyArray_TYPE(a)
     if axis < 0:
         axis += ndim
     cdef tuple key = (ndim, dtype, axis)
@@ -302,7 +302,7 @@ def move_nanstd_selector(arr, int axis):
         try:
             func = move_nanstd_slow_dict[axis]
         except KeyError:
-            tup = (str(ndim), str(dtype), str(axis))
+            tup = (str(ndim), str(a.dtype), str(axis))
             raise TypeError, "Unsupported ndim/dtype/axis (%s/%s/%s)." % tup
     return func, a
 '''   
diff --git a/bottleneck/src/template/move/move_nansum.py b/bottleneck/src/template/move/move_nansum.py
index 41d9c3b437..bcd87b1b89 100644
--- a/bottleneck/src/template/move/move_nansum.py
+++ b/bottleneck/src/template/move/move_nansum.py
@@ -256,11 +256,11 @@ def move_nansum_selector(arr, int axis):
         a = arr
     else:    
         a = np.array(arr, copy=False)
-    cdef int ndim = a.ndim
-    cdef np.dtype dtype = a.dtype
-    if dtype < np.int_:
+    cdef int ndim = PyArray_NDIM(a)
+    cdef int dtype = PyArray_TYPE(a)
+    if dtype < NPY_int_:
         a = a.astype(np.int_)
-        dtype = a.dtype
+        dtype = PyArray_TYPE(a)
     if axis < 0:
         axis += ndim
     cdef tuple key = (ndim, dtype, axis)
@@ -272,7 +272,7 @@ def move_nansum_selector(arr, int axis):
         try:
             func = move_nansum_slow_dict[axis]
         except KeyError:
-            tup = (str(ndim), str(dtype), str(axis))
+            tup = (str(ndim), str(a.dtype), str(axis))
             raise TypeError, "Unsupported ndim/dtype/axis (%s/%s/%s)." % tup
     return func, a
 '''   
diff --git a/bottleneck/src/template/move/move_std.py b/bottleneck/src/template/move/move_std.py
index d1916fbffb..3f3861b048 100644
--- a/bottleneck/src/template/move/move_std.py
+++ b/bottleneck/src/template/move/move_std.py
@@ -379,8 +379,8 @@ def move_std_selector(arr, int axis):
         a = arr
     else:    
         a = np.array(arr, copy=False)
-    cdef np.dtype dtype = a.dtype
-    cdef int ndim = a.ndim
+    cdef int ndim = PyArray_NDIM(a)
+    cdef int dtype = PyArray_TYPE(a)
     if axis < 0:
         axis += ndim
     cdef tuple key = (ndim, dtype, axis)
@@ -392,7 +392,7 @@ def move_std_selector(arr, int axis):
         try:
             func = move_std_slow_dict[axis]
         except KeyError:
-            tup = (str(ndim), str(dtype), str(axis))
+            tup = (str(ndim), str(a.dtype), str(axis))
             raise TypeError, "Unsupported ndim/dtype/axis (%s/%s/%s)." % tup
     return func, a
 '''   
diff --git a/bottleneck/src/template/move/move_sum.py b/bottleneck/src/template/move/move_sum.py
index a44445eb94..9c58b33ef4 100644
--- a/bottleneck/src/template/move/move_sum.py
+++ b/bottleneck/src/template/move/move_sum.py
@@ -319,11 +319,11 @@ def move_sum_selector(arr, int axis):
         a = arr
     else:    
         a = np.array(arr, copy=False)
-    cdef int ndim = a.ndim
-    cdef np.dtype dtype = a.dtype
-    if dtype < np.int_:
+    cdef int ndim = PyArray_NDIM(a)
+    cdef int dtype = PyArray_TYPE(a)
+    if dtype < NPY_int_:
         a = a.astype(np.int_)
-        dtype = a.dtype
+        dtype = PyArray_TYPE(a)
     if axis < 0:
         axis += ndim
     cdef tuple key = (ndim, dtype, axis)
@@ -335,7 +335,7 @@ def move_sum_selector(arr, int axis):
         try:
             func = move_sum_slow_dict[axis]
         except KeyError:
-            tup = (str(ndim), str(dtype), str(axis))
+            tup = (str(ndim), str(a.dtype), str(axis))
             raise TypeError, "Unsupported ndim/dtype/axis (%s/%s/%s)." % tup
     return func, a
 '''   
diff --git a/bottleneck/src/template/template.py b/bottleneck/src/template/template.py
index 6adef76a10..e20e99d238 100644
--- a/bottleneck/src/template/template.py
+++ b/bottleneck/src/template/template.py
@@ -352,7 +352,7 @@ def append(self, ndim, dtype, axis, reuse=False):
         self.data.append((ndim, dtype, axis, reuse))
 
     def __str__(self):    
-        fmt = "%s_dict[(%s, %s, %s)] = %s_%sd_%s_axis%s"
+        fmt = "%s_dict[(%s, NPY_%s, %s)] = %s_%sd_%s_axis%s"
         src = []
         src.append("cdef dict %s_dict = {}" % self.name)
         for ndim, dtype, axis, reuse in self.data: