Changeset 14317


Ignore:
Timestamp:
02/04/13 11:07:47 (12 years ago)
Author:
jschierm
Message:

CHG: Use Python API function to make input arrays contiguous.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • issm/trunk-jpl/src/wrappers/python/io/FetchPythonData.cpp

    r14316 r14317  
    103103        long* lmatrix=NULL;
    104104        bool* bmatrix=NULL;
    105         int i,j,k,ipt=0;
    106         int mstride,nstride;
    107         npy_intp*  strides=NULL;
    108 //      PyObject* py_matrix2;
     105        int i;
     106        PyObject* py_matrix2=NULL;
    109107
    110108        if     (PyArray_Check((PyArrayObject*)py_matrix)) {
    … …  
    114112                        dims=PyArray_DIMS((PyArrayObject*)py_matrix);
    115113                        M=dims[0]; N=dims[1];
    116                         strides=PyArray_STRIDES((PyArrayObject*)py_matrix);
    117                         mstride=strides[0]; nstride=strides[1];
    118114                }
    119115                else if (ndim==1) {
    120116                        dims=PyArray_DIMS((PyArrayObject*)py_matrix);
    121117                        M=dims[0]; N=1;
    122                         strides=PyArray_STRIDES((PyArrayObject*)py_matrix);
    123                         mstride=strides[0]; nstride=1;
    124118                }
    125119                else
    126120                        _error_("expecting an MxN matrix or M vector in input!");
    127121
    128 //              _printf_(1,"M=%d, N=%d\n",M,N);
    129 //              _printf_(1,"mstride=%d, nstride=%d\n",mstride,nstride);
    130 //              _printf_(1,"py_matrix: FLAGS=%d, NPY_ARRAY_C_CONTIGUOUS=%d, FLAGS & NPY_ARRAY_C_CONTIGUOUS=%d\n",PyArray_FLAGS((PyArrayObject*)py_matrix),NPY_ARRAY_C_CONTIGUOUS,PyArray_FLAGS((PyArrayObject*)py_matrix) & NPY_ARRAY_C_CONTIGUOUS);
    131 //              _printf_(1,"NPY_SIZEOF_DOUBLE=%d\n",NPY_SIZEOF_DOUBLE);
    132 //              _printf_(1,"NPY_SIZEOF_INT64=%d\n",NPY_SIZEOF_INT64);
    133 //              _printf_(1,"NPY_SIZEOF_BOOL=%d\n",NPY_SIZEOF_BOOL);
    134 //              _printf_(1,"NPY_LONG=%d\n",NPY_LONG);
    135 //              _printf_(1,"NPY_INT64=%d\n",NPY_INT64);
    136 //              _printf_(1,"NPY_BOOL=%d\n",NPY_BOOL);
    137 //              _printf_(1,"NPY_CHAR=%d\n",NPY_CHAR);
    138 
    139122                if (M && N) {
     123                        if (!PyArray_ISCONTIGUOUS((PyArrayObject*)py_matrix)) {
     124                                py_matrix2=PyArray_ContiguousFromAny(py_matrix,NPY_DOUBLE,ndim,ndim);
     125                                py_matrix=py_matrix2;
     126                        }
     127
    140128                        if      (PyArray_TYPE((PyArrayObject*)py_matrix) == NPY_DOUBLE) {
    141129                                /*retrieve internal value: */
    … …  
    144132                                /*copy matrix: */
    145133                                matrix=xNew<double>(M*N);
    146                                 if (PyArray_FLAGS((PyArrayObject*)py_matrix) & NPY_ARRAY_C_CONTIGUOUS) {
     134//                              if (PyArray_ISCONTIGUOUS((PyArrayObject*)py_matrix)) {
    147135                                        memcpy(matrix,dmatrix,(M*N)*sizeof(double));
    148                                 }
    149                                 else {
    150                                         mstride/=PyArray_ITEMSIZE((PyArrayObject*)py_matrix);
    151                                         nstride/=PyArray_ITEMSIZE((PyArrayObject*)py_matrix);
    152                                         for (i=0; i<M; i++) {
    153                                                 k=i*mstride;
    154                                                 for (j=0; j<N; j++) {
    155                                                         matrix[ipt++]=dmatrix[k];
    156                                                         k+=nstride;
    157                                                 }
    158                                         }
    159 //                               py_matrix2=PyArray_FromObject(py_matrix,NPY_DOUBLE,PyArray_NDIM((const PyArrayObject*)py_matrix),PyArray_NDIM((const PyArrayObject*)py_matrix));
    160 //                              _printf_(1,"py_matrix2: FLAGS=%d, NPY_ARRAY_C_CONTIGUOUS=%d, FLAGS & NPY_ARRAY_C_CONTIGUOUS=%d\n",PyArray_FLAGS((PyArrayObject*)py_matrix2),NPY_ARRAY_C_CONTIGUOUS,PyArray_FLAGS((PyArrayObject*)py_matrix2) & NPY_ARRAY_C_CONTIGUOUS);
    161 //                              dmatrix=(double*)PyArray_DATA((PyArrayObject*)py_matrix2);
    162 //                              memcpy(matrix,dmatrix,(M*N)*sizeof(double));
    163                                 }
     136//                              }
     137
     138//                              else {
     139//                                      int j,k,ipt=0;
     140//                                      int mstride,nstride;
     141//                                      mstride=(int)PyArray_STRIDE((PyArrayObject*)py_matrix,0)/PyArray_ITEMSIZE((PyArrayObject*)py_matrix);
     142//                                      if (ndim > 1)
     143//                                              nstride=(int)PyArray_STRIDE((PyArrayObject*)py_matrix,1)/PyArray_ITEMSIZE((PyArrayObject*)py_matrix);
     144//                                      else
     145//                                              nstride=1;
     146//                                      for (i=0; i<M; i++) {
     147//                                              k=i*mstride;
     148//                                              for (j=0; j<N; j++) {
     149//                                                      matrix[ipt++]=dmatrix[k];
     150//                                                      k+=nstride;
     151//                                              }
     152//                                      }
     153//                              }
    164154                        }
    165155
    … …  
    184174                        else
    185175                                _error_("unrecognized double pyarray type in input!");
     176
     177                        if (py_matrix2)
     178                                delete(py_matrix2);
    186179                }
    187180                else
    … …  
    216209        bool* bmatrix=NULL;
    217210        int i;
     211        PyObject* py_matrix2=NULL;
    218212
    219213        if     (PyArray_Check((PyArrayObject*)py_matrix)) {
    … …  
    232226
    233227                if (M && N) {
     228                        if (!PyArray_ISCONTIGUOUS((PyArrayObject*)py_matrix)) {
     229                                py_matrix2=PyArray_ContiguousFromAny(py_matrix,NPY_LONG,ndim,ndim);
     230                                py_matrix=py_matrix2;
     231                        }
     232
    234233                        if      (PyArray_TYPE((PyArrayObject*)py_matrix) == NPY_DOUBLE) {
    235234                                /*retrieve internal value: */
    … …  
    261260                        else
    262261                                _error_("unrecognized int pyarray type in input!");
     262
     263                        if (py_matrix2)
     264                                delete(py_matrix2);
    263265                }
    264266                else
    … …  
    293295        long* lmatrix=NULL;
    294296        int i;
     297        PyObject* py_matrix2=NULL;
    295298
    296299        if     (PyArray_Check((PyArrayObject*)py_matrix)) {
    … …  
    309312
    310313                if (M && N) {
     314                        if (!PyArray_ISCONTIGUOUS((PyArrayObject*)py_matrix)) {
     315                                py_matrix2=PyArray_ContiguousFromAny(py_matrix,NPY_BOOL,ndim,ndim);
     316                                py_matrix=py_matrix2;
     317                        }
     318
    311319                        if      (PyArray_TYPE((PyArrayObject*)py_matrix) == NPY_DOUBLE) {
    312320                                /*retrieve internal value: */
    … …  
    338346                        else
    339347                                _error_("unrecognized bool pyarray type in input!");
     348
     349                        if (py_matrix2)
     350                                delete(py_matrix2);
    340351                }
    341352                else
    … …  
    370381        bool* bvector=NULL;
    371382        int i;
     383        PyObject* py_vector2=NULL;
    372384
    373385        if     (PyArray_Check((PyArrayObject*)py_vector)) {
    … …  
    389401
    390402                if (M) {
     403                        if (!PyArray_ISCONTIGUOUS((PyArrayObject*)py_vector)) {
     404                                py_vector2=PyArray_ContiguousFromAny(py_vector,NPY_DOUBLE,ndim,ndim);
     405                                py_vector=py_vector2;
     406                        }
     407
    391408                        if      (PyArray_TYPE((PyArrayObject*)py_vector) == NPY_DOUBLE) {
    392409                                /*retrieve internal value: */
    … …  
    418435                        else
    419436                                _error_("unrecognized double pyarray type in input!");
     437
     438                        if (py_vector2)
     439                                delete(py_vector2);
    420440                }
    421441                else
    … …  
    448468        double* dvector=NULL;
    449469        int i;
     470        PyObject* py_vector2=NULL;
    450471
    451472        if     (PyArray_Check((PyArrayObject*)py_vector)) {
    … …  
    467488
    468489                if (M) {
     490                        if (!PyArray_ISCONTIGUOUS((PyArrayObject*)py_vector)) {
     491                                py_vector2=PyArray_ContiguousFromAny(py_vector,NPY_LONG,ndim,ndim);
     492                                py_vector=py_vector2;
     493                        }
     494
    469495                        if      (PyArray_TYPE((PyArrayObject*)py_vector) == NPY_DOUBLE) {
    470496                                /*retrieve internal value: */
    … …  
    496522                        else
    497523                         _error_("unrecognized int pyarray type in input!");
     524
     525                        if (py_vector2)
     526                                delete(py_vector2);
    498527                }
    499528                else
    … …  
    526555        long* lvector=NULL;
    527556        int i;
     557        PyObject* py_vector2=NULL;
    528558
    529559        if     (PyArray_Check((PyArrayObject*)py_vector)) {
    … …  
    545575
    546576                if (M) {
     577                        if (!PyArray_ISCONTIGUOUS((PyArrayObject*)py_vector)) {
     578                                py_vector2=PyArray_ContiguousFromAny(py_vector,NPY_BOOL,ndim,ndim);
     579                                py_vector=py_vector2;
     580                        }
     581
    547582                        if      (PyArray_TYPE((PyArrayObject*)py_vector) == NPY_DOUBLE) {
    548583                                /*retrieve internal value: */
    … …  
    574609                        else
    575610                                _error_("unrecognized bool pyarray type in input!");
     611
     612                        if (py_vector2)
     613                                delete(py_vector2);
    576614                }
    577615                else
Note: See TracChangeset for help on using the changeset viewer.