-// Copyright (C) 2007-2013 CEA/DEN, EDF R&D
+// Copyright (C) 2007-2014 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
// License as published by the Free Software Foundation; either
-// version 2.1 of the License.
+// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
#include "MEDCouplingMemArray.txx"
#include "MEDCouplingAutoRefCountObjectPtr.hxx"
+#include "BBTree.txx"
#include "GenMathFormulae.hxx"
+#include "InterpKernelAutoPtr.hxx"
#include "InterpKernelExprParser.hxx"
#include <set>
}
}
-std::size_t DataArray::getHeapMemorySize() const
+std::size_t DataArray::getHeapMemorySizeWithoutChildren() const
{
std::size_t sz1=_name.capacity();
std::size_t sz2=_info_on_compo.capacity();
return sz1+sz2+sz3;
}
+std::vector<const BigMemoryObject *> DataArray::getDirectChildrenWithNull() const
+{
+ return std::vector<const BigMemoryObject *>();
+}
+
/*!
* Sets the attribute \a _name of \a this array.
* See \ref MEDCouplingArrayBasicsName "DataArrays infos" for more information.
* \param [in] name - new array name
*/
-void DataArray::setName(const char *name)
+void DataArray::setName(const std::string& name)
{
_name=name;
}
* \param [in] other - another instance of DataArray to copy the textual data from.
* \throw If number of components of \a this array differs from that of the \a other.
*/
-void DataArray::copyStringInfoFrom(const DataArray& other) throw(INTERP_KERNEL::Exception)
+void DataArray::copyStringInfoFrom(const DataArray& other)
{
if(_info_on_compo.size()!=other._info_on_compo.size())
throw INTERP_KERNEL::Exception("Size of arrays mismatches on copyStringInfoFrom !");
_info_on_compo=other._info_on_compo;
}
-void DataArray::copyPartOfStringInfoFrom(const DataArray& other, const std::vector<int>& compoIds) throw(INTERP_KERNEL::Exception)
+void DataArray::copyPartOfStringInfoFrom(const DataArray& other, const std::vector<int>& compoIds)
{
int nbOfCompoOth=other.getNumberOfComponents();
std::size_t newNbOfCompo=compoIds.size();
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
for(std::size_t i=0;i<newNbOfCompo;i++)
- setInfoOnComponent((int)i,other.getInfoOnComponent(compoIds[i]).c_str());
+ setInfoOnComponent((int)i,other.getInfoOnComponent(compoIds[i]));
}
-void DataArray::copyPartOfStringInfoFrom2(const std::vector<int>& compoIds, const DataArray& other) throw(INTERP_KERNEL::Exception)
+void DataArray::copyPartOfStringInfoFrom2(const std::vector<int>& compoIds, const DataArray& other)
{
int nbOfCompo=getNumberOfComponents();
std::size_t partOfCompoToSet=compoIds.size();
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
for(std::size_t i=0;i<partOfCompoToSet;i++)
- setInfoOnComponent(compoIds[i],other.getInfoOnComponent((int)i).c_str());
+ setInfoOnComponent(compoIds[i],other.getInfoOnComponent((int)i));
}
-bool DataArray::areInfoEqualsIfNotWhy(const DataArray& other, std::string& reason) const throw(INTERP_KERNEL::Exception)
+bool DataArray::areInfoEqualsIfNotWhy(const DataArray& other, std::string& reason) const
{
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 throw(INTERP_KERNEL::Exception)
+bool DataArray::areInfoEquals(const DataArray& other) const
{
std::string tmp;
return areInfoEqualsIfNotWhy(other,tmp);
}
-void DataArray::reprWithoutNameStream(std::ostream& stream) const throw(INTERP_KERNEL::Exception)
+void DataArray::reprWithoutNameStream(std::ostream& stream) const
{
stream << "Number of components : "<< getNumberOfComponents() << "\n";
stream << "Info of these components : ";
stream << "\n";
}
-std::string DataArray::cppRepr(const char *varName) const throw(INTERP_KERNEL::Exception)
+std::string DataArray::cppRepr(const std::string& varName) const
{
std::ostringstream ret;
reprCppStream(varName,ret);
* \param [in] info - a vector of strings.
* \throw If size of \a info differs from the number of components of \a this.
*/
-void DataArray::setInfoOnComponents(const std::vector<std::string>& info) throw(INTERP_KERNEL::Exception)
+void DataArray::setInfoOnComponents(const std::vector<std::string>& info)
{
if(getNumberOfComponents()!=(int)info.size())
{
*
* \sa DataArrayDouble::setPartOfValues3, DataArrayInt::setPartOfValues3, DataArrayChar::setPartOfValues3.
*/
-void DataArray::setPartOfValuesBase3(const DataArray *aBase, const int *bgTuples, const int *endTuples, int bgComp, int endComp, int stepComp, bool strictCompoCompare) throw(INTERP_KERNEL::Exception)
+void DataArray::setPartOfValuesBase3(const DataArray *aBase, const int *bgTuples, const int *endTuples, int bgComp, int endComp, int stepComp, bool strictCompoCompare)
{
if(!aBase)
throw INTERP_KERNEL::Exception("DataArray::setPartOfValuesBase3 : input aBase object is NULL !");
throw INTERP_KERNEL::Exception("DataArray::setPartOfValuesBase3 : input aBase object and this do not have the same type !");
}
-std::vector<std::string> DataArray::getVarsOnComponent() const throw(INTERP_KERNEL::Exception)
+std::vector<std::string> DataArray::getVarsOnComponent() const
{
int nbOfCompo=(int)_info_on_compo.size();
std::vector<std::string> ret(nbOfCompo);
return ret;
}
-std::vector<std::string> DataArray::getUnitsOnComponent() const throw(INTERP_KERNEL::Exception)
+std::vector<std::string> DataArray::getUnitsOnComponent() const
{
int nbOfCompo=(int)_info_on_compo.size();
std::vector<std::string> ret(nbOfCompo);
* \return std::string - a string containing the information on \a i-th component.
* \throw If \a i is not a valid component index.
*/
-std::string DataArray::getInfoOnComponent(int i) const throw(INTERP_KERNEL::Exception)
+std::string DataArray::getInfoOnComponent(int i) const
{
if(i<(int)_info_on_compo.size() && i>=0)
return _info_on_compo[i];
* \return std::string - a string containing the var information, or the full info.
* \throw If \a i is not a valid component index.
*/
-std::string DataArray::getVarOnComponent(int i) const throw(INTERP_KERNEL::Exception)
+std::string DataArray::getVarOnComponent(int i) const
{
if(i<(int)_info_on_compo.size() && i>=0)
{
* \return std::string - a string containing the unit information, if any, or "".
* \throw If \a i is not a valid component index.
*/
-std::string DataArray::getUnitOnComponent(int i) const throw(INTERP_KERNEL::Exception)
+std::string DataArray::getUnitOnComponent(int i) const
{
if(i<(int)_info_on_compo.size() && i>=0)
{
* \param [in] info - the full component information.
* \return std::string - a string containing only var information, or the \a info.
*/
-std::string DataArray::GetVarNameFromInfo(const std::string& info) throw(INTERP_KERNEL::Exception)
+std::string DataArray::GetVarNameFromInfo(const std::string& info)
{
std::size_t p1=info.find_last_of('[');
std::size_t p2=info.find_last_of(']');
* \param [in] info - the full component information.
* \return std::string - a string containing only unit information, if any, or "".
*/
-std::string DataArray::GetUnitFromInfo(const std::string& info) throw(INTERP_KERNEL::Exception)
+std::string DataArray::GetUnitFromInfo(const std::string& info)
{
std::size_t p1=info.find_last_of('[');
std::size_t p2=info.find_last_of(']');
return info.substr(p1+1,p2-p1-1);
}
+/*!
+ * This method put in info format the result of the merge of \a var and \a unit.
+ * The standard format for that is "var [unit]".
+ * Inversely you can retrieve the var part or the unit part of info string using resp. GetVarNameFromInfo and GetUnitFromInfo.
+ */
+std::string DataArray::BuildInfoFromVarAndUnit(const std::string& var, const std::string& unit)
+{
+ std::ostringstream oss;
+ oss << var << " [" << unit << "]";
+ return oss.str();
+}
+
/*!
* Returns a new DataArray by concatenating all given arrays, so that (1) the number
* of tuples in the result array is a sum of the number of tuples of given arrays and (2)
* \throw If all not null arrays in \a arrs have not the same type.
* \throw If getNumberOfComponents() of arrays within \a arrs.
*/
-DataArray *DataArray::Aggregate(const std::vector<const DataArray *>& arrs) throw(INTERP_KERNEL::Exception)
+DataArray *DataArray::Aggregate(const std::vector<const DataArray *>& arrs)
{
std::vector<const DataArray *> arr2;
for(std::vector<const DataArray *>::const_iterator it=arrs.begin();it!=arrs.end();it++)
* \param [in] info - the string containing the information.
* \throw If \a i is not a valid component index.
*/
-void DataArray::setInfoOnComponent(int i, const char *info) throw(INTERP_KERNEL::Exception)
+void DataArray::setInfoOnComponent(int i, const std::string& info)
{
if(i<(int)_info_on_compo.size() && i>=0)
_info_on_compo[i]=info;
* \param [in] info - a vector of component infos.
* \throw If \a this->getNumberOfComponents() != \a info.size() && \a this->isAllocated()
*/
-void DataArray::setInfoAndChangeNbOfCompo(const std::vector<std::string>& info) throw(INTERP_KERNEL::Exception)
+void DataArray::setInfoAndChangeNbOfCompo(const std::vector<std::string>& info)
{
if(getNumberOfComponents()!=(int)info.size())
{
_info_on_compo=info;
}
-void DataArray::checkNbOfTuples(int nbOfTuples, const char *msg) const throw(INTERP_KERNEL::Exception)
+void DataArray::checkNbOfTuples(int nbOfTuples, const std::string& msg) const
{
if(getNumberOfTuples()!=nbOfTuples)
{
}
}
-void DataArray::checkNbOfComps(int nbOfCompo, const char *msg) const throw(INTERP_KERNEL::Exception)
+void DataArray::checkNbOfComps(int nbOfCompo, const std::string& msg) const
{
if(getNumberOfComponents()!=nbOfCompo)
{
}
}
-void DataArray::checkNbOfElems(std::size_t nbOfElems, const char *msg) const throw(INTERP_KERNEL::Exception)
+void DataArray::checkNbOfElems(std::size_t nbOfElems, const std::string& msg) const
{
if(getNbOfElems()!=nbOfElems)
{
}
}
-void DataArray::checkNbOfTuplesAndComp(const DataArray& other, const char *msg) const throw(INTERP_KERNEL::Exception)
+void DataArray::checkNbOfTuplesAndComp(const DataArray& other, const std::string& msg) const
{
- if(getNumberOfTuples()!=other.getNumberOfTuples())
+ if(getNumberOfTuples()!=other.getNumberOfTuples())
{
std::ostringstream oss; oss << msg << " : mismatch number of tuples : expected " << other.getNumberOfTuples() << " having " << getNumberOfTuples() << " !";
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
}
-void DataArray::checkNbOfTuplesAndComp(int nbOfTuples, int nbOfCompo, const char *msg) const throw(INTERP_KERNEL::Exception)
+void DataArray::checkNbOfTuplesAndComp(int nbOfTuples, int nbOfCompo, const std::string& msg) const
{
checkNbOfTuples(nbOfTuples,msg);
checkNbOfComps(nbOfCompo,msg);
/*!
* Simply this method checks that \b value is in [0,\b ref).
*/
-void DataArray::CheckValueInRange(int ref, int value, const char *msg) throw(INTERP_KERNEL::Exception)
+void DataArray::CheckValueInRange(int ref, int value, const std::string& msg)
{
if(value<0 || value>=ref)
{
* This method checks that [\b start, \b end) is compliant with ref length \b value.
* typicaly start in [0,\b value) and end in [0,\b value). If value==start and start==end, it is supported.
*/
-void DataArray::CheckValueInRangeEx(int value, int start, int end, const char *msg) throw(INTERP_KERNEL::Exception)
+void DataArray::CheckValueInRangeEx(int value, int start, int end, const std::string& msg)
{
if(start<0 || start>=value)
{
}
}
-void DataArray::CheckClosingParInRange(int ref, int value, const char *msg) throw(INTERP_KERNEL::Exception)
+void DataArray::CheckClosingParInRange(int ref, int value, const std::string& msg)
{
if(value<0 || value>ref)
{
* \throw If \a nbOfSlices not > 0
* \throw If \a sliceId not in [0,nbOfSlices)
*/
-void DataArray::GetSlice(int start, int stop, int step, int sliceId, int nbOfSlices, int& startSlice, int& stopSlice) throw(INTERP_KERNEL::Exception)
+void DataArray::GetSlice(int start, int stop, int step, int sliceId, int nbOfSlices, int& startSlice, int& stopSlice)
{
if(nbOfSlices<=0)
{
stopSlice=stop;
}
-int DataArray::GetNumberOfItemGivenBES(int begin, int end, int step, const char *msg) throw(INTERP_KERNEL::Exception)
+int DataArray::GetNumberOfItemGivenBES(int begin, int end, int step, const std::string& msg)
{
if(end<begin)
{
return (end-1-begin)/step+1;
}
-int DataArray::GetNumberOfItemGivenBESRelative(int begin, int end, int step, const char *msg) throw(INTERP_KERNEL::Exception)
+int DataArray::GetNumberOfItemGivenBESRelative(int begin, int end, int step, const std::string& msg)
{
if(step==0)
throw INTERP_KERNEL::Exception("DataArray::GetNumberOfItemGivenBES : step=0 is not allowed !");
return 0;
}
-int DataArray::GetPosOfItemGivenBESRelativeNoThrow(int value, int begin, int end, int step) throw(INTERP_KERNEL::Exception)
+int DataArray::GetPosOfItemGivenBESRelativeNoThrow(int value, int begin, int end, int step)
{
if(step!=0)
{
* 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 throw(INTERP_KERNEL::Exception)
+bool DataArrayDouble::isAllocated() const
{
return getConstPointer()!=0;
}
* Checks if raw data is allocated and throws an exception if it is not the case.
* \throw If the raw data is not allocated.
*/
-void DataArrayDouble::checkAllocated() const throw(INTERP_KERNEL::Exception)
+void DataArrayDouble::checkAllocated() const
{
if(!isAllocated())
throw INTERP_KERNEL::Exception("DataArrayDouble::checkAllocated : Array is defined but not allocated ! Call alloc or setValues method first !");
* After call of this method, DataArrayDouble::isAllocated will return false.
* If \a this is already not allocated, \a this is let unchanged.
*/
-void DataArrayDouble::desallocate() throw(INTERP_KERNEL::Exception)
+void DataArrayDouble::desallocate()
{
_mem.destroy();
}
-std::size_t DataArrayDouble::getHeapMemorySize() const
+std::size_t DataArrayDouble::getHeapMemorySizeWithoutChildren() const
{
- std::size_t sz=_mem.getNbOfElemAllocated();
+ std::size_t sz(_mem.getNbOfElemAllocated());
sz*=sizeof(double);
- return DataArray::getHeapMemorySize()+sz;
+ return DataArray::getHeapMemorySizeWithoutChildren()+sz;
}
/*!
* \return double - the sole value stored in \a this array.
* \throw If at least one of conditions stated above is not fulfilled.
*/
-double DataArrayDouble::doubleValue() const throw(INTERP_KERNEL::Exception)
+double DataArrayDouble::doubleValue() const
{
if(isAllocated())
{
* \return bool - \a true if getNumberOfTuples() == 0, \a false else.
* \throw If \a this is not allocated.
*/
-bool DataArrayDouble::empty() const throw(INTERP_KERNEL::Exception)
+bool DataArrayDouble::empty() const
{
checkAllocated();
return getNumberOfTuples()==0;
* \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 throw(INTERP_KERNEL::Exception)
+DataArrayDouble *DataArrayDouble::deepCpy() 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 throw(INTERP_KERNEL::Exception)
+DataArrayDouble *DataArrayDouble::performCpy(bool dCpy) const
{
if(dCpy)
return deepCpy();
* \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) throw(INTERP_KERNEL::Exception)
+void DataArrayDouble::cpyFrom(const DataArrayDouble& other)
{
other.checkAllocated();
int nbOfTuples=other.getNumberOfTuples();
*
* \sa DataArrayDouble::pack, DataArrayDouble::pushBackSilent, DataArrayDouble::pushBackValsSilent
*/
-void DataArrayDouble::reserve(std::size_t nbOfElems) throw(INTERP_KERNEL::Exception)
+void DataArrayDouble::reserve(std::size_t nbOfElems)
{
int nbCompo=getNumberOfComponents();
if(nbCompo==1)
* \throw If \a this has already been allocated with number of components different from one.
* \sa DataArrayDouble::pushBackValsSilent
*/
-void DataArrayDouble::pushBackSilent(double val) throw(INTERP_KERNEL::Exception)
+void DataArrayDouble::pushBackSilent(double val)
{
int nbCompo=getNumberOfComponents();
if(nbCompo==1)
* \throw If \a this has already been allocated with number of components different from one.
* \sa DataArrayDouble::pushBackSilent
*/
-void DataArrayDouble::pushBackValsSilent(const double *valsBg, const double *valsEnd) throw(INTERP_KERNEL::Exception)
+void DataArrayDouble::pushBackValsSilent(const double *valsBg, const double *valsEnd)
{
int nbCompo=getNumberOfComponents();
if(nbCompo==1)
* \throw If \a this is already empty.
* \throw If \a this has number of components different from one.
*/
-double DataArrayDouble::popBackSilent() throw(INTERP_KERNEL::Exception)
+double DataArrayDouble::popBackSilent()
{
if(getNumberOfComponents()==1)
return _mem.popBack();
/*!
* This method \b do \b not modify content of \a this. It only modify its memory footprint if the allocated memory is to high regarding real data to store.
*
- * \sa DataArrayDouble::getHeapMemorySize, DataArrayDouble::reserve
+ * \sa DataArrayDouble::getHeapMemorySizeWithoutChildren, DataArrayDouble::reserve
*/
-void DataArrayDouble::pack() const throw(INTERP_KERNEL::Exception)
+void DataArrayDouble::pack() const
{
_mem.pack();
}
* \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) throw(INTERP_KERNEL::Exception)
+void DataArrayDouble::allocIfNecessary(int nbOfTuple, int nbOfCompo)
{
if(isAllocated())
{
* \param [in] nbOfCompo - number of components of data to allocate.
* \throw If \a nbOfTuple < 0 or \a nbOfCompo < 0.
*/
-void DataArrayDouble::alloc(int nbOfTuple, int nbOfCompo) throw(INTERP_KERNEL::Exception)
+void DataArrayDouble::alloc(int nbOfTuple, int nbOfCompo)
{
if(nbOfTuple<0 || nbOfCompo<0)
throw INTERP_KERNEL::Exception("DataArrayDouble::alloc : request for negative length of data !");
* \ref MEDCouplingArrayFill.
* \throw If \a this is not allocated.
*/
-void DataArrayDouble::fillWithZero() throw(INTERP_KERNEL::Exception)
+void DataArrayDouble::fillWithZero()
{
checkAllocated();
_mem.fillWithValue(0.);
* \param [in] val - the value to fill with.
* \throw If \a this is not allocated.
*/
-void DataArrayDouble::fillWithValue(double val) throw(INTERP_KERNEL::Exception)
+void DataArrayDouble::fillWithValue(double val)
{
checkAllocated();
_mem.fillWithValue(val);
* \throw If \a this->getNumberOfComponents() != 1
* \throw If \a this is not allocated.
*/
-void DataArrayDouble::iota(double init) throw(INTERP_KERNEL::Exception)
+void DataArrayDouble::iota(double init)
{
checkAllocated();
if(getNumberOfComponents()!=1)
* \throw If \a this->getNumberOfComponents() != 1
* \throw If \a this is not allocated.
*/
-bool DataArrayDouble::isUniform(double val, double eps) const throw(INTERP_KERNEL::Exception)
+bool DataArrayDouble::isUniform(double val, double eps) const
{
checkAllocated();
if(getNumberOfComponents()!=1)
* \throw If \a this is not allocated.
* \throw If \a this->getNumberOfComponents() != 1.
*/
-void DataArrayDouble::sort(bool asc) throw(INTERP_KERNEL::Exception)
+void DataArrayDouble::sort(bool asc)
{
checkAllocated();
if(getNumberOfComponents()!=1)
* \throw If \a this->getNumberOfComponents() < 1.
* \throw If \a this is not allocated.
*/
-void DataArrayDouble::reverse() throw(INTERP_KERNEL::Exception)
+void DataArrayDouble::reverse()
{
checkAllocated();
_mem.reverse(getNumberOfComponents());
* \throw If \a this->getNumberOfComponents() != 1.
* \throw If \a this is not allocated.
*/
-void DataArrayDouble::checkMonotonic(bool increasing, double eps) const throw(INTERP_KERNEL::Exception)
+void DataArrayDouble::checkMonotonic(bool increasing, double eps) const
{
if(!isMonotonic(increasing,eps))
{
* \throw If \a this->getNumberOfComponents() != 1.
* \throw If \a this is not allocated.
*/
-bool DataArrayDouble::isMonotonic(bool increasing, double eps) const throw(INTERP_KERNEL::Exception)
+bool DataArrayDouble::isMonotonic(bool increasing, double eps) const
{
checkAllocated();
if(getNumberOfComponents()!=1)
* 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 throw(INTERP_KERNEL::Exception)
+std::string DataArrayDouble::repr() const
{
std::ostringstream ret;
reprStream(ret);
return ret.str();
}
-std::string DataArrayDouble::reprZip() const throw(INTERP_KERNEL::Exception)
+std::string DataArrayDouble::reprZip() const
{
std::ostringstream ret;
reprZipStream(ret);
return ret.str();
}
-void DataArrayDouble::writeVTK(std::ostream& ofs, int indent, const char *nameInFile) const throw(INTERP_KERNEL::Exception)
+void DataArrayDouble::writeVTK(std::ostream& ofs, int indent, const std::string& nameInFile, DataArrayByte *byteArr) const
{
+ static const char SPACE[4]={' ',' ',' ',' '};
+ checkAllocated();
std::string idt(indent,' ');
ofs.precision(17);
ofs << idt << "<DataArray type=\"Float32\" Name=\"" << nameInFile << "\" NumberOfComponents=\"" << getNumberOfComponents() << "\"";
- ofs << " format=\"ascii\" RangeMin=\"" << getMinValueInArray() << "\" RangeMax=\"" << getMaxValueInArray() << "\">\n" << idt;
- std::copy(begin(),end(),std::ostream_iterator<double>(ofs," "));
+ if(byteArr)
+ {
+ ofs << " format=\"appended\" offset=\"" << byteArr->getNumberOfTuples() << "\">";
+ INTERP_KERNEL::AutoPtr<float> tmp(new float[getNbOfElems()]);
+ float *pt(tmp);
+ // to make Visual C++ happy : instead of std::copy(begin(),end(),(float *)tmp);
+ for(const double *src=begin();src!=end();src++,pt++)
+ *pt=float(*src);
+ const char *data(reinterpret_cast<const char *>((float *)tmp));
+ std::size_t sz(getNbOfElems()*sizeof(float));
+ byteArr->insertAtTheEnd(data,data+sz);
+ byteArr->insertAtTheEnd(SPACE,SPACE+4);
+ }
+ else
+ {
+ ofs << " RangeMin=\"" << getMinValueInArray() << "\" RangeMax=\"" << getMaxValueInArray() << "\" format=\"ascii\">\n" << idt;
+ std::copy(begin(),end(),std::ostream_iterator<double>(ofs," "));
+ }
ofs << std::endl << idt << "</DataArray>\n";
}
-void DataArrayDouble::reprStream(std::ostream& stream) const throw(INTERP_KERNEL::Exception)
+void DataArrayDouble::reprStream(std::ostream& stream) const
{
stream << "Name of double array : \"" << _name << "\"\n";
reprWithoutNameStream(stream);
}
-void DataArrayDouble::reprZipStream(std::ostream& stream) const throw(INTERP_KERNEL::Exception)
+void DataArrayDouble::reprZipStream(std::ostream& stream) const
{
stream << "Name of double array : \"" << _name << "\"\n";
reprZipWithoutNameStream(stream);
}
-void DataArrayDouble::reprWithoutNameStream(std::ostream& stream) const throw(INTERP_KERNEL::Exception)
+void DataArrayDouble::reprWithoutNameStream(std::ostream& stream) const
{
DataArray::reprWithoutNameStream(stream);
stream.precision(17);
_mem.repr(getNumberOfComponents(),stream);
}
-void DataArrayDouble::reprZipWithoutNameStream(std::ostream& stream) const throw(INTERP_KERNEL::Exception)
+void DataArrayDouble::reprZipWithoutNameStream(std::ostream& stream) const
{
DataArray::reprWithoutNameStream(stream);
stream.precision(17);
_mem.reprZip(getNumberOfComponents(),stream);
}
-void DataArrayDouble::reprCppStream(const char *varName, std::ostream& stream) const throw(INTERP_KERNEL::Exception)
+void DataArrayDouble::reprCppStream(const std::string& varName, std::ostream& stream) const
{
int nbTuples=getNumberOfTuples(),nbComp=getNumberOfComponents();
const double *data=getConstPointer();
/*!
* Method that gives a quick overvien of \a this for python.
*/
-void DataArrayDouble::reprQuickOverview(std::ostream& stream) const throw(INTERP_KERNEL::Exception)
+void DataArrayDouble::reprQuickOverview(std::ostream& stream) const
{
static const std::size_t MAX_NB_OF_BYTE_IN_REPR=300;
stream << "DataArrayDouble C++ instance at " << this << ". ";
stream << "*** No data allocated ****";
}
-void DataArrayDouble::reprQuickOverviewData(std::ostream& stream, std::size_t maxNbOfByteInRepr) const throw(INTERP_KERNEL::Exception)
+void DataArrayDouble::reprQuickOverviewData(std::ostream& stream, std::size_t maxNbOfByteInRepr) const
{
const double *data=begin();
int nbOfTuples=getNumberOfTuples();
* \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)
+bool DataArrayDouble::isEqualIfNotWhy(const DataArrayDouble& other, double prec, std::string& reason) const
{
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 throw(INTERP_KERNEL::Exception)
+bool DataArrayDouble::isEqual(const DataArrayDouble& other, double prec) const
{
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 throw(INTERP_KERNEL::Exception)
+bool DataArrayDouble::isEqualWithoutConsideringStr(const DataArrayDouble& other, double prec) const
{
std::string tmp;
return _mem.isEqual(other._mem,prec,tmp);
* \throw If \a this is not allocated.
* \throw If \a nbOfTuples is negative.
*/
-void DataArrayDouble::reAlloc(int nbOfTuples) throw(INTERP_KERNEL::Exception)
+void DataArrayDouble::reAlloc(int nbOfTuples)
{
if(nbOfTuples<0)
throw INTERP_KERNEL::Exception("DataArrayDouble::reAlloc : input new number of tuples should be >=0 !");
{
DataArrayInt *ret=DataArrayInt::New();
ret->alloc(getNumberOfTuples(),getNumberOfComponents());
- std::size_t nbOfVals=getNbOfElems();
- const double *src=getConstPointer();
int *dest=ret->getPointer();
- std::copy(src,src+nbOfVals,dest);
+ // to make Visual C++ happy : instead of std::size_t nbOfVals=getNbOfElems(); std::copy(src,src+nbOfVals,dest);
+ for(const double *src=begin();src!=end();src++,dest++)
+ *dest=(int)*src;
ret->copyStringInfoFrom(*this);
return ret;
}
* is to delete using decrRef() as it is no more needed.
* \throw If \a this is not allocated.
*/
-DataArrayDouble *DataArrayDouble::fromNoInterlace() const throw(INTERP_KERNEL::Exception)
+DataArrayDouble *DataArrayDouble::fromNoInterlace() const
{
if(_mem.isNull())
throw INTERP_KERNEL::Exception("DataArrayDouble::fromNoInterlace : Not defined array !");
* is to delete using decrRef() as it is no more needed.
* \throw If \a this is not allocated.
*/
-DataArrayDouble *DataArrayDouble::toNoInterlace() const throw(INTERP_KERNEL::Exception)
+DataArrayDouble *DataArrayDouble::toNoInterlace() const
{
if(_mem.isNull())
throw INTERP_KERNEL::Exception("DataArrayDouble::toNoInterlace : Not defined array !");
* \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) throw(INTERP_KERNEL::Exception)
+void DataArrayDouble::renumberInPlace(const int *old2New)
{
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) throw(INTERP_KERNEL::Exception)
+void DataArrayDouble::renumberInPlaceR(const int *new2Old)
{
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 throw(INTERP_KERNEL::Exception)
+DataArrayDouble *DataArrayDouble::renumber(const int *old2New) const
{
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.
*/
-DataArrayDouble *DataArrayDouble::renumberR(const int *new2Old) const throw(INTERP_KERNEL::Exception)
+DataArrayDouble *DataArrayDouble::renumberR(const int *new2Old) const
{
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.
*/
-DataArrayDouble *DataArrayDouble::renumberAndReduce(const int *old2New, int newNbOfTuple) const throw(INTERP_KERNEL::Exception)
+DataArrayDouble *DataArrayDouble::renumberAndReduce(const int *old2New, int newNbOfTuple) const
{
checkAllocated();
int nbTuples=getNumberOfTuples();
* is to delete using decrRef() as it is no more needed.
* \throw If \a new2OldEnd - \a new2OldBg > \a this->getNumberOfTuples().
*/
-DataArrayDouble *DataArrayDouble::selectByTupleIdSafe(const int *new2OldBg, const int *new2OldEnd) const throw(INTERP_KERNEL::Exception)
+DataArrayDouble *DataArrayDouble::selectByTupleIdSafe(const int *new2OldBg, const int *new2OldEnd) const
{
checkAllocated();
MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
* is to delete using decrRef() as it is no more needed.
* \sa DataArrayDouble::substr.
*/
-DataArrayDouble *DataArrayDouble::selectByTupleId2(int bg, int end2, int step) const throw(INTERP_KERNEL::Exception)
+DataArrayDouble *DataArrayDouble::selectByTupleId2(int bg, int end2, int step) const
{
checkAllocated();
MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
* \throw If \a end > \a this->getNumberOfTuples().
* \throw If \a this is not allocated.
*/
-DataArray *DataArrayDouble::selectByTupleRanges(const std::vector<std::pair<int,int> >& ranges) const throw(INTERP_KERNEL::Exception)
+DataArray *DataArrayDouble::selectByTupleRanges(const std::vector<std::pair<int,int> >& ranges) const
{
checkAllocated();
int nbOfComp=getNumberOfComponents();
\throw If \a tupleIdEnd != -1 && \a tupleIdEnd < \a this->getNumberOfTuples().
* \sa DataArrayDouble::selectByTupleId2
*/
-DataArrayDouble *DataArrayDouble::substr(int tupleIdBg, int tupleIdEnd) const throw(INTERP_KERNEL::Exception)
+DataArrayDouble *DataArrayDouble::substr(int tupleIdBg, int tupleIdEnd) const
{
checkAllocated();
int nbt=getNumberOfTuples();
* is to delete using decrRef() as it is no more needed.
* \throw If \a this is not allocated.
*/
-DataArrayDouble *DataArrayDouble::changeNbOfComponents(int newNbOfComp, double dftValue) const throw(INTERP_KERNEL::Exception)
+DataArrayDouble *DataArrayDouble::changeNbOfComponents(int newNbOfComp, double dftValue) const
{
checkAllocated();
MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
for(;j<newNbOfComp;j++)
nc[newNbOfComp*i+j]=dftValue;
}
- ret->setName(getName().c_str());
+ ret->setName(getName());
for(int i=0;i<dim;i++)
- ret->setInfoOnComponent(i,getInfoOnComponent(i).c_str());
- ret->setName(getName().c_str());
+ ret->setInfoOnComponent(i,getInfoOnComponent(i));
+ ret->setName(getName());
return ret.retn();
}
* \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)
+void DataArrayDouble::rearrange(int newNbOfCompo)
{
checkAllocated();
if(newNbOfCompo<1)
* \throw If \a this is not allocated.
* \sa rearrange()
*/
-void DataArrayDouble::transpose() throw(INTERP_KERNEL::Exception)
+void DataArrayDouble::transpose()
{
checkAllocated();
int nbOfTuples=getNumberOfTuples();
* \throw If a component index (\a i) is not valid:
* \a i < 0 || \a i >= \a this->getNumberOfComponents().
*
+ * \if ENABLE_EXAMPLES
* \ref py_mcdataarraydouble_KeepSelectedComponents "Here is a Python example".
+ * \endif
*/
-DataArray *DataArrayDouble::keepSelectedComponents(const std::vector<int>& compoIds) const throw(INTERP_KERNEL::Exception)
+DataArrayDouble *DataArrayDouble::keepSelectedComponents(const std::vector<int>& compoIds) const
{
checkAllocated();
MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret(DataArrayDouble::New());
* \throw If \a this is not allocated.
* \throw If \a this and \a other arrays have different number of tuples.
*
+ * \if ENABLE_EXAMPLES
* \ref cpp_mcdataarraydouble_meldwith "Here is a C++ example".
*
* \ref py_mcdataarraydouble_meldwith "Here is a Python example".
+ * \endif
*/
-void DataArrayDouble::meldWith(const DataArrayDouble *other) throw(INTERP_KERNEL::Exception)
+void DataArrayDouble::meldWith(const DataArrayDouble *other)
{
checkAllocated();
other->checkAllocated();
* \param [out] tupleIds - the tuple ids containing the same number of tuples than \a other has.
* \sa DataArrayDouble::findCommonTuples
*/
-bool DataArrayDouble::areIncludedInMe(const DataArrayDouble *other, double prec, DataArrayInt *&tupleIds) const throw(INTERP_KERNEL::Exception)
+bool DataArrayDouble::areIncludedInMe(const DataArrayDouble *other, double prec, DataArrayInt *&tupleIds) const
{
if(!other)
throw INTERP_KERNEL::Exception("DataArrayDouble::areIncludedInMe : input array is NULL !");
* [ \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 the number of components is not in [1,2,3].
+ * \throw If the number of components is not in [1,2,3,4].
*
+ * \if ENABLE_EXAMPLES
* \ref cpp_mcdataarraydouble_findcommontuples "Here is a C++ example".
*
* \ref py_mcdataarraydouble_findcommontuples "Here is a Python example".
+ * \endif
* \sa DataArrayInt::BuildOld2NewArrayFromSurjectiveFormat2(), DataArrayDouble::areIncludedInMe
*/
-void DataArrayDouble::findCommonTuples(double prec, int limitTupleId, DataArrayInt *&comm, DataArrayInt *&commIndex) const throw(INTERP_KERNEL::Exception)
+void DataArrayDouble::findCommonTuples(double prec, int limitTupleId, DataArrayInt *&comm, DataArrayInt *&commIndex) const
{
checkAllocated();
int nbOfCompo=getNumberOfComponents();
- if ((nbOfCompo<1) || (nbOfCompo>3)) //test before work
- throw INTERP_KERNEL::Exception("DataArrayDouble::findCommonTuples : Unexpected spacedim of coords. Must be 1, 2 or 3.");
-
+ if ((nbOfCompo<1) || (nbOfCompo>4)) //test before work
+ throw INTERP_KERNEL::Exception("DataArrayDouble::findCommonTuples : Unexpected spacedim of coords. Must be 1, 2, 3 or 4.");
+
int nbOfTuples=getNumberOfTuples();
//
MEDCouplingAutoRefCountObjectPtr<DataArrayInt> c(DataArrayInt::New()),cI(DataArrayInt::New()); c->alloc(0,1); cI->pushBackSilent(0);
switch(nbOfCompo)
- {
+ {
+ case 4:
+ findCommonTuplesAlg<4>(begin(),nbOfTuples,limitTupleId,prec,c,cI);
+ break;
case 3:
findCommonTuplesAlg<3>(begin(),nbOfTuples,limitTupleId,prec,c,cI);
break;
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 !");
- }
+ throw INTERP_KERNEL::Exception("DataArrayDouble::findCommonTuples : nb of components managed are 1,2,3 and 4 ! not implemented for other number of components !");
+ }
comm=c.retn();
commIndex=cI.retn();
}
* \return a newly allocated DataArrayDouble having one component and number of tuples equal to \a nbTimes * \c this->getNumberOfTuples.
* \throw if \a this is not allocated or if \a this has not number of components set to one or if \a nbTimes is lower than 1.
*/
-DataArrayDouble *DataArrayDouble::duplicateEachTupleNTimes(int nbTimes) const throw(INTERP_KERNEL::Exception)
+DataArrayDouble *DataArrayDouble::duplicateEachTupleNTimes(int nbTimes) const
{
checkAllocated();
if(getNumberOfComponents()!=1)
* \return the minimal distance between the two set of points \a this and \a other.
* \sa DataArrayDouble::findClosestTupleId
*/
-double DataArrayDouble::minimalDistanceTo(const DataArrayDouble *other, int& thisTupleId, int& otherTupleId) const throw(INTERP_KERNEL::Exception)
+double DataArrayDouble::minimalDistanceTo(const DataArrayDouble *other, int& thisTupleId, int& otherTupleId) const
{
MEDCouplingAutoRefCountObjectPtr<DataArrayInt> part1=findClosestTupleId(other);
int nbOfCompo(getNumberOfComponents());
* \return a newly allocated (new object to be dealt by the caller) DataArrayInt having \c other->getNumberOfTuples() tuples and one components.
* \sa DataArrayDouble::minimalDistanceTo
*/
-DataArrayInt *DataArrayDouble::findClosestTupleId(const DataArrayDouble *other) const throw(INTERP_KERNEL::Exception)
+DataArrayInt *DataArrayDouble::findClosestTupleId(const DataArrayDouble *other) const
{
if(!other)
throw INTERP_KERNEL::Exception("DataArrayDouble::findClosestTupleId : other instance is NULL !");
double bounds[6];
getMinMaxPerComponent(bounds);
switch(nbOfCompo)
- {
+ {
case 3:
{
double xDelta(fabs(bounds[1]-bounds[0])),yDelta(fabs(bounds[3]-bounds[2])),zDelta(fabs(bounds[5]-bounds[4]));
}
default:
throw INTERP_KERNEL::Exception("Unexpected spacedim of coords for findClosestTupleId. Must be 1, 2 or 3.");
+ }
+ return ret.retn();
+}
+
+/*!
+ * This method expects that \a this and \a otherBBoxFrmt arrays are bounding box arrays ( as the output of MEDCouplingPointSet::getBoundingBoxForBBTree method ).
+ * This method will return a DataArrayInt array having the same number of tuples than \a this. This returned array tells for each cell in \a this
+ * how many bounding boxes in \a otherBBoxFrmt.
+ * So, this method expects that \a this and \a otherBBoxFrmt have the same number of components.
+ *
+ * \param [in] otherBBoxFrmt - It is an array .
+ * \param [in] eps - the absolute precision of the detection. when eps < 0 the bboxes are enlarged so more interactions are detected. Inversely when > 0 the bboxes are stretched.
+ * \sa MEDCouplingPointSet::getBoundingBoxForBBTree
+ * \throw If \a this and \a otherBBoxFrmt have not the same number of components.
+ * \throw If \a this and \a otherBBoxFrmt number of components is not even (BBox format).
+ */
+DataArrayInt *DataArrayDouble::computeNbOfInteractionsWith(const DataArrayDouble *otherBBoxFrmt, double eps) const
+{
+ if(!otherBBoxFrmt)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::computeNbOfInteractionsWith : input array is NULL !");
+ if(!isAllocated() || !otherBBoxFrmt->isAllocated())
+ throw INTERP_KERNEL::Exception("DataArrayDouble::computeNbOfInteractionsWith : this and input array must be allocated !");
+ int nbOfComp(getNumberOfComponents()),nbOfTuples(getNumberOfTuples());
+ if(nbOfComp!=otherBBoxFrmt->getNumberOfComponents())
+ {
+ std::ostringstream oss; oss << "DataArrayDouble::computeNbOfInteractionsWith : this number of components (" << nbOfComp << ") must be equal to the number of components of input array (" << otherBBoxFrmt->getNumberOfComponents() << ") !";
+ throw INTERP_KERNEL::Exception(oss.str().c_str());
}
+ if(nbOfComp%2!=0)
+ {
+ 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);
+ const double *thisBBPtr(begin());
+ int *retPtr(ret->getPointer());
+ switch(nbOfComp/2)
+ {
+ case 3:
+ {
+ BBTree<3,int> bbt(otherBBoxFrmt->begin(),0,0,otherBBoxFrmt->getNumberOfTuples(),eps);
+ for(int i=0;i<nbOfTuples;i++,retPtr++,thisBBPtr+=nbOfComp)
+ *retPtr=bbt.getNbOfIntersectingElems(thisBBPtr);
+ break;
+ }
+ case 2:
+ {
+ BBTree<2,int> bbt(otherBBoxFrmt->begin(),0,0,otherBBoxFrmt->getNumberOfTuples(),eps);
+ for(int i=0;i<nbOfTuples;i++,retPtr++,thisBBPtr+=nbOfComp)
+ *retPtr=bbt.getNbOfIntersectingElems(thisBBPtr);
+ break;
+ }
+ case 1:
+ {
+ BBTree<1,int> bbt(otherBBoxFrmt->begin(),0,0,otherBBoxFrmt->getNumberOfTuples(),eps);
+ for(int i=0;i<nbOfTuples;i++,retPtr++,thisBBPtr+=nbOfComp)
+ *retPtr=bbt.getNbOfIntersectingElems(thisBBPtr);
+ break;
+ }
+ default:
+ throw INTERP_KERNEL::Exception("DataArrayDouble::computeNbOfInteractionsWith : space dimension supported are [1,2,3] !");
+ }
+
return ret.retn();
}
* \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.
- * \throw If the number of components is not in [1,2,3].
+ * \throw If the number of components is not in [1,2,3,4].
*
+ * \if ENABLE_EXAMPLES
* \ref py_mcdataarraydouble_getdifferentvalues "Here is a Python example".
+ * \endif
*/
-DataArrayDouble *DataArrayDouble::getDifferentValues(double prec, int limitTupleId) const throw(INTERP_KERNEL::Exception)
+DataArrayDouble *DataArrayDouble::getDifferentValues(double prec, int limitTupleId) const
{
checkAllocated();
DataArrayInt *c0=0,*cI0=0;
* \throw If \a compoIds.size() != \a a->getNumberOfComponents().
* \throw If \a compoIds[i] < 0 or \a compoIds[i] > \a this->getNumberOfComponents().
*
+ * \if ENABLE_EXAMPLES
* \ref py_mcdataarraydouble_setselectedcomponents "Here is a Python example".
+ * \endif
*/
-void DataArrayDouble::setSelectedComponents(const DataArrayDouble *a, const std::vector<int>& compoIds) throw(INTERP_KERNEL::Exception)
+void DataArrayDouble::setSelectedComponents(const DataArrayDouble *a, const std::vector<int>& compoIds)
{
if(!a)
throw INTERP_KERNEL::Exception("DataArrayDouble::setSelectedComponents : input DataArrayDouble is NULL !");
* \throw If \a strictCompoCompare == \a true && \a a->getNumberOfComponents() !=
* \c len(\c range(\a bgComp,\a endComp,\a stepComp)).
*
+ * \if ENABLE_EXAMPLES
* \ref py_mcdataarraydouble_setpartofvalues1 "Here is a Python example".
+ * \endif
*/
-void DataArrayDouble::setPartOfValues1(const DataArrayDouble *a, int bgTuples, int endTuples, int stepTuples, int bgComp, int endComp, int stepComp, bool strictCompoCompare) throw(INTERP_KERNEL::Exception)
+void DataArrayDouble::setPartOfValues1(const DataArrayDouble *a, int bgTuples, int endTuples, int stepTuples, int bgComp, int endComp, int stepComp, bool strictCompoCompare)
{
if(!a)
throw INTERP_KERNEL::Exception("DataArrayDouble::setPartOfValues1 : input DataArrayDouble is NULL !");
* non-empty range of increasing indices or indices are out of a valid range
* for \this array.
*
+ * \if ENABLE_EXAMPLES
* \ref py_mcdataarraydouble_setpartofvaluessimple1 "Here is a Python example".
+ * \endif
*/
-void DataArrayDouble::setPartOfValuesSimple1(double a, int bgTuples, int endTuples, int stepTuples, int bgComp, int endComp, int stepComp) throw(INTERP_KERNEL::Exception)
+void DataArrayDouble::setPartOfValuesSimple1(double a, int bgTuples, int endTuples, int stepTuples, int bgComp, int endComp, int stepComp)
{
const char msg[]="DataArrayDouble::setPartOfValuesSimple1";
checkAllocated();
* \throw In the second *mode of usage*, if \a a->getNumberOfTuples() != 1 or
* <em> a->getNumberOfComponents() != (endComp - bgComp)</em>.
*
+ * \if ENABLE_EXAMPLES
* \ref py_mcdataarraydouble_setpartofvalues2 "Here is a Python example".
+ * \endif
*/
-void DataArrayDouble::setPartOfValues2(const DataArrayDouble *a, const int *bgTuples, const int *endTuples, const int *bgComp, const int *endComp, bool strictCompoCompare) throw(INTERP_KERNEL::Exception)
+void DataArrayDouble::setPartOfValues2(const DataArrayDouble *a, const int *bgTuples, const int *endTuples, const int *bgComp, const int *endComp, bool strictCompoCompare)
{
if(!a)
throw INTERP_KERNEL::Exception("DataArrayDouble::setPartOfValues2 : input DataArrayDouble is NULL !");
* \throw If any index of tuple/component given by <em>bgTuples / bgComp</em> is
* out of a valid range for \a this array.
*
+ * \if ENABLE_EXAMPLES
* \ref py_mcdataarraydouble_setpartofvaluessimple2 "Here is a Python example".
+ * \endif
*/
-void DataArrayDouble::setPartOfValuesSimple2(double a, const int *bgTuples, const int *endTuples, const int *bgComp, const int *endComp) throw(INTERP_KERNEL::Exception)
+void DataArrayDouble::setPartOfValuesSimple2(double a, const int *bgTuples, const int *endTuples, const int *bgComp, const int *endComp)
{
checkAllocated();
int nbComp=getNumberOfComponents();
* non-empty range of increasing indices or indices are out of a valid range
* for \this array.
*
+ * \if ENABLE_EXAMPLES
* \ref py_mcdataarraydouble_setpartofvalues3 "Here is a Python example".
+ * \endif
*/
-void DataArrayDouble::setPartOfValues3(const DataArrayDouble *a, const int *bgTuples, const int *endTuples, int bgComp, int endComp, int stepComp, bool strictCompoCompare) throw(INTERP_KERNEL::Exception)
+void DataArrayDouble::setPartOfValues3(const DataArrayDouble *a, const int *bgTuples, const int *endTuples, int bgComp, int endComp, int stepComp, bool strictCompoCompare)
{
if(!a)
throw INTERP_KERNEL::Exception("DataArrayDouble::setPartOfValues3 : input DataArrayDouble is NULL !");
* non-empty range of increasing indices or indices are out of a valid range
* for \this array.
*
+ * \if ENABLE_EXAMPLES
* \ref py_mcdataarraydouble_setpartofvaluessimple3 "Here is a Python example".
+ * \endif
*/
-void DataArrayDouble::setPartOfValuesSimple3(double a, const int *bgTuples, const int *endTuples, int bgComp, int endComp, int stepComp) throw(INTERP_KERNEL::Exception)
+void DataArrayDouble::setPartOfValuesSimple3(double a, const int *bgTuples, const int *endTuples, int bgComp, int endComp, int stepComp)
{
const char msg[]="DataArrayDouble::setPartOfValuesSimple3";
checkAllocated();
* \c len(\c range(\a bgComp,\a endComp,\a stepComp)).
*
*/
-void DataArrayDouble::setPartOfValues4(const DataArrayDouble *a, int bgTuples, int endTuples, int stepTuples, const int *bgComp, const int *endComp, bool strictCompoCompare) throw(INTERP_KERNEL::Exception)
+void DataArrayDouble::setPartOfValues4(const DataArrayDouble *a, int bgTuples, int endTuples, int stepTuples, const int *bgComp, const int *endComp, bool strictCompoCompare)
{
if(!a)
throw INTERP_KERNEL::Exception("DataArrayDouble::setPartOfValues4 : input DataArrayDouble is NULL !");
}
}
-void DataArrayDouble::setPartOfValuesSimple4(double a, int bgTuples, int endTuples, int stepTuples, const int *bgComp, const int *endComp) throw(INTERP_KERNEL::Exception)
+void DataArrayDouble::setPartOfValuesSimple4(double a, int bgTuples, int endTuples, int stepTuples, const int *bgComp, const int *endComp)
{
const char msg[]="DataArrayDouble::setPartOfValuesSimple4";
checkAllocated();
* \throw If any tuple index given by \a tuplesSelec is out of a valid range for
* the corresponding (\a this or \a a) array.
*/
-void DataArrayDouble::setPartOfValuesAdv(const DataArrayDouble *a, const DataArrayInt *tuplesSelec) throw(INTERP_KERNEL::Exception)
+void DataArrayDouble::setPartOfValuesAdv(const DataArrayDouble *a, const DataArrayInt *tuplesSelec)
{
if(!a || !tuplesSelec)
throw INTERP_KERNEL::Exception("DataArrayDouble::setPartOfValuesAdv : input DataArrayDouble is NULL !");
* \throw If any tuple index given by \a tuplesSelec is out of a valid range for
* \a aBase array.
*/
-void DataArrayDouble::setContigPartOfSelectedValues(int tupleIdStart, const DataArray *aBase, const DataArrayInt *tuplesSelec) throw(INTERP_KERNEL::Exception)
+void DataArrayDouble::setContigPartOfSelectedValues(int tupleIdStart, const DataArray *aBase, const DataArrayInt *tuplesSelec)
{
if(!aBase || !tuplesSelec)
throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues : input DataArray is NULL !");
* 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) throw(INTERP_KERNEL::Exception)
+void DataArrayDouble::setContigPartOfSelectedValues2(int tupleIdStart, const DataArray *aBase, int bg, int end2, int step)
{
if(!aBase)
throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues2 : input DataArray is NULL !");
* \throw If condition <em>( 0 <= tupleId < this->getNumberOfTuples() )</em> is violated.
* \throw If condition <em>( 0 <= compoId < this->getNumberOfComponents() )</em> is violated.
*/
-double DataArrayDouble::getIJSafe(int tupleId, int compoId) const throw(INTERP_KERNEL::Exception)
+double DataArrayDouble::getIJSafe(int tupleId, int compoId) const
{
checkAllocated();
if(tupleId<0 || tupleId>=getNumberOfTuples())
* \throw If \a this->getNumberOfComponents() != 1.
* \throw If \a this->getNumberOfTuples() < 1.
*/
-double DataArrayDouble::front() const throw(INTERP_KERNEL::Exception)
+double DataArrayDouble::front() const
{
checkAllocated();
if(getNumberOfComponents()!=1)
* \throw If \a this->getNumberOfComponents() != 1.
* \throw If \a this->getNumberOfTuples() < 1.
*/
-double DataArrayDouble::back() const throw(INTERP_KERNEL::Exception)
+double DataArrayDouble::back() const
{
checkAllocated();
if(getNumberOfComponents()!=1)
* \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) throw(INTERP_KERNEL::Exception)
+void DataArrayDouble::useArray(const double *array, bool ownership, DeallocType type, int nbOfTuple, int nbOfCompo)
{
_info_on_compo.resize(nbOfCompo);
_mem.useArray(array,ownership,type,(std::size_t)nbOfTuple*nbOfCompo);
declareAsNew();
}
-void DataArrayDouble::useExternalArrayWithRWAccess(const double *array, int nbOfTuple, int nbOfCompo) throw(INTERP_KERNEL::Exception)
+void DataArrayDouble::useExternalArrayWithRWAccess(const double *array, int nbOfTuple, int nbOfCompo)
{
_info_on_compo.resize(nbOfCompo);
_mem.useExternalArrayWithRWAccess(array,(std::size_t)nbOfTuple*nbOfCompo);
* is thrown.
* \throw If zero is found in \a this array.
*/
-void DataArrayDouble::checkNoNullValues() const throw(INTERP_KERNEL::Exception)
+void DataArrayDouble::checkNoNullValues() const
{
const double *tmp=getConstPointer();
std::size_t nbOfElems=getNbOfElems();
* \a bounds[3] = \c max_of_component_1 <br>
* ...
*/
-void DataArrayDouble::getMinMaxPerComponent(double *bounds) const throw(INTERP_KERNEL::Exception)
+void DataArrayDouble::getMinMaxPerComponent(double *bounds) const
{
checkAllocated();
int dim=getNumberOfComponents();
*
* \throw If \a this is not allocated yet.
*/
-DataArrayDouble *DataArrayDouble::computeBBoxPerTuple(double epsilon)const throw(INTERP_KERNEL::Exception)
+DataArrayDouble *DataArrayDouble::computeBBoxPerTuple(double epsilon) const
{
checkAllocated();
const double *dataPtr=getConstPointer();
*
* \sa MEDCouplingPointSet::getNodeIdsNearPoints, DataArrayDouble::getDifferentValues
*/
-void DataArrayDouble::computeTupleIdsNearTuples(const DataArrayDouble *other, double eps, DataArrayInt *& c, DataArrayInt *& cI) const throw(INTERP_KERNEL::Exception)
+void DataArrayDouble::computeTupleIdsNearTuples(const DataArrayDouble *other, double eps, DataArrayInt *& c, DataArrayInt *& cI) const
{
if(!other)
throw INTERP_KERNEL::Exception("DataArrayDouble::computeTupleIdsNearTuples : input pointer other is null !");
int nbOfTuplesOther=other->getNumberOfTuples();
MEDCouplingAutoRefCountObjectPtr<DataArrayInt> cArr(DataArrayInt::New()),cIArr(DataArrayInt::New()); cArr->alloc(0,1); cIArr->pushBackSilent(0);
switch(nbOfCompo)
- {
+ {
case 3:
{
BBTreePts<3,int> myTree(begin(),0,0,getNumberOfTuples(),eps);
}
default:
throw INTERP_KERNEL::Exception("Unexpected spacedim of coords for computeTupleIdsNearTuples. Must be 1, 2 or 3.");
- }
+ }
c=cArr.retn(); cI=cIArr.retn();
}
*
* \param [in] eps absolute epsilon. under that value of delta between max and min no scale is performed.
*/
-void DataArrayDouble::recenterForMaxPrecision(double eps) throw(INTERP_KERNEL::Exception)
+void DataArrayDouble::recenterForMaxPrecision(double eps)
{
checkAllocated();
int dim=getNumberOfComponents();
* \throw If \a this->getNumberOfComponents() != 1
* \throw If \a this->getNumberOfTuples() < 1
*/
-double DataArrayDouble::getMaxValue(int& tupleId) const throw(INTERP_KERNEL::Exception)
+double DataArrayDouble::getMaxValue(int& tupleId) const
{
checkAllocated();
if(getNumberOfComponents()!=1)
* \return double - the maximal value among all values of \a this array.
* \throw If \a this is not allocated.
*/
-double DataArrayDouble::getMaxValueInArray() const throw(INTERP_KERNEL::Exception)
+double DataArrayDouble::getMaxValueInArray() const
{
checkAllocated();
const double *loc=std::max_element(begin(),end());
* \throw If \a this->getNumberOfComponents() != 1
* \throw If \a this->getNumberOfTuples() < 1
*/
-double DataArrayDouble::getMaxValue2(DataArrayInt*& tupleIds) const throw(INTERP_KERNEL::Exception)
+double DataArrayDouble::getMaxValue2(DataArrayInt*& tupleIds) const
{
int tmp;
tupleIds=0;
* \throw If \a this->getNumberOfComponents() != 1
* \throw If \a this->getNumberOfTuples() < 1
*/
-double DataArrayDouble::getMinValue(int& tupleId) const throw(INTERP_KERNEL::Exception)
+double DataArrayDouble::getMinValue(int& tupleId) const
{
checkAllocated();
if(getNumberOfComponents()!=1)
* \return double - the minimal value among all values of \a this array.
* \throw If \a this is not allocated.
*/
-double DataArrayDouble::getMinValueInArray() const throw(INTERP_KERNEL::Exception)
+double DataArrayDouble::getMinValueInArray() const
{
checkAllocated();
const double *loc=std::min_element(begin(),end());
* \throw If \a this->getNumberOfComponents() != 1
* \throw If \a this->getNumberOfTuples() < 1
*/
-double DataArrayDouble::getMinValue2(DataArrayInt*& tupleIds) const throw(INTERP_KERNEL::Exception)
+double DataArrayDouble::getMinValue2(DataArrayInt*& tupleIds) const
{
int tmp;
tupleIds=0;
* \throw If \a this is not allocated
*
*/
-int DataArrayDouble::count(double value, double eps) const throw(INTERP_KERNEL::Exception)
+int DataArrayDouble::count(double value, double eps) const
{
int ret=0;
checkAllocated();
* \throw If \a this->getNumberOfComponents() != 1
* \throw If \a this->getNumberOfTuples() < 1
*/
-double DataArrayDouble::getAverageValue() const throw(INTERP_KERNEL::Exception)
+double DataArrayDouble::getAverageValue() const
{
if(getNumberOfComponents()!=1)
throw INTERP_KERNEL::Exception("DataArrayDouble::getAverageValue : must be applied on DataArrayDouble with only one component, you can call 'rearrange' method before !");
* the square root of the inner product of vector.
* \throw If \a this is not allocated.
*/
-double DataArrayDouble::norm2() const throw(INTERP_KERNEL::Exception)
+double DataArrayDouble::norm2() const
{
checkAllocated();
double ret=0.;
/*!
* Returns the maximum norm of the vector defined by \a this array.
+ * This method works even if the number of components is diferent from one.
+ * If the number of elements in \a this is 0, -1. is returned.
* \return double - the value of the maximum norm, i.e.
- * the maximal absolute value among values of \a this array.
+ * the maximal absolute value among values of \a this array (whatever its number of components).
* \throw If \a this is not allocated.
*/
-double DataArrayDouble::normMax() const throw(INTERP_KERNEL::Exception)
+double DataArrayDouble::normMax() const
{
checkAllocated();
- double ret=-1.;
- std::size_t nbOfElems=getNbOfElems();
- const double *pt=getConstPointer();
+ double ret(-1.);
+ std::size_t nbOfElems(getNbOfElems());
+ const double *pt(getConstPointer());
for(std::size_t i=0;i<nbOfElems;i++,pt++)
{
- double val=std::abs(*pt);
+ double val(std::abs(*pt));
if(val>ret)
ret=val;
}
return ret;
}
+/*!
+ * Returns the minimum norm (absolute value) of the vector defined by \a this array.
+ * This method works even if the number of components is diferent from one.
+ * If the number of elements in \a this is 0, std::numeric_limits<double>::max() is returned.
+ * \return double - the value of the minimum norm, i.e.
+ * the minimal absolute value among values of \a this array (whatever its number of components).
+ * \throw If \a this is not allocated.
+ */
+double DataArrayDouble::normMin() const
+{
+ checkAllocated();
+ double ret(std::numeric_limits<double>::max());
+ std::size_t nbOfElems(getNbOfElems());
+ const double *pt(getConstPointer());
+ for(std::size_t i=0;i<nbOfElems;i++,pt++)
+ {
+ double val(std::abs(*pt));
+ if(val<ret)
+ ret=val;
+ }
+ return ret;
+}
+
/*!
* Accumulates values of each component of \a this array.
* \param [out] res - an array of length \a this->getNumberOfComponents(), allocated
* component.
* \throw If \a this is not allocated.
*/
-void DataArrayDouble::accumulate(double *res) const throw(INTERP_KERNEL::Exception)
+void DataArrayDouble::accumulate(double *res) const
{
checkAllocated();
const double *ptr=getConstPointer();
* \return the min distance.
* \sa MEDCouplingUMesh::distanceToPoint
*/
-double DataArrayDouble::distanceToTuple(const double *tupleBg, const double *tupleEnd, int& tupleId) const throw(INTERP_KERNEL::Exception)
+double DataArrayDouble::distanceToTuple(const double *tupleBg, const double *tupleEnd, int& tupleId) const
{
checkAllocated();
int nbTuple=getNumberOfTuples();
* \throw If \a the condition ( 0 <= \a compId < \a this->getNumberOfComponents() ) is
* not respected.
*/
-double DataArrayDouble::accumulate(int compId) const throw(INTERP_KERNEL::Exception)
+double DataArrayDouble::accumulate(int compId) const
{
checkAllocated();
const double *ptr=getConstPointer();
* \throw If there is an id in [ \a bgOfIndex, \a endOfIndex ) not in [0, \c this->getNumberOfTuples).
* \throw If std::distance(bgOfIndex,endOfIndex)==0.
*/
-DataArrayDouble *DataArrayDouble::accumulatePerChunck(const int *bgOfIndex, const int *endOfIndex) const throw(INTERP_KERNEL::Exception)
+DataArrayDouble *DataArrayDouble::accumulatePerChunck(const int *bgOfIndex, const int *endOfIndex) const
{
if(!bgOfIndex || !endOfIndex)
throw INTERP_KERNEL::Exception("DataArrayDouble::accumulatePerChunck : input pointer NULL !");
* does not contain any textual info on components.
* \throw If \a this->getNumberOfComponents() != 2.
*/
-DataArrayDouble *DataArrayDouble::fromPolarToCart() const throw(INTERP_KERNEL::Exception)
+DataArrayDouble *DataArrayDouble::fromPolarToCart() const
{
checkAllocated();
int nbOfComp=getNumberOfComponents();
* is to delete this array using decrRef() as it is no more needed.
* \throw If \a this->getNumberOfComponents() != 3.
*/
-DataArrayDouble *DataArrayDouble::fromCylToCart() const throw(INTERP_KERNEL::Exception)
+DataArrayDouble *DataArrayDouble::fromCylToCart() const
{
checkAllocated();
int nbOfComp=getNumberOfComponents();
w[1]=wIn[0]*sin(wIn[1]);
w[2]=wIn[2];
}
- ret->setInfoOnComponent(2,getInfoOnComponent(2).c_str());
+ ret->setInfoOnComponent(2,getInfoOnComponent(2));
return ret;
}
* is to delete this array using decrRef() as it is no more needed.
* \throw If \a this->getNumberOfComponents() != 3.
*/
-DataArrayDouble *DataArrayDouble::fromSpherToCart() const throw(INTERP_KERNEL::Exception)
+DataArrayDouble *DataArrayDouble::fromSpherToCart() const
{
checkAllocated();
int nbOfComp=getNumberOfComponents();
* The caller is to delete this result array using decrRef() as it is no more needed.
* \throw If \a this->getNumberOfComponents() != 6.
*/
-DataArrayDouble *DataArrayDouble::doublyContractedProduct() const throw(INTERP_KERNEL::Exception)
+DataArrayDouble *DataArrayDouble::doublyContractedProduct() const
{
checkAllocated();
int nbOfComp=getNumberOfComponents();
* needed.
* \throw If \a this->getNumberOfComponents() is not in [4,6,9].
*/
-DataArrayDouble *DataArrayDouble::determinant() const throw(INTERP_KERNEL::Exception)
+DataArrayDouble *DataArrayDouble::determinant() const
{
checkAllocated();
DataArrayDouble *ret=DataArrayDouble::New();
const double *src=getConstPointer();
double *dest=ret->getPointer();
switch(getNumberOfComponents())
- {
+ {
case 6:
for(int i=0;i<nbOfTuple;i++,dest++,src+=6)
*dest=src[0]*src[1]*src[2]+2.*src[4]*src[5]*src[3]-src[0]*src[4]*src[4]-src[2]*src[3]*src[3]-src[1]*src[5]*src[5];
default:
ret->decrRef();
throw INTERP_KERNEL::Exception("DataArrayDouble::determinant : Invalid number of components ! must be in 4,6,9 !");
- }
+ }
}
/*!
* needed.
* \throw If \a this->getNumberOfComponents() != 6.
*/
-DataArrayDouble *DataArrayDouble::eigenValues() const throw(INTERP_KERNEL::Exception)
+DataArrayDouble *DataArrayDouble::eigenValues() const
{
checkAllocated();
int nbOfComp=getNumberOfComponents();
* needed.
* \throw If \a this->getNumberOfComponents() != 6.
*/
-DataArrayDouble *DataArrayDouble::eigenVectors() const throw(INTERP_KERNEL::Exception)
+DataArrayDouble *DataArrayDouble::eigenVectors() const
{
checkAllocated();
int nbOfComp=getNumberOfComponents();
* needed.
* \throw If \a this->getNumberOfComponents() is not in [4,6,9].
*/
-DataArrayDouble *DataArrayDouble::inverse() const throw(INTERP_KERNEL::Exception)
+DataArrayDouble *DataArrayDouble::inverse() const
{
checkAllocated();
int nbOfComp=getNumberOfComponents();
ret->alloc(nbOfTuple,nbOfComp);
const double *src=getConstPointer();
double *dest=ret->getPointer();
-if(nbOfComp==6)
+ if(nbOfComp==6)
for(int i=0;i<nbOfTuple;i++,dest+=6,src+=6)
{
double det=src[0]*src[1]*src[2]+2.*src[4]*src[5]*src[3]-src[0]*src[4]*src[4]-src[2]*src[3]*src[3]-src[1]*src[5]*src[5];
* needed.
* \throw If \a this->getNumberOfComponents() is not in [4,6,9].
*/
-DataArrayDouble *DataArrayDouble::trace() const throw(INTERP_KERNEL::Exception)
+DataArrayDouble *DataArrayDouble::trace() const
{
checkAllocated();
int nbOfComp=getNumberOfComponents();
* needed.
* \throw If \a this->getNumberOfComponents() != 6.
*/
-DataArrayDouble *DataArrayDouble::deviator() const throw(INTERP_KERNEL::Exception)
+DataArrayDouble *DataArrayDouble::deviator() const
{
checkAllocated();
int nbOfComp=getNumberOfComponents();
* needed.
* \throw If \a this is not allocated.
*/
-DataArrayDouble *DataArrayDouble::magnitude() const throw(INTERP_KERNEL::Exception)
+DataArrayDouble *DataArrayDouble::magnitude() const
{
checkAllocated();
int nbOfComp=getNumberOfComponents();
return ret;
}
+/*!
+ * Computes for each tuple the sum of number of components values in the tuple and return it.
+ *
+ * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
+ * same number of tuples as \a this array and one component.
+ * The caller is to delete this result array using decrRef() as it is no more
+ * needed.
+ * \throw If \a this is not allocated.
+ */
+DataArrayDouble *DataArrayDouble::sumPerTuple() const
+{
+ checkAllocated();
+ int nbOfComp(getNumberOfComponents()),nbOfTuple(getNumberOfTuples());
+ MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret(DataArrayDouble::New());
+ ret->alloc(nbOfTuple,1);
+ const double *src(getConstPointer());
+ double *dest(ret->getPointer());
+ for(int i=0;i<nbOfTuple;i++,dest++,src+=nbOfComp)
+ *dest=std::accumulate(src,src+nbOfComp,0.);
+ return ret.retn();
+}
+
/*!
* Computes the maximal value within every tuple of \a this array.
* \return DataArrayDouble * - the new instance of DataArrayDouble containing the
* \throw If \a this is not allocated.
* \sa DataArrayDouble::maxPerTupleWithCompoId
*/
-DataArrayDouble *DataArrayDouble::maxPerTuple() const throw(INTERP_KERNEL::Exception)
+DataArrayDouble *DataArrayDouble::maxPerTuple() const
{
checkAllocated();
int nbOfComp=getNumberOfComponents();
* \throw If \a this is not allocated.
* \sa DataArrayDouble::maxPerTuple
*/
-DataArrayDouble *DataArrayDouble::maxPerTupleWithCompoId(DataArrayInt* &compoIdOfMaxPerTuple) const throw(INTERP_KERNEL::Exception)
+DataArrayDouble *DataArrayDouble::maxPerTupleWithCompoId(DataArrayInt* &compoIdOfMaxPerTuple) const
{
checkAllocated();
int nbOfComp=getNumberOfComponents();
*
* \sa DataArrayDouble::buildEuclidianDistanceDenseMatrixWith
*/
-DataArrayDouble *DataArrayDouble::buildEuclidianDistanceDenseMatrix() const throw(INTERP_KERNEL::Exception)
+DataArrayDouble *DataArrayDouble::buildEuclidianDistanceDenseMatrix() const
{
checkAllocated();
int nbOfComp=getNumberOfComponents();
*
* \sa DataArrayDouble::buildEuclidianDistanceDenseMatrix
*/
-DataArrayDouble *DataArrayDouble::buildEuclidianDistanceDenseMatrixWith(const DataArrayDouble *other) const throw(INTERP_KERNEL::Exception)
+DataArrayDouble *DataArrayDouble::buildEuclidianDistanceDenseMatrixWith(const DataArrayDouble *other) const
{
if(!other)
throw INTERP_KERNEL::Exception("DataArrayDouble::buildEuclidianDistanceDenseMatrixWith : input parameter is null !");
* in descending order.
* \throw If \a this is not allocated.
*/
-void DataArrayDouble::sortPerTuple(bool asc) throw(INTERP_KERNEL::Exception)
+void DataArrayDouble::sortPerTuple(bool asc)
{
checkAllocated();
double *pt=getPointer();
/*!
* Converts every value of \a this array to its absolute value.
- * \throw If \a this is not allocated.
+ * \b WARNING this method is non const. If a new DataArrayDouble instance should be built containing the result of abs DataArrayDouble::computeAbs
+ * should be called instead.
+ *
+ * \throw If \a this is not allocated.
+ * \sa DataArrayDouble::computeAbs
*/
-void DataArrayDouble::abs() throw(INTERP_KERNEL::Exception)
+void DataArrayDouble::abs()
{
checkAllocated();
- double *ptr=getPointer();
- std::size_t nbOfElems=getNbOfElems();
+ double *ptr(getPointer());
+ std::size_t nbOfElems(getNbOfElems());
std::transform(ptr,ptr+nbOfElems,ptr,std::ptr_fun<double,double>(fabs));
declareAsNew();
}
/*!
- * Apply a liner function to a given component of \a this array, so that
+ * This method builds a new instance of \a this object containing the result of std::abs applied of all elements in \a this.
+ * This method is a const method (that do not change any values in \a this) contrary to DataArrayDouble::abs method.
+ *
+ * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
+ * same number of tuples and component as \a this array.
+ * The caller is to delete this result array using decrRef() as it is no more
+ * needed.
+ * \throw If \a this is not allocated.
+ * \sa DataArrayDouble::abs
+ */
+DataArrayDouble *DataArrayDouble::computeAbs() const
+{
+ checkAllocated();
+ DataArrayDouble *newArr(DataArrayDouble::New());
+ int nbOfTuples(getNumberOfTuples());
+ int nbOfComp(getNumberOfComponents());
+ newArr->alloc(nbOfTuples,nbOfComp);
+ std::transform(begin(),end(),newArr->getPointer(),std::ptr_fun<double,double>(fabs));
+ newArr->copyStringInfoFrom(*this);
+ return newArr;
+}
+
+/*!
+ * Apply a linear function to a given component of \a this array, so that
* an array element <em>(x)</em> becomes \f$ a * x + b \f$.
* \param [in] a - the first coefficient of the function.
* \param [in] b - the second coefficient of the function.
* \param [in] compoId - the index of component to modify.
- * \throw If \a this is not allocated.
+ * \throw If \a this is not allocated, or \a compoId is not in [0,\c this->getNumberOfComponents() ).
*/
-void DataArrayDouble::applyLin(double a, double b, int compoId) throw(INTERP_KERNEL::Exception)
+void DataArrayDouble::applyLin(double a, double b, int compoId)
{
checkAllocated();
- double *ptr=getPointer()+compoId;
- int nbOfComp=getNumberOfComponents();
- int nbOfTuple=getNumberOfTuples();
+ double *ptr(getPointer()+compoId);
+ int nbOfComp(getNumberOfComponents()),nbOfTuple(getNumberOfTuples());
+ if(compoId<0 || compoId>=nbOfComp)
+ {
+ std::ostringstream oss; oss << "DataArrayDouble::applyLin : The compoId requested (" << compoId << ") is not valid ! Must be in [0," << nbOfComp << ") !";
+ throw INTERP_KERNEL::Exception(oss.str().c_str());
+ }
for(int i=0;i<nbOfTuple;i++,ptr+=nbOfComp)
*ptr=a*(*ptr)+b;
declareAsNew();
}
/*!
- * Apply a liner function to all elements of \a this array, so that
+ * Apply a linear function to all elements of \a this array, so that
* an element _x_ becomes \f$ a * x + b \f$.
* \param [in] a - the first coefficient of the function.
* \param [in] b - the second coefficient of the function.
* \throw If \a this is not allocated.
*/
-void DataArrayDouble::applyLin(double a, double b) throw(INTERP_KERNEL::Exception)
+void DataArrayDouble::applyLin(double a, double b)
{
checkAllocated();
double *ptr=getPointer();
* \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)
+void DataArrayDouble::applyInv(double numerator)
{
checkAllocated();
double *ptr=getPointer();
* needed.
* \throw If \a this is not allocated.
*/
-DataArrayDouble *DataArrayDouble::negate() const throw(INTERP_KERNEL::Exception)
+DataArrayDouble *DataArrayDouble::negate() const
{
checkAllocated();
DataArrayDouble *newArr=DataArrayDouble::New();
* 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)
+void DataArrayDouble::applyPow(double val)
{
checkAllocated();
double *ptr=getPointer();
* array, all elements processed before detection of the zero element remain
* modified.
*/
-void DataArrayDouble::applyRPow(double val) throw(INTERP_KERNEL::Exception)
+void DataArrayDouble::applyRPow(double val)
{
checkAllocated();
if(val<0.)
* \throw If \a this is not allocated.
* \throw If \a func returns \a false.
*/
-DataArrayDouble *DataArrayDouble::applyFunc(int nbOfComp, FunctionToEvaluate func) const throw(INTERP_KERNEL::Exception)
+DataArrayDouble *DataArrayDouble::applyFunc(int nbOfComp, FunctionToEvaluate func) const
{
checkAllocated();
DataArrayDouble *newArr=DataArrayDouble::New();
* \param [in] nbOfComp - number of components in the result array.
* \param [in] func - the expression defining how to transform a tuple of \a this array.
* Supported expressions are described \ref MEDCouplingArrayApplyFuncExpr "here".
+ * \param [in] isSafe - By default true. If true invalid operation (division by 0. acos of value > 1. ...) leads to a throw of an exception.
+ * If false the computation is carried on without any notification. When false the evaluation is a little faster.
* \return DataArrayDouble * - the new instance of DataArrayDouble containing the
* same number of tuples as \a this array and \a nbOfComp components.
* The caller is to delete this result array using decrRef() as it is no more
* \throw If \a this is not allocated.
* \throw If computing \a func fails.
*/
-DataArrayDouble *DataArrayDouble::applyFunc(int nbOfComp, const char *func) const throw(INTERP_KERNEL::Exception)
+DataArrayDouble *DataArrayDouble::applyFunc(int nbOfComp, const std::string& func, bool isSafe) const
{
- checkAllocated();
INTERP_KERNEL::ExprParser expr(func);
expr.parse();
std::set<std::string> vars;
expr.getTrueSetOfVars(vars);
- int oldNbOfComp=getNumberOfComponents();
- if((int)vars.size()>oldNbOfComp)
- {
- std::ostringstream oss; oss << "The field has " << oldNbOfComp << " components and there are ";
- oss << vars.size() << " variables : ";
- std::copy(vars.begin(),vars.end(),std::ostream_iterator<std::string>(oss," "));
- throw INTERP_KERNEL::Exception(oss.str().c_str());
- }
std::vector<std::string> varsV(vars.begin(),vars.end());
- expr.prepareExprEvaluation(varsV,oldNbOfComp,nbOfComp);
- //
- DataArrayDouble *newArr=DataArrayDouble::New();
- int nbOfTuples=getNumberOfTuples();
- newArr->alloc(nbOfTuples,nbOfComp);
- const double *ptr=getConstPointer();
- double *ptrToFill=newArr->getPointer();
- for(int i=0;i<nbOfTuples;i++)
- {
- try
- {
- expr.evaluateExpr(nbOfComp,ptr+i*oldNbOfComp,ptrToFill+i*nbOfComp);
- }
- catch(INTERP_KERNEL::Exception& e)
- {
- std::ostringstream oss; oss << "For tuple # " << i << " with value (";
- std::copy(ptr+oldNbOfComp*i,ptr+oldNbOfComp*(i+1),std::ostream_iterator<double>(oss,", "));
- oss << ") : Evaluation of function failed !" << e.what();
- newArr->decrRef();
- throw INTERP_KERNEL::Exception(oss.str().c_str());
- }
- }
- return newArr;
+ return applyFunc3(nbOfComp,varsV,func,isSafe);
}
/*!
* Returns a new DataArrayDouble created from \a this one by applying a function to every
- * tuple of \a this array. Textual data is not copied.
+ * tuple of \a this array. Textual data is not copied. This method works by tuples (whatever its size).
+ * If \a this is a one component array, call applyFuncOnThis instead that performs the same work faster.
+ *
* For more info see \ref MEDCouplingArrayApplyFunc0.
* \param [in] func - the expression defining how to transform a tuple of \a this array.
* Supported expressions are described \ref MEDCouplingArrayApplyFuncExpr "here".
+ * \param [in] isSafe - By default true. If true invalid operation (division by 0. acos of value > 1. ...) leads to a throw of an exception.
+ * If false the computation is carried on without any notification. When false the evaluation is a little faster.
* \return DataArrayDouble * - the new instance of DataArrayDouble containing the
* same number of tuples and components as \a this array.
* The caller is to delete this result array using decrRef() as it is no more
* needed.
+ * \sa applyFuncOnThis
* \throw If \a this is not allocated.
* \throw If computing \a func fails.
*/
-DataArrayDouble *DataArrayDouble::applyFunc(const char *func) const throw(INTERP_KERNEL::Exception)
+DataArrayDouble *DataArrayDouble::applyFunc(const std::string& func, bool isSafe) const
{
+ int nbOfComp(getNumberOfComponents());
+ if(nbOfComp<=0)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::applyFunc : output number of component must be > 0 !");
checkAllocated();
+ int nbOfTuples(getNumberOfTuples());
+ MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> newArr(DataArrayDouble::New());
+ newArr->alloc(nbOfTuples,nbOfComp);
INTERP_KERNEL::ExprParser expr(func);
expr.parse();
- expr.prepareExprEvaluationVec();
- //
- DataArrayDouble *newArr=DataArrayDouble::New();
- int nbOfTuples=getNumberOfTuples();
- int nbOfComp=getNumberOfComponents();
- newArr->alloc(nbOfTuples,nbOfComp);
- const double *ptr=getConstPointer();
- double *ptrToFill=newArr->getPointer();
- for(int i=0;i<nbOfTuples;i++)
+ std::set<std::string> vars;
+ 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::copy(vars.begin(),vars.end(),std::ostream_iterator<std::string>(oss," "));
+ throw INTERP_KERNEL::Exception(oss.str().c_str());
+ }
+ if(vars.empty())
{
- try
+ expr.prepareFastEvaluator();
+ newArr->rearrange(1);
+ newArr->fillWithValue(expr.evaluateDouble());
+ newArr->rearrange(nbOfComp);
+ return newArr.retn();
+ }
+ std::vector<std::string> vars2(vars.begin(),vars.end());
+ double buff,*ptrToFill(newArr->getPointer());
+ const double *ptr(begin());
+ std::vector<double> stck;
+ expr.prepareExprEvaluationDouble(vars2,1,1,0,&buff,&buff+1);
+ expr.prepareFastEvaluator();
+ if(!isSafe)
+ {
+ for(int i=0;i<nbOfTuples;i++)
{
- expr.evaluateExpr(nbOfComp,ptr+i*nbOfComp,ptrToFill+i*nbOfComp);
+ for(int iComp=0;iComp<nbOfComp;iComp++,ptr++,ptrToFill++)
+ {
+ buff=*ptr;
+ expr.evaluateDoubleInternal(stck);
+ *ptrToFill=stck.back();
+ stck.pop_back();
+ }
}
- catch(INTERP_KERNEL::Exception& e)
+ }
+ else
+ {
+ for(int i=0;i<nbOfTuples;i++)
{
- std::ostringstream oss; oss << "For tuple # " << i << " with value (";
- std::copy(ptr+nbOfComp*i,ptr+nbOfComp*(i+1),std::ostream_iterator<double>(oss,", "));
- oss << ") : Evaluation of function failed ! " << e.what();
- newArr->decrRef();
- throw INTERP_KERNEL::Exception(oss.str().c_str());
+ for(int iComp=0;iComp<nbOfComp;iComp++,ptr++,ptrToFill++)
+ {
+ buff=*ptr;
+ try
+ {
+ expr.evaluateDoubleInternalSafe(stck);
+ }
+ catch(INTERP_KERNEL::Exception& e)
+ {
+ std::ostringstream oss; oss << "For tuple # " << i << " component # " << iComp << " with value (";
+ oss << buff;
+ oss << ") : Evaluation of function failed !" << e.what();
+ throw INTERP_KERNEL::Exception(oss.str().c_str());
+ }
+ *ptrToFill=stck.back();
+ stck.pop_back();
+ }
}
}
- return newArr;
+ return newArr.retn();
}
/*!
- * Returns a new DataArrayDouble created from \a this one by applying a function to every
- * tuple of \a this array. Textual data is not copied.
- * For more info see \ref MEDCouplingArrayApplyFunc2.
- * \param [in] nbOfComp - number of components in the result array.
+ * This method is a non const method that modify the array in \a this.
+ * This method only works on one component array. It means that function \a func must
+ * contain at most one variable.
+ * This method is a specialization of applyFunc method with one parameter on one component array.
+ *
* \param [in] func - the expression defining how to transform a tuple of \a this array.
* Supported expressions are described \ref MEDCouplingArrayApplyFuncExpr "here".
- * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
- * same number of tuples as \a this array.
- * The caller is to delete this result array using decrRef() as it is no more
- * needed.
- * \throw If \a this is not allocated.
- * \throw If \a func contains vars that are not in \a this->getInfoOnComponent().
- * \throw If computing \a func fails.
+ * \param [in] isSafe - By default true. If true invalid operation (division by 0. acos of value > 1. ...) leads to a throw of an exception.
+ * If false the computation is carried on without any notification. When false the evaluation is a little faster.
+ *
+ * \sa applyFunc
*/
-DataArrayDouble *DataArrayDouble::applyFunc2(int nbOfComp, const char *func) const throw(INTERP_KERNEL::Exception)
+void DataArrayDouble::applyFuncOnThis(const std::string& func, bool isSafe)
{
+ int nbOfComp(getNumberOfComponents());
+ if(nbOfComp<=0)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::applyFuncOnThis : output number of component must be > 0 !");
checkAllocated();
+ int nbOfTuples(getNumberOfTuples());
INTERP_KERNEL::ExprParser expr(func);
expr.parse();
std::set<std::string> vars;
expr.getTrueSetOfVars(vars);
- int oldNbOfComp=getNumberOfComponents();
- if((int)vars.size()>oldNbOfComp)
+ if((int)vars.size()>1)
{
- std::ostringstream oss; oss << "The field has " << oldNbOfComp << " components and there are ";
- oss << vars.size() << " variables : ";
+ 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::copy(vars.begin(),vars.end(),std::ostream_iterator<std::string>(oss," "));
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
- expr.prepareExprEvaluation(getVarsOnComponent(),oldNbOfComp,nbOfComp);
- //
- DataArrayDouble *newArr=DataArrayDouble::New();
- int nbOfTuples=getNumberOfTuples();
- newArr->alloc(nbOfTuples,nbOfComp);
- const double *ptr=getConstPointer();
- double *ptrToFill=newArr->getPointer();
- for(int i=0;i<nbOfTuples;i++)
+ if(vars.empty())
+ {
+ expr.prepareFastEvaluator();
+ std::vector<std::string> compInfo(getInfoOnComponents());
+ rearrange(1);
+ fillWithValue(expr.evaluateDouble());
+ rearrange(nbOfComp);
+ setInfoOnComponents(compInfo);
+ return ;
+ }
+ std::vector<std::string> vars2(vars.begin(),vars.end());
+ double buff,*ptrToFill(getPointer());
+ const double *ptr(begin());
+ std::vector<double> stck;
+ expr.prepareExprEvaluationDouble(vars2,1,1,0,&buff,&buff+1);
+ expr.prepareFastEvaluator();
+ if(!isSafe)
{
- try
+ for(int i=0;i<nbOfTuples;i++)
{
- expr.evaluateExpr(nbOfComp,ptr+i*oldNbOfComp,ptrToFill+i*nbOfComp);
+ for(int iComp=0;iComp<nbOfComp;iComp++,ptr++,ptrToFill++)
+ {
+ buff=*ptr;
+ expr.evaluateDoubleInternal(stck);
+ *ptrToFill=stck.back();
+ stck.pop_back();
+ }
}
- catch(INTERP_KERNEL::Exception& e)
+ }
+ else
+ {
+ for(int i=0;i<nbOfTuples;i++)
{
- std::ostringstream oss; oss << "For tuple # " << i << " with value (";
- std::copy(ptr+oldNbOfComp*i,ptr+oldNbOfComp*(i+1),std::ostream_iterator<double>(oss,", "));
- oss << ") : Evaluation of function failed !" << e.what();
- newArr->decrRef();
- throw INTERP_KERNEL::Exception(oss.str().c_str());
+ for(int iComp=0;iComp<nbOfComp;iComp++,ptr++,ptrToFill++)
+ {
+ buff=*ptr;
+ try
+ {
+ expr.evaluateDoubleInternalSafe(stck);
+ }
+ catch(INTERP_KERNEL::Exception& e)
+ {
+ std::ostringstream oss; oss << "For tuple # " << i << " component # " << iComp << " with value (";
+ oss << buff;
+ oss << ") : Evaluation of function failed !" << e.what();
+ throw INTERP_KERNEL::Exception(oss.str().c_str());
+ }
+ *ptrToFill=stck.back();
+ stck.pop_back();
+ }
}
}
- return newArr;
+}
+
+/*!
+ * Returns a new DataArrayDouble created from \a this one by applying a function to every
+ * tuple of \a this array. Textual data is not copied.
+ * For more info see \ref MEDCouplingArrayApplyFunc2.
+ * \param [in] nbOfComp - number of components in the result array.
+ * \param [in] func - the expression defining how to transform a tuple of \a this array.
+ * Supported expressions are described \ref MEDCouplingArrayApplyFuncExpr "here".
+ * \param [in] isSafe - By default true. If true invalid operation (division by 0. acos of value > 1. ...) leads to a throw of an exception.
+ * If false the computation is carried on without any notification. When false the evaluation is a little faster.
+ * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
+ * same number of tuples as \a this array.
+ * The caller is to delete this result array using decrRef() as it is no more
+ * needed.
+ * \throw If \a this is not allocated.
+ * \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
+{
+ return applyFunc3(nbOfComp,getVarsOnComponent(),func,isSafe);
}
/*!
* \param [in] varsOrder - sequence of vars defining their order.
* \param [in] func - the expression defining how to transform a tuple of \a this array.
* Supported expressions are described \ref MEDCouplingArrayApplyFuncExpr "here".
+ * \param [in] isSafe - By default true. If true invalid operation (division by 0. acos of value > 1. ...) leads to a throw of an exception.
+ * If false the computation is carried on without any notification. When false the evaluation is a little faster.
* \return DataArrayDouble * - the new instance of DataArrayDouble containing the
* same number of tuples as \a this array.
* The caller is to delete this result array using decrRef() as it is no more
* \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 char *func) const throw(INTERP_KERNEL::Exception)
+DataArrayDouble *DataArrayDouble::applyFunc3(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 !");
+ std::vector<std::string> varsOrder2(varsOrder);
+ int oldNbOfComp(getNumberOfComponents());
+ for(int i=(int)varsOrder.size();i<oldNbOfComp;i++)
+ varsOrder2.push_back(std::string());
checkAllocated();
+ int nbOfTuples(getNumberOfTuples());
INTERP_KERNEL::ExprParser expr(func);
expr.parse();
std::set<std::string> vars;
expr.getTrueSetOfVars(vars);
- int oldNbOfComp=getNumberOfComponents();
if((int)vars.size()>oldNbOfComp)
{
std::ostringstream oss; oss << "The field has " << oldNbOfComp << " components and there are ";
std::copy(vars.begin(),vars.end(),std::ostream_iterator<std::string>(oss," "));
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
- expr.prepareExprEvaluation(varsOrder,oldNbOfComp,nbOfComp);
- //
- DataArrayDouble *newArr=DataArrayDouble::New();
- int nbOfTuples=getNumberOfTuples();
+ MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> newArr(DataArrayDouble::New());
newArr->alloc(nbOfTuples,nbOfComp);
- const double *ptr=getConstPointer();
- double *ptrToFill=newArr->getPointer();
- for(int i=0;i<nbOfTuples;i++)
- {
- try
- {
- expr.evaluateExpr(nbOfComp,ptr+i*oldNbOfComp,ptrToFill+i*nbOfComp);
+ INTERP_KERNEL::AutoPtr<double> buff(new double[oldNbOfComp]);
+ double *buffPtr(buff),*ptrToFill;
+ std::vector<double> stck;
+ for(int iComp=0;iComp<nbOfComp;iComp++)
+ {
+ expr.prepareExprEvaluationDouble(varsOrder2,oldNbOfComp,nbOfComp,iComp,buffPtr,buffPtr+oldNbOfComp);
+ expr.prepareFastEvaluator();
+ const double *ptr(getConstPointer());
+ ptrToFill=newArr->getPointer()+iComp;
+ if(!isSafe)
+ {
+ for(int i=0;i<nbOfTuples;i++,ptrToFill+=nbOfComp,ptr+=oldNbOfComp)
+ {
+ std::copy(ptr,ptr+oldNbOfComp,buffPtr);
+ expr.evaluateDoubleInternal(stck);
+ *ptrToFill=stck.back();
+ stck.pop_back();
+ }
}
- catch(INTERP_KERNEL::Exception& e)
+ else
{
- std::ostringstream oss; oss << "For tuple # " << i << " with value (";
- std::copy(ptr+oldNbOfComp*i,ptr+oldNbOfComp*(i+1),std::ostream_iterator<double>(oss,", "));
- oss << ") : Evaluation of function failed !" << e.what();
- newArr->decrRef();
- throw INTERP_KERNEL::Exception(oss.str().c_str());
+ for(int i=0;i<nbOfTuples;i++,ptrToFill+=nbOfComp,ptr+=oldNbOfComp)
+ {
+ std::copy(ptr,ptr+oldNbOfComp,buffPtr);
+ try
+ {
+ expr.evaluateDoubleInternalSafe(stck);
+ *ptrToFill=stck.back();
+ stck.pop_back();
+ }
+ catch(INTERP_KERNEL::Exception& e)
+ {
+ std::ostringstream oss; oss << "For tuple # " << i << " with value (";
+ std::copy(ptr+oldNbOfComp*i,ptr+oldNbOfComp*(i+1),std::ostream_iterator<double>(oss,", "));
+ oss << ") : Evaluation of function failed !" << e.what();
+ throw INTERP_KERNEL::Exception(oss.str().c_str());
+ }
+ }
}
}
- return newArr;
+ return newArr.retn();
}
-void DataArrayDouble::applyFuncFast32(const char *func) throw(INTERP_KERNEL::Exception)
+void DataArrayDouble::applyFuncFast32(const std::string& func)
{
checkAllocated();
INTERP_KERNEL::ExprParser expr(func);
declareAsNew();
}
-void DataArrayDouble::applyFuncFast64(const char *func) throw(INTERP_KERNEL::Exception)
+void DataArrayDouble::applyFuncFast64(const std::string& func)
{
checkAllocated();
INTERP_KERNEL::ExprParser expr(func);
declareAsNew();
}
-DataArrayDoubleIterator *DataArrayDouble::iterator() throw(INTERP_KERNEL::Exception)
+DataArrayDoubleIterator *DataArrayDouble::iterator()
{
return new DataArrayDoubleIterator(this);
}
* needed.
* \throw If \a this->getNumberOfComponents() != 1.
*
+ * \sa DataArrayDouble::getIdsNotInRange
+ *
+ * \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 throw(INTERP_KERNEL::Exception)
+DataArrayInt *DataArrayDouble::getIdsInRange(double vmin, double vmax) const
{
checkAllocated();
if(getNumberOfComponents()!=1)
throw INTERP_KERNEL::Exception("DataArrayDouble::getIdsInRange : this must have exactly one component !");
- const double *cptr=getConstPointer();
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(0,1);
- int nbOfTuples=getNumberOfTuples();
+ const double *cptr(begin());
+ 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)
ret->pushBackSilent(i);
return ret.retn();
}
+/*!
+ * Returns a new DataArrayInt contating indices of tuples of \a this one-dimensional
+ * array whose values are not within a given range. Textual data is not copied.
+ * \param [in] vmin - a lowest not acceptable value (excluded).
+ * \param [in] vmax - a greatest not acceptable value (excluded).
+ * \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.
+ *
+ * \sa DataArrayDouble::getIdsInRange
+ */
+DataArrayInt *DataArrayDouble::getIdsNotInRange(double vmin, double vmax) const
+{
+ checkAllocated();
+ if(getNumberOfComponents()!=1)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::getIdsNotInRange : this must have exactly one component !");
+ const double *cptr(begin());
+ 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)
+ ret->pushBackSilent(i);
+ return ret.retn();
+}
+
/*!
* Returns a new DataArrayDouble by concatenating two given arrays, so that (1) the number
* of tuples in the result array is a sum of the number of tuples of given arrays and (2)
* \throw If both \a a1 and \a a2 are NULL.
* \throw If \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents().
*/
-DataArrayDouble *DataArrayDouble::Aggregate(const DataArrayDouble *a1, const DataArrayDouble *a2) throw(INTERP_KERNEL::Exception)
+DataArrayDouble *DataArrayDouble::Aggregate(const DataArrayDouble *a1, const DataArrayDouble *a2)
{
std::vector<const DataArrayDouble *> tmp(2);
tmp[0]=a1; tmp[1]=a2;
* the number of component in the result array is same as that of each of given arrays.
* Info on components is copied from the first of the given arrays. Number of components
* in the given arrays must be the same.
+ * If the number of non null of elements in \a arr is equal to one the returned object is a copy of it
+ * not the object itself.
* \param [in] arr - a sequence of arrays to include in the result array.
* \return DataArrayDouble * - the new instance of DataArrayDouble.
* The caller is to delete this result array using decrRef() as it is no more
* \throw If all arrays within \a arr are NULL.
* \throw If getNumberOfComponents() of arrays within \a arr.
*/
-DataArrayDouble *DataArrayDouble::Aggregate(const std::vector<const DataArrayDouble *>& arr) throw(INTERP_KERNEL::Exception)
+DataArrayDouble *DataArrayDouble::Aggregate(const std::vector<const DataArrayDouble *>& arr)
{
std::vector<const DataArrayDouble *> a;
for(std::vector<const DataArrayDouble *>::const_iterator it4=arr.begin();it4!=arr.end();it4++)
* \throw If any given array is not allocated.
* \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
*/
-DataArrayDouble *DataArrayDouble::Meld(const DataArrayDouble *a1, const DataArrayDouble *a2) throw(INTERP_KERNEL::Exception)
+DataArrayDouble *DataArrayDouble::Meld(const DataArrayDouble *a1, const DataArrayDouble *a2)
{
std::vector<const DataArrayDouble *> arr(2);
arr[0]=a1; arr[1]=a2;
* \throw If any given array is not allocated.
* \throw If getNumberOfTuples() of arrays within \a arr is different.
*/
-DataArrayDouble *DataArrayDouble::Meld(const std::vector<const DataArrayDouble *>& arr) throw(INTERP_KERNEL::Exception)
+DataArrayDouble *DataArrayDouble::Meld(const std::vector<const DataArrayDouble *>& arr)
{
std::vector<const DataArrayDouble *> a;
for(std::vector<const DataArrayDouble *>::const_iterator it4=arr.begin();it4!=arr.end();it4++)
int k=0;
for(int i=0;i<(int)a.size();i++)
for(int j=0;j<nbc[i];j++,k++)
- ret->setInfoOnComponent(k,a[i]->getInfoOnComponent(j).c_str());
+ ret->setInfoOnComponent(k,a[i]->getInfoOnComponent(j));
return ret;
}
* \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
* \throw If \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents()
*/
-DataArrayDouble *DataArrayDouble::Dot(const DataArrayDouble *a1, const DataArrayDouble *a2) throw(INTERP_KERNEL::Exception)
+DataArrayDouble *DataArrayDouble::Dot(const DataArrayDouble *a1, const DataArrayDouble *a2)
{
if(!a1 || !a2)
throw INTERP_KERNEL::Exception("DataArrayDouble::Dot : input DataArrayDouble instance is NULL !");
sum+=a1Ptr[i*nbOfComp+j]*a2Ptr[i*nbOfComp+j];
retPtr[i]=sum;
}
- ret->setInfoOnComponent(0,a1->getInfoOnComponent(0).c_str());
- ret->setName(a1->getName().c_str());
+ ret->setInfoOnComponent(0,a1->getInfoOnComponent(0));
+ ret->setName(a1->getName());
return ret;
}
* \throw If \a a1->getNumberOfComponents() != 3
* \throw If \a a2->getNumberOfComponents() != 3
*/
-DataArrayDouble *DataArrayDouble::CrossProduct(const DataArrayDouble *a1, const DataArrayDouble *a2) throw(INTERP_KERNEL::Exception)
+DataArrayDouble *DataArrayDouble::CrossProduct(const DataArrayDouble *a1, const DataArrayDouble *a2)
{
if(!a1 || !a2)
throw INTERP_KERNEL::Exception("DataArrayDouble::CrossProduct : input DataArrayDouble instance is NULL !");
* \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
* \throw If \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents()
*/
-DataArrayDouble *DataArrayDouble::Max(const DataArrayDouble *a1, const DataArrayDouble *a2) throw(INTERP_KERNEL::Exception)
+DataArrayDouble *DataArrayDouble::Max(const DataArrayDouble *a1, const DataArrayDouble *a2)
{
if(!a1 || !a2)
throw INTERP_KERNEL::Exception("DataArrayDouble::Max : input DataArrayDouble instance is NULL !");
* \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
* \throw If \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents()
*/
-DataArrayDouble *DataArrayDouble::Min(const DataArrayDouble *a1, const DataArrayDouble *a2) throw(INTERP_KERNEL::Exception)
+DataArrayDouble *DataArrayDouble::Min(const DataArrayDouble *a1, const DataArrayDouble *a2)
{
if(!a1 || !a2)
throw INTERP_KERNEL::Exception("DataArrayDouble::Min : input DataArrayDouble instance is NULL !");
* \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
* none of them has number of tuples or components equal to 1.
*/
-DataArrayDouble *DataArrayDouble::Add(const DataArrayDouble *a1, const DataArrayDouble *a2) throw(INTERP_KERNEL::Exception)
+DataArrayDouble *DataArrayDouble::Add(const DataArrayDouble *a1, const DataArrayDouble *a2)
{
if(!a1 || !a2)
throw INTERP_KERNEL::Exception("DataArrayDouble::Add : input DataArrayDouble instance is NULL !");
* \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
* \a other has number of both tuples and components not equal to 1.
*/
-void DataArrayDouble::addEqual(const DataArrayDouble *other) throw(INTERP_KERNEL::Exception)
+void DataArrayDouble::addEqual(const DataArrayDouble *other)
{
if(!other)
throw INTERP_KERNEL::Exception("DataArrayDouble::addEqual : input DataArrayDouble instance is NULL !");
* \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
* none of them has number of tuples or components equal to 1.
*/
-DataArrayDouble *DataArrayDouble::Substract(const DataArrayDouble *a1, const DataArrayDouble *a2) throw(INTERP_KERNEL::Exception)
+DataArrayDouble *DataArrayDouble::Substract(const DataArrayDouble *a1, const DataArrayDouble *a2)
{
if(!a1 || !a2)
throw INTERP_KERNEL::Exception("DataArrayDouble::Substract : input DataArrayDouble instance is NULL !");
* \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
* \a other has number of both tuples and components not equal to 1.
*/
-void DataArrayDouble::substractEqual(const DataArrayDouble *other) throw(INTERP_KERNEL::Exception)
+void DataArrayDouble::substractEqual(const DataArrayDouble *other)
{
if(!other)
throw INTERP_KERNEL::Exception("DataArrayDouble::substractEqual : input DataArrayDouble instance is NULL !");
* \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
* none of them has number of tuples or components equal to 1.
*/
-DataArrayDouble *DataArrayDouble::Multiply(const DataArrayDouble *a1, const DataArrayDouble *a2) throw(INTERP_KERNEL::Exception)
+DataArrayDouble *DataArrayDouble::Multiply(const DataArrayDouble *a1, const DataArrayDouble *a2)
{
if(!a1 || !a2)
throw INTERP_KERNEL::Exception("DataArrayDouble::Multiply : input DataArrayDouble instance is NULL !");
* \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
* \a other has number of both tuples and components not equal to 1.
*/
-void DataArrayDouble::multiplyEqual(const DataArrayDouble *other) throw(INTERP_KERNEL::Exception)
+void DataArrayDouble::multiplyEqual(const DataArrayDouble *other)
{
if(!other)
throw INTERP_KERNEL::Exception("DataArrayDouble::multiplyEqual : input DataArrayDouble instance is NULL !");
* \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
* none of them has number of tuples or components equal to 1.
*/
-DataArrayDouble *DataArrayDouble::Divide(const DataArrayDouble *a1, const DataArrayDouble *a2) throw(INTERP_KERNEL::Exception)
+DataArrayDouble *DataArrayDouble::Divide(const DataArrayDouble *a1, const DataArrayDouble *a2)
{
if(!a1 || !a2)
throw INTERP_KERNEL::Exception("DataArrayDouble::Divide : input DataArrayDouble instance is NULL !");
* \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
* \a other has number of both tuples and components not equal to 1.
*/
-void DataArrayDouble::divideEqual(const DataArrayDouble *other) throw(INTERP_KERNEL::Exception)
+void DataArrayDouble::divideEqual(const DataArrayDouble *other)
{
if(!other)
throw INTERP_KERNEL::Exception("DataArrayDouble::divideEqual : input DataArrayDouble instance is NULL !");
* \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)
+DataArrayDouble *DataArrayDouble::Pow(const DataArrayDouble *a1, const DataArrayDouble *a2)
{
if(!a1 || !a2)
throw INTERP_KERNEL::Exception("DataArrayDouble::Pow : at least one of input instances is null !");
* \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)
+void DataArrayDouble::powEqual(const DataArrayDouble *other)
{
if(!other)
throw INTERP_KERNEL::Exception("DataArrayDouble::powEqual : input instance is null !");
declareAsNew();
}
+/*!
+ * This method is \b NOT wrapped into python because it can be useful only for performance reasons in C++ context.
+ * All values in \a this must be 0. or 1. within eps error. 0 means false, 1 means true.
+ * If an another value than 0 or 1 appear (within eps precision) an INTERP_KERNEL::Exception will be thrown.
+ *
+ * \throw if \a this is not allocated.
+ * \throw if \a this has not exactly one component.
+ */
+std::vector<bool> DataArrayDouble::toVectorOfBool(double eps) const
+{
+ checkAllocated();
+ if(getNumberOfComponents()!=1)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::toVectorOfBool : must be applied on single component array !");
+ int nbt(getNumberOfTuples());
+ std::vector<bool> ret(nbt);
+ const double *pt(begin());
+ for(int i=0;i<nbt;i++)
+ {
+ if(fabs(pt[i])<eps)
+ ret[i]=false;
+ else if(fabs(pt[i]-1.)<eps)
+ ret[i]=true;
+ else
+ {
+ std::ostringstream oss; oss << "DataArrayDouble::toVectorOfBool : the tuple #" << i << " has value " << pt[i] << " is invalid ! must be 0. or 1. !";
+ throw INTERP_KERNEL::Exception(oss.str().c_str());
+ }
+ }
+ return ret;
+}
+
/*!
* Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
* Server side.
*/
void DataArrayDouble::finishUnserialization(const std::vector<int>& tinyInfoI, const std::vector<std::string>& tinyInfoS)
{
- setName(tinyInfoS[0].c_str());
+ setName(tinyInfoS[0]);
if(isAllocated())
{
int nbOfCompo=getNumberOfComponents();
for(int i=0;i<nbOfCompo;i++)
- setInfoOnComponent(i,tinyInfoS[i+1].c_str());
+ setInfoOnComponent(i,tinyInfoS[i+1]);
}
}
_da->decrRef();
}
-DataArrayDoubleTuple *DataArrayDoubleIterator::nextt() throw(INTERP_KERNEL::Exception)
+DataArrayDoubleTuple *DataArrayDoubleIterator::nextt()
{
if(_tuple_id<_nb_tuple)
{
}
-std::string DataArrayDoubleTuple::repr() const throw(INTERP_KERNEL::Exception)
+std::string DataArrayDoubleTuple::repr() const
{
std::ostringstream oss; oss.precision(17); oss << "(";
for(int i=0;i<_nb_of_compo-1;i++)
return oss.str();
}
-double DataArrayDoubleTuple::doubleValue() const throw(INTERP_KERNEL::Exception)
+double DataArrayDoubleTuple::doubleValue() const
{
if(_nb_of_compo==1)
return *_pt;
* This method throws an INTERP_KERNEL::Exception is it is impossible to match sizes of \b this that is too say \b nbOfCompo=this->_nb_of_elem and \bnbOfTuples==1 or
* \b nbOfCompo=1 and \bnbOfTuples==this->_nb_of_elem.
*/
-DataArrayDouble *DataArrayDoubleTuple::buildDADouble(int nbOfTuples, int nbOfCompo) const throw(INTERP_KERNEL::Exception)
+DataArrayDouble *DataArrayDoubleTuple::buildDADouble(int nbOfTuples, int nbOfCompo) const
{
if((_nb_of_compo==nbOfCompo && nbOfTuples==1) || (_nb_of_compo==nbOfTuples && nbOfCompo==1))
{
* 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 throw(INTERP_KERNEL::Exception)
+bool DataArrayInt::isAllocated() const
{
return getConstPointer()!=0;
}
* Checks if raw data is allocated and throws an exception if it is not the case.
* \throw If the raw data is not allocated.
*/
-void DataArrayInt::checkAllocated() const throw(INTERP_KERNEL::Exception)
+void DataArrayInt::checkAllocated() const
{
if(!isAllocated())
throw INTERP_KERNEL::Exception("DataArrayInt::checkAllocated : Array is defined but not allocated ! Call alloc or setValues method first !");
* After call of this method, DataArrayInt::isAllocated will return false.
* If \a this is already not allocated, \a this is let unchanged.
*/
-void DataArrayInt::desallocate() throw(INTERP_KERNEL::Exception)
+void DataArrayInt::desallocate()
{
_mem.destroy();
}
-std::size_t DataArrayInt::getHeapMemorySize() const
+std::size_t DataArrayInt::getHeapMemorySizeWithoutChildren() const
{
- std::size_t sz=_mem.getNbOfElemAllocated();
+ std::size_t sz(_mem.getNbOfElemAllocated());
sz*=sizeof(int);
- return DataArray::getHeapMemorySize()+sz;
+ return DataArray::getHeapMemorySizeWithoutChildren()+sz;
}
/*!
* \return double - the sole value stored in \a this array.
* \throw If at least one of conditions stated above is not fulfilled.
*/
-int DataArrayInt::intValue() const throw(INTERP_KERNEL::Exception)
+int DataArrayInt::intValue() const
{
if(isAllocated())
{
* \return int - the hash value.
* \throw If \a this is not allocated.
*/
-int DataArrayInt::getHashCode() const throw(INTERP_KERNEL::Exception)
+int DataArrayInt::getHashCode() const
{
checkAllocated();
std::size_t nbOfElems=getNbOfElems();
* \return bool - \a true if getNumberOfTuples() == 0, \a false else.
* \throw If \a this is not allocated.
*/
-bool DataArrayInt::empty() const throw(INTERP_KERNEL::Exception)
+bool DataArrayInt::empty() const
{
checkAllocated();
return getNumberOfTuples()==0;
* \ref MEDCouplingArrayBasicsCopyDeep.
* \return DataArrayInt * - a new instance of DataArrayInt.
*/
-DataArrayInt *DataArrayInt::deepCpy() const throw(INTERP_KERNEL::Exception)
+DataArrayInt *DataArrayInt::deepCpy() 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 throw(INTERP_KERNEL::Exception)
+DataArrayInt *DataArrayInt::performCpy(bool dCpy) const
{
if(dCpy)
return deepCpy();
* \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) throw(INTERP_KERNEL::Exception)
+void DataArrayInt::cpyFrom(const DataArrayInt& other)
{
other.checkAllocated();
int nbOfTuples=other.getNumberOfTuples();
*
* \sa DataArrayInt::pack, DataArrayInt::pushBackSilent, DataArrayInt::pushBackValsSilent
*/
-void DataArrayInt::reserve(std::size_t nbOfElems) throw(INTERP_KERNEL::Exception)
+void DataArrayInt::reserve(std::size_t nbOfElems)
{
int nbCompo=getNumberOfComponents();
if(nbCompo==1)
* \throw If \a this has already been allocated with number of components different from one.
* \sa DataArrayInt::pushBackValsSilent
*/
-void DataArrayInt::pushBackSilent(int val) throw(INTERP_KERNEL::Exception)
+void DataArrayInt::pushBackSilent(int val)
{
int nbCompo=getNumberOfComponents();
if(nbCompo==1)
* \throw If \a this has already been allocated with number of components different from one.
* \sa DataArrayInt::pushBackSilent
*/
-void DataArrayInt::pushBackValsSilent(const int *valsBg, const int *valsEnd) throw(INTERP_KERNEL::Exception)
+void DataArrayInt::pushBackValsSilent(const int *valsBg, const int *valsEnd)
{
int nbCompo=getNumberOfComponents();
if(nbCompo==1)
* \throw If \a this is already empty.
* \throw If \a this has number of components different from one.
*/
-int DataArrayInt::popBackSilent() throw(INTERP_KERNEL::Exception)
+int DataArrayInt::popBackSilent()
{
if(getNumberOfComponents()==1)
return _mem.popBack();
/*!
* This method \b do \b not modify content of \a this. It only modify its memory footprint if the allocated memory is to high regarding real data to store.
*
- * \sa DataArrayInt::getHeapMemorySize, DataArrayInt::reserve
+ * \sa DataArrayInt::getHeapMemorySizeWithoutChildren, DataArrayInt::reserve
*/
-void DataArrayInt::pack() const throw(INTERP_KERNEL::Exception)
+void DataArrayInt::pack() const
{
_mem.pack();
}
* \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) throw(INTERP_KERNEL::Exception)
+void DataArrayInt::allocIfNecessary(int nbOfTuple, int nbOfCompo)
{
if(isAllocated())
{
* \param [in] nbOfCompo - number of components of data to allocate.
* \throw If \a nbOfTuple < 0 or \a nbOfCompo < 0.
*/
-void DataArrayInt::alloc(int nbOfTuple, int nbOfCompo) throw(INTERP_KERNEL::Exception)
+void DataArrayInt::alloc(int nbOfTuple, int nbOfCompo)
{
if(nbOfTuple<0 || nbOfCompo<0)
throw INTERP_KERNEL::Exception("DataArrayInt::alloc : request for negative length of data !");
* \ref MEDCouplingArrayFill.
* \throw If \a this is not allocated.
*/
-void DataArrayInt::fillWithZero() throw(INTERP_KERNEL::Exception)
+void DataArrayInt::fillWithZero()
{
checkAllocated();
_mem.fillWithValue(0);
* \param [in] val - the value to fill with.
* \throw If \a this is not allocated.
*/
-void DataArrayInt::fillWithValue(int val) throw(INTERP_KERNEL::Exception)
+void DataArrayInt::fillWithValue(int val)
{
checkAllocated();
_mem.fillWithValue(val);
* \throw If \a this->getNumberOfComponents() != 1
* \throw If \a this is not allocated.
*/
-void DataArrayInt::iota(int init) throw(INTERP_KERNEL::Exception)
+void DataArrayInt::iota(int init)
{
checkAllocated();
if(getNumberOfComponents()!=1)
* 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 throw(INTERP_KERNEL::Exception)
+std::string DataArrayInt::repr() const
{
std::ostringstream ret;
reprStream(ret);
return ret.str();
}
-std::string DataArrayInt::reprZip() const throw(INTERP_KERNEL::Exception)
+std::string DataArrayInt::reprZip() const
{
std::ostringstream ret;
reprZipStream(ret);
return ret.str();
}
-void DataArrayInt::writeVTK(std::ostream& ofs, int indent, const char *type, const char *nameInFile) const throw(INTERP_KERNEL::Exception)
+void DataArrayInt::writeVTK(std::ostream& ofs, int indent, const std::string& type, const std::string& nameInFile, DataArrayByte *byteArr) const
{
+ static const char SPACE[4]={' ',' ',' ',' '};
checkAllocated();
std::string idt(indent,' ');
ofs << idt << "<DataArray type=\"" << type << "\" Name=\"" << nameInFile << "\" NumberOfComponents=\"" << getNumberOfComponents() << "\"";
- ofs << " format=\"ascii\" RangeMin=\"" << getMinValueInArray() << "\" RangeMax=\"" << getMaxValueInArray() << "\">\n" << idt;
- std::copy(begin(),end(),std::ostream_iterator<int>(ofs," "));
+ if(byteArr)
+ {
+ ofs << " format=\"appended\" offset=\"" << byteArr->getNumberOfTuples() << "\">";
+ if(std::string(type)=="Int32")
+ {
+ const char *data(reinterpret_cast<const char *>(begin()));
+ std::size_t sz(getNbOfElems()*sizeof(int));
+ byteArr->insertAtTheEnd(data,data+sz);
+ byteArr->insertAtTheEnd(SPACE,SPACE+4);
+ }
+ else if(std::string(type)=="Int8")
+ {
+ INTERP_KERNEL::AutoPtr<char> tmp(new char[getNbOfElems()]);
+ std::copy(begin(),end(),(char *)tmp);
+ byteArr->insertAtTheEnd((char *)tmp,(char *)tmp+getNbOfElems());
+ byteArr->insertAtTheEnd(SPACE,SPACE+4);
+ }
+ else if(std::string(type)=="UInt8")
+ {
+ INTERP_KERNEL::AutoPtr<unsigned char> tmp(new unsigned char[getNbOfElems()]);
+ std::copy(begin(),end(),(unsigned char *)tmp);
+ byteArr->insertAtTheEnd((unsigned char *)tmp,(unsigned char *)tmp+getNbOfElems());
+ byteArr->insertAtTheEnd(SPACE,SPACE+4);
+ }
+ else
+ throw INTERP_KERNEL::Exception("DataArrayInt::writeVTK : Only Int32, Int8 and UInt8 supported !");
+ }
+ else
+ {
+ ofs << " RangeMin=\"" << getMinValueInArray() << "\" RangeMax=\"" << getMaxValueInArray() << "\" format=\"ascii\">\n" << idt;
+ std::copy(begin(),end(),std::ostream_iterator<int>(ofs," "));
+ }
ofs << std::endl << idt << "</DataArray>\n";
}
-void DataArrayInt::reprStream(std::ostream& stream) const throw(INTERP_KERNEL::Exception)
+void DataArrayInt::reprStream(std::ostream& stream) const
{
stream << "Name of int array : \"" << _name << "\"\n";
reprWithoutNameStream(stream);
}
-void DataArrayInt::reprZipStream(std::ostream& stream) const throw(INTERP_KERNEL::Exception)
+void DataArrayInt::reprZipStream(std::ostream& stream) const
{
stream << "Name of int array : \"" << _name << "\"\n";
reprZipWithoutNameStream(stream);
}
-void DataArrayInt::reprWithoutNameStream(std::ostream& stream) const throw(INTERP_KERNEL::Exception)
+void DataArrayInt::reprWithoutNameStream(std::ostream& stream) const
{
DataArray::reprWithoutNameStream(stream);
_mem.repr(getNumberOfComponents(),stream);
}
-void DataArrayInt::reprZipWithoutNameStream(std::ostream& stream) const throw(INTERP_KERNEL::Exception)
+void DataArrayInt::reprZipWithoutNameStream(std::ostream& stream) const
{
DataArray::reprWithoutNameStream(stream);
_mem.reprZip(getNumberOfComponents(),stream);
}
-void DataArrayInt::reprCppStream(const char *varName, std::ostream& stream) const throw(INTERP_KERNEL::Exception)
+void DataArrayInt::reprCppStream(const std::string& varName, std::ostream& stream) const
{
int nbTuples=getNumberOfTuples(),nbComp=getNumberOfComponents();
const int *data=getConstPointer();
/*!
* Method that gives a quick overvien of \a this for python.
*/
-void DataArrayInt::reprQuickOverview(std::ostream& stream) const throw(INTERP_KERNEL::Exception)
+void DataArrayInt::reprQuickOverview(std::ostream& stream) const
{
static const std::size_t MAX_NB_OF_BYTE_IN_REPR=300;
stream << "DataArrayInt C++ instance at " << this << ". ";
stream << "*** No data allocated ****";
}
-void DataArrayInt::reprQuickOverviewData(std::ostream& stream, std::size_t maxNbOfByteInRepr) const throw(INTERP_KERNEL::Exception)
+void DataArrayInt::reprQuickOverviewData(std::ostream& stream, std::size_t maxNbOfByteInRepr) const
{
const int *data=begin();
int nbOfTuples=getNumberOfTuples();
* \throw If any value of \a this can't be used as a valid index for
* [\a indArrBg, \a indArrEnd).
*/
-void DataArrayInt::transformWithIndArr(const int *indArrBg, const int *indArrEnd) throw(INTERP_KERNEL::Exception)
+void DataArrayInt::transformWithIndArr(const int *indArrBg, const int *indArrEnd)
{
checkAllocated();
if(getNumberOfComponents()!=1)
* \throw If any value of \a this is not less than \a arrEnd[-1].
*/
void DataArrayInt::splitByValueRange(const int *arrBg, const int *arrEnd,
- DataArrayInt *& castArr, DataArrayInt *& rankInsideCast, DataArrayInt *& castsPresent) const throw(INTERP_KERNEL::Exception)
-{
+ DataArrayInt *& castArr, DataArrayInt *& rankInsideCast, DataArrayInt *& castsPresent) const
+ {
checkAllocated();
if(getNumberOfComponents()!=1)
throw INTERP_KERNEL::Exception("Call splitByValueRange method on DataArrayInt with only one component, you can call 'rearrange' method before !");
castArr=ret1.retn();
rankInsideCast=ret2.retn();
castsPresent=ret3.retn();
-}
+ }
/*!
* Creates a one-dimensional DataArrayInt (\a res) whose contents are computed from
* \throw If any value of \a this array is not a valid index for \a indArrBg array.
* \throw If any value of \a indArrBg is not a valid index for \a this array.
*/
-DataArrayInt *DataArrayInt::transformWithIndArrR(const int *indArrBg, const int *indArrEnd) const throw(INTERP_KERNEL::Exception)
+DataArrayInt *DataArrayInt::transformWithIndArrR(const int *indArrBg, const int *indArrEnd) const
{
checkAllocated();
if(getNumberOfComponents()!=1)
* The caller is to delete this result array using decrRef() as it is no more
* needed.
*
+ * \if ENABLE_EXAMPLES
* \ref cpp_mcdataarrayint_invertarrayo2n2n2o "Here is a C++ example".<br>
* \ref py_mcdataarrayint_invertarrayo2n2n2o "Here is a Python example".
+ * \endif
*/
DataArrayInt *DataArrayInt::invertArrayO2N2N2O(int newNbOfElem) const
{
const int *old2New=getConstPointer();
int *pt=ret->getPointer();
for(int i=0;i!=nbOfOldNodes;i++)
- if(old2New[i]!=-1)
- pt[old2New[i]]=i;
+ {
+ int newp(old2New[i]);
+ if(newp!=-1)
+ {
+ if(newp>=0 && newp<newNbOfElem)
+ pt[newp]=i;
+ else
+ {
+ std::ostringstream oss; oss << "DataArrayInt::invertArrayO2N2N2O : At place #" << i << " the newplace is " << newp << " must be in [0," << newNbOfElem << ") !";
+ throw INTERP_KERNEL::Exception(oss.str().c_str());
+ }
+ }
+ }
return ret.retn();
}
* This method is similar to DataArrayInt::invertArrayO2N2N2O except that
* Example : If \a this contains [0,1,2,0,3,4,5,4,6,4] this method will return [0,1,2,4,5,6,8] whereas DataArrayInt::invertArrayO2N2N2O returns [3,1,2,4,9,6,8]
*/
-DataArrayInt *DataArrayInt::invertArrayO2N2N2OBis(int newNbOfElem) const throw(INTERP_KERNEL::Exception)
+DataArrayInt *DataArrayInt::invertArrayO2N2N2OBis(int newNbOfElem) const
{
MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
ret->alloc(newNbOfElem,1);
const int *old2New=getConstPointer();
int *pt=ret->getPointer();
for(int i=nbOfOldNodes-1;i>=0;i--)
- if(old2New[i]!=-1)
- pt[old2New[i]]=i;
+ {
+ int newp(old2New[i]);
+ if(newp!=-1)
+ {
+ if(newp>=0 && newp<newNbOfElem)
+ pt[newp]=i;
+ else
+ {
+ std::ostringstream oss; oss << "DataArrayInt::invertArrayO2N2N2OBis : At place #" << i << " the newplace is " << newp << " must be in [0," << newNbOfElem << ") !";
+ throw INTERP_KERNEL::Exception(oss.str().c_str());
+ }
+ }
+ }
return ret.retn();
}
* The caller is to delete this result array using decrRef() as it is no more
* needed.
*
+ * \if ENABLE_EXAMPLES
* \ref cpp_mcdataarrayint_invertarrayn2o2o2n "Here is a C++ example".
*
* \ref py_mcdataarrayint_invertarrayn2o2o2n "Here is a Python example".
+ * \endif
*/
DataArrayInt *DataArrayInt::invertArrayN2O2O2N(int oldNbOfElem) const
{
{
int v(new2Old[i]);
if(v>=0 && v<oldNbOfElem)
- pt[v]=i;
+ pt[v]=i;
else
{
std::ostringstream oss; oss << "DataArrayInt::invertArrayN2O2O2N : in new id #" << i << " old value is " << v << " expected to be in [0," << oldNbOfElem << ") !";
* \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)
+bool DataArrayInt::isEqualIfNotWhy(const DataArrayInt& other, std::string& reason) const
{
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 throw(INTERP_KERNEL::Exception)
+bool DataArrayInt::isEqual(const DataArrayInt& other) const
{
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 throw(INTERP_KERNEL::Exception)
+bool DataArrayInt::isEqualWithoutConsideringStr(const DataArrayInt& other) const
{
std::string tmp;
return _mem.isEqual(other._mem,0,tmp);
* \param [in] other - an instance of DataArrayInt to compare with \a this one.
* \return bool - \a true if the sorted values of two arrays are equal, \a false else.
*/
-bool DataArrayInt::isEqualWithoutConsideringStrAndOrder(const DataArrayInt& other) const throw(INTERP_KERNEL::Exception)
+bool DataArrayInt::isEqualWithoutConsideringStrAndOrder(const DataArrayInt& other) const
{
MEDCouplingAutoRefCountObjectPtr<DataArrayInt> a=deepCpy();
MEDCouplingAutoRefCountObjectPtr<DataArrayInt> b=other.deepCpy();
* \throw If \a this has not exactly one component.
* \throw If \a this is not allocated.
*/
-bool DataArrayInt::isFittingWith(const std::vector<bool>& v) const throw(INTERP_KERNEL::Exception)
+bool DataArrayInt::isFittingWith(const std::vector<bool>& v) const
{
checkAllocated();
if(getNumberOfComponents()!=1)
throw INTERP_KERNEL::Exception("DataArrayInt::isFittingWith : number of components of this should be equal to one !");
- int nbOfTuples(getNumberOfTuples());
const int *w(begin()),*end2(end());
int refVal=-std::numeric_limits<int>::max();
int i=0;
* \throw If \a this is not allocated.
* \throw If \a this->getNumberOfComponents() != 1.
*/
-void DataArrayInt::sort(bool asc) throw(INTERP_KERNEL::Exception)
+void DataArrayInt::sort(bool asc)
{
checkAllocated();
if(getNumberOfComponents()!=1)
declareAsNew();
}
+/*!
+ * Computes for each tuple the sum of number of components values in the tuple and return it.
+ *
+ * \return DataArrayInt * - the new instance of DataArrayInt containing the
+ * same number of tuples as \a this array and one component.
+ * The caller is to delete this result array using decrRef() as it is no more
+ * needed.
+ * \throw If \a this is not allocated.
+ */
+DataArrayInt *DataArrayInt::sumPerTuple() const
+{
+ checkAllocated();
+ int nbOfComp(getNumberOfComponents()),nbOfTuple(getNumberOfTuples());
+ MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New());
+ ret->alloc(nbOfTuple,1);
+ const int *src(getConstPointer());
+ int *dest(ret->getPointer());
+ for(int i=0;i<nbOfTuple;i++,dest++,src+=nbOfComp)
+ *dest=std::accumulate(src,src+nbOfComp,0);
+ return ret.retn();
+}
+
/*!
* Reverse the array values.
* \throw If \a this->getNumberOfComponents() < 1.
* \throw If \a this is not allocated.
*/
-void DataArrayInt::reverse() throw(INTERP_KERNEL::Exception)
+void DataArrayInt::reverse()
{
checkAllocated();
_mem.reverse(getNumberOfComponents());
* \throw If \a this->getNumberOfComponents() != 1.
* \throw If \a this is not allocated.
*/
-void DataArrayInt::checkMonotonic(bool increasing) const throw(INTERP_KERNEL::Exception)
+void DataArrayInt::checkMonotonic(bool increasing) const
{
if(!isMonotonic(increasing))
{
* \throw If \a this->getNumberOfComponents() != 1.
* \throw If \a this is not allocated.
*/
-bool DataArrayInt::isMonotonic(bool increasing) const throw(INTERP_KERNEL::Exception)
+bool DataArrayInt::isMonotonic(bool increasing) const
{
checkAllocated();
if(getNumberOfComponents()!=1)
/*!
* This method check that array consistently INCREASING or DECREASING in value.
*/
-bool DataArrayInt::isStrictlyMonotonic(bool increasing) const throw(INTERP_KERNEL::Exception)
+bool DataArrayInt::isStrictlyMonotonic(bool increasing) const
{
checkAllocated();
if(getNumberOfComponents()!=1)
/*!
* This method check that array consistently INCREASING or DECREASING in value.
*/
-void DataArrayInt::checkStrictlyMonotonic(bool increasing) const throw(INTERP_KERNEL::Exception)
+void DataArrayInt::checkStrictlyMonotonic(bool increasing) const
{
if(!isStrictlyMonotonic(increasing))
{
* \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples().
* \throw If \a other includes a value which is not in \a this array.
*
+ * \if ENABLE_EXAMPLES
* \ref cpp_mcdataarrayint_buildpermutationarr "Here is a C++ example".
*
* \ref py_mcdataarrayint_buildpermutationarr "Here is a Python example".
+ * \endif
*/
-DataArrayInt *DataArrayInt::buildPermutationArr(const DataArrayInt& other) const throw(INTERP_KERNEL::Exception)
+DataArrayInt *DataArrayInt::buildPermutationArr(const DataArrayInt& other) const
{
checkAllocated();
if(getNumberOfComponents()!=1 || other.getNumberOfComponents()!=1)
* \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) throw(INTERP_KERNEL::Exception)
+void DataArrayInt::useArray(const int *array, bool ownership, DeallocType type, int nbOfTuple, int nbOfCompo)
{
_info_on_compo.resize(nbOfCompo);
_mem.useArray(array,ownership,type,nbOfTuple*nbOfCompo);
declareAsNew();
}
-void DataArrayInt::useExternalArrayWithRWAccess(const int *array, int nbOfTuple, int nbOfCompo) throw(INTERP_KERNEL::Exception)
+void DataArrayInt::useExternalArrayWithRWAccess(const int *array, int nbOfTuple, int nbOfCompo)
{
_info_on_compo.resize(nbOfCompo);
_mem.useExternalArrayWithRWAccess(array,nbOfTuple*nbOfCompo);
* is to delete using decrRef() as it is no more needed.
* \throw If \a this is not allocated.
*/
-DataArrayInt *DataArrayInt::fromNoInterlace() const throw(INTERP_KERNEL::Exception)
+DataArrayInt *DataArrayInt::fromNoInterlace() const
{
checkAllocated();
if(_mem.isNull())
* is to delete using decrRef() as it is no more needed.
* \throw If \a this is not allocated.
*/
-DataArrayInt *DataArrayInt::toNoInterlace() const throw(INTERP_KERNEL::Exception)
+DataArrayInt *DataArrayInt::toNoInterlace() const
{
checkAllocated();
if(_mem.isNull())
* \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) throw(INTERP_KERNEL::Exception)
+void DataArrayInt::renumberInPlace(const int *old2New)
{
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) throw(INTERP_KERNEL::Exception)
+void DataArrayInt::renumberInPlaceR(const int *new2Old)
{
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 throw(INTERP_KERNEL::Exception)
+DataArrayInt *DataArrayInt::renumber(const int *old2New) const
{
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.
*/
-DataArrayInt *DataArrayInt::renumberR(const int *new2Old) const throw(INTERP_KERNEL::Exception)
+DataArrayInt *DataArrayInt::renumberR(const int *new2Old) const
{
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.
*/
-DataArrayInt *DataArrayInt::renumberAndReduce(const int *old2New, int newNbOfTuple) const throw(INTERP_KERNEL::Exception)
+DataArrayInt *DataArrayInt::renumberAndReduce(const int *old2New, int newNbOfTuple) const
{
checkAllocated();
int nbTuples=getNumberOfTuples();
* is to delete using decrRef() as it is no more needed.
* \throw If \a new2OldEnd - \a new2OldBg > \a this->getNumberOfTuples().
*/
-DataArrayInt *DataArrayInt::selectByTupleIdSafe(const int *new2OldBg, const int *new2OldEnd) const throw(INTERP_KERNEL::Exception)
+DataArrayInt *DataArrayInt::selectByTupleIdSafe(const int *new2OldBg, const int *new2OldEnd) const
{
checkAllocated();
MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
* is to delete using decrRef() as it is no more needed.
* \sa DataArrayInt::substr.
*/
-DataArrayInt *DataArrayInt::selectByTupleId2(int bg, int end2, int step) const throw(INTERP_KERNEL::Exception)
+DataArrayInt *DataArrayInt::selectByTupleId2(int bg, int end2, int step) const
{
checkAllocated();
MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
* \throw If \a end > \a this->getNumberOfTuples().
* \throw If \a this is not allocated.
*/
-DataArray *DataArrayInt::selectByTupleRanges(const std::vector<std::pair<int,int> >& ranges) const throw(INTERP_KERNEL::Exception)
+DataArray *DataArrayInt::selectByTupleRanges(const std::vector<std::pair<int,int> >& ranges) const
{
checkAllocated();
int nbOfComp=getNumberOfComponents();
* \throw If \a this->getNumberOfComponents() != 1.
* \throw If there are equal values in \a this array.
*/
-DataArrayInt *DataArrayInt::checkAndPreparePermutation() const throw(INTERP_KERNEL::Exception)
+DataArrayInt *DataArrayInt::checkAndPreparePermutation() const
{
checkAllocated();
if(getNumberOfComponents()!=1)
* \throw If either ids1 or ids2 is null not allocated or not with one components.
*
*/
-DataArrayInt *DataArrayInt::FindPermutationFromFirstToSecond(const DataArrayInt *ids1, const DataArrayInt *ids2) throw(INTERP_KERNEL::Exception)
+DataArrayInt *DataArrayInt::FindPermutationFromFirstToSecond(const DataArrayInt *ids1, const DataArrayInt *ids2)
{
if(!ids1 || !ids2)
throw INTERP_KERNEL::Exception("DataArrayInt::FindPermutationFromFirstToSecond : the two input arrays must be not null !");
* \throw If \a this->getNumberOfComponents() != 1.
* \throw If any value in \a this is more or equal to \a targetNb.
*/
-void DataArrayInt::changeSurjectiveFormat(int targetNb, DataArrayInt *&arr, DataArrayInt *&arrI) const throw(INTERP_KERNEL::Exception)
+void DataArrayInt::changeSurjectiveFormat(int targetNb, DataArrayInt *&arr, DataArrayInt *&arrI) const
{
checkAllocated();
if(getNumberOfComponents()!=1)
* 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) throw(INTERP_KERNEL::Exception)
+DataArrayInt *DataArrayInt::BuildOld2NewArrayFromSurjectiveFormat2(int nbOfOldTuples, const int *arr, const int *arrIBg, const int *arrIEnd, int &newNbOfTuples)
{
MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
ret->alloc(nbOfOldTuples,1);
* \throw If \a this is not allocated.
* \throw If \a this->getNumberOfComponents() != 1.
*/
-DataArrayInt *DataArrayInt::buildPermArrPerLevel() const throw(INTERP_KERNEL::Exception)
+DataArrayInt *DataArrayInt::buildPermArrPerLevel() const
{
checkAllocated();
if(getNumberOfComponents()!=1)
* \throw If \a this is not allocated.
* \throw If \a this->getNumberOfComponents() != 1.
*/
-bool DataArrayInt::isIdentity() const throw(INTERP_KERNEL::Exception)
+bool DataArrayInt::isIdentity() const
{
checkAllocated();
if(getNumberOfComponents()!=1)
* \throw If \a this is not allocated.
* \throw If \a this->getNumberOfComponents() != 1
*/
-bool DataArrayInt::isUniform(int val) const throw(INTERP_KERNEL::Exception)
+bool DataArrayInt::isUniform(int val) const
{
checkAllocated();
if(getNumberOfComponents()!=1)
\throw If \a tupleIdEnd != -1 && \a tupleIdEnd < \a this->getNumberOfTuples().
* \sa DataArrayInt::selectByTupleId2
*/
-DataArrayInt *DataArrayInt::substr(int tupleIdBg, int tupleIdEnd) const throw(INTERP_KERNEL::Exception)
+DataArrayInt *DataArrayInt::substr(int tupleIdBg, int tupleIdEnd) const
{
checkAllocated();
int nbt=getNumberOfTuples();
* \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)
+void DataArrayInt::rearrange(int newNbOfCompo)
{
checkAllocated();
if(newNbOfCompo<1)
* \throw If \a this is not allocated.
* \sa rearrange()
*/
-void DataArrayInt::transpose() throw(INTERP_KERNEL::Exception)
+void DataArrayInt::transpose()
{
checkAllocated();
int nbOfTuples=getNumberOfTuples();
* is to delete using decrRef() as it is no more needed.
* \throw If \a this is not allocated.
*/
-DataArrayInt *DataArrayInt::changeNbOfComponents(int newNbOfComp, int dftValue) const throw(INTERP_KERNEL::Exception)
+DataArrayInt *DataArrayInt::changeNbOfComponents(int newNbOfComp, int dftValue) const
{
checkAllocated();
MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
for(;j<newNbOfComp;j++)
nc[newNbOfComp*i+j]=dftValue;
}
- ret->setName(getName().c_str());
+ ret->setName(getName());
for(int i=0;i<dim;i++)
- ret->setInfoOnComponent(i,getInfoOnComponent(i).c_str());
- ret->setName(getName().c_str());
+ ret->setInfoOnComponent(i,getInfoOnComponent(i));
+ ret->setName(getName());
return ret.retn();
}
* \throw If \a this is not allocated.
* \throw If \a nbOfTuples is negative.
*/
-void DataArrayInt::reAlloc(int nbOfTuples) throw(INTERP_KERNEL::Exception)
+void DataArrayInt::reAlloc(int nbOfTuples)
{
if(nbOfTuples<0)
throw INTERP_KERNEL::Exception("DataArrayInt::reAlloc : input new number of tuples should be >=0 !");
* \throw If a component index (\a i) is not valid:
* \a i < 0 || \a i >= \a this->getNumberOfComponents().
*
+ * \if ENABLE_EXAMPLES
* \ref py_mcdataarrayint_keepselectedcomponents "Here is a Python example".
+ * \endif
*/
-DataArray *DataArrayInt::keepSelectedComponents(const std::vector<int>& compoIds) const throw(INTERP_KERNEL::Exception)
+DataArrayInt *DataArrayInt::keepSelectedComponents(const std::vector<int>& compoIds) const
{
checkAllocated();
MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New());
* \throw If \a this is not allocated.
* \throw If \a this and \a other arrays have different number of tuples.
*
+ * \if ENABLE_EXAMPLES
* \ref cpp_mcdataarrayint_meldwith "Here is a C++ example".
*
* \ref py_mcdataarrayint_meldwith "Here is a Python example".
+ * \endif
*/
-void DataArrayInt::meldWith(const DataArrayInt *other) throw(INTERP_KERNEL::Exception)
+void DataArrayInt::meldWith(const DataArrayInt *other)
{
if(!other)
throw INTERP_KERNEL::Exception("DataArrayInt::meldWith : DataArrayInt pointer in input is NULL !");
* \throw If \a compoIds.size() != \a a->getNumberOfComponents().
* \throw If \a compoIds[i] < 0 or \a compoIds[i] > \a this->getNumberOfComponents().
*
+ * \if ENABLE_EXAMPLES
* \ref py_mcdataarrayint_setselectedcomponents "Here is a Python example".
+ * \endif
*/
-void DataArrayInt::setSelectedComponents(const DataArrayInt *a, const std::vector<int>& compoIds) throw(INTERP_KERNEL::Exception)
+void DataArrayInt::setSelectedComponents(const DataArrayInt *a, const std::vector<int>& compoIds)
{
if(!a)
throw INTERP_KERNEL::Exception("DataArrayInt::setSelectedComponents : input DataArrayInt is NULL !");
* \throw If \a strictCompoCompare == \a true && \a a->getNumberOfComponents() !=
* \c len(\c range(\a bgComp,\a endComp,\a stepComp)).
*
+ * \if ENABLE_EXAMPLES
* \ref py_mcdataarrayint_setpartofvalues1 "Here is a Python example".
+ * \endif
*/
-void DataArrayInt::setPartOfValues1(const DataArrayInt *a, int bgTuples, int endTuples, int stepTuples, int bgComp, int endComp, int stepComp, bool strictCompoCompare) throw(INTERP_KERNEL::Exception)
+void DataArrayInt::setPartOfValues1(const DataArrayInt *a, int bgTuples, int endTuples, int stepTuples, int bgComp, int endComp, int stepComp, bool strictCompoCompare)
{
if(!a)
throw INTERP_KERNEL::Exception("DataArrayInt::setPartOfValues1 : DataArrayInt pointer in input is NULL !");
* non-empty range of increasing indices or indices are out of a valid range
* for \this array.
*
+ * \if ENABLE_EXAMPLES
* \ref py_mcdataarrayint_setpartofvaluessimple1 "Here is a Python example".
+ * \endif
*/
-void DataArrayInt::setPartOfValuesSimple1(int a, int bgTuples, int endTuples, int stepTuples, int bgComp, int endComp, int stepComp) throw(INTERP_KERNEL::Exception)
+void DataArrayInt::setPartOfValuesSimple1(int a, int bgTuples, int endTuples, int stepTuples, int bgComp, int endComp, int stepComp)
{
const char msg[]="DataArrayInt::setPartOfValuesSimple1";
checkAllocated();
* \throw In the second *mode of usage*, if \a a->getNumberOfTuples() != 1 or
* <em> a->getNumberOfComponents() != (endComp - bgComp)</em>.
*
+ * \if ENABLE_EXAMPLES
* \ref py_mcdataarrayint_setpartofvalues2 "Here is a Python example".
+ * \endif
*/
-void DataArrayInt::setPartOfValues2(const DataArrayInt *a, const int *bgTuples, const int *endTuples, const int *bgComp, const int *endComp, bool strictCompoCompare) throw(INTERP_KERNEL::Exception)
+void DataArrayInt::setPartOfValues2(const DataArrayInt *a, const int *bgTuples, const int *endTuples, const int *bgComp, const int *endComp, bool strictCompoCompare)
{
if(!a)
throw INTERP_KERNEL::Exception("DataArrayInt::setPartOfValues2 : DataArrayInt pointer in input is NULL !");
* \throw If any index of tuple/component given by <em>bgTuples / bgComp</em> is
* out of a valid range for \a this array.
*
+ * \if ENABLE_EXAMPLES
* \ref py_mcdataarrayint_setpartofvaluessimple2 "Here is a Python example".
+ * \endif
*/
-void DataArrayInt::setPartOfValuesSimple2(int a, const int *bgTuples, const int *endTuples, const int *bgComp, const int *endComp) throw(INTERP_KERNEL::Exception)
+void DataArrayInt::setPartOfValuesSimple2(int a, const int *bgTuples, const int *endTuples, const int *bgComp, const int *endComp)
{
checkAllocated();
int nbComp=getNumberOfComponents();
* non-empty range of increasing indices or indices are out of a valid range
* for \this array.
*
+ * \if ENABLE_EXAMPLES
* \ref py_mcdataarrayint_setpartofvalues3 "Here is a Python example".
+ * \endif
*/
-void DataArrayInt::setPartOfValues3(const DataArrayInt *a, const int *bgTuples, const int *endTuples, int bgComp, int endComp, int stepComp, bool strictCompoCompare) throw(INTERP_KERNEL::Exception)
+void DataArrayInt::setPartOfValues3(const DataArrayInt *a, const int *bgTuples, const int *endTuples, int bgComp, int endComp, int stepComp, bool strictCompoCompare)
{
if(!a)
throw INTERP_KERNEL::Exception("DataArrayInt::setPartOfValues3 : DataArrayInt pointer in input is NULL !");
* non-empty range of increasing indices or indices are out of a valid range
* for \this array.
*
+ * \if ENABLE_EXAMPLES
* \ref py_mcdataarrayint_setpartofvaluessimple3 "Here is a Python example".
+ * \endif
*/
-void DataArrayInt::setPartOfValuesSimple3(int a, const int *bgTuples, const int *endTuples, int bgComp, int endComp, int stepComp) throw(INTERP_KERNEL::Exception)
+void DataArrayInt::setPartOfValuesSimple3(int a, const int *bgTuples, const int *endTuples, int bgComp, int endComp, int stepComp)
{
const char msg[]="DataArrayInt::setPartOfValuesSimple3";
checkAllocated();
}
}
-void DataArrayInt::setPartOfValues4(const DataArrayInt *a, int bgTuples, int endTuples, int stepTuples, const int *bgComp, const int *endComp, bool strictCompoCompare) throw(INTERP_KERNEL::Exception)
+void DataArrayInt::setPartOfValues4(const DataArrayInt *a, int bgTuples, int endTuples, int stepTuples, const int *bgComp, const int *endComp, bool strictCompoCompare)
{
if(!a)
throw INTERP_KERNEL::Exception("DataArrayInt::setPartOfValues4 : input DataArrayInt is NULL !");
}
}
-void DataArrayInt::setPartOfValuesSimple4(int a, int bgTuples, int endTuples, int stepTuples, const int *bgComp, const int *endComp) throw(INTERP_KERNEL::Exception)
+void DataArrayInt::setPartOfValuesSimple4(int a, int bgTuples, int endTuples, int stepTuples, const int *bgComp, const int *endComp)
{
const char msg[]="DataArrayInt::setPartOfValuesSimple4";
checkAllocated();
* \throw If any tuple index given by \a tuplesSelec is out of a valid range for
* the corresponding (\a this or \a a) array.
*/
-void DataArrayInt::setPartOfValuesAdv(const DataArrayInt *a, const DataArrayInt *tuplesSelec) throw(INTERP_KERNEL::Exception)
+void DataArrayInt::setPartOfValuesAdv(const DataArrayInt *a, const DataArrayInt *tuplesSelec)
{
if(!a || !tuplesSelec)
throw INTERP_KERNEL::Exception("DataArrayInt::setPartOfValuesAdv : DataArrayInt pointer in input is NULL !");
* \throw If any tuple index given by \a tuplesSelec is out of a valid range for
* \a aBase array.
*/
-void DataArrayInt::setContigPartOfSelectedValues(int tupleIdStart, const DataArray *aBase, const DataArrayInt *tuplesSelec) throw(INTERP_KERNEL::Exception)
+void DataArrayInt::setContigPartOfSelectedValues(int tupleIdStart, const DataArray *aBase, const DataArrayInt *tuplesSelec)
{
if(!aBase || !tuplesSelec)
throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues : input DataArray is NULL !");
* 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) throw(INTERP_KERNEL::Exception)
+void DataArrayInt::setContigPartOfSelectedValues2(int tupleIdStart, const DataArray *aBase, int bg, int end2, int step)
{
if(!aBase)
throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues2 : input DataArray is NULL !");
* \throw If condition <em>( 0 <= tupleId < this->getNumberOfTuples() )</em> is violated.
* \throw If condition <em>( 0 <= compoId < this->getNumberOfComponents() )</em> is violated.
*/
-int DataArrayInt::getIJSafe(int tupleId, int compoId) const throw(INTERP_KERNEL::Exception)
+int DataArrayInt::getIJSafe(int tupleId, int compoId) const
{
checkAllocated();
if(tupleId<0 || tupleId>=getNumberOfTuples())
* \throw If \a this->getNumberOfComponents() != 1.
* \throw If \a this->getNumberOfTuples() < 1.
*/
-int DataArrayInt::front() const throw(INTERP_KERNEL::Exception)
+int DataArrayInt::front() const
{
checkAllocated();
if(getNumberOfComponents()!=1)
* \throw If \a this->getNumberOfComponents() != 1.
* \throw If \a this->getNumberOfTuples() < 1.
*/
-int DataArrayInt::back() const throw(INTERP_KERNEL::Exception)
+int DataArrayInt::back() const
{
checkAllocated();
if(getNumberOfComponents()!=1)
}
}
-DataArrayIntIterator *DataArrayInt::iterator() throw(INTERP_KERNEL::Exception)
+DataArrayIntIterator *DataArrayInt::iterator()
{
return new DataArrayIntIterator(this);
}
/*!
* Creates a new DataArrayInt containing IDs (indices) of tuples holding value equal to a
- * given one.
+ * given one. The ids are sorted in the ascending order.
* \param [in] val - the value to find within \a this.
* \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
* 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
*/
-DataArrayInt *DataArrayInt::getIdsEqual(int val) const throw(INTERP_KERNEL::Exception)
+DataArrayInt *DataArrayInt::getIdsEqual(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 !");
- const int *cptr=getConstPointer();
+ const int *cptr(getConstPointer());
MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
int nbOfTuples=getNumberOfTuples();
for(int i=0;i<nbOfTuples;i++,cptr++)
* \throw If \a this is not allocated.
* \throw If \a this->getNumberOfComponents() != 1.
*/
-DataArrayInt *DataArrayInt::getIdsNotEqual(int val) const throw(INTERP_KERNEL::Exception)
+DataArrayInt *DataArrayInt::getIdsNotEqual(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 !");
- const int *cptr=getConstPointer();
+ const int *cptr(getConstPointer());
MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
int nbOfTuples=getNumberOfTuples();
for(int i=0;i<nbOfTuples;i++,cptr++)
return ret.retn();
}
+/*!
+ * 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.
+ *
+ * \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.
+ * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
+ * array using decrRef() as it is no more needed.
+ * \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
+ */
+DataArrayInt *DataArrayInt::getIdsEqualTuple(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 !";
+ 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);
+ const int *bg(begin()),*end2(end()),*work(begin());
+ while(work!=end2)
+ {
+ work=std::search(work,end2,tupleBg,tupleEnd);
+ if(work!=end2)
+ {
+ std::size_t pos(std::distance(bg,work));
+ if(pos%nbOfCompoExp==0)
+ ret->pushBackSilent(pos/nbOfCompoExp);
+ work++;
+ }
+ }
+ return ret.retn();
+}
/*!
* Assigns \a newValue to all elements holding \a oldValue within \a this
* \throw If \a this is not allocated.
* \throw If \a this->getNumberOfComponents() != 1.
*/
-int DataArrayInt::changeValue(int oldValue, int newValue) throw(INTERP_KERNEL::Exception)
+int DataArrayInt::changeValue(int oldValue, int newValue)
{
checkAllocated();
if(getNumberOfComponents()!=1)
* 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 throw(INTERP_KERNEL::Exception)
+DataArrayInt *DataArrayInt::getIdsEqualList(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 !");
* 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 throw(INTERP_KERNEL::Exception)
+DataArrayInt *DataArrayInt::getIdsNotEqualList(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 !");
* \return tuple id where \b tupl is. -1 if no such tuple exists in \b this.
* \sa DataArrayInt::search, DataArrayInt::presenceOfTuple.
*/
-int DataArrayInt::locateTuple(const std::vector<int>& tupl) const throw(INTERP_KERNEL::Exception)
+int DataArrayInt::locateTuple(const std::vector<int>& tupl) const
{
checkAllocated();
int nbOfCompo=getNumberOfComponents();
* 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
*/
-int DataArrayInt::search(const std::vector<int>& vals) const throw(INTERP_KERNEL::Exception)
+int DataArrayInt::search(const std::vector<int>& vals) const
{
checkAllocated();
int nbOfCompo=getNumberOfComponents();
* If not any tuple contains \b value -1 is returned.
* \sa DataArrayInt::presenceOfValue
*/
-int DataArrayInt::locateValue(int value) const throw(INTERP_KERNEL::Exception)
+int DataArrayInt::locateValue(int value) const
{
checkAllocated();
if(getNumberOfComponents()!=1)
* If not any tuple contains one of the values contained in 'vals' false is returned.
* \sa DataArrayInt::presenceOfValue
*/
-int DataArrayInt::locateValue(const std::vector<int>& vals) const throw(INTERP_KERNEL::Exception)
+int DataArrayInt::locateValue(const std::vector<int>& vals) const
{
checkAllocated();
if(getNumberOfComponents()!=1)
* \throw If \a this is not allocated
*
*/
-int DataArrayInt::count(int value) const throw(INTERP_KERNEL::Exception)
+int DataArrayInt::count(int value) const
{
int ret=0;
checkAllocated();
* the input vector. An INTERP_KERNEL::Exception is thrown too if \b this is not allocated.
* \sa DataArrayInt::locateTuple
*/
-bool DataArrayInt::presenceOfTuple(const std::vector<int>& tupl) const throw(INTERP_KERNEL::Exception)
+bool DataArrayInt::presenceOfTuple(const std::vector<int>& tupl) const
{
return locateTuple(tupl)!=-1;
}
* \throw If \a this->getNumberOfComponents() != 1.
* \sa locateValue()
*/
-bool DataArrayInt::presenceOfValue(int value) const throw(INTERP_KERNEL::Exception)
+bool DataArrayInt::presenceOfValue(int value) const
{
return locateValue(value)!=-1;
}
* If not any tuple contains one of the values contained in 'vals' false is returned.
* \sa DataArrayInt::locateValue
*/
-bool DataArrayInt::presenceOfValue(const std::vector<int>& vals) const throw(INTERP_KERNEL::Exception)
+bool DataArrayInt::presenceOfValue(const std::vector<int>& vals) const
{
return locateValue(vals)!=-1;
}
* component.
* \throw If \a this is not allocated.
*/
-void DataArrayInt::accumulate(int *res) const throw(INTERP_KERNEL::Exception)
+void DataArrayInt::accumulate(int *res) const
{
checkAllocated();
const int *ptr=getConstPointer();
std::transform(ptr+i*nbComps,ptr+(i+1)*nbComps,res,res,std::plus<int>());
}
-int DataArrayInt::accumulate(int compId) const throw(INTERP_KERNEL::Exception)
+int DataArrayInt::accumulate(int compId) const
{
checkAllocated();
const int *ptr=getConstPointer();
* \throw If there is an id in [ \a bgOfIndex, \a endOfIndex ) not in [0, \c this->getNumberOfTuples).
* \throw If std::distance(bgOfIndex,endOfIndex)==0.
*/
-DataArrayInt *DataArrayInt::accumulatePerChunck(const int *bgOfIndex, const int *endOfIndex) const throw(INTERP_KERNEL::Exception)
+DataArrayInt *DataArrayInt::accumulatePerChunck(const int *bgOfIndex, const int *endOfIndex) const
{
if(!bgOfIndex || !endOfIndex)
throw INTERP_KERNEL::Exception("DataArrayInt::accumulatePerChunck : input pointer NULL !");
int *tmp=ret->getPointer();
for(int i=0;i<sz;i++,tmp+=nbCompo,w++)
{
- std::fill(tmp,tmp+nbCompo,0.);
+ std::fill(tmp,tmp+nbCompo,0);
if(w[1]>=w[0])
{
for(int j=w[0];j<w[1];j++,srcPt+=nbCompo)
* the number of component in the result array is same as that of each of given arrays.
* Info on components is copied from the first of the given arrays. Number of components
* in the given arrays must be the same.
+ * If the number of non null of elements in \a arr is equal to one the returned object is a copy of it
+ * not the object itself.
* \param [in] arr - a sequence of arrays to include in the result array.
* \return DataArrayInt * - the new instance of DataArrayInt.
* The caller is to delete this result array using decrRef() as it is no more
* \throw If all arrays within \a arr are NULL.
* \throw If getNumberOfComponents() of arrays within \a arr.
*/
-DataArrayInt *DataArrayInt::Aggregate(const std::vector<const DataArrayInt *>& arr) throw(INTERP_KERNEL::Exception)
+DataArrayInt *DataArrayInt::Aggregate(const std::vector<const DataArrayInt *>& arr)
{
std::vector<const DataArrayInt *> a;
for(std::vector<const DataArrayInt *>::const_iterator it4=arr.begin();it4!=arr.end();it4++)
*
* \return DataArrayInt * - a new object to be managed by the caller.
*/
-DataArrayInt *DataArrayInt::AggregateIndexes(const std::vector<const DataArrayInt *>& arrs) throw(INTERP_KERNEL::Exception)
+DataArrayInt *DataArrayInt::AggregateIndexes(const std::vector<const DataArrayInt *>& arrs)
{
int retSz=1;
for(std::vector<const DataArrayInt *>::const_iterator it4=arrs.begin();it4!=arrs.end();it4++)
* \throw If \a this->getNumberOfComponents() != 1
* \throw If \a this->getNumberOfTuples() < 1
*/
-int DataArrayInt::getMaxValue(int& tupleId) const throw(INTERP_KERNEL::Exception)
+int DataArrayInt::getMaxValue(int& tupleId) const
{
checkAllocated();
if(getNumberOfComponents()!=1)
* \return int - the maximal value among all values of \a this array.
* \throw If \a this is not allocated.
*/
-int DataArrayInt::getMaxValueInArray() const throw(INTERP_KERNEL::Exception)
+int DataArrayInt::getMaxValueInArray() const
{
checkAllocated();
const int *loc=std::max_element(begin(),end());
* \throw If \a this->getNumberOfComponents() != 1
* \throw If \a this->getNumberOfTuples() < 1
*/
-int DataArrayInt::getMinValue(int& tupleId) const throw(INTERP_KERNEL::Exception)
+int DataArrayInt::getMinValue(int& tupleId) const
{
checkAllocated();
if(getNumberOfComponents()!=1)
* \return int - the minimal value among all values of \a this array.
* \throw If \a this is not allocated.
*/
-int DataArrayInt::getMinValueInArray() const throw(INTERP_KERNEL::Exception)
+int DataArrayInt::getMinValueInArray() const
{
checkAllocated();
const int *loc=std::min_element(begin(),end());
/*!
* Converts every value of \a this array to its absolute value.
- * \throw If \a this is not allocated.
+ * \b WARNING this method is non const. If a new DataArrayInt instance should be built containing the result of abs DataArrayInt::computeAbs
+ * should be called instead.
+ *
+ * \throw If \a this is not allocated.
+ * \sa DataArrayInt::computeAbs
*/
-void DataArrayInt::abs() throw(INTERP_KERNEL::Exception)
+void DataArrayInt::abs()
{
checkAllocated();
- int *ptr=getPointer();
- std::size_t nbOfElems=getNbOfElems();
+ int *ptr(getPointer());
+ std::size_t nbOfElems(getNbOfElems());
std::transform(ptr,ptr+nbOfElems,ptr,std::ptr_fun<int,int>(std::abs));
declareAsNew();
}
+/*!
+ * This method builds a new instance of \a this object containing the result of std::abs applied of all elements in \a this.
+ * This method is a const method (that do not change any values in \a this) contrary to DataArrayInt::abs method.
+ *
+ * \return DataArrayInt * - the new instance of DataArrayInt containing the
+ * same number of tuples and component as \a this array.
+ * The caller is to delete this result array using decrRef() as it is no more
+ * needed.
+ * \throw If \a this is not allocated.
+ * \sa DataArrayInt::abs
+ */
+DataArrayInt *DataArrayInt::computeAbs() const
+{
+ checkAllocated();
+ DataArrayInt *newArr(DataArrayInt::New());
+ int nbOfTuples(getNumberOfTuples());
+ int nbOfComp(getNumberOfComponents());
+ newArr->alloc(nbOfTuples,nbOfComp);
+ std::transform(begin(),end(),newArr->getPointer(),std::ptr_fun<int,int>(std::abs));
+ newArr->copyStringInfoFrom(*this);
+ return newArr;
+}
+
/*!
* Apply a liner function to a given component of \a this array, so that
* an array element <em>(x)</em> becomes \f$ a * x + b \f$.
* \param [in] compoId - the index of component to modify.
* \throw If \a this is not allocated.
*/
-void DataArrayInt::applyLin(int a, int b, int compoId) throw(INTERP_KERNEL::Exception)
+void DataArrayInt::applyLin(int a, int b, int compoId)
{
checkAllocated();
int *ptr=getPointer()+compoId;
* \param [in] b - the second coefficient of the function.
* \throw If \a this is not allocated.
*/
-void DataArrayInt::applyLin(int a, int b) throw(INTERP_KERNEL::Exception)
+void DataArrayInt::applyLin(int a, int b)
{
checkAllocated();
int *ptr=getPointer();
* needed.
* \throw If \a this is not allocated.
*/
-DataArrayInt *DataArrayInt::negate() const throw(INTERP_KERNEL::Exception)
+DataArrayInt *DataArrayInt::negate() const
{
checkAllocated();
DataArrayInt *newArr=DataArrayInt::New();
* \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)
+void DataArrayInt::applyInv(int numerator)
{
checkAllocated();
int *ptr=getPointer();
* \throw If \a this is not allocated.
* \throw If \a val == 0.
*/
-void DataArrayInt::applyDivideBy(int val) throw(INTERP_KERNEL::Exception)
+void DataArrayInt::applyDivideBy(int val)
{
if(val==0)
throw INTERP_KERNEL::Exception("DataArrayInt::applyDivideBy : Trying to divide by 0 !");
* \throw If \a this is not allocated.
* \throw If \a val <= 0.
*/
-void DataArrayInt::applyModulus(int val) throw(INTERP_KERNEL::Exception)
+void DataArrayInt::applyModulus(int val)
{
if(val<=0)
throw INTERP_KERNEL::Exception("DataArrayInt::applyDivideBy : Trying to operate modulus on value <= 0 !");
* \param [in] vmin begin of range. This value is included in range (included).
* \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 *DataArrayInt::getIdsInRange(int vmin, int vmax) const throw(INTERP_KERNEL::Exception)
+DataArrayInt *DataArrayInt::getIdsInRange(int vmin, int vmax) const
{
checkAllocated();
if(getNumberOfComponents()!=1)
throw INTERP_KERNEL::Exception("DataArrayInt::getIdsInRange : this must have exactly one component !");
- const int *cptr=getConstPointer();
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(0,1);
- int nbOfTuples=getNumberOfTuples();
+ const int *cptr(begin());
+ 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)
ret->pushBackSilent(i);
return ret.retn();
}
+/*!
+ * This method works only on data array with one component.
+ * This method returns a newly allocated array storing stored ascendantly tuple ids in \b this so that
+ * this[*id] \b not in [\b vmin,\b vmax)
+ *
+ * \param [in] vmin begin of range. This value is \b not included in range (excluded).
+ * \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 *DataArrayInt::getIdsNotInRange(int vmin, int vmax) const
+{
+ checkAllocated();
+ if(getNumberOfComponents()!=1)
+ throw INTERP_KERNEL::Exception("DataArrayInt::getIdsNotInRange : this must have exactly one component !");
+ const int *cptr(getConstPointer());
+ 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)
+ ret->pushBackSilent(i);
+ return ret.retn();
+}
+
/*!
* This method works only on data array with one component.
* This method checks that all ids in \b this are in [ \b vmin, \b vmax ). If there is at least one element in \a this not in [ \b vmin, \b vmax ) an exception will be thrown.
*
* \param [in] vmin begin of range. This value is included in range (included).
* \param [in] vmax end of range. This value is \b not included in range (excluded).
- * \return if all ids in \a this are so that (*this)[i]==i for all i in [ 0, \c this->getNumberOfTuples() ).
- */
-bool DataArrayInt::checkAllIdsInRange(int vmin, int vmax) const throw(INTERP_KERNEL::Exception)
+ * \return if all ids in \a this are so that (*this)[i]==i for all i in [ 0, \c this->getNumberOfTuples() ). */
+bool DataArrayInt::checkAllIdsInRange(int vmin, int vmax) const
{
checkAllocated();
if(getNumberOfComponents()!=1)
* \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)
+void DataArrayInt::applyRModulus(int val)
{
checkAllocated();
int *ptr=getPointer();
* \throw If \a this is not allocated.
* \throw If \a val < 0.
*/
-void DataArrayInt::applyPow(int val) throw(INTERP_KERNEL::Exception)
+void DataArrayInt::applyPow(int val)
{
checkAllocated();
if(val<0)
std::size_t nbOfElems=getNbOfElems();
if(val==0)
{
- std::fill(ptr,ptr+nbOfElems,1.);
+ std::fill(ptr,ptr+nbOfElems,1);
return ;
}
for(std::size_t i=0;i<nbOfElems;i++,ptr++)
* array, all elements processed before detection of the zero element remain
* modified.
*/
-void DataArrayInt::applyRPow(int val) throw(INTERP_KERNEL::Exception)
+void DataArrayInt::applyRPow(int val)
{
checkAllocated();
int *ptr=getPointer();
* \throw If any given array is not allocated.
* \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
*/
-DataArrayInt *DataArrayInt::Meld(const DataArrayInt *a1, const DataArrayInt *a2) throw(INTERP_KERNEL::Exception)
+DataArrayInt *DataArrayInt::Meld(const DataArrayInt *a1, const DataArrayInt *a2)
{
std::vector<const DataArrayInt *> arr(2);
arr[0]=a1; arr[1]=a2;
* \throw If any given array is not allocated.
* \throw If getNumberOfTuples() of arrays within \a arr is different.
*/
-DataArrayInt *DataArrayInt::Meld(const std::vector<const DataArrayInt *>& arr) throw(INTERP_KERNEL::Exception)
+DataArrayInt *DataArrayInt::Meld(const std::vector<const DataArrayInt *>& arr)
{
std::vector<const DataArrayInt *> a;
for(std::vector<const DataArrayInt *>::const_iterator it4=arr.begin();it4!=arr.end();it4++)
int k=0;
for(int i=0;i<(int)a.size();i++)
for(int j=0;j<nbc[i];j++,k++)
- ret->setInfoOnComponent(k,a[i]->getInfoOnComponent(j).c_str());
+ ret->setInfoOnComponent(k,a[i]->getInfoOnComponent(j));
return ret;
}
* delete this array using decrRef() as it is no more needed.
* \throw If any element ID in \a groups violates condition ( 0 <= ID < \a newNb ).
*/
-DataArrayInt *DataArrayInt::MakePartition(const std::vector<const DataArrayInt *>& groups, int newNb, std::vector< std::vector<int> >& fidsOfGroups) throw(INTERP_KERNEL::Exception)
+DataArrayInt *DataArrayInt::MakePartition(const std::vector<const DataArrayInt *>& groups, int newNb, std::vector< std::vector<int> >& fidsOfGroups)
{
std::vector<const DataArrayInt *> groups2;
for(std::vector<const DataArrayInt *>::const_iterator it4=groups.begin();it4!=groups.end();it4++)
* \throw If any \a arr[i] is not allocated.
* \throw If \a arr[i]->getNumberOfComponents() != 1.
*/
-DataArrayInt *DataArrayInt::BuildUnion(const std::vector<const DataArrayInt *>& arr) throw(INTERP_KERNEL::Exception)
+DataArrayInt *DataArrayInt::BuildUnion(const std::vector<const DataArrayInt *>& arr)
{
std::vector<const DataArrayInt *> a;
for(std::vector<const DataArrayInt *>::const_iterator it4=arr.begin();it4!=arr.end();it4++)
* \throw If any \a arr[i] is not allocated.
* \throw If \a arr[i]->getNumberOfComponents() != 1.
*/
-DataArrayInt *DataArrayInt::BuildIntersection(const std::vector<const DataArrayInt *>& arr) throw(INTERP_KERNEL::Exception)
+DataArrayInt *DataArrayInt::BuildIntersection(const std::vector<const DataArrayInt *>& arr)
{
std::vector<const DataArrayInt *> a;
for(std::vector<const DataArrayInt *>::const_iterator it4=arr.begin();it4!=arr.end();it4++)
else
r=s1;
}
- DataArrayInt *ret=DataArrayInt::New();
+ DataArrayInt *ret(DataArrayInt::New());
ret->alloc((int)r.size(),1);
std::copy(r.begin(),r.end(),ret->getPointer());
return ret;
}
+/// @cond INTERNAL
+namespace ParaMEDMEMImpl
+{
+ class OpSwitchedOn
+ {
+ public:
+ OpSwitchedOn(int *pt):_pt(pt),_cnt(0) { }
+ void operator()(const bool& b) { if(b) *_pt++=_cnt; _cnt++; }
+ private:
+ int *_pt;
+ int _cnt;
+ };
+
+ class OpSwitchedOff
+ {
+ public:
+ OpSwitchedOff(int *pt):_pt(pt),_cnt(0) { }
+ void operator()(const bool& b) { if(!b) *_pt++=_cnt; _cnt++; }
+ private:
+ int *_pt;
+ int _cnt;
+ };
+}
+/// @endcond
+
+/*!
+ * This method returns the list of ids in ascending mode so that v[id]==true.
+ */
+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);
+ std::for_each(v.begin(),v.end(),ParaMEDMEMImpl::OpSwitchedOn(ret->getPointer()));
+ return ret.retn();
+}
+
+/*!
+ * This method returns the list of ids in ascending mode so that v[id]==false.
+ */
+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);
+ std::for_each(v.begin(),v.end(),ParaMEDMEMImpl::OpSwitchedOff(ret->getPointer()));
+ return ret.retn();
+}
+
+/*!
+ * This method allows to put a vector of vector of integer into a more compact data stucture (skyline).
+ * This method is not available into python because no available optimized data structure available to map std::vector< std::vector<int> >.
+ *
+ * \param [in] v the input data structure to be translate into skyline format.
+ * \param [out] data the first element of the skyline format. The user is expected to deal with newly allocated array.
+ * \param [out] dataIndex the second element of the skyline format.
+ */
+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());
+ ret1->alloc(sz+1,1);
+ int *pt(ret1->getPointer()); *pt=0;
+ for(int i=0;i<sz;i++,pt++)
+ pt[1]=pt[0]+(int)v[i].size();
+ ret0->alloc(ret1->back(),1);
+ pt=ret0->getPointer();
+ for(int i=0;i<sz;i++)
+ pt=std::copy(v[i].begin(),v[i].end(),pt);
+ data=ret0.retn(); dataIndex=ret1.retn();
+}
+
/*!
* Returns a new DataArrayInt which contains a complement of elements of \a this
* one-dimensional array. I.e. the result array contains all elements from the range [0,
* \throw If any element \a x of \a this array violates condition ( 0 <= \a x < \a
* nbOfElement ).
*/
-DataArrayInt *DataArrayInt::buildComplement(int nbOfElement) const throw(INTERP_KERNEL::Exception)
-{
- checkAllocated();
- if(getNumberOfComponents()!=1)
- throw INTERP_KERNEL::Exception("DataArrayInt::buildComplement : only single component allowed !");
- std::vector<bool> tmp(nbOfElement);
- const int *pt=getConstPointer();
- int nbOfTuples=getNumberOfTuples();
- for(const int *w=pt;w!=pt+nbOfTuples;w++)
- if(*w>=0 && *w<nbOfElement)
- tmp[*w]=true;
- else
- throw INTERP_KERNEL::Exception("DataArrayInt::buildComplement : an element is not in valid range : [0,nbOfElement) !");
- int nbOfRetVal=(int)std::count(tmp.begin(),tmp.end(),false);
- DataArrayInt *ret=DataArrayInt::New();
- ret->alloc(nbOfRetVal,1);
- int j=0;
- int *retPtr=ret->getPointer();
- for(int i=0;i<nbOfElement;i++)
- if(!tmp[i])
- retPtr[j++]=i;
- return ret;
+DataArrayInt *DataArrayInt::buildComplement(int nbOfElement) const
+{
+ checkAllocated();
+ if(getNumberOfComponents()!=1)
+ throw INTERP_KERNEL::Exception("DataArrayInt::buildComplement : only single component allowed !");
+ std::vector<bool> tmp(nbOfElement);
+ const int *pt=getConstPointer();
+ int nbOfTuples=getNumberOfTuples();
+ for(const int *w=pt;w!=pt+nbOfTuples;w++)
+ if(*w>=0 && *w<nbOfElement)
+ tmp[*w]=true;
+ else
+ throw INTERP_KERNEL::Exception("DataArrayInt::buildComplement : an element is not in valid range : [0,nbOfElement) !");
+ int nbOfRetVal=(int)std::count(tmp.begin(),tmp.end(),false);
+ DataArrayInt *ret=DataArrayInt::New();
+ ret->alloc(nbOfRetVal,1);
+ int j=0;
+ int *retPtr=ret->getPointer();
+ for(int i=0;i<nbOfElement;i++)
+ if(!tmp[i])
+ retPtr[j++]=i;
+ return ret;
}
/*!
* \throw If \a this->getNumberOfComponents() != 1.
* \sa DataArrayInt::buildSubstractionOptimized()
*/
-DataArrayInt *DataArrayInt::buildSubstraction(const DataArrayInt *other) const throw(INTERP_KERNEL::Exception)
+DataArrayInt *DataArrayInt::buildSubstraction(const DataArrayInt *other) const
{
if(!other)
throw INTERP_KERNEL::Exception("DataArrayInt::buildSubstraction : DataArrayInt pointer in input is NULL !");
checkAllocated();
other->checkAllocated();
if(getNumberOfComponents()!=1)
- throw INTERP_KERNEL::Exception("DataArrayInt::buildSubstraction : only single component allowed !");
+ throw INTERP_KERNEL::Exception("DataArrayInt::buildSubstraction : only single component allowed !");
if(other->getNumberOfComponents()!=1)
- throw INTERP_KERNEL::Exception("DataArrayInt::buildSubstraction : only single component allowed for other type !");
+ throw INTERP_KERNEL::Exception("DataArrayInt::buildSubstraction : only single component allowed for other type !");
const int *pt=getConstPointer();
int nbOfTuples=getNumberOfTuples();
std::set<int> s1(pt,pt+nbOfTuples);
* \ret list of ids in \a this but not in \a other.
* \sa DataArrayInt::buildSubstraction
*/
-DataArrayInt *DataArrayInt::buildSubstractionOptimized(const DataArrayInt *other) const throw(INTERP_KERNEL::Exception)
+DataArrayInt *DataArrayInt::buildSubstractionOptimized(const DataArrayInt *other) const
{
static const char *MSG="DataArrayInt::buildSubstractionOptimized : only single component allowed !";
if(!other) throw INTERP_KERNEL::Exception("DataArrayInt::buildSubstractionOptimized : NULL input array !");
checkAllocated(); other->checkAllocated();
if(getNumberOfComponents()!=1) throw INTERP_KERNEL::Exception(MSG);
if(other->getNumberOfComponents()!=1) throw INTERP_KERNEL::Exception(MSG);
- const int *pt1Bg(begin()),*pt1End(end()),*pt2Bg(other->begin()),*pt2End(other->end()),*work1(pt1Bg),*work2(pt2Bg);
+ 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);
for(;work1!=pt1End;work1++)
{
* \throw If \a this->getNumberOfComponents() != 1.
* \throw If \a other->getNumberOfComponents() != 1.
*/
-DataArrayInt *DataArrayInt::buildUnion(const DataArrayInt *other) const throw(INTERP_KERNEL::Exception)
+DataArrayInt *DataArrayInt::buildUnion(const DataArrayInt *other) const
{
std::vector<const DataArrayInt *>arrs(2);
arrs[0]=this; arrs[1]=other;
* \throw If \a this->getNumberOfComponents() != 1.
* \throw If \a other->getNumberOfComponents() != 1.
*/
-DataArrayInt *DataArrayInt::buildIntersection(const DataArrayInt *other) const throw(INTERP_KERNEL::Exception)
+DataArrayInt *DataArrayInt::buildIntersection(const DataArrayInt *other) const
{
std::vector<const DataArrayInt *>arrs(2);
arrs[0]=this; arrs[1]=other;
* \return a newly allocated array that contain the result of the unique operation applied on \a this.
* \throw if \a this is not allocated or if \a this has not exactly one component.
*/
-DataArrayInt *DataArrayInt::buildUnique() const throw(INTERP_KERNEL::Exception)
+DataArrayInt *DataArrayInt::buildUnique() const
{
checkAllocated();
if(getNumberOfComponents()!=1)
- throw INTERP_KERNEL::Exception("DataArrayInt::buildUnique : only single component allowed !");
+ throw INTERP_KERNEL::Exception("DataArrayInt::buildUnique : only single component allowed !");
int nbOfTuples=getNumberOfTuples();
MEDCouplingAutoRefCountObjectPtr<DataArrayInt> tmp=deepCpy();
int *data=tmp->getPointer();
*
* \sa DataArrayInt::computeOffsets2
*/
-DataArrayInt *DataArrayInt::deltaShiftIndex() const throw(INTERP_KERNEL::Exception)
+DataArrayInt *DataArrayInt::deltaShiftIndex() const
{
checkAllocated();
if(getNumberOfComponents()!=1)
- throw INTERP_KERNEL::Exception("DataArrayInt::deltaShiftIndex : only single component allowed !");
+ throw INTERP_KERNEL::Exception("DataArrayInt::deltaShiftIndex : only single component allowed !");
int nbOfTuples=getNumberOfTuples();
if(nbOfTuples<2)
throw INTERP_KERNEL::Exception("DataArrayInt::deltaShiftIndex : 1 tuple at least must be present in 'this' !");
* Note that the last element 19 = 11 + 8 is missing because size of \a this
* array is retained and thus there is no space to store the last element.
*/
-void DataArrayInt::computeOffsets() throw(INTERP_KERNEL::Exception)
+void DataArrayInt::computeOffsets()
{
checkAllocated();
if(getNumberOfComponents()!=1)
- throw INTERP_KERNEL::Exception("DataArrayInt::computeOffsets : only single component allowed !");
+ throw INTERP_KERNEL::Exception("DataArrayInt::computeOffsets : only single component allowed !");
int nbOfTuples=getNumberOfTuples();
if(nbOfTuples==0)
return ;
* - After \a this contains [0,3,8,9,11,11,19]<br>
* \sa DataArrayInt::deltaShiftIndex
*/
-void DataArrayInt::computeOffsets2() throw(INTERP_KERNEL::Exception)
+void DataArrayInt::computeOffsets2()
{
checkAllocated();
if(getNumberOfComponents()!=1)
* 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)
+void DataArrayInt::searchRangesInListOfIds(const DataArrayInt *listOfIds, DataArrayInt *& rangeIdsFetched, DataArrayInt *& idsInInputListThatFetch) const
{
if(!listOfIds)
throw INTERP_KERNEL::Exception("DataArrayInt::searchRangesInListOfIds : input list of ids is null !");
* \c range( \a offsets[ \a this[1] ], offsets[ \a this[1]+1 ]) +
* \c range( \a offsets[ \a this[2] ], offsets[ \a this[2]+1 ])
*/
-DataArrayInt *DataArrayInt::buildExplicitArrByRanges(const DataArrayInt *offsets) const throw(INTERP_KERNEL::Exception)
+DataArrayInt *DataArrayInt::buildExplicitArrByRanges(const DataArrayInt *offsets) const
{
if(!offsets)
throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrByRanges : DataArrayInt pointer in input is NULL !");
checkAllocated();
if(getNumberOfComponents()!=1)
- throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrByRanges : only single component allowed !");
+ throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrByRanges : only single component allowed !");
offsets->checkAllocated();
if(offsets->getNumberOfComponents()!=1)
- throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrByRanges : input array should have only single component !");
+ throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrByRanges : input array should have only single component !");
int othNbTuples=offsets->getNumberOfTuples()-1;
int nbOfTuples=getNumberOfTuples();
int retNbOftuples=0;
* \throw If \a this->getNumberOfComponents() != 1.
* \throw If \a this->getNumberOfTuples() == 0.
* \throw If \a this is not monotonically increasing.
- * \throw If any element of ids in ( \a gb \a end \a step ) points outside the scale in \a this.
+ * \throw If any element of ids in ( \a bg \a stop \a step ) points outside the scale in \a this.
*
* \b Example: <br>
- * - \a bg , \a end and \a step : (0,5,2)
+ * - \a bg , \a stop and \a step : (0,5,2)
* - \a this: [0,3,6,10,14,20]
* - result array: [0,0,0, 2,2,2,2, 4,4,4,4,4,4] == <br>
*/
-DataArrayInt *DataArrayInt::buildExplicitArrOfSliceOnScaledArr(int bg, int end, int step) const throw(INTERP_KERNEL::Exception)
+DataArrayInt *DataArrayInt::buildExplicitArrOfSliceOnScaledArr(int bg, int stop, int step) const
{
if(!isAllocated())
throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrOfSliceOnScaledArr : not allocated array !");
if(nbOfTuples==0)
throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrOfSliceOnScaledArr : number of tuples must be != 0 !");
const int *ids(begin());
- int nbOfEltsInSlc(GetNumberOfItemGivenBESRelative(bg,end,step,"DataArrayInt::buildExplicitArrOfSliceOnScaledArr")),sz(0),pos(bg);
+ int nbOfEltsInSlc(GetNumberOfItemGivenBESRelative(bg,stop,step,"DataArrayInt::buildExplicitArrOfSliceOnScaledArr")),sz(0),pos(bg);
for(int i=0;i<nbOfEltsInSlc;i++,pos+=step)
{
if(pos>=0 && pos<nbOfTuples-1)
*
* \sa DataArrayInt::findIdInRangeForEachTuple
*/
-DataArrayInt *DataArrayInt::findRangeIdForEachTuple(const DataArrayInt *ranges) const throw(INTERP_KERNEL::Exception)
+DataArrayInt *DataArrayInt::findRangeIdForEachTuple(const DataArrayInt *ranges) const
{
if(!ranges)
throw INTERP_KERNEL::Exception("DataArrayInt::findRangeIdForEachTuple : null input pointer !");
* is thrown if no ranges in \a ranges contains value in \a this.
* \sa DataArrayInt::findRangeIdForEachTuple
*/
-DataArrayInt *DataArrayInt::findIdInRangeForEachTuple(const DataArrayInt *ranges) const throw(INTERP_KERNEL::Exception)
+DataArrayInt *DataArrayInt::findIdInRangeForEachTuple(const DataArrayInt *ranges) const
{
if(!ranges)
throw INTERP_KERNEL::Exception("DataArrayInt::findIdInRangeForEachTuple : null input pointer !");
* \return a newly allocated DataArrayInt having one component and number of tuples equal to \a nbTimes * \c this->getNumberOfTuples.
* \throw if \a this is not allocated or if \a this has not number of components set to one or if \a nbTimes is lower than 1.
*/
-DataArrayInt *DataArrayInt::duplicateEachTupleNTimes(int nbTimes) const throw(INTERP_KERNEL::Exception)
+DataArrayInt *DataArrayInt::duplicateEachTupleNTimes(int nbTimes) const
{
checkAllocated();
if(getNumberOfComponents()!=1)
* But the number of components can be different from one.
* \return a newly allocated array (that should be dealt by the caller) containing different values in \a this.
*/
-DataArrayInt *DataArrayInt::getDifferentValues() const throw(INTERP_KERNEL::Exception)
+DataArrayInt *DataArrayInt::getDifferentValues() const
{
checkAllocated();
std::set<int> ret;
* The instances of DataArrayInt in the returned vector have be specially allocated and computed by this method. Each of them should be dealt by the caller of this method.
* Example : if this is equal to [1,0,1,2,0,2,2,-3,2] -> differentIds=[-3,0,1,2] and returned array will be equal to [[7],[1,4],[0,2],[3,5,6,8]]
*/
-std::vector<DataArrayInt *> DataArrayInt::partitionByDifferentValues(std::vector<int>& differentIds) const throw(INTERP_KERNEL::Exception)
+std::vector<DataArrayInt *> DataArrayInt::partitionByDifferentValues(std::vector<int>& differentIds) const
{
checkAllocated();
if(getNumberOfComponents()!=1)
return ret;
}
+/*!
+ * This method split ids in [0, \c this->getNumberOfTuples() ) using \a this array as a field of weight (>=0 each).
+ * The aim of this method is to return a set of \a nbOfSlices chunk of contiguous ids as balanced as possible.
+ *
+ * \param [in] nbOfSlices - number of slices expected.
+ * \return - a vector having a size equal to \a nbOfSlices giving the start (included) and the stop (excluded) of each chunks.
+ *
+ * \sa DataArray::GetSlice
+ * \throw If \a this is not allocated or not with exactly one component.
+ * \throw If an element in \a this if < 0.
+ */
+std::vector< std::pair<int,int> > DataArrayInt::splitInBalancedSlices(int nbOfSlices) const
+{
+ if(!isAllocated() || getNumberOfComponents()!=1)
+ throw INTERP_KERNEL::Exception("DataArrayInt::splitInBalancedSlices : this array should have number of components equal to one and must be allocated !");
+ if(nbOfSlices<=0)
+ throw INTERP_KERNEL::Exception("DataArrayInt::splitInBalancedSlices : number of slices must be >= 1 !");
+ int sum(accumulate(0)),nbOfTuples(getNumberOfTuples());
+ int sumPerSlc(sum/nbOfSlices),pos(0);
+ const int *w(begin());
+ std::vector< std::pair<int,int> > ret(nbOfSlices);
+ for(int i=0;i<nbOfSlices;i++)
+ {
+ std::pair<int,int> p(pos,-1);
+ int locSum(0);
+ while(locSum<sumPerSlc && pos<nbOfTuples) { pos++; locSum+=*w++; }
+ if(i!=nbOfSlices-1)
+ p.second=pos;
+ else
+ p.second=nbOfTuples;
+ ret[i]=p;
+ }
+ return ret;
+}
+
/*!
* Returns a new DataArrayInt that is a sum of two given arrays. There are 3
* valid cases.
* \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
* none of them has number of tuples or components equal to 1.
*/
-DataArrayInt *DataArrayInt::Add(const DataArrayInt *a1, const DataArrayInt *a2) throw(INTERP_KERNEL::Exception)
+DataArrayInt *DataArrayInt::Add(const DataArrayInt *a1, const DataArrayInt *a2)
{
if(!a1 || !a2)
throw INTERP_KERNEL::Exception("DataArrayInt::Add : input DataArrayInt instance is NULL !");
* \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
* \a other has number of both tuples and components not equal to 1.
*/
-void DataArrayInt::addEqual(const DataArrayInt *other) throw(INTERP_KERNEL::Exception)
+void DataArrayInt::addEqual(const DataArrayInt *other)
{
if(!other)
throw INTERP_KERNEL::Exception("DataArrayInt::addEqual : input DataArrayInt instance is NULL !");
* \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
* none of them has number of tuples or components equal to 1.
*/
-DataArrayInt *DataArrayInt::Substract(const DataArrayInt *a1, const DataArrayInt *a2) throw(INTERP_KERNEL::Exception)
+DataArrayInt *DataArrayInt::Substract(const DataArrayInt *a1, const DataArrayInt *a2)
{
if(!a1 || !a2)
throw INTERP_KERNEL::Exception("DataArrayInt::Substract : input DataArrayInt instance is NULL !");
* \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
* \a other has number of both tuples and components not equal to 1.
*/
-void DataArrayInt::substractEqual(const DataArrayInt *other) throw(INTERP_KERNEL::Exception)
+void DataArrayInt::substractEqual(const DataArrayInt *other)
{
if(!other)
throw INTERP_KERNEL::Exception("DataArrayInt::substractEqual : input DataArrayInt instance is NULL !");
* \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
* none of them has number of tuples or components equal to 1.
*/
-DataArrayInt *DataArrayInt::Multiply(const DataArrayInt *a1, const DataArrayInt *a2) throw(INTERP_KERNEL::Exception)
+DataArrayInt *DataArrayInt::Multiply(const DataArrayInt *a1, const DataArrayInt *a2)
{
if(!a1 || !a2)
throw INTERP_KERNEL::Exception("DataArrayInt::Multiply : input DataArrayInt instance is NULL !");
* \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
* \a other has number of both tuples and components not equal to 1.
*/
-void DataArrayInt::multiplyEqual(const DataArrayInt *other) throw(INTERP_KERNEL::Exception)
+void DataArrayInt::multiplyEqual(const DataArrayInt *other)
{
if(!other)
throw INTERP_KERNEL::Exception("DataArrayInt::multiplyEqual : input DataArrayInt instance is NULL !");
* \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
* none of them has number of tuples or components equal to 1.
*/
-DataArrayInt *DataArrayInt::Divide(const DataArrayInt *a1, const DataArrayInt *a2) throw(INTERP_KERNEL::Exception)
+DataArrayInt *DataArrayInt::Divide(const DataArrayInt *a1, const DataArrayInt *a2)
{
if(!a1 || !a2)
throw INTERP_KERNEL::Exception("DataArrayInt::Divide : input DataArrayInt instance is NULL !");
* \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
* \a other has number of both tuples and components not equal to 1.
*/
-void DataArrayInt::divideEqual(const DataArrayInt *other) throw(INTERP_KERNEL::Exception)
+void DataArrayInt::divideEqual(const DataArrayInt *other)
{
if(!other)
throw INTERP_KERNEL::Exception("DataArrayInt::divideEqual : input DataArrayInt instance is NULL !");
* \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
* none of them has number of tuples or components equal to 1.
*/
-DataArrayInt *DataArrayInt::Modulus(const DataArrayInt *a1, const DataArrayInt *a2) throw(INTERP_KERNEL::Exception)
+DataArrayInt *DataArrayInt::Modulus(const DataArrayInt *a1, const DataArrayInt *a2)
{
- if(!a1 || !a2)
+ if(!a1 || !a2)
throw INTERP_KERNEL::Exception("DataArrayInt::Modulus : input DataArrayInt instance is NULL !");
int nbOfTuple1=a1->getNumberOfTuples();
int nbOfTuple2=a2->getNumberOfTuples();
* \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
* \a other has number of both tuples and components not equal to 1.
*/
-void DataArrayInt::modulusEqual(const DataArrayInt *other) throw(INTERP_KERNEL::Exception)
+void DataArrayInt::modulusEqual(const DataArrayInt *other)
{
if(!other)
throw INTERP_KERNEL::Exception("DataArrayInt::modulusEqual : input DataArrayInt instance is NULL !");
* \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)
+DataArrayInt *DataArrayInt::Pow(const DataArrayInt *a1, const DataArrayInt *a2)
{
if(!a1 || !a2)
throw INTERP_KERNEL::Exception("DataArrayInt::Pow : at least one of input instances is null !");
* \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)
+void DataArrayInt::powEqual(const DataArrayInt *other)
{
if(!other)
throw INTERP_KERNEL::Exception("DataArrayInt::powEqual : input instance is null !");
* \throw If \a end < \a begin && \a step > 0.
* \throw If \a end > \a begin && \a step < 0.
*/
-DataArrayInt *DataArrayInt::Range(int begin, int end, int step) throw(INTERP_KERNEL::Exception)
+DataArrayInt *DataArrayInt::Range(int begin, int end, int step)
{
int nbOfTuples=GetNumberOfItemGivenBESRelative(begin,end,step,"DataArrayInt::Range");
MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
*/
void DataArrayInt::finishUnserialization(const std::vector<int>& tinyInfoI, const std::vector<std::string>& tinyInfoS)
{
- setName(tinyInfoS[0].c_str());
+ setName(tinyInfoS[0]);
if(isAllocated())
{
int nbOfCompo=tinyInfoI[1];
for(int i=0;i<nbOfCompo;i++)
- setInfoOnComponent(i,tinyInfoS[i+1].c_str());
+ setInfoOnComponent(i,tinyInfoS[i+1]);
}
}
_da->decrRef();
}
-DataArrayIntTuple *DataArrayIntIterator::nextt() throw(INTERP_KERNEL::Exception)
+DataArrayIntTuple *DataArrayIntIterator::nextt()
{
if(_tuple_id<_nb_tuple)
{
{
}
-std::string DataArrayIntTuple::repr() const throw(INTERP_KERNEL::Exception)
+std::string DataArrayIntTuple::repr() const
{
std::ostringstream oss; oss << "(";
for(int i=0;i<_nb_of_compo-1;i++)
return oss.str();
}
-int DataArrayIntTuple::intValue() const throw(INTERP_KERNEL::Exception)
+int DataArrayIntTuple::intValue() const
{
if(_nb_of_compo==1)
return *_pt;
* This method throws an INTERP_KERNEL::Exception is it is impossible to match sizes of \b this that is too say \b nbOfCompo=this->_nb_of_elem and \bnbOfTuples==1 or
* \b nbOfCompo=1 and \bnbOfTuples==this->_nb_of_elem.
*/
-DataArrayInt *DataArrayIntTuple::buildDAInt(int nbOfTuples, int nbOfCompo) const throw(INTERP_KERNEL::Exception)
+DataArrayInt *DataArrayIntTuple::buildDAInt(int nbOfTuples, int nbOfCompo) const
{
if((_nb_of_compo==nbOfCompo && nbOfTuples==1) || (_nb_of_compo==nbOfTuples && nbOfCompo==1))
{
