Back to index

salome-med  6.5.0
Public Member Functions | Static Public Member Functions | Protected Member Functions | Static Protected Member Functions | Protected Attributes | Private Member Functions | Private Attributes | Static Private Attributes
ParaMEDMEM::DataArrayDouble Class Reference

#include <MEDCouplingMemArray.hxx>

Inheritance diagram for ParaMEDMEM::DataArrayDouble:
Inheritance graph
[legend]
Collaboration diagram for ParaMEDMEM::DataArrayDouble:
Collaboration graph
[legend]

List of all members.

Public Member Functions

MEDCOUPLING_EXPORT bool isAllocated () const
MEDCOUPLING_EXPORT void checkAllocated () const throw (INTERP_KERNEL::Exception)
MEDCOUPLING_EXPORT void setInfoAndChangeNbOfCompo (const std::vector< std::string > &info) throw (INTERP_KERNEL::Exception)
 This method differs from DataArray::setInfoOnComponents in the sense that if 'this->getNumberOfComponents()!=info.size()' and if 'this' is not allocated it will change the number of components of 'this'.
MEDCOUPLING_EXPORT double doubleValue () const throw (INTERP_KERNEL::Exception)
 This method returns the only one value in 'this', if and only if number of elements (nb of tuples * nb of components) is equal to 1, and that 'this' is allocated.
MEDCOUPLING_EXPORT bool empty () const throw (INTERP_KERNEL::Exception)
 This method should be called on an allocated DataArrayDouble instance.
MEDCOUPLING_EXPORT
DataArrayDouble
deepCpy () const
MEDCOUPLING_EXPORT
DataArrayDouble
performCpy (bool deepCpy) const
MEDCOUPLING_EXPORT void cpyFrom (const DataArrayDouble &other) throw (INTERP_KERNEL::Exception)
MEDCOUPLING_EXPORT void alloc (int nbOfTuple, int nbOfCompo) throw (INTERP_KERNEL::Exception)
MEDCOUPLING_EXPORT void allocIfNecessary (int nbOfTuple, int nbOfCompo)
MEDCOUPLING_EXPORT void fillWithZero () throw (INTERP_KERNEL::Exception)
MEDCOUPLING_EXPORT void fillWithValue (double val) throw (INTERP_KERNEL::Exception)
MEDCOUPLING_EXPORT void iota (double init=0.) throw (INTERP_KERNEL::Exception)
MEDCOUPLING_EXPORT bool isUniform (double val, double eps) const throw (INTERP_KERNEL::Exception)
MEDCOUPLING_EXPORT void sort () throw (INTERP_KERNEL::Exception)
MEDCOUPLING_EXPORT void reverse () throw (INTERP_KERNEL::Exception)
MEDCOUPLING_EXPORT void checkMonotonic (bool increasing, double eps) const throw (INTERP_KERNEL::Exception)
 This method check that (Maths) array consistently INCREASING or DECREASING in value, with at least absolute difference value of |eps| at each step.
MEDCOUPLING_EXPORT bool isMonotonic (bool increasing, double eps) const throw (INTERP_KERNEL::Exception)
 This method check that (Maths) array consistently INCREASING or DECREASING in value, with at least absolute difference value of |eps| at each step.
MEDCOUPLING_EXPORT std::string repr () const
MEDCOUPLING_EXPORT std::string reprZip () const
MEDCOUPLING_EXPORT void writeVTK (std::ostream &ofs, int indent, const char *nameInFile) const throw (INTERP_KERNEL::Exception)
MEDCOUPLING_EXPORT void reprStream (std::ostream &stream) const
MEDCOUPLING_EXPORT void reprZipStream (std::ostream &stream) const
MEDCOUPLING_EXPORT void reprWithoutNameStream (std::ostream &stream) const
MEDCOUPLING_EXPORT void reprZipWithoutNameStream (std::ostream &stream) const
MEDCOUPLING_EXPORT bool isEqual (const DataArrayDouble &other, double prec) const
MEDCOUPLING_EXPORT bool isEqualWithoutConsideringStr (const DataArrayDouble &other, double prec) const
MEDCOUPLING_EXPORT void reAlloc (int nbOfTuples) throw (INTERP_KERNEL::Exception)
 alloc or useArray should have been called before.
MEDCOUPLING_EXPORT DataArrayIntconvertToIntArr () const
MEDCOUPLING_EXPORT
DataArrayDouble
fromNoInterlace () const throw (INTERP_KERNEL::Exception)
MEDCOUPLING_EXPORT
DataArrayDouble
toNoInterlace () const throw (INTERP_KERNEL::Exception)
MEDCOUPLING_EXPORT void renumberInPlace (const int *old2New)
 This method does not change the number of tuples after this call.
MEDCOUPLING_EXPORT void renumberInPlaceR (const int *new2Old)
 This method does not change the number of tuples after this call.
MEDCOUPLING_EXPORT
DataArrayDouble
renumber (const int *old2New) const
 This method does not change the number of tuples after this call.
MEDCOUPLING_EXPORT
DataArrayDouble
renumberR (const int *new2Old) const
 This method does not change the number of tuples after this call.
MEDCOUPLING_EXPORT
DataArrayDouble
renumberAndReduce (const int *old2New, int newNbOfTuple) const
 Idem DataArrayDouble::renumber method except that the number of tuples is reduced.
MEDCOUPLING_EXPORT
DataArrayDouble
selectByTupleId (const int *new2OldBg, const int *new2OldEnd) const
 This method is a generalization of DataArrayDouble::substr method because a not contigous range can be specified here.
MEDCOUPLING_EXPORT
DataArrayDouble
selectByTupleIdSafe (const int *new2OldBg, const int *new2OldEnd) const throw (INTERP_KERNEL::Exception)
 This method is equivalent to DataArrayDouble::selectByTupleId except that an analyze to the content of input range to check that it will not lead to memory corruption !
MEDCOUPLING_EXPORT
DataArrayDouble
selectByTupleId2 (int bg, int end2, int step) const throw (INTERP_KERNEL::Exception)
 Idem than DataArrayInt::selectByTupleIdSafe except that the input array is not constructed explicitely.
MEDCOUPLING_EXPORT
DataArrayDouble
selectByTupleRanges (const std::vector< std::pair< int, int > > &ranges) const throw (INTERP_KERNEL::Exception)
 This method returns a newly allocated array that is the concatenation of all tuples ranges in param 'ranges'.
MEDCOUPLING_EXPORT
DataArrayDouble
substr (int tupleIdBg, int tupleIdEnd=-1) const throw (INTERP_KERNEL::Exception)
 This methods has a similar behaviour than std::string::substr.
MEDCOUPLING_EXPORT void rearrange (int newNbOfCompo) throw (INTERP_KERNEL::Exception)
 Contrary to DataArrayDouble::changeNbOfComponents method this method is not const.
MEDCOUPLING_EXPORT void transpose () throw (INTERP_KERNEL::Exception)
 This method makes the assumption that this is allocated.
MEDCOUPLING_EXPORT
DataArrayDouble
changeNbOfComponents (int newNbOfComp, double dftValue) const throw (INTERP_KERNEL::Exception)
 This method builds a new instance of DataArrayDouble (to deal with) that is reduction or an extension of 'this'.
MEDCOUPLING_EXPORT
DataArrayDouble
keepSelectedComponents (const std::vector< int > &compoIds) const throw (INTERP_KERNEL::Exception)
MEDCOUPLING_EXPORT void meldWith (const DataArrayDouble *other) throw (INTERP_KERNEL::Exception)
 This method melds the components of 'this' with components of 'other'.
MEDCOUPLING_EXPORT void findCommonTuples (double prec, int limitTupleId, DataArrayInt *&comm, DataArrayInt *&commIndex) const throw (INTERP_KERNEL::Exception)
 This methods searches for each tuple if there are any tuples in 'this' that are less far than 'prec' from n1.
MEDCOUPLING_EXPORT
DataArrayDouble
getDifferentValues (double prec, int limitTupleId=-1) const throw (INTERP_KERNEL::Exception)
 This method returns a newly allocated object the user should deal with.
MEDCOUPLING_EXPORT void setSelectedComponents (const DataArrayDouble *a, const std::vector< int > &compoIds) throw (INTERP_KERNEL::Exception)
MEDCOUPLING_EXPORT void setPartOfValues1 (const DataArrayDouble *a, int bgTuples, int endTuples, int stepTuples, int bgComp, int endComp, int stepComp, bool strictCompoCompare=true) throw (INTERP_KERNEL::Exception)
 This method performs a partial assignment of 'this' using 'a' as input.
MEDCOUPLING_EXPORT void setPartOfValuesSimple1 (double a, int bgTuples, int endTuples, int stepTuples, int bgComp, int endComp, int stepComp) throw (INTERP_KERNEL::Exception)
 This method performs a partial assignment of 'this' using 'a' as input.
MEDCOUPLING_EXPORT void setPartOfValues2 (const DataArrayDouble *a, const int *bgTuples, const int *endTuples, const int *bgComp, const int *endComp, bool strictCompoCompare=true) throw (INTERP_KERNEL::Exception)
 This method performs a partial assignment of 'this' using 'a' as input.
MEDCOUPLING_EXPORT void setPartOfValuesSimple2 (double a, const int *bgTuples, const int *endTuples, const int *bgComp, const int *endComp) throw (INTERP_KERNEL::Exception)
 This method performs a partial assignment of 'this' using 'a' as input.
MEDCOUPLING_EXPORT void setPartOfValues3 (const DataArrayDouble *a, const int *bgTuples, const int *endTuples, int bgComp, int endComp, int stepComp, bool strictCompoCompare=true) throw (INTERP_KERNEL::Exception)
 This method performs a partial assignment of 'this' using 'a' as input.
MEDCOUPLING_EXPORT void setPartOfValuesSimple3 (double a, const int *bgTuples, const int *endTuples, int bgComp, int endComp, int stepComp) throw (INTERP_KERNEL::Exception)
 This method performs a partial assignment of 'this' using 'a' as input.
MEDCOUPLING_EXPORT void setPartOfValuesAdv (const DataArrayDouble *a, const DataArrayInt *tuplesSelec) throw (INTERP_KERNEL::Exception)
 'this', 'a' and 'tuplesSelec' are expected to be defined.
MEDCOUPLING_EXPORT void setContigPartOfSelectedValues (int tupleIdStart, const DataArrayDouble *a, const DataArrayInt *tuplesSelec) throw (INTERP_KERNEL::Exception)
 'this', 'a' and 'tuplesSelec' are expected to be defined.
MEDCOUPLING_EXPORT void setContigPartOfSelectedValues2 (int tupleIdStart, const DataArrayDouble *a, int bg, int end2, int step) throw (INTERP_KERNEL::Exception)
 'this' and 'a' are expected to be defined.
MEDCOUPLING_EXPORT void getTuple (int tupleId, double *res) const
MEDCOUPLING_EXPORT double getIJ (int tupleId, int compoId) const
MEDCOUPLING_EXPORT double back () const throw (INTERP_KERNEL::Exception)
 This method returns the last element in 'this'.
MEDCOUPLING_EXPORT double getIJSafe (int tupleId, int compoId) const throw (INTERP_KERNEL::Exception)
 This method is equivalent to DataArrayDouble::getIJ except that here tupleId is checked to be in [0,this->getNumberOfTuples()) and compoId to be in [0,this->getNumberOfComponents()).
MEDCOUPLING_EXPORT void setIJ (int tupleId, int compoId, double newVal)
MEDCOUPLING_EXPORT void setIJSilent (int tupleId, int compoId, double newVal)
MEDCOUPLING_EXPORT double * getPointer ()
MEDCOUPLING_EXPORT const double * getConstPointer () const
MEDCOUPLING_EXPORT
DataArrayDoubleIterator
iterator ()
MEDCOUPLING_EXPORT const double * begin () const
MEDCOUPLING_EXPORT const double * end () const
MEDCOUPLING_EXPORT void useArray (const double *array, bool ownership, DeallocType type, int nbOfTuple, int nbOfCompo)
MEDCOUPLING_EXPORT void writeOnPlace (int id, double element0, const double *others, int sizeOfOthers)
MEDCOUPLING_EXPORT void checkNoNullValues () const throw (INTERP_KERNEL::Exception)
MEDCOUPLING_EXPORT void getMinMaxPerComponent (double *bounds) const throw (INTERP_KERNEL::Exception)
 This method assume that this is allocated.
MEDCOUPLING_EXPORT double getMaxValue (int &tupleId) const throw (INTERP_KERNEL::Exception)
MEDCOUPLING_EXPORT double getMaxValueInArray () const throw (INTERP_KERNEL::Exception)
 Idem to DataArrayDouble::getMaxValue expect that here number of components can be >=1.
MEDCOUPLING_EXPORT double getMinValue (int &tupleId) const throw (INTERP_KERNEL::Exception)
MEDCOUPLING_EXPORT double getMinValueInArray () const throw (INTERP_KERNEL::Exception)
 Idem to DataArrayDouble::getMinValue expect that here number of components can be >=1.
MEDCOUPLING_EXPORT double getMaxValue2 (DataArrayInt *&tupleIds) const throw (INTERP_KERNEL::Exception)
MEDCOUPLING_EXPORT double getMinValue2 (DataArrayInt *&tupleIds) const throw (INTERP_KERNEL::Exception)
MEDCOUPLING_EXPORT double getAverageValue () const throw (INTERP_KERNEL::Exception)
MEDCOUPLING_EXPORT double norm2 () const throw (INTERP_KERNEL::Exception)
MEDCOUPLING_EXPORT double normMax () const throw (INTERP_KERNEL::Exception)
MEDCOUPLING_EXPORT void accumulate (double *res) const throw (INTERP_KERNEL::Exception)
MEDCOUPLING_EXPORT double accumulate (int compId) const throw (INTERP_KERNEL::Exception)
MEDCOUPLING_EXPORT
DataArrayDouble
fromPolarToCart () const throw (INTERP_KERNEL::Exception)
MEDCOUPLING_EXPORT
DataArrayDouble
fromCylToCart () const throw (INTERP_KERNEL::Exception)
MEDCOUPLING_EXPORT
DataArrayDouble
fromSpherToCart () const throw (INTERP_KERNEL::Exception)
MEDCOUPLING_EXPORT
DataArrayDouble
doublyContractedProduct () const throw (INTERP_KERNEL::Exception)
MEDCOUPLING_EXPORT
DataArrayDouble
determinant () const throw (INTERP_KERNEL::Exception)
MEDCOUPLING_EXPORT
DataArrayDouble
eigenValues () const throw (INTERP_KERNEL::Exception)
MEDCOUPLING_EXPORT
DataArrayDouble
eigenVectors () const throw (INTERP_KERNEL::Exception)
MEDCOUPLING_EXPORT
DataArrayDouble
inverse () const throw (INTERP_KERNEL::Exception)
MEDCOUPLING_EXPORT
DataArrayDouble
trace () const throw (INTERP_KERNEL::Exception)
MEDCOUPLING_EXPORT
DataArrayDouble
deviator () const throw (INTERP_KERNEL::Exception)
MEDCOUPLING_EXPORT
DataArrayDouble
magnitude () const throw (INTERP_KERNEL::Exception)
MEDCOUPLING_EXPORT
DataArrayDouble
maxPerTuple () const throw (INTERP_KERNEL::Exception)
MEDCOUPLING_EXPORT void sortPerTuple (bool asc) throw (INTERP_KERNEL::Exception)
MEDCOUPLING_EXPORT void abs () throw (INTERP_KERNEL::Exception)
MEDCOUPLING_EXPORT void applyLin (double a, double b, int compoId) throw (INTERP_KERNEL::Exception)
MEDCOUPLING_EXPORT void applyLin (double a, double b) throw (INTERP_KERNEL::Exception)
MEDCOUPLING_EXPORT void applyInv (double numerator) throw (INTERP_KERNEL::Exception)
 This method applies the operation 'numerator/x' for each element 'x' in 'this'.
MEDCOUPLING_EXPORT
DataArrayDouble
negate () const throw (INTERP_KERNEL::Exception)
 This method returns a newly allocated array containing the application of negate on this.
MEDCOUPLING_EXPORT
DataArrayDouble
applyFunc (int nbOfComp, FunctionToEvaluate func) const throw (INTERP_KERNEL::Exception)
MEDCOUPLING_EXPORT
DataArrayDouble
applyFunc (int nbOfComp, const char *func) const throw (INTERP_KERNEL::Exception)
 This method returns a newly allocated array the caller should deal with.
MEDCOUPLING_EXPORT
DataArrayDouble
applyFunc (const char *func) const throw (INTERP_KERNEL::Exception)
MEDCOUPLING_EXPORT
DataArrayDouble
applyFunc2 (int nbOfComp, const char *func) const throw (INTERP_KERNEL::Exception)
 This method is equivalent than DataArrayDouble::applyFunc, except that here components names are used to determine vars orders.
MEDCOUPLING_EXPORT
DataArrayDouble
applyFunc3 (int nbOfComp, const std::vector< std::string > &varsOrder, const char *func) const throw (INTERP_KERNEL::Exception)
 This method is equivalent than DataArrayDouble::applyFunc, except that here order of vars is passed explicitely in parameter.
MEDCOUPLING_EXPORT void applyFuncFast32 (const char *func) throw (INTERP_KERNEL::Exception)
MEDCOUPLING_EXPORT void applyFuncFast64 (const char *func) throw (INTERP_KERNEL::Exception)
MEDCOUPLING_EXPORT DataArrayIntgetIdsInRange (double vmin, double vmax) const throw (INTERP_KERNEL::Exception)
MEDCOUPLING_EXPORT void addEqual (const DataArrayDouble *other) throw (INTERP_KERNEL::Exception)
MEDCOUPLING_EXPORT void substractEqual (const DataArrayDouble *other) throw (INTERP_KERNEL::Exception)
MEDCOUPLING_EXPORT void multiplyEqual (const DataArrayDouble *other) throw (INTERP_KERNEL::Exception)
MEDCOUPLING_EXPORT void divideEqual (const DataArrayDouble *other) throw (INTERP_KERNEL::Exception)
MEDCOUPLING_EXPORT void updateTime () const
 nothing to do here because this class does not aggregate any TimeLabel instance.
MEDCOUPLING_EXPORT void getTinySerializationIntInformation (std::vector< int > &tinyInfo) const
 Useless method for end user.
MEDCOUPLING_EXPORT void getTinySerializationStrInformation (std::vector< std::string > &tinyInfo) const
 Useless method for end user.
MEDCOUPLING_EXPORT bool resizeForUnserialization (const std::vector< int > &tinyInfoI)
 Useless method for end user.
MEDCOUPLING_EXPORT void finishUnserialization (const std::vector< int > &tinyInfoI, const std::vector< std::string > &tinyInfoS)
 Useless method for end user.
