replace PyArrayObejct->nd to PyArray_NDIM(PyArrayObject) for numpy 1.7 compatibility.

theano/compile/tests/test_debugmode.py

@@ -56,8 +56,8 @@ class BROKEN_ON_PURPOSE_Add(gof.Op):
         a, b = inp
         z, = out
         return """
-        if (%(a)s->nd != 1) {PyErr_SetString(PyExc_NotImplementedError, "rank(a) != 1"); %(fail)s;}
-        if (%(b)s->nd != 1) {PyErr_SetString(PyExc_NotImplementedError, "rank(b) != 1"); %(fail)s;}
+        if (PyArray_NDIM(%(a)s) != 1) {PyErr_SetString(PyExc_NotImplementedError, "rank(a) != 1"); %(fail)s;}
+        if (PyArray_NDIM(%(b)s) != 1) {PyErr_SetString(PyExc_NotImplementedError, "rank(b) != 1"); %(fail)s;}
 
         if (%(a)s->descr->type_num != NPY_DOUBLE)
         {PyErr_SetString(PyExc_NotImplementedError, "a dtype not NPY_DOUBLE"); %(fail)s;}
@@ -603,8 +603,8 @@ class BrokenCImplementationAdd(gof.Op):
         debug = 0
         return """
         //printf("executing c_code\\n");
-        if (%(a)s->nd != 2) {PyErr_SetString(PyExc_NotImplementedError, "rank(a) != 2"); %(fail)s;}
-        if (%(b)s->nd != 2) {PyErr_SetString(PyExc_NotImplementedError, "rank(b) != 2"); %(fail)s;}
+        if (PyArray_NDIM(%(a)s) != 2) {PyErr_SetString(PyExc_NotImplementedError, "rank(a) != 2"); %(fail)s;}
+        if (PyArray_NDIM(%(b)s) != 2) {PyErr_SetString(PyExc_NotImplementedError, "rank(b) != 2"); %(fail)s;}
 
         if (%(a)s->descr->type_num != NPY_FLOAT)
         {PyErr_SetString(PyExc_NotImplementedError, "a dtype not NPY_FLOAT"); %(fail)s;}

theano/sandbox/cuda/cuda_ndarray.cu

@@ -783,7 +783,7 @@ CudaNdarray_TakeFrom(CudaNdarray * self, PyObject *args){
             PyErr_SetString(PyExc_TypeError, "CudaNdarray_TakeFrom: need a ndarray for indices with dtype int32");
             return NULL;
         }
-        if (((PyArrayObject*)indices_obj)->nd != 1) {
+        if (PyArray_NDIM(((PyArrayObject*)indices_obj)) != 1) {
             PyErr_SetString(PyExc_TypeError, "CudaNdarray_TakeFrom: need a CudaNdarray of indices with only 1 dimensions");
             return NULL;
         }
@@ -2900,7 +2900,7 @@ filter(PyObject* __unsed_self, PyObject *args) // args = (data, broadcastable, s
             Py_DECREF(broadcastable);
             return NULL;
         }
