-// Copyright (C) 2007-2016 CEA/DEN, EDF R&D
+// Copyright (C) 2007-2017 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
#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 <sstream>
+static PyObject *convertArray(MEDCoupling::DataArray *array, int owner)
+{
+ PyObject *ret(NULL);
+ if(!array)
+ {
+ Py_XINCREF(Py_None);
+ return Py_None;
+ }
+ if(dynamic_cast<MEDCoupling::DataArrayDouble *>(array))
+ ret=SWIG_NewPointerObj((void*)array,SWIGTYPE_p_MEDCoupling__DataArrayDouble,owner);
+ if(dynamic_cast<MEDCoupling::DataArrayInt *>(array))
+ ret=SWIG_NewPointerObj((void*)array,SWIGTYPE_p_MEDCoupling__DataArrayInt,owner);
+ if(dynamic_cast<MEDCoupling::DataArrayFloat *>(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<PySliceObject *>(slice),
+#endif
+ length,start,stop,step));
if(ret==0)
return ;
if(*step>0 && *start==*stop && length==*start)
/*!
* 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<int>::max(),start,stop,step));
+ int ret(PySlice_GetIndices(
+#if PY_VERSION_HEX >= 0x03000000
+ slice,
+#else
+ reinterpret_cast<PySliceObject *>(slice),
+#endif
+ std::numeric_limits<int>::max(),start,stop,step));
if(ret==0)
{
if(*start!=std::numeric_limits<int>::max() && *stop!=std::numeric_limits<int>::max())
return val;
}
+#ifdef WITH_NUMPY
// 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<class MCData>
/*
* 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)) {
MEDCoupling::MemArray<T>& 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;
SWIGINTERN PyObject *MEDCoupling_DataArrayInt_toNumPyArray(MEDCoupling::DataArrayInt *self);
SWIGINTERN PyObject *MEDCoupling_DataArrayDouble_toNumPyArray(MEDCoupling::DataArrayDouble *self);
-PyObject *ToCSRMatrix(const std::vector<std::map<int,double> >& m, int nbCols) throw(INTERP_KERNEL::Exception)
+#endif
+
+#ifdef WITH_SCIPY
+PyObject *ToCSRMatrix(const std::vector<std::map<int,double> >& m, int nbCols)
{
int nbRows((int)m.size());
MEDCoupling::MCAuto<MEDCoupling::DataArrayInt> indPtr(MEDCoupling::DataArrayInt::New()),indices(MEDCoupling::DataArrayInt::New());
return ret;
}
-static PyObject *convertDataArrayChar(MEDCoupling::DataArrayChar *dac, int owner) throw(INTERP_KERNEL::Exception)
+#endif
+
+static PyObject *convertDataArrayChar(MEDCoupling::DataArrayChar *dac, int owner)
{
PyObject *ret=0;
if(!dac)
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)
return ret;
}
-static PyObject *convertIntArrToPyList(const int *ptr, int size) throw(INTERP_KERNEL::Exception)
+static PyObject *convertIntArrToPyList(const int *ptr, int size)
{
PyObject *ret=PyList_New(size);
for(int i=0;i<size;i++)
return ret;
}
-static PyObject *convertIntArrToPyList2(const std::vector<int>& v) throw(INTERP_KERNEL::Exception)
+static PyObject *convertIntArrToPyList2(const std::vector<int>& v)
{
int size=v.size();
PyObject *ret=PyList_New(size);
return ret;
}
-static PyObject *convertIntArrToPyList3(const std::set<int>& v) throw(INTERP_KERNEL::Exception)
+static PyObject *convertIntArrToPyList3(const std::set<int>& v)
{
int size=v.size();
PyObject *ret=PyList_New(size);
return ret;
}
-static PyObject *convertIntArrToPyListOfTuple(const int *vals, int nbOfComp, int nbOfTuples) throw(INTERP_KERNEL::Exception)
+static bool convertPyObjectToStrNT(PyObject *obj, std::string& ret)
+{
+ if(PyString_Check(obj))
+ {
+ ret=PyString_AsString(obj);
+ return true;
+ }
+#if PY_VERSION_HEX >= 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;
+}
+
+static PyObject *convertIntArrToPyListOfTuple(const int *vals, int nbOfComp, int nbOfTuples)
{
PyObject *ret=PyList_New(nbOfTuples);
for(int i=0;i<nbOfTuples;i++)
return ret;
}
-static int *convertPyToNewIntArr2(PyObject *pyLi, int *size) throw(INTERP_KERNEL::Exception)
+static int *convertPyToNewIntArr2(PyObject *pyLi, int *size)
{
if(PyList_Check(pyLi))
{
}
}
-static PyObject *convertFromVectorPairInt(const std::vector< std::pair<int,int> >& arr) throw(INTERP_KERNEL::Exception)
+static PyObject *convertFromVectorPairInt(const std::vector< std::pair<int,int> >& arr)
{
PyObject *ret=PyList_New(arr.size());
for(std::size_t i=0;i<arr.size();i++)
return ret;
}
-static void convertPyToVectorPairInt(PyObject *pyLi, std::vector< std::pair<int,int> >& arr) throw(INTERP_KERNEL::Exception)
+static void convertPyToVectorPairInt(PyObject *pyLi, std::vector< std::pair<int,int> >& 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))
throw INTERP_KERNEL::Exception(msg);
}
-static void convertPyToVectorPairStringInt(PyObject *pyLi, std::vector< std::pair<std::string,int> >& arr) throw(INTERP_KERNEL::Exception)
+static void convertPyToVectorPairStringInt(PyObject *pyLi, std::vector< std::pair<std::string,int> >& 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))
if(sz2!=2)
throw INTERP_KERNEL::Exception(msg);
PyObject *o_0=PyTuple_GetItem(o,0);
- if(!PyString_Check(o_0))
- throw INTERP_KERNEL::Exception(msg);
PyObject *o_1=PyTuple_GetItem(o,1);
+ arr[i].first=convertPyObjectToStr(o_0,msg);
if(!PyInt_Check(o_1))
throw INTERP_KERNEL::Exception(msg);
- arr[i].first=PyString_AsString(o_0);
arr[i].second=(int)PyInt_AS_LONG(o_1);
}
else
if(sz2!=2)
throw INTERP_KERNEL::Exception(msg);
PyObject *o_0=PyTuple_GetItem(o,0);
- if(!PyString_Check(o_0))
- throw INTERP_KERNEL::Exception(msg);
PyObject *o_1=PyTuple_GetItem(o,1);
+ arr[i].first=convertPyObjectToStr(o_0,msg);
if(!PyInt_Check(o_1))
throw INTERP_KERNEL::Exception(msg);
- arr[i].first=PyString_AsString(o_0);
arr[i].second=(int)PyInt_AS_LONG(o_1);
}
else
throw INTERP_KERNEL::Exception(msg);
}
-static void convertPyToNewIntArr3(PyObject *pyLi, std::vector<int>& arr) throw(INTERP_KERNEL::Exception)
+static void convertPyToNewIntArr3(PyObject *pyLi, std::vector<int>& arr)
{
if(PyList_Check(pyLi))
{
}
}
-static void convertPyToNewIntArr4(PyObject *pyLi, int recurseLev, int nbOfSubPart, std::vector<int>& arr) throw(INTERP_KERNEL::Exception)
+static void convertPyToNewIntArr4(PyObject *pyLi, int recurseLev, int nbOfSubPart, std::vector<int>& arr)
{
if(recurseLev<0)
throw INTERP_KERNEL::Exception("convertPyToNewIntArr4 : invalid list of integers level of recursion !");
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(int size1, int size2, int& nbOfTuples, int& nbOfComp)
{
if(nbOfTuples==-1)
{
throw INTERP_KERNEL::Exception("fillArrayWithPyListInt3 : Unrecognized type ! Should be a composition of tuple,list,int !");
}
-static std::vector<int> fillArrayWithPyListInt2(PyObject *pyLi, int& nbOfTuples, int& nbOfComp) throw(INTERP_KERNEL::Exception)
+static std::vector<int> fillArrayWithPyListInt2(PyObject *pyLi, int& nbOfTuples, int& nbOfComp)
{
std::vector<int> ret;
int size1=-1,size2=-1;
return ret;
}
-static bool fillStringVector(PyObject *pyLi, std::vector<std::string>& vec) throw(INTERP_KERNEL::Exception)
+static bool fillStringVector(PyObject *pyLi, std::vector<std::string>& vec)
{
if(PyList_Check(pyLi))
{
for(int i=0;i<sz;i++)
{
PyObject *o=PyList_GetItem(pyLi,i);
- if(PyString_Check(o))
- vec[i]=PyString_AsString(o);
- else
+ if(!convertPyObjectToStrNT(o,vec[i]))
return false;
}
return true;
for(int i=0;i<sz;i++)
{
PyObject *o=PyTuple_GetItem(pyLi,i);
- if(PyString_Check(o))
- vec[i]=PyString_AsString(o);
- else
+ if(!convertPyObjectToStrNT(o,vec[i]))
return false;
}
return true;
else
return false;
}
-static void convertPyToVectorOfVectorOfString(PyObject *pyLi, std::vector< std::vector<std::string> >& arr) throw(INTERP_KERNEL::Exception)
+static void convertPyToVectorOfVectorOfString(PyObject *pyLi, std::vector< std::vector<std::string> >& arr)
{
const char msg[]="convertPyToVectorOfVectorOfString : expecting list of list of strings !";
if(PyList_Check(pyLi))
throw INTERP_KERNEL::Exception(msg);
}
-static bool fillIntVector(PyObject *pyLi, std::vector<int>& vec) throw(INTERP_KERNEL::Exception)
+static bool fillIntVector(PyObject *pyLi, std::vector<int>& vec)
{
if(PyList_Check(pyLi))
{
return false;
}
-static void convertPyToVectorOfVectorOfInt(PyObject *pyLi, std::vector< std::vector<int> >& arr) throw(INTERP_KERNEL::Exception)
+static void convertPyToVectorOfVectorOfInt(PyObject *pyLi, std::vector< std::vector<int> >& arr)
{
const char msg[]="convertPyToVectorOfVectorOfInt : expecting list of list of strings !";
if(PyList_Check(pyLi))
throw INTERP_KERNEL::Exception(msg);
}
-static void convertPyToVectorPairStringVecString(PyObject *pyLi, std::vector< std::pair<std::string, std::vector<std::string> > >& arr) throw(INTERP_KERNEL::Exception)
+static void convertPyToVectorPairStringVecString(PyObject *pyLi, std::vector< std::pair<std::string, std::vector<std::string> > >& 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))
throw INTERP_KERNEL::Exception(msg);
std::pair<std::string, std::vector<std::string> > 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);
throw INTERP_KERNEL::Exception(msg);
std::pair<std::string, std::vector<std::string> > 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);
}
template<class T>
-PyObject *convertDblArrToPyList(const T *ptr, int size) throw(INTERP_KERNEL::Exception)
+PyObject *convertDblArrToPyList(const T *ptr, int size)
{
PyObject *ret(PyList_New(size));
for(int i=0;i<size;i++)
return ret;
}
-static PyObject *convertDblArrToPyList2(const std::vector<double>& v) throw(INTERP_KERNEL::Exception)
+static PyObject *convertDblArrToPyList2(const std::vector<double>& v)
{
int size(v.size());
PyObject *ret(PyList_New(size));
}
template<class T>
-PyObject *convertDblArrToPyListOfTuple(const T *vals, int nbOfComp, int nbOfTuples) throw(INTERP_KERNEL::Exception)
+PyObject *convertDblArrToPyListOfTuple(const T *vals, int nbOfComp, int nbOfTuples)
{
PyObject *ret(PyList_New(nbOfTuples));
for(int i=0;i<nbOfTuples;i++)
return ret;
}
-static PyObject *convertCharArrToPyListOfTuple(const char *vals, int nbOfComp, int nbOfTuples) throw(INTERP_KERNEL::Exception)
+static PyObject *convertCharArrToPyListOfTuple(const char *vals, int nbOfComp, int nbOfTuples)
{
PyObject *ret=PyList_New(nbOfTuples);
INTERP_KERNEL::AutoPtr<char> tmp=new char[nbOfComp+1]; tmp[nbOfComp]='\0';
return ret;
}
-static double *convertPyToNewDblArr2(PyObject *pyLi, int *size) throw(INTERP_KERNEL::Exception)
+static double *convertPyToNewDblArr2(PyObject *pyLi, int *size)
{
if(PyList_Check(pyLi))
{
throw INTERP_KERNEL::Exception("fillArrayWithPyListDbl3 : Unrecognized type ! Should be a composition of tuple,list,int and float !");
}
-static std::vector<double> fillArrayWithPyListDbl2(PyObject *pyLi, int& nbOfTuples, int& nbOfComp) throw(INTERP_KERNEL::Exception)
+static std::vector<double> fillArrayWithPyListDbl2(PyObject *pyLi, int& nbOfTuples, int& nbOfComp)
{
std::vector<double> ret;
int size1=-1,size2=-1;
*
* switch between (int,vector<int>,DataArrayInt)
*/
-static void convertIntStarLikePyObjToCpp(PyObject *value, int& sw, int& iTyypp, std::vector<int>& stdvecTyypp, MEDCoupling::DataArrayInt *& daIntTyypp, MEDCoupling::DataArrayIntTuple *&daIntTuple) throw(INTERP_KERNEL::Exception)
+static void convertIntStarLikePyObjToCpp(PyObject *value, int& sw, int& iTyypp, std::vector<int>& stdvecTyypp, MEDCoupling::DataArrayInt *& daIntTyypp, MEDCoupling::DataArrayIntTuple *&daIntTuple)
{
sw=-1;
if(PyInt_Check(value))
}
status=SWIG_ConvertPtr(value,&argp,SWIGTYPE_p_MEDCoupling__DataArrayIntTuple,0|0);
if(SWIG_IsOK(status))
- {
+ {
daIntTuple=reinterpret_cast< MEDCoupling::DataArrayIntTuple * >(argp);
sw=4;
return ;
*
* switch between (int,vector<int>,DataArrayInt)
*/
-static const int *convertIntStarLikePyObjToCppIntStar(PyObject *value, int& sw, int& sz, int& iTyypp, std::vector<int>& stdvecTyypp) throw(INTERP_KERNEL::Exception)
+static const int *convertIntStarLikePyObjToCppIntStar(PyObject *value, int& sw, int& sz, int& iTyypp, std::vector<int>& stdvecTyypp)
{
sw=-1;
if(PyInt_Check(value))
}
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();
* switch between (int,vector<int>,DataArrayInt)
*/
template<class T>
-void considerPyObjAsATStarLikeObject(PyObject *value, int& sw, T& iTyypp, std::vector<T>& stdvecTyypp, typename MEDCoupling::Traits<T>::ArrayType *& daIntTyypp, swig_type_info *ti) throw(INTERP_KERNEL::Exception)
+void considerPyObjAsATStarLikeObject(PyObject *value, int& sw, T& iTyypp, std::vector<T>& stdvecTyypp, typename MEDCoupling::Traits<T>::ArrayType *& daIntTyypp, swig_type_info *ti)
{
sw=-1;
if(PyFloat_Check(value))
*
* switch between (int,vector<int>,DataArrayInt)
*/
-static void convertDoubleStarLikePyObjToCpp(PyObject *value, int& sw, double& iTyypp, std::vector<double>& stdvecTyypp, MEDCoupling::DataArrayDoubleTuple *& daIntTyypp) throw(INTERP_KERNEL::Exception)
+static void convertDoubleStarLikePyObjToCpp(PyObject *value, int& sw, double& iTyypp, std::vector<double>& stdvecTyypp, MEDCoupling::DataArrayDoubleTuple *& daIntTyypp)
{
sw=-1;
if(PyFloat_Check(value))
void *argp;
int status=SWIG_ConvertPtr(value,&argp,ti_da,0|0);
if(SWIG_IsOK(status))
- {
+ {
d=reinterpret_cast< typename MEDCoupling::Traits<T>::ArrayType * >(argp);
sw=2;
return ;
}
status=SWIG_ConvertPtr(value,&argp,ti_tuple,0|0);
if(SWIG_IsOK(status))
- {
+ {
e=reinterpret_cast< typename MEDCoupling::Traits<T>::ArrayTuple * >(argp);
sw=3;
return ;
convertFPStarLikePyObjToCpp_2<double>(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<double> sw=4
+ * if value tuple[int,double] -> cpp std::vector<double> sw=4
+ */
+static void convertFloatStarLikePyObjToCpp_2(PyObject *value, int& sw, float& val, MEDCoupling::DataArrayFloat *&d, MEDCoupling::DataArrayFloatTuple *&e, std::vector<float>& f)
+{
+ convertFPStarLikePyObjToCpp_2<float>(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<int> sw=2
*
* switch between (int,vector<int>,DataArrayInt)
*/
-static void convertIntStarOrSliceLikePyObjToCpp(PyObject *value, int nbelem, int& sw, int& iTyypp, std::vector<int>& stdvecTyypp, std::pair<int, std::pair<int,int> >& p, MEDCoupling::DataArrayInt *& daIntTyypp) throw(INTERP_KERNEL::Exception)
+static void convertIntStarOrSliceLikePyObjToCpp(PyObject *value, int nbelem, int& sw, int& iTyypp, std::vector<int>& stdvecTyypp, std::pair<int, std::pair<int,int> >& p, MEDCoupling::DataArrayInt *& daIntTyypp)
{
const char *msg="5 types accepted : integer, tuple of integer, list of integer, slice, DataArrayInt, DataArrayIntTuple";
sw=-1;
if(PySlice_Check(value))
{
Py_ssize_t strt=2,stp=2,step=2;
- PySliceObject *oC=reinterpret_cast<PySliceObject *>(value);
- GetIndicesOfSlice(oC,nbelem,&strt,&stp,&step,"Slice in subscriptable object DataArray invalid !");
+ GetIndicesOfSlice(value,nbelem,&strt,&stp,&step,"Slice in subscriptable object DataArray invalid !");
p.first=strt;
p.second.first=stp;
p.second.second=step;
/*!
* Idem than convertIntStarOrSliceLikePyObjToCpp
*/
-static void convertIntStarOrSliceLikePyObjToCppWithNegIntInterp(PyObject *value, int nbelem, int& sw, int& iTyypp, std::vector<int>& stdvecTyypp, std::pair<int, std::pair<int,int> >& p, MEDCoupling::DataArrayInt *& daIntTyypp) throw(INTERP_KERNEL::Exception)
+static void convertIntStarOrSliceLikePyObjToCppWithNegIntInterp(PyObject *value, int nbelem, int& sw, int& iTyypp, std::vector<int>& stdvecTyypp, std::pair<int, std::pair<int,int> >& p, MEDCoupling::DataArrayInt *& daIntTyypp)
{
convertIntStarOrSliceLikePyObjToCpp(value,nbelem,sw,iTyypp,stdvecTyypp,p,daIntTyypp);
if(sw==1)
* if python slice -> cpp pair sw=3
* if python DataArrayIntTuple -> cpp DataArrayIntTuple sw=4 . WARNING The returned pointer can be the null pointer !
*/
-static void convertObjToPossibleCpp22(PyObject *value, int nbelem, int& sw, int& iTyypp, std::vector<int>& stdvecTyypp, std::pair<int, std::pair<int,int> >& p, MEDCoupling::DataArrayIntTuple *& daIntTyypp) throw(INTERP_KERNEL::Exception)
+static void convertObjToPossibleCpp22(PyObject *value, int nbelem, int& sw, int& iTyypp, std::vector<int>& stdvecTyypp, std::pair<int, std::pair<int,int> >& p, MEDCoupling::DataArrayIntTuple *& daIntTyypp)
{
sw=-1;
if(PyInt_Check(value))
if(PySlice_Check(value))
{
Py_ssize_t strt=2,stp=2,step=2;
- PySliceObject *oC=reinterpret_cast<PySliceObject *>(value);
- GetIndicesOfSlice(oC,nbelem,&strt,&stp,&step,"Slice in subscriptable object DataArray invalid !");
+ GetIndicesOfSlice(value,nbelem,&strt,&stp,&step,"Slice in subscriptable object DataArray invalid !");
p.first=strt;
p.second.first=stp;
p.second.second=step;
* if python not null pointer of DataArrayChar -> cpp DataArrayChar sw=4
* switch between (int,string,vector<string>,DataArrayChar)
*/
-static void convertObjToPossibleCpp6(PyObject *value, int& sw, char& cTyp, std::string& sType, std::vector<std::string>& vsType, MEDCoupling::DataArrayChar *& dacType) throw(INTERP_KERNEL::Exception)
+static void convertObjToPossibleCpp6(PyObject *value, int& sw, char& cTyp, std::string& sType, std::vector<std::string>& 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;
return;
}
}
+#if PY_VERSION_HEX >= 0x03000000
+ if(PyUnicode_Check(value))
+ {
+ Py_ssize_t sz;
+ const char *pt = PyUnicode_AsUTF8AndSize(value, &sz);
+ if(sz==1)
+ {
+ cTyp=pt[0];
+ sw=1;
+ return;
+ }
+ else
+ {
+ sType=pt;
+ sw=2;
+ return;
+ }
+ }
+#endif
if(PyTuple_Check(value))
{
int size=PyTuple_Size(value);
for(int i=0;i<size;i++)
{
PyObject *o=PyTuple_GetItem(value,i);
- if(PyString_Check(o))
- vsType[i]=PyString_AsString(o);
- else
+ try
+ {
+ vsType[i]=convertPyObjectToStr(o);
+ }
+ catch(INTERP_KERNEL::Exception& e)
{
std::ostringstream oss; oss << "Tuple as been detected but element #" << i << " is not a string ! only tuples of strings accepted !";
throw INTERP_KERNEL::Exception(oss.str().c_str());
for(int i=0;i<size;i++)
{
PyObject *o=PyList_GetItem(value,i);
- if(PyString_Check(o))
- vsType[i]=PyString_AsString(o);
- else
+ try
{
- std::ostringstream oss; oss << "List as been detected but element #" << i << " is not string ! only lists of strings accepted !";
+ vsType[i]=convertPyObjectToStr(o);
+ }
+ catch(INTERP_KERNEL::Exception& e)
+ {
+ std::ostringstream oss; oss << "List as been detected but element #" << i << " is not a string ! only tuples of strings accepted !";
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
}
*/
static void convertObjToPossibleCpp3(PyObject *value, int nbTuple, int nbCompo, int& sw, int& it, int& ic, std::vector<int>& vt, std::vector<int>& vc,
std::pair<int, std::pair<int,int> >& pt, std::pair<int, std::pair<int,int> >& pc,
- MEDCoupling::DataArrayInt *&dt, MEDCoupling::DataArrayInt *&dc) throw(INTERP_KERNEL::Exception)
+ MEDCoupling::DataArrayInt *&dt, MEDCoupling::DataArrayInt *&dc)
{
if(!PyTuple_Check(value))
{
* if value tuple[int,double] -> cpp std::vector<double> sw=4
*/
static const double *convertObjToPossibleCpp5_Safe(PyObject *value, int& sw, double& val, MEDCoupling::DataArrayDouble *&d, MEDCoupling::DataArrayDoubleTuple *&e, std::vector<double>& f,
- const char *msg, int nbTuplesExpected, int nbCompExpected, bool throwIfNullPt) throw(INTERP_KERNEL::Exception)
+ const char *msg, int nbTuplesExpected, int nbCompExpected, bool throwIfNullPt)
{
sw=-1;
if(PyFloat_Check(value))
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;
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;
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)
}
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)
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());
}
}
* if value tuple[int,double] -> cpp std::vector<double> sw=4
*/
static const double *convertObjToPossibleCpp5_Safe2(PyObject *value, int& sw, double& val, MEDCoupling::DataArrayDouble *&d, MEDCoupling::DataArrayDoubleTuple *&e, std::vector<double>& f,
- const char *msg, int nbCompExpected, bool throwIfNullPt, int& nbTuples) throw(INTERP_KERNEL::Exception)
+ const char *msg, int nbCompExpected, bool throwIfNullPt, int& nbTuples)
{
sw=-1;
if(PyFloat_Check(value))
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;
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;
sw=4;
if(size%nbCompExpected!=0)
{
- std::ostringstream oss; oss << msg << "dimension expected to be a multiple of " << nbCompExpected << " , and your data in input has dimension " << f.size() << " !";
+ std::ostringstream oss; oss << msg << "dimension expected to be a multiple of " << nbCompExpected << " , and your data in input has dimension " << f.size() << " !";
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
nbTuples=size/nbCompExpected;
sw=4;
if(size%nbCompExpected!=0)
{
- std::ostringstream oss; oss << msg << "dimension expected to be a multiple of " << nbCompExpected << " , and your data in input has dimension " << f.size() << " !";
+ std::ostringstream oss; oss << msg << "dimension expected to be a multiple of " << nbCompExpected << " , and your data in input has dimension " << f.size() << " !";
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
nbTuples=size/nbCompExpected;
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)
}
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 value tuple[int,double] -> cpp std::vector<double> sw=4
*/
static const double *convertObjToPossibleCpp5_SingleCompo(PyObject *value, int& sw, double& val, std::vector<double>& f,
- const char *msg, bool throwIfNullPt, int& nbTuples) throw(INTERP_KERNEL::Exception)
+ const char *msg, bool throwIfNullPt, int& nbTuples)
{
MEDCoupling::DataArrayDouble *d=0;
MEDCoupling::DataArrayDoubleTuple *e=0;
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)
}
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)
return reinterpret_cast< MEDCoupling::DataArray * >(aBasePtrVS);
}
-static PyObject *NewMethWrapCallInitOnlyIfEmptyDictInInput(PyObject *cls, PyObject *args, const char *clsName)
-{
- if(!PyTuple_Check(args))
- {
- std::ostringstream oss; oss << clsName << ".__new__ : the args in input is expected to be a tuple !";
- throw INTERP_KERNEL::Exception(oss.str().c_str());
- }
- PyObject *builtinsd(PyEval_GetBuiltins());//borrowed
- PyObject *obj(PyDict_GetItemString(builtinsd,"object"));//borrowed
- PyObject *selfMeth(PyObject_GetAttrString(obj,"__new__"));
- //
- PyObject *tmp0(PyTuple_New(1));
- PyTuple_SetItem(tmp0,0,cls); Py_XINCREF(cls);
- PyObject *instance(PyObject_CallObject(selfMeth,tmp0));
- Py_DECREF(tmp0);
- Py_DECREF(selfMeth);
- if(PyTuple_Size(args)==2 && PyDict_Check(PyTuple_GetItem(args,1)) && PyDict_Size(PyTuple_GetItem(args,1))==0 )
- {// NOT general case. only true if in unpickeling context ! call __init__. Because for all other cases, __init__ is called right after __new__ !
- PyObject *initMeth(PyObject_GetAttrString(instance,"__init__"));
- PyObject *tmp3(PyTuple_New(0));
- PyObject *tmp2(PyObject_CallObject(initMeth,tmp3));
- Py_XDECREF(tmp2);
- Py_DECREF(tmp3);
- Py_DECREF(initMeth);
- }
- return instance;
-}
-
-template<class T>
-static PyObject *NewMethWrapCallInitOnlyIfDictWithSingleEltInInputGeneral(PyObject *cls, PyObject *args, const char *clsName)
-{
- if(!PyTuple_Check(args))
- {
- std::ostringstream oss; oss << clsName << ".__new__ : the args in input is expected to be a tuple !";
- throw INTERP_KERNEL::Exception(oss.str().c_str());
- }
- PyObject *builtinsd(PyEval_GetBuiltins());//borrowed
- PyObject *obj(PyDict_GetItemString(builtinsd,"object"));//borrowed
- PyObject *selfMeth(PyObject_GetAttrString(obj,"__new__"));
- //
- PyObject *tmp0(PyTuple_New(1));
- PyTuple_SetItem(tmp0,0,cls); Py_XINCREF(cls);
- PyObject *instance(PyObject_CallObject(selfMeth,tmp0));
- Py_DECREF(tmp0);
- Py_DECREF(selfMeth);
- if(PyTuple_Size(args)==2 && PyDict_Check(PyTuple_GetItem(args,1)) && PyDict_Size(PyTuple_GetItem(args,1))==1 )
- {// NOT general case. only true if in unpickeling context ! call __init__. Because for all other cases, __init__ is called right after __new__ !
- PyObject *initMeth(PyObject_GetAttrString(instance,"__init__"));
- PyObject *zeNumpyRepr(0);
- {
- PyObject *tmp1(PyInt_FromLong(0));
- zeNumpyRepr=PyDict_GetItem(PyTuple_GetItem(args,1),tmp1);//borrowed
- Py_DECREF(tmp1);
- }
- if(!zeNumpyRepr)
- {
- std::ostringstream oss; oss << clsName << ".__new__ : the args in input is expected to be a tuple !";
- throw INTERP_KERNEL::Exception(oss.str().c_str());
- }
- T tt;
- {
- PyObject *tmp3(0);
- try
- {
- tmp3=tt(zeNumpyRepr);
- }
- catch(INTERP_KERNEL::Exception& e)
- {
- std::ostringstream oss; oss << clsName << ".__new__ : Invalid type in input " << " : " << e.what();
- throw INTERP_KERNEL::Exception(oss.str());
- }
- {
- PyObject *tmp2(PyObject_CallObject(initMeth,tmp3));
- Py_XDECREF(tmp2);
- }
- Py_DECREF(tmp3);
- }
- Py_DECREF(initMeth);
- }
- return instance;
-}
-
-struct SinglePyObjToBePutInATuple
-{
- PyObject *operator()(PyObject *zeNumpyRepr)
- {
- PyObject *tmp3(PyTuple_New(1));
- PyTuple_SetItem(tmp3,0,zeNumpyRepr); Py_XINCREF(zeNumpyRepr);
- return tmp3;
- }
-};
-
-struct SinglePyObjExpectToBeAListOfSz2
-{
- PyObject *operator()(PyObject *uniqueElt)
- {
- if(!PyTuple_Check(uniqueElt) || PyTuple_Size(uniqueElt)!=2)
- throw INTERP_KERNEL::Exception("Not a tuple of size 2 !");
- Py_XINCREF(uniqueElt);
- return uniqueElt;
- }
-};
-
-static PyObject *NewMethWrapCallInitOnlyIfDictWithSingleEltInInput(PyObject *cls, PyObject *args, const char *clsName)
-{
- return NewMethWrapCallInitOnlyIfDictWithSingleEltInInputGeneral<SinglePyObjToBePutInATuple>(cls,args,clsName);
-}
-
-static PyObject *convertPartDefinition(MEDCoupling::PartDefinition *pd, int owner) throw(INTERP_KERNEL::Exception)
+static PyObject *convertPartDefinition(MEDCoupling::PartDefinition *pd, int owner)
{
PyObject *ret=0;
if(!pd)
}
}
+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::DataArrayInt *indptrPtr, const MEDCoupling::DataArrayInt *indicesPtr, const MEDCoupling::DataArrayDouble *dataPtr, std::vector<std::map<int,double> >& mCpp)
+{
+#if __cplusplus >= 201103L
+ 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<nbOfRows;i++)
+ {
+ auto& line(mCpp[i]);
+ for(auto j=indPtrCPtr[i];j<indPtrCPtr[i+1];j++)
+ {
+ line[indicesCPtr[j]]=dataCPtr[j];
+ }
+ }
+#else
+ throw INTERP_KERNEL::Exception("Breaking news : 10% off for C++11 compiler :)");
+#endif
+}
+
+void convertToVectMapIntDouble(PyObject *pyobj, std::vector<std::map<int,double> >& 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<sz;i++)
+ {
+ PyObject *elt(PyList_GetItem(pyobj,i));
+ if(!PyDict_Check(elt))
+ {
+ std::ostringstream oss; oss << "convertToVectMapIntDouble : at pos # " << i << " of pylist a dict is exepect !";
+ throw INTERP_KERNEL::Exception(oss.str());
+ }
+ PyObject *key, *value;
+ Py_ssize_t pos(0);
+ std::map<int,double>& mapCpp(mCpp[i]);
+ while(PyDict_Next(elt,&pos,&key,&value))
+ {
+ if(!PyInt_Check(key))
+ {
+ 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[(int)PyInt_AS_LONG(key)]=PyFloat_AS_DOUBLE(value);
+ }
+ }
+}
+
template<class T>
PyObject *DataArrayT_imul__internal(PyObject *trueSelf, PyObject *obj, typename MEDCoupling::Traits<T>::ArrayType *self, swig_type_info *ti_da, swig_type_info *ti_tuple)
{
throw INTERP_KERNEL::Exception(msg);
}
}
-
+
template<class T>
PyObject *DataArrayT_isub__internal(PyObject *trueSelf, PyObject *obj, typename MEDCoupling::Traits<T>::ArrayType *self, swig_type_info *ti_da, swig_type_info *ti_tuple)
{
swig_type_info *SWIGTITraits<float>::TI_TUPLE=NULL;//unfortunately SWIGTYPE_p_MEDCoupling__DataArrayFloat is null when called here ! Postpone initialization at inlined initializeMe()
swig_type_info *SWIGTITraits<int>::TI_TUPLE=NULL;//unfortunately SWIGTYPE_p_MEDCoupling__DataArrayFloat is null when called here ! Postpone initialization at inlined initializeMe()
+#ifdef WITH_NUMPY
PyTypeObject *NPYTraits<double>::NPYFunc=&PyCallBackDataArrayDouble_RefType;
PyTypeObject *NPYTraits<float>::NPYFunc=&PyCallBackDataArrayFloat_RefType;
+#endif
template<class T>
typename MEDCoupling::Traits<T>::ArrayType *DataArrayT__setitem__(typename MEDCoupling::Traits<T>::ArrayType *self, PyObject *obj, PyObject *value)
return DataArrayT_isub__internal<T>(trueSelf,obj,self,SWIGTITraits<T>::TI,SWIGTITraits<T>::TI_TUPLE);
}
+template<class T>
+typename MEDCoupling::Traits<T>::ArrayType *DataArrayFPT_rmul(typename MEDCoupling::Traits<T>::ArrayType *self, PyObject *obj)
+{
+ const char msg[]="Unexpected situation in __rmul__ !";
+ T val;
+ typename MEDCoupling::Traits<T>::ArrayType *a;
+ typename MEDCoupling::Traits<T>::ArrayTuple *aa;
+ std::vector<T> bb;
+ int sw;
+ convertFPStarLikePyObjToCpp_2<T>(obj,sw,val,a,aa,bb,SWIGTITraits<T>::TI,SWIGTITraits<T>::TI_TUPLE);
+ switch(sw)
+ {
+ case 1:
+ {
+ typename MEDCoupling::MCAuto<typename MEDCoupling::Traits<T>::ArrayType> ret(self->deepCopy());
+ ret->applyLin(val,0.);
+ return ret.retn();
+ }
+ case 3:
+ {
+ typename MEDCoupling::MCAuto<typename MEDCoupling::Traits<T>::ArrayType> aaa(aa->buildDA(1,self->getNumberOfComponents()));
+ return MEDCoupling::Traits<T>::ArrayType::Multiply(self,aaa);
+ }
+ case 4:
+ {
+ typename MEDCoupling::MCAuto<typename MEDCoupling::Traits<T>::ArrayType> aaa(MEDCoupling::Traits<T>::ArrayType::New()); aaa->useArray(&bb[0],false,MEDCoupling::CPP_DEALLOC,1,(int)bb.size());
+ return MEDCoupling::Traits<T>::ArrayType::Multiply(self,aaa);
+ }
+ default:
+ throw INTERP_KERNEL::Exception(msg);
+ }
+}
+
#endif