def __init__
def isAllocated
def checkAllocated
def setInfoAndChangeNbOfCompo
def doubleValue
def empty
def deepCpy
def performCpy
def cpyFrom
def alloc
def allocIfNecessary
def fillWithZero
def fillWithValue
def iota
def isUniform
def sort
def reverse
def checkMonotonic
def isMonotonic
def repr
def reprZip
def reprStream
def reprZipStream
def reprWithoutNameStream
def reprZipWithoutNameStream
def isEqual
def isEqualWithoutConsideringStr
def reAlloc
def convertToIntArr
def fromNoInterlace
def toNoInterlace
def selectByTupleId2
def substr
def rearrange
def transpose
def changeNbOfComponents
def meldWith
def getDifferentValues
def setPartOfValues1
def setPartOfValuesSimple1
def setPartOfValues2
def setPartOfValuesSimple2
def setPartOfValues3
def setPartOfValuesSimple3
def setPartOfValuesAdv
def setContigPartOfSelectedValues
def setContigPartOfSelectedValues2
def getIJ
def back
def getIJSafe
def setIJ
def setIJSilent
def getPointer
def getConstPointer
def iterator
def begin
def end
def useArray
def writeOnPlace
def checkNoNullValues
def getMaxValueInArray
def getMinValueInArray
def getAverageValue
def norm2
def normMax
def fromPolarToCart
def fromCylToCart
def fromSpherToCart
def doublyContractedProduct
def determinant
def eigenValues
def eigenVectors
def inverse
def trace
def deviator
def magnitude
def maxPerTuple
def sortPerTuple
def abs
def applyLin
def applyInv
def negate
def applyFunc
def applyFunc2
def applyFunc3
def applyFuncFast32
def applyFuncFast64
def getIdsInRange
def Dot
def CrossProduct
def Max
def Min
def Add
def addEqual
def Substract
def substractEqual
def Multiply
def multiplyEqual
def Divide
def divideEqual
def updateTime
def getTinySerializationIntInformation
def getTinySerializationStrInformation
def resizeForUnserialization
def finishUnserialization
def New
def __str__
def __float__
def __len__
def __iter__
def setValues
def getValues
def getValuesAsTuple
def renumber
def renumberR
def renumberAndReduce
def renumberInPlace
def renumberInPlaceR
def selectByTupleId
def selectByTupleIdSafe
def getMaxValue
def getMaxValue2
def getMinValue
def getMinValue2
def getMinMaxPerComponent
def accumulate
def keepSelectedComponents
def findCommonTuples
def setSelectedComponents
def getTuple
def Aggregate
def Meld
def selectByTupleRanges
def __getitem__
def __setitem__
def __neg__
def __add__
def __radd__
def __iadd__
def __sub__
def __rsub__
def __isub__
def __mul__
def __rmul__
def __imul__
def __div__
def __rdiv__
def __idiv__
MEDCOUPLING_EXPORT void setName (const char *name)
def setName
MEDCOUPLING_EXPORT void copyStringInfoFrom (const DataArray &other) throw (INTERP_KERNEL::Exception)
def copyStringInfoFrom
MEDCOUPLING_EXPORT void copyPartOfStringInfoFrom (const DataArray &other, const std::vector< int > &compoIds) throw (INTERP_KERNEL::Exception)
def copyPartOfStringInfoFrom
MEDCOUPLING_EXPORT void copyPartOfStringInfoFrom2 (const std::vector< int > &compoIds, const DataArray &other) throw (INTERP_KERNEL::Exception)
def copyPartOfStringInfoFrom2
MEDCOUPLING_EXPORT bool areInfoEquals (const DataArray &other) const
def areInfoEquals
MEDCOUPLING_EXPORT std::string getName () const
def getName
MEDCOUPLING_EXPORT const
std::vector< std::string > & 
getInfoOnComponents () const
MEDCOUPLING_EXPORT std::vector
< std::string > & 
getInfoOnComponents ()
def getInfoOnComponents
MEDCOUPLING_EXPORT void setInfoOnComponents (const std::vector< std::string > &info) throw (INTERP_KERNEL::Exception)
def setInfoOnComponents
MEDCOUPLING_EXPORT std::vector
< std::string > 
getVarsOnComponent () const
def getVarsOnComponent
MEDCOUPLING_EXPORT std::vector
< std::string > 
getUnitsOnComponent () const
def getUnitsOnComponent
MEDCOUPLING_EXPORT std::string getInfoOnComponent (int i) const throw (INTERP_KERNEL::Exception)
def getInfoOnComponent
MEDCOUPLING_EXPORT std::string getVarOnComponent (int i) const throw (INTERP_KERNEL::Exception)
 In the info part of i_th component this method returns the var part.
def getVarOnComponent
MEDCOUPLING_EXPORT std::string getUnitOnComponent (int i) const throw (INTERP_KERNEL::Exception)
 In the info part of i_th component this method returns the var part.
def getUnitOnComponent
MEDCOUPLING_EXPORT void setInfoOnComponent (int i, const char *info) throw (INTERP_KERNEL::Exception)
def setInfoOnComponent
MEDCOUPLING_EXPORT int getNumberOfComponents () const
def getNumberOfComponents
MEDCOUPLING_EXPORT int getNumberOfTuples () const
def getNumberOfTuples
MEDCOUPLING_EXPORT int getNbOfElems () const
def getNbOfElems
MEDCOUPLING_EXPORT void checkNbOfTuplesAndComp (const DataArray &other, const char *msg) const throw (INTERP_KERNEL::Exception)
MEDCOUPLING_EXPORT void checkNbOfTuplesAndComp (int nbOfTuples, int nbOfCompo, const char *msg) const throw (INTERP_KERNEL::Exception)
def checkNbOfTuplesAndComp
MEDCOUPLING_EXPORT void checkNbOfElems (int nbOfElems, const char *msg) const throw (INTERP_KERNEL::Exception)
def checkNbOfElems
def GetNumberOfItemGivenBES
def GetNumberOfItemGivenBESRelative
def GetVarNameFromInfo
def GetUnitFromInfo
def incrRef
def getHiddenCppPointer
def assign
def declareAsNew
def getTimeOfThis

Static Public Member Functions

static MEDCOUPLING_EXPORT
DataArrayDouble
New ()
static MEDCOUPLING_EXPORT void SetArrayIn (DataArrayDouble *newArray, DataArrayDouble *&arrayToSet)
static MEDCOUPLING_EXPORT
DataArrayDouble
Aggregate (const DataArrayDouble *a1, const DataArrayDouble *a2) throw (INTERP_KERNEL::Exception)
static MEDCOUPLING_EXPORT
DataArrayDouble
Aggregate (const std::vector< const DataArrayDouble * > &a) throw (INTERP_KERNEL::Exception)
static MEDCOUPLING_EXPORT
DataArrayDouble
Meld (const DataArrayDouble *a1, const DataArrayDouble *a2) throw (INTERP_KERNEL::Exception)
static MEDCOUPLING_EXPORT
DataArrayDouble
Meld (const std::vector< const DataArrayDouble * > &a) throw (INTERP_KERNEL::Exception)
static MEDCOUPLING_EXPORT
DataArrayDouble
Dot (const DataArrayDouble *a1, const DataArrayDouble *a2) throw (INTERP_KERNEL::Exception)
static MEDCOUPLING_EXPORT
DataArrayDouble
CrossProduct (const DataArrayDouble *a1, const DataArrayDouble *a2) throw (INTERP_KERNEL::Exception)
static MEDCOUPLING_EXPORT
DataArrayDouble
Max (const DataArrayDouble *a1, const DataArrayDouble *a2) throw (INTERP_KERNEL::Exception)
static MEDCOUPLING_EXPORT
DataArrayDouble
Min (const DataArrayDouble *a1, const DataArrayDouble *a2) throw (INTERP_KERNEL::Exception)
static MEDCOUPLING_EXPORT
DataArrayDouble
Add (const DataArrayDouble *a1, const DataArrayDouble *a2) throw (INTERP_KERNEL::Exception)
static MEDCOUPLING_EXPORT
DataArrayDouble
Substract (const DataArrayDouble *a1, const DataArrayDouble *a2) throw (INTERP_KERNEL::Exception)
static MEDCOUPLING_EXPORT
DataArrayDouble
Multiply (const DataArrayDouble *a1, const DataArrayDouble *a2) throw (INTERP_KERNEL::Exception)
static MEDCOUPLING_EXPORT
DataArrayDouble
Divide (const DataArrayDouble *a1, const DataArrayDouble *a2) throw (INTERP_KERNEL::Exception)
static MEDCOUPLING_EXPORT int GetNumberOfItemGivenBES (int begin, int end, int step, const char *msg) throw (INTERP_KERNEL::Exception)
static MEDCOUPLING_EXPORT int GetNumberOfItemGivenBESRelative (int begin, int end, int step, const char *msg) throw (INTERP_KERNEL::Exception)
static MEDCOUPLING_EXPORT
std::string 
GetVarNameFromInfo (const std::string &info) throw (INTERP_KERNEL::Exception)
static MEDCOUPLING_EXPORT
std::string 
GetUnitFromInfo (const std::string &info) throw (INTERP_KERNEL::Exception)

Protected Member Functions

template<int SPACEDIM>
void findCommonTuplesAlg (std::vector< double > &bbox, int nbNodes, int limitNodeId, double prec, std::vector< int > &c, std::vector< int > &cI) const

Static Protected Member Functions

static void CheckValueInRange (int ref, int value, const char *msg) throw (INTERP_KERNEL::Exception)
static void CheckClosingParInRange (int ref, int value, const char *msg) throw (INTERP_KERNEL::Exception)

Protected Attributes

int _nb_of_tuples
std::string _name
std::vector< std::string > _info_on_compo

Private Member Functions

 DataArrayDouble ()

Private Attributes

MemArray< double > _mem

Static Private Attributes

dictionary __swig_setmethods__ = {}
tuple __setattr__ = lambdaself,name,value:_swig_setattr(self, DataArrayDouble, name, value)
dictionary __swig_getmethods__ = {}
tuple __getattr__ = lambdaself,name:_swig_getattr(self, DataArrayDouble, name)
 __repr__ = _swig_repr
 __swig_destroy__ = _ParaMEDMEM.delete_DataArrayDouble

Detailed Description

1

Definition at line 135 of file MEDCouplingMemArray.hxx.


Constructor & Destructor Documentation

Definition at line 279 of file MEDCouplingMemArray.hxx.

{ }

Here is the caller graph for this function:

def ParaMEDMEM.DataArrayDouble.__init__ (   self,
  args,
  kwargs 
)

Reimplemented from ParaMEDMEM::DataArray.

Definition at line 1120 of file ParaMEDMEM.py.

01120 
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")

Member Function Documentation

def ParaMEDMEM.DataArrayDouble.__add__ (   self,
  args 
)
__add__(self, PyObject obj) -> DataArrayDouble

1

Definition at line 2272 of file ParaMEDMEM.py.

02272 
02273     def __add__(self, *args):
02274         """
02275         __add__(self, PyObject obj) -> DataArrayDouble
02276 
02277         1
02278         """
02279         return _ParaMEDMEM.DataArrayDouble___add__(self, *args)

def ParaMEDMEM.DataArrayDouble.__div__ (   self,
  args 
)
__div__(self, PyObject obj) -> DataArrayDouble

1

Definition at line 2344 of file ParaMEDMEM.py.

02344 
02345     def __div__(self, *args):
02346         """
02347         __div__(self, PyObject obj) -> DataArrayDouble
02348 
02349         1
02350         """
02351         return _ParaMEDMEM.DataArrayDouble___div__(self, *args)

__float__(self) -> double

1

Definition at line 2012 of file ParaMEDMEM.py.

02012 
02013     def __float__(self):
02014         """
02015         __float__(self) -> double
02016 
02017         1
02018         """
02019         return _ParaMEDMEM.DataArrayDouble___float__(self)

def ParaMEDMEM.DataArrayDouble.__getitem__ (   self,
  args 
)
__getitem__(self, PyObject obj) -> PyObject

1

Definition at line 2248 of file ParaMEDMEM.py.

02248 
02249     def __getitem__(self, *args):
02250         """
02251         __getitem__(self, PyObject obj) -> PyObject
02252 
02253         1
02254         """
02255         return _ParaMEDMEM.DataArrayDouble___getitem__(self, *args)

def ParaMEDMEM.DataArrayDouble.__iadd__ (   self,
  args 
)
__iadd__(self, PyObject obj) -> DataArrayDouble

1

Definition at line 2288 of file ParaMEDMEM.py.

02288 
02289     def __iadd__(self, *args):
02290         """
02291         __iadd__(self, PyObject obj) -> DataArrayDouble
02292 
02293         1
02294         """
02295         return _ParaMEDMEM.DataArrayDouble___iadd__(self, *args)

def ParaMEDMEM.DataArrayDouble.__idiv__ (   self,
  args 
)
__idiv__(self, PyObject obj) -> DataArrayDouble

1

Definition at line 2360 of file ParaMEDMEM.py.

02360 
02361     def __idiv__(self, *args):
02362         """
02363         __idiv__(self, PyObject obj) -> DataArrayDouble
02364 
02365         1
02366         """
02367         return _ParaMEDMEM.DataArrayDouble___idiv__(self, *args)

def ParaMEDMEM.DataArrayDouble.__imul__ (   self,
  args 
)
__imul__(self, PyObject obj) -> DataArrayDouble

1

Definition at line 2336 of file ParaMEDMEM.py.

02336 
02337     def __imul__(self, *args):
02338         """
02339         __imul__(self, PyObject obj) -> DataArrayDouble
02340 
02341         1
02342         """
02343         return _ParaMEDMEM.DataArrayDouble___imul__(self, *args)

def ParaMEDMEM.DataArrayDouble.__isub__ (   self,
  args 
)
__isub__(self, PyObject obj) -> DataArrayDouble

1

Definition at line 2312 of file ParaMEDMEM.py.

02312 
02313     def __isub__(self, *args):
02314         """
02315         __isub__(self, PyObject obj) -> DataArrayDouble
02316 
02317         1
02318         """
02319         return _ParaMEDMEM.DataArrayDouble___isub__(self, *args)

__iter__(self) -> DataArrayDoubleIterator

1

Definition at line 2028 of file ParaMEDMEM.py.

02028 
02029     def __iter__(self):
02030         """
02031         __iter__(self) -> DataArrayDoubleIterator
02032 
02033         1
02034         """
02035         return _ParaMEDMEM.DataArrayDouble___iter__(self)

__len__(self) -> int

1

Definition at line 2020 of file ParaMEDMEM.py.

02020 
02021     def __len__(self):
02022         """
02023         __len__(self) -> int
02024 
02025         1
02026         """
02027         return _ParaMEDMEM.DataArrayDouble___len__(self)

def ParaMEDMEM.DataArrayDouble.__mul__ (   self,
  args 
)
__mul__(self, PyObject obj) -> DataArrayDouble

1

Definition at line 2320 of file ParaMEDMEM.py.

02320 
02321     def __mul__(self, *args):
02322         """
02323         __mul__(self, PyObject obj) -> DataArrayDouble
02324 
02325         1
02326         """
02327         return _ParaMEDMEM.DataArrayDouble___mul__(self, *args)

__neg__(self) -> DataArrayDouble

1

Definition at line 2264 of file ParaMEDMEM.py.

02264 
02265     def __neg__(self):
02266         """
02267         __neg__(self) -> DataArrayDouble
02268 
02269         1
02270         """
02271         return _ParaMEDMEM.DataArrayDouble___neg__(self)

def ParaMEDMEM.DataArrayDouble.__radd__ (   self,
  args 
)
__radd__(self, PyObject obj) -> DataArrayDouble

1

Definition at line 2280 of file ParaMEDMEM.py.

02280 
02281     def __radd__(self, *args):
02282         """
02283         __radd__(self, PyObject obj) -> DataArrayDouble
02284 
02285         1
02286         """
02287         return _ParaMEDMEM.DataArrayDouble___radd__(self, *args)

def ParaMEDMEM.DataArrayDouble.__rdiv__ (   self,
  args 
)
__rdiv__(self, PyObject obj) -> DataArrayDouble

1

Definition at line 2352 of file ParaMEDMEM.py.

02352 
02353     def __rdiv__(self, *args):
02354         """
02355         __rdiv__(self, PyObject obj) -> DataArrayDouble
02356 
02357         1
02358         """
02359         return _ParaMEDMEM.DataArrayDouble___rdiv__(self, *args)

def ParaMEDMEM.DataArrayDouble.__rmul__ (   self,
  args 
)
__rmul__(self, PyObject obj) -> DataArrayDouble

1

Definition at line 2328 of file ParaMEDMEM.py.

02328 
02329     def __rmul__(self, *args):
02330         """
02331         __rmul__(self, PyObject obj) -> DataArrayDouble
02332 
02333         1
02334         """
02335         return _ParaMEDMEM.DataArrayDouble___rmul__(self, *args)

def ParaMEDMEM.DataArrayDouble.__rsub__ (   self,
  args 
)
__rsub__(self, PyObject obj) -> DataArrayDouble

1

Definition at line 2304 of file ParaMEDMEM.py.

02304 
02305     def __rsub__(self, *args):
02306         """
02307         __rsub__(self, PyObject obj) -> DataArrayDouble
02308 
02309         1
02310         """
02311         return _ParaMEDMEM.DataArrayDouble___rsub__(self, *args)

def ParaMEDMEM.DataArrayDouble.__setitem__ (   self,
  args 
)
__setitem__(self, PyObject obj, PyObject value) -> DataArrayDouble

1

Definition at line 2256 of file ParaMEDMEM.py.

02256 
02257     def __setitem__(self, *args):
02258         """
02259         __setitem__(self, PyObject obj, PyObject value) -> DataArrayDouble
02260 
02261         1
02262         """
02263         return _ParaMEDMEM.DataArrayDouble___setitem__(self, *args)

__str__(self) -> string

1

Definition at line 2004 of file ParaMEDMEM.py.

02004 
02005     def __str__(self):
02006         """
02007         __str__(self) -> string
02008 
02009         1
02010         """
02011         return _ParaMEDMEM.DataArrayDouble___str__(self)

def ParaMEDMEM.DataArrayDouble.__sub__ (   self,
  args 
)
__sub__(self, PyObject obj) -> DataArrayDouble

1

Definition at line 2296 of file ParaMEDMEM.py.

02296 
02297     def __sub__(self, *args):
02298         """
02299         __sub__(self, PyObject obj) -> DataArrayDouble
02300 
02301         1
02302         """
02303         return _ParaMEDMEM.DataArrayDouble___sub__(self, *args)

void DataArrayDouble::abs ( ) throw (INTERP_KERNEL::Exception)

Definition at line 1927 of file MEDCouplingMemArray.cxx.

{
  checkAllocated();
  double *ptr=getPointer();
  int nbOfElems=getNbOfElems();
  std::transform(ptr,ptr+nbOfElems,ptr,std::ptr_fun<double,double>(fabs));
}

Here is the call graph for this function:

Here is the caller graph for this function:

abs(self)

1

Definition at line 1756 of file ParaMEDMEM.py.

01756 
01757     def abs(self):
01758         """
01759         abs(self)
01760 
01761         1
01762         """
01763         return _ParaMEDMEM.DataArrayDouble_abs(self)

Here is the call graph for this function:

void DataArrayDouble::accumulate ( double *  res) const throw (INTERP_KERNEL::Exception)

Definition at line 1627 of file MEDCouplingMemArray.cxx.

{
  checkAllocated();
  const double *ptr=getConstPointer();
  int nbTuple=getNumberOfTuples();
  int nbComps=getNumberOfComponents();
  std::fill(res,res+nbComps,0.);
  for(int i=0;i<nbTuple;i++)
    std::transform(ptr+i*nbComps,ptr+(i+1)*nbComps,res,res,std::plus<double>());
}

Here is the call graph for this function:

Here is the caller graph for this function:

double DataArrayDouble::accumulate ( int  compId) const throw (INTERP_KERNEL::Exception)

Definition at line 1638 of file MEDCouplingMemArray.cxx.

{
  checkAllocated();
  const double *ptr=getConstPointer();
  int nbTuple=getNumberOfTuples();
  int nbComps=getNumberOfComponents();
  if(compId>=nbComps)
    throw INTERP_KERNEL::Exception("DataArrayDouble::accumulate : Invalid compId specified : No such nb of components !");
  double ret=0.;
  for(int i=0;i<nbTuple;i++)
    ret+=ptr[i*nbComps+compId];
  return ret;
}
def ParaMEDMEM.DataArrayDouble.accumulate (   self,
  args 
)
accumulate(self, double res)
accumulate(self, int compId) -> double
accumulate(self) -> PyObject

1

Definition at line 2168 of file ParaMEDMEM.py.

02168 
02169     def accumulate(self, *args):
02170         """
02171         accumulate(self, double res)
02172         accumulate(self, int compId) -> double
02173         accumulate(self) -> PyObject
02174 
02175         1
02176         """
02177         return _ParaMEDMEM.DataArrayDouble_accumulate(self, *args)

Here is the call graph for this function:

DataArrayDouble * DataArrayDouble::Add ( const DataArrayDouble a1,
const DataArrayDouble a2 
) throw (INTERP_KERNEL::Exception) [static]

Definition at line 2408 of file MEDCouplingMemArray.cxx.

