X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FMEDCoupling_Swig%2FMEDCouplingMemArray.i;h=397712f5d8666b668385c02c562585be7fbccc94;hb=b7e277ad50223814bc479c5bd64cf12abe8fc959;hp=4bfeddfae5714f28e334aa2aafecc93e04238a43;hpb=fb6ad3f990cf8c26e23ff4f6ed571d85dc738aac;p=tools%2Fmedcoupling.git diff --git a/src/MEDCoupling_Swig/MEDCouplingMemArray.i b/src/MEDCoupling_Swig/MEDCouplingMemArray.i index 4bfeddfae..397712f5d 100644 --- a/src/MEDCoupling_Swig/MEDCouplingMemArray.i +++ b/src/MEDCoupling_Swig/MEDCouplingMemArray.i @@ -1,4 +1,4 @@ -// Copyright (C) 2007-2015 CEA/DEN, EDF R&D +// Copyright (C) 2007-2016 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 @@ -42,17 +42,19 @@ } //$$$$$$$$$$$$$$$$$$ -%newobject MEDCoupling::DataArray::deepCpy; +%newobject MEDCoupling::DataArray::deepCopy; +%newobject MEDCoupling::DataArray::buildNewEmptyInstance; %newobject MEDCoupling::DataArray::selectByTupleRanges; %newobject MEDCoupling::DataArray::selectByTupleId; %newobject MEDCoupling::DataArray::selectByTupleIdSafe; -%newobject MEDCoupling::DataArray::selectByTupleId2; +%newobject MEDCoupling::DataArray::selectByTupleIdSafeSlice; %newobject MEDCoupling::DataArray::Aggregate; %newobject MEDCoupling::DataArrayInt::New; %newobject MEDCoupling::DataArrayInt::__iter__; +%newobject MEDCoupling::DataArrayInt::selectPartDef; %newobject MEDCoupling::DataArrayInt::convertToDblArr; -%newobject MEDCoupling::DataArrayInt::performCpy; -%newobject MEDCoupling::DataArrayInt::substr; +%newobject MEDCoupling::DataArrayInt::performCopyOrIncrRef; +%newobject MEDCoupling::DataArrayInt::subArray; %newobject MEDCoupling::DataArrayInt::changeNbOfComponents; %newobject MEDCoupling::DataArrayInt::accumulatePerChunck; %newobject MEDCoupling::DataArrayInt::checkAndPreparePermutation; @@ -63,17 +65,17 @@ %newobject MEDCoupling::DataArrayInt::invertArrayO2N2N2O; %newobject MEDCoupling::DataArrayInt::invertArrayN2O2O2N; %newobject MEDCoupling::DataArrayInt::invertArrayO2N2N2OBis; -%newobject MEDCoupling::DataArrayInt::getIdsEqual; -%newobject MEDCoupling::DataArrayInt::getIdsNotEqual; -%newobject MEDCoupling::DataArrayInt::getIdsEqualList; -%newobject MEDCoupling::DataArrayInt::getIdsNotEqualList; -%newobject MEDCoupling::DataArrayInt::getIdsEqualTuple; +%newobject MEDCoupling::DataArrayInt::findIdsEqual; +%newobject MEDCoupling::DataArrayInt::findIdsNotEqual; +%newobject MEDCoupling::DataArrayInt::findIdsEqualList; +%newobject MEDCoupling::DataArrayInt::findIdsNotEqualList; +%newobject MEDCoupling::DataArrayInt::findIdsEqualTuple; %newobject MEDCoupling::DataArrayInt::sumPerTuple; %newobject MEDCoupling::DataArrayInt::negate; %newobject MEDCoupling::DataArrayInt::computeAbs; -%newobject MEDCoupling::DataArrayInt::getIdsInRange; -%newobject MEDCoupling::DataArrayInt::getIdsNotInRange; -%newobject MEDCoupling::DataArrayInt::getIdsStrictlyNegative; +%newobject MEDCoupling::DataArrayInt::findIdsInRange; +%newobject MEDCoupling::DataArrayInt::findIdsNotInRange; +%newobject MEDCoupling::DataArrayInt::findIdsStricltyNegative; %newobject MEDCoupling::DataArrayInt::Aggregate; %newobject MEDCoupling::DataArrayInt::AggregateIndexes; %newobject MEDCoupling::DataArrayInt::Meld; @@ -85,6 +87,7 @@ %newobject MEDCoupling::DataArrayInt::BuildUnion; %newobject MEDCoupling::DataArrayInt::BuildIntersection; %newobject MEDCoupling::DataArrayInt::Range; +%newobject MEDCoupling::DataArrayInt::indicesOfSubPart; %newobject MEDCoupling::DataArrayInt::fromNoInterlace; %newobject MEDCoupling::DataArrayInt::toNoInterlace; %newobject MEDCoupling::DataArrayInt::buildComplement; @@ -124,23 +127,24 @@ %newobject MEDCoupling::DataArrayChar::renumberR; %newobject MEDCoupling::DataArrayChar::renumberAndReduce; %newobject MEDCoupling::DataArrayChar::changeNbOfComponents; -%newobject MEDCoupling::DataArrayChar::getIdsEqual; -%newobject MEDCoupling::DataArrayChar::getIdsNotEqual; +%newobject MEDCoupling::DataArrayChar::findIdsEqual; +%newobject MEDCoupling::DataArrayChar::findIdsNotEqual; %newobject MEDCoupling::DataArrayChar::Aggregate; %newobject MEDCoupling::DataArrayChar::Meld; %newobject MEDCoupling::DataArrayByte::New; %newobject MEDCoupling::DataArrayByte::__iter__; -%newobject MEDCoupling::DataArrayByte::performCpy; +%newobject MEDCoupling::DataArrayByte::performCopyOrIncrRef; %newobject MEDCoupling::DataArrayByteTuple::buildDAByte; -%newobject MEDCoupling::DataArrayChar::substr; +%newobject MEDCoupling::DataArrayChar::subArray; %newobject MEDCoupling::DataArrayAsciiChar::New; %newobject MEDCoupling::DataArrayAsciiChar::__iter__; -%newobject MEDCoupling::DataArrayAsciiChar::performCpy; +%newobject MEDCoupling::DataArrayAsciiChar::performCopyOrIncrRef; %newobject MEDCoupling::DataArrayAsciiCharTuple::buildDAAsciiChar; %newobject MEDCoupling::DataArrayDouble::New; %newobject MEDCoupling::DataArrayDouble::__iter__; +%newobject MEDCoupling::DataArrayDouble::selectPartDef; %newobject MEDCoupling::DataArrayDouble::convertToIntArr; -%newobject MEDCoupling::DataArrayDouble::performCpy; +%newobject MEDCoupling::DataArrayDouble::performCopyOrIncrRef; %newobject MEDCoupling::DataArrayDouble::Aggregate; %newobject MEDCoupling::DataArrayDouble::Meld; %newobject MEDCoupling::DataArrayDouble::Dot; @@ -150,16 +154,17 @@ %newobject MEDCoupling::DataArrayDouble::Multiply; %newobject MEDCoupling::DataArrayDouble::Divide; %newobject MEDCoupling::DataArrayDouble::Pow; -%newobject MEDCoupling::DataArrayDouble::substr; +%newobject MEDCoupling::DataArrayDouble::symmetry3DPlane; +%newobject MEDCoupling::DataArrayDouble::subArray; %newobject MEDCoupling::DataArrayDouble::changeNbOfComponents; %newobject MEDCoupling::DataArrayDouble::accumulatePerChunck; -%newobject MEDCoupling::DataArrayDouble::getIdsInRange; -%newobject MEDCoupling::DataArrayDouble::getIdsNotInRange; +%newobject MEDCoupling::DataArrayDouble::findIdsInRange; +%newobject MEDCoupling::DataArrayDouble::findIdsNotInRange; %newobject MEDCoupling::DataArrayDouble::negate; %newobject MEDCoupling::DataArrayDouble::computeAbs; %newobject MEDCoupling::DataArrayDouble::applyFunc; -%newobject MEDCoupling::DataArrayDouble::applyFunc2; -%newobject MEDCoupling::DataArrayDouble::applyFunc3; +%newobject MEDCoupling::DataArrayDouble::applyFuncCompo; +%newobject MEDCoupling::DataArrayDouble::applyFuncNamedCompo; %newobject MEDCoupling::DataArrayDouble::doublyContractedProduct; %newobject MEDCoupling::DataArrayDouble::determinant; %newobject MEDCoupling::DataArrayDouble::eigenValues; @@ -181,6 +186,10 @@ %newobject MEDCoupling::DataArrayDouble::fromPolarToCart; %newobject MEDCoupling::DataArrayDouble::fromCylToCart; %newobject MEDCoupling::DataArrayDouble::fromSpherToCart; +%newobject MEDCoupling::DataArrayDouble::fromCartToPolar; +%newobject MEDCoupling::DataArrayDouble::fromCartToCyl; +%newobject MEDCoupling::DataArrayDouble::fromCartToSpher; +%newobject MEDCoupling::DataArrayDouble::fromCartToCylGiven; %newobject MEDCoupling::DataArrayDouble::cartesianize; %newobject MEDCoupling::DataArrayDouble::getDifferentValues; %newobject MEDCoupling::DataArrayDouble::findClosestTupleId; @@ -195,6 +204,15 @@ %newobject MEDCoupling::DataArrayDouble::__rpow__; %newobject MEDCoupling::DataArrayDoubleTuple::buildDADouble; +%newobject MEDCoupling::PartDefinition::New; +%newobject MEDCoupling::PartDefinition::toDAI; +%newobject MEDCoupling::PartDefinition::__add__; +%newobject MEDCoupling::PartDefinition::composeWith; +%newobject MEDCoupling::PartDefinition::tryToSimplify; +%newobject MEDCoupling::DataArrayPartDefinition::New; +%newobject MEDCoupling::SlicePartDefinition::New; + + %feature("unref") DataArray "$this->decrRef();" %feature("unref") DataArrayDouble "$this->decrRef();" %feature("unref") DataArrayInt "$this->decrRef();" @@ -202,6 +220,10 @@ %feature("unref") DataArrayAsciiChar "$this->decrRef();" %feature("unref") DataArrayByte "$this->decrRef();" +%feature("unref") PartDefinition "$this->decrRef();" +%feature("unref") DataArrayPartDefinition "$this->decrRef();" +%feature("unref") SlicePartDefinition "$this->decrRef();" + namespace MEDCoupling { typedef enum @@ -211,6 +233,109 @@ namespace MEDCoupling AX_SPHER = 5 } MEDCouplingAxisType; + class DataArrayInt; + + class PartDefinition : public RefCountObject, public TimeLabel + { + public: + static PartDefinition *New(int start, int stop, int step) throw(INTERP_KERNEL::Exception); + static PartDefinition *New(DataArrayInt *listOfIds) throw(INTERP_KERNEL::Exception); + virtual DataArrayInt *toDAI() const throw(INTERP_KERNEL::Exception); + virtual int getNumberOfElems() const throw(INTERP_KERNEL::Exception); + virtual std::string getRepr() const throw(INTERP_KERNEL::Exception); + virtual PartDefinition *composeWith(const PartDefinition *other) const throw(INTERP_KERNEL::Exception); + virtual void checkConsistencyLight() const throw(INTERP_KERNEL::Exception); + virtual PartDefinition *tryToSimplify() const throw(INTERP_KERNEL::Exception); + %extend + { + virtual PartDefinition *__add__(const PartDefinition& other) const throw(INTERP_KERNEL::Exception) + { + return (*self)+other; + } + + virtual PyObject *isEqual(const PartDefinition *other) const throw(INTERP_KERNEL::Exception) + { + std::string ret1; + bool ret0(self->isEqual(other,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; + } + + virtual PyObject *deepCopy() const throw(INTERP_KERNEL::Exception) + { + return convertPartDefinition(self->deepCopy(),SWIG_POINTER_OWN | 0); + } + } + protected: + virtual ~PartDefinition(); + }; + + class DataArrayPartDefinition : public PartDefinition + { + public: + static DataArrayPartDefinition *New(DataArrayInt *listOfIds) throw(INTERP_KERNEL::Exception); + %extend + { + DataArrayPartDefinition(DataArrayInt *listOfIds) throw(INTERP_KERNEL::Exception) + { + return DataArrayPartDefinition::New(listOfIds); + } + + std::string __str__() const throw(INTERP_KERNEL::Exception) + { + return self->getRepr(); + } + + std::string __repr__() const throw(INTERP_KERNEL::Exception) + { + std::ostringstream oss; oss << "DataArrayPartDefinition C++ instance at " << self << "." << std::endl; + oss << self->getRepr(); + return oss.str(); + } + } + protected: + virtual ~DataArrayPartDefinition(); + }; + + class SlicePartDefinition : public PartDefinition + { + public: + static SlicePartDefinition *New(int start, int stop, int step) throw(INTERP_KERNEL::Exception); + int getEffectiveStop() const throw(INTERP_KERNEL::Exception); + %extend + { + SlicePartDefinition(int start, int stop, int step) throw(INTERP_KERNEL::Exception) + { + return SlicePartDefinition::New(start,stop,step); + } + + PyObject *getSlice() const throw(INTERP_KERNEL::Exception) + { + int a,b,c; + self->getSlice(a,b,c); + return PySlice_New(PyInt_FromLong(a),PyInt_FromLong(b),PyInt_FromLong(c)); + } + + std::string __str__() const throw(INTERP_KERNEL::Exception) + { + return self->getRepr(); + } + + std::string __repr__() const throw(INTERP_KERNEL::Exception) + { + std::ostringstream oss; oss << "SlicePartDefinition C++ instance at " << self << "." << std::endl; + oss << self->getRepr(); + return oss.str(); + } + } + protected: + virtual ~SlicePartDefinition(); + }; + class DataArray : public RefCountObject, public TimeLabel { public: @@ -239,9 +364,13 @@ namespace MEDCoupling virtual int getNumberOfTuples() const throw(INTERP_KERNEL::Exception); virtual std::size_t getNbOfElems() const throw(INTERP_KERNEL::Exception); virtual std::size_t getNbOfElemAllocated() const throw(INTERP_KERNEL::Exception); - virtual DataArray *deepCpy() const throw(INTERP_KERNEL::Exception); - virtual DataArray *selectByTupleId2(int bg, int end2, int step) const throw(INTERP_KERNEL::Exception); + virtual DataArray *deepCopy() const throw(INTERP_KERNEL::Exception); + virtual DataArray *buildNewEmptyInstance() const throw(INTERP_KERNEL::Exception); + virtual DataArray *selectByTupleIdSafeSlice(int bg, int end2, int step) const throw(INTERP_KERNEL::Exception); virtual void rearrange(int newNbOfCompo) throw(INTERP_KERNEL::Exception); + virtual void circularPermutation(int nbOfShift=1) throw(INTERP_KERNEL::Exception); + virtual void circularPermutationPerTuple(int nbOfShift=1) throw(INTERP_KERNEL::Exception); + virtual void reversePerTuple() throw(INTERP_KERNEL::Exception); void checkNbOfTuples(int nbOfTuples, const std::string& msg) const throw(INTERP_KERNEL::Exception); void checkNbOfComps(int nbOfCompo, const std::string& msg) const throw(INTERP_KERNEL::Exception); void checkNbOfTuplesAndComp(const DataArray& other, const std::string& msg) const throw(INTERP_KERNEL::Exception); @@ -253,7 +382,7 @@ namespace MEDCoupling static std::string GetVarNameFromInfo(const std::string& info) throw(INTERP_KERNEL::Exception); static std::string GetUnitFromInfo(const std::string& info) throw(INTERP_KERNEL::Exception); static std::string BuildInfoFromVarAndUnit(const std::string& var, const std::string& unit) throw(INTERP_KERNEL::Exception); - static std::string GetAxTypeRepr(MEDCouplingAxisType at) throw(INTERP_KERNEL::Exception); + static std::string GetAxisTypeRepr(MEDCouplingAxisType at) throw(INTERP_KERNEL::Exception); void updateTime() const; %extend { @@ -341,8 +470,8 @@ namespace MEDCoupling //tuplesSelec in PyObject * because DataArrayInt is not already existing ! virtual void setContigPartOfSelectedValues(int tupleIdStart, PyObject *aBase, PyObject *tuplesSelec) throw(INTERP_KERNEL::Exception) { - static const char msg[]="DataArray::setContigPartOfSelectedValues2 : 4th parameter \"tuplesSelec\" should be of type DataArrayInt"; - DataArray *a=CheckAndRetrieveDataArrayInstance(aBase,"DataArray::setContigPartOfSelectedValues2 : 3rd parameter \"aBase\" should be of type DataArray"); + static const char msg[]="DataArray::setContigPartOfSelectedValuesSlice : 4th parameter \"tuplesSelec\" should be of type DataArrayInt"; + DataArray *a=CheckAndRetrieveDataArrayInstance(aBase,"DataArray::setContigPartOfSelectedValuesSlice : 3rd parameter \"aBase\" should be of type DataArray"); DataArray *tuplesSelecPtr=CheckAndRetrieveDataArrayInstance(tuplesSelec,msg); DataArrayInt *tuplesSelecPtr2=0; if(tuplesSelecPtr) @@ -354,10 +483,10 @@ namespace MEDCoupling self->setContigPartOfSelectedValues(tupleIdStart,a,tuplesSelecPtr2); } - virtual void setContigPartOfSelectedValues2(int tupleIdStart, PyObject *aBase, int bg, int end2, int step) throw(INTERP_KERNEL::Exception) + virtual void setContigPartOfSelectedValuesSlice(int tupleIdStart, PyObject *aBase, int bg, int end2, int step) throw(INTERP_KERNEL::Exception) { - DataArray *a=CheckAndRetrieveDataArrayInstance(aBase,"DataArray::setContigPartOfSelectedValues2 : 2nd parameter \"aBase\" should be of type DataArray"); - self->setContigPartOfSelectedValues2(tupleIdStart,a,bg,end2,step); + DataArray *a=CheckAndRetrieveDataArrayInstance(aBase,"DataArray::setContigPartOfSelectedValuesSlice : 2nd parameter \"aBase\" should be of type DataArray"); + self->setContigPartOfSelectedValuesSlice(tupleIdStart,a,bg,end2,step); } virtual DataArray *selectByTupleRanges(PyObject *li) const throw(INTERP_KERNEL::Exception) @@ -532,8 +661,9 @@ namespace MEDCoupling static DataArrayDouble *New(); double doubleValue() const throw(INTERP_KERNEL::Exception); bool empty() const throw(INTERP_KERNEL::Exception); - DataArrayDouble *performCpy(bool deepCpy) const throw(INTERP_KERNEL::Exception); - void cpyFrom(const DataArrayDouble& other) throw(INTERP_KERNEL::Exception); + void aggregate(const DataArrayDouble *other) throw(INTERP_KERNEL::Exception); + DataArrayDouble *performCopyOrIncrRef(bool deepCopy) const throw(INTERP_KERNEL::Exception); + void deepCopyFrom(const DataArrayDouble& other) throw(INTERP_KERNEL::Exception); void reserve(std::size_t nbOfElems) throw(INTERP_KERNEL::Exception); void pushBackSilent(double val) throw(INTERP_KERNEL::Exception); double popBackSilent() throw(INTERP_KERNEL::Exception); @@ -555,7 +685,7 @@ namespace MEDCoupling DataArrayInt *convertToIntArr() const throw(INTERP_KERNEL::Exception); DataArrayDouble *fromNoInterlace() const throw(INTERP_KERNEL::Exception); DataArrayDouble *toNoInterlace() const throw(INTERP_KERNEL::Exception); - DataArrayDouble *substr(int tupleIdBg, int tupleIdEnd=-1) const throw(INTERP_KERNEL::Exception); + DataArrayDouble *subArray(int tupleIdBg, int tupleIdEnd=-1) const throw(INTERP_KERNEL::Exception); void transpose() throw(INTERP_KERNEL::Exception); DataArrayDouble *changeNbOfComponents(int newNbOfComp, double dftValue) const throw(INTERP_KERNEL::Exception); void meldWith(const DataArrayDouble *other) throw(INTERP_KERNEL::Exception); @@ -589,6 +719,9 @@ namespace MEDCoupling DataArrayDouble *fromPolarToCart() const throw(INTERP_KERNEL::Exception); DataArrayDouble *fromCylToCart() const throw(INTERP_KERNEL::Exception); DataArrayDouble *fromSpherToCart() const throw(INTERP_KERNEL::Exception); + DataArrayDouble *fromCartToPolar() const throw(INTERP_KERNEL::Exception); + DataArrayDouble *fromCartToCyl() const throw(INTERP_KERNEL::Exception); + DataArrayDouble *fromCartToSpher() const throw(INTERP_KERNEL::Exception); DataArrayDouble *cartesianize(MEDCouplingAxisType atOfThis) const throw(INTERP_KERNEL::Exception); DataArrayDouble *doublyContractedProduct() const throw(INTERP_KERNEL::Exception); DataArrayDouble *determinant() const throw(INTERP_KERNEL::Exception); @@ -615,12 +748,12 @@ namespace MEDCoupling DataArrayDouble *applyFunc(int nbOfComp, const std::string& func, bool isSafe=true) const throw(INTERP_KERNEL::Exception); DataArrayDouble *applyFunc(const std::string& func, bool isSafe=true) const throw(INTERP_KERNEL::Exception); void applyFuncOnThis(const std::string& func, bool isSafe=true) throw(INTERP_KERNEL::Exception); - DataArrayDouble *applyFunc2(int nbOfComp, const std::string& func, bool isSafe=true) const throw(INTERP_KERNEL::Exception); - DataArrayDouble *applyFunc3(int nbOfComp, const std::vector& varsOrder, const std::string& func, bool isSafe=true) const throw(INTERP_KERNEL::Exception); + DataArrayDouble *applyFuncCompo(int nbOfComp, const std::string& func, bool isSafe=true) const throw(INTERP_KERNEL::Exception); + DataArrayDouble *applyFuncNamedCompo(int nbOfComp, const std::vector& varsOrder, const std::string& func, bool isSafe=true) const throw(INTERP_KERNEL::Exception); void applyFuncFast32(const std::string& func) throw(INTERP_KERNEL::Exception); void applyFuncFast64(const std::string& func) throw(INTERP_KERNEL::Exception); - DataArrayInt *getIdsInRange(double vmin, double vmax) const throw(INTERP_KERNEL::Exception); - DataArrayInt *getIdsNotInRange(double vmin, double vmax) const throw(INTERP_KERNEL::Exception); + DataArrayInt *findIdsInRange(double vmin, double vmax) const throw(INTERP_KERNEL::Exception); + DataArrayInt *findIdsNotInRange(double vmin, double vmax) const throw(INTERP_KERNEL::Exception); static DataArrayDouble *Aggregate(const DataArrayDouble *a1, const DataArrayDouble *a2) throw(INTERP_KERNEL::Exception); static DataArrayDouble *Meld(const DataArrayDouble *a1, const DataArrayDouble *a2) throw(INTERP_KERNEL::Exception); static DataArrayDouble *Dot(const DataArrayDouble *a1, const DataArrayDouble *a2) throw(INTERP_KERNEL::Exception); @@ -668,7 +801,7 @@ namespace MEDCoupling int nbOfCompo=PyInt_AS_LONG(elt2); if(nbOfCompo<0) throw INTERP_KERNEL::Exception("DataArrayDouble::New : should be a positive number of components !"); - MEDCouplingAutoRefCountObjectPtr ret=DataArrayDouble::New(); + MCAuto ret=DataArrayDouble::New(); std::vector tmp=fillArrayWithPyListDbl2(elt0,nbOfTuples1,nbOfCompo); ret->alloc(nbOfTuples1,nbOfCompo); std::copy(tmp.begin(),tmp.end(),ret->getPointer()); return ret.retn(); @@ -678,7 +811,7 @@ namespace MEDCoupling } else {//DataArrayDouble.New([1.,3.,4.],3) - MEDCouplingAutoRefCountObjectPtr ret=DataArrayDouble::New(); + MCAuto ret=DataArrayDouble::New(); int tmpp1=-1; std::vector tmp=fillArrayWithPyListDbl2(elt0,nbOfTuples1,tmpp1); ret->alloc(nbOfTuples1,tmpp1); std::copy(tmp.begin(),tmp.end(),ret->getPointer()); @@ -690,7 +823,7 @@ namespace MEDCoupling } else {// DataArrayDouble.New([1.,3.,4.]) - MEDCouplingAutoRefCountObjectPtr ret=DataArrayDouble::New(); + MCAuto ret=DataArrayDouble::New(); int tmpp1=-1,tmpp2=-1; std::vector tmp=fillArrayWithPyListDbl2(elt0,tmpp1,tmpp2); ret->alloc(tmpp1,tmpp2); std::copy(tmp.begin(),tmp.end(),ret->getPointer()); @@ -711,7 +844,7 @@ namespace MEDCoupling int nbOfCompo=PyInt_AS_LONG(nbOfTuples); if(nbOfCompo<0) throw INTERP_KERNEL::Exception("DataArrayDouble::New : should be a positive number of components !"); - MEDCouplingAutoRefCountObjectPtr ret=DataArrayDouble::New(); + MCAuto ret=DataArrayDouble::New(); ret->alloc(nbOfTuples1,nbOfCompo); return ret.retn(); } @@ -723,7 +856,7 @@ namespace MEDCoupling } else {//DataArrayDouble.New(5) - MEDCouplingAutoRefCountObjectPtr ret=DataArrayDouble::New(); + MCAuto ret=DataArrayDouble::New(); ret->alloc(nbOfTuples1,1); return ret.retn(); } @@ -744,6 +877,12 @@ namespace MEDCoupling return MEDCoupling_DataArrayDouble_New__SWIG_1(elt0,nbOfTuples,elt2); } + DataArrayDouble *selectPartDef(const PartDefinition* pd) const throw(INTERP_KERNEL::Exception) + { + MCAuto ret(self->selectPartDef(pd)); + return ret.retn(); + } + void pushBackValsSilent(PyObject *li) throw(INTERP_KERNEL::Exception) { double val; @@ -867,6 +1006,47 @@ namespace MEDCoupling return convertDblArrToPyListOfTuple(vals,nbOfComp,nbOfTuples); } + DataArrayDouble *symmetry3DPlane(PyObject *point, PyObject *normalVector) throw(INTERP_KERNEL::Exception) + { + const char msg[]="Python wrap of DataArrayDouble::symmetry3DPlane : "; + double val,val2; + DataArrayDouble *a,*a2; + DataArrayDoubleTuple *aa,*aa2; + std::vector bb,bb2; + int sw; + const double *centerPtr(convertObjToPossibleCpp5_Safe(point,sw,val,a,aa,bb,msg,1,3,true)); + const double *vectorPtr(convertObjToPossibleCpp5_Safe(normalVector,sw,val2,a2,aa2,bb2,msg,1,3,true)); + MCAuto ret(self->symmetry3DPlane(centerPtr,vectorPtr)); + return ret.retn(); + } + + static PyObject *GiveBaseForPlane(PyObject *normalVector) throw(INTERP_KERNEL::Exception) + { + const char msg[]="Python wrap of DataArrayDouble::GiveBaseForPlane : "; + double val,val2; + DataArrayDouble *a,*a2; + DataArrayDoubleTuple *aa,*aa2; + std::vector bb,bb2; + int sw; + const double *vectorPtr(convertObjToPossibleCpp5_Safe(normalVector,sw,val,a,aa,bb,msg,1,3,true)); + double res[9]; + DataArrayDouble::GiveBaseForPlane(vectorPtr,res); + return convertDblArrToPyListOfTuple(res,3,3); + } + + DataArrayDouble *fromCartToCylGiven(const DataArrayDouble *coords, PyObject *center, PyObject *vector) const + { + const char msg[]="Python wrap of DataArrayDouble::fromCartToCylGiven : "; + double val,val2; + DataArrayDouble *a,*a2; + DataArrayDoubleTuple *aa,*aa2; + std::vector bb,bb2; + int sw; + const double *centerPtr=convertObjToPossibleCpp5_Safe(center,sw,val,a,aa,bb,msg,1,3,true); + const double *vectorPtr=convertObjToPossibleCpp5_Safe(vector,sw,val2,a2,aa2,bb2,msg,1,3,true); + return self->fromCartToCylGiven(coords,centerPtr,vectorPtr); + } + DataArrayDouble *renumber(PyObject *li) throw(INTERP_KERNEL::Exception) { void *da=0; @@ -1063,6 +1243,16 @@ namespace MEDCoupling convertPyToNewIntArr3(li,tmp); self->setSelectedComponents(a,tmp); } + + PyObject *explodeComponents() const throw(INTERP_KERNEL::Exception) + { + std::vector< MCAuto > retCpp(self->explodeComponents()); + std::size_t sz(retCpp.size()); + PyObject *res(PyList_New(sz)); + for(std::size_t i=0;igetNumberOfComponents(),nbTuples=-1; const char msg[]="Python wrap of DataArrayDouble::computeTupleIdsNearTuples : "; const double *pos=convertObjToPossibleCpp5_Safe2(pt,sw,val,a,aa,bb,msg,nbComp,true,nbTuples); - MEDCouplingAutoRefCountObjectPtr inpu=DataArrayDouble::New(); inpu->useArray(pos,false,CPP_DEALLOC,nbTuples,nbComp); + MCAuto inpu=DataArrayDouble::New(); inpu->useArray(pos,false,CPP_DEALLOC,nbTuples,nbComp); DataArrayInt *c=0,*cI=0; self->computeTupleIdsNearTuples(inpu,eps,c,cI); PyObject *ret=PyTuple_New(2); @@ -1130,7 +1320,7 @@ namespace MEDCoupling DataArrayInt *dt1=0,*dc1=0; int sw; convertObjToPossibleCpp3(obj,nbOfTuples,nbOfComponents,sw,it1,ic1,vt1,vc1,pt1,pc1,dt1,dc1); - MEDCouplingAutoRefCountObjectPtr ret; + MCAuto ret; switch(sw) { case 1: @@ -1140,7 +1330,7 @@ namespace MEDCoupling case 2: return SWIG_NewPointerObj(SWIG_as_voidptr(self->selectByTupleIdSafe(&vt1[0],&vt1[0]+vt1.size())),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 ); case 3: - return SWIG_NewPointerObj(SWIG_as_voidptr(self->selectByTupleId2(pt1.first,pt1.second.first,pt1.second.second)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 ); + return SWIG_NewPointerObj(SWIG_as_voidptr(self->selectByTupleIdSafeSlice(pt1.first,pt1.second.first,pt1.second.second)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 ); case 4: return SWIG_NewPointerObj(SWIG_as_voidptr(self->selectByTupleIdSafe(dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems())),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 ); case 5: @@ -1153,7 +1343,7 @@ namespace MEDCoupling } case 7: { - ret=self->selectByTupleId2(pt1.first,pt1.second.first,pt1.second.second); + 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)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 ); } @@ -1175,7 +1365,7 @@ namespace MEDCoupling } case 11: { - ret=self->selectByTupleId2(pt1.first,pt1.second.first,pt1.second.second); + ret=self->selectByTupleIdSafeSlice(pt1.first,pt1.second.first,pt1.second.second); return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(vc1)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 ); } case 12: @@ -1203,7 +1393,7 @@ namespace MEDCoupling } case 15: { - ret=self->selectByTupleId2(pt1.first,pt1.second.first,pt1.second.second); + ret=self->selectByTupleIdSafeSlice(pt1.first,pt1.second.first,pt1.second.second); int nbOfComp=DataArray::GetNumberOfItemGivenBESRelative(pc1.first,pc1.second.first,pc1.second.second,msg2); std::vector v2(nbOfComp); for(int i=0;i > pt1,pc1; DataArrayInt *dt1=0,*dc1=0; convertObjToPossibleCpp3(obj,nbOfTuples,nbOfComponents,sw2,it1,ic1,vt1,vc1,pt1,pc1,dt1,dc1); - MEDCouplingAutoRefCountObjectPtr tmp; + MCAuto tmp; switch(sw2) { case 1: @@ -1591,7 +1781,7 @@ namespace MEDCoupling if(other) { PyObject *tmp=SWIG_NewPointerObj(SWIG_as_voidptr(self),SWIGTYPE_p_MEDCoupling__DataArrayDouble, 0 | 0 ); - MEDCouplingAutoRefCountObjectPtr ret=MEDCoupling_MEDCouplingFieldDouble___radd__Impl(other,tmp); + MCAuto ret=MEDCoupling_MEDCouplingFieldDouble___radd__Impl(other,tmp); Py_XDECREF(tmp); return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble, SWIG_POINTER_OWN | 0 ); } @@ -1605,7 +1795,7 @@ namespace MEDCoupling { case 1: { - MEDCouplingAutoRefCountObjectPtr ret=self->deepCpy(); + MCAuto ret=self->deepCopy(); ret->applyLin(1.,val); return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 ); } @@ -1615,12 +1805,12 @@ namespace MEDCoupling } case 3: { - MEDCouplingAutoRefCountObjectPtr aaa=aa->buildDADouble(1,self->getNumberOfComponents()); + MCAuto aaa=aa->buildDADouble(1,self->getNumberOfComponents()); return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Add(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 ); } case 4: { - MEDCouplingAutoRefCountObjectPtr aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,CPP_DEALLOC,1,(int)bb.size()); + MCAuto aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,CPP_DEALLOC,1,(int)bb.size()); return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Add(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 ); } default: @@ -1641,18 +1831,18 @@ namespace MEDCoupling { case 1: { - MEDCouplingAutoRefCountObjectPtr ret=self->deepCpy(); + MCAuto ret=self->deepCopy(); ret->applyLin(1.,val); return ret.retn(); } case 3: { - MEDCouplingAutoRefCountObjectPtr aaa=aa->buildDADouble(1,self->getNumberOfComponents()); + MCAuto aaa=aa->buildDADouble(1,self->getNumberOfComponents()); return DataArrayDouble::Add(self,aaa); } case 4: { - MEDCouplingAutoRefCountObjectPtr aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,CPP_DEALLOC,1,(int)bb.size()); + MCAuto aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,CPP_DEALLOC,1,(int)bb.size()); return DataArrayDouble::Add(self,aaa); } default: @@ -1685,14 +1875,14 @@ namespace MEDCoupling } case 3: { - MEDCouplingAutoRefCountObjectPtr aaa=aa->buildDADouble(1,self->getNumberOfComponents()); + MCAuto aaa=aa->buildDADouble(1,self->getNumberOfComponents()); self->addEqual(aaa); Py_XINCREF(trueSelf); return trueSelf; } case 4: { - MEDCouplingAutoRefCountObjectPtr aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,CPP_DEALLOC,1,(int)bb.size()); + MCAuto aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,CPP_DEALLOC,1,(int)bb.size()); self->addEqual(aaa); Py_XINCREF(trueSelf); return trueSelf; @@ -1719,7 +1909,7 @@ namespace MEDCoupling if(other) { PyObject *tmp=SWIG_NewPointerObj(SWIG_as_voidptr(self),SWIGTYPE_p_MEDCoupling__DataArrayDouble, 0 | 0 ); - MEDCouplingAutoRefCountObjectPtr ret=MEDCoupling_MEDCouplingFieldDouble___rsub__Impl(other,tmp); + MCAuto ret=MEDCoupling_MEDCouplingFieldDouble___rsub__Impl(other,tmp); Py_XDECREF(tmp); return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble, SWIG_POINTER_OWN | 0 ); } @@ -1733,7 +1923,7 @@ namespace MEDCoupling { case 1: { - MEDCouplingAutoRefCountObjectPtr ret=self->deepCpy(); + MCAuto ret=self->deepCopy(); ret->applyLin(1.,-val); return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 ); } @@ -1743,12 +1933,12 @@ namespace MEDCoupling } case 3: { - MEDCouplingAutoRefCountObjectPtr aaa=aa->buildDADouble(1,self->getNumberOfComponents()); + MCAuto aaa=aa->buildDADouble(1,self->getNumberOfComponents()); return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Substract(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 ); } case 4: { - MEDCouplingAutoRefCountObjectPtr aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,CPP_DEALLOC,1,(int)bb.size()); + MCAuto aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,CPP_DEALLOC,1,(int)bb.size()); return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Substract(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 ); } default: @@ -1769,18 +1959,18 @@ namespace MEDCoupling { case 1: { - MEDCouplingAutoRefCountObjectPtr ret=self->deepCpy(); + MCAuto ret=self->deepCopy(); ret->applyLin(-1.,val); return ret.retn(); } case 3: { - MEDCouplingAutoRefCountObjectPtr aaa=aa->buildDADouble(1,self->getNumberOfComponents()); + MCAuto aaa=aa->buildDADouble(1,self->getNumberOfComponents()); return DataArrayDouble::Substract(aaa,self); } case 4: { - MEDCouplingAutoRefCountObjectPtr aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,CPP_DEALLOC,1,(int)bb.size()); + MCAuto aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,CPP_DEALLOC,1,(int)bb.size()); return DataArrayDouble::Substract(aaa,self); } default: @@ -1813,14 +2003,14 @@ namespace MEDCoupling } case 3: { - MEDCouplingAutoRefCountObjectPtr aaa=aa->buildDADouble(1,self->getNumberOfComponents()); + MCAuto aaa=aa->buildDADouble(1,self->getNumberOfComponents()); self->substractEqual(aaa); Py_XINCREF(trueSelf); return trueSelf; } case 4: { - MEDCouplingAutoRefCountObjectPtr aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,CPP_DEALLOC,1,(int)bb.size()); + MCAuto aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,CPP_DEALLOC,1,(int)bb.size()); self->substractEqual(aaa); Py_XINCREF(trueSelf); return trueSelf; @@ -1847,7 +2037,7 @@ namespace MEDCoupling if(other) { PyObject *tmp=SWIG_NewPointerObj(SWIG_as_voidptr(self),SWIGTYPE_p_MEDCoupling__DataArrayDouble, 0 | 0 ); - MEDCouplingAutoRefCountObjectPtr ret=MEDCoupling_MEDCouplingFieldDouble___rmul__Impl(other,tmp); + MCAuto ret=MEDCoupling_MEDCouplingFieldDouble___rmul__Impl(other,tmp); Py_XDECREF(tmp); return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble, SWIG_POINTER_OWN | 0 ); } @@ -1861,7 +2051,7 @@ namespace MEDCoupling { case 1: { - MEDCouplingAutoRefCountObjectPtr ret=self->deepCpy(); + MCAuto ret=self->deepCopy(); ret->applyLin(val,0.); return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 ); } @@ -1871,12 +2061,12 @@ namespace MEDCoupling } case 3: { - MEDCouplingAutoRefCountObjectPtr aaa=aa->buildDADouble(1,self->getNumberOfComponents()); + MCAuto aaa=aa->buildDADouble(1,self->getNumberOfComponents()); return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Multiply(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 ); } case 4: { - MEDCouplingAutoRefCountObjectPtr aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,CPP_DEALLOC,1,(int)bb.size()); + MCAuto aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,CPP_DEALLOC,1,(int)bb.size()); return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Multiply(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 ); } default: @@ -1897,18 +2087,18 @@ namespace MEDCoupling { case 1: { - MEDCouplingAutoRefCountObjectPtr ret=self->deepCpy(); + MCAuto ret=self->deepCopy(); ret->applyLin(val,0.); return ret.retn(); } case 3: { - MEDCouplingAutoRefCountObjectPtr aaa=aa->buildDADouble(1,self->getNumberOfComponents()); + MCAuto aaa=aa->buildDADouble(1,self->getNumberOfComponents()); return DataArrayDouble::Multiply(self,aaa); } case 4: { - MEDCouplingAutoRefCountObjectPtr aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,CPP_DEALLOC,1,(int)bb.size()); + MCAuto aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,CPP_DEALLOC,1,(int)bb.size()); return DataArrayDouble::Multiply(self,aaa); } default: @@ -1941,14 +2131,14 @@ namespace MEDCoupling } case 3: { - MEDCouplingAutoRefCountObjectPtr aaa=aa->buildDADouble(1,self->getNumberOfComponents()); + MCAuto aaa=aa->buildDADouble(1,self->getNumberOfComponents()); self->multiplyEqual(aaa); Py_XINCREF(trueSelf); return trueSelf; } case 4: { - MEDCouplingAutoRefCountObjectPtr aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,CPP_DEALLOC,1,(int)bb.size()); + MCAuto aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,CPP_DEALLOC,1,(int)bb.size()); self->multiplyEqual(aaa); Py_XINCREF(trueSelf); return trueSelf; @@ -1975,7 +2165,7 @@ namespace MEDCoupling if(other) { PyObject *tmp=SWIG_NewPointerObj(SWIG_as_voidptr(self),SWIGTYPE_p_MEDCoupling__DataArrayDouble, 0 | 0 ); - MEDCouplingAutoRefCountObjectPtr ret=MEDCoupling_MEDCouplingFieldDouble___rdiv__Impl(other,tmp); + MCAuto ret=MEDCoupling_MEDCouplingFieldDouble___rdiv__Impl(other,tmp); Py_XDECREF(tmp); return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble, SWIG_POINTER_OWN | 0 ); } @@ -1991,7 +2181,7 @@ namespace MEDCoupling { if(val==0.) throw INTERP_KERNEL::Exception("DataArrayDouble::__div__ : trying to divide by zero !"); - MEDCouplingAutoRefCountObjectPtr ret=self->deepCpy(); + MCAuto ret=self->deepCopy(); ret->applyLin(1/val,0.); return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 ); } @@ -2001,12 +2191,12 @@ namespace MEDCoupling } case 3: { - MEDCouplingAutoRefCountObjectPtr aaa=aa->buildDADouble(1,self->getNumberOfComponents()); + MCAuto aaa=aa->buildDADouble(1,self->getNumberOfComponents()); return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Divide(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 ); } case 4: { - MEDCouplingAutoRefCountObjectPtr aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,CPP_DEALLOC,1,(int)bb.size()); + MCAuto aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,CPP_DEALLOC,1,(int)bb.size()); return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Divide(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 ); } default: @@ -2027,18 +2217,18 @@ namespace MEDCoupling { case 1: { - MEDCouplingAutoRefCountObjectPtr ret=self->deepCpy(); + MCAuto ret=self->deepCopy(); ret->applyInv(val); return ret.retn(); } case 3: { - MEDCouplingAutoRefCountObjectPtr aaa=aa->buildDADouble(1,self->getNumberOfComponents()); + MCAuto aaa=aa->buildDADouble(1,self->getNumberOfComponents()); return DataArrayDouble::Divide(aaa,self); } case 4: { - MEDCouplingAutoRefCountObjectPtr aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,CPP_DEALLOC,1,(int)bb.size()); + MCAuto aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,CPP_DEALLOC,1,(int)bb.size()); return DataArrayDouble::Divide(aaa,self); } default: @@ -2073,14 +2263,14 @@ namespace MEDCoupling } case 3: { - MEDCouplingAutoRefCountObjectPtr aaa=aa->buildDADouble(1,self->getNumberOfComponents()); + MCAuto aaa=aa->buildDADouble(1,self->getNumberOfComponents()); self->divideEqual(aaa); Py_XINCREF(trueSelf); return trueSelf; } case 4: { - MEDCouplingAutoRefCountObjectPtr aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,CPP_DEALLOC,1,(int)bb.size()); + MCAuto aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,CPP_DEALLOC,1,(int)bb.size()); self->divideEqual(aaa); Py_XINCREF(trueSelf); return trueSelf; @@ -2103,7 +2293,7 @@ namespace MEDCoupling { case 1: { - MEDCouplingAutoRefCountObjectPtr ret=self->deepCpy(); + MCAuto ret=self->deepCopy(); ret->applyPow(val); return ret.retn(); } @@ -2113,12 +2303,12 @@ namespace MEDCoupling } case 3: { - MEDCouplingAutoRefCountObjectPtr aaa=aa->buildDADouble(1,self->getNumberOfComponents()); + MCAuto aaa=aa->buildDADouble(1,self->getNumberOfComponents()); return DataArrayDouble::Pow(self,aaa); } case 4: { - MEDCouplingAutoRefCountObjectPtr aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,CPP_DEALLOC,1,(int)bb.size()); + MCAuto aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,CPP_DEALLOC,1,(int)bb.size()); return DataArrayDouble::Pow(self,aaa); } default: @@ -2139,18 +2329,18 @@ namespace MEDCoupling { case 1: { - MEDCouplingAutoRefCountObjectPtr ret=self->deepCpy(); + MCAuto ret=self->deepCopy(); ret->applyRPow(val); return ret.retn(); } case 3: { - MEDCouplingAutoRefCountObjectPtr aaa=aa->buildDADouble(1,self->getNumberOfComponents()); + MCAuto aaa=aa->buildDADouble(1,self->getNumberOfComponents()); return DataArrayDouble::Pow(aaa,self); } case 4: { - MEDCouplingAutoRefCountObjectPtr aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,CPP_DEALLOC,1,(int)bb.size()); + MCAuto aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,CPP_DEALLOC,1,(int)bb.size()); return DataArrayDouble::Pow(aaa,self); } default: @@ -2183,14 +2373,14 @@ namespace MEDCoupling } case 3: { - MEDCouplingAutoRefCountObjectPtr aaa=aa->buildDADouble(1,self->getNumberOfComponents()); + MCAuto aaa=aa->buildDADouble(1,self->getNumberOfComponents()); self->powEqual(aaa); Py_XINCREF(trueSelf); return trueSelf; } case 4: { - MEDCouplingAutoRefCountObjectPtr aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,CPP_DEALLOC,1,(int)bb.size()); + MCAuto aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,CPP_DEALLOC,1,(int)bb.size()); self->powEqual(aaa); Py_XINCREF(trueSelf); return trueSelf; @@ -2224,35 +2414,7 @@ namespace MEDCoupling // serialization static PyObject *___new___(PyObject *cls, PyObject *args) throw(INTERP_KERNEL::Exception) { - static const char MSG[]="DataArrayDouble.__new__ : the args in input is expected to be a tuple !"; - if(!PyTuple_Check(args)) - throw INTERP_KERNEL::Exception(MSG); - 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); - PyObject *initMeth(PyObject_GetAttrString(instance,"__init__")); - int sz(PyTuple_Size(args)); - - 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 *zeNumpyRepr(0); - PyObject *tmp1(PyInt_FromLong(0)); - zeNumpyRepr=PyDict_GetItem(PyTuple_GetItem(args,1),tmp1);//borrowed - Py_DECREF(tmp1); - PyObject *tmp3(PyTuple_New(1)); - PyTuple_SetItem(tmp3,0,zeNumpyRepr); Py_XINCREF(zeNumpyRepr); - PyObject *tmp2(PyObject_CallObject(initMeth,tmp3)); - Py_XDECREF(tmp2); - Py_DECREF(tmp3); - } - Py_DECREF(initMeth); - return instance; + return NewMethWrapCallInitOnlyIfDictWithSingleEltInInput(cls,args,"DataArrayDouble"); } PyObject *__getnewargs__() throw(INTERP_KERNEL::Exception) @@ -2323,7 +2485,7 @@ namespace MEDCoupling PyObject *___iadd___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception) { - MEDCouplingAutoRefCountObjectPtr ret=self->buildDADouble(1,self->getNumberOfCompo()); + MCAuto ret=self->buildDADouble(1,self->getNumberOfCompo()); MEDCoupling_DataArrayDouble____iadd___(ret,0,obj); Py_XINCREF(trueSelf); return trueSelf; @@ -2331,7 +2493,7 @@ namespace MEDCoupling PyObject *___isub___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception) { - MEDCouplingAutoRefCountObjectPtr ret=self->buildDADouble(1,self->getNumberOfCompo()); + MCAuto ret=self->buildDADouble(1,self->getNumberOfCompo()); MEDCoupling_DataArrayDouble____isub___(ret,0,obj); Py_XINCREF(trueSelf); return trueSelf; @@ -2339,7 +2501,7 @@ namespace MEDCoupling PyObject *___imul___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception) { - MEDCouplingAutoRefCountObjectPtr ret=self->buildDADouble(1,self->getNumberOfCompo()); + MCAuto ret=self->buildDADouble(1,self->getNumberOfCompo()); MEDCoupling_DataArrayDouble____imul___(ret,0,obj); Py_XINCREF(trueSelf); return trueSelf; @@ -2347,7 +2509,7 @@ namespace MEDCoupling PyObject *___idiv___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception) { - MEDCouplingAutoRefCountObjectPtr ret=self->buildDADouble(1,self->getNumberOfCompo()); + MCAuto ret=self->buildDADouble(1,self->getNumberOfCompo()); MEDCoupling_DataArrayDouble____idiv___(ret,0,obj); Py_XINCREF(trueSelf); return trueSelf; @@ -2587,8 +2749,9 @@ namespace MEDCoupling int intValue() const throw(INTERP_KERNEL::Exception); int getHashCode() const throw(INTERP_KERNEL::Exception); bool empty() const throw(INTERP_KERNEL::Exception); - DataArrayInt *performCpy(bool deepCpy) const throw(INTERP_KERNEL::Exception); - void cpyFrom(const DataArrayInt& other) throw(INTERP_KERNEL::Exception); + void aggregate(const DataArrayInt *other) throw(INTERP_KERNEL::Exception); + DataArrayInt *performCopyOrIncrRef(bool deepCopy) const throw(INTERP_KERNEL::Exception); + void deepCopyFrom(const DataArrayInt& other) throw(INTERP_KERNEL::Exception); void reserve(std::size_t nbOfElems) throw(INTERP_KERNEL::Exception); void pushBackSilent(int val) throw(INTERP_KERNEL::Exception); int popBackSilent() throw(INTERP_KERNEL::Exception); @@ -2615,14 +2778,16 @@ namespace MEDCoupling DataArrayInt *invertArrayN2O2O2N(int oldNbOfElem) const throw(INTERP_KERNEL::Exception); DataArrayInt *invertArrayO2N2N2OBis(int newNbOfElem) const throw(INTERP_KERNEL::Exception); DataArrayDouble *convertToDblArr() const throw(INTERP_KERNEL::Exception); + DataArrayInt *indicesOfSubPart(const DataArrayInt& partOfThis) const throw(INTERP_KERNEL::Exception); DataArrayInt *fromNoInterlace() const throw(INTERP_KERNEL::Exception); DataArrayInt *toNoInterlace() const throw(INTERP_KERNEL::Exception); - DataArrayInt *selectByTupleId2(int bg, int end, int step) const throw(INTERP_KERNEL::Exception); + DataArrayInt *selectByTupleIdSafeSlice(int bg, int end, int step) const throw(INTERP_KERNEL::Exception); DataArrayInt *checkAndPreparePermutation() const throw(INTERP_KERNEL::Exception); DataArrayInt *buildPermArrPerLevel() const throw(INTERP_KERNEL::Exception); - bool isIdentity2(int sizeExpected) const throw(INTERP_KERNEL::Exception); + bool isIota(int sizeExpected) const throw(INTERP_KERNEL::Exception); bool isUniform(int val) const throw(INTERP_KERNEL::Exception); - DataArrayInt *substr(int tupleIdBg, int tupleIdEnd=-1) const throw(INTERP_KERNEL::Exception); + bool hasUniqueValues() const throw(INTERP_KERNEL::Exception); + DataArrayInt *subArray(int tupleIdBg, int tupleIdEnd=-1) const throw(INTERP_KERNEL::Exception); void transpose() throw(INTERP_KERNEL::Exception); DataArrayInt *changeNbOfComponents(int newNbOfComp, int dftValue) const throw(INTERP_KERNEL::Exception); void meldWith(const DataArrayInt *other) throw(INTERP_KERNEL::Exception); @@ -2641,13 +2806,13 @@ namespace MEDCoupling DataArrayIntIterator *iterator() throw(INTERP_KERNEL::Exception); const int *begin() const throw(INTERP_KERNEL::Exception); const int *end() const throw(INTERP_KERNEL::Exception); - DataArrayInt *getIdsEqual(int val) const throw(INTERP_KERNEL::Exception); - DataArrayInt *getIdsNotEqual(int val) const throw(INTERP_KERNEL::Exception); + DataArrayInt *findIdsEqual(int val) const throw(INTERP_KERNEL::Exception); + DataArrayInt *findIdsNotEqual(int val) const throw(INTERP_KERNEL::Exception); int changeValue(int oldValue, int newValue) throw(INTERP_KERNEL::Exception); - int locateTuple(const std::vector& tupl) const throw(INTERP_KERNEL::Exception); - int locateValue(int value) const throw(INTERP_KERNEL::Exception); - int locateValue(const std::vector& vals) const throw(INTERP_KERNEL::Exception); - int search(const std::vector& vals) const throw(INTERP_KERNEL::Exception); + int findIdFirstEqualTuple(const std::vector& tupl) const throw(INTERP_KERNEL::Exception); + int findIdFirstEqual(int value) const throw(INTERP_KERNEL::Exception); + int findIdFirstEqual(const std::vector& vals) const throw(INTERP_KERNEL::Exception); + int findIdSequence(const std::vector& vals) const throw(INTERP_KERNEL::Exception); bool presenceOfTuple(const std::vector& tupl) const throw(INTERP_KERNEL::Exception); bool presenceOfValue(int value) const throw(INTERP_KERNEL::Exception); bool presenceOfValue(const std::vector& vals) const throw(INTERP_KERNEL::Exception); @@ -2668,9 +2833,9 @@ namespace MEDCoupling void applyRModulus(int val) throw(INTERP_KERNEL::Exception); void applyPow(int val) throw(INTERP_KERNEL::Exception); void applyRPow(int val) throw(INTERP_KERNEL::Exception); - DataArrayInt *getIdsInRange(int vmin, int vmax) const throw(INTERP_KERNEL::Exception); - DataArrayInt *getIdsNotInRange(int vmin, int vmax) const throw(INTERP_KERNEL::Exception); - DataArrayInt *getIdsStrictlyNegative() const throw(INTERP_KERNEL::Exception); + DataArrayInt *findIdsInRange(int vmin, int vmax) const throw(INTERP_KERNEL::Exception); + DataArrayInt *findIdsNotInRange(int vmin, int vmax) const throw(INTERP_KERNEL::Exception); + DataArrayInt *findIdsStricltyNegative() const throw(INTERP_KERNEL::Exception); bool checkAllIdsInRange(int vmin, int vmax) const throw(INTERP_KERNEL::Exception); static DataArrayInt *Aggregate(const DataArrayInt *a1, const DataArrayInt *a2, int offsetA2) throw(INTERP_KERNEL::Exception); static DataArrayInt *Meld(const DataArrayInt *a1, const DataArrayInt *a2) throw(INTERP_KERNEL::Exception); @@ -2687,7 +2852,7 @@ namespace MEDCoupling DataArrayInt *buildUniqueNotSorted() const throw(INTERP_KERNEL::Exception); DataArrayInt *deltaShiftIndex() const throw(INTERP_KERNEL::Exception); void computeOffsets() throw(INTERP_KERNEL::Exception); - void computeOffsets2() throw(INTERP_KERNEL::Exception); + void computeOffsetsFull() throw(INTERP_KERNEL::Exception); DataArrayInt *buildExplicitArrByRanges(const DataArrayInt *offsets) const throw(INTERP_KERNEL::Exception); DataArrayInt *findRangeIdForEachTuple(const DataArrayInt *ranges) const throw(INTERP_KERNEL::Exception); DataArrayInt *findIdInRangeForEachTuple(const DataArrayInt *ranges) const throw(INTERP_KERNEL::Exception); @@ -2739,7 +2904,7 @@ namespace MEDCoupling int nbOfCompo=PyInt_AS_LONG(nbOfComp); if(nbOfCompo<0) throw INTERP_KERNEL::Exception("DataArrayInt::New : should be a positive number of components !"); - MEDCouplingAutoRefCountObjectPtr ret=DataArrayInt::New(); + MCAuto ret=DataArrayInt::New(); std::vector tmp=fillArrayWithPyListInt2(elt0,nbOfTuples1,nbOfCompo); ret->alloc(nbOfTuples1,nbOfCompo); std::copy(tmp.begin(),tmp.end(),ret->getPointer()); return ret.retn(); @@ -2749,7 +2914,7 @@ namespace MEDCoupling } else {//DataArrayInt.New([1,3,4],3) - MEDCouplingAutoRefCountObjectPtr ret=DataArrayInt::New(); + MCAuto ret=DataArrayInt::New(); int tmpp1=-1; std::vector tmp=fillArrayWithPyListInt2(elt0,nbOfTuples1,tmpp1); ret->alloc(nbOfTuples1,tmpp1); std::copy(tmp.begin(),tmp.end(),ret->getPointer()); @@ -2761,7 +2926,7 @@ namespace MEDCoupling } else {// DataArrayInt.New([1,3,4]) - MEDCouplingAutoRefCountObjectPtr ret=DataArrayInt::New(); + MCAuto ret=DataArrayInt::New(); int tmpp1=-1,tmpp2=-1; std::vector tmp=fillArrayWithPyListInt2(elt0,tmpp1,tmpp2); ret->alloc(tmpp1,tmpp2); std::copy(tmp.begin(),tmp.end(),ret->getPointer()); @@ -2782,7 +2947,7 @@ namespace MEDCoupling int nbOfCompo=PyInt_AS_LONG(nbOfTuples); if(nbOfCompo<0) throw INTERP_KERNEL::Exception("DataArrayInt::New : should be a positive number of components !"); - MEDCouplingAutoRefCountObjectPtr ret=DataArrayInt::New(); + MCAuto ret=DataArrayInt::New(); ret->alloc(nbOfTuples1,nbOfCompo); return ret.retn(); } @@ -2794,7 +2959,7 @@ namespace MEDCoupling } else {//DataArrayInt.New(5) - MEDCouplingAutoRefCountObjectPtr ret=DataArrayInt::New(); + MCAuto ret=DataArrayInt::New(); ret->alloc(nbOfTuples1,1); return ret.retn(); } @@ -2841,6 +3006,12 @@ namespace MEDCoupling { return self->iterator(); } + + DataArrayInt *selectPartDef(const PartDefinition* pd) const throw(INTERP_KERNEL::Exception) + { + MCAuto ret(self->selectPartDef(pd)); + return ret.retn(); + } PyObject *accumulate() const throw(INTERP_KERNEL::Exception) { @@ -2858,12 +3029,12 @@ namespace MEDCoupling return self->accumulatePerChunck(bg,bg+sz); } - DataArrayInt *getIdsEqualTuple(PyObject *inputTuple) const throw(INTERP_KERNEL::Exception) + DataArrayInt *findIdsEqualTuple(PyObject *inputTuple) const throw(INTERP_KERNEL::Exception) { int sw,sz,val; std::vector val2; const int *bg(convertObjToPossibleCpp1_Safe(inputTuple,sw,sz,val,val2)); - return self->getIdsEqualTuple(bg,bg+sz); + return self->findIdsEqualTuple(bg,bg+sz); } PyObject *splitInBalancedSlices(int nbOfSlices) const throw(INTERP_KERNEL::Exception) @@ -2897,14 +3068,14 @@ namespace MEDCoupling return ret; } - static PyObject *BuildOld2NewArrayFromSurjectiveFormat2(int nbOfOldTuples, PyObject *arr, PyObject *arrI) throw(INTERP_KERNEL::Exception) + static PyObject *ConvertIndexArrayToO2N(int nbOfOldTuples, PyObject *arr, PyObject *arrI) throw(INTERP_KERNEL::Exception) { int newNbOfTuples=-1; int szArr,szArrI,sw,iTypppArr,iTypppArrI; std::vector stdvecTyyppArr,stdvecTyyppArrI; const int *arrPtr=convertObjToPossibleCpp1_Safe(arr,sw,szArr,iTypppArr,stdvecTyyppArr); const int *arrIPtr=convertObjToPossibleCpp1_Safe(arrI,sw,szArrI,iTypppArrI,stdvecTyyppArrI); - DataArrayInt *ret0=MEDCoupling::DataArrayInt::BuildOld2NewArrayFromSurjectiveFormat2(nbOfOldTuples,arrPtr,arrIPtr,arrIPtr+szArrI,newNbOfTuples); + DataArrayInt *ret0=MEDCoupling::DataArrayInt::ConvertIndexArrayToO2N(nbOfOldTuples,arrPtr,arrIPtr,arrIPtr+szArrI,newNbOfTuples); PyObject *ret=PyTuple_New(2); PyTuple_SetItem(ret,0,SWIG_NewPointerObj((void*)ret0,SWIGTYPE_p_MEDCoupling__DataArrayInt,SWIG_POINTER_OWN | 0)); PyTuple_SetItem(ret,1,PyInt_FromLong(newNbOfTuples)); @@ -2913,7 +3084,7 @@ namespace MEDCoupling static DataArrayInt *CheckAndPreparePermutation(PyObject *arr) throw(INTERP_KERNEL::Exception) { - MEDCouplingAutoRefCountObjectPtr ret(DataArrayInt::New()); + MCAuto ret(DataArrayInt::New()); int szArr,sw,iTypppArr; std::vector stdvecTyyppArr; const int *arrPtr(convertObjToPossibleCpp1_Safe(arr,sw,szArr,iTypppArr,stdvecTyyppArr)); @@ -2927,14 +3098,14 @@ namespace MEDCoupling const char *msg="MEDCoupling::DataArrayInt::setValues : Available API are : \n-DataArrayInt.setValues([1,3,4])\n-DataArrayInt.setValues([1,3,4],3)\n-DataArrayInt.setValues([1,3,4,5],2,2)\n-DataArrayInt.New(5)\n !"; if(PyList_Check(li) || PyTuple_Check(li)) { - if(nbOfTuples) + if(nbOfTuples && nbOfTuples != Py_None) { if(PyInt_Check(nbOfTuples)) { int nbOfTuples1=PyInt_AS_LONG(nbOfTuples); if(nbOfTuples<0) throw INTERP_KERNEL::Exception("DataArrayInt::setValue : should be a positive set of allocated memory !"); - if(nbOfComp) + if(nbOfComp && nbOfComp != Py_None) { if(PyInt_Check(nbOfComp)) {//DataArrayInt.setValues([1,3,4,5],2,2) @@ -3034,7 +3205,7 @@ namespace MEDCoupling } } - DataArrayInt *getIdsEqualList(PyObject *obj) throw(INTERP_KERNEL::Exception) + DataArrayInt *findIdsEqualList(PyObject *obj) throw(INTERP_KERNEL::Exception) { int sw; int singleVal; @@ -3045,17 +3216,17 @@ namespace MEDCoupling switch(sw) { case 1: - return self->getIdsEqualList(&singleVal,&singleVal+1); + return self->findIdsEqualList(&singleVal,&singleVal+1); case 2: - return self->getIdsEqualList(&multiVal[0],&multiVal[0]+multiVal.size()); + return self->findIdsEqualList(&multiVal[0],&multiVal[0]+multiVal.size()); case 4: - return self->getIdsEqualList(daIntTyypp->begin(),daIntTyypp->end()); + return self->findIdsEqualList(daIntTyypp->begin(),daIntTyypp->end()); default: - throw INTERP_KERNEL::Exception("DataArrayInt::getIdsEqualList : unrecognized type entered, expected list of int, tuple of int or DataArrayInt !"); + throw INTERP_KERNEL::Exception("DataArrayInt::findIdsEqualList : unrecognized type entered, expected list of int, tuple of int or DataArrayInt !"); } } - DataArrayInt *getIdsNotEqualList(PyObject *obj) throw(INTERP_KERNEL::Exception) + DataArrayInt *findIdsNotEqualList(PyObject *obj) throw(INTERP_KERNEL::Exception) { int sw; int singleVal; @@ -3066,13 +3237,13 @@ namespace MEDCoupling switch(sw) { case 1: - return self->getIdsNotEqualList(&singleVal,&singleVal+1); + return self->findIdsNotEqualList(&singleVal,&singleVal+1); case 2: - return self->getIdsNotEqualList(&multiVal[0],&multiVal[0]+multiVal.size()); + return self->findIdsNotEqualList(&multiVal[0],&multiVal[0]+multiVal.size()); case 4: - return self->getIdsNotEqualList(daIntTyypp->begin(),daIntTyypp->end()); + return self->findIdsNotEqualList(daIntTyypp->begin(),daIntTyypp->end()); default: - throw INTERP_KERNEL::Exception("DataArrayInt::getIdsNotEqualList : unrecognized type entered, expected list of int, tuple of int or DataArrayInt !"); + throw INTERP_KERNEL::Exception("DataArrayInt::findIdsNotEqualList : unrecognized type entered, expected list of int, tuple of int or DataArrayInt !"); } } @@ -3093,8 +3264,7 @@ namespace MEDCoupling if(!da2) throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !"); da2->checkAllocated(); - int size=self->getNumberOfTuples(); - self->splitByValueRange(da2->getConstPointer(),da2->getConstPointer()+size,ret0,ret1,ret2); + self->splitByValueRange(da2->begin(),da2->end(),ret0,ret1,ret2); } PyObject *ret = PyList_New(3); PyList_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(ret0),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); @@ -3214,6 +3384,16 @@ namespace MEDCoupling self->setSelectedComponents(a,tmp); } + PyObject *explodeComponents() const throw(INTERP_KERNEL::Exception) + { + std::vector< MCAuto > retCpp(self->explodeComponents()); + std::size_t sz(retCpp.size()); + PyObject *res(PyList_New(sz)); + for(std::size_t i=0;igetNumberOfComponents(); @@ -3298,7 +3478,7 @@ namespace MEDCoupling if(PyInt_Check(obj)) { int val=(int)PyInt_AS_LONG(obj); - return self->locateValue(val); + return self->findIdFirstEqual(val); } else throw INTERP_KERNEL::Exception("DataArrayInt::index : 'this' contains one component and trying to find an element which is not an integer !"); @@ -3307,7 +3487,7 @@ namespace MEDCoupling { std::vector arr; convertPyToNewIntArr3(obj,arr); - return self->locateTuple(arr); + return self->findIdFirstEqualTuple(arr); } } } @@ -3351,7 +3531,7 @@ namespace MEDCoupling DataArrayInt *dt1=0,*dc1=0; int sw; convertObjToPossibleCpp3(obj,nbOfTuples,nbOfComponents,sw,it1,ic1,vt1,vc1,pt1,pc1,dt1,dc1); - MEDCouplingAutoRefCountObjectPtr ret; + MCAuto ret; switch(sw) { case 1: @@ -3363,7 +3543,7 @@ namespace MEDCoupling case 2: return SWIG_NewPointerObj(SWIG_as_voidptr(self->selectByTupleIdSafe(&vt1[0],&vt1[0]+vt1.size())),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 ); case 3: - return SWIG_NewPointerObj(SWIG_as_voidptr(self->selectByTupleId2(pt1.first,pt1.second.first,pt1.second.second)),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 ); + return SWIG_NewPointerObj(SWIG_as_voidptr(self->selectByTupleIdSafeSlice(pt1.first,pt1.second.first,pt1.second.second)),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 ); case 4: return SWIG_NewPointerObj(SWIG_as_voidptr(self->selectByTupleIdSafe(dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems())),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 ); case 5: @@ -3376,7 +3556,7 @@ namespace MEDCoupling } case 7: { - ret=self->selectByTupleId2(pt1.first,pt1.second.first,pt1.second.second); + 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)),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 ); } @@ -3398,7 +3578,7 @@ namespace MEDCoupling } case 11: { - ret=self->selectByTupleId2(pt1.first,pt1.second.first,pt1.second.second); + ret=self->selectByTupleIdSafeSlice(pt1.first,pt1.second.first,pt1.second.second); return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(vc1)),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 ); } case 12: @@ -3426,7 +3606,7 @@ namespace MEDCoupling } case 15: { - ret=self->selectByTupleId2(pt1.first,pt1.second.first,pt1.second.second); + ret=self->selectByTupleIdSafeSlice(pt1.first,pt1.second.first,pt1.second.second); int nbOfComp=DataArray::GetNumberOfItemGivenBESRelative(pc1.first,pc1.second.first,pc1.second.second,msg2); std::vector v2(nbOfComp); for(int i=0;i > pt1,pc1; DataArrayInt *dt1=0,*dc1=0; convertObjToPossibleCpp3(obj,nbOfTuples,nbOfComponents,sw2,it1,ic1,vt1,vc1,pt1,pc1,dt1,dc1); - MEDCouplingAutoRefCountObjectPtr tmp; + MCAuto tmp; switch(sw2) { case 1: @@ -3875,13 +4055,13 @@ namespace MEDCoupling { case 1: { - MEDCouplingAutoRefCountObjectPtr ret=self->deepCpy(); + MCAuto ret=self->deepCopy(); ret->applyLin(1,val); return ret.retn(); } case 2: { - MEDCouplingAutoRefCountObjectPtr aaaa=DataArrayInt::New(); aaaa->useArray(&aa[0],false,CPP_DEALLOC,1,(int)aa.size()); + MCAuto aaaa=DataArrayInt::New(); aaaa->useArray(&aa[0],false,CPP_DEALLOC,1,(int)aa.size()); return DataArrayInt::Add(self,aaaa); } case 3: @@ -3890,7 +4070,7 @@ namespace MEDCoupling } case 4: { - MEDCouplingAutoRefCountObjectPtr aaaa=aaa->buildDAInt(1,self->getNumberOfComponents()); + MCAuto aaaa=aaa->buildDAInt(1,self->getNumberOfComponents()); return DataArrayInt::Add(self,aaaa); } default: @@ -3911,18 +4091,18 @@ namespace MEDCoupling { case 1: { - MEDCouplingAutoRefCountObjectPtr ret=self->deepCpy(); + MCAuto ret=self->deepCopy(); ret->applyLin(1,val); return ret.retn(); } case 2: { - MEDCouplingAutoRefCountObjectPtr aaaa=DataArrayInt::New(); aaaa->useArray(&aa[0],false,CPP_DEALLOC,1,(int)aa.size()); + MCAuto aaaa=DataArrayInt::New(); aaaa->useArray(&aa[0],false,CPP_DEALLOC,1,(int)aa.size()); return DataArrayInt::Add(self,aaaa); } case 4: { - MEDCouplingAutoRefCountObjectPtr aaaa=aaa->buildDAInt(1,self->getNumberOfComponents()); + MCAuto aaaa=aaa->buildDAInt(1,self->getNumberOfComponents()); return DataArrayInt::Add(self,aaaa); } default: @@ -3949,7 +4129,7 @@ namespace MEDCoupling } case 2: { - MEDCouplingAutoRefCountObjectPtr bb=DataArrayInt::New(); bb->useArray(&aa[0],false,CPP_DEALLOC,1,(int)aa.size()); + MCAuto bb=DataArrayInt::New(); bb->useArray(&aa[0],false,CPP_DEALLOC,1,(int)aa.size()); self->addEqual(bb); Py_XINCREF(trueSelf); return trueSelf; @@ -3962,7 +4142,7 @@ namespace MEDCoupling } case 4: { - MEDCouplingAutoRefCountObjectPtr aaaa=aaa->buildDAInt(1,self->getNumberOfComponents()); + MCAuto aaaa=aaa->buildDAInt(1,self->getNumberOfComponents()); self->addEqual(aaaa); Py_XINCREF(trueSelf); return trueSelf; @@ -3985,13 +4165,13 @@ namespace MEDCoupling { case 1: { - MEDCouplingAutoRefCountObjectPtr ret=self->deepCpy(); + MCAuto ret=self->deepCopy(); ret->applyLin(1,-val); return ret.retn(); } case 2: { - MEDCouplingAutoRefCountObjectPtr aaaa=DataArrayInt::New(); aaaa->useArray(&aa[0],false,CPP_DEALLOC,1,(int)aa.size()); + MCAuto aaaa=DataArrayInt::New(); aaaa->useArray(&aa[0],false,CPP_DEALLOC,1,(int)aa.size()); return DataArrayInt::Substract(self,aaaa); } case 3: @@ -4000,7 +4180,7 @@ namespace MEDCoupling } case 4: { - MEDCouplingAutoRefCountObjectPtr aaaa=aaa->buildDAInt(1,self->getNumberOfComponents()); + MCAuto aaaa=aaa->buildDAInt(1,self->getNumberOfComponents()); return DataArrayInt::Substract(self,aaaa); } default: @@ -4021,18 +4201,18 @@ namespace MEDCoupling { case 1: { - MEDCouplingAutoRefCountObjectPtr ret=self->deepCpy(); + MCAuto ret=self->deepCopy(); ret->applyLin(-1,val); return ret.retn(); } case 2: { - MEDCouplingAutoRefCountObjectPtr aaaa=DataArrayInt::New(); aaaa->useArray(&aa[0],false,CPP_DEALLOC,1,(int)aa.size()); + MCAuto aaaa=DataArrayInt::New(); aaaa->useArray(&aa[0],false,CPP_DEALLOC,1,(int)aa.size()); return DataArrayInt::Substract(aaaa,self); } case 4: { - MEDCouplingAutoRefCountObjectPtr aaaa=aaa->buildDAInt(1,self->getNumberOfComponents()); + MCAuto aaaa=aaa->buildDAInt(1,self->getNumberOfComponents()); return DataArrayInt::Substract(aaaa,self); } default: @@ -4059,7 +4239,7 @@ namespace MEDCoupling } case 2: { - MEDCouplingAutoRefCountObjectPtr bb=DataArrayInt::New(); bb->useArray(&aa[0],false,CPP_DEALLOC,1,(int)aa.size()); + MCAuto bb=DataArrayInt::New(); bb->useArray(&aa[0],false,CPP_DEALLOC,1,(int)aa.size()); self->substractEqual(bb); Py_XINCREF(trueSelf); return trueSelf; @@ -4072,7 +4252,7 @@ namespace MEDCoupling } case 4: { - MEDCouplingAutoRefCountObjectPtr aaaa=aaa->buildDAInt(1,self->getNumberOfComponents()); + MCAuto aaaa=aaa->buildDAInt(1,self->getNumberOfComponents()); self->substractEqual(aaaa); Py_XINCREF(trueSelf); return trueSelf; @@ -4095,13 +4275,13 @@ namespace MEDCoupling { case 1: { - MEDCouplingAutoRefCountObjectPtr ret=self->deepCpy(); + MCAuto ret=self->deepCopy(); ret->applyLin(val,0); return ret.retn(); } case 2: { - MEDCouplingAutoRefCountObjectPtr aaaa=DataArrayInt::New(); aaaa->useArray(&aa[0],false,CPP_DEALLOC,1,(int)aa.size()); + MCAuto aaaa=DataArrayInt::New(); aaaa->useArray(&aa[0],false,CPP_DEALLOC,1,(int)aa.size()); return DataArrayInt::Multiply(self,aaaa); } case 3: @@ -4110,7 +4290,7 @@ namespace MEDCoupling } case 4: { - MEDCouplingAutoRefCountObjectPtr aaaa=aaa->buildDAInt(1,self->getNumberOfComponents()); + MCAuto aaaa=aaa->buildDAInt(1,self->getNumberOfComponents()); return DataArrayInt::Multiply(self,aaaa); } default: @@ -4131,18 +4311,18 @@ namespace MEDCoupling { case 1: { - MEDCouplingAutoRefCountObjectPtr ret=self->deepCpy(); + MCAuto ret=self->deepCopy(); ret->applyLin(val,0); return ret.retn(); } case 2: { - MEDCouplingAutoRefCountObjectPtr aaaa=DataArrayInt::New(); aaaa->useArray(&aa[0],false,CPP_DEALLOC,1,(int)aa.size()); + MCAuto aaaa=DataArrayInt::New(); aaaa->useArray(&aa[0],false,CPP_DEALLOC,1,(int)aa.size()); return DataArrayInt::Multiply(self,aaaa); } case 4: { - MEDCouplingAutoRefCountObjectPtr aaaa=aaa->buildDAInt(1,self->getNumberOfComponents()); + MCAuto aaaa=aaa->buildDAInt(1,self->getNumberOfComponents()); return DataArrayInt::Multiply(self,aaaa); } default: @@ -4169,7 +4349,7 @@ namespace MEDCoupling } case 2: { - MEDCouplingAutoRefCountObjectPtr bb=DataArrayInt::New(); bb->useArray(&aa[0],false,CPP_DEALLOC,1,(int)aa.size()); + MCAuto bb=DataArrayInt::New(); bb->useArray(&aa[0],false,CPP_DEALLOC,1,(int)aa.size()); self->multiplyEqual(bb); Py_XINCREF(trueSelf); return trueSelf; @@ -4182,7 +4362,7 @@ namespace MEDCoupling } case 4: { - MEDCouplingAutoRefCountObjectPtr aaaa=aaa->buildDAInt(1,self->getNumberOfComponents()); + MCAuto aaaa=aaa->buildDAInt(1,self->getNumberOfComponents()); self->multiplyEqual(aaaa); Py_XINCREF(trueSelf); return trueSelf; @@ -4205,13 +4385,13 @@ namespace MEDCoupling { case 1: { - MEDCouplingAutoRefCountObjectPtr ret=self->deepCpy(); + MCAuto ret=self->deepCopy(); ret->applyDivideBy(val); return ret.retn(); } case 2: { - MEDCouplingAutoRefCountObjectPtr aaaa=DataArrayInt::New(); aaaa->useArray(&aa[0],false,CPP_DEALLOC,1,(int)aa.size()); + MCAuto aaaa=DataArrayInt::New(); aaaa->useArray(&aa[0],false,CPP_DEALLOC,1,(int)aa.size()); return DataArrayInt::Divide(self,aaaa); } case 3: @@ -4220,7 +4400,7 @@ namespace MEDCoupling } case 4: { - MEDCouplingAutoRefCountObjectPtr aaaa=aaa->buildDAInt(1,self->getNumberOfComponents()); + MCAuto aaaa=aaa->buildDAInt(1,self->getNumberOfComponents()); return DataArrayInt::Divide(self,aaaa); } default: @@ -4241,18 +4421,18 @@ namespace MEDCoupling { case 1: { - MEDCouplingAutoRefCountObjectPtr ret=self->deepCpy(); + MCAuto ret=self->deepCopy(); ret->applyInv(val); return ret.retn(); } case 2: { - MEDCouplingAutoRefCountObjectPtr aaaa=DataArrayInt::New(); aaaa->useArray(&aa[0],false,CPP_DEALLOC,1,(int)aa.size()); + MCAuto aaaa=DataArrayInt::New(); aaaa->useArray(&aa[0],false,CPP_DEALLOC,1,(int)aa.size()); return DataArrayInt::Divide(aaaa,self); } case 4: { - MEDCouplingAutoRefCountObjectPtr aaaa=aaa->buildDAInt(1,self->getNumberOfComponents()); + MCAuto aaaa=aaa->buildDAInt(1,self->getNumberOfComponents()); return DataArrayInt::Divide(aaaa,self); } default: @@ -4279,7 +4459,7 @@ namespace MEDCoupling } case 2: { - MEDCouplingAutoRefCountObjectPtr bb=DataArrayInt::New(); bb->useArray(&aa[0],false,CPP_DEALLOC,1,(int)aa.size()); + MCAuto bb=DataArrayInt::New(); bb->useArray(&aa[0],false,CPP_DEALLOC,1,(int)aa.size()); self->divideEqual(bb); Py_XINCREF(trueSelf); return trueSelf; @@ -4292,7 +4472,7 @@ namespace MEDCoupling } case 4: { - MEDCouplingAutoRefCountObjectPtr aaaa=aaa->buildDAInt(1,self->getNumberOfComponents()); + MCAuto aaaa=aaa->buildDAInt(1,self->getNumberOfComponents()); self->divideEqual(aaaa); Py_XINCREF(trueSelf); return trueSelf; @@ -4315,13 +4495,13 @@ namespace MEDCoupling { case 1: { - MEDCouplingAutoRefCountObjectPtr ret=self->deepCpy(); + MCAuto ret=self->deepCopy(); ret->applyModulus(val); return ret.retn(); } case 2: { - MEDCouplingAutoRefCountObjectPtr aaaa=DataArrayInt::New(); aaaa->useArray(&aa[0],false,CPP_DEALLOC,1,(int)aa.size()); + MCAuto aaaa=DataArrayInt::New(); aaaa->useArray(&aa[0],false,CPP_DEALLOC,1,(int)aa.size()); return DataArrayInt::Modulus(self,aaaa); } case 3: @@ -4330,7 +4510,7 @@ namespace MEDCoupling } case 4: { - MEDCouplingAutoRefCountObjectPtr aaaa=aaa->buildDAInt(1,self->getNumberOfComponents()); + MCAuto aaaa=aaa->buildDAInt(1,self->getNumberOfComponents()); return DataArrayInt::Modulus(self,aaaa); } default: @@ -4351,13 +4531,13 @@ namespace MEDCoupling { case 1: { - MEDCouplingAutoRefCountObjectPtr ret=self->deepCpy(); + MCAuto ret=self->deepCopy(); ret->applyRModulus(val); return ret.retn(); } case 2: { - MEDCouplingAutoRefCountObjectPtr aaaa=DataArrayInt::New(); aaaa->useArray(&aa[0],false,CPP_DEALLOC,1,(int)aa.size()); + MCAuto aaaa=DataArrayInt::New(); aaaa->useArray(&aa[0],false,CPP_DEALLOC,1,(int)aa.size()); return DataArrayInt::Modulus(aaaa,self); } case 3: @@ -4366,7 +4546,7 @@ namespace MEDCoupling } case 4: { - MEDCouplingAutoRefCountObjectPtr aaaa=aaa->buildDAInt(1,self->getNumberOfComponents()); + MCAuto aaaa=aaa->buildDAInt(1,self->getNumberOfComponents()); return DataArrayInt::Modulus(aaaa,self); } default: @@ -4399,7 +4579,7 @@ namespace MEDCoupling } case 4: { - MEDCouplingAutoRefCountObjectPtr aaaa=aaa->buildDAInt(1,self->getNumberOfComponents()); + MCAuto aaaa=aaa->buildDAInt(1,self->getNumberOfComponents()); self->modulusEqual(aaaa); Py_XINCREF(trueSelf); return trueSelf; @@ -4422,13 +4602,13 @@ namespace MEDCoupling { case 1: { - MEDCouplingAutoRefCountObjectPtr ret=self->deepCpy(); + MCAuto ret=self->deepCopy(); ret->applyPow(val); return ret.retn(); } case 2: { - MEDCouplingAutoRefCountObjectPtr aaaa=DataArrayInt::New(); aaaa->useArray(&aa[0],false,CPP_DEALLOC,1,(int)aa.size()); + MCAuto aaaa=DataArrayInt::New(); aaaa->useArray(&aa[0],false,CPP_DEALLOC,1,(int)aa.size()); return DataArrayInt::Pow(self,aaaa); } case 3: @@ -4437,7 +4617,7 @@ namespace MEDCoupling } case 4: { - MEDCouplingAutoRefCountObjectPtr aaaa=aaa->buildDAInt(1,self->getNumberOfComponents()); + MCAuto aaaa=aaa->buildDAInt(1,self->getNumberOfComponents()); return DataArrayInt::Pow(self,aaaa); } default: @@ -4458,13 +4638,13 @@ namespace MEDCoupling { case 1: { - MEDCouplingAutoRefCountObjectPtr ret=self->deepCpy(); + MCAuto ret=self->deepCopy(); ret->applyRPow(val); return ret.retn(); } case 2: { - MEDCouplingAutoRefCountObjectPtr aaaa=DataArrayInt::New(); aaaa->useArray(&aa[0],false,CPP_DEALLOC,1,(int)aa.size()); + MCAuto aaaa=DataArrayInt::New(); aaaa->useArray(&aa[0],false,CPP_DEALLOC,1,(int)aa.size()); return DataArrayInt::Pow(aaaa,self); } case 3: @@ -4473,7 +4653,7 @@ namespace MEDCoupling } case 4: { - MEDCouplingAutoRefCountObjectPtr aaaa=aaa->buildDAInt(1,self->getNumberOfComponents()); + MCAuto aaaa=aaa->buildDAInt(1,self->getNumberOfComponents()); return DataArrayInt::Pow(aaaa,self); } default: @@ -4506,7 +4686,7 @@ namespace MEDCoupling } case 4: { - MEDCouplingAutoRefCountObjectPtr aaaa=aaa->buildDAInt(1,self->getNumberOfComponents()); + MCAuto aaaa=aaa->buildDAInt(1,self->getNumberOfComponents()); self->powEqual(aaaa); Py_XINCREF(trueSelf); return trueSelf; @@ -4549,10 +4729,10 @@ namespace MEDCoupling return pyRet; } - PyObject *searchRangesInListOfIds(const DataArrayInt *listOfIds) const throw(INTERP_KERNEL::Exception) + PyObject *findIdsRangesInListOfIds(const DataArrayInt *listOfIds) const throw(INTERP_KERNEL::Exception) { DataArrayInt *ret0=0,*ret1=0; - self->searchRangesInListOfIds(listOfIds,ret0,ret1); + self->findIdsRangesInListOfIds(listOfIds,ret0,ret1); PyObject *pyRet=PyTuple_New(2); PyTuple_SetItem(pyRet,0,SWIG_NewPointerObj(SWIG_as_voidptr(ret0),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); PyTuple_SetItem(pyRet,1,SWIG_NewPointerObj(SWIG_as_voidptr(ret1),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); @@ -4581,35 +4761,7 @@ namespace MEDCoupling // serialization static PyObject *___new___(PyObject *cls, PyObject *args) throw(INTERP_KERNEL::Exception) { - static const char MSG[]="DataArrayInt.__new__ : the args in input is expected to be a tuple !"; - if(!PyTuple_Check(args)) - throw INTERP_KERNEL::Exception(MSG); - 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); - PyObject *initMeth(PyObject_GetAttrString(instance,"__init__")); - int sz(PyTuple_Size(args)); - - 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 *zeNumpyRepr(0); - PyObject *tmp1(PyInt_FromLong(0)); - zeNumpyRepr=PyDict_GetItem(PyTuple_GetItem(args,1),tmp1);//borrowed - Py_DECREF(tmp1); - PyObject *tmp3(PyTuple_New(1)); - PyTuple_SetItem(tmp3,0,zeNumpyRepr); Py_XINCREF(zeNumpyRepr); - PyObject *tmp2(PyObject_CallObject(initMeth,tmp3)); - Py_XDECREF(tmp2); - Py_DECREF(tmp3); - } - Py_DECREF(initMeth); - return instance; + return NewMethWrapCallInitOnlyIfDictWithSingleEltInInput(cls,args,"DataArrayInt"); } PyObject *__getnewargs__() throw(INTERP_KERNEL::Exception) @@ -4680,7 +4832,7 @@ namespace MEDCoupling PyObject *___iadd___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception) { - MEDCouplingAutoRefCountObjectPtr ret=self->buildDAInt(1,self->getNumberOfCompo()); + MCAuto ret=self->buildDAInt(1,self->getNumberOfCompo()); MEDCoupling_DataArrayInt____iadd___(ret,0,obj); Py_XINCREF(trueSelf); return trueSelf; @@ -4688,7 +4840,7 @@ namespace MEDCoupling PyObject *___isub___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception) { - MEDCouplingAutoRefCountObjectPtr ret=self->buildDAInt(1,self->getNumberOfCompo()); + MCAuto ret=self->buildDAInt(1,self->getNumberOfCompo()); MEDCoupling_DataArrayInt____isub___(ret,0,obj); Py_XINCREF(trueSelf); return trueSelf; @@ -4696,7 +4848,7 @@ namespace MEDCoupling PyObject *___imul___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception) { - MEDCouplingAutoRefCountObjectPtr ret=self->buildDAInt(1,self->getNumberOfCompo()); + MCAuto ret=self->buildDAInt(1,self->getNumberOfCompo()); MEDCoupling_DataArrayInt____imul___(ret,0,obj); Py_XINCREF(trueSelf); return trueSelf; @@ -4704,7 +4856,7 @@ namespace MEDCoupling PyObject *___idiv___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception) { - MEDCouplingAutoRefCountObjectPtr ret=self->buildDAInt(1,self->getNumberOfCompo()); + MCAuto ret=self->buildDAInt(1,self->getNumberOfCompo()); MEDCoupling_DataArrayInt____idiv___(ret,0,obj); Py_XINCREF(trueSelf); return trueSelf; @@ -4712,7 +4864,7 @@ namespace MEDCoupling PyObject *___imod___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception) { - MEDCouplingAutoRefCountObjectPtr ret=self->buildDAInt(1,self->getNumberOfCompo()); + MCAuto ret=self->buildDAInt(1,self->getNumberOfCompo()); MEDCoupling_DataArrayInt____imod___(ret,0,obj); Py_XINCREF(trueSelf); return trueSelf; @@ -4950,7 +5102,7 @@ namespace MEDCoupling virtual DataArrayChar *buildEmptySpecializedDAChar() const throw(INTERP_KERNEL::Exception); int getHashCode() const throw(INTERP_KERNEL::Exception); bool empty() const throw(INTERP_KERNEL::Exception); - void cpyFrom(const DataArrayChar& other) throw(INTERP_KERNEL::Exception); + void deepCopyFrom(const DataArrayChar& other) throw(INTERP_KERNEL::Exception); void reserve(std::size_t nbOfElems) throw(INTERP_KERNEL::Exception); void pushBackSilent(char val) throw(INTERP_KERNEL::Exception); char popBackSilent() throw(INTERP_KERNEL::Exception); @@ -4968,24 +5120,25 @@ namespace MEDCoupling DataArrayChar *renumberR(const int *new2Old) const throw(INTERP_KERNEL::Exception); DataArrayChar *renumberAndReduce(const int *old2NewBg, int newNbOfTuple) const throw(INTERP_KERNEL::Exception); bool isUniform(char val) const throw(INTERP_KERNEL::Exception); - DataArrayChar *substr(int tupleIdBg, int tupleIdEnd=-1) const throw(INTERP_KERNEL::Exception); + void sort(bool asc=true) throw(INTERP_KERNEL::Exception); + DataArrayChar *subArray(int tupleIdBg, int tupleIdEnd=-1) const throw(INTERP_KERNEL::Exception); DataArrayChar *changeNbOfComponents(int newNbOfComp, char dftValue) const throw(INTERP_KERNEL::Exception); void meldWith(const DataArrayChar *other) throw(INTERP_KERNEL::Exception); - void setPartOfValuesAdv(const DataArrayChar *a, const DataArrayChar *tuplesSelec) throw(INTERP_KERNEL::Exception); + void setPartOfValuesAdv(const DataArrayChar *a, const DataArrayInt *tuplesSelec) throw(INTERP_KERNEL::Exception); char front() const throw(INTERP_KERNEL::Exception); char back() const throw(INTERP_KERNEL::Exception); void setIJ(int tupleId, int compoId, char newVal) throw(INTERP_KERNEL::Exception); void setIJSilent(int tupleId, int compoId, char newVal) throw(INTERP_KERNEL::Exception); char *getPointer() throw(INTERP_KERNEL::Exception); - DataArrayInt *getIdsEqual(char val) const throw(INTERP_KERNEL::Exception); - DataArrayInt *getIdsNotEqual(char val) const throw(INTERP_KERNEL::Exception); - int locateTuple(const std::vector& tupl) const throw(INTERP_KERNEL::Exception); + DataArrayInt *findIdsEqual(char val) const throw(INTERP_KERNEL::Exception); + DataArrayInt *findIdsNotEqual(char val) const throw(INTERP_KERNEL::Exception); + int findIdFirstEqualTuple(const std::vector& tupl) const throw(INTERP_KERNEL::Exception); bool presenceOfTuple(const std::vector& tupl) const throw(INTERP_KERNEL::Exception); char getMaxValue(int& tupleId) const throw(INTERP_KERNEL::Exception); char getMaxValueInArray() const throw(INTERP_KERNEL::Exception); char getMinValue(int& tupleId) const throw(INTERP_KERNEL::Exception); char getMinValueInArray() const throw(INTERP_KERNEL::Exception); - DataArrayInt *getIdsInRange(char vmin, char vmax) const throw(INTERP_KERNEL::Exception); + DataArrayInt *findIdsInRange(char vmin, char vmax) const throw(INTERP_KERNEL::Exception); static DataArrayChar *Aggregate(const DataArrayChar *a1, const DataArrayChar *a2) throw(INTERP_KERNEL::Exception); static DataArrayChar *Meld(const DataArrayChar *a1, const DataArrayChar *a2) throw(INTERP_KERNEL::Exception); %extend @@ -5124,7 +5277,7 @@ namespace MEDCoupling public: static DataArrayByte *New(); DataArrayByteIterator *iterator() throw(INTERP_KERNEL::Exception); - DataArrayByte *performCpy(bool deepCpy) const throw(INTERP_KERNEL::Exception); + DataArrayByte *performCopyOrIncrRef(bool deepCopy) const throw(INTERP_KERNEL::Exception); char byteValue() const throw(INTERP_KERNEL::Exception); %extend { @@ -5152,7 +5305,7 @@ namespace MEDCoupling int nbOfCompo=PyInt_AS_LONG(nbOfComp); if(nbOfCompo<0) throw INTERP_KERNEL::Exception("DataArrayByte::New : should be a positive number of components !"); - MEDCouplingAutoRefCountObjectPtr ret=DataArrayByte::New(); + MCAuto ret=DataArrayByte::New(); std::vector tmp=fillArrayWithPyListInt2(elt0,nbOfTuples1,nbOfCompo); ret->alloc(nbOfTuples1,nbOfCompo); std::copy(tmp.begin(),tmp.end(),ret->getPointer()); return ret.retn(); @@ -5162,7 +5315,7 @@ namespace MEDCoupling } else {//DataArrayByte.New([1,3,4],3) - MEDCouplingAutoRefCountObjectPtr ret=DataArrayByte::New(); + MCAuto ret=DataArrayByte::New(); int tmpp1=-1; std::vector tmp=fillArrayWithPyListInt2(elt0,nbOfTuples1,tmpp1); ret->alloc(nbOfTuples1,tmpp1); std::copy(tmp.begin(),tmp.end(),ret->getPointer()); @@ -5174,7 +5327,7 @@ namespace MEDCoupling } else {// DataArrayByte.New([1,3,4]) - MEDCouplingAutoRefCountObjectPtr ret=DataArrayByte::New(); + MCAuto ret=DataArrayByte::New(); int tmpp1=-1,tmpp2=-1; std::vector tmp=fillArrayWithPyListInt2(elt0,tmpp1,tmpp2); ret->alloc(tmpp1,tmpp2); std::copy(tmp.begin(),tmp.end(),ret->getPointer()); @@ -5195,7 +5348,7 @@ namespace MEDCoupling int nbOfCompo=PyInt_AS_LONG(nbOfTuples); if(nbOfCompo<0) throw INTERP_KERNEL::Exception("DataArrayByte::New : should be a positive number of components !"); - MEDCouplingAutoRefCountObjectPtr ret=DataArrayByte::New(); + MCAuto ret=DataArrayByte::New(); ret->alloc(nbOfTuples1,nbOfCompo); return ret.retn(); } @@ -5207,11 +5360,17 @@ namespace MEDCoupling } else {//DataArrayByte.New(5) - MEDCouplingAutoRefCountObjectPtr ret=DataArrayByte::New(); + MCAuto ret=DataArrayByte::New(); ret->alloc(nbOfTuples1,1); return ret.retn(); } } +#ifdef WITH_NUMPY + else if(PyArray_Check(elt0) && nbOfTuples==NULL && nbOfComp==NULL) + {//DataArrayDouble.New(numpyArray) + return BuildNewInstance(elt0,NPY_INT8,&PyCallBackDataArrayChar_RefType,"INT8"); + } +#endif else throw INTERP_KERNEL::Exception(msg); } @@ -5281,34 +5440,34 @@ namespace MEDCoupling return self->presenceOfValue(vals2); } - int locateValue(PyObject *vals) const throw(INTERP_KERNEL::Exception) + int findIdFirstEqual(PyObject *vals) const throw(INTERP_KERNEL::Exception) { int sz=-1,sw=-1; int ival=-1; std::vector ivval; const int *pt=convertObjToPossibleCpp1_Safe(vals,sw,sz,ival,ivval); std::vector vals2(sz); std::copy(pt,pt+sz,vals2.begin()); - return self->locateValue(vals2); + return self->findIdFirstEqual(vals2); } - int locateTuple(PyObject *tupl) const throw(INTERP_KERNEL::Exception) + int findIdFirstEqualTuple(PyObject *tupl) const throw(INTERP_KERNEL::Exception) { int sz=-1,sw=-1; int ival=-1; std::vector ivval; const int *pt=convertObjToPossibleCpp1_Safe(tupl,sw,sz,ival,ivval); std::vector vals(sz); std::copy(pt,pt+sz,vals.begin()); - return self->locateTuple(vals); + return self->findIdFirstEqualTuple(vals); } - int search(PyObject *strOrListOfInt) const throw(INTERP_KERNEL::Exception) + int findIdSequence(PyObject *strOrListOfInt) const throw(INTERP_KERNEL::Exception) { int sz=-1,sw=-1; int ival=-1; std::vector ivval; const int *pt=convertObjToPossibleCpp1_Safe(strOrListOfInt,sw,sz,ival,ivval); std::vector vals(sz); std::copy(pt,pt+sz,vals.begin()); - return self->search(vals); + return self->findIdSequence(vals); } PyObject *getTuple(int tupleId) throw(INTERP_KERNEL::Exception) @@ -5351,13 +5510,13 @@ namespace MEDCoupling if(PyInt_Check(obj)) { int val=(int)PyInt_AS_LONG(obj); - return self->locateValue(val); + return self->findIdFirstEqual(val); } else throw INTERP_KERNEL::Exception("DataArrayByte::index : 'this' contains one component and trying to find an element which is not an integer !"); } default: - return MEDCoupling_DataArrayByte_locateTuple(self,obj); + return MEDCoupling_DataArrayByte_findIdFirstEqualTuple(self,obj); } } @@ -5382,6 +5541,38 @@ namespace MEDCoupling return MEDCoupling_DataArrayByte_presenceOfTuple(self,obj); } } + +#ifdef WITH_NUMPY + PyObject *toNumPyArray() throw(INTERP_KERNEL::Exception) // not const. It is not a bug ! + { + return ToNumPyArray(self,NPY_INT8,"DataArrayByte"); + } +#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) { @@ -5399,7 +5590,7 @@ namespace MEDCoupling std::pair > pt1,pc1; DataArrayInt *dt1=0,*dc1=0; convertObjToPossibleCpp3(obj,nbOfTuples,nbOfComponents,sw2,it1,ic1,vt1,vc1,pt1,pc1,dt1,dc1); - MEDCouplingAutoRefCountObjectPtr tmp; + MCAuto tmp; switch(sw2) { case 1: @@ -5642,7 +5833,7 @@ namespace MEDCoupling public: static DataArrayAsciiChar *New(); DataArrayAsciiCharIterator *iterator() throw(INTERP_KERNEL::Exception); - DataArrayAsciiChar *performCpy(bool deepCpy) const throw(INTERP_KERNEL::Exception); + DataArrayAsciiChar *performCopyOrIncrRef(bool deepCopy) const throw(INTERP_KERNEL::Exception); char asciiCharValue() const throw(INTERP_KERNEL::Exception); %extend { @@ -5670,7 +5861,7 @@ namespace MEDCoupling int nbOfCompo=PyInt_AS_LONG(nbOfComp); if(nbOfCompo<0) throw INTERP_KERNEL::Exception("DataArrayAsciiChar::New : should be a positive number of components !"); - MEDCouplingAutoRefCountObjectPtr ret=DataArrayAsciiChar::New(); + MCAuto ret=DataArrayAsciiChar::New(); std::vector tmp=fillArrayWithPyListInt2(elt0,nbOfTuples1,nbOfCompo); ret->alloc(nbOfTuples1,nbOfCompo); std::copy(tmp.begin(),tmp.end(),ret->getPointer()); return ret.retn(); @@ -5680,7 +5871,7 @@ namespace MEDCoupling } else {//DataArrayAsciiChar.New([1,3,4],3) - MEDCouplingAutoRefCountObjectPtr ret=DataArrayAsciiChar::New(); + MCAuto ret=DataArrayAsciiChar::New(); int tmpp1=-1; std::vector tmp=fillArrayWithPyListInt2(elt0,nbOfTuples1,tmpp1); ret->alloc(nbOfTuples1,tmpp1); std::copy(tmp.begin(),tmp.end(),ret->getPointer()); @@ -5710,7 +5901,7 @@ namespace MEDCoupling else { // DataArrayAsciiChar.New([1,3,4]) - MEDCouplingAutoRefCountObjectPtr ret=DataArrayAsciiChar::New(); + MCAuto ret=DataArrayAsciiChar::New(); int tmpp1=-1,tmpp2=-1; std::vector tmp=fillArrayWithPyListInt2(elt0,tmpp1,tmpp2); ret->alloc(tmpp1,tmpp2); std::copy(tmp.begin(),tmp.end(),ret->getPointer()); @@ -5732,7 +5923,7 @@ namespace MEDCoupling int nbOfCompo=PyInt_AS_LONG(nbOfTuples); if(nbOfCompo<0) throw INTERP_KERNEL::Exception("DataArrayAsciiChar::New : should be a positive number of components !"); - MEDCouplingAutoRefCountObjectPtr ret=DataArrayAsciiChar::New(); + MCAuto ret=DataArrayAsciiChar::New(); ret->alloc(nbOfTuples1,nbOfCompo); return ret.retn(); } @@ -5744,7 +5935,7 @@ namespace MEDCoupling } else {//DataArrayAsciiChar.New(5) - MEDCouplingAutoRefCountObjectPtr ret=DataArrayAsciiChar::New(); + MCAuto ret=DataArrayAsciiChar::New(); ret->alloc(nbOfTuples1,1); return ret.retn(); } @@ -5823,40 +6014,40 @@ namespace MEDCoupling throw INTERP_KERNEL::Exception("DataArrayAsciiChar::presenceOfValue : only strings in input supported !"); } - int locateValue(PyObject *vals) const throw(INTERP_KERNEL::Exception) + int findIdFirstEqual(PyObject *vals) const throw(INTERP_KERNEL::Exception) { if(PyString_Check(vals)) { Py_ssize_t sz=PyString_Size(vals); std::vector vals2(sz); std::copy(PyString_AsString(vals),PyString_AsString(vals)+sz,vals2.begin()); - return self->locateValue(vals2); + return self->findIdFirstEqual(vals2); } else - throw INTERP_KERNEL::Exception("DataArrayAsciiChar::locateValue : only strings in input supported !"); + throw INTERP_KERNEL::Exception("DataArrayAsciiChar::findIdFirstEqual : only strings in input supported !"); } - int locateTuple(PyObject *tupl) const throw(INTERP_KERNEL::Exception) + int findIdFirstEqualTuple(PyObject *tupl) const throw(INTERP_KERNEL::Exception) { if(PyString_Check(tupl)) { Py_ssize_t sz=PyString_Size(tupl); std::vector vals(sz); std::copy(PyString_AsString(tupl),PyString_AsString(tupl)+sz,vals.begin()); - return self->locateTuple(vals); + return self->findIdFirstEqualTuple(vals); } else - throw INTERP_KERNEL::Exception("DataArrayAsciiChar::locateTuple : only strings in input supported !"); + throw INTERP_KERNEL::Exception("DataArrayAsciiChar::findIdFirstEqualTuple : only strings in input supported !"); } - int search(PyObject *strOrListOfInt) const throw(INTERP_KERNEL::Exception) + int findIdSequence(PyObject *strOrListOfInt) const throw(INTERP_KERNEL::Exception) { if(PyString_Check(strOrListOfInt)) { Py_ssize_t sz=PyString_Size(strOrListOfInt); std::vector vals(sz); std::copy(PyString_AsString(strOrListOfInt),PyString_AsString(strOrListOfInt)+sz,vals.begin()); - return self->search(vals); + return self->findIdSequence(vals); } else throw INTERP_KERNEL::Exception("DataArrayAsciiChar::search : only strings in input supported !"); @@ -5904,7 +6095,7 @@ namespace MEDCoupling Py_ssize_t sz=PyString_Size(obj); char *pt=PyString_AsString(obj); if(sz==1) - return self->locateValue(pt[0]); + return self->findIdFirstEqual(pt[0]); else throw INTERP_KERNEL::Exception("DataArrayAsciiChar::index : 'this' contains one component and trying to find a string with size different from 1 !"); } @@ -5912,7 +6103,7 @@ namespace MEDCoupling throw INTERP_KERNEL::Exception("DataArrayAsciiChar::index : 'this' contains one component and trying to find an element which is not an integer !"); } default: - return MEDCoupling_DataArrayAsciiChar_locateTuple(self,obj); + return MEDCoupling_DataArrayAsciiChar_findIdFirstEqualTuple(self,obj); } } @@ -5956,7 +6147,7 @@ namespace MEDCoupling case 2: return convertDataArrayChar(self->selectByTupleIdSafe(&stdvecTyyppArr[0],&stdvecTyyppArr[0]+stdvecTyyppArr.size()), SWIG_POINTER_OWN | 0 ); case 3: - return convertDataArrayChar(self->selectByTupleId2(sTyyppArr.first,sTyyppArr.second.first,sTyyppArr.second.second), SWIG_POINTER_OWN | 0 ); + return convertDataArrayChar(self->selectByTupleIdSafeSlice(sTyyppArr.first,sTyyppArr.second.first,sTyyppArr.second.second), SWIG_POINTER_OWN | 0 ); case 4: return convertDataArrayChar(self->selectByTupleIdSafe(daIntTyypp->begin(),daIntTyypp->end()), SWIG_POINTER_OWN | 0 ); default: @@ -5991,14 +6182,14 @@ namespace MEDCoupling //value string case 2: { - MEDCouplingAutoRefCountObjectPtr tmp=DataArrayAsciiChar::New(sc); + MCAuto tmp=DataArrayAsciiChar::New(sc); self->setPartOfValues3(tmp,&iTypppArr,&iTypppArr+1,0,nbOfCompo,1,false); return self; } //value vector case 3: { - MEDCouplingAutoRefCountObjectPtr tmp=DataArrayAsciiChar::New(vsc,' '); + MCAuto tmp=DataArrayAsciiChar::New(vsc,' '); self->setPartOfValues3(tmp,&iTypppArr,&iTypppArr+1,0,nbOfCompo,1,false); return self; } @@ -6025,14 +6216,14 @@ namespace MEDCoupling //value string case 2: { - MEDCouplingAutoRefCountObjectPtr tmp=DataArrayAsciiChar::New(sc); + MCAuto tmp=DataArrayAsciiChar::New(sc); self->setPartOfValues3(tmp,&stdvecTyyppArr[0],&stdvecTyyppArr[0]+stdvecTyyppArr.size(),0,nbOfCompo,1,false); return self; } //value vector case 3: { - MEDCouplingAutoRefCountObjectPtr tmp=DataArrayAsciiChar::New(vsc,' '); + MCAuto tmp=DataArrayAsciiChar::New(vsc,' '); self->setPartOfValues3(tmp,&stdvecTyyppArr[0],&stdvecTyyppArr[0]+stdvecTyyppArr.size(),0,nbOfCompo,1,false); return self; } @@ -6060,14 +6251,14 @@ namespace MEDCoupling //value string case 2: { - MEDCouplingAutoRefCountObjectPtr tmp=DataArrayAsciiChar::New(sc); + MCAuto tmp=DataArrayAsciiChar::New(sc); self->setPartOfValues1(tmp,sTyyppArr.first,sTyyppArr.second.first,sTyyppArr.second.second,0,nbOfCompo,1,false); return self; } //value vector case 3: { - MEDCouplingAutoRefCountObjectPtr tmp=DataArrayAsciiChar::New(vsc,' '); + MCAuto tmp=DataArrayAsciiChar::New(vsc,' '); self->setPartOfValues1(tmp,sTyyppArr.first,sTyyppArr.second.first,sTyyppArr.second.second,0,nbOfCompo,1,false); return self; } @@ -6095,14 +6286,14 @@ namespace MEDCoupling //value string case 2: { - MEDCouplingAutoRefCountObjectPtr tmp=DataArrayAsciiChar::New(sc); + MCAuto tmp=DataArrayAsciiChar::New(sc); self->setPartOfValues3(tmp,daIntTyypp->begin(),daIntTyypp->end(),0,nbOfCompo,1,false); return self; } //value vector case 3: { - MEDCouplingAutoRefCountObjectPtr tmp=DataArrayAsciiChar::New(vsc,' '); + MCAuto tmp=DataArrayAsciiChar::New(vsc,' '); self->setPartOfValues3(tmp,daIntTyypp->begin(),daIntTyypp->end(),0,nbOfCompo,1,false); return self; }