-// Copyright (C) 2007-2015 CEA/DEN, EDF R&D
+// Copyright (C) 2007-2016 CEA/DEN, EDF R&D
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// Author : Anthony Geay (CEA/DEN)
#include "MEDCouplingMemArray.txx"
-#include "MEDCouplingAutoRefCountObjectPtr.hxx"
+#include "MCAuto.hxx"
#include "BBTree.txx"
#include "GenMathFormulae.hxx"
return oss.str();
}
-std::string DataArray::GetAxTypeRepr(MEDCouplingAxisType at)
+std::string DataArray::GetAxisTypeRepr(MEDCouplingAxisType at)
{
switch(at)
{
case AX_SPHER:
return std::string("AX_SPHER");
default:
- throw INTERP_KERNEL::Exception("DataArray::GetAxTypeRepr : unrecognized axis type enum !");
+ throw INTERP_KERNEL::Exception("DataArray::GetAxisTypeRepr : unrecognized axis type enum !");
}
}
* \return DataArrayDouble * - a new instance of DataArrayDouble. The caller is to
* delete this array using decrRef() as it is no more needed.
*/
-DataArrayDouble *DataArrayDouble::deepCpy() const
+DataArrayDouble *DataArrayDouble::deepCopy() const
{
return new DataArrayDouble(*this);
}
* \return DataArrayDouble * - either a new instance of DataArrayDouble (if \a dCpy
* == \a true) or \a this instance (if \a dCpy == \a false).
*/
-DataArrayDouble *DataArrayDouble::performCpy(bool dCpy) const
+DataArrayDouble *DataArrayDouble::performCopyOrIncrRef(bool dCpy) const
{
if(dCpy)
- return deepCpy();
+ return deepCopy();
else
{
incrRef();
* \param [in] other - another instance of DataArrayDouble to copy data from.
* \throw If the \a other is not allocated.
*/
-void DataArrayDouble::cpyFrom(const DataArrayDouble& other)
+void DataArrayDouble::deepCopyFrom(const DataArrayDouble& other)
{
other.checkAllocated();
int nbOfTuples=other.getNumberOfTuples();
* Permutes values of \a this array as required by \a old2New array. The values are
* permuted so that \c new[ \a old2New[ i ]] = \c old[ i ]. Number of tuples remains
* the same as in \c this one.
- * If a permutation reduction is needed, substr() or selectByTupleId() should be used.
+ * If a permutation reduction is needed, subArray() or selectByTupleId() should be used.
* For more info on renumbering see \ref numbering.
* \param [in] old2New - C array of length equal to \a this->getNumberOfTuples()
* giving a new position for i-th old value.
checkAllocated();
int nbTuples=getNumberOfTuples();
int nbOfCompo=getNumberOfComponents();
- MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
+ MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
ret->alloc(nbTuples,nbOfCompo);
ret->copyStringInfoFrom(*this);
const double *iptr=getConstPointer();
* Returns a copy of \a this array with values permuted as required by \a new2Old array.
* The values are permuted so that \c new[ i ] = \c old[ \a new2Old[ i ]]. Number of
* tuples in the result array remains the same as in \c this one.
- * If a permutation reduction is needed, substr() or selectByTupleId() should be used.
+ * If a permutation reduction is needed, subArray() or selectByTupleId() should be used.
* For more info on renumbering see \ref numbering.
* \param [in] new2Old - C array of length equal to \a this->getNumberOfTuples()
* giving a previous position of i-th new value.
checkAllocated();
int nbTuples=getNumberOfTuples();
int nbOfCompo=getNumberOfComponents();
- MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
+ MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
ret->alloc(nbTuples,nbOfCompo);
ret->copyStringInfoFrom(*this);
const double *iptr=getConstPointer();
checkAllocated();
int nbTuples=getNumberOfTuples();
int nbOfCompo=getNumberOfComponents();
- MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
+ MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
ret->alloc(newNbOfTuple,nbOfCompo);
const double *iptr=getConstPointer();
double *optr=ret->getPointer();
DataArrayDouble *DataArrayDouble::selectByTupleId(const int *new2OldBg, const int *new2OldEnd) const
{
checkAllocated();
- MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
+ MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
int nbComp=getNumberOfComponents();
ret->alloc((int)std::distance(new2OldBg,new2OldEnd),nbComp);
ret->copyStringInfoFrom(*this);
DataArrayDouble *DataArrayDouble::selectByTupleIdSafe(const int *new2OldBg, const int *new2OldEnd) const
{
checkAllocated();
- MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
+ MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
int nbComp=getNumberOfComponents();
int oldNbOfTuples=getNumberOfTuples();
ret->alloc((int)std::distance(new2OldBg,new2OldEnd),nbComp);
* \param [in] step - index increment to get index of the next tuple to copy.
* \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
* is to delete using decrRef() as it is no more needed.
- * \sa DataArrayDouble::substr.
+ * \sa DataArrayDouble::subArray.
*/
-DataArrayDouble *DataArrayDouble::selectByTupleId2(int bg, int end2, int step) const
+DataArrayDouble *DataArrayDouble::selectByTupleIdSafeSlice(int bg, int end2, int step) const
{
checkAllocated();
- MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
+ MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
int nbComp=getNumberOfComponents();
- int newNbOfTuples=GetNumberOfItemGivenBESRelative(bg,end2,step,"DataArrayDouble::selectByTupleId2 : ");
+ int newNbOfTuples=GetNumberOfItemGivenBESRelative(bg,end2,step,"DataArrayDouble::selectByTupleIdSafeSlice : ");
ret->alloc(newNbOfTuples,nbComp);
double *pt=ret->getPointer();
const double *srcPt=getConstPointer()+bg*nbComp;
}
}
if(isIncreasing && nbOfTuplesThis==nbOfTuples)
- return deepCpy();
- MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
+ return deepCopy();
+ MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
ret->alloc(nbOfTuples,nbOfComp);
ret->copyStringInfoFrom(*this);
const double *src=getConstPointer();
* Returns a shorten copy of \a this array. The new DataArrayDouble contains all
* tuples starting from the \a tupleIdBg-th tuple and including all tuples located before
* the \a tupleIdEnd-th one. This methods has a similar behavior as std::string::substr().
- * This method is a specialization of selectByTupleId2().
+ * This method is a specialization of selectByTupleIdSafeSlice().
* \param [in] tupleIdBg - index of the first tuple to copy from \a this array.
* \param [in] tupleIdEnd - index of the tuple before which the tuples to copy are located.
* If \a tupleIdEnd == -1, all the tuples till the end of \a this array are copied.
* \throw If \a tupleIdBg < 0.
* \throw If \a tupleIdBg > \a this->getNumberOfTuples().
\throw If \a tupleIdEnd != -1 && \a tupleIdEnd < \a this->getNumberOfTuples().
- * \sa DataArrayDouble::selectByTupleId2
+ * \sa DataArrayDouble::selectByTupleIdSafeSlice
*/
-DataArrayDouble *DataArrayDouble::substr(int tupleIdBg, int tupleIdEnd) const
+DataArrayDouble *DataArrayDouble::subArray(int tupleIdBg, int tupleIdEnd) const
{
checkAllocated();
int nbt=getNumberOfTuples();
if(tupleIdBg<0)
- throw INTERP_KERNEL::Exception("DataArrayDouble::substr : The tupleIdBg parameter must be greater than 0 !");
+ throw INTERP_KERNEL::Exception("DataArrayDouble::subArray : The tupleIdBg parameter must be greater than 0 !");
if(tupleIdBg>nbt)
- throw INTERP_KERNEL::Exception("DataArrayDouble::substr : The tupleIdBg parameter is greater than number of tuples !");
+ throw INTERP_KERNEL::Exception("DataArrayDouble::subArray : The tupleIdBg parameter is greater than number of tuples !");
int trueEnd=tupleIdEnd;
if(tupleIdEnd!=-1)
{
if(tupleIdEnd>nbt)
- throw INTERP_KERNEL::Exception("DataArrayDouble::substr : The tupleIdBg parameter is greater or equal than number of tuples !");
+ throw INTERP_KERNEL::Exception("DataArrayDouble::subArray : The tupleIdBg parameter is greater or equal than number of tuples !");
}
else
trueEnd=nbt;
int nbComp=getNumberOfComponents();
- MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
+ MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
ret->alloc(trueEnd-tupleIdBg,nbComp);
ret->copyStringInfoFrom(*this);
std::copy(getConstPointer()+tupleIdBg*nbComp,getConstPointer()+trueEnd*nbComp,ret->getPointer());
DataArrayDouble *DataArrayDouble::changeNbOfComponents(int newNbOfComp, double dftValue) const
{
checkAllocated();
- MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
+ MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
ret->alloc(getNumberOfTuples(),newNbOfComp);
const double *oldc=getConstPointer();
double *nc=ret->getPointer();
DataArrayDouble *DataArrayDouble::keepSelectedComponents(const std::vector<int>& compoIds) const
{
checkAllocated();
- MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret(DataArrayDouble::New());
+ MCAuto<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++)
checkAllocated(); other->checkAllocated();
if(getNumberOfComponents()!=other->getNumberOfComponents())
throw INTERP_KERNEL::Exception("DataArrayDouble::areIncludedInMe : the number of components does not match !");
- MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> a=DataArrayDouble::Aggregate(this,other);
+ MCAuto<DataArrayDouble> a=DataArrayDouble::Aggregate(this,other);
DataArrayInt *c=0,*ci=0;
a->findCommonTuples(prec,getNumberOfTuples(),c,ci);
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> cSafe(c),ciSafe(ci);
+ MCAuto<DataArrayInt> cSafe(c),ciSafe(ci);
int newNbOfTuples=-1;
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ids=DataArrayInt::BuildOld2NewArrayFromSurjectiveFormat2(a->getNumberOfTuples(),c->begin(),ci->begin(),ci->end(),newNbOfTuples);
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret1=ids->selectByTupleId2(getNumberOfTuples(),a->getNumberOfTuples(),1);
+ MCAuto<DataArrayInt> ids=DataArrayInt::ConvertIndexArrayToO2N(a->getNumberOfTuples(),c->begin(),ci->begin(),ci->end(),newNbOfTuples);
+ MCAuto<DataArrayInt> ret1=ids->selectByTupleIdSafeSlice(getNumberOfTuples(),a->getNumberOfTuples(),1);
tupleIds=ret1.retn();
return newNbOfTuples==getNumberOfTuples();
}
*
* \ref py_mcdataarraydouble_findcommontuples "Here is a Python example".
* \endif
- * \sa DataArrayInt::BuildOld2NewArrayFromSurjectiveFormat2(), DataArrayDouble::areIncludedInMe
+ * \sa DataArrayInt::ConvertIndexArrayToO2N(), DataArrayDouble::areIncludedInMe
*/
void DataArrayDouble::findCommonTuples(double prec, int limitTupleId, DataArrayInt *&comm, DataArrayInt *&commIndex) const
{
int nbOfTuples=getNumberOfTuples();
//
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> c(DataArrayInt::New()),cI(DataArrayInt::New()); c->alloc(0,1); cI->pushBackSilent(0);
+ MCAuto<DataArrayInt> c(DataArrayInt::New()),cI(DataArrayInt::New()); c->alloc(0,1); cI->pushBackSilent(0);
switch(nbOfCompo)
{
case 4:
throw INTERP_KERNEL::Exception("DataArrayDouble::duplicateEachTupleNTimes : nb times should be >= 1 !");
int nbTuples=getNumberOfTuples();
const double *inPtr=getConstPointer();
- MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New(); ret->alloc(nbTimes*nbTuples,1);
+ MCAuto<DataArrayDouble> ret=DataArrayDouble::New(); ret->alloc(nbTimes*nbTuples,1);
double *retPtr=ret->getPointer();
for(int i=0;i<nbTuples;i++,inPtr++)
{
*/
double DataArrayDouble::minimalDistanceTo(const DataArrayDouble *other, int& thisTupleId, int& otherTupleId) const
{
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> part1=findClosestTupleId(other);
+ MCAuto<DataArrayInt> part1=findClosestTupleId(other);
int nbOfCompo(getNumberOfComponents());
int otherNbTuples(other->getNumberOfTuples());
const double *thisPt(begin()),*otherPt(other->begin());
}
int nbOfTuples=other->getNumberOfTuples();
int thisNbOfTuples=getNumberOfTuples();
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(nbOfTuples,1);
+ MCAuto<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(nbOfTuples,1);
double bounds[6];
getMinMaxPerComponent(bounds);
switch(nbOfCompo)
std::ostringstream oss; oss << "DataArrayDouble::computeNbOfInteractionsWith : Number of components (" << nbOfComp << ") is not even ! It should be to be compatible with bbox format !";
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(nbOfTuples,1);
+ MCAuto<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(nbOfTuples,1);
const double *thisBBPtr(begin());
int *retPtr(ret->getPointer());
switch(nbOfComp/2)
checkAllocated();
DataArrayInt *c0=0,*cI0=0;
findCommonTuples(prec,limitTupleId,c0,cI0);
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> c(c0),cI(cI0);
+ MCAuto<DataArrayInt> c(c0),cI(cI0);
int newNbOfTuples=-1;
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> o2n=DataArrayInt::BuildOld2NewArrayFromSurjectiveFormat2(getNumberOfTuples(),c0->begin(),cI0->begin(),cI0->end(),newNbOfTuples);
+ MCAuto<DataArrayInt> o2n=DataArrayInt::ConvertIndexArrayToO2N(getNumberOfTuples(),c0->begin(),cI0->begin(),cI0->end(),newNbOfTuples);
return renumberAndReduce(o2n->getConstPointer(),newNbOfTuples);
}
* non-empty range of increasing indices or indices are out of a valid range
* for the array \a aBase.
*/
-void DataArrayDouble::setContigPartOfSelectedValues2(int tupleIdStart, const DataArray *aBase, int bg, int end2, int step)
+void DataArrayDouble::setContigPartOfSelectedValuesSlice(int tupleIdStart, const DataArray *aBase, int bg, int end2, int step)
{
if(!aBase)
- throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues2 : input DataArray is NULL !");
+ throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValuesSlice : input DataArray is NULL !");
const DataArrayDouble *a=dynamic_cast<const DataArrayDouble *>(aBase);
if(!a)
- throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues2 : input DataArray aBase is not a DataArrayDouble !");
+ throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValuesSlice : input DataArray aBase is not a DataArrayDouble !");
checkAllocated();
a->checkAllocated();
int nbOfComp=getNumberOfComponents();
- const char msg[]="DataArrayDouble::setContigPartOfSelectedValues2";
+ const char msg[]="DataArrayDouble::setContigPartOfSelectedValuesSlice";
int nbOfTupleToWrite=DataArray::GetNumberOfItemGivenBES(bg,end2,step,msg);
if(nbOfComp!=a->getNumberOfComponents())
- throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues2 : This and a do not have the same number of components !");
+ throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValuesSlice : This and a do not have the same number of components !");
int thisNt=getNumberOfTuples();
int aNt=a->getNumberOfTuples();
double *valsToSet=getPointer()+tupleIdStart*nbOfComp;
if(tupleIdStart+nbOfTupleToWrite>thisNt)
- throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues2 : invalid number range of values to write !");
+ throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValuesSlice : invalid number range of values to write !");
if(end2>aNt)
- throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues2 : invalid range of values to read !");
+ throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValuesSlice : invalid range of values to read !");
const double *valsSrc=a->getConstPointer()+bg*nbOfComp;
for(int i=0;i<nbOfTupleToWrite;i++,valsToSet+=nbOfComp,valsSrc+=step*nbOfComp)
{
declareAsNew();
}
+void DataArrayDouble::aggregate(const DataArrayDouble *other)
+{
+ if(!other)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::aggregate : null pointer !");
+ if(getNumberOfComponents()!=other->getNumberOfComponents())
+ throw INTERP_KERNEL::Exception("DataArrayDouble::aggregate : mismatch number of components !");
+ _mem.insertAtTheEnd(other->begin(),other->end());
+}
+
/*!
* Checks if 0.0 value is present in \a this array. If it is the case, an exception
* is thrown.
const double *dataPtr=getConstPointer();
int nbOfCompo=getNumberOfComponents();
int nbTuples=getNumberOfTuples();
- MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> bbox=DataArrayDouble::New();
+ MCAuto<DataArrayDouble> bbox=DataArrayDouble::New();
bbox->alloc(nbTuples,2*nbOfCompo);
double *bboxPtr=bbox->getPointer();
for(int i=0;i<nbTuples;i++)
if(nbOfCompo!=otherNbOfCompo)
throw INTERP_KERNEL::Exception("DataArrayDouble::computeTupleIdsNearTuples : number of components should be equal between this and other !");
int nbOfTuplesOther=other->getNumberOfTuples();
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> cArr(DataArrayInt::New()),cIArr(DataArrayInt::New()); cArr->alloc(0,1); cIArr->pushBackSilent(0);
+ MCAuto<DataArrayInt> cArr(DataArrayInt::New()),cIArr(DataArrayInt::New()); cArr->alloc(0,1); cIArr->pushBackSilent(0);
switch(nbOfCompo)
{
case 3:
int tmp;
tupleIds=0;
double ret=getMaxValue(tmp);
- tupleIds=getIdsInRange(ret,ret);
+ tupleIds=findIdsInRange(ret,ret);
return ret;
}
int tmp;
tupleIds=0;
double ret=getMinValue(tmp);
- tupleIds=getIdsInRange(ret,ret);
+ tupleIds=findIdsInRange(ret,ret);
return ret;
}
if(sz<1)
throw INTERP_KERNEL::Exception("DataArrayDouble::accumulatePerChunck : invalid size of input index array !");
sz--;
- MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New(); ret->alloc(sz,nbCompo);
+ MCAuto<DataArrayDouble> ret=DataArrayDouble::New(); ret->alloc(sz,nbCompo);
const int *w=bgOfIndex;
if(*w<0 || *w>=nbOfTuples)
throw INTERP_KERNEL::Exception("DataArrayDouble::accumulatePerChunck : The first element of the input index not in [0,nbOfTuples) !");
{
checkAllocated();
int nbOfComp(getNumberOfComponents());
- MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret;
+ MCAuto<DataArrayDouble> ret;
switch(atOfThis)
{
case AX_CART:
- ret=deepCpy();
+ ret=deepCopy();
case AX_CYL:
if(nbOfComp==3)
{
{
checkAllocated();
int nbOfComp(getNumberOfComponents()),nbOfTuple(getNumberOfTuples());
- MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret(DataArrayDouble::New());
+ MCAuto<DataArrayDouble> ret(DataArrayDouble::New());
ret->alloc(nbOfTuple,1);
const double *src(getConstPointer());
double *dest(ret->getPointer());
{
checkAllocated();
int nbOfComp=getNumberOfComponents();
- MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
+ MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
int nbOfTuple=getNumberOfTuples();
ret->alloc(nbOfTuple,1);
const double *src=getConstPointer();
{
checkAllocated();
int nbOfComp=getNumberOfComponents();
- MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret0=DataArrayDouble::New();
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret1=DataArrayInt::New();
+ MCAuto<DataArrayDouble> ret0=DataArrayDouble::New();
+ MCAuto<DataArrayInt> ret1=DataArrayInt::New();
int nbOfTuple=getNumberOfTuples();
ret0->alloc(nbOfTuple,1); ret1->alloc(nbOfTuple,1);
const double *src=getConstPointer();
int nbOfComp=getNumberOfComponents();
int nbOfTuples=getNumberOfTuples();
const double *inData=getConstPointer();
- MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
+ MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
ret->alloc(nbOfTuples*nbOfTuples,1);
double *outData=ret->getPointer();
for(int i=0;i<nbOfTuples;i++)
int otherNbOfTuples=other->getNumberOfTuples();
const double *inData=getConstPointer();
const double *inDataOther=other->getConstPointer();
- MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
+ MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
ret->alloc(otherNbOfTuples*nbOfTuples,1);
double *outData=ret->getPointer();
for(int i=0;i<otherNbOfTuples;i++,inDataOther+=nbOfComp)
std::set<std::string> vars;
expr.getTrueSetOfVars(vars);
std::vector<std::string> varsV(vars.begin(),vars.end());
- return applyFunc3(nbOfComp,varsV,func,isSafe);
+ return applyFuncNamedCompo(nbOfComp,varsV,func,isSafe);
}
/*!
throw INTERP_KERNEL::Exception("DataArrayDouble::applyFunc : output number of component must be > 0 !");
checkAllocated();
int nbOfTuples(getNumberOfTuples());
- MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> newArr(DataArrayDouble::New());
+ MCAuto<DataArrayDouble> newArr(DataArrayDouble::New());
newArr->alloc(nbOfTuples,nbOfComp);
INTERP_KERNEL::ExprParser expr(func);
expr.parse();
expr.getTrueSetOfVars(vars);
if((int)vars.size()>1)
{
- std::ostringstream oss; oss << "DataArrayDouble::applyFunc : this method works only with at most one var func expression ! If you need to map comps on variables please use applyFunc2 or applyFunc3 instead ! Vars in expr are : ";
+ std::ostringstream oss; oss << "DataArrayDouble::applyFunc : this method works only with at most one var func expression ! If you need to map comps on variables please use applyFuncCompo or applyFuncNamedCompo instead ! Vars in expr are : ";
std::copy(vars.begin(),vars.end(),std::ostream_iterator<std::string>(oss," "));
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
expr.getTrueSetOfVars(vars);
if((int)vars.size()>1)
{
- std::ostringstream oss; oss << "DataArrayDouble::applyFuncOnThis : this method works only with at most one var func expression ! If you need to map comps on variables please use applyFunc2 or applyFunc3 instead ! Vars in expr are : ";
+ std::ostringstream oss; oss << "DataArrayDouble::applyFuncOnThis : this method works only with at most one var func expression ! If you need to map comps on variables please use applyFuncCompo or applyFuncNamedCompo instead ! Vars in expr are : ";
std::copy(vars.begin(),vars.end(),std::ostream_iterator<std::string>(oss," "));
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
* \throw If \a func contains vars that are not in \a this->getInfoOnComponent().
* \throw If computing \a func fails.
*/
-DataArrayDouble *DataArrayDouble::applyFunc2(int nbOfComp, const std::string& func, bool isSafe) const
+DataArrayDouble *DataArrayDouble::applyFuncCompo(int nbOfComp, const std::string& func, bool isSafe) const
{
- return applyFunc3(nbOfComp,getVarsOnComponent(),func,isSafe);
+ return applyFuncNamedCompo(nbOfComp,getVarsOnComponent(),func,isSafe);
}
/*!
* \throw If \a func contains vars not in \a varsOrder.
* \throw If computing \a func fails.
*/
-DataArrayDouble *DataArrayDouble::applyFunc3(int nbOfComp, const std::vector<std::string>& varsOrder, const std::string& func, bool isSafe) const
+DataArrayDouble *DataArrayDouble::applyFuncNamedCompo(int nbOfComp, const std::vector<std::string>& varsOrder, const std::string& func, bool isSafe) const
{
if(nbOfComp<=0)
- throw INTERP_KERNEL::Exception("DataArrayDouble::applyFunc3 : output number of component must be > 0 !");
+ throw INTERP_KERNEL::Exception("DataArrayDouble::applyFuncNamedCompo : output number of component must be > 0 !");
std::vector<std::string> varsOrder2(varsOrder);
int oldNbOfComp(getNumberOfComponents());
for(int i=(int)varsOrder.size();i<oldNbOfComp;i++)
std::copy(vars.begin(),vars.end(),std::ostream_iterator<std::string>(oss," "));
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
- MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> newArr(DataArrayDouble::New());
+ MCAuto<DataArrayDouble> newArr(DataArrayDouble::New());
newArr->alloc(nbOfTuples,nbOfComp);
INTERP_KERNEL::AutoPtr<double> buff(new double[oldNbOfComp]);
double *buffPtr(buff),*ptrToFill;
* needed.
* \throw If \a this->getNumberOfComponents() != 1.
*
- * \sa DataArrayDouble::getIdsNotInRange
+ * \sa DataArrayDouble::findIdsNotInRange
*
* \if ENABLE_EXAMPLES
* \ref cpp_mcdataarraydouble_getidsinrange "Here is a C++ example".<br>
* \ref py_mcdataarraydouble_getidsinrange "Here is a Python example".
* \endif
*/
-DataArrayInt *DataArrayDouble::getIdsInRange(double vmin, double vmax) const
+DataArrayInt *DataArrayDouble::findIdsInRange(double vmin, double vmax) const
{
checkAllocated();
if(getNumberOfComponents()!=1)
- throw INTERP_KERNEL::Exception("DataArrayDouble::getIdsInRange : this must have exactly one component !");
+ throw INTERP_KERNEL::Exception("DataArrayDouble::findIdsInRange : this must have exactly one component !");
const double *cptr(begin());
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
+ MCAuto<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
int nbOfTuples(getNumberOfTuples());
for(int i=0;i<nbOfTuples;i++,cptr++)
if(*cptr>=vmin && *cptr<=vmax)
* needed.
* \throw If \a this->getNumberOfComponents() != 1.
*
- * \sa DataArrayDouble::getIdsInRange
+ * \sa DataArrayDouble::findIdsInRange
*/
-DataArrayInt *DataArrayDouble::getIdsNotInRange(double vmin, double vmax) const
+DataArrayInt *DataArrayDouble::findIdsNotInRange(double vmin, double vmax) const
{
checkAllocated();
if(getNumberOfComponents()!=1)
- throw INTERP_KERNEL::Exception("DataArrayDouble::getIdsNotInRange : this must have exactly one component !");
+ throw INTERP_KERNEL::Exception("DataArrayDouble::findIdsNotInRange : this must have exactly one component !");
const double *cptr(begin());
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
+ MCAuto<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
int nbOfTuples(getNumberOfTuples());
for(int i=0;i<nbOfTuples;i++,cptr++)
if(*cptr<vmin || *cptr>vmax)
throw INTERP_KERNEL::Exception("DataArrayDouble::Aggregate : Nb of components mismatch for array aggregation !");
nbt+=(*it)->getNumberOfTuples();
}
- MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
+ MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
ret->alloc(nbt,nbOfComp);
double *pt=ret->getPointer();
for(it=a.begin();it!=a.end();it++)
int nbOfTuple2=a2->getNumberOfTuples();
int nbOfComp=a1->getNumberOfComponents();
int nbOfComp2=a2->getNumberOfComponents();
- MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=0;
+ MCAuto<DataArrayDouble> ret=0;
if(nbOfTuple==nbOfTuple2)
{
if(nbOfComp==nbOfComp2)
{
if(nbOfComp1==nbOfComp2)
{
- MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
+ MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
ret->alloc(nbOfTuple2,nbOfComp1);
std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::minus<double>());
ret->copyStringInfoFrom(*a1);
}
else if(nbOfComp2==1)
{
- MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
+ MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
ret->alloc(nbOfTuple1,nbOfComp1);
const double *a2Ptr=a2->getConstPointer();
const double *a1Ptr=a1->getConstPointer();
else if(nbOfTuple2==1)
{
a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Substract !");
- MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
+ MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
ret->alloc(nbOfTuple1,nbOfComp1);
const double *a1ptr=a1->getConstPointer(),*a2ptr=a2->getConstPointer();
double *pt=ret->getPointer();
int nbOfTuple2=a2->getNumberOfTuples();
int nbOfComp=a1->getNumberOfComponents();
int nbOfComp2=a2->getNumberOfComponents();
- MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=0;
+ MCAuto<DataArrayDouble> ret=0;
if(nbOfTuple==nbOfTuple2)
{
if(nbOfComp==nbOfComp2)
{
if(nbOfComp1==nbOfComp2)
{
- MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
+ MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
ret->alloc(nbOfTuple2,nbOfComp1);
std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::divides<double>());
ret->copyStringInfoFrom(*a1);
}
else if(nbOfComp2==1)
{
- MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
+ MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
ret->alloc(nbOfTuple1,nbOfComp1);
const double *a2Ptr=a2->getConstPointer();
const double *a1Ptr=a1->getConstPointer();
else if(nbOfTuple2==1)
{
a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Divide !");
- MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
+ MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
ret->alloc(nbOfTuple1,nbOfComp1);
const double *a1ptr=a1->getConstPointer(),*a2ptr=a2->getConstPointer();
double *pt=ret->getPointer();
throw INTERP_KERNEL::Exception("DataArrayDouble::Pow : number of tuples mismatches !");
if(nbOfComp!=1 || nbOfComp2!=1)
throw INTERP_KERNEL::Exception("DataArrayDouble::Pow : number of components of both arrays must be equal to 1 !");
- MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New(); ret->alloc(nbOfTuple,1);
+ MCAuto<DataArrayDouble> ret=DataArrayDouble::New(); ret->alloc(nbOfTuple,1);
const double *ptr1(a1->begin()),*ptr2(a2->begin());
double *ptr=ret->getPointer();
for(int i=0;i<nbOfTuple;i++,ptr1++,ptr2++,ptr++)
* \ref MEDCouplingArrayBasicsCopyDeep.
* \return DataArrayInt * - a new instance of DataArrayInt.
*/
-DataArrayInt *DataArrayInt::deepCpy() const
+DataArrayInt *DataArrayInt::deepCopy() const
{
return new DataArrayInt(*this);
}
* \return DataArrayInt * - either a new instance of DataArrayInt (if \a dCpy
* == \a true) or \a this instance (if \a dCpy == \a false).
*/
-DataArrayInt *DataArrayInt::performCpy(bool dCpy) const
+DataArrayInt *DataArrayInt::performCopyOrIncrRef(bool dCpy) const
{
if(dCpy)
- return deepCpy();
+ return deepCopy();
else
{
incrRef();
* \param [in] other - another instance of DataArrayInt to copy data from.
* \throw If the \a other is not allocated.
*/
-void DataArrayInt::cpyFrom(const DataArrayInt& other)
+void DataArrayInt::deepCopyFrom(const DataArrayInt& other)
{
other.checkAllocated();
int nbOfTuples=other.getNumberOfTuples();
typedef std::reverse_iterator<const int *> rintstart;
rintstart bg(arrEnd);//OK no problem because size of 'arr' is greater or equal 2
rintstart end2(arrBg);
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret1=DataArrayInt::New();
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret2=DataArrayInt::New();
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret3=DataArrayInt::New();
+ MCAuto<DataArrayInt> ret1=DataArrayInt::New();
+ MCAuto<DataArrayInt> ret2=DataArrayInt::New();
+ MCAuto<DataArrayInt> ret3=DataArrayInt::New();
ret1->alloc(nbOfTuples,1);
ret2->alloc(nbOfTuples,1);
int *ret1Ptr=ret1->getPointer();
int nbElemsIn=(int)std::distance(indArrBg,indArrEnd);
int nbOfTuples=getNumberOfTuples();
const int *pt=getConstPointer();
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
+ MCAuto<DataArrayInt> ret=DataArrayInt::New();
ret->alloc(nbOfTuples,1);
ret->fillWithValue(-1);
int *tmp=ret->getPointer();
*/
DataArrayInt *DataArrayInt::invertArrayO2N2N2O(int newNbOfElem) const
{
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
+ MCAuto<DataArrayInt> ret=DataArrayInt::New();
ret->alloc(newNbOfElem,1);
int nbOfOldNodes=getNumberOfTuples();
const int *old2New=getConstPointer();
*/
DataArrayInt *DataArrayInt::invertArrayO2N2N2OBis(int newNbOfElem) const
{
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
+ MCAuto<DataArrayInt> ret=DataArrayInt::New();
ret->alloc(newNbOfElem,1);
int nbOfOldNodes=getNumberOfTuples();
const int *old2New=getConstPointer();
DataArrayInt *DataArrayInt::invertArrayN2O2O2N(int oldNbOfElem) const
{
checkAllocated();
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
+ MCAuto<DataArrayInt> ret=DataArrayInt::New();
ret->alloc(oldNbOfElem,1);
const int *new2Old=getConstPointer();
int *pt=ret->getPointer();
*/
bool DataArrayInt::isEqualWithoutConsideringStrAndOrder(const DataArrayInt& other) const
{
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> a=deepCpy();
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> b=other.deepCpy();
+ MCAuto<DataArrayInt> a=deepCopy();
+ MCAuto<DataArrayInt> b=other.deepCopy();
a->sort();
b->sort();
return a->isEqualWithoutConsideringStr(*b);
* This method assumes that \a this has one component and is allocated. This method scans all tuples in \a this and for all tuple equal to \a val
* put True to the corresponding entry in \a vec.
* \a vec is expected to be with the same size than the number of tuples of \a this.
+ *
+ * \sa DataArrayInt::switchOnTupleNotEqualTo.
*/
void DataArrayInt::switchOnTupleEqualTo(int val, std::vector<bool>& vec) const
{
vec[i]=true;
}
+/*!
+ * This method assumes that \a this has one component and is allocated. This method scans all tuples in \a this and for all tuple different from \a val
+ * put True to the corresponding entry in \a vec.
+ * \a vec is expected to be with the same size than the number of tuples of \a this.
+ *
+ * \sa DataArrayInt::switchOnTupleEqualTo.
+ */
+void DataArrayInt::switchOnTupleNotEqualTo(int val, std::vector<bool>& vec) const
+{
+ checkAllocated();
+ if(getNumberOfComponents()!=1)
+ throw INTERP_KERNEL::Exception("DataArrayInt::switchOnTupleNotEqualTo : number of components of this should be equal to one !");
+ int nbOfTuples(getNumberOfTuples());
+ if(nbOfTuples!=(int)vec.size())
+ throw INTERP_KERNEL::Exception("DataArrayInt::switchOnTupleNotEqualTo : number of tuples of this should be equal to size of input vector of bool !");
+ const int *pt(begin());
+ for(int i=0;i<nbOfTuples;i++)
+ if(pt[i]!=val)
+ vec[i]=true;
+}
+
/*!
* Sorts values of the array.
* \param [in] asc - \a true means ascending order, \a false, descending.
{
checkAllocated();
int nbOfComp(getNumberOfComponents()),nbOfTuple(getNumberOfTuples());
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New());
+ MCAuto<DataArrayInt> ret(DataArrayInt::New());
ret->alloc(nbOfTuple,1);
const int *src(getConstPointer());
int *dest(ret->getPointer());
other.checkAllocated();
if(nbTuple!=other.getNumberOfTuples())
throw INTERP_KERNEL::Exception("DataArrayInt::buildPermutationArr : 'this' and 'other' must have the same number of tuple !");
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
+ MCAuto<DataArrayInt> ret=DataArrayInt::New();
ret->alloc(nbTuple,1);
ret->fillWithValue(-1);
const int *pt=getConstPointer();
declareAsNew();
}
+void DataArrayInt::aggregate(const DataArrayInt *other)
+{
+ if(!other)
+ throw INTERP_KERNEL::Exception("DataArrayInt::aggregate : null pointer !");
+ if(getNumberOfComponents()!=other->getNumberOfComponents())
+ throw INTERP_KERNEL::Exception("DataArrayInt::aggregate : mismatch number of components !");
+ _mem.insertAtTheEnd(other->begin(),other->end());
+}
+
/*!
* Returns a new DataArrayInt holding the same values as \a this array but differently
* arranged in memory. If \a this array holds 2 components of 3 values:
* Permutes values of \a this array as required by \a old2New array. The values are
* permuted so that \c new[ \a old2New[ i ]] = \c old[ i ]. Number of tuples remains
* the same as in \c this one.
- * If a permutation reduction is needed, substr() or selectByTupleId() should be used.
+ * If a permutation reduction is needed, subArray() or selectByTupleId() should be used.
* For more info on renumbering see \ref numbering.
* \param [in] old2New - C array of length equal to \a this->getNumberOfTuples()
* giving a new position for i-th old value.
checkAllocated();
int nbTuples=getNumberOfTuples();
int nbOfCompo=getNumberOfComponents();
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
+ MCAuto<DataArrayInt> ret=DataArrayInt::New();
ret->alloc(nbTuples,nbOfCompo);
ret->copyStringInfoFrom(*this);
const int *iptr=getConstPointer();
* Returns a copy of \a this array with values permuted as required by \a new2Old array.
* The values are permuted so that \c new[ i ] = \c old[ \a new2Old[ i ]]. Number of
* tuples in the result array remains the same as in \c this one.
- * If a permutation reduction is needed, substr() or selectByTupleId() should be used.
+ * If a permutation reduction is needed, subArray() or selectByTupleId() should be used.
* For more info on renumbering see \ref numbering.
* \param [in] new2Old - C array of length equal to \a this->getNumberOfTuples()
* giving a previous position of i-th new value.
checkAllocated();
int nbTuples=getNumberOfTuples();
int nbOfCompo=getNumberOfComponents();
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
+ MCAuto<DataArrayInt> ret=DataArrayInt::New();
ret->alloc(nbTuples,nbOfCompo);
ret->copyStringInfoFrom(*this);
const int *iptr=getConstPointer();
checkAllocated();
int nbTuples=getNumberOfTuples();
int nbOfCompo=getNumberOfComponents();
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
+ MCAuto<DataArrayInt> ret=DataArrayInt::New();
ret->alloc(newNbOfTuple,nbOfCompo);
const int *iptr=getConstPointer();
int *optr=ret->getPointer();
DataArrayInt *DataArrayInt::selectByTupleId(const int *new2OldBg, const int *new2OldEnd) const
{
checkAllocated();
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
+ MCAuto<DataArrayInt> ret=DataArrayInt::New();
int nbComp=getNumberOfComponents();
ret->alloc((int)std::distance(new2OldBg,new2OldEnd),nbComp);
ret->copyStringInfoFrom(*this);
DataArrayInt *DataArrayInt::selectByTupleIdSafe(const int *new2OldBg, const int *new2OldEnd) const
{
checkAllocated();
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
+ MCAuto<DataArrayInt> ret=DataArrayInt::New();
int nbComp=getNumberOfComponents();
int oldNbOfTuples=getNumberOfTuples();
ret->alloc((int)std::distance(new2OldBg,new2OldEnd),nbComp);
* \param [in] step - index increment to get index of the next tuple to copy.
* \return DataArrayInt * - the new instance of DataArrayInt that the caller
* is to delete using decrRef() as it is no more needed.
- * \sa DataArrayInt::substr.
+ * \sa DataArrayInt::subArray.
*/
-DataArrayInt *DataArrayInt::selectByTupleId2(int bg, int end2, int step) const
+DataArrayInt *DataArrayInt::selectByTupleIdSafeSlice(int bg, int end2, int step) const
{
checkAllocated();
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
+ MCAuto<DataArrayInt> ret=DataArrayInt::New();
int nbComp=getNumberOfComponents();
- int newNbOfTuples=GetNumberOfItemGivenBESRelative(bg,end2,step,"DataArrayInt::selectByTupleId2 : ");
+ int newNbOfTuples=GetNumberOfItemGivenBESRelative(bg,end2,step,"DataArrayInt::selectByTupleIdSafeSlice : ");
ret->alloc(newNbOfTuples,nbComp);
int *pt=ret->getPointer();
const int *srcPt=getConstPointer()+bg*nbComp;
int nbOfTuplesThis=getNumberOfTuples();
if(ranges.empty())
{
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
+ MCAuto<DataArrayInt> ret=DataArrayInt::New();
ret->alloc(0,nbOfComp);
ret->copyStringInfoFrom(*this);
return ret.retn();
}
}
if(isIncreasing && nbOfTuplesThis==nbOfTuples)
- return deepCpy();
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
+ return deepCopy();
+ MCAuto<DataArrayInt> ret=DataArrayInt::New();
ret->alloc(nbOfTuples,nbOfComp);
ret->copyStringInfoFrom(*this);
const int *src=getConstPointer();
std::ostringstream oss; oss << "DataArrayInt::FindPermutationFromFirstToSecond : first array has " << ids1->getNumberOfTuples() << " tuples and the second one " << ids2->getNumberOfTuples() << " tuples ! No chance to find a permutation between the 2 arrays !";
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> p1(ids1->deepCpy());
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> p2(ids2->deepCpy());
+ MCAuto<DataArrayInt> p1(ids1->deepCopy());
+ MCAuto<DataArrayInt> p2(ids2->deepCopy());
p1->sort(true); p2->sort(true);
if(!p1->isEqualWithoutConsideringStr(*p2))
throw INTERP_KERNEL::Exception("DataArrayInt::FindPermutationFromFirstToSecond : the two arrays are not lying on same ids ! Impossible to find a permutation between the 2 arrays !");
if(getNumberOfComponents()!=1)
throw INTERP_KERNEL::Exception("DataArrayInt::changeSurjectiveFormat : number of components must == 1 !");
int nbOfTuples=getNumberOfTuples();
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New());
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> retI(DataArrayInt::New());
+ MCAuto<DataArrayInt> ret(DataArrayInt::New());
+ MCAuto<DataArrayInt> retI(DataArrayInt::New());
retI->alloc(targetNb+1,1);
const int *input=getConstPointer();
std::vector< std::vector<int> > tmp(targetNb);
* array using decrRef() as it is no more needed.
* \throw If any value of \a arr breaks condition ( 0 <= \a arr[ i ] < \a nbOfOldTuples ).
*/
-DataArrayInt *DataArrayInt::BuildOld2NewArrayFromSurjectiveFormat2(int nbOfOldTuples, const int *arr, const int *arrIBg, const int *arrIEnd, int &newNbOfTuples)
+DataArrayInt *DataArrayInt::ConvertIndexArrayToO2N(int nbOfOldTuples, const int *arr, const int *arrIBg, const int *arrIEnd, int &newNbOfTuples)
{
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
+ MCAuto<DataArrayInt> ret=DataArrayInt::New();
ret->alloc(nbOfOldTuples,1);
int *pt=ret->getPointer();
std::fill(pt,pt+nbOfOldTuples,-1);
pt[arr[j]]=newNb;
else
{
- std::ostringstream oss; oss << "DataArrayInt::BuildOld2NewArrayFromSurjectiveFormat2 : With element #" << j << " value is " << arr[j] << " should be in [0," << nbOfOldTuples << ") !";
+ std::ostringstream oss; oss << "DataArrayInt::ConvertIndexArrayToO2N : With element #" << j << " value is " << arr[j] << " should be in [0," << nbOfOldTuples << ") !";
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
}
int nbOfTuples=getNumberOfTuples();
const int *pt=getConstPointer();
std::map<int,int> m;
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
+ MCAuto<DataArrayInt> ret=DataArrayInt::New();
ret->alloc(nbOfTuples,1);
int *opt=ret->getPointer();
for(int i=0;i<nbOfTuples;i++,pt++,opt++)
* \throw If \a this is not allocated.
* \throw If \a this->getNumberOfComponents() != 1.
*/
-bool DataArrayInt::isIdentity2(int sizeExpected) const
+bool DataArrayInt::isIota(int sizeExpected) const
{
checkAllocated();
if(getNumberOfComponents()!=1)
return true;
}
+/*!
+ * Checks if all values in \a this array are unique.
+ * \return bool - \a true if condition above is true
+ * \throw If \a this is not allocated.
+ * \throw If \a this->getNumberOfComponents() != 1
+ */
+bool DataArrayInt::hasUniqueValues() const
+{
+ checkAllocated();
+ if(getNumberOfComponents()!=1)
+ throw INTERP_KERNEL::Exception("DataArrayInt::hasOnlyUniqueValues: must be applied on DataArrayInt with only one component, you can call 'rearrange' method before !");
+ int nbOfTuples(getNumberOfTuples());
+ std::set<int> s(begin(),end()); // in C++11, should use unordered_set (O(1) complexity)
+ if (s.size() != nbOfTuples)
+ return false;
+ return true;
+}
+
/*!
* Creates a new DataArrayDouble and assigns all (textual and numerical) data of \a this
* array to the new one.
* Returns a shorten copy of \a this array. The new DataArrayInt contains all
* tuples starting from the \a tupleIdBg-th tuple and including all tuples located before
* the \a tupleIdEnd-th one. This methods has a similar behavior as std::string::substr().
- * This method is a specialization of selectByTupleId2().
+ * This method is a specialization of selectByTupleIdSafeSlice().
* \param [in] tupleIdBg - index of the first tuple to copy from \a this array.
* \param [in] tupleIdEnd - index of the tuple before which the tuples to copy are located.
* If \a tupleIdEnd == -1, all the tuples till the end of \a this array are copied.
* \throw If \a tupleIdBg < 0.
* \throw If \a tupleIdBg > \a this->getNumberOfTuples().
\throw If \a tupleIdEnd != -1 && \a tupleIdEnd < \a this->getNumberOfTuples().
- * \sa DataArrayInt::selectByTupleId2
+ * \sa DataArrayInt::selectByTupleIdSafeSlice
*/
-DataArrayInt *DataArrayInt::substr(int tupleIdBg, int tupleIdEnd) const
+DataArrayInt *DataArrayInt::subArray(int tupleIdBg, int tupleIdEnd) const
{
checkAllocated();
int nbt=getNumberOfTuples();
if(tupleIdBg<0)
- throw INTERP_KERNEL::Exception("DataArrayInt::substr : The tupleIdBg parameter must be greater than 0 !");
+ throw INTERP_KERNEL::Exception("DataArrayInt::subArray : The tupleIdBg parameter must be greater than 0 !");
if(tupleIdBg>nbt)
- throw INTERP_KERNEL::Exception("DataArrayInt::substr : The tupleIdBg parameter is greater than number of tuples !");
+ throw INTERP_KERNEL::Exception("DataArrayInt::subArray : The tupleIdBg parameter is greater than number of tuples !");
int trueEnd=tupleIdEnd;
if(tupleIdEnd!=-1)
{
if(tupleIdEnd>nbt)
- throw INTERP_KERNEL::Exception("DataArrayInt::substr : The tupleIdBg parameter is greater or equal than number of tuples !");
+ throw INTERP_KERNEL::Exception("DataArrayInt::subArray : The tupleIdBg parameter is greater or equal than number of tuples !");
}
else
trueEnd=nbt;
int nbComp=getNumberOfComponents();
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
+ MCAuto<DataArrayInt> ret=DataArrayInt::New();
ret->alloc(trueEnd-tupleIdBg,nbComp);
ret->copyStringInfoFrom(*this);
std::copy(getConstPointer()+tupleIdBg*nbComp,getConstPointer()+trueEnd*nbComp,ret->getPointer());
DataArrayInt *DataArrayInt::changeNbOfComponents(int newNbOfComp, int dftValue) const
{
checkAllocated();
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
+ MCAuto<DataArrayInt> ret=DataArrayInt::New();
ret->alloc(getNumberOfTuples(),newNbOfComp);
const int *oldc=getConstPointer();
int *nc=ret->getPointer();
DataArrayInt *DataArrayInt::keepSelectedComponents(const std::vector<int>& compoIds) const
{
checkAllocated();
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New());
+ MCAuto<DataArrayInt> ret(DataArrayInt::New());
int newNbOfCompo=(int)compoIds.size();
int oldNbOfCompo=getNumberOfComponents();
for(std::vector<int>::const_iterator it=compoIds.begin();it!=compoIds.end();it++)
* non-empty range of increasing indices or indices are out of a valid range
* for the array \a aBase.
*/
-void DataArrayInt::setContigPartOfSelectedValues2(int tupleIdStart, const DataArray *aBase, int bg, int end2, int step)
+void DataArrayInt::setContigPartOfSelectedValuesSlice(int tupleIdStart, const DataArray *aBase, int bg, int end2, int step)
{
if(!aBase)
- throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues2 : input DataArray is NULL !");
+ throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValuesSlice : input DataArray is NULL !");
const DataArrayInt *a=dynamic_cast<const DataArrayInt *>(aBase);
if(!a)
- throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues2 : input DataArray aBase is not a DataArrayInt !");
+ throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValuesSlice : input DataArray aBase is not a DataArrayInt !");
checkAllocated();
a->checkAllocated();
int nbOfComp=getNumberOfComponents();
- const char msg[]="DataArrayInt::setContigPartOfSelectedValues2";
+ const char msg[]="DataArrayInt::setContigPartOfSelectedValuesSlice";
int nbOfTupleToWrite=DataArray::GetNumberOfItemGivenBES(bg,end2,step,msg);
if(nbOfComp!=a->getNumberOfComponents())
- throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues2 : This and a do not have the same number of components !");
+ throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValuesSlice : This and a do not have the same number of components !");
int thisNt=getNumberOfTuples();
int aNt=a->getNumberOfTuples();
int *valsToSet=getPointer()+tupleIdStart*nbOfComp;
if(tupleIdStart+nbOfTupleToWrite>thisNt)
- throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues2 : invalid number range of values to write !");
+ throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValuesSlice : invalid number range of values to write !");
if(end2>aNt)
- throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues2 : invalid range of values to read !");
+ throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValuesSlice : invalid range of values to read !");
const int *valsSrc=a->getConstPointer()+bg*nbOfComp;
for(int i=0;i<nbOfTupleToWrite;i++,valsToSet+=nbOfComp,valsSrc+=step*nbOfComp)
{
* array using decrRef() as it is no more needed.
* \throw If \a this is not allocated.
* \throw If \a this->getNumberOfComponents() != 1.
- * \sa DataArrayInt::getIdsEqualTuple
+ * \sa DataArrayInt::findIdsEqualTuple
*/
-DataArrayInt *DataArrayInt::getIdsEqual(int val) const
+DataArrayInt *DataArrayInt::findIdsEqual(int val) const
{
checkAllocated();
if(getNumberOfComponents()!=1)
- throw INTERP_KERNEL::Exception("DataArrayInt::getIdsEqual : the array must have only one component, you can call 'rearrange' method before !");
+ throw INTERP_KERNEL::Exception("DataArrayInt::findIdsEqual : the array must have only one component, you can call 'rearrange' method before !");
const int *cptr(getConstPointer());
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
+ MCAuto<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
int nbOfTuples=getNumberOfTuples();
for(int i=0;i<nbOfTuples;i++,cptr++)
if(*cptr==val)
* \throw If \a this is not allocated.
* \throw If \a this->getNumberOfComponents() != 1.
*/
-DataArrayInt *DataArrayInt::getIdsNotEqual(int val) const
+DataArrayInt *DataArrayInt::findIdsNotEqual(int val) const
{
checkAllocated();
if(getNumberOfComponents()!=1)
- throw INTERP_KERNEL::Exception("DataArrayInt::getIdsNotEqual : the array must have only one component, you can call 'rearrange' method before !");
+ throw INTERP_KERNEL::Exception("DataArrayInt::findIdsNotEqual : the array must have only one component, you can call 'rearrange' method before !");
const int *cptr(getConstPointer());
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
+ MCAuto<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
int nbOfTuples=getNumberOfTuples();
for(int i=0;i<nbOfTuples;i++,cptr++)
if(*cptr!=val)
/*!
* Creates a new DataArrayInt containing IDs (indices) of tuples holding tuple equal to those defined by [ \a tupleBg , \a tupleEnd )
- * This method is an extension of DataArrayInt::getIdsEqual method.
+ * This method is an extension of DataArrayInt::findIdsEqual method.
*
* \param [in] tupleBg - the begin (included) of the input tuple to find within \a this.
* \param [in] tupleEnd - the end (excluded) of the input tuple to find within \a this.
* \throw If \a this is not allocated.
* \throw If \a this->getNumberOfComponents() != std::distance(tupleBg,tupleEnd).
* \throw If \a this->getNumberOfComponents() is equal to 0.
- * \sa DataArrayInt::getIdsEqual
+ * \sa DataArrayInt::findIdsEqual
*/
-DataArrayInt *DataArrayInt::getIdsEqualTuple(const int *tupleBg, const int *tupleEnd) const
+DataArrayInt *DataArrayInt::findIdsEqualTuple(const int *tupleBg, const int *tupleEnd) const
{
std::size_t nbOfCompoExp(std::distance(tupleBg,tupleEnd));
checkAllocated();
if(getNumberOfComponents()!=(int)nbOfCompoExp)
{
- std::ostringstream oss; oss << "DataArrayInt::getIdsEqualTuple : mismatch of number of components. Input tuple has " << nbOfCompoExp << " whereas this array has " << getNumberOfComponents() << " components !";
+ std::ostringstream oss; oss << "DataArrayInt::findIdsEqualTuple : mismatch of number of components. Input tuple has " << nbOfCompoExp << " whereas this array has " << getNumberOfComponents() << " components !";
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
if(nbOfCompoExp==0)
- throw INTERP_KERNEL::Exception("DataArrayInt::getIdsEqualTuple : number of components should be > 0 !");
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
+ throw INTERP_KERNEL::Exception("DataArrayInt::findIdsEqualTuple : number of components should be > 0 !");
+ MCAuto<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
const int *bg(begin()),*end2(end()),*work(begin());
while(work!=end2)
{
* array using decrRef() as it is no more needed.
* \throw If \a this->getNumberOfComponents() != 1.
*/
-DataArrayInt *DataArrayInt::getIdsEqualList(const int *valsBg, const int *valsEnd) const
+DataArrayInt *DataArrayInt::findIdsEqualList(const int *valsBg, const int *valsEnd) const
{
if(getNumberOfComponents()!=1)
- throw INTERP_KERNEL::Exception("DataArrayInt::getIdsEqualList : the array must have only one component, you can call 'rearrange' method before !");
+ throw INTERP_KERNEL::Exception("DataArrayInt::findIdsEqualList : the array must have only one component, you can call 'rearrange' method before !");
std::set<int> vals2(valsBg,valsEnd);
const int *cptr(getConstPointer());
std::vector<int> res;
int nbOfTuples(getNumberOfTuples());
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
+ MCAuto<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
for(int i=0;i<nbOfTuples;i++,cptr++)
if(vals2.find(*cptr)!=vals2.end())
ret->pushBackSilent(i);
* array using decrRef() as it is no more needed.
* \throw If \a this->getNumberOfComponents() != 1.
*/
-DataArrayInt *DataArrayInt::getIdsNotEqualList(const int *valsBg, const int *valsEnd) const
+DataArrayInt *DataArrayInt::findIdsNotEqualList(const int *valsBg, const int *valsEnd) const
{
if(getNumberOfComponents()!=1)
- throw INTERP_KERNEL::Exception("DataArrayInt::getIdsNotEqualList : the array must have only one component, you can call 'rearrange' method before !");
+ throw INTERP_KERNEL::Exception("DataArrayInt::findIdsNotEqualList : the array must have only one component, you can call 'rearrange' method before !");
std::set<int> vals2(valsBg,valsEnd);
const int *cptr=getConstPointer();
std::vector<int> res;
int nbOfTuples=getNumberOfTuples();
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
+ MCAuto<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
for(int i=0;i<nbOfTuples;i++,cptr++)
if(vals2.find(*cptr)==vals2.end())
ret->pushBackSilent(i);
}
/*!
- * This method is an extension of DataArrayInt::locateValue method because this method works for DataArrayInt with
+ * This method is an extension of DataArrayInt::findIdFirstEqual method because this method works for DataArrayInt with
* any number of components excepted 0 (an INTERP_KERNEL::Exception is thrown in this case).
* This method searches in \b this is there is a tuple that matched the input parameter \b tupl.
* If any the tuple id is returned. If not -1 is returned.
* the input vector. An INTERP_KERNEL::Exception is thrown too if \b this is not allocated.
*
* \return tuple id where \b tupl is. -1 if no such tuple exists in \b this.
- * \sa DataArrayInt::search, DataArrayInt::presenceOfTuple.
+ * \sa DataArrayInt::findIdSequence, DataArrayInt::presenceOfTuple.
*/
-int DataArrayInt::locateTuple(const std::vector<int>& tupl) const
+int DataArrayInt::findIdFirstEqualTuple(const std::vector<int>& tupl) const
{
checkAllocated();
int nbOfCompo=getNumberOfComponents();
if(nbOfCompo==0)
- throw INTERP_KERNEL::Exception("DataArrayInt::locateTuple : 0 components in 'this' !");
+ throw INTERP_KERNEL::Exception("DataArrayInt::findIdFirstEqualTuple : 0 components in 'this' !");
if(nbOfCompo!=(int)tupl.size())
{
- std::ostringstream oss; oss << "DataArrayInt::locateTuple : 'this' contains " << nbOfCompo << " components and searching for a tuple of length " << tupl.size() << " !";
+ std::ostringstream oss; oss << "DataArrayInt::findIdFirstEqualTuple : 'this' contains " << nbOfCompo << " components and searching for a tuple of length " << tupl.size() << " !";
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
const int *cptr=getConstPointer();
/*!
* This method searches the sequence specified in input parameter \b vals in \b this.
* This works only for DataArrayInt having number of components equal to one (if not an INTERP_KERNEL::Exception will be thrown).
- * This method differs from DataArrayInt::locateTuple in that the position is internal raw data is not considered here contrary to DataArrayInt::locateTuple.
- * \sa DataArrayInt::locateTuple
+ * This method differs from DataArrayInt::findIdFirstEqualTuple in that the position is internal raw data is not considered here contrary to DataArrayInt::findIdFirstEqualTuple.
+ * \sa DataArrayInt::findIdFirstEqualTuple
*/
-int DataArrayInt::search(const std::vector<int>& vals) const
+int DataArrayInt::findIdSequence(const std::vector<int>& vals) const
{
checkAllocated();
int nbOfCompo=getNumberOfComponents();
if(nbOfCompo!=1)
- throw INTERP_KERNEL::Exception("DataArrayInt::search : works only for DataArrayInt instance with one component !");
+ throw INTERP_KERNEL::Exception("DataArrayInt::findIdSequence : works only for DataArrayInt instance with one component !");
const int *cptr=getConstPointer();
std::size_t nbOfVals=getNbOfElems();
const int *loc=std::search(cptr,cptr+nbOfVals,vals.begin(),vals.end());
* If not any tuple contains \b value -1 is returned.
* \sa DataArrayInt::presenceOfValue
*/
-int DataArrayInt::locateValue(int value) const
+int DataArrayInt::findIdFirstEqual(int value) const
{
checkAllocated();
if(getNumberOfComponents()!=1)
* If not any tuple contains one of the values contained in 'vals' -1 is returned.
* \sa DataArrayInt::presenceOfValue
*/
-int DataArrayInt::locateValue(const std::vector<int>& vals) const
+int DataArrayInt::findIdFirstEqual(const std::vector<int>& vals) const
{
checkAllocated();
if(getNumberOfComponents()!=1)
* This method searches in \b this is there is a tuple that matched the input parameter \b tupl.
* This method throws an INTERP_KERNEL::Exception if the number of components in \b this mismatches with the size of
* the input vector. An INTERP_KERNEL::Exception is thrown too if \b this is not allocated.
- * \sa DataArrayInt::locateTuple
+ * \sa DataArrayInt::findIdFirstEqualTuple
*/
bool DataArrayInt::presenceOfTuple(const std::vector<int>& tupl) const
{
- return locateTuple(tupl)!=-1;
+ return findIdFirstEqualTuple(tupl)!=-1;
}
* \return bool - \a true in case if \a value is present within \a this array.
* \throw If \a this is not allocated.
* \throw If \a this->getNumberOfComponents() != 1.
- * \sa locateValue()
+ * \sa findIdFirstEqual()
*/
bool DataArrayInt::presenceOfValue(int value) const
{
- return locateValue(value)!=-1;
+ return findIdFirstEqual(value)!=-1;
}
/*!
* This method expects to be called when number of components of this is equal to one.
* This method returns true if it exists a tuple so that the value is contained in \b vals.
* If not any tuple contains one of the values contained in 'vals' false is returned.
- * \sa DataArrayInt::locateValue
+ * \sa DataArrayInt::findIdFirstEqual
*/
bool DataArrayInt::presenceOfValue(const std::vector<int>& vals) const
{
- return locateValue(vals)!=-1;
+ return findIdFirstEqual(vals)!=-1;
}
/*!
if(sz<1)
throw INTERP_KERNEL::Exception("DataArrayInt::accumulatePerChunck : invalid size of input index array !");
sz--;
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(sz,nbCompo);
+ MCAuto<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(sz,nbCompo);
const int *w=bgOfIndex;
if(*w<0 || *w>=nbOfTuples)
throw INTERP_KERNEL::Exception("DataArrayInt::accumulatePerChunck : The first element of the input index not in [0,nbOfTuples) !");
throw INTERP_KERNEL::Exception("DataArrayInt::Aggregate : Nb of components mismatch for array aggregation !");
nbt+=(*it)->getNumberOfTuples();
}
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
+ MCAuto<DataArrayInt> ret=DataArrayInt::New();
ret->alloc(nbt,nbOfComp);
int *pt=ret->getPointer();
for(it=a.begin();it!=a.end();it++)
}
if(arrs.empty())
throw INTERP_KERNEL::Exception("DataArrayInt::AggregateIndexes : input list must be NON EMPTY !");
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
+ MCAuto<DataArrayInt> ret=DataArrayInt::New();
ret->alloc(retSz,1);
int *pt=ret->getPointer(); *pt++=0;
for(std::vector<const DataArrayInt *>::const_iterator it=arrs.begin();it!=arrs.end();it++)
* \param [in] vmax end of range. This value is \b not included in range (excluded).
* \return a newly allocated data array that the caller should deal with.
*
- * \sa DataArrayInt::getIdsNotInRange , DataArrayInt::getIdsStrictlyNegative
+ * \sa DataArrayInt::findIdsNotInRange , DataArrayInt::findIdsStricltyNegative
*/
-DataArrayInt *DataArrayInt::getIdsInRange(int vmin, int vmax) const
+DataArrayInt *DataArrayInt::findIdsInRange(int vmin, int vmax) const
{
checkAllocated();
if(getNumberOfComponents()!=1)
- throw INTERP_KERNEL::Exception("DataArrayInt::getIdsInRange : this must have exactly one component !");
+ throw INTERP_KERNEL::Exception("DataArrayInt::findIdsInRange : this must have exactly one component !");
const int *cptr(begin());
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
+ MCAuto<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
int nbOfTuples(getNumberOfTuples());
for(int i=0;i<nbOfTuples;i++,cptr++)
if(*cptr>=vmin && *cptr<vmax)
* \param [in] vmax end of range. This value is included in range (included).
* \return a newly allocated data array that the caller should deal with.
*
- * \sa DataArrayInt::getIdsInRange , DataArrayInt::getIdsStrictlyNegative
+ * \sa DataArrayInt::findIdsInRange , DataArrayInt::findIdsStricltyNegative
*/
-DataArrayInt *DataArrayInt::getIdsNotInRange(int vmin, int vmax) const
+DataArrayInt *DataArrayInt::findIdsNotInRange(int vmin, int vmax) const
{
checkAllocated();
if(getNumberOfComponents()!=1)
- throw INTERP_KERNEL::Exception("DataArrayInt::getIdsNotInRange : this must have exactly one component !");
+ throw INTERP_KERNEL::Exception("DataArrayInt::findIdsNotInRange : this must have exactly one component !");
const int *cptr(getConstPointer());
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
+ MCAuto<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
int nbOfTuples(getNumberOfTuples());
for(int i=0;i<nbOfTuples;i++,cptr++)
if(*cptr<vmin || *cptr>=vmax)
* This method works only on data array with one component. This method returns a newly allocated array storing stored ascendantly of tuple ids in \a this so that this[id]<0.
*
* \return a newly allocated data array that the caller should deal with.
- * \sa DataArrayInt::getIdsInRange
+ * \sa DataArrayInt::findIdsInRange
*/
-DataArrayInt *DataArrayInt::getIdsStrictlyNegative() const
+DataArrayInt *DataArrayInt::findIdsStricltyNegative() const
{
checkAllocated();
if(getNumberOfComponents()!=1)
- throw INTERP_KERNEL::Exception("DataArrayInt::getIdsStrictlyNegative : this must have exactly one component !");
+ throw INTERP_KERNEL::Exception("DataArrayInt::findIdsStricltyNegative : this must have exactly one component !");
const int *cptr(getConstPointer());
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
+ MCAuto<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
int nbOfTuples(getNumberOfTuples());
for(int i=0;i<nbOfTuples;i++,cptr++)
if(*cptr<0)
for(std::vector<const DataArrayInt *>::const_iterator it4=groups.begin();it4!=groups.end();it4++)
if(*it4)
groups2.push_back(*it4);
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
+ MCAuto<DataArrayInt> ret=DataArrayInt::New();
ret->alloc(newNb,1);
int *retPtr=ret->getPointer();
std::fill(retPtr,retPtr+newNb,0);
DataArrayInt *DataArrayInt::BuildListOfSwitchedOn(const std::vector<bool>& v)
{
int sz((int)std::count(v.begin(),v.end(),true));
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(sz,1);
+ MCAuto<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(sz,1);
std::for_each(v.begin(),v.end(),MEDCouplingImpl::OpSwitchedOn(ret->getPointer()));
return ret.retn();
}
DataArrayInt *DataArrayInt::BuildListOfSwitchedOff(const std::vector<bool>& v)
{
int sz((int)std::count(v.begin(),v.end(),false));
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(sz,1);
+ MCAuto<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(sz,1);
std::for_each(v.begin(),v.end(),MEDCouplingImpl::OpSwitchedOff(ret->getPointer()));
return ret.retn();
}
void DataArrayInt::PutIntoToSkylineFrmt(const std::vector< std::vector<int> >& v, DataArrayInt *& data, DataArrayInt *& dataIndex)
{
int sz((int)v.size());
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret0(DataArrayInt::New()),ret1(DataArrayInt::New());
+ MCAuto<DataArrayInt> ret0(DataArrayInt::New()),ret1(DataArrayInt::New());
ret1->alloc(sz+1,1);
int *pt(ret1->getPointer()); *pt=0;
for(int i=0;i<sz;i++,pt++)
if(other->getNumberOfComponents()!=1) throw INTERP_KERNEL::Exception(MSG);
const int *pt1Bg(begin()),*pt1End(end()),*pt2Bg(other->begin()),*pt2End(other->end());
const int *work1(pt1Bg),*work2(pt2Bg);
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
+ MCAuto<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
for(;work1!=pt1End;work1++)
{
if(work2!=pt2End && *work1==*work2)
if(getNumberOfComponents()!=1)
throw INTERP_KERNEL::Exception("DataArrayInt::buildUnique : only single component allowed !");
int nbOfTuples=getNumberOfTuples();
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> tmp=deepCpy();
+ MCAuto<DataArrayInt> tmp=deepCopy();
int *data=tmp->getPointer();
int *last=std::unique(data,data+nbOfTuples);
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
+ MCAuto<DataArrayInt> ret=DataArrayInt::New();
ret->alloc(std::distance(data,last),1);
std::copy(data,last,ret->getPointer());
return ret.retn();
getMinMaxValues(minVal,maxVal);
std::vector<bool> b(maxVal-minVal+1,false);
const int *ptBg(begin()),*endBg(end());
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
+ MCAuto<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
for(const int *pt=ptBg;pt!=endBg;pt++)
{
if(!b[*pt-minVal])
* "MEDCouplingUMesh::buildDescendingConnectivity" and
* \ref MEDCoupling::MEDCouplingUMesh::getNodalConnectivityIndex
* "MEDCouplingUMesh::getNodalConnectivityIndex" etc.
- * This method preforms the reverse operation of DataArrayInt::computeOffsets2.
+ * This method preforms the reverse operation of DataArrayInt::computeOffsetsFull.
* \return DataArrayInt * - a new instance of DataArrayInt, whose number of tuples
* equals to \a this->getNumberOfComponents() - 1, and number of components is 1.
* The caller is to delete this array using decrRef() as it is no more needed.
* - result array contains [2,3,1,0,2,6],
* where 2 = 3 - 1, 3 = 6 - 3, 1 = 7 - 6 etc.
*
- * \sa DataArrayInt::computeOffsets2
+ * \sa DataArrayInt::computeOffsetsFull
*/
DataArrayInt *DataArrayInt::deltaShiftIndex() const
{
* Or: for each i>0 new[i]=new[i-1]+old[i-1] for i==0 new[i]=0. Number of tuples
* and components remains the same.<br>
* This method is useful for allToAllV in MPI with contiguous policy. This method
- * differs from computeOffsets2() in that the number of tuples is \b not changed by
+ * differs from computeOffsetsFull() in that the number of tuples is \b not changed by
* this one.
* \throw If \a this is not allocated.
* \throw If \a this->getNumberOfComponents() != 1.
* - After \a this contains [0,3,8,9,11,11,19]<br>
* \sa DataArrayInt::deltaShiftIndex
*/
-void DataArrayInt::computeOffsets2()
+void DataArrayInt::computeOffsetsFull()
{
checkAllocated();
if(getNumberOfComponents()!=1)
- throw INTERP_KERNEL::Exception("DataArrayInt::computeOffsets2 : only single component allowed !");
+ throw INTERP_KERNEL::Exception("DataArrayInt::computeOffsetsFull : only single component allowed !");
int nbOfTuples=getNumberOfTuples();
int *ret=(int *)malloc((nbOfTuples+1)*sizeof(int));
const int *work=getConstPointer();
/*!
* Returns two new DataArrayInt instances whose contents is computed from that of \a this and \a listOfIds arrays as follows.
- * \a this is expected to be an offset format ( as returned by DataArrayInt::computeOffsets2 ) that is to say with one component
+ * \a this is expected to be an offset format ( as returned by DataArrayInt::computeOffsetsFull ) that is to say with one component
* and ** sorted strictly increasingly **. \a listOfIds is expected to be sorted ascendingly (not strictly needed for \a listOfIds).
* This methods searches in \a this, considered as a set of contiguous \c this->getNumberOfComponents() ranges, all ids in \a listOfIds
* filling completely one of the ranges in \a this.
* \param [out] idsInInputListThatFetch contains the list of ids in \a listOfIds that are \b fully included in a range in \a this. So
* \a idsInInputListThatFetch is a part of input \a listOfIds.
*
- * \sa DataArrayInt::computeOffsets2
+ * \sa DataArrayInt::computeOffsetsFull
*
* \b Example: <br>
* - \a this : [0,3,7,9,15,18]
* In this example id 3 in input \a listOfIds is alone so it do not appear in output \a idsInInputListThatFetch.
* <br>
*/
-void DataArrayInt::searchRangesInListOfIds(const DataArrayInt *listOfIds, DataArrayInt *& rangeIdsFetched, DataArrayInt *& idsInInputListThatFetch) const
+void DataArrayInt::findIdsRangesInListOfIds(const DataArrayInt *listOfIds, DataArrayInt *& rangeIdsFetched, DataArrayInt *& idsInInputListThatFetch) const
{
if(!listOfIds)
- throw INTERP_KERNEL::Exception("DataArrayInt::searchRangesInListOfIds : input list of ids is null !");
+ throw INTERP_KERNEL::Exception("DataArrayInt::findIdsRangesInListOfIds : input list of ids is null !");
listOfIds->checkAllocated(); checkAllocated();
if(listOfIds->getNumberOfComponents()!=1)
- throw INTERP_KERNEL::Exception("DataArrayInt::searchRangesInListOfIds : input list of ids must have exactly one component !");
+ throw INTERP_KERNEL::Exception("DataArrayInt::findIdsRangesInListOfIds : input list of ids must have exactly one component !");
if(getNumberOfComponents()!=1)
- throw INTERP_KERNEL::Exception("DataArrayInt::searchRangesInListOfIds : this must have exactly one component !");
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret0=DataArrayInt::New(); ret0->alloc(0,1);
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret1=DataArrayInt::New(); ret1->alloc(0,1);
+ throw INTERP_KERNEL::Exception("DataArrayInt::findIdsRangesInListOfIds : this must have exactly one component !");
+ MCAuto<DataArrayInt> ret0=DataArrayInt::New(); ret0->alloc(0,1);
+ MCAuto<DataArrayInt> ret1=DataArrayInt::New(); ret1->alloc(0,1);
const int *tupEnd(listOfIds->end()),*offBg(begin()),*offEnd(end()-1);
const int *tupPtr(listOfIds->begin()),*offPtr(offBg);
while(tupPtr!=tupEnd && offPtr!=offEnd)
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
}
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
+ MCAuto<DataArrayInt> ret=DataArrayInt::New();
ret->alloc(retNbOftuples,1);
int *retPtr=ret->getPointer();
for(int i=0;i<nbOfTuples;i++)
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
}
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(sz,1);
+ MCAuto<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(sz,1);
int *retPtr(ret->getPointer());
pos=bg;
for(int i=0;i<nbOfEltsInSlc;i++,pos+=step)
if(getNumberOfComponents()!=1)
throw INTERP_KERNEL::Exception("DataArrayInt::findRangeIdForEachTuple : this should have only one component !");
int nbTuples=getNumberOfTuples();
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(nbTuples,1);
+ MCAuto<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(nbTuples,1);
int nbOfRanges=ranges->getNumberOfTuples();
const int *rangesPtr=ranges->getConstPointer();
int *retPtr=ret->getPointer();
if(getNumberOfComponents()!=1)
throw INTERP_KERNEL::Exception("DataArrayInt::findIdInRangeForEachTuple : this should have only one component !");
int nbTuples=getNumberOfTuples();
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(nbTuples,1);
+ MCAuto<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(nbTuples,1);
int nbOfRanges=ranges->getNumberOfTuples();
const int *rangesPtr=ranges->getConstPointer();
int *retPtr=ret->getPointer();
{ tmp[3]=conn[2];}
std::copy(tmp,tmp+4,conn);
}
+ else
+ {//here we are sure to have (std::count(conn,conn+4,conn[1])==2)
+ if(conn[1]==conn[3])
+ std::swap(conn[2],conn[3]);
+ }
}
}
}
throw INTERP_KERNEL::Exception("DataArrayInt::duplicateEachTupleNTimes : nb times should be >= 1 !");
int nbTuples=getNumberOfTuples();
const int *inPtr=getConstPointer();
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(nbTimes*nbTuples,1);
+ MCAuto<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(nbTimes*nbTuples,1);
int *retPtr=ret->getPointer();
for(int i=0;i<nbTuples;i++,inPtr++)
{
checkAllocated();
std::set<int> ret;
ret.insert(begin(),end());
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret2=DataArrayInt::New(); ret2->alloc((int)ret.size(),1);
+ MCAuto<DataArrayInt> ret2=DataArrayInt::New(); ret2->alloc((int)ret.size(),1);
std::copy(ret.begin(),ret.end(),ret2->getPointer());
return ret2.retn();
}
int nbOfTuple2=a2->getNumberOfTuples();
int nbOfComp=a1->getNumberOfComponents();
int nbOfComp2=a2->getNumberOfComponents();
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=0;
+ MCAuto<DataArrayInt> ret=0;
if(nbOfTuple==nbOfTuple2)
{
if(nbOfComp==nbOfComp2)
{
if(nbOfComp1==nbOfComp2)
{
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
+ MCAuto<DataArrayInt> ret=DataArrayInt::New();
ret->alloc(nbOfTuple2,nbOfComp1);
std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::minus<int>());
ret->copyStringInfoFrom(*a1);
}
else if(nbOfComp2==1)
{
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
+ MCAuto<DataArrayInt> ret=DataArrayInt::New();
ret->alloc(nbOfTuple1,nbOfComp1);
const int *a2Ptr=a2->getConstPointer();
const int *a1Ptr=a1->getConstPointer();
else if(nbOfTuple2==1)
{
a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Substract !");
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
+ MCAuto<DataArrayInt> ret=DataArrayInt::New();
ret->alloc(nbOfTuple1,nbOfComp1);
const int *a1ptr=a1->getConstPointer(),*a2ptr=a2->getConstPointer();
int *pt=ret->getPointer();
int nbOfTuple2=a2->getNumberOfTuples();
int nbOfComp=a1->getNumberOfComponents();
int nbOfComp2=a2->getNumberOfComponents();
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=0;
+ MCAuto<DataArrayInt> ret=0;
if(nbOfTuple==nbOfTuple2)
{
if(nbOfComp==nbOfComp2)
{
if(nbOfComp1==nbOfComp2)
{
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
+ MCAuto<DataArrayInt> ret=DataArrayInt::New();
ret->alloc(nbOfTuple2,nbOfComp1);
std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::divides<int>());
ret->copyStringInfoFrom(*a1);
}
else if(nbOfComp2==1)
{
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
+ MCAuto<DataArrayInt> ret=DataArrayInt::New();
ret->alloc(nbOfTuple1,nbOfComp1);
const int *a2Ptr=a2->getConstPointer();
const int *a1Ptr=a1->getConstPointer();
else if(nbOfTuple2==1)
{
a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Divide !");
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
+ MCAuto<DataArrayInt> ret=DataArrayInt::New();
ret->alloc(nbOfTuple1,nbOfComp1);
const int *a1ptr=a1->getConstPointer(),*a2ptr=a2->getConstPointer();
int *pt=ret->getPointer();
{
if(nbOfComp1==nbOfComp2)
{
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
+ MCAuto<DataArrayInt> ret=DataArrayInt::New();
ret->alloc(nbOfTuple2,nbOfComp1);
std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::modulus<int>());
ret->copyStringInfoFrom(*a1);
}
else if(nbOfComp2==1)
{
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
+ MCAuto<DataArrayInt> ret=DataArrayInt::New();
ret->alloc(nbOfTuple1,nbOfComp1);
const int *a2Ptr=a2->getConstPointer();
const int *a1Ptr=a1->getConstPointer();
else if(nbOfTuple2==1)
{
a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Modulus !");
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
+ MCAuto<DataArrayInt> ret=DataArrayInt::New();
ret->alloc(nbOfTuple1,nbOfComp1);
const int *a1ptr=a1->getConstPointer(),*a2ptr=a2->getConstPointer();
int *pt=ret->getPointer();
throw INTERP_KERNEL::Exception("DataArrayInt::Pow : number of tuples mismatches !");
if(nbOfComp!=1 || nbOfComp2!=1)
throw INTERP_KERNEL::Exception("DataArrayInt::Pow : number of components of both arrays must be equal to 1 !");
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(nbOfTuple,1);
+ MCAuto<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(nbOfTuple,1);
const int *ptr1(a1->begin()),*ptr2(a2->begin());
int *ptr=ret->getPointer();
for(int i=0;i<nbOfTuple;i++,ptr1++,ptr2++,ptr++)
DataArrayInt *DataArrayInt::Range(int begin, int end, int step)
{
int nbOfTuples=GetNumberOfItemGivenBESRelative(begin,end,step,"DataArrayInt::Range");
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
+ MCAuto<DataArrayInt> ret=DataArrayInt::New();
ret->alloc(nbOfTuples,1);
int *ptr=ret->getPointer();
if(step>0)