{
  int nbOfTuple=a1->getNumberOfTuples();
  int nbOfTuple2=a2->getNumberOfTuples();
  int nbOfComp=a1->getNumberOfComponents();
  int nbOfComp2=a2->getNumberOfComponents();
  if(nbOfTuple!=nbOfTuple2)
    throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array Add !");
  DataArrayDouble *ret=0;
  if(nbOfComp==nbOfComp2)
    {
      ret=DataArrayDouble::New();
      ret->alloc(nbOfTuple,nbOfComp);
      std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::plus<double>());
      ret->copyStringInfoFrom(*a1);
    }
  else
    {
      int nbOfCompMin,nbOfCompMax;
      const DataArrayDouble *aMin, *aMax;
      if(nbOfComp>nbOfComp2)
        {
          nbOfCompMin=nbOfComp2; nbOfCompMax=nbOfComp;
          aMin=a2; aMax=a1;
        }
      else
        {
          nbOfCompMin=nbOfComp; nbOfCompMax=nbOfComp2;
          aMin=a1; aMax=a2;
        }
      if(nbOfCompMin==1)
        {
          ret=DataArrayDouble::New();
          ret->alloc(nbOfTuple,nbOfCompMax);
          const double *aMinPtr=aMin->getConstPointer();
          const double *aMaxPtr=aMax->getConstPointer();
          double *res=ret->getPointer();
          for(int i=0;i<nbOfTuple;i++)
            res=std::transform(aMaxPtr+i*nbOfCompMax,aMaxPtr+(i+1)*nbOfCompMax,res,std::bind2nd(std::plus<double>(),aMinPtr[i]));
          ret->copyStringInfoFrom(*aMax);
        }
      else
        throw INTERP_KERNEL::Exception("Nb of components mismatch for array Add !");
    }
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Add(DataArrayDouble a1, DataArrayDouble a2) -> DataArrayDouble

1

Definition at line 1879 of file ParaMEDMEM.py.

01879 
01880     def Add(*args):
01881         """
01882         Add(DataArrayDouble a1, DataArrayDouble a2) -> DataArrayDouble
01883 
01884         1
01885         """
01886         return _ParaMEDMEM.DataArrayDouble_Add(*args)

Here is the call graph for this function:

void DataArrayDouble::addEqual ( const DataArrayDouble other) throw (INTERP_KERNEL::Exception)

Definition at line 2455 of file MEDCouplingMemArray.cxx.

{
  const char *msg="Nb of tuples mismatch for DataArrayDouble::addEqual  !";
  int nbOfTuple=getNumberOfTuples();
  int nbOfTuple2=other->getNumberOfTuples();
  int nbOfComp=getNumberOfComponents();
  int nbOfComp2=other->getNumberOfComponents();
  if(nbOfTuple==nbOfTuple2)
    {
      if(nbOfComp==nbOfComp2)
        {
          std::transform(begin(),end(),other->begin(),getPointer(),std::plus<double>());
        }
      else if(nbOfComp2==1)
        {
          double *ptr=getPointer();
          const double *ptrc=other->getConstPointer();
          for(int i=0;i<nbOfTuple;i++)
            std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::plus<double>(),*ptrc++));
        }
      else
        throw INTERP_KERNEL::Exception(msg);
    }
  else if(nbOfTuple2==1)
    {
      if(nbOfComp2==nbOfComp)
        {
          double *ptr=getPointer();
          const double *ptrc=other->getConstPointer();
          for(int i=0;i<nbOfTuple;i++)
            std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::plus<double>());
        }
      else
        throw INTERP_KERNEL::Exception(msg);
    }
  else
    throw INTERP_KERNEL::Exception(msg);
  declareAsNew();
}

Here is the caller graph for this function:

def ParaMEDMEM.DataArrayDouble.addEqual (   self,
  args 
)
addEqual(self, DataArrayDouble other)

1

Definition at line 1889 of file ParaMEDMEM.py.

01889 
01890     def addEqual(self, *args):
01891         """
01892         addEqual(self, DataArrayDouble other)
01893 
01894         1
01895         """
01896         return _ParaMEDMEM.DataArrayDouble_addEqual(self, *args)

Here is the call graph for this function:

DataArrayDouble * DataArrayDouble::Aggregate ( const DataArrayDouble a1,
const DataArrayDouble a2 
) throw (INTERP_KERNEL::Exception) [static]

Definition at line 2243 of file MEDCouplingMemArray.cxx.

{
  std::vector<const DataArrayDouble *> tmp(2);
  tmp[0]=a1; tmp[1]=a2;
  return Aggregate(tmp);
}

Here is the caller graph for this function:

DataArrayDouble * DataArrayDouble::Aggregate ( const std::vector< const DataArrayDouble * > &  a) throw (INTERP_KERNEL::Exception) [static]

Definition at line 2250 of file MEDCouplingMemArray.cxx.

{
  if(a.empty())
    throw INTERP_KERNEL::Exception("DataArrayDouble::Aggregate : input list must be NON EMPTY !");
  std::vector<const DataArrayDouble *>::const_iterator it=a.begin();
  int nbOfComp=(*it)->getNumberOfComponents();
  int nbt=(*it++)->getNumberOfTuples();
  for(int i=1;it!=a.end();it++,i++)
    {
      if((*it)->getNumberOfComponents()!=nbOfComp)
        throw INTERP_KERNEL::Exception("DataArrayDouble::Aggregate : Nb of components mismatch for array aggregation !");
      nbt+=(*it)->getNumberOfTuples();
    }
  DataArrayDouble *ret=DataArrayDouble::New();
  ret->alloc(nbt,nbOfComp);
  double *pt=ret->getPointer();
  for(it=a.begin();it!=a.end();it++)
    pt=std::copy((*it)->getConstPointer(),(*it)->getConstPointer()+(*it)->getNbOfElems(),pt);
  ret->copyStringInfoFrom(*(a[0]));
  return ret;
}

Here is the call graph for this function:

Aggregate(DataArrayDouble a1, DataArrayDouble a2) -> DataArrayDouble
Aggregate(std::vector<(p.q(const).ParaMEDMEM::DataArrayDouble,std::allocator<(p.q(const).ParaMEDMEM::DataArrayDouble)>)> a) -> DataArrayDouble
Aggregate(PyObject li) -> DataArrayDouble

1

Definition at line 2215 of file ParaMEDMEM.py.

02215 
02216     def Aggregate(*args):
02217         """
02218         Aggregate(DataArrayDouble a1, DataArrayDouble a2) -> DataArrayDouble
02219         Aggregate(std::vector<(p.q(const).ParaMEDMEM::DataArrayDouble,std::allocator<(p.q(const).ParaMEDMEM::DataArrayDouble)>)> a) -> DataArrayDouble
02220         Aggregate(PyObject li) -> DataArrayDouble
02221 
02222         1
02223         """
02224         return _ParaMEDMEM.DataArrayDouble_Aggregate(*args)

Here is the call graph for this function:

void DataArrayDouble::alloc ( int  nbOfTuple,
int  nbOfCompo 
) throw (INTERP_KERNEL::Exception)

Definition at line 446 of file MEDCouplingMemArray.cxx.

{
  if(nbOfTuple<0 || nbOfCompo<0)
    throw INTERP_KERNEL::Exception("DataArrayDouble::alloc : request for negative length of data !");
  _nb_of_tuples=nbOfTuple;
  _info_on_compo.resize(nbOfCompo);
  _mem.alloc(nbOfCompo*_nb_of_tuples);
  declareAsNew();
}
def ParaMEDMEM.DataArrayDouble.alloc (   self,
  args 
)
alloc(self, int nbOfTuple, int nbOfCompo)

1

Definition at line 1186 of file ParaMEDMEM.py.

01186 
01187     def alloc(self, *args):
01188         """
01189         alloc(self, int nbOfTuple, int nbOfCompo)
01190 
01191         1
01192         """
01193         return _ParaMEDMEM.DataArrayDouble_alloc(self, *args)

Here is the call graph for this function:

void DataArrayDouble::allocIfNecessary ( int  nbOfTuple,
int  nbOfCompo 
)

Definition at line 435 of file MEDCouplingMemArray.cxx.

{
  if(isAllocated())
    {
      if(nbOfTuple!=getNumberOfTuples() || nbOfCompo!=getNumberOfComponents())
        alloc(nbOfTuple,nbOfCompo);
    }
  else
    alloc(nbOfTuple,nbOfCompo);
}

Here is the call graph for this function:

Here is the caller graph for this function:

def ParaMEDMEM.DataArrayDouble.allocIfNecessary (   self,
  args 
)
allocIfNecessary(self, int nbOfTuple, int nbOfCompo)

1

Definition at line 1194 of file ParaMEDMEM.py.

01194 
01195     def allocIfNecessary(self, *args):
01196         """
01197         allocIfNecessary(self, int nbOfTuple, int nbOfCompo)
01198 
01199         1
01200         """
01201         return _ParaMEDMEM.DataArrayDouble_allocIfNecessary(self, *args)

Here is the call graph for this function:

DataArrayDouble * DataArrayDouble::applyFunc ( int  nbOfComp,
FunctionToEvaluate  func 
) const throw (INTERP_KERNEL::Exception)

Definition at line 1999 of file MEDCouplingMemArray.cxx.

