-// Copyright (C) 2007-2021 CEA/DEN, EDF R&D
+// Copyright (C) 2007-2024 CEA, EDF
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
%newobject MEDCoupling::DataArrayInt32::occurenceRankInThis;
%newobject MEDCoupling::DataArrayInt32::buildPermutationArr;
%newobject MEDCoupling::DataArrayInt32::buildPermArrPerLevel;
+%newobject MEDCoupling::DataArrayInt32::locateComponentId;
%newobject MEDCoupling::DataArrayInt32::getDifferentValues;
%newobject MEDCoupling::DataArrayInt32::FindPermutationFromFirstToSecond;
%newobject MEDCoupling::DataArrayInt32::FindPermutationFromFirstToSecondDuplicate;
%newobject MEDCoupling::DataArrayInt64::occurenceRankInThis;
%newobject MEDCoupling::DataArrayInt64::buildPermutationArr;
%newobject MEDCoupling::DataArrayInt64::buildPermArrPerLevel;
+%newobject MEDCoupling::DataArrayInt64::locateComponentId;
%newobject MEDCoupling::DataArrayInt64::getDifferentValues;
%newobject MEDCoupling::DataArrayInt64::FindPermutationFromFirstToSecond;
%newobject MEDCoupling::DataArrayInt64::FindPermutationFromFirstToSecondDuplicate;
%newobject MEDCoupling::DataArrayDouble::deviator;
%newobject MEDCoupling::DataArrayDouble::magnitude;
%newobject MEDCoupling::DataArrayDouble::maxPerTuple;
+%newobject MEDCoupling::DataArrayDouble::minPerTuple;
%newobject MEDCoupling::DataArrayDouble::sumPerTuple;
%newobject MEDCoupling::DataArrayDouble::computeBBoxPerTuple;
%newobject MEDCoupling::DataArrayDouble::buildEuclidianDistanceDenseMatrix;
%newobject MEDCoupling::DataArrayPartDefinition::New;
%newobject MEDCoupling::SlicePartDefinition::New;
+%newobject FromPyIntPtrToDataArrayByte;
+
%feature("unref") DataArray "$this->decrRef();"
%feature("unref") DataArrayDouble "$this->decrRef();"
public:
static MCAuto< MapII > New();
};
-
+
class PartDefinition : public RefCountObject, public TimeLabel
{
public:
{
return self->getRepr();
}
-
+
std::string __repr__() const
{
std::ostringstream oss; oss << "DataArrayPartDefinition C++ instance at " << self << "." << std::endl;
self->getSlice(a,b,c);
return PySlice_New(PyInt_FromLong(a),PyInt_FromLong(b),PyInt_FromLong(c));
}
-
+
std::string __str__() const
{
return self->getRepr();
}
-
+
std::string __repr__() const
{
std::ostringstream oss; oss << "SlicePartDefinition C++ instance at " << self << "." << std::endl;
protected:
virtual ~SlicePartDefinition();
};
-
+
class DataArray : public RefCountObject, public TimeLabel
{
public:
PyList_SetItem(ret,i,PyString_FromString(comps[i].c_str()));
return ret;
}
-
+
void copyPartOfStringInfoFrom(const DataArray& other, PyObject *li)
{
std::vector<std::size_t> tmp;
}
self->setContigPartOfSelectedValues(tupleIdStart,a,tuplesSelecPtr2);
}
-
+
virtual void setContigPartOfSelectedValuesSlice(mcIdType tupleIdStart, PyObject *aBase, mcIdType bg, mcIdType end2, mcIdType step)
{
DataArray *a=CheckAndRetrieveDataArrayInstance(aBase,"DataArray::setContigPartOfSelectedValuesSlice : 2nd parameter \"aBase\" should be of type DataArray");
GetIndicesOfSliceExplicitely(slic,&strt,&stp,&step,"DataArray::GetNumberOfItemGivenBESRelative (wrap) : the input slice is invalid !");
return DataArray::GetNumberOfItemGivenBESRelative(ToIdType(strt),ToIdType(stp),ToIdType(step),"");
}
-
+
static DataArray *Aggregate(PyObject *arrs)
{
std::vector<const DataArray *> tmp;
{
return DataArrayT_New<float>(elt0,nbOfTuples,elt2);
}
-
+
DataArrayFloat(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *elt2=0)
{
return MEDCoupling_DataArrayFloat_New__SWIG_1(elt0,nbOfTuples,elt2);
PyTuple_SetItem(ret,1,PyString_FromString(ret1.c_str()));
return ret;
}
-
+
PyObject *__getitem__(PyObject *obj)
{
return DataArrayT__getitem<float>(self,obj);
{
return DataArrayT__setitem__<float>(self,obj,value);
}
-
+
PyObject *___iadd___(PyObject *trueSelf, PyObject *obj)
{
return DataArrayT_iadd<float>(trueSelf,obj,self);
{
return DataArrayT_idiv<float>(trueSelf,obj,self);
}
-
+
#ifdef WITH_NUMPY
PyObject *toNumPyArray() // not const. It is not a bug !
{
{
return self->buildDAFloat(1,self->getNumberOfCompo());
}
-
+
/*PyObject *___imul___(PyObject *trueSelf, PyObject *obj)
{
MCAuto<DataArrayFloat> ret=self->buildDAFloat(1,self->getNumberOfCompo());
}
}
};
-
+
class DataArrayDoubleIterator;
-
+
class DataArrayDouble : public DataArray
{
public:
DataArrayDouble *deviator() const;
DataArrayDouble *magnitude() const;
DataArrayDouble *maxPerTuple() const;
+ DataArrayDouble *minPerTuple() const;
DataArrayDouble *sumPerTuple() const;
DataArrayDouble *buildEuclidianDistanceDenseMatrix() const;
DataArrayDouble *buildEuclidianDistanceDenseMatrixWith(const DataArrayDouble *other) const;
MCAuto<DataArrayIdType> findIdsLowerOrEqualTo(double val) const;
MCAuto<DataArrayIdType> findIdsLowerThan(double val) const;
MCAuto<DataArrayInt32> convertToIntArr() const;
+ MCAuto<DataArrayInt64> convertToInt64Arr() const;
MCAuto<DataArrayDouble> selectPartDef(const PartDefinition* pd) const;
MCAuto<DataArrayDouble> cumSum() const;
MCAuto<DataArrayFloat> convertToFloatArr() const;
{
return DataArrayT_New<double>(elt0,nbOfTuples,elt2);
}
-
+
DataArrayDouble(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *elt2=0)
{
return MEDCoupling_DataArrayDouble_New__SWIG_1(elt0,nbOfTuples,elt2);
PyTuple_SetItem(ret,0,ret0);
}
PyTuple_SetItem(ret,1,PyFloat_FromDouble(radius));
- PyTuple_SetItem(ret,2,PyFloat_FromDouble(ang));
+ PyTuple_SetItem(ret,2,PyFloat_FromDouble(ang));
return ret;
}
{
return self->iterator();
}
-
+
void setValues(PyObject *li, PyObject *nbOfTuples=0, PyObject *nbOfComp=0)
{
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 !";
PyTuple_SetItem(ret,1,PyFloat_FromDouble(res1));
return ret;
}
-
+
DataArrayDouble *symmetry3DPlane(PyObject *point, PyObject *normalVector)
{
const char msg[]="Python wrap of DataArrayDouble::symmetry3DPlane : ";
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)
{
void *da=0;
PyObject *ret=convertDblArrToPyListOfTuple<double>(tmp,2,ToIdType(nbOfCompo));
return ret;
}
-
+
PyObject *normMaxPerComponent() const
{
std::size_t nbOfCompo(self->getNumberOfComponents());
PyList_SetItem(res,i,SWIG_NewPointerObj(SWIG_as_voidptr(retCpp[i].retn()),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 ));
return res;
}
-
+
PyObject *getTuple(mcIdType tupleId)
{
std::size_t sz=self->getNumberOfComponents();
throw INTERP_KERNEL::Exception(msg);
}
}
-
+
PyObject *___iadd___(PyObject *trueSelf, PyObject *obj)
{
return DataArrayT_iadd<double>(trueSelf,obj,self);
{
return DataArrayT_idiv<double>(trueSelf,obj,self);
}
-
+
DataArrayDouble *__pow__(PyObject *obj)
{
const char msg[]="Unexpected situation in __pow__ !";
throw INTERP_KERNEL::Exception(msg);
}
}
-
+
PyObject *computeTupleIdsNearTuples(const DataArrayDouble *other, double eps)
{
DataArrayIdType *c=0,*cI=0;
Py_XINCREF(trueSelf);
return trueSelf;
}
-
+
PyObject *___isub___(PyObject *trueSelf, PyObject *obj)
{
MCAuto<DataArrayDouble> ret=self->buildDADouble(1,self->getNumberOfCompo());
Py_XINCREF(trueSelf);
return trueSelf;
}
-
+
PyObject *___imul___(PyObject *trueSelf, PyObject *obj)
{
MCAuto<DataArrayDouble> ret=self->buildDADouble(1,self->getNumberOfCompo());
throw INTERP_KERNEL::Exception("DataArrayChar::__len__ : Instance is NOT allocated !");
}
}
-
+
PyObject *isEqualIfNotWhy(const DataArrayChar& other) const
{
std::string ret1;
PyTuple_SetItem(ret,1,PyString_FromString(ret1.c_str()));
return ret;
}
-
+
DataArrayChar *renumber(PyObject *li)
{
void *da=0;
return self->renumber(da2->getConstPointer());
}
}
-
+
DataArrayChar *renumberR(PyObject *li)
{
void *da=0;
return self->renumberR(da2->getConstPointer());
}
}
-
+
DataArrayChar *renumberAndReduce(PyObject *li, mcIdType newNbOfTuple)
{
void *da=0;
return self->renumberAndReduce(da2->getConstPointer(),newNbOfTuple);
}
}
-
+
static DataArrayChar *Aggregate(PyObject *dachs)
{
std::vector<const MEDCoupling::DataArrayChar *> tmp;
convertFromPyObjVectorOfObj<const MEDCoupling::DataArrayChar *>(dachs,SWIGTYPE_p_MEDCoupling__DataArrayChar,"DataArrayChar",tmp);
return DataArrayChar::Aggregate(tmp);
}
-
+
static DataArrayChar *Meld(PyObject *dachs)
{
std::vector<const MEDCoupling::DataArrayChar *> tmp;
}
}
};
-
+
class DataArrayByteIterator;
class DataArrayByte : public DataArrayChar
{
return MEDCoupling_DataArrayByte_New__SWIG_1(elt0,nbOfTuples,nbOfComp);
}
-
+
std::string __repr__() const
{
std::ostringstream oss;
self->reprQuickOverview(oss);
return oss.str();
}
-
+
int __int__() const
{
return (int) self->byteValue();
{
return (mcIdType)self->getIJ(tupleId,compoId);
}
-
+
mcIdType getIJSafe(mcIdType tupleId, mcIdType compoId) const
{
return (mcIdType)self->getIJSafe(tupleId,compoId);
mcIdType nbOfTuples=self->getNumberOfTuples();
return convertCharArrToPyListOfTuple(vals,(int)nbOfComp,nbOfTuples);
}
-
+
bool presenceOfTuple(PyObject *tupl) const
{
mcIdType sz=-1,sw=-1;
return MEDCoupling_DataArrayByte_presenceOfTuple(self,obj);
}
}
-
+
#ifdef WITH_NUMPY
PyObject *toNumPyArray() // not const. It is not a bug !
{
{
return self->repr();
}
-
+
char __int__() const
{
return self->byteValue();
}
-
+
DataArrayByte *buildDAByte()
{
return self->buildDAByte(1,self->getNumberOfCompo());
}
}
};
-
+
class DataArrayAsciiCharIterator;
-
+
class DataArrayAsciiChar : public DataArrayChar
{
public:
tmp[0]=self->getIJ(tupleId,compoId);
return std::string(tmp);
}
-
+
std::string getIJSafe(mcIdType tupleId, mcIdType compoId) const
{
char tmp[2]; tmp[1]='\0';
else
throw INTERP_KERNEL::Exception("DataArrayAsciiChar::presenceOfTuple : only strings in input supported !");
}
-
+
bool presenceOfValue(PyObject *vals) const
{
if(PyString_Check(vals))
else
throw INTERP_KERNEL::Exception("DataArrayAsciiChar::search : only strings in input supported !");
}
-
+
PyObject *getTuple(mcIdType tupleId) const
{
std::size_t sz=self->getNumberOfComponents();
{
return self->repr();
}
-
+
DataArrayAsciiChar *buildDAAsciiChar()
{
return self->buildDAAsciiChar(1,self->getNumberOfCompo());
}
}
};
+
+}
+
+%inline
+{
+ MEDCoupling::DataArrayByte *FromPyIntPtrToDataArrayByte(mcPyPtrType intPtr)
+ {
+ MEDCoupling::DataArrayByte *ret(reinterpret_cast<MEDCoupling::DataArrayByte *>(intPtr));
+ return ret;
+ }
}
%include "DataArrayInt.i"
+
%pythoncode %{
def MEDCouplingStdReduceFunct(cls,params):
a,b=params
