//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// Author : Anthony Geay (CEA/DEN)
+// Author : Anthony Geay (EDF R&D)
#ifndef __PARAMEDMEM_MEDCOUPLINGMEMARRAY_TXX__
#define __PARAMEDMEM_MEDCOUPLINGMEMARRAY_TXX__
/*!
* This method performs systematically an allocation of \a newNbOfElements elements in \a this.
* \a _nb_of_elem and \a _nb_of_elem_alloc will be equal even if only std::min<std::size_t>(_nb_of_elem,newNbOfElements) come from the .
- * The remaing part of the new allocated chunk are available but not set previouly !
+ * The remaining part of the new allocated chunk are available but not set previously !
*
* So this method should not be confused with MemArray<T>::reserve that is close to MemArray<T>::reAlloc but not same.
*/
}
/*!
- * This method desallocated \a this without modification of informations relative to the components.
+ * This method deallocated \a this without modification of information relative to the components.
* After call of this method, DataArrayDouble::isAllocated will return false.
* If \a this is already not allocated, \a this is let unchanged.
*/
* This method reserve nbOfElems elements in memory ( nbOfElems*8 bytes ) \b without impacting the number of tuples in \a this.
* If \a this has already been allocated, this method checks that \a this has only one component. If not an INTERP_KERNEL::Exception will be thrown.
* If \a this has not already been allocated, number of components is set to one.
- * This method allows to reduce number of reallocations on invokation of DataArrayDouble::pushBackSilent and DataArrayDouble::pushBackValsSilent on \a this.
+ * This method allows to reduce number of reallocations on invocation of DataArrayDouble::pushBackSilent and DataArrayDouble::pushBackValsSilent on \a this.
*
* \sa DataArrayDouble::pack, DataArrayDouble::pushBackSilent, DataArrayDouble::pushBackValsSilent
*/
}
/*!
- * This method adds at the end of \a this a serie of values [\c valsBg,\c valsEnd). This method do \b not update its time label to avoid useless incrementation
+ * This method adds at the end of \a this a series of values [\c valsBg,\c valsEnd). This method do \b not update its time label to avoid useless incrementation
* of counter. So the caller is expected to call TimeLabel::declareAsNew on \a this at the end of the push session.
*
* \param [in] valsBg - an array of values to push at the end of \c this.
{
int a,b,c;
spd->getSlice(a,b,c);
- if(a==0 && b==getNumberOfTuples() && c==1)
+ if(a==0 && b==(int)getNumberOfTuples() && c==1)
{
DataArrayTemplate<T> *directRet(const_cast<DataArrayTemplate<T> *>(this));
directRet->incrRef();
* \return double - the maximal value among all values of \a this array.
* \throw If \a this->getNumberOfComponents() != 1
* \throw If \a this->getNumberOfTuples() < 1
+ * \sa getMaxAbsValue, getMinValue
*/
template<class T>
T DataArrayTemplate<T>::getMaxValue(int& tupleId) const
* one component.
* \return double - the maximal value among all values of \a this array.
* \throw If \a this is not allocated.
+ * \sa getMaxAbsValueInArray, getMinValueInArray
*/
template<class T>
T DataArrayTemplate<T>::getMaxValueInArray() const
return *loc;
}
+ /*!
+ * Returns the maximal absolute value in \a this and the first occurrence location associated to it.
+ * \return the element in this (positive or negative) having the max abs value in \a this.
+ * \throw If \a this is not allocated.
+ * \throw If \a this is non one component array.
+ * \throw If \a this is empty.
+ */
+ template<class T>
+ T DataArrayTemplate<T>::getMaxAbsValue(std::size_t& tupleId) const
+ {
+ checkAllocated();
+ if(getNumberOfComponents()!=1)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::getMaxAbsValue : must be applied on DataArrayDouble with only one component, you can call 'rearrange' method before or call 'getMaxValueInArray' method !");
+ std::size_t nbTuples(this->getNumberOfTuples());
+ if(nbTuples==0)
+ throw INTERP_KERNEL::Exception("DataArrayTemplate<T>::getMaxAbsValue : empty array !");
+ T ret((T)-1);
+ tupleId=0;
+ const T *pt(begin());
+ for(std::size_t i=0;i<nbTuples;i++,pt++)
+ {
+ T cand(std::abs(*pt));
+ if(cand>ret)
+ {
+ ret=cand;
+ tupleId=i;
+ }
+ }
+ return this->getIJ(tupleId,0);
+ }
+
+ /*!
+ * Returns the maximal absolute value in \a this.
+ * \throw If \a this is not allocated.
+ * \throw If \a this is non one component array.
+ * \throw If \a this is empty.
+ */
+ template<class T>
+ T DataArrayTemplate<T>::getMaxAbsValueInArray() const
+ {
+ std::size_t dummy;
+ return getMaxAbsValue(dummy);
+ }
+
/*!
* Returns the minimal value and its location within \a this one-dimensional array.
* \param [out] tupleId - index of the tuple holding the minimal value.
}
}
+ /*!
+ * Assign zero to all values in \a this array. To know more on filling arrays see
+ * \ref MEDCouplingArrayFill.
+ * \throw If \a this is not allocated.
+ */
+ template<class T>
+ void DataArrayTemplate<T>::fillWithZero()
+ {
+ fillWithValue((T)0);
+ }
+
+ //////////////////////////////
+
template<class T>
template<class U>
MCAuto< typename Traits<U>::ArrayType > DataArrayTemplateClassic<T>::convertToOtherTypeOfArr() const
for(it=a.begin();it!=a.end();it++)
(*it)->checkAllocated();
it=a.begin();
- int nbOfTuples((*it)->getNumberOfTuples());
+ std::size_t nbOfTuples((*it)->getNumberOfTuples());
std::vector<int> nbc(a.size());
std::vector<const T *> pts(a.size());
nbc[0]=(*it)->getNumberOfComponents();
typename Traits<T>::ArrayType *ret(Traits<T>::ArrayType::New());
ret->alloc(nbOfTuples,totalNbOfComp);
T *retPtr(ret->getPointer());
- for(int i=0;i<nbOfTuples;i++)
- for(int j=0;j<(int)a.size();j++)
+ for(std::size_t i=0;i<nbOfTuples;i++)
+ for(std::size_t j=0;j<a.size();j++)
{
retPtr=std::copy(pts[j],pts[j]+nbc[j],retPtr);
pts[j]+=nbc[j];
{
this->checkAllocated();
other->checkAllocated();
- int nbOfTuples(this->getNumberOfTuples());
+ std::size_t nbOfTuples(this->getNumberOfTuples());
if(nbOfTuples!=other->getNumberOfTuples())
throw INTERP_KERNEL::Exception("DataArrayDouble::meldWith : mismatch of number of tuples !");
int nbOfComp1(this->getNumberOfComponents()),nbOfComp2(other->getNumberOfComponents());
T *newArr=(T *)malloc((nbOfTuples*(nbOfComp1+nbOfComp2))*sizeof(T));
T *w=newArr;
const T *inp1(this->begin()),*inp2(other->begin());
- for(int i=0;i<nbOfTuples;i++,inp1+=nbOfComp1,inp2+=nbOfComp2)
+ for(std::size_t i=0;i<nbOfTuples;i++,inp1+=nbOfComp1,inp2+=nbOfComp2)
{
w=std::copy(inp1,inp1+nbOfComp1,w);
w=std::copy(inp2,inp2+nbOfComp2,w);
const typename Traits<T>::ArrayType *thisC(static_cast<const typename Traits<T>::ArrayType *>(this));
return DataArrayTemplateClassic<T>::PerformCopyOrIncrRef(dCpy,*thisC);
}
-
+
/*!
- * Checks if all values in \a this array are equal to \a val at precision \a eps.
- * \param [in] val - value to check equality of array values to.
- * \param [in] eps - precision to check the equality.
- * \return bool - \a true if all values are in range (_val_ - _eps_; _val_ + _eps_),
- * \a false else.
- * \throw If \a this->getNumberOfComponents() != 1
+ * 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.
*/
template<class T>
- bool DataArrayTemplateFP<T>::isUniform(T val, T eps) const
+ typename Traits<T>::ArrayType *DataArrayTemplateClassic<T>::sumPerTuple() const
{
this->checkAllocated();
- if(this->getNumberOfComponents()!=1)
- throw INTERP_KERNEL::Exception("DataArrayDouble::isUniform : must be applied on DataArrayDouble with only one component, you can call 'rearrange' method before !");
- const T *w(this->begin()),*end2(this->end());
- const T vmin(val-eps),vmax(val+eps);
- for(;w!=end2;w++)
- if(*w<vmin || *w>vmax)
- return false;
- return true;
+ std::size_t nbOfComp(this->getNumberOfComponents()),nbOfTuple(this->getNumberOfTuples());
+ MCAuto<typename Traits<T>::ArrayType> ret(Traits<T>::ArrayType::New());
+ ret->alloc(nbOfTuple,1);
+ const T *src(this->begin());
+ T *dest(ret->getPointer());
+ for(std::size_t i=0;i<nbOfTuple;i++,dest++,src+=nbOfComp)
+ *dest=std::accumulate(src,src+nbOfComp,(T)0);
+ return ret.retn();
}
/*!
* \throw If \a this is not allocated.
*/
template<class T>
- void DataArrayTemplateFP<T>::iota(T init)
+ void DataArrayTemplateClassic<T>::iota(T init)
{
this->checkAllocated();
if(this->getNumberOfComponents()!=1)
throw INTERP_KERNEL::Exception("DataArrayDouble::iota : works only for arrays with only one component, you can call 'rearrange' method before !");
T *ptr(this->getPointer());
- int ntuples(this->getNumberOfTuples());
- for(int i=0;i<ntuples;i++)
- ptr[i]=init+T(i);
+ std::size_t ntuples(this->getNumberOfTuples());
+ for(std::size_t i=0;i<ntuples;i++)
+ ptr[i]=init+(T)i;
this->declareAsNew();
}
+ template<class T>
+ struct ImplReprTraits { static void SetPrecision(std::ostream& oss) { } };
+
+ template<>
+ struct ImplReprTraits<double> { static void SetPrecision(std::ostream& oss) { oss.precision(17); } };
+
+ template<>
+ struct ImplReprTraits<float> { static void SetPrecision(std::ostream& oss) { oss.precision(7); } };
+
+ template<class T>
+ void DataArrayTemplateClassic<T>::reprStream(std::ostream& stream) const
+ {
+ stream << "Name of " << Traits<T>::ReprStr << " array : \"" << this->_name << "\"\n";
+ reprWithoutNameStream(stream);
+ }
+
+ template<class T>
+ void DataArrayTemplateClassic<T>::reprZipStream(std::ostream& stream) const
+ {
+ stream << "Name of " << Traits<T>::ReprStr << " array : \"" << this->_name << "\"\n";
+ reprZipWithoutNameStream(stream);
+ }
+
+ template<class T>
+ void DataArrayTemplateClassic<T>::reprNotTooLongStream(std::ostream& stream) const
+ {
+ stream << "Name of "<< Traits<T>::ReprStr << " array : \"" << this->_name << "\"\n";
+ reprNotTooLongWithoutNameStream(stream);
+ }
+
+ template<class T>
+ void DataArrayTemplateClassic<T>::reprWithoutNameStream(std::ostream& stream) const
+ {
+ DataArray::reprWithoutNameStream(stream);
+ ImplReprTraits<T>::SetPrecision(stream);
+ this->_mem.repr(this->getNumberOfComponents(),stream);
+ }
+
+ template<class T>
+ void DataArrayTemplateClassic<T>::reprZipWithoutNameStream(std::ostream& stream) const
+ {
+ DataArray::reprWithoutNameStream(stream);
+ ImplReprTraits<T>::SetPrecision(stream);
+ this->_mem.reprZip(this->getNumberOfComponents(),stream);
+ }
+
+ template<class T>
+ void DataArrayTemplateClassic<T>::reprNotTooLongWithoutNameStream(std::ostream& stream) const
+ {
+ DataArray::reprWithoutNameStream(stream);
+ ImplReprTraits<T>::SetPrecision(stream);
+ this->_mem.reprNotTooLong(this->getNumberOfComponents(),stream);
+ }
+
+ /*!
+ * This method is close to repr method except that when \a this has more than 1000 tuples, all tuples are not
+ * printed out to avoid to consume too much space in interpretor.
+ * \sa repr
+ */
+ template<class T>
+ std::string DataArrayTemplateClassic<T>::reprNotTooLong() const
+ {
+ std::ostringstream ret;
+ reprNotTooLongStream(ret);
+ return ret.str();
+ }
+
+ /////////////////////////////////
+
+ /*!
+ * Checks if all values in \a this array are equal to \a val at precision \a eps.
+ * \param [in] val - value to check equality of array values to.
+ * \param [in] eps - precision to check the equality.
+ * \return bool - \a true if all values are in range (_val_ - _eps_; _val_ + _eps_),
+ * \a false else.
+ * \throw If \a this->getNumberOfComponents() != 1
+ * \throw If \a this is not allocated.
+ */
+ template<class T>
+ bool DataArrayTemplateFP<T>::isUniform(T val, T eps) const
+ {
+ this->checkAllocated();
+ if(this->getNumberOfComponents()!=1)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::isUniform : must be applied on DataArrayDouble with only one component, you can call 'rearrange' method before !");
+ const T *w(this->begin()),*end2(this->end());
+ const T vmin(val-eps),vmax(val+eps);
+ for(;w!=end2;w++)
+ if(*w<vmin || *w>vmax)
+ return false;
+ return true;
+ }
+
/*!
* Equivalent to DataArrayInt::isEqual except that if false the reason of
* mismatch is given.
switchOnTupleAlg(val,vec,std::not_equal_to<T>());
}
+ /*!
+ * Creates a new one-dimensional DataArrayInt of the same size as \a this and a given
+ * one-dimensional arrays that must be of the same length. The result array describes
+ * correspondence between \a this and \a other arrays, so that
+ * <em> other.getIJ(i,0) == this->getIJ(ret->getIJ(i),0)</em>. If such a permutation is
+ * not possible because some element in \a other is not in \a this, an exception is thrown.
+ * \param [in] other - an array to compute permutation to.
+ * \return DataArrayInt * - a new instance of DataArrayInt, which is a permutation array
+ * from \a this to \a other. The caller is to delete this array using decrRef() as it is
+ * no more needed.
+ * \throw If \a this->getNumberOfComponents() != 1.
+ * \throw If \a other->getNumberOfComponents() != 1.
+ * \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
+ */
+ template<class T>
+ DataArrayIdType *DataArrayDiscrete<T>::buildPermutationArr(const DataArrayDiscrete<T>& other) const
+ {
+ this->checkAllocated();
+ if(this->getNumberOfComponents()!=1 || other.getNumberOfComponents()!=1)
+ throw INTERP_KERNEL::Exception("DataArrayInt::buildPermutationArr : 'this' and 'other' have to have exactly ONE component !");
+ std::size_t nbTuple(this->getNumberOfTuples());
+ other.checkAllocated();
+ if(nbTuple!=other.getNumberOfTuples())
+ throw INTERP_KERNEL::Exception("DataArrayInt::buildPermutationArr : 'this' and 'other' must have the same number of tuple !");
+ MCAuto<DataArrayIdType> ret(DataArrayIdType::New());
+ ret->alloc(nbTuple,1);
+ ret->fillWithValue(-1);
+ const T *pt(this->begin());
+ std::map<int,mcIdType> mm;
+ for(std::size_t i=0;i<nbTuple;i++)
+ mm[pt[i]]=(mcIdType)i;
+ pt=other.begin();
+ mcIdType *retToFill(ret->getPointer());
+ for(std::size_t i=0;i<nbTuple;i++)
+ {
+ std::map<int,int>::const_iterator it=mm.find(pt[i]);
+ if(it==mm.end())
+ {
+ std::ostringstream oss; oss << "DataArrayInt::buildPermutationArr : Arrays mismatch : element (" << pt[i] << ") in 'other' not findable in 'this' !";
+ throw INTERP_KERNEL::Exception(oss.str().c_str());
+ }
+ retToFill[i]=(*it).second;
+ }
+ return ret.retn();
+ }
+
+ /*!
+ * Elements of \a partOfThis are expected to be included in \a this.
+ * The returned array \a ret is so that this[ret]==partOfThis
+ *
+ * For example, if \a this array contents are [9,10,0,6,4,11,3,8] and if \a partOfThis contains [6,0,11,8]
+ * the return array will contain [3,2,5,7].
+ *
+ * \a this is expected to be a 1 compo allocated array.
+ * \param [in] partOfThis - A 1 compo allocated array
+ * \return - A newly allocated array to be dealed by caller having the same number of tuples than \a partOfThis.
+ * \throw if two same element is present twice in \a this
+ * \throw if an element in \a partOfThis is \b NOT in \a this.
+ */
+ template<class T>
+ DataArrayIdType *DataArrayDiscrete<T>::indicesOfSubPart(const DataArrayDiscrete<T>& partOfThis) const
+ {
+ if(this->getNumberOfComponents()!=1 || partOfThis.getNumberOfComponents()!=1)
+ throw INTERP_KERNEL::Exception("DataArrayInt::indicesOfSubPart : this and input array must be one component array !");
+ this->checkAllocated(); partOfThis.checkAllocated();
+ std::size_t thisNbTuples(this->getNumberOfTuples()),nbTuples(partOfThis.getNumberOfTuples());
+ const T *thisPt(this->begin()),*pt(partOfThis.begin());
+ MCAuto<DataArrayIdType> ret(DataArrayIdType::New());
+ ret->alloc(nbTuples,1);
+ T *retPt(ret->getPointer());
+ std::map<int,mcIdType> m;
+ for(std::size_t i=0;i<thisNbTuples;i++,thisPt++)
+ m[*thisPt]=(mcIdType)i;
+ if(m.size()!=thisNbTuples)
+ throw INTERP_KERNEL::Exception("DataArrayInt::indicesOfSubPart : some elements appears more than once !");
+ for(std::size_t i=0;i<nbTuples;i++,retPt++,pt++)
+ {
+ std::map<int,mcIdType>::const_iterator it(m.find(*pt));
+ if(it!=m.end())
+ *retPt=(*it).second;
+ else
+ {
+ std::ostringstream oss; oss << "DataArrayInt::indicesOfSubPart : At pos #" << i << " of input array value is " << *pt << " not in this !";
+ throw INTERP_KERNEL::Exception(oss.str());
+ }
+ }
+ return ret.retn();
+ }
+
+ /*!
+ * Checks that \a this array is consistently **increasing** or **decreasing** in value.
+ * If not an exception is thrown.
+ * \param [in] increasing - if \a true, the array values should be increasing.
+ * \throw If sequence of values is not strictly monotonic in agreement with \a
+ * increasing arg.
+ * \throw If \a this->getNumberOfComponents() != 1.
+ * \throw If \a this is not allocated.
+ */
+ template<class T>
+ void DataArrayDiscrete<T>::checkMonotonic(bool increasing) const
+ {
+ if(!isMonotonic(increasing))
+ {
+ if (increasing)
+ throw INTERP_KERNEL::Exception("DataArrayInt::checkMonotonic : 'this' is not INCREASING monotonic !");
+ else
+ throw INTERP_KERNEL::Exception("DataArrayInt::checkMonotonic : 'this' is not DECREASING monotonic !");
+ }
+ }
+
+ /*!
+ * Checks that \a this array is consistently **increasing** or **decreasing** in value.
+ * \param [in] increasing - if \a true, array values should be increasing.
+ * \return bool - \a true if values change in accordance with \a increasing arg.
+ * \throw If \a this->getNumberOfComponents() != 1.
+ * \throw If \a this is not allocated.
+ */
+ template<class T>
+ bool DataArrayDiscrete<T>::isMonotonic(bool increasing) const
+ {
+ this->checkAllocated();
+ if(this->getNumberOfComponents()!=1)
+ throw INTERP_KERNEL::Exception("DataArrayInt::isMonotonic : only supported with 'this' array with ONE component !");
+ std::size_t nbOfElements(this->getNumberOfTuples());
+ const T *ptr(this->begin());
+ if(nbOfElements==0)
+ return true;
+ T ref(ptr[0]);
+ if(increasing)
+ {
+ for(std::size_t i=1;i<nbOfElements;i++)
+ {
+ if(ptr[i]>=ref)
+ ref=ptr[i];
+ else
+ return false;
+ }
+ }
+ else
+ {
+ for(std::size_t i=1;i<nbOfElements;i++)
+ {
+ if(ptr[i]<=ref)
+ ref=ptr[i];
+ else
+ return false;
+ }
+ }
+ return true;
+ }
+
+ /*!
+ * This method check that array consistently INCREASING or DECREASING in value.
+ */
+ template<class T>
+ bool DataArrayDiscrete<T>::isStrictlyMonotonic(bool increasing) const
+ {
+ this->checkAllocated();
+ if(this->getNumberOfComponents()!=1)
+ throw INTERP_KERNEL::Exception("DataArrayInt::isStrictlyMonotonic : only supported with 'this' array with ONE component !");
+ std::size_t nbOfElements(this->getNumberOfTuples());
+ const T *ptr(this->begin());
+ if(nbOfElements==0)
+ return true;
+ T ref(ptr[0]);
+ if(increasing)
+ {
+ for(std::size_t i=1;i<nbOfElements;i++)
+ {
+ if(ptr[i]>ref)
+ ref=ptr[i];
+ else
+ return false;
+ }
+ }
+ else
+ {
+ for(std::size_t i=1;i<nbOfElements;i++)
+ {
+ if(ptr[i]<ref)
+ ref=ptr[i];
+ else
+ return false;
+ }
+ }
+ return true;
+ }
+
+ /*!
+ * This method check that array consistently INCREASING or DECREASING in value.
+ */
+ template<class T>
+ void DataArrayDiscrete<T>::checkStrictlyMonotonic(bool increasing) const
+ {
+ if(!isStrictlyMonotonic(increasing))
+ {
+ if (increasing)
+ throw INTERP_KERNEL::Exception("DataArrayInt::checkStrictlyMonotonic : 'this' is not strictly INCREASING monotonic !");
+ else
+ throw INTERP_KERNEL::Exception("DataArrayInt::checkStrictlyMonotonic : 'this' is not strictly DECREASING monotonic !");
+ }
+ }
+
+ ////////////////////////////////////
+
/*!
* This method compares content of input vector \a v and \a this.
* If for each id in \a this v[id]==True and for all other ids id2 not in \a this v[id2]==False, true is returned.