{
  checkAllocated();
  DataArrayDouble *newArr=DataArrayDouble::New();
  int nbOfTuples=getNumberOfTuples();
  int oldNbOfComp=getNumberOfComponents();
  newArr->alloc(nbOfTuples,nbOfComp);
  const double *ptr=getConstPointer();
  double *ptrToFill=newArr->getPointer();
  for(int i=0;i<nbOfTuples;i++)
    {
      if(!func(ptr+i*oldNbOfComp,ptrToFill+i*nbOfComp))
        {
          std::ostringstream oss; oss << "For tuple # " << i << " with value (";
          std::copy(ptr+oldNbOfComp*i,ptr+oldNbOfComp*(i+1),std::ostream_iterator<double>(oss,", "));
          oss << ") : Evaluation of function failed !";
          newArr->decrRef();
          throw INTERP_KERNEL::Exception(oss.str().c_str());
        }
    }
  return newArr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

DataArrayDouble * DataArrayDouble::applyFunc ( int  nbOfComp,
const char *  func 
) const throw (INTERP_KERNEL::Exception)

This method returns a newly allocated array the caller should deal with.

The returned array will have 'nbOfComp' components (that can be different from this->getNumberOfComponents()) contrary to the other DataArrayDouble::applyFunc overload method.

Definition at line 2026 of file MEDCouplingMemArray.cxx.

{
  checkAllocated();
  INTERP_KERNEL::ExprParser expr(func);
  expr.parse();
  std::set<std::string> vars;
  expr.getTrueSetOfVars(vars);
  int oldNbOfComp=getNumberOfComponents();
  if((int)vars.size()>oldNbOfComp)
    {
      std::ostringstream oss; oss << "The field has " << oldNbOfComp << " components and there are ";
      oss << vars.size() << " variables : ";
      std::copy(vars.begin(),vars.end(),std::ostream_iterator<std::string>(oss," "));
      throw INTERP_KERNEL::Exception(oss.str().c_str());
    }
  std::vector<std::string> varsV(vars.begin(),vars.end());
  expr.prepareExprEvaluation(varsV);
  //
  DataArrayDouble *newArr=DataArrayDouble::New();
  int nbOfTuples=getNumberOfTuples();
  newArr->alloc(nbOfTuples,nbOfComp);
  const double *ptr=getConstPointer();
  double *ptrToFill=newArr->getPointer();
  for(int i=0;i<nbOfTuples;i++)
    {
      try
        {
          expr.evaluateExpr(nbOfComp,ptr+i*oldNbOfComp,ptrToFill+i*nbOfComp);
        }
      catch(INTERP_KERNEL::Exception& e)
        {
          std::ostringstream oss; oss << "For tuple # " << i << " with value (";
          std::copy(ptr+oldNbOfComp*i,ptr+oldNbOfComp*(i+1),std::ostream_iterator<double>(oss,", "));
          oss << ") : Evaluation of function failed !" << e.what();
          newArr->decrRef();
          throw INTERP_KERNEL::Exception(oss.str().c_str());
        }
    }
  return newArr;
}

Here is the call graph for this function:

DataArrayDouble * DataArrayDouble::applyFunc ( const char *  func) const throw (INTERP_KERNEL::Exception)

Definition at line 2067 of file MEDCouplingMemArray.cxx.

{
  checkAllocated();
  INTERP_KERNEL::ExprParser expr(func);
  expr.parse();
  expr.prepareExprEvaluationVec();
  //
  DataArrayDouble *newArr=DataArrayDouble::New();
  int nbOfTuples=getNumberOfTuples();
  int nbOfComp=getNumberOfComponents();
  newArr->alloc(nbOfTuples,nbOfComp);
  const double *ptr=getConstPointer();
  double *ptrToFill=newArr->getPointer();
  for(int i=0;i<nbOfTuples;i++)
    {
      try
        {
          expr.evaluateExpr(nbOfComp,ptr+i*nbOfComp,ptrToFill+i*nbOfComp);
        }
      catch(INTERP_KERNEL::Exception& e)
        {
          std::ostringstream oss; oss << "For tuple # " << i << " with value (";
          std::copy(ptr+nbOfComp*i,ptr+nbOfComp*(i+1),std::ostream_iterator<double>(oss,", "));
          oss << ") : Evaluation of function failed ! " << e.what();
          newArr->decrRef();
          throw INTERP_KERNEL::Exception(oss.str().c_str());
        }
    }
  return newArr;
}

Here is the call graph for this function:

def ParaMEDMEM.DataArrayDouble.applyFunc (   self,
  args 
)
applyFunc(self, int nbOfComp, FunctionToEvaluate func) -> DataArrayDouble
applyFunc(self, int nbOfComp, char func) -> DataArrayDouble
applyFunc(self, char func) -> DataArrayDouble

1

Definition at line 1789 of file ParaMEDMEM.py.

01789 
01790     def applyFunc(self, *args):
01791         """
01792         applyFunc(self, int nbOfComp, FunctionToEvaluate func) -> DataArrayDouble
01793         applyFunc(self, int nbOfComp, char func) -> DataArrayDouble
01794         applyFunc(self, char func) -> DataArrayDouble
01795 
01796         1
01797         """
01798         return _ParaMEDMEM.DataArrayDouble_applyFunc(self, *args)

Here is the call graph for this function:

DataArrayDouble * DataArrayDouble::applyFunc2 ( int  nbOfComp,
const char *  func 
) const throw (INTERP_KERNEL::Exception)

This method is equivalent than DataArrayDouble::applyFunc, except that here components names are used to determine vars orders.

If 'func' contains vars that are not in this->getInfoOnComponent() an exception will be thrown.

Definition at line 2102 of file MEDCouplingMemArray.cxx.

{
  checkAllocated();
  INTERP_KERNEL::ExprParser expr(func);
  expr.parse();
  std::set<std::string> vars;
  expr.getTrueSetOfVars(vars);
  int oldNbOfComp=getNumberOfComponents();
  if((int)vars.size()>oldNbOfComp)
    {
      std::ostringstream oss; oss << "The field has " << oldNbOfComp << " components and there are ";
      oss << vars.size() << " variables : ";
      std::copy(vars.begin(),vars.end(),std::ostream_iterator<std::string>(oss," "));
      throw INTERP_KERNEL::Exception(oss.str().c_str());
    }
  expr.prepareExprEvaluation(getVarsOnComponent());
  //
  DataArrayDouble *newArr=DataArrayDouble::New();
  int nbOfTuples=getNumberOfTuples();
  newArr->alloc(nbOfTuples,nbOfComp);
  const double *ptr=getConstPointer();
  double *ptrToFill=newArr->getPointer();
  for(int i=0;i<nbOfTuples;i++)
    {
      try
        {
          expr.evaluateExpr(nbOfComp,ptr+i*oldNbOfComp,ptrToFill+i*nbOfComp);
        }
      catch(INTERP_KERNEL::Exception& e)
        {
          std::ostringstream oss; oss << "For tuple # " << i << " with value (";
          std::copy(ptr+oldNbOfComp*i,ptr+oldNbOfComp*(i+1),std::ostream_iterator<double>(oss,", "));
          oss << ") : Evaluation of function failed !" << e.what();
          newArr->decrRef();
          throw INTERP_KERNEL::Exception(oss.str().c_str());
        }
    }
  return newArr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

def ParaMEDMEM.DataArrayDouble.applyFunc2 (   self,
  args 
)
applyFunc2(self, int nbOfComp, char func) -> DataArrayDouble

1

Definition at line 1799 of file ParaMEDMEM.py.

01799 
01800     def applyFunc2(self, *args):
01801         """
01802         applyFunc2(self, int nbOfComp, char func) -> DataArrayDouble
01803 
01804         1
01805         """
01806         return _ParaMEDMEM.DataArrayDouble_applyFunc2(self, *args)

Here is the call graph for this function:

DataArrayDouble * DataArrayDouble::applyFunc3 ( int  nbOfComp,
const std::vector< std::string > &  varsOrder,
const char *  func 
) const throw (INTERP_KERNEL::Exception)

This method is equivalent than DataArrayDouble::applyFunc, except that here order of vars is passed explicitely in parameter.

In 'func' contains vars not in 'varsOrder' an exception will be thrown.

Definition at line 2146 of file MEDCouplingMemArray.cxx.

{
  checkAllocated();
  INTERP_KERNEL::ExprParser expr(func);
  expr.parse();
  std::set<std::string> vars;
  expr.getTrueSetOfVars(vars);
  int oldNbOfComp=getNumberOfComponents();
  if((int)vars.size()>oldNbOfComp)
    {
      std::ostringstream oss; oss << "The field has " << oldNbOfComp << " components and there are ";
      oss << vars.size() << " variables : ";
      std::copy(vars.begin(),vars.end(),std::ostream_iterator<std::string>(oss," "));
      throw INTERP_KERNEL::Exception(oss.str().c_str());
    }
  expr.prepareExprEvaluation(varsOrder);
  //
  DataArrayDouble *newArr=DataArrayDouble::New();
  int nbOfTuples=getNumberOfTuples();
  newArr->alloc(nbOfTuples,nbOfComp);
  const double *ptr=getConstPointer();
  double *ptrToFill=newArr->getPointer();
  for(int i=0;i<nbOfTuples;i++)
    {
      try
        {
          expr.evaluateExpr(nbOfComp,ptr+i*oldNbOfComp,ptrToFill+i*nbOfComp);
        }
      catch(INTERP_KERNEL::Exception& e)
        {
          std::ostringstream oss; oss << "For tuple # " << i << " with value (";
          std::copy(ptr+oldNbOfComp*i,ptr+oldNbOfComp*(i+1),std::ostream_iterator<double>(oss,", "));
          oss << ") : Evaluation of function failed !" << e.what();
          newArr->decrRef();
          throw INTERP_KERNEL::Exception(oss.str().c_str());
        }
    }
  return newArr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

def ParaMEDMEM.DataArrayDouble.applyFunc3 (   self,
  args 
)
applyFunc3(self, int nbOfComp, svec varsOrder, char func) -> DataArrayDouble

1

Definition at line 1807 of file ParaMEDMEM.py.

01807 
01808     def applyFunc3(self, *args):
01809         """
01810         applyFunc3(self, int nbOfComp, svec varsOrder, char func) -> DataArrayDouble
01811 
01812         1
01813         """
01814         return _ParaMEDMEM.DataArrayDouble_applyFunc3(self, *args)

Here is the call graph for this function:

void DataArrayDouble::applyFuncFast32 ( const char *  func) throw (INTERP_KERNEL::Exception)

Definition at line 2186 of file MEDCouplingMemArray.cxx.

{
  checkAllocated();
  INTERP_KERNEL::ExprParser expr(func);
  expr.parse();
  char *funcStr=expr.compileX86();
  MYFUNCPTR funcPtr;
  *((void **)&funcPtr)=funcStr;//he he...
  //
  double *ptr=getPointer();
  int nbOfComp=getNumberOfComponents();
  int nbOfTuples=getNumberOfTuples();
  int nbOfElems=nbOfTuples*nbOfComp;
  for(int i=0;i<nbOfElems;i++,ptr++)
    *ptr=funcPtr(*ptr);
  declareAsNew();
}

Here is the caller graph for this function:

def ParaMEDMEM.DataArrayDouble.applyFuncFast32 (   self,
  args 
)
applyFuncFast32(self, char func)

1

Definition at line 1815 of file ParaMEDMEM.py.

01815 
01816     def applyFuncFast32(self, *args):
01817         """
01818         applyFuncFast32(self, char func)
01819 
01820         1
01821         """
01822         return _ParaMEDMEM.DataArrayDouble_applyFuncFast32(self, *args)

Here is the call graph for this function:

void DataArrayDouble::applyFuncFast64 ( const char *  func) throw (INTERP_KERNEL::Exception)

Definition at line 2204 of file MEDCouplingMemArray.cxx.

{
  checkAllocated();
  INTERP_KERNEL::ExprParser expr(func);
  expr.parse();
  char *funcStr=expr.compileX86_64();
  MYFUNCPTR funcPtr;
  *((void **)&funcPtr)=funcStr;//he he...
  //
  double *ptr=getPointer();
  int nbOfComp=getNumberOfComponents();
  int nbOfTuples=getNumberOfTuples();
  int nbOfElems=nbOfTuples*nbOfComp;
  for(int i=0;i<nbOfElems;i++,ptr++)
    *ptr=funcPtr(*ptr);
  declareAsNew();
}

Here is the caller graph for this function:

def ParaMEDMEM.DataArrayDouble.applyFuncFast64 (   self,
  args 
)
applyFuncFast64(self, char func)

1

Definition at line 1823 of file ParaMEDMEM.py.

01823 
01824     def applyFuncFast64(self, *args):
01825         """
01826         applyFuncFast64(self, char func)
01827 
01828         1
01829         """
01830         return _ParaMEDMEM.DataArrayDouble_applyFuncFast64(self, *args)

Here is the call graph for this function:

void DataArrayDouble::applyInv ( double  numerator) throw (INTERP_KERNEL::Exception)

This method applies the operation 'numerator/x' for each element 'x' in 'this'.

If there is a value in 'this' exactly equal to 0. an exception is thrown. Warning if presence of null this is modified for each values previous than place where exception was thrown !

Definition at line 1961 of file MEDCouplingMemArray.cxx.

{
  checkAllocated();
  double *ptr=getPointer();
  int nbOfElems=getNbOfElems();
  for(int i=0;i<nbOfElems;i++,ptr++)
    {
      if(std::abs(*ptr)>std::numeric_limits<double>::min())
        {
          *ptr=numerator/(*ptr);
        }
      else
        {
          std::ostringstream oss; oss << "DataArrayDouble::applyInv : presence of null value in tuple #" << i/getNumberOfComponents() << " component #" << i%getNumberOfComponents();
          oss << " !";
          throw INTERP_KERNEL::Exception(oss.str().c_str());
        }
    }
  declareAsNew();
}

Here is the caller graph for this function:

def ParaMEDMEM.DataArrayDouble.applyInv (   self,
  args 
)
applyInv(self, double numerator)

1

Definition at line 1773 of file ParaMEDMEM.py.

01773 
01774     def applyInv(self, *args):
01775         """
01776         applyInv(self, double numerator)
01777 
01778         1
01779         """
01780         return _ParaMEDMEM.DataArrayDouble_applyInv(self, *args)

Here is the call graph for this function:

void DataArrayDouble::applyLin ( double  a,
double  b,
int  compoId 
) throw (INTERP_KERNEL::Exception)

Definition at line 1935 of file MEDCouplingMemArray.cxx.

{
  checkAllocated();
  double *ptr=getPointer()+compoId;
  int nbOfComp=getNumberOfComponents();
  int nbOfTuple=getNumberOfTuples();
  for(int i=0;i<nbOfTuple;i++,ptr+=nbOfComp)
    *ptr=a*(*ptr)+b;
  declareAsNew();
}

Here is the caller graph for this function:

void DataArrayDouble::applyLin ( double  a,
double  b 
) throw (INTERP_KERNEL::Exception)

Definition at line 1946 of file MEDCouplingMemArray.cxx.

{
  checkAllocated();
  double *ptr=getPointer();
  int nbOfElems=getNbOfElems();
  for(int i=0;i<nbOfElems;i++,ptr++)
    *ptr=a*(*ptr)+b;
  declareAsNew();
}
def ParaMEDMEM.DataArrayDouble.applyLin (   self,
  args 
)
applyLin(self, double a, double b, int compoId)
applyLin(self, double a, double b)

1

Definition at line 1764 of file ParaMEDMEM.py.

01764 
01765     def applyLin(self, *args):
01766         """
01767         applyLin(self, double a, double b, int compoId)
01768         applyLin(self, double a, double b)
01769 
01770         1
01771         """
01772         return _ParaMEDMEM.DataArrayDouble_applyLin(self, *args)

Here is the call graph for this function:

bool DataArray::areInfoEquals ( const DataArray other) const [inherited]

Definition at line 121 of file MEDCouplingMemArray.cxx.

{
  if(_nb_of_tuples!=other._nb_of_tuples)
    return false;
  if(_name!=other._name)
    return false;
  return _info_on_compo==other._info_on_compo;
}

Here is the caller graph for this function:

def ParaMEDMEM.DataArray.areInfoEquals (   self,
  args 
) [inherited]
areInfoEquals(self, DataArray other) -> bool

1

Definition at line 887 of file ParaMEDMEM.py.

00887 
00888     def areInfoEquals(self, *args):
00889         """
00890         areInfoEquals(self, DataArray other) -> bool
00891 
00892         1
00893         """
00894         return _ParaMEDMEM.DataArray_areInfoEquals(self, *args)

Here is the call graph for this function:

def ParaMEDMEM.TimeLabel.assign (   self,
  args 
) [inherited]
assign(self, TimeLabel other) -> TimeLabel

1

Reimplemented in ParaMEDMEM.MEDCouplingFieldDouble.

Definition at line 284 of file ParaMEDMEM.py.

00284 
00285     def assign(self, *args):
00286         """
00287         assign(self, TimeLabel other) -> TimeLabel
00288 
00289         1
00290         """
00291         return _ParaMEDMEM.TimeLabel_assign(self, *args)

double DataArrayDouble::back ( ) const throw (INTERP_KERNEL::Exception)

This method returns the last element in 'this'.

So this method makes the hypothesis that 'this' is allocated. This method works only for arrays that have exactly number of components equal to 1. If not an exception is thrown. And to finish this method works for arrays that have number of tuples >= 1.

Definition at line 1450 of file MEDCouplingMemArray.cxx.

{
  checkAllocated();
  if(getNumberOfComponents()!=1)
    throw INTERP_KERNEL::Exception("DataArrayDouble::back : number of components not equal to one !");
  int nbOfTuples=getNumberOfTuples();
  if(nbOfTuples<1)
    throw INTERP_KERNEL::Exception("DataArrayDouble::back : number of tuples must be >= 1 !");
  return *(getConstPointer()+nbOfTuples-1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

back(self) -> double

1

Definition at line 1515 of file ParaMEDMEM.py.

01515 
01516     def back(self):
01517         """
01518         back(self) -> double
01519 
01520         1
01521         """
01522         return _ParaMEDMEM.DataArrayDouble_back(self)

Here is the call graph for this function:

MEDCOUPLING_EXPORT const double* ParaMEDMEM::DataArrayDouble::begin ( ) const [inline]

Definition at line 208 of file MEDCouplingMemArray.hxx.

{ return getConstPointer(); }

Here is the call graph for this function:

Here is the caller graph for this function:

begin(self) -> double

1

Definition at line 1571 of file ParaMEDMEM.py.

01571 
01572     def begin(self):
01573         """
01574         begin(self) -> double
01575 
01576         1
01577         """
01578         return _ParaMEDMEM.DataArrayDouble_begin(self)

Here is the call graph for this function:

DataArrayDouble * DataArrayDouble::changeNbOfComponents ( int  newNbOfComp,
double  dftValue 
) const throw (INTERP_KERNEL::Exception)

This method builds a new instance of DataArrayDouble (to deal with) that is reduction or an extension of 'this'.

if 'newNbOfComp' < this->getNumberOfComponents() a reduction is done and for each tuple 'newNbOfComp' first components are kept. If 'newNbOfComp' > this->getNumberOfComponents() an extension is done, and for each components i such that i > getNumberOfComponents() 'dftValue' parameter is taken.

Definition at line 924 of file MEDCouplingMemArray.cxx.

{
  checkAllocated();
  DataArrayDouble *ret=DataArrayDouble::New();
  ret->alloc(getNumberOfTuples(),newNbOfComp);
  const double *oldc=getConstPointer();
  double *nc=ret->getPointer();
  int nbOfTuples=getNumberOfTuples();
  int oldNbOfComp=getNumberOfComponents();
  int dim=std::min(oldNbOfComp,newNbOfComp);
  for(int i=0;i<nbOfTuples;i++)
    {
      int j=0;
      for(;j<dim;j++)
        nc[newNbOfComp*i+j]=oldc[i*oldNbOfComp+j];
      for(;j<newNbOfComp;j++)
        nc[newNbOfComp*i+j]=dftValue;
    }
  ret->setName(getName().c_str());
  for(int i=0;i<dim;i++)
    ret->setInfoOnComponent(i,getInfoOnComponent(i).c_str());
  ret->setName(getName().c_str());
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

changeNbOfComponents(self, int newNbOfComp, double dftValue) -> DataArrayDouble

1

Definition at line 1396 of file ParaMEDMEM.py.

01396 
01397     def changeNbOfComponents(self, *args):
01398         """
01399         changeNbOfComponents(self, int newNbOfComp, double dftValue) -> DataArrayDouble
01400 
01401         1
01402         """
01403         return _ParaMEDMEM.DataArrayDouble_changeNbOfComponents(self, *args)

Here is the call graph for this function:

void DataArrayDouble::checkAllocated ( ) const throw (INTERP_KERNEL::Exception)

Definition at line 348 of file MEDCouplingMemArray.cxx.

{
  if(!isAllocated())
    throw INTERP_KERNEL::Exception("DataArrayDouble::checkAllocated : Array is defined but not allocated ! Call alloc or setValues method first !");
}

Here is the call graph for this function:

Here is the caller graph for this function:

checkAllocated(self)

1

Definition at line 1130 of file ParaMEDMEM.py.

01130 
01131     def checkAllocated(self):
01132         """
01133         checkAllocated(self)
01134 
01135         1
01136         """
01137         return _ParaMEDMEM.DataArrayDouble_checkAllocated(self)

Here is the call graph for this function:

void DataArray::CheckClosingParInRange ( int  ref,
int  value,
const char *  msg 
) throw (INTERP_KERNEL::Exception) [static, protected, inherited]

Definition at line 294 of file MEDCouplingMemArray.cxx.

{
  if(value<0 || value>ref)
    {
      std::ostringstream oss; oss << "DataArray::CheckClosingParInRange : " << msg  << " ! Expected a range in [0," << ref << "] having closing open parenthesis " << value << " !";
      throw INTERP_KERNEL::Exception(oss.str().c_str());
    }
}

Here is the caller graph for this function:

void DataArrayDouble::checkMonotonic ( bool  increasing,
double  eps 
) const throw (INTERP_KERNEL::Exception)

This method check that (Maths) array consistently INCREASING or DECREASING in value, with at least absolute difference value of |eps| at each step.

if not an exception will be thrown.

Definition at line 519 of file MEDCouplingMemArray.cxx.

{
  if(!isMonotonic(increasing, eps))
    {
      if (increasing)
        {
          throw INTERP_KERNEL::Exception("DataArrayDouble::checkMonotonic : 'this' is not INCREASING monotonic !");
        }
      else
        {
          throw INTERP_KERNEL::Exception("DataArrayDouble::checkMonotonic : 'this' is not DECREASING monotonic !");
        }
    }
}

Here is the caller graph for this function:

def ParaMEDMEM.DataArrayDouble.checkMonotonic (   self,
  args 
)
checkMonotonic(self, bool increasing, double eps)

1

Definition at line 1251 of file ParaMEDMEM.py.

01251 
01252     def checkMonotonic(self, *args):
01253         """
01254         checkMonotonic(self, bool increasing, double eps)
01255 
01256         1
01257         """
01258         return _ParaMEDMEM.DataArrayDouble_checkMonotonic(self, *args)

Here is the call graph for this function:

void DataArray::checkNbOfElems ( int  nbOfElems,
const char *  msg 
) const throw (INTERP_KERNEL::Exception) [inherited]

Definition at line 276 of file MEDCouplingMemArray.cxx.

{
  if(getNbOfElems()!=nbOfElems)
    {
      std::ostringstream oss; oss << msg << " : mismatch number of elems : Expected " << nbOfElems << " having " << getNbOfElems() << " !";
      throw INTERP_KERNEL::Exception(oss.str().c_str());
    }
}

Here is the caller graph for this function:

def ParaMEDMEM.DataArray.checkNbOfElems (   self,
  args 
) [inherited]
checkNbOfElems(self, int nbOfElems, char msg)

1

Definition at line 1009 of file ParaMEDMEM.py.

01009 
01010     def checkNbOfElems(self, *args):
01011         """
01012         checkNbOfElems(self, int nbOfElems, char msg)
01013 
01014         1
01015         """
01016         return _ParaMEDMEM.DataArray_checkNbOfElems(self, *args)

Here is the call graph for this function:

void DataArray::checkNbOfTuplesAndComp ( const DataArray other,
const char *  msg 
) const throw (INTERP_KERNEL::Exception) [inherited]

Definition at line 248 of file MEDCouplingMemArray.cxx.

{
   if(getNumberOfTuples()!=other.getNumberOfTuples())
    {
      std::ostringstream oss; oss << msg << " : mismatch number of tuples : expected " <<  other.getNumberOfTuples() << " having " << getNumberOfTuples() << " !";
      throw INTERP_KERNEL::Exception(oss.str().c_str());
    }
  if(getNumberOfComponents()!=other.getNumberOfComponents())
    {
      std::ostringstream oss; oss << msg << " : mismatch number of components : expected " << other.getNumberOfComponents() << " having " << getNumberOfComponents() << " !";
      throw INTERP_KERNEL::Exception(oss.str().c_str());
    }
}

Here is the caller graph for this function:

void DataArray::checkNbOfTuplesAndComp ( int  nbOfTuples,
int  nbOfCompo,
const char *  msg 
) const throw (INTERP_KERNEL::Exception) [inherited]

Definition at line 262 of file MEDCouplingMemArray.cxx.

{
  if(getNumberOfTuples()!=nbOfTuples)
    {
      std::ostringstream oss; oss << msg << " : mismatch number of tuples : expected " <<  nbOfTuples << " having " << getNumberOfTuples() << " !";
      throw INTERP_KERNEL::Exception(oss.str().c_str());
    }
  if(getNumberOfComponents()!=nbOfCompo)
    {
      std::ostringstream oss; oss << msg << " : mismatch number of components : expected " << nbOfCompo << " having " << getNumberOfComponents() << " !";
      throw INTERP_KERNEL::Exception(oss.str().c_str());
    }
}
def ParaMEDMEM.DataArray.checkNbOfTuplesAndComp (   self,
  args 
) [inherited]
checkNbOfTuplesAndComp(self, DataArray other, char msg)
checkNbOfTuplesAndComp(self, int nbOfTuples, int nbOfCompo, char msg)

1

Definition at line 1000 of file ParaMEDMEM.py.

01000 
01001     def checkNbOfTuplesAndComp(self, *args):
01002         """
01003         checkNbOfTuplesAndComp(self, DataArray other, char msg)
01004         checkNbOfTuplesAndComp(self, int nbOfTuples, int nbOfCompo, char msg)
01005 
01006         1
01007         """
01008         return _ParaMEDMEM.DataArray_checkNbOfTuplesAndComp(self, *args)

Here is the call graph for this function:

void DataArrayDouble::checkNoNullValues ( ) const throw (INTERP_KERNEL::Exception)

Definition at line 1481 of file MEDCouplingMemArray.cxx.

{
  const double *tmp=getConstPointer();
  int nbOfElems=getNbOfElems();
  const double *where=std::find(tmp,tmp+nbOfElems,0.);
  if(where!=tmp+nbOfElems)
    throw INTERP_KERNEL::Exception("A value 0.0 have been detected !");
}

Here is the call graph for this function:

Here is the caller graph for this function:

checkNoNullValues(self)

1

Definition at line 1604 of file ParaMEDMEM.py.

01604 
01605     def checkNoNullValues(self):
01606         """
01607         checkNoNullValues(self)
01608 
01609         1
01610         """
01611         return _ParaMEDMEM.DataArrayDouble_checkNoNullValues(self)

Here is the call graph for this function:

void DataArray::CheckValueInRange ( int  ref,
int  value,
const char *  msg 
) throw (INTERP_KERNEL::Exception) [static, protected, inherited]

Definition at line 285 of file MEDCouplingMemArray.cxx.

{
  if(value<0 || value>=ref)
    {
      std::ostringstream oss; oss << "DataArray::CheckValueInRange : " << msg  << " ! Expected in range [0," << ref << "[ having " << value << " !";
      throw INTERP_KERNEL::Exception(oss.str().c_str());
    }
}

Here is the caller graph for this function:

Definition at line 639 of file MEDCouplingMemArray.cxx.

{
  DataArrayInt *ret=DataArrayInt::New();
  ret->alloc(getNumberOfTuples(),getNumberOfComponents());
  int nbOfVals=getNbOfElems();
  const double *src=getConstPointer();
  int *dest=ret->getPointer();
  std::copy(src,src+nbOfVals,dest);
  ret->copyStringInfoFrom(*this);
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

convertToIntArr(self) -> DataArrayInt

1

Definition at line 1339 of file ParaMEDMEM.py.

01339 
01340     def convertToIntArr(self):
01341         """
01342         convertToIntArr(self) -> DataArrayInt
01343 
01344         1
01345         """
01346         return _ParaMEDMEM.DataArrayDouble_convertToIntArr(self)

Here is the call graph for this function:

void DataArray::copyPartOfStringInfoFrom ( const DataArray other,
const std::vector< int > &  compoIds 
) throw (INTERP_KERNEL::Exception) [inherited]

Definition at line 91 of file MEDCouplingMemArray.cxx.

{
  int nbOfCompoOth=other.getNumberOfComponents();
  std::size_t newNbOfCompo=compoIds.size();
  for(std::size_t i=0;i<newNbOfCompo;i++)
    if(compoIds[i]>=nbOfCompoOth || compoIds[i]<0)
      {
        std::ostringstream oss; oss << "Specified component id is out of range (" << compoIds[i] << ") compared with nb of actual components (" << nbOfCompoOth << ")";
        throw INTERP_KERNEL::Exception(oss.str().c_str());
      }
  for(std::size_t i=0;i<newNbOfCompo;i++)
    setInfoOnComponent((int)i,other.getInfoOnComponent(compoIds[i]).c_str());
}

Here is the call graph for this function:

Here is the caller graph for this function:

def ParaMEDMEM.DataArray.copyPartOfStringInfoFrom (   self,
  args 
) [inherited]
copyPartOfStringInfoFrom(self, DataArray other, ivec compoIds)
copyPartOfStringInfoFrom(self, DataArray other, PyObject li)

1

Definition at line 1057 of file ParaMEDMEM.py.

01057 
01058     def copyPartOfStringInfoFrom(self, *args):
01059         """
01060         copyPartOfStringInfoFrom(self, DataArray other, ivec compoIds)
01061         copyPartOfStringInfoFrom(self, DataArray other, PyObject li)
01062 
01063         1
01064         """
01065         return _ParaMEDMEM.DataArray_copyPartOfStringInfoFrom(self, *args)

Here is the call graph for this function:

void DataArray::copyPartOfStringInfoFrom2 ( const std::vector< int > &  compoIds,
const DataArray other 
) throw (INTERP_KERNEL::Exception) [inherited]

Definition at line 105 of file MEDCouplingMemArray.cxx.

{
  int nbOfCompo=getNumberOfComponents();
  std::size_t partOfCompoToSet=compoIds.size();
  if((int)partOfCompoToSet!=other.getNumberOfComponents())
    throw INTERP_KERNEL::Exception("Given compoIds has not the same size as number of components of given array !");
  for(std::size_t i=0;i<partOfCompoToSet;i++)
    if(compoIds[i]>=nbOfCompo || compoIds[i]<0)
      {
        std::ostringstream oss; oss << "Specified component id is out of range (" << compoIds[i] << ") compared with nb of actual components (" << nbOfCompo << ")";
        throw INTERP_KERNEL::Exception(oss.str().c_str());
      }
  for(std::size_t i=0;i<partOfCompoToSet;i++)
    setInfoOnComponent(compoIds[i],other.getInfoOnComponent((int)i).c_str());
}

Here is the caller graph for this function:

def ParaMEDMEM.DataArray.copyPartOfStringInfoFrom2 (   self,
  args 
) [inherited]
copyPartOfStringInfoFrom2(self, ivec compoIds, DataArray other)
copyPartOfStringInfoFrom2(self, PyObject li, DataArray other)

1

Definition at line 1066 of file ParaMEDMEM.py.

01066 
01067     def copyPartOfStringInfoFrom2(self, *args):
01068         """
01069         copyPartOfStringInfoFrom2(self, ivec compoIds, DataArray other)
01070         copyPartOfStringInfoFrom2(self, PyObject li, DataArray other)
01071 
01072         1
01073         """
01074         return _ParaMEDMEM.DataArray_copyPartOfStringInfoFrom2(self, *args)

Here is the call graph for this function:

void DataArray::copyStringInfoFrom ( const DataArray other) throw (INTERP_KERNEL::Exception) [inherited]

Definition at line 83 of file MEDCouplingMemArray.cxx.

{
  if(_info_on_compo.size()!=other._info_on_compo.size())
    throw INTERP_KERNEL::Exception("Size of arrays mismatches on copyStringInfoFrom !");
  _name=other._name;
  _info_on_compo=other._info_on_compo;
}
def ParaMEDMEM.DataArray.copyStringInfoFrom (   self,
  args 
) [inherited]
copyStringInfoFrom(self, DataArray other)

1

Definition at line 879 of file ParaMEDMEM.py.

00879 
00880     def copyStringInfoFrom(self, *args):
00881         """
00882         copyStringInfoFrom(self, DataArray other)
00883 
00884         1
00885         """
00886         return _ParaMEDMEM.DataArray_copyStringInfoFrom(self, *args)

Here is the call graph for this function:

void DataArrayDouble::cpyFrom ( const DataArrayDouble other) throw (INTERP_KERNEL::Exception)

Definition at line 421 of file MEDCouplingMemArray.cxx.

{
  other.checkAllocated();
  int nbOfTuples=other.getNumberOfTuples();
  int nbOfComp=other.getNumberOfComponents();
  allocIfNecessary(nbOfTuples,nbOfComp);
  int nbOfElems=nbOfTuples*nbOfComp;
  double *pt=getPointer();
  const double *ptI=other.getConstPointer();
  for(int i=0;i<nbOfElems;i++)
    pt[i]=ptI[i];
  copyStringInfoFrom(other);
}

Here is the call graph for this function:

Here is the caller graph for this function:

def ParaMEDMEM.DataArrayDouble.cpyFrom (   self,
  args 
)
cpyFrom(self, DataArrayDouble other)

1

Definition at line 1178 of file ParaMEDMEM.py.

01178 
01179     def cpyFrom(self, *args):
01180         """
01181         cpyFrom(self, DataArrayDouble other)
01182 
01183         1
01184         """
01185         return _ParaMEDMEM.DataArrayDouble_cpyFrom(self, *args)

Here is the call graph for this function:

DataArrayDouble * DataArrayDouble::CrossProduct ( const DataArrayDouble a1,
const DataArrayDouble a2 
) throw (INTERP_KERNEL::Exception) [static]

Definition at line 2343 of file MEDCouplingMemArray.cxx.

{
  int nbOfComp=a1->getNumberOfComponents();
  if(nbOfComp!=a2->getNumberOfComponents())
    throw INTERP_KERNEL::Exception("Nb of components mismatch for array crossProduct !");
  if(nbOfComp!=3)
    throw INTERP_KERNEL::Exception("Nb of components must be equal to 3 for array crossProduct !");
  int nbOfTuple=a1->getNumberOfTuples();
  if(nbOfTuple!=a2->getNumberOfTuples())
    throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array crossProduct !");
  DataArrayDouble *ret=DataArrayDouble::New();
  ret->alloc(nbOfTuple,3);
  double *retPtr=ret->getPointer();
  const double *a1Ptr=a1->getConstPointer();
  const double *a2Ptr=a2->getConstPointer();
  for(int i=0;i<nbOfTuple;i++)
    {
      retPtr[3*i]=a1Ptr[3*i+1]*a2Ptr[3*i+2]-a1Ptr[3*i+2]*a2Ptr[3*i+1];
      retPtr[3*i+1]=a1Ptr[3*i+2]*a2Ptr[3*i]-a1Ptr[3*i]*a2Ptr[3*i+2];
      retPtr[3*i+2]=a1Ptr[3*i]*a2Ptr[3*i+1]-a1Ptr[3*i+1]*a2Ptr[3*i];
    }
  ret->copyStringInfoFrom(*a1);
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

CrossProduct(DataArrayDouble a1, DataArrayDouble a2) -> DataArrayDouble

1

Definition at line 1849 of file ParaMEDMEM.py.

01849 
01850     def CrossProduct(*args):
01851         """
01852         CrossProduct(DataArrayDouble a1, DataArrayDouble a2) -> DataArrayDouble
01853 
01854         1
01855         """
01856         return _ParaMEDMEM.DataArrayDouble_CrossProduct(*args)

Here is the call graph for this function:

def ParaMEDMEM.TimeLabel.declareAsNew (   self) [inherited]
declareAsNew(self)

1

Definition at line 292 of file ParaMEDMEM.py.

00292 
00293     def declareAsNew(self):
00294         """
00295         declareAsNew(self)
00296 
00297         1
00298         """
00299         return _ParaMEDMEM.TimeLabel_declareAsNew(self)

Here is the caller graph for this function:

Definition at line 405 of file MEDCouplingMemArray.cxx.

{
  return new DataArrayDouble(*this);
}

Here is the call graph for this function:

Here is the caller graph for this function:

deepCpy(self) -> DataArrayDouble

1

Definition at line 1162 of file ParaMEDMEM.py.

01162 
01163     def deepCpy(self):
01164         """
01165         deepCpy(self) -> DataArrayDouble
01166 
01167         1
01168         """
01169         return _ParaMEDMEM.DataArrayDouble_deepCpy(self)

Here is the call graph for this function:

DataArrayDouble * DataArrayDouble::determinant ( ) const throw (INTERP_KERNEL::Exception)

Definition at line 1724 of file MEDCouplingMemArray.cxx.

{
  checkAllocated();
  DataArrayDouble *ret=DataArrayDouble::New();
  int nbOfTuple=getNumberOfTuples();
  ret->alloc(nbOfTuple,1);
  const double *src=getConstPointer();
  double *dest=ret->getPointer();
  switch(getNumberOfComponents())
    {
    case 6:
      for(int i=0;i<nbOfTuple;i++,dest++,src+=6)
        *dest=src[0]*src[1]*src[2]+2.*src[4]*src[5]*src[3]-src[0]*src[4]*src[4]-src[2]*src[3]*src[3]-src[1]*src[5]*src[5];
      return ret;
    case 4:
      for(int i=0;i<nbOfTuple;i++,dest++,src+=4)
        *dest=src[0]*src[3]-src[1]*src[2];
      return ret;
    case 9:
      for(int i=0;i<nbOfTuple;i++,dest++,src+=9)
        *dest=src[0]*src[4]*src[8]+src[1]*src[5]*src[6]+src[2]*src[3]*src[7]-src[0]*src[5]*src[7]-src[1]*src[3]*src[8]-src[2]*src[4]*src[6];
      return ret;
    default:
      ret->decrRef();
      throw INTERP_KERNEL::Exception("DataArrayDouble::determinant : Invalid number of components ! must be in 4,6,9 !");
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

determinant(self) -> DataArrayDouble

1

Definition at line 1684 of file ParaMEDMEM.py.

01684 
01685     def determinant(self):
01686         """
01687         determinant(self) -> DataArrayDouble
01688 
01689         1
01690         """
01691         return _ParaMEDMEM.DataArrayDouble_determinant(self)

Here is the call graph for this function:

DataArrayDouble * DataArrayDouble::deviator ( ) const throw (INTERP_KERNEL::Exception)

Definition at line 1856 of file MEDCouplingMemArray.cxx.

{
  int nbOfComp=getNumberOfComponents();
  if(nbOfComp!=6)
    throw INTERP_KERNEL::Exception("DataArrayDouble::deviator : must be an array with exactly 6 components !");
  DataArrayDouble *ret=DataArrayDouble::New();
  int nbOfTuple=getNumberOfTuples();
  ret->alloc(nbOfTuple,6);
  const double *src=getConstPointer();
  double *dest=ret->getPointer();
  for(int i=0;i<nbOfTuple;i++,dest+=6,src+=6)
    {
      double tr=(src[0]+src[1]+src[2])/3.;
      dest[0]=src[0]-tr;
      dest[1]=src[1]-tr;
      dest[2]=src[2]-tr;
      dest[3]=src[3];
      dest[4]=src[4];
      dest[5]=src[5];
    }
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

deviator(self) -> DataArrayDouble

1

Definition at line 1724 of file ParaMEDMEM.py.

01724 
01725     def deviator(self):
01726         """
01727         deviator(self) -> DataArrayDouble
01728 
01729         1
01730         """
01731         return _ParaMEDMEM.DataArrayDouble_deviator(self)

Here is the call graph for this function:

DataArrayDouble * DataArrayDouble::Divide ( const DataArrayDouble a1,
const DataArrayDouble a2 
) throw (INTERP_KERNEL::Exception) [static]

Definition at line 2634 of file MEDCouplingMemArray.cxx.

{
  int nbOfTuple=a1->getNumberOfTuples();
  int nbOfTuple2=a2->getNumberOfTuples();
  int nbOfComp=a1->getNumberOfComponents();
  int nbOfComp2=a2->getNumberOfComponents();
  if(nbOfTuple!=nbOfTuple2)
    throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array Divide !");
  DataArrayDouble *ret=0;
  if(nbOfComp==nbOfComp2)
    {
      ret=DataArrayDouble::New();
      ret->alloc(nbOfTuple,nbOfComp);
      std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::divides<double>());
      ret->copyStringInfoFrom(*a1);
    }
  else
    {
      if(nbOfComp2==1)
        {
          ret=DataArrayDouble::New();
          ret->alloc(nbOfTuple,nbOfComp);
          const double *a2Ptr=a2->getConstPointer();
          const double *a1Ptr=a1->getConstPointer();
          double *res=ret->getPointer();
          for(int i=0;i<nbOfTuple;i++)
            res=std::transform(a1Ptr+i*nbOfComp,a1Ptr+(i+1)*nbOfComp,res,std::bind2nd(std::divides<double>(),a2Ptr[i]));
          ret->copyStringInfoFrom(*a1);
        }
      else
        throw INTERP_KERNEL::Exception("Nb of components mismatch for array Divide !");
    }
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Divide(DataArrayDouble a1, DataArrayDouble a2) -> DataArrayDouble

1

Definition at line 1933 of file ParaMEDMEM.py.

01933 
01934     def Divide(*args):
01935         """
01936         Divide(DataArrayDouble a1, DataArrayDouble a2) -> DataArrayDouble
01937 
01938         1
01939         """
01940         return _ParaMEDMEM.DataArrayDouble_Divide(*args)

Here is the call graph for this function:

void DataArrayDouble::divideEqual ( const DataArrayDouble other) throw (INTERP_KERNEL::Exception)

Definition at line 2669 of file MEDCouplingMemArray.cxx.

{
  const char *msg="Nb of tuples mismatch for DataArrayDouble::divideEqual !";
  int nbOfTuple=getNumberOfTuples();
  int nbOfTuple2=other->getNumberOfTuples();
  int nbOfComp=getNumberOfComponents();
  int nbOfComp2=other->getNumberOfComponents();
  if(nbOfTuple==nbOfTuple2)
    {
      if(nbOfComp==nbOfComp2)
        {
          std::transform(begin(),end(),other->begin(),getPointer(),std::divides<double>());
        }
      else if(nbOfComp2==1)
        {
          double *ptr=getPointer();
          const double *ptrc=other->getConstPointer();
          for(int i=0;i<nbOfTuple;i++)
            std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::divides<double>(),*ptrc++));
        }
      else
        throw INTERP_KERNEL::Exception(msg);
    }
  else if(nbOfTuple2==1)
    {
      if(nbOfComp2==nbOfComp)
        {
          double *ptr=getPointer();
          const double *ptrc=other->getConstPointer();
          for(int i=0;i<nbOfTuple;i++)
            std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::divides<double>());
        }
      else
        throw INTERP_KERNEL::Exception(msg);
    }
  else
    throw INTERP_KERNEL::Exception(msg);
  declareAsNew();
}

Here is the caller graph for this function:

def ParaMEDMEM.DataArrayDouble.divideEqual (   self,
  args 
)
divideEqual(self, DataArrayDouble other)

1

Definition at line 1943 of file ParaMEDMEM.py.

01943 
01944     def divideEqual(self, *args):
01945         """
01946         divideEqual(self, DataArrayDouble other)
01947 
01948         1
01949         """
01950         return _ParaMEDMEM.DataArrayDouble_divideEqual(self, *args)

Here is the call graph for this function:

DataArrayDouble * DataArrayDouble::Dot ( const DataArrayDouble a1,
const DataArrayDouble a2 
) throw (INTERP_KERNEL::Exception) [static]

Definition at line 2316 of file MEDCouplingMemArray.cxx.

{
  a1->checkAllocated();
  a2->checkAllocated();
  int nbOfComp=a1->getNumberOfComponents();
  if(nbOfComp!=a2->getNumberOfComponents())
    throw INTERP_KERNEL::Exception("Nb of components mismatch for array Dot !");
  int nbOfTuple=a1->getNumberOfTuples();
  if(nbOfTuple!=a2->getNumberOfTuples())
    throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array Dot !");
  DataArrayDouble *ret=DataArrayDouble::New();
  ret->alloc(nbOfTuple,1);
  double *retPtr=ret->getPointer();
  const double *a1Ptr=a1->getConstPointer();
  const double *a2Ptr=a2->getConstPointer();
  for(int i=0;i<nbOfTuple;i++)
    {
      double sum=0.;
      for(int j=0;j<nbOfComp;j++)
        sum+=a1Ptr[i*nbOfComp+j]*a2Ptr[i*nbOfComp+j];
      retPtr[i]=sum;
    }
  ret->setInfoOnComponent(0,a1->getInfoOnComponent(0).c_str());
  ret->setName(a1->getName().c_str());
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Dot(DataArrayDouble a1, DataArrayDouble a2) -> DataArrayDouble

1

Definition at line 1839 of file ParaMEDMEM.py.

01839 
01840     def Dot(*args):
01841         """
01842         Dot(DataArrayDouble a1, DataArrayDouble a2) -> DataArrayDouble
01843 
01844         1
01845         """
01846         return _ParaMEDMEM.DataArrayDouble_Dot(*args)

Here is the call graph for this function:

double DataArrayDouble::doubleValue ( ) const throw (INTERP_KERNEL::Exception)

This method returns the only one value in 'this', if and only if number of elements (nb of tuples * nb of components) is equal to 1, and that 'this' is allocated.

If one or more conditions is not fulfilled an exception will be thrown.

Definition at line 380 of file MEDCouplingMemArray.cxx.

{
  if(isAllocated())
    {
      if(getNbOfElems()==1)
        {
          return *getConstPointer();
        }
      else
        throw INTERP_KERNEL::Exception("DataArrayDouble::doubleValue : DataArrayDouble instance is allocated but number of elements is not equal to 1 !");
    }
  else
    throw INTERP_KERNEL::Exception("DataArrayDouble::doubleValue : DataArrayDouble instance is not allocated !");
}

Here is the call graph for this function:

Here is the caller graph for this function:

doubleValue(self) -> double

1

Definition at line 1146 of file ParaMEDMEM.py.

01146 
01147     def doubleValue(self):
01148         """
01149         doubleValue(self) -> double
01150 
01151         1
01152         """
01153         return _ParaMEDMEM.DataArrayDouble_doubleValue(self)

Here is the call graph for this function:

DataArrayDouble * DataArrayDouble::doublyContractedProduct ( ) const throw (INTERP_KERNEL::Exception)

Definition at line 1709 of file MEDCouplingMemArray.cxx.

{
  int nbOfComp=getNumberOfComponents();
  if(nbOfComp!=6)
    throw INTERP_KERNEL::Exception("DataArrayDouble::doublyContractedProduct : must be an array with exactly 6 components !");
  DataArrayDouble *ret=DataArrayDouble::New();
  int nbOfTuple=getNumberOfTuples();
  ret->alloc(nbOfTuple,1);
  const double *src=getConstPointer();
  double *dest=ret->getPointer();
  for(int i=0;i<nbOfTuple;i++,dest++,src+=6)
    *dest=src[0]*src[0]+src[1]*src[1]+src[2]*src[2]+2.*src[3]*src[3]+2.*src[4]*src[4]+2.*src[5]*src[5];
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

doublyContractedProduct(self) -> DataArrayDouble

1

Definition at line 1676 of file ParaMEDMEM.py.

01676 
01677     def doublyContractedProduct(self):
01678         """
01679         doublyContractedProduct(self) -> DataArrayDouble
01680 
01681         1
01682         """
01683         return _ParaMEDMEM.DataArrayDouble_doublyContractedProduct(self)

Here is the call graph for this function:

DataArrayDouble * DataArrayDouble::eigenValues ( ) const throw (INTERP_KERNEL::Exception)

Definition at line 1752 of file MEDCouplingMemArray.cxx.

{
  int nbOfComp=getNumberOfComponents();
  if(nbOfComp!=6)
    throw INTERP_KERNEL::Exception("DataArrayDouble::eigenValues : must be an array with exactly 6 components !");
  DataArrayDouble *ret=DataArrayDouble::New();
  int nbOfTuple=getNumberOfTuples();
  ret->alloc(nbOfTuple,3);
  const double *src=getConstPointer();
  double *dest=ret->getPointer();
  for(int i=0;i<nbOfTuple;i++,dest+=3,src+=6)
    INTERP_KERNEL::computeEigenValues6(src,dest);
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

eigenValues(self) -> DataArrayDouble

1

Definition at line 1692 of file ParaMEDMEM.py.

01692 
01693     def eigenValues(self):
01694         """
01695         eigenValues(self) -> DataArrayDouble
01696 
01697         1
01698         """
01699         return _ParaMEDMEM.DataArrayDouble_eigenValues(self)

Here is the call graph for this function:

DataArrayDouble * DataArrayDouble::eigenVectors ( ) const throw (INTERP_KERNEL::Exception)

Definition at line 1767 of file MEDCouplingMemArray.cxx.

{
  int nbOfComp=getNumberOfComponents();
  if(nbOfComp!=6)
    throw INTERP_KERNEL::Exception("DataArrayDouble::eigenVectors : must be an array with exactly 6 components !");
  DataArrayDouble *ret=DataArrayDouble::New();
  int nbOfTuple=getNumberOfTuples();
  ret->alloc(nbOfTuple,9);
  const double *src=getConstPointer();
  double *dest=ret->getPointer();
  for(int i=0;i<nbOfTuple;i++,src+=6)
    {
      double tmp[3];
      INTERP_KERNEL::computeEigenValues6(src,tmp);
      for(int j=0;j<3;j++,dest+=3)
        INTERP_KERNEL::computeEigenVectorForEigenValue6(src,tmp[j],1e-12,dest);
    }
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

eigenVectors(self) -> DataArrayDouble

1

Definition at line 1700 of file ParaMEDMEM.py.

01700 
01701     def eigenVectors(self):
01702         """
01703         eigenVectors(self) -> DataArrayDouble
01704 
01705         1
01706         """
01707         return _ParaMEDMEM.DataArrayDouble_eigenVectors(self)

Here is the call graph for this function:

bool DataArrayDouble::empty ( ) const throw (INTERP_KERNEL::Exception)

This method should be called on an allocated DataArrayDouble instance.

If not an exception will be throw ! This method checks the number of tupes. If it is equal to 0, it returns true, if not false is returned.

Definition at line 399 of file MEDCouplingMemArray.cxx.

{
  checkAllocated();
  return getNumberOfTuples()==0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

empty(self) -> bool

1

Definition at line 1154 of file ParaMEDMEM.py.

01154 
01155     def empty(self):
01156         """
01157         empty(self) -> bool
01158 
01159         1
01160         """
01161         return _ParaMEDMEM.DataArrayDouble_empty(self)

Here is the call graph for this function:

MEDCOUPLING_EXPORT const double* ParaMEDMEM::DataArrayDouble::end ( ) const [inline]

Definition at line 209 of file MEDCouplingMemArray.hxx.

{ return getConstPointer()+getNbOfElems(); }

Here is the call graph for this function:

Here is the caller graph for this function:

end(self) -> double

1

Definition at line 1579 of file ParaMEDMEM.py.

01579 
01580     def end(self):
01581         """
01582         end(self) -> double
01583 
01584         1
01585         """
01586         return _ParaMEDMEM.DataArrayDouble_end(self)

Here is the call graph for this function:

void DataArrayDouble::fillWithValue ( double  val) throw (INTERP_KERNEL::Exception)

Definition at line 463 of file MEDCouplingMemArray.cxx.

Here is the caller graph for this function:

def ParaMEDMEM.DataArrayDouble.fillWithValue (   self,
  args 
)
fillWithValue(self, double val)

1

Definition at line 1210 of file ParaMEDMEM.py.

01210 
01211     def fillWithValue(self, *args):
01212         """
01213         fillWithValue(self, double val)
01214 
01215         1
01216         """
01217         return _ParaMEDMEM.DataArrayDouble_fillWithValue(self, *args)

Here is the call graph for this function:

void DataArrayDouble::fillWithZero ( ) throw (INTERP_KERNEL::Exception)

Definition at line 456 of file MEDCouplingMemArray.cxx.

Here is the call graph for this function:

Here is the caller graph for this function:

fillWithZero(self)

1

Definition at line 1202 of file ParaMEDMEM.py.

01202 
01203     def fillWithZero(self):
01204         """
01205         fillWithZero(self)
01206 
01207         1
01208         """
01209         return _ParaMEDMEM.DataArrayDouble_fillWithZero(self)

Here is the call graph for this function:

void DataArrayDouble::findCommonTuples ( double  prec,
int  limitTupleId,
DataArrayInt *&  comm,
DataArrayInt *&  commIndex 
) const throw (INTERP_KERNEL::Exception)

This methods searches for each tuple if there are any tuples in 'this' that are less far than 'prec' from n1.

if any, these tuples are stored in out params comm and commIndex. The distance is computed using norm2. This method expects that 'this' is allocated and that the number of components is in [1,2,3]. If not an exception will be thrown. This method is typically used by MEDCouplingPointSet::findCommonNodes and MEDCouplingUMesh::mergeNodes. In case of success, commIndex->getNumberOfTuples()-1 gives the number of tuples groupes that are within distance 'prec'. comm->getNumberOfTuples()==commIndex->back() The returned pair of DataArrayInt instances ('comm','commIndex') is called Surjectived Format 2

See also:
DataArrayInt::BuildNew2OldArrayFromSurjectiveFormat2. This format is more compact in surjective format because only all tuple ids not in 'comm' are remain unchanged.
Parameters:
precis an absolute precision.
limitTupleIdis the limit tuple id. All tuples which id is strictly lower than 'limiTupleId' will not be merged each other.
commout parameter (not inout). Number of components is equal to 1.
commIndexout parameter (not inout). Number of components is equal to 1.

Definition at line 1050 of file MEDCouplingMemArray.cxx.

{
  checkAllocated();
  int nbOfCompo=getNumberOfComponents();
  if ((nbOfCompo<1) || (nbOfCompo>3)) //test before work
    throw INTERP_KERNEL::Exception("DataArrayDouble::findCommonTuples : Unexpected spacedim of coords. Must be 1, 2 or 3.");
  
  int nbOfTuples=getNumberOfTuples();
  comm=DataArrayInt::New();
  commIndex=DataArrayInt::New();
  //
  std::vector<double> bbox(2*nbOfTuples*nbOfCompo);
  const double *coordsPtr=getConstPointer();
  for(int i=0;i<nbOfTuples;i++)
    {
      for(int j=0;j<nbOfCompo;j++)
        {
          bbox[2*nbOfCompo*i+2*j]=coordsPtr[nbOfCompo*i+j];
          bbox[2*nbOfCompo*i+2*j+1]=coordsPtr[nbOfCompo*i+j];
        }
    }
  //
  std::vector<int> c,cI(1);
  switch(nbOfCompo)
    {
    case 3:
      findCommonTuplesAlg<3>(bbox,nbOfTuples,limitTupleId,prec,c,cI);
      break;
    case 2:
      findCommonTuplesAlg<2>(bbox,nbOfTuples,limitTupleId,prec,c,cI);
      break;
    case 1:
      findCommonTuplesAlg<1>(bbox,nbOfTuples,limitTupleId,prec,c,cI);
      break;
    //default: test yet
    }
  commIndex->alloc((int)cI.size(),1);
  std::copy(cI.begin(),cI.end(),commIndex->getPointer());
  comm->alloc(cI.back(),1);
  std::copy(c.begin(),c.end(),comm->getPointer());
}

Here is the call graph for this function:

Here is the caller graph for this function:

def ParaMEDMEM.DataArrayDouble.findCommonTuples (   self,
  args 
)
findCommonTuples(self, double prec, int limitTupleId, DataArrayInt comm, DataArrayInt commIndex)
findCommonTuples(self, double prec, int limitNodeId = -1) -> PyObject
findCommonTuples(self, double prec) -> PyObject

1

Definition at line 2187 of file ParaMEDMEM.py.

02187 
02188     def findCommonTuples(self, *args):
02189         """
02190         findCommonTuples(self, double prec, int limitTupleId, DataArrayInt comm, DataArrayInt commIndex)
02191         findCommonTuples(self, double prec, int limitNodeId = -1) -> PyObject
02192         findCommonTuples(self, double prec) -> PyObject
02193 
02194         1
02195         """
02196         return _ParaMEDMEM.DataArrayDouble_findCommonTuples(self, *args)

Here is the call graph for this function:

template<int SPACEDIM>
void DataArrayDouble::findCommonTuplesAlg ( std::vector< double > &  bbox,
int  nbNodes,
int  limitNodeId,
double  prec,
std::vector< int > &  c,
std::vector< int > &  cI 
) const [protected]

Definition at line 37 of file MEDCouplingMemArray.cxx.

{
  const double *coordsPtr=getConstPointer();
  BBTree<SPACEDIM,int> myTree(&bbox[0],0,0,nbNodes,-prec);
  double bb[2*SPACEDIM];
  double prec2=prec*prec;
  std::vector<bool> isDone(nbNodes);
  for(int i=0;i<nbNodes;i++)
    {
      if(!isDone[i])
        {
          for(int j=0;j<SPACEDIM;j++)
            {
              bb[2*j]=coordsPtr[SPACEDIM*i+j];
              bb[2*j+1]=coordsPtr[SPACEDIM*i+j];
            }
          std::vector<int> intersectingElems;
          myTree.getIntersectingElems(bb,intersectingElems);
          if(intersectingElems.size()>1)
            {
              std::vector<int> commonNodes;
              for(std::vector<int>::const_iterator it=intersectingElems.begin();it!=intersectingElems.end();it++)
                if(*it!=i)
                  if(*it>=limitNodeId)
                    if(INTERP_KERNEL::distance2<SPACEDIM>(coordsPtr+SPACEDIM*i,coordsPtr+SPACEDIM*(*it))<prec2)
                      {
                        commonNodes.push_back(*it);
                        isDone[*it]=true;
                      }
              if(!commonNodes.empty())
                {
                  cI.push_back(cI.back()+(int)commonNodes.size()+1);
                  c.push_back(i);
                  c.insert(c.end(),commonNodes.begin(),commonNodes.end());
                }
            }
        }
    }
}

Here is the call graph for this function:

void DataArrayDouble::finishUnserialization ( const std::vector< int > &  tinyInfoI,
const std::vector< std::string > &  tinyInfoS 
)

Useless method for end user.

Only for MPI/Corba/File serialsation for multi arrays class.

Definition at line 2768 of file MEDCouplingMemArray.cxx.

{
  setName(tinyInfoS[0].c_str());
  if(isAllocated())
    {
      int nbOfCompo=getNumberOfComponents();
      for(int i=0;i<nbOfCompo;i++)
        setInfoOnComponent(i,tinyInfoS[i+1].c_str());
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

finishUnserialization(self, ivec tinyInfoI, svec tinyInfoS)

1

Definition at line 1983 of file ParaMEDMEM.py.

01983 
01984     def finishUnserialization(self, *args):
01985         """
01986         finishUnserialization(self, ivec tinyInfoI, svec tinyInfoS)
01987 
01988         1
01989         """
01990         return _ParaMEDMEM.DataArrayDouble_finishUnserialization(self, *args)

Here is the call graph for this function:

DataArrayDouble * DataArrayDouble::fromCylToCart ( ) const throw (INTERP_KERNEL::Exception)

Definition at line 1670 of file MEDCouplingMemArray.cxx.

{
  int nbOfComp=getNumberOfComponents();
  if(nbOfComp!=3)
    throw INTERP_KERNEL::Exception("DataArrayDouble::fromCylToCart : must be an array with exactly 3 components !");
  int nbOfTuple=getNumberOfTuples();
  DataArrayDouble *ret=DataArrayDouble::New();
  ret->alloc(getNumberOfTuples(),3);
  double *w=ret->getPointer();
  const double *wIn=getConstPointer();
  for(int i=0;i<nbOfTuple;i++,w+=3,wIn+=3)
    {
      w[0]=wIn[0]*cos(wIn[1]);
      w[1]=wIn[0]*sin(wIn[1]);
      w[2]=wIn[2];
    }
  ret->setInfoOnComponent(2,getInfoOnComponent(2).c_str());
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

fromCylToCart(self) -> DataArrayDouble

1

Definition at line 1660 of file ParaMEDMEM.py.

01660 
01661     def fromCylToCart(self):
01662         """
01663         fromCylToCart(self) -> DataArrayDouble
01664 
01665         1
01666         """
01667         return _ParaMEDMEM.DataArrayDouble_fromCylToCart(self)

Here is the call graph for this function:

DataArrayDouble * DataArrayDouble::fromNoInterlace ( ) const throw (INTERP_KERNEL::Exception)

Definition at line 651 of file MEDCouplingMemArray.cxx.

{
  if(_mem.isNull())
    throw INTERP_KERNEL::Exception("DataArrayDouble::fromNoInterlace : Not defined array !");
  double *tab=_mem.fromNoInterlace(getNumberOfComponents());
  DataArrayDouble *ret=DataArrayDouble::New();
  ret->useArray(tab,true,CPP_DEALLOC,getNumberOfTuples(),getNumberOfComponents());
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

fromNoInterlace(self) -> DataArrayDouble

1

Definition at line 1347 of file ParaMEDMEM.py.

01347 
01348     def fromNoInterlace(self):
01349         """
01350         fromNoInterlace(self) -> DataArrayDouble
01351 
01352         1
01353         """
01354         return _ParaMEDMEM.DataArrayDouble_fromNoInterlace(self)

Here is the call graph for this function:

DataArrayDouble * DataArrayDouble::fromPolarToCart ( ) const throw (INTERP_KERNEL::Exception)

Definition at line 1652 of file MEDCouplingMemArray.cxx.

{
  int nbOfComp=getNumberOfComponents();
  if(nbOfComp!=2)
    throw INTERP_KERNEL::Exception("DataArrayDouble::fromPolarToCart : must be an array with exactly 2 components !");
  int nbOfTuple=getNumberOfTuples();
  DataArrayDouble *ret=DataArrayDouble::New();
  ret->alloc(nbOfTuple,2);
  double *w=ret->getPointer();
  const double *wIn=getConstPointer();
  for(int i=0;i<nbOfTuple;i++,w+=2,wIn+=2)
    {
      w[0]=wIn[0]*cos(wIn[1]);
      w[1]=wIn[0]*sin(wIn[1]);
    }
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

fromPolarToCart(self) -> DataArrayDouble

1

Definition at line 1652 of file ParaMEDMEM.py.

01652 
01653     def fromPolarToCart(self):
01654         """
01655         fromPolarToCart(self) -> DataArrayDouble
01656 
01657         1
01658         """
01659         return _ParaMEDMEM.DataArrayDouble_fromPolarToCart(self)

Here is the call graph for this function:

DataArrayDouble * DataArrayDouble::fromSpherToCart ( ) const throw (INTERP_KERNEL::Exception)

Definition at line 1690 of file MEDCouplingMemArray.cxx.

{
  int nbOfComp=getNumberOfComponents();
  if(nbOfComp!=3)
    throw INTERP_KERNEL::Exception("DataArrayDouble::fromSpherToCart : must be an array with exactly 3 components !");
  int nbOfTuple=getNumberOfTuples();
  DataArrayDouble *ret=DataArrayDouble::New();
  ret->alloc(getNumberOfTuples(),3);
  double *w=ret->getPointer();
  const double *wIn=getConstPointer();
  for(int i=0;i<nbOfTuple;i++,w+=3,wIn+=3)
    {
      w[0]=wIn[0]*cos(wIn[2])*sin(wIn[1]);
      w[1]=wIn[0]*sin(wIn[2])*sin(wIn[1]);
      w[2]=wIn[0]*cos(wIn[1]);
    }
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

fromSpherToCart(self) -> DataArrayDouble

1

Definition at line 1668 of file ParaMEDMEM.py.

01668 
01669     def fromSpherToCart(self):
01670         """
01671         fromSpherToCart(self) -> DataArrayDouble
01672 
01673         1
01674         """
01675         return _ParaMEDMEM.DataArrayDouble_fromSpherToCart(self)

Here is the call graph for this function:

double DataArrayDouble::getAverageValue ( ) const throw (INTERP_KERNEL::Exception)

Definition at line 1589 of file MEDCouplingMemArray.cxx.

{
  if(getNumberOfComponents()!=1)
    throw INTERP_KERNEL::Exception("DataArrayDouble::getAverageValue : must be applied on DataArrayDouble with only one component, you can call 'rearrange' method before !");
  int nbOfTuples=getNumberOfTuples();
  if(nbOfTuples<=0)
    throw INTERP_KERNEL::Exception("DataArrayDouble::getAverageValue : array exists but number of tuples must be > 0 !");
  const double *vals=getConstPointer();
  double ret=std::accumulate(vals,vals+nbOfTuples,0.);
  return ret/nbOfTuples;
}

Here is the call graph for this function:

Here is the caller graph for this function:

getAverageValue(self) -> double

1

Definition at line 1628 of file ParaMEDMEM.py.

01628 
01629     def getAverageValue(self):
01630         """
01631         getAverageValue(self) -> double
01632 
01633         1
01634         """
01635         return _ParaMEDMEM.DataArrayDouble_getAverageValue(self)

Here is the call graph for this function:

Definition at line 206 of file MEDCouplingMemArray.hxx.

{ return _mem.getConstPointer(); }

Here is the call graph for this function:

getConstPointer(self) -> double

1

Definition at line 1555 of file ParaMEDMEM.py.

01555 
01556     def getConstPointer(self):
01557         """
01558         getConstPointer(self) -> double
01559 
01560         1
01561         """
01562         return _ParaMEDMEM.DataArrayDouble_getConstPointer(self)

Here is the call graph for this function:

DataArrayDouble * DataArrayDouble::getDifferentValues ( double  prec,
int  limitTupleId = -1 
) const throw (INTERP_KERNEL::Exception)

This method returns a newly allocated object the user should deal with.

This method works for arrays which have number of components into [1,2,3]. If not an exception will be thrown. This method returns the different values in 'this' using 'prec'. The different values are kept in the same order than 'this'. That is to say that returned DataArrayDouble instance is not systematically sorted.

Parameters:
precis an absolute precision.
limitTupleIdis the limit tuple id. All tuples which id is strictly lower than 'limiTupleId' will not be merged each other.

Definition at line 1101 of file MEDCouplingMemArray.cxx.

{
  DataArrayInt *c0=0,*cI0=0;
  findCommonTuples(prec,limitTupleId,c0,cI0);
  MEDCouplingAutoRefCountObjectPtr<DataArrayInt> c(c0),cI(cI0);
  int newNbOfTuples=-1;
  MEDCouplingAutoRefCountObjectPtr<DataArrayInt> o2n=DataArrayInt::BuildOld2NewArrayFromSurjectiveFormat2(getNumberOfTuples(),c0,cI0,newNbOfTuples);
  return renumberAndReduce(o2n->getConstPointer(),newNbOfTuples);
}

Here is the call graph for this function:

Here is the caller graph for this function:

getDifferentValues(self, double prec, int limitTupleId = -1) -> DataArrayDouble
getDifferentValues(self, double prec) -> DataArrayDouble

1

Definition at line 1412 of file ParaMEDMEM.py.

01412 
01413     def getDifferentValues(self, *args):
01414         """
01415         getDifferentValues(self, double prec, int limitTupleId = -1) -> DataArrayDouble
01416         getDifferentValues(self, double prec) -> DataArrayDouble
01417 
01418         1
01419         """
01420         return _ParaMEDMEM.DataArrayDouble_getDifferentValues(self, *args)

Here is the call graph for this function:

getHiddenCppPointer(self) -> string

1

Definition at line 345 of file ParaMEDMEM.py.

00345 
00346     def getHiddenCppPointer(self):
00347         """
00348         getHiddenCppPointer(self) -> string
00349 
00350         1
00351         """
00352         return _ParaMEDMEM.RefCountObject_getHiddenCppPointer(self)

DataArrayInt * DataArrayDouble::getIdsInRange ( double  vmin,
double  vmax 
) const throw (INTERP_KERNEL::Exception)

Definition at line 2227 of file MEDCouplingMemArray.cxx.

{
  if(getNumberOfComponents()!=1)
    throw INTERP_KERNEL::Exception("DataArrayDouble::getIdsInRange : this must have exactly one component !");
  const double *cptr=getConstPointer();
  std::vector<int> res;
  int nbOfTuples=getNumberOfTuples();
  for(int i=0;i<nbOfTuples;i++,cptr++)
    if(*cptr>=vmin && *cptr<=vmax)
      res.push_back(i);
  DataArrayInt *ret=DataArrayInt::New();
  ret->alloc((int)res.size(),1);
  std::copy(res.begin(),res.end(),ret->getPointer());
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

def ParaMEDMEM.DataArrayDouble.getIdsInRange (   self,
  args 
)
getIdsInRange(self, double vmin, double vmax) -> DataArrayInt

1

Definition at line 1831 of file ParaMEDMEM.py.

01831 
01832     def getIdsInRange(self, *args):
01833         """
01834         getIdsInRange(self, double vmin, double vmax) -> DataArrayInt
01835 
01836         1
01837         """
01838         return _ParaMEDMEM.DataArrayDouble_getIdsInRange(self, *args)

Here is the call graph for this function:

MEDCOUPLING_EXPORT double ParaMEDMEM::DataArrayDouble::getIJ ( int  tupleId,
int  compoId 
) const [inline]

Definition at line 199 of file MEDCouplingMemArray.hxx.

{ return _mem[tupleId*((int)_info_on_compo.size())+compoId]; }

Here is the caller graph for this function:

def ParaMEDMEM.DataArrayDouble.getIJ (   self,
  args 
)
getIJ(self, int tupleId, int compoId) -> double

1

Definition at line 1507 of file ParaMEDMEM.py.

01507 
01508     def getIJ(self, *args):
01509         """
01510         getIJ(self, int tupleId, int compoId) -> double
01511 
01512         1
01513         """
01514         return _ParaMEDMEM.DataArrayDouble_getIJ(self, *args)

Here is the call graph for this function:

double DataArrayDouble::getIJSafe ( int  tupleId,
int  compoId 
) const throw (INTERP_KERNEL::Exception)

This method is equivalent to DataArrayDouble::getIJ except that here tupleId is checked to be in [0,this->getNumberOfTuples()) and compoId to be in [0,this->getNumberOfComponents()).

If one of these check fails an INTERP_KERNEL::Exception will be thrown. So this method is safe but expensive if used to go through all data of this.

Definition at line 1429 of file MEDCouplingMemArray.cxx.

{
  checkAllocated();
  if(tupleId<0 || tupleId>=getNumberOfTuples())
    {
      std::ostringstream oss; oss << "DataArrayDouble::getIJSafe : request for tupleId " << tupleId << " should be in [0," << getNumberOfTuples() << ") !";
      throw INTERP_KERNEL::Exception(oss.str().c_str());
    }
  if(compoId<0 || compoId>=getNumberOfComponents())
    {
      std::ostringstream oss; oss << "DataArrayDouble::getIJSafe : request for compoId " << compoId << " should be in [0," << getNumberOfComponents() << ") !";
      throw INTERP_KERNEL::Exception(oss.str().c_str());
    }
  return _mem[tupleId*((int)_info_on_compo.size())+compoId];
}

Here is the caller graph for this function:

def ParaMEDMEM.DataArrayDouble.getIJSafe (   self,
  args 
)
getIJSafe(self, int tupleId, int compoId) -> double

1

Definition at line 1523 of file ParaMEDMEM.py.

01523 
01524     def getIJSafe(self, *args):
01525         """
01526         getIJSafe(self, int tupleId, int compoId) -> double
01527 
01528         1
01529         """
01530         return _ParaMEDMEM.DataArrayDouble_getIJSafe(self, *args)

Here is the call graph for this function:

std::string DataArray::getInfoOnComponent ( int  i) const throw (INTERP_KERNEL::Exception) [inherited]

Definition at line 167 of file MEDCouplingMemArray.cxx.

{
  if(i<(int)_info_on_compo.size() && i>=0)
    return _info_on_compo[i];
  else
    {
      std::ostringstream oss; oss << "DataArray::getInfoOnComponent : Specified component id is out of range (" << i << ") compared with nb of actual components (" << (int) _info_on_compo.size();
      throw INTERP_KERNEL::Exception(oss.str().c_str());
    }
}

Here is the caller graph for this function:

def ParaMEDMEM.DataArray.getInfoOnComponent (   self,
  args 
) [inherited]
getInfoOnComponent(self, int i) -> string

1

Definition at line 944 of file ParaMEDMEM.py.

00944 
00945     def getInfoOnComponent(self, *args):
00946         """
00947         getInfoOnComponent(self, int i) -> string
00948 
00949         1
00950         """
00951         return _ParaMEDMEM.DataArray_getInfoOnComponent(self, *args)

Here is the call graph for this function:

MEDCOUPLING_EXPORT const std::vector<std::string>& ParaMEDMEM::DataArray::getInfoOnComponents ( ) const [inline, inherited]

Definition at line 98 of file MEDCouplingMemArray.hxx.

{ return _info_on_compo; }

Here is the caller graph for this function:

MEDCOUPLING_EXPORT std::vector<std::string>& ParaMEDMEM::DataArray::getInfoOnComponents ( ) [inline, inherited]

Definition at line 99 of file MEDCouplingMemArray.hxx.

{ return _info_on_compo; }
def ParaMEDMEM.DataArray.getInfoOnComponents (   self,
  args 
) [inherited]
getInfoOnComponents(self) -> svec
getInfoOnComponents(self) -> svec

1

Definition at line 911 of file ParaMEDMEM.py.

00911 
00912     def getInfoOnComponents(self, *args):
00913         """
00914         getInfoOnComponents(self) -> svec
00915         getInfoOnComponents(self) -> svec
00916 
00917         1
00918         """
00919         return _ParaMEDMEM.DataArray_getInfoOnComponents(self, *args)

Here is the call graph for this function:

double DataArrayDouble::getMaxValue ( int &  tupleId) const throw (INTERP_KERNEL::Exception)

Definition at line 1525 of file MEDCouplingMemArray.cxx.

{
  if(getNumberOfComponents()!=1)
    throw INTERP_KERNEL::Exception("DataArrayDouble::getMaxValue : must be applied on DataArrayDouble with only one component, you can call 'rearrange' method before or call 'getMaxValueInArray' method !");
  int nbOfTuples=getNumberOfTuples();
  if(nbOfTuples<=0)
    throw INTERP_KERNEL::Exception("DataArrayDouble::getMaxValue : array exists but number of tuples must be > 0 !");
  const double *vals=getConstPointer();
  const double *loc=std::max_element(vals,vals+nbOfTuples);
  tupleId=(int)std::distance(vals,loc);
  return *loc;
}

Here is the caller graph for this function:

def ParaMEDMEM.DataArrayDouble.getMaxValue (   self,
  args 
)
getMaxValue(self, int tupleId) -> double
getMaxValue(self) -> PyObject

1

Definition at line 2123 of file ParaMEDMEM.py.

02123 
02124     def getMaxValue(self, *args):
02125         """
02126         getMaxValue(self, int tupleId) -> double
02127         getMaxValue(self) -> PyObject
02128 
02129         1
02130         """
02131         return _ParaMEDMEM.DataArrayDouble_getMaxValue(self, *args)

Here is the call graph for this function:

double DataArrayDouble::getMaxValue2 ( DataArrayInt *&  tupleIds) const throw (INTERP_KERNEL::Exception)

Definition at line 1548 of file MEDCouplingMemArray.cxx.

{
  int tmp;
  tupleIds=0;
  double ret=getMaxValue(tmp);
  tupleIds=getIdsInRange(ret,ret);
  return ret;
}

Here is the caller graph for this function:

def ParaMEDMEM.DataArrayDouble.getMaxValue2 (   self,
  args 
)
getMaxValue2(self, DataArrayInt tupleIds) -> double
getMaxValue2(self) -> PyObject

1

Definition at line 2132 of file ParaMEDMEM.py.

02132 
02133     def getMaxValue2(self, *args):
02134         """
02135         getMaxValue2(self, DataArrayInt tupleIds) -> double
02136         getMaxValue2(self) -> PyObject
02137 
02138         1
02139         """
02140         return _ParaMEDMEM.DataArrayDouble_getMaxValue2(self, *args)

Here is the call graph for this function:

double DataArrayDouble::getMaxValueInArray ( ) const throw (INTERP_KERNEL::Exception)

Idem to DataArrayDouble::getMaxValue expect that here number of components can be >=1.

Definition at line 1541 of file MEDCouplingMemArray.cxx.

{
  checkAllocated();
  const double *loc=std::max_element(begin(),end());
  return *loc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

getMaxValueInArray(self) -> double

1

Definition at line 1612 of file ParaMEDMEM.py.

01612 
01613     def getMaxValueInArray(self):
01614         """
01615         getMaxValueInArray(self) -> double
01616 
01617         1
01618         """
01619         return _ParaMEDMEM.DataArrayDouble_getMaxValueInArray(self)

Here is the call graph for this function:

void DataArrayDouble::getMinMaxPerComponent ( double *  bounds) const throw (INTERP_KERNEL::Exception)

This method assume that this is allocated.

If not an INTERP_KERNEL::Exception will be thrown. This method fills bounds params like that : bounds[0]=XMin, bounds[1]=XMax, bounds[2]=YMin, bounds[3]=YMax... Where X refers to component #0, and Y to component #1... This method set 2*this->getNumberOfComponents() elements in bounds, so it is up to the caller to allocated enough space before calling this method.

Parameters:
[out]boundsarray of size 2*this->getNumberOfComponents().

Definition at line 1498 of file MEDCouplingMemArray.cxx.

{
  checkAllocated();
  int dim=getNumberOfComponents();
  for (int idim=0; idim<dim; idim++)
    {
      bounds[idim*2]=std::numeric_limits<double>::max();
      bounds[idim*2+1]=-std::numeric_limits<double>::max();
    } 
  const double *ptr=getConstPointer();
  int nbOfTuples=getNumberOfTuples();
  for(int i=0;i<nbOfTuples;i++)
    {
      for(int idim=0;idim<dim;idim++)
        {
          if(bounds[idim*2]>ptr[i*dim+idim])
            {
              bounds[idim*2]=ptr[i*dim+idim];
            }
          if(bounds[idim*2+1]<ptr[i*dim+idim])
            {
              bounds[idim*2+1]=ptr[i*dim+idim];
            }
        }
    }
}

Here is the caller graph for this function:

getMinMaxPerComponent(self, double bounds)
getMinMaxPerComponent(self) -> PyObject

1

Definition at line 2159 of file ParaMEDMEM.py.

02159 
02160     def getMinMaxPerComponent(self, *args):
02161         """
02162         getMinMaxPerComponent(self, double bounds)
02163         getMinMaxPerComponent(self) -> PyObject
02164 
02165         1
02166         """
02167         return _ParaMEDMEM.DataArrayDouble_getMinMaxPerComponent(self, *args)

Here is the call graph for this function:

double DataArrayDouble::getMinValue ( int &  tupleId) const throw (INTERP_KERNEL::Exception)

Definition at line 1557 of file MEDCouplingMemArray.cxx.

{
  if(getNumberOfComponents()!=1)
    throw INTERP_KERNEL::Exception("DataArrayDouble::getMinValue : must be applied on DataArrayDouble with only one component, you can call 'rearrange' method before call 'getMinValueInArray' method !");
  int nbOfTuples=getNumberOfTuples();
  if(nbOfTuples<=0)
    throw INTERP_KERNEL::Exception("DataArrayDouble::getMinValue : array exists but number of tuples must be > 0 !");
  const double *vals=getConstPointer();
  const double *loc=std::min_element(vals,vals+nbOfTuples);
  tupleId=(int)std::distance(vals,loc);
  return *loc;
}

Here is the caller graph for this function:

def ParaMEDMEM.DataArrayDouble.getMinValue (   self,
  args 
)
getMinValue(self, int tupleId) -> double
getMinValue(self) -> PyObject

1

Definition at line 2141 of file ParaMEDMEM.py.

02141 
02142     def getMinValue(self, *args):
02143         """
02144         getMinValue(self, int tupleId) -> double
02145         getMinValue(self) -> PyObject
02146 
02147         1
02148         """
02149         return _ParaMEDMEM.DataArrayDouble_getMinValue(self, *args)

Here is the call graph for this function:

double DataArrayDouble::getMinValue2 ( DataArrayInt *&  tupleIds) const throw (INTERP_KERNEL::Exception)

Definition at line 1580 of file MEDCouplingMemArray.cxx.

{
  int tmp;
  tupleIds=0;
  double ret=getMinValue(tmp);
  tupleIds=getIdsInRange(ret,ret);
  return ret;
}

Here is the caller graph for this function:

def ParaMEDMEM.DataArrayDouble.getMinValue2 (   self,
  args 
)
getMinValue2(self, DataArrayInt tupleIds) -> double
getMinValue2(self) -> PyObject

1

Definition at line 2150 of file ParaMEDMEM.py.

02150 
02151     def getMinValue2(self, *args):
02152         """
02153         getMinValue2(self, DataArrayInt tupleIds) -> double
02154         getMinValue2(self) -> PyObject
02155 
02156         1
02157         """
02158         return _ParaMEDMEM.DataArrayDouble_getMinValue2(self, *args)

Here is the call graph for this function:

double DataArrayDouble::getMinValueInArray ( ) const throw (INTERP_KERNEL::Exception)

Idem to DataArrayDouble::getMinValue expect that here number of components can be >=1.

Definition at line 1573 of file MEDCouplingMemArray.cxx.

{
  checkAllocated();
  const double *loc=std::min_element(begin(),end());
  return *loc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

getMinValueInArray(self) -> double

1

Definition at line 1620 of file ParaMEDMEM.py.

01620 
01621     def getMinValueInArray(self):
01622         """
01623         getMinValueInArray(self) -> double
01624 
01625         1
01626         """
01627         return _ParaMEDMEM.DataArrayDouble_getMinValueInArray(self)

Here is the call graph for this function:

MEDCOUPLING_EXPORT std::string ParaMEDMEM::DataArray::getName ( ) const [inline, inherited]

Definition at line 97 of file MEDCouplingMemArray.hxx.

{ return _name; }

Here is the caller graph for this function:

def ParaMEDMEM.DataArray.getName (   self) [inherited]
getName(self) -> string

1

Definition at line 903 of file ParaMEDMEM.py.

00903 
00904     def getName(self):
00905         """
00906         getName(self) -> string
00907 
00908         1
00909         """
00910         return _ParaMEDMEM.DataArray_getName(self)

Here is the call graph for this function:

MEDCOUPLING_EXPORT int ParaMEDMEM::DataArray::getNbOfElems ( ) const [inline, inherited]

Definition at line 109 of file MEDCouplingMemArray.hxx.

{ return ((int)_info_on_compo.size())*_nb_of_tuples; }
def ParaMEDMEM.DataArray.getNbOfElems (   self) [inherited]
getNbOfElems(self) -> int

1

Definition at line 992 of file ParaMEDMEM.py.

00992 
00993     def getNbOfElems(self):
00994         """
00995         getNbOfElems(self) -> int
00996 
00997         1
00998         """
00999         return _ParaMEDMEM.DataArray_getNbOfElems(self)

Here is the call graph for this function:

Definition at line 107 of file MEDCouplingMemArray.hxx.

{ return (int)_info_on_compo.size(); }
def ParaMEDMEM.DataArray.getNumberOfComponents (   self) [inherited]
getNumberOfComponents(self) -> int

1

Definition at line 976 of file ParaMEDMEM.py.

00976 
00977     def getNumberOfComponents(self):
00978         """
00979         getNumberOfComponents(self) -> int
00980 
00981         1
00982         """
00983         return _ParaMEDMEM.DataArray_getNumberOfComponents(self)

Here is the call graph for this function:

int DataArray::GetNumberOfItemGivenBES ( int  begin,
int  end,
int  step,
const char *  msg 
) throw (INTERP_KERNEL::Exception) [static, inherited]

Definition at line 303 of file MEDCouplingMemArray.cxx.

{
  if(end<begin)
    {
      std::ostringstream oss; oss << msg << " : end before begin !";
      throw INTERP_KERNEL::Exception(oss.str().c_str());
    }
  if(step<=0)
    {
      std::ostringstream oss; oss << msg << " : invalid step should be > 0 !";
      throw INTERP_KERNEL::Exception(oss.str().c_str());
    }
  return (end-1-begin)/step+1;
}

Here is the caller graph for this function:

GetNumberOfItemGivenBES(int begin, int end, int step, char msg) -> int

1

Definition at line 1017 of file ParaMEDMEM.py.

01017 
01018     def GetNumberOfItemGivenBES(*args):
01019         """
01020         GetNumberOfItemGivenBES(int begin, int end, int step, char msg) -> int
01021 
01022         1
01023         """
01024         return _ParaMEDMEM.DataArray_GetNumberOfItemGivenBES(*args)

Here is the call graph for this function:

int DataArray::GetNumberOfItemGivenBESRelative ( int  begin,
int  end,
int  step,
const char *  msg 
) throw (INTERP_KERNEL::Exception) [static, inherited]

Definition at line 318 of file MEDCouplingMemArray.cxx.

{
  if(step==0)
    throw INTERP_KERNEL::Exception("DataArray::GetNumberOfItemGivenBES : step=0 is not allowed !");
  if(end<begin && step>0)
    {
      std::ostringstream oss; oss << msg << " : end before begin whereas step is positive !";
      throw INTERP_KERNEL::Exception(oss.str().c_str());
    }
  if(begin<end && step<0)
    {
      std::ostringstream oss; oss << msg << " : invalid step should be > 0 !";
      throw INTERP_KERNEL::Exception(oss.str().c_str());
    }
  if(begin!=end)
    return (std::max(begin,end)-1-std::min(begin,end))/std::abs(step)+1;
  else
    return 0;
}

Here is the caller graph for this function:

GetNumberOfItemGivenBESRelative(int begin, int end, int step, char msg) -> int

1

Definition at line 1027 of file ParaMEDMEM.py.

01027 
01028     def GetNumberOfItemGivenBESRelative(*args):
01029         """
01030         GetNumberOfItemGivenBESRelative(int begin, int end, int step, char msg) -> int
01031 
01032         1
01033         """
01034         return _ParaMEDMEM.DataArray_GetNumberOfItemGivenBESRelative(*args)

Here is the call graph for this function:

Definition at line 108 of file MEDCouplingMemArray.hxx.

{ return _nb_of_tuples; }
def ParaMEDMEM.DataArray.getNumberOfTuples (   self) [inherited]
getNumberOfTuples(self) -> int

1

Definition at line 984 of file ParaMEDMEM.py.

00984 
00985     def getNumberOfTuples(self):
00986         """
00987         getNumberOfTuples(self) -> int
00988 
00989         1
00990         """
00991         return _ParaMEDMEM.DataArray_getNumberOfTuples(self)

Here is the call graph for this function:

Definition at line 204 of file MEDCouplingMemArray.hxx.

{ return _mem.getPointer(); }

Here is the call graph for this function:

getPointer(self) -> double

1

Definition at line 1547 of file ParaMEDMEM.py.

01547 
01548     def getPointer(self):
01549         """
01550         getPointer(self) -> double
01551 
01552         1
01553         """
01554         return _ParaMEDMEM.DataArrayDouble_getPointer(self)

Here is the call graph for this function:

def ParaMEDMEM.TimeLabel.getTimeOfThis (   self) [inherited]
getTimeOfThis(self) -> unsigned int

1

Definition at line 308 of file ParaMEDMEM.py.

00308 
00309     def getTimeOfThis(self):
00310         """
00311         getTimeOfThis(self) -> unsigned int
00312 
00313         1
00314         """
00315         return _ParaMEDMEM.TimeLabel_getTimeOfThis(self)

Here is the caller graph for this function:

void DataArrayDouble::getTinySerializationIntInformation ( std::vector< int > &  tinyInfo) const

Useless method for end user.

Only for MPI/Corba/File serialsation for multi arrays class. Server side.

Definition at line 2713 of file MEDCouplingMemArray.cxx.

{
  tinyInfo.resize(2);
  if(isAllocated())
    {
      tinyInfo[0]=getNumberOfTuples();
      tinyInfo[1]=getNumberOfComponents();
    }
  else
    {
      tinyInfo[0]=-1;
      tinyInfo[1]=-1;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

getTinySerializationIntInformation(self, ivec tinyInfo)

1

Definition at line 1959 of file ParaMEDMEM.py.

01959 
01960     def getTinySerializationIntInformation(self, *args):
01961         """
01962         getTinySerializationIntInformation(self, ivec tinyInfo)
01963 
01964         1
01965         """
01966         return _ParaMEDMEM.DataArrayDouble_getTinySerializationIntInformation(self, *args)

Here is the call graph for this function:

void DataArrayDouble::getTinySerializationStrInformation ( std::vector< std::string > &  tinyInfo) const

Useless method for end user.

Only for MPI/Corba/File serialsation for multi arrays class. Server side.

Definition at line 2732 of file MEDCouplingMemArray.cxx.

{
  if(isAllocated())
    {
      int nbOfCompo=getNumberOfComponents();
      tinyInfo.resize(nbOfCompo+1);
      tinyInfo[0]=getName();
      for(int i=0;i<nbOfCompo;i++)
        tinyInfo[i+1]=getInfoOnComponent(i);
    }
  else
    {
      tinyInfo.resize(1);
      tinyInfo[0]=getName();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

getTinySerializationStrInformation(self, svec tinyInfo)

1

Definition at line 1967 of file ParaMEDMEM.py.

01967 
01968     def getTinySerializationStrInformation(self, *args):
01969         """
01970         getTinySerializationStrInformation(self, svec tinyInfo)
01971 
01972         1
01973         """
01974         return _ParaMEDMEM.DataArrayDouble_getTinySerializationStrInformation(self, *args)

Here is the call graph for this function:

MEDCOUPLING_EXPORT void ParaMEDMEM::DataArrayDouble::getTuple ( int  tupleId,
double *  res 
) const [inline]

Definition at line 198 of file MEDCouplingMemArray.hxx.

{ std::copy(_mem.getConstPointerLoc(tupleId*((int)_info_on_compo.size())),_mem.getConstPointerLoc((tupleId+1)*((int)_info_on_compo.size())),res); }

Here is the call graph for this function:

Here is the caller graph for this function:

def ParaMEDMEM.DataArrayDouble.getTuple (   self,
  args 
)
getTuple(self, int tupleId, double res)
getTuple(self, int tupleId) -> PyObject

1

Definition at line 2206 of file ParaMEDMEM.py.

02206 
02207     def getTuple(self, *args):
02208         """
02209         getTuple(self, int tupleId, double res)
02210         getTuple(self, int tupleId) -> PyObject
02211 
02212         1
02213         """
02214         return _ParaMEDMEM.DataArrayDouble_getTuple(self, *args)

Here is the call graph for this function:

std::string DataArray::GetUnitFromInfo ( const std::string &  info) throw (INTERP_KERNEL::Exception) [static, inherited]

Definition at line 226 of file MEDCouplingMemArray.cxx.

{
  std::size_t p1=info.find_last_of('[');
  std::size_t p2=info.find_last_of(']');
  if(p1==std::string::npos || p2==std::string::npos)
    return std::string();
  if(p1>p2)
    return std::string();
  return info.substr(p1+1,p2-p1-1);
}

Here is the caller graph for this function:

def ParaMEDMEM.DataArray.GetUnitFromInfo (   args) [inherited]
GetUnitFromInfo(string info) -> string

1

Definition at line 1047 of file ParaMEDMEM.py.

01047 
01048     def GetUnitFromInfo(*args):
01049         """
01050         GetUnitFromInfo(string info) -> string
01051 
01052         1
01053         """
01054         return _ParaMEDMEM.DataArray_GetUnitFromInfo(*args)

Here is the call graph for this function:

std::string DataArray::getUnitOnComponent ( int  i) const throw (INTERP_KERNEL::Exception) [inherited]

In the info part of i_th component this method returns the var part.

For example, if getInfoOnComponent(0) return "SIGXY (N/m^2)", getUnitOnComponent(0) will return "N/m^2"

Definition at line 199 of file MEDCouplingMemArray.cxx.

{
  if(i<(int)_info_on_compo.size() && i>=0)
    {
      return GetUnitFromInfo(_info_on_compo[i]);
    }
  else
    {
      std::ostringstream oss; oss << "DataArray::getUnitOnComponent : Specified component id is out of range  (" << i << ") compared with nb of actual components (" << (int) _info_on_compo.size();
      throw INTERP_KERNEL::Exception(oss.str().c_str());
    }
}

Here is the caller graph for this function:

def ParaMEDMEM.DataArray.getUnitOnComponent (   self,
  args 
) [inherited]
getUnitOnComponent(self, int i) -> string

1

Definition at line 960 of file ParaMEDMEM.py.

00960 
00961     def getUnitOnComponent(self, *args):
00962         """
00963         getUnitOnComponent(self, int i) -> string
00964 
00965         1
00966         """
00967         return _ParaMEDMEM.DataArray_getUnitOnComponent(self, *args)

Here is the call graph for this function:

std::vector< std::string > DataArray::getUnitsOnComponent ( ) const [inherited]

Definition at line 158 of file MEDCouplingMemArray.cxx.

{
  int nbOfCompo=(int)_info_on_compo.size();
  std::vector<std::string> ret(nbOfCompo);
  for(int i=0;i<nbOfCompo;i++)
    ret[i]=getUnitOnComponent(i);
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

def ParaMEDMEM.DataArray.getUnitsOnComponent (   self) [inherited]
getUnitsOnComponent(self) -> svec

1

Definition at line 936 of file ParaMEDMEM.py.

00936 
00937     def getUnitsOnComponent(self):
00938         """
00939         getUnitsOnComponent(self) -> svec
00940 
00941         1
00942         """
00943         return _ParaMEDMEM.DataArray_getUnitsOnComponent(self)

Here is the call graph for this function:

getValues(self) -> PyObject

1

Definition at line 2044 of file ParaMEDMEM.py.

02044 
02045     def getValues(self):
02046         """
02047         getValues(self) -> PyObject
02048 
02049         1
02050         """
02051         return _ParaMEDMEM.DataArrayDouble_getValues(self)

getValuesAsTuple(self) -> PyObject

1

Definition at line 2052 of file ParaMEDMEM.py.

02052 
02053     def getValuesAsTuple(self):
02054         """
02055         getValuesAsTuple(self) -> PyObject
02056 
02057         1
02058         """
02059         return _ParaMEDMEM.DataArrayDouble_getValuesAsTuple(self)

std::string DataArray::GetVarNameFromInfo ( const std::string &  info) throw (INTERP_KERNEL::Exception) [static, inherited]

Definition at line 212 of file MEDCouplingMemArray.cxx.

{
  std::size_t p1=info.find_last_of('[');
  std::size_t p2=info.find_last_of(']');
  if(p1==std::string::npos || p2==std::string::npos)
    return info;
  if(p1>p2)
    return info;
  if(p1==0)
    return std::string();
  std::size_t p3=info.find_last_not_of(' ',p1-1);
  return info.substr(0,p3+1);
}

Here is the caller graph for this function:

def ParaMEDMEM.DataArray.GetVarNameFromInfo (   args) [inherited]
GetVarNameFromInfo(string info) -> string

1

Definition at line 1037 of file ParaMEDMEM.py.

01037 
01038     def GetVarNameFromInfo(*args):
01039         """
01040         GetVarNameFromInfo(string info) -> string
01041 
01042         1
01043         """
01044         return _ParaMEDMEM.DataArray_GetVarNameFromInfo(*args)

Here is the call graph for this function:

std::string DataArray::getVarOnComponent ( int  i) const throw (INTERP_KERNEL::Exception) [inherited]

In the info part of i_th component this method returns the var part.

For example, if getInfoOnComponent(0) return "SIGXY (N/m^2)", getVarOnComponent(0) will return "SIGXY"

Definition at line 182 of file MEDCouplingMemArray.cxx.

{
  if(i<(int)_info_on_compo.size() && i>=0)
    {
      return GetVarNameFromInfo(_info_on_compo[i]);
    }
  else
    {
      std::ostringstream oss; oss << "DataArray::getVarOnComponent : Specified component id is out of range  (" << i << ") compared with nb of actual components (" << (int) _info_on_compo.size();
      throw INTERP_KERNEL::Exception(oss.str().c_str());
    }
}

Here is the caller graph for this function:

def ParaMEDMEM.DataArray.getVarOnComponent (   self,
  args 
) [inherited]
getVarOnComponent(self, int i) -> string

1

Definition at line 952 of file ParaMEDMEM.py.

00952 
00953     def getVarOnComponent(self, *args):
00954         """
00955         getVarOnComponent(self, int i) -> string
00956 
00957         1
00958         """
00959         return _ParaMEDMEM.DataArray_getVarOnComponent(self, *args)

Here is the call graph for this function:

std::vector< std::string > DataArray::getVarsOnComponent ( ) const [inherited]

Definition at line 149 of file MEDCouplingMemArray.cxx.

{
  int nbOfCompo=(int)_info_on_compo.size();
  std::vector<std::string> ret(nbOfCompo);
  for(int i=0;i<nbOfCompo;i++)
    ret[i]=getVarOnComponent(i);
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

def ParaMEDMEM.DataArray.getVarsOnComponent (   self) [inherited]
getVarsOnComponent(self) -> svec

1

Definition at line 928 of file ParaMEDMEM.py.

00928 
00929     def getVarsOnComponent(self):
00930         """
00931         getVarsOnComponent(self) -> svec
00932 
00933         1
00934         """
00935         return _ParaMEDMEM.DataArray_getVarsOnComponent(self)

Here is the call graph for this function:

def ParaMEDMEM.RefCountObject.incrRef (   self) [inherited]
incrRef(self)

1

Definition at line 337 of file ParaMEDMEM.py.

00337 
00338     def incrRef(self):
00339         """
00340         incrRef(self)
00341 
00342         1
00343         """
00344         return _ParaMEDMEM.RefCountObject_incrRef(self)

DataArrayDouble * DataArrayDouble::inverse ( ) const throw (INTERP_KERNEL::Exception)

Definition at line 1787 of file MEDCouplingMemArray.cxx.

{
  int nbOfComp=getNumberOfComponents();
  if(nbOfComp!=6 && nbOfComp!=9 && nbOfComp!=4)
    throw INTERP_KERNEL::Exception("DataArrayDouble::inversion : must be an array with 4,6 or 9 components !");
  DataArrayDouble *ret=DataArrayDouble::New();
  int nbOfTuple=getNumberOfTuples();
  ret->alloc(nbOfTuple,nbOfComp);
  const double *src=getConstPointer();
  double *dest=ret->getPointer();
if(nbOfComp==6)
    for(int i=0;i<nbOfTuple;i++,dest+=6,src+=6)
      {
        double det=src[0]*src[1]*src[2]+2.*src[4]*src[5]*src[3]-src[0]*src[4]*src[4]-src[2]*src[3]*src[3]-src[1]*src[5]*src[5];
        dest[0]=(src[1]*src[2]-src[4]*src[4])/det;
        dest[1]=(src[0]*src[2]-src[5]*src[5])/det;
        dest[2]=(src[0]*src[1]-src[3]*src[3])/det;
        dest[3]=(src[5]*src[4]-src[3]*src[2])/det;
        dest[4]=(src[5]*src[3]-src[0]*src[4])/det;
        dest[5]=(src[3]*src[4]-src[1]*src[5])/det;
      }
  else if(nbOfComp==4)
    for(int i=0;i<nbOfTuple;i++,dest+=4,src+=4)
      {
        double det=src[0]*src[3]-src[1]*src[2];
        dest[0]=src[3]/det;
        dest[1]=-src[1]/det;
        dest[2]=-src[2]/det;
        dest[3]=src[0]/det;
      }
  else
    for(int i=0;i<nbOfTuple;i++,dest+=9,src+=9)
      {
        double det=src[0]*src[4]*src[8]+src[1]*src[5]*src[6]+src[2]*src[3]*src[7]-src[0]*src[5]*src[7]-src[1]*src[3]*src[8]-src[2]*src[4]*src[6];
        dest[0]=(src[4]*src[8]-src[7]*src[5])/det;
        dest[1]=(src[7]*src[2]-src[1]*src[8])/det;
        dest[2]=(src[1]*src[5]-src[4]*src[2])/det;
        dest[3]=(src[6]*src[5]-src[3]*src[8])/det;
        dest[4]=(src[0]*src[8]-src[6]*src[2])/det;
        dest[5]=(src[2]*src[3]-src[0]*src[5])/det;
        dest[6]=(src[3]*src[7]-src[6]*src[4])/det;
        dest[7]=(src[6]*src[1]-src[0]*src[7])/det;
        dest[8]=(src[0]*src[4]-src[1]*src[3])/det;
      }
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

inverse(self) -> DataArrayDouble

1

Definition at line 1708 of file ParaMEDMEM.py.

01708 
01709     def inverse(self):
01710         """
01711         inverse(self) -> DataArrayDouble
01712 
01713         1
01714         """
01715         return _ParaMEDMEM.DataArrayDouble_inverse(self)

Here is the call graph for this function:

void DataArrayDouble::iota ( double  init = 0.) throw (INTERP_KERNEL::Exception)

Definition at line 470 of file MEDCouplingMemArray.cxx.

{
  checkAllocated();
  if(getNumberOfComponents()!=1)
    throw INTERP_KERNEL::Exception("DataArrayDouble::iota : works only for arrays with only one component, you can call 'rearrange' method before !");
  double *ptr=getPointer();
  int ntuples=getNumberOfTuples();
  for(int i=0;i<ntuples;i++)
    ptr[i]=init+double(i);
  declareAsNew();
}

Here is the caller graph for this function:

def ParaMEDMEM.DataArrayDouble.iota (   self,
  init = 0. 
)
iota(self, double init = 0.)
iota(self)

1

Definition at line 1218 of file ParaMEDMEM.py.

01218 
01219     def iota(self, init = 0.):
01220         """
01221         iota(self, double init = 0.)
01222         iota(self)
01223 
01224         1
01225         """
01226         return _ParaMEDMEM.DataArrayDouble_iota(self, init)

Here is the call graph for this function:

Definition at line 343 of file MEDCouplingMemArray.cxx.

{
  return getConstPointer()!=0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

isAllocated(self) -> bool

1

Definition at line 1122 of file ParaMEDMEM.py.

01122 
01123     def isAllocated(self):
01124         """
01125         isAllocated(self) -> bool
01126 
01127         1
01128         """
01129         return _ParaMEDMEM.DataArrayDouble_isAllocated(self)

Here is the call graph for this function:

bool DataArrayDouble::isEqual ( const DataArrayDouble other,
double  prec 
) const

Definition at line 619 of file MEDCouplingMemArray.cxx.

{
  if(!areInfoEquals(other))
    return false;
  return _mem.isEqual(other._mem,prec);
}

Here is the call graph for this function:

Here is the caller graph for this function:

def ParaMEDMEM.DataArrayDouble.isEqual (   self,
  args 
)
isEqual(self, DataArrayDouble other, double prec) -> bool

1

Definition at line 1315 of file ParaMEDMEM.py.

01315 
01316     def isEqual(self, *args):
01317         """
01318         isEqual(self, DataArrayDouble other, double prec) -> bool
01319 
01320         1
01321         """
01322         return _ParaMEDMEM.DataArrayDouble_isEqual(self, *args)

Here is the call graph for this function:

bool DataArrayDouble::isEqualWithoutConsideringStr ( const DataArrayDouble other,
double  prec 
) const

Definition at line 626 of file MEDCouplingMemArray.cxx.

{
  return _mem.isEqual(other._mem,prec);
}

Here is the call graph for this function:

Here is the caller graph for this function:

isEqualWithoutConsideringStr(self, DataArrayDouble other, double prec) -> bool

1

Definition at line 1323 of file ParaMEDMEM.py.

01323 
01324     def isEqualWithoutConsideringStr(self, *args):
01325         """
01326         isEqualWithoutConsideringStr(self, DataArrayDouble other, double prec) -> bool
01327 
01328         1
01329         """
01330         return _ParaMEDMEM.DataArrayDouble_isEqualWithoutConsideringStr(self, *args)

Here is the call graph for this function:

bool DataArrayDouble::isMonotonic ( bool  increasing,
double  eps 
) const throw (INTERP_KERNEL::Exception)

This method check that (Maths) array consistently INCREASING or DECREASING in value, with at least absolute difference value of |eps| at each step.

Definition at line 538 of file MEDCouplingMemArray.cxx.

{
  checkAllocated();
  if(getNumberOfComponents()!=1)
    throw INTERP_KERNEL::Exception("DataArrayDouble::isMonotonic : only supported with 'this' array with ONE component !");
  int nbOfElements=getNumberOfTuples();
  const double *ptr=getConstPointer();
  if(nbOfElements==0)
    return true;
  double ref=ptr[0];
  double absEps=fabs(eps);
  if (increasing)
    {
      for(int i=1;i<nbOfElements;i++)
        {
          if(ptr[i]<(ref+absEps)) return false;
          ref=ptr[i];
        }
      return true;
    }
  else
    {
      for(int i=1;i<nbOfElements;i++)
        {
          if(ptr[i]>(ref-absEps)) return false;
          ref=ptr[i];
        }
      return true;
    }
}

Here is the caller graph for this function:

def ParaMEDMEM.DataArrayDouble.isMonotonic (   self,
  args 
)
isMonotonic(self, bool increasing, double eps) -> bool

1

Definition at line 1259 of file ParaMEDMEM.py.

01259 
01260     def isMonotonic(self, *args):
01261         """
01262         isMonotonic(self, bool increasing, double eps) -> bool
01263 
01264         1
01265         """
01266         return _ParaMEDMEM.DataArrayDouble_isMonotonic(self, *args)

Here is the call graph for this function:

bool DataArrayDouble::isUniform ( double  val,
double  eps 
) const throw (INTERP_KERNEL::Exception)

Definition at line 482 of file MEDCouplingMemArray.cxx.

{
  checkAllocated();
  if(getNumberOfComponents()!=1)
    throw INTERP_KERNEL::Exception("DataArrayDouble::isUniform : must be applied on DataArrayDouble with only one component, you can call 'rearrange' method before !");
  int nbOfTuples=getNumberOfTuples();
  const double *w=getConstPointer();
  const double *end2=w+nbOfTuples;
  const double vmin=val-eps;
  const double vmax=val+eps;
  for(;w!=end2;w++)
    if(*w<vmin || *w>vmax)
      return false;
  return true;
}

Here is the caller graph for this function:

def ParaMEDMEM.DataArrayDouble.isUniform (   self,
  args 
)
isUniform(self, double val, double eps) -> bool

1

Definition at line 1227 of file ParaMEDMEM.py.

01227 
01228     def isUniform(self, *args):
01229         """
01230         isUniform(self, double val, double eps) -> bool
01231 
01232         1
01233         """
01234         return _ParaMEDMEM.DataArrayDouble_isUniform(self, *args)

Here is the call graph for this function:

Definition at line 2222 of file MEDCouplingMemArray.cxx.

{
  return new DataArrayDoubleIterator(this);
}

Here is the caller graph for this function:

iterator(self) -> DataArrayDoubleIterator

1

Definition at line 1563 of file ParaMEDMEM.py.

01563 
01564     def iterator(self):
01565         """
01566         iterator(self) -> DataArrayDoubleIterator
01567 
01568         1
01569         """
01570         return _ParaMEDMEM.DataArrayDouble_iterator(self)

Here is the call graph for this function:

DataArrayDouble * DataArrayDouble::keepSelectedComponents ( const std::vector< int > &  compoIds) const throw (INTERP_KERNEL::Exception)

Definition at line 980 of file MEDCouplingMemArray.cxx.

{
  checkAllocated();
  MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret(DataArrayDouble::New());
  std::size_t newNbOfCompo=compoIds.size();
  int oldNbOfCompo=getNumberOfComponents();
  for(std::vector<int>::const_iterator it=compoIds.begin();it!=compoIds.end();it++)
    if((*it)<0 || (*it)>=oldNbOfCompo)
      {
        std::ostringstream oss; oss << "DataArrayDouble::keepSelectedComponents : invalid requested component : " << *it << " whereas it should be in [0," << oldNbOfCompo << ") !";
        throw INTERP_KERNEL::Exception(oss.str().c_str());
      }
  int nbOfTuples=getNumberOfTuples();
  ret->alloc(nbOfTuples,(int)newNbOfCompo);
  ret->copyPartOfStringInfoFrom(*this,compoIds);
  const double *oldc=getConstPointer();
  double *nc=ret->getPointer();
  for(int i=0;i<nbOfTuples;i++)
    for(std::size_t j=0;j<newNbOfCompo;j++,nc++)
      *nc=oldc[i*oldNbOfCompo+compoIds[j]];
  ret->incrRef();
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

keepSelectedComponents(self, ivec compoIds) -> DataArrayDouble
keepSelectedComponents(self, PyObject li) -> DataArrayDouble

1

Definition at line 2178 of file ParaMEDMEM.py.

02178 
02179     def keepSelectedComponents(self, *args):
02180         """
02181         keepSelectedComponents(self, ivec compoIds) -> DataArrayDouble
02182         keepSelectedComponents(self, PyObject li) -> DataArrayDouble
02183 
02184         1
02185         """
02186         return _ParaMEDMEM.DataArrayDouble_keepSelectedComponents(self, *args)

Here is the call graph for this function:

DataArrayDouble * DataArrayDouble::magnitude ( ) const throw (INTERP_KERNEL::Exception)

Definition at line 1879 of file MEDCouplingMemArray.cxx.

{
  checkAllocated();
  int nbOfComp=getNumberOfComponents();
  DataArrayDouble *ret=DataArrayDouble::New();
  int nbOfTuple=getNumberOfTuples();
  ret->alloc(nbOfTuple,1);
  const double *src=getConstPointer();
  double *dest=ret->getPointer();
  for(int i=0;i<nbOfTuple;i++,dest++)
    {
      double sum=0.;
      for(int j=0;j<nbOfComp;j++,src++)
        sum+=(*src)*(*src);
      *dest=sqrt(sum);
    }
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

magnitude(self) -> DataArrayDouble

1

Definition at line 1732 of file ParaMEDMEM.py.

01732 
01733     def magnitude(self):
01734         """
01735         magnitude(self) -> DataArrayDouble
01736 
01737         1
01738         """
01739         return _ParaMEDMEM.DataArrayDouble_magnitude(self)

Here is the call graph for this function:

DataArrayDouble * DataArrayDouble::Max ( const DataArrayDouble a1,
const DataArrayDouble a2 
) throw (INTERP_KERNEL::Exception) [static]

Definition at line 2368 of file MEDCouplingMemArray.cxx.

{
  int nbOfComp=a1->getNumberOfComponents();
  if(nbOfComp!=a2->getNumberOfComponents())
    throw INTERP_KERNEL::Exception("Nb of components mismatch for array Max !");
  int nbOfTuple=a1->getNumberOfTuples();
  if(nbOfTuple!=a2->getNumberOfTuples())
    throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array Max !");
  DataArrayDouble *ret=DataArrayDouble::New();
  ret->alloc(nbOfTuple,nbOfComp);
  double *retPtr=ret->getPointer();
  const double *a1Ptr=a1->getConstPointer();
  const double *a2Ptr=a2->getConstPointer();
  int nbElem=nbOfTuple*nbOfComp;
  for(int i=0;i<nbElem;i++)
    retPtr[i]=std::max(a1Ptr[i],a2Ptr[i]);
  ret->copyStringInfoFrom(*a1);
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Max(DataArrayDouble a1, DataArrayDouble a2) -> DataArrayDouble

1

Definition at line 1859 of file ParaMEDMEM.py.

01859 
01860     def Max(*args):
01861         """
01862         Max(DataArrayDouble a1, DataArrayDouble a2) -> DataArrayDouble
01863 
01864         1
01865         """
01866         return _ParaMEDMEM.DataArrayDouble_Max(*args)

Here is the call graph for this function: