X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FMEDCoupling_Swig%2FMEDCouplingMemArray.i;h=ce219c7749ecc698cdec2ba48a863a2a0eed7a90;hb=5b299d506fcc63ff652df59a13f5b082fd45dabf;hp=ab06253fe49c237e28f7886a263523fd72bc2318;hpb=c5f9a2bb5f775564b5bd81de58dfa708bcef020d;p=tools%2Fmedcoupling.git diff --git a/src/MEDCoupling_Swig/MEDCouplingMemArray.i b/src/MEDCoupling_Swig/MEDCouplingMemArray.i index ab06253fe..ce219c774 100644 --- a/src/MEDCoupling_Swig/MEDCouplingMemArray.i +++ b/src/MEDCoupling_Swig/MEDCouplingMemArray.i @@ -73,6 +73,7 @@ %newobject MEDCoupling::DataArrayFloat::iterator; %newobject MEDCoupling::DataArrayFloat::__iter__; %newobject MEDCoupling::DataArrayFloat::Meld; +%newobject MEDCoupling::DataArrayFloat::__rmul__; %newobject MEDCoupling::DataArrayInt::New; %newobject MEDCoupling::DataArrayInt::__iter__; %newobject MEDCoupling::DataArrayInt::performCopyOrIncrRef; @@ -92,6 +93,7 @@ %newobject MEDCoupling::DataArrayInt::findIdsEqualList; %newobject MEDCoupling::DataArrayInt::findIdsNotEqualList; %newobject MEDCoupling::DataArrayInt::findIdsEqualTuple; +%newobject MEDCoupling::DataArrayInt::findIdForEach; %newobject MEDCoupling::DataArrayInt::sumPerTuple; %newobject MEDCoupling::DataArrayInt::negate; %newobject MEDCoupling::DataArrayInt::computeAbs; @@ -745,6 +747,18 @@ namespace MEDCoupling int nbOfComp(self->getNumberOfComponents()),nbOfTuples(self->getNumberOfTuples()); return convertDblArrToPyListOfTuple(vals,nbOfComp,nbOfTuples); } + + PyObject *isEqualIfNotWhy(const DataArrayFloat& other, float prec) const throw(INTERP_KERNEL::Exception) + { + std::string ret1; + bool ret0=self->isEqualIfNotWhy(other,prec,ret1); + PyObject *ret=PyTuple_New(2); + PyObject *ret0Py=ret0?Py_True:Py_False; + Py_XINCREF(ret0Py); + PyTuple_SetItem(ret,0,ret0Py); + PyTuple_SetItem(ret,1,PyString_FromString(ret1.c_str())); + return ret; + } PyObject *__getitem__(PyObject *obj) throw(INTERP_KERNEL::Exception) { @@ -771,6 +785,11 @@ namespace MEDCoupling return DataArrayT_imul(trueSelf,obj,self); } + DataArrayFloat *__rmul__(PyObject *obj) throw(INTERP_KERNEL::Exception) + { + return DataArrayFPT_rmul(self,obj); + } + PyObject *___idiv___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception) { return DataArrayT_idiv(trueSelf,obj,self); @@ -782,31 +801,6 @@ namespace MEDCoupling return ToNumPyArray(self,NPY_FLOAT,"DataArrayFloat"); } #endif - - // serialization - static PyObject *___new___(PyObject *cls, PyObject *args) throw(INTERP_KERNEL::Exception) - { - return NewMethWrapCallInitOnlyIfDictWithSingleEltInInput(cls,args,"DataArrayFloat"); - } - - PyObject *__getnewargs__() throw(INTERP_KERNEL::Exception) - { -#ifdef WITH_NUMPY - if(!self->isAllocated()) - throw INTERP_KERNEL::Exception("PyWrap of DataArrayFloat.__getnewargs__ : self is not allocated !"); - PyObject *ret(PyTuple_New(1)); - PyObject *ret0(PyDict_New()); - PyObject *numpyArryObj(MEDCoupling_DataArrayFloat_toNumPyArray(self)); - {// create a dict to discriminite in __new__ if __init__ should be called. Not beautiful but not idea ... - PyObject *tmp1(PyInt_FromLong(0)); - PyDict_SetItem(ret0,tmp1,numpyArryObj); Py_DECREF(tmp1); Py_DECREF(numpyArryObj); - PyTuple_SetItem(ret,0,ret0); - } - return ret; -#else - throw INTERP_KERNEL::Exception("PyWrap of DataArrayByte.__getnewargs__ : not implemented because numpy is not active in your configuration ! No serialization/unserialization available without numpy !"); -#endif - } } }; @@ -923,9 +917,8 @@ namespace MEDCoupling void checkNoNullValues() const throw(INTERP_KERNEL::Exception); DataArrayDouble *computeBBoxPerTuple(double epsilon=0.0) const throw(INTERP_KERNEL::Exception); void recenterForMaxPrecision(double eps) throw(INTERP_KERNEL::Exception); - double getMaxValue(int& tupleId) const throw(INTERP_KERNEL::Exception); double getMaxValueInArray() const throw(INTERP_KERNEL::Exception); - double getMinValue(int& tupleId) const throw(INTERP_KERNEL::Exception); + double getMaxAbsValueInArray() const throw(INTERP_KERNEL::Exception); double getMinValueInArray() const throw(INTERP_KERNEL::Exception); int count(double value, double eps) const throw(INTERP_KERNEL::Exception); double getAverageValue() const throw(INTERP_KERNEL::Exception); @@ -1052,6 +1045,22 @@ namespace MEDCoupling } } + PyObject *asArcOfCircle() const throw(INTERP_KERNEL::Exception) + { + double center[2],radius,ang; + self->asArcOfCircle(center,radius,ang); + PyObject *ret(PyTuple_New(3)); + { + PyObject *ret0(PyList_New(2)); + PyList_SetItem(ret0,0,PyFloat_FromDouble(center[0])); + PyList_SetItem(ret0,1,PyFloat_FromDouble(center[1])); + PyTuple_SetItem(ret,0,ret0); + } + PyTuple_SetItem(ret,1,PyFloat_FromDouble(radius)); + PyTuple_SetItem(ret,2,PyFloat_FromDouble(ang)); + return ret; + } + DataArrayDoubleIterator *__iter__() throw(INTERP_KERNEL::Exception) { return self->iterator(); @@ -1284,6 +1293,16 @@ namespace MEDCoupling return ret; } + PyObject *getMaxAbsValue() const throw(INTERP_KERNEL::Exception) + { + std::size_t tmp; + double r1=self->getMaxAbsValue(tmp); + PyObject *ret=PyTuple_New(2); + PyTuple_SetItem(ret,0,PyFloat_FromDouble(r1)); + PyTuple_SetItem(ret,1,PyInt_FromLong(tmp)); + return ret; + } + PyObject *getMaxValue2() const throw(INTERP_KERNEL::Exception) { DataArrayInt *tmp; @@ -1689,34 +1708,7 @@ namespace MEDCoupling DataArrayDouble *__rmul__(PyObject *obj) throw(INTERP_KERNEL::Exception) { - const char msg[]="Unexpected situation in __rmul__ !"; - double val; - DataArrayDouble *a; - DataArrayDoubleTuple *aa; - std::vector bb; - int sw; - convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb); - switch(sw) - { - case 1: - { - MCAuto ret=self->deepCopy(); - ret->applyLin(val,0.); - return ret.retn(); - } - case 3: - { - MCAuto aaa=aa->buildDADouble(1,self->getNumberOfComponents()); - return DataArrayDouble::Multiply(self,aaa); - } - case 4: - { - MCAuto aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,CPP_DEALLOC,1,(int)bb.size()); - return DataArrayDouble::Multiply(self,aaa); - } - default: - throw INTERP_KERNEL::Exception(msg); - } + return DataArrayFPT_rmul(self,obj); } PyObject *___imul___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception) @@ -1947,31 +1939,6 @@ namespace MEDCoupling PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(ret1),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); return ret; } - - // serialization - static PyObject *___new___(PyObject *cls, PyObject *args) throw(INTERP_KERNEL::Exception) - { - return NewMethWrapCallInitOnlyIfDictWithSingleEltInInput(cls,args,"DataArrayDouble"); - } - - PyObject *__getnewargs__() throw(INTERP_KERNEL::Exception) - { -#ifdef WITH_NUMPY - if(!self->isAllocated()) - throw INTERP_KERNEL::Exception("PyWrap of DataArrayDouble.__getnewargs__ : self is not allocated !"); - PyObject *ret(PyTuple_New(1)); - PyObject *ret0(PyDict_New()); - PyObject *numpyArryObj(MEDCoupling_DataArrayDouble_toNumPyArray(self)); - {// create a dict to discriminite in __new__ if __init__ should be called. Not beautiful but not idea ... - PyObject *tmp1(PyInt_FromLong(0)); - PyDict_SetItem(ret0,tmp1,numpyArryObj); Py_DECREF(tmp1); Py_DECREF(numpyArryObj); - PyTuple_SetItem(ret,0,ret0); - } - return ret; -#else - throw INTERP_KERNEL::Exception("PyWrap of DataArrayDouble.__getnewargs__ : not implemented because numpy is not active in your configuration ! No serialization/unserialization available without numpy !"); -#endif - } } }; @@ -2356,9 +2323,8 @@ namespace MEDCoupling bool presenceOfValue(const std::vector& vals) const throw(INTERP_KERNEL::Exception); int count(int value) const throw(INTERP_KERNEL::Exception); int accumulate(int compId) const throw(INTERP_KERNEL::Exception); - int getMaxValue(int& tupleId) const throw(INTERP_KERNEL::Exception); int getMaxValueInArray() const throw(INTERP_KERNEL::Exception); - int getMinValue(int& tupleId) const throw(INTERP_KERNEL::Exception); + int getMaxAbsValueInArray() const throw(INTERP_KERNEL::Exception); int getMinValueInArray() const throw(INTERP_KERNEL::Exception); void abs() throw(INTERP_KERNEL::Exception); DataArrayInt *computeAbs() const throw(INTERP_KERNEL::Exception); @@ -2577,6 +2543,15 @@ namespace MEDCoupling return self->findIdsEqualTuple(bg,bg+sz); } + DataArrayInt *findIdForEach(PyObject *vals) const throw(INTERP_KERNEL::Exception) + { + int sw,sz,val; + std::vector val2; + const int *bg(convertIntStarLikePyObjToCppIntStar(vals,sw,sz,val,val2)); + MCAuto ret(self->findIdForEach(bg,bg+sz)); + return ret.retn(); + } + PyObject *splitInBalancedSlices(int nbOfSlices) const throw(INTERP_KERNEL::Exception) { std::vector< std::pair > slcs(self->splitInBalancedSlices(nbOfSlices)); @@ -3005,6 +2980,16 @@ namespace MEDCoupling PyTuple_SetItem(ret,1,PyInt_FromLong(tmp)); return ret; } + + PyObject *getMaxAbsValue(std::size_t& tupleId) const throw(INTERP_KERNEL::Exception) + { + std::size_t tmp; + int r1=self->getMaxAbsValue(tmp); + PyObject *ret=PyTuple_New(2); + PyTuple_SetItem(ret,0,PyInt_FromLong(r1)); + PyTuple_SetItem(ret,1,PyInt_FromLong(tmp)); + return ret; + } PyObject *getMinValue() const throw(INTERP_KERNEL::Exception) { @@ -4305,31 +4290,6 @@ namespace MEDCoupling PyTuple_SetItem(pyRet,1,ret1Py); return pyRet; } - - // serialization - static PyObject *___new___(PyObject *cls, PyObject *args) throw(INTERP_KERNEL::Exception) - { - return NewMethWrapCallInitOnlyIfDictWithSingleEltInInput(cls,args,"DataArrayInt"); - } - - PyObject *__getnewargs__() throw(INTERP_KERNEL::Exception) - { -#ifdef WITH_NUMPY - if(!self->isAllocated()) - throw INTERP_KERNEL::Exception("PyWrap of DataArrayInt.__getnewargs__ : self is not allocated !"); - PyObject *ret(PyTuple_New(1)); - PyObject *ret0(PyDict_New()); - PyObject *numpyArryObj(MEDCoupling_DataArrayInt_toNumPyArray(self)); - {// create a dict to discriminite in __new__ if __init__ should be called. Not beautiful but not idea ... - PyObject *tmp1(PyInt_FromLong(0)); - PyDict_SetItem(ret0,tmp1,numpyArryObj); Py_DECREF(tmp1); Py_DECREF(numpyArryObj); - PyTuple_SetItem(ret,0,ret0); - } - return ret; -#else - throw INTERP_KERNEL::Exception("PyWrap of DataArrayInt.__getnewargs__ : not implemented because numpy is not active in your configuration ! No serialization/unserialization available without numpy !"); -#endif - } } }; @@ -5096,31 +5056,6 @@ namespace MEDCoupling } #endif - // serialization - static PyObject *___new___(PyObject *cls, PyObject *args) throw(INTERP_KERNEL::Exception) - { - return NewMethWrapCallInitOnlyIfDictWithSingleEltInInput(cls,args,"DataArrayByte"); - } - - PyObject *__getnewargs__() throw(INTERP_KERNEL::Exception) - { -#ifdef WITH_NUMPY - if(!self->isAllocated()) - throw INTERP_KERNEL::Exception("PyWrap of DataArrayByte.__getnewargs__ : self is not allocated !"); - PyObject *ret(PyTuple_New(1)); - PyObject *ret0(PyDict_New()); - PyObject *numpyArryObj(MEDCoupling_DataArrayByte_toNumPyArray(self)); - {// create a dict to discriminite in __new__ if __init__ should be called. Not beautiful but not idea ... - PyObject *tmp1(PyInt_FromLong(0)); - PyDict_SetItem(ret0,tmp1,numpyArryObj); Py_DECREF(tmp1); Py_DECREF(numpyArryObj); - PyTuple_SetItem(ret,0,ret0); - } - return ret; -#else - throw INTERP_KERNEL::Exception("PyWrap of DataArrayByte.__getnewargs__ : not implemented because numpy is not active in your configuration ! No serialization/unserialization available without numpy !"); -#endif - } - DataArrayByte *__setitem__(PyObject *obj, PyObject *value) throw(INTERP_KERNEL::Exception) { self->checkAllocated(); @@ -5984,3 +5919,32 @@ namespace MEDCoupling } }; } + +%pythoncode %{ +def MEDCouplingStdReduceFunct(cls,params): + a,b=params + ret=object.__new__(cls) + ret.__init__(*a) + ret.__setstate__(b) + return ret + +def MEDCouplingDataArrayDoubleReduce(self): + if not MEDCouplingHasNumPyBindings(): + raise InterpKernelException("PyWrap of DataArrayDouble.__reduce__ : not implemented because numpy is not active in your configuration ! No serialization/unserialization available without numpy !") + return MEDCouplingStdReduceFunct,(DataArrayDouble,((self.toNumPyArray(),),(self.__getstate__()),)) + +def MEDCouplingDataArrayIntReduce(self): + if not MEDCouplingHasNumPyBindings(): + raise InterpKernelException("PyWrap of DataArrayInt.__reduce__ : not implemented because numpy is not active in your configuration ! No serialization/unserialization available without numpy !") + return MEDCouplingStdReduceFunct,(DataArrayInt,((self.toNumPyArray(),),(self.__getstate__()),)) + +def MEDCouplingDataArrayByteReduce(self): + if not MEDCouplingHasNumPyBindings(): + raise InterpKernelException("PyWrap of DataArrayByte.__reduce__ : not implemented because numpy is not active in your configuration ! No serialization/unserialization available without numpy !") + return MEDCouplingStdReduceFunct,(DataArrayByte,((self.toNumPyArray(),),(self.__getstate__()),)) + +def MEDCouplingDataArrayFloatReduce(self): + if not MEDCouplingHasNumPyBindings(): + raise InterpKernelException("PyWrap of DataArrayFloat.__reduce__ : not implemented because numpy is not active in your configuration ! No serialization/unserialization available without numpy !") + return MEDCouplingStdReduceFunct,(DataArrayFloat,((self.toNumPyArray(),),(self.__getstate__()),)) +%}