-// Copyright (C) 2007-2012 CEA/DEN, EDF R&D
+// Copyright (C) 2007-2013 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
void DataArrayDouble::findCommonTuplesAlg(const double *bbox, int nbNodes, int limitNodeId, double prec, DataArrayInt *c, DataArrayInt *cI) const
{
const double *coordsPtr=getConstPointer();
- BBTree<SPACEDIM,int> myTree(bbox,0,0,nbNodes,prec/10);
+ BBTreePts<SPACEDIM,int> myTree(bbox,0,0,nbNodes,prec);
std::vector<bool> isDone(nbNodes);
for(int i=0;i<nbNodes;i++)
{
}
template<int SPACEDIM>
-void DataArrayDouble::FindTupleIdsNearTuplesAlg(const BBTree<SPACEDIM,int>& myTree, const double *pos, int nbOfTuples, double eps,
+void DataArrayDouble::FindTupleIdsNearTuplesAlg(const BBTreePts<SPACEDIM,int>& myTree, const double *pos, int nbOfTuples, double eps,
DataArrayInt *c, DataArrayInt *cI)
{
for(int i=0;i<nbOfTuples;i++)
setInfoOnComponent(compoIds[i],other.getInfoOnComponent((int)i).c_str());
}
-bool DataArray::areInfoEqualsIfNotWhy(const DataArray& other, std::string& reason) const
+bool DataArray::areInfoEqualsIfNotWhy(const DataArray& other, std::string& reason) const throw(INTERP_KERNEL::Exception)
{
std::ostringstream oss;
if(_name!=other._name)
* \param [in] other - another instance of DataArray to compare the textual data of.
* \return bool - \a true if the textual information is same, \a false else.
*/
-bool DataArray::areInfoEquals(const DataArray& other) const
+bool DataArray::areInfoEquals(const DataArray& other) const throw(INTERP_KERNEL::Exception)
{
std::string tmp;
return areInfoEqualsIfNotWhy(other,tmp);
}
-void DataArray::reprWithoutNameStream(std::ostream& stream) const
+void DataArray::reprWithoutNameStream(std::ostream& stream) const throw(INTERP_KERNEL::Exception)
{
stream << "Number of components : "<< getNumberOfComponents() << "\n";
stream << "Info of these components : ";
_info_on_compo=info;
}
-std::vector<std::string> DataArray::getVarsOnComponent() const
+std::vector<std::string> DataArray::getVarsOnComponent() const throw(INTERP_KERNEL::Exception)
{
int nbOfCompo=(int)_info_on_compo.size();
std::vector<std::string> ret(nbOfCompo);
return ret;
}
-std::vector<std::string> DataArray::getUnitsOnComponent() const
+std::vector<std::string> DataArray::getUnitsOnComponent() const throw(INTERP_KERNEL::Exception)
{
int nbOfCompo=(int)_info_on_compo.size();
std::vector<std::string> ret(nbOfCompo);
* Sets information on a component specified by an index.
* To know more on format of this information
* see \ref MEDCouplingArrayBasicsCompoName "DataArrays infos".
+ * \warning Don't pass NULL as \a info!
* \param [in] i - the index (zero based) of the component of interest.
* \param [in] info - the string containing the information.
* \throw If \a i is not a valid component index.
- * \warning Don't pass NULL as \a info!
*/
void DataArray::setInfoOnComponent(int i, const char *info) throw(INTERP_KERNEL::Exception)
{
}
}
-void DataArray::checkNbOfElems(int nbOfElems, const char *msg) const throw(INTERP_KERNEL::Exception)
+void DataArray::checkNbOfElems(std::size_t nbOfElems, const char *msg) const throw(INTERP_KERNEL::Exception)
{
if(getNbOfElems()!=nbOfElems)
{
* in \ref MEDCouplingArrayBasicsTuplesAndCompo "DataArrays infos" for more information.
* \return bool - \a true if the raw data is allocated, \a false else.
*/
-bool DataArrayDouble::isAllocated() const
+bool DataArrayDouble::isAllocated() const throw(INTERP_KERNEL::Exception)
{
return getConstPointer()!=0;
}
std::size_t DataArrayDouble::getHeapMemorySize() const
{
- std::size_t sz=(std::size_t)_mem.getNbOfElemAllocated();
+ std::size_t sz=_mem.getNbOfElemAllocated();
sz*=sizeof(double);
return DataArray::getHeapMemorySize()+sz;
}
/*!
* Returns a full copy of \a this. For more info on copying data arrays see
* \ref MEDCouplingArrayBasicsCopyDeep.
- * \return DataArrayDouble * - a new instance of DataArrayDouble.
+ * \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::deepCpy() const throw(INTERP_KERNEL::Exception)
{
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::performCpy(bool dCpy) const throw(INTERP_KERNEL::Exception)
{
if(dCpy)
return deepCpy();
int nbOfTuples=other.getNumberOfTuples();
int nbOfComp=other.getNumberOfComponents();
allocIfNecessary(nbOfTuples,nbOfComp);
- int nbOfElems=nbOfTuples*nbOfComp;
+ std::size_t nbOfElems=(std::size_t)nbOfTuples*nbOfComp;
double *pt=getPointer();
const double *ptI=other.getConstPointer();
- for(int i=0;i<nbOfElems;i++)
+ for(std::size_t i=0;i<nbOfElems;i++)
pt[i]=ptI[i];
copyStringInfoFrom(other);
}
*
* \sa DataArrayDouble::pack, DataArrayDouble::pushBackSilent, DataArrayDouble::pushBackValsSilent
*/
-void DataArrayDouble::reserve(int nbOfElems) throw(INTERP_KERNEL::Exception)
+void DataArrayDouble::reserve(std::size_t nbOfElems) throw(INTERP_KERNEL::Exception)
{
int nbCompo=getNumberOfComponents();
if(nbCompo==1)
* \param [in] nbOfCompo - number of components of data to allocate.
* \throw If \a nbOfTuple < 0 or \a nbOfCompo < 0.
*/
-void DataArrayDouble::allocIfNecessary(int nbOfTuple, int nbOfCompo)
+void DataArrayDouble::allocIfNecessary(int nbOfTuple, int nbOfCompo) throw(INTERP_KERNEL::Exception)
{
if(isAllocated())
{
if(nbOfTuple<0 || nbOfCompo<0)
throw INTERP_KERNEL::Exception("DataArrayDouble::alloc : request for negative length of data !");
_info_on_compo.resize(nbOfCompo);
- _mem.alloc(nbOfCompo*nbOfTuple);
+ _mem.alloc(nbOfCompo*(std::size_t)nbOfTuple);
declareAsNew();
}
if(getNumberOfComponents()!=1)
throw INTERP_KERNEL::Exception("DataArrayDouble::sort : only supported with 'this' array with ONE component !");
_mem.sort(asc);
+ declareAsNew();
}
/*!
* Reverse the array values.
- * \throw If \a this->getNumberOfComponents() != 1.
+ * \throw If \a this->getNumberOfComponents() < 1.
* \throw If \a this is not allocated.
*/
void DataArrayDouble::reverse() throw(INTERP_KERNEL::Exception)
{
checkAllocated();
- if(getNumberOfComponents()!=1)
- throw INTERP_KERNEL::Exception("DataArrayDouble::reverse : only supported with 'this' array with ONE component !");
- _mem.reverse();
+ _mem.reverse(getNumberOfComponents());
+ declareAsNew();
}
/*!
* DataArrayDouble. This text is shown when a DataArrayDouble is printed in Python.
* \return std::string - text describing \a this DataArrayDouble.
*/
-std::string DataArrayDouble::repr() const
+std::string DataArrayDouble::repr() const throw(INTERP_KERNEL::Exception)
{
std::ostringstream ret;
reprStream(ret);
return ret.str();
}
-std::string DataArrayDouble::reprZip() const
+std::string DataArrayDouble::reprZip() const throw(INTERP_KERNEL::Exception)
{
std::ostringstream ret;
reprZipStream(ret);
ofs << std::endl << idt << "</DataArray>\n";
}
-void DataArrayDouble::reprStream(std::ostream& stream) const
+void DataArrayDouble::reprStream(std::ostream& stream) const throw(INTERP_KERNEL::Exception)
{
stream << "Name of double array : \"" << _name << "\"\n";
reprWithoutNameStream(stream);
}
-void DataArrayDouble::reprZipStream(std::ostream& stream) const
+void DataArrayDouble::reprZipStream(std::ostream& stream) const throw(INTERP_KERNEL::Exception)
{
stream << "Name of double array : \"" << _name << "\"\n";
reprZipWithoutNameStream(stream);
}
-void DataArrayDouble::reprWithoutNameStream(std::ostream& stream) const
+void DataArrayDouble::reprWithoutNameStream(std::ostream& stream) const throw(INTERP_KERNEL::Exception)
{
DataArray::reprWithoutNameStream(stream);
stream.precision(17);
_mem.repr(getNumberOfComponents(),stream);
}
-void DataArrayDouble::reprZipWithoutNameStream(std::ostream& stream) const
+void DataArrayDouble::reprZipWithoutNameStream(std::ostream& stream) const throw(INTERP_KERNEL::Exception)
{
DataArray::reprWithoutNameStream(stream);
stream.precision(17);
_mem.reprZip(getNumberOfComponents(),stream);
}
-void DataArrayDouble::reprCppStream(const char *varName, std::ostream& stream) const
+void DataArrayDouble::reprCppStream(const char *varName, std::ostream& stream) const throw(INTERP_KERNEL::Exception)
{
int nbTuples=getNumberOfTuples(),nbComp=getNumberOfComponents();
const double *data=getConstPointer();
stream << varName << "->setName(\"" << getName() << "\");" << std::endl;
}
-bool DataArrayDouble::isEqualIfNotWhy(const DataArrayDouble& other, double prec, std::string& reason) const
+/*!
+ * Method that gives a quick overvien of \a this for python.
+ */
+void DataArrayDouble::reprQuickOverview(std::ostream& stream) const throw(INTERP_KERNEL::Exception)
+{
+ static const std::size_t MAX_NB_OF_BYTE_IN_REPR=300;
+ stream << "DataArrayDouble C++ instance at " << this << ". ";
+ if(isAllocated())
+ {
+ int nbOfCompo=(int)_info_on_compo.size();
+ if(nbOfCompo>=1)
+ {
+ int nbOfTuples=getNumberOfTuples();
+ stream << "Number of tuples : " << nbOfTuples << ". Number of components : " << nbOfCompo << "." << std::endl;
+ reprQuickOverviewData(stream,MAX_NB_OF_BYTE_IN_REPR);
+ }
+ else
+ stream << "Number of components : 0.";
+ }
+ else
+ stream << "*** No data allocated ****";
+}
+
+void DataArrayDouble::reprQuickOverviewData(std::ostream& stream, std::size_t maxNbOfByteInRepr) const throw(INTERP_KERNEL::Exception)
+{
+ const double *data=begin();
+ int nbOfTuples=getNumberOfTuples();
+ int nbOfCompo=(int)_info_on_compo.size();
+ std::ostringstream oss2; oss2 << "[";
+ oss2.precision(17);
+ std::string oss2Str(oss2.str());
+ bool isFinished=true;
+ for(int i=0;i<nbOfTuples && isFinished;i++)
+ {
+ if(nbOfCompo>1)
+ {
+ oss2 << "(";
+ for(int j=0;j<nbOfCompo;j++,data++)
+ {
+ oss2 << *data;
+ if(j!=nbOfCompo-1) oss2 << ", ";
+ }
+ oss2 << ")";
+ }
+ else
+ oss2 << *data++;
+ if(i!=nbOfTuples-1) oss2 << ", ";
+ std::string oss3Str(oss2.str());
+ if(oss3Str.length()<maxNbOfByteInRepr)
+ oss2Str=oss3Str;
+ else
+ isFinished=false;
+ }
+ stream << oss2Str;
+ if(!isFinished)
+ stream << "... ";
+ stream << "]";
+}
+
+/*!
+ * Equivalent to DataArrayDouble::isEqual except that if false the reason of
+ * mismatch is given.
+ *
+ * \param [in] other the instance to be compared with \a this
+ * \param [in] prec the precision to compare numeric data of the arrays.
+ * \param [out] reason In case of inequality returns the reason.
+ * \sa DataArrayDouble::isEqual
+ */
+bool DataArrayDouble::isEqualIfNotWhy(const DataArrayDouble& other, double prec, std::string& reason) const throw(INTERP_KERNEL::Exception)
{
if(!areInfoEqualsIfNotWhy(other,reason))
return false;
* \param [in] prec - precision value to compare numeric data of the arrays.
* \return bool - \a true if the two arrays are equal, \a false else.
*/
-bool DataArrayDouble::isEqual(const DataArrayDouble& other, double prec) const
+bool DataArrayDouble::isEqual(const DataArrayDouble& other, double prec) const throw(INTERP_KERNEL::Exception)
{
std::string tmp;
return isEqualIfNotWhy(other,prec,tmp);
* \param [in] prec - precision value to compare numeric data of the arrays.
* \return bool - \a true if the values of two arrays are equal, \a false else.
*/
-bool DataArrayDouble::isEqualWithoutConsideringStr(const DataArrayDouble& other, double prec) const
+bool DataArrayDouble::isEqualWithoutConsideringStr(const DataArrayDouble& other, double prec) const throw(INTERP_KERNEL::Exception)
{
std::string tmp;
return _mem.isEqual(other._mem,prec,tmp);
void DataArrayDouble::reAlloc(int nbOfTuples) throw(INTERP_KERNEL::Exception)
{
checkAllocated();
- _mem.reAlloc(getNumberOfComponents()*nbOfTuples);
+ _mem.reAlloc(getNumberOfComponents()*(std::size_t)nbOfTuples);
declareAsNew();
}
{
DataArrayInt *ret=DataArrayInt::New();
ret->alloc(getNumberOfTuples(),getNumberOfComponents());
- int nbOfVals=getNbOfElems();
+ std::size_t nbOfVals=getNbOfElems();
const double *src=getConstPointer();
int *dest=ret->getPointer();
std::copy(src,src+nbOfVals,dest);
* arranged in memory. If \a this array holds 2 components of 3 values:
* \f$ x_0,x_1,x_2,y_0,y_1,y_2 \f$, then the result array holds these values arranged
* as follows: \f$ x_0,y_0,x_1,y_1,x_2,y_2 \f$.
+ * \warning Do not confuse this method with transpose()!
* \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
* is to delete using decrRef() as it is no more needed.
* \throw If \a this is not allocated.
- * \warning Do not confuse this method with transpose()!
*/
DataArrayDouble *DataArrayDouble::fromNoInterlace() const throw(INTERP_KERNEL::Exception)
{
* arranged in memory. If \a this array holds 2 components of 3 values:
* \f$ x_0,y_0,x_1,y_1,x_2,y_2 \f$, then the result array holds these values arranged
* as follows: \f$ x_0,x_1,x_2,y_0,y_1,y_2 \f$.
+ * \warning Do not confuse this method with transpose()!
* \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
* is to delete using decrRef() as it is no more needed.
* \throw If \a this is not allocated.
- * \warning Do not confuse this method with transpose()!
*/
DataArrayDouble *DataArrayDouble::toNoInterlace() const throw(INTERP_KERNEL::Exception)
{
* \param [in] old2New - C array of length equal to \a this->getNumberOfTuples()
* giving a new position for i-th old value.
*/
-void DataArrayDouble::renumberInPlace(const int *old2New)
+void DataArrayDouble::renumberInPlace(const int *old2New) throw(INTERP_KERNEL::Exception)
{
checkAllocated();
int nbTuples=getNumberOfTuples();
* \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
* is to delete using decrRef() as it is no more needed.
*/
-void DataArrayDouble::renumberInPlaceR(const int *new2Old)
+void DataArrayDouble::renumberInPlaceR(const int *new2Old) throw(INTERP_KERNEL::Exception)
{
checkAllocated();
int nbTuples=getNumberOfTuples();
* is to delete using decrRef() as it is no more needed.
* \throw If \a this is not allocated.
*/
-DataArrayDouble *DataArrayDouble::renumber(const int *old2New) const
+DataArrayDouble *DataArrayDouble::renumber(const int *old2New) const throw(INTERP_KERNEL::Exception)
{
checkAllocated();
int nbTuples=getNumberOfTuples();
int nbOfCompo=getNumberOfComponents();
- DataArrayDouble *ret=DataArrayDouble::New();
+ MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
ret->alloc(nbTuples,nbOfCompo);
ret->copyStringInfoFrom(*this);
const double *iptr=getConstPointer();
for(int i=0;i<nbTuples;i++)
std::copy(iptr+nbOfCompo*i,iptr+nbOfCompo*(i+1),optr+nbOfCompo*old2New[i]);
ret->copyStringInfoFrom(*this);
- return ret;
+ return ret.retn();
}
/*!
* \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
* is to delete using decrRef() as it is no more needed.
*/
-DataArrayDouble *DataArrayDouble::renumberR(const int *new2Old) const
+DataArrayDouble *DataArrayDouble::renumberR(const int *new2Old) const throw(INTERP_KERNEL::Exception)
{
checkAllocated();
int nbTuples=getNumberOfTuples();
int nbOfCompo=getNumberOfComponents();
- DataArrayDouble *ret=DataArrayDouble::New();
+ MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
ret->alloc(nbTuples,nbOfCompo);
ret->copyStringInfoFrom(*this);
const double *iptr=getConstPointer();
for(int i=0;i<nbTuples;i++)
std::copy(iptr+nbOfCompo*new2Old[i],iptr+nbOfCompo*(new2Old[i]+1),optr+i*nbOfCompo);
ret->copyStringInfoFrom(*this);
- return ret;
+ return ret.retn();
}
/*!
* \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
* is to delete using decrRef() as it is no more needed.
*/
-DataArrayDouble *DataArrayDouble::renumberAndReduce(const int *old2New, int newNbOfTuple) const
+DataArrayDouble *DataArrayDouble::renumberAndReduce(const int *old2New, int newNbOfTuple) const throw(INTERP_KERNEL::Exception)
{
checkAllocated();
int nbTuples=getNumberOfTuples();
int nbOfCompo=getNumberOfComponents();
- DataArrayDouble *ret=DataArrayDouble::New();
+ MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
ret->alloc(newNbOfTuple,nbOfCompo);
const double *iptr=getConstPointer();
double *optr=ret->getPointer();
std::copy(iptr+i*nbOfCompo,iptr+(i+1)*nbOfCompo,optr+w*nbOfCompo);
}
ret->copyStringInfoFrom(*this);
- return ret;
+ return ret.retn();
}
/*!
if(*w>=0 && *w<oldNbOfTuples)
std::copy(srcPt+(*w)*nbComp,srcPt+((*w)+1)*nbComp,pt+i*nbComp);
else
- throw INTERP_KERNEL::Exception("DataArrayInt::selectByTupleIdSafe : some ids has been detected to be out of [0,this->getNumberOfTuples) !");
+ throw INTERP_KERNEL::Exception("DataArrayDouble::selectByTupleIdSafe : some ids has been detected to be out of [0,this->getNumberOfTuples) !");
ret->copyStringInfoFrom(*this);
return ret.retn();
}
* \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.
- * \throw If (\a end2 < \a bg) or (\a step <= 0).
* \sa DataArrayDouble::substr.
*/
DataArrayDouble *DataArrayDouble::selectByTupleId2(int bg, int end2, int step) const throw(INTERP_KERNEL::Exception)
checkAllocated();
MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
int nbComp=getNumberOfComponents();
- int newNbOfTuples=GetNumberOfItemGivenBES(bg,end2,step,"DataArrayDouble::selectByTupleId2 : ");
+ int newNbOfTuples=GetNumberOfItemGivenBESRelative(bg,end2,step,"DataArrayDouble::selectByTupleId2 : ");
ret->alloc(newNbOfTuples,nbComp);
double *pt=ret->getPointer();
const double *srcPt=getConstPointer()+bg*nbComp;
else
trueEnd=nbt;
int nbComp=getNumberOfComponents();
- DataArrayDouble *ret=DataArrayDouble::New();
+ MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
ret->alloc(trueEnd-tupleIdBg,nbComp);
ret->copyStringInfoFrom(*this);
std::copy(getConstPointer()+tupleIdBg*nbComp,getConstPointer()+trueEnd*nbComp,ret->getPointer());
- return ret;
+ return ret.retn();
}
/*!
DataArrayDouble *DataArrayDouble::changeNbOfComponents(int newNbOfComp, double dftValue) const throw(INTERP_KERNEL::Exception)
{
checkAllocated();
- DataArrayDouble *ret=DataArrayDouble::New();
+ MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
ret->alloc(getNumberOfTuples(),newNbOfComp);
const double *oldc=getConstPointer();
double *nc=ret->getPointer();
for(int i=0;i<dim;i++)
ret->setInfoOnComponent(i,getInfoOnComponent(i).c_str());
ret->setName(getName().c_str());
- return ret;
+ return ret.retn();
}
/*!
* Changes the number of components within \a this array so that its raw data **does
* not** change, instead splitting this data into tuples changes.
+ * \warning This method erases all (name and unit) component info set before!
* \param [in] newNbOfComp - number of components for \a this array to have.
* \throw If \a this is not allocated
* \throw If getNbOfElems() % \a newNbOfCompo != 0.
+ * \throw If \a newNbOfCompo is lower than 1.
+ * \throw If the rearrange method would lead to a number of tuples higher than 2147483647 (maximal capacity of int32 !).
* \warning This method erases all (name and unit) component info set before!
*/
void DataArrayDouble::rearrange(int newNbOfCompo) throw(INTERP_KERNEL::Exception)
{
checkAllocated();
- int nbOfElems=getNbOfElems();
+ if(newNbOfCompo<1)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::rearrange : input newNbOfCompo must be > 0 !");
+ std::size_t nbOfElems=getNbOfElems();
if(nbOfElems%newNbOfCompo!=0)
throw INTERP_KERNEL::Exception("DataArrayDouble::rearrange : nbOfElems%newNbOfCompo!=0 !");
+ if(nbOfElems/newNbOfCompo>(std::size_t)std::numeric_limits<int>::max())
+ throw INTERP_KERNEL::Exception("DataArrayDouble::rearrange : the rearrangement leads to too high number of tuples (> 2147483647) !");
_info_on_compo.clear();
_info_on_compo.resize(newNbOfCompo);
declareAsNew();
* of tuples, and inversely its number of tuples to become equal to its number of
* components. So that its raw data **does not** change, instead splitting this
* data into tuples changes.
- * \throw If \a this is not allocated.
* \warning This method erases all (name and unit) component info set before!
* \warning Do not confuse this method with fromNoInterlace() and toNoInterlace()!
+ * \throw If \a this is not allocated.
* \sa rearrange()
*/
void DataArrayDouble::transpose() throw(INTERP_KERNEL::Exception)
*
* This method is typically used by MEDCouplingPointSet::findCommonNodes() and
* MEDCouplingUMesh::mergeNodes().
- * \param [in] prec - minimal absolute distance between two tuples at which they are
+ * \param [in] prec - minimal absolute distance between two tuples (infinite norm) at which they are
* considered not coincident.
- * \param [in] limitTupleId - limit tuple id. Tuples with id strictly lower than \a
- * limitTupleId are not considered.
+ * \param [in] limitTupleId - limit tuple id. If all tuples within a group of coincident
+ * tuples have id strictly lower than \a limitTupleId then they are not returned.
* \param [out] comm - the array holding ids (== indices) of coincident tuples.
* \a comm->getNumberOfComponents() == 1.
* \a comm->getNumberOfTuples() == \a commIndex->back().
* [ \a commIndex[1], \a commIndex[2] ). \a commIndex->getNumberOfTuples()-1
* gives the number of groups of coincident tuples.
* \throw If \a this is not allocated.
- * \throw If \a this and \a other arrays have different number of tuples.
* \throw If the number of components is not in [1,2,3].
*
* \ref cpp_mcdataarraydouble_findcommontuples "Here is a C++ example".
int nbOfTuples=getNumberOfTuples();
//
- MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> bbox=computeBBoxPerTuple(prec);
- //
MEDCouplingAutoRefCountObjectPtr<DataArrayInt> c(DataArrayInt::New()),cI(DataArrayInt::New()); c->alloc(0,1); cI->pushBackSilent(0);
switch(nbOfCompo)
{
case 3:
- findCommonTuplesAlg<3>(bbox->getConstPointer(),nbOfTuples,limitTupleId,prec,c,cI);
+ findCommonTuplesAlg<3>(begin(),nbOfTuples,limitTupleId,prec,c,cI);
break;
case 2:
- findCommonTuplesAlg<2>(bbox->getConstPointer(),nbOfTuples,limitTupleId,prec,c,cI);
+ findCommonTuplesAlg<2>(begin(),nbOfTuples,limitTupleId,prec,c,cI);
break;
case 1:
- findCommonTuplesAlg<1>(bbox->getConstPointer(),nbOfTuples,limitTupleId,prec,c,cI);
+ findCommonTuplesAlg<1>(begin(),nbOfTuples,limitTupleId,prec,c,cI);
break;
default:
throw INTERP_KERNEL::Exception("DataArrayDouble::findCommonTuples : nb of components managed are 1,2 and 3 ! not implemented for other number of components !");
* that coincident tuples are excluded.
* \param [in] prec - minimal absolute distance between two tuples at which they are
* considered not coincident.
- * \param [in] limitTupleId - limit tuple id. Tuples with id strictly lower than \a
- * limiTupleId are not considered and thus not excluded.
+ * \param [in] limitTupleId - limit tuple id. If all tuples within a group of coincident
+ * tuples have id strictly lower than \a limitTupleId then they are not excluded.
* \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
* is to delete using decrRef() as it is no more needed.
* \throw If \a this is not allocated.
/*!
* Copy all components in a specified order from another DataArrayDouble.
- * The specified components become the first ones in \a this array.
* Both numerical and textual data is copied. The number of tuples in \a this and
* the other array can be different.
* \param [in] a - the array to copy data from.
DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
bool assignTech=true;
- if(a->getNbOfElems()==newNbOfTuples*newNbOfComp)
+ if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
{
if(strictCompoCompare)
a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
int newNbOfTuples=(int)std::distance(bgTuples,endTuples);
int newNbOfComp=(int)std::distance(bgComp,endComp);
bool assignTech=true;
- if(a->getNbOfElems()==newNbOfTuples*newNbOfComp)
+ if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
{
if(strictCompoCompare)
a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
for(const int *z=bgComp;z!=endComp;z++,srcPt++)
{
- pt[(*w)*nbComp+(*z)]=*srcPt;
+ pt[(std::size_t)(*w)*nbComp+(*z)]=*srcPt;
}
}
}
DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
for(const int *z=bgComp;z!=endComp;z++,srcPt2++)
{
- pt[(*w)*nbComp+(*z)]=*srcPt2;
+ pt[(std::size_t)(*w)*nbComp+(*z)]=*srcPt2;
}
}
}
for(const int *z=bgComp;z!=endComp;z++)
{
DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
- pt[(*w)*nbComp+(*z)]=a;
+ pt[(std::size_t)(*w)*nbComp+(*z)]=a;
}
}
DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
int newNbOfTuples=(int)std::distance(bgTuples,endTuples);
bool assignTech=true;
- if(a->getNbOfElems()==newNbOfTuples*newNbOfComp)
+ if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
{
if(strictCompoCompare)
a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
for(int j=0;j<newNbOfComp;j++,srcPt++)
{
DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
- pt[(*w)*nbComp+j*stepComp]=*srcPt;
+ pt[(std::size_t)(*w)*nbComp+j*stepComp]=*srcPt;
}
}
else
for(int j=0;j<newNbOfComp;j++,srcPt2++)
{
DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
- pt[(*w)*nbComp+j*stepComp]=*srcPt2;
+ pt[(std::size_t)(*w)*nbComp+j*stepComp]=*srcPt2;
}
}
}
for(int j=0;j<newNbOfComp;j++)
{
DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
- pt[(*w)*nbComp+j*stepComp]=a;
+ pt[(std::size_t)(*w)*nbComp+j*stepComp]=a;
}
}
int nbOfTuples=getNumberOfTuples();
DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
bool assignTech=true;
- if(a->getNbOfElems()==newNbOfTuples*newNbOfComp)
+ if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
{
if(strictCompoCompare)
a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
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];
+ return _mem[tupleId*_info_on_compo.size()+compoId];
}
/*!
* \param [in] nbOfTuple - new number of tuples in \a this.
* \param [in] nbOfCompo - new number of components in \a this.
*/
-void DataArrayDouble::useArray(const double *array, bool ownership, DeallocType type, int nbOfTuple, int nbOfCompo)
+void DataArrayDouble::useArray(const double *array, bool ownership, DeallocType type, int nbOfTuple, int nbOfCompo) throw(INTERP_KERNEL::Exception)
{
_info_on_compo.resize(nbOfCompo);
- _mem.useArray(array,ownership,type,nbOfTuple*nbOfCompo);
+ _mem.useArray(array,ownership,type,(std::size_t)nbOfTuple*nbOfCompo);
declareAsNew();
}
-void DataArrayDouble::useExternalArrayWithRWAccess(const double *array, int nbOfTuple, int nbOfCompo)
+void DataArrayDouble::useExternalArrayWithRWAccess(const double *array, int nbOfTuple, int nbOfCompo) throw(INTERP_KERNEL::Exception)
{
_info_on_compo.resize(nbOfCompo);
- _mem.useExternalArrayWithRWAccess(array,nbOfTuple*nbOfCompo);
+ _mem.useExternalArrayWithRWAccess(array,(std::size_t)nbOfTuple*nbOfCompo);
declareAsNew();
}
void DataArrayDouble::checkNoNullValues() const throw(INTERP_KERNEL::Exception)
{
const double *tmp=getConstPointer();
- int nbOfElems=getNbOfElems();
+ std::size_t 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 !");
* Two tuples are considered equal if the euclidian distance between the two tuples is lower than \a eps.
*
* \param [in] other a DataArrayDouble having same number of components than \a this.
- * \param [in] eps absolute precision representing euclidian distance between 2 tuples behind which 2 tuples are considered equal.
+ * \param [in] eps absolute precision representing distance (using infinite norm) between 2 tuples behind which 2 tuples are considered equal.
* \param [out] c will contain the set of tuple ids in \a this that are equal to to the tuple ids in \a other contiguously.
* \a cI allows to extract information in \a c.
* \param [out] cI is an indirection array that allows to extract the data contained in \a c.
if(!other)
throw INTERP_KERNEL::Exception("DataArrayDouble::computeTupleIdsNearTuples : input pointer other is null !");
checkAllocated();
- MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> bbox=computeBBoxPerTuple(eps);
other->checkAllocated();
int nbOfCompo=getNumberOfComponents();
int otherNbOfCompo=other->getNumberOfComponents();
{
case 3:
{
- BBTree<3,int> myTree(bbox->getConstPointer(),0,0,getNumberOfTuples(),eps/10);
+ BBTreePts<3,int> myTree(begin(),0,0,getNumberOfTuples(),eps);
FindTupleIdsNearTuplesAlg<3>(myTree,other->getConstPointer(),nbOfTuplesOther,eps,cArr,cIArr);
break;
}
case 2:
{
- BBTree<2,int> myTree(bbox->getConstPointer(),0,0,getNumberOfTuples(),eps/10);
+ BBTreePts<2,int> myTree(begin(),0,0,getNumberOfTuples(),eps);
FindTupleIdsNearTuplesAlg<2>(myTree,other->getConstPointer(),nbOfTuplesOther,eps,cArr,cIArr);
break;
}
case 1:
{
- BBTree<1,int> myTree(bbox->getConstPointer(),0,0,getNumberOfTuples(),eps/10);
+ BBTreePts<1,int> myTree(begin(),0,0,getNumberOfTuples(),eps);
FindTupleIdsNearTuplesAlg<1>(myTree,other->getConstPointer(),nbOfTuplesOther,eps,cArr,cIArr);
break;
}
{
checkAllocated();
double ret=0.;
- int nbOfElems=getNbOfElems();
+ std::size_t nbOfElems=getNbOfElems();
const double *pt=getConstPointer();
- for(int i=0;i<nbOfElems;i++,pt++)
+ for(std::size_t i=0;i<nbOfElems;i++,pt++)
ret+=(*pt)*(*pt);
return sqrt(ret);
}
{
checkAllocated();
double ret=-1.;
- int nbOfElems=getNbOfElems();
+ std::size_t nbOfElems=getNbOfElems();
const double *pt=getConstPointer();
- for(int i=0;i<nbOfElems;i++,pt++)
+ for(std::size_t i=0;i<nbOfElems;i++,pt++)
{
double val=std::abs(*pt);
if(val>ret)
{
checkAllocated();
double *ptr=getPointer();
- int nbOfElems=getNbOfElems();
+ std::size_t nbOfElems=getNbOfElems();
std::transform(ptr,ptr+nbOfElems,ptr,std::ptr_fun<double,double>(fabs));
declareAsNew();
}
{
checkAllocated();
double *ptr=getPointer();
- int nbOfElems=getNbOfElems();
- for(int i=0;i<nbOfElems;i++,ptr++)
+ std::size_t nbOfElems=getNbOfElems();
+ for(std::size_t i=0;i<nbOfElems;i++,ptr++)
*ptr=a*(*ptr)+b;
declareAsNew();
}
/*!
* Modify all elements of \a this array, so that
* an element _x_ becomes \f$ numerator / x \f$.
- * \param [in] numerator - the numerator used to modify array elements.
- * \throw If \a this is not allocated.
- * \throw If there is an element equal to 0.0 in \a this array.
* \warning If an exception is thrown because of presence of 0.0 element in \a this
* array, all elements processed before detection of the zero element remain
* modified.
+ * \param [in] numerator - the numerator used to modify array elements.
+ * \throw If \a this is not allocated.
+ * \throw If there is an element equal to 0.0 in \a this array.
*/
void DataArrayDouble::applyInv(double numerator) throw(INTERP_KERNEL::Exception)
{
checkAllocated();
double *ptr=getPointer();
- int nbOfElems=getNbOfElems();
- for(int i=0;i<nbOfElems;i++,ptr++)
+ std::size_t nbOfElems=getNbOfElems();
+ for(std::size_t i=0;i<nbOfElems;i++,ptr++)
{
if(std::abs(*ptr)>std::numeric_limits<double>::min())
{
return newArr;
}
+/*!
+ * Modify all elements of \a this array, so that
+ * an element _x_ becomes <em> val ^ x </em>. Contrary to DataArrayInt::applyPow
+ * all values in \a this have to be >= 0 if val is \b not integer.
+ * \param [in] val - the value used to apply pow on all array elements.
+ * \throw If \a this is not allocated.
+ * \warning If an exception is thrown because of presence of 0 element in \a this
+ * array and \a val is \b not integer, all elements processed before detection of the zero element remain
+ * modified.
+ */
+void DataArrayDouble::applyPow(double val) throw(INTERP_KERNEL::Exception)
+{
+ checkAllocated();
+ double *ptr=getPointer();
+ std::size_t nbOfElems=getNbOfElems();
+ int val2=(int)val;
+ bool isInt=((double)val2)==val;
+ if(!isInt)
+ {
+ for(std::size_t i=0;i<nbOfElems;i++,ptr++)
+ {
+ if(*ptr>=0)
+ *ptr=pow(*ptr,val);
+ else
+ {
+ std::ostringstream oss; oss << "DataArrayDouble::applyPow (double) : At elem # " << i << " value is " << *ptr << " ! must be >=0. !";
+ throw INTERP_KERNEL::Exception(oss.str().c_str());
+ }
+ }
+ }
+ else
+ {
+ for(std::size_t i=0;i<nbOfElems;i++,ptr++)
+ *ptr=pow(*ptr,val2);
+ }
+ declareAsNew();
+}
+
+/*!
+ * Modify all elements of \a this array, so that
+ * an element _x_ becomes \f$ val ^ x \f$.
+ * \param [in] val - the value used to apply pow on all array elements.
+ * \throw If \a this is not allocated.
+ * \throw If \a val < 0.
+ * \warning If an exception is thrown because of presence of 0 element in \a this
+ * array, all elements processed before detection of the zero element remain
+ * modified.
+ */
+void DataArrayDouble::applyRPow(double val) throw(INTERP_KERNEL::Exception)
+{
+ checkAllocated();
+ if(val<0.)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::applyRPow : the input value has to be >= 0 !");
+ double *ptr=getPointer();
+ std::size_t nbOfElems=getNbOfElems();
+ for(std::size_t i=0;i<nbOfElems;i++,ptr++)
+ *ptr=pow(val,*ptr);
+ declareAsNew();
+}
+
/*!
* Returns a new DataArrayDouble created from \a this one by applying \a
* FunctionToEvaluate to every tuple of \a this array. Textual data is not copied.
declareAsNew();
}
-DataArrayDoubleIterator *DataArrayDouble::iterator()
+DataArrayDoubleIterator *DataArrayDouble::iterator() throw(INTERP_KERNEL::Exception)
{
return new DataArrayDoubleIterator(this);
}
* array whose values are within a given range. Textual data is not copied.
* \param [in] vmin - a lowest acceptable value.
* \param [in] vmax - a greatest acceptable value.
- * \return DataArrayDouble * - the new instance of DataArrayDouble.
+ * \return DataArrayInt * - the new instance of DataArrayInt.
* The caller is to delete this result array using decrRef() as it is no more
* needed.
- * \throw If \a this->getNumberOfComponents() != 1
- *
- * \ref cpp_mcdataarraydouble_getidsinrange "Here is a C++ example".
+ * \throw If \a this->getNumberOfComponents() != 1.
*
+ * \ref cpp_mcdataarraydouble_getidsinrange "Here is a C++ example".<br>
* \ref py_mcdataarraydouble_getidsinrange "Here is a Python example".
*/
DataArrayInt *DataArrayDouble::getIdsInRange(double vmin, double vmax) const throw(INTERP_KERNEL::Exception)
if(getNumberOfComponents()!=1)
throw INTERP_KERNEL::Exception("DataArrayDouble::getIdsInRange : this must have exactly one component !");
const double *cptr=getConstPointer();
- std::vector<int> res;
+ MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(0,1);
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;
+ ret->pushBackSilent(i);
+ return ret.retn();
}
/*!
throw INTERP_KERNEL::Exception("DataArrayDouble::Aggregate : Nb of components mismatch for array aggregation !");
nbt+=(*it)->getNumberOfTuples();
}
- DataArrayDouble *ret=DataArrayDouble::New();
+ MEDCouplingAutoRefCountObjectPtr<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;
+ return ret.retn();
}
/*!
* valid cases.
* 1. The arrays have same number of tuples and components. Then each value of
* the result array (_a_) is a product of the corresponding values of \a a1 and
- * \a a2, i.e.: _a_ [ i, j ] = _a1_ [ i, j ] * _a2_ [ i, j ].
+ * \a a2, i.e. _a_ [ i, j ] = _a1_ [ i, j ] * _a2_ [ i, j ].
* 2. The arrays have same number of tuples and one array, say _a2_, has one
* component. Then
* _a_ [ i, j ] = _a1_ [ i, j ] * _a2_ [ i, 0 ].
* Multiply values of another DataArrayDouble to values of \a this one. There are 3
* valid cases.
* 1. The arrays have same number of tuples and components. Then each value of
- * \a other array is multiplied to the corresponding value of \a this array, i.e.:
- * _a_ [ i, j ] *= _other_ [ i, j ].
+ * \a other array is multiplied to the corresponding value of \a this array, i.e.
+ * _this_ [ i, j ] *= _other_ [ i, j ].
* 2. The arrays have same number of tuples and \a other array has one component. Then
- * _a_ [ i, j ] *= _other_ [ i, 0 ].
+ * _this_ [ i, j ] *= _other_ [ i, 0 ].
* 3. The arrays have same number of components and \a other array has one tuple. Then
- * _a_ [ i, j ] *= _a2_ [ 0, j ].
+ * _this_ [ i, j ] *= _a2_ [ 0, j ].
*
* \param [in] other - an array to multiply to \a this one.
* \throw If \a other is NULL.
*
* Info on components is copied either from the first array (in the first case) or from
* the array with maximal number of elements (getNbOfElems()).
+ * \warning No check of division by zero is performed!
* \param [in] a1 - a numerator array.
* \param [in] a2 - a denominator array.
* \return DataArrayDouble * - the new instance of DataArrayDouble.
* \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
* \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
* none of them has number of tuples or components equal to 1.
- * \warning No check of division by zero is performed!
*/
DataArrayDouble *DataArrayDouble::Divide(const DataArrayDouble *a1, const DataArrayDouble *a2) throw(INTERP_KERNEL::Exception)
{
* 3. The arrays have same number of components and \a other array has one tuple. Then
* _a_ [ i, j ] /= _a2_ [ 0, j ].
*
+ * \warning No check of division by zero is performed!
* \param [in] other - an array to divide \a this one by.
* \throw If \a other is NULL.
* \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
* \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
* \a other has number of both tuples and components not equal to 1.
- * \warning No check of division by zero is performed!
*/
void DataArrayDouble::divideEqual(const DataArrayDouble *other) throw(INTERP_KERNEL::Exception)
{
declareAsNew();
}
+/*!
+ * Returns a new DataArrayDouble that is the result of pow of two given arrays. There are 3
+ * valid cases.
+ *
+ * \param [in] a1 - an array to pow up.
+ * \param [in] a2 - another array to sum up.
+ * \return DataArrayDouble * - the new instance of DataArrayDouble.
+ * The caller is to delete this result array using decrRef() as it is no more
+ * needed.
+ * \throw If either \a a1 or \a a2 is NULL.
+ * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
+ * \throw If \a a1->getNumberOfComponents() != 1 or \a a2->getNumberOfComponents() != 1.
+ * \throw If there is a negative value in \a a1.
+ */
+DataArrayDouble *DataArrayDouble::Pow(const DataArrayDouble *a1, const DataArrayDouble *a2) throw(INTERP_KERNEL::Exception)
+{
+ if(!a1 || !a2)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::Pow : at least one of input instances is null !");
+ int nbOfTuple=a1->getNumberOfTuples();
+ int nbOfTuple2=a2->getNumberOfTuples();
+ int nbOfComp=a1->getNumberOfComponents();
+ int nbOfComp2=a2->getNumberOfComponents();
+ if(nbOfTuple!=nbOfTuple2)
+ 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);
+ const double *ptr1(a1->begin()),*ptr2(a2->begin());
+ double *ptr=ret->getPointer();
+ for(int i=0;i<nbOfTuple;i++,ptr1++,ptr2++,ptr++)
+ {
+ if(*ptr1>=0)
+ {
+ *ptr=pow(*ptr1,*ptr2);
+ }
+ else
+ {
+ std::ostringstream oss; oss << "DataArrayDouble::Pow : on tuple #" << i << " of a1 value is < 0 (" << *ptr1 << ") !";
+ throw INTERP_KERNEL::Exception(oss.str().c_str());
+ }
+ }
+ return ret.retn();
+}
+
+/*!
+ * Apply pow on values of another DataArrayDouble to values of \a this one.
+ *
+ * \param [in] other - an array to pow to \a this one.
+ * \throw If \a other is NULL.
+ * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples()
+ * \throw If \a this->getNumberOfComponents() != 1 or \a other->getNumberOfComponents() != 1
+ * \throw If there is a negative value in \a this.
+ */
+void DataArrayDouble::powEqual(const DataArrayDouble *other) throw(INTERP_KERNEL::Exception)
+{
+ if(!other)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::powEqual : input instance is null !");
+ int nbOfTuple=getNumberOfTuples();
+ int nbOfTuple2=other->getNumberOfTuples();
+ int nbOfComp=getNumberOfComponents();
+ int nbOfComp2=other->getNumberOfComponents();
+ if(nbOfTuple!=nbOfTuple2)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::powEqual : number of tuples mismatches !");
+ if(nbOfComp!=1 || nbOfComp2!=1)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::powEqual : number of components of both arrays must be equal to 1 !");
+ double *ptr=getPointer();
+ const double *ptrc=other->begin();
+ for(int i=0;i<nbOfTuple;i++,ptrc++,ptr++)
+ {
+ if(*ptr>=0)
+ *ptr=pow(*ptr,*ptrc);
+ else
+ {
+ std::ostringstream oss; oss << "DataArrayDouble::powEqual : on tuple #" << i << " of this value is < 0 (" << *ptr << ") !";
+ throw INTERP_KERNEL::Exception(oss.str().c_str());
+ }
+ }
+ declareAsNew();
+}
+
/*!
* Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
* Server side.
_da->decrRef();
}
-DataArrayDoubleTuple *DataArrayDoubleIterator::nextt()
+DataArrayDoubleTuple *DataArrayDoubleIterator::nextt() throw(INTERP_KERNEL::Exception)
{
if(_tuple_id<_nb_tuple)
{
}
-std::string DataArrayDoubleTuple::repr() const
+std::string DataArrayDoubleTuple::repr() const throw(INTERP_KERNEL::Exception)
{
std::ostringstream oss; oss.precision(17); oss << "(";
for(int i=0;i<_nb_of_compo-1;i++)
* in \ref MEDCouplingArrayBasicsTuplesAndCompo "DataArrays infos" for more information.
* \return bool - \a true if the raw data is allocated, \a false else.
*/
-bool DataArrayInt::isAllocated() const
+bool DataArrayInt::isAllocated() const throw(INTERP_KERNEL::Exception)
{
return getConstPointer()!=0;
}
std::size_t DataArrayInt::getHeapMemorySize() const
{
- std::size_t sz=(std::size_t)_mem.getNbOfElemAllocated();
+ std::size_t sz=_mem.getNbOfElemAllocated();
sz*=sizeof(int);
return DataArray::getHeapMemorySize()+sz;
}
int DataArrayInt::getHashCode() const throw(INTERP_KERNEL::Exception)
{
checkAllocated();
- int nbOfElems=getNbOfElems();
+ std::size_t nbOfElems=getNbOfElems();
int ret=nbOfElems*65536;
int delta=3;
if(nbOfElems>48)
delta=nbOfElems/8;
int ret0=0;
const int *pt=begin();
- for(int i=0;i<nbOfElems;i+=delta)
+ for(std::size_t i=0;i<nbOfElems;i+=delta)
ret0+=pt[i] & 0x1FFF;
return ret+ret0;
}
* \ref MEDCouplingArrayBasicsCopyDeep.
* \return DataArrayInt * - a new instance of DataArrayInt.
*/
-DataArrayInt *DataArrayInt::deepCpy() const
+DataArrayInt *DataArrayInt::deepCpy() const throw(INTERP_KERNEL::Exception)
{
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::performCpy(bool dCpy) const throw(INTERP_KERNEL::Exception)
{
if(dCpy)
return deepCpy();
int nbOfTuples=other.getNumberOfTuples();
int nbOfComp=other.getNumberOfComponents();
allocIfNecessary(nbOfTuples,nbOfComp);
- int nbOfElems=nbOfTuples*nbOfComp;
+ std::size_t nbOfElems=(std::size_t)nbOfTuples*nbOfComp;
int *pt=getPointer();
const int *ptI=other.getConstPointer();
- for(int i=0;i<nbOfElems;i++)
+ for(std::size_t i=0;i<nbOfElems;i++)
pt[i]=ptI[i];
copyStringInfoFrom(other);
}
*
* \sa DataArrayInt::pack, DataArrayInt::pushBackSilent, DataArrayInt::pushBackValsSilent
*/
-void DataArrayInt::reserve(int nbOfElems) throw(INTERP_KERNEL::Exception)
+void DataArrayInt::reserve(std::size_t nbOfElems) throw(INTERP_KERNEL::Exception)
{
int nbCompo=getNumberOfComponents();
if(nbCompo==1)
* \param [in] nbOfCompo - number of components of data to allocate.
* \throw If \a nbOfTuple < 0 or \a nbOfCompo < 0.
*/
-void DataArrayInt::allocIfNecessary(int nbOfTuple, int nbOfCompo)
+void DataArrayInt::allocIfNecessary(int nbOfTuple, int nbOfCompo) throw(INTERP_KERNEL::Exception)
{
if(isAllocated())
{
if(nbOfTuple<0 || nbOfCompo<0)
throw INTERP_KERNEL::Exception("DataArrayInt::alloc : request for negative length of data !");
_info_on_compo.resize(nbOfCompo);
- _mem.alloc(nbOfCompo*nbOfTuple);
+ _mem.alloc(nbOfCompo*(std::size_t)nbOfTuple);
declareAsNew();
}
* DataArrayInt. This text is shown when a DataArrayInt is printed in Python.
* \return std::string - text describing \a this DataArrayInt.
*/
-std::string DataArrayInt::repr() const
+std::string DataArrayInt::repr() const throw(INTERP_KERNEL::Exception)
{
std::ostringstream ret;
reprStream(ret);
return ret.str();
}
-std::string DataArrayInt::reprZip() const
+std::string DataArrayInt::reprZip() const throw(INTERP_KERNEL::Exception)
{
std::ostringstream ret;
reprZipStream(ret);
ofs << std::endl << idt << "</DataArray>\n";
}
-void DataArrayInt::reprStream(std::ostream& stream) const
+void DataArrayInt::reprStream(std::ostream& stream) const throw(INTERP_KERNEL::Exception)
{
stream << "Name of int array : \"" << _name << "\"\n";
reprWithoutNameStream(stream);
}
-void DataArrayInt::reprZipStream(std::ostream& stream) const
+void DataArrayInt::reprZipStream(std::ostream& stream) const throw(INTERP_KERNEL::Exception)
{
stream << "Name of int array : \"" << _name << "\"\n";
reprZipWithoutNameStream(stream);
}
-void DataArrayInt::reprWithoutNameStream(std::ostream& stream) const
+void DataArrayInt::reprWithoutNameStream(std::ostream& stream) const throw(INTERP_KERNEL::Exception)
{
DataArray::reprWithoutNameStream(stream);
_mem.repr(getNumberOfComponents(),stream);
}
-void DataArrayInt::reprZipWithoutNameStream(std::ostream& stream) const
+void DataArrayInt::reprZipWithoutNameStream(std::ostream& stream) const throw(INTERP_KERNEL::Exception)
{
DataArray::reprWithoutNameStream(stream);
_mem.reprZip(getNumberOfComponents(),stream);
}
-void DataArrayInt::reprCppStream(const char *varName, std::ostream& stream) const
+void DataArrayInt::reprCppStream(const char *varName, std::ostream& stream) const throw(INTERP_KERNEL::Exception)
{
int nbTuples=getNumberOfTuples(),nbComp=getNumberOfComponents();
const int *data=getConstPointer();
stream << varName << "->setName(\"" << getName() << "\");" << std::endl;
}
+/*!
+ * Method that gives a quick overvien of \a this for python.
+ */
+void DataArrayInt::reprQuickOverview(std::ostream& stream) const throw(INTERP_KERNEL::Exception)
+{
+ static const std::size_t MAX_NB_OF_BYTE_IN_REPR=300;
+ stream << "DataArrayInt C++ instance at " << this << ". ";
+ if(isAllocated())
+ {
+ int nbOfCompo=(int)_info_on_compo.size();
+ if(nbOfCompo>=1)
+ {
+ int nbOfTuples=getNumberOfTuples();
+ stream << "Number of tuples : " << nbOfTuples << ". Number of components : " << nbOfCompo << "." << std::endl;
+ reprQuickOverviewData(stream,MAX_NB_OF_BYTE_IN_REPR);
+ }
+ else
+ stream << "Number of components : 0.";
+ }
+ else
+ stream << "*** No data allocated ****";
+}
+
+void DataArrayInt::reprQuickOverviewData(std::ostream& stream, std::size_t maxNbOfByteInRepr) const throw(INTERP_KERNEL::Exception)
+{
+ const int *data=begin();
+ int nbOfTuples=getNumberOfTuples();
+ int nbOfCompo=(int)_info_on_compo.size();
+ std::ostringstream oss2; oss2 << "[";
+ std::string oss2Str(oss2.str());
+ bool isFinished=true;
+ for(int i=0;i<nbOfTuples && isFinished;i++)
+ {
+ if(nbOfCompo>1)
+ {
+ oss2 << "(";
+ for(int j=0;j<nbOfCompo;j++,data++)
+ {
+ oss2 << *data;
+ if(j!=nbOfCompo-1) oss2 << ", ";
+ }
+ oss2 << ")";
+ }
+ else
+ oss2 << *data++;
+ if(i!=nbOfTuples-1) oss2 << ", ";
+ std::string oss3Str(oss2.str());
+ if(oss3Str.length()<maxNbOfByteInRepr)
+ oss2Str=oss3Str;
+ else
+ isFinished=false;
+ }
+ stream << oss2Str;
+ if(!isFinished)
+ stream << "... ";
+ stream << "]";
+}
+
/*!
* Modifies \a this one-dimensional array so that each value \a v = \a indArrBg[ \a v ],
* i.e. a current value is used as in index to get a new value from \a indArrBg.
* Computes distribution of values of \a this one-dimensional array between given value
* ranges (casts). This method is typically useful for entity number spliting by types,
* for example.
+ * \warning The values contained in \a arrBg should be sorted ascendently. No
+ * check of this is be done. If not, the result is not warranted.
* \param [in] arrBg - the array of ascending values defining the value ranges. The i-th
* value of \a arrBg (\a arrBg[ i ]) gives the lowest value of the i-th range,
* and the greatest value of the i-th range equals to \a arrBg[ i+1 ] - 1. \a
* \throw If \a this->getNumberOfComponents() != 1.
* \throw If \a arrEnd - arrBg < 2.
* \throw If any value of \a this is not less than \a arrEnd[-1].
- * \warning The values contained in \a arrBg should be sorted ascendently. No
- * check of this is be done. If not, the result is not warranted.
- *
*/
void DataArrayInt::splitByValueRange(const int *arrBg, const int *arrEnd,
DataArrayInt *& castArr, DataArrayInt *& rankInsideCast, DataArrayInt *& castsPresent) const throw(INTERP_KERNEL::Exception)
* The caller is to delete this result array using decrRef() as it is no more
* needed.
*
- * \ref cpp_mcdataarrayint_invertarrayo2n2n2o "Here is a C++ example".
- *
- * \ref py_mcdataarrayint_invertarrayo2n2n2o "Here is a Python example".
+ * \ref cpp_mcdataarrayint_invertarrayo2n2n2o "Here is a C++ example".<br>
+ * \ref py_mcdataarrayint_invertarrayo2n2n2o "Here is a Python example".
*/
DataArrayInt *DataArrayInt::invertArrayO2N2N2O(int newNbOfElem) const
{
return ret.retn();
}
-bool DataArrayInt::isEqualIfNotWhy(const DataArrayInt& other, std::string& reason) const
+/*!
+ * Equivalent to DataArrayInt::isEqual except that if false the reason of
+ * mismatch is given.
+ *
+ * \param [in] other the instance to be compared with \a this
+ * \param [out] reason In case of inequality returns the reason.
+ * \sa DataArrayInt::isEqual
+ */
+bool DataArrayInt::isEqualIfNotWhy(const DataArrayInt& other, std::string& reason) const throw(INTERP_KERNEL::Exception)
{
if(!areInfoEqualsIfNotWhy(other,reason))
return false;
* \param [in] other - an instance of DataArrayInt to compare with \a this one.
* \return bool - \a true if the two arrays are equal, \a false else.
*/
-bool DataArrayInt::isEqual(const DataArrayInt& other) const
+bool DataArrayInt::isEqual(const DataArrayInt& other) const throw(INTERP_KERNEL::Exception)
{
std::string tmp;
return isEqualIfNotWhy(other,tmp);
* \param [in] other - an instance of DataArrayInt to compare with \a this one.
* \return bool - \a true if the values of two arrays are equal, \a false else.
*/
-bool DataArrayInt::isEqualWithoutConsideringStr(const DataArrayInt& other) const
+bool DataArrayInt::isEqualWithoutConsideringStr(const DataArrayInt& other) const throw(INTERP_KERNEL::Exception)
{
std::string tmp;
return _mem.isEqual(other._mem,0,tmp);
if(getNumberOfComponents()!=1)
throw INTERP_KERNEL::Exception("DataArrayInt::sort : only supported with 'this' array with ONE component !");
_mem.sort(asc);
+ declareAsNew();
}
/*!
* Reverse the array values.
- * \throw If \a this->getNumberOfComponents() != 1.
+ * \throw If \a this->getNumberOfComponents() < 1.
* \throw If \a this is not allocated.
*/
void DataArrayInt::reverse() throw(INTERP_KERNEL::Exception)
{
checkAllocated();
- if(getNumberOfComponents()!=1)
- throw INTERP_KERNEL::Exception("DataArrayInt::reverse : only supported with 'this' array with ONE component !");
- _mem.reverse();
+ _mem.reverse(getNumberOfComponents());
+ declareAsNew();
}
/*!
* \param [in] nbOfTuple - new number of tuples in \a this.
* \param [in] nbOfCompo - new number of components in \a this.
*/
-void DataArrayInt::useArray(const int *array, bool ownership, DeallocType type, int nbOfTuple, int nbOfCompo)
+void DataArrayInt::useArray(const int *array, bool ownership, DeallocType type, int nbOfTuple, int nbOfCompo) throw(INTERP_KERNEL::Exception)
{
_info_on_compo.resize(nbOfCompo);
_mem.useArray(array,ownership,type,nbOfTuple*nbOfCompo);
declareAsNew();
}
-void DataArrayInt::useExternalArrayWithRWAccess(const int *array, int nbOfTuple, int nbOfCompo)
+void DataArrayInt::useExternalArrayWithRWAccess(const int *array, int nbOfTuple, int nbOfCompo) throw(INTERP_KERNEL::Exception)
{
_info_on_compo.resize(nbOfCompo);
_mem.useExternalArrayWithRWAccess(array,nbOfTuple*nbOfCompo);
* arranged in memory. If \a this array holds 2 components of 3 values:
* \f$ x_0,x_1,x_2,y_0,y_1,y_2 \f$, then the result array holds these values arranged
* as follows: \f$ x_0,y_0,x_1,y_1,x_2,y_2 \f$.
+ * \warning Do not confuse this method with transpose()!
* \return DataArrayInt * - the new instance of DataArrayInt that the caller
* is to delete using decrRef() as it is no more needed.
* \throw If \a this is not allocated.
- * \warning Do not confuse this method with transpose()!
*/
DataArrayInt *DataArrayInt::fromNoInterlace() const throw(INTERP_KERNEL::Exception)
{
* arranged in memory. If \a this array holds 2 components of 3 values:
* \f$ x_0,y_0,x_1,y_1,x_2,y_2 \f$, then the result array holds these values arranged
* as follows: \f$ x_0,x_1,x_2,y_0,y_1,y_2 \f$.
+ * \warning Do not confuse this method with transpose()!
* \return DataArrayInt * - the new instance of DataArrayInt that the caller
* is to delete using decrRef() as it is no more needed.
* \throw If \a this is not allocated.
- * \warning Do not confuse this method with transpose()!
*/
DataArrayInt *DataArrayInt::toNoInterlace() const throw(INTERP_KERNEL::Exception)
{
* \param [in] old2New - C array of length equal to \a this->getNumberOfTuples()
* giving a new position for i-th old value.
*/
-void DataArrayInt::renumberInPlace(const int *old2New)
+void DataArrayInt::renumberInPlace(const int *old2New) throw(INTERP_KERNEL::Exception)
{
checkAllocated();
int nbTuples=getNumberOfTuples();
* \return DataArrayInt * - the new instance of DataArrayInt that the caller
* is to delete using decrRef() as it is no more needed.
*/
-void DataArrayInt::renumberInPlaceR(const int *new2Old)
+void DataArrayInt::renumberInPlaceR(const int *new2Old) throw(INTERP_KERNEL::Exception)
{
checkAllocated();
int nbTuples=getNumberOfTuples();
* is to delete using decrRef() as it is no more needed.
* \throw If \a this is not allocated.
*/
-DataArrayInt *DataArrayInt::renumber(const int *old2New) const
+DataArrayInt *DataArrayInt::renumber(const int *old2New) const throw(INTERP_KERNEL::Exception)
{
checkAllocated();
int nbTuples=getNumberOfTuples();
int nbOfCompo=getNumberOfComponents();
- DataArrayInt *ret=DataArrayInt::New();
+ MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
ret->alloc(nbTuples,nbOfCompo);
ret->copyStringInfoFrom(*this);
const int *iptr=getConstPointer();
for(int i=0;i<nbTuples;i++)
std::copy(iptr+nbOfCompo*i,iptr+nbOfCompo*(i+1),optr+nbOfCompo*old2New[i]);
ret->copyStringInfoFrom(*this);
- return ret;
+ return ret.retn();
}
/*!
* \return DataArrayInt * - the new instance of DataArrayInt that the caller
* is to delete using decrRef() as it is no more needed.
*/
-DataArrayInt *DataArrayInt::renumberR(const int *new2Old) const
+DataArrayInt *DataArrayInt::renumberR(const int *new2Old) const throw(INTERP_KERNEL::Exception)
{
checkAllocated();
int nbTuples=getNumberOfTuples();
int nbOfCompo=getNumberOfComponents();
- DataArrayInt *ret=DataArrayInt::New();
+ MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
ret->alloc(nbTuples,nbOfCompo);
ret->copyStringInfoFrom(*this);
const int *iptr=getConstPointer();
for(int i=0;i<nbTuples;i++)
std::copy(iptr+nbOfCompo*new2Old[i],iptr+nbOfCompo*(new2Old[i]+1),optr+nbOfCompo*i);
ret->copyStringInfoFrom(*this);
- return ret;
+ return ret.retn();
}
/*!
* \return DataArrayInt * - the new instance of DataArrayInt that the caller
* is to delete using decrRef() as it is no more needed.
*/
-DataArrayInt *DataArrayInt::renumberAndReduce(const int *old2New, int newNbOfTuple) const
+DataArrayInt *DataArrayInt::renumberAndReduce(const int *old2New, int newNbOfTuple) const throw(INTERP_KERNEL::Exception)
{
checkAllocated();
int nbTuples=getNumberOfTuples();
int nbOfCompo=getNumberOfComponents();
- DataArrayInt *ret=DataArrayInt::New();
+ MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
ret->alloc(newNbOfTuple,nbOfCompo);
const int *iptr=getConstPointer();
int *optr=ret->getPointer();
std::copy(iptr+i*nbOfCompo,iptr+(i+1)*nbOfCompo,optr+w*nbOfCompo);
}
ret->copyStringInfoFrom(*this);
- return ret;
+ return ret.retn();
}
/*!
* \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.
- * \throw If (\a end2 < \a bg) or (\a step <= 0).
* \sa DataArrayInt::substr.
*/
DataArrayInt *DataArrayInt::selectByTupleId2(int bg, int end2, int step) const throw(INTERP_KERNEL::Exception)
checkAllocated();
MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
int nbComp=getNumberOfComponents();
- int newNbOfTuples=GetNumberOfItemGivenBES(bg,end2,step,"DataArrayInt::selectByTupleId2 : ");
+ int newNbOfTuples=GetNumberOfItemGivenBESRelative(bg,end2,step,"DataArrayInt::selectByTupleId2 : ");
ret->alloc(newNbOfTuples,nbComp);
int *pt=ret->getPointer();
const int *srcPt=getConstPointer()+bg*nbComp;
checkAllocated();
DataArrayDouble *ret=DataArrayDouble::New();
ret->alloc(getNumberOfTuples(),getNumberOfComponents());
- int nbOfVals=getNbOfElems();
+ std::size_t nbOfVals=getNbOfElems();
const int *src=getConstPointer();
double *dest=ret->getPointer();
std::copy(src,src+nbOfVals,dest);
else
trueEnd=nbt;
int nbComp=getNumberOfComponents();
- DataArrayInt *ret=DataArrayInt::New();
+ MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
ret->alloc(trueEnd-tupleIdBg,nbComp);
ret->copyStringInfoFrom(*this);
std::copy(getConstPointer()+tupleIdBg*nbComp,getConstPointer()+trueEnd*nbComp,ret->getPointer());
- return ret;
+ return ret.retn();
}
/*!
* Changes the number of components within \a this array so that its raw data **does
* not** change, instead splitting this data into tuples changes.
+ * \warning This method erases all (name and unit) component info set before!
* \param [in] newNbOfComp - number of components for \a this array to have.
* \throw If \a this is not allocated
* \throw If getNbOfElems() % \a newNbOfCompo != 0.
+ * \throw If \a newNbOfCompo is lower than 1.
+ * \throw If the rearrange method would lead to a number of tuples higher than 2147483647 (maximal capacity of int32 !).
* \warning This method erases all (name and unit) component info set before!
*/
void DataArrayInt::rearrange(int newNbOfCompo) throw(INTERP_KERNEL::Exception)
{
checkAllocated();
- int nbOfElems=getNbOfElems();
+ if(newNbOfCompo<1)
+ throw INTERP_KERNEL::Exception("DataArrayInt::rearrange : input newNbOfCompo must be > 0 !");
+ std::size_t nbOfElems=getNbOfElems();
if(nbOfElems%newNbOfCompo!=0)
throw INTERP_KERNEL::Exception("DataArrayInt::rearrange : nbOfElems%newNbOfCompo!=0 !");
+ if(nbOfElems/newNbOfCompo>(std::size_t)std::numeric_limits<int>::max())
+ throw INTERP_KERNEL::Exception("DataArrayInt::rearrange : the rearrangement leads to too high number of tuples (> 2147483647) !");
_info_on_compo.clear();
_info_on_compo.resize(newNbOfCompo);
declareAsNew();
* of tuples, and inversely its number of tuples to become equal to its number of
* components. So that its raw data **does not** change, instead splitting this
* data into tuples changes.
- * \throw If \a this is not allocated.
* \warning This method erases all (name and unit) component info set before!
* \warning Do not confuse this method with fromNoInterlace() and toNoInterlace()!
+ * \throw If \a this is not allocated.
* \sa rearrange()
*/
void DataArrayInt::transpose() throw(INTERP_KERNEL::Exception)
DataArrayInt *DataArrayInt::changeNbOfComponents(int newNbOfComp, int dftValue) const throw(INTERP_KERNEL::Exception)
{
checkAllocated();
- DataArrayInt *ret=DataArrayInt::New();
+ MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
ret->alloc(getNumberOfTuples(),newNbOfComp);
const int *oldc=getConstPointer();
int *nc=ret->getPointer();
for(int i=0;i<dim;i++)
ret->setInfoOnComponent(i,getInfoOnComponent(i).c_str());
ret->setName(getName().c_str());
- return ret;
+ return ret.retn();
}
/*!
void DataArrayInt::reAlloc(int nbOfTuples) throw(INTERP_KERNEL::Exception)
{
checkAllocated();
- _mem.reAlloc(getNumberOfComponents()*nbOfTuples);
+ _mem.reAlloc(getNumberOfComponents()*(std::size_t)nbOfTuples);
declareAsNew();
}
DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
bool assignTech=true;
- if(a->getNbOfElems()==newNbOfTuples*newNbOfComp)
+ if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
{
if(strictCompoCompare)
a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
int newNbOfTuples=(int)std::distance(bgTuples,endTuples);
int newNbOfComp=(int)std::distance(bgComp,endComp);
bool assignTech=true;
- if(a->getNbOfElems()==newNbOfTuples*newNbOfComp)
+ if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
{
if(strictCompoCompare)
a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
for(const int *z=bgComp;z!=endComp;z++,srcPt++)
{
- pt[(*w)*nbComp+(*z)]=*srcPt;
+ pt[(std::size_t)(*w)*nbComp+(*z)]=*srcPt;
}
}
}
DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
for(const int *z=bgComp;z!=endComp;z++,srcPt2++)
{
- pt[(*w)*nbComp+(*z)]=*srcPt2;
+ pt[(std::size_t)(*w)*nbComp+(*z)]=*srcPt2;
}
}
}
for(const int *z=bgComp;z!=endComp;z++)
{
DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
- pt[(*w)*nbComp+(*z)]=a;
+ pt[(std::size_t)(*w)*nbComp+(*z)]=a;
}
}
DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
int newNbOfTuples=(int)std::distance(bgTuples,endTuples);
bool assignTech=true;
- if(a->getNbOfElems()==newNbOfTuples*newNbOfComp)
+ if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
{
if(strictCompoCompare)
a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
for(int j=0;j<newNbOfComp;j++,srcPt++)
{
DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
- pt[(*w)*nbComp+j*stepComp]=*srcPt;
+ pt[(std::size_t)(*w)*nbComp+j*stepComp]=*srcPt;
}
}
else
for(int j=0;j<newNbOfComp;j++,srcPt2++)
{
DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
- pt[(*w)*nbComp+j*stepComp]=*srcPt2;
+ pt[(std::size_t)(*w)*nbComp+j*stepComp]=*srcPt2;
}
}
}
for(int j=0;j<newNbOfComp;j++)
{
DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
- pt[(*w)*nbComp+j*stepComp]=a;
+ pt[(std::size_t)(*w)*nbComp+j*stepComp]=a;
}
}
int nbOfTuples=getNumberOfTuples();
DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
bool assignTech=true;
- if(a->getNbOfElems()==newNbOfTuples*newNbOfComp)
+ if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
{
if(strictCompoCompare)
a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
std::ostringstream oss; oss << "DataArrayInt::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];
+ return _mem[tupleId*_info_on_compo.size()+compoId];
}
/*!
}
}
-DataArrayIntIterator *DataArrayInt::iterator()
+DataArrayIntIterator *DataArrayInt::iterator() throw(INTERP_KERNEL::Exception)
{
return new DataArrayIntIterator(this);
}
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
const int *cptr=getConstPointer();
- int nbOfVals=getNbOfElems();
+ std::size_t nbOfVals=getNbOfElems();
for(const int *work=cptr;work!=cptr+nbOfVals;)
{
work=std::search(work,cptr+nbOfVals,tupl.begin(),tupl.end());
if(nbOfCompo!=1)
throw INTERP_KERNEL::Exception("DataArrayInt::search : works only for DataArrayInt instance with one component !");
const int *cptr=getConstPointer();
- int nbOfVals=getNbOfElems();
+ std::size_t nbOfVals=getNbOfElems();
const int *loc=std::search(cptr,cptr+nbOfVals,vals.begin(),vals.end());
if(loc!=cptr+nbOfVals)
return std::distance(cptr,loc);
throw INTERP_KERNEL::Exception("DataArrayInt::Aggregate : Nb of components mismatch for array aggregation !");
nbt+=(*it)->getNumberOfTuples();
}
- DataArrayInt *ret=DataArrayInt::New();
+ MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
ret->alloc(nbt,nbOfComp);
int *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;
+ return ret.retn();
}
/*!
{
checkAllocated();
int *ptr=getPointer();
- int nbOfElems=getNbOfElems();
+ std::size_t nbOfElems=getNbOfElems();
std::transform(ptr,ptr+nbOfElems,ptr,std::ptr_fun<int,int>(std::abs));
declareAsNew();
}
{
checkAllocated();
int *ptr=getPointer();
- int nbOfElems=getNbOfElems();
- for(int i=0;i<nbOfElems;i++,ptr++)
+ std::size_t nbOfElems=getNbOfElems();
+ for(std::size_t i=0;i<nbOfElems;i++,ptr++)
*ptr=a*(*ptr)+b;
declareAsNew();
}
/*!
* Modify all elements of \a this array, so that
* an element _x_ becomes \f$ numerator / x \f$.
- * \param [in] numerator - the numerator used to modify array elements.
- * \throw If \a this is not allocated.
- * \throw If there is an element equal to 0 in \a this array.
* \warning If an exception is thrown because of presence of 0 element in \a this
* array, all elements processed before detection of the zero element remain
* modified.
+ * \param [in] numerator - the numerator used to modify array elements.
+ * \throw If \a this is not allocated.
+ * \throw If there is an element equal to 0 in \a this array.
*/
void DataArrayInt::applyInv(int numerator) throw(INTERP_KERNEL::Exception)
{
checkAllocated();
int *ptr=getPointer();
- int nbOfElems=getNbOfElems();
- for(int i=0;i<nbOfElems;i++,ptr++)
+ std::size_t nbOfElems=getNbOfElems();
+ for(std::size_t i=0;i<nbOfElems;i++,ptr++)
{
if(*ptr!=0)
{
throw INTERP_KERNEL::Exception("DataArrayInt::applyDivideBy : Trying to divide by 0 !");
checkAllocated();
int *ptr=getPointer();
- int nbOfElems=getNbOfElems();
+ std::size_t nbOfElems=getNbOfElems();
std::transform(ptr,ptr+nbOfElems,ptr,std::bind2nd(std::divides<int>(),val));
declareAsNew();
}
throw INTERP_KERNEL::Exception("DataArrayInt::applyDivideBy : Trying to operate modulus on value <= 0 !");
checkAllocated();
int *ptr=getPointer();
- int nbOfElems=getNbOfElems();
+ std::size_t nbOfElems=getNbOfElems();
std::transform(ptr,ptr+nbOfElems,ptr,std::bind2nd(std::modulus<int>(),val));
declareAsNew();
}
if(getNumberOfComponents()!=1)
throw INTERP_KERNEL::Exception("DataArrayInt::getIdsInRange : this must have exactly one component !");
const int *cptr=getConstPointer();
- std::vector<int> res;
+ MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(0,1);
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;
+ ret->pushBackSilent(i);
+ return ret.retn();
}
/*!
* Modify all elements of \a this array, so that
* an element _x_ becomes <em> val % x </em>.
- * \param [in] val - the divident used to modify array elements.
- * \throw If \a this is not allocated.
- * \throw If there is an element equal to or less than 0 in \a this array.
* \warning If an exception is thrown because of presence of an element <= 0 in \a this
* array, all elements processed before detection of the zero element remain
* modified.
+ * \param [in] val - the divident used to modify array elements.
+ * \throw If \a this is not allocated.
+ * \throw If there is an element equal to or less than 0 in \a this array.
*/
void DataArrayInt::applyRModulus(int val) throw(INTERP_KERNEL::Exception)
{
checkAllocated();
int *ptr=getPointer();
- int nbOfElems=getNbOfElems();
- for(int i=0;i<nbOfElems;i++,ptr++)
+ std::size_t nbOfElems=getNbOfElems();
+ for(std::size_t i=0;i<nbOfElems;i++,ptr++)
{
if(*ptr>0)
{
declareAsNew();
}
+/*!
+ * Modify all elements of \a this array, so that
+ * an element _x_ becomes <em> val ^ x </em>.
+ * \param [in] val - the value used to apply pow on all array elements.
+ * \throw If \a this is not allocated.
+ * \throw If \a val < 0.
+ */
+void DataArrayInt::applyPow(int val) throw(INTERP_KERNEL::Exception)
+{
+ checkAllocated();
+ if(val<0)
+ throw INTERP_KERNEL::Exception("DataArrayInt::applyPow : input pow in < 0 !");
+ int *ptr=getPointer();
+ std::size_t nbOfElems=getNbOfElems();
+ if(val==0)
+ {
+ std::fill(ptr,ptr+nbOfElems,1.);
+ return ;
+ }
+ for(std::size_t i=0;i<nbOfElems;i++,ptr++)
+ {
+ int tmp=1;
+ for(int j=0;j<val;j++)
+ tmp*=*ptr;
+ *ptr=tmp;
+ }
+ declareAsNew();
+}
+
+/*!
+ * Modify all elements of \a this array, so that
+ * an element _x_ becomes \f$ val ^ x \f$.
+ * \param [in] val - the value used to apply pow on all array elements.
+ * \throw If \a this is not allocated.
+ * \throw If there is an element < 0 in \a this array.
+ * \warning If an exception is thrown because of presence of 0 element in \a this
+ * array, all elements processed before detection of the zero element remain
+ * modified.
+ */
+void DataArrayInt::applyRPow(int val) throw(INTERP_KERNEL::Exception)
+{
+ checkAllocated();
+ int *ptr=getPointer();
+ std::size_t nbOfElems=getNbOfElems();
+ for(std::size_t i=0;i<nbOfElems;i++,ptr++)
+ {
+ if(*ptr>=0)
+ {
+ int tmp=1;
+ for(int j=0;j<*ptr;j++)
+ tmp*=val;
+ *ptr=tmp;
+ }
+ else
+ {
+ std::ostringstream oss; oss << "DataArrayInt::applyRPow : presence of negative value in tuple #" << i/getNumberOfComponents() << " component #" << i%getNumberOfComponents();
+ oss << " !";
+ throw INTERP_KERNEL::Exception(oss.str().c_str());
+ }
+ }
+ declareAsNew();
+}
+
/*!
* Returns a new DataArrayInt by aggregating two given arrays, so that (1) the number
* of components in the result array is a sum of the number of components of given arrays
for(std::vector<const DataArrayInt *>::const_iterator iter=groups2.begin();iter!=groups2.end();iter++)
{
const int *ptr=(*iter)->getConstPointer();
- int nbOfElem=(*iter)->getNbOfElems();
+ std::size_t nbOfElem=(*iter)->getNbOfElems();
int sfid=fid;
for(int j=0;j<sfid;j++)
{
bool found=false;
- for(int i=0;i<nbOfElem;i++)
+ for(std::size_t i=0;i<nbOfElem;i++)
{
if(ptr[i]>=0 && ptr[i]<newNb)
{
{
std::set<int> tmp;
const int *ptr=(*iter)->getConstPointer();
- int nbOfElem=(*iter)->getNbOfElems();
+ std::size_t nbOfElem=(*iter)->getNbOfElems();
for(const int *p=ptr;p!=ptr+nbOfElem;p++)
tmp.insert(retPtr[*p]);
fidsOfGroups[grId].insert(fidsOfGroups[grId].end(),tmp.begin(),tmp.end());
declareAsNew();
}
+/*!
+ * 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
+ * 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 [in] listOfIds a list of ids that has to be sorted ascendingly.
+ * \param [out] rangeIdsFetched the range ids fetched
+ * \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
+ *
+ * \b Example: <br>
+ * - \a this : [0,3,7,9,15,18]
+ * - \a listOfIds contains [0,1,2,3,7,8,15,16,17]
+ * - \a rangeIdsFetched result array: [0,2,4]
+ * - \a idsInInputListThatFetch result array: [0,1,2,7,8,15,16,17]
+ * 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 throw(INTERP_KERNEL::Exception)
+{
+ if(!listOfIds)
+ throw INTERP_KERNEL::Exception("DataArrayInt::searchRangesInListOfIds : 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 !");
+ 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);
+ const int *tupEnd(listOfIds->end()),*offBg(begin()),*offEnd(end()-1);
+ const int *tupPtr(listOfIds->begin()),*offPtr(offBg);
+ while(tupPtr!=tupEnd && offPtr!=offEnd)
+ {
+ if(*tupPtr==*offPtr)
+ {
+ int i=offPtr[0];
+ while(i<offPtr[1] && *tupPtr==i && tupPtr!=tupEnd) { i++; tupPtr++; }
+ if(i==offPtr[1])
+ {
+ ret0->pushBackSilent((int)std::distance(offBg,offPtr));
+ ret1->pushBackValsSilent(tupPtr-(offPtr[1]-offPtr[0]),tupPtr);
+ offPtr++;
+ }
+ }
+ else
+ { if(*tupPtr<*offPtr) tupPtr++; else offPtr++; }
+ }
+ rangeIdsFetched=ret0.retn();
+ idsInInputListThatFetch=ret1.retn();
+}
/*!
* Returns a new DataArrayInt whose contents is computed from that of \a this and \a
*
* Info on components is copied either from the first array (in the first case) or from
* the array with maximal number of elements (getNbOfElems()).
+ * \warning No check of division by zero is performed!
* \param [in] a1 - a numerator array.
* \param [in] a2 - a denominator array.
* \return DataArrayInt * - the new instance of DataArrayInt.
* \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
* \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
* none of them has number of tuples or components equal to 1.
- * \warning No check of division by zero is performed!
*/
DataArrayInt *DataArrayInt::Divide(const DataArrayInt *a1, const DataArrayInt *a2) throw(INTERP_KERNEL::Exception)
{
* 3. The arrays have same number of components and \a other array has one tuple. Then
* _a_ [ i, j ] /= _a2_ [ 0, j ].
*
+ * \warning No check of division by zero is performed!
* \param [in] other - an array to divide \a this one by.
* \throw If \a other is NULL.
* \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
* \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
* \a other has number of both tuples and components not equal to 1.
- * \warning No check of division by zero is performed!
*/
void DataArrayInt::divideEqual(const DataArrayInt *other) throw(INTERP_KERNEL::Exception)
{
*
* Info on components is copied either from the first array (in the first case) or from
* the array with maximal number of elements (getNbOfElems()).
+ * \warning No check of division by zero is performed!
* \param [in] a1 - a dividend array.
* \param [in] a2 - a divisor array.
* \return DataArrayInt * - the new instance of DataArrayInt.
* \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
* \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
* none of them has number of tuples or components equal to 1.
- * \warning No check of division by zero is performed!
*/
DataArrayInt *DataArrayInt::Modulus(const DataArrayInt *a1, const DataArrayInt *a2) throw(INTERP_KERNEL::Exception)
{
* 3. The arrays have same number of components and \a other array has one tuple. Then
* _a_ [ i, j ] %= _a2_ [ 0, j ].
*
+ * \warning No check of division by zero is performed!
* \param [in] other - a divisor array.
* \throw If \a other is NULL.
* \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
* \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
* \a other has number of both tuples and components not equal to 1.
- * \warning No check of division by zero is performed!
*/
void DataArrayInt::modulusEqual(const DataArrayInt *other) throw(INTERP_KERNEL::Exception)
{
declareAsNew();
}
+/*!
+ * Returns a new DataArrayInt that is the result of pow of two given arrays. There are 3
+ * valid cases.
+ *
+ * \param [in] a1 - an array to pow up.
+ * \param [in] a2 - another array to sum up.
+ * \return DataArrayInt * - the new instance of DataArrayInt.
+ * The caller is to delete this result array using decrRef() as it is no more
+ * needed.
+ * \throw If either \a a1 or \a a2 is NULL.
+ * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
+ * \throw If \a a1->getNumberOfComponents() != 1 or \a a2->getNumberOfComponents() != 1.
+ * \throw If there is a negative value in \a a2.
+ */
+DataArrayInt *DataArrayInt::Pow(const DataArrayInt *a1, const DataArrayInt *a2) throw(INTERP_KERNEL::Exception)
+{
+ if(!a1 || !a2)
+ throw INTERP_KERNEL::Exception("DataArrayInt::Pow : at least one of input instances is null !");
+ int nbOfTuple=a1->getNumberOfTuples();
+ int nbOfTuple2=a2->getNumberOfTuples();
+ int nbOfComp=a1->getNumberOfComponents();
+ int nbOfComp2=a2->getNumberOfComponents();
+ if(nbOfTuple!=nbOfTuple2)
+ 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);
+ const int *ptr1(a1->begin()),*ptr2(a2->begin());
+ int *ptr=ret->getPointer();
+ for(int i=0;i<nbOfTuple;i++,ptr1++,ptr2++,ptr++)
+ {
+ if(*ptr2>=0)
+ {
+ int tmp=1;
+ for(int j=0;j<*ptr2;j++)
+ tmp*=*ptr1;
+ *ptr=tmp;
+ }
+ else
+ {
+ std::ostringstream oss; oss << "DataArrayInt::Pow : on tuple #" << i << " of a2 value is < 0 (" << *ptr2 << ") !";
+ throw INTERP_KERNEL::Exception(oss.str().c_str());
+ }
+ }
+ return ret.retn();
+}
+
+/*!
+ * Apply pow on values of another DataArrayInt to values of \a this one.
+ *
+ * \param [in] other - an array to pow to \a this one.
+ * \throw If \a other is NULL.
+ * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples()
+ * \throw If \a this->getNumberOfComponents() != 1 or \a other->getNumberOfComponents() != 1
+ * \throw If there is a negative value in \a other.
+ */
+void DataArrayInt::powEqual(const DataArrayInt *other) throw(INTERP_KERNEL::Exception)
+{
+ if(!other)
+ throw INTERP_KERNEL::Exception("DataArrayInt::powEqual : input instance is null !");
+ int nbOfTuple=getNumberOfTuples();
+ int nbOfTuple2=other->getNumberOfTuples();
+ int nbOfComp=getNumberOfComponents();
+ int nbOfComp2=other->getNumberOfComponents();
+ if(nbOfTuple!=nbOfTuple2)
+ throw INTERP_KERNEL::Exception("DataArrayInt::powEqual : number of tuples mismatches !");
+ if(nbOfComp!=1 || nbOfComp2!=1)
+ throw INTERP_KERNEL::Exception("DataArrayInt::powEqual : number of components of both arrays must be equal to 1 !");
+ int *ptr=getPointer();
+ const int *ptrc=other->begin();
+ for(int i=0;i<nbOfTuple;i++,ptrc++,ptr++)
+ {
+ if(*ptrc>=0)
+ {
+ int tmp=1;
+ for(int j=0;j<*ptrc;j++)
+ tmp*=*ptr;
+ *ptr=tmp;
+ }
+ else
+ {
+ std::ostringstream oss; oss << "DataArrayInt::powEqual : on tuple #" << i << " of other value is < 0 (" << *ptrc << ") !";
+ throw INTERP_KERNEL::Exception(oss.str().c_str());
+ }
+ }
+ declareAsNew();
+}
+
/*!
* Returns a C array which is a renumbering map in "Old to New" mode for the input array.
* This map, if applied to \a start array, would make it sorted. For example, if
_da->decrRef();
}
-DataArrayIntTuple *DataArrayIntIterator::nextt()
+DataArrayIntTuple *DataArrayIntIterator::nextt() throw(INTERP_KERNEL::Exception)
{
if(_tuple_id<_nb_tuple)
{
{
}
-std::string DataArrayIntTuple::repr() const
+std::string DataArrayIntTuple::repr() const throw(INTERP_KERNEL::Exception)
{
std::ostringstream oss; oss << "(";
for(int i=0;i<_nb_of_compo-1;i++)
