X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FMEDCoupling_Swig%2FMEDCouplingDataArrayTypemaps.i;h=8fb267b853eec982b85aa780ed12e3d0de064213;hb=95dc805fa1b8b94ef0c8509b0a597ae7aee13903;hp=1d04637275d3b45eb172e1f311d741c99b636685;hpb=5da72d398d0eb1820c3ce6dd90b8579b6b14edf5;p=tools%2Fmedcoupling.git diff --git a/src/MEDCoupling_Swig/MEDCouplingDataArrayTypemaps.i b/src/MEDCoupling_Swig/MEDCouplingDataArrayTypemaps.i index 1d0463727..8fb267b85 100644 --- a/src/MEDCoupling_Swig/MEDCouplingDataArrayTypemaps.i +++ b/src/MEDCoupling_Swig/MEDCouplingDataArrayTypemaps.i @@ -1,4 +1,4 @@ -// Copyright (C) 2007-2016 CEA/DEN, EDF R&D +// Copyright (C) 2007-2020 CEA/DEN, EDF R&D // // This library is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public @@ -16,17 +16,86 @@ // // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com // -// Author : Anthony Geay (CEA/DEN) +// Author : Anthony Geay (EDF R&D) + +#ifndef __MEDCOUPLINGDATAARRAYTYPEMAPS_I__ +#define __MEDCOUPLINGDATAARRAYTYPEMAPS_I__ + +#if PY_VERSION_HEX >= 0x03000000 +#define PyInt_AS_LONG PyLong_AS_LONG +#endif #include "InterpKernelAutoPtr.hxx" +#include "MEDCouplingDataArrayTraits.hxx" +#include "MCType.hxx" + +#include + +using namespace MEDCoupling; + +template +struct SWIGTITraits +{ }; + +template<> +struct SWIGTITraits +{ static swig_type_info *TI; static swig_type_info *TI_TUPLE; }; + +template<> +struct SWIGTITraits +{ static swig_type_info *TI; static swig_type_info *TI_TUPLE; }; + +template<> +struct SWIGTITraits +{ static swig_type_info *TI; static swig_type_info *TI_TUPLE; }; + +template<> +struct SWIGTITraits +{ static swig_type_info *TI; static swig_type_info *TI_TUPLE; }; + +swig_type_info *SWIGTITraits::TI=NULL;//unfortunately SWIGTYPE_p_MEDCoupling__DataArrayDouble is null when called here ! Postpone initialization at inlined initializeMe() +swig_type_info *SWIGTITraits::TI=NULL;//unfortunately SWIGTYPE_p_MEDCoupling__DataArrayFloat is null when called here ! Postpone initialization at inlined initializeMe() +swig_type_info *SWIGTITraits::TI=NULL;//unfortunately SWIGTYPE_p_MEDCoupling__DataArrayInt32 is null when called here ! Postpone initialization at inlined initializeMe() +swig_type_info *SWIGTITraits::TI=NULL;//unfortunately SWIGTYPE_p_MEDCoupling__DataArrayInt64 is null when called here ! Postpone initialization at inlined initializeMe() +swig_type_info *SWIGTITraits::TI_TUPLE=NULL;//unfortunately SWIGTYPE_p_MEDCoupling__DataArrayDouble is null when called here ! Postpone initialization at inlined initializeMe() +swig_type_info *SWIGTITraits::TI_TUPLE=NULL;//unfortunately SWIGTYPE_p_MEDCoupling__DataArrayFloat is null when called here ! Postpone initialization at inlined initializeMe() +swig_type_info *SWIGTITraits::TI_TUPLE=NULL;//unfortunately SWIGTYPE_p_MEDCoupling__DataArrayInt32 is null when called here ! Postpone initialization at inlined initializeMe() +swig_type_info *SWIGTITraits::TI_TUPLE=NULL;//unfortunately SWIGTYPE_p_MEDCoupling__DataArrayInt64 is null when called here ! Postpone initialization at inlined initializeMe() + +static PyObject *convertArray(MEDCoupling::DataArray *array, int owner) +{ + PyObject *ret(NULL); + if(!array) + { + Py_XINCREF(Py_None); + return Py_None; + } + if(dynamic_cast(array)) + ret=SWIG_NewPointerObj((void*)array,SWIGTYPE_p_MEDCoupling__DataArrayDouble,owner); + if(dynamic_cast(array)) + ret=SWIG_NewPointerObj((void*)array,SWIGTYPE_p_MEDCoupling__DataArrayInt32,owner); + if(dynamic_cast(array)) + ret=SWIG_NewPointerObj((void*)array,SWIGTYPE_p_MEDCoupling__DataArrayInt64,owner); + if(dynamic_cast(array)) + ret=SWIG_NewPointerObj((void*)array,SWIGTYPE_p_MEDCoupling__DataArrayFloat,owner); + if(!ret) + throw INTERP_KERNEL::Exception("Not recognized type of array on downcast !"); + return ret; +} /*! - * This method is an extention of PySlice_GetIndices but less + * This method is an extension of PySlice_GetIndices but less * open than PySlice_GetIndicesEx that accepts too many situations. */ -void GetIndicesOfSlice(PySliceObject *slice, Py_ssize_t length, Py_ssize_t *start, Py_ssize_t *stop, Py_ssize_t *step, const char *msgInCaseOfFailure) +void GetIndicesOfSlice(PyObject *slice, Py_ssize_t length, Py_ssize_t *start, Py_ssize_t *stop, Py_ssize_t *step, const char *msgInCaseOfFailure) { - int ret(PySlice_GetIndices(slice,length,start,stop,step)); + int ret(PySlice_GetIndices( +#if PY_VERSION_HEX >= 0x03000000 + slice, +#else + reinterpret_cast(slice), +#endif + length,start,stop,step)); if(ret==0) return ; if(*step>0 && *start==*stop && length==*start) @@ -37,9 +106,15 @@ void GetIndicesOfSlice(PySliceObject *slice, Py_ssize_t length, Py_ssize_t *star /*! * This method allows to retrieve slice info from \a slice. */ -void GetIndicesOfSliceExplicitely(PySliceObject *slice, Py_ssize_t *start, Py_ssize_t *stop, Py_ssize_t *step, const char *msgInCaseOfFailure) +void GetIndicesOfSliceExplicitely(PyObject *slice, Py_ssize_t *start, Py_ssize_t *stop, Py_ssize_t *step, const char *msgInCaseOfFailure) { - int ret(PySlice_GetIndices(slice,std::numeric_limits::max(),start,stop,step)); + int ret(PySlice_GetIndices( +#if PY_VERSION_HEX >= 0x03000000 + slice, +#else + reinterpret_cast(slice), +#endif + std::numeric_limits::max(),start,stop,step)); if(ret==0) { if(*start!=std::numeric_limits::max() && *stop!=std::numeric_limits::max()) @@ -51,11 +126,11 @@ void GetIndicesOfSliceExplicitely(PySliceObject *slice, Py_ssize_t *start, Py_ss throw INTERP_KERNEL::Exception(msgInCaseOfFailure); } -int InterpreteNegativeInt(int val, int nbelem) +int InterpreteNegativeInt(long val, mcIdType nbelem) { if(val<0) { - int newVal(nbelem+val); + int newVal((int)(nbelem+val)); if(newVal<0) { std::ostringstream oss; oss << "interpreteNegativeInt : request for negative int=" << val << " but number of elems is equal to " << nbelem << " !"; @@ -64,184 +139,10 @@ int InterpreteNegativeInt(int val, int nbelem) return newVal; } else - return val; + return (int)val; } #ifdef WITH_NUMPY -#include -#if NPY_API_VERSION <= 0x00000006 -# define MED_NUMPY_OWNDATA NPY_OWNDATA -#else -# define MED_NUMPY_OWNDATA NPY_ARRAY_OWNDATA -#endif - -// specific DataArray deallocator callback. This deallocator is used both in the constructor of DataArray and in the toNumPyArr -// method. This dellocator uses weakref to determine if the linked numArr is still alive or not. If alive the ownership is given to it. -// if no more alive the "standart" DataArray deallocator is called. -void numarrdeal(void *pt, void *wron) -{ - void **wronc=(void **)wron; - PyObject *weakRefOnOwner=reinterpret_cast(wronc[0]); - PyObject *obj=PyWeakref_GetObject(weakRefOnOwner); - if(obj!=Py_None) - { - Py_XINCREF(obj); - PyArrayObject *objC=reinterpret_cast(obj); - objC->flags|=MED_NUMPY_OWNDATA; - Py_XDECREF(weakRefOnOwner); - Py_XDECREF(obj); - } - else - { - typedef void (*MyDeallocator)(void *,void *); - MyDeallocator deall=(MyDeallocator)wronc[1]; - deall(pt,NULL); - Py_XDECREF(weakRefOnOwner); - } - delete [] wronc; -} - -template -struct PyCallBackDataArraySt { - PyObject_HEAD - MCData *_pt_mc; -}; - -typedef struct PyCallBackDataArraySt PyCallBackDataArrayInt; -typedef struct PyCallBackDataArraySt PyCallBackDataArrayDouble; - -extern "C" -{ - static int callbackmcdataarray___init__(PyObject *self, PyObject *args, PyObject *kwargs) { return 0; } - - static PyObject *callbackmcdataarrayint___new__(PyTypeObject *type, PyObject *args, PyObject *kwargs) - { - PyCallBackDataArrayInt *self = (PyCallBackDataArrayInt *) ( type->tp_alloc(type, 0) ); - return (PyObject *)self; - } - - static PyObject *callbackmcdataarraydouble___new__(PyTypeObject *type, PyObject *args, PyObject *kwargs) - { - PyCallBackDataArrayDouble *self = (PyCallBackDataArrayDouble *) ( type->tp_alloc(type, 0) ); - return (PyObject *)self; - } - - static void callbackmcdataarray_dealloc(PyObject *self) - { - Py_TYPE(self)->tp_free(self); - } - - // real callback called when a numpy arr having more than one DataArray instance client on it is destroyed. - // In this case, all the "weak" clients, except the first one, invoke this call back that desable the content of these "weak" clients. - static PyObject *callbackmcdataarrayint_call(PyCallBackDataArrayInt *self, PyObject *args, PyObject *kw) - { - if(self->_pt_mc) - { - MEDCoupling::MemArray& mma=self->_pt_mc->accessToMemArray(); - mma.destroy(); - } - Py_XINCREF(Py_None); - return Py_None; - } - - // real callback called when a numpy arr having more than one DataArray instance client on it is destroyed. - // In this case, all the "weak" clients, except the first one, invoke this call back that desable the content of these "weak" clients. - static PyObject *callbackmcdataarraydouble_call(PyCallBackDataArrayDouble *self, PyObject *args, PyObject *kw) - { - if(self->_pt_mc) - { - MEDCoupling::MemArray& mma=self->_pt_mc->accessToMemArray(); - mma.destroy(); - } - Py_XINCREF(Py_None); - return Py_None; - } -} - -PyTypeObject PyCallBackDataArrayInt_RefType = { - PyVarObject_HEAD_INIT(&PyType_Type, 0) - "callbackmcdataarrayint", - sizeof(PyCallBackDataArrayInt), - 0, - callbackmcdataarray_dealloc, /*tp_dealloc*/ - 0, /*tp_print*/ - 0, /*tp_getattr*/ - 0, /*tp_setattr*/ - 0, /*tp_compare*/ - 0, /*tp_repr*/ - 0, /*tp_as_number*/ - 0, /*tp_as_sequence*/ - 0, /*tp_as_mapping*/ - 0, /*tp_hash*/ - (ternaryfunc)callbackmcdataarrayint_call, /*tp_call*/ - 0, /*tp_str*/ - 0, /*tp_getattro*/ - 0, /*tp_setattro*/ - 0, /*tp_as_buffer*/ - Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, /*tp_flags*/ - 0, /*tp_doc*/ - 0, /*tp_traverse*/ - 0, /*tp_clear*/ - 0, /*tp_richcompare*/ - 0, /*tp_weaklistoffset*/ - 0, /*tp_iter*/ - 0, /*tp_iternext*/ - 0, /*tp_methods*/ - 0, /*tp_members*/ - 0, /*tp_getset*/ - 0, /*tp_base*/ - 0, /*tp_dict*/ - 0, /*tp_descr_get*/ - 0, /*tp_descr_set*/ - 0, /*tp_dictoffset*/ - callbackmcdataarray___init__, /*tp_init*/ - PyType_GenericAlloc, /*tp_alloc*/ - callbackmcdataarrayint___new__, /*tp_new*/ - PyObject_GC_Del, /*tp_free*/ -}; - -PyTypeObject PyCallBackDataArrayDouble_RefType = { - PyVarObject_HEAD_INIT(&PyType_Type, 0) - "callbackmcdataarraydouble", - sizeof(PyCallBackDataArrayDouble), - 0, - callbackmcdataarray_dealloc, /*tp_dealloc*/ - 0, /*tp_print*/ - 0, /*tp_getattr*/ - 0, /*tp_setattr*/ - 0, /*tp_compare*/ - 0, /*tp_repr*/ - 0, /*tp_as_number*/ - 0, /*tp_as_sequence*/ - 0, /*tp_as_mapping*/ - 0, /*tp_hash*/ - (ternaryfunc)callbackmcdataarraydouble_call, /*tp_call*/ - 0, /*tp_str*/ - 0, /*tp_getattro*/ - 0, /*tp_setattro*/ - 0, /*tp_as_buffer*/ - Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, /*tp_flags*/ - 0, /*tp_doc*/ - 0, /*tp_traverse*/ - 0, /*tp_clear*/ - 0, /*tp_richcompare*/ - 0, /*tp_weaklistoffset*/ - 0, /*tp_iter*/ - 0, /*tp_iternext*/ - 0, /*tp_methods*/ - 0, /*tp_members*/ - 0, /*tp_getset*/ - 0, /*tp_base*/ - 0, /*tp_dict*/ - 0, /*tp_descr_get*/ - 0, /*tp_descr_set*/ - 0, /*tp_dictoffset*/ - callbackmcdataarray___init__, /*tp_init*/ - PyType_GenericAlloc, /*tp_alloc*/ - callbackmcdataarraydouble___new__, /*tp_new*/ - PyObject_GC_Del, /*tp_free*/ -}; - // this is the second type of specific deallocator, only valid for the constructor of DataArrays taking numpy array // in input when an another DataArray is already client of this. template @@ -266,6 +167,9 @@ MCData *BuildNewInstance(PyObject *elt0, int npyObjectType, PyTypeObject *pytype if(PyArray_DESCR(elt0)->type_num != npyObjectType) { std::ostringstream oss; oss << "Input numpy array has not the type " << msg << "!"; +#ifdef _DEBUG_ + oss << " type_num == " << PyArray_DESCR(elt0)->type_num; +#endif throw INTERP_KERNEL::Exception(oss.str().c_str()); } npy_intp sz0=PyArray_DIM(elt0,0); @@ -315,7 +219,7 @@ MCData *BuildNewInstance(PyObject *elt0, int npyObjectType, PyTypeObject *pytype std::size_t nbOfElems(sz0*sz1); T *dataCpy=(T*)malloc(sizeof(T)*nbOfElems); std::copy(reinterpret_cast(data),reinterpret_cast(data)+nbOfElems,dataCpy); - ret->useArray(dataCpy,true,MEDCoupling::C_DEALLOC,sz0,sz1); + ret->useArray(dataCpy,true,MEDCoupling::DeallocType::C_DEALLOC,sz0,sz1); return ret.retn(); } typename MEDCoupling::MemArray& mma=ret->accessToMemArray(); @@ -323,26 +227,32 @@ MCData *BuildNewInstance(PyObject *elt0, int npyObjectType, PyTypeObject *pytype { PyCallBackDataArraySt *cb=PyObject_GC_New(PyCallBackDataArraySt,pytype); cb->_pt_mc=ret; - ret->useArray(reinterpret_cast(data),true,MEDCoupling::C_DEALLOC,sz0,sz1); + ret->useArray(reinterpret_cast(data),true,MEDCoupling::DeallocType::C_DEALLOC,sz0,sz1); PyObject *ref=PyWeakref_NewRef(deepestObj,(PyObject *)cb); void **objs=new void *[2]; objs[0]=cb; objs[1]=ref; mma.setParameterForDeallocator(objs); mma.setSpecificDeallocator(numarrdeal2); - //"Impossible to share this numpy array chunk of data, because already shared by an another non numpy array object (maybe an another DataArrayInt instance) ! Release it, or perform a copy on the input array !"); + //"Impossible to share this numpy array chunk of data, because already shared by an another non numpy array object (maybe an another DataArrayIdType instance) ! Release it, or perform a copy on the input array !"); } else { - ret->useArray(reinterpret_cast(data),true,MEDCoupling::C_DEALLOC,sz0,sz1); + ret->useArray(reinterpret_cast(data),true,MEDCoupling::DeallocType::C_DEALLOC_WITH_OFFSET,sz0,sz1); PyObject *ref=PyWeakref_NewRef(reinterpret_cast(eltOwning),NULL); - typename MEDCoupling::MemArray::Deallocator tmp(MEDCoupling::MemArray::CDeallocator); + typename MEDCoupling::MemArray::Deallocator tmp(MEDCoupling::MemArray::COffsetDeallocator); void **tmp2 = reinterpret_cast(&tmp); // MSVC2010 does not support constructor() - void **objs=new void *[2]; objs[0]=ref; objs[1]=*tmp2; + const char *dataEltOwning(PyArray_BYTES(eltOwning));//In case of input array is a sub array of a 2D,3D... array there is an offset + int64_t offset(0); + if(data!=dataEltOwning) + { + offset=data>dataEltOwning?-((int64_t)(std::distance(dataEltOwning,data))):(int64_t)std::distance(data,dataEltOwning); + } + void **objs=new void *[3]; objs[0]=ref; objs[1]=*tmp2; objs[2]=new int64_t(offset); mma.setParameterForDeallocator(objs); mma.setSpecificDeallocator(numarrdeal); } } else if(PyArray_ISBEHAVED_RO(elt0)) - ret->useArray(reinterpret_cast(data),false,MEDCoupling::CPP_DEALLOC,sz0,sz1); + ret->useArray(reinterpret_cast(data),false,MEDCoupling::DeallocType::CPP_DEALLOC,sz0,sz1); return ret.retn(); } @@ -369,27 +279,27 @@ int NumpyArrSetBaseObjectExt(PyArrayObject *arr, PyObject *obj) /* * Don't allow infinite chains of views, always set the base - * to the first owner of the data. - * That is, either the first object which isn't an array, + * to the first owner of the data. + * That is, either the first object which isn't an array, * or the first object which owns its own data. */ while (PyArray_Check(obj) && (PyObject *)arr != obj) { PyArrayObject *obj_arr = (PyArrayObject *)obj; PyObject *tmp; - + /* If this array owns its own data, stop collapsing */ - if (PyArray_CHKFLAGS(obj_arr, MED_NUMPY_OWNDATA )) { + if (PyArray_CHKFLAGS(obj_arr, MED_NUMPY_OWNDATA )) { break; - } + } tmp = PyArray_BASE(obj_arr); /* If there's no base, stop collapsing */ if (tmp == NULL) { break; } - /* Stop the collapse new base when the would not be of the same + /* Stop the collapse new base when the would not be of the same * type (i.e. different subclass). */ if (Py_TYPE(tmp) != Py_TYPE(arr)) { @@ -416,7 +326,7 @@ int NumpyArrSetBaseObjectExt(PyArrayObject *arr, PyObject *obj) } template -PyObject *ToNumPyArrayUnderground(MCData *self, int npyObjectType, const char *MCDataStr, int nbTuples, int nbComp) +PyObject *ToNumPyArrayUnderground(MCData *self, int npyObjectType, const char *MCDataStr, mcIdType nbTuples, std::size_t nbComp) { if(!self->isAllocated()) { @@ -426,12 +336,12 @@ PyObject *ToNumPyArrayUnderground(MCData *self, int npyObjectType, const char *M MEDCoupling::MemArray& mem=self->accessToMemArray(); if(nbComp==0) { - std::ostringstream oss; oss << MCDataStr << "::toNumPyArray : number of components of this is 0 ! Should be > 0 !"; + std::ostringstream oss; oss << MCDataStr << "::toNumPyArray : number of components of this is 0 ! Should be > 0 !"; throw INTERP_KERNEL::Exception(oss.str().c_str()); } int nbDims=nbComp==1?1:2; npy_intp dim[2]; - dim[0]=(npy_intp)nbTuples; dim[1]=nbComp; + dim[0]=(npy_intp)nbTuples; dim[1]=(npy_intp)nbComp; const T *bg=self->getConstPointer(); PyObject *ret(PyArray_SimpleNewFromData(nbDims,dim,npyObjectType,const_cast(bg))); if(mem.isDeallocatorCalled()) @@ -441,7 +351,7 @@ PyObject *ToNumPyArrayUnderground(MCData *self, int npyObjectType, const char *M PyObject *ref(PyWeakref_NewRef(ret,NULL)); typename MEDCoupling::MemArray::Deallocator tmp(mem.getDeallocator()); void **tmp2 = reinterpret_cast(&tmp); // MSVC2010 does not support constructor() - void **objs=new void *[2]; objs[0]=reinterpret_cast(ref); objs[1]=*tmp2; + void **objs=new void *[3]; objs[0]=reinterpret_cast(ref); objs[1]=*tmp2; objs[2]=new int64_t(0); mem.setParameterForDeallocator(objs); mem.setSpecificDeallocator(numarrdeal); return ret; @@ -473,32 +383,40 @@ PyObject *ToNumPyArray(MCData *self, int npyObjectType, const char *MCDataStr) return ToNumPyArrayUnderground(self,npyObjectType,MCDataStr,self->getNumberOfTuples(),self->getNumberOfComponents()); } -SWIGINTERN PyObject *MEDCoupling_DataArrayInt_toNumPyArray(MEDCoupling::DataArrayInt *self); +SWIGINTERN PyObject *MEDCoupling_DataArrayInt32_toNumPyArray(MEDCoupling::DataArrayInt32 *self); +SWIGINTERN PyObject *MEDCoupling_DataArrayInt64_toNumPyArray(MEDCoupling::DataArrayInt64 *self); SWIGINTERN PyObject *MEDCoupling_DataArrayDouble_toNumPyArray(MEDCoupling::DataArrayDouble *self); -PyObject *ToCSRMatrix(const std::vector >& m, int nbCols) throw(INTERP_KERNEL::Exception) +#endif + +#ifdef WITH_SCIPY +PyObject *ToCSRMatrix(const std::vector >& m, mcIdType nbCols) { - int nbRows((int)m.size()); - MEDCoupling::MCAuto indPtr(MEDCoupling::DataArrayInt::New()),indices(MEDCoupling::DataArrayInt::New()); + mcIdType nbRows((mcIdType)m.size()); + MEDCoupling::MCAuto indPtr(MEDCoupling::DataArrayIdType::New()),indices(MEDCoupling::DataArrayIdType::New()); MEDCoupling::MCAuto data(MEDCoupling::DataArrayDouble::New()); indPtr->alloc(nbRows+1,1); - int *intPtr_ptr(indPtr->getPointer()); intPtr_ptr[0]=0; intPtr_ptr++; - int sz2(0); - for(std::vector >::const_iterator it0=m.begin();it0!=m.end();it0++,intPtr_ptr++) + mcIdType *intPtr_ptr(indPtr->getPointer()); intPtr_ptr[0]=0; intPtr_ptr++; + mcIdType sz2(0); + for(std::vector >::const_iterator it0=m.begin();it0!=m.end();it0++,intPtr_ptr++) { - sz2+=(int)(*it0).size(); + sz2+=(mcIdType)(*it0).size(); *intPtr_ptr=sz2; } indices->alloc(sz2,1); data->alloc(sz2,1); - int *indices_ptr(indices->getPointer()); + mcIdType *indices_ptr(indices->getPointer()); double *data_ptr(data->getPointer()); - for(std::vector >::const_iterator it0=m.begin();it0!=m.end();it0++) - for(std::map::const_iterator it1=(*it0).begin();it1!=(*it0).end();it1++,indices_ptr++,data_ptr++) + for(std::vector >::const_iterator it0=m.begin();it0!=m.end();it0++) + for(std::map::const_iterator it1=(*it0).begin();it1!=(*it0).end();it1++,indices_ptr++,data_ptr++) { *indices_ptr=(*it1).first; *data_ptr=(*it1).second; } - PyObject *a(MEDCoupling_DataArrayDouble_toNumPyArray(data)),*b(MEDCoupling_DataArrayInt_toNumPyArray(indices)),*c(MEDCoupling_DataArrayInt_toNumPyArray(indPtr)); +#ifndef MEDCOUPLING_USE_64BIT_IDS + PyObject *a(MEDCoupling_DataArrayDouble_toNumPyArray(data)),*b(MEDCoupling_DataArrayInt32_toNumPyArray(indices)),*c(MEDCoupling_DataArrayInt32_toNumPyArray(indPtr)); +#else + PyObject *a(MEDCoupling_DataArrayDouble_toNumPyArray(data)),*b(MEDCoupling_DataArrayInt64_toNumPyArray(indices)),*c(MEDCoupling_DataArrayInt64_toNumPyArray(indPtr)); +#endif // PyObject *args(PyTuple_New(1)),*args0(PyTuple_New(3)),*kw(PyDict_New()),*kw1(PyTuple_New(2)); PyTuple_SetItem(args0,0,a); PyTuple_SetItem(args0,1,b); PyTuple_SetItem(args0,2,c); PyTuple_SetItem(args,0,args0); @@ -520,7 +438,7 @@ PyObject *ToCSRMatrix(const std::vector >& m, int nbCols) t #endif -static PyObject *convertDataArrayChar(MEDCoupling::DataArrayChar *dac, int owner) throw(INTERP_KERNEL::Exception) +static PyObject *convertDataArrayChar(MEDCoupling::DataArrayChar *dac, int owner) { PyObject *ret=0; if(!dac) @@ -537,7 +455,7 @@ static PyObject *convertDataArrayChar(MEDCoupling::DataArrayChar *dac, int owner return ret; } -static PyObject *convertDataArray(MEDCoupling::DataArray *dac, int owner) throw(INTERP_KERNEL::Exception) +static PyObject *convertDataArray(MEDCoupling::DataArray *dac, int owner) { PyObject *ret=0; if(!dac) @@ -547,8 +465,12 @@ static PyObject *convertDataArray(MEDCoupling::DataArray *dac, int owner) throw( } if(dynamic_cast(dac)) ret=SWIG_NewPointerObj((void*)dac,SWIGTYPE_p_MEDCoupling__DataArrayDouble,owner); - if(dynamic_cast(dac)) - ret=SWIG_NewPointerObj((void*)dac,SWIGTYPE_p_MEDCoupling__DataArrayInt,owner); + if(dynamic_cast(dac)) + ret=SWIG_NewPointerObj((void*)dac,SWIGTYPE_p_MEDCoupling__DataArrayInt32,owner); + if(dynamic_cast(dac)) + ret=SWIG_NewPointerObj((void*)dac,SWIGTYPE_p_MEDCoupling__DataArrayInt64,owner); + if(dynamic_cast(dac)) + ret=SWIG_NewPointerObj((void*)dac,SWIGTYPE_p_MEDCoupling__DataArrayFloat,owner); if(dynamic_cast(dac)) ret=SWIG_NewPointerObj((void*)dac,SWIGTYPE_p_MEDCoupling__DataArrayByte,owner); if(dynamic_cast(dac)) @@ -558,58 +480,101 @@ static PyObject *convertDataArray(MEDCoupling::DataArray *dac, int owner) throw( return ret; } -static PyObject *convertIntArrToPyList(const int *ptr, int size) throw(INTERP_KERNEL::Exception) +template +static PyObject *convertIntArrToPyList(const T *ptr, mcIdType size) { PyObject *ret=PyList_New(size); - for(int i=0;i& v) throw(INTERP_KERNEL::Exception) +template +static PyObject *convertIntArrToPyList2(const std::vector& v) { - int size=v.size(); + std::size_t size=v.size(); PyObject *ret=PyList_New(size); - for(int i=0;i& v) throw(INTERP_KERNEL::Exception) +template +static PyObject *convertIntArrToPyList3(const std::set& v) { - int size=v.size(); + std::size_t size=v.size(); PyObject *ret=PyList_New(size); - std::set::const_iterator it=v.begin(); - for(int i=0;i::const_iterator it=v.begin(); + for(std::size_t i=0;i= 0x03000000 + else if(PyUnicode_Check(obj)) + { + ret=PyUnicode_AsUTF8(obj); + return true; + } +#endif + return false; +} + +static std::string convertPyObjectToStr(PyObject *obj, const char *msg=NULL) +{ + std::string ret; + if(PyString_Check(obj)) + ret=PyString_AsString(obj); +#if PY_VERSION_HEX >= 0x03000000 + else if(PyUnicode_Check(obj)) + ret=PyUnicode_AsUTF8(obj); +#endif + else + { + std::ostringstream oss; + if(msg) + oss << msg; + else + oss << "PyWrap convertPyObjectToStr : expect a string like py object !"; + throw INTERP_KERNEL::Exception(oss.str()); + } + return ret; +} + +template +static PyObject *convertIntArrToPyListOfTuple(const T *vals, mcIdType nbOfComp, mcIdType nbOfTuples) { PyObject *ret=PyList_New(nbOfTuples); - for(int i=0;i +static T *convertPyToNewIntArr2(PyObject *pyLi, mcIdType *size) { if(PyList_Check(pyLi)) { - *size=PyList_Size(pyLi); - int *tmp=new int[*size]; - for(int i=0;i<*size;i++) + *size=ToIdType(PyList_Size(pyLi)); + T *tmp=new T[*size]; + for(mcIdType i=0;i<*size;i++) { PyObject *o=PyList_GetItem(pyLi,i); if(PyInt_Check(o)) { - int val=(int)PyInt_AS_LONG(o); + T val=(T)PyInt_AS_LONG(o); tmp[i]=val; } else @@ -622,14 +587,14 @@ static int *convertPyToNewIntArr2(PyObject *pyLi, int *size) throw(INTERP_KERNEL } else if(PyTuple_Check(pyLi)) { - *size=PyTuple_Size(pyLi); - int *tmp=new int[*size]; - for(int i=0;i<*size;i++) + *size=ToIdType(PyTuple_Size(pyLi)); + T *tmp=new T[*size]; + for(mcIdType i=0;i<*size;i++) { PyObject *o=PyTuple_GetItem(pyLi,i); if(PyInt_Check(o)) { - int val=(int)PyInt_AS_LONG(o); + T val=(T)PyInt_AS_LONG(o); tmp[i]=val; } else @@ -646,7 +611,7 @@ static int *convertPyToNewIntArr2(PyObject *pyLi, int *size) throw(INTERP_KERNEL } } -static PyObject *convertFromVectorPairInt(const std::vector< std::pair >& arr) throw(INTERP_KERNEL::Exception) +static PyObject *convertFromVectorPairInt(const std::vector< std::pair >& arr) { PyObject *ret=PyList_New(arr.size()); for(std::size_t i=0;i return ret; } -static void convertPyToVectorPairInt(PyObject *pyLi, std::vector< std::pair >& arr) throw(INTERP_KERNEL::Exception) +static void convertPyToVectorPairInt(PyObject *pyLi, std::vector< std::pair >& arr) { const char msg[]="list must contain tuples of 2 integers only or tuple must contain tuples of 2 integers only !"; if(PyList_Check(pyLi)) { - int size=PyList_Size(pyLi); + std::size_t size=PyList_Size(pyLi); arr.resize(size); - for(int i=0;i >& arr) throw(INTERP_KERNEL::Exception) +static void convertPyToVectorPairStringInt(PyObject *pyLi, std::vector< std::pair >& arr) { const char msg[]="convertPyToVectorPairStringInt : list must contain tuples of 2 integers only or tuple must contain tuples of 1 string and 1 integer only !"; if(PyList_Check(pyLi)) { - int size=PyList_Size(pyLi); + std::size_t size=PyList_Size(pyLi); arr.resize(size); - for(int i=0;i& arr) throw(INTERP_KERNEL::Exception) +template +static void convertPyToNewIntArr3(PyObject *pyLi, std::vector& arr) { if(PyList_Check(pyLi)) { - int size=PyList_Size(pyLi); + std::size_t size=PyList_Size(pyLi); arr.resize(size); - for(int i=0;i& arr) throw(I } else if(PyTuple_Check(pyLi)) { - int size=PyTuple_Size(pyLi); + std::size_t size=PyTuple_Size(pyLi); arr.resize(size); - for(int i=0;i& arr) throw(I } } -static void convertPyToNewIntArr4(PyObject *pyLi, int recurseLev, int nbOfSubPart, std::vector& arr) throw(INTERP_KERNEL::Exception) +static void convertPyToNewIntArr4(PyObject *pyLi, mcIdType recurseLev, mcIdType nbOfSubPart, std::vector& arr) { if(recurseLev<0) throw INTERP_KERNEL::Exception("convertPyToNewIntArr4 : invalid list of integers level of recursion !"); arr.clear(); if(PyList_Check(pyLi)) { - int size=PyList_Size(pyLi); - for(int i=0;i arr2; + std::vector arr2; convertPyToNewIntArr4(o,recurseLev-1,nbOfSubPart,arr2); - if(nbOfSubPart>=1 && nbOfSubPart!=(int)arr2.size()) + if(nbOfSubPart>=1 && nbOfSubPart!=(mcIdType)arr2.size()) { std::ostringstream oss; oss << "convertPyToNewIntArr4 : input list at lev " << recurseLev << " invalid nb of subpart elts expected " << nbOfSubPart << " having " << arr2.size() << " !"; throw INTERP_KERNEL::Exception(oss.str().c_str()); @@ -844,20 +806,20 @@ static void convertPyToNewIntArr4(PyObject *pyLi, int recurseLev, int nbOfSubPar } else if(PyTuple_Check(pyLi)) { - int size=PyTuple_Size(pyLi); - for(int i=0;i arr2; + std::vector arr2; convertPyToNewIntArr4(o,recurseLev-1,nbOfSubPart,arr2); - if(nbOfSubPart>=1 && nbOfSubPart!=(int)arr2.size()) + if(nbOfSubPart>=1 && nbOfSubPart!=(mcIdType)arr2.size()) { std::ostringstream oss; oss << "convertPyToNewIntArr4 : input list at lev " << recurseLev << " invalid nb of subpart elts expected " << nbOfSubPart << " having " << arr2.size() << " !"; throw INTERP_KERNEL::Exception(oss.str().c_str()); @@ -870,7 +832,7 @@ static void convertPyToNewIntArr4(PyObject *pyLi, int recurseLev, int nbOfSubPar throw INTERP_KERNEL::Exception("convertPyToNewIntArr4 : not a list nor a tuple recursively !"); } -static void checkFillArrayWithPyList(int size1, int size2, int& nbOfTuples, int& nbOfComp) throw(INTERP_KERNEL::Exception) +static void checkFillArrayWithPyList(mcIdType size1, mcIdType size2, mcIdType& nbOfTuples, mcIdType& nbOfComp) { if(nbOfTuples==-1) { @@ -910,12 +872,13 @@ static void checkFillArrayWithPyList(int size1, int size2, int& nbOfTuples, int& } } -static void fillArrayWithPyListInt3(PyObject *pyLi, int& nbOfElt, std::vector& ret) +template< class T > +static void fillArrayWithPyListInt3(PyObject *pyLi, mcIdType& nbOfElt, std::vector& ret) { static const char MSG[]="fillArrayWithPyListInt3 : It appears that the input list or tuple is composed by elts having different sizes !"; if(PyInt_Check(pyLi)) { - long val=PyInt_AS_LONG(pyLi); + T val=(T)PyInt_AS_LONG(pyLi); if(nbOfElt==-1) nbOfElt=1; else @@ -925,12 +888,12 @@ static void fillArrayWithPyListInt3(PyObject *pyLi, int& nbOfElt, std::vector fillArrayWithPyListInt2(PyObject *pyLi, int& nbOfTuples, int& nbOfComp) throw(INTERP_KERNEL::Exception) +template< class T = mcIdType > +static std::vector fillArrayWithPyListInt2(PyObject *pyLi, mcIdType& nbOfTuples, mcIdType& nbOfComp) { - std::vector ret; - int size1=-1,size2=-1; + std::vector ret; + mcIdType size1=-1,size2=-1; if(PyList_Check(pyLi)) { - size1=PyList_Size(pyLi); - for(int i=0;i fillArrayWithPyListInt2(PyObject *pyLi, int& nbOfTuples, } else if(PyTuple_Check(pyLi)) { - size1=PyTuple_Size(pyLi); - for(int i=0;i fillArrayWithPyListInt2(PyObject *pyLi, int& nbOfTuples, return ret; } -static bool fillStringVector(PyObject *pyLi, std::vector& vec) throw(INTERP_KERNEL::Exception) +static bool fillStringVector(PyObject *pyLi, std::vector& vec) { if(PyList_Check(pyLi)) { Py_ssize_t sz=PyList_Size(pyLi); vec.resize(sz); - for(int i=0;i& vec) thro { Py_ssize_t sz=PyTuple_Size(pyLi); vec.resize(sz); - for(int i=0;i& vec) thro else return false; } -static void convertPyToVectorOfVectorOfString(PyObject *pyLi, std::vector< std::vector >& arr) throw(INTERP_KERNEL::Exception) +static void convertPyToVectorOfVectorOfString(PyObject *pyLi, std::vector< std::vector >& arr) { const char msg[]="convertPyToVectorOfVectorOfString : expecting list of list of strings !"; if(PyList_Check(pyLi)) { Py_ssize_t sz=PyList_Size(pyLi); arr.resize(sz); - for(int i=0;i& vec) throw(INTERP_KERNEL::Exception) +static bool fillIntVector(PyObject *pyLi, std::vector& vec) { if(PyList_Check(pyLi)) { Py_ssize_t sz=PyList_Size(pyLi); vec.resize(sz); - for(int i=0;i& vec) throw(INTERP_KE { Py_ssize_t sz=PyTuple_Size(pyLi); vec.resize(sz); - for(int i=0;i& vec) throw(INTERP_KE return false; } -static void convertPyToVectorOfVectorOfInt(PyObject *pyLi, std::vector< std::vector >& arr) throw(INTERP_KERNEL::Exception) +static void convertPyToVectorOfVectorOfInt(PyObject *pyLi, std::vector< std::vector >& arr) { const char msg[]="convertPyToVectorOfVectorOfInt : expecting list of list of strings !"; if(PyList_Check(pyLi)) { Py_ssize_t sz=PyList_Size(pyLi); arr.resize(sz); - for(int i=0;i > >& arr) throw(INTERP_KERNEL::Exception) +static void convertPyToVectorPairStringVecString(PyObject *pyLi, std::vector< std::pair > >& arr) { const char msg[]="convertPyToVectorPairStringVecString : expecting list of tuples containing each exactly 2 items : one string and one vector of string !"; if(PyList_Check(pyLi)) { Py_ssize_t sz=PyList_Size(pyLi); arr.resize(sz); - for(int i=0;i > item; PyObject *o_0=PyTuple_GetItem(o,0); - if(!PyString_Check(o_0)) - throw INTERP_KERNEL::Exception(msg); - item.first=PyString_AsString(o_0); + item.first=convertPyObjectToStr(o_0,msg); PyObject *o_1=PyTuple_GetItem(o,1); if(!fillStringVector(o_1,item.second)) throw INTERP_KERNEL::Exception(msg); @@ -1156,19 +1114,17 @@ static void convertPyToVectorPairStringVecString(PyObject *pyLi, std::vector< st { Py_ssize_t sz=PyTuple_Size(pyLi); arr.resize(sz); - for(int i=0;i > item; PyObject *o_0=PyTuple_GetItem(o,0); - if(!PyString_Check(o_0)) - throw INTERP_KERNEL::Exception(msg); - item.first=PyString_AsString(o_0); + item.first=convertPyObjectToStr(o_0,msg); PyObject *o_1=PyTuple_GetItem(o,1); if(!fillStringVector(o_1,item.second)) throw INTERP_KERNEL::Exception(msg); @@ -1182,41 +1138,43 @@ static void convertPyToVectorPairStringVecString(PyObject *pyLi, std::vector< st throw INTERP_KERNEL::Exception(msg); } -static PyObject *convertDblArrToPyList(const double *ptr, int size) throw(INTERP_KERNEL::Exception) +template +PyObject *convertDblArrToPyList(const T *ptr, std::size_t size) { - PyObject *ret=PyList_New(size); - for(int i=0;i& v) throw(INTERP_KERNEL::Exception) +static PyObject *convertDblArrToPyList2(const std::vector& v) { - int size=v.size(); - PyObject *ret=PyList_New(size); - for(int i=0;i +PyObject *convertDblArrToPyListOfTuple(const T *vals, std::size_t nbOfComp, mcIdType nbOfTuples) { - PyObject *ret=PyList_New(nbOfTuples); - for(int i=0;i tmp=new char[nbOfComp+1]; tmp[nbOfComp]='\0'; - for(int i=0;i& ret) +static void fillArrayWithPyListDbl3(PyObject *pyLi, mcIdType& nbOfElt, std::vector& ret) { static const char MSG[]="fillArrayWithPyListDbl3 : It appears that the input list or tuple is composed by elts having different sizes !"; if(PyFloat_Check(pyLi)) @@ -1297,8 +1255,8 @@ static void fillArrayWithPyListDbl3(PyObject *pyLi, int& nbOfElt, std::vector fillArrayWithPyListDbl2(PyObject *pyLi, int& nbOfTuples, int& nbOfComp) throw(INTERP_KERNEL::Exception) +static std::vector fillArrayWithPyListDbl2(PyObject *pyLi, mcIdType& nbOfTuples, mcIdType& nbOfComp) { std::vector ret; - int size1=-1,size2=-1; + std::size_t size1=-1; + mcIdType size2=-1; if(PyList_Check(pyLi)) { size1=PyList_Size(pyLi); - for(int i=0;i fillArrayWithPyListDbl2(PyObject *pyLi, int& nbOfTupl else if(PyTuple_Check(pyLi)) { size1=PyTuple_Size(pyLi); - for(int i=0;i fillArrayWithPyListDbl2(PyObject *pyLi, int& nbOfTupl else throw INTERP_KERNEL::Exception("fillArrayWithPyListDbl2 : Unrecognized type ! Should be a tuple or a list !"); // - checkFillArrayWithPyList(size1,size2,nbOfTuples,nbOfComp); + checkFillArrayWithPyList(ToIdType(size1),ToIdType(size2),nbOfTuples,nbOfComp); return ret; } @@ -1388,9 +1347,9 @@ static void convertFromPyObjVectorOfObj(PyObject *pyLi, swig_type_info *ty, cons void *argp=0; if(PyList_Check(pyLi)) { - int size=PyList_Size(pyLi); + std::size_t size=PyList_Size(pyLi); ret.resize(size); - for(int i=0;i(inpv,SWIGTYPE_p_MEDCoupling__MEDCouplingUMesh) +template +static PyObject *convertFromVectorAutoObjToPyObj(std::vector< MCAuto >& inpVector, swig_type_info *ty) +{ + std::size_t sz(inpVector.size()); + PyObject *ret = PyList_New(sz); + for(std::size_t i=0;i cpp int sw=1 * if python list[int] -> cpp vector sw=2 * if python tuple[int] -> cpp vector sw=2 - * if python DataArrayInt -> cpp DataArrayInt sw=3 - * if python DataArrayIntTuple -> cpp DataArrayIntTuple sw=4 + * if python DataArrayIdType -> cpp DataArrayIdType sw=3 + * if python DataArrayIntTuple -> cpp DataArrayIdTypeTuple sw=4 * - * switch between (int,vector,DataArrayInt) + * switch between (int,vector,DataArrayIdType) */ -static void convertObjToPossibleCpp1(PyObject *value, int& sw, int& iTyypp, std::vector& stdvecTyypp, MEDCoupling::DataArrayInt *& daIntTyypp, MEDCoupling::DataArrayIntTuple *&daIntTuple) throw(INTERP_KERNEL::Exception) +template< class T, class ARRAY > +static void convertIntStarLikePyObjToCpp(PyObject *value, mcIdType& sw, T& iTyypp, std::vector& stdvecTyypp, ARRAY *& daIntTyypp, typename MEDCoupling::Traits< T >::ArrayTuple *&daIntTuple) { sw=-1; if(PyInt_Check(value)) { - iTyypp=(int)PyInt_AS_LONG(value); + iTyypp=(T)PyInt_AS_LONG(value); sw=1; return; } if(PyTuple_Check(value)) { - int size=PyTuple_Size(value); + std::size_t size=PyTuple_Size(value); stdvecTyypp.resize(size); - for(int i=0;i::TI,0|0); if(SWIG_IsOK(status)) { - daIntTyypp=reinterpret_cast< MEDCoupling::DataArrayInt * >(argp); + daIntTyypp=reinterpret_cast< ARRAY * >(argp); sw=3; return; } - status=SWIG_ConvertPtr(value,&argp,SWIGTYPE_p_MEDCoupling__DataArrayIntTuple,0|0); + status=SWIG_ConvertPtr(value,&argp,SWIGTITraits::TI_TUPLE,0|0); if(SWIG_IsOK(status)) - { - daIntTuple=reinterpret_cast< MEDCoupling::DataArrayIntTuple * >(argp); + { + daIntTuple=reinterpret_cast< typename MEDCoupling::Traits< T >::ArrayTuple * >(argp); sw=4; return ; } - throw INTERP_KERNEL::Exception("5 types accepted : integer, tuple of integer, list of integer, DataArrayInt, DataArrayIntTuple"); + throw INTERP_KERNEL::Exception("5 types accepted : integer, tuple of integer, list of integer, DataArrayIdType, DataArrayIdTypeTuple"); +} + +/*! + * if python int -> cpp int sw=1 + * if python list[int] -> cpp vector sw=2 + * if python tuple[int] -> cpp vector sw=2 + * if python DataArrayIdType -> cpp DataArrayIdType sw=3 + * if python DataArrayIdTypeTuple -> cpp DataArrayIdTypeTuple sw=4 + * + * switch between (int,vector,DataArrayIdType) + */ +template< class T > +static const T *convertIntStarLikePyObjToCppIntStar(PyObject *value, mcIdType& sw, mcIdType& sz, T& iTyypp, std::vector& stdvecTyypp) +{ + sw=-1; + if(PyInt_Check(value)) + { + iTyypp=(T)PyInt_AS_LONG(value); + sw=1; sz=1; + return &iTyypp; + } + if(PyTuple_Check(value)) + { + std::size_t size=PyTuple_Size(value); + stdvecTyypp.resize(size); + for(std::size_t i=0;i::TI,0|0); + if(SWIG_IsOK(status)) + { + typedef typename MEDCoupling::Traits< T >::ArrayType ARRAY; + ARRAY *daIntTyypp=reinterpret_cast< ARRAY * >(argp); + if(daIntTyypp) + { + sw=3; sz=daIntTyypp->getNbOfElems(); + return daIntTyypp->begin(); + } + else + { + sz=0; + return 0; + } + } + status=SWIG_ConvertPtr(value,&argp,SWIGTITraits::TI_TUPLE,0|0); + if(SWIG_IsOK(status)) + { + typedef typename MEDCoupling::Traits< T >::ArrayTuple ARRAYTUPLE; + ARRAYTUPLE *daIntTuple=reinterpret_cast< ARRAYTUPLE * >(argp); + sw=4; sz=ToIdType(daIntTuple->getNumberOfCompo()); + return daIntTuple->getConstPointer(); + } + throw INTERP_KERNEL::Exception("5 types accepted : integer, tuple of integer, list of integer, DataArrayIdType, DataArrayIdTypeTuple"); } /*! @@ -1511,34 +1565,35 @@ static void convertObjToPossibleCpp1(PyObject *value, int& sw, int& iTyypp, std: * if python tuple[int] -> cpp vector sw=2 * if python DataArrayDouble -> cpp DataArrayDouble sw=3 * - * switch between (int,vector,DataArrayInt) + * switch between (int,vector,DataArrayIdType) */ -static void convertObjToPossibleCpp4(PyObject *value, int& sw, double& iTyypp, std::vector& stdvecTyypp, MEDCoupling::DataArrayDouble *& daIntTyypp) throw(INTERP_KERNEL::Exception) +template +void considerPyObjAsATStarLikeObject(PyObject *value, mcIdType& sw, T& iTyypp, std::vector& stdvecTyypp, typename MEDCoupling::Traits::ArrayType *& daIntTyypp, swig_type_info *ti) { sw=-1; if(PyFloat_Check(value)) { - iTyypp=PyFloat_AS_DOUBLE(value); + iTyypp=(T)PyFloat_AS_DOUBLE(value); sw=1; return; } if(PyInt_Check(value)) { - iTyypp=(double)PyInt_AS_LONG(value); + iTyypp=(T)PyInt_AS_LONG(value); sw=1; return; } if(PyTuple_Check(value)) { - int size=PyTuple_Size(value); + std::size_t size=PyTuple_Size(value); stdvecTyypp.resize(size); - for(int i=0;i(argp); + daIntTyypp=reinterpret_cast< typename MEDCoupling::Traits::ArrayType * >(argp); sw=3; } @@ -1585,9 +1640,9 @@ static void convertObjToPossibleCpp4(PyObject *value, int& sw, double& iTyypp, s * if python tuple[int] -> cpp vector sw=2 * if python DataArrayDoubleTuple -> cpp DataArrayDoubleTuple sw=3 * - * switch between (int,vector,DataArrayInt) + * switch between (int,vector,DataArrayIdType) */ -static void convertObjToPossibleCpp44(PyObject *value, int& sw, double& iTyypp, std::vector& stdvecTyypp, MEDCoupling::DataArrayDoubleTuple *& daIntTyypp) throw(INTERP_KERNEL::Exception) +static void convertDoubleStarLikePyObjToCpp(PyObject *value, mcIdType& sw, double& iTyypp, std::vector& stdvecTyypp, MEDCoupling::DataArrayDoubleTuple *& daIntTyypp) { sw=-1; if(PyFloat_Check(value)) @@ -1604,9 +1659,9 @@ static void convertObjToPossibleCpp44(PyObject *value, int& sw, double& iTyypp, } if(PyTuple_Check(value)) { - int size=PyTuple_Size(value); + std::size_t size=PyTuple_Size(value); stdvecTyypp.resize(size); - for(int i=0;i +void convertFPStarLikePyObjToCpp_2(PyObject *value, mcIdType& sw, T& val, typename MEDCoupling::Traits::ArrayType *&d, typename MEDCoupling::Traits::ArrayTuple *&e, std::vector& f, swig_type_info *ti_da, swig_type_info *ti_tuple) +{ + sw=-1; + if(PyFloat_Check(value)) + { + val=(T)PyFloat_AS_DOUBLE(value); + sw=1; + return; + } + if(PyInt_Check(value)) + { + val=(T)PyInt_AS_LONG(value); + sw=1; + return; + } + if(PyTuple_Check(value)) + { + std::size_t size=PyTuple_Size(value); + f.resize(size); + for(std::size_t i=0;i::ArrayType * >(argp); + sw=2; + return ; + } + status=SWIG_ConvertPtr(value,&argp,ti_tuple,0|0); + if(SWIG_IsOK(status)) + { + e=reinterpret_cast< typename MEDCoupling::Traits::ArrayTuple * >(argp); + sw=3; + return ; + } + throw INTERP_KERNEL::Exception("4 types accepted : integer, double, DataArrayDouble, DataArrayDoubleTuple"); +} + +/*! + * if value int -> cpp val sw=1 + * if value double -> cpp val sw=1 + * if value DataArrayDouble -> cpp DataArrayDouble sw=2 + * if value DataArrayDoubleTuple -> cpp DataArrayDoubleTuple sw=3 + * if value list[int,double] -> cpp std::vector sw=4 + * if value tuple[int,double] -> cpp std::vector sw=4 + */ +static void convertDoubleStarLikePyObjToCpp_2(PyObject *value, mcIdType& sw, double& val, MEDCoupling::DataArrayDouble *&d, MEDCoupling::DataArrayDoubleTuple *&e, std::vector& f) +{ + convertFPStarLikePyObjToCpp_2(value,sw,val,d,e,f,SWIGTYPE_p_MEDCoupling__DataArrayDouble,SWIGTYPE_p_MEDCoupling__DataArrayDoubleTuple); +} + +/*! + * if value int -> cpp val sw=1 + * if value double -> cpp val sw=1 + * if value DataArrayDouble -> cpp DataArrayDouble sw=2 + * if value DataArrayDoubleTuple -> cpp DataArrayDoubleTuple sw=3 + * if value list[int,double] -> cpp std::vector sw=4 + * if value tuple[int,double] -> cpp std::vector sw=4 + */ +static void convertFloatStarLikePyObjToCpp_2(PyObject *value, mcIdType& sw, float& val, MEDCoupling::DataArrayFloat *&d, MEDCoupling::DataArrayFloatTuple *&e, std::vector& f) +{ + convertFPStarLikePyObjToCpp_2(value,sw,val,d,e,f,SWIGTYPE_p_MEDCoupling__DataArrayFloat,SWIGTYPE_p_MEDCoupling__DataArrayFloatTuple); +} + /*! * if python int -> cpp int sw=1 * if python list[int] -> cpp vector sw=2 * if python tuple[int] -> cpp vector sw=2 * if python slicp -> cpp pair sw=3 (begin,end,step) - * if python DataArrayInt -> cpp DataArrayInt sw=4 . The returned pointer cannot be the null pointer ! If null an exception is thrown. + * if python DataArrayIdType -> cpp DataArrayIdType sw=4 . The returned pointer cannot be the null pointer ! If null an exception is thrown. * - * switch between (int,vector,DataArrayInt) + * switch between (int,vector,DataArrayIdType) */ -static void convertObjToPossibleCpp2(PyObject *value, int nbelem, int& sw, int& iTyypp, std::vector& stdvecTyypp, std::pair >& p, MEDCoupling::DataArrayInt *& daIntTyypp) throw(INTERP_KERNEL::Exception) +template +static void convertIntStarOrSliceLikePyObjToCpp(PyObject *value, mcIdType nbelem, mcIdType& sw, T& iTyypp, std::vector& stdvecTyypp, std::pair >& p, ARRAY *& daIntTyypp) { - const char *msg="5 types accepted : integer, tuple of integer, list of integer, slice, DataArrayInt, DataArrayIntTuple"; + const char *msg="5 types accepted : integer, tuple of integer, list of integer, slice, DataArrayIdType, DataArrayIdTypeTuple"; sw=-1; if(PyInt_Check(value)) { - iTyypp=(int)PyInt_AS_LONG(value); + iTyypp=(T)PyInt_AS_LONG(value); sw=1; return; } if(PyTuple_Check(value)) { - int size=PyTuple_Size(value); + std::size_t size=PyTuple_Size(value); stdvecTyypp.resize(size); - for(int i=0;i(value); - GetIndicesOfSlice(oC,nbelem,&strt,&stp,&step,"Slice in subscriptable object DataArray invalid !"); - p.first=strt; - p.second.first=stp; - p.second.second=step; + GetIndicesOfSlice(value,nbelem,&strt,&stp,&step,"Slice in subscriptable object DataArray invalid !"); + p.first=ToIdType(strt); + p.second.first=ToIdType(stp); + p.second.second=ToIdType(step); sw=3; return ; } void *argp; - int status=SWIG_ConvertPtr(value,&argp,SWIGTYPE_p_MEDCoupling__DataArrayInt,0|0); + int status=SWIG_ConvertPtr(value,&argp,SWIGTITraits< typename ARRAY::Type >::TI,0|0); if(SWIG_IsOK(status)) { - daIntTyypp=reinterpret_cast< MEDCoupling::DataArrayInt * >(argp); + daIntTyypp=reinterpret_cast< ARRAY * >(argp); if(!daIntTyypp) { std::ostringstream oss; oss << msg << " Instance in null !"; @@ -1729,10 +1884,11 @@ static void convertObjToPossibleCpp2(PyObject *value, int nbelem, int& sw, int& sw=4; return ; } - status=SWIG_ConvertPtr(value,&argp,SWIGTYPE_p_MEDCoupling__DataArrayIntTuple,0|0); + status=SWIG_ConvertPtr(value,&argp,SWIGTITraits< typename ARRAY::Type >::TI_TUPLE,0|0); if(SWIG_IsOK(status)) { - MEDCoupling::DataArrayIntTuple *tmp=reinterpret_cast< MEDCoupling::DataArrayIntTuple * >(argp); + typedef typename MEDCoupling::Traits< typename ARRAY::Type >::ArrayTuple ARRAYTUPLE; + ARRAYTUPLE *tmp=reinterpret_cast< ARRAYTUPLE * >(argp); if(!tmp) { std::ostringstream oss; oss << msg << " Instance in null !"; @@ -1747,14 +1903,15 @@ static void convertObjToPossibleCpp2(PyObject *value, int nbelem, int& sw, int& } /*! - * Idem than convertObjToPossibleCpp2 + * Idem than convertIntStarOrSliceLikePyObjToCpp */ -static void convertObjToPossibleCpp2WithNegIntInterp(PyObject *value, int nbelem, int& sw, int& iTyypp, std::vector& stdvecTyypp, std::pair >& p, MEDCoupling::DataArrayInt *& daIntTyypp) throw(INTERP_KERNEL::Exception) +template +static void convertIntStarOrSliceLikePyObjToCppWithNegIntInterp(PyObject *value, mcIdType nbelem, mcIdType& sw, T& iTyypp, std::vector& stdvecTyypp, std::pair >& p, ARRAY *& daIntTyypp) { - convertObjToPossibleCpp2(value,nbelem,sw,iTyypp,stdvecTyypp,p,daIntTyypp); + convertIntStarOrSliceLikePyObjToCpp(value,nbelem,sw,iTyypp,stdvecTyypp,p,daIntTyypp); if(sw==1) { - iTyypp=InterpreteNegativeInt(iTyypp,nbelem); + iTyypp=(T)InterpreteNegativeInt(iTyypp,nbelem); } } @@ -1763,26 +1920,27 @@ static void convertObjToPossibleCpp2WithNegIntInterp(PyObject *value, int nbelem * if python tuple[int] -> cpp vector sw=2 * if python list[int] -> cpp vector sw=2 * if python slice -> cpp pair sw=3 - * if python DataArrayIntTuple -> cpp DataArrayIntTuple sw=4 . WARNING The returned pointer can be the null pointer ! + * if python DataArrayIdTypeTuple -> cpp DataArrayIdTypeTuple sw=4 . WARNING The returned pointer can be the null pointer ! */ -static void convertObjToPossibleCpp22(PyObject *value, int nbelem, int& sw, int& iTyypp, std::vector& stdvecTyypp, std::pair >& p, MEDCoupling::DataArrayIntTuple *& daIntTyypp) throw(INTERP_KERNEL::Exception) +template< class TUPLE_T > +static void convertObjToPossibleCpp22(PyObject *value, mcIdType nbelem, mcIdType& sw, mcIdType& iTyypp, std::vector& stdvecTyypp, std::pair >& p, typename MEDCoupling::Traits< TUPLE_T >::ArrayTuple *& daIntTyypp) { sw=-1; if(PyInt_Check(value)) { - iTyypp=(int)PyInt_AS_LONG(value); + iTyypp=ToIdType(PyInt_AS_LONG(value)); sw=1; return; } if(PyTuple_Check(value)) { - int size=PyTuple_Size(value); + std::size_t size=PyTuple_Size(value); stdvecTyypp.resize(size); - for(int i=0;i(value); - GetIndicesOfSlice(oC,nbelem,&strt,&stp,&step,"Slice in subscriptable object DataArray invalid !"); - p.first=strt; - p.second.first=stp; - p.second.second=step; + GetIndicesOfSlice(value,nbelem,&strt,&stp,&step,"Slice in subscriptable object DataArray invalid !"); + p.first=ToIdType(strt); + p.second.first=ToIdType(stp); + p.second.second=ToIdType(step); sw=3; return ; } void *argp; - int status=SWIG_ConvertPtr(value,&argp,SWIGTYPE_p_MEDCoupling__DataArrayIntTuple,0|0); + int status=SWIG_ConvertPtr(value,&argp,SWIGTITraits::TI_TUPLE,0|0); if(!SWIG_IsOK(status)) - throw INTERP_KERNEL::Exception("4 types accepted : integer, tuple of integer, list of integer, slice, DataArrayIntTuple"); - daIntTyypp=reinterpret_cast< MEDCoupling::DataArrayIntTuple * >(argp); + throw INTERP_KERNEL::Exception("4 types accepted : integer, tuple of integer, list of integer, slice, DataArrayIdTypeTuple"); + daIntTyypp=reinterpret_cast< typename MEDCoupling::Traits< TUPLE_T >::ArrayTuple * >(argp); sw=4; } @@ -1836,7 +1993,7 @@ static void convertObjToPossibleCpp22(PyObject *value, int nbelem, int& sw, int& * if python not null pointer of DataArrayChar -> cpp DataArrayChar sw=4 * switch between (int,string,vector,DataArrayChar) */ -static void convertObjToPossibleCpp6(PyObject *value, int& sw, char& cTyp, std::string& sType, std::vector& vsType, MEDCoupling::DataArrayChar *& dacType) throw(INTERP_KERNEL::Exception) +static void convertObjToPossibleCpp6(PyObject *value, mcIdType& sw, char& cTyp, std::string& sType, std::vector& vsType, MEDCoupling::DataArrayChar *& dacType) { const char *msg="4 types accepted : string, list or tuple of strings having same size, not null DataArrayChar instance."; sw=-1; @@ -1857,36 +2014,59 @@ static void convertObjToPossibleCpp6(PyObject *value, int& sw, char& cTyp, std:: return; } } - if(PyTuple_Check(value)) +#if PY_VERSION_HEX >= 0x03000000 + if(PyUnicode_Check(value)) { - int size=PyTuple_Size(value); - vsType.resize(size); - for(int i=0;i vt sw=2 * if value tuple[int] -> vt sw=2 * if value slice -> pt sw=3 - * if value DataArrayInt -> dt sw=4 + * if value DataArrayIdType -> dt sw=4 * if value tuple [int,int] -> cpp it,ip sw=5 * if value tuple [list[int],int] -> cpp vt,ip sw=6 * if value tuple [tuple[int],int] -> cpp vt,ip sw=6 @@ -1936,27 +2116,28 @@ static void convertObjToPossibleCpp6(PyObject *value, int& sw, char& cTyp, std:: * if value tuple [slice,slice] -> cpp pt,pc sw=15 * if value tuple [DaI,slice] -> cpp dt,pc sw=16 * - * switch between (int,vector,DataArrayInt) + * switch between (int,vector,DataArrayIdType) */ -static void convertObjToPossibleCpp3(PyObject *value, int nbTuple, int nbCompo, int& sw, int& it, int& ic, std::vector& vt, std::vector& vc, - std::pair >& pt, std::pair >& pc, - MEDCoupling::DataArrayInt *&dt, MEDCoupling::DataArrayInt *&dc) throw(INTERP_KERNEL::Exception) +template +static void convertObjToPossibleCpp3(PyObject *value, mcIdType nbTuple, int nbCompo, mcIdType& sw, mcIdType& it, TC& ic, std::vector& vt, std::vector& vc, + std::pair >& pt, std::pair >& pc, + MEDCoupling::DataArrayIdType *&dt, MEDCoupling::DataArrayIdType *&dc) { if(!PyTuple_Check(value)) { - convertObjToPossibleCpp2WithNegIntInterp(value,nbTuple,sw,it,vt,pt,dt); + convertIntStarOrSliceLikePyObjToCppWithNegIntInterp(value,nbTuple,sw,it,vt,pt,dt); return ; } else { - int sz=PyTuple_Size(value); + std::size_t sz=PyTuple_Size(value); if(sz!=2) throw INTERP_KERNEL::Exception("Unexpected nb of slice element : 1 or 2 expected !\n1st is for tuple selection, 2nd for component selection !"); PyObject *ob0=PyTuple_GetItem(value,0); - int sw1,sw2; - convertObjToPossibleCpp2WithNegIntInterp(ob0,nbTuple,sw1,it,vt,pt,dt); + mcIdType sw1,sw2; + convertIntStarOrSliceLikePyObjToCppWithNegIntInterp(ob0,nbTuple,sw1,it,vt,pt,dt); PyObject *ob1=PyTuple_GetItem(value,1); - convertObjToPossibleCpp2WithNegIntInterp(ob1,nbCompo,sw2,ic,vc,pc,dc); + convertIntStarOrSliceLikePyObjToCppWithNegIntInterp(ob1,nbCompo,sw2,ic,vc,pc,dc); sw=4*sw2+sw1; } } @@ -1969,89 +2150,8 @@ static void convertObjToPossibleCpp3(PyObject *value, int nbTuple, int nbCompo, * if value list[int,double] -> cpp std::vector sw=4 * if value tuple[int,double] -> cpp std::vector sw=4 */ -static void convertObjToPossibleCpp5(PyObject *value, int& sw, double& val, MEDCoupling::DataArrayDouble *&d, MEDCoupling::DataArrayDoubleTuple *&e, std::vector& f) -{ - sw=-1; - if(PyFloat_Check(value)) - { - val=PyFloat_AS_DOUBLE(value); - sw=1; - return; - } - if(PyInt_Check(value)) - { - val=(double)PyInt_AS_LONG(value); - sw=1; - return; - } - if(PyTuple_Check(value)) - { - int size=PyTuple_Size(value); - f.resize(size); - for(int i=0;i(argp); - sw=2; - return ; - } - status=SWIG_ConvertPtr(value,&argp,SWIGTYPE_p_MEDCoupling__DataArrayDoubleTuple,0|0); - if(SWIG_IsOK(status)) - { - e=reinterpret_cast< MEDCoupling::DataArrayDoubleTuple * >(argp); - sw=3; - return ; - } - throw INTERP_KERNEL::Exception("4 types accepted : integer, double, DataArrayDouble, DataArrayDoubleTuple"); -} - -/*! - * if value int -> cpp val sw=1 - * if value double -> cpp val sw=1 - * if value DataArrayDouble -> cpp DataArrayDouble sw=2 - * if value DataArrayDoubleTuple -> cpp DataArrayDoubleTuple sw=3 - * if value list[int,double] -> cpp std::vector sw=4 - * if value tuple[int,double] -> cpp std::vector sw=4 - */ -static const double *convertObjToPossibleCpp5_Safe(PyObject *value, int& sw, double& val, MEDCoupling::DataArrayDouble *&d, MEDCoupling::DataArrayDoubleTuple *&e, std::vector& f, - const char *msg, int nbTuplesExpected, int nbCompExpected, bool throwIfNullPt) throw(INTERP_KERNEL::Exception) +static const double *convertObjToPossibleCpp5_Safe(PyObject *value, mcIdType& sw, double& val, MEDCoupling::DataArrayDouble *&d, MEDCoupling::DataArrayDoubleTuple *&e, std::vector& f, + const char *msg, mcIdType nbTuplesExpected, int nbCompExpected, bool throwIfNullPt) { sw=-1; if(PyFloat_Check(value)) @@ -2060,7 +2160,7 @@ static const double *convertObjToPossibleCpp5_Safe(PyObject *value, int& sw, dou sw=1; if(nbTuplesExpected*nbCompExpected!=1) { - std::ostringstream oss; oss << msg << "dimension expected to be " << nbTuplesExpected*nbCompExpected << " , and your data in input has dimension one (single PyFloat) !"; + std::ostringstream oss; oss << msg << "dimension expected to be " << nbTuplesExpected*nbCompExpected << " , and your data in input has dimension one (single PyFloat) !"; throw INTERP_KERNEL::Exception(oss.str().c_str()); } return &val; @@ -2071,7 +2171,7 @@ static const double *convertObjToPossibleCpp5_Safe(PyObject *value, int& sw, dou sw=1; if(nbTuplesExpected*nbCompExpected!=1) { - std::ostringstream oss; oss << msg << "dimension expected to be " << nbTuplesExpected*nbCompExpected << " , and your data in input has dimension one (single PyInt) !"; + std::ostringstream oss; oss << msg << "dimension expected to be " << nbTuplesExpected*nbCompExpected << " , and your data in input has dimension one (single PyInt) !"; throw INTERP_KERNEL::Exception(oss.str().c_str()); } return &val; @@ -2080,7 +2180,7 @@ static const double *convertObjToPossibleCpp5_Safe(PyObject *value, int& sw, dou { try { - int tmp1=nbTuplesExpected,tmp2=nbCompExpected; + mcIdType tmp1=nbTuplesExpected,tmp2=nbCompExpected; std::vector ret=fillArrayWithPyListDbl2(value,tmp1,tmp2); sw=4; f=ret; @@ -2091,14 +2191,14 @@ static const double *convertObjToPossibleCpp5_Safe(PyObject *value, int& sw, dou void *argp; int status=SWIG_ConvertPtr(value,&argp,SWIGTYPE_p_MEDCoupling__DataArrayDouble,0|0); if(SWIG_IsOK(status)) - { + { d=reinterpret_cast< MEDCoupling::DataArrayDouble * >(argp); sw=2; if(d) { if(d->getNumberOfTuples()==nbTuplesExpected) { - if(d->getNumberOfComponents()==nbCompExpected) + if(ToIdType(d->getNumberOfComponents())==nbCompExpected) { return d->getConstPointer(); } @@ -2127,16 +2227,16 @@ static const double *convertObjToPossibleCpp5_Safe(PyObject *value, int& sw, dou } status=SWIG_ConvertPtr(value,&argp,SWIGTYPE_p_MEDCoupling__DataArrayDoubleTuple,0|0); if(SWIG_IsOK(status)) - { + { e=reinterpret_cast< MEDCoupling::DataArrayDoubleTuple * >(argp); sw=3; - if(e->getNumberOfCompo()==nbCompExpected) + if(ToIdType(e->getNumberOfCompo())==nbCompExpected) { if(nbTuplesExpected==1) return e->getConstPointer(); else { - std::ostringstream oss; oss << msg << "nb of tuples expected to be " << nbTuplesExpected << " , and input DataArrayDoubleTuple has always one tuple by contruction !"; + std::ostringstream oss; oss << msg << "nb of tuples expected to be " << nbTuplesExpected << " , and input DataArrayDoubleTuple has always one tuple by construction !"; throw INTERP_KERNEL::Exception(oss.str().c_str()); } } @@ -2157,8 +2257,8 @@ static const double *convertObjToPossibleCpp5_Safe(PyObject *value, int& sw, dou * if value list[int,double] -> cpp std::vector sw=4 * if value tuple[int,double] -> cpp std::vector sw=4 */ -static const double *convertObjToPossibleCpp5_Safe2(PyObject *value, int& sw, double& val, MEDCoupling::DataArrayDouble *&d, MEDCoupling::DataArrayDoubleTuple *&e, std::vector& f, - const char *msg, int nbCompExpected, bool throwIfNullPt, int& nbTuples) throw(INTERP_KERNEL::Exception) +static const double *convertObjToPossibleCpp5_Safe2(PyObject *value, mcIdType& sw, double& val, MEDCoupling::DataArrayDouble *&d, MEDCoupling::DataArrayDoubleTuple *&e, std::vector& f, + const char *msg, int nbCompExpected, bool throwIfNullPt, mcIdType& nbTuples) { sw=-1; if(PyFloat_Check(value)) @@ -2167,7 +2267,7 @@ static const double *convertObjToPossibleCpp5_Safe2(PyObject *value, int& sw, do sw=1; if(nbCompExpected!=1) { - std::ostringstream oss; oss << msg << "dimension expected to be " << nbCompExpected << " , and your data in input has dimension one (single PyFloat) !"; + std::ostringstream oss; oss << msg << "dimension expected to be " << nbCompExpected << " , and your data in input has dimension one (single PyFloat) !"; throw INTERP_KERNEL::Exception(oss.str().c_str()); } nbTuples=1; @@ -2179,7 +2279,7 @@ static const double *convertObjToPossibleCpp5_Safe2(PyObject *value, int& sw, do sw=1; if(nbCompExpected!=1) { - std::ostringstream oss; oss << msg << "dimension expected to be " << nbCompExpected << " , and your data in input has dimension one (single PyInt) !"; + std::ostringstream oss; oss << msg << "dimension expected to be " << nbCompExpected << " , and your data in input has dimension one (single PyInt) !"; throw INTERP_KERNEL::Exception(oss.str().c_str()); } nbTuples=1; @@ -2187,9 +2287,9 @@ static const double *convertObjToPossibleCpp5_Safe2(PyObject *value, int& sw, do } if(PyTuple_Check(value)) { - int size=PyTuple_Size(value); + std::size_t size=PyTuple_Size(value); f.resize(size); - for(int i=0;i(argp); sw=2; if(d) { - if(d->getNumberOfComponents()==nbCompExpected) + if(ToIdType(d->getNumberOfComponents())==nbCompExpected) { nbTuples=d->getNumberOfTuples(); return d->getConstPointer(); @@ -2269,12 +2369,12 @@ static const double *convertObjToPossibleCpp5_Safe2(PyObject *value, int& sw, do } status=SWIG_ConvertPtr(value,&argp,SWIGTYPE_p_MEDCoupling__DataArrayDoubleTuple,0|0); if(SWIG_IsOK(status)) - { + { e=reinterpret_cast< MEDCoupling::DataArrayDoubleTuple * >(argp); sw=3; if(e) { - if(e->getNumberOfCompo()==nbCompExpected) + if(ToIdType(e->getNumberOfCompo())==nbCompExpected) { nbTuples=1; return e->getConstPointer(); @@ -2307,8 +2407,8 @@ static const double *convertObjToPossibleCpp5_Safe2(PyObject *value, int& sw, do * if value list[int,double] -> cpp std::vector sw=4 * if value tuple[int,double] -> cpp std::vector sw=4 */ -static const double *convertObjToPossibleCpp5_SingleCompo(PyObject *value, int& sw, double& val, std::vector& f, - const char *msg, bool throwIfNullPt, int& nbTuples) throw(INTERP_KERNEL::Exception) +static const double *convertObjToPossibleCpp5_SingleCompo(PyObject *value, mcIdType& sw, double& val, std::vector& f, + const char *msg, bool throwIfNullPt, mcIdType& nbTuples) { MEDCoupling::DataArrayDouble *d=0; MEDCoupling::DataArrayDoubleTuple *e=0; @@ -2329,9 +2429,9 @@ static const double *convertObjToPossibleCpp5_SingleCompo(PyObject *value, int& } if(PyTuple_Check(value)) { - int size=PyTuple_Size(value); + std::size_t size=PyTuple_Size(value); f.resize(size); - for(int i=0;i(argp); sw=2; if(d) @@ -2401,12 +2501,12 @@ static const double *convertObjToPossibleCpp5_SingleCompo(PyObject *value, int& } status=SWIG_ConvertPtr(value,&argp,SWIGTYPE_p_MEDCoupling__DataArrayDoubleTuple,0|0); if(SWIG_IsOK(status)) - { + { e=reinterpret_cast< MEDCoupling::DataArrayDoubleTuple * >(argp); sw=3; if(e) { - nbTuples=e->getNumberOfCompo(); + nbTuples=ToIdType(e->getNumberOfCompo()); return e->getConstPointer(); } else @@ -2423,107 +2523,927 @@ static const double *convertObjToPossibleCpp5_SingleCompo(PyObject *value, int& throw INTERP_KERNEL::Exception("4 types accepted : integer, double, DataArrayDouble, DataArrayDoubleTuple"); } -/*! - * if python int -> cpp int sw=1 - * if python list[int] -> cpp vector sw=2 - * if python tuple[int] -> cpp vector sw=2 - * if python DataArrayInt -> cpp DataArrayInt sw=3 - * if python DataArrayIntTuple -> cpp DataArrayIntTuple sw=4 - * - * switch between (int,vector,DataArrayInt) - */ -static const int *convertObjToPossibleCpp1_Safe(PyObject *value, int& sw, int& sz, int& iTyypp, std::vector& stdvecTyypp) throw(INTERP_KERNEL::Exception) +static MEDCoupling::DataArray *CheckAndRetrieveDataArrayInstance(PyObject *obj, const char *msg) { - sw=-1; - if(PyInt_Check(value)) - { - iTyypp=(int)PyInt_AS_LONG(value); - sw=1; sz=1; - return &iTyypp; - } - if(PyTuple_Check(value)) + void *aBasePtrVS=0; + int status=SWIG_ConvertPtr(obj,&aBasePtrVS,SWIGTYPE_p_MEDCoupling__DataArray,0|0); + if(!SWIG_IsOK(status)) { - int size=PyTuple_Size(value); - stdvecTyypp.resize(size); - for(int i=0;i(aBasePtrVS); +} + +static PyObject *convertPartDefinition(MEDCoupling::PartDefinition *pd, int owner) +{ + PyObject *ret=0; + if(!pd) { - int size=PyList_Size(value); - stdvecTyypp.resize(size); - for(int i=0;i(pd)) + ret=SWIG_NewPointerObj((void*)pd,SWIGTYPE_p_MEDCoupling__DataArrayPartDefinition,owner); + else + ret=SWIG_NewPointerObj((void*)pd,SWIGTYPE_p_MEDCoupling__SlicePartDefinition,owner); + return ret; +} + +template +static typename MEDCoupling::Traits::ArrayType *DataArrayT_New(PyObject *elt0, PyObject *nbOfTuples, PyObject *elt2) +{ + const char *msgBase="MEDCoupling::DataArrayDouble::New : Available API are : \n-DataArrayDouble.New()\n-DataArrayDouble.New([1.,3.,4.])\n-DataArrayDouble.New([1.,3.,4.],3)\n-DataArrayDouble.New([1.,3.,4.,5.],2,2)\n-DataArrayDouble.New([1.,3.,4.,5.,7,8.],3,2)\n-DataArrayDouble.New([(1.,3.),(4.,5.),(7,8.)])\n-DataArrayDouble.New(5)\n-DataArrayDouble.New(5,2)"; + std::string msg(msgBase); +#ifdef WITH_NUMPY + msg+="\n-DataArrayDouble.New(numpy array with dtype=float64)"; +#endif + msg+=" !"; + if(PyList_Check(elt0) || PyTuple_Check(elt0)) + { + if(nbOfTuples) { - PyObject *o=PyList_GetItem(value,i); - if(PyInt_Check(o)) - stdvecTyypp[i]=(int)PyInt_AS_LONG(o); - else + if(PyInt_Check(nbOfTuples)) { - std::ostringstream oss; oss << "List as been detected but element #" << i << " is not integer ! only lists of integers accepted !"; - throw INTERP_KERNEL::Exception(oss.str().c_str()); + mcIdType nbOfTuples1=ToIdType(PyInt_AS_LONG(nbOfTuples)); + if(nbOfTuples1<0) + throw INTERP_KERNEL::Exception("DataArrayDouble::New : should be a positive set of allocated memory !"); + if(elt2) + { + if(PyInt_Check(elt2)) + {//DataArrayDouble.New([1.,3.,4.,5.],2,2) + mcIdType nbOfCompo=ToIdType(PyInt_AS_LONG(elt2)); + if(nbOfCompo<0) + throw INTERP_KERNEL::Exception("DataArrayDouble::New : should be a positive number of components !"); + MEDCoupling::MCAuto< typename MEDCoupling::Traits::ArrayType > ret(MEDCoupling::Traits::ArrayType::New()); + std::vector tmp(fillArrayWithPyListDbl2(elt0,nbOfTuples1,nbOfCompo)); + ret->alloc(nbOfTuples1,nbOfCompo); std::copy(tmp.begin(),tmp.end(),ret->getPointer()); + return ret.retn(); + } + else + throw INTERP_KERNEL::Exception(msg.c_str()); + } + else + {//DataArrayDouble.New([1.,3.,4.],3) + MEDCoupling::MCAuto< typename MEDCoupling::Traits::ArrayType > ret(MEDCoupling::Traits::ArrayType::New()); + mcIdType tmpp1(-1); + std::vector tmp(fillArrayWithPyListDbl2(elt0,nbOfTuples1,tmpp1)); + ret->alloc(nbOfTuples1,tmpp1); std::copy(tmp.begin(),tmp.end(),ret->getPointer()); + return ret.retn(); + } } + else + throw INTERP_KERNEL::Exception(msg.c_str()); + } + else + {// DataArrayDouble.New([1.,3.,4.]) + MEDCoupling::MCAuto< typename MEDCoupling::Traits::ArrayType > ret(MEDCoupling::Traits::ArrayType::New()); + mcIdType tmpp1(-1),tmpp2(-1); + std::vector tmp=fillArrayWithPyListDbl2(elt0,tmpp1,tmpp2); + ret->alloc(tmpp1,tmpp2); std::copy(tmp.begin(),tmp.end(),ret->getPointer()); + return ret.retn(); } - sw=2; sz=size; - return &stdvecTyypp[0]; } - void *argp; - int status=SWIG_ConvertPtr(value,&argp,SWIGTYPE_p_MEDCoupling__DataArrayInt,0|0); - if(SWIG_IsOK(status)) + else if(PyInt_Check(elt0)) { - MEDCoupling::DataArrayInt *daIntTyypp=reinterpret_cast< MEDCoupling::DataArrayInt * >(argp); - if(daIntTyypp) + mcIdType nbOfTuples1(ToIdType(PyInt_AS_LONG(elt0))); + if(nbOfTuples1<0) + throw INTERP_KERNEL::Exception("DataArrayDouble::New : should be a positive set of allocated memory !"); + if(nbOfTuples) { - sw=3; sz=daIntTyypp->getNbOfElems(); - return daIntTyypp->begin(); + if(!elt2) + { + if(PyInt_Check(nbOfTuples)) + {//DataArrayDouble.New(5,2) + mcIdType nbOfCompo=ToIdType(PyInt_AS_LONG(nbOfTuples)); + if(nbOfCompo<0) + throw INTERP_KERNEL::Exception("DataArrayDouble::New : should be a positive number of components !"); + MEDCoupling::MCAuto< typename MEDCoupling::Traits::ArrayType > ret(MEDCoupling::Traits::ArrayType::New()); + ret->alloc(nbOfTuples1,nbOfCompo); + return ret.retn(); + } + else + throw INTERP_KERNEL::Exception(msg.c_str()); + } + else + throw INTERP_KERNEL::Exception(msg.c_str()); } else - { - sz=0; - return 0; + {//DataArrayDouble.New(5) + MEDCoupling::MCAuto< typename MEDCoupling::Traits::ArrayType > ret(MEDCoupling::Traits::ArrayType::New()); + ret->alloc(nbOfTuples1,1); + return ret.retn(); } } - status=SWIG_ConvertPtr(value,&argp,SWIGTYPE_p_MEDCoupling__DataArrayIntTuple,0|0); - if(SWIG_IsOK(status)) - { - MEDCoupling::DataArrayIntTuple *daIntTuple=reinterpret_cast< MEDCoupling::DataArrayIntTuple * >(argp); - sw=4; sz=daIntTuple->getNumberOfCompo(); - return daIntTuple->getConstPointer(); +#ifdef WITH_NUMPY + else if(PyArray_Check(elt0) && nbOfTuples==NULL && elt2==NULL) + {//DataArrayDouble.New(numpyArray) + return BuildNewInstance< typename MEDCoupling::Traits::ArrayType , T >(elt0,NPYTraits::NPYObjectType,NPYTraits::NPYFunc,MEDCoupling::Traits::NPYStr); } - throw INTERP_KERNEL::Exception("5 types accepted : integer, tuple of integer, list of integer, DataArrayInt, DataArrayIntTuple"); +#endif + else + throw INTERP_KERNEL::Exception(msg.c_str()); + throw INTERP_KERNEL::Exception(msg.c_str());//to make g++ happy } -static MEDCoupling::DataArray *CheckAndRetrieveDataArrayInstance(PyObject *obj, const char *msg) +template +typename MEDCoupling::Traits::ArrayType *DataArrayT__setitem__internal(typename MEDCoupling::Traits::ArrayType *self, PyObject *obj, PyObject *value, swig_type_info *ti) { - void *aBasePtrVS=0; - int status=SWIG_ConvertPtr(obj,&aBasePtrVS,SWIGTYPE_p_MEDCoupling__DataArray,0|0); - if(!SWIG_IsOK(status)) + self->checkAllocated(); + const char msg[]="Unexpected situation in DataArrayDouble::__setitem__ !"; + mcIdType nbOfTuples(self->getNumberOfTuples()); + int nbOfComponents((int)(self->getNumberOfComponents())); + mcIdType sw1,sw2; + T i1; + std::vector v1; + typename MEDCoupling::Traits::ArrayType *d1=0; + considerPyObjAsATStarLikeObject(value,sw1,i1,v1,d1,ti); + mcIdType it1,ic1; + std::vector vt1; + std::vector vc1; + std::pair > pt1,pc1; + MEDCoupling::DataArrayIdType *dt1=0,*dc1=0; + convertObjToPossibleCpp3(obj,nbOfTuples,nbOfComponents,sw2,it1,ic1,vt1,vc1,pt1,pc1,dt1,dc1); + MEDCoupling::MCAuto< typename MEDCoupling::Traits::ArrayType > tmp; + switch(sw2) + { + case 1: + { + switch(sw1) + { + case 1: + self->setPartOfValuesSimple1(i1,it1,it1+1,1,0,nbOfComponents,1); + return self; + case 2: + tmp=MEDCoupling::Traits::ArrayType::New(); + tmp->useArray(&v1[0],false,MEDCoupling::DeallocType::CPP_DEALLOC,1,v1.size()); + self->setPartOfValues1(tmp,it1,it1+1,1,0,nbOfComponents,1,false); + return self; + case 3: + self->setPartOfValues1(d1,it1,it1+1,1,0,nbOfComponents,1); + return self; + default: + throw INTERP_KERNEL::Exception(msg); + } + break; + } + case 2: + { + switch(sw1) + { + case 1: + self->setPartOfValuesSimple3(i1,&vt1[0],&vt1[0]+vt1.size(),0,nbOfComponents,1); + return self; + case 2: + tmp=MEDCoupling::Traits::ArrayType::New(); + tmp->useArray(&v1[0],false,MEDCoupling::DeallocType::CPP_DEALLOC,1,v1.size()); + self->setPartOfValues3(tmp,&vt1[0],&vt1[0]+vt1.size(),0,nbOfComponents,1,false); + return self; + case 3: + self->setPartOfValues3(d1,&vt1[0],&vt1[0]+vt1.size(),0,nbOfComponents,1); + return self; + default: + throw INTERP_KERNEL::Exception(msg); + } + break; + } + case 3: + { + switch(sw1) + { + case 1: + self->setPartOfValuesSimple1(i1,pt1.first,pt1.second.first,pt1.second.second,0,nbOfComponents,1); + return self; + case 2: + tmp=MEDCoupling::Traits::ArrayType::New(); + tmp->useArray(&v1[0],false,MEDCoupling::DeallocType::CPP_DEALLOC,1,v1.size()); + self->setPartOfValues1(tmp,pt1.first,pt1.second.first,pt1.second.second,0,nbOfComponents,1,false); + return self; + case 3: + self->setPartOfValues1(d1,pt1.first,pt1.second.first,pt1.second.second,0,nbOfComponents,1); + return self; + default: + throw INTERP_KERNEL::Exception(msg); + } + break; + } + case 4: + { + switch(sw1) + { + case 1: + self->setPartOfValuesSimple3(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),0,nbOfComponents,1); + return self; + case 2: + tmp=MEDCoupling::Traits::ArrayType::New(); + tmp->useArray(&v1[0],false,MEDCoupling::DeallocType::CPP_DEALLOC,1,v1.size()); + self->setPartOfValues3(tmp,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),0,nbOfComponents,1,false); + return self; + case 3: + self->setPartOfValues3(d1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),0,nbOfComponents,1); + return self; + default: + throw INTERP_KERNEL::Exception(msg); + } + break; + } + case 5: + { + switch(sw1) + { + case 1: + self->setPartOfValuesSimple1(i1,it1,it1+1,1,ic1,ic1+1,1); + return self; + case 2: + tmp=MEDCoupling::Traits::ArrayType::New(); + tmp->useArray(&v1[0],false,MEDCoupling::DeallocType::CPP_DEALLOC,1,v1.size()); + self->setPartOfValues1(tmp,it1,it1+1,1,ic1,ic1+1,1,false); + return self; + case 3: + self->setPartOfValues1(d1,it1,it1+1,1,ic1,ic1+1,1); + return self; + default: + throw INTERP_KERNEL::Exception(msg); + } + break; + } + case 6: + { + switch(sw1) + { + case 1: + self->setPartOfValuesSimple3(i1,&vt1[0],&vt1[0]+vt1.size(),ic1,ic1+1,1); + return self; + case 2: + tmp=MEDCoupling::Traits::ArrayType::New(); + tmp->useArray(&v1[0],false,MEDCoupling::DeallocType::CPP_DEALLOC,1,v1.size()); + self->setPartOfValues3(tmp,&vt1[0],&vt1[0]+vt1.size(),ic1,ic1+1,1,false); + return self; + case 3: + self->setPartOfValues3(d1,&vt1[0],&vt1[0]+vt1.size(),ic1,ic1+1,1); + return self; + default: + throw INTERP_KERNEL::Exception(msg); + } + break; + } + case 7: + { + switch(sw1) + { + case 1: + self->setPartOfValuesSimple1(i1,pt1.first,pt1.second.first,pt1.second.second,ic1,ic1+1,1); + return self; + case 2: + tmp=MEDCoupling::Traits::ArrayType::New(); + tmp->useArray(&v1[0],false,MEDCoupling::DeallocType::CPP_DEALLOC,1,v1.size()); + self->setPartOfValues1(tmp,pt1.first,pt1.second.first,pt1.second.second,ic1,ic1+1,1,false); + return self; + case 3: + self->setPartOfValues1(d1,pt1.first,pt1.second.first,pt1.second.second,ic1,ic1+1,1); + return self; + default: + throw INTERP_KERNEL::Exception(msg); + } + break; + } + case 8: + { + switch(sw1) + { + case 1: + self->setPartOfValuesSimple3(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),ic1,ic1+1,1); + return self; + case 2: + tmp=MEDCoupling::Traits::ArrayType::New(); + tmp->useArray(&v1[0],false,MEDCoupling::DeallocType::CPP_DEALLOC,1,v1.size()); + self->setPartOfValues3(tmp,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),ic1,ic1+1,1,false); + return self; + case 3: + self->setPartOfValues3(d1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),ic1,ic1+1,1); + return self; + default: + throw INTERP_KERNEL::Exception(msg); + } + break; + } + case 9: + { + switch(sw1) + { + case 1: + self->setPartOfValuesSimple2(i1,&it1,&it1+1,&vc1[0],&vc1[0]+vc1.size()); + return self; + case 2: + tmp=MEDCoupling::Traits::ArrayType::New(); + tmp->useArray(&v1[0],false,MEDCoupling::DeallocType::CPP_DEALLOC,1,v1.size()); + self->setPartOfValues2(tmp,&it1,&it1+1,&vc1[0],&vc1[0]+vc1.size(),false); + return self; + case 3: + self->setPartOfValues2(d1,&it1,&it1+1,&vc1[0],&vc1[0]+vc1.size()); + return self; + default: + throw INTERP_KERNEL::Exception(msg); + } + break; + } + case 10: + { + switch(sw1) + { + case 1: + self->setPartOfValuesSimple2(i1,&vt1[0],&vt1[0]+vt1.size(),&vc1[0],&vc1[0]+vc1.size()); + return self; + case 2: + tmp=MEDCoupling::Traits::ArrayType::New(); + tmp->useArray(&v1[0],false,MEDCoupling::DeallocType::CPP_DEALLOC,1,v1.size()); + self->setPartOfValues2(tmp,&vt1[0],&vt1[0]+vt1.size(),&vc1[0],&vc1[0]+vc1.size(),false); + return self; + case 3: + self->setPartOfValues2(d1,&vt1[0],&vt1[0]+vt1.size(),&vc1[0],&vc1[0]+vc1.size()); + return self; + default: + throw INTERP_KERNEL::Exception(msg); + } + break; + } + case 11: + { + switch(sw1) + { + case 1: + self->setPartOfValuesSimple4(i1,pt1.first,pt1.second.first,pt1.second.second,&vc1[0],&vc1[0]+vc1.size()); + return self; + case 2: + tmp=MEDCoupling::Traits::ArrayType::New(); + tmp->useArray(&v1[0],false,MEDCoupling::DeallocType::CPP_DEALLOC,1,v1.size()); + self->setPartOfValues4(tmp,pt1.first,pt1.second.first,pt1.second.second,&vc1[0],&vc1[0]+vc1.size(),false); + return self; + case 3: + self->setPartOfValues4(d1,pt1.first,pt1.second.first,pt1.second.second,&vc1[0],&vc1[0]+vc1.size()); + return self; + default: + throw INTERP_KERNEL::Exception(msg); + } + break; + } + case 12: + { + switch(sw1) + { + case 1: + self->setPartOfValuesSimple2(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),&vc1[0],&vc1[0]+vc1.size()); + return self; + case 2: + tmp=MEDCoupling::Traits::ArrayType::New(); + tmp->useArray(&v1[0],false,MEDCoupling::DeallocType::CPP_DEALLOC,1,v1.size()); + self->setPartOfValues2(tmp,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),&vc1[0],&vc1[0]+vc1.size(),false); + return self; + case 3: + self->setPartOfValues2(d1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),&vc1[0],&vc1[0]+vc1.size()); + return self; + default: + throw INTERP_KERNEL::Exception(msg); + } + break; + } + case 13: + { + switch(sw1) + { + case 1: + self->setPartOfValuesSimple1(i1,it1,it1+1,1,pc1.first,pc1.second.first,pc1.second.second); + return self; + case 2: + tmp=MEDCoupling::Traits::ArrayType::New(); + tmp->useArray(&v1[0],false,MEDCoupling::DeallocType::CPP_DEALLOC,1,v1.size()); + self->setPartOfValues1(tmp,it1,it1+1,1,pc1.first,pc1.second.first,pc1.second.second,false); + return self; + case 3: + self->setPartOfValues1(d1,it1,it1+1,1,pc1.first,pc1.second.first,pc1.second.second); + return self; + default: + throw INTERP_KERNEL::Exception(msg); + } + break; + } + case 14: + { + switch(sw1) + { + case 1: + self->setPartOfValuesSimple3(i1,&vt1[0],&vt1[0]+vt1.size(),pc1.first,pc1.second.first,pc1.second.second); + return self; + case 2: + tmp=MEDCoupling::Traits::ArrayType::New(); + tmp->useArray(&v1[0],false,MEDCoupling::DeallocType::CPP_DEALLOC,1,v1.size()); + self->setPartOfValues3(tmp,&vt1[0],&vt1[0]+vt1.size(),pc1.first,pc1.second.first,pc1.second.second,false); + return self; + case 3: + self->setPartOfValues3(d1,&vt1[0],&vt1[0]+vt1.size(),pc1.first,pc1.second.first,pc1.second.second); + return self; + default: + throw INTERP_KERNEL::Exception(msg); + } + break; + } + case 15: + { + switch(sw1) + { + case 1: + self->setPartOfValuesSimple1(i1,pt1.first,pt1.second.first,pt1.second.second,pc1.first,pc1.second.first,pc1.second.second); + return self; + case 2: + tmp=MEDCoupling::Traits::ArrayType::New(); + tmp->useArray(&v1[0],false,MEDCoupling::DeallocType::CPP_DEALLOC,1,v1.size()); + self->setPartOfValues1(tmp,pt1.first,pt1.second.first,pt1.second.second,pc1.first,pc1.second.first,pc1.second.second,false); + return self; + case 3: + self->setPartOfValues1(d1,pt1.first,pt1.second.first,pt1.second.second,pc1.first,pc1.second.first,pc1.second.second); + return self; + default: + throw INTERP_KERNEL::Exception(msg); + } + break; + } + case 16: + { + switch(sw1) + { + case 1: + self->setPartOfValuesSimple3(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),pc1.first,pc1.second.first,pc1.second.second); + return self; + case 2: + tmp=MEDCoupling::Traits::ArrayType::New(); + tmp->useArray(&v1[0],false,MEDCoupling::DeallocType::CPP_DEALLOC,1,v1.size()); + self->setPartOfValues3(tmp,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),pc1.first,pc1.second.first,pc1.second.second,false); + return self; + case 3: + self->setPartOfValues3(d1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),pc1.first,pc1.second.first,pc1.second.second); + return self; + default: + throw INTERP_KERNEL::Exception(msg); + } + break; + } + default: + throw INTERP_KERNEL::Exception(msg); + } + return self; +} + +template +PyObject *DataArrayT__getitem__internal(const typename MEDCoupling::Traits::ArrayType *self, PyObject *obj, swig_type_info *ti) +{ + const char msg[]="Unexpected situation in DataArrayDouble::__getitem__ !"; + const char msg2[]="DataArrayDouble::__getitem__ : Mismatch of slice values in 2nd parameter (components) !"; + self->checkAllocated(); + mcIdType nbOfTuples(self->getNumberOfTuples()); + int nbOfComponents((int)(self->getNumberOfComponents())); + mcIdType it1; + std::size_t ic1; + std::vector vt1; + std::vector vc1; + std::pair > pt1,pc1; + MEDCoupling::DataArrayIdType *dt1=0,*dc1=0; + mcIdType sw; + convertObjToPossibleCpp3(obj,nbOfTuples,nbOfComponents,sw,it1,ic1,vt1,vc1,pt1,pc1,dt1,dc1); + MEDCoupling::MCAuto::ArrayType > ret; + switch(sw) + { + case 1: + if(nbOfComponents==1) + return PyFloat_FromDouble((T)self->getIJSafe(it1,0)); + return SWIG_NewPointerObj(SWIG_as_voidptr(self->selectByTupleIdSafe(&it1,&it1+1)),ti, SWIG_POINTER_OWN | 0 ); + case 2: + return SWIG_NewPointerObj(SWIG_as_voidptr(self->selectByTupleIdSafe(&vt1[0],&vt1[0]+vt1.size())),ti, SWIG_POINTER_OWN | 0 ); + case 3: + return SWIG_NewPointerObj(SWIG_as_voidptr(self->selectByTupleIdSafeSlice(pt1.first,pt1.second.first,pt1.second.second)),ti, SWIG_POINTER_OWN | 0 ); + case 4: + return SWIG_NewPointerObj(SWIG_as_voidptr(self->selectByTupleIdSafe(dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems())),ti, SWIG_POINTER_OWN | 0 ); + case 5: + return PyFloat_FromDouble((T)self->getIJSafe(it1,ic1)); + case 6: + { + ret=self->selectByTupleIdSafe(&vt1[0],&vt1[0]+vt1.size()); + std::vector v2(1,ic1); + return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(v2)),ti, SWIG_POINTER_OWN | 0 ); + } + case 7: + { + ret=self->selectByTupleIdSafeSlice(pt1.first,pt1.second.first,pt1.second.second); + std::vector v2(1,ic1); + return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(v2)),ti, SWIG_POINTER_OWN | 0 ); + } + case 8: + { + ret=self->selectByTupleIdSafe(dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems()); + std::vector v2(1,ic1); + return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(v2)),ti, SWIG_POINTER_OWN | 0 ); + } + case 9: + { + ret=self->selectByTupleIdSafe(&it1,&it1+1); + return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(vc1)),ti, SWIG_POINTER_OWN | 0 ); + } + case 10: + { + ret=self->selectByTupleIdSafe(&vt1[0],&vt1[0]+vt1.size()); + return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(vc1)),ti, SWIG_POINTER_OWN | 0 ); + } + case 11: + { + ret=self->selectByTupleIdSafeSlice(pt1.first,pt1.second.first,pt1.second.second); + return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(vc1)),ti, SWIG_POINTER_OWN | 0 ); + } + case 12: + { + ret=self->selectByTupleIdSafe(dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems()); + return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(vc1)),ti, SWIG_POINTER_OWN | 0 ); + } + case 13: + { + ret=self->selectByTupleIdSafe(&it1,&it1+1); + mcIdType nbOfComp(MEDCoupling::DataArray::GetNumberOfItemGivenBESRelative(pc1.first,pc1.second.first,pc1.second.second,msg2)); + std::vector v2(nbOfComp); + for(mcIdType i=0;ikeepSelectedComponents(v2)),ti, SWIG_POINTER_OWN | 0 ); + } + case 14: + { + ret=self->selectByTupleIdSafe(&vt1[0],&vt1[0]+vt1.size()); + mcIdType nbOfComp(MEDCoupling::DataArray::GetNumberOfItemGivenBESRelative(pc1.first,pc1.second.first,pc1.second.second,msg2)); + std::vector v2(nbOfComp); + for(int i=0;ikeepSelectedComponents(v2)),ti, SWIG_POINTER_OWN | 0 ); + } + case 15: + { + ret=self->selectByTupleIdSafeSlice(pt1.first,pt1.second.first,pt1.second.second); + mcIdType nbOfComp(MEDCoupling::DataArray::GetNumberOfItemGivenBESRelative(pc1.first,pc1.second.first,pc1.second.second,msg2)); + std::vector v2(nbOfComp); + for(int i=0;ikeepSelectedComponents(v2)),ti, SWIG_POINTER_OWN | 0 ); + } + case 16: + { + ret=self->selectByTupleIdSafe(dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems()); + mcIdType nbOfComp(MEDCoupling::DataArray::GetNumberOfItemGivenBESRelative(pc1.first,pc1.second.first,pc1.second.second,msg2)); + std::vector v2(nbOfComp); + for(int i=0;ikeepSelectedComponents(v2)),ti, SWIG_POINTER_OWN | 0 ); + } + default: + throw INTERP_KERNEL::Exception(msg); + } +} + +bool isCSRMatrix(PyObject *m) +{ +#if defined(WITH_NUMPY) && defined(WITH_SCIPY) + PyObject* pdict(PyDict_New()); + PyDict_SetItemString(pdict, "__builtins__", PyEval_GetBuiltins()); + PyObject *tmp(PyRun_String("from scipy.sparse import csr_matrix", Py_single_input, pdict, pdict)); + if(!tmp) + throw INTERP_KERNEL::Exception("Problem during loading csr_matrix in scipy.sparse ! Is Scipy module available in present ?"); + PyObject *csrMatrixCls=PyDict_GetItemString(pdict,"csr_matrix"); + if(!csrMatrixCls) + throw INTERP_KERNEL::Exception("csr_matrix not found in scipy.sparse ! Is Scipy module available in present ?"); + bool ret(PyObject_IsInstance(m,csrMatrixCls)); + Py_DECREF(pdict); Py_XDECREF(tmp); + return ret; +#else + return false; +#endif +} + +void convertCSR_MCDataToVectMapIntDouble(const MEDCoupling::DataArrayInt32 *indptrPtr, const MEDCoupling::DataArrayInt32 *indicesPtr, const MEDCoupling::DataArrayDouble *dataPtr, std::vector >& mCpp) +{ + auto nbOfRows(indptrPtr->getNumberOfTuples()-1); + if(nbOfRows<0) + throw INTERP_KERNEL::Exception("pywrap of MEDCouplingRemapper::setMatrix : input CSR matrix looks bad regarding indptr array !"); + mCpp.resize(nbOfRows); + auto indPtrCPtr(indptrPtr->begin()); + auto indicesCPtr(indicesPtr->begin()); + auto dataCPtr(dataPtr->begin()); + for(auto i=0;i >& mCpp) +{ + if(!PyList_Check(pyobj)) + throw INTERP_KERNEL::Exception("convertToVectMapIntDouble : input is not a python list !"); + mCpp.clear(); + Py_ssize_t sz(PyList_Size(pyobj)); + mCpp.resize(sz); + for(Py_ssize_t i=0;i& mapCpp(mCpp[i]); + while(PyDict_Next(elt,&pos,&key,&value)) + { + if(!PyInt_Check(key)) { - status=SWIG_ConvertPtr(obj,&aBasePtrVS,SWIGTYPE_p_MEDCoupling__DataArrayAsciiChar,0|0); - if(!SWIG_IsOK(status)) - { - status=SWIG_ConvertPtr(obj,&aBasePtrVS,SWIGTYPE_p_MEDCoupling__DataArrayByte,0|0); - std::ostringstream oss; oss << msg << " ! Accepted instances are DataArrayDouble, DataArrayInt, DataArrayAsciiChar, DataArrayByte !"; - throw INTERP_KERNEL::Exception(oss.str().c_str()); - } + std::ostringstream oss; oss << "convertToVectMapIntDouble : at pos # " << i << " of pylist the dict contains at pos " << pos << " a key not mappable to pyint !"; + throw INTERP_KERNEL::Exception(oss.str()); + } + if(!PyFloat_Check(value)) + { + std::ostringstream oss; oss << "convertToVectMapIntDouble : at pos # " << i << " of pylist the dict contains at pos " << pos << " the value not mappable to pyfloat !"; + throw INTERP_KERNEL::Exception(oss.str()); } + mapCpp[ToIdType(PyInt_AS_LONG(key))]=PyFloat_AS_DOUBLE(value); } } - return reinterpret_cast< MEDCoupling::DataArray * >(aBasePtrVS); } + +template +PyObject *DataArrayT_imul__internal(PyObject *trueSelf, PyObject *obj, typename MEDCoupling::Traits::ArrayType *self, swig_type_info *ti_da, swig_type_info *ti_tuple) +{ + const char msg[]="Unexpected situation in __imul__ !"; + T val; + typename MEDCoupling::Traits::ArrayType *a; + typename MEDCoupling::Traits::ArrayTuple *aa; + std::vector bb; + mcIdType sw; + convertFPStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb,ti_da,ti_tuple); + switch(sw) + { + case 1: + { + self->applyLin(val,0.); + Py_XINCREF(trueSelf); + return trueSelf; + } + case 2: + { + self->multiplyEqual(a); + Py_XINCREF(trueSelf); + return trueSelf; + } + case 3: + { + MEDCoupling::MCAuto< typename MEDCoupling::Traits::ArrayType > aaa(aa->buildDA(1,self->getNumberOfComponents())); + self->multiplyEqual(aaa); + Py_XINCREF(trueSelf); + return trueSelf; + } + case 4: + { + MEDCoupling::MCAuto< typename MEDCoupling::Traits::ArrayType > aaa(MEDCoupling::Traits::ArrayType::New()); aaa->useArray(&bb[0],false,MEDCoupling::DeallocType::CPP_DEALLOC,1,bb.size()); + self->multiplyEqual(aaa); + Py_XINCREF(trueSelf); + return trueSelf; + } + default: + throw INTERP_KERNEL::Exception(msg); + } +} + +template +PyObject *DataArrayT_idiv__internal(PyObject *trueSelf, PyObject *obj, typename MEDCoupling::Traits::ArrayType *self, swig_type_info *ti_da, swig_type_info *ti_tuple) +{ + const char msg[]="Unexpected situation in __idiv__ !"; + T val; + typename MEDCoupling::Traits::ArrayType *a; + typename MEDCoupling::Traits::ArrayTuple *aa; + std::vector bb; + mcIdType sw; + convertFPStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb,ti_da,ti_tuple); + switch(sw) + { + case 1: + { + if(val==0.) + throw INTERP_KERNEL::Exception("DataArrayDouble::__div__ : trying to divide by zero !"); + self->applyLin((T)(1./val),(T)0.); + Py_XINCREF(trueSelf); + return trueSelf; + } + case 2: + { + self->divideEqual(a); + Py_XINCREF(trueSelf); + return trueSelf; + } + case 3: + { + MEDCoupling::MCAuto< typename MEDCoupling::Traits::ArrayType > aaa(aa->buildDA(1,self->getNumberOfComponents())); + self->divideEqual(aaa); + Py_XINCREF(trueSelf); + return trueSelf; + } + case 4: + { + MEDCoupling::MCAuto< typename MEDCoupling::Traits::ArrayType > aaa(MEDCoupling::Traits::ArrayType::New()); aaa->useArray(&bb[0],false,MEDCoupling::DeallocType::CPP_DEALLOC,1,bb.size()); + self->divideEqual(aaa); + Py_XINCREF(trueSelf); + return trueSelf; + } + default: + throw INTERP_KERNEL::Exception(msg); + } +} + +template +PyObject *DataArrayT_iadd__internal(PyObject *trueSelf, PyObject *obj, typename MEDCoupling::Traits::ArrayType *self, swig_type_info *ti_da, swig_type_info *ti_tuple) +{ + const char msg[]="Unexpected situation in __iadd__ !"; + T val; + typename MEDCoupling::Traits::ArrayType *a; + typename MEDCoupling::Traits::ArrayTuple *aa; + std::vector bb; + mcIdType sw; + convertFPStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb,ti_da,ti_tuple); + switch(sw) + { + case 1: + { + self->applyLin(1.,val); + Py_XINCREF(trueSelf); + return trueSelf; + } + case 2: + { + self->addEqual(a); + Py_XINCREF(trueSelf); + return trueSelf; + } + case 3: + { + MEDCoupling::MCAuto< typename MEDCoupling::Traits::ArrayType > aaa(aa->buildDA(1,self->getNumberOfComponents())); + self->addEqual(aaa); + Py_XINCREF(trueSelf); + return trueSelf; + } + case 4: + { + MEDCoupling::MCAuto< typename MEDCoupling::Traits::ArrayType > aaa(MEDCoupling::Traits::ArrayType::New()); aaa->useArray(&bb[0],false,MEDCoupling::DeallocType::CPP_DEALLOC,1,bb.size()); + self->addEqual(aaa); + Py_XINCREF(trueSelf); + return trueSelf; + } + default: + throw INTERP_KERNEL::Exception(msg); + } +} + +template +PyObject *DataArrayT_isub__internal(PyObject *trueSelf, PyObject *obj, typename MEDCoupling::Traits::ArrayType *self, swig_type_info *ti_da, swig_type_info *ti_tuple) +{ + const char msg[]="Unexpected situation in __isub__ !"; + T val; + typename MEDCoupling::Traits::ArrayType *a; + typename MEDCoupling::Traits::ArrayTuple *aa; + std::vector bb; + mcIdType sw; + convertFPStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb,ti_da,ti_tuple); + switch(sw) + { + case 1: + { + self->applyLin(1.,-val); + Py_XINCREF(trueSelf); + return trueSelf; + } + case 2: + { + self->substractEqual(a); + Py_XINCREF(trueSelf); + return trueSelf; + } + case 3: + { + MEDCoupling::MCAuto< typename MEDCoupling::Traits::ArrayType > aaa(aa->buildDA(1,self->getNumberOfComponents())); + self->substractEqual(aaa); + Py_XINCREF(trueSelf); + return trueSelf; + } + case 4: + { + MEDCoupling::MCAuto< typename MEDCoupling::Traits::ArrayType > aaa(MEDCoupling::Traits::ArrayType::New()); aaa->useArray(&bb[0],false,MEDCoupling::DeallocType::CPP_DEALLOC,1,bb.size()); + self->substractEqual(aaa); + Py_XINCREF(trueSelf); + return trueSelf; + } + default: + throw INTERP_KERNEL::Exception(msg); + } +} + +#ifdef WITH_NUMPY +PyTypeObject *NPYTraits::NPYFunc=&PyCallBackDataArrayDouble_RefType; + +PyTypeObject *NPYTraits::NPYFunc=&PyCallBackDataArrayFloat_RefType; + +PyTypeObject *NPYTraits::NPYFunc=&PyCallBackDataArrayInt32_RefType; + +PyTypeObject *NPYTraits::NPYFunc=&PyCallBackDataArrayInt64_RefType; +#endif + +template +typename MEDCoupling::Traits::ArrayType *DataArrayT__setitem__(typename MEDCoupling::Traits::ArrayType *self, PyObject *obj, PyObject *value) +{ + return DataArrayT__setitem__internal(self,obj,value,SWIGTITraits::TI); +} + +template +PyObject *DataArrayT__getitem(const typename MEDCoupling::Traits::ArrayType *self, PyObject *obj) +{ + return DataArrayT__getitem__internal(self,obj,SWIGTITraits::TI); +} + +template +PyObject *DataArrayT_imul(PyObject *trueSelf, PyObject *obj, typename MEDCoupling::Traits::ArrayType *self) +{ + return DataArrayT_imul__internal(trueSelf,obj,self,SWIGTITraits::TI,SWIGTITraits::TI_TUPLE); +} + +template +PyObject *DataArrayT_idiv(PyObject *trueSelf, PyObject *obj, typename MEDCoupling::Traits::ArrayType *self) +{ + return DataArrayT_idiv__internal(trueSelf,obj,self,SWIGTITraits::TI,SWIGTITraits::TI_TUPLE); +} + +template +PyObject *DataArrayT_iadd(PyObject *trueSelf, PyObject *obj, typename MEDCoupling::Traits::ArrayType *self) +{ + return DataArrayT_iadd__internal(trueSelf,obj,self,SWIGTITraits::TI,SWIGTITraits::TI_TUPLE); +} + +template +PyObject *DataArrayT_isub(PyObject *trueSelf, PyObject *obj, typename MEDCoupling::Traits::ArrayType *self) +{ + return DataArrayT_isub__internal(trueSelf,obj,self,SWIGTITraits::TI,SWIGTITraits::TI_TUPLE); +} + +template +typename MEDCoupling::Traits::ArrayType *DataArrayFPT_rmul(typename MEDCoupling::Traits::ArrayType *self, PyObject *obj) +{ + const char msg[]="Unexpected situation in __rmul__ !"; + T val; + typename MEDCoupling::Traits::ArrayType *a; + typename MEDCoupling::Traits::ArrayTuple *aa; + std::vector bb; + mcIdType sw; + convertFPStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb,SWIGTITraits::TI,SWIGTITraits::TI_TUPLE); + switch(sw) + { + case 1: + { + typename MEDCoupling::MCAuto::ArrayType> ret(self->deepCopy()); + ret->applyLin(val,0.); + return ret.retn(); + } + case 3: + { + typename MEDCoupling::MCAuto::ArrayType> aaa(aa->buildDA(1,self->getNumberOfComponents())); + return MEDCoupling::Traits::ArrayType::Multiply(self,aaa); + } + case 4: + { + typename MEDCoupling::MCAuto::ArrayType> aaa(MEDCoupling::Traits::ArrayType::New()); aaa->useArray(&bb[0],false,MEDCoupling::DeallocType::CPP_DEALLOC,1,bb.size()); + return MEDCoupling::Traits::ArrayType::Multiply(self,aaa); + } + default: + throw INTERP_KERNEL::Exception(msg); + } +} + +#endif