Changeset 14236


Ignore:
Timestamp:
01/10/13 11:36:04 (12 years ago)
Author:
jschierm
Message:

CHG: Allow more possibilities for reading python vectors.

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r14234 r14236  
    336336        int i;
    337337
    338         /*retrieve dimensions: */
    339         ndim=PyArray_NDIM((const PyArrayObject*)py_vector);
    340         if(ndim!=1)_error_("expecting an Mx1 vector in input!");
    341         dims=PyArray_DIMS((PyArrayObject*)py_vector);
    342         M=dims[0];
    343 
    344         if (M) {
    345                 if      (PyArray_TYPE((PyArrayObject*)py_vector) == NPY_DOUBLE) {
    346                         /*retrieve internal value: */
    347                         dvector=(double*)PyArray_DATA((PyArrayObject*)py_vector);
    348 
    349                         /*copy vector: */
    350                         vector=xNew<double>(M);
    351                         memcpy(vector,dvector,(M)*sizeof(double));
    352                 }
    353 
    354                 else if (PyArray_TYPE((PyArrayObject*)py_vector) == NPY_INT64) {
    355                         /*retrieve internal value: */
    356                         lvector=(long*)PyArray_DATA((PyArrayObject*)py_vector);
    357 
    358                         /*transform into double vector: */
    359                         vector=xNew<double>(M);
    360                         for(i=0;i<M;i++)vector[i]=(double)lvector[i];
    361                 }
    362 
    363                 else if (PyArray_TYPE((PyArrayObject*)py_vector) == NPY_BOOL) {
    364                         /*retrieve internal value: */
    365                         bvector=(bool*)PyArray_DATA((PyArrayObject*)py_vector);
    366 
    367                         /*transform into double vector: */
    368                         vector=xNew<double>(M);
    369                         for(i=0;i<M;i++)vector[i]=(double)bvector[i];
    370                 }
    371 
    372                 else
    373                         _error_("unrecognized double pyarray type in input!");
    374         }
    375         else
    376                 vector=NULL;
     338        if     (PyArray_Check((PyArrayObject*)py_vector)) {
     339                /*retrieve dimensions: */
     340                ndim=PyArray_NDIM((const PyArrayObject*)py_vector);
     341                if      (ndim==1) {
     342                        dims=PyArray_DIMS((PyArrayObject*)py_vector);
     343                        M=dims[0];
     344                }
     345                else if (ndim==2) {
     346                        dims=PyArray_DIMS((PyArrayObject*)py_vector);
     347                        if (dims[1]==1)
     348                                M=dims[0];
     349                        else
     350                                _error_("expecting an Mx1 matrix or M vector in input!");
     351                }
     352                else
     353                        _error_("expecting an Mx1 matrix or M vector in input!");
     354
     355                if (M) {
     356                        if      (PyArray_TYPE((PyArrayObject*)py_vector) == NPY_DOUBLE) {
     357                                /*retrieve internal value: */
     358                                dvector=(double*)PyArray_DATA((PyArrayObject*)py_vector);
     359
     360                                /*copy vector: */
     361                                vector=xNew<double>(M);
     362                                memcpy(vector,dvector,(M)*sizeof(double));
     363                        }
     364
     365                        else if (PyArray_TYPE((PyArrayObject*)py_vector) == NPY_INT64) {
     366                                /*retrieve internal value: */
     367                                lvector=(long*)PyArray_DATA((PyArrayObject*)py_vector);
     368
     369                                /*transform into double vector: */
     370                                vector=xNew<double>(M);
     371                                for(i=0;i<M;i++)vector[i]=(double)lvector[i];
     372                        }
     373
     374                        else if (PyArray_TYPE((PyArrayObject*)py_vector) == NPY_BOOL) {
     375                                /*retrieve internal value: */
     376                                bvector=(bool*)PyArray_DATA((PyArrayObject*)py_vector);
     377
     378                                /*transform into double vector: */
     379                                vector=xNew<double>(M);
     380                                for(i=0;i<M;i++)vector[i]=(double)bvector[i];
     381                        }
     382
     383                        else
     384                                _error_("unrecognized double pyarray type in input!");
     385                }
     386                else
     387                        vector=NULL;
     388        }
     389
     390        else {
     391                M=1;
     392                vector=xNew<double>(M);
     393                FetchData(&(vector[0]),py_vector);
     394        }
    377395
    378396        /*output: */
    … …  
    396414        int i;
    397415
    398         /*retrieve dimensions: */
    399         ndim=PyArray_NDIM((const PyArrayObject*)py_vector);
    400         if(ndim!=1)_error_("expecting an Mx1 vector in input!");
    401         dims=PyArray_DIMS((PyArrayObject*)py_vector);
    402         M=dims[0];
    403 
    404         if (M) {
    405                 if      (PyArray_TYPE((PyArrayObject*)py_vector) == NPY_DOUBLE) {
    406                         /*retrieve internal value: */
    407                         dvector=(double*)PyArray_DATA((PyArrayObject*)py_vector);
    408 
    409                         /*transform into int vector: */
    410                         vector=xNew<int>(M);
    411                         for(i=0;i<M;i++)vector[i]=(int)lvector[i];
    412                 }
    413 
    414                 else if (PyArray_TYPE((PyArrayObject*)py_vector) == NPY_INT64) {
    415                         /*retrieve internal value: */
    416                         lvector=(long*)PyArray_DATA((PyArrayObject*)py_vector);
    417 
    418                         /*transform into int vector: */
    419                         vector=xNew<int>(M);
    420                         for(i=0;i<M;i++)vector[i]=(int)lvector[i];
    421                 }
    422 
    423                 else if (PyArray_TYPE((PyArrayObject*)py_vector) == NPY_BOOL) {
    424                         /*retrieve internal value: */
    425                         bvector=(bool*)PyArray_DATA((PyArrayObject*)py_vector);
    426 
    427                         /*transform into int vector: */
    428                         vector=xNew<int>(M);
    429                         for(i=0;i<M;i++)vector[i]=(int)bvector[i];
    430                 }
    431 
    432                 else
    433                  _error_("unrecognized int pyarray type in input!");
    434         }
    435         else
    436          vector=NULL;
     416        if     (PyArray_Check((PyArrayObject*)py_vector)) {
     417                /*retrieve dimensions: */
     418                ndim=PyArray_NDIM((const PyArrayObject*)py_vector);
     419                if      (ndim==1) {
     420                        dims=PyArray_DIMS((PyArrayObject*)py_vector);
     421                        M=dims[0];
     422                }
     423                else if (ndim==2) {
     424                        dims=PyArray_DIMS((PyArrayObject*)py_vector);
     425                        if (dims[1]==1)
     426                                M=dims[0];
     427                        else
     428                                _error_("expecting an Mx1 matrix or M vector in input!");
     429                }
     430                else
     431                        _error_("expecting an Mx1 matrix or M vector in input!");
     432
     433                if (M) {
     434                        if      (PyArray_TYPE((PyArrayObject*)py_vector) == NPY_DOUBLE) {
     435                                /*retrieve internal value: */
     436                                dvector=(double*)PyArray_DATA((PyArrayObject*)py_vector);
     437
     438                                /*transform into int vector: */
     439                                vector=xNew<int>(M);
     440                                for(i=0;i<M;i++)vector[i]=(int)lvector[i];
     441                        }
     442
     443                        else if (PyArray_TYPE((PyArrayObject*)py_vector) == NPY_INT64) {
     444                                /*retrieve internal value: */
     445                                lvector=(long*)PyArray_DATA((PyArrayObject*)py_vector);
     446
     447                                /*transform into int vector: */
     448                                vector=xNew<int>(M);
     449                                for(i=0;i<M;i++)vector[i]=(int)lvector[i];
     450                        }
     451
     452                        else if (PyArray_TYPE((PyArrayObject*)py_vector) == NPY_BOOL) {
     453                                /*retrieve internal value: */
     454                                bvector=(bool*)PyArray_DATA((PyArrayObject*)py_vector);
     455
     456                                /*transform into int vector: */
     457                                vector=xNew<int>(M);
     458                                for(i=0;i<M;i++)vector[i]=(int)bvector[i];
     459                        }
     460
     461                        else
     462                         _error_("unrecognized int pyarray type in input!");
     463                }
     464                else
     465                        vector=NULL;
     466        }
     467
     468        else {
     469                M=1;
     470                vector=xNew<int>(M);
     471                FetchData(&(vector[0]),py_vector);
     472        }
    437473
    438474        /*output: */
    … …  
    456492        int i;
    457493
    458         /*retrieve dimensions: */
    459         ndim=PyArray_NDIM((const PyArrayObject*)py_vector);
    460         if(ndim!=1)_error_("expecting an Mx1 vector in input!");
    461         dims=PyArray_DIMS((PyArrayObject*)py_vector);
    462         M=dims[0];
    463 
    464         if (M) {
    465                 if      (PyArray_TYPE((PyArrayObject*)py_vector) == NPY_DOUBLE) {
    466                         /*retrieve internal value: */
    467                         dvector=(double*)PyArray_DATA((PyArrayObject*)py_vector);
    468 
    469                         /*transform into bool vector: */
    470                         vector=xNew<bool>(M);
    471                         for(i=0;i<M;i++)vector[i]=(bool)dvector[i];
    472                 }
    473 
    474                 else if (PyArray_TYPE((PyArrayObject*)py_vector) == NPY_INT64) {
    475                         /*retrieve internal value: */
    476                         lvector=(long*)PyArray_DATA((PyArrayObject*)py_vector);
    477 
    478                         /*transform into bool vector: */
    479                         vector=xNew<bool>(M);
    480                         for(i=0;i<M;i++)vector[i]=(bool)lvector[i];
    481                 }
    482 
    483                 else if (PyArray_TYPE((PyArrayObject*)py_vector) == NPY_BOOL) {
    484                         /*retrieve internal value: */
    485                         bvector=(bool*)PyArray_DATA((PyArrayObject*)py_vector);
    486 
    487                         /*copy vector: */
    488                         vector=xNew<bool>(M);
    489                         memcpy(vector,bvector,(M)*sizeof(bool));
    490                 }
    491 
    492                 else
    493                         _error_("unrecognized bool pyarray type in input!");
    494         }
    495         else
    496                 vector=NULL;
     494        if     (PyArray_Check((PyArrayObject*)py_vector)) {
     495                /*retrieve dimensions: */
     496                ndim=PyArray_NDIM((const PyArrayObject*)py_vector);
     497                if      (ndim==1) {
     498                        dims=PyArray_DIMS((PyArrayObject*)py_vector);
     499                        M=dims[0];
     500                }
     501                else if (ndim==2) {
     502                        dims=PyArray_DIMS((PyArrayObject*)py_vector);
     503                        if (dims[1]==1)
     504                                M=dims[0];
     505                        else
     506                                _error_("expecting an Mx1 matrix or M vector in input!");
     507                }
     508                else
     509                        _error_("expecting an Mx1 matrix or M vector in input!");
     510
     511                if (M) {
     512                        if      (PyArray_TYPE((PyArrayObject*)py_vector) == NPY_DOUBLE) {
     513                                /*retrieve internal value: */
     514                                dvector=(double*)PyArray_DATA((PyArrayObject*)py_vector);
     515
     516                                /*transform into bool vector: */
     517                                vector=xNew<bool>(M);
     518                                for(i=0;i<M;i++)vector[i]=(bool)dvector[i];
     519                        }
     520
     521                        else if (PyArray_TYPE((PyArrayObject*)py_vector) == NPY_INT64) {
     522                                /*retrieve internal value: */
     523                                lvector=(long*)PyArray_DATA((PyArrayObject*)py_vector);
     524
     525                                /*transform into bool vector: */
     526                                vector=xNew<bool>(M);
     527                                for(i=0;i<M;i++)vector[i]=(bool)lvector[i];
     528                        }
     529
     530                        else if (PyArray_TYPE((PyArrayObject*)py_vector) == NPY_BOOL) {
     531                                /*retrieve internal value: */
     532                                bvector=(bool*)PyArray_DATA((PyArrayObject*)py_vector);
     533
     534                                /*copy vector: */
     535                                vector=xNew<bool>(M);
     536                                memcpy(vector,bvector,(M)*sizeof(bool));
     537                        }
     538
     539                        else
     540                                _error_("unrecognized bool pyarray type in input!");
     541                }
     542                else
     543                        vector=NULL;
     544        }
     545
     546        else {
     547                M=1;
     548                vector=xNew<bool>(M);
     549                FetchData(&(vector[0]),py_vector);
     550        }
    497551
    498552        /*output: */
Note: See TracChangeset for help on using the changeset viewer.