X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FMEDCoupling_Swig%2FMEDCouplingMemArray.i;h=7bc107464dc3967dfcec647000d8449bfff904b1;hb=9727e779d56acece98be02cdccd0f99cc5ef0fa2;hp=e13e8eec1f9fdc9f3a7e911ba8dfbf228ce9801a;hpb=df138a71c1f646f44f33ff3a2539cd9be1c8e377;p=tools%2Fmedcoupling.git diff --git a/src/MEDCoupling_Swig/MEDCouplingMemArray.i b/src/MEDCoupling_Swig/MEDCouplingMemArray.i index e13e8eec1..7bc107464 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-2019 CEA/DEN, EDF R&D // // This library is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public @@ -16,10 +16,10 @@ // // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com // -// Author : Anthony Geay (CEA/DEN) +// Author : Anthony Geay (EDF R&D) //////////////////// -%typemap(out) ParaMEDMEM::DataArray* +%typemap(out) MEDCoupling::DataArray* { $result=convertDataArray($1,$owner); } @@ -31,7 +31,7 @@ //$$$$$$$$$$$$$$$$$$ //////////////////// -%typemap(out) ParaMEDMEM::DataArrayChar* +%typemap(out) MEDCoupling::DataArrayChar* { $result=convertDataArrayChar($1,$owner); } @@ -40,160 +40,201 @@ { $result=convertDataArrayChar($1,$owner); } + +%typemap(out) MCAuto +{ + $result=SWIG_NewPointerObj(SWIG_as_voidptr($1.retn()),SWIGTYPE_p_MEDCoupling__DataArrayInt,SWIG_POINTER_OWN|0); +} + +%typemap(out) MCAuto +{ + $result=SWIG_NewPointerObj(SWIG_as_voidptr($1.retn()),SWIGTYPE_p_MEDCoupling__DataArrayDouble,SWIG_POINTER_OWN|0); +} + +%typemap(out) MCAuto +{ + $result=SWIG_NewPointerObj(SWIG_as_voidptr($1.retn()),SWIGTYPE_p_MEDCoupling__DataArrayFloat,SWIG_POINTER_OWN|0); +} + +%typemap(out) MCAuto +{ + $result=SWIG_NewPointerObj(SWIG_as_voidptr($1.retn()),SWIGTYPE_p_MEDCoupling__MapII,SWIG_POINTER_OWN|0); +} //$$$$$$$$$$$$$$$$$$ -%newobject ParaMEDMEM::DataArray::deepCpy; -%newobject ParaMEDMEM::DataArray::selectByTupleRanges; -%newobject ParaMEDMEM::DataArray::selectByTupleId; -%newobject ParaMEDMEM::DataArray::selectByTupleIdSafe; -%newobject ParaMEDMEM::DataArray::selectByTupleId2; -%newobject ParaMEDMEM::DataArray::Aggregate; -%newobject ParaMEDMEM::DataArrayInt::New; -%newobject ParaMEDMEM::DataArrayInt::__iter__; -%newobject ParaMEDMEM::DataArrayInt::convertToDblArr; -%newobject ParaMEDMEM::DataArrayInt::performCpy; -%newobject ParaMEDMEM::DataArrayInt::substr; -%newobject ParaMEDMEM::DataArrayInt::changeNbOfComponents; -%newobject ParaMEDMEM::DataArrayInt::accumulatePerChunck; -%newobject ParaMEDMEM::DataArrayInt::checkAndPreparePermutation; -%newobject ParaMEDMEM::DataArrayInt::transformWithIndArrR; -%newobject ParaMEDMEM::DataArrayInt::renumber; -%newobject ParaMEDMEM::DataArrayInt::renumberR; -%newobject ParaMEDMEM::DataArrayInt::renumberAndReduce; -%newobject ParaMEDMEM::DataArrayInt::invertArrayO2N2N2O; -%newobject ParaMEDMEM::DataArrayInt::invertArrayN2O2O2N; -%newobject ParaMEDMEM::DataArrayInt::invertArrayO2N2N2OBis; -%newobject ParaMEDMEM::DataArrayInt::getIdsEqual; -%newobject ParaMEDMEM::DataArrayInt::getIdsNotEqual; -%newobject ParaMEDMEM::DataArrayInt::getIdsEqualList; -%newobject ParaMEDMEM::DataArrayInt::getIdsNotEqualList; -%newobject ParaMEDMEM::DataArrayInt::getIdsEqualTuple; -%newobject ParaMEDMEM::DataArrayInt::sumPerTuple; -%newobject ParaMEDMEM::DataArrayInt::negate; -%newobject ParaMEDMEM::DataArrayInt::computeAbs; -%newobject ParaMEDMEM::DataArrayInt::getIdsInRange; -%newobject ParaMEDMEM::DataArrayInt::getIdsNotInRange; -%newobject ParaMEDMEM::DataArrayInt::getIdsStrictlyNegative; -%newobject ParaMEDMEM::DataArrayInt::Aggregate; -%newobject ParaMEDMEM::DataArrayInt::AggregateIndexes; -%newobject ParaMEDMEM::DataArrayInt::Meld; -%newobject ParaMEDMEM::DataArrayInt::Add; -%newobject ParaMEDMEM::DataArrayInt::Substract; -%newobject ParaMEDMEM::DataArrayInt::Multiply; -%newobject ParaMEDMEM::DataArrayInt::Divide; -%newobject ParaMEDMEM::DataArrayInt::Pow; -%newobject ParaMEDMEM::DataArrayInt::BuildUnion; -%newobject ParaMEDMEM::DataArrayInt::BuildIntersection; -%newobject ParaMEDMEM::DataArrayInt::Range; -%newobject ParaMEDMEM::DataArrayInt::fromNoInterlace; -%newobject ParaMEDMEM::DataArrayInt::toNoInterlace; -%newobject ParaMEDMEM::DataArrayInt::buildComplement; -%newobject ParaMEDMEM::DataArrayInt::buildUnion; -%newobject ParaMEDMEM::DataArrayInt::buildSubstraction; -%newobject ParaMEDMEM::DataArrayInt::buildSubstractionOptimized; -%newobject ParaMEDMEM::DataArrayInt::buildIntersection; -%newobject ParaMEDMEM::DataArrayInt::buildUnique; -%newobject ParaMEDMEM::DataArrayInt::buildUniqueNotSorted; -%newobject ParaMEDMEM::DataArrayInt::deltaShiftIndex; -%newobject ParaMEDMEM::DataArrayInt::buildExplicitArrByRanges; -%newobject ParaMEDMEM::DataArrayInt::buildExplicitArrOfSliceOnScaledArr; -%newobject ParaMEDMEM::DataArrayInt::findRangeIdForEachTuple; -%newobject ParaMEDMEM::DataArrayInt::findIdInRangeForEachTuple; -%newobject ParaMEDMEM::DataArrayInt::duplicateEachTupleNTimes; -%newobject ParaMEDMEM::DataArrayInt::buildPermutationArr; -%newobject ParaMEDMEM::DataArrayInt::buildPermArrPerLevel; -%newobject ParaMEDMEM::DataArrayInt::getDifferentValues; -%newobject ParaMEDMEM::DataArrayInt::FindPermutationFromFirstToSecond; -%newobject ParaMEDMEM::DataArrayInt::CheckAndPreparePermutation; -%newobject ParaMEDMEM::DataArrayInt::__neg__; -%newobject ParaMEDMEM::DataArrayInt::__add__; -%newobject ParaMEDMEM::DataArrayInt::__radd__; -%newobject ParaMEDMEM::DataArrayInt::__sub__; -%newobject ParaMEDMEM::DataArrayInt::__rsub__; -%newobject ParaMEDMEM::DataArrayInt::__mul__; -%newobject ParaMEDMEM::DataArrayInt::__rmul__; -%newobject ParaMEDMEM::DataArrayInt::__div__; -%newobject ParaMEDMEM::DataArrayInt::__rdiv__; -%newobject ParaMEDMEM::DataArrayInt::__mod__; -%newobject ParaMEDMEM::DataArrayInt::__rmod__; -%newobject ParaMEDMEM::DataArrayInt::__pow__; -%newobject ParaMEDMEM::DataArrayInt::__rpow__; -%newobject ParaMEDMEM::DataArrayIntTuple::buildDAInt; -%newobject ParaMEDMEM::DataArrayChar::convertToIntArr; -%newobject ParaMEDMEM::DataArrayChar::renumber; -%newobject ParaMEDMEM::DataArrayChar::renumberR; -%newobject ParaMEDMEM::DataArrayChar::renumberAndReduce; -%newobject ParaMEDMEM::DataArrayChar::changeNbOfComponents; -%newobject ParaMEDMEM::DataArrayChar::getIdsEqual; -%newobject ParaMEDMEM::DataArrayChar::getIdsNotEqual; -%newobject ParaMEDMEM::DataArrayChar::Aggregate; -%newobject ParaMEDMEM::DataArrayChar::Meld; -%newobject ParaMEDMEM::DataArrayByte::New; -%newobject ParaMEDMEM::DataArrayByte::__iter__; -%newobject ParaMEDMEM::DataArrayByte::performCpy; -%newobject ParaMEDMEM::DataArrayByteTuple::buildDAByte; -%newobject ParaMEDMEM::DataArrayChar::substr; -%newobject ParaMEDMEM::DataArrayAsciiChar::New; -%newobject ParaMEDMEM::DataArrayAsciiChar::__iter__; -%newobject ParaMEDMEM::DataArrayAsciiChar::performCpy; -%newobject ParaMEDMEM::DataArrayAsciiCharTuple::buildDAAsciiChar; -%newobject ParaMEDMEM::DataArrayDouble::New; -%newobject ParaMEDMEM::DataArrayDouble::__iter__; -%newobject ParaMEDMEM::DataArrayDouble::convertToIntArr; -%newobject ParaMEDMEM::DataArrayDouble::performCpy; -%newobject ParaMEDMEM::DataArrayDouble::Aggregate; -%newobject ParaMEDMEM::DataArrayDouble::Meld; -%newobject ParaMEDMEM::DataArrayDouble::Dot; -%newobject ParaMEDMEM::DataArrayDouble::CrossProduct; -%newobject ParaMEDMEM::DataArrayDouble::Add; -%newobject ParaMEDMEM::DataArrayDouble::Substract; -%newobject ParaMEDMEM::DataArrayDouble::Multiply; -%newobject ParaMEDMEM::DataArrayDouble::Divide; -%newobject ParaMEDMEM::DataArrayDouble::Pow; -%newobject ParaMEDMEM::DataArrayDouble::substr; -%newobject ParaMEDMEM::DataArrayDouble::changeNbOfComponents; -%newobject ParaMEDMEM::DataArrayDouble::accumulatePerChunck; -%newobject ParaMEDMEM::DataArrayDouble::getIdsInRange; -%newobject ParaMEDMEM::DataArrayDouble::getIdsNotInRange; -%newobject ParaMEDMEM::DataArrayDouble::negate; -%newobject ParaMEDMEM::DataArrayDouble::computeAbs; -%newobject ParaMEDMEM::DataArrayDouble::applyFunc; -%newobject ParaMEDMEM::DataArrayDouble::applyFunc2; -%newobject ParaMEDMEM::DataArrayDouble::applyFunc3; -%newobject ParaMEDMEM::DataArrayDouble::doublyContractedProduct; -%newobject ParaMEDMEM::DataArrayDouble::determinant; -%newobject ParaMEDMEM::DataArrayDouble::eigenValues; -%newobject ParaMEDMEM::DataArrayDouble::eigenVectors; -%newobject ParaMEDMEM::DataArrayDouble::inverse; -%newobject ParaMEDMEM::DataArrayDouble::trace; -%newobject ParaMEDMEM::DataArrayDouble::deviator; -%newobject ParaMEDMEM::DataArrayDouble::magnitude; -%newobject ParaMEDMEM::DataArrayDouble::maxPerTuple; -%newobject ParaMEDMEM::DataArrayDouble::sumPerTuple; -%newobject ParaMEDMEM::DataArrayDouble::computeBBoxPerTuple; -%newobject ParaMEDMEM::DataArrayDouble::buildEuclidianDistanceDenseMatrix; -%newobject ParaMEDMEM::DataArrayDouble::buildEuclidianDistanceDenseMatrixWith; -%newobject ParaMEDMEM::DataArrayDouble::renumber; -%newobject ParaMEDMEM::DataArrayDouble::renumberR; -%newobject ParaMEDMEM::DataArrayDouble::renumberAndReduce; -%newobject ParaMEDMEM::DataArrayDouble::fromNoInterlace; -%newobject ParaMEDMEM::DataArrayDouble::toNoInterlace; -%newobject ParaMEDMEM::DataArrayDouble::fromPolarToCart; -%newobject ParaMEDMEM::DataArrayDouble::fromCylToCart; -%newobject ParaMEDMEM::DataArrayDouble::fromSpherToCart; -%newobject ParaMEDMEM::DataArrayDouble::cartesianize; -%newobject ParaMEDMEM::DataArrayDouble::getDifferentValues; -%newobject ParaMEDMEM::DataArrayDouble::findClosestTupleId; -%newobject ParaMEDMEM::DataArrayDouble::computeNbOfInteractionsWith; -%newobject ParaMEDMEM::DataArrayDouble::duplicateEachTupleNTimes; -%newobject ParaMEDMEM::DataArrayDouble::__neg__; -%newobject ParaMEDMEM::DataArrayDouble::__radd__; -%newobject ParaMEDMEM::DataArrayDouble::__rsub__; -%newobject ParaMEDMEM::DataArrayDouble::__rmul__; -%newobject ParaMEDMEM::DataArrayDouble::__rdiv__; -%newobject ParaMEDMEM::DataArrayDouble::__pow__; -%newobject ParaMEDMEM::DataArrayDouble::__rpow__; -%newobject ParaMEDMEM::DataArrayDoubleTuple::buildDADouble; +%newobject MEDCoupling::DataArray::deepCopy; +%newobject MEDCoupling::DataArray::buildNewEmptyInstance; +%newobject MEDCoupling::DataArray::selectByTupleRanges; +%newobject MEDCoupling::DataArray::selectByTupleId; +%newobject MEDCoupling::DataArray::selectByTupleIdSafe; +%newobject MEDCoupling::DataArray::selectByTupleIdSafeSlice; +%newobject MEDCoupling::DataArray::Aggregate; +%newobject MEDCoupling::DataArrayFloat::New; +%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; +%newobject MEDCoupling::DataArrayInt::subArray; +%newobject MEDCoupling::DataArrayInt::changeNbOfComponents; +%newobject MEDCoupling::DataArrayInt::accumulatePerChunck; +%newobject MEDCoupling::DataArrayInt::checkAndPreparePermutation; +%newobject MEDCoupling::DataArrayInt::transformWithIndArrR; +%newobject MEDCoupling::DataArrayInt::renumber; +%newobject MEDCoupling::DataArrayInt::renumberR; +%newobject MEDCoupling::DataArrayInt::renumberAndReduce; +%newobject MEDCoupling::DataArrayInt::invertArrayO2N2N2O; +%newobject MEDCoupling::DataArrayInt::invertArrayN2O2O2N; +%newobject MEDCoupling::DataArrayInt::invertArrayO2N2N2OBis; +%newobject MEDCoupling::DataArrayInt::findIdsEqual; +%newobject MEDCoupling::DataArrayInt::findIdsNotEqual; +%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; +%newobject MEDCoupling::DataArrayInt::findIdsInRange; +%newobject MEDCoupling::DataArrayInt::findIdsNotInRange; +%newobject MEDCoupling::DataArrayInt::findIdsStrictlyNegative; +%newobject MEDCoupling::DataArrayInt::Aggregate; +%newobject MEDCoupling::DataArrayInt::AggregateIndexes; +%newobject MEDCoupling::DataArrayInt::Meld; +%newobject MEDCoupling::DataArrayInt::Add; +%newobject MEDCoupling::DataArrayInt::Substract; +%newobject MEDCoupling::DataArrayInt::Multiply; +%newobject MEDCoupling::DataArrayInt::Divide; +%newobject MEDCoupling::DataArrayInt::Pow; +%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; +%newobject MEDCoupling::DataArrayInt::buildUnion; +%newobject MEDCoupling::DataArrayInt::buildSubstraction; +%newobject MEDCoupling::DataArrayInt::buildSubstractionOptimized; +%newobject MEDCoupling::DataArrayInt::buildIntersection; +%newobject MEDCoupling::DataArrayInt::buildUnique; +%newobject MEDCoupling::DataArrayInt::buildUniqueNotSorted; +%newobject MEDCoupling::DataArrayInt::deltaShiftIndex; +%newobject MEDCoupling::DataArrayInt::buildExplicitArrByRanges; +%newobject MEDCoupling::DataArrayInt::buildExplicitArrOfSliceOnScaledArr; +%newobject MEDCoupling::DataArrayInt::findRangeIdForEachTuple; +%newobject MEDCoupling::DataArrayInt::findIdInRangeForEachTuple; +%newobject MEDCoupling::DataArrayInt::duplicateEachTupleNTimes; +%newobject MEDCoupling::DataArrayInt::buildPermutationArr; +%newobject MEDCoupling::DataArrayInt::buildPermArrPerLevel; +%newobject MEDCoupling::DataArrayInt::getDifferentValues; +%newobject MEDCoupling::DataArrayInt::FindPermutationFromFirstToSecond; +%newobject MEDCoupling::DataArrayInt::CheckAndPreparePermutation; +%newobject MEDCoupling::DataArrayInt::__neg__; +%newobject MEDCoupling::DataArrayInt::__add__; +%newobject MEDCoupling::DataArrayInt::__radd__; +%newobject MEDCoupling::DataArrayInt::__sub__; +%newobject MEDCoupling::DataArrayInt::__rsub__; +%newobject MEDCoupling::DataArrayInt::__mul__; +%newobject MEDCoupling::DataArrayInt::__rmul__; +%newobject MEDCoupling::DataArrayInt::__div__; +%newobject MEDCoupling::DataArrayInt::__rdiv__; +%newobject MEDCoupling::DataArrayInt::__mod__; +%newobject MEDCoupling::DataArrayInt::__rmod__; +%newobject MEDCoupling::DataArrayInt::__pow__; +%newobject MEDCoupling::DataArrayInt::__rpow__; +%newobject MEDCoupling::DataArrayIntTuple::buildDAInt; +%newobject MEDCoupling::DataArrayChar::convertToIntArr; +%newobject MEDCoupling::DataArrayChar::renumber; +%newobject MEDCoupling::DataArrayChar::renumberR; +%newobject MEDCoupling::DataArrayChar::renumberAndReduce; +%newobject MEDCoupling::DataArrayChar::changeNbOfComponents; +%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::performCopyOrIncrRef; +%newobject MEDCoupling::DataArrayByteTuple::buildDAByte; +%newobject MEDCoupling::DataArrayChar::subArray; +%newobject MEDCoupling::DataArrayAsciiChar::New; +%newobject MEDCoupling::DataArrayAsciiChar::__iter__; +%newobject MEDCoupling::DataArrayAsciiChar::performCopyOrIncrRef; +%newobject MEDCoupling::DataArrayAsciiCharTuple::buildDAAsciiChar; +%newobject MEDCoupling::DataArrayDouble::New; +%newobject MEDCoupling::DataArrayDouble::__iter__; +%newobject MEDCoupling::DataArrayDouble::performCopyOrIncrRef; +%newobject MEDCoupling::DataArrayDouble::Aggregate; +%newobject MEDCoupling::DataArrayDouble::Meld; +%newobject MEDCoupling::DataArrayDouble::Dot; +%newobject MEDCoupling::DataArrayDouble::CrossProduct; +%newobject MEDCoupling::DataArrayDouble::Add; +%newobject MEDCoupling::DataArrayDouble::Substract; +%newobject MEDCoupling::DataArrayDouble::Multiply; +%newobject MEDCoupling::DataArrayDouble::Divide; +%newobject MEDCoupling::DataArrayDouble::Pow; +%newobject MEDCoupling::DataArrayDouble::symmetry3DPlane; +%newobject MEDCoupling::DataArrayDouble::subArray; +%newobject MEDCoupling::DataArrayDouble::changeNbOfComponents; +%newobject MEDCoupling::DataArrayDouble::accumulatePerChunck; +%newobject MEDCoupling::DataArrayDouble::findIdsInRange; +%newobject MEDCoupling::DataArrayDouble::findIdsNotInRange; +%newobject MEDCoupling::DataArrayDouble::findIdsStrictlyNegative; +%newobject MEDCoupling::DataArrayDouble::negate; +%newobject MEDCoupling::DataArrayDouble::computeAbs; +%newobject MEDCoupling::DataArrayDouble::applyFunc; +%newobject MEDCoupling::DataArrayDouble::applyFuncCompo; +%newobject MEDCoupling::DataArrayDouble::applyFuncNamedCompo; +%newobject MEDCoupling::DataArrayDouble::doublyContractedProduct; +%newobject MEDCoupling::DataArrayDouble::determinant; +%newobject MEDCoupling::DataArrayDouble::eigenValues; +%newobject MEDCoupling::DataArrayDouble::eigenVectors; +%newobject MEDCoupling::DataArrayDouble::inverse; +%newobject MEDCoupling::DataArrayDouble::trace; +%newobject MEDCoupling::DataArrayDouble::deviator; +%newobject MEDCoupling::DataArrayDouble::magnitude; +%newobject MEDCoupling::DataArrayDouble::maxPerTuple; +%newobject MEDCoupling::DataArrayDouble::sumPerTuple; +%newobject MEDCoupling::DataArrayDouble::computeBBoxPerTuple; +%newobject MEDCoupling::DataArrayDouble::buildEuclidianDistanceDenseMatrix; +%newobject MEDCoupling::DataArrayDouble::buildEuclidianDistanceDenseMatrixWith; +%newobject MEDCoupling::DataArrayDouble::renumber; +%newobject MEDCoupling::DataArrayDouble::renumberR; +%newobject MEDCoupling::DataArrayDouble::renumberAndReduce; +%newobject MEDCoupling::DataArrayDouble::fromNoInterlace; +%newobject MEDCoupling::DataArrayDouble::toNoInterlace; +%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; +%newobject MEDCoupling::DataArrayDouble::computeNbOfInteractionsWith; +%newobject MEDCoupling::DataArrayDouble::duplicateEachTupleNTimes; +%newobject MEDCoupling::DataArrayDouble::__neg__; +%newobject MEDCoupling::DataArrayDouble::__radd__; +%newobject MEDCoupling::DataArrayDouble::__rsub__; +%newobject MEDCoupling::DataArrayDouble::__rmul__; +%newobject MEDCoupling::DataArrayDouble::__rdiv__; +%newobject MEDCoupling::DataArrayDouble::__pow__; +%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();" @@ -202,7 +243,12 @@ %feature("unref") DataArrayAsciiChar "$this->decrRef();" %feature("unref") DataArrayByte "$this->decrRef();" -namespace ParaMEDMEM +%feature("unref") MapII "$this->decrRef();" +%feature("unref") PartDefinition "$this->decrRef();" +%feature("unref") DataArrayPartDefinition "$this->decrRef();" +%feature("unref") SlicePartDefinition "$this->decrRef();" + +namespace MEDCoupling { typedef enum { @@ -211,6 +257,115 @@ namespace ParaMEDMEM AX_SPHER = 5 } MEDCouplingAxisType; + class DataArrayInt; + + class MapII : public RefCountObject, public TimeLabel + { + public: + static MCAuto< MapII > New(); + }; + + 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 +394,13 @@ namespace ParaMEDMEM 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 +412,7 @@ namespace ParaMEDMEM 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 { @@ -283,7 +442,7 @@ namespace ParaMEDMEM virtual void renumberInPlace(PyObject *li) throw(INTERP_KERNEL::Exception) { void *da=0; - int res1=SWIG_ConvertPtr(li,&da,SWIGTYPE_p_ParaMEDMEM__DataArrayInt, 0 | 0 ); + int res1=SWIG_ConvertPtr(li,&da,SWIGTYPE_p_MEDCoupling__DataArrayInt, 0 | 0 ); if (!SWIG_IsOK(res1)) { int size; @@ -312,7 +471,7 @@ namespace ParaMEDMEM virtual void renumberInPlaceR(PyObject *li) throw(INTERP_KERNEL::Exception) { void *da=0; - int res1=SWIG_ConvertPtr(li,&da,SWIGTYPE_p_ParaMEDMEM__DataArrayInt, 0 | 0 ); + int res1=SWIG_ConvertPtr(li,&da,SWIGTYPE_p_MEDCoupling__DataArrayInt, 0 | 0 ); if (!SWIG_IsOK(res1)) { int size; @@ -341,8 +500,8 @@ namespace ParaMEDMEM //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 +513,10 @@ namespace ParaMEDMEM 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) @@ -370,7 +529,7 @@ namespace ParaMEDMEM virtual DataArray *selectByTupleId(PyObject *li) const throw(INTERP_KERNEL::Exception) { void *da=0; - int res1=SWIG_ConvertPtr(li,&da,SWIGTYPE_p_ParaMEDMEM__DataArrayInt, 0 | 0 ); + int res1=SWIG_ConvertPtr(li,&da,SWIGTYPE_p_MEDCoupling__DataArrayInt, 0 | 0 ); if (!SWIG_IsOK(res1)) { int size; @@ -390,7 +549,7 @@ namespace ParaMEDMEM virtual DataArray *selectByTupleIdSafe(PyObject *li) const throw(INTERP_KERNEL::Exception) { void *da=0; - int res1=SWIG_ConvertPtr(li,&da,SWIGTYPE_p_ParaMEDMEM__DataArrayInt, 0 | 0 ); + int res1=SWIG_ConvertPtr(li,&da,SWIGTYPE_p_MEDCoupling__DataArrayInt, 0 | 0 ); if (!SWIG_IsOK(res1)) { int size; @@ -420,8 +579,7 @@ namespace ParaMEDMEM if(!PySlice_Check(slic)) throw INTERP_KERNEL::Exception("DataArray::GetSlice (wrap) : expecting a pyslice as second (first) parameter !"); Py_ssize_t strt=2,stp=2,step=2; - PySliceObject *sly=reinterpret_cast(slic); - GetIndicesOfSliceExplicitely(sly,&strt,&stp,&step,"DataArray::GetSlice (wrap) : the input slice is invalid !"); + GetIndicesOfSliceExplicitely(slic,&strt,&stp,&step,"DataArray::GetSlice (wrap) : the input slice is invalid !"); int a,b; DataArray::GetSlice(strt,stp,step,sliceId,nbOfSlices,a,b); return PySlice_New(PyInt_FromLong(a),PyInt_FromLong(b),PyInt_FromLong(step)); @@ -432,8 +590,7 @@ namespace ParaMEDMEM if(!PySlice_Check(slic)) throw INTERP_KERNEL::Exception("DataArray::getSlice (wrap) : expecting a pyslice as second (first) parameter !"); Py_ssize_t strt=2,stp=2,step=2; - PySliceObject *sly=reinterpret_cast(slic); - GetIndicesOfSlice(sly,self->getNumberOfTuples(),&strt,&stp,&step,"DataArray::getSlice (wrap) : the input slice is invalid !"); + GetIndicesOfSlice(slic,self->getNumberOfTuples(),&strt,&stp,&step,"DataArray::getSlice (wrap) : the input slice is invalid !"); int a,b; DataArray::GetSlice(strt,stp,step,sliceId,nbOfSlices,a,b); return PySlice_New(PyInt_FromLong(a),PyInt_FromLong(b),PyInt_FromLong(step)); @@ -444,8 +601,7 @@ namespace ParaMEDMEM if(!PySlice_Check(slic)) throw INTERP_KERNEL::Exception("DataArray::GetNumberOfItemGivenBES (wrap) : expecting a pyslice as second (first) parameter !"); Py_ssize_t strt=2,stp=2,step=2; - PySliceObject *sly=reinterpret_cast(slic); - GetIndicesOfSliceExplicitely(sly,&strt,&stp,&step,"DataArray::GetNumberOfItemGivenBES (wrap) : the input slice is invalid !"); + GetIndicesOfSliceExplicitely(slic,&strt,&stp,&step,"DataArray::GetNumberOfItemGivenBES (wrap) : the input slice is invalid !"); return DataArray::GetNumberOfItemGivenBES(strt,stp,step,""); } @@ -454,15 +610,14 @@ namespace ParaMEDMEM if(!PySlice_Check(slic)) throw INTERP_KERNEL::Exception("DataArray::GetNumberOfItemGivenBESRelative (wrap) : expecting a pyslice as second (first) parameter !"); Py_ssize_t strt=2,stp=2,step=2; - PySliceObject *sly=reinterpret_cast(slic); - GetIndicesOfSliceExplicitely(sly,&strt,&stp,&step,"DataArray::GetNumberOfItemGivenBESRelative (wrap) : the input slice is invalid !"); + GetIndicesOfSliceExplicitely(slic,&strt,&stp,&step,"DataArray::GetNumberOfItemGivenBESRelative (wrap) : the input slice is invalid !"); return DataArray::GetNumberOfItemGivenBESRelative(strt,stp,step,""); } static DataArray *Aggregate(PyObject *arrs) throw(INTERP_KERNEL::Exception) { std::vector tmp; - convertFromPyObjVectorOfObj(arrs,SWIGTYPE_p_ParaMEDMEM__DataArray,"DataArray",tmp); + convertFromPyObjVectorOfObj(arrs,SWIGTYPE_p_MEDCoupling__DataArray,"DataArray",tmp); return DataArray::Aggregate(tmp); } @@ -471,8 +626,7 @@ namespace ParaMEDMEM if(!PySlice_Check(slic)) throw INTERP_KERNEL::Exception("DataArray::getNumberOfItemGivenBES (wrap) : expecting a pyslice as second (first) parameter !"); Py_ssize_t strt=2,stp=2,step=2; - PySliceObject *sly=reinterpret_cast(slic); - GetIndicesOfSlice(sly,self->getNumberOfTuples(),&strt,&stp,&step,"DataArray::getNumberOfItemGivenBES (wrap) : the input slice is invalid !"); + GetIndicesOfSlice(slic,self->getNumberOfTuples(),&strt,&stp,&step,"DataArray::getNumberOfItemGivenBES (wrap) : the input slice is invalid !"); return DataArray::GetNumberOfItemGivenBES(strt,stp,step,""); } @@ -481,8 +635,7 @@ namespace ParaMEDMEM if(!PySlice_Check(slic)) throw INTERP_KERNEL::Exception("DataArray::getNumberOfItemGivenBESRelative (wrap) : expecting a pyslice as second (first) parameter !"); Py_ssize_t strt=2,stp=2,step=2; - PySliceObject *sly=reinterpret_cast(slic); - GetIndicesOfSlice(sly,self->getNumberOfTuples(),&strt,&stp,&step,"DataArray::getNumberOfItemGivenBESRelative (wrap) : the input slice is invalid !"); + GetIndicesOfSlice(slic,self->getNumberOfTuples(),&strt,&stp,&step,"DataArray::getNumberOfItemGivenBESRelative (wrap) : the input slice is invalid !"); return DataArray::GetNumberOfItemGivenBESRelative(strt,stp,step,""); } @@ -511,17 +664,205 @@ namespace ParaMEDMEM if(sz!=2) throw INTERP_KERNEL::Exception("DataArrayDouble.__setstate__ : invalid tuple in input ! Should be of size 2 ! Invalid overwrite of __getstate__ ?"); PyObject *a0(PyTuple_GetItem(inp,0)); - if(!PyString_Check(a0)) - throw INTERP_KERNEL::Exception(MSG); + self->setName(convertPyObjectToStr(a0,MSG)); PyObject *a1(PyTuple_GetItem(inp,1)); std::vector a1cpp; if(!fillStringVector(a1,a1cpp)) throw INTERP_KERNEL::Exception(MSG); - self->setName(PyString_AsString(a0)); self->setInfoOnComponents(a1cpp); } } }; + + class DataArrayDouble; + + class DataArrayFloat : public DataArray + { + public: + static DataArrayFloat *New(); + void fillWithValue(float val) throw(INTERP_KERNEL::Exception); + bool isEqual(const DataArrayFloat& other, float prec) const throw(INTERP_KERNEL::Exception); + bool isEqualWithoutConsideringStr(const DataArrayFloat& other, float prec) const throw(INTERP_KERNEL::Exception); + bool isUniform(float val, float eps) const throw(INTERP_KERNEL::Exception); + void pushBackSilent(float val) throw(INTERP_KERNEL::Exception); + void iota(float init=0.) throw(INTERP_KERNEL::Exception); + DataArrayFloatIterator *iterator() throw(INTERP_KERNEL::Exception); + MCAuto convertToDblArr() const throw(INTERP_KERNEL::Exception); + static DataArrayFloat *Meld(const DataArrayFloat *a1, const DataArrayFloat *a2) throw(INTERP_KERNEL::Exception); + %extend + { + DataArrayFloat() throw(INTERP_KERNEL::Exception) + { + return DataArrayFloat::New(); + } + + static DataArrayFloat *New(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *elt2=0) throw(INTERP_KERNEL::Exception) + { + return DataArrayT_New(elt0,nbOfTuples,elt2); + } + + DataArrayFloat(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *elt2=0) throw(INTERP_KERNEL::Exception) + { + return MEDCoupling_DataArrayFloat_New__SWIG_1(elt0,nbOfTuples,elt2); + } + + DataArrayFloatIterator *__iter__() throw(INTERP_KERNEL::Exception) + { + return self->iterator(); + } + + std::string __repr__() const throw(INTERP_KERNEL::Exception) + { + std::ostringstream oss; + self->reprQuickOverview(oss); + return oss.str(); + } + + std::string __str__() const throw(INTERP_KERNEL::Exception) + { + return self->reprNotTooLong(); + } + + int __len__() const throw(INTERP_KERNEL::Exception) + { + if(self->isAllocated()) + { + return self->getNumberOfTuples(); + } + else + { + throw INTERP_KERNEL::Exception("DataArrayFloat::__len__ : Instance is NOT allocated !"); + } + } + + PyObject *getValues() const throw(INTERP_KERNEL::Exception) + { + const float *vals(self->begin()); + return convertDblArrToPyList(vals,self->getNbOfElems()); + } + + PyObject *getValuesAsTuple() const throw(INTERP_KERNEL::Exception) + { + const float *vals(self->begin()); + 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) + { + return DataArrayT__getitem(self,obj); + } + + DataArrayFloat *__setitem__(PyObject *obj, PyObject *value) throw(INTERP_KERNEL::Exception) + { + return DataArrayT__setitem__(self,obj,value); + } + + PyObject *___iadd___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception) + { + return DataArrayT_iadd(trueSelf,obj,self); + } + + PyObject *___isub___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception) + { + return DataArrayT_isub(trueSelf,obj,self); + } + + PyObject *___imul___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception) + { + 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); + } + +#ifdef WITH_NUMPY + PyObject *toNumPyArray() throw(INTERP_KERNEL::Exception) // not const. It is not a bug ! + { + return ToNumPyArray(self,NPY_FLOAT,"DataArrayFloat"); + } +#endif + } + }; + + class DataArrayFloatTuple; + + class DataArrayFloatIterator + { + public: + DataArrayFloatIterator(DataArrayFloat *da); + ~DataArrayFloatIterator(); + %extend + { + PyObject *next() + { + DataArrayFloatTuple *ret=self->nextt(); + if(ret) + return SWIG_NewPointerObj(SWIG_as_voidptr(ret),SWIGTYPE_p_MEDCoupling__DataArrayFloatTuple,SWIG_POINTER_OWN|0); + else + { + PyErr_SetString(PyExc_StopIteration,"No more data."); + return 0; + } + } + } + }; + + class DataArrayFloatTuple + { + public: + int getNumberOfCompo() const throw(INTERP_KERNEL::Exception); + DataArrayFloat *buildDAFloat(int nbOfTuples, int nbOfCompo) const throw(INTERP_KERNEL::Exception); + %extend + { + std::string __str__() const throw(INTERP_KERNEL::Exception) + { + return self->repr(); + } + + float __float__() const throw(INTERP_KERNEL::Exception) + { + return self->floatValue(); + } + + DataArrayFloat *buildDAFloat() throw(INTERP_KERNEL::Exception) + { + return self->buildDAFloat(1,self->getNumberOfCompo()); + } + + /*PyObject *___imul___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception) + { + MCAuto ret=self->buildDAFloat(1,self->getNumberOfCompo()); + MEDCoupling_DataArrayFloat____imul___(ret,0,obj); + Py_XINCREF(trueSelf); + return trueSelf; + }*/ + + PyObject *__len__() throw(INTERP_KERNEL::Exception) + { + return PyInt_FromLong(self->getNumberOfCompo()); + } + } + }; class DataArrayInt; class DataArrayDoubleIterator; @@ -532,8 +873,9 @@ namespace ParaMEDMEM 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); @@ -552,10 +894,9 @@ namespace ParaMEDMEM std::string reprNotTooLong() const throw(INTERP_KERNEL::Exception); bool isEqual(const DataArrayDouble& other, double prec) const throw(INTERP_KERNEL::Exception); bool isEqualWithoutConsideringStr(const DataArrayDouble& other, double prec) const throw(INTERP_KERNEL::Exception); - 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); @@ -576,9 +917,8 @@ namespace ParaMEDMEM 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); @@ -589,6 +929,9 @@ namespace ParaMEDMEM 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 +958,13 @@ namespace ParaMEDMEM 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); + DataArrayInt *findIdsStrictlyNegative() 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); @@ -637,112 +981,30 @@ namespace ParaMEDMEM void divideEqual(const DataArrayDouble *other) throw(INTERP_KERNEL::Exception); static DataArrayDouble *Pow(const DataArrayDouble *a1, const DataArrayDouble *a2) throw(INTERP_KERNEL::Exception); void powEqual(const DataArrayDouble *other) throw(INTERP_KERNEL::Exception); + MCAuto findIdsGreaterOrEqualTo(double val) const throw(INTERP_KERNEL::Exception); + MCAuto findIdsGreaterThan(double val) const throw(INTERP_KERNEL::Exception); + MCAuto findIdsLowerOrEqualTo(double val) const throw(INTERP_KERNEL::Exception); + MCAuto findIdsLowerThan(double val) const throw(INTERP_KERNEL::Exception); + MCAuto convertToIntArr() const throw(INTERP_KERNEL::Exception); + MCAuto selectPartDef(const PartDefinition* pd) const throw(INTERP_KERNEL::Exception); + MCAuto cumSum() const throw(INTERP_KERNEL::Exception); + MCAuto convertToFloatArr() const throw(INTERP_KERNEL::Exception); %extend { DataArrayDouble() throw(INTERP_KERNEL::Exception) - { - return DataArrayDouble::New(); - } + { + return DataArrayDouble::New(); + } static DataArrayDouble *New(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *elt2=0) throw(INTERP_KERNEL::Exception) { - const char *msgBase="ParaMEDMEM::DataArrayDouble::New : Available API are : \n-DataArrayDouble.New()\n-DataArrayDouble.New([1.,3.,4.])\n-DataArrayDouble.New([1.,3.,4.],3)\n-DataArrayDouble.New([1.,3.,4.,5.],2,2)\n-DataArrayDouble.New([1.,3.,4.,5.,7,8.],3,2)\n-DataArrayDouble.New([(1.,3.),(4.,5.),(7,8.)])\n-DataArrayDouble.New(5)\n-DataArrayDouble.New(5,2)"; - std::string msg(msgBase); -#ifdef WITH_NUMPY - msg+="\n-DataArrayDouble.New(numpy array with dtype=float64)"; -#endif - msg+=" !"; - if(PyList_Check(elt0) || PyTuple_Check(elt0)) - { - if(nbOfTuples) - { - if(PyInt_Check(nbOfTuples)) - { - int nbOfTuples1=PyInt_AS_LONG(nbOfTuples); - if(nbOfTuples1<0) - throw INTERP_KERNEL::Exception("DataArrayDouble::New : should be a positive set of allocated memory !"); - if(elt2) - { - if(PyInt_Check(elt2)) - {//DataArrayDouble.New([1.,3.,4.,5.],2,2) - 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(); - std::vector tmp=fillArrayWithPyListDbl2(elt0,nbOfTuples1,nbOfCompo); - ret->alloc(nbOfTuples1,nbOfCompo); std::copy(tmp.begin(),tmp.end(),ret->getPointer()); - return ret.retn(); - } - else - throw INTERP_KERNEL::Exception(msg.c_str()); - } - else - {//DataArrayDouble.New([1.,3.,4.],3) - MEDCouplingAutoRefCountObjectPtr 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()); - return ret.retn(); - } - } - else - throw INTERP_KERNEL::Exception(msg.c_str()); - } - else - {// DataArrayDouble.New([1.,3.,4.]) - MEDCouplingAutoRefCountObjectPtr 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()); - return ret.retn(); - } - } - else if(PyInt_Check(elt0)) - { - int nbOfTuples1=PyInt_AS_LONG(elt0); - if(nbOfTuples1<0) - throw INTERP_KERNEL::Exception("DataArrayDouble::New : should be a positive set of allocated memory !"); - if(nbOfTuples) - { - if(!elt2) - { - if(PyInt_Check(nbOfTuples)) - {//DataArrayDouble.New(5,2) - 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(); - ret->alloc(nbOfTuples1,nbOfCompo); - return ret.retn(); - } - else - throw INTERP_KERNEL::Exception(msg.c_str()); - } - else - throw INTERP_KERNEL::Exception(msg.c_str()); - } - else - {//DataArrayDouble.New(5) - MEDCouplingAutoRefCountObjectPtr ret=DataArrayDouble::New(); - ret->alloc(nbOfTuples1,1); - return ret.retn(); - } - } -#ifdef WITH_NUMPY - else if(PyArray_Check(elt0) && nbOfTuples==NULL && elt2==NULL) - {//DataArrayDouble.New(numpyArray) - return BuildNewInstance(elt0,NPY_DOUBLE,&PyCallBackDataArrayDouble_RefType,"FLOAT64"); - } -#endif - else - throw INTERP_KERNEL::Exception(msg.c_str()); - throw INTERP_KERNEL::Exception(msg.c_str());//to make g++ happy + return DataArrayT_New(elt0,nbOfTuples,elt2); } DataArrayDouble(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *elt2=0) throw(INTERP_KERNEL::Exception) - { - return ParaMEDMEM_DataArrayDouble_New__SWIG_1(elt0,nbOfTuples,elt2); - } + { + return MEDCoupling_DataArrayDouble_New__SWIG_1(elt0,nbOfTuples,elt2); + } void pushBackValsSilent(PyObject *li) throw(INTERP_KERNEL::Exception) { @@ -783,6 +1045,22 @@ namespace ParaMEDMEM } } + 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(); @@ -790,7 +1068,7 @@ namespace ParaMEDMEM void setValues(PyObject *li, PyObject *nbOfTuples=0, PyObject *nbOfComp=0) throw(INTERP_KERNEL::Exception) { - const char *msg="ParaMEDMEM::DataArrayDouble::setValues : Available API are : \n-DataArrayDouble.setValues([1.,3.,4.])\n-DataArrayDouble.setValues([1.,3.,4.],3)\n-DataArrayDouble.setValues([1.,3.,4.,5.],2,2)\n-DataArrayDouble.setValues([(1.,1.7),(3.,3.7),(4.,4.7)])\n !"; + const char *msg="MEDCoupling::DataArrayDouble::setValues : Available API are : \n-DataArrayDouble.setValues([1.,3.,4.])\n-DataArrayDouble.setValues([1.,3.,4.],3)\n-DataArrayDouble.setValues([1.,3.,4.,5.],2,2)\n-DataArrayDouble.setValues([(1.,1.7),(3.,3.7),(4.,4.7)])\n !"; if(PyList_Check(li) || PyTuple_Check(li)) { if(nbOfTuples) @@ -836,8 +1114,8 @@ namespace ParaMEDMEM PyObject *getValues() const throw(INTERP_KERNEL::Exception) { - const double *vals=self->getConstPointer(); - return convertDblArrToPyList(vals,self->getNbOfElems()); + const double *vals(self->begin()); + return convertDblArrToPyList(vals,self->getNbOfElems()); } #ifdef WITH_NUMPY @@ -861,16 +1139,78 @@ namespace ParaMEDMEM PyObject *getValuesAsTuple() const throw(INTERP_KERNEL::Exception) { - const double *vals=self->getConstPointer(); - int nbOfComp=self->getNumberOfComponents(); - int nbOfTuples=self->getNumberOfTuples(); - return convertDblArrToPyListOfTuple(vals,nbOfComp,nbOfTuples); + const double *vals(self->begin()); + int nbOfComp(self->getNumberOfComponents()),nbOfTuples(self->getNumberOfTuples()); + return convertDblArrToPyListOfTuple(vals,nbOfComp,nbOfTuples); } + static PyObject *ComputeIntegralOfSeg2IntoTri3(PyObject *seg2, PyObject *tri3) throw(INTERP_KERNEL::Exception) + { + const char msg[]="Python wrap of DataArrayDouble::ComputeIntegralOfSeg2IntoTri3 : "; + double val,val2; + DataArrayDouble *a,*a2; + DataArrayDoubleTuple *aa,*aa2; + std::vector bb,bb2; + int sw; + const double *seg2Ptr(convertObjToPossibleCpp5_Safe(seg2,sw,val,a,aa,bb,msg,2,2,true)); + const double *tri3Ptr(convertObjToPossibleCpp5_Safe(tri3,sw,val2,a2,aa2,bb2,msg,3,2,true)); + // + double res0[3],res1; + DataArrayDouble::ComputeIntegralOfSeg2IntoTri3(seg2Ptr,tri3Ptr,res0,res1); + PyObject *ret(PyTuple_New(2)),*ret0(PyTuple_New(3)); + PyTuple_SetItem(ret0,0,PyFloat_FromDouble(res0[0])); + PyTuple_SetItem(ret0,1,PyFloat_FromDouble(res0[1])); + PyTuple_SetItem(ret0,2,PyFloat_FromDouble(res0[2])); + PyTuple_SetItem(ret,0,ret0); + PyTuple_SetItem(ret,1,PyFloat_FromDouble(res1)); + return ret; + } + + 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; - int res1=SWIG_ConvertPtr(li,&da,SWIGTYPE_p_ParaMEDMEM__DataArrayInt, 0 | 0 ); + int res1=SWIG_ConvertPtr(li,&da,SWIGTYPE_p_MEDCoupling__DataArrayInt, 0 | 0 ); if (!SWIG_IsOK(res1)) { int size; @@ -899,7 +1239,7 @@ namespace ParaMEDMEM DataArrayDouble *renumberR(PyObject *li) throw(INTERP_KERNEL::Exception) { void *da=0; - int res1=SWIG_ConvertPtr(li,&da,SWIGTYPE_p_ParaMEDMEM__DataArrayInt, 0 | 0 ); + int res1=SWIG_ConvertPtr(li,&da,SWIGTYPE_p_MEDCoupling__DataArrayInt, 0 | 0 ); if (!SWIG_IsOK(res1)) { int size; @@ -928,7 +1268,7 @@ namespace ParaMEDMEM DataArrayDouble *renumberAndReduce(PyObject *li, int newNbOfTuple) throw(INTERP_KERNEL::Exception) { void *da=0; - int res1=SWIG_ConvertPtr(li,&da,SWIGTYPE_p_ParaMEDMEM__DataArrayInt, 0 | 0 ); + int res1=SWIG_ConvertPtr(li,&da,SWIGTYPE_p_MEDCoupling__DataArrayInt, 0 | 0 ); if (!SWIG_IsOK(res1)) { int size; @@ -975,13 +1315,23 @@ namespace ParaMEDMEM 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; double r1=self->getMaxValue2(tmp); PyObject *ret=PyTuple_New(2); PyTuple_SetItem(ret,0,PyFloat_FromDouble(r1)); - PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(tmp),SWIGTYPE_p_ParaMEDMEM__DataArrayInt, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(tmp),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); return ret; } @@ -1001,32 +1351,40 @@ namespace ParaMEDMEM double r1=self->getMinValue2(tmp); PyObject *ret=PyTuple_New(2); PyTuple_SetItem(ret,0,PyFloat_FromDouble(r1)); - PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(tmp),SWIGTYPE_p_ParaMEDMEM__DataArrayInt, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(tmp),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); return ret; } PyObject *getMinMaxPerComponent() const throw(INTERP_KERNEL::Exception) { - int nbOfCompo=self->getNumberOfComponents(); - INTERP_KERNEL::AutoPtr tmp=new double[2*nbOfCompo]; + int nbOfCompo(self->getNumberOfComponents()); + INTERP_KERNEL::AutoPtr tmp(new double[2*nbOfCompo]); self->getMinMaxPerComponent(tmp); - PyObject *ret=convertDblArrToPyListOfTuple(tmp,2,nbOfCompo); + PyObject *ret=convertDblArrToPyListOfTuple(tmp,2,nbOfCompo); return ret; } + + PyObject *normMaxPerComponent() const throw(INTERP_KERNEL::Exception) + { + int nbOfCompo(self->getNumberOfComponents()); + INTERP_KERNEL::AutoPtr tmp(new double[nbOfCompo]); + self->normMaxPerComponent(tmp); + return convertDblArrToPyList(tmp,nbOfCompo); + } PyObject *accumulate() const throw(INTERP_KERNEL::Exception) { int sz=self->getNumberOfComponents(); INTERP_KERNEL::AutoPtr tmp=new double[sz]; self->accumulate(tmp); - return convertDblArrToPyList(tmp,sz); + return convertDblArrToPyList(tmp,sz); } DataArrayDouble *accumulatePerChunck(PyObject *indexArr) const throw(INTERP_KERNEL::Exception) { int sw,sz,val; std::vector val2; - const int *bg=convertObjToPossibleCpp1_Safe(indexArr,sw,sz,val,val2); + const int *bg=convertIntStarLikePyObjToCppIntStar(indexArr,sw,sz,val,val2); return self->accumulatePerChunck(bg,bg+sz); } @@ -1035,8 +1393,8 @@ namespace ParaMEDMEM DataArrayInt *comm, *commIndex; self->findCommonTuples(prec,limitNodeId,comm,commIndex); PyObject *res = PyList_New(2); - PyList_SetItem(res,0,SWIG_NewPointerObj(SWIG_as_voidptr(comm),SWIGTYPE_p_ParaMEDMEM__DataArrayInt, SWIG_POINTER_OWN | 0 )); - PyList_SetItem(res,1,SWIG_NewPointerObj(SWIG_as_voidptr(commIndex),SWIGTYPE_p_ParaMEDMEM__DataArrayInt, SWIG_POINTER_OWN | 0 )); + PyList_SetItem(res,0,SWIG_NewPointerObj(SWIG_as_voidptr(comm),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); + PyList_SetItem(res,1,SWIG_NewPointerObj(SWIG_as_voidptr(commIndex),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); return res; } @@ -1063,26 +1421,36 @@ namespace ParaMEDMEM 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(); INTERP_KERNEL::AutoPtr tmp=new double[sz]; self->getTuple(tupleId,tmp); - return convertDblArrToPyList(tmp,sz); + return convertDblArrToPyList(tmp,sz); } static DataArrayDouble *Aggregate(PyObject *li) throw(INTERP_KERNEL::Exception) { std::vector tmp; - convertFromPyObjVectorOfObj(li,SWIGTYPE_p_ParaMEDMEM__DataArrayDouble,"DataArrayDouble",tmp); + convertFromPyObjVectorOfObj(li,SWIGTYPE_p_MEDCoupling__DataArrayDouble,"DataArrayDouble",tmp); return DataArrayDouble::Aggregate(tmp); } static DataArrayDouble *Meld(PyObject *li) throw(INTERP_KERNEL::Exception) { std::vector tmp; - convertFromPyObjVectorOfObj(li,SWIGTYPE_p_ParaMEDMEM__DataArrayDouble,"DataArrayDouble",tmp); + convertFromPyObjVectorOfObj(li,SWIGTYPE_p_MEDCoupling__DataArrayDouble,"DataArrayDouble",tmp); return DataArrayDouble::Meld(tmp); } @@ -1096,12 +1464,12 @@ namespace ParaMEDMEM int nbComp=self->getNumberOfComponents(),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,DeallocType::CPP_DEALLOC,nbTuples,nbComp); DataArrayInt *c=0,*cI=0; self->computeTupleIdsNearTuples(inpu,eps,c,cI); PyObject *ret=PyTuple_New(2); - PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(c),SWIGTYPE_p_ParaMEDMEM__DataArrayInt, SWIG_POINTER_OWN | 0 )); - PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(cI),SWIGTYPE_p_ParaMEDMEM__DataArrayInt, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(c),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(cI),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); return ret; } @@ -1113,460 +1481,18 @@ namespace ParaMEDMEM PyObject *ret0Py=ret0?Py_True:Py_False; Py_XINCREF(ret0Py); PyTuple_SetItem(ret,0,ret0Py); - PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(ret1),SWIGTYPE_p_ParaMEDMEM__DataArrayInt, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(ret1),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); return ret; } PyObject *__getitem__(PyObject *obj) throw(INTERP_KERNEL::Exception) { - const char msg[]="Unexpected situation in DataArrayDouble::__getitem__ !"; - const char msg2[]="DataArrayDouble::__getitem__ : Mismatch of slice values in 2nd parameter (components) !"; - self->checkAllocated(); - int nbOfTuples=self->getNumberOfTuples(); - int nbOfComponents=self->getNumberOfComponents(); - int it1,ic1; - std::vector vt1,vc1; - std::pair > pt1,pc1; - DataArrayInt *dt1=0,*dc1=0; - int sw; - convertObjToPossibleCpp3(obj,nbOfTuples,nbOfComponents,sw,it1,ic1,vt1,vc1,pt1,pc1,dt1,dc1); - MEDCouplingAutoRefCountObjectPtr ret; - switch(sw) - { - case 1: - if(nbOfComponents==1) - return PyFloat_FromDouble(self->getIJSafe(it1,0)); - return SWIG_NewPointerObj(SWIG_as_voidptr(self->selectByTupleIdSafe(&it1,&it1+1)),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, SWIG_POINTER_OWN | 0 ); - case 2: - return SWIG_NewPointerObj(SWIG_as_voidptr(self->selectByTupleIdSafe(&vt1[0],&vt1[0]+vt1.size())),SWIGTYPE_p_ParaMEDMEM__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_ParaMEDMEM__DataArrayDouble, SWIG_POINTER_OWN | 0 ); - case 4: - return SWIG_NewPointerObj(SWIG_as_voidptr(self->selectByTupleIdSafe(dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems())),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, SWIG_POINTER_OWN | 0 ); - case 5: - return PyFloat_FromDouble(self->getIJSafe(it1,ic1)); - case 6: - { - ret=self->selectByTupleIdSafe(&vt1[0],&vt1[0]+vt1.size()); - std::vector v2(1,ic1); - return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(v2)),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, SWIG_POINTER_OWN | 0 ); - } - case 7: - { - ret=self->selectByTupleId2(pt1.first,pt1.second.first,pt1.second.second); - std::vector v2(1,ic1); - return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(v2)),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, SWIG_POINTER_OWN | 0 ); - } - case 8: - { - ret=self->selectByTupleIdSafe(dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems()); - std::vector v2(1,ic1); - return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(v2)),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, SWIG_POINTER_OWN | 0 ); - } - case 9: - { - ret=self->selectByTupleIdSafe(&it1,&it1+1); - return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(vc1)),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, SWIG_POINTER_OWN | 0 ); - } - case 10: - { - ret=self->selectByTupleIdSafe(&vt1[0],&vt1[0]+vt1.size()); - return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(vc1)),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, SWIG_POINTER_OWN | 0 ); - } - case 11: - { - ret=self->selectByTupleId2(pt1.first,pt1.second.first,pt1.second.second); - return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(vc1)),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, SWIG_POINTER_OWN | 0 ); - } - case 12: - { - ret=self->selectByTupleIdSafe(dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems()); - return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(vc1)),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, SWIG_POINTER_OWN | 0 ); - } - case 13: - { - ret=self->selectByTupleIdSafe(&it1,&it1+1); - int nbOfComp=DataArray::GetNumberOfItemGivenBESRelative(pc1.first,pc1.second.first,pc1.second.second,msg2); - std::vector v2(nbOfComp); - for(int i=0;ikeepSelectedComponents(v2)),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, SWIG_POINTER_OWN | 0 ); - } - case 14: - { - ret=self->selectByTupleIdSafe(&vt1[0],&vt1[0]+vt1.size()); - int nbOfComp=DataArray::GetNumberOfItemGivenBESRelative(pc1.first,pc1.second.first,pc1.second.second,msg2); - std::vector v2(nbOfComp); - for(int i=0;ikeepSelectedComponents(v2)),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, SWIG_POINTER_OWN | 0 ); - } - case 15: - { - ret=self->selectByTupleId2(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;ikeepSelectedComponents(v2)),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, SWIG_POINTER_OWN | 0 ); - } - case 16: - { - ret=self->selectByTupleIdSafe(dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems()); - int nbOfComp=DataArray::GetNumberOfItemGivenBESRelative(pc1.first,pc1.second.first,pc1.second.second,msg2); - std::vector v2(nbOfComp); - for(int i=0;ikeepSelectedComponents(v2)),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, SWIG_POINTER_OWN | 0 ); - } - default: - throw INTERP_KERNEL::Exception(msg); - } + return DataArrayT__getitem(self,obj); } DataArrayDouble *__setitem__(PyObject *obj, PyObject *value) throw(INTERP_KERNEL::Exception) { - self->checkAllocated(); - const char msg[]="Unexpected situation in DataArrayDouble::__setitem__ !"; - int nbOfTuples=self->getNumberOfTuples(); - int nbOfComponents=self->getNumberOfComponents(); - int sw1,sw2; - double i1; - std::vector v1; - DataArrayDouble *d1=0; - convertObjToPossibleCpp4(value,sw1,i1,v1,d1); - int it1,ic1; - std::vector vt1,vc1; - std::pair > pt1,pc1; - DataArrayInt *dt1=0,*dc1=0; - convertObjToPossibleCpp3(obj,nbOfTuples,nbOfComponents,sw2,it1,ic1,vt1,vc1,pt1,pc1,dt1,dc1); - MEDCouplingAutoRefCountObjectPtr tmp; - switch(sw2) - { - case 1: - { - switch(sw1) - { - case 1: - self->setPartOfValuesSimple1(i1,it1,it1+1,1,0,nbOfComponents,1); - return self; - case 2: - tmp=DataArrayDouble::New(); - tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size()); - self->setPartOfValues1(tmp,it1,it1+1,1,0,nbOfComponents,1,false); - return self; - case 3: - self->setPartOfValues1(d1,it1,it1+1,1,0,nbOfComponents,1); - return self; - default: - throw INTERP_KERNEL::Exception(msg); - } - break; - } - case 2: - { - switch(sw1) - { - case 1: - self->setPartOfValuesSimple3(i1,&vt1[0],&vt1[0]+vt1.size(),0,nbOfComponents,1); - return self; - case 2: - tmp=DataArrayDouble::New(); - tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size()); - self->setPartOfValues3(tmp,&vt1[0],&vt1[0]+vt1.size(),0,nbOfComponents,1,false); - return self; - case 3: - self->setPartOfValues3(d1,&vt1[0],&vt1[0]+vt1.size(),0,nbOfComponents,1); - return self; - default: - throw INTERP_KERNEL::Exception(msg); - } - break; - } - case 3: - { - switch(sw1) - { - case 1: - self->setPartOfValuesSimple1(i1,pt1.first,pt1.second.first,pt1.second.second,0,nbOfComponents,1); - return self; - case 2: - tmp=DataArrayDouble::New(); - tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size()); - self->setPartOfValues1(tmp,pt1.first,pt1.second.first,pt1.second.second,0,nbOfComponents,1,false); - return self; - case 3: - self->setPartOfValues1(d1,pt1.first,pt1.second.first,pt1.second.second,0,nbOfComponents,1); - return self; - default: - throw INTERP_KERNEL::Exception(msg); - } - break; - } - case 4: - { - switch(sw1) - { - case 1: - self->setPartOfValuesSimple3(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),0,nbOfComponents,1); - return self; - case 2: - tmp=DataArrayDouble::New(); - tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size()); - self->setPartOfValues3(tmp,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),0,nbOfComponents,1,false); - return self; - case 3: - self->setPartOfValues3(d1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),0,nbOfComponents,1); - return self; - default: - throw INTERP_KERNEL::Exception(msg); - } - break; - } - case 5: - { - switch(sw1) - { - case 1: - self->setPartOfValuesSimple1(i1,it1,it1+1,1,ic1,ic1+1,1); - return self; - case 2: - tmp=DataArrayDouble::New(); - tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size()); - self->setPartOfValues1(tmp,it1,it1+1,1,ic1,ic1+1,1,false); - return self; - case 3: - self->setPartOfValues1(d1,it1,it1+1,1,ic1,ic1+1,1); - return self; - default: - throw INTERP_KERNEL::Exception(msg); - } - break; - } - case 6: - { - switch(sw1) - { - case 1: - self->setPartOfValuesSimple3(i1,&vt1[0],&vt1[0]+vt1.size(),ic1,ic1+1,1); - return self; - case 2: - tmp=DataArrayDouble::New(); - tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size()); - self->setPartOfValues3(tmp,&vt1[0],&vt1[0]+vt1.size(),ic1,ic1+1,1,false); - return self; - case 3: - self->setPartOfValues3(d1,&vt1[0],&vt1[0]+vt1.size(),ic1,ic1+1,1); - return self; - default: - throw INTERP_KERNEL::Exception(msg); - } - break; - } - case 7: - { - switch(sw1) - { - case 1: - self->setPartOfValuesSimple1(i1,pt1.first,pt1.second.first,pt1.second.second,ic1,ic1+1,1); - return self; - case 2: - tmp=DataArrayDouble::New(); - tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size()); - self->setPartOfValues1(tmp,pt1.first,pt1.second.first,pt1.second.second,ic1,ic1+1,1,false); - return self; - case 3: - self->setPartOfValues1(d1,pt1.first,pt1.second.first,pt1.second.second,ic1,ic1+1,1); - return self; - default: - throw INTERP_KERNEL::Exception(msg); - } - break; - } - case 8: - { - switch(sw1) - { - case 1: - self->setPartOfValuesSimple3(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),ic1,ic1+1,1); - return self; - case 2: - tmp=DataArrayDouble::New(); - tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size()); - self->setPartOfValues3(tmp,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),ic1,ic1+1,1,false); - return self; - case 3: - self->setPartOfValues3(d1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),ic1,ic1+1,1); - return self; - default: - throw INTERP_KERNEL::Exception(msg); - } - break; - } - case 9: - { - switch(sw1) - { - case 1: - self->setPartOfValuesSimple2(i1,&it1,&it1+1,&vc1[0],&vc1[0]+vc1.size()); - return self; - case 2: - tmp=DataArrayDouble::New(); - tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size()); - self->setPartOfValues2(tmp,&it1,&it1+1,&vc1[0],&vc1[0]+vc1.size(),false); - return self; - case 3: - self->setPartOfValues2(d1,&it1,&it1+1,&vc1[0],&vc1[0]+vc1.size()); - return self; - default: - throw INTERP_KERNEL::Exception(msg); - } - break; - } - case 10: - { - switch(sw1) - { - case 1: - self->setPartOfValuesSimple2(i1,&vt1[0],&vt1[0]+vt1.size(),&vc1[0],&vc1[0]+vc1.size()); - return self; - case 2: - tmp=DataArrayDouble::New(); - tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size()); - self->setPartOfValues2(tmp,&vt1[0],&vt1[0]+vt1.size(),&vc1[0],&vc1[0]+vc1.size(),false); - return self; - case 3: - self->setPartOfValues2(d1,&vt1[0],&vt1[0]+vt1.size(),&vc1[0],&vc1[0]+vc1.size()); - return self; - default: - throw INTERP_KERNEL::Exception(msg); - } - break; - } - case 11: - { - switch(sw1) - { - case 1: - self->setPartOfValuesSimple4(i1,pt1.first,pt1.second.first,pt1.second.second,&vc1[0],&vc1[0]+vc1.size()); - return self; - case 2: - tmp=DataArrayDouble::New(); - tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size()); - self->setPartOfValues4(tmp,pt1.first,pt1.second.first,pt1.second.second,&vc1[0],&vc1[0]+vc1.size(),false); - return self; - case 3: - self->setPartOfValues4(d1,pt1.first,pt1.second.first,pt1.second.second,&vc1[0],&vc1[0]+vc1.size()); - return self; - default: - throw INTERP_KERNEL::Exception(msg); - } - break; - } - case 12: - { - switch(sw1) - { - case 1: - self->setPartOfValuesSimple2(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),&vc1[0],&vc1[0]+vc1.size()); - return self; - case 2: - tmp=DataArrayDouble::New(); - tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size()); - self->setPartOfValues2(tmp,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),&vc1[0],&vc1[0]+vc1.size(),false); - return self; - case 3: - self->setPartOfValues2(d1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),&vc1[0],&vc1[0]+vc1.size()); - return self; - default: - throw INTERP_KERNEL::Exception(msg); - } - break; - } - case 13: - { - switch(sw1) - { - case 1: - self->setPartOfValuesSimple1(i1,it1,it1+1,1,pc1.first,pc1.second.first,pc1.second.second); - return self; - case 2: - tmp=DataArrayDouble::New(); - tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size()); - self->setPartOfValues1(tmp,it1,it1+1,1,pc1.first,pc1.second.first,pc1.second.second,false); - return self; - case 3: - self->setPartOfValues1(d1,it1,it1+1,1,pc1.first,pc1.second.first,pc1.second.second); - return self; - default: - throw INTERP_KERNEL::Exception(msg); - } - break; - } - case 14: - { - switch(sw1) - { - case 1: - self->setPartOfValuesSimple3(i1,&vt1[0],&vt1[0]+vt1.size(),pc1.first,pc1.second.first,pc1.second.second); - return self; - case 2: - tmp=DataArrayDouble::New(); - tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size()); - self->setPartOfValues3(tmp,&vt1[0],&vt1[0]+vt1.size(),pc1.first,pc1.second.first,pc1.second.second,false); - return self; - case 3: - self->setPartOfValues3(d1,&vt1[0],&vt1[0]+vt1.size(),pc1.first,pc1.second.first,pc1.second.second); - return self; - default: - throw INTERP_KERNEL::Exception(msg); - } - break; - } - case 15: - { - switch(sw1) - { - case 1: - self->setPartOfValuesSimple1(i1,pt1.first,pt1.second.first,pt1.second.second,pc1.first,pc1.second.first,pc1.second.second); - return self; - case 2: - tmp=DataArrayDouble::New(); - tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size()); - self->setPartOfValues1(tmp,pt1.first,pt1.second.first,pt1.second.second,pc1.first,pc1.second.first,pc1.second.second,false); - return self; - case 3: - self->setPartOfValues1(d1,pt1.first,pt1.second.first,pt1.second.second,pc1.first,pc1.second.first,pc1.second.second); - return self; - default: - throw INTERP_KERNEL::Exception(msg); - } - break; - } - case 16: - { - switch(sw1) - { - case 1: - self->setPartOfValuesSimple3(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),pc1.first,pc1.second.first,pc1.second.second); - return self; - case 2: - tmp=DataArrayDouble::New(); - tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size()); - self->setPartOfValues3(tmp,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),pc1.first,pc1.second.first,pc1.second.second,false); - return self; - case 3: - self->setPartOfValues3(d1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),pc1.first,pc1.second.first,pc1.second.second); - return self; - default: - throw INTERP_KERNEL::Exception(msg); - } - break; - } - default: - throw INTERP_KERNEL::Exception(msg); - } - return self; + return DataArrayT__setitem__(self,obj,value); } DataArrayDouble *__neg__() const throw(INTERP_KERNEL::Exception) @@ -1585,122 +1511,85 @@ namespace ParaMEDMEM // #ifndef WITHOUT_AUTOFIELD void *argp; - if(SWIG_IsOK(SWIG_ConvertPtr(obj,&argp,SWIGTYPE_p_ParaMEDMEM__MEDCouplingFieldDouble,0|0))) + if(SWIG_IsOK(SWIG_ConvertPtr(obj,&argp,SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble,0|0))) { - MEDCouplingFieldDouble *other=reinterpret_cast< ParaMEDMEM::MEDCouplingFieldDouble * >(argp); + MEDCouplingFieldDouble *other=reinterpret_cast< MEDCoupling::MEDCouplingFieldDouble * >(argp); if(other) { - PyObject *tmp=SWIG_NewPointerObj(SWIG_as_voidptr(self),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, 0 | 0 ); - MEDCouplingAutoRefCountObjectPtr ret=ParaMEDMEM_MEDCouplingFieldDouble___radd__Impl(other,tmp); + PyObject *tmp=SWIG_NewPointerObj(SWIG_as_voidptr(self),SWIGTYPE_p_MEDCoupling__DataArrayDouble, 0 | 0 ); + MCAuto ret=MEDCoupling_MEDCouplingFieldDouble___radd__Impl(other,tmp); Py_XDECREF(tmp); - return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_ParaMEDMEM__MEDCouplingFieldDouble, SWIG_POINTER_OWN | 0 ); + return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble, SWIG_POINTER_OWN | 0 ); } else throw INTERP_KERNEL::Exception(msg); } #endif // - convertObjToPossibleCpp5(obj,sw,val,a,aa,bb); + convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb); switch(sw) { case 1: { - MEDCouplingAutoRefCountObjectPtr ret=self->deepCpy(); + MCAuto ret=self->deepCopy(); ret->applyLin(1.,val); - return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, SWIG_POINTER_OWN | 0 ); + return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 ); } case 2: { - return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Add(self,a)),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, SWIG_POINTER_OWN | 0 ); - } - case 3: - { - MEDCouplingAutoRefCountObjectPtr aaa=aa->buildDADouble(1,self->getNumberOfComponents()); - return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Add(self,aaa)),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, SWIG_POINTER_OWN | 0 ); - } - case 4: - { - MEDCouplingAutoRefCountObjectPtr 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_ParaMEDMEM__DataArrayDouble, SWIG_POINTER_OWN | 0 ); - } - default: - throw INTERP_KERNEL::Exception(msg); - } - } - - DataArrayDouble *__radd__(PyObject *obj) throw(INTERP_KERNEL::Exception) - { - const char msg[]="Unexpected situation in __radd__ !"; - double val; - DataArrayDouble *a; - DataArrayDoubleTuple *aa; - std::vector bb; - int sw; - convertObjToPossibleCpp5(obj,sw,val,a,aa,bb); - switch(sw) - { - case 1: - { - MEDCouplingAutoRefCountObjectPtr ret=self->deepCpy(); - ret->applyLin(1.,val); - return ret.retn(); + return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Add(self,a)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 ); } case 3: { - MEDCouplingAutoRefCountObjectPtr aaa=aa->buildDADouble(1,self->getNumberOfComponents()); - return DataArrayDouble::Add(self,aaa); + 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()); - return DataArrayDouble::Add(self,aaa); + MCAuto aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::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: throw INTERP_KERNEL::Exception(msg); } } - - PyObject *___iadd___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception) + + DataArrayDouble *__radd__(PyObject *obj) throw(INTERP_KERNEL::Exception) { - const char msg[]="Unexpected situation in __iadd__ !"; + const char msg[]="Unexpected situation in __radd__ !"; double val; DataArrayDouble *a; DataArrayDoubleTuple *aa; std::vector bb; int sw; - convertObjToPossibleCpp5(obj,sw,val,a,aa,bb); + convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb); switch(sw) { case 1: { - self->applyLin(1.,val); - Py_XINCREF(trueSelf); - return trueSelf; - } - case 2: - { - self->addEqual(a); - Py_XINCREF(trueSelf); - return trueSelf; + MCAuto ret=self->deepCopy(); + ret->applyLin(1.,val); + return ret.retn(); } case 3: { - MEDCouplingAutoRefCountObjectPtr aaa=aa->buildDADouble(1,self->getNumberOfComponents()); - self->addEqual(aaa); - Py_XINCREF(trueSelf); - return trueSelf; + 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()); - self->addEqual(aaa); - Py_XINCREF(trueSelf); - return trueSelf; + MCAuto aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,(int)bb.size()); + return DataArrayDouble::Add(self,aaa); } default: throw INTERP_KERNEL::Exception(msg); } } + + PyObject *___iadd___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception) + { + return DataArrayT_iadd(trueSelf,obj,self); + } PyObject *__sub__(PyObject *obj) throw(INTERP_KERNEL::Exception) { @@ -1713,43 +1602,43 @@ namespace ParaMEDMEM // #ifndef WITHOUT_AUTOFIELD void *argp; - if(SWIG_IsOK(SWIG_ConvertPtr(obj,&argp,SWIGTYPE_p_ParaMEDMEM__MEDCouplingFieldDouble,0|0))) + if(SWIG_IsOK(SWIG_ConvertPtr(obj,&argp,SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble,0|0))) { - MEDCouplingFieldDouble *other=reinterpret_cast< ParaMEDMEM::MEDCouplingFieldDouble * >(argp); + MEDCouplingFieldDouble *other=reinterpret_cast< MEDCoupling::MEDCouplingFieldDouble * >(argp); if(other) { - PyObject *tmp=SWIG_NewPointerObj(SWIG_as_voidptr(self),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, 0 | 0 ); - MEDCouplingAutoRefCountObjectPtr ret=ParaMEDMEM_MEDCouplingFieldDouble___rsub__Impl(other,tmp); + PyObject *tmp=SWIG_NewPointerObj(SWIG_as_voidptr(self),SWIGTYPE_p_MEDCoupling__DataArrayDouble, 0 | 0 ); + MCAuto ret=MEDCoupling_MEDCouplingFieldDouble___rsub__Impl(other,tmp); Py_XDECREF(tmp); - return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_ParaMEDMEM__MEDCouplingFieldDouble, SWIG_POINTER_OWN | 0 ); + return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble, SWIG_POINTER_OWN | 0 ); } else throw INTERP_KERNEL::Exception(msg); } #endif // - convertObjToPossibleCpp5(obj,sw,val,a,aa,bb); + convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb); switch(sw) { case 1: { - MEDCouplingAutoRefCountObjectPtr ret=self->deepCpy(); + MCAuto ret=self->deepCopy(); ret->applyLin(1.,-val); - return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, SWIG_POINTER_OWN | 0 ); + return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 ); } case 2: { - return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Substract(self,a)),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, SWIG_POINTER_OWN | 0 ); + return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Substract(self,a)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 ); } case 3: { - MEDCouplingAutoRefCountObjectPtr aaa=aa->buildDADouble(1,self->getNumberOfComponents()); - return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Substract(self,aaa)),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, SWIG_POINTER_OWN | 0 ); + 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()); - return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Substract(self,aaa)),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, SWIG_POINTER_OWN | 0 ); + MCAuto aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::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: throw INTERP_KERNEL::Exception(msg); @@ -1764,23 +1653,23 @@ namespace ParaMEDMEM DataArrayDoubleTuple *aa; std::vector bb; int sw; - convertObjToPossibleCpp5(obj,sw,val,a,aa,bb); + convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb); switch(sw) { 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,DeallocType::CPP_DEALLOC,1,(int)bb.size()); return DataArrayDouble::Substract(aaa,self); } default: @@ -1790,44 +1679,7 @@ namespace ParaMEDMEM PyObject *___isub___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception) { - const char msg[]="Unexpected situation in __isub__ !"; - double val; - DataArrayDouble *a; - DataArrayDoubleTuple *aa; - std::vector bb; - int sw; - convertObjToPossibleCpp5(obj,sw,val,a,aa,bb); - switch(sw) - { - case 1: - { - self->applyLin(1,-val); - Py_XINCREF(trueSelf); - return trueSelf; - } - case 2: - { - self->substractEqual(a); - Py_XINCREF(trueSelf); - return trueSelf; - } - case 3: - { - MEDCouplingAutoRefCountObjectPtr 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()); - self->substractEqual(aaa); - Py_XINCREF(trueSelf); - return trueSelf; - } - default: - throw INTERP_KERNEL::Exception(msg); - } + return DataArrayT_isub(trueSelf,obj,self); } PyObject *__mul__(PyObject *obj) throw(INTERP_KERNEL::Exception) @@ -1841,43 +1693,43 @@ namespace ParaMEDMEM // #ifndef WITHOUT_AUTOFIELD void *argp; - if(SWIG_IsOK(SWIG_ConvertPtr(obj,&argp,SWIGTYPE_p_ParaMEDMEM__MEDCouplingFieldDouble,0|0))) + if(SWIG_IsOK(SWIG_ConvertPtr(obj,&argp,SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble,0|0))) { - MEDCouplingFieldDouble *other=reinterpret_cast< ParaMEDMEM::MEDCouplingFieldDouble * >(argp); + MEDCouplingFieldDouble *other=reinterpret_cast< MEDCoupling::MEDCouplingFieldDouble * >(argp); if(other) { - PyObject *tmp=SWIG_NewPointerObj(SWIG_as_voidptr(self),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, 0 | 0 ); - MEDCouplingAutoRefCountObjectPtr ret=ParaMEDMEM_MEDCouplingFieldDouble___rmul__Impl(other,tmp); + PyObject *tmp=SWIG_NewPointerObj(SWIG_as_voidptr(self),SWIGTYPE_p_MEDCoupling__DataArrayDouble, 0 | 0 ); + MCAuto ret=MEDCoupling_MEDCouplingFieldDouble___rmul__Impl(other,tmp); Py_XDECREF(tmp); - return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_ParaMEDMEM__MEDCouplingFieldDouble, SWIG_POINTER_OWN | 0 ); + return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble, SWIG_POINTER_OWN | 0 ); } else throw INTERP_KERNEL::Exception(msg); } #endif // - convertObjToPossibleCpp5(obj,sw,val,a,aa,bb); + convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb); switch(sw) { case 1: { - MEDCouplingAutoRefCountObjectPtr ret=self->deepCpy(); + MCAuto ret=self->deepCopy(); ret->applyLin(val,0.); - return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, SWIG_POINTER_OWN | 0 ); + return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 ); } case 2: { - return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Multiply(self,a)),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, SWIG_POINTER_OWN | 0 ); + return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Multiply(self,a)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 ); } case 3: { - MEDCouplingAutoRefCountObjectPtr aaa=aa->buildDADouble(1,self->getNumberOfComponents()); - return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Multiply(self,aaa)),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, SWIG_POINTER_OWN | 0 ); + 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()); - return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Multiply(self,aaa)),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, SWIG_POINTER_OWN | 0 ); + MCAuto aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::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: throw INTERP_KERNEL::Exception(msg); @@ -1886,76 +1738,12 @@ namespace ParaMEDMEM 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; - convertObjToPossibleCpp5(obj,sw,val,a,aa,bb); - switch(sw) - { - case 1: - { - MEDCouplingAutoRefCountObjectPtr ret=self->deepCpy(); - ret->applyLin(val,0.); - return ret.retn(); - } - case 3: - { - MEDCouplingAutoRefCountObjectPtr 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()); - 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) { - const char msg[]="Unexpected situation in __imul__ !"; - double val; - DataArrayDouble *a; - DataArrayDoubleTuple *aa; - std::vector bb; - int sw; - convertObjToPossibleCpp5(obj,sw,val,a,aa,bb); - switch(sw) - { - case 1: - { - self->applyLin(val,0.); - Py_XINCREF(trueSelf); - return trueSelf; - } - case 2: - { - self->multiplyEqual(a); - Py_XINCREF(trueSelf); - return trueSelf; - } - case 3: - { - MEDCouplingAutoRefCountObjectPtr 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()); - self->multiplyEqual(aaa); - Py_XINCREF(trueSelf); - return trueSelf; - } - default: - throw INTERP_KERNEL::Exception(msg); - } + return DataArrayT_imul(trueSelf,obj,self); } PyObject *__div__(PyObject *obj) throw(INTERP_KERNEL::Exception) @@ -1969,45 +1757,45 @@ namespace ParaMEDMEM // #ifndef WITHOUT_AUTOFIELD void *argp; - if(SWIG_IsOK(SWIG_ConvertPtr(obj,&argp,SWIGTYPE_p_ParaMEDMEM__MEDCouplingFieldDouble,0|0))) + if(SWIG_IsOK(SWIG_ConvertPtr(obj,&argp,SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble,0|0))) { - MEDCouplingFieldDouble *other=reinterpret_cast< ParaMEDMEM::MEDCouplingFieldDouble * >(argp); + MEDCouplingFieldDouble *other=reinterpret_cast< MEDCoupling::MEDCouplingFieldDouble * >(argp); if(other) { - PyObject *tmp=SWIG_NewPointerObj(SWIG_as_voidptr(self),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, 0 | 0 ); - MEDCouplingAutoRefCountObjectPtr ret=ParaMEDMEM_MEDCouplingFieldDouble___rdiv__Impl(other,tmp); + PyObject *tmp=SWIG_NewPointerObj(SWIG_as_voidptr(self),SWIGTYPE_p_MEDCoupling__DataArrayDouble, 0 | 0 ); + MCAuto ret=MEDCoupling_MEDCouplingFieldDouble___rdiv__Impl(other,tmp); Py_XDECREF(tmp); - return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_ParaMEDMEM__MEDCouplingFieldDouble, SWIG_POINTER_OWN | 0 ); + return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble, SWIG_POINTER_OWN | 0 ); } else throw INTERP_KERNEL::Exception(msg); } #endif // - convertObjToPossibleCpp5(obj,sw,val,a,aa,bb); + convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb); switch(sw) { case 1: { 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_ParaMEDMEM__DataArrayDouble, SWIG_POINTER_OWN | 0 ); + return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 ); } case 2: { - return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Divide(self,a)),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, SWIG_POINTER_OWN | 0 ); + return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Divide(self,a)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 ); } case 3: { - MEDCouplingAutoRefCountObjectPtr aaa=aa->buildDADouble(1,self->getNumberOfComponents()); - return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Divide(self,aaa)),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, SWIG_POINTER_OWN | 0 ); + 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()); - return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Divide(self,aaa)),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, SWIG_POINTER_OWN | 0 ); + MCAuto aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::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: throw INTERP_KERNEL::Exception(msg); @@ -2022,23 +1810,23 @@ namespace ParaMEDMEM DataArrayDoubleTuple *aa; std::vector bb; int sw; - convertObjToPossibleCpp5(obj,sw,val,a,aa,bb); + convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb); switch(sw) { 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,DeallocType::CPP_DEALLOC,1,(int)bb.size()); return DataArrayDouble::Divide(aaa,self); } default: @@ -2048,46 +1836,7 @@ namespace ParaMEDMEM PyObject *___idiv___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception) { - const char msg[]="Unexpected situation in __idiv__ !"; - double val; - DataArrayDouble *a; - DataArrayDoubleTuple *aa; - std::vector bb; - int sw; - convertObjToPossibleCpp5(obj,sw,val,a,aa,bb); - switch(sw) - { - case 1: - { - if(val==0.) - throw INTERP_KERNEL::Exception("DataArrayDouble::__div__ : trying to divide by zero !"); - self->applyLin(1./val,0.); - Py_XINCREF(trueSelf); - return trueSelf; - } - case 2: - { - self->divideEqual(a); - Py_XINCREF(trueSelf); - return trueSelf; - } - case 3: - { - MEDCouplingAutoRefCountObjectPtr 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()); - self->divideEqual(aaa); - Py_XINCREF(trueSelf); - return trueSelf; - } - default: - throw INTERP_KERNEL::Exception(msg); - } + return DataArrayT_idiv(trueSelf,obj,self); } DataArrayDouble *__pow__(PyObject *obj) throw(INTERP_KERNEL::Exception) @@ -2098,12 +1847,12 @@ namespace ParaMEDMEM DataArrayDoubleTuple *aa; std::vector bb; int sw; - convertObjToPossibleCpp5(obj,sw,val,a,aa,bb); + convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb); switch(sw) { case 1: { - MEDCouplingAutoRefCountObjectPtr ret=self->deepCpy(); + MCAuto ret=self->deepCopy(); ret->applyPow(val); return ret.retn(); } @@ -2113,12 +1862,12 @@ namespace ParaMEDMEM } 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,DeallocType::CPP_DEALLOC,1,(int)bb.size()); return DataArrayDouble::Pow(self,aaa); } default: @@ -2134,23 +1883,23 @@ namespace ParaMEDMEM DataArrayDoubleTuple *aa; std::vector bb; int sw; - convertObjToPossibleCpp5(obj,sw,val,a,aa,bb); + convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb); switch(sw) { 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,DeallocType::CPP_DEALLOC,1,(int)bb.size()); return DataArrayDouble::Pow(aaa,self); } default: @@ -2166,7 +1915,7 @@ namespace ParaMEDMEM DataArrayDoubleTuple *aa; std::vector bb; int sw; - convertObjToPossibleCpp5(obj,sw,val,a,aa,bb); + convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb); switch(sw) { case 1: @@ -2183,14 +1932,14 @@ namespace ParaMEDMEM } 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,DeallocType::CPP_DEALLOC,1,(int)bb.size()); self->powEqual(aaa); Py_XINCREF(trueSelf); return trueSelf; @@ -2206,8 +1955,8 @@ namespace ParaMEDMEM // self->computeTupleIdsNearTuples(other,eps,c,cI); PyObject *ret=PyTuple_New(2); - PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(c),SWIGTYPE_p_ParaMEDMEM__DataArrayInt, SWIG_POINTER_OWN | 0 )); - PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(cI),SWIGTYPE_p_ParaMEDMEM__DataArrayInt, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(c),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(cI),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); return ret; } @@ -2216,62 +1965,9 @@ namespace ParaMEDMEM DataArrayInt *ret1=0; DataArrayDouble *ret0=self->maxPerTupleWithCompoId(ret1); PyObject *ret=PyTuple_New(2); - PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(ret0),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, SWIG_POINTER_OWN | 0 )); - PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(ret1),SWIGTYPE_p_ParaMEDMEM__DataArrayInt, SWIG_POINTER_OWN | 0 )); - return ret; - } - - // 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; - } - - 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(ParaMEDMEM_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); - } + PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(ret0),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(ret1),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); 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 } } }; @@ -2289,7 +1985,7 @@ namespace ParaMEDMEM { DataArrayDoubleTuple *ret=self->nextt(); if(ret) - return SWIG_NewPointerObj(SWIG_as_voidptr(ret),SWIGTYPE_p_ParaMEDMEM__DataArrayDoubleTuple,SWIG_POINTER_OWN|0); + return SWIG_NewPointerObj(SWIG_as_voidptr(ret),SWIGTYPE_p_MEDCoupling__DataArrayDoubleTuple,SWIG_POINTER_OWN|0); else { PyErr_SetString(PyExc_StopIteration,"No more data."); @@ -2323,32 +2019,32 @@ namespace ParaMEDMEM PyObject *___iadd___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception) { - MEDCouplingAutoRefCountObjectPtr ret=self->buildDADouble(1,self->getNumberOfCompo()); - ParaMEDMEM_DataArrayDouble____iadd___(ret,0,obj); + MCAuto ret=self->buildDADouble(1,self->getNumberOfCompo()); + MEDCoupling_DataArrayDouble____iadd___(ret,0,obj); Py_XINCREF(trueSelf); return trueSelf; } PyObject *___isub___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception) { - MEDCouplingAutoRefCountObjectPtr ret=self->buildDADouble(1,self->getNumberOfCompo()); - ParaMEDMEM_DataArrayDouble____isub___(ret,0,obj); + MCAuto ret=self->buildDADouble(1,self->getNumberOfCompo()); + MEDCoupling_DataArrayDouble____isub___(ret,0,obj); Py_XINCREF(trueSelf); return trueSelf; } PyObject *___imul___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception) { - MEDCouplingAutoRefCountObjectPtr ret=self->buildDADouble(1,self->getNumberOfCompo()); - ParaMEDMEM_DataArrayDouble____imul___(ret,0,obj); + MCAuto ret=self->buildDADouble(1,self->getNumberOfCompo()); + MEDCoupling_DataArrayDouble____imul___(ret,0,obj); Py_XINCREF(trueSelf); return trueSelf; } PyObject *___idiv___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception) { - MEDCouplingAutoRefCountObjectPtr ret=self->buildDADouble(1,self->getNumberOfCompo()); - ParaMEDMEM_DataArrayDouble____idiv___(ret,0,obj); + MCAuto ret=self->buildDADouble(1,self->getNumberOfCompo()); + MEDCoupling_DataArrayDouble____idiv___(ret,0,obj); Py_XINCREF(trueSelf); return trueSelf; } @@ -2365,10 +2061,10 @@ namespace ParaMEDMEM int singleVal; std::vector multiVal; std::pair > slic; - ParaMEDMEM::DataArrayInt *daIntTyypp=0; + MEDCoupling::DataArrayInt *daIntTyypp=0; const double *pt=self->getConstPointer(); int nbc=self->getNumberOfCompo(); - convertObjToPossibleCpp2WithNegIntInterp(obj,nbc,sw,singleVal,multiVal,slic,daIntTyypp); + convertIntStarOrSliceLikePyObjToCppWithNegIntInterp(obj,nbc,sw,singleVal,multiVal,slic,daIntTyypp); switch(sw) { case 1: @@ -2430,15 +2126,15 @@ namespace ParaMEDMEM int sw1,sw2; double singleValV; std::vector multiValV; - ParaMEDMEM::DataArrayDoubleTuple *daIntTyyppV=0; + MEDCoupling::DataArrayDoubleTuple *daIntTyyppV=0; int nbc=self->getNumberOfCompo(); - convertObjToPossibleCpp44(value,sw1,singleValV,multiValV,daIntTyyppV); + convertDoubleStarLikePyObjToCpp(value,sw1,singleValV,multiValV,daIntTyyppV); int singleVal; std::vector multiVal; std::pair > slic; - ParaMEDMEM::DataArrayInt *daIntTyypp=0; + MEDCoupling::DataArrayInt *daIntTyypp=0; double *pt=self->getPointer(); - convertObjToPossibleCpp2WithNegIntInterp(obj,nbc,sw2,singleVal,multiVal,slic,daIntTyypp); + convertIntStarOrSliceLikePyObjToCppWithNegIntInterp(obj,nbc,sw2,singleVal,multiVal,slic,daIntTyypp); switch(sw2) { case 1: @@ -2587,8 +2283,9 @@ namespace ParaMEDMEM 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); @@ -2614,15 +2311,19 @@ namespace ParaMEDMEM DataArrayInt *invertArrayO2N2N2O(int newNbOfElem) const throw(INTERP_KERNEL::Exception); 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); + MCAuto< MapII > invertArrayN2O2O2NOptimized() const throw(INTERP_KERNEL::Exception); + MCAuto< MapII > giveN2OOptimized() 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); + int checkUniformAndGuess() 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,21 +2342,20 @@ namespace ParaMEDMEM 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); 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); @@ -2668,9 +2368,9 @@ namespace ParaMEDMEM 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 *findIdsStrictlyNegative() 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 +2387,7 @@ namespace ParaMEDMEM 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); @@ -2706,6 +2406,14 @@ namespace ParaMEDMEM void modulusEqual(const DataArrayInt *other) throw(INTERP_KERNEL::Exception); static DataArrayInt *Pow(const DataArrayInt *a1, const DataArrayInt *a2) throw(INTERP_KERNEL::Exception); void powEqual(const DataArrayInt *other) throw(INTERP_KERNEL::Exception); + MCAuto fromLinkedListOfPairToList() const throw(INTERP_KERNEL::Exception); + MCAuto findIdsGreaterOrEqualTo(int val) const throw(INTERP_KERNEL::Exception); + MCAuto findIdsGreaterThan(int val) const throw(INTERP_KERNEL::Exception); + MCAuto findIdsLowerOrEqualTo(int val) const throw(INTERP_KERNEL::Exception); + MCAuto findIdsLowerThan(int val) const throw(INTERP_KERNEL::Exception); + MCAuto selectPartDef(const PartDefinition* pd) const throw(INTERP_KERNEL::Exception); + MCAuto convertToDblArr() const throw(INTERP_KERNEL::Exception); + MCAuto convertToFloatArr() const throw(INTERP_KERNEL::Exception); public: static DataArrayInt *Range(int begin, int end, int step) throw(INTERP_KERNEL::Exception); %extend @@ -2717,7 +2425,7 @@ namespace ParaMEDMEM static DataArrayInt *New(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *nbOfComp=0) throw(INTERP_KERNEL::Exception) { - const char *msgBase="ParaMEDMEM::DataArrayInt::New : Available API are : \n-DataArrayInt.New()\n-DataArrayInt.New([1,3,4])\n-DataArrayInt.New([1,3,4],3)\n-DataArrayInt.New([1,3,4,5],2,2)\n-DataArrayInt.New([1,3,4,5,7,8],3,2)\n-DataArrayInt.New([(1,3),(4,5),(7,8)])\n-DataArrayInt.New(5)\n-DataArrayInt.New(5,2)"; + const char *msgBase="MEDCoupling::DataArrayInt::New : Available API are : \n-DataArrayInt.New()\n-DataArrayInt.New([1,3,4])\n-DataArrayInt.New([1,3,4],3)\n-DataArrayInt.New([1,3,4,5],2,2)\n-DataArrayInt.New([1,3,4,5,7,8],3,2)\n-DataArrayInt.New([(1,3),(4,5),(7,8)])\n-DataArrayInt.New(5)\n-DataArrayInt.New(5,2)"; std::string msg(msgBase); #ifdef WITH_NUMPY msg+="\n-DataArrayInt.New(numpy array with dtype=int32)"; @@ -2739,7 +2447,7 @@ namespace ParaMEDMEM 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 +2457,7 @@ namespace ParaMEDMEM } 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 +2469,7 @@ namespace ParaMEDMEM } 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 +2490,7 @@ namespace ParaMEDMEM 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 +2502,7 @@ namespace ParaMEDMEM } else {//DataArrayInt.New(5) - MEDCouplingAutoRefCountObjectPtr ret=DataArrayInt::New(); + MCAuto ret=DataArrayInt::New(); ret->alloc(nbOfTuples1,1); return ret.retn(); } @@ -2812,9 +2520,9 @@ namespace ParaMEDMEM DataArrayInt(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *nbOfComp=0) throw(INTERP_KERNEL::Exception) { - return ParaMEDMEM_DataArrayInt_New__SWIG_1(elt0,nbOfTuples,nbOfComp); + return MEDCoupling_DataArrayInt_New__SWIG_1(elt0,nbOfTuples,nbOfComp); } - + std::string __str__() const throw(INTERP_KERNEL::Exception) { return self->reprNotTooLong(); @@ -2854,16 +2562,25 @@ namespace ParaMEDMEM { int sw,sz,val; std::vector val2; - const int *bg=convertObjToPossibleCpp1_Safe(indexArr,sw,sz,val,val2); + const int *bg=convertIntStarLikePyObjToCppIntStar(indexArr,sw,sz,val,val2); 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(convertIntStarLikePyObjToCppIntStar(inputTuple,sw,sz,val,val2)); + 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(convertObjToPossibleCpp1_Safe(inputTuple,sw,sz,val,val2)); - return self->getIdsEqualTuple(bg,bg+sz); + 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) @@ -2880,8 +2597,7 @@ namespace ParaMEDMEM if(!PySlice_Check(slic)) throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrOfSliceOnScaledArr (wrap) : expecting a pyslice as second (first) parameter !"); Py_ssize_t strt=2,stp=2,step=2; - PySliceObject *sly=reinterpret_cast(slic); - GetIndicesOfSliceExplicitely(sly,&strt,&stp,&step,"DataArrayInt::buildExplicitArrOfSliceOnScaledArr (wrap) : the input slice is invalid !"); + GetIndicesOfSliceExplicitely(slic,&strt,&stp,&step,"DataArrayInt::buildExplicitArrOfSliceOnScaledArr (wrap) : the input slice is invalid !"); if(strt==std::numeric_limits::max() || stp==std::numeric_limits::max()) throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrOfSliceOnScaledArr (wrap) : the input slice contains some unknowns that can't be determined in static method ! Call DataArray::getSlice (non static) instead !"); return self->buildExplicitArrOfSliceOnScaledArr(strt,stp,step); @@ -2897,44 +2613,44 @@ namespace ParaMEDMEM 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=ParaMEDMEM::DataArrayInt::BuildOld2NewArrayFromSurjectiveFormat2(nbOfOldTuples,arrPtr,arrIPtr,arrIPtr+szArrI,newNbOfTuples); + const int *arrPtr=convertIntStarLikePyObjToCppIntStar(arr,sw,szArr,iTypppArr,stdvecTyyppArr); + const int *arrIPtr=convertIntStarLikePyObjToCppIntStar(arrI,sw,szArrI,iTypppArrI,stdvecTyyppArrI); + 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_ParaMEDMEM__DataArrayInt,SWIG_POINTER_OWN | 0)); + PyTuple_SetItem(ret,0,SWIG_NewPointerObj((void*)ret0,SWIGTYPE_p_MEDCoupling__DataArrayInt,SWIG_POINTER_OWN | 0)); PyTuple_SetItem(ret,1,PyInt_FromLong(newNbOfTuples)); return ret; } 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)); - int *pt(ParaMEDMEM::DataArrayInt::CheckAndPreparePermutation(arrPtr,arrPtr+szArr)); - ret->useArray(pt,true,ParaMEDMEM::C_DEALLOC,szArr,1); + const int *arrPtr(convertIntStarLikePyObjToCppIntStar(arr,sw,szArr,iTypppArr,stdvecTyyppArr)); + int *pt(MEDCoupling::DataArrayInt::CheckAndPreparePermutation(arrPtr,arrPtr+szArr)); + ret->useArray(pt,true,MEDCoupling::DeallocType::C_DEALLOC,szArr,1); return ret.retn(); } void setValues(PyObject *li, PyObject *nbOfTuples=0, PyObject *nbOfComp=0) throw(INTERP_KERNEL::Exception) { - const char *msg="ParaMEDMEM::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 !"; + 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) @@ -3005,10 +2721,10 @@ namespace ParaMEDMEM { std::vector groups; std::vector< std::vector > fidsOfGroups; - convertFromPyObjVectorOfObj(gps,SWIGTYPE_p_ParaMEDMEM__DataArrayInt,"DataArrayInt",groups); - ParaMEDMEM::DataArrayInt *ret0=ParaMEDMEM::DataArrayInt::MakePartition(groups,newNb,fidsOfGroups); + convertFromPyObjVectorOfObj(gps,SWIGTYPE_p_MEDCoupling__DataArrayInt,"DataArrayInt",groups); + MEDCoupling::DataArrayInt *ret0=MEDCoupling::DataArrayInt::MakePartition(groups,newNb,fidsOfGroups); PyObject *ret = PyList_New(2); - PyList_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(ret0),SWIGTYPE_p_ParaMEDMEM__DataArrayInt, SWIG_POINTER_OWN | 0 )); + PyList_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(ret0),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); int sz=fidsOfGroups.size(); PyObject *ret1 = PyList_New(sz); for(int i=0;i tmp=convertPyToNewIntArr2(li,&size); - self->transformWithIndArr(tmp,tmp+size); + int res2(SWIG_ConvertPtr(li,&da,SWIGTYPE_p_MEDCoupling__MapII, 0 | 0 )); + if(SWIG_IsOK(res2)) + { + MapII *m=reinterpret_cast(da); + self->transformWithIndArr(*m); + } + else + { + int size; + INTERP_KERNEL::AutoPtr tmp=convertPyToNewIntArr2(li,&size); + self->transformWithIndArr(tmp,tmp+size); + } } else { @@ -3034,45 +2759,45 @@ namespace ParaMEDMEM } } - DataArrayInt *getIdsEqualList(PyObject *obj) throw(INTERP_KERNEL::Exception) + DataArrayInt *findIdsEqualList(PyObject *obj) throw(INTERP_KERNEL::Exception) { int sw; int singleVal; std::vector multiVal; std::pair > slic; - ParaMEDMEM::DataArrayInt *daIntTyypp=0; - convertObjToPossibleCpp2(obj,self->getNumberOfTuples(),sw,singleVal,multiVal,slic,daIntTyypp); + MEDCoupling::DataArrayInt *daIntTyypp=0; + convertIntStarOrSliceLikePyObjToCpp(obj,self->getNumberOfTuples(),sw,singleVal,multiVal,slic,daIntTyypp); 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; std::vector multiVal; std::pair > slic; - ParaMEDMEM::DataArrayInt *daIntTyypp=0; - convertObjToPossibleCpp2(obj,self->getNumberOfTuples(),sw,singleVal,multiVal,slic,daIntTyypp); + MEDCoupling::DataArrayInt *daIntTyypp=0; + convertIntStarOrSliceLikePyObjToCpp(obj,self->getNumberOfTuples(),sw,singleVal,multiVal,slic,daIntTyypp); 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 !"); } } @@ -3080,7 +2805,7 @@ namespace ParaMEDMEM { DataArrayInt *ret0=0,*ret1=0,*ret2=0; void *da=0; - int res1=SWIG_ConvertPtr(li,&da,SWIGTYPE_p_ParaMEDMEM__DataArrayInt, 0 | 0 ); + int res1=SWIG_ConvertPtr(li,&da,SWIGTYPE_p_MEDCoupling__DataArrayInt, 0 | 0 ); if (!SWIG_IsOK(res1)) { int size; @@ -3093,20 +2818,19 @@ namespace ParaMEDMEM 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_ParaMEDMEM__DataArrayInt, SWIG_POINTER_OWN | 0 )); - PyList_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(ret1),SWIGTYPE_p_ParaMEDMEM__DataArrayInt, SWIG_POINTER_OWN | 0 )); - PyList_SetItem(ret,2,SWIG_NewPointerObj(SWIG_as_voidptr(ret2),SWIGTYPE_p_ParaMEDMEM__DataArrayInt, SWIG_POINTER_OWN | 0 )); + PyList_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(ret0),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); + PyList_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(ret1),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); + PyList_SetItem(ret,2,SWIG_NewPointerObj(SWIG_as_voidptr(ret2),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); return ret; } DataArrayInt *transformWithIndArrR(PyObject *li) const throw(INTERP_KERNEL::Exception) { void *da=0; - int res1=SWIG_ConvertPtr(li,&da,SWIGTYPE_p_ParaMEDMEM__DataArrayInt, 0 | 0 ); + int res1=SWIG_ConvertPtr(li,&da,SWIGTYPE_p_MEDCoupling__DataArrayInt, 0 | 0 ); if (!SWIG_IsOK(res1)) { int size; @@ -3123,7 +2847,7 @@ namespace ParaMEDMEM DataArrayInt *renumberAndReduce(PyObject *li, int newNbOfTuple) throw(INTERP_KERNEL::Exception) { void *da=0; - int res1=SWIG_ConvertPtr(li,&da,SWIGTYPE_p_ParaMEDMEM__DataArrayInt, 0 | 0 ); + int res1=SWIG_ConvertPtr(li,&da,SWIGTYPE_p_MEDCoupling__DataArrayInt, 0 | 0 ); if (!SWIG_IsOK(res1)) { int size; @@ -3152,7 +2876,7 @@ namespace ParaMEDMEM DataArrayInt *renumber(PyObject *li) throw(INTERP_KERNEL::Exception) { void *da=0; - int res1=SWIG_ConvertPtr(li,&da,SWIGTYPE_p_ParaMEDMEM__DataArrayInt, 0 | 0 ); + int res1=SWIG_ConvertPtr(li,&da,SWIGTYPE_p_MEDCoupling__DataArrayInt, 0 | 0 ); if (!SWIG_IsOK(res1)) { int size; @@ -3181,7 +2905,7 @@ namespace ParaMEDMEM DataArrayInt *renumberR(PyObject *li) throw(INTERP_KERNEL::Exception) { void *da=0; - int res1=SWIG_ConvertPtr(li,&da,SWIGTYPE_p_ParaMEDMEM__DataArrayInt, 0 | 0 ); + int res1=SWIG_ConvertPtr(li,&da,SWIGTYPE_p_MEDCoupling__DataArrayInt, 0 | 0 ); if (!SWIG_IsOK(res1)) { int size; @@ -3214,6 +2938,16 @@ namespace ParaMEDMEM 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(); @@ -3228,43 +2962,43 @@ namespace ParaMEDMEM DataArrayInt *arrI=0; self->changeSurjectiveFormat(targetNb,arr,arrI); PyObject *res = PyList_New(2); - PyList_SetItem(res,0,SWIG_NewPointerObj((void*)arr,SWIGTYPE_p_ParaMEDMEM__DataArrayInt,SWIG_POINTER_OWN | 0)); - PyList_SetItem(res,1,SWIG_NewPointerObj((void*)arrI,SWIGTYPE_p_ParaMEDMEM__DataArrayInt,SWIG_POINTER_OWN | 0)); + PyList_SetItem(res,0,SWIG_NewPointerObj((void*)arr,SWIGTYPE_p_MEDCoupling__DataArrayInt,SWIG_POINTER_OWN | 0)); + PyList_SetItem(res,1,SWIG_NewPointerObj((void*)arrI,SWIGTYPE_p_MEDCoupling__DataArrayInt,SWIG_POINTER_OWN | 0)); return res; } static DataArrayInt *Meld(PyObject *li) throw(INTERP_KERNEL::Exception) { std::vector tmp; - convertFromPyObjVectorOfObj(li,SWIGTYPE_p_ParaMEDMEM__DataArrayInt,"DataArrayInt",tmp); + convertFromPyObjVectorOfObj(li,SWIGTYPE_p_MEDCoupling__DataArrayInt,"DataArrayInt",tmp); return DataArrayInt::Meld(tmp); } static DataArrayInt *Aggregate(PyObject *li) throw(INTERP_KERNEL::Exception) { std::vector tmp; - convertFromPyObjVectorOfObj(li,SWIGTYPE_p_ParaMEDMEM__DataArrayInt,"DataArrayInt",tmp); + convertFromPyObjVectorOfObj(li,SWIGTYPE_p_MEDCoupling__DataArrayInt,"DataArrayInt",tmp); return DataArrayInt::Aggregate(tmp); } static DataArrayInt *AggregateIndexes(PyObject *li) throw(INTERP_KERNEL::Exception) { std::vector tmp; - convertFromPyObjVectorOfObj(li,SWIGTYPE_p_ParaMEDMEM__DataArrayInt,"DataArrayInt",tmp); + convertFromPyObjVectorOfObj(li,SWIGTYPE_p_MEDCoupling__DataArrayInt,"DataArrayInt",tmp); return DataArrayInt::AggregateIndexes(tmp); } static DataArrayInt *BuildUnion(PyObject *li) throw(INTERP_KERNEL::Exception) { std::vector tmp; - convertFromPyObjVectorOfObj(li,SWIGTYPE_p_ParaMEDMEM__DataArrayInt,"DataArrayInt",tmp); + convertFromPyObjVectorOfObj(li,SWIGTYPE_p_MEDCoupling__DataArrayInt,"DataArrayInt",tmp); return DataArrayInt::BuildUnion(tmp); } static DataArrayInt *BuildIntersection(PyObject *li) throw(INTERP_KERNEL::Exception) { std::vector tmp; - convertFromPyObjVectorOfObj(li,SWIGTYPE_p_ParaMEDMEM__DataArrayInt,"DataArrayInt",tmp); + convertFromPyObjVectorOfObj(li,SWIGTYPE_p_MEDCoupling__DataArrayInt,"DataArrayInt",tmp); return DataArrayInt::BuildIntersection(tmp); } @@ -3277,6 +3011,16 @@ namespace ParaMEDMEM 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) { @@ -3298,7 +3042,7 @@ namespace ParaMEDMEM 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 +3051,7 @@ namespace ParaMEDMEM { std::vector arr; convertPyToNewIntArr3(obj,arr); - return self->locateTuple(arr); + return self->findIdFirstEqualTuple(arr); } } } @@ -3351,60 +3095,60 @@ namespace ParaMEDMEM 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: { if(nbOfComponents==1) return PyInt_FromLong(self->getIJSafe(it1,0)); - return SWIG_NewPointerObj(SWIG_as_voidptr(self->selectByTupleIdSafe(&it1,&it1+1)),SWIGTYPE_p_ParaMEDMEM__DataArrayInt, SWIG_POINTER_OWN | 0 ); + return SWIG_NewPointerObj(SWIG_as_voidptr(self->selectByTupleIdSafe(&it1,&it1+1)),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 ); } case 2: - return SWIG_NewPointerObj(SWIG_as_voidptr(self->selectByTupleIdSafe(&vt1[0],&vt1[0]+vt1.size())),SWIGTYPE_p_ParaMEDMEM__DataArrayInt, SWIG_POINTER_OWN | 0 ); + 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_ParaMEDMEM__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_ParaMEDMEM__DataArrayInt, SWIG_POINTER_OWN | 0 ); + return SWIG_NewPointerObj(SWIG_as_voidptr(self->selectByTupleIdSafe(dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems())),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 ); case 5: return PyInt_FromLong(self->getIJSafe(it1,ic1)); case 6: { ret=self->selectByTupleIdSafe(&vt1[0],&vt1[0]+vt1.size()); std::vector v2(1,ic1); - return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(v2)),SWIGTYPE_p_ParaMEDMEM__DataArrayInt, SWIG_POINTER_OWN | 0 ); + return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(v2)),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 ); } 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_ParaMEDMEM__DataArrayInt, SWIG_POINTER_OWN | 0 ); + return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(v2)),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 ); } case 8: { ret=self->selectByTupleIdSafe(dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems()); std::vector v2(1,ic1); - return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(v2)),SWIGTYPE_p_ParaMEDMEM__DataArrayInt, SWIG_POINTER_OWN | 0 ); + return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(v2)),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 ); } case 9: { ret=self->selectByTupleIdSafe(&it1,&it1+1); - return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(vc1)),SWIGTYPE_p_ParaMEDMEM__DataArrayInt, SWIG_POINTER_OWN | 0 ); + return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(vc1)),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 ); } case 10: { ret=self->selectByTupleIdSafe(&vt1[0],&vt1[0]+vt1.size()); - return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(vc1)),SWIGTYPE_p_ParaMEDMEM__DataArrayInt, SWIG_POINTER_OWN | 0 ); + return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(vc1)),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 ); } case 11: { - ret=self->selectByTupleId2(pt1.first,pt1.second.first,pt1.second.second); - return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(vc1)),SWIGTYPE_p_ParaMEDMEM__DataArrayInt, SWIG_POINTER_OWN | 0 ); + 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: { ret=self->selectByTupleIdSafe(dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems()); - return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(vc1)),SWIGTYPE_p_ParaMEDMEM__DataArrayInt, SWIG_POINTER_OWN | 0 ); + return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(vc1)),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 ); } case 13: { @@ -3413,7 +3157,7 @@ namespace ParaMEDMEM std::vector v2(nbOfComp); for(int i=0;ikeepSelectedComponents(v2)),SWIGTYPE_p_ParaMEDMEM__DataArrayInt, SWIG_POINTER_OWN | 0 ); + return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(v2)),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 ); } case 14: { @@ -3422,16 +3166,16 @@ namespace ParaMEDMEM std::vector v2(nbOfComp); for(int i=0;ikeepSelectedComponents(v2)),SWIGTYPE_p_ParaMEDMEM__DataArrayInt, SWIG_POINTER_OWN | 0 ); + return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(v2)),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 ); } 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;ikeepSelectedComponents(v2)),SWIGTYPE_p_ParaMEDMEM__DataArrayInt, SWIG_POINTER_OWN | 0 ); + return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(v2)),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 ); } case 16: { @@ -3440,7 +3184,7 @@ namespace ParaMEDMEM std::vector v2(nbOfComp); for(int i=0;ikeepSelectedComponents(v2)),SWIGTYPE_p_ParaMEDMEM__DataArrayInt, SWIG_POINTER_OWN | 0 ); + return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(v2)),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 ); } default: throw INTERP_KERNEL::Exception(msg); @@ -3458,13 +3202,13 @@ namespace ParaMEDMEM std::vector v1; DataArrayInt *d1=0; DataArrayIntTuple *dd1=0; - convertObjToPossibleCpp1(value,sw1,i1,v1,d1,dd1); + convertIntStarLikePyObjToCpp(value,sw1,i1,v1,d1,dd1); int it1,ic1; std::vector vt1,vc1; 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: @@ -3476,7 +3220,7 @@ namespace ParaMEDMEM return self; case 2: tmp=DataArrayInt::New(); - tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size()); + tmp->useArray(&v1[0],false,DeallocType::CPP_DEALLOC,1,v1.size()); self->setPartOfValues1(tmp,it1,it1+1,1,0,nbOfComponents,1,false); return self; case 3: @@ -3500,7 +3244,7 @@ namespace ParaMEDMEM return self; case 2: tmp=DataArrayInt::New(); - tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size()); + tmp->useArray(&v1[0],false,DeallocType::CPP_DEALLOC,1,v1.size()); self->setPartOfValues3(tmp,&vt1[0],&vt1[0]+vt1.size(),0,nbOfComponents,1,false); return self; case 3: @@ -3524,7 +3268,7 @@ namespace ParaMEDMEM return self; case 2: tmp=DataArrayInt::New(); - tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size()); + tmp->useArray(&v1[0],false,DeallocType::CPP_DEALLOC,1,v1.size()); self->setPartOfValues1(tmp,pt1.first,pt1.second.first,pt1.second.second,0,nbOfComponents,1,false); return self; case 3: @@ -3548,7 +3292,7 @@ namespace ParaMEDMEM return self; case 2: tmp=DataArrayInt::New(); - tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size()); + tmp->useArray(&v1[0],false,DeallocType::CPP_DEALLOC,1,v1.size()); self->setPartOfValues3(tmp,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),0,nbOfComponents,1,false); return self; case 3: @@ -3572,7 +3316,7 @@ namespace ParaMEDMEM return self; case 2: tmp=DataArrayInt::New(); - tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size()); + tmp->useArray(&v1[0],false,DeallocType::CPP_DEALLOC,1,v1.size()); self->setPartOfValues1(tmp,it1,it1+1,1,ic1,ic1+1,1,false); return self; case 3: @@ -3596,7 +3340,7 @@ namespace ParaMEDMEM return self; case 2: tmp=DataArrayInt::New(); - tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size()); + tmp->useArray(&v1[0],false,DeallocType::CPP_DEALLOC,1,v1.size()); self->setPartOfValues3(tmp,&vt1[0],&vt1[0]+vt1.size(),ic1,ic1+1,1,false); return self; case 3: @@ -3620,7 +3364,7 @@ namespace ParaMEDMEM return self; case 2: tmp=DataArrayInt::New(); - tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size()); + tmp->useArray(&v1[0],false,DeallocType::CPP_DEALLOC,1,v1.size()); self->setPartOfValues1(tmp,pt1.first,pt1.second.first,pt1.second.second,ic1,ic1+1,1,false); return self; case 3: @@ -3644,7 +3388,7 @@ namespace ParaMEDMEM return self; case 2: tmp=DataArrayInt::New(); - tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size()); + tmp->useArray(&v1[0],false,DeallocType::CPP_DEALLOC,1,v1.size()); self->setPartOfValues3(tmp,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),ic1,ic1+1,1,false); return self; case 3: @@ -3668,7 +3412,7 @@ namespace ParaMEDMEM return self; case 2: tmp=DataArrayInt::New(); - tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size()); + tmp->useArray(&v1[0],false,DeallocType::CPP_DEALLOC,1,v1.size()); self->setPartOfValues2(tmp,&it1,&it1+1,&vc1[0],&vc1[0]+vc1.size(),false); return self; case 3: @@ -3692,7 +3436,7 @@ namespace ParaMEDMEM return self; case 2: tmp=DataArrayInt::New(); - tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size()); + tmp->useArray(&v1[0],false,DeallocType::CPP_DEALLOC,1,v1.size()); self->setPartOfValues2(tmp,&vt1[0],&vt1[0]+vt1.size(),&vc1[0],&vc1[0]+vc1.size(),false); return self; case 3: @@ -3716,7 +3460,7 @@ namespace ParaMEDMEM return self; case 2: tmp=DataArrayInt::New(); - tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size()); + tmp->useArray(&v1[0],false,DeallocType::CPP_DEALLOC,1,v1.size()); self->setPartOfValues4(tmp,pt1.first,pt1.second.first,pt1.second.second,&vc1[0],&vc1[0]+vc1.size(),false); return self; case 3: @@ -3740,7 +3484,7 @@ namespace ParaMEDMEM return self; case 2: tmp=DataArrayInt::New(); - tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size()); + tmp->useArray(&v1[0],false,DeallocType::CPP_DEALLOC,1,v1.size()); self->setPartOfValues2(tmp,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),&vc1[0],&vc1[0]+vc1.size(),false); return self; case 3: @@ -3764,7 +3508,7 @@ namespace ParaMEDMEM return self; case 2: tmp=DataArrayInt::New(); - tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size()); + tmp->useArray(&v1[0],false,DeallocType::CPP_DEALLOC,1,v1.size()); self->setPartOfValues1(tmp,it1,it1+1,1,pc1.first,pc1.second.first,pc1.second.second,false); return self; case 3: @@ -3788,7 +3532,7 @@ namespace ParaMEDMEM return self; case 2: tmp=DataArrayInt::New(); - tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size()); + tmp->useArray(&v1[0],false,DeallocType::CPP_DEALLOC,1,v1.size()); self->setPartOfValues3(tmp,&vt1[0],&vt1[0]+vt1.size(),pc1.first,pc1.second.first,pc1.second.second,false); return self; case 3: @@ -3812,7 +3556,7 @@ namespace ParaMEDMEM return self; case 2: tmp=DataArrayInt::New(); - tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size()); + tmp->useArray(&v1[0],false,DeallocType::CPP_DEALLOC,1,v1.size()); self->setPartOfValues1(tmp,pt1.first,pt1.second.first,pt1.second.second,pc1.first,pc1.second.first,pc1.second.second,false); return self; case 3: @@ -3836,7 +3580,7 @@ namespace ParaMEDMEM return self; case 2: tmp=DataArrayInt::New(); - tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size()); + tmp->useArray(&v1[0],false,DeallocType::CPP_DEALLOC,1,v1.size()); self->setPartOfValues3(tmp,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),pc1.first,pc1.second.first,pc1.second.second,false); return self; case 3: @@ -3870,18 +3614,18 @@ namespace ParaMEDMEM std::vector aa; DataArrayIntTuple *aaa; int sw; - convertObjToPossibleCpp1(obj,sw,val,aa,a,aaa); + convertIntStarLikePyObjToCpp(obj,sw,val,aa,a,aaa); switch(sw) { 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,DeallocType::CPP_DEALLOC,1,(int)aa.size()); return DataArrayInt::Add(self,aaaa); } case 3: @@ -3890,7 +3634,7 @@ namespace ParaMEDMEM } case 4: { - MEDCouplingAutoRefCountObjectPtr aaaa=aaa->buildDAInt(1,self->getNumberOfComponents()); + MCAuto aaaa=aaa->buildDAInt(1,self->getNumberOfComponents()); return DataArrayInt::Add(self,aaaa); } default: @@ -3906,23 +3650,23 @@ namespace ParaMEDMEM std::vector aa; DataArrayIntTuple *aaa; int sw; - convertObjToPossibleCpp1(obj,sw,val,aa,a,aaa); + convertIntStarLikePyObjToCpp(obj,sw,val,aa,a,aaa); switch(sw) { 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,DeallocType::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: @@ -3938,7 +3682,7 @@ namespace ParaMEDMEM std::vector aa; DataArrayIntTuple *aaa; int sw; - convertObjToPossibleCpp1(obj,sw,val,aa,a,aaa); + convertIntStarLikePyObjToCpp(obj,sw,val,aa,a,aaa); switch(sw) { case 1: @@ -3949,7 +3693,7 @@ namespace ParaMEDMEM } 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,DeallocType::CPP_DEALLOC,1,(int)aa.size()); self->addEqual(bb); Py_XINCREF(trueSelf); return trueSelf; @@ -3962,7 +3706,7 @@ namespace ParaMEDMEM } case 4: { - MEDCouplingAutoRefCountObjectPtr aaaa=aaa->buildDAInt(1,self->getNumberOfComponents()); + MCAuto aaaa=aaa->buildDAInt(1,self->getNumberOfComponents()); self->addEqual(aaaa); Py_XINCREF(trueSelf); return trueSelf; @@ -3980,18 +3724,18 @@ namespace ParaMEDMEM std::vector aa; DataArrayIntTuple *aaa; int sw; - convertObjToPossibleCpp1(obj,sw,val,aa,a,aaa); + convertIntStarLikePyObjToCpp(obj,sw,val,aa,a,aaa); switch(sw) { 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,DeallocType::CPP_DEALLOC,1,(int)aa.size()); return DataArrayInt::Substract(self,aaaa); } case 3: @@ -4000,7 +3744,7 @@ namespace ParaMEDMEM } case 4: { - MEDCouplingAutoRefCountObjectPtr aaaa=aaa->buildDAInt(1,self->getNumberOfComponents()); + MCAuto aaaa=aaa->buildDAInt(1,self->getNumberOfComponents()); return DataArrayInt::Substract(self,aaaa); } default: @@ -4016,23 +3760,23 @@ namespace ParaMEDMEM std::vector aa; DataArrayIntTuple *aaa; int sw; - convertObjToPossibleCpp1(obj,sw,val,aa,a,aaa); + convertIntStarLikePyObjToCpp(obj,sw,val,aa,a,aaa); switch(sw) { 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,DeallocType::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: @@ -4048,7 +3792,7 @@ namespace ParaMEDMEM std::vector aa; DataArrayIntTuple *aaa; int sw; - convertObjToPossibleCpp1(obj,sw,val,aa,a,aaa); + convertIntStarLikePyObjToCpp(obj,sw,val,aa,a,aaa); switch(sw) { case 1: @@ -4059,7 +3803,7 @@ namespace ParaMEDMEM } 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,DeallocType::CPP_DEALLOC,1,(int)aa.size()); self->substractEqual(bb); Py_XINCREF(trueSelf); return trueSelf; @@ -4072,7 +3816,7 @@ namespace ParaMEDMEM } case 4: { - MEDCouplingAutoRefCountObjectPtr aaaa=aaa->buildDAInt(1,self->getNumberOfComponents()); + MCAuto aaaa=aaa->buildDAInt(1,self->getNumberOfComponents()); self->substractEqual(aaaa); Py_XINCREF(trueSelf); return trueSelf; @@ -4090,18 +3834,18 @@ namespace ParaMEDMEM std::vector aa; DataArrayIntTuple *aaa; int sw; - convertObjToPossibleCpp1(obj,sw,val,aa,a,aaa); + convertIntStarLikePyObjToCpp(obj,sw,val,aa,a,aaa); switch(sw) { 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,DeallocType::CPP_DEALLOC,1,(int)aa.size()); return DataArrayInt::Multiply(self,aaaa); } case 3: @@ -4110,7 +3854,7 @@ namespace ParaMEDMEM } case 4: { - MEDCouplingAutoRefCountObjectPtr aaaa=aaa->buildDAInt(1,self->getNumberOfComponents()); + MCAuto aaaa=aaa->buildDAInt(1,self->getNumberOfComponents()); return DataArrayInt::Multiply(self,aaaa); } default: @@ -4126,23 +3870,23 @@ namespace ParaMEDMEM std::vector aa; DataArrayIntTuple *aaa; int sw; - convertObjToPossibleCpp1(obj,sw,val,aa,a,aaa); + convertIntStarLikePyObjToCpp(obj,sw,val,aa,a,aaa); switch(sw) { 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,DeallocType::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: @@ -4158,7 +3902,7 @@ namespace ParaMEDMEM std::vector aa; DataArrayIntTuple *aaa; int sw; - convertObjToPossibleCpp1(obj,sw,val,aa,a,aaa); + convertIntStarLikePyObjToCpp(obj,sw,val,aa,a,aaa); switch(sw) { case 1: @@ -4169,7 +3913,7 @@ namespace ParaMEDMEM } 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,DeallocType::CPP_DEALLOC,1,(int)aa.size()); self->multiplyEqual(bb); Py_XINCREF(trueSelf); return trueSelf; @@ -4182,7 +3926,7 @@ namespace ParaMEDMEM } case 4: { - MEDCouplingAutoRefCountObjectPtr aaaa=aaa->buildDAInt(1,self->getNumberOfComponents()); + MCAuto aaaa=aaa->buildDAInt(1,self->getNumberOfComponents()); self->multiplyEqual(aaaa); Py_XINCREF(trueSelf); return trueSelf; @@ -4200,18 +3944,18 @@ namespace ParaMEDMEM std::vector aa; DataArrayIntTuple *aaa; int sw; - convertObjToPossibleCpp1(obj,sw,val,aa,a,aaa); + convertIntStarLikePyObjToCpp(obj,sw,val,aa,a,aaa); switch(sw) { 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,DeallocType::CPP_DEALLOC,1,(int)aa.size()); return DataArrayInt::Divide(self,aaaa); } case 3: @@ -4220,7 +3964,7 @@ namespace ParaMEDMEM } case 4: { - MEDCouplingAutoRefCountObjectPtr aaaa=aaa->buildDAInt(1,self->getNumberOfComponents()); + MCAuto aaaa=aaa->buildDAInt(1,self->getNumberOfComponents()); return DataArrayInt::Divide(self,aaaa); } default: @@ -4236,23 +3980,23 @@ namespace ParaMEDMEM std::vector aa; DataArrayIntTuple *aaa; int sw; - convertObjToPossibleCpp1(obj,sw,val,aa,a,aaa); + convertIntStarLikePyObjToCpp(obj,sw,val,aa,a,aaa); switch(sw) { 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,DeallocType::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: @@ -4268,7 +4012,7 @@ namespace ParaMEDMEM std::vector aa; DataArrayIntTuple *aaa; int sw; - convertObjToPossibleCpp1(obj,sw,val,aa,a,aaa); + convertIntStarLikePyObjToCpp(obj,sw,val,aa,a,aaa); switch(sw) { case 1: @@ -4279,7 +4023,7 @@ namespace ParaMEDMEM } 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,DeallocType::CPP_DEALLOC,1,(int)aa.size()); self->divideEqual(bb); Py_XINCREF(trueSelf); return trueSelf; @@ -4292,7 +4036,7 @@ namespace ParaMEDMEM } case 4: { - MEDCouplingAutoRefCountObjectPtr aaaa=aaa->buildDAInt(1,self->getNumberOfComponents()); + MCAuto aaaa=aaa->buildDAInt(1,self->getNumberOfComponents()); self->divideEqual(aaaa); Py_XINCREF(trueSelf); return trueSelf; @@ -4310,18 +4054,18 @@ namespace ParaMEDMEM std::vector aa; DataArrayIntTuple *aaa; int sw; - convertObjToPossibleCpp1(obj,sw,val,aa,a,aaa); + convertIntStarLikePyObjToCpp(obj,sw,val,aa,a,aaa); switch(sw) { 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,DeallocType::CPP_DEALLOC,1,(int)aa.size()); return DataArrayInt::Modulus(self,aaaa); } case 3: @@ -4330,7 +4074,7 @@ namespace ParaMEDMEM } case 4: { - MEDCouplingAutoRefCountObjectPtr aaaa=aaa->buildDAInt(1,self->getNumberOfComponents()); + MCAuto aaaa=aaa->buildDAInt(1,self->getNumberOfComponents()); return DataArrayInt::Modulus(self,aaaa); } default: @@ -4346,18 +4090,18 @@ namespace ParaMEDMEM std::vector aa; DataArrayIntTuple *aaa; int sw; - convertObjToPossibleCpp1(obj,sw,val,aa,a,aaa); + convertIntStarLikePyObjToCpp(obj,sw,val,aa,a,aaa); switch(sw) { 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,DeallocType::CPP_DEALLOC,1,(int)aa.size()); return DataArrayInt::Modulus(aaaa,self); } case 3: @@ -4366,7 +4110,7 @@ namespace ParaMEDMEM } case 4: { - MEDCouplingAutoRefCountObjectPtr aaaa=aaa->buildDAInt(1,self->getNumberOfComponents()); + MCAuto aaaa=aaa->buildDAInt(1,self->getNumberOfComponents()); return DataArrayInt::Modulus(aaaa,self); } default: @@ -4382,7 +4126,7 @@ namespace ParaMEDMEM std::vector aa; DataArrayIntTuple *aaa; int sw; - convertObjToPossibleCpp1(obj,sw,val,aa,a,aaa); + convertIntStarLikePyObjToCpp(obj,sw,val,aa,a,aaa); switch(sw) { case 1: @@ -4399,7 +4143,7 @@ namespace ParaMEDMEM } case 4: { - MEDCouplingAutoRefCountObjectPtr aaaa=aaa->buildDAInt(1,self->getNumberOfComponents()); + MCAuto aaaa=aaa->buildDAInt(1,self->getNumberOfComponents()); self->modulusEqual(aaaa); Py_XINCREF(trueSelf); return trueSelf; @@ -4417,18 +4161,18 @@ namespace ParaMEDMEM std::vector aa; DataArrayIntTuple *aaa; int sw; - convertObjToPossibleCpp1(obj,sw,val,aa,a,aaa); + convertIntStarLikePyObjToCpp(obj,sw,val,aa,a,aaa); switch(sw) { 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,DeallocType::CPP_DEALLOC,1,(int)aa.size()); return DataArrayInt::Pow(self,aaaa); } case 3: @@ -4437,7 +4181,7 @@ namespace ParaMEDMEM } case 4: { - MEDCouplingAutoRefCountObjectPtr aaaa=aaa->buildDAInt(1,self->getNumberOfComponents()); + MCAuto aaaa=aaa->buildDAInt(1,self->getNumberOfComponents()); return DataArrayInt::Pow(self,aaaa); } default: @@ -4453,18 +4197,18 @@ namespace ParaMEDMEM std::vector aa; DataArrayIntTuple *aaa; int sw; - convertObjToPossibleCpp1(obj,sw,val,aa,a,aaa); + convertIntStarLikePyObjToCpp(obj,sw,val,aa,a,aaa); switch(sw) { 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,DeallocType::CPP_DEALLOC,1,(int)aa.size()); return DataArrayInt::Pow(aaaa,self); } case 3: @@ -4473,7 +4217,7 @@ namespace ParaMEDMEM } case 4: { - MEDCouplingAutoRefCountObjectPtr aaaa=aaa->buildDAInt(1,self->getNumberOfComponents()); + MCAuto aaaa=aaa->buildDAInt(1,self->getNumberOfComponents()); return DataArrayInt::Pow(aaaa,self); } default: @@ -4489,7 +4233,7 @@ namespace ParaMEDMEM std::vector aa; DataArrayIntTuple *aaa; int sw; - convertObjToPossibleCpp1(obj,sw,val,aa,a,aaa); + convertIntStarLikePyObjToCpp(obj,sw,val,aa,a,aaa); switch(sw) { case 1: @@ -4506,7 +4250,7 @@ namespace ParaMEDMEM } case 4: { - MEDCouplingAutoRefCountObjectPtr aaaa=aaa->buildDAInt(1,self->getNumberOfComponents()); + MCAuto aaaa=aaa->buildDAInt(1,self->getNumberOfComponents()); self->powEqual(aaaa); Py_XINCREF(trueSelf); return trueSelf; @@ -4527,7 +4271,7 @@ namespace ParaMEDMEM { int szArr,sw,iTypppArr; std::vector stdvecTyyppArr; - const int *tmp=convertObjToPossibleCpp1_Safe(li,sw,szArr,iTypppArr,stdvecTyyppArr); + const int *tmp=convertIntStarLikePyObjToCppIntStar(li,sw,szArr,iTypppArr,stdvecTyyppArr); self->pushBackValsSilent(tmp,tmp+szArr); } @@ -4541,7 +4285,7 @@ namespace ParaMEDMEM PyObject *pyRet1=PyList_New((int)sz); for(std::size_t i=0;isearchRangesInListOfIds(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_ParaMEDMEM__DataArrayInt, SWIG_POINTER_OWN | 0 )); - PyTuple_SetItem(pyRet,1,SWIG_NewPointerObj(SWIG_as_voidptr(ret1),SWIGTYPE_p_ParaMEDMEM__DataArrayInt, SWIG_POINTER_OWN | 0 )); + 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 )); return pyRet; } @@ -4577,59 +4321,6 @@ namespace ParaMEDMEM PyTuple_SetItem(pyRet,1,ret1Py); return pyRet; } - - // 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; - } - - 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(ParaMEDMEM_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 - } } }; @@ -4646,7 +4337,7 @@ namespace ParaMEDMEM { DataArrayIntTuple *ret=self->nextt(); if(ret) - return SWIG_NewPointerObj(SWIG_as_voidptr(ret),SWIGTYPE_p_ParaMEDMEM__DataArrayIntTuple,SWIG_POINTER_OWN | 0); + return SWIG_NewPointerObj(SWIG_as_voidptr(ret),SWIGTYPE_p_MEDCoupling__DataArrayIntTuple,SWIG_POINTER_OWN | 0); else { PyErr_SetString(PyExc_StopIteration,"No more data."); @@ -4680,40 +4371,39 @@ namespace ParaMEDMEM PyObject *___iadd___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception) { - MEDCouplingAutoRefCountObjectPtr ret=self->buildDAInt(1,self->getNumberOfCompo()); - ParaMEDMEM_DataArrayInt____iadd___(ret,0,obj); + MCAuto ret=self->buildDAInt(1,self->getNumberOfCompo()); + MEDCoupling_DataArrayInt____iadd___(ret,0,obj); Py_XINCREF(trueSelf); return trueSelf; } PyObject *___isub___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception) { - MEDCouplingAutoRefCountObjectPtr ret=self->buildDAInt(1,self->getNumberOfCompo()); - ParaMEDMEM_DataArrayInt____isub___(ret,0,obj); + MCAuto ret=self->buildDAInt(1,self->getNumberOfCompo()); + MEDCoupling_DataArrayInt____isub___(ret,0,obj); Py_XINCREF(trueSelf); return trueSelf; } PyObject *___imul___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception) { - MEDCouplingAutoRefCountObjectPtr ret=self->buildDAInt(1,self->getNumberOfCompo()); - ParaMEDMEM_DataArrayInt____imul___(ret,0,obj); + MCAuto ret=self->buildDAInt(1,self->getNumberOfCompo()); + MEDCoupling_DataArrayInt____imul___(ret,0,obj); Py_XINCREF(trueSelf); return trueSelf; } - PyObject *___idiv___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception) { - MEDCouplingAutoRefCountObjectPtr ret=self->buildDAInt(1,self->getNumberOfCompo()); - ParaMEDMEM_DataArrayInt____idiv___(ret,0,obj); + MCAuto ret=self->buildDAInt(1,self->getNumberOfCompo()); + MEDCoupling_DataArrayInt____idiv___(ret,0,obj); Py_XINCREF(trueSelf); return trueSelf; } PyObject *___imod___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception) { - MEDCouplingAutoRefCountObjectPtr ret=self->buildDAInt(1,self->getNumberOfCompo()); - ParaMEDMEM_DataArrayInt____imod___(ret,0,obj); + MCAuto ret=self->buildDAInt(1,self->getNumberOfCompo()); + MEDCoupling_DataArrayInt____imod___(ret,0,obj); Py_XINCREF(trueSelf); return trueSelf; } @@ -4730,10 +4420,10 @@ namespace ParaMEDMEM int singleVal; std::vector multiVal; std::pair > slic; - ParaMEDMEM::DataArrayInt *daIntTyypp=0; + MEDCoupling::DataArrayInt *daIntTyypp=0; const int *pt=self->getConstPointer(); int nbc=self->getNumberOfCompo(); - convertObjToPossibleCpp2WithNegIntInterp(obj,nbc,sw,singleVal,multiVal,slic,daIntTyypp); + convertIntStarOrSliceLikePyObjToCppWithNegIntInterp(obj,nbc,sw,singleVal,multiVal,slic,daIntTyypp); switch(sw) { case 1: @@ -4796,15 +4486,15 @@ namespace ParaMEDMEM int singleValV; std::vector multiValV; std::pair > slicV; - ParaMEDMEM::DataArrayIntTuple *daIntTyyppV=0; + MEDCoupling::DataArrayIntTuple *daIntTyyppV=0; int nbc=self->getNumberOfCompo(); convertObjToPossibleCpp22(value,nbc,sw1,singleValV,multiValV,slicV,daIntTyyppV); int singleVal; std::vector multiVal; std::pair > slic; - ParaMEDMEM::DataArrayInt *daIntTyypp=0; + MEDCoupling::DataArrayInt *daIntTyypp=0; int *pt=self->getPointer(); - convertObjToPossibleCpp2WithNegIntInterp(obj,nbc,sw2,singleVal,multiVal,slic,daIntTyypp); + convertIntStarOrSliceLikePyObjToCppWithNegIntInterp(obj,nbc,sw2,singleVal,multiVal,slic,daIntTyypp); switch(sw2) { case 1: @@ -4950,7 +4640,7 @@ namespace ParaMEDMEM 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 +4658,25 @@ namespace ParaMEDMEM 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 @@ -5017,7 +4708,7 @@ namespace ParaMEDMEM DataArrayChar *renumber(PyObject *li) throw(INTERP_KERNEL::Exception) { void *da=0; - int res1=SWIG_ConvertPtr(li,&da,SWIGTYPE_p_ParaMEDMEM__DataArrayInt, 0 | 0 ); + int res1=SWIG_ConvertPtr(li,&da,SWIGTYPE_p_MEDCoupling__DataArrayInt, 0 | 0 ); if (!SWIG_IsOK(res1)) { int size; @@ -5046,7 +4737,7 @@ namespace ParaMEDMEM DataArrayChar *renumberR(PyObject *li) throw(INTERP_KERNEL::Exception) { void *da=0; - int res1=SWIG_ConvertPtr(li,&da,SWIGTYPE_p_ParaMEDMEM__DataArrayInt, 0 | 0 ); + int res1=SWIG_ConvertPtr(li,&da,SWIGTYPE_p_MEDCoupling__DataArrayInt, 0 | 0 ); if (!SWIG_IsOK(res1)) { int size; @@ -5075,7 +4766,7 @@ namespace ParaMEDMEM DataArrayChar *renumberAndReduce(PyObject *li, int newNbOfTuple) throw(INTERP_KERNEL::Exception) { void *da=0; - int res1=SWIG_ConvertPtr(li,&da,SWIGTYPE_p_ParaMEDMEM__DataArrayInt, 0 | 0 ); + int res1=SWIG_ConvertPtr(li,&da,SWIGTYPE_p_MEDCoupling__DataArrayInt, 0 | 0 ); if (!SWIG_IsOK(res1)) { int size; @@ -5103,15 +4794,15 @@ namespace ParaMEDMEM static DataArrayChar *Aggregate(PyObject *dachs) throw(INTERP_KERNEL::Exception) { - std::vector tmp; - convertFromPyObjVectorOfObj(dachs,SWIGTYPE_p_ParaMEDMEM__DataArrayChar,"DataArrayChar",tmp); + std::vector tmp; + convertFromPyObjVectorOfObj(dachs,SWIGTYPE_p_MEDCoupling__DataArrayChar,"DataArrayChar",tmp); return DataArrayChar::Aggregate(tmp); } static DataArrayChar *Meld(PyObject *dachs) throw(INTERP_KERNEL::Exception) { - std::vector tmp; - convertFromPyObjVectorOfObj(dachs,SWIGTYPE_p_ParaMEDMEM__DataArrayChar,"DataArrayChar",tmp); + std::vector tmp; + convertFromPyObjVectorOfObj(dachs,SWIGTYPE_p_MEDCoupling__DataArrayChar,"DataArrayChar",tmp); return DataArrayChar::Meld(tmp); } } @@ -5124,7 +4815,7 @@ namespace ParaMEDMEM 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 { @@ -5135,7 +4826,7 @@ namespace ParaMEDMEM static DataArrayByte *New(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *nbOfComp=0) throw(INTERP_KERNEL::Exception) { - const char *msg="ParaMEDMEM::DataArrayByte::New : Available API are : \n-DataArrayByte.New()\n--DataArrayByte.New([1,3,4])\n-DataArrayByte.New([1,3,4],3)\n-DataArrayByte.New([1,3,4,5],2,2)\n-DataArrayByte.New(5)\n-DataArrayByte.New(5,2) !"; + const char *msg="MEDCoupling::DataArrayByte::New : Available API are : \n-DataArrayByte.New()\n--DataArrayByte.New([1,3,4])\n-DataArrayByte.New([1,3,4],3)\n-DataArrayByte.New([1,3,4,5],2,2)\n-DataArrayByte.New(5)\n-DataArrayByte.New(5,2) !"; if(PyList_Check(elt0) || PyTuple_Check(elt0)) { if(nbOfTuples) @@ -5152,7 +4843,7 @@ namespace ParaMEDMEM 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 +4853,7 @@ namespace ParaMEDMEM } 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 +4865,7 @@ namespace ParaMEDMEM } 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 +4886,7 @@ namespace ParaMEDMEM 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,18 +4898,24 @@ namespace ParaMEDMEM } 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); } DataArrayByte(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *nbOfComp=0) throw(INTERP_KERNEL::Exception) { - return ParaMEDMEM_DataArrayByte_New__SWIG_1(elt0,nbOfTuples,nbOfComp); + return MEDCoupling_DataArrayByte_New__SWIG_1(elt0,nbOfTuples,nbOfComp); } std::string __repr__() const throw(INTERP_KERNEL::Exception) @@ -5265,7 +4962,7 @@ namespace ParaMEDMEM { int sz=-1,sw=-1; int ival=-1; std::vector ivval; - const int *pt=convertObjToPossibleCpp1_Safe(tupl,sw,sz,ival,ivval); + const int *pt=convertIntStarLikePyObjToCppIntStar(tupl,sw,sz,ival,ivval); std::vector vals(sz); std::copy(pt,pt+sz,vals.begin()); return self->presenceOfTuple(vals); @@ -5275,40 +4972,40 @@ namespace ParaMEDMEM { int sz=-1,sw=-1; int ival=-1; std::vector ivval; - const int *pt=convertObjToPossibleCpp1_Safe(vals,sw,sz,ival,ivval); + const int *pt=convertIntStarLikePyObjToCppIntStar(vals,sw,sz,ival,ivval); std::vector vals2(sz); std::copy(pt,pt+sz,vals2.begin()); 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); + const int *pt=convertIntStarLikePyObjToCppIntStar(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); + const int *pt=convertIntStarLikePyObjToCppIntStar(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); + const int *pt=convertIntStarLikePyObjToCppIntStar(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 +5048,13 @@ namespace ParaMEDMEM 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 ParaMEDMEM_DataArrayByte_locateTuple(self,obj); + return MEDCoupling_DataArrayByte_findIdFirstEqualTuple(self,obj); } } @@ -5379,9 +5076,16 @@ namespace ParaMEDMEM throw INTERP_KERNEL::Exception("DataArrayByte::__contains__ : 'this' contains one component and trying to find an element which is not an integer !"); } default: - return ParaMEDMEM_DataArrayByte_presenceOfTuple(self,obj); + 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 DataArrayByte *__setitem__(PyObject *obj, PyObject *value) throw(INTERP_KERNEL::Exception) { @@ -5393,13 +5097,13 @@ namespace ParaMEDMEM std::vector v1; DataArrayInt *d1=0; DataArrayIntTuple *dd1=0; - convertObjToPossibleCpp1(value,sw1,i1,v1,d1,dd1); + convertIntStarLikePyObjToCpp(value,sw1,i1,v1,d1,dd1); int it1,ic1; std::vector vt1,vc1; 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 +5346,7 @@ namespace ParaMEDMEM 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 { @@ -5653,7 +5357,7 @@ namespace ParaMEDMEM static DataArrayAsciiChar *New(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *nbOfComp=0) throw(INTERP_KERNEL::Exception) { - const char *msg="ParaMEDMEM::DataArrayAsciiChar::New : Available API are : \n-DataArrayAsciiChar.New()\n-DataArrayAsciiChar.New([1,3,4])\n-DataArrayAsciiChar.New([\"abc\",\"de\",\"fghi\"])\n-DataArrayAsciiChar.New([\"abc\",\"de\",\"fghi\"],\"t\")\n-DataArrayAsciiChar.New([1,3,4],3)\n-DataArrayAsciiChar.New([1,3,4,5],2,2)\n-DataArrayAsciiChar.New(5)\n-DataArrayAsciiChar.New(5,2) !"; + const char *msg="MEDCoupling::DataArrayAsciiChar::New : Available API are : \n-DataArrayAsciiChar.New()\n-DataArrayAsciiChar.New([1,3,4])\n-DataArrayAsciiChar.New([\"abc\",\"de\",\"fghi\"])\n-DataArrayAsciiChar.New([\"abc\",\"de\",\"fghi\"],\"t\")\n-DataArrayAsciiChar.New([1,3,4],3)\n-DataArrayAsciiChar.New([1,3,4,5],2,2)\n-DataArrayAsciiChar.New(5)\n-DataArrayAsciiChar.New(5,2) !"; if(PyList_Check(elt0) || PyTuple_Check(elt0)) { if(nbOfTuples) @@ -5670,7 +5374,7 @@ namespace ParaMEDMEM 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 +5384,7 @@ namespace ParaMEDMEM } 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()); @@ -5698,6 +5402,19 @@ namespace ParaMEDMEM else throw INTERP_KERNEL::Exception(msg); } +%#if PY_VERSION_HEX >= 0x03000000 + else if(PyUnicode_Check(nbOfTuples)) + { + if(PyUnicode_GET_LENGTH(nbOfTuples)!=1) + throw INTERP_KERNEL::Exception(msg); + //DataArrayAsciiChar.New(["abc","de","fghi"],"t") + std::vector tmp; + if(fillStringVector(elt0,tmp)) + return DataArrayAsciiChar::New(tmp,PyUnicode_AsUTF8(nbOfTuples)[0]); + else + throw INTERP_KERNEL::Exception(msg); + } +%#endif else throw INTERP_KERNEL::Exception(msg); } @@ -5710,7 +5427,7 @@ namespace ParaMEDMEM 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 +5449,7 @@ namespace ParaMEDMEM 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 +5461,7 @@ namespace ParaMEDMEM } else {//DataArrayAsciiChar.New(5) - MEDCouplingAutoRefCountObjectPtr ret=DataArrayAsciiChar::New(); + MCAuto ret=DataArrayAsciiChar::New(); ret->alloc(nbOfTuples1,1); return ret.retn(); } @@ -5755,7 +5472,7 @@ namespace ParaMEDMEM DataArrayAsciiChar(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *nbOfComp=0) throw(INTERP_KERNEL::Exception) { - return ParaMEDMEM_DataArrayAsciiChar_New__SWIG_1(elt0,nbOfTuples,nbOfComp); + return MEDCoupling_DataArrayAsciiChar_New__SWIG_1(elt0,nbOfTuples,nbOfComp); } std::string __repr__() const throw(INTERP_KERNEL::Exception) @@ -5806,6 +5523,15 @@ namespace ParaMEDMEM std::copy(PyString_AsString(tupl),PyString_AsString(tupl)+sz,vals.begin()); return self->presenceOfTuple(vals); } +%#if PY_VERSION_HEX >= 0x03000000 + else if(PyUnicode_Check(tupl)) + { + Py_ssize_t sz=PyUnicode_GET_LENGTH(tupl); + std::vector vals(sz); + std::copy(PyUnicode_AsUTF8(tupl),PyUnicode_AsUTF8(tupl)+sz,vals.begin()); + return self->presenceOfTuple(vals); + } +%#endif else throw INTERP_KERNEL::Exception("DataArrayAsciiChar::presenceOfTuple : only strings in input supported !"); } @@ -5819,45 +5545,81 @@ namespace ParaMEDMEM std::copy(PyString_AsString(vals),PyString_AsString(vals)+sz,vals2.begin()); return self->presenceOfValue(vals2); } +%#if PY_VERSION_HEX >= 0x03000000 + if(PyUnicode_Check(vals)) + { + Py_ssize_t sz=PyUnicode_GET_LENGTH(vals); + std::vector vals2(sz); + std::copy(PyUnicode_AsUTF8(vals),PyUnicode_AsUTF8(vals)+sz,vals2.begin()); + return self->presenceOfValue(vals2); + } +%#endif else 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); + } +%#if PY_VERSION_HEX >= 0x03000000 + if(PyUnicode_Check(vals)) + { + Py_ssize_t sz=PyUnicode_GET_LENGTH(vals); + std::vector vals2(sz); + std::copy(PyUnicode_AsUTF8(vals),PyUnicode_AsUTF8(vals)+sz,vals2.begin()); + return self->findIdFirstEqual(vals2); } +%#endif 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); + } +%#if PY_VERSION_HEX >= 0x03000000 + if(PyUnicode_Check(tupl)) + { + Py_ssize_t sz=PyUnicode_GET_LENGTH(tupl); + std::vector vals(sz); + std::copy(PyUnicode_AsUTF8(tupl),PyUnicode_AsUTF8(tupl)+sz,vals.begin()); + return self->findIdFirstEqualTuple(vals); } +%#endif 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); + } +%#if PY_VERSION_HEX >= 0x03000000 + else if(PyUnicode_Check(strOrListOfInt)) + { + Py_ssize_t sz=PyUnicode_GET_LENGTH(strOrListOfInt); + std::vector vals(sz); + std::copy(PyUnicode_AsUTF8(strOrListOfInt),PyUnicode_AsUTF8(strOrListOfInt)+sz,vals.begin()); + return self->findIdSequence(vals); } +%#endif else throw INTERP_KERNEL::Exception("DataArrayAsciiChar::search : only strings in input supported !"); } @@ -5904,15 +5666,26 @@ namespace ParaMEDMEM 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 !"); + } +%#if PY_VERSION_HEX >= 0x03000000 + if(PyUnicode_Check(obj)) + { + Py_ssize_t sz; + char *pt=PyUnicode_AsUTF8AndSize(obj, &sz); + if(sz==1) + 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 !"); } +%#endif else throw INTERP_KERNEL::Exception("DataArrayAsciiChar::index : 'this' contains one component and trying to find an element which is not an integer !"); } default: - return ParaMEDMEM_DataArrayAsciiChar_locateTuple(self,obj); + return MEDCoupling_DataArrayAsciiChar_findIdFirstEqualTuple(self,obj); } } @@ -5934,11 +5707,22 @@ namespace ParaMEDMEM else throw INTERP_KERNEL::Exception("DataArrayAsciiChar::__contains__ : 'this' contains one component and trying to find a string with size different from 1 !"); } +%#if PY_VERSION_HEX >= 0x03000000 + if(PyUnicode_Check(obj)) + { + Py_ssize_t sz; + char *pt=PyUnicode_AsUTF8AndSize(obj, &sz); + if(sz==1) + return self->presenceOfValue(pt[0]); + else + throw INTERP_KERNEL::Exception("DataArrayAsciiChar::__contains__ : 'this' contains one component and trying to find a string with size different from 1 !"); + } +%#endif else throw INTERP_KERNEL::Exception("DataArrayAsciiChar::__contains__ : 'this' contains one component and trying to find an element which is not an integer !"); } default: - return ParaMEDMEM_DataArrayAsciiChar_presenceOfTuple(self,obj); + return MEDCoupling_DataArrayAsciiChar_presenceOfTuple(self,obj); } } @@ -5947,16 +5731,16 @@ namespace ParaMEDMEM int sw,iTypppArr; std::vector stdvecTyyppArr; std::pair > sTyyppArr; - ParaMEDMEM::DataArrayInt *daIntTyypp=0; - convertObjToPossibleCpp2WithNegIntInterp(obj,self->getNumberOfTuples(),sw,iTypppArr,stdvecTyyppArr,sTyyppArr,daIntTyypp); + MEDCoupling::DataArrayInt *daIntTyypp=0; + convertIntStarOrSliceLikePyObjToCppWithNegIntInterp(obj,self->getNumberOfTuples(),sw,iTypppArr,stdvecTyyppArr,sTyyppArr,daIntTyypp); switch(sw) { case 1: - return ParaMEDMEM_DataArrayAsciiChar_getTuple(self,iTypppArr); + return MEDCoupling_DataArrayAsciiChar_getTuple(self,iTypppArr); 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: @@ -5970,10 +5754,10 @@ namespace ParaMEDMEM int sw1,iTypppArr; std::vector stdvecTyyppArr; std::pair > sTyyppArr; - ParaMEDMEM::DataArrayInt *daIntTyypp=0; + MEDCoupling::DataArrayInt *daIntTyypp=0; int nbOfCompo=self->getNumberOfComponents(); int nbOfTuples=self->getNumberOfTuples(); - convertObjToPossibleCpp2WithNegIntInterp(obj,nbOfTuples,sw1,iTypppArr,stdvecTyyppArr,sTyyppArr,daIntTyypp); + convertIntStarOrSliceLikePyObjToCppWithNegIntInterp(obj,nbOfTuples,sw1,iTypppArr,stdvecTyyppArr,sTyyppArr,daIntTyypp); int sw2; char vc; std::string sc; std::vector vsc; DataArrayChar *dacc=0; convertObjToPossibleCpp6(value,sw2,vc,sc,vsc,dacc); @@ -5991,14 +5775,14 @@ namespace ParaMEDMEM //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 +5809,14 @@ namespace ParaMEDMEM //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 +5844,14 @@ namespace ParaMEDMEM //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 +5879,14 @@ namespace ParaMEDMEM //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; } @@ -6137,7 +5921,7 @@ namespace ParaMEDMEM { DataArrayAsciiCharTuple *ret=self->nextt(); if(ret) - return SWIG_NewPointerObj(SWIG_as_voidptr(ret),SWIGTYPE_p_ParaMEDMEM__DataArrayAsciiCharTuple,SWIG_POINTER_OWN | 0); + return SWIG_NewPointerObj(SWIG_as_voidptr(ret),SWIGTYPE_p_MEDCoupling__DataArrayAsciiCharTuple,SWIG_POINTER_OWN | 0); else { PyErr_SetString(PyExc_StopIteration,"No more data."); @@ -6166,3 +5950,32 @@ namespace ParaMEDMEM } }; } + +%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__()),)) +%}