-        for (int i = 0; i < data->nd; ++i)
+        for (int i = 0; i < PyArray_NDIM(data); ++i)
         {
             if ((data->dimensions[i] > 1) && PyInt_AsLong(PyTuple_GetItem(broadcastable, Py_ssize_t(i))))
             {
@@ -3080,7 +3080,7 @@ cublas_shutdown()
 int
 CudaNdarray_CopyFromArray(CudaNdarray * self, PyArrayObject*obj)
 {
-    int err = CudaNdarray_alloc_contiguous(self, obj->nd, obj->dimensions);
+    int err = CudaNdarray_alloc_contiguous(self, PyArray_NDIM(obj), obj->dimensions);
     if (err) {
         return err;
     }

theano/sandbox/multinomial.py

@@ -55,12 +55,12 @@ class MultinomialFromUniform(Op):
 
         fail = sub['fail']
         return """
-        if (%(pvals)s->nd != 2)
+        if (PyArray_NDIM(%(pvals)s) != 2)
         {
             PyErr_Format(PyExc_TypeError, "pvals wrong rank");
             %(fail)s;
         }
-        if (%(unis)s->nd != 1)
+        if (PyArray_NDIM(%(unis)s) != 1)
         {
             PyErr_Format(PyExc_TypeError, "unis wrong rank");
             %(fail)s;
@@ -233,12 +233,12 @@ class GpuMultinomialFromUniform(MultinomialFromUniform, GpuOp):
 
         fail = sub['fail']
         return """
-        if (%(pvals)s->nd != 2)
+        if (PyArray_NDIM(%(pvals)s) != 2)
         {
             PyErr_Format(PyExc_TypeError, "pvals wrong rank");
             %(fail)s;
         }
-        if (%(unis)s->nd != 1)
+        if (PyArray_NDIM(%(unis)s) != 1)
         {
             PyErr_Format(PyExc_TypeError, "unis wrong rank");
             %(fail)s;

theano/sandbox/neighbours.py

@@ -114,12 +114,12 @@ class Images2Neibs(Op):
         int grid_c = -1; //number of patch in height
         int grid_d = -1; //number of patch in width
         {
-        if (%(ten4)s->nd != 4)
+        if (PyArray_NDIM(%(ten4)s) != 4)
         {
             PyErr_Format(PyExc_TypeError, "ten4 wrong rank");
             %(fail)s;
         }
-        if (%(neib_shape)s->nd != 1)
+        if (PyArray_NDIM(%(neib_shape)s) != 1)
         {
             PyErr_Format(PyExc_TypeError, "neib_shape wrong rank");
             %(fail)s;
@@ -130,7 +130,7 @@ class Images2Neibs(Op):
                                           " contain 2 elements");
             %(fail)s;
         }
-        if (%(neib_step)s->nd != 1)
+        if (PyArray_NDIM(%(neib_step)s) != 1)
         {
             PyErr_Format(PyExc_TypeError, "neib_step wrong rank");
             %(fail)s;

theano/sandbox/rng_mrg.py

@@ -241,7 +241,7 @@ class mrg_uniform(mrg_uniform_base):
         int n_elements = 1;
         int n_streams = 0;
         int must_alloc_sample = ((NULL == %(o_sample)s)
-                                 || (%(o_sample)s->nd != %(ndim)s)
+                                 || (PyArray_NDIM(%(o_sample)s) != %(ndim)s)
                                  || !(PyArray_ISCONTIGUOUS(%(o_sample)s)));
         %(otype)s * sample_data;
         npy_int32 * state_data;
@@ -261,7 +261,7 @@ class mrg_uniform(mrg_uniform_base):
         const npy_int32 MASK2 = 65535;      //2^16 - 1
         const npy_int32 MULT2 = 21069;
 
-        if (%(size)s->nd != 1)
+        if (PyArray_NDIM(%(size)s) != 1)
         {
             PyErr_SetString(PyExc_ValueError, "size must be vector");
             %(fail)s
@@ -296,7 +296,7 @@ class mrg_uniform(mrg_uniform_base):
         Py_XDECREF(%(o_rstate)s);
         %(o_rstate)s = (PyArrayObject*)PyArray_FromAny(py_%(rstate)s, NULL, 0, 0, %(o_rstate_requirement)s,NULL);
 
-        if (%(o_rstate)s->nd != 2)
+        if (PyArray_NDIM(%(o_rstate)s) != 2)
         {
             PyErr_SetString(PyExc_ValueError, "rstate must be matrix");
             %(fail)s
@@ -501,9 +501,9 @@ class GPU_mrg_uniform(mrg_uniform_base, GpuOp):
         int must_alloc_sample = ((NULL == %(o_sample)s)
                 || !CudaNdarray_Check(py_%(o_sample)s)
                 || !CudaNdarray_is_c_contiguous(%(o_sample)s)
-                || (%(o_sample)s->nd != %(ndim)s));
+                || (PyArray_NDIM(%(o_sample)s) != %(ndim)s));
 
-        if (%(size)s->nd != 1)
+        if (PyArray_NDIM(%(size)s) != 1)
         {
             PyErr_SetString(PyExc_ValueError, "size must be vector");
             %(fail)s
@@ -552,7 +552,7 @@ class GPU_mrg_uniform(mrg_uniform_base, GpuOp):
             %(o_rstate)s = (CudaNdarray*)CudaNdarray_Copy(%(rstate)s);
         }
 
-        if (%(o_rstate)s->nd != 1)
+        if (PyArray_NDIM(%(o_rstate)s) != 1)
         {
             PyErr_SetString(PyExc_ValueError, "rstate must be vector");
             %(fail)s;

theano/sparse/basic.py

@@ -3006,10 +3006,10 @@ class StructuredDotGradCSC(gof.Op):
                                       'g_ab')
 
         return """
-        if (%(_d)s->nd != 2) {PyErr_SetString(PyExc_NotImplementedError, "rank(d) != 2"); %(fail)s;}
-        if (%(_g)s->nd != 2) {PyErr_SetString(PyExc_NotImplementedError, "rank(g) != 2"); %(fail)s;}
-        if (%(_indices)s->nd != 1) {PyErr_SetString(PyExc_NotImplementedError, "rank(indices) != 1"); %(fail)s;}
-        if (%(_indptr)s->nd != 1) {PyErr_SetString(PyExc_NotImplementedError, "rank(indptr) != 1"); %(fail)s;}
+        if (PyArray_NDIM(%(_d)s) != 2) {PyErr_SetString(PyExc_NotImplementedError, "rank(d) != 2"); %(fail)s;}
+        if (PyArray_NDIM(%(_g)s) != 2) {PyErr_SetString(PyExc_NotImplementedError, "rank(g) != 2"); %(fail)s;}
+        if (PyArray_NDIM(%(_indices)s) != 1) {PyErr_SetString(PyExc_NotImplementedError, "rank(indices) != 1"); %(fail)s;}
+        if (PyArray_NDIM(%(_indptr)s) != 1) {PyErr_SetString(PyExc_NotImplementedError, "rank(indptr) != 1"); %(fail)s;}
 
         if( %(_indices)s->descr->type_num != NPY_INT32) {
         PyErr_SetString(PyExc_NotImplementedError, "C"); %(fail)s;}
@@ -3142,10 +3142,10 @@ class StructuredDotGradCSR(gof.Op):
                                       'g_ab')
 
         return """
-        if (%(_d)s->nd != 2) {PyErr_SetString(PyExc_NotImplementedError, "rank(d) != 2"); %(fail)s;}
-        if (%(_g)s->nd != 2) {PyErr_SetString(PyExc_NotImplementedError, "rank(g) != 2"); %(fail)s;}
-        if (%(_indices)s->nd != 1) {PyErr_SetString(PyExc_NotImplementedError, "rank(indices) != 1"); %(fail)s;}
-        if (%(_indptr)s->nd != 1) {PyErr_SetString(PyExc_NotImplementedError, "rank(indptr) != 1"); %(fail)s;}
+        if (PyArray_NDIM(%(_d)s) != 2) {PyErr_SetString(PyExc_NotImplementedError, "rank(d) != 2"); %(fail)s;}
+        if (PyArray_NDIM(%(_g)s) != 2) {PyErr_SetString(PyExc_NotImplementedError, "rank(g) != 2"); %(fail)s;}
+        if (PyArray_NDIM(%(_indices)s) != 1) {PyErr_SetString(PyExc_NotImplementedError, "rank(indices) != 1"); %(fail)s;}
+        if (PyArray_NDIM(%(_indptr)s) != 1) {PyErr_SetString(PyExc_NotImplementedError, "rank(indptr) != 1"); %(fail)s;}
 
         if( %(_indices)s->descr->type_num != NPY_INT32) {
         PyErr_SetString(PyExc_NotImplementedError, "C"); %(fail)s;}

theano/tensor/basic.py

@@ -4063,7 +4063,7 @@ class Subtensor(Op):
             PyErr_Format(PyExc_ValueError, "x and xview"
                          "(with %%d dims) have the same dimensions"
                          " pointers: %%p and %%p",
-                         %(x)s->nd, xview->dimensions, %(x)s->dimensions);
+                         PyArray_NDIM(%(x)s), xview->dimensions, %(x)s->dimensions);
             %(fail)s;
         }
         if (xview->strides == %(x)s->strides
@@ -4072,7 +4072,7 @@ class Subtensor(Op):
             PyErr_Format(PyExc_ValueError, "x and xview"
                          "(with %%d dims) have the same strides"
                          " pointers: %%p and %%p",
-                         %(x)s->nd, xview->strides, %(x)s->strides);
+                         PyArray_NDIM(%(x)s), xview->strides, %(x)s->strides);
             %(fail)s;
         }
 
@@ -4176,10 +4176,10 @@ class Subtensor(Op):
                 spec_pos += 1;
             }
         }
-        assert (inner_ii <= xview->nd);
-        while (inner_ii < xview->nd)
+        assert (inner_ii <= PyArray_NDIM(xview));
+        while (inner_ii < PyArray_NDIM(xview))
         {
-            assert (outer_ii < %(x)s->nd);
+            assert (outer_ii < PyArray_NDIM(%(x)s));
             xview->dimensions[inner_ii] = %(x)s->dimensions[outer_ii];
             xview->strides[inner_ii] = %(x)s->strides[outer_ii];
             inner_ii += 1;
@@ -5373,7 +5373,7 @@ class Reshape(Op):
             new_ndim = self.ndim
             fail = sub['fail']
             return """
-            assert (%(shp)s->nd == 1);
+            assert (PyArray_NDIM(%(shp)s) == 1);
             npy_intp new_dims[%(new_ndim)s];
             PyArray_Dims newshape;
             newshape.ptr = new_dims;

theano/tensor/blas.py

@@ -511,12 +511,22 @@ class GemmRelated(Op):
     #setup_z_Nz_Sz = None
 
     check_xyz_rank2 = """
-        if (%(_x)s->nd != 2) {
-            PyErr_Format(PyExc_NotImplementedError, "rank(x) != 2. rank(x) is %%d.", %(_x)s->nd); %(fail)s;}
-        if (%(_y)s->nd != 2) {
-            PyErr_Format(PyExc_NotImplementedError, "rank(y) != 2. rank(y) is %%d.", %(_y)s->nd); %(fail)s;}
-        if (%(_zout)s && %(_zout)s->nd != 2) {
-            PyErr_Format(PyExc_NotImplementedError, "rank(z) != 2. rank(z) is %%d.", %(_zout)s->nd); %(fail)s;}
+        if (PyArray_NDIM(%(_x)s) != 2) {
+            PyErr_Format(PyExc_NotImplementedError,
+                         "rank(x) != 2. rank(x) is %%d.",
+                         PyArray_NDIM(%(_x)s));
+            %(fail)s;
+        }
+        if (PyArray_NDIM(%(_y)s) != 2) {
+            PyErr_Format(PyExc_NotImplementedError,
+                         "rank(y) != 2. rank(y) is %%d.", PyArray_NDIM(%(_y)s));
+            %(fail)s;
+        }
+        if (%(_zout)s && PyArray_NDIM(%(_zout)s) != 2) {
+            PyErr_Format(PyExc_NotImplementedError,
+                         "rank(z) != 2. rank(z) is %%d.", PyArray_NDIM(%(_zout)s));
+            %(fail)s;
+        }
         """
     check_xyz_double_or_float = """
         if ((%(_x)s->descr->type_num != NPY_DOUBLE)

theano/tensor/blas_c.py

@@ -33,13 +33,13 @@ def ger_c_code(A, a, x, y, Z, destructive, fail):
 
     int elemsize ;
 
-    if (%(A)s->nd != 2)
+    if (PyArray_NDIM(%(A)s) != 2)
     {PyErr_SetString(PyExc_NotImplementedError, "rank(A) != 2"); %(fail)s;}
-    if (%(x)s->nd != 1)
+    if (PyArray_NDIM(%(x)s) != 1)
     {PyErr_SetString(PyExc_NotImplementedError, "rank(x) != 1"); %(fail)s;}
-    if (%(y)s->nd != 1)
+    if (PyArray_NDIM(%(y)s) != 1)
     {PyErr_SetString(PyExc_NotImplementedError, "rank(y) != 1"); %(fail)s;}
-    if (%(a)s->nd != 0)
+    if (PyArray_NDIM(%(a)s) != 0)
     {PyErr_SetString(PyExc_NotImplementedError, "rank(a) != 0"); %(fail)s;}
 
     if (%(A)s->descr->type_num != %(x)s->descr->type_num)
@@ -290,27 +290,27 @@ def gemv_c_code(aa, xx, yy, zz, alpha, beta, destructive, fail):
     float fbeta;
     double dbeta;
 
-    if (%(aa)s->nd != 1)
+    if (PyArray_NDIM(%(aa)s) != 1)
     {
         PyErr_SetString(PyExc_NotImplementedError, "Gemv: rank(aa) != 1");
         %(fail)s;
     }
-    if (%(xx)s->nd != 2)
+    if (PyArray_NDIM(%(xx)s) != 2)
     {
         PyErr_SetString(PyExc_NotImplementedError, "Gemv: rank(xx) != 2");
         %(fail)s;
     }
-    if (%(yy)s->nd != 1)
+    if (PyArray_NDIM(%(yy)s) != 1)
     {
         PyErr_SetString(PyExc_NotImplementedError, "Gemv: rank(yy) != 1");
         %(fail)s;
     }
-    if (%(alpha)s->nd != 0)
+    if (PyArray_NDIM(%(alpha)s) != 0)
     {
         PyErr_SetString(PyExc_NotImplementedError, "Gemv: rank(alpha) != 0");
         %(fail)s;
     }
-    if (%(beta)s->nd != 0)
+    if (PyArray_NDIM(%(beta)s) != 0)
     {
         PyErr_SetString(PyExc_NotImplementedError, "Gemv: rank(beta) != 0");
         %(fail)s;

theano/tensor/blas_headers.py

@@ -809,9 +809,9 @@ def ____gemm_code(check_ab, a_init, b_init):
 
         int unit = 0;
 
-        if (_x->nd != 2) goto _dot_execute_fallback;
-        if (_y->nd != 2) goto _dot_execute_fallback;
-        if (_z->nd != 2) goto _dot_execute_fallback;
+        if (PyArray_NDIM(_x) != 2) goto _dot_execute_fallback;
+        if (PyArray_NDIM(_y) != 2) goto _dot_execute_fallback;
+        if (PyArray_NDIM(_z) != 2) goto _dot_execute_fallback;
 
         %(check_ab)s
 

theano/tensor/elemwise.py

@@ -270,7 +270,7 @@ class DimShuffle(Op):
         nd_in = len(self.input_broadcastable)
         nd_out = len(self.new_order)
 
-        check_input_nd = [('if (%(input)s->nd != ' + str(nd_in) + ')'
+        check_input_nd = [('if (PyArray_NDIM(%(input)s) != ' + str(nd_in) + ')'
                 '{PyErr_SetString(PyExc_NotImplementedError, "input nd"); %(fail)s;}')]
 
         clear_output = ['if (%(res)s) {Py_XDECREF(%(res)s);}']
@@ -1341,7 +1341,7 @@ class CAReduce(Op):
             pattern_ = str(pattern)[1:-1]
             decl += """int tosum[]={%(pattern_)s};""" % locals()
             alloc += """
-for(int i=0;i<%(iname)s->nd;i++){
+for(int i=0;i<PyArray_NDIM(%(iname)s);i++){
   if(PyArray_DIMS(%(iname)s)[i]==0 && tosum[i]){
     PyErr_Format(PyExc_ValueError,
          "Input of CAReduce{%(scal_name)s} has zero-size on axis %%d",i);

theano/tensor/elemwise_cgen.py

@@ -47,7 +47,7 @@ def make_checks(loop_orders, dtypes, sub):
             # tensor is as expected.
             min_nd = max(nonx) + 1
             init += """
-            if (%(var)s->nd < %(min_nd)s) {
+            if (PyArray_NDIM(%(var)s) < %(min_nd)s) {
                 PyErr_SetString(PyExc_ValueError, "Not enough dimensions on input.");
                 %%(fail)s
             }

theano/tensor/nnet/Conv3D.py

@@ -182,26 +182,26 @@ class Conv3D(theano.Op):
             //printf("\t\t\t\tConv3D c code\\n");
 
             //Check dimensionality of inputs
-            if (%(W)s->nd != 5)
+            if (PyArray_NDIM(%(W)s) != 5)
             {
                 PyErr_Format(PyExc_ValueError, "Conv3D: W must be a 5 dimensional tensor");
                             %(fail)s
 
             }
 
-            if (%(V)s->nd != 5)
+            if (PyArray_NDIM(%(V)s) != 5)
             {
                 PyErr_Format(PyExc_ValueError, "Conv3D: V must be a 5 dimensional tensor");
                             %(fail)s
             }
 
-            if (%(b)s->nd != 1)
+            if (PyArray_NDIM(%(b)s) != 1)
             {
                 PyErr_Format(PyExc_ValueError,"Conv3D: b must be a vector.");
                 %(fail)s
             }
 
-            if (%(d)s->nd != 1)
+            if (PyArray_NDIM(%(d)s) != 1)
             {
                 PyErr_Format(PyExc_ValueError,"Conv3D: d must be a vector.");
                 %(fail)s

theano/tensor/nnet/ConvGrad3D.py

@@ -97,25 +97,25 @@ class ConvGrad3D(theano.Op):
             //printf("\t\t\t\tConvGradW3D c code\\n");
 
             //Check dimensionality of inputs
-            if (%(dCdH)s->nd != 5)
+            if (PyArray_NDIM(%(dCdH)s) != 5)
             {
                 PyErr_Format(PyExc_ValueError, "ConvGrad3D: dCdH must be a 5 dimensional tensor");
                             %(fail)s
             }
 
-            if (%(V)s->nd != 5)
+            if (PyArray_NDIM(%(V)s) != 5)
             {
                 PyErr_Format(PyExc_ValueError, "ConvGrad3D: V must be a 5 dimensional tensor");
                 %(fail)s
             }
 
-            if (%(WShape)s->nd != 1)
+            if (PyArray_NDIM(%(WShape)s) != 1)
             {
                 PyErr_Format(PyExc_ValueError,"ConvGrad3D: WShape must be a vector.");
                 %(fail)s
             }
 
-            if (%(d)s->nd != 1)
+            if (PyArray_NDIM(%(d)s) != 1)
             {
                 PyErr_Format(PyExc_ValueError,"ConvGrad3D: d must be a vector.");
                 %(fail)s

theano/tensor/nnet/ConvTransp3D.py

@@ -99,25 +99,27 @@ class ConvTransp3D(theano.Op):
                     //printf("\t\t\t\tConvTransp3D c code\\n");
 
                     //Check dimensionality of inputs
-                    if (%(H)s->nd != 5)
+                    if (PyArray_NDIM(%(H)s) != 5)
                     {
-                        PyErr_Format(PyExc_ValueError, "H must be a 5-D tensor but it is %%i-D",%(H)s->nd);
+                        PyErr_Format(PyExc_ValueError,
+                                     "H must be a 5-D tensor but it is %%i-D",
+                                     PyArray_NDIM(%(H)s));
                         %(fail)s
                     }
 
-                    if (%(W)s->nd != 5)
+                    if (PyArray_NDIM(%(W)s) != 5)
                     {
                          PyErr_Format(PyExc_ValueError, "ConvTransp3D: W must be a 5-D tensor");
                 %(fail)s
                     }
 
-                    if (%(b)s->nd != 1)
+                    if (PyArray_NDIM(%(b)s) != 1)
                     {
                          PyErr_Format(PyExc_ValueError, "ConvTransp3D: b must be a vector");
                          %(fail)s
                     }
 
-                    if (%(d)s->nd != 1)
+                    if (PyArray_NDIM(%(d)s) != 1)
                     {
                          PyErr_Format(PyExc_ValueError, "ConvTransp3D: d must be a vector");
                          %(fail)s
@@ -179,7 +181,7 @@ class ConvTransp3D(theano.Op):
 
                                 if (%(RShape)s)
                                 {
-                                    if (%(RShape)s->nd != 1)
+                                    if (PyArray_NDIM(%(RShape)s) != 1)
                                     {
                                         PyErr_Format(PyExc_ValueError, "ConvTransp3D: RShape must be a vector");
                                         %(fail)s

theano/tensor/nnet/conv.py

@@ -1266,14 +1266,14 @@ kerns_shape.len=4;
 PyObject *img2d=NULL, *contig, *filtersflipped=NULL;
 
 
-if(%(img2d)s->nd==2){
+if(PyArray_NDIM(%(img2d)s)==2){
   img2d_dim[3]=%(img2d)s->dimensions[1];
   img2d_dim[2]=%(img2d)s->dimensions[0];
-}else if(%(img2d)s->nd==3){
+}else if(PyArray_NDIM(%(img2d)s)==3){
   img2d_dim[3]=%(img2d)s->dimensions[2];
   img2d_dim[2]=%(img2d)s->dimensions[1];
   img2d_dim[0]=%(img2d)s->dimensions[0];
-}else if(%(img2d)s->nd==4){
+}else if(PyArray_NDIM(%(img2d)s)==4){
   img2d_dim[3]=%(img2d)s->dimensions[3];
   img2d_dim[2]=%(img2d)s->dimensions[2];
   img2d_dim[1]=%(img2d)s->dimensions[1];
@@ -1283,18 +1283,18 @@ if(%(img2d)s->nd==2){
     %(fail)s;
 }
 
-if(%(filtersflipped)s->nd==3){
+if(PyArray_NDIM(%(filtersflipped)s)==3){
   kerns_dim[3]=%(filtersflipped)s->dimensions[2];
   kerns_dim[2]=%(filtersflipped)s->dimensions[1];
   kerns_dim[0]=%(filtersflipped)s->dimensions[0];
-}else if(%(filtersflipped)s->nd==4){
+}else if(PyArray_NDIM(%(filtersflipped)s)==4){
   kerns_dim[3]=%(filtersflipped)s->dimensions[3];
   kerns_dim[2]=%(filtersflipped)s->dimensions[2];
   kerns_dim[1]=%(filtersflipped)s->dimensions[1];
   kerns_dim[0]=%(filtersflipped)s->dimensions[0];
 }else{
     std::stringstream temp;
-    temp << "nddim="<<%(filtersflipped)s->nd;
+    temp << "nddim="<<PyArray_NDIM(%(filtersflipped)s);
     std::string param = temp.str();
     PyErr_SetString(PyExc_ValueError,
       ("kernel don't have a good shape. " + param).c_str());
@@ -1536,14 +1536,14 @@ kerns_shape.ptr=kerns_dim;
 kerns_shape.len=4;
 PyObject *img2d=NULL, *contig;
 
-if(%(img2d)s->nd==2){
+if(PyArray_NDIM(%(img2d)s)==2){
   img2d_dim[3]=%(img2d)s->dimensions[1];
   img2d_dim[2]=%(img2d)s->dimensions[0];
-}else if(%(img2d)s->nd==3){
+}else if(PyArray_NDIM(%(img2d)s)==3){
   img2d_dim[3]=%(img2d)s->dimensions[2];
   img2d_dim[2]=%(img2d)s->dimensions[1];
   img2d_dim[0]=%(img2d)s->dimensions[0];
-}else if(%(img2d)s->nd==4){
+}else if(PyArray_NDIM(%(img2d)s)==4){
   img2d_dim[3]=%(img2d)s->dimensions[3];
   img2d_dim[2]=%(img2d)s->dimensions[2];
   img2d_dim[1]=%(img2d)s->dimensions[1];
@@ -1553,18 +1553,18 @@ if(%(img2d)s->nd==2){
     %(fail)s;
 }
 
-if(%(filtersflipped)s->nd==3){
+if(PyArray_NDIM(%(filtersflipped)s)==3){
   kerns_dim[3]=%(filtersflipped)s->dimensions[2];
   kerns_dim[2]=%(filtersflipped)s->dimensions[1];
   kerns_dim[0]=%(filtersflipped)s->dimensions[0];
-}else if(%(filtersflipped)s->nd==4){
+}else if(PyArray_NDIM(%(filtersflipped)s)==4){
   kerns_dim[3]=%(filtersflipped)s->dimensions[3];
   kerns_dim[2]=%(filtersflipped)s->dimensions[2];
   kerns_dim[1]=%(filtersflipped)s->dimensions[1];
   kerns_dim[0]=%(filtersflipped)s->dimensions[0];
 }else{
     std::stringstream temp;
-    temp << "nddim="<<%(filtersflipped)s->nd;
+    temp << "nddim="<<PyArray_NDIM(%(filtersflipped)s);
     std::string param = temp.str();
     PyErr_SetString(PyExc_ValueError,
       ("kernel don't have a good shape. " + param).c_str());
@@ -1637,7 +1637,7 @@ for(int i=0;i < kerns_dim[0];++i){
     for(int j=0;j < kerns_dim[1];++j){
         for(int k=0;k < kerns_dim[2];++k){
             for(int l=0;l < kerns_dim[3];++l){
-                %(type)s * ff = ((%(filtersflipped)s)->nd == 3)
+                %(type)s * ff = ((PyArray_NDIM(%(filtersflipped)s)) == 3)
                     ? (%(type)s *)PyArray_GETPTR3(%(filtersflipped)s, i, kerns_dim[2]-1-k, kerns_dim[3]-1-l)
                     : (%(type)s *)PyArray_GETPTR4(%(filtersflipped)s, i, j, kerns_dim[2]-1-k, kerns_dim[3]-1-l);
                 myfilters[i * (kerns_dim[1]*kerns_dim[2]*kerns_dim[3])
@@ -1788,32 +1788,32 @@ kerns_shape.ptr=kerns_dim;
 kerns_shape.len=4;
 PyObject *img2d=NULL, *contig, *filtersflipped=NULL;
 
-if(%(img2d)s->nd==2){
+if(PyArray_NDIM(%(img2d)s)==2){
   img2d_dim[3]=%(img2d)s->dimensions[1];
   img2d_dim[2]=%(img2d)s->dimensions[0];
-}else if(%(img2d)s->nd==3){
+}else if(PyArray_NDIM(%(img2d)s)==3){
   img2d_dim[3]=%(img2d)s->dimensions[2];
   img2d_dim[2]=%(img2d)s->dimensions[1];
   img2d_dim[0]=%(img2d)s->dimensions[0];
-}else if(%(img2d)s->nd==4){
+}else if(PyArray_NDIM(%(img2d)s)==4){
   img2d_dim[3]=%(img2d)s->dimensions[3];
   img2d_dim[2]=%(img2d)s->dimensions[2];
   img2d_dim[1]=%(img2d)s->dimensions[1];
   img2d_dim[0]=%(img2d)s->dimensions[0];
 }else {
     std::stringstream temp;
-    temp << "nddim="<<%(img2d)s->nd;
+    temp << "nddim="<<PyArray_NDIM(%(img2d)s);
     std::string param = temp.str();
     PyErr_SetString(PyExc_ValueError,
       ("img don't have a good shape. " + param).c_str());
     %(fail)s;
 }
 
-if(%(filtersflipped)s->nd==3){
+if(PyArray_NDIM(%(filtersflipped)s)==3){
   kerns_dim[3]=%(filtersflipped)s->dimensions[2];
   kerns_dim[2]=%(filtersflipped)s->dimensions[1];
   kerns_dim[0]=%(filtersflipped)s->dimensions[0];
-}else if(%(filtersflipped)s->nd==4){
+}else if(PyArray_NDIM(%(filtersflipped)s)==4){
   kerns_dim[3]=%(filtersflipped)s->dimensions[3];
   kerns_dim[2]=%(filtersflipped)s->dimensions[2];
   kerns_dim[1]=%(filtersflipped)s->dimensions[1];
@@ -2025,36 +2025,36 @@ kerns_shape.ptr=kerns_dim;
 kerns_shape.len=4;
 PyObject *img2d=NULL, *contig, *filtersflipped=NULL;
 
-if(%(img2d)s->nd==2){
+if(PyArray_NDIM(%(img2d)s)==2){
   img2d_dim[3]=%(img2d)s->dimensions[1];
   img2d_dim[2]=%(img2d)s->dimensions[0];
-}else if(%(img2d)s->nd==3){
+}else if(PyArray_NDIM(%(img2d)s)==3){
   img2d_dim[3]=%(img2d)s->dimensions[2];
   img2d_dim[2]=%(img2d)s->dimensions[1];
   img2d_dim[0]=%(img2d)s->dimensions[0];
-}else if(%(img2d)s->nd==4){
+}else if(PyArray_NDIM(%(img2d)s)==4){
   img2d_dim[3]=%(img2d)s->dimensions[3];
   img2d_dim[2]=%(img2d)s->dimensions[2];
   img2d_dim[1]=%(img2d)s->dimensions[1];
   img2d_dim[0]=%(img2d)s->dimensions[0];
 }else {
     PyErr_Format(PyExc_ValueError,
-      "image don't have a good number of dimensions %%d. ", %(filtersflipped)s->nd);
+      "image don't have a good number of dimensions %%d. ", PyArray_NDIM(%(filtersflipped)s));
     %(fail)s;
 }
 
-if(%(filtersflipped)s->nd==3){
+if(PyArray_NDIM(%(filtersflipped)s)==3){
   kerns_dim[3]=%(filtersflipped)s->dimensions[2];
   kerns_dim[2]=%(filtersflipped)s->dimensions[1];
   kerns_dim[0]=%(filtersflipped)s->dimensions[0];
-}else if(%(filtersflipped)s->nd==4){
+}else if(PyArray_NDIM(%(filtersflipped)s)==4){
   kerns_dim[3]=%(filtersflipped)s->dimensions[3];
   kerns_dim[2]=%(filtersflipped)s->dimensions[2];
   kerns_dim[1]=%(filtersflipped)s->dimensions[1];
   kerns_dim[0]=%(filtersflipped)s->dimensions[0];
 }else{
     PyErr_Format(PyExc_ValueError,
-      "kernel don't have a good number of dimensions %%d. ", %(filtersflipped)s->nd);
+      "kernel don't have a good number of dimensions %%d. ", PyArray_NDIM(%(filtersflipped)s));
     %(fail)s;
 }
 

theano/tensor/nnet/nnet.py

@@ -107,12 +107,12 @@ class SoftmaxWithBias(gof.Op):
         init_decl = """
         npy_intp* Nx = %(x)s->dimensions;
 
-        if (%(x)s->nd != 2)
+        if (PyArray_NDIM(%(x)s) != 2)
         {
             PyErr_SetString(PyExc_ValueError, "a not 2d tensor");
             %(fail)s;
         }
-        if (%(b)s->nd != 1)
+        if (PyArray_NDIM(%(b)s) != 1)
         {
             PyErr_SetString(PyExc_ValueError, "b not 1d tensor");
             %(fail)s;
@@ -277,8 +277,8 @@ class SoftmaxGrad(gof.Op):
                  "types should be float or float64");
             %(fail)s;
         }
-        if ((%(dy)s->nd != 2)
-            || (%(sm)s->nd != 2))
+        if ((PyArray_NDIM(%(dy)s) != 2)
+            || (PyArray_NDIM(%(sm)s) != 2))
         {
             PyErr_SetString(PyExc_ValueError, "rank error");
             %(fail)s;
@@ -773,7 +773,7 @@ class CrossentropySoftmaxArgmax1HotWithBias(gof.Op):
                 SoftmaxWithBias.c_code_template()
         return (init_decl,
                 """
-        if (%(y_idx)s->nd != 1)
+        if (PyArray_NDIM(%(y_idx)s) != 1)
         {
             PyErr_SetString(PyExc_ValueError, "y_idx not 1d tensor");
             %(fail)s;
@@ -937,9 +937,9 @@ class CrossentropySoftmax1HotWithBiasDx (gof.Op):
                  "y_idx not int8, int16, int32, or int64");
             %(fail)s;
         }
-        if ((%(dnll)s->nd != 1)
-            || (%(sm)s->nd != 2)
-            || (%(y_idx)s->nd != 1))
+        if ((PyArray_NDIM(%(dnll)s) != 1)
+            || (PyArray_NDIM(%(sm)s) != 2)
+            || (PyArray_NDIM(%(y_idx)s) != 1))
         {
             PyErr_SetString(PyExc_ValueError, "rank error");
             %(fail)s;

theano/tensor/signal/downsample.py

@@ -176,7 +176,7 @@ class DownsampleFactorMax(Op):
         int x_shp0_usable;
         int x_shp1_usable;
         int z_shp0, z_shp1;
-        if(%(x)s->nd!=4)
+        if(PyArray_NDIM(%(x)s)!=4)
         {
             PyErr_SetString(PyExc_ValueError, "x must be a 4d ndarray");
             %(fail)s;
@@ -306,17 +306,17 @@ class DownsampleFactorMaxGrad(Op):
             PyErr_SetString(PyExc_ValueError, "input types must all match");
             %(fail)s;
         }
-        if(%(x)s->nd!=4)
+        if(PyArray_NDIM(%(x)s)!=4)
         {
             PyErr_SetString(PyExc_ValueError, "x must be a 4d ndarray");
             %(fail)s;
         }
-        if(%(z)s->nd!=4)
+        if(PyArray_NDIM(%(z)s)!=4)
         {
             PyErr_SetString(PyExc_ValueError, "z must be a 4d ndarray");
             %(fail)s;
         }
-        if(%(gz)s->nd!=4)
+        if(PyArray_NDIM(%(gz)s)!=4)
         {
             PyErr_SetString(PyExc_ValueError, "gz must be a 4d ndarray");
             %(fail)s;