-// Copyright (C) 2007-2015 CEA/DEN, EDF R&D
+// Copyright (C) 2007-2016 CEA/DEN, EDF R&D
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// Author : Anthony Geay (CEA/DEN)
#include "MEDCouplingMemArray.txx"
-#include "MCAuto.hxx"
#include "BBTree.txx"
#include "GenMathFormulae.hxx"
using namespace MEDCoupling;
+template class DataArrayTemplate<int>;
+template class DataArrayTemplate<double>;
+
template<int SPACEDIM>
void DataArrayDouble::findCommonTuplesAlg(const double *bbox, int nbNodes, int limitNodeId, double prec, DataArrayInt *c, DataArrayInt *cI) const
{
return new DataArrayDouble;
}
-/*!
- * Checks if raw data is allocated. Read more on the raw data
- * 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
-{
- 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
-{
- if(!isAllocated())
- throw INTERP_KERNEL::Exception("DataArrayDouble::checkAllocated : Array is defined but not allocated ! Call alloc or setValues method first !");
-}
-
-/*!
- * This method desallocated \a this without modification of informations 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.
- */
-void DataArrayDouble::desallocate()
-{
- _mem.destroy();
-}
-
-std::size_t DataArrayDouble::getHeapMemorySizeWithoutChildren() const
-{
- std::size_t sz(_mem.getNbOfElemAllocated());
- sz*=sizeof(double);
- return DataArray::getHeapMemorySizeWithoutChildren()+sz;
-}
-
/*!
* Returns the only one value in \a this, if and only if number of elements
* (nb of tuples * nb of components) is equal to 1, and that \a this is allocated.
throw INTERP_KERNEL::Exception("DataArrayDouble::doubleValue : DataArrayDouble instance is not allocated !");
}
-/*!
- * Checks the number of tuples.
- * \return bool - \a true if getNumberOfTuples() == 0, \a false else.
- * \throw If \a this is not allocated.
- */
-bool DataArrayDouble::empty() const
-{
- checkAllocated();
- return getNumberOfTuples()==0;
-}
-
/*!
* Returns a full copy of \a this. For more info on copying data arrays see
* \ref MEDCouplingArrayBasicsCopyDeep.
}
}
-/*!
- * Copies all the data from another DataArrayDouble. For more info see
- * \ref MEDCouplingArrayBasicsCopyDeepAssign.
- * \param [in] other - another instance of DataArrayDouble to copy data from.
- * \throw If the \a other is not allocated.
- */
-void DataArrayDouble::deepCopyFrom(const DataArrayDouble& other)
-{
- other.checkAllocated();
- int nbOfTuples=other.getNumberOfTuples();
- int nbOfComp=other.getNumberOfComponents();
- allocIfNecessary(nbOfTuples,nbOfComp);
- std::size_t nbOfElems=(std::size_t)nbOfTuples*nbOfComp;
- double *pt=getPointer();
- const double *ptI=other.getConstPointer();
- for(std::size_t i=0;i<nbOfElems;i++)
- pt[i]=ptI[i];
- copyStringInfoFrom(other);
-}
-
-/*!
- * 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.
- *
- * \sa DataArrayDouble::pack, DataArrayDouble::pushBackSilent, DataArrayDouble::pushBackValsSilent
- */
-void DataArrayDouble::reserve(std::size_t nbOfElems)
-{
- int nbCompo=getNumberOfComponents();
- if(nbCompo==1)
- {
- _mem.reserve(nbOfElems);
- }
- else if(nbCompo==0)
- {
- _mem.reserve(nbOfElems);
- _info_on_compo.resize(1);
- }
- else
- throw INTERP_KERNEL::Exception("DataArrayDouble::reserve : not available for DataArrayDouble with number of components different than 1 !");
-}
-
-/*!
- * This method adds at the end of \a this the single value \a val. 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] val the value to be added in \a this
- * \throw If \a this has already been allocated with number of components different from one.
- * \sa DataArrayDouble::pushBackValsSilent
- */
-void DataArrayDouble::pushBackSilent(double val)
-{
- int nbCompo=getNumberOfComponents();
- if(nbCompo==1)
- _mem.pushBack(val);
- else if(nbCompo==0)
- {
- _info_on_compo.resize(1);
- _mem.pushBack(val);
- }
- else
- throw INTERP_KERNEL::Exception("DataArrayDouble::pushBackSilent : not available for DataArrayDouble with number of components different than 1 !");
-}
-
-/*!
- * 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
- * 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.
- * \param [in] valsEnd - specifies the end of the array \a valsBg, so that
- * the last value of \a valsBg is \a valsEnd[ -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)
-{
- int nbCompo=getNumberOfComponents();
- if(nbCompo==1)
- _mem.insertAtTheEnd(valsBg,valsEnd);
- else if(nbCompo==0)
- {
- _info_on_compo.resize(1);
- _mem.insertAtTheEnd(valsBg,valsEnd);
- }
- else
- throw INTERP_KERNEL::Exception("DataArrayDouble::pushBackValsSilent : not available for DataArrayDouble with number of components different than 1 !");
-}
-
-/*!
- * This method returns silently ( without updating time label in \a this ) the last value, if any and suppress it.
- * \throw If \a this is already empty.
- * \throw If \a this has number of components different from one.
- */
-double DataArrayDouble::popBackSilent()
-{
- if(getNumberOfComponents()==1)
- return _mem.popBack();
- else
- throw INTERP_KERNEL::Exception("DataArrayDouble::popBackSilent : not available for DataArrayDouble with number of components different than 1 !");
-}
-
-/*!
- * 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::getHeapMemorySizeWithoutChildren, DataArrayDouble::reserve
- */
-void DataArrayDouble::pack() const
-{
- _mem.pack();
-}
-
-/*!
- * Allocates the raw data in memory. If exactly same memory as needed already
- * allocated, it is not re-allocated.
- * \param [in] nbOfTuple - number of tuples of data to allocate.
- * \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)
-{
- if(isAllocated())
- {
- if(nbOfTuple!=getNumberOfTuples() || nbOfCompo!=getNumberOfComponents())
- alloc(nbOfTuple,nbOfCompo);
- }
- else
- alloc(nbOfTuple,nbOfCompo);
-}
-
-/*!
- * Allocates the raw data in memory. If the memory was already allocated, then it is
- * freed and re-allocated. See an example of this method use
- * \ref MEDCouplingArraySteps1WC "here".
- * \param [in] nbOfTuple - number of tuples of data to allocate.
- * \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)
-{
- if(nbOfTuple<0 || nbOfCompo<0)
- throw INTERP_KERNEL::Exception("DataArrayDouble::alloc : request for negative length of data !");
- _info_on_compo.resize(nbOfCompo);
- _mem.alloc(nbOfCompo*(std::size_t)nbOfTuple);
- declareAsNew();
-}
-
/*!
* Assign zero to all values in \a this array. To know more on filling arrays see
* \ref MEDCouplingArrayFill.
*/
void DataArrayDouble::fillWithZero()
{
- checkAllocated();
- _mem.fillWithValue(0.);
- declareAsNew();
-}
-
-/*!
- * Assign \a val to all values in \a this array. To know more on filling arrays see
- * \ref MEDCouplingArrayFill.
- * \param [in] val - the value to fill with.
- * \throw If \a this is not allocated.
- */
-void DataArrayDouble::fillWithValue(double val)
-{
- checkAllocated();
- _mem.fillWithValue(val);
- declareAsNew();
+ fillWithValue(0.);
}
/*!
return true;
}
-/*!
- * Sorts values of the array.
- * \param [in] asc - \a true means ascending order, \a false, descending.
- * \throw If \a this is not allocated.
- * \throw If \a this->getNumberOfComponents() != 1.
- */
-void DataArrayDouble::sort(bool asc)
-{
- checkAllocated();
- if(getNumberOfComponents()!=1)
- throw INTERP_KERNEL::Exception("DataArrayDouble::sort : only supported with 'this' array with ONE component !");
- _mem.sort(asc);
- declareAsNew();
-}
-
-/*!
- * Reverse the array values.
- * \throw If \a this->getNumberOfComponents() < 1.
- * \throw If \a this is not allocated.
- */
-void DataArrayDouble::reverse()
-{
- checkAllocated();
- _mem.reverse(getNumberOfComponents());
- declareAsNew();
-}
-
/*!
* Checks that \a this array is consistently **increasing** or **decreasing** in value,
* with at least absolute difference value of |\a eps| at each step.
return _mem.isEqual(other._mem,prec,tmp);
}
-/*!
- * Changes number of tuples in the array. If the new number of tuples is smaller
- * than the current number the array is truncated, otherwise the array is extended.
- * \param [in] nbOfTuples - new number of tuples.
- * \throw If \a this is not allocated.
- * \throw If \a nbOfTuples is negative.
- */
-void DataArrayDouble::reAlloc(int nbOfTuples)
-{
- if(nbOfTuples<0)
- throw INTERP_KERNEL::Exception("DataArrayDouble::reAlloc : input new number of tuples should be >=0 !");
- checkAllocated();
- _mem.reAlloc(getNumberOfComponents()*(std::size_t)nbOfTuples);
- declareAsNew();
-}
-
/*!
* Creates a new DataArrayInt and assigns all (textual and numerical) data of \a this
* array to the new one.
}
/*!
- * Permutes values of \a this array as required by \a old2New array. The values are
- * permuted so that \c new[ \a old2New[ i ]] = \c old[ i ]. Number of tuples remains
- * the same as in \c this one.
- * If a permutation reduction is needed, substr() or selectByTupleId() should be used.
- * For more info on renumbering see \ref numbering.
- * \param [in] old2New - C array of length equal to \a this->getNumberOfTuples()
- * giving a new position for i-th old value.
+ * Appends components of another array to components of \a this one, tuple by tuple.
+ * So that the number of tuples of \a this array remains the same and the number of
+ * components increases.
+ * \param [in] other - the DataArrayDouble to append to \a this one.
+ * \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::renumberInPlace(const int *old2New)
+void DataArrayDouble::meldWith(const DataArrayDouble *other)
{
checkAllocated();
- int nbTuples=getNumberOfTuples();
- int nbOfCompo=getNumberOfComponents();
- double *tmp=new double[nbTuples*nbOfCompo];
- const double *iptr=getConstPointer();
- for(int i=0;i<nbTuples;i++)
+ other->checkAllocated();
+ int nbOfTuples=getNumberOfTuples();
+ if(nbOfTuples!=other->getNumberOfTuples())
+ throw INTERP_KERNEL::Exception("DataArrayDouble::meldWith : mismatch of number of tuples !");
+ int nbOfComp1=getNumberOfComponents();
+ int nbOfComp2=other->getNumberOfComponents();
+ double *newArr=(double *)malloc((nbOfTuples*(nbOfComp1+nbOfComp2))*sizeof(double));
+ double *w=newArr;
+ const double *inp1=getConstPointer();
+ const double *inp2=other->getConstPointer();
+ for(int i=0;i<nbOfTuples;i++,inp1+=nbOfComp1,inp2+=nbOfComp2)
{
- int v=old2New[i];
- if(v>=0 && v<nbTuples)
- std::copy(iptr+nbOfCompo*i,iptr+nbOfCompo*(i+1),tmp+nbOfCompo*v);
- else
- {
- std::ostringstream oss; oss << "DataArrayDouble::renumberInPlace : At place #" << i << " value is " << v << " ! Should be in [0," << nbTuples << ") !";
- throw INTERP_KERNEL::Exception(oss.str().c_str());
- }
+ w=std::copy(inp1,inp1+nbOfComp1,w);
+ w=std::copy(inp2,inp2+nbOfComp2,w);
}
- std::copy(tmp,tmp+nbTuples*nbOfCompo,getPointer());
- delete [] tmp;
- declareAsNew();
+ useArray(newArr,true,C_DEALLOC,nbOfTuples,nbOfComp1+nbOfComp2);
+ std::vector<int> compIds(nbOfComp2);
+ for(int i=0;i<nbOfComp2;i++)
+ compIds[i]=nbOfComp1+i;
+ copyPartOfStringInfoFrom2(compIds,*other);
}
/*!
- * Permutes values of \a this array as required by \a new2Old array. The values are
- * permuted so that \c new[ i ] = \c old[ \a new2Old[ i ]]. Number of tuples remains
- * the same as in \c this one.
- * For more info on renumbering see \ref numbering.
- * \param [in] new2Old - C array of length equal to \a this->getNumberOfTuples()
- * giving a previous position of i-th new value.
- * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
- * is to delete using decrRef() as it is no more needed.
+ * This method checks that all tuples in \a other are in \a this.
+ * If true, the output param \a tupleIds contains the tuples ids of \a this that correspond to tupes in \a this.
+ * For each i in [ 0 , other->getNumberOfTuples() ) tuple #i in \a other is equal ( regarding input precision \a prec ) to tuple tupleIds[i] in \a this.
+ *
+ * \param [in] other - the array having the same number of components than \a this.
+ * \param [out] tupleIds - the tuple ids containing the same number of tuples than \a other has.
+ * \sa DataArrayDouble::findCommonTuples
*/
-void DataArrayDouble::renumberInPlaceR(const int *new2Old)
+bool DataArrayDouble::areIncludedInMe(const DataArrayDouble *other, double prec, DataArrayInt *&tupleIds) const
{
- checkAllocated();
- int nbTuples=getNumberOfTuples();
- int nbOfCompo=getNumberOfComponents();
- double *tmp=new double[nbTuples*nbOfCompo];
- const double *iptr=getConstPointer();
- for(int i=0;i<nbTuples;i++)
- {
- int v=new2Old[i];
- if(v>=0 && v<nbTuples)
- std::copy(iptr+nbOfCompo*v,iptr+nbOfCompo*(v+1),tmp+nbOfCompo*i);
- else
- {
- std::ostringstream oss; oss << "DataArrayDouble::renumberInPlaceR : At place #" << i << " value is " << v << " ! Should be in [0," << nbTuples << ") !";
- throw INTERP_KERNEL::Exception(oss.str().c_str());
- }
- }
- std::copy(tmp,tmp+nbTuples*nbOfCompo,getPointer());
- delete [] tmp;
- declareAsNew();
+ if(!other)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::areIncludedInMe : input array is NULL !");
+ checkAllocated(); other->checkAllocated();
+ if(getNumberOfComponents()!=other->getNumberOfComponents())
+ throw INTERP_KERNEL::Exception("DataArrayDouble::areIncludedInMe : the number of components does not match !");
+ MCAuto<DataArrayDouble> a=DataArrayDouble::Aggregate(this,other);
+ DataArrayInt *c=0,*ci=0;
+ a->findCommonTuples(prec,getNumberOfTuples(),c,ci);
+ MCAuto<DataArrayInt> cSafe(c),ciSafe(ci);
+ int newNbOfTuples=-1;
+ MCAuto<DataArrayInt> ids=DataArrayInt::ConvertIndexArrayToO2N(a->getNumberOfTuples(),c->begin(),ci->begin(),ci->end(),newNbOfTuples);
+ MCAuto<DataArrayInt> ret1=ids->selectByTupleIdSafeSlice(getNumberOfTuples(),a->getNumberOfTuples(),1);
+ tupleIds=ret1.retn();
+ return newNbOfTuples==getNumberOfTuples();
}
/*!
- * Returns a copy of \a this array with values permuted as required by \a old2New array.
- * The values are permuted so that \c new[ \a old2New[ i ]] = \c old[ i ].
- * Number of tuples in the result array remains the same as in \c this one.
- * If a permutation reduction is needed, renumberAndReduce() should be used.
- * For more info on renumbering see \ref numbering.
- * \param [in] old2New - C array of length equal to \a this->getNumberOfTuples()
- * giving a new position for i-th old value.
- * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
- * is to delete using decrRef() as it is no more needed.
+ * Searches for tuples coincident within \a prec tolerance. Each tuple is considered
+ * as coordinates of a point in getNumberOfComponents()-dimensional space. The
+ * distance separating two points is computed with the infinite norm.
+ *
+ * Indices of coincident tuples are stored in output arrays.
+ * A pair of arrays (\a comm, \a commIndex) is called "Surjective Format 2".
+ *
+ * This method is typically used by MEDCouplingPointSet::findCommonNodes() and
+ * MEDCouplingUMesh::mergeNodes().
+ * \param [in] prec - minimal absolute distance between two tuples (infinite norm) at which they are
+ * considered not coincident.
+ * \param [in] limitTupleId - limit tuple id. If all tuples within a group of coincident
+ * tuples have id strictly lower than \a limitTupleId then they are not returned.
+ * \param [out] comm - the array holding ids (== indices) of coincident tuples.
+ * \a comm->getNumberOfComponents() == 1.
+ * \a comm->getNumberOfTuples() == \a commIndex->back().
+ * \param [out] commIndex - the array dividing all indices stored in \a comm into
+ * groups of (indices of) coincident tuples. Its every value is a tuple
+ * index where a next group of tuples begins. For example the second
+ * group of tuples in \a comm is described by following range of indices:
+ * [ \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,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::ConvertIndexArrayToO2N(), DataArrayDouble::areIncludedInMe
*/
-DataArrayDouble *DataArrayDouble::renumber(const int *old2New) const
+void DataArrayDouble::findCommonTuples(double prec, int limitTupleId, DataArrayInt *&comm, DataArrayInt *&commIndex) const
{
checkAllocated();
- int nbTuples=getNumberOfTuples();
int nbOfCompo=getNumberOfComponents();
- MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
- ret->alloc(nbTuples,nbOfCompo);
- ret->copyStringInfoFrom(*this);
- const double *iptr=getConstPointer();
- double *optr=ret->getPointer();
- for(int i=0;i<nbTuples;i++)
- std::copy(iptr+nbOfCompo*i,iptr+nbOfCompo*(i+1),optr+nbOfCompo*old2New[i]);
- ret->copyStringInfoFrom(*this);
- return ret.retn();
-}
+ 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.");
-/*!
- * Returns a copy of \a this array with values permuted as required by \a new2Old array.
- * The values are permuted so that \c new[ i ] = \c old[ \a new2Old[ i ]]. Number of
- * tuples in the result array remains the same as in \c this one.
- * If a permutation reduction is needed, substr() or selectByTupleId() should be used.
- * For more info on renumbering see \ref numbering.
- * \param [in] new2Old - C array of length equal to \a this->getNumberOfTuples()
- * giving a previous position of i-th new value.
- * \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
-{
- checkAllocated();
- int nbTuples=getNumberOfTuples();
- int nbOfCompo=getNumberOfComponents();
- MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
- ret->alloc(nbTuples,nbOfCompo);
- ret->copyStringInfoFrom(*this);
- const double *iptr=getConstPointer();
- double *optr=ret->getPointer();
- for(int i=0;i<nbTuples;i++)
- std::copy(iptr+nbOfCompo*new2Old[i],iptr+nbOfCompo*(new2Old[i]+1),optr+i*nbOfCompo);
- ret->copyStringInfoFrom(*this);
- return ret.retn();
+ int nbOfTuples=getNumberOfTuples();
+ //
+ MCAuto<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;
+ case 2:
+ findCommonTuplesAlg<2>(begin(),nbOfTuples,limitTupleId,prec,c,cI);
+ break;
+ case 1:
+ findCommonTuplesAlg<1>(begin(),nbOfTuples,limitTupleId,prec,c,cI);
+ break;
+ default:
+ 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();
}
/*!
- * Returns a shorten and permuted copy of \a this array. The new DataArrayDouble is
- * of size \a newNbOfTuple and it's values are permuted as required by \a old2New array.
- * The values are permuted so that \c new[ \a old2New[ i ]] = \c old[ i ] for all
- * \a old2New[ i ] >= 0. In other words every i-th tuple in \a this array, for which
- * \a old2New[ i ] is negative, is missing from the result array.
- * For more info on renumbering see \ref numbering.
- * \param [in] old2New - C array of length equal to \a this->getNumberOfTuples()
- * giving a new position for i-th old tuple and giving negative position for
- * for i-th old tuple that should be omitted.
- * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
- * is to delete using decrRef() as it is no more needed.
+ *
+ * \param [in] nbTimes specifies the nb of times each tuples in \a this will be duplicated contiguouly in returned DataArrayDouble instance.
+ * \a nbTimes should be at least equal to 1.
+ * \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::renumberAndReduce(const int *old2New, int newNbOfTuple) const
+DataArrayDouble *DataArrayDouble::duplicateEachTupleNTimes(int nbTimes) const
{
checkAllocated();
+ if(getNumberOfComponents()!=1)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::duplicateEachTupleNTimes : this should have only one component !");
+ if(nbTimes<1)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::duplicateEachTupleNTimes : nb times should be >= 1 !");
int nbTuples=getNumberOfTuples();
- int nbOfCompo=getNumberOfComponents();
- MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
- ret->alloc(newNbOfTuple,nbOfCompo);
- const double *iptr=getConstPointer();
- double *optr=ret->getPointer();
- for(int i=0;i<nbTuples;i++)
+ const double *inPtr=getConstPointer();
+ MCAuto<DataArrayDouble> ret=DataArrayDouble::New(); ret->alloc(nbTimes*nbTuples,1);
+ double *retPtr=ret->getPointer();
+ for(int i=0;i<nbTuples;i++,inPtr++)
{
- int w=old2New[i];
- if(w>=0)
- std::copy(iptr+i*nbOfCompo,iptr+(i+1)*nbOfCompo,optr+w*nbOfCompo);
+ double val=*inPtr;
+ for(int j=0;j<nbTimes;j++,retPtr++)
+ *retPtr=val;
}
ret->copyStringInfoFrom(*this);
return ret.retn();
}
/*!
- * Returns a shorten and permuted copy of \a this array. The new DataArrayDouble is
- * of size \a new2OldEnd - \a new2OldBg and it's values are permuted as required by
- * \a new2OldBg array.
- * The values are permuted so that \c new[ i ] = \c old[ \a new2OldBg[ i ]].
- * This method is equivalent to renumberAndReduce() except that convention in input is
- * \c new2old and \b not \c old2new.
- * For more info on renumbering see \ref numbering.
- * \param [in] new2OldBg - pointer to the beginning of a permutation array that gives a
- * tuple index in \a this array to fill the i-th tuple in the new array.
- * \param [in] new2OldEnd - specifies the end of the permutation array that starts at
- * \a new2OldBg, so that pointer to a tuple index (\a pi) varies as this:
- * \a new2OldBg <= \a pi < \a new2OldEnd.
- * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
- * is to delete using decrRef() as it is no more needed.
- */
-DataArrayDouble *DataArrayDouble::selectByTupleId(const int *new2OldBg, const int *new2OldEnd) const
-{
- checkAllocated();
- MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
- int nbComp=getNumberOfComponents();
- ret->alloc((int)std::distance(new2OldBg,new2OldEnd),nbComp);
- ret->copyStringInfoFrom(*this);
- double *pt=ret->getPointer();
- const double *srcPt=getConstPointer();
- int i=0;
- for(const int *w=new2OldBg;w!=new2OldEnd;w++,i++)
- std::copy(srcPt+(*w)*nbComp,srcPt+((*w)+1)*nbComp,pt+i*nbComp);
- ret->copyStringInfoFrom(*this);
- return ret.retn();
-}
-
-DataArrayDouble *DataArrayDouble::selectByTupleId(const DataArrayInt & di) const
-{
- return selectByTupleId(di.getConstPointer(), di.getConstPointer()+di.getNumberOfTuples());
-}
-
-/*!
- * Returns a shorten and permuted copy of \a this array. The new DataArrayDouble is
- * of size \a new2OldEnd - \a new2OldBg and it's values are permuted as required by
- * \a new2OldBg array.
- * The values are permuted so that \c new[ i ] = \c old[ \a new2OldBg[ i ]].
- * This method is equivalent to renumberAndReduce() except that convention in input is
- * \c new2old and \b not \c old2new.
- * This method is equivalent to selectByTupleId() except that it prevents coping data
- * from behind the end of \a this array.
- * For more info on renumbering see \ref numbering.
- * \param [in] new2OldBg - pointer to the beginning of a permutation array that gives a
- * tuple index in \a this array to fill the i-th tuple in the new array.
- * \param [in] new2OldEnd - specifies the end of the permutation array that starts at
- * \a new2OldBg, so that pointer to a tuple index (\a pi) varies as this:
- * \a new2OldBg <= \a pi < \a new2OldEnd.
- * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
- * is to delete using decrRef() as it is no more needed.
- * \throw If \a new2OldEnd - \a new2OldBg > \a this->getNumberOfTuples().
+ * This methods returns the minimal distance between the two set of points \a this and \a other.
+ * So \a this and \a other have to have the same number of components. If not an INTERP_KERNEL::Exception will be thrown.
+ * This method works only if number of components of \a this (equal to those of \a other) is in 1, 2 or 3.
+ *
+ * \param [out] thisTupleId the tuple id in \a this corresponding to the returned minimal distance
+ * \param [out] otherTupleId the tuple id in \a other corresponding to the returned minimal distance
+ * \return the minimal distance between the two set of points \a this and \a other.
+ * \sa DataArrayDouble::findClosestTupleId
*/
-DataArrayDouble *DataArrayDouble::selectByTupleIdSafe(const int *new2OldBg, const int *new2OldEnd) const
+double DataArrayDouble::minimalDistanceTo(const DataArrayDouble *other, int& thisTupleId, int& otherTupleId) const
{
- checkAllocated();
- MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
- int nbComp=getNumberOfComponents();
- int oldNbOfTuples=getNumberOfTuples();
- ret->alloc((int)std::distance(new2OldBg,new2OldEnd),nbComp);
- ret->copyStringInfoFrom(*this);
- double *pt=ret->getPointer();
- const double *srcPt=getConstPointer();
- int i=0;
- for(const int *w=new2OldBg;w!=new2OldEnd;w++,i++)
- if(*w>=0 && *w<oldNbOfTuples)
- std::copy(srcPt+(*w)*nbComp,srcPt+((*w)+1)*nbComp,pt+i*nbComp);
- else
- throw INTERP_KERNEL::Exception("DataArrayDouble::selectByTupleIdSafe : some ids has been detected to be out of [0,this->getNumberOfTuples) !");
- ret->copyStringInfoFrom(*this);
- return ret.retn();
+ MCAuto<DataArrayInt> part1=findClosestTupleId(other);
+ int nbOfCompo(getNumberOfComponents());
+ int otherNbTuples(other->getNumberOfTuples());
+ const double *thisPt(begin()),*otherPt(other->begin());
+ const int *part1Pt(part1->begin());
+ double ret=std::numeric_limits<double>::max();
+ for(int i=0;i<otherNbTuples;i++,part1Pt++,otherPt+=nbOfCompo)
+ {
+ double tmp(0.);
+ for(int j=0;j<nbOfCompo;j++)
+ tmp+=(otherPt[j]-thisPt[nbOfCompo*(*part1Pt)+j])*(otherPt[j]-thisPt[nbOfCompo*(*part1Pt)+j]);
+ if(tmp<ret)
+ { ret=tmp; thisTupleId=*part1Pt; otherTupleId=i; }
+ }
+ return sqrt(ret);
}
/*!
- * Returns a shorten copy of \a this array. The new DataArrayDouble contains every
- * (\a bg + \c i * \a step)-th tuple of \a this array located before the \a end2-th
- * tuple. Indices of the selected tuples are the same as ones returned by the Python
- * command \c range( \a bg, \a end2, \a step ).
- * This method is equivalent to selectByTupleIdSafe() except that the input array is
- * not constructed explicitly.
- * For more info on renumbering see \ref numbering.
- * \param [in] bg - index of the first tuple to copy from \a this array.
- * \param [in] end2 - index of the tuple before which the tuples to copy are located.
- * \param [in] step - index increment to get index of the next tuple to copy.
- * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
- * is to delete using decrRef() as it is no more needed.
- * \sa DataArrayDouble::substr.
+ * This methods returns for each tuple in \a other which tuple in \a this is the closest.
+ * So \a this and \a other have to have the same number of components. If not an INTERP_KERNEL::Exception will be thrown.
+ * This method works only if number of components of \a this (equal to those of \a other) is in 1, 2 or 3.
+ *
+ * \return a newly allocated (new object to be dealt by the caller) DataArrayInt having \c other->getNumberOfTuples() tuples and one components.
+ * \sa DataArrayDouble::minimalDistanceTo
*/
-DataArrayDouble *DataArrayDouble::selectByTupleIdSafeSlice(int bg, int end2, int step) const
+DataArrayInt *DataArrayDouble::findClosestTupleId(const DataArrayDouble *other) const
{
- checkAllocated();
- MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
- int nbComp=getNumberOfComponents();
- int newNbOfTuples=GetNumberOfItemGivenBESRelative(bg,end2,step,"DataArrayDouble::selectByTupleIdSafeSlice : ");
- ret->alloc(newNbOfTuples,nbComp);
- double *pt=ret->getPointer();
- const double *srcPt=getConstPointer()+bg*nbComp;
- for(int i=0;i<newNbOfTuples;i++,srcPt+=step*nbComp)
- std::copy(srcPt,srcPt+nbComp,pt+i*nbComp);
- ret->copyStringInfoFrom(*this);
+ if(!other)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::findClosestTupleId : other instance is NULL !");
+ checkAllocated(); other->checkAllocated();
+ int nbOfCompo=getNumberOfComponents();
+ if(nbOfCompo!=other->getNumberOfComponents())
+ {
+ std::ostringstream oss; oss << "DataArrayDouble::findClosestTupleId : number of components in this is " << nbOfCompo;
+ oss << ", whereas number of components in other is " << other->getNumberOfComponents() << "! Should be equal !";
+ throw INTERP_KERNEL::Exception(oss.str().c_str());
+ }
+ int nbOfTuples=other->getNumberOfTuples();
+ int thisNbOfTuples=getNumberOfTuples();
+ MCAuto<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(nbOfTuples,1);
+ 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]));
+ double delta=std::max(xDelta,yDelta); delta=std::max(delta,zDelta);
+ double characSize=pow((delta*delta*delta)/((double)thisNbOfTuples),1./3.);
+ BBTreePts<3,int> myTree(begin(),0,0,getNumberOfTuples(),characSize*1e-12);
+ FindClosestTupleIdAlg<3>(myTree,3.*characSize*characSize,other->begin(),nbOfTuples,begin(),thisNbOfTuples,ret->getPointer());
+ break;
+ }
+ case 2:
+ {
+ double xDelta(fabs(bounds[1]-bounds[0])),yDelta(fabs(bounds[3]-bounds[2]));
+ double delta=std::max(xDelta,yDelta);
+ double characSize=sqrt(delta/(double)thisNbOfTuples);
+ BBTreePts<2,int> myTree(begin(),0,0,getNumberOfTuples(),characSize*1e-12);
+ FindClosestTupleIdAlg<2>(myTree,2.*characSize*characSize,other->begin(),nbOfTuples,begin(),thisNbOfTuples,ret->getPointer());
+ break;
+ }
+ case 1:
+ {
+ double characSize=fabs(bounds[1]-bounds[0])/thisNbOfTuples;
+ BBTreePts<1,int> myTree(begin(),0,0,getNumberOfTuples(),characSize*1e-12);
+ FindClosestTupleIdAlg<1>(myTree,1.*characSize*characSize,other->begin(),nbOfTuples,begin(),thisNbOfTuples,ret->getPointer());
+ break;
+ }
+ default:
+ throw INTERP_KERNEL::Exception("Unexpected spacedim of coords for findClosestTupleId. Must be 1, 2 or 3.");
+ }
return ret.retn();
}
/*!
- * Returns a shorten copy of \a this array. The new DataArrayDouble contains ranges
- * of tuples specified by \a ranges parameter.
- * For more info on renumbering see \ref numbering.
- * \param [in] ranges - std::vector of std::pair's each of which defines a range
- * of tuples in [\c begin,\c end) format.
- * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
- * is to delete using decrRef() as it is no more needed.
- * \throw If \a end < \a begin.
- * \throw If \a end > \a this->getNumberOfTuples().
- * \throw If \a this is not allocated.
+ * 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).
*/
-DataArray *DataArrayDouble::selectByTupleRanges(const std::vector<std::pair<int,int> >& ranges) const
+DataArrayInt *DataArrayDouble::computeNbOfInteractionsWith(const DataArrayDouble *otherBBoxFrmt, double eps) const
{
- checkAllocated();
- int nbOfComp=getNumberOfComponents();
- int nbOfTuplesThis=getNumberOfTuples();
- if(ranges.empty())
+ 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())
{
- DataArrayDouble *ret=DataArrayDouble::New();
- ret->alloc(0,nbOfComp);
- ret->copyStringInfoFrom(*this);
- return ret;
+ 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());
}
- int ref=ranges.front().first;
- int nbOfTuples=0;
- bool isIncreasing=true;
- for(std::vector<std::pair<int,int> >::const_iterator it=ranges.begin();it!=ranges.end();it++)
+ if(nbOfComp%2!=0)
{
- if((*it).first<=(*it).second)
- {
- if((*it).first>=0 && (*it).second<=nbOfTuplesThis)
- {
- nbOfTuples+=(*it).second-(*it).first;
- if(isIncreasing)
- isIncreasing=ref<=(*it).first;
- ref=(*it).second;
- }
- else
- {
- std::ostringstream oss; oss << "DataArrayDouble::selectByTupleRanges : on range #" << std::distance(ranges.begin(),it);
- oss << " (" << (*it).first << "," << (*it).second << ") is greater than number of tuples of this :" << nbOfTuples << " !";
- throw INTERP_KERNEL::Exception(oss.str().c_str());
- }
- }
- else
- {
- std::ostringstream oss; oss << "DataArrayDouble::selectByTupleRanges : on range #" << std::distance(ranges.begin(),it);
- oss << " (" << (*it).first << "," << (*it).second << ") end is before begin !";
- throw INTERP_KERNEL::Exception(oss.str().c_str());
- }
+ 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());
}
- if(isIncreasing && nbOfTuplesThis==nbOfTuples)
- return deepCopy();
- MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
- ret->alloc(nbOfTuples,nbOfComp);
- ret->copyStringInfoFrom(*this);
- const double *src=getConstPointer();
- double *work=ret->getPointer();
- for(std::vector<std::pair<int,int> >::const_iterator it=ranges.begin();it!=ranges.end();it++)
- work=std::copy(src+(*it).first*nbOfComp,src+(*it).second*nbOfComp,work);
+ MCAuto<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();
}
/*!
- * Returns a shorten copy of \a this array. The new DataArrayDouble contains all
- * tuples starting from the \a tupleIdBg-th tuple and including all tuples located before
- * the \a tupleIdEnd-th one. This methods has a similar behavior as std::string::substr().
- * This method is a specialization of selectByTupleIdSafeSlice().
- * \param [in] tupleIdBg - index of the first tuple to copy from \a this array.
- * \param [in] tupleIdEnd - index of the tuple before which the tuples to copy are located.
- * If \a tupleIdEnd == -1, all the tuples till the end of \a this array are copied.
+ * Returns a copy of \a this array by excluding coincident tuples. Each tuple is
+ * considered as coordinates of a point in getNumberOfComponents()-dimensional
+ * space. The distance between tuples is computed using norm2. If several tuples are
+ * not far each from other than \a prec, only one of them remains in the result
+ * array. The order of tuples in the result array is same as in \a this one except
+ * that coincident tuples are excluded.
+ * \param [in] prec - minimal absolute distance between two tuples at which they are
+ * considered not coincident.
+ * \param [in] limitTupleId - limit tuple id. If all tuples within a group of coincident
+ * tuples have id strictly lower than \a limitTupleId then they are not excluded.
* \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
* is to delete using decrRef() as it is no more needed.
- * \throw If \a tupleIdBg < 0.
- * \throw If \a tupleIdBg > \a this->getNumberOfTuples().
- \throw If \a tupleIdEnd != -1 && \a tupleIdEnd < \a this->getNumberOfTuples().
- * \sa DataArrayDouble::selectByTupleIdSafeSlice
+ * \throw If \a this is not allocated.
+ * \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::substr(int tupleIdBg, int tupleIdEnd) const
+DataArrayDouble *DataArrayDouble::getDifferentValues(double prec, int limitTupleId) const
{
checkAllocated();
- int nbt=getNumberOfTuples();
- if(tupleIdBg<0)
- throw INTERP_KERNEL::Exception("DataArrayDouble::substr : The tupleIdBg parameter must be greater than 0 !");
- if(tupleIdBg>nbt)
- throw INTERP_KERNEL::Exception("DataArrayDouble::substr : The tupleIdBg parameter is greater than number of tuples !");
- int trueEnd=tupleIdEnd;
- if(tupleIdEnd!=-1)
- {
- if(tupleIdEnd>nbt)
- throw INTERP_KERNEL::Exception("DataArrayDouble::substr : The tupleIdBg parameter is greater or equal than number of tuples !");
- }
- else
- trueEnd=nbt;
- int nbComp=getNumberOfComponents();
- MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
- ret->alloc(trueEnd-tupleIdBg,nbComp);
- ret->copyStringInfoFrom(*this);
- std::copy(getConstPointer()+tupleIdBg*nbComp,getConstPointer()+trueEnd*nbComp,ret->getPointer());
- return ret.retn();
+ DataArrayInt *c0=0,*cI0=0;
+ findCommonTuples(prec,limitTupleId,c0,cI0);
+ MCAuto<DataArrayInt> c(c0),cI(cI0);
+ int newNbOfTuples=-1;
+ MCAuto<DataArrayInt> o2n=DataArrayInt::ConvertIndexArrayToO2N(getNumberOfTuples(),c0->begin(),cI0->begin(),cI0->end(),newNbOfTuples);
+ return renumberAndReduce(o2n->getConstPointer(),newNbOfTuples);
}
/*!
- * Returns a shorten or extended copy of \a this array. If \a newNbOfComp is less
- * than \a this->getNumberOfComponents() then the result array is shorten as each tuple
- * is truncated to have \a newNbOfComp components, keeping first components. If \a
- * newNbOfComp is more than \a this->getNumberOfComponents() then the result array is
- * expanded as each tuple is populated with \a dftValue to have \a newNbOfComp
- * components.
- * \param [in] newNbOfComp - number of components for the new array to have.
- * \param [in] dftValue - value assigned to new values added to the new array.
- * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
- * is to delete using decrRef() as it is no more needed.
- * \throw If \a this is not allocated.
+ * Copy all components in a specified order from another DataArrayDouble.
+ * Both numerical and textual data is copied. The number of tuples in \a this and
+ * the other array can be different.
+ * \param [in] a - the array to copy data from.
+ * \param [in] compoIds - sequence of zero based indices of components, data of which is
+ * to be copied.
+ * \throw If \a a 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_mcdataarraydouble_setselectedcomponents "Here is a Python example".
+ * \endif
*/
-DataArrayDouble *DataArrayDouble::changeNbOfComponents(int newNbOfComp, double dftValue) const
+void DataArrayDouble::setSelectedComponents(const DataArrayDouble *a, const std::vector<int>& compoIds)
{
+ if(!a)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::setSelectedComponents : input DataArrayDouble is NULL !");
checkAllocated();
- MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
- ret->alloc(getNumberOfTuples(),newNbOfComp);
- const double *oldc=getConstPointer();
- double *nc=ret->getPointer();
- int nbOfTuples=getNumberOfTuples();
- int oldNbOfComp=getNumberOfComponents();
- int dim=std::min(oldNbOfComp,newNbOfComp);
+ copyPartOfStringInfoFrom2(compoIds,*a);
+ std::size_t partOfCompoSz=compoIds.size();
+ int nbOfCompo=getNumberOfComponents();
+ int nbOfTuples=std::min(getNumberOfTuples(),a->getNumberOfTuples());
+ const double *ac=a->getConstPointer();
+ double *nc=getPointer();
for(int i=0;i<nbOfTuples;i++)
+ for(std::size_t j=0;j<partOfCompoSz;j++,ac++)
+ nc[nbOfCompo*i+compoIds[j]]=*ac;
+}
+
+void DataArrayDouble::SetArrayIn(DataArrayDouble *newArray, DataArrayDouble* &arrayToSet)
+{
+ if(newArray!=arrayToSet)
{
- int j=0;
- for(;j<dim;j++)
- nc[newNbOfComp*i+j]=oldc[i*oldNbOfComp+j];
- for(;j<newNbOfComp;j++)
- nc[newNbOfComp*i+j]=dftValue;
+ if(arrayToSet)
+ arrayToSet->decrRef();
+ arrayToSet=newArray;
+ if(arrayToSet)
+ arrayToSet->incrRef();
}
- ret->setName(getName());
- for(int i=0;i<dim;i++)
- ret->setInfoOnComponent(i,getInfoOnComponent(i));
- ret->setName(getName());
- return ret.retn();
}
-/*!
- * Changes the number of components within \a this array so that its raw data **does
- * not** change, instead splitting this data into tuples changes.
- * \warning This method erases all (name and unit) component info set before!
- * \param [in] newNbOfComp - number of components for \a this array to have.
- * \throw If \a this is not allocated
- * \throw If getNbOfElems() % \a newNbOfCompo != 0.
- * \throw If \a newNbOfCompo is lower than 1.
- * \throw If the rearrange method would lead to a number of tuples higher than 2147483647 (maximal capacity of int32 !).
- * \warning This method erases all (name and unit) component info set before!
- */
-void DataArrayDouble::rearrange(int newNbOfCompo)
+void DataArrayDouble::aggregate(const DataArrayDouble *other)
{
- checkAllocated();
- if(newNbOfCompo<1)
- throw INTERP_KERNEL::Exception("DataArrayDouble::rearrange : input newNbOfCompo must be > 0 !");
- std::size_t nbOfElems=getNbOfElems();
- if(nbOfElems%newNbOfCompo!=0)
- throw INTERP_KERNEL::Exception("DataArrayDouble::rearrange : nbOfElems%newNbOfCompo!=0 !");
- if(nbOfElems/newNbOfCompo>(std::size_t)std::numeric_limits<int>::max())
- throw INTERP_KERNEL::Exception("DataArrayDouble::rearrange : the rearrangement leads to too high number of tuples (> 2147483647) !");
- _info_on_compo.clear();
- _info_on_compo.resize(newNbOfCompo);
- declareAsNew();
+ if(!other)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::aggregate : null pointer !");
+ if(getNumberOfComponents()!=other->getNumberOfComponents())
+ throw INTERP_KERNEL::Exception("DataArrayDouble::aggregate : mismatch number of components !");
+ _mem.insertAtTheEnd(other->begin(),other->end());
}
/*!
- * Changes the number of components within \a this array to be equal to its number
- * of tuples, and inversely its number of tuples to become equal to its number of
- * components. So that its raw data **does not** change, instead splitting this
- * data into tuples changes.
- * \warning This method erases all (name and unit) component info set before!
- * \warning Do not confuse this method with fromNoInterlace() and toNoInterlace()!
- * \throw If \a this is not allocated.
- * \sa rearrange()
+ * Checks if 0.0 value is present in \a this array. If it is the case, an exception
+ * is thrown.
+ * \throw If zero is found in \a this array.
*/
-void DataArrayDouble::transpose()
+void DataArrayDouble::checkNoNullValues() const
{
- checkAllocated();
- int nbOfTuples=getNumberOfTuples();
- rearrange(nbOfTuples);
+ const double *tmp=getConstPointer();
+ std::size_t nbOfElems=getNbOfElems();
+ const double *where=std::find(tmp,tmp+nbOfElems,0.);
+ if(where!=tmp+nbOfElems)
+ throw INTERP_KERNEL::Exception("A value 0.0 have been detected !");
}
/*!
- * Returns a copy of \a this array composed of selected components.
- * The new DataArrayDouble has the same number of tuples but includes components
- * specified by \a compoIds parameter. So that getNbOfElems() of the result array
- * can be either less, same or more than \a this->getNbOfElems().
- * \param [in] compoIds - sequence of zero based indices of components to include
- * into the new array.
- * \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 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
+ * Computes minimal and maximal value in each component. An output array is filled
+ * with \c 2 * \a this->getNumberOfComponents() values, so the caller is to allocate
+ * enough memory before calling this method.
+ * \param [out] bounds - array of size at least 2 *\a this->getNumberOfComponents().
+ * It is filled as follows:<br>
+ * \a bounds[0] = \c min_of_component_0 <br>
+ * \a bounds[1] = \c max_of_component_0 <br>
+ * \a bounds[2] = \c min_of_component_1 <br>
+ * \a bounds[3] = \c max_of_component_1 <br>
+ * ...
*/
-DataArrayDouble *DataArrayDouble::keepSelectedComponents(const std::vector<int>& compoIds) const
+void DataArrayDouble::getMinMaxPerComponent(double *bounds) const
{
checkAllocated();
- MCAuto<DataArrayDouble> ret(DataArrayDouble::New());
- std::size_t newNbOfCompo=compoIds.size();
- int oldNbOfCompo=getNumberOfComponents();
- for(std::vector<int>::const_iterator it=compoIds.begin();it!=compoIds.end();it++)
- if((*it)<0 || (*it)>=oldNbOfCompo)
- {
- std::ostringstream oss; oss << "DataArrayDouble::keepSelectedComponents : invalid requested component : " << *it << " whereas it should be in [0," << oldNbOfCompo << ") !";
- throw INTERP_KERNEL::Exception(oss.str().c_str());
- }
+ int dim=getNumberOfComponents();
+ for (int idim=0; idim<dim; idim++)
+ {
+ bounds[idim*2]=std::numeric_limits<double>::max();
+ bounds[idim*2+1]=-std::numeric_limits<double>::max();
+ }
+ const double *ptr=getConstPointer();
int nbOfTuples=getNumberOfTuples();
- ret->alloc(nbOfTuples,(int)newNbOfCompo);
- ret->copyPartOfStringInfoFrom(*this,compoIds);
- const double *oldc=getConstPointer();
- double *nc=ret->getPointer();
for(int i=0;i<nbOfTuples;i++)
- for(std::size_t j=0;j<newNbOfCompo;j++,nc++)
- *nc=oldc[i*oldNbOfCompo+compoIds[j]];
- return ret.retn();
+ {
+ for(int idim=0;idim<dim;idim++)
+ {
+ if(bounds[idim*2]>ptr[i*dim+idim])
+ {
+ bounds[idim*2]=ptr[i*dim+idim];
+ }
+ if(bounds[idim*2+1]<ptr[i*dim+idim])
+ {
+ bounds[idim*2+1]=ptr[i*dim+idim];
+ }
+ }
+ }
}
/*!
- * Appends components of another array to components of \a this one, tuple by tuple.
- * So that the number of tuples of \a this array remains the same and the number of
- * components increases.
- * \param [in] other - the DataArrayDouble to append to \a this one.
- * \throw If \a this is not allocated.
- * \throw If \a this and \a other arrays have different number of tuples.
+ * This method retrieves a newly allocated DataArrayDouble instance having same number of tuples than \a this and twice number of components than \a this
+ * to store both the min and max per component of each tuples.
+ * \param [in] epsilon the width of the bbox (identical in each direction) - 0.0 by default
*
- * \if ENABLE_EXAMPLES
- * \ref cpp_mcdataarraydouble_meldwith "Here is a C++ example".
+ * \return a newly created DataArrayDouble instance having \c this->getNumberOfTuples() tuples and 2 * \c this->getNumberOfComponent() components
*
- * \ref py_mcdataarraydouble_meldwith "Here is a Python example".
- * \endif
+ * \throw If \a this is not allocated yet.
*/
-void DataArrayDouble::meldWith(const DataArrayDouble *other)
+DataArrayDouble *DataArrayDouble::computeBBoxPerTuple(double epsilon) const
{
checkAllocated();
- other->checkAllocated();
- int nbOfTuples=getNumberOfTuples();
- if(nbOfTuples!=other->getNumberOfTuples())
- throw INTERP_KERNEL::Exception("DataArrayDouble::meldWith : mismatch of number of tuples !");
- int nbOfComp1=getNumberOfComponents();
- int nbOfComp2=other->getNumberOfComponents();
- double *newArr=(double *)malloc((nbOfTuples*(nbOfComp1+nbOfComp2))*sizeof(double));
- double *w=newArr;
- const double *inp1=getConstPointer();
- const double *inp2=other->getConstPointer();
- for(int i=0;i<nbOfTuples;i++,inp1+=nbOfComp1,inp2+=nbOfComp2)
+ const double *dataPtr=getConstPointer();
+ int nbOfCompo=getNumberOfComponents();
+ int nbTuples=getNumberOfTuples();
+ MCAuto<DataArrayDouble> bbox=DataArrayDouble::New();
+ bbox->alloc(nbTuples,2*nbOfCompo);
+ double *bboxPtr=bbox->getPointer();
+ for(int i=0;i<nbTuples;i++)
{
- w=std::copy(inp1,inp1+nbOfComp1,w);
- w=std::copy(inp2,inp2+nbOfComp2,w);
+ for(int j=0;j<nbOfCompo;j++)
+ {
+ bboxPtr[2*nbOfCompo*i+2*j]=dataPtr[nbOfCompo*i+j]-epsilon;
+ bboxPtr[2*nbOfCompo*i+2*j+1]=dataPtr[nbOfCompo*i+j]+epsilon;
+ }
}
- useArray(newArr,true,C_DEALLOC,nbOfTuples,nbOfComp1+nbOfComp2);
- std::vector<int> compIds(nbOfComp2);
- for(int i=0;i<nbOfComp2;i++)
- compIds[i]=nbOfComp1+i;
- copyPartOfStringInfoFrom2(compIds,*other);
-}
-
-/*!
- * This method checks that all tuples in \a other are in \a this.
- * If true, the output param \a tupleIds contains the tuples ids of \a this that correspond to tupes in \a this.
- * For each i in [ 0 , other->getNumberOfTuples() ) tuple #i in \a other is equal ( regarding input precision \a prec ) to tuple tupleIds[i] in \a this.
- *
- * \param [in] other - the array having the same number of components than \a this.
- * \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
-{
- if(!other)
- throw INTERP_KERNEL::Exception("DataArrayDouble::areIncludedInMe : input array is NULL !");
- checkAllocated(); other->checkAllocated();
- if(getNumberOfComponents()!=other->getNumberOfComponents())
- throw INTERP_KERNEL::Exception("DataArrayDouble::areIncludedInMe : the number of components does not match !");
- MCAuto<DataArrayDouble> a=DataArrayDouble::Aggregate(this,other);
- DataArrayInt *c=0,*ci=0;
- a->findCommonTuples(prec,getNumberOfTuples(),c,ci);
- MCAuto<DataArrayInt> cSafe(c),ciSafe(ci);
- int newNbOfTuples=-1;
- MCAuto<DataArrayInt> ids=DataArrayInt::ConvertIndexArrayToO2N(a->getNumberOfTuples(),c->begin(),ci->begin(),ci->end(),newNbOfTuples);
- MCAuto<DataArrayInt> ret1=ids->selectByTupleIdSafeSlice(getNumberOfTuples(),a->getNumberOfTuples(),1);
- tupleIds=ret1.retn();
- return newNbOfTuples==getNumberOfTuples();
+ return bbox.retn();
}
/*!
- * Searches for tuples coincident within \a prec tolerance. Each tuple is considered
- * as coordinates of a point in getNumberOfComponents()-dimensional space. The
- * distance separating two points is computed with the infinite norm.
- *
- * Indices of coincident tuples are stored in output arrays.
- * A pair of arrays (\a comm, \a commIndex) is called "Surjective Format 2".
- *
- * This method is typically used by MEDCouplingPointSet::findCommonNodes() and
- * MEDCouplingUMesh::mergeNodes().
- * \param [in] prec - minimal absolute distance between two tuples (infinite norm) at which they are
- * considered not coincident.
- * \param [in] limitTupleId - limit tuple id. If all tuples within a group of coincident
- * tuples have id strictly lower than \a limitTupleId then they are not returned.
- * \param [out] comm - the array holding ids (== indices) of coincident tuples.
- * \a comm->getNumberOfComponents() == 1.
- * \a comm->getNumberOfTuples() == \a commIndex->back().
- * \param [out] commIndex - the array dividing all indices stored in \a comm into
- * groups of (indices of) coincident tuples. Its every value is a tuple
- * index where a next group of tuples begins. For example the second
- * group of tuples in \a comm is described by following range of indices:
- * [ \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,4].
+ * For each tuples **t** in \a other, this method retrieves tuples in \a this that are equal to **t**.
+ * Two tuples are considered equal if the euclidian distance between the two tuples is lower than \a eps.
+ *
+ * \param [in] other a DataArrayDouble having same number of components than \a this.
+ * \param [in] eps absolute precision representing distance (using infinite norm) between 2 tuples behind which 2 tuples are considered equal.
+ * \param [out] c will contain the set of tuple ids in \a this that are equal to to the tuple ids in \a other contiguously.
+ * \a cI allows to extract information in \a c.
+ * \param [out] cI is an indirection array that allows to extract the data contained in \a c.
*
- * \if ENABLE_EXAMPLES
- * \ref cpp_mcdataarraydouble_findcommontuples "Here is a C++ example".
+ * \throw In case of:
+ * - \a this is not allocated
+ * - \a other is not allocated or null
+ * - \a this and \a other do not have the same number of components
+ * - if number of components of \a this is not in [1,2,3]
*
- * \ref py_mcdataarraydouble_findcommontuples "Here is a Python example".
- * \endif
- * \sa DataArrayInt::ConvertIndexArrayToO2N(), DataArrayDouble::areIncludedInMe
+ * \sa MEDCouplingPointSet::getNodeIdsNearPoints, DataArrayDouble::getDifferentValues
*/
-void DataArrayDouble::findCommonTuples(double prec, int limitTupleId, DataArrayInt *&comm, DataArrayInt *&commIndex) const
+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 !");
checkAllocated();
+ other->checkAllocated();
int nbOfCompo=getNumberOfComponents();
- 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();
- //
- MCAuto<DataArrayInt> c(DataArrayInt::New()),cI(DataArrayInt::New()); c->alloc(0,1); cI->pushBackSilent(0);
+ int otherNbOfCompo=other->getNumberOfComponents();
+ if(nbOfCompo!=otherNbOfCompo)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::computeTupleIdsNearTuples : number of components should be equal between this and other !");
+ int nbOfTuplesOther=other->getNumberOfTuples();
+ MCAuto<DataArrayInt> cArr(DataArrayInt::New()),cIArr(DataArrayInt::New()); cArr->alloc(0,1); cIArr->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;
+ {
+ BBTreePts<3,int> myTree(begin(),0,0,getNumberOfTuples(),eps);
+ FindTupleIdsNearTuplesAlg<3>(myTree,other->getConstPointer(),nbOfTuplesOther,eps,cArr,cIArr);
+ break;
+ }
case 2:
- findCommonTuplesAlg<2>(begin(),nbOfTuples,limitTupleId,prec,c,cI);
- break;
+ {
+ BBTreePts<2,int> myTree(begin(),0,0,getNumberOfTuples(),eps);
+ FindTupleIdsNearTuplesAlg<2>(myTree,other->getConstPointer(),nbOfTuplesOther,eps,cArr,cIArr);
+ break;
+ }
case 1:
- findCommonTuplesAlg<1>(begin(),nbOfTuples,limitTupleId,prec,c,cI);
- break;
+ {
+ BBTreePts<1,int> myTree(begin(),0,0,getNumberOfTuples(),eps);
+ FindTupleIdsNearTuplesAlg<1>(myTree,other->getConstPointer(),nbOfTuplesOther,eps,cArr,cIArr);
+ break;
+ }
default:
- throw INTERP_KERNEL::Exception("DataArrayDouble::findCommonTuples : nb of components managed are 1,2,3 and 4 ! not implemented for other number of components !");
+ throw INTERP_KERNEL::Exception("Unexpected spacedim of coords for computeTupleIdsNearTuples. Must be 1, 2 or 3.");
}
- comm=c.retn();
- commIndex=cI.retn();
+ c=cArr.retn(); cI=cIArr.retn();
}
/*!
+ * This method recenter tuples in \b this in order to be centered at the origin to benefit about the advantages of maximal precision to be around the box
+ * around origin of 'radius' 1.
*
- * \param [in] nbTimes specifies the nb of times each tuples in \a this will be duplicated contiguouly in returned DataArrayDouble instance.
- * \a nbTimes should be at least equal to 1.
- * \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.
+ * \param [in] eps absolute epsilon. under that value of delta between max and min no scale is performed.
*/
-DataArrayDouble *DataArrayDouble::duplicateEachTupleNTimes(int nbTimes) const
+void DataArrayDouble::recenterForMaxPrecision(double eps)
{
checkAllocated();
- if(getNumberOfComponents()!=1)
- throw INTERP_KERNEL::Exception("DataArrayDouble::duplicateEachTupleNTimes : this should have only one component !");
- if(nbTimes<1)
- throw INTERP_KERNEL::Exception("DataArrayDouble::duplicateEachTupleNTimes : nb times should be >= 1 !");
- int nbTuples=getNumberOfTuples();
- const double *inPtr=getConstPointer();
- MCAuto<DataArrayDouble> ret=DataArrayDouble::New(); ret->alloc(nbTimes*nbTuples,1);
- double *retPtr=ret->getPointer();
- for(int i=0;i<nbTuples;i++,inPtr++)
+ int dim=getNumberOfComponents();
+ std::vector<double> bounds(2*dim);
+ getMinMaxPerComponent(&bounds[0]);
+ for(int i=0;i<dim;i++)
{
- double val=*inPtr;
- for(int j=0;j<nbTimes;j++,retPtr++)
- *retPtr=val;
+ double delta=bounds[2*i+1]-bounds[2*i];
+ double offset=(bounds[2*i]+bounds[2*i+1])/2.;
+ if(delta>eps)
+ applyLin(1./delta,-offset/delta,i);
+ else
+ applyLin(1.,-offset,i);
}
- ret->copyStringInfoFrom(*this);
- return ret.retn();
}
/*!
- * This methods returns the minimal distance between the two set of points \a this and \a other.
- * So \a this and \a other have to have the same number of components. If not an INTERP_KERNEL::Exception will be thrown.
- * This method works only if number of components of \a this (equal to those of \a other) is in 1, 2 or 3.
- *
- * \param [out] thisTupleId the tuple id in \a this corresponding to the returned minimal distance
- * \param [out] otherTupleId the tuple id in \a other corresponding to the returned minimal distance
- * \return the minimal distance between the two set of points \a this and \a other.
- * \sa DataArrayDouble::findClosestTupleId
+ * Returns the maximal value and all its locations within \a this one-dimensional array.
+ * \param [out] tupleIds - a new instance of DataArrayInt containg indices of
+ * tuples holding the maximal value. The caller is to delete it using
+ * decrRef() as it is no more needed.
+ * \return double - the maximal value among all values of \a this array.
+ * \throw If \a this->getNumberOfComponents() != 1
+ * \throw If \a this->getNumberOfTuples() < 1
*/
-double DataArrayDouble::minimalDistanceTo(const DataArrayDouble *other, int& thisTupleId, int& otherTupleId) const
+double DataArrayDouble::getMaxValue2(DataArrayInt*& tupleIds) const
{
- MCAuto<DataArrayInt> part1=findClosestTupleId(other);
- int nbOfCompo(getNumberOfComponents());
- int otherNbTuples(other->getNumberOfTuples());
- const double *thisPt(begin()),*otherPt(other->begin());
- const int *part1Pt(part1->begin());
- double ret=std::numeric_limits<double>::max();
- for(int i=0;i<otherNbTuples;i++,part1Pt++,otherPt+=nbOfCompo)
- {
- double tmp(0.);
- for(int j=0;j<nbOfCompo;j++)
- tmp+=(otherPt[j]-thisPt[nbOfCompo*(*part1Pt)+j])*(otherPt[j]-thisPt[nbOfCompo*(*part1Pt)+j]);
- if(tmp<ret)
- { ret=tmp; thisTupleId=*part1Pt; otherTupleId=i; }
- }
- return sqrt(ret);
+ int tmp;
+ tupleIds=0;
+ double ret=getMaxValue(tmp);
+ tupleIds=findIdsInRange(ret,ret);
+ return ret;
}
/*!
- * This methods returns for each tuple in \a other which tuple in \a this is the closest.
- * So \a this and \a other have to have the same number of components. If not an INTERP_KERNEL::Exception will be thrown.
- * This method works only if number of components of \a this (equal to those of \a other) is in 1, 2 or 3.
- *
- * \return a newly allocated (new object to be dealt by the caller) DataArrayInt having \c other->getNumberOfTuples() tuples and one components.
- * \sa DataArrayDouble::minimalDistanceTo
+ * Returns the minimal value and all its locations within \a this one-dimensional array.
+ * \param [out] tupleIds - a new instance of DataArrayInt containg indices of
+ * tuples holding the minimal value. The caller is to delete it using
+ * decrRef() as it is no more needed.
+ * \return double - the minimal value among all values of \a this array.
+ * \throw If \a this->getNumberOfComponents() != 1
+ * \throw If \a this->getNumberOfTuples() < 1
*/
-DataArrayInt *DataArrayDouble::findClosestTupleId(const DataArrayDouble *other) const
+double DataArrayDouble::getMinValue2(DataArrayInt*& tupleIds) const
{
- if(!other)
- throw INTERP_KERNEL::Exception("DataArrayDouble::findClosestTupleId : other instance is NULL !");
- checkAllocated(); other->checkAllocated();
- int nbOfCompo=getNumberOfComponents();
- if(nbOfCompo!=other->getNumberOfComponents())
- {
- std::ostringstream oss; oss << "DataArrayDouble::findClosestTupleId : number of components in this is " << nbOfCompo;
- oss << ", whereas number of components in other is " << other->getNumberOfComponents() << "! Should be equal !";
- throw INTERP_KERNEL::Exception(oss.str().c_str());
- }
- int nbOfTuples=other->getNumberOfTuples();
- int thisNbOfTuples=getNumberOfTuples();
- MCAuto<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(nbOfTuples,1);
- 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]));
- double delta=std::max(xDelta,yDelta); delta=std::max(delta,zDelta);
- double characSize=pow((delta*delta*delta)/((double)thisNbOfTuples),1./3.);
- BBTreePts<3,int> myTree(begin(),0,0,getNumberOfTuples(),characSize*1e-12);
- FindClosestTupleIdAlg<3>(myTree,3.*characSize*characSize,other->begin(),nbOfTuples,begin(),thisNbOfTuples,ret->getPointer());
- break;
- }
- case 2:
- {
- double xDelta(fabs(bounds[1]-bounds[0])),yDelta(fabs(bounds[3]-bounds[2]));
- double delta=std::max(xDelta,yDelta);
- double characSize=sqrt(delta/(double)thisNbOfTuples);
- BBTreePts<2,int> myTree(begin(),0,0,getNumberOfTuples(),characSize*1e-12);
- FindClosestTupleIdAlg<2>(myTree,2.*characSize*characSize,other->begin(),nbOfTuples,begin(),thisNbOfTuples,ret->getPointer());
- break;
- }
- case 1:
- {
- double characSize=fabs(bounds[1]-bounds[0])/thisNbOfTuples;
- BBTreePts<1,int> myTree(begin(),0,0,getNumberOfTuples(),characSize*1e-12);
- FindClosestTupleIdAlg<1>(myTree,1.*characSize*characSize,other->begin(),nbOfTuples,begin(),thisNbOfTuples,ret->getPointer());
- break;
- }
- default:
- throw INTERP_KERNEL::Exception("Unexpected spacedim of coords for findClosestTupleId. Must be 1, 2 or 3.");
- }
- return ret.retn();
+ int tmp;
+ tupleIds=0;
+ double ret=getMinValue(tmp);
+ tupleIds=findIdsInRange(ret,ret);
+ return ret;
}
/*!
- * 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.
+ * This method returns the number of values in \a this that are equals ( within an absolute precision of \a eps ) to input parameter \a value.
+ * This method only works for single component array.
*
- * \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());
- }
- MCAuto<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();
-}
-
-/*!
- * Returns a copy of \a this array by excluding coincident tuples. Each tuple is
- * considered as coordinates of a point in getNumberOfComponents()-dimensional
- * space. The distance between tuples is computed using norm2. If several tuples are
- * not far each from other than \a prec, only one of them remains in the result
- * array. The order of tuples in the result array is same as in \a this one except
- * that coincident tuples are excluded.
- * \param [in] prec - minimal absolute distance between two tuples at which they are
- * considered not coincident.
- * \param [in] limitTupleId - limit tuple id. If all tuples within a group of coincident
- * tuples have id strictly lower than \a limitTupleId then they are not excluded.
- * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
- * is to delete using decrRef() as it is no more needed.
- * \throw If \a this is not allocated.
- * \throw If the number of components is not in [1,2,3,4].
+ * \return a value in [ 0, \c this->getNumberOfTuples() )
+ *
+ * \throw If \a this is not allocated
*
- * \if ENABLE_EXAMPLES
- * \ref py_mcdataarraydouble_getdifferentvalues "Here is a Python example".
- * \endif
*/
-DataArrayDouble *DataArrayDouble::getDifferentValues(double prec, int limitTupleId) const
+int DataArrayDouble::count(double value, double eps) const
{
+ int ret=0;
checkAllocated();
- DataArrayInt *c0=0,*cI0=0;
- findCommonTuples(prec,limitTupleId,c0,cI0);
- MCAuto<DataArrayInt> c(c0),cI(cI0);
- int newNbOfTuples=-1;
- MCAuto<DataArrayInt> o2n=DataArrayInt::ConvertIndexArrayToO2N(getNumberOfTuples(),c0->begin(),cI0->begin(),cI0->end(),newNbOfTuples);
- return renumberAndReduce(o2n->getConstPointer(),newNbOfTuples);
+ if(getNumberOfComponents()!=1)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::count : must be applied on DataArrayDouble with only one component, you can call 'rearrange' method before !");
+ const double *vals=begin();
+ int nbOfTuples=getNumberOfTuples();
+ for(int i=0;i<nbOfTuples;i++,vals++)
+ if(fabs(*vals-value)<=eps)
+ ret++;
+ return ret;
}
/*!
- * Copy all components in a specified order from another DataArrayDouble.
- * Both numerical and textual data is copied. The number of tuples in \a this and
- * the other array can be different.
- * \param [in] a - the array to copy data from.
- * \param [in] compoIds - sequence of zero based indices of components, data of which is
- * to be copied.
- * \throw If \a a 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_mcdataarraydouble_setselectedcomponents "Here is a Python example".
- * \endif
+ * Returns the average value of \a this one-dimensional array.
+ * \return double - the average value over all values of \a this array.
+ * \throw If \a this->getNumberOfComponents() != 1
+ * \throw If \a this->getNumberOfTuples() < 1
*/
-void DataArrayDouble::setSelectedComponents(const DataArrayDouble *a, const std::vector<int>& compoIds)
+double DataArrayDouble::getAverageValue() const
{
- if(!a)
- throw INTERP_KERNEL::Exception("DataArrayDouble::setSelectedComponents : input DataArrayDouble is NULL !");
- checkAllocated();
- copyPartOfStringInfoFrom2(compoIds,*a);
- std::size_t partOfCompoSz=compoIds.size();
- int nbOfCompo=getNumberOfComponents();
- int nbOfTuples=std::min(getNumberOfTuples(),a->getNumberOfTuples());
- const double *ac=a->getConstPointer();
- double *nc=getPointer();
- for(int i=0;i<nbOfTuples;i++)
- for(std::size_t j=0;j<partOfCompoSz;j++,ac++)
- nc[nbOfCompo*i+compoIds[j]]=*ac;
+ if(getNumberOfComponents()!=1)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::getAverageValue : must be applied on DataArrayDouble with only one component, you can call 'rearrange' method before !");
+ int nbOfTuples=getNumberOfTuples();
+ if(nbOfTuples<=0)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::getAverageValue : array exists but number of tuples must be > 0 !");
+ const double *vals=getConstPointer();
+ double ret=std::accumulate(vals,vals+nbOfTuples,0.);
+ return ret/nbOfTuples;
}
/*!
- * Copy all values from another DataArrayDouble into specified tuples and components
- * of \a this array. Textual data is not copied.
- * The tree parameters defining set of indices of tuples and components are similar to
- * the tree parameters of the Python function \c range(\c start,\c stop,\c step).
- * \param [in] a - the array to copy values from.
- * \param [in] bgTuples - index of the first tuple of \a this array to assign values to.
- * \param [in] endTuples - index of the tuple before which the tuples to assign to
- * are located.
- * \param [in] stepTuples - index increment to get index of the next tuple to assign to.
- * \param [in] bgComp - index of the first component of \a this array to assign values to.
- * \param [in] endComp - index of the component before which the components to assign
- * to are located.
- * \param [in] stepComp - index increment to get index of the next component to assign to.
- * \param [in] strictCompoCompare - if \a true (by default), then \a a->getNumberOfComponents()
- * must be equal to the number of columns to assign to, else an
- * exception is thrown; if \a false, then it is only required that \a
- * a->getNbOfElems() equals to number of values to assign to (this condition
- * must be respected even if \a strictCompoCompare is \a true). The number of
- * values to assign to is given by following Python expression:
- * \a nbTargetValues =
- * \c len(\c range(\a bgTuples,\a endTuples,\a stepTuples)) *
- * \c len(\c range(\a bgComp,\a endComp,\a stepComp)).
- * \throw If \a a is NULL.
- * \throw If \a a is not allocated.
+ * Returns the Euclidean norm of the vector defined by \a this array.
+ * \return double - the value of the Euclidean norm, i.e.
+ * the square root of the inner product of vector.
* \throw If \a this is not allocated.
- * \throw If parameters specifying tuples and components to assign to do not give a
- * non-empty range of increasing indices.
- * \throw If \a a->getNbOfElems() != \a nbTargetValues.
- * \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)
+double DataArrayDouble::norm2() const
{
- if(!a)
- throw INTERP_KERNEL::Exception("DataArrayDouble::setPartOfValues1 : input DataArrayDouble is NULL !");
- const char msg[]="DataArrayDouble::setPartOfValues1";
checkAllocated();
- a->checkAllocated();
- int newNbOfTuples=DataArray::GetNumberOfItemGivenBES(bgTuples,endTuples,stepTuples,msg);
- int newNbOfComp=DataArray::GetNumberOfItemGivenBES(bgComp,endComp,stepComp,msg);
- int nbComp=getNumberOfComponents();
- int nbOfTuples=getNumberOfTuples();
- DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
- DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
- bool assignTech=true;
- if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
- {
- if(strictCompoCompare)
- a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
- }
- else
- {
- a->checkNbOfTuplesAndComp(1,newNbOfComp,msg);
- assignTech=false;
- }
- const double *srcPt=a->getConstPointer();
- double *pt=getPointer()+bgTuples*nbComp+bgComp;
- if(assignTech)
- {
- for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
- for(int j=0;j<newNbOfComp;j++,srcPt++)
- pt[j*stepComp]=*srcPt;
- }
- else
- {
- for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
- {
- const double *srcPt2=srcPt;
- for(int j=0;j<newNbOfComp;j++,srcPt2++)
- pt[j*stepComp]=*srcPt2;
- }
- }
+ double ret=0.;
+ std::size_t nbOfElems=getNbOfElems();
+ const double *pt=getConstPointer();
+ for(std::size_t i=0;i<nbOfElems;i++,pt++)
+ ret+=(*pt)*(*pt);
+ return sqrt(ret);
}
/*!
- * Assign a given value to values at specified tuples and components of \a this array.
- * The tree parameters defining set of indices of tuples and components are similar to
- * the tree parameters of the Python function \c range(\c start,\c stop,\c step)..
- * \param [in] a - the value to assign.
- * \param [in] bgTuples - index of the first tuple of \a this array to assign to.
- * \param [in] endTuples - index of the tuple before which the tuples to assign to
- * are located.
- * \param [in] stepTuples - index increment to get index of the next tuple to assign to.
- * \param [in] bgComp - index of the first component of \a this array to assign to.
- * \param [in] endComp - index of the component before which the components to assign
- * to are located.
- * \param [in] stepComp - index increment to get index of the next component to assign to.
+ * 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 (whatever its number of components).
* \throw If \a this is not allocated.
- * \throw If parameters specifying tuples and components to assign to, do not give a
- * non-empty range of increasing indices or indices are out of a valid range
- * for \c 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)
+double DataArrayDouble::normMax() const
{
- const char msg[]="DataArrayDouble::setPartOfValuesSimple1";
checkAllocated();
- int newNbOfTuples=DataArray::GetNumberOfItemGivenBES(bgTuples,endTuples,stepTuples,msg);
- int newNbOfComp=DataArray::GetNumberOfItemGivenBES(bgComp,endComp,stepComp,msg);
- int nbComp=getNumberOfComponents();
- int nbOfTuples=getNumberOfTuples();
- DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
- DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
- double *pt=getPointer()+bgTuples*nbComp+bgComp;
- for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
- for(int j=0;j<newNbOfComp;j++)
- pt[j*stepComp]=a;
-}
-
-/*!
- * Copy all values from another DataArrayDouble (\a a) into specified tuples and
- * components of \a this array. Textual data is not copied.
- * The tuples and components to assign to are defined by C arrays of indices.
- * There are two *modes of usage*:
- * - If \a a->getNbOfElems() equals to number of values to assign to, then every value
- * of \a a is assigned to its own location within \a this array.
- * - If \a a includes one tuple, then all values of \a a are assigned to the specified
- * components of every specified tuple of \a this array. In this mode it is required
- * that \a a->getNumberOfComponents() equals to the number of specified components.
- *
- * \param [in] a - the array to copy values from.
- * \param [in] bgTuples - pointer to an array of tuple indices of \a this array to
- * assign values of \a a to.
- * \param [in] endTuples - specifies the end of the array \a bgTuples, so that
- * pointer to a tuple index <em>(pi)</em> varies as this:
- * \a bgTuples <= \a pi < \a endTuples.
- * \param [in] bgComp - pointer to an array of component indices of \a this array to
- * assign values of \a a to.
- * \param [in] endComp - specifies the end of the array \a bgTuples, so that
- * pointer to a component index <em>(pi)</em> varies as this:
- * \a bgComp <= \a pi < \a endComp.
- * \param [in] strictCompoCompare - this parameter is checked only if the
- * *mode of usage* is the first; if it is \a true (default),
- * then \a a->getNumberOfComponents() must be equal
- * to the number of specified columns, else this is not required.
- * \throw If \a a is NULL.
- * \throw If \a a is not allocated.
+ 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));
+ 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.
- * \throw If any index of tuple/component given by <em>bgTuples / bgComp</em> is
- * out of a valid range for \a this array.
- * \throw In the first *mode of usage*, if <em>strictCompoCompare == true </em> and
- * if <em> a->getNumberOfComponents() != (endComp - bgComp) </em>.
- * \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)
+double DataArrayDouble::normMin() const
{
- if(!a)
- throw INTERP_KERNEL::Exception("DataArrayDouble::setPartOfValues2 : input DataArrayDouble is NULL !");
- const char msg[]="DataArrayDouble::setPartOfValues2";
checkAllocated();
- a->checkAllocated();
- int nbComp=getNumberOfComponents();
- int nbOfTuples=getNumberOfTuples();
- for(const int *z=bgComp;z!=endComp;z++)
- DataArray::CheckValueInRange(nbComp,*z,"invalid component id");
- int newNbOfTuples=(int)std::distance(bgTuples,endTuples);
- int newNbOfComp=(int)std::distance(bgComp,endComp);
- bool assignTech=true;
- if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
- {
- if(strictCompoCompare)
- a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
- }
- else
- {
- a->checkNbOfTuplesAndComp(1,newNbOfComp,msg);
- assignTech=false;
- }
- double *pt=getPointer();
- const double *srcPt=a->getConstPointer();
- if(assignTech)
- {
- for(const int *w=bgTuples;w!=endTuples;w++)
- {
- DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
- for(const int *z=bgComp;z!=endComp;z++,srcPt++)
- {
- pt[(std::size_t)(*w)*nbComp+(*z)]=*srcPt;
- }
- }
- }
- else
+ 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++)
{
- for(const int *w=bgTuples;w!=endTuples;w++)
- {
- const double *srcPt2=srcPt;
- DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
- for(const int *z=bgComp;z!=endComp;z++,srcPt2++)
- {
- pt[(std::size_t)(*w)*nbComp+(*z)]=*srcPt2;
- }
- }
+ double val(std::abs(*pt));
+ if(val<ret)
+ ret=val;
}
+ return ret;
}
/*!
- * Assign a given value to values at specified tuples and components of \a this array.
- * The tuples and components to assign to are defined by C arrays of indices.
- * \param [in] a - the value to assign.
- * \param [in] bgTuples - pointer to an array of tuple indices of \a this array to
- * assign \a a to.
- * \param [in] endTuples - specifies the end of the array \a bgTuples, so that
- * pointer to a tuple index (\a pi) varies as this:
- * \a bgTuples <= \a pi < \a endTuples.
- * \param [in] bgComp - pointer to an array of component indices of \a this array to
- * assign \a a to.
- * \param [in] endComp - specifies the end of the array \a bgTuples, so that
- * pointer to a component index (\a pi) varies as this:
- * \a bgComp <= \a pi < \a endComp.
+ * Accumulates values of each component of \a this array.
+ * \param [out] res - an array of length \a this->getNumberOfComponents(), allocated
+ * by the caller, that is filled by this method with sum value for each
+ * component.
* \throw If \a this is not allocated.
- * \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)
+void DataArrayDouble::accumulate(double *res) const
{
checkAllocated();
- int nbComp=getNumberOfComponents();
- int nbOfTuples=getNumberOfTuples();
- for(const int *z=bgComp;z!=endComp;z++)
- DataArray::CheckValueInRange(nbComp,*z,"invalid component id");
- double *pt=getPointer();
- for(const int *w=bgTuples;w!=endTuples;w++)
- for(const int *z=bgComp;z!=endComp;z++)
- {
- DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
- pt[(std::size_t)(*w)*nbComp+(*z)]=a;
- }
+ const double *ptr=getConstPointer();
+ int nbTuple=getNumberOfTuples();
+ int nbComps=getNumberOfComponents();
+ std::fill(res,res+nbComps,0.);
+ for(int i=0;i<nbTuple;i++)
+ std::transform(ptr+i*nbComps,ptr+(i+1)*nbComps,res,res,std::plus<double>());
}
/*!
- * Copy all values from another DataArrayDouble (\a a) into specified tuples and
- * components of \a this array. Textual data is not copied.
- * The tuples to assign to are defined by a C array of indices.
- * The components to assign to are defined by three values similar to parameters of
- * the Python function \c range(\c start,\c stop,\c step).
- * There are two *modes of usage*:
- * - If \a a->getNbOfElems() equals to number of values to assign to, then every value
- * of \a a is assigned to its own location within \a this array.
- * - If \a a includes one tuple, then all values of \a a are assigned to the specified
- * components of every specified tuple of \a this array. In this mode it is required
- * that \a a->getNumberOfComponents() equals to the number of specified components.
+ * This method returns the min distance from an external tuple defined by [ \a tupleBg , \a tupleEnd ) to \a this and
+ * the first tuple in \a this that matches the returned distance. If there is no tuples in \a this an exception will be thrown.
*
- * \param [in] a - the array to copy values from.
- * \param [in] bgTuples - pointer to an array of tuple indices of \a this array to
- * assign values of \a a to.
- * \param [in] endTuples - specifies the end of the array \a bgTuples, so that
- * pointer to a tuple index <em>(pi)</em> varies as this:
- * \a bgTuples <= \a pi < \a endTuples.
- * \param [in] bgComp - index of the first component of \a this array to assign to.
- * \param [in] endComp - index of the component before which the components to assign
- * to are located.
- * \param [in] stepComp - index increment to get index of the next component to assign to.
- * \param [in] strictCompoCompare - this parameter is checked only in the first
- * *mode of usage*; if \a strictCompoCompare is \a true (default),
- * then \a a->getNumberOfComponents() must be equal
- * to the number of specified columns, else this is not required.
- * \throw If \a a is NULL.
- * \throw If \a a is not allocated.
- * \throw If \a this is not allocated.
- * \throw If any index of tuple given by \a bgTuples is out of a valid range for
- * \a this array.
- * \throw In the first *mode of usage*, if <em>strictCompoCompare == true </em> and
- * if <em> a->getNumberOfComponents()</em> is unequal to the number of components
- * defined by <em>(bgComp,endComp,stepComp)</em>.
- * \throw In the second *mode of usage*, if \a a->getNumberOfTuples() != 1 or
- * <em> a->getNumberOfComponents()</em> is unequal to the number of components
- * defined by <em>(bgComp,endComp,stepComp)</em>.
- * \throw If parameters specifying components to assign to, do not give a
- * non-empty range of increasing indices or indices are out of a valid range
- * for \c this array.
*
- * \if ENABLE_EXAMPLES
- * \ref py_mcdataarraydouble_setpartofvalues3 "Here is a Python example".
- * \endif
+ * \a this is expected to be allocated and expected to have a number of components equal to the distance from \a tupleBg to
+ * \a tupleEnd. If not an exception will be thrown.
+ *
+ * \param [in] tupleBg start pointer (included) of input external tuple
+ * \param [in] tupleEnd end pointer (not included) of input external tuple
+ * \param [out] tupleId the tuple id in \a this that matches the min of distance between \a this and input external tuple
+ * \return the min distance.
+ * \sa MEDCouplingUMesh::distanceToPoint
*/
-void DataArrayDouble::setPartOfValues3(const DataArrayDouble *a, const int *bgTuples, const int *endTuples, int bgComp, int endComp, int stepComp, bool strictCompoCompare)
+double DataArrayDouble::distanceToTuple(const double *tupleBg, const double *tupleEnd, int& tupleId) const
{
- if(!a)
- throw INTERP_KERNEL::Exception("DataArrayDouble::setPartOfValues3 : input DataArrayDouble is NULL !");
- const char msg[]="DataArrayDouble::setPartOfValues3";
checkAllocated();
- a->checkAllocated();
- int newNbOfComp=DataArray::GetNumberOfItemGivenBES(bgComp,endComp,stepComp,msg);
- int nbComp=getNumberOfComponents();
- int nbOfTuples=getNumberOfTuples();
- DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
- int newNbOfTuples=(int)std::distance(bgTuples,endTuples);
- bool assignTech=true;
- if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
- {
- if(strictCompoCompare)
- a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
- }
- else
- {
- a->checkNbOfTuplesAndComp(1,newNbOfComp,msg);
- assignTech=false;
- }
- double *pt=getPointer()+bgComp;
- const double *srcPt=a->getConstPointer();
- if(assignTech)
- {
- for(const int *w=bgTuples;w!=endTuples;w++)
- for(int j=0;j<newNbOfComp;j++,srcPt++)
- {
- DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
- pt[(std::size_t)(*w)*nbComp+j*stepComp]=*srcPt;
- }
- }
- else
+ int nbTuple=getNumberOfTuples();
+ int nbComps=getNumberOfComponents();
+ if(nbComps!=(int)std::distance(tupleBg,tupleEnd))
+ { std::ostringstream oss; oss << "DataArrayDouble::distanceToTuple : size of input tuple is " << std::distance(tupleBg,tupleEnd) << " should be equal to the number of components in this : " << nbComps << " !"; throw INTERP_KERNEL::Exception(oss.str().c_str()); }
+ if(nbTuple==0)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::distanceToTuple : no tuple in this ! No distance to compute !");
+ double ret0=std::numeric_limits<double>::max();
+ tupleId=-1;
+ const double *work=getConstPointer();
+ for(int i=0;i<nbTuple;i++)
{
- for(const int *w=bgTuples;w!=endTuples;w++)
- {
- const double *srcPt2=srcPt;
- for(int j=0;j<newNbOfComp;j++,srcPt2++)
- {
- DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
- pt[(std::size_t)(*w)*nbComp+j*stepComp]=*srcPt2;
- }
- }
+ double val=0.;
+ for(int j=0;j<nbComps;j++,work++)
+ val+=(*work-tupleBg[j])*((*work-tupleBg[j]));
+ if(val>=ret0)
+ continue;
+ else
+ { ret0=val; tupleId=i; }
}
+ return sqrt(ret0);
}
/*!
- * Assign a given value to values at specified tuples and components of \a this array.
- * The tuples to assign to are defined by a C array of indices.
- * The components to assign to are defined by three values similar to parameters of
- * the Python function \c range(\c start,\c stop,\c step).
- * \param [in] a - the value to assign.
- * \param [in] bgTuples - pointer to an array of tuple indices of \a this array to
- * assign \a a to.
- * \param [in] endTuples - specifies the end of the array \a bgTuples, so that
- * pointer to a tuple index <em>(pi)</em> varies as this:
- * \a bgTuples <= \a pi < \a endTuples.
- * \param [in] bgComp - index of the first component of \a this array to assign to.
- * \param [in] endComp - index of the component before which the components to assign
- * to are located.
- * \param [in] stepComp - index increment to get index of the next component to assign to.
+ * Accumulate values of the given component of \a this array.
+ * \param [in] compId - the index of the component of interest.
+ * \return double - a sum value of \a compId-th component.
* \throw If \a this is not allocated.
- * \throw If any index of tuple given by \a bgTuples is out of a valid range for
- * \a this array.
- * \throw If parameters specifying components to assign to, do not give a
- * non-empty range of increasing indices or indices are out of a valid range
- * for \c this array.
- *
- * \if ENABLE_EXAMPLES
- * \ref py_mcdataarraydouble_setpartofvaluessimple3 "Here is a Python example".
- * \endif
+ * \throw If \a the condition ( 0 <= \a compId < \a this->getNumberOfComponents() ) is
+ * not respected.
*/
-void DataArrayDouble::setPartOfValuesSimple3(double a, const int *bgTuples, const int *endTuples, int bgComp, int endComp, int stepComp)
+double DataArrayDouble::accumulate(int compId) const
{
- const char msg[]="DataArrayDouble::setPartOfValuesSimple3";
checkAllocated();
- int newNbOfComp=DataArray::GetNumberOfItemGivenBES(bgComp,endComp,stepComp,msg);
- int nbComp=getNumberOfComponents();
- int nbOfTuples=getNumberOfTuples();
- DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
- double *pt=getPointer()+bgComp;
- for(const int *w=bgTuples;w!=endTuples;w++)
- for(int j=0;j<newNbOfComp;j++)
- {
- DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
- pt[(std::size_t)(*w)*nbComp+j*stepComp]=a;
- }
+ const double *ptr=getConstPointer();
+ int nbTuple=getNumberOfTuples();
+ int nbComps=getNumberOfComponents();
+ if(compId<0 || compId>=nbComps)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::accumulate : Invalid compId specified : No such nb of components !");
+ double ret=0.;
+ for(int i=0;i<nbTuple;i++)
+ ret+=ptr[i*nbComps+compId];
+ return ret;
}
/*!
- * Copy all values from another DataArrayDouble into specified tuples and components
- * of \a this array. Textual data is not copied.
- * The tree parameters defining set of indices of tuples and components are similar to
- * the tree parameters of the Python function \c range(\c start,\c stop,\c step).
- * \param [in] a - the array to copy values from.
- * \param [in] bgTuples - index of the first tuple of \a this array to assign values to.
- * \param [in] endTuples - index of the tuple before which the tuples to assign to
- * are located.
- * \param [in] stepTuples - index increment to get index of the next tuple to assign to.
- * \param [in] bgComp - pointer to an array of component indices of \a this array to
- * assign \a a to.
- * \param [in] endComp - specifies the end of the array \a bgTuples, so that
- * pointer to a component index (\a pi) varies as this:
- * \a bgComp <= \a pi < \a endComp.
- * \param [in] strictCompoCompare - if \a true (by default), then \a a->getNumberOfComponents()
- * must be equal to the number of columns to assign to, else an
- * exception is thrown; if \a false, then it is only required that \a
- * a->getNbOfElems() equals to number of values to assign to (this condition
- * must be respected even if \a strictCompoCompare is \a true). The number of
- * values to assign to is given by following Python expression:
- * \a nbTargetValues =
- * \c len(\c range(\a bgTuples,\a endTuples,\a stepTuples)) *
- * \c len(\c range(\a bgComp,\a endComp,\a stepComp)).
- * \throw If \a a is NULL.
- * \throw If \a a is not allocated.
- * \throw If \a this is not allocated.
- * \throw If parameters specifying tuples and components to assign to do not give a
- * non-empty range of increasing indices.
- * \throw If \a a->getNbOfElems() != \a nbTargetValues.
- * \throw If \a strictCompoCompare == \a true && \a a->getNumberOfComponents() !=
- * \c len(\c range(\a bgComp,\a endComp,\a stepComp)).
+ * This method accumulate using addition tuples in \a this using input index array [ \a bgOfIndex, \a endOfIndex ).
+ * The returned array will have same number of components than \a this and number of tuples equal to
+ * \c std::distance(bgOfIndex,endOfIndex) \b minus \b one.
+ *
+ * The input index array is expected to be ascendingly sorted in which the all referenced ids should be in [0, \c this->getNumberOfTuples).
+ * This method is quite useful for users that need to put a field on cells to field on nodes on the same mesh without a need of conservation.
*
+ * \param [in] bgOfIndex - begin (included) of the input index array.
+ * \param [in] endOfIndex - end (excluded) of the input index array.
+ * \return DataArrayDouble * - the new instance having the same number of components than \a this.
+ *
+ * \throw If bgOfIndex or end is NULL.
+ * \throw If input index array is not ascendingly sorted.
+ * \throw If there is an id in [ \a bgOfIndex, \a endOfIndex ) not in [0, \c this->getNumberOfTuples).
+ * \throw If std::distance(bgOfIndex,endOfIndex)==0.
*/
-void DataArrayDouble::setPartOfValues4(const DataArrayDouble *a, int bgTuples, int endTuples, int stepTuples, const int *bgComp, const int *endComp, bool strictCompoCompare)
+DataArrayDouble *DataArrayDouble::accumulatePerChunck(const int *bgOfIndex, const int *endOfIndex) const
{
- if(!a)
- throw INTERP_KERNEL::Exception("DataArrayDouble::setPartOfValues4 : input DataArrayDouble is NULL !");
- const char msg[]="DataArrayDouble::setPartOfValues4";
+ if(!bgOfIndex || !endOfIndex)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::accumulatePerChunck : input pointer NULL !");
checkAllocated();
- a->checkAllocated();
- int newNbOfTuples=DataArray::GetNumberOfItemGivenBES(bgTuples,endTuples,stepTuples,msg);
- int newNbOfComp=(int)std::distance(bgComp,endComp);
- int nbComp=getNumberOfComponents();
- for(const int *z=bgComp;z!=endComp;z++)
- DataArray::CheckValueInRange(nbComp,*z,"invalid component id");
+ int nbCompo=getNumberOfComponents();
int nbOfTuples=getNumberOfTuples();
- DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
- bool assignTech=true;
- if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
- {
- if(strictCompoCompare)
- a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
- }
- else
- {
- a->checkNbOfTuplesAndComp(1,newNbOfComp,msg);
- assignTech=false;
- }
- const double *srcPt=a->getConstPointer();
- double *pt=getPointer()+bgTuples*nbComp;
- if(assignTech)
- {
- for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
- for(const int *z=bgComp;z!=endComp;z++,srcPt++)
- pt[*z]=*srcPt;
- }
- else
+ int sz=(int)std::distance(bgOfIndex,endOfIndex);
+ if(sz<1)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::accumulatePerChunck : invalid size of input index array !");
+ sz--;
+ MCAuto<DataArrayDouble> ret=DataArrayDouble::New(); ret->alloc(sz,nbCompo);
+ const int *w=bgOfIndex;
+ if(*w<0 || *w>=nbOfTuples)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::accumulatePerChunck : The first element of the input index not in [0,nbOfTuples) !");
+ const double *srcPt=begin()+(*w)*nbCompo;
+ double *tmp=ret->getPointer();
+ for(int i=0;i<sz;i++,tmp+=nbCompo,w++)
{
- for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
+ std::fill(tmp,tmp+nbCompo,0.);
+ if(w[1]>=w[0])
{
- const double *srcPt2=srcPt;
- for(const int *z=bgComp;z!=endComp;z++,srcPt2++)
- pt[*z]=*srcPt2;
- }
- }
-}
-
-void DataArrayDouble::setPartOfValuesSimple4(double a, int bgTuples, int endTuples, int stepTuples, const int *bgComp, const int *endComp)
-{
- const char msg[]="DataArrayDouble::setPartOfValuesSimple4";
- checkAllocated();
- int newNbOfTuples=DataArray::GetNumberOfItemGivenBES(bgTuples,endTuples,stepTuples,msg);
- int nbComp=getNumberOfComponents();
- for(const int *z=bgComp;z!=endComp;z++)
- DataArray::CheckValueInRange(nbComp,*z,"invalid component id");
- int nbOfTuples=getNumberOfTuples();
- DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
- double *pt=getPointer()+bgTuples*nbComp;
- for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
- for(const int *z=bgComp;z!=endComp;z++)
- pt[*z]=a;
-}
-
-/*!
- * Copy some tuples from another DataArrayDouble into specified tuples
- * of \a this array. Textual data is not copied. Both arrays must have equal number of
- * components.
- * Both the tuples to assign and the tuples to assign to are defined by a DataArrayInt.
- * All components of selected tuples are copied.
- * \param [in] a - the array to copy values from.
- * \param [in] tuplesSelec - the array specifying both source tuples of \a a and
- * target tuples of \a this. \a tuplesSelec has two components, and the
- * first component specifies index of the source tuple and the second
- * one specifies index of the target tuple.
- * \throw If \a this is not allocated.
- * \throw If \a a is NULL.
- * \throw If \a a is not allocated.
- * \throw If \a tuplesSelec is NULL.
- * \throw If \a tuplesSelec is not allocated.
- * \throw If <em>this->getNumberOfComponents() != a->getNumberOfComponents()</em>.
- * \throw If \a tuplesSelec->getNumberOfComponents() != 2.
- * \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)
-{
- if(!a || !tuplesSelec)
- throw INTERP_KERNEL::Exception("DataArrayDouble::setPartOfValuesAdv : input DataArrayDouble is NULL !");
- checkAllocated();
- a->checkAllocated();
- tuplesSelec->checkAllocated();
- int nbOfComp=getNumberOfComponents();
- if(nbOfComp!=a->getNumberOfComponents())
- throw INTERP_KERNEL::Exception("DataArrayDouble::setPartOfValuesAdv : This and a do not have the same number of components !");
- if(tuplesSelec->getNumberOfComponents()!=2)
- throw INTERP_KERNEL::Exception("DataArrayDouble::setPartOfValuesAdv : Expecting to have a tuple selector DataArrayInt instance with exactly 2 components !");
- int thisNt=getNumberOfTuples();
- int aNt=a->getNumberOfTuples();
- double *valsToSet=getPointer();
- const double *valsSrc=a->getConstPointer();
- for(const int *tuple=tuplesSelec->begin();tuple!=tuplesSelec->end();tuple+=2)
- {
- if(tuple[1]>=0 && tuple[1]<aNt)
- {
- if(tuple[0]>=0 && tuple[0]<thisNt)
- std::copy(valsSrc+nbOfComp*tuple[1],valsSrc+nbOfComp*(tuple[1]+1),valsToSet+nbOfComp*tuple[0]);
- else
+ for(int j=w[0];j<w[1];j++,srcPt+=nbCompo)
{
- std::ostringstream oss; oss << "DataArrayDouble::setPartOfValuesAdv : Tuple #" << std::distance(tuplesSelec->begin(),tuple)/2;
- oss << " of 'tuplesSelec' request of tuple id #" << tuple[0] << " in 'this' ! It should be in [0," << thisNt << ") !";
- throw INTERP_KERNEL::Exception(oss.str().c_str());
+ if(j>=0 && j<nbOfTuples)
+ std::transform(srcPt,srcPt+nbCompo,tmp,tmp,std::plus<double>());
+ else
+ {
+ std::ostringstream oss; oss << "DataArrayDouble::accumulatePerChunck : At rank #" << i << " the input index array points to id " << j << " should be in [0," << nbOfTuples << ") !";
+ throw INTERP_KERNEL::Exception(oss.str().c_str());
+ }
}
}
else
{
- std::ostringstream oss; oss << "DataArrayDouble::setPartOfValuesAdv : Tuple #" << std::distance(tuplesSelec->begin(),tuple)/2;
- oss << " of 'tuplesSelec' request of tuple id #" << tuple[1] << " in 'a' ! It should be in [0," << aNt << ") !";
+ std::ostringstream oss; oss << "DataArrayDouble::accumulatePerChunck : At rank #" << i << " the input index array is not in ascendingly sorted.";
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
}
+ ret->copyStringInfoFrom(*this);
+ return ret.retn();
}
/*!
- * Copy some tuples from another DataArrayDouble (\a aBase) into contiguous tuples
- * of \a this array. Textual data is not copied. Both arrays must have equal number of
- * components.
- * The tuples to assign to are defined by index of the first tuple, and
- * their number is defined by \a tuplesSelec->getNumberOfTuples().
- * The tuples to copy are defined by values of a DataArrayInt.
- * All components of selected tuples are copied.
- * \param [in] tupleIdStart - index of the first tuple of \a this array to assign
- * values to.
- * \param [in] aBase - the array to copy values from.
- * \param [in] tuplesSelec - the array specifying tuples of \a a to copy.
- * \throw If \a this is not allocated.
- * \throw If \a aBase is NULL.
- * \throw If \a aBase is not allocated.
- * \throw If \a tuplesSelec is NULL.
- * \throw If \a tuplesSelec is not allocated.
- * \throw If <em>this->getNumberOfComponents() != aBase->getNumberOfComponents()</em>.
- * \throw If \a tuplesSelec->getNumberOfComponents() != 1.
- * \throw If <em>tupleIdStart + tuplesSelec->getNumberOfTuples() > this->getNumberOfTuples().</em>
- * \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)
-{
- if(!aBase || !tuplesSelec)
- throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues : input DataArray is NULL !");
- const DataArrayDouble *a=dynamic_cast<const DataArrayDouble *>(aBase);
- if(!a)
- throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues : input DataArray aBase is not a DataArrayDouble !");
+ * Converts each 2D point defined by the tuple of \a this array from the Polar to the
+ * Cartesian coordinate system. The two components of the tuple of \a this array are
+ * considered to contain (1) radius and (2) angle of the point in the Polar CS.
+ * \return DataArrayDouble * - the new instance of DataArrayDouble, whose each tuple
+ * contains X and Y coordinates of the point in the Cartesian CS. The caller
+ * is to delete this array using decrRef() as it is no more needed. The array
+ * does not contain any textual info on components.
+ * \throw If \a this->getNumberOfComponents() != 2.
+ * \sa fromCartToPolar
+ */
+DataArrayDouble *DataArrayDouble::fromPolarToCart() const
+{
checkAllocated();
- a->checkAllocated();
- tuplesSelec->checkAllocated();
- int nbOfComp=getNumberOfComponents();
- if(nbOfComp!=a->getNumberOfComponents())
- throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues : This and a do not have the same number of components !");
- if(tuplesSelec->getNumberOfComponents()!=1)
- throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues : Expecting to have a tuple selector DataArrayInt instance with exactly 1 component !");
- int thisNt=getNumberOfTuples();
- int aNt=a->getNumberOfTuples();
- int nbOfTupleToWrite=tuplesSelec->getNumberOfTuples();
- double *valsToSet=getPointer()+tupleIdStart*nbOfComp;
- if(tupleIdStart+nbOfTupleToWrite>thisNt)
- throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues : invalid number range of values to write !");
- const double *valsSrc=a->getConstPointer();
- for(const int *tuple=tuplesSelec->begin();tuple!=tuplesSelec->end();tuple++,valsToSet+=nbOfComp)
- {
- if(*tuple>=0 && *tuple<aNt)
- {
- std::copy(valsSrc+nbOfComp*(*tuple),valsSrc+nbOfComp*(*tuple+1),valsToSet);
- }
- else
- {
- std::ostringstream oss; oss << "DataArrayDouble::setContigPartOfSelectedValues : Tuple #" << std::distance(tuplesSelec->begin(),tuple);
- oss << " of 'tuplesSelec' request of tuple id #" << *tuple << " in 'a' ! It should be in [0," << aNt << ") !";
- throw INTERP_KERNEL::Exception(oss.str().c_str());
- }
+ int nbOfComp(getNumberOfComponents());
+ if(nbOfComp!=2)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::fromPolarToCart : must be an array with exactly 2 components !");
+ int nbOfTuple(getNumberOfTuples());
+ DataArrayDouble *ret(DataArrayDouble::New());
+ ret->alloc(nbOfTuple,2);
+ double *w(ret->getPointer());
+ const double *wIn(getConstPointer());
+ for(int i=0;i<nbOfTuple;i++,w+=2,wIn+=2)
+ {
+ w[0]=wIn[0]*cos(wIn[1]);
+ w[1]=wIn[0]*sin(wIn[1]);
}
+ return ret;
}
/*!
- * Copy some tuples from another DataArrayDouble (\a aBase) into contiguous tuples
- * of \a this array. Textual data is not copied. Both arrays must have equal number of
- * components.
- * The tuples to copy are defined by three values similar to parameters of
- * the Python function \c range(\c start,\c stop,\c step).
- * The tuples to assign to are defined by index of the first tuple, and
- * their number is defined by number of tuples to copy.
- * All components of selected tuples are copied.
- * \param [in] tupleIdStart - index of the first tuple of \a this array to assign
- * values to.
- * \param [in] aBase - the array to copy values from.
- * \param [in] bg - index of the first tuple to copy of the array \a aBase.
- * \param [in] end2 - index of the tuple of \a aBase before which the tuples to copy
- * are located.
- * \param [in] step - index increment to get index of the next tuple to copy.
- * \throw If \a this is not allocated.
- * \throw If \a aBase is NULL.
- * \throw If \a aBase is not allocated.
- * \throw If <em>this->getNumberOfComponents() != aBase->getNumberOfComponents()</em>.
- * \throw If <em>tupleIdStart + len(range(bg,end2,step)) > this->getNumberOfTuples().</em>
- * \throw If parameters specifying tuples to copy, do not give a
- * non-empty range of increasing indices or indices are out of a valid range
- * for the array \a aBase.
+ * Converts each 3D point defined by the tuple of \a this array from the Cylindrical to
+ * the Cartesian coordinate system. The three components of the tuple of \a this array
+ * are considered to contain (1) radius, (2) azimuth and (3) altitude of the point in
+ * the Cylindrical CS.
+ * \return DataArrayDouble * - the new instance of DataArrayDouble, whose each tuple
+ * contains X, Y and Z coordinates of the point in the Cartesian CS. The info
+ * on the third component is copied from \a this array. The caller
+ * is to delete this array using decrRef() as it is no more needed.
+ * \throw If \a this->getNumberOfComponents() != 3.
+ * \sa fromCartToCyl
*/
-void DataArrayDouble::setContigPartOfSelectedValuesSlice(int tupleIdStart, const DataArray *aBase, int bg, int end2, int step)
+DataArrayDouble *DataArrayDouble::fromCylToCart() const
{
- if(!aBase)
- throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValuesSlice : input DataArray is NULL !");
- const DataArrayDouble *a=dynamic_cast<const DataArrayDouble *>(aBase);
- if(!a)
- throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValuesSlice : input DataArray aBase is not a DataArrayDouble !");
checkAllocated();
- a->checkAllocated();
- int nbOfComp=getNumberOfComponents();
- const char msg[]="DataArrayDouble::setContigPartOfSelectedValuesSlice";
- int nbOfTupleToWrite=DataArray::GetNumberOfItemGivenBES(bg,end2,step,msg);
- if(nbOfComp!=a->getNumberOfComponents())
- throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValuesSlice : This and a do not have the same number of components !");
- int thisNt=getNumberOfTuples();
- int aNt=a->getNumberOfTuples();
- double *valsToSet=getPointer()+tupleIdStart*nbOfComp;
- if(tupleIdStart+nbOfTupleToWrite>thisNt)
- throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValuesSlice : invalid number range of values to write !");
- if(end2>aNt)
- throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValuesSlice : invalid range of values to read !");
- const double *valsSrc=a->getConstPointer()+bg*nbOfComp;
- for(int i=0;i<nbOfTupleToWrite;i++,valsToSet+=nbOfComp,valsSrc+=step*nbOfComp)
- {
- std::copy(valsSrc,valsSrc+nbOfComp,valsToSet);
- }
-}
-
-/*!
- * Returns a value located at specified tuple and component.
- * This method is equivalent to DataArrayDouble::getIJ() except that validity of
- * parameters is checked. So this method is safe but expensive if used to go through
- * all values of \a this.
- * \param [in] tupleId - index of tuple of interest.
- * \param [in] compoId - index of component of interest.
- * \return double - value located by \a tupleId and \a compoId.
- * \throw If \a this is not allocated.
- * \throw If condition <em>( 0 <= tupleId < this->getNumberOfTuples() )</em> is violated.
- * \throw If condition <em>( 0 <= compoId < this->getNumberOfComponents() )</em> is violated.
+ int nbOfComp(getNumberOfComponents());
+ if(nbOfComp!=3)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::fromCylToCart : must be an array with exactly 3 components !");
+ int nbOfTuple(getNumberOfTuples());
+ DataArrayDouble *ret(DataArrayDouble::New());
+ ret->alloc(getNumberOfTuples(),3);
+ double *w(ret->getPointer());
+ const double *wIn(getConstPointer());
+ for(int i=0;i<nbOfTuple;i++,w+=3,wIn+=3)
+ {
+ w[0]=wIn[0]*cos(wIn[1]);
+ w[1]=wIn[0]*sin(wIn[1]);
+ w[2]=wIn[2];
+ }
+ ret->setInfoOnComponent(2,getInfoOnComponent(2));
+ return ret;
+}
+
+/*!
+ * Converts each 3D point defined by the tuple of \a this array from the Spherical to
+ * the Cartesian coordinate system. The three components of the tuple of \a this array
+ * are considered to contain (1) radius, (2) polar angle and (3) azimuthal angle of the
+ * point in the Cylindrical CS.
+ * \return DataArrayDouble * - the new instance of DataArrayDouble, whose each tuple
+ * contains X, Y and Z coordinates of the point in the Cartesian CS. The info
+ * on the third component is copied from \a this array. The caller
+ * is to delete this array using decrRef() as it is no more needed.
+ * \throw If \a this->getNumberOfComponents() != 3.
+ * \sa fromCartToSpher
*/
-double DataArrayDouble::getIJSafe(int tupleId, int compoId) const
+DataArrayDouble *DataArrayDouble::fromSpherToCart() const
{
checkAllocated();
- if(tupleId<0 || tupleId>=getNumberOfTuples())
- {
- std::ostringstream oss; oss << "DataArrayDouble::getIJSafe : request for tupleId " << tupleId << " should be in [0," << getNumberOfTuples() << ") !";
- throw INTERP_KERNEL::Exception(oss.str().c_str());
- }
- if(compoId<0 || compoId>=getNumberOfComponents())
+ int nbOfComp(getNumberOfComponents());
+ if(nbOfComp!=3)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::fromSpherToCart : must be an array with exactly 3 components !");
+ int nbOfTuple(getNumberOfTuples());
+ DataArrayDouble *ret(DataArrayDouble::New());
+ ret->alloc(getNumberOfTuples(),3);
+ double *w(ret->getPointer());
+ const double *wIn(getConstPointer());
+ for(int i=0;i<nbOfTuple;i++,w+=3,wIn+=3)
{
- std::ostringstream oss; oss << "DataArrayDouble::getIJSafe : request for compoId " << compoId << " should be in [0," << getNumberOfComponents() << ") !";
- throw INTERP_KERNEL::Exception(oss.str().c_str());
+ w[0]=wIn[0]*cos(wIn[2])*sin(wIn[1]);
+ w[1]=wIn[0]*sin(wIn[2])*sin(wIn[1]);
+ w[2]=wIn[0]*cos(wIn[1]);
}
- return _mem[tupleId*_info_on_compo.size()+compoId];
+ return ret;
}
/*!
- * Returns the first value of \a this.
- * \return double - the last value of \a this array.
- * \throw If \a this is not allocated.
- * \throw If \a this->getNumberOfComponents() != 1.
- * \throw If \a this->getNumberOfTuples() < 1.
+ * This method returns a new array containing the same number of tuples than \a this. To do this, this method needs \a at parameter to specify the convention of \a this.
+ * All the tuples of the returned array will be in cartesian sense. So if \a at equals to AX_CART the returned array is basically a deep copy of \a this.
+ * If \a at equals to AX_CYL the returned array will be the result of operation cylindric to cartesian of \a this...
+ *
+ * \param [in] atOfThis - The axis type of \a this.
+ * \return DataArrayDouble * - the new instance of DataArrayDouble (that must be dealed by caller) containing the result of the cartesianizification of \a this.
*/
-double DataArrayDouble::front() const
+DataArrayDouble *DataArrayDouble::cartesianize(MEDCouplingAxisType atOfThis) const
{
checkAllocated();
- if(getNumberOfComponents()!=1)
- throw INTERP_KERNEL::Exception("DataArrayDouble::front : number of components not equal to one !");
- int nbOfTuples=getNumberOfTuples();
- if(nbOfTuples<1)
- throw INTERP_KERNEL::Exception("DataArrayDouble::front : number of tuples must be >= 1 !");
- return *(getConstPointer());
+ int nbOfComp(getNumberOfComponents());
+ MCAuto<DataArrayDouble> ret;
+ switch(atOfThis)
+ {
+ case AX_CART:
+ ret=deepCopy();
+ case AX_CYL:
+ if(nbOfComp==3)
+ {
+ ret=fromCylToCart();
+ break;
+ }
+ if(nbOfComp==2)
+ {
+ ret=fromPolarToCart();
+ break;
+ }
+ else
+ throw INTERP_KERNEL::Exception("DataArrayDouble::cartesianize : For AX_CYL, number of components must be in [2,3] !");
+ case AX_SPHER:
+ if(nbOfComp==3)
+ {
+ ret=fromSpherToCart();
+ break;
+ }
+ if(nbOfComp==2)
+ {
+ ret=fromPolarToCart();
+ break;
+ }
+ else
+ throw INTERP_KERNEL::Exception("DataArrayDouble::cartesianize : For AX_CYL, number of components must be in [2,3] !");
+ default:
+ throw INTERP_KERNEL::Exception("DataArrayDouble::cartesianize : not recognized axis type ! Only AX_CART, AX_CYL and AX_SPHER supported !");
+ }
+ ret->copyStringInfoFrom(*this);
+ return ret.retn();
}
/*!
- * Returns the last value of \a this.
- * \return double - the last value of \a this array.
- * \throw If \a this is not allocated.
- * \throw If \a this->getNumberOfComponents() != 1.
- * \throw If \a this->getNumberOfTuples() < 1.
+ * This method returns a newly created array to be deallocated that contains the result of conversion from cartesian to polar.
+ * This method expects that \a this has exactly 2 components.
+ * \sa fromPolarToCart
*/
-double DataArrayDouble::back() const
+DataArrayDouble *DataArrayDouble::fromCartToPolar() const
{
+ MCAuto<DataArrayDouble> ret(DataArrayDouble::New());
checkAllocated();
- if(getNumberOfComponents()!=1)
- throw INTERP_KERNEL::Exception("DataArrayDouble::back : number of components not equal to one !");
- int nbOfTuples=getNumberOfTuples();
- if(nbOfTuples<1)
- throw INTERP_KERNEL::Exception("DataArrayDouble::back : number of tuples must be >= 1 !");
- return *(getConstPointer()+nbOfTuples-1);
+ int nbOfComp(getNumberOfComponents()),nbTuples(getNumberOfTuples());
+ if(nbOfComp!=2)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::fromCartToPolar : must be an array with exactly 2 components !");
+ ret->alloc(nbTuples,2);
+ double *retPtr(ret->getPointer());
+ const double *ptr(begin());
+ for(int i=0;i<nbTuples;i++,ptr+=2,retPtr+=2)
+ {
+ retPtr[0]=sqrt(ptr[0]*ptr[0]+ptr[1]*ptr[1]);
+ retPtr[1]=atan2(ptr[1],ptr[0]);
+ }
+ return ret.retn();
}
-void DataArrayDouble::SetArrayIn(DataArrayDouble *newArray, DataArrayDouble* &arrayToSet)
+/*!
+ * This method returns a newly created array to be deallocated that contains the result of conversion from cartesian to cylindrical.
+ * This method expects that \a this has exactly 3 components.
+ * \sa fromCylToCart
+ */
+DataArrayDouble *DataArrayDouble::fromCartToCyl() const
{
- if(newArray!=arrayToSet)
+ MCAuto<DataArrayDouble> ret(DataArrayDouble::New());
+ checkAllocated();
+ int nbOfComp(getNumberOfComponents()),nbTuples(getNumberOfTuples());
+ if(nbOfComp!=3)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::fromCartToCyl : must be an array with exactly 3 components !");
+ ret->alloc(nbTuples,3);
+ double *retPtr(ret->getPointer());
+ const double *ptr(begin());
+ for(int i=0;i<nbTuples;i++,ptr+=3,retPtr+=3)
{
- if(arrayToSet)
- arrayToSet->decrRef();
- arrayToSet=newArray;
- if(arrayToSet)
- arrayToSet->incrRef();
+ retPtr[0]=sqrt(ptr[0]*ptr[0]+ptr[1]*ptr[1]);
+ retPtr[1]=atan2(ptr[1],ptr[0]);
+ retPtr[2]=ptr[2];
}
+ return ret.retn();
}
/*!
- * Sets a C array to be used as raw data of \a this. The previously set info
- * of components is retained and re-sized.
- * For more info see \ref MEDCouplingArraySteps1.
- * \param [in] array - the C array to be used as raw data of \a this.
- * \param [in] ownership - if \a true, \a array will be deallocated at destruction of \a this.
- * \param [in] type - specifies how to deallocate \a array. If \a type == MEDCoupling::CPP_DEALLOC,
- * \c delete [] \c array; will be called. If \a type == MEDCoupling::C_DEALLOC,
- * \c free(\c array ) will be called.
- * \param [in] nbOfTuple - new number of tuples in \a this.
- * \param [in] nbOfCompo - new number of components in \a this.
+ * This method returns a newly created array to be deallocated that contains the result of conversion from cartesian to spherical coordinates.
+ * \sa fromSpherToCart
*/
-void DataArrayDouble::useArray(const double *array, bool ownership, DeallocType type, int nbOfTuple, int nbOfCompo)
+DataArrayDouble *DataArrayDouble::fromCartToSpher() const
{
- _info_on_compo.resize(nbOfCompo);
- _mem.useArray(array,ownership,type,(std::size_t)nbOfTuple*nbOfCompo);
- declareAsNew();
+ MCAuto<DataArrayDouble> ret(DataArrayDouble::New());
+ checkAllocated();
+ int nbOfComp(getNumberOfComponents()),nbTuples(getNumberOfTuples());
+ if(nbOfComp!=3)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::fromCartToSpher : must be an array with exactly 3 components !");
+ ret->alloc(nbTuples,3);
+ double *retPtr(ret->getPointer());
+ const double *ptr(begin());
+ for(int i=0;i<nbTuples;i++,ptr+=3,retPtr+=3)
+ {
+ retPtr[0]=sqrt(ptr[0]*ptr[0]+ptr[1]*ptr[1]+ptr[2]*ptr[2]);
+ retPtr[1]=acos(ptr[2]/retPtr[0]);
+ retPtr[2]=atan2(ptr[1],ptr[0]);
+ }
+ return ret.retn();
}
-void DataArrayDouble::useExternalArrayWithRWAccess(const double *array, int nbOfTuple, int nbOfCompo)
+/*!
+ * This method returns a newly created array to be deallocated that contains the result of conversion from cartesian to cylindrical relative to the given \a center and a \a vector.
+ * This method expects that \a this has exactly 3 components.
+ * \sa MEDCouplingFieldDouble::computeVectorFieldCyl
+ */
+DataArrayDouble *DataArrayDouble::fromCartToCylGiven(const DataArrayDouble *coords, const double center[3], const double vect[3]) const
{
- _info_on_compo.resize(nbOfCompo);
- _mem.useExternalArrayWithRWAccess(array,(std::size_t)nbOfTuple*nbOfCompo);
- declareAsNew();
+ if(!coords)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::fromCartToCylGiven : input coords are NULL !");
+ MCAuto<DataArrayDouble> ret(DataArrayDouble::New());
+ checkAllocated(); coords->checkAllocated();
+ int nbOfComp(getNumberOfComponents()),nbTuples(getNumberOfTuples());
+ if(nbOfComp!=3)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::fromCartToCylGiven : must be an array with exactly 3 components !");
+ if(coords->getNumberOfComponents()!=3)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::fromCartToCylGiven : coords array must have exactly 3 components !");
+ if(coords->getNumberOfTuples()!=nbTuples)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::fromCartToCylGiven : coords array must have the same number of tuples !");
+ ret->alloc(nbTuples,nbOfComp);
+ double magOfVect(sqrt(vect[0]*vect[0]+vect[1]*vect[1]+vect[2]*vect[2]));
+ if(magOfVect<1e-12)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::fromCartToCylGiven : magnitude of vect is too low !");
+ double Ur[3],Uteta[3],Uz[3],*retPtr(ret->getPointer());
+ const double *coo(coords->begin()),*vectField(begin());
+ std::transform(vect,vect+3,Uz,std::bind2nd(std::multiplies<double>(),1./magOfVect));
+ for(int i=0;i<nbTuples;i++,vectField+=3,retPtr+=3,coo+=3)
+ {
+ std::transform(coo,coo+3,center,Ur,std::minus<double>());
+ Uteta[0]=Uz[1]*Ur[2]-Uz[2]*Ur[1]; Uteta[1]=Uz[2]*Ur[0]-Uz[0]*Ur[2]; Uteta[2]=Uz[0]*Ur[1]-Uz[1]*Ur[0];
+ double magOfTeta(sqrt(Uteta[0]*Uteta[0]+Uteta[1]*Uteta[1]+Uteta[2]*Uteta[2]));
+ std::transform(Uteta,Uteta+3,Uteta,std::bind2nd(std::multiplies<double>(),1./magOfTeta));
+ Ur[0]=Uteta[1]*Uz[2]-Uteta[2]*Uz[1]; Ur[1]=Uteta[2]*Uz[0]-Uteta[0]*Uz[2]; Ur[2]=Uteta[0]*Uz[1]-Uteta[1]*Uz[0];
+ retPtr[0]=Ur[0]*vectField[0]+Ur[1]*vectField[1]+Ur[2]*vectField[2];
+ retPtr[1]=Uteta[0]*vectField[0]+Uteta[1]*vectField[1]+Uteta[2]*vectField[2];
+ retPtr[2]=Uz[0]*vectField[0]+Uz[1]*vectField[1]+Uz[2]*vectField[2];
+ }
+ ret->copyStringInfoFrom(*this);
+ return ret.retn();
}
/*!
- * Checks if 0.0 value is present in \a this array. If it is the case, an exception
- * is thrown.
- * \throw If zero is found in \a this array.
+ * Computes the doubly contracted product of every tensor defined by the tuple of \a this
+ * array contating 6 components.
+ * \return DataArrayDouble * - the new instance of DataArrayDouble, whose each tuple
+ * is calculated from the tuple <em>(t)</em> of \a this array as follows:
+ * \f$ t[0]^2+t[1]^2+t[2]^2+2*t[3]^2+2*t[4]^2+2*t[5]^2\f$.
+ * The caller is to delete this result array using decrRef() as it is no more needed.
+ * \throw If \a this->getNumberOfComponents() != 6.
*/
-void DataArrayDouble::checkNoNullValues() const
+DataArrayDouble *DataArrayDouble::doublyContractedProduct() const
{
- const double *tmp=getConstPointer();
- std::size_t nbOfElems=getNbOfElems();
- const double *where=std::find(tmp,tmp+nbOfElems,0.);
- if(where!=tmp+nbOfElems)
- throw INTERP_KERNEL::Exception("A value 0.0 have been detected !");
+ checkAllocated();
+ int nbOfComp(getNumberOfComponents());
+ if(nbOfComp!=6)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::doublyContractedProduct : must be an array with exactly 6 components !");
+ DataArrayDouble *ret=DataArrayDouble::New();
+ int nbOfTuple=getNumberOfTuples();
+ ret->alloc(nbOfTuple,1);
+ const double *src=getConstPointer();
+ double *dest=ret->getPointer();
+ for(int i=0;i<nbOfTuple;i++,dest++,src+=6)
+ *dest=src[0]*src[0]+src[1]*src[1]+src[2]*src[2]+2.*src[3]*src[3]+2.*src[4]*src[4]+2.*src[5]*src[5];
+ return ret;
}
/*!
- * Computes minimal and maximal value in each component. An output array is filled
- * with \c 2 * \a this->getNumberOfComponents() values, so the caller is to allocate
- * enough memory before calling this method.
- * \param [out] bounds - array of size at least 2 *\a this->getNumberOfComponents().
- * It is filled as follows:<br>
- * \a bounds[0] = \c min_of_component_0 <br>
- * \a bounds[1] = \c max_of_component_0 <br>
- * \a bounds[2] = \c min_of_component_1 <br>
- * \a bounds[3] = \c max_of_component_1 <br>
- * ...
+ * Computes the determinant of every square matrix defined by the tuple of \a this
+ * array, which contains either 4, 6 or 9 components. The case of 6 components
+ * corresponds to that of the upper triangular matrix.
+ * \return DataArrayDouble * - the new instance of DataArrayDouble, whose each tuple
+ * is the determinant of matrix of the corresponding tuple of \a this array.
+ * The caller is to delete this result array using decrRef() as it is no more
+ * needed.
+ * \throw If \a this->getNumberOfComponents() is not in [4,6,9].
*/
-void DataArrayDouble::getMinMaxPerComponent(double *bounds) const
+DataArrayDouble *DataArrayDouble::determinant() const
{
checkAllocated();
- int dim=getNumberOfComponents();
- for (int idim=0; idim<dim; idim++)
- {
- bounds[idim*2]=std::numeric_limits<double>::max();
- bounds[idim*2+1]=-std::numeric_limits<double>::max();
- }
- const double *ptr=getConstPointer();
- int nbOfTuples=getNumberOfTuples();
- for(int i=0;i<nbOfTuples;i++)
- {
- for(int idim=0;idim<dim;idim++)
- {
- if(bounds[idim*2]>ptr[i*dim+idim])
- {
- bounds[idim*2]=ptr[i*dim+idim];
- }
- if(bounds[idim*2+1]<ptr[i*dim+idim])
- {
- bounds[idim*2+1]=ptr[i*dim+idim];
- }
- }
- }
+ DataArrayDouble *ret=DataArrayDouble::New();
+ int nbOfTuple=getNumberOfTuples();
+ ret->alloc(nbOfTuple,1);
+ const double *src=getConstPointer();
+ double *dest=ret->getPointer();
+ switch(getNumberOfComponents())
+ {
+ case 6:
+ for(int i=0;i<nbOfTuple;i++,dest++,src+=6)
+ *dest=src[0]*src[1]*src[2]+2.*src[4]*src[5]*src[3]-src[0]*src[4]*src[4]-src[2]*src[3]*src[3]-src[1]*src[5]*src[5];
+ return ret;
+ case 4:
+ for(int i=0;i<nbOfTuple;i++,dest++,src+=4)
+ *dest=src[0]*src[3]-src[1]*src[2];
+ return ret;
+ case 9:
+ for(int i=0;i<nbOfTuple;i++,dest++,src+=9)
+ *dest=src[0]*src[4]*src[8]+src[1]*src[5]*src[6]+src[2]*src[3]*src[7]-src[0]*src[5]*src[7]-src[1]*src[3]*src[8]-src[2]*src[4]*src[6];
+ return ret;
+ default:
+ ret->decrRef();
+ throw INTERP_KERNEL::Exception("DataArrayDouble::determinant : Invalid number of components ! must be in 4,6,9 !");
+ }
}
/*!
- * This method retrieves a newly allocated DataArrayDouble instance having same number of tuples than \a this and twice number of components than \a this
- * to store both the min and max per component of each tuples.
- * \param [in] epsilon the width of the bbox (identical in each direction) - 0.0 by default
- *
- * \return a newly created DataArrayDouble instance having \c this->getNumberOfTuples() tuples and 2 * \c this->getNumberOfComponent() components
- *
- * \throw If \a this is not allocated yet.
+ * Computes 3 eigenvalues of every upper triangular matrix defined by the tuple of
+ * \a this array, which contains 6 components.
+ * \return DataArrayDouble * - the new instance of DataArrayDouble containing 3
+ * components, whose each tuple contains the eigenvalues of the matrix of
+ * corresponding tuple of \a this array.
+ * The caller is to delete this result array using decrRef() as it is no more
+ * needed.
+ * \throw If \a this->getNumberOfComponents() != 6.
*/
-DataArrayDouble *DataArrayDouble::computeBBoxPerTuple(double epsilon) const
+DataArrayDouble *DataArrayDouble::eigenValues() const
{
checkAllocated();
- const double *dataPtr=getConstPointer();
- int nbOfCompo=getNumberOfComponents();
- int nbTuples=getNumberOfTuples();
- MCAuto<DataArrayDouble> bbox=DataArrayDouble::New();
- bbox->alloc(nbTuples,2*nbOfCompo);
- double *bboxPtr=bbox->getPointer();
- for(int i=0;i<nbTuples;i++)
+ int nbOfComp=getNumberOfComponents();
+ if(nbOfComp!=6)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::eigenValues : must be an array with exactly 6 components !");
+ DataArrayDouble *ret=DataArrayDouble::New();
+ int nbOfTuple=getNumberOfTuples();
+ ret->alloc(nbOfTuple,3);
+ const double *src=getConstPointer();
+ double *dest=ret->getPointer();
+ for(int i=0;i<nbOfTuple;i++,dest+=3,src+=6)
+ INTERP_KERNEL::computeEigenValues6(src,dest);
+ return ret;
+}
+
+/*!
+ * Computes 3 eigenvectors of every upper triangular matrix defined by the tuple of
+ * \a this array, which contains 6 components.
+ * \return DataArrayDouble * - the new instance of DataArrayDouble containing 9
+ * components, whose each tuple contains 3 eigenvectors of the matrix of
+ * corresponding tuple of \a this array.
+ * The caller is to delete this result array using decrRef() as it is no more
+ * needed.
+ * \throw If \a this->getNumberOfComponents() != 6.
+ */
+DataArrayDouble *DataArrayDouble::eigenVectors() const
+{
+ checkAllocated();
+ int nbOfComp=getNumberOfComponents();
+ if(nbOfComp!=6)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::eigenVectors : must be an array with exactly 6 components !");
+ DataArrayDouble *ret=DataArrayDouble::New();
+ int nbOfTuple=getNumberOfTuples();
+ ret->alloc(nbOfTuple,9);
+ const double *src=getConstPointer();
+ double *dest=ret->getPointer();
+ for(int i=0;i<nbOfTuple;i++,src+=6)
{
- for(int j=0;j<nbOfCompo;j++)
- {
- bboxPtr[2*nbOfCompo*i+2*j]=dataPtr[nbOfCompo*i+j]-epsilon;
- bboxPtr[2*nbOfCompo*i+2*j+1]=dataPtr[nbOfCompo*i+j]+epsilon;
- }
+ double tmp[3];
+ INTERP_KERNEL::computeEigenValues6(src,tmp);
+ for(int j=0;j<3;j++,dest+=3)
+ INTERP_KERNEL::computeEigenVectorForEigenValue6(src,tmp[j],1e-12,dest);
}
- return bbox.retn();
+ return ret;
}
/*!
- * For each tuples **t** in \a other, this method retrieves tuples in \a this that are equal to **t**.
- * Two tuples are considered equal if the euclidian distance between the two tuples is lower than \a eps.
- *
- * \param [in] other a DataArrayDouble having same number of components than \a this.
- * \param [in] eps absolute precision representing distance (using infinite norm) between 2 tuples behind which 2 tuples are considered equal.
- * \param [out] c will contain the set of tuple ids in \a this that are equal to to the tuple ids in \a other contiguously.
- * \a cI allows to extract information in \a c.
- * \param [out] cI is an indirection array that allows to extract the data contained in \a c.
- *
- * \throw In case of:
- * - \a this is not allocated
- * - \a other is not allocated or null
- * - \a this and \a other do not have the same number of components
- * - if number of components of \a this is not in [1,2,3]
- *
- * \sa MEDCouplingPointSet::getNodeIdsNearPoints, DataArrayDouble::getDifferentValues
+ * Computes the inverse matrix of every matrix defined by the tuple of \a this
+ * array, which contains either 4, 6 or 9 components. The case of 6 components
+ * corresponds to that of the upper triangular matrix.
+ * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
+ * same number of components as \a this one, whose each tuple is the inverse
+ * matrix of the matrix of corresponding tuple of \a this array.
+ * The caller is to delete this result array using decrRef() as it is no more
+ * needed.
+ * \throw If \a this->getNumberOfComponents() is not in [4,6,9].
*/
-void DataArrayDouble::computeTupleIdsNearTuples(const DataArrayDouble *other, double eps, DataArrayInt *& c, DataArrayInt *& cI) const
+DataArrayDouble *DataArrayDouble::inverse() const
{
- if(!other)
- throw INTERP_KERNEL::Exception("DataArrayDouble::computeTupleIdsNearTuples : input pointer other is null !");
checkAllocated();
- other->checkAllocated();
- int nbOfCompo=getNumberOfComponents();
- int otherNbOfCompo=other->getNumberOfComponents();
- if(nbOfCompo!=otherNbOfCompo)
- throw INTERP_KERNEL::Exception("DataArrayDouble::computeTupleIdsNearTuples : number of components should be equal between this and other !");
- int nbOfTuplesOther=other->getNumberOfTuples();
- MCAuto<DataArrayInt> cArr(DataArrayInt::New()),cIArr(DataArrayInt::New()); cArr->alloc(0,1); cIArr->pushBackSilent(0);
- switch(nbOfCompo)
- {
- case 3:
+ int nbOfComp=getNumberOfComponents();
+ if(nbOfComp!=6 && nbOfComp!=9 && nbOfComp!=4)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::inversion : must be an array with 4,6 or 9 components !");
+ DataArrayDouble *ret=DataArrayDouble::New();
+ int nbOfTuple=getNumberOfTuples();
+ ret->alloc(nbOfTuple,nbOfComp);
+ const double *src=getConstPointer();
+ double *dest=ret->getPointer();
+ if(nbOfComp==6)
+ for(int i=0;i<nbOfTuple;i++,dest+=6,src+=6)
{
- BBTreePts<3,int> myTree(begin(),0,0,getNumberOfTuples(),eps);
- FindTupleIdsNearTuplesAlg<3>(myTree,other->getConstPointer(),nbOfTuplesOther,eps,cArr,cIArr);
- break;
+ double det=src[0]*src[1]*src[2]+2.*src[4]*src[5]*src[3]-src[0]*src[4]*src[4]-src[2]*src[3]*src[3]-src[1]*src[5]*src[5];
+ dest[0]=(src[1]*src[2]-src[4]*src[4])/det;
+ dest[1]=(src[0]*src[2]-src[5]*src[5])/det;
+ dest[2]=(src[0]*src[1]-src[3]*src[3])/det;
+ dest[3]=(src[5]*src[4]-src[3]*src[2])/det;
+ dest[4]=(src[5]*src[3]-src[0]*src[4])/det;
+ dest[5]=(src[3]*src[4]-src[1]*src[5])/det;
}
- case 2:
+ else if(nbOfComp==4)
+ for(int i=0;i<nbOfTuple;i++,dest+=4,src+=4)
{
- BBTreePts<2,int> myTree(begin(),0,0,getNumberOfTuples(),eps);
- FindTupleIdsNearTuplesAlg<2>(myTree,other->getConstPointer(),nbOfTuplesOther,eps,cArr,cIArr);
- break;
+ double det=src[0]*src[3]-src[1]*src[2];
+ dest[0]=src[3]/det;
+ dest[1]=-src[1]/det;
+ dest[2]=-src[2]/det;
+ dest[3]=src[0]/det;
}
- case 1:
+ else
+ for(int i=0;i<nbOfTuple;i++,dest+=9,src+=9)
{
- BBTreePts<1,int> myTree(begin(),0,0,getNumberOfTuples(),eps);
- FindTupleIdsNearTuplesAlg<1>(myTree,other->getConstPointer(),nbOfTuplesOther,eps,cArr,cIArr);
- break;
+ double det=src[0]*src[4]*src[8]+src[1]*src[5]*src[6]+src[2]*src[3]*src[7]-src[0]*src[5]*src[7]-src[1]*src[3]*src[8]-src[2]*src[4]*src[6];
+ dest[0]=(src[4]*src[8]-src[7]*src[5])/det;
+ dest[1]=(src[7]*src[2]-src[1]*src[8])/det;
+ dest[2]=(src[1]*src[5]-src[4]*src[2])/det;
+ dest[3]=(src[6]*src[5]-src[3]*src[8])/det;
+ dest[4]=(src[0]*src[8]-src[6]*src[2])/det;
+ dest[5]=(src[2]*src[3]-src[0]*src[5])/det;
+ dest[6]=(src[3]*src[7]-src[6]*src[4])/det;
+ dest[7]=(src[6]*src[1]-src[0]*src[7])/det;
+ dest[8]=(src[0]*src[4]-src[1]*src[3])/det;
}
- default:
- throw INTERP_KERNEL::Exception("Unexpected spacedim of coords for computeTupleIdsNearTuples. Must be 1, 2 or 3.");
- }
- c=cArr.retn(); cI=cIArr.retn();
+ return ret;
}
/*!
- * This method recenter tuples in \b this in order to be centered at the origin to benefit about the advantages of maximal precision to be around the box
- * around origin of 'radius' 1.
- *
- * \param [in] eps absolute epsilon. under that value of delta between max and min no scale is performed.
+ * Computes the trace of every matrix defined by the tuple of \a this
+ * array, which contains either 4, 6 or 9 components. The case of 6 components
+ * corresponds to that of the upper triangular matrix.
+ * \return DataArrayDouble * - the new instance of DataArrayDouble containing
+ * 1 component, whose each tuple is the trace of
+ * the matrix of corresponding tuple of \a this array.
+ * The caller is to delete this result array using decrRef() as it is no more
+ * needed.
+ * \throw If \a this->getNumberOfComponents() is not in [4,6,9].
*/
-void DataArrayDouble::recenterForMaxPrecision(double eps)
+DataArrayDouble *DataArrayDouble::trace() const
{
checkAllocated();
- int dim=getNumberOfComponents();
- std::vector<double> bounds(2*dim);
- getMinMaxPerComponent(&bounds[0]);
- for(int i=0;i<dim;i++)
- {
- double delta=bounds[2*i+1]-bounds[2*i];
- double offset=(bounds[2*i]+bounds[2*i+1])/2.;
- if(delta>eps)
- applyLin(1./delta,-offset/delta,i);
- else
- applyLin(1.,-offset,i);
- }
+ int nbOfComp=getNumberOfComponents();
+ if(nbOfComp!=6 && nbOfComp!=9 && nbOfComp!=4)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::trace : must be an array with 4,6 or 9 components !");
+ DataArrayDouble *ret=DataArrayDouble::New();
+ int nbOfTuple=getNumberOfTuples();
+ ret->alloc(nbOfTuple,1);
+ const double *src=getConstPointer();
+ double *dest=ret->getPointer();
+ if(nbOfComp==6)
+ for(int i=0;i<nbOfTuple;i++,dest++,src+=6)
+ *dest=src[0]+src[1]+src[2];
+ else if(nbOfComp==4)
+ for(int i=0;i<nbOfTuple;i++,dest++,src+=4)
+ *dest=src[0]+src[3];
+ else
+ for(int i=0;i<nbOfTuple;i++,dest++,src+=9)
+ *dest=src[0]+src[4]+src[8];
+ return ret;
}
/*!
- * Returns the maximal value and its location within \a this one-dimensional array.
- * \param [out] tupleId - index of the tuple holding the maximal value.
- * \return double - the maximal value among all values of \a this array.
- * \throw If \a this->getNumberOfComponents() != 1
- * \throw If \a this->getNumberOfTuples() < 1
- */
-double DataArrayDouble::getMaxValue(int& tupleId) const
-{
- checkAllocated();
- if(getNumberOfComponents()!=1)
- throw INTERP_KERNEL::Exception("DataArrayDouble::getMaxValue : must be applied on DataArrayDouble with only one component, you can call 'rearrange' method before or call 'getMaxValueInArray' method !");
- int nbOfTuples=getNumberOfTuples();
- if(nbOfTuples<=0)
- throw INTERP_KERNEL::Exception("DataArrayDouble::getMaxValue : array exists but number of tuples must be > 0 !");
- const double *vals=getConstPointer();
- const double *loc=std::max_element(vals,vals+nbOfTuples);
- tupleId=(int)std::distance(vals,loc);
- return *loc;
-}
-
-/*!
- * Returns the maximal value within \a this array that is allowed to have more than
- * one component.
- * \return double - the maximal value among all values of \a this array.
- * \throw If \a this is not allocated.
+ * Computes the stress deviator tensor of every stress tensor defined by the tuple of
+ * \a this array, which contains 6 components.
+ * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
+ * same number of components and 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->getNumberOfComponents() != 6.
*/
-double DataArrayDouble::getMaxValueInArray() const
+DataArrayDouble *DataArrayDouble::deviator() const
{
checkAllocated();
- const double *loc=std::max_element(begin(),end());
- return *loc;
+ int nbOfComp=getNumberOfComponents();
+ if(nbOfComp!=6)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::deviator : must be an array with exactly 6 components !");
+ DataArrayDouble *ret=DataArrayDouble::New();
+ int nbOfTuple=getNumberOfTuples();
+ ret->alloc(nbOfTuple,6);
+ const double *src=getConstPointer();
+ double *dest=ret->getPointer();
+ for(int i=0;i<nbOfTuple;i++,dest+=6,src+=6)
+ {
+ double tr=(src[0]+src[1]+src[2])/3.;
+ dest[0]=src[0]-tr;
+ dest[1]=src[1]-tr;
+ dest[2]=src[2]-tr;
+ dest[3]=src[3];
+ dest[4]=src[4];
+ dest[5]=src[5];
+ }
+ return ret;
}
/*!
- * Returns the maximal value and all its locations within \a this one-dimensional array.
- * \param [out] tupleIds - a new instance of DataArrayInt containg indices of
- * tuples holding the maximal value. The caller is to delete it using
- * decrRef() as it is no more needed.
- * \return double - the maximal value among all values of \a this array.
- * \throw If \a this->getNumberOfComponents() != 1
- * \throw If \a this->getNumberOfTuples() < 1
+ * Computes the magnitude of every vector defined by the tuple of
+ * \a this array.
+ * \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.
*/
-double DataArrayDouble::getMaxValue2(DataArrayInt*& tupleIds) const
+DataArrayDouble *DataArrayDouble::magnitude() const
{
- int tmp;
- tupleIds=0;
- double ret=getMaxValue(tmp);
- tupleIds=findIdsInRange(ret,ret);
+ checkAllocated();
+ int nbOfComp=getNumberOfComponents();
+ DataArrayDouble *ret=DataArrayDouble::New();
+ int nbOfTuple=getNumberOfTuples();
+ ret->alloc(nbOfTuple,1);
+ const double *src=getConstPointer();
+ double *dest=ret->getPointer();
+ for(int i=0;i<nbOfTuple;i++,dest++)
+ {
+ double sum=0.;
+ for(int j=0;j<nbOfComp;j++,src++)
+ sum+=(*src)*(*src);
+ *dest=sqrt(sum);
+ }
return ret;
}
/*!
- * Returns the minimal value and its location within \a this one-dimensional array.
- * \param [out] tupleId - index of the tuple holding the minimal value.
- * \return double - the minimal value among all values of \a this array.
- * \throw If \a this->getNumberOfComponents() != 1
- * \throw If \a this->getNumberOfTuples() < 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.
*/
-double DataArrayDouble::getMinValue(int& tupleId) const
+DataArrayDouble *DataArrayDouble::sumPerTuple() const
{
checkAllocated();
- if(getNumberOfComponents()!=1)
- throw INTERP_KERNEL::Exception("DataArrayDouble::getMinValue : must be applied on DataArrayDouble with only one component, you can call 'rearrange' method before call 'getMinValueInArray' method !");
- int nbOfTuples=getNumberOfTuples();
- if(nbOfTuples<=0)
- throw INTERP_KERNEL::Exception("DataArrayDouble::getMinValue : array exists but number of tuples must be > 0 !");
- const double *vals=getConstPointer();
- const double *loc=std::min_element(vals,vals+nbOfTuples);
- tupleId=(int)std::distance(vals,loc);
- return *loc;
+ int nbOfComp(getNumberOfComponents()),nbOfTuple(getNumberOfTuples());
+ MCAuto<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();
}
/*!
- * Returns the minimal value within \a this array that is allowed to have more than
- * one component.
- * \return double - the minimal value among all values of \a this array.
+ * Computes the maximal value within every tuple of \a this array.
+ * \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.
+ * \sa DataArrayDouble::maxPerTupleWithCompoId
*/
-double DataArrayDouble::getMinValueInArray() const
+DataArrayDouble *DataArrayDouble::maxPerTuple() const
{
checkAllocated();
- const double *loc=std::min_element(begin(),end());
- return *loc;
+ int nbOfComp=getNumberOfComponents();
+ MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
+ int nbOfTuple=getNumberOfTuples();
+ ret->alloc(nbOfTuple,1);
+ const double *src=getConstPointer();
+ double *dest=ret->getPointer();
+ for(int i=0;i<nbOfTuple;i++,dest++,src+=nbOfComp)
+ *dest=*std::max_element(src,src+nbOfComp);
+ return ret.retn();
}
/*!
- * Returns the minimal value and all its locations within \a this one-dimensional array.
- * \param [out] tupleIds - a new instance of DataArrayInt containg indices of
- * tuples holding the minimal value. The caller is to delete it using
- * decrRef() as it is no more needed.
- * \return double - the minimal value among all values of \a this array.
- * \throw If \a this->getNumberOfComponents() != 1
- * \throw If \a this->getNumberOfTuples() < 1
+ * Computes the maximal value within every tuple of \a this array and it returns the first component
+ * id for each tuple that corresponds to the maximal value within the tuple.
+ *
+ * \param [out] compoIdOfMaxPerTuple - the new new instance of DataArrayInt containing the
+ * same number of tuples and only one component.
+ * \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.
+ * \sa DataArrayDouble::maxPerTuple
*/
-double DataArrayDouble::getMinValue2(DataArrayInt*& tupleIds) const
+DataArrayDouble *DataArrayDouble::maxPerTupleWithCompoId(DataArrayInt* &compoIdOfMaxPerTuple) const
{
- int tmp;
- tupleIds=0;
- double ret=getMinValue(tmp);
- tupleIds=findIdsInRange(ret,ret);
- return ret;
+ checkAllocated();
+ int nbOfComp=getNumberOfComponents();
+ MCAuto<DataArrayDouble> ret0=DataArrayDouble::New();
+ MCAuto<DataArrayInt> ret1=DataArrayInt::New();
+ int nbOfTuple=getNumberOfTuples();
+ ret0->alloc(nbOfTuple,1); ret1->alloc(nbOfTuple,1);
+ const double *src=getConstPointer();
+ double *dest=ret0->getPointer(); int *dest1=ret1->getPointer();
+ for(int i=0;i<nbOfTuple;i++,dest++,dest1++,src+=nbOfComp)
+ {
+ const double *loc=std::max_element(src,src+nbOfComp);
+ *dest=*loc;
+ *dest1=(int)std::distance(src,loc);
+ }
+ compoIdOfMaxPerTuple=ret1.retn();
+ return ret0.retn();
}
/*!
- * This method returns the number of values in \a this that are equals ( within an absolute precision of \a eps ) to input parameter \a value.
- * This method only works for single component array.
+ * This method returns a newly allocated DataArrayDouble instance having one component and \c this->getNumberOfTuples() * \c this->getNumberOfTuples() tuples.
+ * \n This returned array contains the euclidian distance for each tuple in \a this.
+ * \n So the returned array can be seen as a dense symmetrical matrix whose diagonal elements are equal to 0.
+ * \n The returned array has only one component (and **not** \c this->getNumberOfTuples() components to avoid the useless memory consumption due to components info in returned DataArrayDouble)
*
- * \return a value in [ 0, \c this->getNumberOfTuples() )
+ * \warning use this method with care because it can leads to big amount of consumed memory !
+ *
+ * \return A newly allocated (huge) MEDCoupling::DataArrayDouble instance that the caller should deal with.
*
- * \throw If \a this is not allocated
+ * \throw If \a this is not allocated.
*
+ * \sa DataArrayDouble::buildEuclidianDistanceDenseMatrixWith
*/
-int DataArrayDouble::count(double value, double eps) const
+DataArrayDouble *DataArrayDouble::buildEuclidianDistanceDenseMatrix() const
{
- int ret=0;
checkAllocated();
- if(getNumberOfComponents()!=1)
- throw INTERP_KERNEL::Exception("DataArrayDouble::count : must be applied on DataArrayDouble with only one component, you can call 'rearrange' method before !");
- const double *vals=begin();
+ int nbOfComp=getNumberOfComponents();
int nbOfTuples=getNumberOfTuples();
- for(int i=0;i<nbOfTuples;i++,vals++)
- if(fabs(*vals-value)<=eps)
- ret++;
- return ret;
+ const double *inData=getConstPointer();
+ MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
+ ret->alloc(nbOfTuples*nbOfTuples,1);
+ double *outData=ret->getPointer();
+ for(int i=0;i<nbOfTuples;i++)
+ {
+ outData[i*nbOfTuples+i]=0.;
+ for(int j=i+1;j<nbOfTuples;j++)
+ {
+ double dist=0.;
+ for(int k=0;k<nbOfComp;k++)
+ { double delta=inData[i*nbOfComp+k]-inData[j*nbOfComp+k]; dist+=delta*delta; }
+ dist=sqrt(dist);
+ outData[i*nbOfTuples+j]=dist;
+ outData[j*nbOfTuples+i]=dist;
+ }
+ }
+ return ret.retn();
}
/*!
- * Returns the average value of \a this one-dimensional array.
- * \return double - the average value over all values of \a this array.
- * \throw If \a this->getNumberOfComponents() != 1
- * \throw If \a this->getNumberOfTuples() < 1
+ * This method returns a newly allocated DataArrayDouble instance having one component and \c this->getNumberOfTuples() * \c other->getNumberOfTuples() tuples.
+ * \n This returned array contains the euclidian distance for each tuple in \a other with each tuple in \a this.
+ * \n So the returned array can be seen as a dense rectangular matrix with \c other->getNumberOfTuples() rows and \c this->getNumberOfTuples() columns.
+ * \n Output rectangular matrix is sorted along rows.
+ * \n The returned array has only one component (and **not** \c this->getNumberOfTuples() components to avoid the useless memory consumption due to components info in returned DataArrayDouble)
+ *
+ * \warning use this method with care because it can leads to big amount of consumed memory !
+ *
+ * \param [in] other DataArrayDouble instance having same number of components than \a this.
+ * \return A newly allocated (huge) MEDCoupling::DataArrayDouble instance that the caller should deal with.
+ *
+ * \throw If \a this is not allocated, or if \a other is null or if \a other is not allocated, or if number of components of \a other and \a this differs.
+ *
+ * \sa DataArrayDouble::buildEuclidianDistanceDenseMatrix
*/
-double DataArrayDouble::getAverageValue() const
+DataArrayDouble *DataArrayDouble::buildEuclidianDistanceDenseMatrixWith(const DataArrayDouble *other) 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 !");
+ if(!other)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::buildEuclidianDistanceDenseMatrixWith : input parameter is null !");
+ checkAllocated();
+ other->checkAllocated();
+ int nbOfComp=getNumberOfComponents();
+ int otherNbOfComp=other->getNumberOfComponents();
+ if(nbOfComp!=otherNbOfComp)
+ {
+ std::ostringstream oss; oss << "DataArrayDouble::buildEuclidianDistanceDenseMatrixWith : this nb of compo=" << nbOfComp << " and other nb of compo=" << otherNbOfComp << ". It should match !";
+ throw INTERP_KERNEL::Exception(oss.str().c_str());
+ }
int nbOfTuples=getNumberOfTuples();
- if(nbOfTuples<=0)
- throw INTERP_KERNEL::Exception("DataArrayDouble::getAverageValue : array exists but number of tuples must be > 0 !");
- const double *vals=getConstPointer();
- double ret=std::accumulate(vals,vals+nbOfTuples,0.);
- return ret/nbOfTuples;
+ int otherNbOfTuples=other->getNumberOfTuples();
+ const double *inData=getConstPointer();
+ const double *inDataOther=other->getConstPointer();
+ MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
+ ret->alloc(otherNbOfTuples*nbOfTuples,1);
+ double *outData=ret->getPointer();
+ for(int i=0;i<otherNbOfTuples;i++,inDataOther+=nbOfComp)
+ {
+ for(int j=0;j<nbOfTuples;j++)
+ {
+ double dist=0.;
+ for(int k=0;k<nbOfComp;k++)
+ { double delta=inDataOther[k]-inData[j*nbOfComp+k]; dist+=delta*delta; }
+ dist=sqrt(dist);
+ outData[i*nbOfTuples+j]=dist;
+ }
+ }
+ return ret.retn();
}
/*!
- * Returns the Euclidean norm of the vector defined by \a this array.
- * \return double - the value of the Euclidean norm, i.e.
- * the square root of the inner product of vector.
+ * Sorts value within every tuple of \a this array.
+ * \param [in] asc - if \a true, the values are sorted in ascending order, else,
+ * in descending order.
* \throw If \a this is not allocated.
*/
-double DataArrayDouble::norm2() const
-{
- checkAllocated();
- double ret=0.;
- std::size_t nbOfElems=getNbOfElems();
- const double *pt=getConstPointer();
- for(std::size_t i=0;i<nbOfElems;i++,pt++)
- ret+=(*pt)*(*pt);
- return sqrt(ret);
-}
-
-/*!
- * 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 (whatever its number of components).
- * \throw If \a this is not allocated.
- */
-double DataArrayDouble::normMax() const
+void DataArrayDouble::sortPerTuple(bool asc)
{
checkAllocated();
- 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));
- if(val>ret)
- ret=val;
- }
- return ret;
+ double *pt=getPointer();
+ int nbOfTuple=getNumberOfTuples();
+ int nbOfComp=getNumberOfComponents();
+ if(asc)
+ for(int i=0;i<nbOfTuple;i++,pt+=nbOfComp)
+ std::sort(pt,pt+nbOfComp);
+ else
+ for(int i=0;i<nbOfTuple;i++,pt+=nbOfComp)
+ std::sort(pt,pt+nbOfComp,std::greater<double>());
+ declareAsNew();
}
/*!
- * 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.
+ * Converts every value of \a this array to its absolute value.
+ * \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
*/
-double DataArrayDouble::normMin() const
+void DataArrayDouble::abs()
{
checkAllocated();
- double ret(std::numeric_limits<double>::max());
+ double *ptr(getPointer());
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;
+ std::transform(ptr,ptr+nbOfElems,ptr,std::ptr_fun<double,double>(fabs));
+ declareAsNew();
}
/*!
- * Accumulates values of each component of \a this array.
- * \param [out] res - an array of length \a this->getNumberOfComponents(), allocated
- * by the caller, that is filled by this method with sum value for each
- * component.
- * \throw If \a this is not allocated.
+ * 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
*/
-void DataArrayDouble::accumulate(double *res) const
+DataArrayDouble *DataArrayDouble::computeAbs() const
{
checkAllocated();
- const double *ptr=getConstPointer();
- int nbTuple=getNumberOfTuples();
- int nbComps=getNumberOfComponents();
- std::fill(res,res+nbComps,0.);
- for(int i=0;i<nbTuple;i++)
- std::transform(ptr+i*nbComps,ptr+(i+1)*nbComps,res,res,std::plus<double>());
+ 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;
}
/*!
- * This method returns the min distance from an external tuple defined by [ \a tupleBg , \a tupleEnd ) to \a this and
- * the first tuple in \a this that matches the returned distance. If there is no tuples in \a this an exception will be thrown.
- *
- *
- * \a this is expected to be allocated and expected to have a number of components equal to the distance from \a tupleBg to
- * \a tupleEnd. If not an exception will be thrown.
- *
- * \param [in] tupleBg start pointer (included) of input external tuple
- * \param [in] tupleEnd end pointer (not included) of input external tuple
- * \param [out] tupleId the tuple id in \a this that matches the min of distance between \a this and input external tuple
- * \return the min distance.
- * \sa MEDCouplingUMesh::distanceToPoint
+ * 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, or \a compoId is not in [0,\c this->getNumberOfComponents() ).
*/
-double DataArrayDouble::distanceToTuple(const double *tupleBg, const double *tupleEnd, int& tupleId) const
+void DataArrayDouble::applyLin(double a, double b, int compoId)
{
checkAllocated();
- int nbTuple=getNumberOfTuples();
- int nbComps=getNumberOfComponents();
- if(nbComps!=(int)std::distance(tupleBg,tupleEnd))
- { std::ostringstream oss; oss << "DataArrayDouble::distanceToTuple : size of input tuple is " << std::distance(tupleBg,tupleEnd) << " should be equal to the number of components in this : " << nbComps << " !"; throw INTERP_KERNEL::Exception(oss.str().c_str()); }
- if(nbTuple==0)
- throw INTERP_KERNEL::Exception("DataArrayDouble::distanceToTuple : no tuple in this ! No distance to compute !");
- double ret0=std::numeric_limits<double>::max();
- tupleId=-1;
- const double *work=getConstPointer();
- for(int i=0;i<nbTuple;i++)
+ double *ptr(getPointer()+compoId);
+ int nbOfComp(getNumberOfComponents()),nbOfTuple(getNumberOfTuples());
+ if(compoId<0 || compoId>=nbOfComp)
{
- double val=0.;
- for(int j=0;j<nbComps;j++,work++)
- val+=(*work-tupleBg[j])*((*work-tupleBg[j]));
- if(val>=ret0)
- continue;
- else
- { ret0=val; tupleId=i; }
+ 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());
}
- return sqrt(ret0);
+ for(int i=0;i<nbOfTuple;i++,ptr+=nbOfComp)
+ *ptr=a*(*ptr)+b;
+ declareAsNew();
}
/*!
- * Accumulate values of the given component of \a this array.
- * \param [in] compId - the index of the component of interest.
- * \return double - a sum value of \a compId-th component.
+ * 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.
- * \throw If \a the condition ( 0 <= \a compId < \a this->getNumberOfComponents() ) is
- * not respected.
*/
-double DataArrayDouble::accumulate(int compId) const
+void DataArrayDouble::applyLin(double a, double b)
{
checkAllocated();
- const double *ptr=getConstPointer();
- int nbTuple=getNumberOfTuples();
- int nbComps=getNumberOfComponents();
- if(compId<0 || compId>=nbComps)
- throw INTERP_KERNEL::Exception("DataArrayDouble::accumulate : Invalid compId specified : No such nb of components !");
- double ret=0.;
- for(int i=0;i<nbTuple;i++)
- ret+=ptr[i*nbComps+compId];
- return ret;
+ double *ptr=getPointer();
+ std::size_t nbOfElems=getNbOfElems();
+ for(std::size_t i=0;i<nbOfElems;i++,ptr++)
+ *ptr=a*(*ptr)+b;
+ declareAsNew();
}
/*!
- * This method accumulate using addition tuples in \a this using input index array [ \a bgOfIndex, \a endOfIndex ).
- * The returned array will have same number of components than \a this and number of tuples equal to
- * \c std::distance(bgOfIndex,endOfIndex) \b minus \b one.
- *
- * The input index array is expected to be ascendingly sorted in which the all referenced ids should be in [0, \c this->getNumberOfTuples).
- * This method is quite useful for users that need to put a field on cells to field on nodes on the same mesh without a need of conservation.
- *
- * \param [in] bgOfIndex - begin (included) of the input index array.
- * \param [in] endOfIndex - end (excluded) of the input index array.
- * \return DataArrayDouble * - the new instance having the same number of components than \a this.
- *
- * \throw If bgOfIndex or end is NULL.
- * \throw If input index array is not ascendingly sorted.
- * \throw If there is an id in [ \a bgOfIndex, \a endOfIndex ) not in [0, \c this->getNumberOfTuples).
- * \throw If std::distance(bgOfIndex,endOfIndex)==0.
+ * Modify all elements of \a this array, so that
+ * an element _x_ becomes \f$ numerator / x \f$.
+ * \warning If an exception is thrown because of presence of 0.0 element in \a this
+ * array, all elements processed before detection of the zero element remain
+ * modified.
+ * \param [in] numerator - the numerator used to modify array elements.
+ * \throw If \a this is not allocated.
+ * \throw If there is an element equal to 0.0 in \a this array.
*/
-DataArrayDouble *DataArrayDouble::accumulatePerChunck(const int *bgOfIndex, const int *endOfIndex) const
+void DataArrayDouble::applyInv(double numerator)
{
- if(!bgOfIndex || !endOfIndex)
- throw INTERP_KERNEL::Exception("DataArrayDouble::accumulatePerChunck : input pointer NULL !");
checkAllocated();
- int nbCompo=getNumberOfComponents();
- int nbOfTuples=getNumberOfTuples();
- int sz=(int)std::distance(bgOfIndex,endOfIndex);
- if(sz<1)
- throw INTERP_KERNEL::Exception("DataArrayDouble::accumulatePerChunck : invalid size of input index array !");
- sz--;
- MCAuto<DataArrayDouble> ret=DataArrayDouble::New(); ret->alloc(sz,nbCompo);
- const int *w=bgOfIndex;
- if(*w<0 || *w>=nbOfTuples)
- throw INTERP_KERNEL::Exception("DataArrayDouble::accumulatePerChunck : The first element of the input index not in [0,nbOfTuples) !");
- const double *srcPt=begin()+(*w)*nbCompo;
- double *tmp=ret->getPointer();
- for(int i=0;i<sz;i++,tmp+=nbCompo,w++)
+ double *ptr=getPointer();
+ std::size_t nbOfElems=getNbOfElems();
+ for(std::size_t i=0;i<nbOfElems;i++,ptr++)
{
- std::fill(tmp,tmp+nbCompo,0.);
- if(w[1]>=w[0])
+ if(std::abs(*ptr)>std::numeric_limits<double>::min())
{
- for(int j=w[0];j<w[1];j++,srcPt+=nbCompo)
- {
- if(j>=0 && j<nbOfTuples)
- std::transform(srcPt,srcPt+nbCompo,tmp,tmp,std::plus<double>());
- else
- {
- std::ostringstream oss; oss << "DataArrayDouble::accumulatePerChunck : At rank #" << i << " the input index array points to id " << j << " should be in [0," << nbOfTuples << ") !";
- throw INTERP_KERNEL::Exception(oss.str().c_str());
- }
- }
+ *ptr=numerator/(*ptr);
}
else
{
- std::ostringstream oss; oss << "DataArrayDouble::accumulatePerChunck : At rank #" << i << " the input index array is not in ascendingly sorted.";
+ std::ostringstream oss; oss << "DataArrayDouble::applyInv : presence of null value in tuple #" << i/getNumberOfComponents() << " component #" << i%getNumberOfComponents();
+ oss << " !";
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
}
- ret->copyStringInfoFrom(*this);
- return ret.retn();
+ declareAsNew();
}
/*!
- * Converts each 2D point defined by the tuple of \a this array from the Polar to the
- * Cartesian coordinate system. The two components of the tuple of \a this array are
- * considered to contain (1) radius and (2) angle of the point in the Polar CS.
- * \return DataArrayDouble * - the new instance of DataArrayDouble, whose each tuple
- * contains X and Y coordinates of the point in the Cartesian CS. The caller
- * is to delete this array using decrRef() as it is no more needed. The array
- * does not contain any textual info on components.
- * \throw If \a this->getNumberOfComponents() != 2.
+ * Returns a full copy of \a this array except that sign of all elements is reversed.
+ * \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.
*/
-DataArrayDouble *DataArrayDouble::fromPolarToCart() const
+DataArrayDouble *DataArrayDouble::negate() const
{
checkAllocated();
- int nbOfComp(getNumberOfComponents());
- if(nbOfComp!=2)
- throw INTERP_KERNEL::Exception("DataArrayDouble::fromPolarToCart : must be an array with exactly 2 components !");
- int nbOfTuple(getNumberOfTuples());
- DataArrayDouble *ret(DataArrayDouble::New());
- ret->alloc(nbOfTuple,2);
- double *w(ret->getPointer());
- const double *wIn(getConstPointer());
- for(int i=0;i<nbOfTuple;i++,w+=2,wIn+=2)
- {
- w[0]=wIn[0]*cos(wIn[1]);
- w[1]=wIn[0]*sin(wIn[1]);
- }
- return ret;
+ DataArrayDouble *newArr=DataArrayDouble::New();
+ int nbOfTuples=getNumberOfTuples();
+ int nbOfComp=getNumberOfComponents();
+ newArr->alloc(nbOfTuples,nbOfComp);
+ const double *cptr=getConstPointer();
+ std::transform(cptr,cptr+nbOfTuples*nbOfComp,newArr->getPointer(),std::negate<double>());
+ newArr->copyStringInfoFrom(*this);
+ return newArr;
}
/*!
- * Converts each 3D point defined by the tuple of \a this array from the Cylindrical to
- * the Cartesian coordinate system. The three components of the tuple of \a this array
- * are considered to contain (1) radius, (2) azimuth and (3) altitude of the point in
- * the Cylindrical CS.
- * \return DataArrayDouble * - the new instance of DataArrayDouble, whose each tuple
- * contains X, Y and Z coordinates of the point in the Cartesian CS. The info
- * on the third component is copied from \a this array. The caller
- * is to delete this array using decrRef() as it is no more needed.
- * \throw If \a this->getNumberOfComponents() != 3.
+ * Modify all elements of \a this array, so that
+ * an element _x_ becomes <em> val ^ x </em>. Contrary to DataArrayInt::applyPow
+ * all values in \a this have to be >= 0 if val is \b not integer.
+ * \param [in] val - the value used to apply pow on all array elements.
+ * \throw If \a this is not allocated.
+ * \warning If an exception is thrown because of presence of 0 element in \a this
+ * array and \a val is \b not integer, all elements processed before detection of the zero element remain
+ * modified.
*/
-DataArrayDouble *DataArrayDouble::fromCylToCart() const
+void DataArrayDouble::applyPow(double val)
{
checkAllocated();
- int nbOfComp(getNumberOfComponents());
- if(nbOfComp!=3)
- throw INTERP_KERNEL::Exception("DataArrayDouble::fromCylToCart : must be an array with exactly 3 components !");
- int nbOfTuple(getNumberOfTuples());
- DataArrayDouble *ret(DataArrayDouble::New());
- ret->alloc(getNumberOfTuples(),3);
- double *w(ret->getPointer());
- const double *wIn(getConstPointer());
- for(int i=0;i<nbOfTuple;i++,w+=3,wIn+=3)
+ double *ptr=getPointer();
+ std::size_t nbOfElems=getNbOfElems();
+ int val2=(int)val;
+ bool isInt=((double)val2)==val;
+ if(!isInt)
{
- w[0]=wIn[0]*cos(wIn[1]);
- w[1]=wIn[0]*sin(wIn[1]);
- w[2]=wIn[2];
+ for(std::size_t i=0;i<nbOfElems;i++,ptr++)
+ {
+ if(*ptr>=0)
+ *ptr=pow(*ptr,val);
+ else
+ {
+ std::ostringstream oss; oss << "DataArrayDouble::applyPow (double) : At elem # " << i << " value is " << *ptr << " ! must be >=0. !";
+ throw INTERP_KERNEL::Exception(oss.str().c_str());
+ }
+ }
}
- ret->setInfoOnComponent(2,getInfoOnComponent(2));
- return ret;
+ else
+ {
+ for(std::size_t i=0;i<nbOfElems;i++,ptr++)
+ *ptr=pow(*ptr,val2);
+ }
+ declareAsNew();
}
/*!
- * Converts each 3D point defined by the tuple of \a this array from the Spherical to
- * the Cartesian coordinate system. The three components of the tuple of \a this array
- * are considered to contain (1) radius, (2) polar angle and (3) azimuthal angle of the
- * point in the Cylindrical CS.
- * \return DataArrayDouble * - the new instance of DataArrayDouble, whose each tuple
- * contains X, Y and Z coordinates of the point in the Cartesian CS. The info
- * on the third component is copied from \a this array. The caller
- * is to delete this array using decrRef() as it is no more needed.
- * \throw If \a this->getNumberOfComponents() != 3.
+ * Modify all elements of \a this array, so that
+ * an element _x_ becomes \f$ val ^ x \f$.
+ * \param [in] val - the value used to apply pow on all array elements.
+ * \throw If \a this is not allocated.
+ * \throw If \a val < 0.
+ * \warning If an exception is thrown because of presence of 0 element in \a this
+ * array, all elements processed before detection of the zero element remain
+ * modified.
*/
-DataArrayDouble *DataArrayDouble::fromSpherToCart() const
+void DataArrayDouble::applyRPow(double val)
{
checkAllocated();
- int nbOfComp(getNumberOfComponents());
- if(nbOfComp!=3)
- throw INTERP_KERNEL::Exception("DataArrayDouble::fromSpherToCart : must be an array with exactly 3 components !");
- int nbOfTuple(getNumberOfTuples());
- DataArrayDouble *ret(DataArrayDouble::New());
- ret->alloc(getNumberOfTuples(),3);
- double *w(ret->getPointer());
- const double *wIn(getConstPointer());
- for(int i=0;i<nbOfTuple;i++,w+=3,wIn+=3)
- {
- w[0]=wIn[0]*cos(wIn[2])*sin(wIn[1]);
- w[1]=wIn[0]*sin(wIn[2])*sin(wIn[1]);
- w[2]=wIn[0]*cos(wIn[1]);
- }
- return ret;
+ if(val<0.)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::applyRPow : the input value has to be >= 0 !");
+ double *ptr=getPointer();
+ std::size_t nbOfElems=getNbOfElems();
+ for(std::size_t i=0;i<nbOfElems;i++,ptr++)
+ *ptr=pow(val,*ptr);
+ declareAsNew();
}
/*!
- * This method returns a new array containing the same number of tuples than \a this. To do this, this method needs \a at parameter to specify the convention of \a this.
- * All the tuples of the returned array will be in cartesian sense. So if \a at equals to AX_CART the returned array is basically a deep copy of \a this.
- * If \a at equals to AX_CYL the returned array will be the result of operation cylindric to cartesian of \a this...
- *
- * \param [in] atOfThis - The axis type of \a this.
- * \return DataArrayDouble * - the new instance of DataArrayDouble (that must be dealed by caller) containing the result of the cartesianizification of \a this.
+ * Returns a new DataArrayDouble created from \a this one by applying \a
+ * FunctionToEvaluate to every tuple of \a this array. Textual data is not copied.
+ * For more info see \ref MEDCouplingArrayApplyFunc
+ * \param [in] nbOfComp - number of components in the result array.
+ * \param [in] func - the \a FunctionToEvaluate declared as
+ * \c bool (*\a func)(\c const \c double *\a pos, \c double *\a res),
+ * where \a pos points to the first component of a tuple of \a this array
+ * and \a res points to the first component of a tuple of the result array.
+ * Note that length (number of components) of \a pos can differ from
+ * that of \a res.
+ * \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 returns \a false.
*/
-DataArrayDouble *DataArrayDouble::cartesianize(MEDCouplingAxisType atOfThis) const
+DataArrayDouble *DataArrayDouble::applyFunc(int nbOfComp, FunctionToEvaluate func) const
{
checkAllocated();
- int nbOfComp(getNumberOfComponents());
- MCAuto<DataArrayDouble> ret;
- switch(atOfThis)
+ DataArrayDouble *newArr=DataArrayDouble::New();
+ int nbOfTuples=getNumberOfTuples();
+ int oldNbOfComp=getNumberOfComponents();
+ newArr->alloc(nbOfTuples,nbOfComp);
+ const double *ptr=getConstPointer();
+ double *ptrToFill=newArr->getPointer();
+ for(int i=0;i<nbOfTuples;i++)
{
- case AX_CART:
- ret=deepCopy();
- case AX_CYL:
- if(nbOfComp==3)
- {
- ret=fromCylToCart();
- break;
- }
- if(nbOfComp==2)
- {
- ret=fromPolarToCart();
- break;
- }
- else
- throw INTERP_KERNEL::Exception("DataArrayDouble::cartesianize : For AX_CYL, number of components must be in [2,3] !");
- case AX_SPHER:
- if(nbOfComp==3)
- {
- ret=fromSpherToCart();
- break;
- }
- if(nbOfComp==2)
+ if(!func(ptr+i*oldNbOfComp,ptrToFill+i*nbOfComp))
{
- ret=fromPolarToCart();
- break;
+ std::ostringstream oss; oss << "For tuple # " << i << " with value (";
+ std::copy(ptr+oldNbOfComp*i,ptr+oldNbOfComp*(i+1),std::ostream_iterator<double>(oss,", "));
+ oss << ") : Evaluation of function failed !";
+ newArr->decrRef();
+ throw INTERP_KERNEL::Exception(oss.str().c_str());
}
- else
- throw INTERP_KERNEL::Exception("DataArrayDouble::cartesianize : For AX_CYL, number of components must be in [2,3] !");
- default:
- throw INTERP_KERNEL::Exception("DataArrayDouble::cartesianize : not recognized axis type ! Only AX_CART, AX_CYL and AX_SPHER supported !");
}
- ret->copyStringInfoFrom(*this);
- return ret.retn();
+ return newArr;
}
/*!
- * Computes the doubly contracted product of every tensor defined by the tuple of \a this
- * array contating 6 components.
- * \return DataArrayDouble * - the new instance of DataArrayDouble, whose each tuple
- * is calculated from the tuple <em>(t)</em> of \a this array as follows:
- * \f$ t[0]^2+t[1]^2+t[2]^2+2*t[3]^2+2*t[4]^2+2*t[5]^2\f$.
- * The caller is to delete this result array using decrRef() as it is no more needed.
- * \throw If \a this->getNumberOfComponents() != 6.
+ * 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 MEDCouplingArrayApplyFunc1.
+ * \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
+ * needed.
+ * \throw If \a this is not allocated.
+ * \throw If computing \a func fails.
*/
-DataArrayDouble *DataArrayDouble::doublyContractedProduct() const
+DataArrayDouble *DataArrayDouble::applyFunc(int nbOfComp, const std::string& func, bool isSafe) const
{
- checkAllocated();
- int nbOfComp(getNumberOfComponents());
- if(nbOfComp!=6)
- throw INTERP_KERNEL::Exception("DataArrayDouble::doublyContractedProduct : must be an array with exactly 6 components !");
- DataArrayDouble *ret=DataArrayDouble::New();
- int nbOfTuple=getNumberOfTuples();
- ret->alloc(nbOfTuple,1);
- const double *src=getConstPointer();
- double *dest=ret->getPointer();
- for(int i=0;i<nbOfTuple;i++,dest++,src+=6)
- *dest=src[0]*src[0]+src[1]*src[1]+src[2]*src[2]+2.*src[3]*src[3]+2.*src[4]*src[4]+2.*src[5]*src[5];
- return ret;
+ INTERP_KERNEL::ExprParser expr(func);
+ expr.parse();
+ std::set<std::string> vars;
+ expr.getTrueSetOfVars(vars);
+ std::vector<std::string> varsV(vars.begin(),vars.end());
+ return applyFuncNamedCompo(nbOfComp,varsV,func,isSafe);
}
/*!
- * Computes the determinant of every square matrix defined by the tuple of \a this
- * array, which contains either 4, 6 or 9 components. The case of 6 components
- * corresponds to that of the upper triangular matrix.
- * \return DataArrayDouble * - the new instance of DataArrayDouble, whose each tuple
- * is the determinant of matrix of the corresponding tuple of \a this array.
+ * 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. 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.
- * \throw If \a this->getNumberOfComponents() is not in [4,6,9].
+ * needed.
+ * \sa applyFuncOnThis
+ * \throw If \a this is not allocated.
+ * \throw If computing \a func fails.
*/
-DataArrayDouble *DataArrayDouble::determinant() const
+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();
- DataArrayDouble *ret=DataArrayDouble::New();
- int nbOfTuple=getNumberOfTuples();
- ret->alloc(nbOfTuple,1);
- const double *src=getConstPointer();
- double *dest=ret->getPointer();
- switch(getNumberOfComponents())
- {
- case 6:
- for(int i=0;i<nbOfTuple;i++,dest++,src+=6)
- *dest=src[0]*src[1]*src[2]+2.*src[4]*src[5]*src[3]-src[0]*src[4]*src[4]-src[2]*src[3]*src[3]-src[1]*src[5]*src[5];
- return ret;
- case 4:
- for(int i=0;i<nbOfTuple;i++,dest++,src+=4)
- *dest=src[0]*src[3]-src[1]*src[2];
- return ret;
- case 9:
- for(int i=0;i<nbOfTuple;i++,dest++,src+=9)
- *dest=src[0]*src[4]*src[8]+src[1]*src[5]*src[6]+src[2]*src[3]*src[7]-src[0]*src[5]*src[7]-src[1]*src[3]*src[8]-src[2]*src[4]*src[6];
- return ret;
- default:
- ret->decrRef();
- throw INTERP_KERNEL::Exception("DataArrayDouble::determinant : Invalid number of components ! must be in 4,6,9 !");
- }
-}
-
-/*!
- * Computes 3 eigenvalues of every upper triangular matrix defined by the tuple of
- * \a this array, which contains 6 components.
- * \return DataArrayDouble * - the new instance of DataArrayDouble containing 3
- * components, whose each tuple contains the eigenvalues of the matrix of
- * corresponding tuple of \a this array.
- * The caller is to delete this result array using decrRef() as it is no more
- * needed.
- * \throw If \a this->getNumberOfComponents() != 6.
- */
-DataArrayDouble *DataArrayDouble::eigenValues() const
-{
- checkAllocated();
- int nbOfComp=getNumberOfComponents();
- if(nbOfComp!=6)
- throw INTERP_KERNEL::Exception("DataArrayDouble::eigenValues : must be an array with exactly 6 components !");
- DataArrayDouble *ret=DataArrayDouble::New();
- int nbOfTuple=getNumberOfTuples();
- ret->alloc(nbOfTuple,3);
- const double *src=getConstPointer();
- double *dest=ret->getPointer();
- for(int i=0;i<nbOfTuple;i++,dest+=3,src+=6)
- INTERP_KERNEL::computeEigenValues6(src,dest);
- return ret;
-}
-
-/*!
- * Computes 3 eigenvectors of every upper triangular matrix defined by the tuple of
- * \a this array, which contains 6 components.
- * \return DataArrayDouble * - the new instance of DataArrayDouble containing 9
- * components, whose each tuple contains 3 eigenvectors of the matrix of
- * corresponding tuple of \a this array.
- * The caller is to delete this result array using decrRef() as it is no more
- * needed.
- * \throw If \a this->getNumberOfComponents() != 6.
- */
-DataArrayDouble *DataArrayDouble::eigenVectors() const
-{
- checkAllocated();
- int nbOfComp=getNumberOfComponents();
- if(nbOfComp!=6)
- throw INTERP_KERNEL::Exception("DataArrayDouble::eigenVectors : must be an array with exactly 6 components !");
- DataArrayDouble *ret=DataArrayDouble::New();
- int nbOfTuple=getNumberOfTuples();
- ret->alloc(nbOfTuple,9);
- const double *src=getConstPointer();
- double *dest=ret->getPointer();
- for(int i=0;i<nbOfTuple;i++,src+=6)
- {
- double tmp[3];
- INTERP_KERNEL::computeEigenValues6(src,tmp);
- for(int j=0;j<3;j++,dest+=3)
- INTERP_KERNEL::computeEigenVectorForEigenValue6(src,tmp[j],1e-12,dest);
- }
- return ret;
-}
-
-/*!
- * Computes the inverse matrix of every matrix defined by the tuple of \a this
- * array, which contains either 4, 6 or 9 components. The case of 6 components
- * corresponds to that of the upper triangular matrix.
- * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
- * same number of components as \a this one, whose each tuple is the inverse
- * matrix of the matrix of corresponding tuple of \a this array.
- * The caller is to delete this result array using decrRef() as it is no more
- * needed.
- * \throw If \a this->getNumberOfComponents() is not in [4,6,9].
- */
-DataArrayDouble *DataArrayDouble::inverse() const
-{
- checkAllocated();
- int nbOfComp=getNumberOfComponents();
- if(nbOfComp!=6 && nbOfComp!=9 && nbOfComp!=4)
- throw INTERP_KERNEL::Exception("DataArrayDouble::inversion : must be an array with 4,6 or 9 components !");
- DataArrayDouble *ret=DataArrayDouble::New();
- int nbOfTuple=getNumberOfTuples();
- ret->alloc(nbOfTuple,nbOfComp);
- const double *src=getConstPointer();
- double *dest=ret->getPointer();
- if(nbOfComp==6)
- for(int i=0;i<nbOfTuple;i++,dest+=6,src+=6)
- {
- double det=src[0]*src[1]*src[2]+2.*src[4]*src[5]*src[3]-src[0]*src[4]*src[4]-src[2]*src[3]*src[3]-src[1]*src[5]*src[5];
- dest[0]=(src[1]*src[2]-src[4]*src[4])/det;
- dest[1]=(src[0]*src[2]-src[5]*src[5])/det;
- dest[2]=(src[0]*src[1]-src[3]*src[3])/det;
- dest[3]=(src[5]*src[4]-src[3]*src[2])/det;
- dest[4]=(src[5]*src[3]-src[0]*src[4])/det;
- dest[5]=(src[3]*src[4]-src[1]*src[5])/det;
- }
- else if(nbOfComp==4)
- for(int i=0;i<nbOfTuple;i++,dest+=4,src+=4)
- {
- double det=src[0]*src[3]-src[1]*src[2];
- dest[0]=src[3]/det;
- dest[1]=-src[1]/det;
- dest[2]=-src[2]/det;
- dest[3]=src[0]/det;
- }
- else
- for(int i=0;i<nbOfTuple;i++,dest+=9,src+=9)
- {
- double det=src[0]*src[4]*src[8]+src[1]*src[5]*src[6]+src[2]*src[3]*src[7]-src[0]*src[5]*src[7]-src[1]*src[3]*src[8]-src[2]*src[4]*src[6];
- dest[0]=(src[4]*src[8]-src[7]*src[5])/det;
- dest[1]=(src[7]*src[2]-src[1]*src[8])/det;
- dest[2]=(src[1]*src[5]-src[4]*src[2])/det;
- dest[3]=(src[6]*src[5]-src[3]*src[8])/det;
- dest[4]=(src[0]*src[8]-src[6]*src[2])/det;
- dest[5]=(src[2]*src[3]-src[0]*src[5])/det;
- dest[6]=(src[3]*src[7]-src[6]*src[4])/det;
- dest[7]=(src[6]*src[1]-src[0]*src[7])/det;
- dest[8]=(src[0]*src[4]-src[1]*src[3])/det;
- }
- return ret;
-}
-
-/*!
- * Computes the trace of every matrix defined by the tuple of \a this
- * array, which contains either 4, 6 or 9 components. The case of 6 components
- * corresponds to that of the upper triangular matrix.
- * \return DataArrayDouble * - the new instance of DataArrayDouble containing
- * 1 component, whose each tuple is the trace of
- * the matrix of corresponding tuple of \a this array.
- * The caller is to delete this result array using decrRef() as it is no more
- * needed.
- * \throw If \a this->getNumberOfComponents() is not in [4,6,9].
- */
-DataArrayDouble *DataArrayDouble::trace() const
-{
- checkAllocated();
- int nbOfComp=getNumberOfComponents();
- if(nbOfComp!=6 && nbOfComp!=9 && nbOfComp!=4)
- throw INTERP_KERNEL::Exception("DataArrayDouble::trace : must be an array with 4,6 or 9 components !");
- DataArrayDouble *ret=DataArrayDouble::New();
- int nbOfTuple=getNumberOfTuples();
- ret->alloc(nbOfTuple,1);
- const double *src=getConstPointer();
- double *dest=ret->getPointer();
- if(nbOfComp==6)
- for(int i=0;i<nbOfTuple;i++,dest++,src+=6)
- *dest=src[0]+src[1]+src[2];
- else if(nbOfComp==4)
- for(int i=0;i<nbOfTuple;i++,dest++,src+=4)
- *dest=src[0]+src[3];
- else
- for(int i=0;i<nbOfTuple;i++,dest++,src+=9)
- *dest=src[0]+src[4]+src[8];
- return ret;
-}
-
-/*!
- * Computes the stress deviator tensor of every stress tensor defined by the tuple of
- * \a this array, which contains 6 components.
- * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
- * same number of components and 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->getNumberOfComponents() != 6.
- */
-DataArrayDouble *DataArrayDouble::deviator() const
-{
- checkAllocated();
- int nbOfComp=getNumberOfComponents();
- if(nbOfComp!=6)
- throw INTERP_KERNEL::Exception("DataArrayDouble::deviator : must be an array with exactly 6 components !");
- DataArrayDouble *ret=DataArrayDouble::New();
- int nbOfTuple=getNumberOfTuples();
- ret->alloc(nbOfTuple,6);
- const double *src=getConstPointer();
- double *dest=ret->getPointer();
- for(int i=0;i<nbOfTuple;i++,dest+=6,src+=6)
- {
- double tr=(src[0]+src[1]+src[2])/3.;
- dest[0]=src[0]-tr;
- dest[1]=src[1]-tr;
- dest[2]=src[2]-tr;
- dest[3]=src[3];
- dest[4]=src[4];
- dest[5]=src[5];
- }
- return ret;
-}
-
-/*!
- * Computes the magnitude of every vector defined by the tuple of
- * \a this array.
- * \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::magnitude() const
-{
- checkAllocated();
- int nbOfComp=getNumberOfComponents();
- DataArrayDouble *ret=DataArrayDouble::New();
- int nbOfTuple=getNumberOfTuples();
- ret->alloc(nbOfTuple,1);
- const double *src=getConstPointer();
- double *dest=ret->getPointer();
- for(int i=0;i<nbOfTuple;i++,dest++)
- {
- double sum=0.;
- for(int j=0;j<nbOfComp;j++,src++)
- sum+=(*src)*(*src);
- *dest=sqrt(sum);
- }
- return ret;
-}
-
-/*!
- * 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());
- MCAuto<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
- * 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.
- * \sa DataArrayDouble::maxPerTupleWithCompoId
- */
-DataArrayDouble *DataArrayDouble::maxPerTuple() const
-{
- checkAllocated();
- int nbOfComp=getNumberOfComponents();
- MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
- int nbOfTuple=getNumberOfTuples();
- ret->alloc(nbOfTuple,1);
- const double *src=getConstPointer();
- double *dest=ret->getPointer();
- for(int i=0;i<nbOfTuple;i++,dest++,src+=nbOfComp)
- *dest=*std::max_element(src,src+nbOfComp);
- return ret.retn();
-}
-
-/*!
- * Computes the maximal value within every tuple of \a this array and it returns the first component
- * id for each tuple that corresponds to the maximal value within the tuple.
- *
- * \param [out] compoIdOfMaxPerTuple - the new new instance of DataArrayInt containing the
- * same number of tuples and only one component.
- * \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.
- * \sa DataArrayDouble::maxPerTuple
- */
-DataArrayDouble *DataArrayDouble::maxPerTupleWithCompoId(DataArrayInt* &compoIdOfMaxPerTuple) const
-{
- checkAllocated();
- int nbOfComp=getNumberOfComponents();
- MCAuto<DataArrayDouble> ret0=DataArrayDouble::New();
- MCAuto<DataArrayInt> ret1=DataArrayInt::New();
- int nbOfTuple=getNumberOfTuples();
- ret0->alloc(nbOfTuple,1); ret1->alloc(nbOfTuple,1);
- const double *src=getConstPointer();
- double *dest=ret0->getPointer(); int *dest1=ret1->getPointer();
- for(int i=0;i<nbOfTuple;i++,dest++,dest1++,src+=nbOfComp)
- {
- const double *loc=std::max_element(src,src+nbOfComp);
- *dest=*loc;
- *dest1=(int)std::distance(src,loc);
- }
- compoIdOfMaxPerTuple=ret1.retn();
- return ret0.retn();
-}
-
-/*!
- * This method returns a newly allocated DataArrayDouble instance having one component and \c this->getNumberOfTuples() * \c this->getNumberOfTuples() tuples.
- * \n This returned array contains the euclidian distance for each tuple in \a this.
- * \n So the returned array can be seen as a dense symmetrical matrix whose diagonal elements are equal to 0.
- * \n The returned array has only one component (and **not** \c this->getNumberOfTuples() components to avoid the useless memory consumption due to components info in returned DataArrayDouble)
- *
- * \warning use this method with care because it can leads to big amount of consumed memory !
- *
- * \return A newly allocated (huge) MEDCoupling::DataArrayDouble instance that the caller should deal with.
- *
- * \throw If \a this is not allocated.
- *
- * \sa DataArrayDouble::buildEuclidianDistanceDenseMatrixWith
- */
-DataArrayDouble *DataArrayDouble::buildEuclidianDistanceDenseMatrix() const
-{
- checkAllocated();
- int nbOfComp=getNumberOfComponents();
- int nbOfTuples=getNumberOfTuples();
- const double *inData=getConstPointer();
- MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
- ret->alloc(nbOfTuples*nbOfTuples,1);
- double *outData=ret->getPointer();
- for(int i=0;i<nbOfTuples;i++)
- {
- outData[i*nbOfTuples+i]=0.;
- for(int j=i+1;j<nbOfTuples;j++)
- {
- double dist=0.;
- for(int k=0;k<nbOfComp;k++)
- { double delta=inData[i*nbOfComp+k]-inData[j*nbOfComp+k]; dist+=delta*delta; }
- dist=sqrt(dist);
- outData[i*nbOfTuples+j]=dist;
- outData[j*nbOfTuples+i]=dist;
- }
- }
- return ret.retn();
-}
-
-/*!
- * This method returns a newly allocated DataArrayDouble instance having one component and \c this->getNumberOfTuples() * \c other->getNumberOfTuples() tuples.
- * \n This returned array contains the euclidian distance for each tuple in \a other with each tuple in \a this.
- * \n So the returned array can be seen as a dense rectangular matrix with \c other->getNumberOfTuples() rows and \c this->getNumberOfTuples() columns.
- * \n Output rectangular matrix is sorted along rows.
- * \n The returned array has only one component (and **not** \c this->getNumberOfTuples() components to avoid the useless memory consumption due to components info in returned DataArrayDouble)
- *
- * \warning use this method with care because it can leads to big amount of consumed memory !
- *
- * \param [in] other DataArrayDouble instance having same number of components than \a this.
- * \return A newly allocated (huge) MEDCoupling::DataArrayDouble instance that the caller should deal with.
- *
- * \throw If \a this is not allocated, or if \a other is null or if \a other is not allocated, or if number of components of \a other and \a this differs.
- *
- * \sa DataArrayDouble::buildEuclidianDistanceDenseMatrix
- */
-DataArrayDouble *DataArrayDouble::buildEuclidianDistanceDenseMatrixWith(const DataArrayDouble *other) const
-{
- if(!other)
- throw INTERP_KERNEL::Exception("DataArrayDouble::buildEuclidianDistanceDenseMatrixWith : input parameter is null !");
- checkAllocated();
- other->checkAllocated();
- int nbOfComp=getNumberOfComponents();
- int otherNbOfComp=other->getNumberOfComponents();
- if(nbOfComp!=otherNbOfComp)
- {
- std::ostringstream oss; oss << "DataArrayDouble::buildEuclidianDistanceDenseMatrixWith : this nb of compo=" << nbOfComp << " and other nb of compo=" << otherNbOfComp << ". It should match !";
- throw INTERP_KERNEL::Exception(oss.str().c_str());
- }
- int nbOfTuples=getNumberOfTuples();
- int otherNbOfTuples=other->getNumberOfTuples();
- const double *inData=getConstPointer();
- const double *inDataOther=other->getConstPointer();
- MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
- ret->alloc(otherNbOfTuples*nbOfTuples,1);
- double *outData=ret->getPointer();
- for(int i=0;i<otherNbOfTuples;i++,inDataOther+=nbOfComp)
- {
- for(int j=0;j<nbOfTuples;j++)
- {
- double dist=0.;
- for(int k=0;k<nbOfComp;k++)
- { double delta=inDataOther[k]-inData[j*nbOfComp+k]; dist+=delta*delta; }
- dist=sqrt(dist);
- outData[i*nbOfTuples+j]=dist;
- }
- }
- return ret.retn();
-}
-
-/*!
- * Sorts value within every tuple of \a this array.
- * \param [in] asc - if \a true, the values are sorted in ascending order, else,
- * in descending order.
- * \throw If \a this is not allocated.
- */
-void DataArrayDouble::sortPerTuple(bool asc)
-{
- checkAllocated();
- double *pt=getPointer();
- int nbOfTuple=getNumberOfTuples();
- int nbOfComp=getNumberOfComponents();
- if(asc)
- for(int i=0;i<nbOfTuple;i++,pt+=nbOfComp)
- std::sort(pt,pt+nbOfComp);
- else
- for(int i=0;i<nbOfTuple;i++,pt+=nbOfComp)
- std::sort(pt,pt+nbOfComp,std::greater<double>());
- declareAsNew();
-}
-
-/*!
- * Converts every value of \a this array to its absolute value.
- * \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()
-{
- checkAllocated();
- double *ptr(getPointer());
- std::size_t nbOfElems(getNbOfElems());
- std::transform(ptr,ptr+nbOfElems,ptr,std::ptr_fun<double,double>(fabs));
- 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 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, or \a compoId is not in [0,\c this->getNumberOfComponents() ).
- */
-void DataArrayDouble::applyLin(double a, double b, int compoId)
-{
- checkAllocated();
- 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 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)
-{
- checkAllocated();
- double *ptr=getPointer();
- std::size_t nbOfElems=getNbOfElems();
- for(std::size_t i=0;i<nbOfElems;i++,ptr++)
- *ptr=a*(*ptr)+b;
- declareAsNew();
-}
-
-/*!
- * Modify all elements of \a this array, so that
- * an element _x_ becomes \f$ numerator / x \f$.
- * \warning If an exception is thrown because of presence of 0.0 element in \a this
- * array, all elements processed before detection of the zero element remain
- * modified.
- * \param [in] numerator - the numerator used to modify array elements.
- * \throw If \a this is not allocated.
- * \throw If there is an element equal to 0.0 in \a this array.
- */
-void DataArrayDouble::applyInv(double numerator)
-{
- checkAllocated();
- double *ptr=getPointer();
- std::size_t nbOfElems=getNbOfElems();
- for(std::size_t i=0;i<nbOfElems;i++,ptr++)
- {
- if(std::abs(*ptr)>std::numeric_limits<double>::min())
- {
- *ptr=numerator/(*ptr);
- }
- else
- {
- std::ostringstream oss; oss << "DataArrayDouble::applyInv : presence of null value in tuple #" << i/getNumberOfComponents() << " component #" << i%getNumberOfComponents();
- oss << " !";
- throw INTERP_KERNEL::Exception(oss.str().c_str());
- }
- }
- declareAsNew();
-}
-
-/*!
- * Returns a full copy of \a this array except that sign of all elements is reversed.
- * \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.
- */
-DataArrayDouble *DataArrayDouble::negate() const
-{
- checkAllocated();
- DataArrayDouble *newArr=DataArrayDouble::New();
- int nbOfTuples=getNumberOfTuples();
- int nbOfComp=getNumberOfComponents();
- newArr->alloc(nbOfTuples,nbOfComp);
- const double *cptr=getConstPointer();
- std::transform(cptr,cptr+nbOfTuples*nbOfComp,newArr->getPointer(),std::negate<double>());
- newArr->copyStringInfoFrom(*this);
- return newArr;
-}
-
-/*!
- * Modify all elements of \a this array, so that
- * an element _x_ becomes <em> val ^ x </em>. Contrary to DataArrayInt::applyPow
- * all values in \a this have to be >= 0 if val is \b not integer.
- * \param [in] val - the value used to apply pow on all array elements.
- * \throw If \a this is not allocated.
- * \warning If an exception is thrown because of presence of 0 element in \a this
- * array and \a val is \b not integer, all elements processed before detection of the zero element remain
- * modified.
- */
-void DataArrayDouble::applyPow(double val)
-{
- checkAllocated();
- double *ptr=getPointer();
- std::size_t nbOfElems=getNbOfElems();
- int val2=(int)val;
- bool isInt=((double)val2)==val;
- if(!isInt)
- {
- for(std::size_t i=0;i<nbOfElems;i++,ptr++)
- {
- if(*ptr>=0)
- *ptr=pow(*ptr,val);
- else
- {
- std::ostringstream oss; oss << "DataArrayDouble::applyPow (double) : At elem # " << i << " value is " << *ptr << " ! must be >=0. !";
- throw INTERP_KERNEL::Exception(oss.str().c_str());
- }
- }
- }
- else
- {
- for(std::size_t i=0;i<nbOfElems;i++,ptr++)
- *ptr=pow(*ptr,val2);
- }
- declareAsNew();
-}
-
-/*!
- * Modify all elements of \a this array, so that
- * an element _x_ becomes \f$ val ^ x \f$.
- * \param [in] val - the value used to apply pow on all array elements.
- * \throw If \a this is not allocated.
- * \throw If \a val < 0.
- * \warning If an exception is thrown because of presence of 0 element in \a this
- * array, all elements processed before detection of the zero element remain
- * modified.
- */
-void DataArrayDouble::applyRPow(double val)
-{
- checkAllocated();
- if(val<0.)
- throw INTERP_KERNEL::Exception("DataArrayDouble::applyRPow : the input value has to be >= 0 !");
- double *ptr=getPointer();
- std::size_t nbOfElems=getNbOfElems();
- for(std::size_t i=0;i<nbOfElems;i++,ptr++)
- *ptr=pow(val,*ptr);
- declareAsNew();
-}
-
-/*!
- * Returns a new DataArrayDouble created from \a this one by applying \a
- * FunctionToEvaluate to every tuple of \a this array. Textual data is not copied.
- * For more info see \ref MEDCouplingArrayApplyFunc
- * \param [in] nbOfComp - number of components in the result array.
- * \param [in] func - the \a FunctionToEvaluate declared as
- * \c bool (*\a func)(\c const \c double *\a pos, \c double *\a res),
- * where \a pos points to the first component of a tuple of \a this array
- * and \a res points to the first component of a tuple of the result array.
- * Note that length (number of components) of \a pos can differ from
- * that of \a res.
- * \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 returns \a false.
- */
-DataArrayDouble *DataArrayDouble::applyFunc(int nbOfComp, FunctionToEvaluate func) const
-{
- checkAllocated();
- DataArrayDouble *newArr=DataArrayDouble::New();
- int nbOfTuples=getNumberOfTuples();
- int oldNbOfComp=getNumberOfComponents();
- newArr->alloc(nbOfTuples,nbOfComp);
- const double *ptr=getConstPointer();
- double *ptrToFill=newArr->getPointer();
- for(int i=0;i<nbOfTuples;i++)
- {
- if(!func(ptr+i*oldNbOfComp,ptrToFill+i*nbOfComp))
- {
- std::ostringstream oss; oss << "For tuple # " << i << " with value (";
- std::copy(ptr+oldNbOfComp*i,ptr+oldNbOfComp*(i+1),std::ostream_iterator<double>(oss,", "));
- oss << ") : Evaluation of function failed !";
- newArr->decrRef();
- throw INTERP_KERNEL::Exception(oss.str().c_str());
- }
- }
- return newArr;
-}
-
-/*!
- * 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 MEDCouplingArrayApplyFunc1.
- * \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
- * needed.
- * \throw If \a this is not allocated.
- * \throw If computing \a func fails.
- */
-DataArrayDouble *DataArrayDouble::applyFunc(int nbOfComp, const std::string& func, bool isSafe) const
-{
- INTERP_KERNEL::ExprParser expr(func);
- expr.parse();
- std::set<std::string> vars;
- expr.getTrueSetOfVars(vars);
- std::vector<std::string> varsV(vars.begin(),vars.end());
- return applyFuncNamedCompo(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. 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 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());
- MCAuto<DataArrayDouble> newArr(DataArrayDouble::New());
- newArr->alloc(nbOfTuples,nbOfComp);
- INTERP_KERNEL::ExprParser expr(func);
- expr.parse();
- 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 applyFuncCompo or applyFuncNamedCompo instead ! Vars in expr are : ";
- std::copy(vars.begin(),vars.end(),std::ostream_iterator<std::string>(oss," "));
- throw INTERP_KERNEL::Exception(oss.str().c_str());
- }
- if(vars.empty())
- {
- 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++)
- {
- for(int iComp=0;iComp<nbOfComp;iComp++,ptr++,ptrToFill++)
- {
- buff=*ptr;
- expr.evaluateDoubleInternal(stck);
- *ptrToFill=stck.back();
- stck.pop_back();
- }
- }
- }
- else
- {
- for(int i=0;i<nbOfTuples;i++)
- {
- 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.retn();
-}
-
-/*!
- * 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".
- * \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
- */
-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);
- if((int)vars.size()>1)
- {
- std::ostringstream oss; oss << "DataArrayDouble::applyFuncOnThis : this method works only with at most one var func expression ! If you need to map comps on variables please use applyFuncCompo or applyFuncNamedCompo instead ! Vars in expr are : ";
- std::copy(vars.begin(),vars.end(),std::ostream_iterator<std::string>(oss," "));
- throw INTERP_KERNEL::Exception(oss.str().c_str());
- }
- 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)
- {
- for(int i=0;i<nbOfTuples;i++)
- {
- for(int iComp=0;iComp<nbOfComp;iComp++,ptr++,ptrToFill++)
- {
- buff=*ptr;
- expr.evaluateDoubleInternal(stck);
- *ptrToFill=stck.back();
- stck.pop_back();
- }
- }
- }
- else
- {
- for(int i=0;i<nbOfTuples;i++)
- {
- 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();
- }
- }
- }
-}
-
-/*!
- * 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::applyFuncCompo(int nbOfComp, const std::string& func, bool isSafe) const
-{
- return applyFuncNamedCompo(nbOfComp,getVarsOnComponent(),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.
- * For more info see \ref MEDCouplingArrayApplyFunc3.
- * \param [in] nbOfComp - number of components in the result array.
- * \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
- * needed.
- * \throw If \a this is not allocated.
- * \throw If \a func contains vars not in \a varsOrder.
- * \throw If computing \a func fails.
- */
-DataArrayDouble *DataArrayDouble::applyFuncNamedCompo(int nbOfComp, const std::vector<std::string>& varsOrder, const std::string& func, bool isSafe) const
-{
- if(nbOfComp<=0)
- throw INTERP_KERNEL::Exception("DataArrayDouble::applyFuncNamedCompo : output number of component must be > 0 !");
- std::vector<std::string> varsOrder2(varsOrder);
- int oldNbOfComp(getNumberOfComponents());
- for(int i=(int)varsOrder.size();i<oldNbOfComp;i++)
- varsOrder2.push_back(std::string());
- checkAllocated();
- int nbOfTuples(getNumberOfTuples());
- INTERP_KERNEL::ExprParser expr(func);
- expr.parse();
- std::set<std::string> vars;
- expr.getTrueSetOfVars(vars);
- 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());
- }
- MCAuto<DataArrayDouble> newArr(DataArrayDouble::New());
- newArr->alloc(nbOfTuples,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();
- }
- }
- else
- {
- 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.retn();
-}
-
-void DataArrayDouble::applyFuncFast32(const std::string& func)
-{
- checkAllocated();
- INTERP_KERNEL::ExprParser expr(func);
- expr.parse();
- char *funcStr=expr.compileX86();
- MYFUNCPTR funcPtr;
- *((void **)&funcPtr)=funcStr;//he he...
- //
- double *ptr=getPointer();
- int nbOfComp=getNumberOfComponents();
- int nbOfTuples=getNumberOfTuples();
- int nbOfElems=nbOfTuples*nbOfComp;
- for(int i=0;i<nbOfElems;i++,ptr++)
- *ptr=funcPtr(*ptr);
- declareAsNew();
-}
-
-void DataArrayDouble::applyFuncFast64(const std::string& func)
-{
- checkAllocated();
- INTERP_KERNEL::ExprParser expr(func);
- expr.parse();
- char *funcStr=expr.compileX86_64();
- MYFUNCPTR funcPtr;
- *((void **)&funcPtr)=funcStr;//he he...
- //
- double *ptr=getPointer();
- int nbOfComp=getNumberOfComponents();
- int nbOfTuples=getNumberOfTuples();
- int nbOfElems=nbOfTuples*nbOfComp;
- for(int i=0;i<nbOfElems;i++,ptr++)
- *ptr=funcPtr(*ptr);
- declareAsNew();
-}
-
-DataArrayDoubleIterator *DataArrayDouble::iterator()
-{
- return new DataArrayDoubleIterator(this);
-}
-
-/*!
- * Returns a new DataArrayInt contating indices of tuples of \a this one-dimensional
- * array whose values are within a given range. Textual data is not copied.
- * \param [in] vmin - a lowest acceptable value (included).
- * \param [in] vmax - a greatest acceptable value (included).
- * \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::findIdsNotInRange
- *
- * \if ENABLE_EXAMPLES
- * \ref cpp_mcdataarraydouble_getidsinrange "Here is a C++ example".<br>
- * \ref py_mcdataarraydouble_getidsinrange "Here is a Python example".
- * \endif
- */
-DataArrayInt *DataArrayDouble::findIdsInRange(double vmin, double vmax) const
-{
- checkAllocated();
- if(getNumberOfComponents()!=1)
- throw INTERP_KERNEL::Exception("DataArrayDouble::findIdsInRange : this must have exactly one component !");
- const double *cptr(begin());
- MCAuto<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
- int nbOfTuples(getNumberOfTuples());
- for(int i=0;i<nbOfTuples;i++,cptr++)
- if(*cptr>=vmin && *cptr<=vmax)
- 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::findIdsInRange
- */
-DataArrayInt *DataArrayDouble::findIdsNotInRange(double vmin, double vmax) const
-{
- checkAllocated();
- if(getNumberOfComponents()!=1)
- throw INTERP_KERNEL::Exception("DataArrayDouble::findIdsNotInRange : this must have exactly one component !");
- const double *cptr(begin());
- MCAuto<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
- int nbOfTuples(getNumberOfTuples());
- for(int i=0;i<nbOfTuples;i++,cptr++)
- if(*cptr<vmin || *cptr>vmax)
- 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)
- * 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.
- * \param [in] a1 - an array to include in the result array.
- * \param [in] a2 - another array 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
- * needed.
- * \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)
-{
- std::vector<const DataArrayDouble *> tmp(2);
- tmp[0]=a1; tmp[1]=a2;
- return Aggregate(tmp);
-}
-
-/*!
- * Returns a new DataArrayDouble 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)
- * 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
- * needed.
- * \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)
-{
- std::vector<const DataArrayDouble *> a;
- for(std::vector<const DataArrayDouble *>::const_iterator it4=arr.begin();it4!=arr.end();it4++)
- if(*it4)
- a.push_back(*it4);
- if(a.empty())
- throw INTERP_KERNEL::Exception("DataArrayDouble::Aggregate : input list must contain at least one NON EMPTY DataArrayDouble !");
- std::vector<const DataArrayDouble *>::const_iterator it=a.begin();
- int nbOfComp=(*it)->getNumberOfComponents();
- int nbt=(*it++)->getNumberOfTuples();
- for(int i=1;it!=a.end();it++,i++)
- {
- if((*it)->getNumberOfComponents()!=nbOfComp)
- throw INTERP_KERNEL::Exception("DataArrayDouble::Aggregate : Nb of components mismatch for array aggregation !");
- nbt+=(*it)->getNumberOfTuples();
- }
- MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
- ret->alloc(nbt,nbOfComp);
- double *pt=ret->getPointer();
- for(it=a.begin();it!=a.end();it++)
- pt=std::copy((*it)->getConstPointer(),(*it)->getConstPointer()+(*it)->getNbOfElems(),pt);
- ret->copyStringInfoFrom(*(a[0]));
- return ret.retn();
-}
-
-/*!
- * Returns a new DataArrayDouble by aggregating two given arrays, so that (1) the number
- * of components in the result array is a sum of the number of components of given arrays
- * and (2) the number of tuples in the result array is same as that of each of given
- * arrays. In other words the i-th tuple of result array includes all components of
- * i-th tuples of all given arrays.
- * Number of tuples in the given arrays must be the same.
- * \param [in] a1 - an array to include in the result array.
- * \param [in] a2 - another array 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
- * needed.
- * \throw If both \a a1 and \a a2 are NULL.
- * \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)
-{
- std::vector<const DataArrayDouble *> arr(2);
- arr[0]=a1; arr[1]=a2;
- return Meld(arr);
-}
-
-/*!
- * Returns a new DataArrayDouble by aggregating all given arrays, so that (1) the number
- * of components in the result array is a sum of the number of components of given arrays
- * and (2) the number of tuples in the result array is same as that of each of given
- * arrays. In other words the i-th tuple of result array includes all components of
- * i-th tuples of all given arrays.
- * Number of tuples in the given arrays must be the same.
- * \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
- * needed.
- * \throw If all arrays within \a arr are NULL.
- * \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)
-{
- std::vector<const DataArrayDouble *> a;
- for(std::vector<const DataArrayDouble *>::const_iterator it4=arr.begin();it4!=arr.end();it4++)
- if(*it4)
- a.push_back(*it4);
- if(a.empty())
- throw INTERP_KERNEL::Exception("DataArrayDouble::Meld : input list must contain at least one NON EMPTY DataArrayDouble !");
- std::vector<const DataArrayDouble *>::const_iterator it;
- for(it=a.begin();it!=a.end();it++)
- (*it)->checkAllocated();
- it=a.begin();
- int nbOfTuples=(*it)->getNumberOfTuples();
- std::vector<int> nbc(a.size());
- std::vector<const double *> pts(a.size());
- nbc[0]=(*it)->getNumberOfComponents();
- pts[0]=(*it++)->getConstPointer();
- for(int i=1;it!=a.end();it++,i++)
- {
- if(nbOfTuples!=(*it)->getNumberOfTuples())
- throw INTERP_KERNEL::Exception("DataArrayDouble::Meld : mismatch of number of tuples !");
- nbc[i]=(*it)->getNumberOfComponents();
- pts[i]=(*it)->getConstPointer();
- }
- int totalNbOfComp=std::accumulate(nbc.begin(),nbc.end(),0);
- DataArrayDouble *ret=DataArrayDouble::New();
- ret->alloc(nbOfTuples,totalNbOfComp);
- double *retPtr=ret->getPointer();
- for(int i=0;i<nbOfTuples;i++)
- for(int j=0;j<(int)a.size();j++)
- {
- retPtr=std::copy(pts[j],pts[j]+nbc[j],retPtr);
- pts[j]+=nbc[j];
- }
- 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));
- return ret;
-}
-
-/*!
- * Returns a new DataArrayDouble containing a dot product of two given arrays, so that
- * the i-th tuple of the result array is a sum of products of j-th components of i-th
- * tuples of given arrays (\f$ a_i = \sum_{j=1}^n a1_j * a2_j \f$).
- * Info on components and name is copied from the first of the given arrays.
- * Number of tuples and components in the given arrays must be the same.
- * \param [in] a1 - a given array.
- * \param [in] a2 - another given array.
- * \return DataArrayDouble * - the new instance of DataArrayDouble.
- * The caller is to delete this result array using decrRef() as it is no more
- * needed.
- * \throw If either \a a1 or \a a2 is NULL.
- * \throw If any given array is not allocated.
- * \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)
-{
- if(!a1 || !a2)
- throw INTERP_KERNEL::Exception("DataArrayDouble::Dot : input DataArrayDouble instance is NULL !");
- a1->checkAllocated();
- a2->checkAllocated();
- int nbOfComp=a1->getNumberOfComponents();
- if(nbOfComp!=a2->getNumberOfComponents())
- throw INTERP_KERNEL::Exception("Nb of components mismatch for array Dot !");
- int nbOfTuple=a1->getNumberOfTuples();
- if(nbOfTuple!=a2->getNumberOfTuples())
- throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array Dot !");
- DataArrayDouble *ret=DataArrayDouble::New();
- ret->alloc(nbOfTuple,1);
- double *retPtr=ret->getPointer();
- const double *a1Ptr=a1->getConstPointer();
- const double *a2Ptr=a2->getConstPointer();
- for(int i=0;i<nbOfTuple;i++)
- {
- double sum=0.;
- for(int j=0;j<nbOfComp;j++)
- sum+=a1Ptr[i*nbOfComp+j]*a2Ptr[i*nbOfComp+j];
- retPtr[i]=sum;
- }
- ret->setInfoOnComponent(0,a1->getInfoOnComponent(0));
- ret->setName(a1->getName());
- return ret;
-}
-
-/*!
- * Returns a new DataArrayDouble containing a cross product of two given arrays, so that
- * the i-th tuple of the result array contains 3 components of a vector which is a cross
- * product of two vectors defined by the i-th tuples of given arrays.
- * Info on components is copied from the first of the given arrays.
- * Number of tuples in the given arrays must be the same.
- * Number of components in the given arrays must be 3.
- * \param [in] a1 - a given array.
- * \param [in] a2 - another given array.
- * \return DataArrayDouble * - the new instance of DataArrayDouble.
- * The caller is to delete this result array using decrRef() as it is no more
- * needed.
- * \throw If either \a a1 or \a a2 is NULL.
- * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
- * \throw If \a a1->getNumberOfComponents() != 3
- * \throw If \a a2->getNumberOfComponents() != 3
- */
-DataArrayDouble *DataArrayDouble::CrossProduct(const DataArrayDouble *a1, const DataArrayDouble *a2)
-{
- if(!a1 || !a2)
- throw INTERP_KERNEL::Exception("DataArrayDouble::CrossProduct : input DataArrayDouble instance is NULL !");
- int nbOfComp=a1->getNumberOfComponents();
- if(nbOfComp!=a2->getNumberOfComponents())
- throw INTERP_KERNEL::Exception("Nb of components mismatch for array crossProduct !");
- if(nbOfComp!=3)
- throw INTERP_KERNEL::Exception("Nb of components must be equal to 3 for array crossProduct !");
- int nbOfTuple=a1->getNumberOfTuples();
- if(nbOfTuple!=a2->getNumberOfTuples())
- throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array crossProduct !");
- DataArrayDouble *ret=DataArrayDouble::New();
- ret->alloc(nbOfTuple,3);
- double *retPtr=ret->getPointer();
- const double *a1Ptr=a1->getConstPointer();
- const double *a2Ptr=a2->getConstPointer();
- for(int i=0;i<nbOfTuple;i++)
- {
- retPtr[3*i]=a1Ptr[3*i+1]*a2Ptr[3*i+2]-a1Ptr[3*i+2]*a2Ptr[3*i+1];
- retPtr[3*i+1]=a1Ptr[3*i+2]*a2Ptr[3*i]-a1Ptr[3*i]*a2Ptr[3*i+2];
- retPtr[3*i+2]=a1Ptr[3*i]*a2Ptr[3*i+1]-a1Ptr[3*i+1]*a2Ptr[3*i];
- }
- ret->copyStringInfoFrom(*a1);
- return ret;
-}
-
-/*!
- * Returns a new DataArrayDouble containing maximal values of two given arrays.
- * Info on components is copied from the first of the given arrays.
- * Number of tuples and components in the given arrays must be the same.
- * \param [in] a1 - an array to compare values with another one.
- * \param [in] a2 - another array to compare values with the first one.
- * \return DataArrayDouble * - the new instance of DataArrayDouble.
- * The caller is to delete this result array using decrRef() as it is no more
- * needed.
- * \throw If either \a a1 or \a a2 is NULL.
- * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
- * \throw If \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents()
- */
-DataArrayDouble *DataArrayDouble::Max(const DataArrayDouble *a1, const DataArrayDouble *a2)
-{
- if(!a1 || !a2)
- throw INTERP_KERNEL::Exception("DataArrayDouble::Max : input DataArrayDouble instance is NULL !");
- int nbOfComp=a1->getNumberOfComponents();
- if(nbOfComp!=a2->getNumberOfComponents())
- throw INTERP_KERNEL::Exception("Nb of components mismatch for array Max !");
- int nbOfTuple=a1->getNumberOfTuples();
- if(nbOfTuple!=a2->getNumberOfTuples())
- throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array Max !");
- DataArrayDouble *ret=DataArrayDouble::New();
- ret->alloc(nbOfTuple,nbOfComp);
- double *retPtr=ret->getPointer();
- const double *a1Ptr=a1->getConstPointer();
- const double *a2Ptr=a2->getConstPointer();
- int nbElem=nbOfTuple*nbOfComp;
- for(int i=0;i<nbElem;i++)
- retPtr[i]=std::max(a1Ptr[i],a2Ptr[i]);
- ret->copyStringInfoFrom(*a1);
- return ret;
-}
-
-/*!
- * Returns a new DataArrayDouble containing minimal values of two given arrays.
- * Info on components is copied from the first of the given arrays.
- * Number of tuples and components in the given arrays must be the same.
- * \param [in] a1 - an array to compare values with another one.
- * \param [in] a2 - another array to compare values with the first one.
- * \return DataArrayDouble * - the new instance of DataArrayDouble.
- * The caller is to delete this result array using decrRef() as it is no more
- * needed.
- * \throw If either \a a1 or \a a2 is NULL.
- * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
- * \throw If \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents()
- */
-DataArrayDouble *DataArrayDouble::Min(const DataArrayDouble *a1, const DataArrayDouble *a2)
-{
- if(!a1 || !a2)
- throw INTERP_KERNEL::Exception("DataArrayDouble::Min : input DataArrayDouble instance is NULL !");
- int nbOfComp=a1->getNumberOfComponents();
- if(nbOfComp!=a2->getNumberOfComponents())
- throw INTERP_KERNEL::Exception("Nb of components mismatch for array min !");
- int nbOfTuple=a1->getNumberOfTuples();
- if(nbOfTuple!=a2->getNumberOfTuples())
- throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array min !");
- DataArrayDouble *ret=DataArrayDouble::New();
- ret->alloc(nbOfTuple,nbOfComp);
- double *retPtr=ret->getPointer();
- const double *a1Ptr=a1->getConstPointer();
- const double *a2Ptr=a2->getConstPointer();
- int nbElem=nbOfTuple*nbOfComp;
- for(int i=0;i<nbElem;i++)
- retPtr[i]=std::min(a1Ptr[i],a2Ptr[i]);
- ret->copyStringInfoFrom(*a1);
- return ret;
-}
-
-/*!
- * Returns a new DataArrayDouble that is a sum of two given arrays. There are 3
- * valid cases.
- * 1. The arrays have same number of tuples and components. Then each value of
- * the result array (_a_) is a sum of the corresponding values of \a a1 and \a a2,
- * i.e.: _a_ [ i, j ] = _a1_ [ i, j ] + _a2_ [ i, j ].
- * 2. The arrays have same number of tuples and one array, say _a2_, has one
- * component. Then
- * _a_ [ i, j ] = _a1_ [ i, j ] + _a2_ [ i, 0 ].
- * 3. The arrays have same number of components and one array, say _a2_, has one
- * tuple. Then
- * _a_ [ i, j ] = _a1_ [ i, j ] + _a2_ [ 0, j ].
- *
- * Info on components is copied either from the first array (in the first case) or from
- * the array with maximal number of elements (getNbOfElems()).
- * \param [in] a1 - an array to sum up.
- * \param [in] a2 - another array to sum up.
- * \return DataArrayDouble * - the new instance of DataArrayDouble.
- * The caller is to delete this result array using decrRef() as it is no more
- * needed.
- * \throw If either \a a1 or \a a2 is NULL.
- * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
- * \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)
-{
- if(!a1 || !a2)
- throw INTERP_KERNEL::Exception("DataArrayDouble::Add : input DataArrayDouble instance is NULL !");
- int nbOfTuple=a1->getNumberOfTuples();
- int nbOfTuple2=a2->getNumberOfTuples();
- int nbOfComp=a1->getNumberOfComponents();
- int nbOfComp2=a2->getNumberOfComponents();
- MCAuto<DataArrayDouble> ret=0;
- if(nbOfTuple==nbOfTuple2)
- {
- if(nbOfComp==nbOfComp2)
- {
- ret=DataArrayDouble::New();
- ret->alloc(nbOfTuple,nbOfComp);
- std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::plus<double>());
- ret->copyStringInfoFrom(*a1);
- }
- else
- {
- int nbOfCompMin,nbOfCompMax;
- const DataArrayDouble *aMin, *aMax;
- if(nbOfComp>nbOfComp2)
- {
- nbOfCompMin=nbOfComp2; nbOfCompMax=nbOfComp;
- aMin=a2; aMax=a1;
- }
- else
- {
- nbOfCompMin=nbOfComp; nbOfCompMax=nbOfComp2;
- aMin=a1; aMax=a2;
- }
- if(nbOfCompMin==1)
- {
- ret=DataArrayDouble::New();
- ret->alloc(nbOfTuple,nbOfCompMax);
- const double *aMinPtr=aMin->getConstPointer();
- const double *aMaxPtr=aMax->getConstPointer();
- double *res=ret->getPointer();
- for(int i=0;i<nbOfTuple;i++)
- res=std::transform(aMaxPtr+i*nbOfCompMax,aMaxPtr+(i+1)*nbOfCompMax,res,std::bind2nd(std::plus<double>(),aMinPtr[i]));
- ret->copyStringInfoFrom(*aMax);
- }
- else
- throw INTERP_KERNEL::Exception("Nb of components mismatch for array Add !");
- }
- }
- else if((nbOfTuple==1 && nbOfTuple2>1) || (nbOfTuple>1 && nbOfTuple2==1))
- {
- if(nbOfComp==nbOfComp2)
- {
- int nbOfTupleMax=std::max(nbOfTuple,nbOfTuple2);
- const DataArrayDouble *aMin=nbOfTuple>nbOfTuple2?a2:a1;
- const DataArrayDouble *aMax=nbOfTuple>nbOfTuple2?a1:a2;
- const double *aMinPtr=aMin->getConstPointer(),*aMaxPtr=aMax->getConstPointer();
- ret=DataArrayDouble::New();
- ret->alloc(nbOfTupleMax,nbOfComp);
- double *res=ret->getPointer();
- for(int i=0;i<nbOfTupleMax;i++)
- res=std::transform(aMaxPtr+i*nbOfComp,aMaxPtr+(i+1)*nbOfComp,aMinPtr,res,std::plus<double>());
- ret->copyStringInfoFrom(*aMax);
- }
- else
- throw INTERP_KERNEL::Exception("Nb of components mismatch for array Add !");
- }
- else
- throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array Add !");
- return ret.retn();
-}
-
-/*!
- * Adds values of another DataArrayDouble to values of \a this one. There are 3
- * valid cases.
- * 1. The arrays have same number of tuples and components. Then each value of
- * \a other array is added to the corresponding value of \a this array, i.e.:
- * _a_ [ i, j ] += _other_ [ i, j ].
- * 2. The arrays have same number of tuples and \a other array has one component. Then
- * _a_ [ i, j ] += _other_ [ i, 0 ].
- * 3. The arrays have same number of components and \a other array has one tuple. Then
- * _a_ [ i, j ] += _a2_ [ 0, j ].
- *
- * \param [in] other - an array to add to \a this one.
- * \throw If \a other is NULL.
- * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
- * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
- * \a other has number of both tuples and components not equal to 1.
- */
-void DataArrayDouble::addEqual(const DataArrayDouble *other)
-{
- if(!other)
- throw INTERP_KERNEL::Exception("DataArrayDouble::addEqual : input DataArrayDouble instance is NULL !");
- const char *msg="Nb of tuples mismatch for DataArrayDouble::addEqual !";
- checkAllocated();
- other->checkAllocated();
- int nbOfTuple=getNumberOfTuples();
- int nbOfTuple2=other->getNumberOfTuples();
- int nbOfComp=getNumberOfComponents();
- int nbOfComp2=other->getNumberOfComponents();
- if(nbOfTuple==nbOfTuple2)
- {
- if(nbOfComp==nbOfComp2)
- {
- std::transform(begin(),end(),other->begin(),getPointer(),std::plus<double>());
- }
- else if(nbOfComp2==1)
- {
- double *ptr=getPointer();
- const double *ptrc=other->getConstPointer();
- for(int i=0;i<nbOfTuple;i++)
- std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::plus<double>(),*ptrc++));
- }
- else
- throw INTERP_KERNEL::Exception(msg);
- }
- else if(nbOfTuple2==1)
- {
- if(nbOfComp2==nbOfComp)
- {
- double *ptr=getPointer();
- const double *ptrc=other->getConstPointer();
- for(int i=0;i<nbOfTuple;i++)
- std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::plus<double>());
- }
- else
- throw INTERP_KERNEL::Exception(msg);
- }
- else
- throw INTERP_KERNEL::Exception(msg);
- declareAsNew();
-}
-
-/*!
- * Returns a new DataArrayDouble that is a subtraction of two given arrays. There are 3
- * valid cases.
- * 1. The arrays have same number of tuples and components. Then each value of
- * the result array (_a_) is a subtraction of the corresponding values of \a a1 and
- * \a a2, i.e.: _a_ [ i, j ] = _a1_ [ i, j ] - _a2_ [ i, j ].
- * 2. The arrays have same number of tuples and one array, say _a2_, has one
- * component. Then
- * _a_ [ i, j ] = _a1_ [ i, j ] - _a2_ [ i, 0 ].
- * 3. The arrays have same number of components and one array, say _a2_, has one
- * tuple. Then
- * _a_ [ i, j ] = _a1_ [ i, j ] - _a2_ [ 0, j ].
- *
- * Info on components is copied either from the first array (in the first case) or from
- * the array with maximal number of elements (getNbOfElems()).
- * \param [in] a1 - an array to subtract from.
- * \param [in] a2 - an array to subtract.
- * \return DataArrayDouble * - the new instance of DataArrayDouble.
- * The caller is to delete this result array using decrRef() as it is no more
- * needed.
- * \throw If either \a a1 or \a a2 is NULL.
- * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
- * \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)
-{
- if(!a1 || !a2)
- throw INTERP_KERNEL::Exception("DataArrayDouble::Substract : input DataArrayDouble instance is NULL !");
- int nbOfTuple1=a1->getNumberOfTuples();
- int nbOfTuple2=a2->getNumberOfTuples();
- int nbOfComp1=a1->getNumberOfComponents();
- int nbOfComp2=a2->getNumberOfComponents();
- if(nbOfTuple2==nbOfTuple1)
- {
- if(nbOfComp1==nbOfComp2)
- {
- MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
- ret->alloc(nbOfTuple2,nbOfComp1);
- std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::minus<double>());
- ret->copyStringInfoFrom(*a1);
- return ret.retn();
- }
- else if(nbOfComp2==1)
- {
- MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
- ret->alloc(nbOfTuple1,nbOfComp1);
- const double *a2Ptr=a2->getConstPointer();
- const double *a1Ptr=a1->getConstPointer();
- double *res=ret->getPointer();
- for(int i=0;i<nbOfTuple1;i++)
- res=std::transform(a1Ptr+i*nbOfComp1,a1Ptr+(i+1)*nbOfComp1,res,std::bind2nd(std::minus<double>(),a2Ptr[i]));
- ret->copyStringInfoFrom(*a1);
- return ret.retn();
- }
- else
- {
- a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Substract !");
- return 0;
- }
- }
- else if(nbOfTuple2==1)
- {
- a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Substract !");
- MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
- ret->alloc(nbOfTuple1,nbOfComp1);
- const double *a1ptr=a1->getConstPointer(),*a2ptr=a2->getConstPointer();
- double *pt=ret->getPointer();
- for(int i=0;i<nbOfTuple1;i++)
- pt=std::transform(a1ptr+i*nbOfComp1,a1ptr+(i+1)*nbOfComp1,a2ptr,pt,std::minus<double>());
- ret->copyStringInfoFrom(*a1);
- return ret.retn();
- }
- else
- {
- a1->checkNbOfTuples(nbOfTuple2,"Nb of tuples mismatch for array Substract !");//will always throw an exception
- return 0;
- }
-}
-
-/*!
- * Subtract values of another DataArrayDouble from values of \a this one. There are 3
- * valid cases.
- * 1. The arrays have same number of tuples and components. Then each value of
- * \a other array is subtracted from the corresponding value of \a this array, i.e.:
- * _a_ [ i, j ] -= _other_ [ i, j ].
- * 2. The arrays have same number of tuples and \a other array has one component. Then
- * _a_ [ i, j ] -= _other_ [ i, 0 ].
- * 3. The arrays have same number of components and \a other array has one tuple. Then
- * _a_ [ i, j ] -= _a2_ [ 0, j ].
- *
- * \param [in] other - an array to subtract from \a this one.
- * \throw If \a other is NULL.
- * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
- * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
- * \a other has number of both tuples and components not equal to 1.
- */
-void DataArrayDouble::substractEqual(const DataArrayDouble *other)
-{
- if(!other)
- throw INTERP_KERNEL::Exception("DataArrayDouble::substractEqual : input DataArrayDouble instance is NULL !");
- const char *msg="Nb of tuples mismatch for DataArrayDouble::substractEqual !";
- checkAllocated();
- other->checkAllocated();
- int nbOfTuple=getNumberOfTuples();
- int nbOfTuple2=other->getNumberOfTuples();
- int nbOfComp=getNumberOfComponents();
- int nbOfComp2=other->getNumberOfComponents();
- if(nbOfTuple==nbOfTuple2)
- {
- if(nbOfComp==nbOfComp2)
- {
- std::transform(begin(),end(),other->begin(),getPointer(),std::minus<double>());
- }
- else if(nbOfComp2==1)
- {
- double *ptr=getPointer();
- const double *ptrc=other->getConstPointer();
- for(int i=0;i<nbOfTuple;i++)
- std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::minus<double>(),*ptrc++));
- }
- else
- throw INTERP_KERNEL::Exception(msg);
- }
- else if(nbOfTuple2==1)
- {
- if(nbOfComp2==nbOfComp)
- {
- double *ptr=getPointer();
- const double *ptrc=other->getConstPointer();
- for(int i=0;i<nbOfTuple;i++)
- std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::minus<double>());
- }
- else
- throw INTERP_KERNEL::Exception(msg);
- }
- else
- throw INTERP_KERNEL::Exception(msg);
- declareAsNew();
-}
-
-/*!
- * Returns a new DataArrayDouble that is a product of two given arrays. There are 3
- * valid cases.
- * 1. The arrays have same number of tuples and components. Then each value of
- * the result array (_a_) is a product of the corresponding values of \a a1 and
- * \a a2, i.e. _a_ [ i, j ] = _a1_ [ i, j ] * _a2_ [ i, j ].
- * 2. The arrays have same number of tuples and one array, say _a2_, has one
- * component. Then
- * _a_ [ i, j ] = _a1_ [ i, j ] * _a2_ [ i, 0 ].
- * 3. The arrays have same number of components and one array, say _a2_, has one
- * tuple. Then
- * _a_ [ i, j ] = _a1_ [ i, j ] * _a2_ [ 0, j ].
- *
- * Info on components is copied either from the first array (in the first case) or from
- * the array with maximal number of elements (getNbOfElems()).
- * \param [in] a1 - a factor array.
- * \param [in] a2 - another factor array.
- * \return DataArrayDouble * - the new instance of DataArrayDouble.
- * The caller is to delete this result array using decrRef() as it is no more
- * needed.
- * \throw If either \a a1 or \a a2 is NULL.
- * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
- * \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)
-{
- if(!a1 || !a2)
- throw INTERP_KERNEL::Exception("DataArrayDouble::Multiply : input DataArrayDouble instance is NULL !");
- int nbOfTuple=a1->getNumberOfTuples();
- int nbOfTuple2=a2->getNumberOfTuples();
- int nbOfComp=a1->getNumberOfComponents();
- int nbOfComp2=a2->getNumberOfComponents();
- MCAuto<DataArrayDouble> ret=0;
- if(nbOfTuple==nbOfTuple2)
- {
- if(nbOfComp==nbOfComp2)
- {
- ret=DataArrayDouble::New();
- ret->alloc(nbOfTuple,nbOfComp);
- std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::multiplies<double>());
- ret->copyStringInfoFrom(*a1);
- }
- else
- {
- int nbOfCompMin,nbOfCompMax;
- const DataArrayDouble *aMin, *aMax;
- if(nbOfComp>nbOfComp2)
- {
- nbOfCompMin=nbOfComp2; nbOfCompMax=nbOfComp;
- aMin=a2; aMax=a1;
- }
- else
- {
- nbOfCompMin=nbOfComp; nbOfCompMax=nbOfComp2;
- aMin=a1; aMax=a2;
- }
- if(nbOfCompMin==1)
- {
- ret=DataArrayDouble::New();
- ret->alloc(nbOfTuple,nbOfCompMax);
- const double *aMinPtr=aMin->getConstPointer();
- const double *aMaxPtr=aMax->getConstPointer();
- double *res=ret->getPointer();
- for(int i=0;i<nbOfTuple;i++)
- res=std::transform(aMaxPtr+i*nbOfCompMax,aMaxPtr+(i+1)*nbOfCompMax,res,std::bind2nd(std::multiplies<double>(),aMinPtr[i]));
- ret->copyStringInfoFrom(*aMax);
- }
- else
- throw INTERP_KERNEL::Exception("Nb of components mismatch for array Multiply !");
- }
- }
- else if((nbOfTuple==1 && nbOfTuple2>1) || (nbOfTuple>1 && nbOfTuple2==1))
- {
- if(nbOfComp==nbOfComp2)
- {
- int nbOfTupleMax=std::max(nbOfTuple,nbOfTuple2);
- const DataArrayDouble *aMin=nbOfTuple>nbOfTuple2?a2:a1;
- const DataArrayDouble *aMax=nbOfTuple>nbOfTuple2?a1:a2;
- const double *aMinPtr=aMin->getConstPointer(),*aMaxPtr=aMax->getConstPointer();
- ret=DataArrayDouble::New();
- ret->alloc(nbOfTupleMax,nbOfComp);
- double *res=ret->getPointer();
- for(int i=0;i<nbOfTupleMax;i++)
- res=std::transform(aMaxPtr+i*nbOfComp,aMaxPtr+(i+1)*nbOfComp,aMinPtr,res,std::multiplies<double>());
- ret->copyStringInfoFrom(*aMax);
- }
- else
- throw INTERP_KERNEL::Exception("Nb of components mismatch for array Multiply !");
- }
- else
- throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array Multiply !");
- return ret.retn();
-}
-
-/*!
- * Multiply values of another DataArrayDouble to values of \a this one. There are 3
- * valid cases.
- * 1. The arrays have same number of tuples and components. Then each value of
- * \a other array is multiplied to the corresponding value of \a this array, i.e.
- * _this_ [ i, j ] *= _other_ [ i, j ].
- * 2. The arrays have same number of tuples and \a other array has one component. Then
- * _this_ [ i, j ] *= _other_ [ i, 0 ].
- * 3. The arrays have same number of components and \a other array has one tuple. Then
- * _this_ [ i, j ] *= _a2_ [ 0, j ].
- *
- * \param [in] other - an array to multiply to \a this one.
- * \throw If \a other is NULL.
- * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
- * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
- * \a other has number of both tuples and components not equal to 1.
- */
-void DataArrayDouble::multiplyEqual(const DataArrayDouble *other)
-{
- if(!other)
- throw INTERP_KERNEL::Exception("DataArrayDouble::multiplyEqual : input DataArrayDouble instance is NULL !");
- const char *msg="Nb of tuples mismatch for DataArrayDouble::multiplyEqual !";
- checkAllocated();
- other->checkAllocated();
- int nbOfTuple=getNumberOfTuples();
- int nbOfTuple2=other->getNumberOfTuples();
- int nbOfComp=getNumberOfComponents();
- int nbOfComp2=other->getNumberOfComponents();
- if(nbOfTuple==nbOfTuple2)
- {
- if(nbOfComp==nbOfComp2)
- {
- std::transform(begin(),end(),other->begin(),getPointer(),std::multiplies<double>());
- }
- else if(nbOfComp2==1)
- {
- double *ptr=getPointer();
- const double *ptrc=other->getConstPointer();
- for(int i=0;i<nbOfTuple;i++)
- std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::multiplies<double>(),*ptrc++));
- }
- else
- throw INTERP_KERNEL::Exception(msg);
- }
- else if(nbOfTuple2==1)
- {
- if(nbOfComp2==nbOfComp)
- {
- double *ptr=getPointer();
- const double *ptrc=other->getConstPointer();
- for(int i=0;i<nbOfTuple;i++)
- std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::multiplies<double>());
- }
- else
- throw INTERP_KERNEL::Exception(msg);
- }
- else
- throw INTERP_KERNEL::Exception(msg);
- declareAsNew();
-}
-
-/*!
- * Returns a new DataArrayDouble that is a division of two given arrays. There are 3
- * valid cases.
- * 1. The arrays have same number of tuples and components. Then each value of
- * the result array (_a_) is a division of the corresponding values of \a a1 and
- * \a a2, i.e.: _a_ [ i, j ] = _a1_ [ i, j ] / _a2_ [ i, j ].
- * 2. The arrays have same number of tuples and one array, say _a2_, has one
- * component. Then
- * _a_ [ i, j ] = _a1_ [ i, j ] / _a2_ [ i, 0 ].
- * 3. The arrays have same number of components and one array, say _a2_, has one
- * tuple. Then
- * _a_ [ i, j ] = _a1_ [ i, j ] / _a2_ [ 0, j ].
- *
- * Info on components is copied either from the first array (in the first case) or from
- * the array with maximal number of elements (getNbOfElems()).
- * \warning No check of division by zero is performed!
- * \param [in] a1 - a numerator array.
- * \param [in] a2 - a denominator array.
- * \return DataArrayDouble * - the new instance of DataArrayDouble.
- * The caller is to delete this result array using decrRef() as it is no more
- * needed.
- * \throw If either \a a1 or \a a2 is NULL.
- * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
- * \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)
-{
- if(!a1 || !a2)
- throw INTERP_KERNEL::Exception("DataArrayDouble::Divide : input DataArrayDouble instance is NULL !");
- int nbOfTuple1=a1->getNumberOfTuples();
- int nbOfTuple2=a2->getNumberOfTuples();
- int nbOfComp1=a1->getNumberOfComponents();
- int nbOfComp2=a2->getNumberOfComponents();
- if(nbOfTuple2==nbOfTuple1)
- {
- if(nbOfComp1==nbOfComp2)
- {
- MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
- ret->alloc(nbOfTuple2,nbOfComp1);
- std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::divides<double>());
- ret->copyStringInfoFrom(*a1);
- return ret.retn();
- }
- else if(nbOfComp2==1)
- {
- MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
- ret->alloc(nbOfTuple1,nbOfComp1);
- const double *a2Ptr=a2->getConstPointer();
- const double *a1Ptr=a1->getConstPointer();
- double *res=ret->getPointer();
- for(int i=0;i<nbOfTuple1;i++)
- res=std::transform(a1Ptr+i*nbOfComp1,a1Ptr+(i+1)*nbOfComp1,res,std::bind2nd(std::divides<double>(),a2Ptr[i]));
- ret->copyStringInfoFrom(*a1);
- return ret.retn();
- }
- else
- {
- a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Divide !");
- return 0;
- }
- }
- else if(nbOfTuple2==1)
- {
- a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Divide !");
- MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
- ret->alloc(nbOfTuple1,nbOfComp1);
- const double *a1ptr=a1->getConstPointer(),*a2ptr=a2->getConstPointer();
- double *pt=ret->getPointer();
- for(int i=0;i<nbOfTuple1;i++)
- pt=std::transform(a1ptr+i*nbOfComp1,a1ptr+(i+1)*nbOfComp1,a2ptr,pt,std::divides<double>());
- ret->copyStringInfoFrom(*a1);
- return ret.retn();
- }
- else
+ int nbOfTuples(getNumberOfTuples());
+ MCAuto<DataArrayDouble> newArr(DataArrayDouble::New());
+ newArr->alloc(nbOfTuples,nbOfComp);
+ INTERP_KERNEL::ExprParser expr(func);
+ expr.parse();
+ std::set<std::string> vars;
+ expr.getTrueSetOfVars(vars);
+ if((int)vars.size()>1)
{
- a1->checkNbOfTuples(nbOfTuple2,"Nb of tuples mismatch for array Divide !");//will always throw an exception
- return 0;
+ std::ostringstream oss; oss << "DataArrayDouble::applyFunc : this method works only with at most one var func expression ! If you need to map comps on variables please use applyFuncCompo or applyFuncNamedCompo instead ! Vars in expr are : ";
+ std::copy(vars.begin(),vars.end(),std::ostream_iterator<std::string>(oss," "));
+ throw INTERP_KERNEL::Exception(oss.str().c_str());
}
-}
-
-/*!
- * Divide values of \a this array by values of another DataArrayDouble. There are 3
- * valid cases.
- * 1. The arrays have same number of tuples and components. Then each value of
- * \a this array is divided by the corresponding value of \a other one, i.e.:
- * _a_ [ i, j ] /= _other_ [ i, j ].
- * 2. The arrays have same number of tuples and \a other array has one component. Then
- * _a_ [ i, j ] /= _other_ [ i, 0 ].
- * 3. The arrays have same number of components and \a other array has one tuple. Then
- * _a_ [ i, j ] /= _a2_ [ 0, j ].
- *
- * \warning No check of division by zero is performed!
- * \param [in] other - an array to divide \a this one by.
- * \throw If \a other is NULL.
- * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
- * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
- * \a other has number of both tuples and components not equal to 1.
- */
-void DataArrayDouble::divideEqual(const DataArrayDouble *other)
-{
- if(!other)
- throw INTERP_KERNEL::Exception("DataArrayDouble::divideEqual : input DataArrayDouble instance is NULL !");
- const char *msg="Nb of tuples mismatch for DataArrayDouble::divideEqual !";
- checkAllocated();
- other->checkAllocated();
- int nbOfTuple=getNumberOfTuples();
- int nbOfTuple2=other->getNumberOfTuples();
- int nbOfComp=getNumberOfComponents();
- int nbOfComp2=other->getNumberOfComponents();
- if(nbOfTuple==nbOfTuple2)
+ if(vars.empty())
{
- if(nbOfComp==nbOfComp2)
- {
- std::transform(begin(),end(),other->begin(),getPointer(),std::divides<double>());
- }
- else if(nbOfComp2==1)
- {
- double *ptr=getPointer();
- const double *ptrc=other->getConstPointer();
- for(int i=0;i<nbOfTuple;i++)
- std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::divides<double>(),*ptrc++));
- }
- else
- throw INTERP_KERNEL::Exception(msg);
+ expr.prepareFastEvaluator();
+ newArr->rearrange(1);
+ newArr->fillWithValue(expr.evaluateDouble());
+ newArr->rearrange(nbOfComp);
+ return newArr.retn();
}
- else if(nbOfTuple2==1)
+ 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)
{
- if(nbOfComp2==nbOfComp)
+ for(int i=0;i<nbOfTuples;i++)
{
- double *ptr=getPointer();
- const double *ptrc=other->getConstPointer();
- for(int i=0;i<nbOfTuple;i++)
- std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::divides<double>());
+ for(int iComp=0;iComp<nbOfComp;iComp++,ptr++,ptrToFill++)
+ {
+ buff=*ptr;
+ expr.evaluateDoubleInternal(stck);
+ *ptrToFill=stck.back();
+ stck.pop_back();
+ }
}
- else
- throw INTERP_KERNEL::Exception(msg);
}
else
- throw INTERP_KERNEL::Exception(msg);
- declareAsNew();
-}
-
-/*!
- * Returns a new DataArrayDouble that is the result of pow of two given arrays. There are 3
- * valid cases.
- *
- * \param [in] a1 - an array to pow up.
- * \param [in] a2 - another array to sum up.
- * \return DataArrayDouble * - the new instance of DataArrayDouble.
- * The caller is to delete this result array using decrRef() as it is no more
- * needed.
- * \throw If either \a a1 or \a a2 is NULL.
- * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
- * \throw If \a a1->getNumberOfComponents() != 1 or \a a2->getNumberOfComponents() != 1.
- * \throw If there is a negative value in \a a1.
- */
-DataArrayDouble *DataArrayDouble::Pow(const DataArrayDouble *a1, const DataArrayDouble *a2)
-{
- if(!a1 || !a2)
- throw INTERP_KERNEL::Exception("DataArrayDouble::Pow : at least one of input instances is null !");
- int nbOfTuple=a1->getNumberOfTuples();
- int nbOfTuple2=a2->getNumberOfTuples();
- int nbOfComp=a1->getNumberOfComponents();
- int nbOfComp2=a2->getNumberOfComponents();
- if(nbOfTuple!=nbOfTuple2)
- throw INTERP_KERNEL::Exception("DataArrayDouble::Pow : number of tuples mismatches !");
- if(nbOfComp!=1 || nbOfComp2!=1)
- throw INTERP_KERNEL::Exception("DataArrayDouble::Pow : number of components of both arrays must be equal to 1 !");
- MCAuto<DataArrayDouble> ret=DataArrayDouble::New(); ret->alloc(nbOfTuple,1);
- const double *ptr1(a1->begin()),*ptr2(a2->begin());
- double *ptr=ret->getPointer();
- for(int i=0;i<nbOfTuple;i++,ptr1++,ptr2++,ptr++)
- {
- if(*ptr1>=0)
- {
- *ptr=pow(*ptr1,*ptr2);
- }
- else
- {
- std::ostringstream oss; oss << "DataArrayDouble::Pow : on tuple #" << i << " of a1 value is < 0 (" << *ptr1 << ") !";
- throw INTERP_KERNEL::Exception(oss.str().c_str());
- }
- }
- return ret.retn();
-}
-
-/*!
- * Apply pow on values of another DataArrayDouble to values of \a this one.
- *
- * \param [in] other - an array to pow to \a this one.
- * \throw If \a other is NULL.
- * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples()
- * \throw If \a this->getNumberOfComponents() != 1 or \a other->getNumberOfComponents() != 1
- * \throw If there is a negative value in \a this.
- */
-void DataArrayDouble::powEqual(const DataArrayDouble *other)
-{
- if(!other)
- throw INTERP_KERNEL::Exception("DataArrayDouble::powEqual : input instance is null !");
- int nbOfTuple=getNumberOfTuples();
- int nbOfTuple2=other->getNumberOfTuples();
- int nbOfComp=getNumberOfComponents();
- int nbOfComp2=other->getNumberOfComponents();
- if(nbOfTuple!=nbOfTuple2)
- throw INTERP_KERNEL::Exception("DataArrayDouble::powEqual : number of tuples mismatches !");
- if(nbOfComp!=1 || nbOfComp2!=1)
- throw INTERP_KERNEL::Exception("DataArrayDouble::powEqual : number of components of both arrays must be equal to 1 !");
- double *ptr=getPointer();
- const double *ptrc=other->begin();
- for(int i=0;i<nbOfTuple;i++,ptrc++,ptr++)
- {
- if(*ptr>=0)
- *ptr=pow(*ptr,*ptrc);
- else
- {
- std::ostringstream oss; oss << "DataArrayDouble::powEqual : on tuple #" << i << " of this value is < 0 (" << *ptr << ") !";
- throw INTERP_KERNEL::Exception(oss.str().c_str());
- }
- }
- declareAsNew();
-}
-
-/*!
- * 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
+ for(int i=0;i<nbOfTuples;i++)
{
- 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());
+ 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 ret;
+ return newArr.retn();
}
/*!
- * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
- * Server side.
+ * 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".
+ * \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
*/
-void DataArrayDouble::getTinySerializationIntInformation(std::vector<int>& tinyInfo) const
+void DataArrayDouble::applyFuncOnThis(const std::string& func, bool isSafe)
{
- tinyInfo.resize(2);
- if(isAllocated())
+ 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);
+ if((int)vars.size()>1)
{
- tinyInfo[0]=getNumberOfTuples();
- tinyInfo[1]=getNumberOfComponents();
+ std::ostringstream oss; oss << "DataArrayDouble::applyFuncOnThis : this method works only with at most one var func expression ! If you need to map comps on variables please use applyFuncCompo or applyFuncNamedCompo instead ! Vars in expr are : ";
+ std::copy(vars.begin(),vars.end(),std::ostream_iterator<std::string>(oss," "));
+ throw INTERP_KERNEL::Exception(oss.str().c_str());
}
- else
+ if(vars.empty())
{
- tinyInfo[0]=-1;
- tinyInfo[1]=-1;
+ expr.prepareFastEvaluator();
+ std::vector<std::string> compInfo(getInfoOnComponents());
+ rearrange(1);
+ fillWithValue(expr.evaluateDouble());
+ rearrange(nbOfComp);
+ setInfoOnComponents(compInfo);
+ return ;
}
-}
-
-/*!
- * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
- * Server side.
- */
-void DataArrayDouble::getTinySerializationStrInformation(std::vector<std::string>& tinyInfo) const
-{
- if(isAllocated())
+ 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)
{
- int nbOfCompo=getNumberOfComponents();
- tinyInfo.resize(nbOfCompo+1);
- tinyInfo[0]=getName();
- for(int i=0;i<nbOfCompo;i++)
- tinyInfo[i+1]=getInfoOnComponent(i);
+ for(int i=0;i<nbOfTuples;i++)
+ {
+ for(int iComp=0;iComp<nbOfComp;iComp++,ptr++,ptrToFill++)
+ {
+ buff=*ptr;
+ expr.evaluateDoubleInternal(stck);
+ *ptrToFill=stck.back();
+ stck.pop_back();
+ }
+ }
}
else
{
- tinyInfo.resize(1);
- tinyInfo[0]=getName();
+ for(int i=0;i<nbOfTuples;i++)
+ {
+ 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();
+ }
+ }
}
}
/*!
- * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
- * This method returns if a feeding is needed.
+ * 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.
*/
-bool DataArrayDouble::resizeForUnserialization(const std::vector<int>& tinyInfoI)
+DataArrayDouble *DataArrayDouble::applyFuncCompo(int nbOfComp, const std::string& func, bool isSafe) const
{
- int nbOfTuple=tinyInfoI[0];
- int nbOfComp=tinyInfoI[1];
- if(nbOfTuple!=-1 || nbOfComp!=-1)
- {
- alloc(nbOfTuple,nbOfComp);
- return true;
- }
- return false;
+ return applyFuncNamedCompo(nbOfComp,getVarsOnComponent(),func,isSafe);
}
/*!
- * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
+ * 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 MEDCouplingArrayApplyFunc3.
+ * \param [in] nbOfComp - number of components in the result array.
+ * \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
+ * needed.
+ * \throw If \a this is not allocated.
+ * \throw If \a func contains vars not in \a varsOrder.
+ * \throw If computing \a func fails.
*/
-void DataArrayDouble::finishUnserialization(const std::vector<int>& tinyInfoI, const std::vector<std::string>& tinyInfoS)
+DataArrayDouble *DataArrayDouble::applyFuncNamedCompo(int nbOfComp, const std::vector<std::string>& varsOrder, const std::string& func, bool isSafe) const
{
- setName(tinyInfoS[0]);
- if(isAllocated())
+ if(nbOfComp<=0)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::applyFuncNamedCompo : output number of component must be > 0 !");
+ std::vector<std::string> varsOrder2(varsOrder);
+ int oldNbOfComp(getNumberOfComponents());
+ for(int i=(int)varsOrder.size();i<oldNbOfComp;i++)
+ varsOrder2.push_back(std::string());
+ checkAllocated();
+ int nbOfTuples(getNumberOfTuples());
+ INTERP_KERNEL::ExprParser expr(func);
+ expr.parse();
+ std::set<std::string> vars;
+ expr.getTrueSetOfVars(vars);
+ if((int)vars.size()>oldNbOfComp)
{
- int nbOfCompo=getNumberOfComponents();
- for(int i=0;i<nbOfCompo;i++)
- setInfoOnComponent(i,tinyInfoS[i+1]);
+ 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());
}
-}
-
-DataArrayDoubleIterator::DataArrayDoubleIterator(DataArrayDouble *da):_da(da),_tuple_id(0),_nb_comp(0),_nb_tuple(0)
-{
- if(_da)
+ MCAuto<DataArrayDouble> newArr(DataArrayDouble::New());
+ newArr->alloc(nbOfTuples,nbOfComp);
+ INTERP_KERNEL::AutoPtr<double> buff(new double[oldNbOfComp]);
+ double *buffPtr(buff),*ptrToFill;
+ std::vector<double> stck;
+ for(int iComp=0;iComp<nbOfComp;iComp++)
{
- _da->incrRef();
- if(_da->isAllocated())
+ expr.prepareExprEvaluationDouble(varsOrder2,oldNbOfComp,nbOfComp,iComp,buffPtr,buffPtr+oldNbOfComp);
+ expr.prepareFastEvaluator();
+ const double *ptr(getConstPointer());
+ ptrToFill=newArr->getPointer()+iComp;
+ if(!isSafe)
{
- _nb_comp=da->getNumberOfComponents();
- _nb_tuple=da->getNumberOfTuples();
- _pt=da->getPointer();
+ 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();
+ }
+ }
+ else
+ {
+ 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.retn();
}
-DataArrayDoubleIterator::~DataArrayDoubleIterator()
-{
- if(_da)
- _da->decrRef();
-}
-
-DataArrayDoubleTuple *DataArrayDoubleIterator::nextt()
+void DataArrayDouble::applyFuncFast32(const std::string& func)
{
- if(_tuple_id<_nb_tuple)
- {
- _tuple_id++;
- DataArrayDoubleTuple *ret=new DataArrayDoubleTuple(_pt,_nb_comp);
- _pt+=_nb_comp;
- return ret;
- }
- else
- return 0;
+ checkAllocated();
+ INTERP_KERNEL::ExprParser expr(func);
+ expr.parse();
+ char *funcStr=expr.compileX86();
+ MYFUNCPTR funcPtr;
+ *((void **)&funcPtr)=funcStr;//he he...
+ //
+ double *ptr=getPointer();
+ int nbOfComp=getNumberOfComponents();
+ int nbOfTuples=getNumberOfTuples();
+ int nbOfElems=nbOfTuples*nbOfComp;
+ for(int i=0;i<nbOfElems;i++,ptr++)
+ *ptr=funcPtr(*ptr);
+ declareAsNew();
}
-DataArrayDoubleTuple::DataArrayDoubleTuple(double *pt, int nbOfComp):_pt(pt),_nb_of_compo(nbOfComp)
+void DataArrayDouble::applyFuncFast64(const std::string& func)
{
+ checkAllocated();
+ INTERP_KERNEL::ExprParser expr(func);
+ expr.parse();
+ char *funcStr=expr.compileX86_64();
+ MYFUNCPTR funcPtr;
+ *((void **)&funcPtr)=funcStr;//he he...
+ //
+ double *ptr=getPointer();
+ int nbOfComp=getNumberOfComponents();
+ int nbOfTuples=getNumberOfTuples();
+ int nbOfElems=nbOfTuples*nbOfComp;
+ for(int i=0;i<nbOfElems;i++,ptr++)
+ *ptr=funcPtr(*ptr);
+ declareAsNew();
}
-
-std::string DataArrayDoubleTuple::repr() const
+/*!
+ * \return a new object that is the result of the symmetry along 3D plane defined by its normal vector \a normalVector and a point \a point.
+ */
+MCAuto<DataArrayDouble> DataArrayDouble::symmetry3DPlane(const double point[3], const double normalVector[3]) const
{
- std::ostringstream oss; oss.precision(17); oss << "(";
- for(int i=0;i<_nb_of_compo-1;i++)
- oss << _pt[i] << ", ";
- oss << _pt[_nb_of_compo-1] << ")";
- return oss.str();
+ checkAllocated();
+ if(getNumberOfComponents()!=3)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::symmetry3DPlane : this is excepted to have 3 components !");
+ int nbTuples(getNumberOfTuples());
+ MCAuto<DataArrayDouble> ret(DataArrayDouble::New());
+ ret->alloc(nbTuples,3);
+ Symmetry3DPlane(point,normalVector,nbTuples,begin(),ret->getPointer());
+ return ret;
}
-double DataArrayDoubleTuple::doubleValue() const
+DataArrayDoubleIterator *DataArrayDouble::iterator()
{
- if(_nb_of_compo==1)
- return *_pt;
- throw INTERP_KERNEL::Exception("DataArrayDoubleTuple::doubleValue : DataArrayDoubleTuple instance has not exactly 1 component -> Not possible to convert it into a double precision float !");
+ return new DataArrayDoubleIterator(this);
}
/*!
- * This method returns a newly allocated instance the caller should dealed with by a MEDCoupling::DataArrayDouble::decrRef.
- * This method performs \b no copy of data. The content is only referenced using MEDCoupling::DataArrayDouble::useArray with ownership set to \b false.
- * 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.
+ * Returns a new DataArrayInt contating indices of tuples of \a this one-dimensional
+ * array whose values are within a given range. Textual data is not copied.
+ * \param [in] vmin - a lowest acceptable value (included).
+ * \param [in] vmax - a greatest acceptable value (included).
+ * \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::findIdsNotInRange
+ *
+ * \if ENABLE_EXAMPLES
+ * \ref cpp_mcdataarraydouble_getidsinrange "Here is a C++ example".<br>
+ * \ref py_mcdataarraydouble_getidsinrange "Here is a Python example".
+ * \endif
*/
-DataArrayDouble *DataArrayDoubleTuple::buildDADouble(int nbOfTuples, int nbOfCompo) const
+DataArrayInt *DataArrayDouble::findIdsInRange(double vmin, double vmax) const
{
- if((_nb_of_compo==nbOfCompo && nbOfTuples==1) || (_nb_of_compo==nbOfTuples && nbOfCompo==1))
- {
- DataArrayDouble *ret=DataArrayDouble::New();
- ret->useExternalArrayWithRWAccess(_pt,nbOfTuples,nbOfCompo);
- return ret;
- }
- else
- {
- std::ostringstream oss; oss << "DataArrayDoubleTuple::buildDADouble : unable to build a requested DataArrayDouble instance with nbofTuple=" << nbOfTuples << " and nbOfCompo=" << nbOfCompo;
- oss << ".\nBecause the number of elements in this is " << _nb_of_compo << " !";
- throw INTERP_KERNEL::Exception(oss.str().c_str());
- }
+ checkAllocated();
+ if(getNumberOfComponents()!=1)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::findIdsInRange : this must have exactly one component !");
+ const double *cptr(begin());
+ MCAuto<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
+ int nbOfTuples(getNumberOfTuples());
+ for(int i=0;i<nbOfTuples;i++,cptr++)
+ if(*cptr>=vmin && *cptr<=vmax)
+ ret->pushBackSilent(i);
+ return ret.retn();
}
/*!
- * Returns a new instance of DataArrayInt. The caller is to delete this array
- * using decrRef() as it is no more needed.
+ * 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::findIdsInRange
*/
-DataArrayInt *DataArrayInt::New()
+DataArrayInt *DataArrayDouble::findIdsNotInRange(double vmin, double vmax) const
{
- return new DataArrayInt;
+ checkAllocated();
+ if(getNumberOfComponents()!=1)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::findIdsNotInRange : this must have exactly one component !");
+ const double *cptr(begin());
+ MCAuto<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
+ int nbOfTuples(getNumberOfTuples());
+ for(int i=0;i<nbOfTuples;i++,cptr++)
+ if(*cptr<vmin || *cptr>vmax)
+ ret->pushBackSilent(i);
+ return ret.retn();
}
/*!
- * Checks if raw data is allocated. Read more on the raw data
- * in \ref MEDCouplingArrayBasicsTuplesAndCompo "DataArrays infos" for more information.
- * \return bool - \a true if the raw data is allocated, \a false else.
+ * 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)
+ * 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.
+ * \param [in] a1 - an array to include in the result array.
+ * \param [in] a2 - another array 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
+ * needed.
+ * \throw If both \a a1 and \a a2 are NULL.
+ * \throw If \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents().
*/
-bool DataArrayInt::isAllocated() const
+DataArrayDouble *DataArrayDouble::Aggregate(const DataArrayDouble *a1, const DataArrayDouble *a2)
{
- return getConstPointer()!=0;
+ std::vector<const DataArrayDouble *> tmp(2);
+ tmp[0]=a1; tmp[1]=a2;
+ return Aggregate(tmp);
}
/*!
- * Checks if raw data is allocated and throws an exception if it is not the case.
- * \throw If the raw data is not allocated.
+ * Returns a new DataArrayDouble 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)
+ * 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
+ * needed.
+ * \throw If all arrays within \a arr are NULL.
+ * \throw If getNumberOfComponents() of arrays within \a arr.
*/
-void DataArrayInt::checkAllocated() const
+DataArrayDouble *DataArrayDouble::Aggregate(const std::vector<const DataArrayDouble *>& arr)
{
- if(!isAllocated())
- throw INTERP_KERNEL::Exception("DataArrayInt::checkAllocated : Array is defined but not allocated ! Call alloc or setValues method first !");
+ std::vector<const DataArrayDouble *> a;
+ for(std::vector<const DataArrayDouble *>::const_iterator it4=arr.begin();it4!=arr.end();it4++)
+ if(*it4)
+ a.push_back(*it4);
+ if(a.empty())
+ throw INTERP_KERNEL::Exception("DataArrayDouble::Aggregate : input list must contain at least one NON EMPTY DataArrayDouble !");
+ std::vector<const DataArrayDouble *>::const_iterator it=a.begin();
+ int nbOfComp=(*it)->getNumberOfComponents();
+ int nbt=(*it++)->getNumberOfTuples();
+ for(int i=1;it!=a.end();it++,i++)
+ {
+ if((*it)->getNumberOfComponents()!=nbOfComp)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::Aggregate : Nb of components mismatch for array aggregation !");
+ nbt+=(*it)->getNumberOfTuples();
+ }
+ MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
+ ret->alloc(nbt,nbOfComp);
+ double *pt=ret->getPointer();
+ for(it=a.begin();it!=a.end();it++)
+ pt=std::copy((*it)->getConstPointer(),(*it)->getConstPointer()+(*it)->getNbOfElems(),pt);
+ ret->copyStringInfoFrom(*(a[0]));
+ return ret.retn();
}
/*!
- * This method desallocated \a this without modification of informations relative to the components.
- * After call of this method, DataArrayInt::isAllocated will return false.
- * If \a this is already not allocated, \a this is let unchanged.
+ * Returns a new DataArrayDouble by aggregating two given arrays, so that (1) the number
+ * of components in the result array is a sum of the number of components of given arrays
+ * and (2) the number of tuples in the result array is same as that of each of given
+ * arrays. In other words the i-th tuple of result array includes all components of
+ * i-th tuples of all given arrays.
+ * Number of tuples in the given arrays must be the same.
+ * \param [in] a1 - an array to include in the result array.
+ * \param [in] a2 - another array 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
+ * needed.
+ * \throw If both \a a1 and \a a2 are NULL.
+ * \throw If any given array is not allocated.
+ * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
*/
-void DataArrayInt::desallocate()
+DataArrayDouble *DataArrayDouble::Meld(const DataArrayDouble *a1, const DataArrayDouble *a2)
{
- _mem.destroy();
+ std::vector<const DataArrayDouble *> arr(2);
+ arr[0]=a1; arr[1]=a2;
+ return Meld(arr);
}
-std::size_t DataArrayInt::getHeapMemorySizeWithoutChildren() const
+/*!
+ * Returns a new DataArrayDouble by aggregating all given arrays, so that (1) the number
+ * of components in the result array is a sum of the number of components of given arrays
+ * and (2) the number of tuples in the result array is same as that of each of given
+ * arrays. In other words the i-th tuple of result array includes all components of
+ * i-th tuples of all given arrays.
+ * Number of tuples in the given arrays must be the same.
+ * \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
+ * needed.
+ * \throw If all arrays within \a arr are NULL.
+ * \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)
{
- std::size_t sz(_mem.getNbOfElemAllocated());
- sz*=sizeof(int);
- return DataArray::getHeapMemorySizeWithoutChildren()+sz;
+ std::vector<const DataArrayDouble *> a;
+ for(std::vector<const DataArrayDouble *>::const_iterator it4=arr.begin();it4!=arr.end();it4++)
+ if(*it4)
+ a.push_back(*it4);
+ if(a.empty())
+ throw INTERP_KERNEL::Exception("DataArrayDouble::Meld : input list must contain at least one NON EMPTY DataArrayDouble !");
+ std::vector<const DataArrayDouble *>::const_iterator it;
+ for(it=a.begin();it!=a.end();it++)
+ (*it)->checkAllocated();
+ it=a.begin();
+ int nbOfTuples=(*it)->getNumberOfTuples();
+ std::vector<int> nbc(a.size());
+ std::vector<const double *> pts(a.size());
+ nbc[0]=(*it)->getNumberOfComponents();
+ pts[0]=(*it++)->getConstPointer();
+ for(int i=1;it!=a.end();it++,i++)
+ {
+ if(nbOfTuples!=(*it)->getNumberOfTuples())
+ throw INTERP_KERNEL::Exception("DataArrayDouble::Meld : mismatch of number of tuples !");
+ nbc[i]=(*it)->getNumberOfComponents();
+ pts[i]=(*it)->getConstPointer();
+ }
+ int totalNbOfComp=std::accumulate(nbc.begin(),nbc.end(),0);
+ DataArrayDouble *ret=DataArrayDouble::New();
+ ret->alloc(nbOfTuples,totalNbOfComp);
+ double *retPtr=ret->getPointer();
+ for(int i=0;i<nbOfTuples;i++)
+ for(int j=0;j<(int)a.size();j++)
+ {
+ retPtr=std::copy(pts[j],pts[j]+nbc[j],retPtr);
+ pts[j]+=nbc[j];
+ }
+ 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));
+ return ret;
}
/*!
- * Returns the only one value in \a this, if and only if number of elements
- * (nb of tuples * nb of components) is equal to 1, and that \a this is allocated.
- * \return double - the sole value stored in \a this array.
- * \throw If at least one of conditions stated above is not fulfilled.
+ * Returns a new DataArrayDouble containing a dot product of two given arrays, so that
+ * the i-th tuple of the result array is a sum of products of j-th components of i-th
+ * tuples of given arrays (\f$ a_i = \sum_{j=1}^n a1_j * a2_j \f$).
+ * Info on components and name is copied from the first of the given arrays.
+ * Number of tuples and components in the given arrays must be the same.
+ * \param [in] a1 - a given array.
+ * \param [in] a2 - another given array.
+ * \return DataArrayDouble * - the new instance of DataArrayDouble.
+ * The caller is to delete this result array using decrRef() as it is no more
+ * needed.
+ * \throw If either \a a1 or \a a2 is NULL.
+ * \throw If any given array is not allocated.
+ * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
+ * \throw If \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents()
*/
-int DataArrayInt::intValue() const
+DataArrayDouble *DataArrayDouble::Dot(const DataArrayDouble *a1, const DataArrayDouble *a2)
{
- if(isAllocated())
+ if(!a1 || !a2)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::Dot : input DataArrayDouble instance is NULL !");
+ a1->checkAllocated();
+ a2->checkAllocated();
+ int nbOfComp=a1->getNumberOfComponents();
+ if(nbOfComp!=a2->getNumberOfComponents())
+ throw INTERP_KERNEL::Exception("Nb of components mismatch for array Dot !");
+ int nbOfTuple=a1->getNumberOfTuples();
+ if(nbOfTuple!=a2->getNumberOfTuples())
+ throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array Dot !");
+ DataArrayDouble *ret=DataArrayDouble::New();
+ ret->alloc(nbOfTuple,1);
+ double *retPtr=ret->getPointer();
+ const double *a1Ptr=a1->getConstPointer();
+ const double *a2Ptr=a2->getConstPointer();
+ for(int i=0;i<nbOfTuple;i++)
{
- if(getNbOfElems()==1)
- {
- return *getConstPointer();
- }
- else
- throw INTERP_KERNEL::Exception("DataArrayInt::intValue : DataArrayInt instance is allocated but number of elements is not equal to 1 !");
+ double sum=0.;
+ for(int j=0;j<nbOfComp;j++)
+ sum+=a1Ptr[i*nbOfComp+j]*a2Ptr[i*nbOfComp+j];
+ retPtr[i]=sum;
}
- else
- throw INTERP_KERNEL::Exception("DataArrayInt::intValue : DataArrayInt instance is not allocated !");
+ ret->setInfoOnComponent(0,a1->getInfoOnComponent(0));
+ ret->setName(a1->getName());
+ return ret;
}
/*!
- * Returns an integer value characterizing \a this array, which is useful for a quick
- * comparison of many instances of DataArrayInt.
- * \return int - the hash value.
- * \throw If \a this is not allocated.
+ * Returns a new DataArrayDouble containing a cross product of two given arrays, so that
+ * the i-th tuple of the result array contains 3 components of a vector which is a cross
+ * product of two vectors defined by the i-th tuples of given arrays.
+ * Info on components is copied from the first of the given arrays.
+ * Number of tuples in the given arrays must be the same.
+ * Number of components in the given arrays must be 3.
+ * \param [in] a1 - a given array.
+ * \param [in] a2 - another given array.
+ * \return DataArrayDouble * - the new instance of DataArrayDouble.
+ * The caller is to delete this result array using decrRef() as it is no more
+ * needed.
+ * \throw If either \a a1 or \a a2 is NULL.
+ * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
+ * \throw If \a a1->getNumberOfComponents() != 3
+ * \throw If \a a2->getNumberOfComponents() != 3
*/
-int DataArrayInt::getHashCode() const
+DataArrayDouble *DataArrayDouble::CrossProduct(const DataArrayDouble *a1, const DataArrayDouble *a2)
{
- checkAllocated();
- std::size_t nbOfElems=getNbOfElems();
- int ret=nbOfElems*65536;
- int delta=3;
- if(nbOfElems>48)
- delta=nbOfElems/8;
- int ret0=0;
- const int *pt=begin();
- for(std::size_t i=0;i<nbOfElems;i+=delta)
- ret0+=pt[i] & 0x1FFF;
- return ret+ret0;
+ if(!a1 || !a2)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::CrossProduct : input DataArrayDouble instance is NULL !");
+ int nbOfComp=a1->getNumberOfComponents();
+ if(nbOfComp!=a2->getNumberOfComponents())
+ throw INTERP_KERNEL::Exception("Nb of components mismatch for array crossProduct !");
+ if(nbOfComp!=3)
+ throw INTERP_KERNEL::Exception("Nb of components must be equal to 3 for array crossProduct !");
+ int nbOfTuple=a1->getNumberOfTuples();
+ if(nbOfTuple!=a2->getNumberOfTuples())
+ throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array crossProduct !");
+ DataArrayDouble *ret=DataArrayDouble::New();
+ ret->alloc(nbOfTuple,3);
+ double *retPtr=ret->getPointer();
+ const double *a1Ptr=a1->getConstPointer();
+ const double *a2Ptr=a2->getConstPointer();
+ for(int i=0;i<nbOfTuple;i++)
+ {
+ retPtr[3*i]=a1Ptr[3*i+1]*a2Ptr[3*i+2]-a1Ptr[3*i+2]*a2Ptr[3*i+1];
+ retPtr[3*i+1]=a1Ptr[3*i+2]*a2Ptr[3*i]-a1Ptr[3*i]*a2Ptr[3*i+2];
+ retPtr[3*i+2]=a1Ptr[3*i]*a2Ptr[3*i+1]-a1Ptr[3*i+1]*a2Ptr[3*i];
+ }
+ ret->copyStringInfoFrom(*a1);
+ return ret;
}
/*!
- * Checks the number of tuples.
- * \return bool - \a true if getNumberOfTuples() == 0, \a false else.
- * \throw If \a this is not allocated.
+ * Returns a new DataArrayDouble containing maximal values of two given arrays.
+ * Info on components is copied from the first of the given arrays.
+ * Number of tuples and components in the given arrays must be the same.
+ * \param [in] a1 - an array to compare values with another one.
+ * \param [in] a2 - another array to compare values with the first one.
+ * \return DataArrayDouble * - the new instance of DataArrayDouble.
+ * The caller is to delete this result array using decrRef() as it is no more
+ * needed.
+ * \throw If either \a a1 or \a a2 is NULL.
+ * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
+ * \throw If \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents()
*/
-bool DataArrayInt::empty() const
+DataArrayDouble *DataArrayDouble::Max(const DataArrayDouble *a1, const DataArrayDouble *a2)
{
- checkAllocated();
- return getNumberOfTuples()==0;
+ if(!a1 || !a2)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::Max : input DataArrayDouble instance is NULL !");
+ int nbOfComp=a1->getNumberOfComponents();
+ if(nbOfComp!=a2->getNumberOfComponents())
+ throw INTERP_KERNEL::Exception("Nb of components mismatch for array Max !");
+ int nbOfTuple=a1->getNumberOfTuples();
+ if(nbOfTuple!=a2->getNumberOfTuples())
+ throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array Max !");
+ DataArrayDouble *ret=DataArrayDouble::New();
+ ret->alloc(nbOfTuple,nbOfComp);
+ double *retPtr=ret->getPointer();
+ const double *a1Ptr=a1->getConstPointer();
+ const double *a2Ptr=a2->getConstPointer();
+ int nbElem=nbOfTuple*nbOfComp;
+ for(int i=0;i<nbElem;i++)
+ retPtr[i]=std::max(a1Ptr[i],a2Ptr[i]);
+ ret->copyStringInfoFrom(*a1);
+ return ret;
}
/*!
- * Returns a full copy of \a this. For more info on copying data arrays see
- * \ref MEDCouplingArrayBasicsCopyDeep.
- * \return DataArrayInt * - a new instance of DataArrayInt.
+ * Returns a new DataArrayDouble containing minimal values of two given arrays.
+ * Info on components is copied from the first of the given arrays.
+ * Number of tuples and components in the given arrays must be the same.
+ * \param [in] a1 - an array to compare values with another one.
+ * \param [in] a2 - another array to compare values with the first one.
+ * \return DataArrayDouble * - the new instance of DataArrayDouble.
+ * The caller is to delete this result array using decrRef() as it is no more
+ * needed.
+ * \throw If either \a a1 or \a a2 is NULL.
+ * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
+ * \throw If \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents()
*/
-DataArrayInt *DataArrayInt::deepCopy() const
+DataArrayDouble *DataArrayDouble::Min(const DataArrayDouble *a1, const DataArrayDouble *a2)
{
- return new DataArrayInt(*this);
+ if(!a1 || !a2)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::Min : input DataArrayDouble instance is NULL !");
+ int nbOfComp=a1->getNumberOfComponents();
+ if(nbOfComp!=a2->getNumberOfComponents())
+ throw INTERP_KERNEL::Exception("Nb of components mismatch for array min !");
+ int nbOfTuple=a1->getNumberOfTuples();
+ if(nbOfTuple!=a2->getNumberOfTuples())
+ throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array min !");
+ DataArrayDouble *ret=DataArrayDouble::New();
+ ret->alloc(nbOfTuple,nbOfComp);
+ double *retPtr=ret->getPointer();
+ const double *a1Ptr=a1->getConstPointer();
+ const double *a2Ptr=a2->getConstPointer();
+ int nbElem=nbOfTuple*nbOfComp;
+ for(int i=0;i<nbElem;i++)
+ retPtr[i]=std::min(a1Ptr[i],a2Ptr[i]);
+ ret->copyStringInfoFrom(*a1);
+ return ret;
}
/*!
- * Returns either a \a deep or \a shallow copy of this array. For more info see
- * \ref MEDCouplingArrayBasicsCopyDeep and \ref MEDCouplingArrayBasicsCopyShallow.
- * \param [in] dCpy - if \a true, a deep copy is returned, else, a shallow one.
- * \return DataArrayInt * - either a new instance of DataArrayInt (if \a dCpy
- * == \a true) or \a this instance (if \a dCpy == \a false).
+ * Returns a new DataArrayDouble that is a sum of two given arrays. There are 3
+ * valid cases.
+ * 1. The arrays have same number of tuples and components. Then each value of
+ * the result array (_a_) is a sum of the corresponding values of \a a1 and \a a2,
+ * i.e.: _a_ [ i, j ] = _a1_ [ i, j ] + _a2_ [ i, j ].
+ * 2. The arrays have same number of tuples and one array, say _a2_, has one
+ * component. Then
+ * _a_ [ i, j ] = _a1_ [ i, j ] + _a2_ [ i, 0 ].
+ * 3. The arrays have same number of components and one array, say _a2_, has one
+ * tuple. Then
+ * _a_ [ i, j ] = _a1_ [ i, j ] + _a2_ [ 0, j ].
+ *
+ * Info on components is copied either from the first array (in the first case) or from
+ * the array with maximal number of elements (getNbOfElems()).
+ * \param [in] a1 - an array to sum up.
+ * \param [in] a2 - another array to sum up.
+ * \return DataArrayDouble * - the new instance of DataArrayDouble.
+ * The caller is to delete this result array using decrRef() as it is no more
+ * needed.
+ * \throw If either \a a1 or \a a2 is NULL.
+ * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
+ * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
+ * none of them has number of tuples or components equal to 1.
*/
-DataArrayInt *DataArrayInt::performCopyOrIncrRef(bool dCpy) const
+DataArrayDouble *DataArrayDouble::Add(const DataArrayDouble *a1, const DataArrayDouble *a2)
{
- if(dCpy)
- return deepCopy();
- else
+ if(!a1 || !a2)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::Add : input DataArrayDouble instance is NULL !");
+ int nbOfTuple=a1->getNumberOfTuples();
+ int nbOfTuple2=a2->getNumberOfTuples();
+ int nbOfComp=a1->getNumberOfComponents();
+ int nbOfComp2=a2->getNumberOfComponents();
+ MCAuto<DataArrayDouble> ret=0;
+ if(nbOfTuple==nbOfTuple2)
{
- incrRef();
- return const_cast<DataArrayInt *>(this);
+ if(nbOfComp==nbOfComp2)
+ {
+ ret=DataArrayDouble::New();
+ ret->alloc(nbOfTuple,nbOfComp);
+ std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::plus<double>());
+ ret->copyStringInfoFrom(*a1);
+ }
+ else
+ {
+ int nbOfCompMin,nbOfCompMax;
+ const DataArrayDouble *aMin, *aMax;
+ if(nbOfComp>nbOfComp2)
+ {
+ nbOfCompMin=nbOfComp2; nbOfCompMax=nbOfComp;
+ aMin=a2; aMax=a1;
+ }
+ else
+ {
+ nbOfCompMin=nbOfComp; nbOfCompMax=nbOfComp2;
+ aMin=a1; aMax=a2;
+ }
+ if(nbOfCompMin==1)
+ {
+ ret=DataArrayDouble::New();
+ ret->alloc(nbOfTuple,nbOfCompMax);
+ const double *aMinPtr=aMin->getConstPointer();
+ const double *aMaxPtr=aMax->getConstPointer();
+ double *res=ret->getPointer();
+ for(int i=0;i<nbOfTuple;i++)
+ res=std::transform(aMaxPtr+i*nbOfCompMax,aMaxPtr+(i+1)*nbOfCompMax,res,std::bind2nd(std::plus<double>(),aMinPtr[i]));
+ ret->copyStringInfoFrom(*aMax);
+ }
+ else
+ throw INTERP_KERNEL::Exception("Nb of components mismatch for array Add !");
+ }
+ }
+ else if((nbOfTuple==1 && nbOfTuple2>1) || (nbOfTuple>1 && nbOfTuple2==1))
+ {
+ if(nbOfComp==nbOfComp2)
+ {
+ int nbOfTupleMax=std::max(nbOfTuple,nbOfTuple2);
+ const DataArrayDouble *aMin=nbOfTuple>nbOfTuple2?a2:a1;
+ const DataArrayDouble *aMax=nbOfTuple>nbOfTuple2?a1:a2;
+ const double *aMinPtr=aMin->getConstPointer(),*aMaxPtr=aMax->getConstPointer();
+ ret=DataArrayDouble::New();
+ ret->alloc(nbOfTupleMax,nbOfComp);
+ double *res=ret->getPointer();
+ for(int i=0;i<nbOfTupleMax;i++)
+ res=std::transform(aMaxPtr+i*nbOfComp,aMaxPtr+(i+1)*nbOfComp,aMinPtr,res,std::plus<double>());
+ ret->copyStringInfoFrom(*aMax);
+ }
+ else
+ throw INTERP_KERNEL::Exception("Nb of components mismatch for array Add !");
}
+ else
+ throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array Add !");
+ return ret.retn();
}
/*!
- * Copies all the data from another DataArrayInt. For more info see
- * \ref MEDCouplingArrayBasicsCopyDeepAssign.
- * \param [in] other - another instance of DataArrayInt to copy data from.
- * \throw If the \a other is not allocated.
- */
-void DataArrayInt::deepCopyFrom(const DataArrayInt& other)
-{
- other.checkAllocated();
- int nbOfTuples=other.getNumberOfTuples();
- int nbOfComp=other.getNumberOfComponents();
- allocIfNecessary(nbOfTuples,nbOfComp);
- std::size_t nbOfElems=(std::size_t)nbOfTuples*nbOfComp;
- int *pt=getPointer();
- const int *ptI=other.getConstPointer();
- for(std::size_t i=0;i<nbOfElems;i++)
- pt[i]=ptI[i];
- copyStringInfoFrom(other);
-}
-
-/*!
- * This method reserve nbOfElems elements in memory ( nbOfElems*4 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 DataArrayInt::pushBackSilent and DataArrayInt::pushBackValsSilent on \a this.
- *
- * \sa DataArrayInt::pack, DataArrayInt::pushBackSilent, DataArrayInt::pushBackValsSilent
+ * Adds values of another DataArrayDouble to values of \a this one. There are 3
+ * valid cases.
+ * 1. The arrays have same number of tuples and components. Then each value of
+ * \a other array is added to the corresponding value of \a this array, i.e.:
+ * _a_ [ i, j ] += _other_ [ i, j ].
+ * 2. The arrays have same number of tuples and \a other array has one component. Then
+ * _a_ [ i, j ] += _other_ [ i, 0 ].
+ * 3. The arrays have same number of components and \a other array has one tuple. Then
+ * _a_ [ i, j ] += _a2_ [ 0, j ].
+ *
+ * \param [in] other - an array to add to \a this one.
+ * \throw If \a other is NULL.
+ * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
+ * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
+ * \a other has number of both tuples and components not equal to 1.
*/
-void DataArrayInt::reserve(std::size_t nbOfElems)
+void DataArrayDouble::addEqual(const DataArrayDouble *other)
{
- int nbCompo=getNumberOfComponents();
- if(nbCompo==1)
+ if(!other)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::addEqual : input DataArrayDouble instance is NULL !");
+ const char *msg="Nb of tuples mismatch for DataArrayDouble::addEqual !";
+ checkAllocated();
+ other->checkAllocated();
+ int nbOfTuple=getNumberOfTuples();
+ int nbOfTuple2=other->getNumberOfTuples();
+ int nbOfComp=getNumberOfComponents();
+ int nbOfComp2=other->getNumberOfComponents();
+ if(nbOfTuple==nbOfTuple2)
{
- _mem.reserve(nbOfElems);
+ if(nbOfComp==nbOfComp2)
+ {
+ std::transform(begin(),end(),other->begin(),getPointer(),std::plus<double>());
+ }
+ else if(nbOfComp2==1)
+ {
+ double *ptr=getPointer();
+ const double *ptrc=other->getConstPointer();
+ for(int i=0;i<nbOfTuple;i++)
+ std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::plus<double>(),*ptrc++));
+ }
+ else
+ throw INTERP_KERNEL::Exception(msg);
}
- else if(nbCompo==0)
+ else if(nbOfTuple2==1)
{
- _mem.reserve(nbOfElems);
- _info_on_compo.resize(1);
+ if(nbOfComp2==nbOfComp)
+ {
+ double *ptr=getPointer();
+ const double *ptrc=other->getConstPointer();
+ for(int i=0;i<nbOfTuple;i++)
+ std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::plus<double>());
+ }
+ else
+ throw INTERP_KERNEL::Exception(msg);
}
else
- throw INTERP_KERNEL::Exception("DataArrayInt::reserve : not available for DataArrayInt with number of components different than 1 !");
+ throw INTERP_KERNEL::Exception(msg);
+ declareAsNew();
}
/*!
- * This method adds at the end of \a this the single value \a val. 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.
+ * Returns a new DataArrayDouble that is a subtraction of two given arrays. There are 3
+ * valid cases.
+ * 1. The arrays have same number of tuples and components. Then each value of
+ * the result array (_a_) is a subtraction of the corresponding values of \a a1 and
+ * \a a2, i.e.: _a_ [ i, j ] = _a1_ [ i, j ] - _a2_ [ i, j ].
+ * 2. The arrays have same number of tuples and one array, say _a2_, has one
+ * component. Then
+ * _a_ [ i, j ] = _a1_ [ i, j ] - _a2_ [ i, 0 ].
+ * 3. The arrays have same number of components and one array, say _a2_, has one
+ * tuple. Then
+ * _a_ [ i, j ] = _a1_ [ i, j ] - _a2_ [ 0, j ].
*
- * \param [in] val the value to be added in \a this
- * \throw If \a this has already been allocated with number of components different from one.
- * \sa DataArrayInt::pushBackValsSilent
+ * Info on components is copied either from the first array (in the first case) or from
+ * the array with maximal number of elements (getNbOfElems()).
+ * \param [in] a1 - an array to subtract from.
+ * \param [in] a2 - an array to subtract.
+ * \return DataArrayDouble * - the new instance of DataArrayDouble.
+ * The caller is to delete this result array using decrRef() as it is no more
+ * needed.
+ * \throw If either \a a1 or \a a2 is NULL.
+ * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
+ * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
+ * none of them has number of tuples or components equal to 1.
*/
-void DataArrayInt::pushBackSilent(int val)
+DataArrayDouble *DataArrayDouble::Substract(const DataArrayDouble *a1, const DataArrayDouble *a2)
{
- int nbCompo=getNumberOfComponents();
- if(nbCompo==1)
- _mem.pushBack(val);
- else if(nbCompo==0)
+ if(!a1 || !a2)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::Substract : input DataArrayDouble instance is NULL !");
+ int nbOfTuple1=a1->getNumberOfTuples();
+ int nbOfTuple2=a2->getNumberOfTuples();
+ int nbOfComp1=a1->getNumberOfComponents();
+ int nbOfComp2=a2->getNumberOfComponents();
+ if(nbOfTuple2==nbOfTuple1)
+ {
+ if(nbOfComp1==nbOfComp2)
+ {
+ MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
+ ret->alloc(nbOfTuple2,nbOfComp1);
+ std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::minus<double>());
+ ret->copyStringInfoFrom(*a1);
+ return ret.retn();
+ }
+ else if(nbOfComp2==1)
+ {
+ MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
+ ret->alloc(nbOfTuple1,nbOfComp1);
+ const double *a2Ptr=a2->getConstPointer();
+ const double *a1Ptr=a1->getConstPointer();
+ double *res=ret->getPointer();
+ for(int i=0;i<nbOfTuple1;i++)
+ res=std::transform(a1Ptr+i*nbOfComp1,a1Ptr+(i+1)*nbOfComp1,res,std::bind2nd(std::minus<double>(),a2Ptr[i]));
+ ret->copyStringInfoFrom(*a1);
+ return ret.retn();
+ }
+ else
+ {
+ a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Substract !");
+ return 0;
+ }
+ }
+ else if(nbOfTuple2==1)
{
- _info_on_compo.resize(1);
- _mem.pushBack(val);
+ a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Substract !");
+ MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
+ ret->alloc(nbOfTuple1,nbOfComp1);
+ const double *a1ptr=a1->getConstPointer(),*a2ptr=a2->getConstPointer();
+ double *pt=ret->getPointer();
+ for(int i=0;i<nbOfTuple1;i++)
+ pt=std::transform(a1ptr+i*nbOfComp1,a1ptr+(i+1)*nbOfComp1,a2ptr,pt,std::minus<double>());
+ ret->copyStringInfoFrom(*a1);
+ return ret.retn();
}
else
- throw INTERP_KERNEL::Exception("DataArrayInt::pushBackSilent : not available for DataArrayInt with number of components different than 1 !");
+ {
+ a1->checkNbOfTuples(nbOfTuple2,"Nb of tuples mismatch for array Substract !");//will always throw an exception
+ return 0;
+ }
}
/*!
- * 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
- * of counter. So the caller is expected to call TimeLabel::declareAsNew on \a this at the end of the push session.
+ * Subtract values of another DataArrayDouble from values of \a this one. There are 3
+ * valid cases.
+ * 1. The arrays have same number of tuples and components. Then each value of
+ * \a other array is subtracted from the corresponding value of \a this array, i.e.:
+ * _a_ [ i, j ] -= _other_ [ i, j ].
+ * 2. The arrays have same number of tuples and \a other array has one component. Then
+ * _a_ [ i, j ] -= _other_ [ i, 0 ].
+ * 3. The arrays have same number of components and \a other array has one tuple. Then
+ * _a_ [ i, j ] -= _a2_ [ 0, j ].
*
- * \param [in] valsBg - an array of values to push at the end of \c this.
- * \param [in] valsEnd - specifies the end of the array \a valsBg, so that
- * the last value of \a valsBg is \a valsEnd[ -1 ].
- * \throw If \a this has already been allocated with number of components different from one.
- * \sa DataArrayInt::pushBackSilent
+ * \param [in] other - an array to subtract from \a this one.
+ * \throw If \a other is NULL.
+ * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
+ * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
+ * \a other has number of both tuples and components not equal to 1.
*/
-void DataArrayInt::pushBackValsSilent(const int *valsBg, const int *valsEnd)
+void DataArrayDouble::substractEqual(const DataArrayDouble *other)
{
- int nbCompo=getNumberOfComponents();
- if(nbCompo==1)
- _mem.insertAtTheEnd(valsBg,valsEnd);
- else if(nbCompo==0)
+ if(!other)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::substractEqual : input DataArrayDouble instance is NULL !");
+ const char *msg="Nb of tuples mismatch for DataArrayDouble::substractEqual !";
+ checkAllocated();
+ other->checkAllocated();
+ int nbOfTuple=getNumberOfTuples();
+ int nbOfTuple2=other->getNumberOfTuples();
+ int nbOfComp=getNumberOfComponents();
+ int nbOfComp2=other->getNumberOfComponents();
+ if(nbOfTuple==nbOfTuple2)
{
- _info_on_compo.resize(1);
- _mem.insertAtTheEnd(valsBg,valsEnd);
+ if(nbOfComp==nbOfComp2)
+ {
+ std::transform(begin(),end(),other->begin(),getPointer(),std::minus<double>());
+ }
+ else if(nbOfComp2==1)
+ {
+ double *ptr=getPointer();
+ const double *ptrc=other->getConstPointer();
+ for(int i=0;i<nbOfTuple;i++)
+ std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::minus<double>(),*ptrc++));
+ }
+ else
+ throw INTERP_KERNEL::Exception(msg);
+ }
+ else if(nbOfTuple2==1)
+ {
+ if(nbOfComp2==nbOfComp)
+ {
+ double *ptr=getPointer();
+ const double *ptrc=other->getConstPointer();
+ for(int i=0;i<nbOfTuple;i++)
+ std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::minus<double>());
+ }
+ else
+ throw INTERP_KERNEL::Exception(msg);
}
else
- throw INTERP_KERNEL::Exception("DataArrayInt::pushBackValsSilent : not available for DataArrayInt with number of components different than 1 !");
-}
-
-/*!
- * This method returns silently ( without updating time label in \a this ) the last value, if any and suppress it.
- * \throw If \a this is already empty.
- * \throw If \a this has number of components different from one.
- */
-int DataArrayInt::popBackSilent()
-{
- if(getNumberOfComponents()==1)
- return _mem.popBack();
- else
- throw INTERP_KERNEL::Exception("DataArrayInt::popBackSilent : not available for DataArrayInt with number of components different than 1 !");
+ throw INTERP_KERNEL::Exception(msg);
+ declareAsNew();
}
/*!
- * 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.
+ * Returns a new DataArrayDouble that is a product of two given arrays. There are 3
+ * valid cases.
+ * 1. The arrays have same number of tuples and components. Then each value of
+ * the result array (_a_) is a product of the corresponding values of \a a1 and
+ * \a a2, i.e. _a_ [ i, j ] = _a1_ [ i, j ] * _a2_ [ i, j ].
+ * 2. The arrays have same number of tuples and one array, say _a2_, has one
+ * component. Then
+ * _a_ [ i, j ] = _a1_ [ i, j ] * _a2_ [ i, 0 ].
+ * 3. The arrays have same number of components and one array, say _a2_, has one
+ * tuple. Then
+ * _a_ [ i, j ] = _a1_ [ i, j ] * _a2_ [ 0, j ].
*
- * \sa DataArrayInt::getHeapMemorySizeWithoutChildren, DataArrayInt::reserve
- */
-void DataArrayInt::pack() const
-{
- _mem.pack();
-}
-
-/*!
- * Allocates the raw data in memory. If exactly as same memory as needed already
- * allocated, it is not re-allocated.
- * \param [in] nbOfTuple - number of tuples of data to allocate.
- * \param [in] nbOfCompo - number of components of data to allocate.
- * \throw If \a nbOfTuple < 0 or \a nbOfCompo < 0.
+ * Info on components is copied either from the first array (in the first case) or from
+ * the array with maximal number of elements (getNbOfElems()).
+ * \param [in] a1 - a factor array.
+ * \param [in] a2 - another factor array.
+ * \return DataArrayDouble * - the new instance of DataArrayDouble.
+ * The caller is to delete this result array using decrRef() as it is no more
+ * needed.
+ * \throw If either \a a1 or \a a2 is NULL.
+ * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
+ * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
+ * none of them has number of tuples or components equal to 1.
*/
-void DataArrayInt::allocIfNecessary(int nbOfTuple, int nbOfCompo)
+DataArrayDouble *DataArrayDouble::Multiply(const DataArrayDouble *a1, const DataArrayDouble *a2)
{
- if(isAllocated())
+ if(!a1 || !a2)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::Multiply : input DataArrayDouble instance is NULL !");
+ int nbOfTuple=a1->getNumberOfTuples();
+ int nbOfTuple2=a2->getNumberOfTuples();
+ int nbOfComp=a1->getNumberOfComponents();
+ int nbOfComp2=a2->getNumberOfComponents();
+ MCAuto<DataArrayDouble> ret=0;
+ if(nbOfTuple==nbOfTuple2)
+ {
+ if(nbOfComp==nbOfComp2)
+ {
+ ret=DataArrayDouble::New();
+ ret->alloc(nbOfTuple,nbOfComp);
+ std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::multiplies<double>());
+ ret->copyStringInfoFrom(*a1);
+ }
+ else
+ {
+ int nbOfCompMin,nbOfCompMax;
+ const DataArrayDouble *aMin, *aMax;
+ if(nbOfComp>nbOfComp2)
+ {
+ nbOfCompMin=nbOfComp2; nbOfCompMax=nbOfComp;
+ aMin=a2; aMax=a1;
+ }
+ else
+ {
+ nbOfCompMin=nbOfComp; nbOfCompMax=nbOfComp2;
+ aMin=a1; aMax=a2;
+ }
+ if(nbOfCompMin==1)
+ {
+ ret=DataArrayDouble::New();
+ ret->alloc(nbOfTuple,nbOfCompMax);
+ const double *aMinPtr=aMin->getConstPointer();
+ const double *aMaxPtr=aMax->getConstPointer();
+ double *res=ret->getPointer();
+ for(int i=0;i<nbOfTuple;i++)
+ res=std::transform(aMaxPtr+i*nbOfCompMax,aMaxPtr+(i+1)*nbOfCompMax,res,std::bind2nd(std::multiplies<double>(),aMinPtr[i]));
+ ret->copyStringInfoFrom(*aMax);
+ }
+ else
+ throw INTERP_KERNEL::Exception("Nb of components mismatch for array Multiply !");
+ }
+ }
+ else if((nbOfTuple==1 && nbOfTuple2>1) || (nbOfTuple>1 && nbOfTuple2==1))
{
- if(nbOfTuple!=getNumberOfTuples() || nbOfCompo!=getNumberOfComponents())
- alloc(nbOfTuple,nbOfCompo);
+ if(nbOfComp==nbOfComp2)
+ {
+ int nbOfTupleMax=std::max(nbOfTuple,nbOfTuple2);
+ const DataArrayDouble *aMin=nbOfTuple>nbOfTuple2?a2:a1;
+ const DataArrayDouble *aMax=nbOfTuple>nbOfTuple2?a1:a2;
+ const double *aMinPtr=aMin->getConstPointer(),*aMaxPtr=aMax->getConstPointer();
+ ret=DataArrayDouble::New();
+ ret->alloc(nbOfTupleMax,nbOfComp);
+ double *res=ret->getPointer();
+ for(int i=0;i<nbOfTupleMax;i++)
+ res=std::transform(aMaxPtr+i*nbOfComp,aMaxPtr+(i+1)*nbOfComp,aMinPtr,res,std::multiplies<double>());
+ ret->copyStringInfoFrom(*aMax);
+ }
+ else
+ throw INTERP_KERNEL::Exception("Nb of components mismatch for array Multiply !");
}
else
- alloc(nbOfTuple,nbOfCompo);
-}
-
-/*!
- * Allocates the raw data in memory. If the memory was already allocated, then it is
- * freed and re-allocated. See an example of this method use
- * \ref MEDCouplingArraySteps1WC "here".
- * \param [in] nbOfTuple - number of tuples of data to allocate.
- * \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)
-{
- if(nbOfTuple<0 || nbOfCompo<0)
- throw INTERP_KERNEL::Exception("DataArrayInt::alloc : request for negative length of data !");
- _info_on_compo.resize(nbOfCompo);
- _mem.alloc(nbOfCompo*(std::size_t)nbOfTuple);
- declareAsNew();
-}
-
-/*!
- * 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.
- */
-void DataArrayInt::fillWithZero()
-{
- checkAllocated();
- _mem.fillWithValue(0);
- declareAsNew();
-}
-
-/*!
- * Assign \a val to all values in \a this array. To know more on filling arrays see
- * \ref MEDCouplingArrayFill.
- * \param [in] val - the value to fill with.
- * \throw If \a this is not allocated.
- */
-void DataArrayInt::fillWithValue(int val)
-{
- checkAllocated();
- _mem.fillWithValue(val);
- declareAsNew();
+ throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array Multiply !");
+ return ret.retn();
}
/*!
- * Set all values in \a this array so that the i-th element equals to \a init + i
- * (i starts from zero). To know more on filling arrays see \ref MEDCouplingArrayFill.
- * \param [in] init - value to assign to the first element of array.
- * \throw If \a this->getNumberOfComponents() != 1
- * \throw If \a this is not allocated.
+ * Multiply values of another DataArrayDouble to values of \a this one. There are 3
+ * valid cases.
+ * 1. The arrays have same number of tuples and components. Then each value of
+ * \a other array is multiplied to the corresponding value of \a this array, i.e.
+ * _this_ [ i, j ] *= _other_ [ i, j ].
+ * 2. The arrays have same number of tuples and \a other array has one component. Then
+ * _this_ [ i, j ] *= _other_ [ i, 0 ].
+ * 3. The arrays have same number of components and \a other array has one tuple. Then
+ * _this_ [ i, j ] *= _a2_ [ 0, j ].
+ *
+ * \param [in] other - an array to multiply to \a this one.
+ * \throw If \a other is NULL.
+ * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
+ * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
+ * \a other has number of both tuples and components not equal to 1.
*/
-void DataArrayInt::iota(int init)
+void DataArrayDouble::multiplyEqual(const DataArrayDouble *other)
{
+ if(!other)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::multiplyEqual : input DataArrayDouble instance is NULL !");
+ const char *msg="Nb of tuples mismatch for DataArrayDouble::multiplyEqual !";
checkAllocated();
- if(getNumberOfComponents()!=1)
- throw INTERP_KERNEL::Exception("DataArrayInt::iota : works only for arrays with only one component, you can call 'rearrange' method before !");
- int *ptr=getPointer();
- int ntuples=getNumberOfTuples();
- for(int i=0;i<ntuples;i++)
- ptr[i]=init+i;
+ other->checkAllocated();
+ int nbOfTuple=getNumberOfTuples();
+ int nbOfTuple2=other->getNumberOfTuples();
+ int nbOfComp=getNumberOfComponents();
+ int nbOfComp2=other->getNumberOfComponents();
+ if(nbOfTuple==nbOfTuple2)
+ {
+ if(nbOfComp==nbOfComp2)
+ {
+ std::transform(begin(),end(),other->begin(),getPointer(),std::multiplies<double>());
+ }
+ else if(nbOfComp2==1)
+ {
+ double *ptr=getPointer();
+ const double *ptrc=other->getConstPointer();
+ for(int i=0;i<nbOfTuple;i++)
+ std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::multiplies<double>(),*ptrc++));
+ }
+ else
+ throw INTERP_KERNEL::Exception(msg);
+ }
+ else if(nbOfTuple2==1)
+ {
+ if(nbOfComp2==nbOfComp)
+ {
+ double *ptr=getPointer();
+ const double *ptrc=other->getConstPointer();
+ for(int i=0;i<nbOfTuple;i++)
+ std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::multiplies<double>());
+ }
+ else
+ throw INTERP_KERNEL::Exception(msg);
+ }
+ else
+ throw INTERP_KERNEL::Exception(msg);
declareAsNew();
}
/*!
- * Returns a textual and human readable representation of \a this instance of
- * DataArrayInt. This text is shown when a DataArrayInt is printed in Python.
- * \return std::string - text describing \a this DataArrayInt.
- *
- * \sa reprNotTooLong, reprZip
- */
-std::string DataArrayInt::repr() const
-{
- std::ostringstream ret;
- reprStream(ret);
- return ret.str();
-}
-
-std::string DataArrayInt::reprZip() const
-{
- std::ostringstream ret;
- reprZipStream(ret);
- return ret.str();
-}
-
-/*!
- * 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
+ * Returns a new DataArrayDouble that is a division of two given arrays. There are 3
+ * valid cases.
+ * 1. The arrays have same number of tuples and components. Then each value of
+ * the result array (_a_) is a division of the corresponding values of \a a1 and
+ * \a a2, i.e.: _a_ [ i, j ] = _a1_ [ i, j ] / _a2_ [ i, j ].
+ * 2. The arrays have same number of tuples and one array, say _a2_, has one
+ * component. Then
+ * _a_ [ i, j ] = _a1_ [ i, j ] / _a2_ [ i, 0 ].
+ * 3. The arrays have same number of components and one array, say _a2_, has one
+ * tuple. Then
+ * _a_ [ i, j ] = _a1_ [ i, j ] / _a2_ [ 0, j ].
+ *
+ * Info on components is copied either from the first array (in the first case) or from
+ * the array with maximal number of elements (getNbOfElems()).
+ * \warning No check of division by zero is performed!
+ * \param [in] a1 - a numerator array.
+ * \param [in] a2 - a denominator array.
+ * \return DataArrayDouble * - the new instance of DataArrayDouble.
+ * The caller is to delete this result array using decrRef() as it is no more
+ * needed.
+ * \throw If either \a a1 or \a a2 is NULL.
+ * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
+ * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
+ * none of them has number of tuples or components equal to 1.
*/
-std::string DataArrayInt::reprNotTooLong() const
-{
- std::ostringstream ret;
- reprNotTooLongStream(ret);
- return ret.str();
-}
-
-void DataArrayInt::writeVTK(std::ostream& ofs, int indent, const std::string& type, const std::string& nameInFile, DataArrayByte *byteArr) const
+DataArrayDouble *DataArrayDouble::Divide(const DataArrayDouble *a1, const DataArrayDouble *a2)
{
- static const char SPACE[4]={' ',' ',' ',' '};
- checkAllocated();
- std::string idt(indent,' ');
- ofs << idt << "<DataArray type=\"" << type << "\" Name=\"" << nameInFile << "\" NumberOfComponents=\"" << getNumberOfComponents() << "\"";
- if(byteArr)
+ if(!a1 || !a2)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::Divide : input DataArrayDouble instance is NULL !");
+ int nbOfTuple1=a1->getNumberOfTuples();
+ int nbOfTuple2=a2->getNumberOfTuples();
+ int nbOfComp1=a1->getNumberOfComponents();
+ int nbOfComp2=a2->getNumberOfComponents();
+ if(nbOfTuple2==nbOfTuple1)
{
- ofs << " format=\"appended\" offset=\"" << byteArr->getNumberOfTuples() << "\">";
- if(std::string(type)=="Int32")
+ if(nbOfComp1==nbOfComp2)
{
- 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);
+ MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
+ ret->alloc(nbOfTuple2,nbOfComp1);
+ std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::divides<double>());
+ ret->copyStringInfoFrom(*a1);
+ return ret.retn();
}
- else if(std::string(type)=="Int8")
+ else if(nbOfComp2==1)
{
- 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);
+ MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
+ ret->alloc(nbOfTuple1,nbOfComp1);
+ const double *a2Ptr=a2->getConstPointer();
+ const double *a1Ptr=a1->getConstPointer();
+ double *res=ret->getPointer();
+ for(int i=0;i<nbOfTuple1;i++)
+ res=std::transform(a1Ptr+i*nbOfComp1,a1Ptr+(i+1)*nbOfComp1,res,std::bind2nd(std::divides<double>(),a2Ptr[i]));
+ ret->copyStringInfoFrom(*a1);
+ return ret.retn();
}
- else if(std::string(type)=="UInt8")
+ else
{
- 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);
+ a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Divide !");
+ return 0;
}
- 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
-{
- stream << "Name of int array : \"" << _name << "\"\n";
- reprWithoutNameStream(stream);
-}
-
-void DataArrayInt::reprZipStream(std::ostream& stream) const
-{
- stream << "Name of int array : \"" << _name << "\"\n";
- reprZipWithoutNameStream(stream);
-}
-
-void DataArrayInt::reprNotTooLongStream(std::ostream& stream) const
-{
- stream << "Name of int array : \"" << _name << "\"\n";
- reprNotTooLongWithoutNameStream(stream);
-}
-
-void DataArrayInt::reprWithoutNameStream(std::ostream& stream) const
-{
- DataArray::reprWithoutNameStream(stream);
- _mem.repr(getNumberOfComponents(),stream);
-}
-
-void DataArrayInt::reprZipWithoutNameStream(std::ostream& stream) const
-{
- DataArray::reprWithoutNameStream(stream);
- _mem.reprZip(getNumberOfComponents(),stream);
-}
-
-void DataArrayInt::reprNotTooLongWithoutNameStream(std::ostream& stream) const
-{
- DataArray::reprWithoutNameStream(stream);
- stream.precision(17);
- _mem.reprNotTooLong(getNumberOfComponents(),stream);
-}
-
-void DataArrayInt::reprCppStream(const std::string& varName, std::ostream& stream) const
-{
- int nbTuples=getNumberOfTuples(),nbComp=getNumberOfComponents();
- const int *data=getConstPointer();
- stream << "DataArrayInt *" << varName << "=DataArrayInt::New();" << std::endl;
- if(nbTuples*nbComp>=1)
+ else if(nbOfTuple2==1)
{
- stream << "const int " << varName << "Data[" << nbTuples*nbComp << "]={";
- std::copy(data,data+nbTuples*nbComp-1,std::ostream_iterator<int>(stream,","));
- stream << data[nbTuples*nbComp-1] << "};" << std::endl;
- stream << varName << "->useArray(" << varName << "Data,false,CPP_DEALLOC," << nbTuples << "," << nbComp << ");" << std::endl;
+ a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Divide !");
+ MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
+ ret->alloc(nbOfTuple1,nbOfComp1);
+ const double *a1ptr=a1->getConstPointer(),*a2ptr=a2->getConstPointer();
+ double *pt=ret->getPointer();
+ for(int i=0;i<nbOfTuple1;i++)
+ pt=std::transform(a1ptr+i*nbOfComp1,a1ptr+(i+1)*nbOfComp1,a2ptr,pt,std::divides<double>());
+ ret->copyStringInfoFrom(*a1);
+ return ret.retn();
}
else
- stream << varName << "->alloc(" << nbTuples << "," << nbComp << ");" << std::endl;
- stream << varName << "->setName(\"" << getName() << "\");" << std::endl;
+ {
+ a1->checkNbOfTuples(nbOfTuple2,"Nb of tuples mismatch for array Divide !");//will always throw an exception
+ return 0;
+ }
}
/*!
- * Method that gives a quick overvien of \a this for python.
+ * Divide values of \a this array by values of another DataArrayDouble. There are 3
+ * valid cases.
+ * 1. The arrays have same number of tuples and components. Then each value of
+ * \a this array is divided by the corresponding value of \a other one, i.e.:
+ * _a_ [ i, j ] /= _other_ [ i, j ].
+ * 2. The arrays have same number of tuples and \a other array has one component. Then
+ * _a_ [ i, j ] /= _other_ [ i, 0 ].
+ * 3. The arrays have same number of components and \a other array has one tuple. Then
+ * _a_ [ i, j ] /= _a2_ [ 0, j ].
+ *
+ * \warning No check of division by zero is performed!
+ * \param [in] other - an array to divide \a this one by.
+ * \throw If \a other is NULL.
+ * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
+ * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
+ * \a other has number of both tuples and components not equal to 1.
*/
-void DataArrayInt::reprQuickOverview(std::ostream& stream) const
+void DataArrayDouble::divideEqual(const DataArrayDouble *other)
{
- static const std::size_t MAX_NB_OF_BYTE_IN_REPR=300;
- stream << "DataArrayInt C++ instance at " << this << ". ";
- if(isAllocated())
+ if(!other)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::divideEqual : input DataArrayDouble instance is NULL !");
+ const char *msg="Nb of tuples mismatch for DataArrayDouble::divideEqual !";
+ checkAllocated();
+ other->checkAllocated();
+ int nbOfTuple=getNumberOfTuples();
+ int nbOfTuple2=other->getNumberOfTuples();
+ int nbOfComp=getNumberOfComponents();
+ int nbOfComp2=other->getNumberOfComponents();
+ if(nbOfTuple==nbOfTuple2)
{
- int nbOfCompo=(int)_info_on_compo.size();
- if(nbOfCompo>=1)
+ if(nbOfComp==nbOfComp2)
{
- int nbOfTuples=getNumberOfTuples();
- stream << "Number of tuples : " << nbOfTuples << ". Number of components : " << nbOfCompo << "." << std::endl;
- reprQuickOverviewData(stream,MAX_NB_OF_BYTE_IN_REPR);
+ std::transform(begin(),end(),other->begin(),getPointer(),std::divides<double>());
+ }
+ else if(nbOfComp2==1)
+ {
+ double *ptr=getPointer();
+ const double *ptrc=other->getConstPointer();
+ for(int i=0;i<nbOfTuple;i++)
+ std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::divides<double>(),*ptrc++));
}
else
- stream << "Number of components : 0.";
+ throw INTERP_KERNEL::Exception(msg);
}
- else
- stream << "*** No data allocated ****";
-}
-
-void DataArrayInt::reprQuickOverviewData(std::ostream& stream, std::size_t maxNbOfByteInRepr) const
-{
- const int *data=begin();
- int nbOfTuples=getNumberOfTuples();
- int nbOfCompo=(int)_info_on_compo.size();
- std::ostringstream oss2; oss2 << "[";
- std::string oss2Str(oss2.str());
- bool isFinished=true;
- for(int i=0;i<nbOfTuples && isFinished;i++)
+ else if(nbOfTuple2==1)
{
- if(nbOfCompo>1)
+ if(nbOfComp2==nbOfComp)
{
- oss2 << "(";
- for(int j=0;j<nbOfCompo;j++,data++)
- {
- oss2 << *data;
- if(j!=nbOfCompo-1) oss2 << ", ";
- }
- oss2 << ")";
+ double *ptr=getPointer();
+ const double *ptrc=other->getConstPointer();
+ for(int i=0;i<nbOfTuple;i++)
+ std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::divides<double>());
}
else
- oss2 << *data++;
- if(i!=nbOfTuples-1) oss2 << ", ";
- std::string oss3Str(oss2.str());
- if(oss3Str.length()<maxNbOfByteInRepr)
- oss2Str=oss3Str;
- else
- isFinished=false;
+ throw INTERP_KERNEL::Exception(msg);
}
- stream << oss2Str;
- if(!isFinished)
- stream << "... ";
- stream << "]";
+ else
+ throw INTERP_KERNEL::Exception(msg);
+ declareAsNew();
}
/*!
- * Modifies in place \a this one-dimensional array so that each value \a v = \a indArrBg[ \a v ],
- * i.e. a current value is used as in index to get a new value from \a indArrBg.
- * \param [in] indArrBg - pointer to the first element of array of new values to assign
- * to \a this array.
- * \param [in] indArrEnd - specifies the end of the array \a indArrBg, so that
- * the last value of \a indArrBg is \a indArrEnd[ -1 ].
- * \throw If \a this->getNumberOfComponents() != 1
- * \throw If any value of \a this can't be used as a valid index for
- * [\a indArrBg, \a indArrEnd).
+ * Returns a new DataArrayDouble that is the result of pow of two given arrays. There are 3
+ * valid cases.
*
- * \sa changeValue
+ * \param [in] a1 - an array to pow up.
+ * \param [in] a2 - another array to sum up.
+ * \return DataArrayDouble * - the new instance of DataArrayDouble.
+ * The caller is to delete this result array using decrRef() as it is no more
+ * needed.
+ * \throw If either \a a1 or \a a2 is NULL.
+ * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
+ * \throw If \a a1->getNumberOfComponents() != 1 or \a a2->getNumberOfComponents() != 1.
+ * \throw If there is a negative value in \a a1.
*/
-void DataArrayInt::transformWithIndArr(const int *indArrBg, const int *indArrEnd)
+DataArrayDouble *DataArrayDouble::Pow(const DataArrayDouble *a1, const DataArrayDouble *a2)
{
- checkAllocated();
- if(getNumberOfComponents()!=1)
- throw INTERP_KERNEL::Exception("Call transformWithIndArr method on DataArrayInt with only one component, you can call 'rearrange' method before !");
- int nbElemsIn((int)std::distance(indArrBg,indArrEnd)),nbOfTuples(getNumberOfTuples()),*pt(getPointer());
- for(int i=0;i<nbOfTuples;i++,pt++)
+ if(!a1 || !a2)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::Pow : at least one of input instances is null !");
+ int nbOfTuple=a1->getNumberOfTuples();
+ int nbOfTuple2=a2->getNumberOfTuples();
+ int nbOfComp=a1->getNumberOfComponents();
+ int nbOfComp2=a2->getNumberOfComponents();
+ if(nbOfTuple!=nbOfTuple2)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::Pow : number of tuples mismatches !");
+ if(nbOfComp!=1 || nbOfComp2!=1)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::Pow : number of components of both arrays must be equal to 1 !");
+ MCAuto<DataArrayDouble> ret=DataArrayDouble::New(); ret->alloc(nbOfTuple,1);
+ const double *ptr1(a1->begin()),*ptr2(a2->begin());
+ double *ptr=ret->getPointer();
+ for(int i=0;i<nbOfTuple;i++,ptr1++,ptr2++,ptr++)
{
- if(*pt>=0 && *pt<nbElemsIn)
- *pt=indArrBg[*pt];
+ if(*ptr1>=0)
+ {
+ *ptr=pow(*ptr1,*ptr2);
+ }
else
{
- std::ostringstream oss; oss << "DataArrayInt::transformWithIndArr : error on tuple #" << i << " of this value is " << *pt << ", should be in [0," << nbElemsIn << ") !";
+ std::ostringstream oss; oss << "DataArrayDouble::Pow : on tuple #" << i << " of a1 value is < 0 (" << *ptr1 << ") !";
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
}
- declareAsNew();
+ return ret.retn();
}
/*!
- * Computes distribution of values of \a this one-dimensional array between given value
- * ranges (casts). This method is typically useful for entity number spliting by types,
- * for example.
- * \warning The values contained in \a arrBg should be sorted ascendently. No
- * check of this is be done. If not, the result is not warranted.
- * \param [in] arrBg - the array of ascending values defining the value ranges. The i-th
- * value of \a arrBg (\a arrBg[ i ]) gives the lowest value of the i-th range,
- * and the greatest value of the i-th range equals to \a arrBg[ i+1 ] - 1. \a
- * arrBg containing \a n values defines \a n-1 ranges. The last value of \a arrBg
- * should be more than every value in \a this array.
- * \param [in] arrEnd - specifies the end of the array \a arrBg, so that
- * the last value of \a arrBg is \a arrEnd[ -1 ].
- * \param [out] castArr - a new instance of DataArrayInt, of same size as \a this array
- * (same number of tuples and components), the caller is to delete
- * using decrRef() as it is no more needed.
- * This array contains indices of ranges for every value of \a this array. I.e.
- * the i-th value of \a castArr gives the index of range the i-th value of \a this
- * belongs to. Or, in other words, this parameter contains for each tuple in \a
- * this in which cast it holds.
- * \param [out] rankInsideCast - a new instance of DataArrayInt, of same size as \a this
- * array, the caller is to delete using decrRef() as it is no more needed.
- * This array contains ranks of values of \a this array within ranges
- * they belongs to. I.e. the i-th value of \a rankInsideCast gives the rank of
- * the i-th value of \a this array within the \a castArr[ i ]-th range, to which
- * the i-th value of \a this belongs to. Or, in other words, this param contains
- * for each tuple its rank inside its cast. The rank is computed as difference
- * between the value and the lowest value of range.
- * \param [out] castsPresent - a new instance of DataArrayInt, containing indices of
- * ranges (casts) to which at least one value of \a this array belongs.
- * Or, in other words, this param contains the casts that \a this contains.
- * The caller is to delete this array using decrRef() as it is no more needed.
- *
- * \b Example: If \a this contains [6,5,0,3,2,7,8,1,4] and \a arrBg contains [0,4,9] then
- * the output of this method will be :
- * - \a castArr : [1,1,0,0,0,1,1,0,1]
- * - \a rankInsideCast: [2,1,0,3,2,3,4,1,0]
- * - \a castsPresent : [0,1]
- *
- * I.e. values of \a this array belong to 2 ranges: #0 and #1. Value 6 belongs to the
- * range #1 and its rank within this range is 2; etc.
+ * Apply pow on values of another DataArrayDouble to values of \a this one.
*
- * \throw If \a this->getNumberOfComponents() != 1.
- * \throw If \a arrEnd - arrBg < 2.
- * \throw If any value of \a this is not less than \a arrEnd[-1].
+ * \param [in] other - an array to pow to \a this one.
+ * \throw If \a other is NULL.
+ * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples()
+ * \throw If \a this->getNumberOfComponents() != 1 or \a other->getNumberOfComponents() != 1
+ * \throw If there is a negative value in \a this.
*/
-void DataArrayInt::splitByValueRange(const int *arrBg, const int *arrEnd,
- DataArrayInt *& castArr, DataArrayInt *& rankInsideCast, DataArrayInt *& castsPresent) const
+void DataArrayDouble::powEqual(const DataArrayDouble *other)
{
- checkAllocated();
- if(getNumberOfComponents()!=1)
- throw INTERP_KERNEL::Exception("Call splitByValueRange method on DataArrayInt with only one component, you can call 'rearrange' method before !");
- int nbOfTuples=getNumberOfTuples();
- std::size_t nbOfCast=std::distance(arrBg,arrEnd);
- if(nbOfCast<2)
- throw INTERP_KERNEL::Exception("DataArrayInt::splitByValueRange : The input array giving the cast range values should be of size >=2 !");
- nbOfCast--;
- const int *work=getConstPointer();
- typedef std::reverse_iterator<const int *> rintstart;
- rintstart bg(arrEnd);//OK no problem because size of 'arr' is greater or equal 2
- rintstart end2(arrBg);
- MCAuto<DataArrayInt> ret1=DataArrayInt::New();
- MCAuto<DataArrayInt> ret2=DataArrayInt::New();
- MCAuto<DataArrayInt> ret3=DataArrayInt::New();
- ret1->alloc(nbOfTuples,1);
- ret2->alloc(nbOfTuples,1);
- int *ret1Ptr=ret1->getPointer();
- int *ret2Ptr=ret2->getPointer();
- std::set<std::size_t> castsDetected;
- for(int i=0;i<nbOfTuples;i++)
- {
- rintstart res=std::find_if(bg,end2,std::bind2nd(std::less_equal<int>(), work[i]));
- std::size_t pos=std::distance(bg,res);
- std::size_t pos2=nbOfCast-pos;
- if(pos2<nbOfCast)
- {
- ret1Ptr[i]=(int)pos2;
- ret2Ptr[i]=work[i]-arrBg[pos2];
- castsDetected.insert(pos2);
- }
+ if(!other)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::powEqual : input instance is null !");
+ int nbOfTuple=getNumberOfTuples();
+ int nbOfTuple2=other->getNumberOfTuples();
+ int nbOfComp=getNumberOfComponents();
+ int nbOfComp2=other->getNumberOfComponents();
+ if(nbOfTuple!=nbOfTuple2)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::powEqual : number of tuples mismatches !");
+ if(nbOfComp!=1 || nbOfComp2!=1)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::powEqual : number of components of both arrays must be equal to 1 !");
+ double *ptr=getPointer();
+ const double *ptrc=other->begin();
+ for(int i=0;i<nbOfTuple;i++,ptrc++,ptr++)
+ {
+ if(*ptr>=0)
+ *ptr=pow(*ptr,*ptrc);
else
{
- std::ostringstream oss; oss << "DataArrayInt::splitByValueRange : At rank #" << i << " the value is " << work[i] << " should be in [0," << *bg << ") !";
+ std::ostringstream oss; oss << "DataArrayDouble::powEqual : on tuple #" << i << " of this value is < 0 (" << *ptr << ") !";
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
}
- ret3->alloc((int)castsDetected.size(),1);
- std::copy(castsDetected.begin(),castsDetected.end(),ret3->getPointer());
- castArr=ret1.retn();
- rankInsideCast=ret2.retn();
- castsPresent=ret3.retn();
+ declareAsNew();
}
/*!
- * This method look at \a this if it can be considered as a range defined by the 3-tuple ( \a strt , \a sttoopp , \a stteepp ).
- * If false is returned the tuple must be ignored. If true is returned \a this can be considered by a range( \a strt , \a sttoopp , \a stteepp ).
- * This method works only if \a this is allocated and single component. If not an exception will be thrown.
- *
- * \param [out] strt - the start of the range (included) if true is returned.
- * \param [out] sttoopp - the end of the range (not included) if true is returned.
- * \param [out] stteepp - the step of the range if true is returned.
- * \return the verdict of the check.
+ * 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.
*
- * \sa DataArray::GetNumberOfItemGivenBES
+ * \throw if \a this is not allocated.
+ * \throw if \a this has not exactly one component.
*/
-bool DataArrayInt::isRange(int& strt, int& sttoopp, int& stteepp) const
+std::vector<bool> DataArrayDouble::toVectorOfBool(double eps) const
{
checkAllocated();
if(getNumberOfComponents()!=1)
- throw INTERP_KERNEL::Exception("DataArrayInt::isRange : this must be single component array !");
- int nbTuples(getNumberOfTuples());
- if(nbTuples==0)
- { strt=0; sttoopp=0; stteepp=1; return true; }
- const int *pt(begin());
- strt=*pt;
- if(nbTuples==1)
- { sttoopp=strt+1; stteepp=1; return true; }
- strt=*pt; sttoopp=pt[nbTuples-1];
- if(strt==sttoopp)
- return false;
- if(sttoopp>strt)
+ 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++)
{
- sttoopp++;
- int a(sttoopp-1-strt),tmp(strt);
- if(a%(nbTuples-1)!=0)
- return false;
- stteepp=a/(nbTuples-1);
- for(int i=0;i<nbTuples;i++,tmp+=stteepp)
- if(pt[i]!=tmp)
- return false;
- return true;
+ 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::getTinySerializationIntInformation(std::vector<int>& tinyInfo) const
+{
+ tinyInfo.resize(2);
+ if(isAllocated())
+ {
+ tinyInfo[0]=getNumberOfTuples();
+ tinyInfo[1]=getNumberOfComponents();
}
else
{
- sttoopp--;
- int a(strt-sttoopp-1),tmp(strt);
- if(a%(nbTuples-1)!=0)
- return false;
- stteepp=-(a/(nbTuples-1));
- for(int i=0;i<nbTuples;i++,tmp+=stteepp)
- if(pt[i]!=tmp)
- return false;
+ tinyInfo[0]=-1;
+ tinyInfo[1]=-1;
+ }
+}
+
+/*!
+ * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
+ * Server side.
+ */
+void DataArrayDouble::getTinySerializationStrInformation(std::vector<std::string>& tinyInfo) const
+{
+ if(isAllocated())
+ {
+ int nbOfCompo=getNumberOfComponents();
+ tinyInfo.resize(nbOfCompo+1);
+ tinyInfo[0]=getName();
+ for(int i=0;i<nbOfCompo;i++)
+ tinyInfo[i+1]=getInfoOnComponent(i);
+ }
+ else
+ {
+ tinyInfo.resize(1);
+ tinyInfo[0]=getName();
+ }
+}
+
+/*!
+ * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
+ * This method returns if a feeding is needed.
+ */
+bool DataArrayDouble::resizeForUnserialization(const std::vector<int>& tinyInfoI)
+{
+ int nbOfTuple=tinyInfoI[0];
+ int nbOfComp=tinyInfoI[1];
+ if(nbOfTuple!=-1 || nbOfComp!=-1)
+ {
+ alloc(nbOfTuple,nbOfComp);
return true;
}
+ return false;
}
/*!
- * Creates a one-dimensional DataArrayInt (\a res) whose contents are computed from
- * values of \a this (\a a) and the given (\a indArr) arrays as follows:
- * \a res[ \a indArr[ \a a[ i ]]] = i. I.e. for each value in place i \a v = \a a[ i ],
- * new value in place \a indArr[ \a v ] is i.
- * \param [in] indArrBg - the array holding indices within the result array to assign
- * indices of values of \a this array pointing to values of \a indArrBg.
- * \param [in] indArrEnd - specifies the end of the array \a indArrBg, so that
- * the last value of \a indArrBg is \a indArrEnd[ -1 ].
- * \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.
- * \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.
+ * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
*/
-DataArrayInt *DataArrayInt::transformWithIndArrR(const int *indArrBg, const int *indArrEnd) const
+void DataArrayDouble::finishUnserialization(const std::vector<int>& tinyInfoI, const std::vector<std::string>& tinyInfoS)
{
- checkAllocated();
- if(getNumberOfComponents()!=1)
- throw INTERP_KERNEL::Exception("Call transformWithIndArrR method on DataArrayInt with only one component, you can call 'rearrange' method before !");
- int nbElemsIn=(int)std::distance(indArrBg,indArrEnd);
- int nbOfTuples=getNumberOfTuples();
- const int *pt=getConstPointer();
- MCAuto<DataArrayInt> ret=DataArrayInt::New();
- ret->alloc(nbOfTuples,1);
- ret->fillWithValue(-1);
- int *tmp=ret->getPointer();
- for(int i=0;i<nbOfTuples;i++,pt++)
+ setName(tinyInfoS[0]);
+ if(isAllocated())
{
- if(*pt>=0 && *pt<nbElemsIn)
- {
- int pos=indArrBg[*pt];
- if(pos>=0 && pos<nbOfTuples)
- tmp[pos]=i;
- else
- {
- std::ostringstream oss; oss << "DataArrayInt::transformWithIndArrR : error on tuple #" << i << " value of new pos is " << pos << " ( indArrBg[" << *pt << "]) ! Should be in [0," << nbOfTuples << ") !";
- throw INTERP_KERNEL::Exception(oss.str().c_str());
- }
- }
- else
- {
- std::ostringstream oss; oss << "DataArrayInt::transformWithIndArrR : error on tuple #" << i << " value is " << *pt << " and indirectionnal array as a size equal to " << nbElemsIn << " !";
- throw INTERP_KERNEL::Exception(oss.str().c_str());
- }
+ int nbOfCompo=getNumberOfComponents();
+ for(int i=0;i<nbOfCompo;i++)
+ setInfoOnComponent(i,tinyInfoS[i+1]);
}
- return ret.retn();
}
/*!
- * Creates a one-dimensional DataArrayInt of given length, whose contents are computed
- * from values of \a this array, which is supposed to contain a renumbering map in
- * "Old to New" mode. The result array contains a renumbering map in "New to Old" mode.
- * To know how to use the renumbering maps see \ref numbering.
- * \param [in] newNbOfElem - the number of tuples 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
- * needed.
- *
- * \if ENABLE_EXAMPLES
- * \ref cpp_mcdataarrayint_invertarrayo2n2n2o "Here is a C++ example".<br>
- * \ref py_mcdataarrayint_invertarrayo2n2n2o "Here is a Python example".
- * \endif
+ * Low static method that operates 3D rotation of 'nbNodes' 3D nodes whose coordinates are arranged in \a coordsIn
+ * around an axe ( \a center, \a vect) and with angle \a angle.
+ */
+void DataArrayDouble::Rotate3DAlg(const double *center, const double *vect, double angle, int nbNodes, const double *coordsIn, double *coordsOut)
+{
+ if(!center || !vect)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::Rotate3DAlg : null vector in input !");
+ double sina(sin(angle));
+ double cosa(cos(angle));
+ double vectorNorm[3];
+ double matrix[9];
+ double matrixTmp[9];
+ double norm(sqrt(vect[0]*vect[0]+vect[1]*vect[1]+vect[2]*vect[2]));
+ if(norm<std::numeric_limits<double>::min())
+ throw INTERP_KERNEL::Exception("DataArrayDouble::Rotate3DAlg : magnitude of input vector is too close of 0. !");
+ std::transform(vect,vect+3,vectorNorm,std::bind2nd(std::multiplies<double>(),1/norm));
+ //rotation matrix computation
+ matrix[0]=cosa; matrix[1]=0.; matrix[2]=0.; matrix[3]=0.; matrix[4]=cosa; matrix[5]=0.; matrix[6]=0.; matrix[7]=0.; matrix[8]=cosa;
+ matrixTmp[0]=vectorNorm[0]*vectorNorm[0]; matrixTmp[1]=vectorNorm[0]*vectorNorm[1]; matrixTmp[2]=vectorNorm[0]*vectorNorm[2];
+ matrixTmp[3]=vectorNorm[1]*vectorNorm[0]; matrixTmp[4]=vectorNorm[1]*vectorNorm[1]; matrixTmp[5]=vectorNorm[1]*vectorNorm[2];
+ matrixTmp[6]=vectorNorm[2]*vectorNorm[0]; matrixTmp[7]=vectorNorm[2]*vectorNorm[1]; matrixTmp[8]=vectorNorm[2]*vectorNorm[2];
+ std::transform(matrixTmp,matrixTmp+9,matrixTmp,std::bind2nd(std::multiplies<double>(),1-cosa));
+ std::transform(matrix,matrix+9,matrixTmp,matrix,std::plus<double>());
+ matrixTmp[0]=0.; matrixTmp[1]=-vectorNorm[2]; matrixTmp[2]=vectorNorm[1];
+ matrixTmp[3]=vectorNorm[2]; matrixTmp[4]=0.; matrixTmp[5]=-vectorNorm[0];
+ matrixTmp[6]=-vectorNorm[1]; matrixTmp[7]=vectorNorm[0]; matrixTmp[8]=0.;
+ std::transform(matrixTmp,matrixTmp+9,matrixTmp,std::bind2nd(std::multiplies<double>(),sina));
+ std::transform(matrix,matrix+9,matrixTmp,matrix,std::plus<double>());
+ //rotation matrix computed.
+ double tmp[3];
+ for(int i=0; i<nbNodes; i++)
+ {
+ std::transform(coordsIn+i*3,coordsIn+(i+1)*3,center,tmp,std::minus<double>());
+ coordsOut[i*3]=matrix[0]*tmp[0]+matrix[1]*tmp[1]+matrix[2]*tmp[2]+center[0];
+ coordsOut[i*3+1]=matrix[3]*tmp[0]+matrix[4]*tmp[1]+matrix[5]*tmp[2]+center[1];
+ coordsOut[i*3+2]=matrix[6]*tmp[0]+matrix[7]*tmp[1]+matrix[8]*tmp[2]+center[2];
+ }
+}
+
+void DataArrayDouble::Symmetry3DPlane(const double point[3], const double normalVector[3], int nbNodes, const double *coordsIn, double *coordsOut)
+{
+ double matrix[9],matrix2[9],matrix3[9];
+ double vect[3],crossVect[3];
+ INTERP_KERNEL::orthogonalVect3(normalVector,vect);
+ crossVect[0]=normalVector[1]*vect[2]-normalVector[2]*vect[1];
+ crossVect[1]=normalVector[2]*vect[0]-normalVector[0]*vect[2];
+ crossVect[2]=normalVector[0]*vect[1]-normalVector[1]*vect[0];
+ double nv(INTERP_KERNEL::norm<3>(vect)),ni(INTERP_KERNEL::norm<3>(normalVector)),nc(INTERP_KERNEL::norm<3>(crossVect));
+ matrix[0]=vect[0]/nv; matrix[1]=crossVect[0]/nc; matrix[2]=-normalVector[0]/ni;
+ matrix[3]=vect[1]/nv; matrix[4]=crossVect[1]/nc; matrix[5]=-normalVector[1]/ni;
+ matrix[6]=vect[2]/nv; matrix[7]=crossVect[2]/nc; matrix[8]=-normalVector[2]/ni;
+ matrix2[0]=vect[0]/nv; matrix2[1]=vect[1]/nv; matrix2[2]=vect[2]/nv;
+ matrix2[3]=crossVect[0]/nc; matrix2[4]=crossVect[1]/nc; matrix2[5]=crossVect[2]/nc;
+ matrix2[6]=normalVector[0]/ni; matrix2[7]=normalVector[1]/ni; matrix2[8]=normalVector[2]/ni;
+ for(int i=0;i<3;i++)
+ for(int j=0;j<3;j++)
+ {
+ double val(0.);
+ for(int k=0;k<3;k++)
+ val+=matrix[3*i+k]*matrix2[3*k+j];
+ matrix3[3*i+j]=val;
+ }
+ //rotation matrix computed.
+ double tmp[3];
+ for(int i=0; i<nbNodes; i++)
+ {
+ std::transform(coordsIn+i*3,coordsIn+(i+1)*3,point,tmp,std::minus<double>());
+ coordsOut[i*3]=matrix3[0]*tmp[0]+matrix3[1]*tmp[1]+matrix3[2]*tmp[2]+point[0];
+ coordsOut[i*3+1]=matrix3[3]*tmp[0]+matrix3[4]*tmp[1]+matrix3[5]*tmp[2]+point[1];
+ coordsOut[i*3+2]=matrix3[6]*tmp[0]+matrix3[7]*tmp[1]+matrix3[8]*tmp[2]+point[2];
+ }
+}
+
+void DataArrayDouble::GiveBaseForPlane(const double normalVector[3], double baseOfPlane[9])
+{
+ double vect[3],crossVect[3];
+ INTERP_KERNEL::orthogonalVect3(normalVector,vect);
+ crossVect[0]=normalVector[1]*vect[2]-normalVector[2]*vect[1];
+ crossVect[1]=normalVector[2]*vect[0]-normalVector[0]*vect[2];
+ crossVect[2]=normalVector[0]*vect[1]-normalVector[1]*vect[0];
+ double nv(INTERP_KERNEL::norm<3>(vect)),ni(INTERP_KERNEL::norm<3>(normalVector)),nc(INTERP_KERNEL::norm<3>(crossVect));
+ baseOfPlane[0]=vect[0]/nv; baseOfPlane[1]=vect[1]/nv; baseOfPlane[2]=vect[2]/nv;
+ baseOfPlane[3]=crossVect[0]/nc; baseOfPlane[4]=crossVect[1]/nc; baseOfPlane[5]=crossVect[2]/nc;
+ baseOfPlane[6]=normalVector[0]/ni; baseOfPlane[7]=normalVector[1]/ni; baseOfPlane[8]=normalVector[2]/ni;
+}
+
+/*!
+ * Low static method that operates 3D rotation of \a nbNodes 3D nodes whose coordinates are arranged in \a coords
+ * around the center point \a center and with angle \a angle.
*/
-DataArrayInt *DataArrayInt::invertArrayO2N2N2O(int newNbOfElem) const
+void DataArrayDouble::Rotate2DAlg(const double *center, double angle, int nbNodes, const double *coordsIn, double *coordsOut)
{
- MCAuto<DataArrayInt> ret=DataArrayInt::New();
- ret->alloc(newNbOfElem,1);
- int nbOfOldNodes=getNumberOfTuples();
- const int *old2New=getConstPointer();
- int *pt=ret->getPointer();
- for(int i=0;i!=nbOfOldNodes;i++)
+ double cosa=cos(angle);
+ double sina=sin(angle);
+ double matrix[4];
+ matrix[0]=cosa; matrix[1]=-sina; matrix[2]=sina; matrix[3]=cosa;
+ double tmp[2];
+ for(int i=0; i<nbNodes; i++)
{
- int newp(old2New[i]);
- if(newp!=-1)
+ std::transform(coordsIn+i*2,coordsIn+(i+1)*2,center,tmp,std::minus<double>());
+ coordsOut[i*2]=matrix[0]*tmp[0]+matrix[1]*tmp[1]+center[0];
+ coordsOut[i*2+1]=matrix[2]*tmp[0]+matrix[3]*tmp[1]+center[1];
+ }
+}
+
+DataArrayDoubleIterator::DataArrayDoubleIterator(DataArrayDouble *da):_da(da),_tuple_id(0),_nb_comp(0),_nb_tuple(0)
+{
+ if(_da)
+ {
+ _da->incrRef();
+ if(_da->isAllocated())
{
- 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());
- }
+ _nb_comp=da->getNumberOfComponents();
+ _nb_tuple=da->getNumberOfTuples();
+ _pt=da->getPointer();
}
}
- 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
+DataArrayDoubleIterator::~DataArrayDoubleIterator()
+{
+ if(_da)
+ _da->decrRef();
+}
+
+DataArrayDoubleTuple *DataArrayDoubleIterator::nextt()
+{
+ if(_tuple_id<_nb_tuple)
+ {
+ _tuple_id++;
+ DataArrayDoubleTuple *ret=new DataArrayDoubleTuple(_pt,_nb_comp);
+ _pt+=_nb_comp;
+ return ret;
+ }
+ else
+ return 0;
+}
+
+DataArrayDoubleTuple::DataArrayDoubleTuple(double *pt, int nbOfComp):_pt(pt),_nb_of_compo(nbOfComp)
+{
+}
+
+
+std::string DataArrayDoubleTuple::repr() const
+{
+ std::ostringstream oss; oss.precision(17); oss << "(";
+ for(int i=0;i<_nb_of_compo-1;i++)
+ oss << _pt[i] << ", ";
+ oss << _pt[_nb_of_compo-1] << ")";
+ return oss.str();
+}
+
+double DataArrayDoubleTuple::doubleValue() const
{
- MCAuto<DataArrayInt> ret=DataArrayInt::New();
- ret->alloc(newNbOfElem,1);
- int nbOfOldNodes=getNumberOfTuples();
- const int *old2New=getConstPointer();
- int *pt=ret->getPointer();
- for(int i=nbOfOldNodes-1;i>=0;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();
+ if(_nb_of_compo==1)
+ return *_pt;
+ throw INTERP_KERNEL::Exception("DataArrayDoubleTuple::doubleValue : DataArrayDoubleTuple instance has not exactly 1 component -> Not possible to convert it into a double precision float !");
}
/*!
- * Creates a one-dimensional DataArrayInt of given length, whose contents are computed
- * from values of \a this array, which is supposed to contain a renumbering map in
- * "New to Old" mode. The result array contains a renumbering map in "Old to New" mode.
- * To know how to use the renumbering maps see \ref numbering.
- * \param [in] newNbOfElem - the number of tuples 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
- * needed.
- *
- * \if ENABLE_EXAMPLES
- * \ref cpp_mcdataarrayint_invertarrayn2o2o2n "Here is a C++ example".
- *
- * \ref py_mcdataarrayint_invertarrayn2o2o2n "Here is a Python example".
- * \endif
+ * This method returns a newly allocated instance the caller should dealed with by a MEDCoupling::DataArrayDouble::decrRef.
+ * This method performs \b no copy of data. The content is only referenced using MEDCoupling::DataArrayDouble::useArray with ownership set to \b false.
+ * 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 *DataArrayInt::invertArrayN2O2O2N(int oldNbOfElem) const
+DataArrayDouble *DataArrayDoubleTuple::buildDADouble(int nbOfTuples, int nbOfCompo) const
{
- checkAllocated();
- MCAuto<DataArrayInt> ret=DataArrayInt::New();
- ret->alloc(oldNbOfElem,1);
- const int *new2Old=getConstPointer();
- int *pt=ret->getPointer();
- std::fill(pt,pt+oldNbOfElem,-1);
- int nbOfNewElems=getNumberOfTuples();
- for(int i=0;i<nbOfNewElems;i++)
+ if((_nb_of_compo==nbOfCompo && nbOfTuples==1) || (_nb_of_compo==nbOfTuples && nbOfCompo==1))
{
- int v(new2Old[i]);
- if(v>=0 && v<oldNbOfElem)
- pt[v]=i;
- else
- {
- std::ostringstream oss; oss << "DataArrayInt::invertArrayN2O2O2N : in new id #" << i << " old value is " << v << " expected to be in [0," << oldNbOfElem << ") !";
- throw INTERP_KERNEL::Exception(oss.str().c_str());
- }
+ DataArrayDouble *ret=DataArrayDouble::New();
+ ret->useExternalArrayWithRWAccess(_pt,nbOfTuples,nbOfCompo);
+ return ret;
+ }
+ else
+ {
+ std::ostringstream oss; oss << "DataArrayDoubleTuple::buildDADouble : unable to build a requested DataArrayDouble instance with nbofTuple=" << nbOfTuples << " and nbOfCompo=" << nbOfCompo;
+ oss << ".\nBecause the number of elements in this is " << _nb_of_compo << " !";
+ throw INTERP_KERNEL::Exception(oss.str().c_str());
}
- return ret.retn();
}
/*!
- * Equivalent to DataArrayInt::isEqual except that if false the reason of
- * mismatch is given.
- *
- * \param [in] other the instance to be compared with \a this
- * \param [out] reason In case of inequality returns the reason.
- * \sa DataArrayInt::isEqual
+ * Returns a new instance of DataArrayInt. The caller is to delete this array
+ * using decrRef() as it is no more needed.
*/
-bool DataArrayInt::isEqualIfNotWhy(const DataArrayInt& other, std::string& reason) const
+DataArrayInt *DataArrayInt::New()
{
- if(!areInfoEqualsIfNotWhy(other,reason))
- return false;
- return _mem.isEqual(other._mem,0,reason);
+ return new DataArrayInt;
}
/*!
- * Checks if \a this and another DataArrayInt are fully equal. For more info see
- * \ref MEDCouplingArrayBasicsCompare.
- * \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.
+ * Returns the only one value in \a this, if and only if number of elements
+ * (nb of tuples * nb of components) is equal to 1, and that \a this is allocated.
+ * \return double - the sole value stored in \a this array.
+ * \throw If at least one of conditions stated above is not fulfilled.
*/
-bool DataArrayInt::isEqual(const DataArrayInt& other) const
+int DataArrayInt::intValue() const
{
- std::string tmp;
- return isEqualIfNotWhy(other,tmp);
+ if(isAllocated())
+ {
+ if(getNbOfElems()==1)
+ {
+ return *getConstPointer();
+ }
+ else
+ throw INTERP_KERNEL::Exception("DataArrayInt::intValue : DataArrayInt instance is allocated but number of elements is not equal to 1 !");
+ }
+ else
+ throw INTERP_KERNEL::Exception("DataArrayInt::intValue : DataArrayInt instance is not allocated !");
}
/*!
- * Checks if values of \a this and another DataArrayInt are equal. For more info see
- * \ref MEDCouplingArrayBasicsCompare.
- * \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.
+ * Returns an integer value characterizing \a this array, which is useful for a quick
+ * comparison of many instances of DataArrayInt.
+ * \return int - the hash value.
+ * \throw If \a this is not allocated.
*/
-bool DataArrayInt::isEqualWithoutConsideringStr(const DataArrayInt& other) const
+int DataArrayInt::getHashCode() const
{
- std::string tmp;
- return _mem.isEqual(other._mem,0,tmp);
+ checkAllocated();
+ std::size_t nbOfElems=getNbOfElems();
+ int ret=nbOfElems*65536;
+ int delta=3;
+ if(nbOfElems>48)
+ delta=nbOfElems/8;
+ int ret0=0;
+ const int *pt=begin();
+ for(std::size_t i=0;i<nbOfElems;i+=delta)
+ ret0+=pt[i] & 0x1FFF;
+ return ret+ret0;
}
/*!
- * Checks if values of \a this and another DataArrayInt are equal. Comparison is
- * performed on sorted value sequences.
- * For more info see\ref MEDCouplingArrayBasicsCompare.
- * \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.
+ * Returns a full copy of \a this. For more info on copying data arrays see
+ * \ref MEDCouplingArrayBasicsCopyDeep.
+ * \return DataArrayInt * - a new instance of DataArrayInt.
*/
-bool DataArrayInt::isEqualWithoutConsideringStrAndOrder(const DataArrayInt& other) const
+DataArrayInt *DataArrayInt::deepCopy() const
{
- MCAuto<DataArrayInt> a=deepCopy();
- MCAuto<DataArrayInt> b=other.deepCopy();
- a->sort();
- b->sort();
- return a->isEqualWithoutConsideringStr(*b);
+ return new DataArrayInt(*this);
}
/*!
- * 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.
- * For performance reasons \a this is expected to be sorted ascendingly. If not an exception will be thrown.
- *
- * \param [in] v - the vector of 'flags' to be compared with \a this.
- *
- * \throw If \a this is not sorted ascendingly.
- * \throw If \a this has not exactly one component.
- * \throw If \a this is not allocated.
+ * Returns either a \a deep or \a shallow copy of this array. For more info see
+ * \ref MEDCouplingArrayBasicsCopyDeep and \ref MEDCouplingArrayBasicsCopyShallow.
+ * \param [in] dCpy - if \a true, a deep copy is returned, else, a shallow one.
+ * \return DataArrayInt * - either a new instance of DataArrayInt (if \a dCpy
+ * == \a true) or \a this instance (if \a dCpy == \a false).
*/
-bool DataArrayInt::isFittingWith(const std::vector<bool>& v) const
+DataArrayInt *DataArrayInt::performCopyOrIncrRef(bool dCpy) const
{
- checkAllocated();
- if(getNumberOfComponents()!=1)
- throw INTERP_KERNEL::Exception("DataArrayInt::isFittingWith : number of components of this should be equal to one !");
- const int *w(begin()),*end2(end());
- int refVal=-std::numeric_limits<int>::max();
- int i=0;
- std::vector<bool>::const_iterator it(v.begin());
- for(;it!=v.end();it++,i++)
+ if(dCpy)
+ return deepCopy();
+ else
{
- if(*it)
- {
- if(w!=end2)
- {
- if(*w++==i)
- {
- if(i>refVal)
- refVal=i;
- else
- {
- std::ostringstream oss; oss << "DataArrayInt::isFittingWith : At pos #" << std::distance(begin(),w-1) << " this is not sorted ascendingly !";
- throw INTERP_KERNEL::Exception(oss.str().c_str());
- }
- }
- else
- return false;
- }
- else
- return false;
- }
+ incrRef();
+ return const_cast<DataArrayInt *>(this);
}
- return w==end2;
}
/*!
- * This method assumes that \a this has one component and is allocated. This method scans all tuples in \a this and for all tuple equal to \a val
- * put True to the corresponding entry in \a vec.
- * \a vec is expected to be with the same size than the number of tuples of \a this.
+ * 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.
*/
-void DataArrayInt::switchOnTupleEqualTo(int val, std::vector<bool>& vec) const
+void DataArrayInt::fillWithZero()
{
- checkAllocated();
- if(getNumberOfComponents()!=1)
- throw INTERP_KERNEL::Exception("DataArrayInt::switchOnTupleEqualTo : number of components of this should be equal to one !");
- int nbOfTuples(getNumberOfTuples());
- if(nbOfTuples!=(int)vec.size())
- throw INTERP_KERNEL::Exception("DataArrayInt::switchOnTupleEqualTo : number of tuples of this should be equal to size of input vector of bool !");
- const int *pt(begin());
- for(int i=0;i<nbOfTuples;i++)
- if(pt[i]==val)
- vec[i]=true;
+ fillWithValue(0);
}
/*!
- * Sorts values of the array.
- * \param [in] asc - \a true means ascending order, \a false, descending.
+ * Set all values in \a this array so that the i-th element equals to \a init + i
+ * (i starts from zero). To know more on filling arrays see \ref MEDCouplingArrayFill.
+ * \param [in] init - value to assign to the first element of array.
+ * \throw If \a this->getNumberOfComponents() != 1
* \throw If \a this is not allocated.
- * \throw If \a this->getNumberOfComponents() != 1.
*/
-void DataArrayInt::sort(bool asc)
+void DataArrayInt::iota(int init)
{
checkAllocated();
if(getNumberOfComponents()!=1)
- throw INTERP_KERNEL::Exception("DataArrayInt::sort : only supported with 'this' array with ONE component !");
- _mem.sort(asc);
+ throw INTERP_KERNEL::Exception("DataArrayInt::iota : works only for arrays with only one component, you can call 'rearrange' method before !");
+ int *ptr=getPointer();
+ int ntuples=getNumberOfTuples();
+ for(int i=0;i<ntuples;i++)
+ ptr[i]=init+i;
declareAsNew();
}
/*!
- * Computes for each tuple the sum of number of components values in the tuple and return it.
+ * Returns a textual and human readable representation of \a this instance of
+ * DataArrayInt. This text is shown when a DataArrayInt is printed in Python.
+ * \return std::string - text describing \a this DataArrayInt.
*
- * \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.
+ * \sa reprNotTooLong, reprZip
*/
-DataArrayInt *DataArrayInt::sumPerTuple() const
+std::string DataArrayInt::repr() const
{
- checkAllocated();
- int nbOfComp(getNumberOfComponents()),nbOfTuple(getNumberOfTuples());
- MCAuto<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();
+ std::ostringstream ret;
+ reprStream(ret);
+ return ret.str();
}
-/*!
- * Reverse the array values.
- * \throw If \a this->getNumberOfComponents() < 1.
- * \throw If \a this is not allocated.
- */
-void DataArrayInt::reverse()
+std::string DataArrayInt::reprZip() const
{
- checkAllocated();
- _mem.reverse(getNumberOfComponents());
- declareAsNew();
+ std::ostringstream ret;
+ reprZipStream(ret);
+ return ret.str();
}
/*!
- * 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.
+ * 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
*/
-void DataArrayInt::checkMonotonic(bool increasing) const
+std::string DataArrayInt::reprNotTooLong() 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 !");
- }
+ std::ostringstream ret;
+ reprNotTooLongStream(ret);
+ return ret.str();
}
-/*!
- * 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.
- */
-bool DataArrayInt::isMonotonic(bool increasing) const
+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();
- if(getNumberOfComponents()!=1)
- throw INTERP_KERNEL::Exception("DataArrayInt::isMonotonic : only supported with 'this' array with ONE component !");
- int nbOfElements=getNumberOfTuples();
- const int *ptr=getConstPointer();
- if(nbOfElements==0)
- return true;
- int ref=ptr[0];
- if(increasing)
+ std::string idt(indent,' ');
+ ofs << idt << "<DataArray type=\"" << type << "\" Name=\"" << nameInFile << "\" NumberOfComponents=\"" << getNumberOfComponents() << "\"";
+ if(byteArr)
{
- for(int i=1;i<nbOfElements;i++)
+ ofs << " format=\"appended\" offset=\"" << byteArr->getNumberOfTuples() << "\">";
+ if(std::string(type)=="Int32")
{
- if(ptr[i]>=ref)
- ref=ptr[i];
- else
- return false;
+ 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
- {
- for(int i=1;i<nbOfElements;i++)
+ else if(std::string(type)=="Int8")
{
- if(ptr[i]<=ref)
- ref=ptr[i];
- else
- return false;
+ 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);
}
- }
- return true;
-}
-
-/*!
- * This method check that array consistently INCREASING or DECREASING in value.
- */
-bool DataArrayInt::isStrictlyMonotonic(bool increasing) const
-{
- checkAllocated();
- if(getNumberOfComponents()!=1)
- throw INTERP_KERNEL::Exception("DataArrayInt::isStrictlyMonotonic : only supported with 'this' array with ONE component !");
- int nbOfElements=getNumberOfTuples();
- const int *ptr=getConstPointer();
- if(nbOfElements==0)
- return true;
- int ref=ptr[0];
- if(increasing)
- {
- for(int i=1;i<nbOfElements;i++)
+ else if(std::string(type)=="UInt8")
{
- if(ptr[i]>ref)
- ref=ptr[i];
- else
- return false;
+ 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
{
- for(int i=1;i<nbOfElements;i++)
- {
- if(ptr[i]<ref)
- ref=ptr[i];
- else
- return false;
- }
+ ofs << " RangeMin=\"" << getMinValueInArray() << "\" RangeMax=\"" << getMaxValueInArray() << "\" format=\"ascii\">\n" << idt;
+ std::copy(begin(),end(),std::ostream_iterator<int>(ofs," "));
}
- return true;
+ ofs << std::endl << idt << "</DataArray>\n";
}
-/*!
- * This method check that array consistently INCREASING or DECREASING in value.
- */
-void DataArrayInt::checkStrictlyMonotonic(bool increasing) const
+void DataArrayInt::reprStream(std::ostream& stream) 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 !");
- }
+ stream << "Name of int array : \"" << _name << "\"\n";
+ reprWithoutNameStream(stream);
}
-/*!
- * 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
- */
-DataArrayInt *DataArrayInt::buildPermutationArr(const DataArrayInt& other) const
+void DataArrayInt::reprZipStream(std::ostream& stream) const
{
- checkAllocated();
- if(getNumberOfComponents()!=1 || other.getNumberOfComponents()!=1)
- throw INTERP_KERNEL::Exception("DataArrayInt::buildPermutationArr : 'this' and 'other' have to have exactly ONE component !");
- int nbTuple=getNumberOfTuples();
- other.checkAllocated();
- if(nbTuple!=other.getNumberOfTuples())
- throw INTERP_KERNEL::Exception("DataArrayInt::buildPermutationArr : 'this' and 'other' must have the same number of tuple !");
- MCAuto<DataArrayInt> ret=DataArrayInt::New();
- ret->alloc(nbTuple,1);
- ret->fillWithValue(-1);
- const int *pt=getConstPointer();
- std::map<int,int> mm;
- for(int i=0;i<nbTuple;i++)
- mm[pt[i]]=i;
- pt=other.getConstPointer();
- int *retToFill=ret->getPointer();
- for(int 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();
+ stream << "Name of int array : \"" << _name << "\"\n";
+ reprZipWithoutNameStream(stream);
}
-/*!
- * Sets a C array to be used as raw data of \a this. The previously set info
- * of components is retained and re-sized.
- * For more info see \ref MEDCouplingArraySteps1.
- * \param [in] array - the C array to be used as raw data of \a this.
- * \param [in] ownership - if \a true, \a array will be deallocated at destruction of \a this.
- * \param [in] type - specifies how to deallocate \a array. If \a type == MEDCoupling::CPP_DEALLOC,
- * \c delete [] \c array; will be called. If \a type == MEDCoupling::C_DEALLOC,
- * \c free(\c array ) will be called.
- * \param [in] nbOfTuple - new number of tuples in \a this.
- * \param [in] nbOfCompo - new number of components in \a this.
- */
-void DataArrayInt::useArray(const int *array, bool ownership, DeallocType type, int nbOfTuple, int nbOfCompo)
+void DataArrayInt::reprNotTooLongStream(std::ostream& stream) const
{
- _info_on_compo.resize(nbOfCompo);
- _mem.useArray(array,ownership,type,nbOfTuple*nbOfCompo);
- declareAsNew();
+ stream << "Name of int array : \"" << _name << "\"\n";
+ reprNotTooLongWithoutNameStream(stream);
}
-void DataArrayInt::useExternalArrayWithRWAccess(const int *array, int nbOfTuple, int nbOfCompo)
+void DataArrayInt::reprWithoutNameStream(std::ostream& stream) const
{
- _info_on_compo.resize(nbOfCompo);
- _mem.useExternalArrayWithRWAccess(array,nbOfTuple*nbOfCompo);
- declareAsNew();
+ DataArray::reprWithoutNameStream(stream);
+ _mem.repr(getNumberOfComponents(),stream);
}
-/*!
- * Returns a new DataArrayInt holding the same values as \a this array but differently
- * arranged in memory. If \a this array holds 2 components of 3 values:
- * \f$ x_0,x_1,x_2,y_0,y_1,y_2 \f$, then the result array holds these values arranged
- * as follows: \f$ x_0,y_0,x_1,y_1,x_2,y_2 \f$.
- * \warning Do not confuse this method with transpose()!
- * \return DataArrayInt * - the new instance of DataArrayInt that the caller
- * is to delete using decrRef() as it is no more needed.
- * \throw If \a this is not allocated.
- */
-DataArrayInt *DataArrayInt::fromNoInterlace() const
+void DataArrayInt::reprZipWithoutNameStream(std::ostream& stream) const
{
- checkAllocated();
- if(_mem.isNull())
- throw INTERP_KERNEL::Exception("DataArrayInt::fromNoInterlace : Not defined array !");
- int *tab=_mem.fromNoInterlace(getNumberOfComponents());
- DataArrayInt *ret=DataArrayInt::New();
- ret->useArray(tab,true,C_DEALLOC,getNumberOfTuples(),getNumberOfComponents());
- return ret;
+ DataArray::reprWithoutNameStream(stream);
+ _mem.reprZip(getNumberOfComponents(),stream);
}
-/*!
- * Returns a new DataArrayInt holding the same values as \a this array but differently
- * arranged in memory. If \a this array holds 2 components of 3 values:
- * \f$ x_0,y_0,x_1,y_1,x_2,y_2 \f$, then the result array holds these values arranged
- * as follows: \f$ x_0,x_1,x_2,y_0,y_1,y_2 \f$.
- * \warning Do not confuse this method with transpose()!
- * \return DataArrayInt * - the new instance of DataArrayInt that the caller
- * is to delete using decrRef() as it is no more needed.
- * \throw If \a this is not allocated.
- */
-DataArrayInt *DataArrayInt::toNoInterlace() const
+void DataArrayInt::reprNotTooLongWithoutNameStream(std::ostream& stream) const
{
- checkAllocated();
- if(_mem.isNull())
- throw INTERP_KERNEL::Exception("DataArrayInt::toNoInterlace : Not defined array !");
- int *tab=_mem.toNoInterlace(getNumberOfComponents());
- DataArrayInt *ret=DataArrayInt::New();
- ret->useArray(tab,true,C_DEALLOC,getNumberOfTuples(),getNumberOfComponents());
- return ret;
+ DataArray::reprWithoutNameStream(stream);
+ stream.precision(17);
+ _mem.reprNotTooLong(getNumberOfComponents(),stream);
+}
+
+void DataArrayInt::reprCppStream(const std::string& varName, std::ostream& stream) const
+{
+ int nbTuples=getNumberOfTuples(),nbComp=getNumberOfComponents();
+ const int *data=getConstPointer();
+ stream << "DataArrayInt *" << varName << "=DataArrayInt::New();" << std::endl;
+ if(nbTuples*nbComp>=1)
+ {
+ stream << "const int " << varName << "Data[" << nbTuples*nbComp << "]={";
+ std::copy(data,data+nbTuples*nbComp-1,std::ostream_iterator<int>(stream,","));
+ stream << data[nbTuples*nbComp-1] << "};" << std::endl;
+ stream << varName << "->useArray(" << varName << "Data,false,CPP_DEALLOC," << nbTuples << "," << nbComp << ");" << std::endl;
+ }
+ else
+ stream << varName << "->alloc(" << nbTuples << "," << nbComp << ");" << std::endl;
+ stream << varName << "->setName(\"" << getName() << "\");" << std::endl;
}
/*!
- * Permutes values of \a this array as required by \a old2New array. The values are
- * permuted so that \c new[ \a old2New[ i ]] = \c old[ i ]. Number of tuples remains
- * the same as in \c this one.
- * If a permutation reduction is needed, substr() or selectByTupleId() should be used.
- * For more info on renumbering see \ref numbering.
- * \param [in] old2New - C array of length equal to \a this->getNumberOfTuples()
- * giving a new position for i-th old value.
+ * Method that gives a quick overvien of \a this for python.
*/
-void DataArrayInt::renumberInPlace(const int *old2New)
+void DataArrayInt::reprQuickOverview(std::ostream& stream) const
{
- checkAllocated();
- int nbTuples=getNumberOfTuples();
- int nbOfCompo=getNumberOfComponents();
- int *tmp=new int[nbTuples*nbOfCompo];
- const int *iptr=getConstPointer();
- for(int i=0;i<nbTuples;i++)
+ static const std::size_t MAX_NB_OF_BYTE_IN_REPR=300;
+ stream << "DataArrayInt C++ instance at " << this << ". ";
+ if(isAllocated())
{
- int v=old2New[i];
- if(v>=0 && v<nbTuples)
- std::copy(iptr+nbOfCompo*i,iptr+nbOfCompo*(i+1),tmp+nbOfCompo*v);
+ int nbOfCompo=(int)_info_on_compo.size();
+ if(nbOfCompo>=1)
+ {
+ int nbOfTuples=getNumberOfTuples();
+ stream << "Number of tuples : " << nbOfTuples << ". Number of components : " << nbOfCompo << "." << std::endl;
+ reprQuickOverviewData(stream,MAX_NB_OF_BYTE_IN_REPR);
+ }
else
+ stream << "Number of components : 0.";
+ }
+ else
+ stream << "*** No data allocated ****";
+}
+
+void DataArrayInt::reprQuickOverviewData(std::ostream& stream, std::size_t maxNbOfByteInRepr) const
+{
+ const int *data=begin();
+ int nbOfTuples=getNumberOfTuples();
+ int nbOfCompo=(int)_info_on_compo.size();
+ std::ostringstream oss2; oss2 << "[";
+ std::string oss2Str(oss2.str());
+ bool isFinished=true;
+ for(int i=0;i<nbOfTuples && isFinished;i++)
+ {
+ if(nbOfCompo>1)
{
- std::ostringstream oss; oss << "DataArrayInt::renumberInPlace : At place #" << i << " value is " << v << " ! Should be in [0," << nbTuples << ") !";
- throw INTERP_KERNEL::Exception(oss.str().c_str());
+ oss2 << "(";
+ for(int j=0;j<nbOfCompo;j++,data++)
+ {
+ oss2 << *data;
+ if(j!=nbOfCompo-1) oss2 << ", ";
+ }
+ oss2 << ")";
}
+ else
+ oss2 << *data++;
+ if(i!=nbOfTuples-1) oss2 << ", ";
+ std::string oss3Str(oss2.str());
+ if(oss3Str.length()<maxNbOfByteInRepr)
+ oss2Str=oss3Str;
+ else
+ isFinished=false;
}
- std::copy(tmp,tmp+nbTuples*nbOfCompo,getPointer());
- delete [] tmp;
- declareAsNew();
+ stream << oss2Str;
+ if(!isFinished)
+ stream << "... ";
+ stream << "]";
}
/*!
- * Permutes values of \a this array as required by \a new2Old array. The values are
- * permuted so that \c new[ i ] = \c old[ \a new2Old[ i ]]. Number of tuples remains
- * the same as in \c this one.
- * For more info on renumbering see \ref numbering.
- * \param [in] new2Old - C array of length equal to \a this->getNumberOfTuples()
- * giving a previous position of i-th new value.
- * \return DataArrayInt * - the new instance of DataArrayInt that the caller
- * is to delete using decrRef() as it is no more needed.
+ * Modifies in place \a this one-dimensional array so that each value \a v = \a indArrBg[ \a v ],
+ * i.e. a current value is used as in index to get a new value from \a indArrBg.
+ * \param [in] indArrBg - pointer to the first element of array of new values to assign
+ * to \a this array.
+ * \param [in] indArrEnd - specifies the end of the array \a indArrBg, so that
+ * the last value of \a indArrBg is \a indArrEnd[ -1 ].
+ * \throw If \a this->getNumberOfComponents() != 1
+ * \throw If any value of \a this can't be used as a valid index for
+ * [\a indArrBg, \a indArrEnd).
+ *
+ * \sa changeValue
*/
-void DataArrayInt::renumberInPlaceR(const int *new2Old)
+void DataArrayInt::transformWithIndArr(const int *indArrBg, const int *indArrEnd)
{
checkAllocated();
- int nbTuples=getNumberOfTuples();
- int nbOfCompo=getNumberOfComponents();
- int *tmp=new int[nbTuples*nbOfCompo];
- const int *iptr=getConstPointer();
- for(int i=0;i<nbTuples;i++)
+ if(getNumberOfComponents()!=1)
+ throw INTERP_KERNEL::Exception("Call transformWithIndArr method on DataArrayInt with only one component, you can call 'rearrange' method before !");
+ int nbElemsIn((int)std::distance(indArrBg,indArrEnd)),nbOfTuples(getNumberOfTuples()),*pt(getPointer());
+ for(int i=0;i<nbOfTuples;i++,pt++)
{
- int v=new2Old[i];
- if(v>=0 && v<nbTuples)
- std::copy(iptr+nbOfCompo*v,iptr+nbOfCompo*(v+1),tmp+nbOfCompo*i);
+ if(*pt>=0 && *pt<nbElemsIn)
+ *pt=indArrBg[*pt];
else
{
- std::ostringstream oss; oss << "DataArrayInt::renumberInPlaceR : At place #" << i << " value is " << v << " ! Should be in [0," << nbTuples << ") !";
+ std::ostringstream oss; oss << "DataArrayInt::transformWithIndArr : error on tuple #" << i << " of this value is " << *pt << ", should be in [0," << nbElemsIn << ") !";
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
}
- std::copy(tmp,tmp+nbTuples*nbOfCompo,getPointer());
- delete [] tmp;
declareAsNew();
}
/*!
- * Returns a copy of \a this array with values permuted as required by \a old2New array.
- * The values are permuted so that \c new[ \a old2New[ i ]] = \c old[ i ].
- * Number of tuples in the result array remains the same as in \c this one.
- * If a permutation reduction is needed, renumberAndReduce() should be used.
- * For more info on renumbering see \ref numbering.
- * \param [in] old2New - C array of length equal to \a this->getNumberOfTuples()
- * giving a new position for i-th old value.
- * \return DataArrayInt * - the new instance of DataArrayInt that the caller
- * is to delete using decrRef() as it is no more needed.
- * \throw If \a this is not allocated.
- */
-DataArrayInt *DataArrayInt::renumber(const int *old2New) const
-{
- checkAllocated();
- int nbTuples=getNumberOfTuples();
- int nbOfCompo=getNumberOfComponents();
- MCAuto<DataArrayInt> ret=DataArrayInt::New();
- ret->alloc(nbTuples,nbOfCompo);
- ret->copyStringInfoFrom(*this);
- const int *iptr=getConstPointer();
- int *optr=ret->getPointer();
- for(int i=0;i<nbTuples;i++)
- std::copy(iptr+nbOfCompo*i,iptr+nbOfCompo*(i+1),optr+nbOfCompo*old2New[i]);
- ret->copyStringInfoFrom(*this);
- return ret.retn();
-}
-
-/*!
- * Returns a copy of \a this array with values permuted as required by \a new2Old array.
- * The values are permuted so that \c new[ i ] = \c old[ \a new2Old[ i ]]. Number of
- * tuples in the result array remains the same as in \c this one.
- * If a permutation reduction is needed, substr() or selectByTupleId() should be used.
- * For more info on renumbering see \ref numbering.
- * \param [in] new2Old - C array of length equal to \a this->getNumberOfTuples()
- * giving a previous position of i-th new value.
- * \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
-{
- checkAllocated();
- int nbTuples=getNumberOfTuples();
- int nbOfCompo=getNumberOfComponents();
- MCAuto<DataArrayInt> ret=DataArrayInt::New();
- ret->alloc(nbTuples,nbOfCompo);
- ret->copyStringInfoFrom(*this);
- const int *iptr=getConstPointer();
- int *optr=ret->getPointer();
- for(int i=0;i<nbTuples;i++)
- std::copy(iptr+nbOfCompo*new2Old[i],iptr+nbOfCompo*(new2Old[i]+1),optr+nbOfCompo*i);
- ret->copyStringInfoFrom(*this);
- return ret.retn();
-}
-
-/*!
- * Returns a shorten and permuted copy of \a this array. The new DataArrayInt is
- * of size \a newNbOfTuple and it's values are permuted as required by \a old2New array.
- * The values are permuted so that \c new[ \a old2New[ i ]] = \c old[ i ] for all
- * \a old2New[ i ] >= 0. In other words every i-th tuple in \a this array, for which
- * \a old2New[ i ] is negative, is missing from the result array.
- * For more info on renumbering see \ref numbering.
- * \param [in] old2New - C array of length equal to \a this->getNumberOfTuples()
- * giving a new position for i-th old tuple and giving negative position for
- * for i-th old tuple that should be omitted.
- * \return DataArrayInt * - the new instance of DataArrayInt that the caller
- * is to delete using decrRef() as it is no more needed.
+ * Computes distribution of values of \a this one-dimensional array between given value
+ * ranges (casts). This method is typically useful for entity number spliting by types,
+ * for example.
+ * \warning The values contained in \a arrBg should be sorted ascendently. No
+ * check of this is be done. If not, the result is not warranted.
+ * \param [in] arrBg - the array of ascending values defining the value ranges. The i-th
+ * value of \a arrBg (\a arrBg[ i ]) gives the lowest value of the i-th range,
+ * and the greatest value of the i-th range equals to \a arrBg[ i+1 ] - 1. \a
+ * arrBg containing \a n values defines \a n-1 ranges. The last value of \a arrBg
+ * should be more than every value in \a this array.
+ * \param [in] arrEnd - specifies the end of the array \a arrBg, so that
+ * the last value of \a arrBg is \a arrEnd[ -1 ].
+ * \param [out] castArr - a new instance of DataArrayInt, of same size as \a this array
+ * (same number of tuples and components), the caller is to delete
+ * using decrRef() as it is no more needed.
+ * This array contains indices of ranges for every value of \a this array. I.e.
+ * the i-th value of \a castArr gives the index of range the i-th value of \a this
+ * belongs to. Or, in other words, this parameter contains for each tuple in \a
+ * this in which cast it holds.
+ * \param [out] rankInsideCast - a new instance of DataArrayInt, of same size as \a this
+ * array, the caller is to delete using decrRef() as it is no more needed.
+ * This array contains ranks of values of \a this array within ranges
+ * they belongs to. I.e. the i-th value of \a rankInsideCast gives the rank of
+ * the i-th value of \a this array within the \a castArr[ i ]-th range, to which
+ * the i-th value of \a this belongs to. Or, in other words, this param contains
+ * for each tuple its rank inside its cast. The rank is computed as difference
+ * between the value and the lowest value of range.
+ * \param [out] castsPresent - a new instance of DataArrayInt, containing indices of
+ * ranges (casts) to which at least one value of \a this array belongs.
+ * Or, in other words, this param contains the casts that \a this contains.
+ * The caller is to delete this array using decrRef() as it is no more needed.
+ *
+ * \b Example: If \a this contains [6,5,0,3,2,7,8,1,4] and \a arrBg contains [0,4,9] then
+ * the output of this method will be :
+ * - \a castArr : [1,1,0,0,0,1,1,0,1]
+ * - \a rankInsideCast: [2,1,0,3,2,3,4,1,0]
+ * - \a castsPresent : [0,1]
+ *
+ * I.e. values of \a this array belong to 2 ranges: #0 and #1. Value 6 belongs to the
+ * range #1 and its rank within this range is 2; etc.
+ *
+ * \throw If \a this->getNumberOfComponents() != 1.
+ * \throw If \a arrEnd - arrBg < 2.
+ * \throw If any value of \a this is not less than \a arrEnd[-1].
*/
-DataArrayInt *DataArrayInt::renumberAndReduce(const int *old2New, int newNbOfTuple) const
+void DataArrayInt::splitByValueRange(const int *arrBg, const int *arrEnd,
+ DataArrayInt *& castArr, DataArrayInt *& rankInsideCast, DataArrayInt *& castsPresent) const
{
checkAllocated();
- int nbTuples=getNumberOfTuples();
- int nbOfCompo=getNumberOfComponents();
- MCAuto<DataArrayInt> ret=DataArrayInt::New();
- ret->alloc(newNbOfTuple,nbOfCompo);
- const int *iptr=getConstPointer();
- int *optr=ret->getPointer();
- for(int i=0;i<nbTuples;i++)
+ if(getNumberOfComponents()!=1)
+ throw INTERP_KERNEL::Exception("Call splitByValueRange method on DataArrayInt with only one component, you can call 'rearrange' method before !");
+ int nbOfTuples=getNumberOfTuples();
+ std::size_t nbOfCast=std::distance(arrBg,arrEnd);
+ if(nbOfCast<2)
+ throw INTERP_KERNEL::Exception("DataArrayInt::splitByValueRange : The input array giving the cast range values should be of size >=2 !");
+ nbOfCast--;
+ const int *work=getConstPointer();
+ typedef std::reverse_iterator<const int *> rintstart;
+ rintstart bg(arrEnd);//OK no problem because size of 'arr' is greater or equal 2
+ rintstart end2(arrBg);
+ MCAuto<DataArrayInt> ret1=DataArrayInt::New();
+ MCAuto<DataArrayInt> ret2=DataArrayInt::New();
+ MCAuto<DataArrayInt> ret3=DataArrayInt::New();
+ ret1->alloc(nbOfTuples,1);
+ ret2->alloc(nbOfTuples,1);
+ int *ret1Ptr=ret1->getPointer();
+ int *ret2Ptr=ret2->getPointer();
+ std::set<std::size_t> castsDetected;
+ for(int i=0;i<nbOfTuples;i++)
{
- int w=old2New[i];
- if(w>=0)
- std::copy(iptr+i*nbOfCompo,iptr+(i+1)*nbOfCompo,optr+w*nbOfCompo);
+ rintstart res=std::find_if(bg,end2,std::bind2nd(std::less_equal<int>(), work[i]));
+ std::size_t pos=std::distance(bg,res);
+ std::size_t pos2=nbOfCast-pos;
+ if(pos2<nbOfCast)
+ {
+ ret1Ptr[i]=(int)pos2;
+ ret2Ptr[i]=work[i]-arrBg[pos2];
+ castsDetected.insert(pos2);
+ }
+ else
+ {
+ std::ostringstream oss; oss << "DataArrayInt::splitByValueRange : At rank #" << i << " the value is " << work[i] << " should be in [0," << *bg << ") !";
+ throw INTERP_KERNEL::Exception(oss.str().c_str());
+ }
}
- ret->copyStringInfoFrom(*this);
- return ret.retn();
-}
-
-/*!
- * Returns a shorten and permuted copy of \a this array. The new DataArrayInt is
- * of size \a new2OldEnd - \a new2OldBg and it's values are permuted as required by
- * \a new2OldBg array.
- * The values are permuted so that \c new[ i ] = \c old[ \a new2OldBg[ i ]].
- * This method is equivalent to renumberAndReduce() except that convention in input is
- * \c new2old and \b not \c old2new.
- * For more info on renumbering see \ref numbering.
- * \param [in] new2OldBg - pointer to the beginning of a permutation array that gives a
- * tuple index in \a this array to fill the i-th tuple in the new array.
- * \param [in] new2OldEnd - specifies the end of the permutation array that starts at
- * \a new2OldBg, so that pointer to a tuple index (\a pi) varies as this:
- * \a new2OldBg <= \a pi < \a new2OldEnd.
- * \return DataArrayInt * - the new instance of DataArrayInt that the caller
- * is to delete using decrRef() as it is no more needed.
- */
-DataArrayInt *DataArrayInt::selectByTupleId(const int *new2OldBg, const int *new2OldEnd) const
-{
- checkAllocated();
- MCAuto<DataArrayInt> ret=DataArrayInt::New();
- int nbComp=getNumberOfComponents();
- ret->alloc((int)std::distance(new2OldBg,new2OldEnd),nbComp);
- ret->copyStringInfoFrom(*this);
- int *pt=ret->getPointer();
- const int *srcPt=getConstPointer();
- int i=0;
- for(const int *w=new2OldBg;w!=new2OldEnd;w++,i++)
- std::copy(srcPt+(*w)*nbComp,srcPt+((*w)+1)*nbComp,pt+i*nbComp);
- ret->copyStringInfoFrom(*this);
- return ret.retn();
+ ret3->alloc((int)castsDetected.size(),1);
+ std::copy(castsDetected.begin(),castsDetected.end(),ret3->getPointer());
+ castArr=ret1.retn();
+ rankInsideCast=ret2.retn();
+ castsPresent=ret3.retn();
}
/*!
- * Returns a shorten and permuted copy of \a this array. The new DataArrayInt is
- * of size \a new2OldEnd - \a new2OldBg and it's values are permuted as required by
- * \a new2OldBg array.
- * The values are permuted so that \c new[ i ] = \c old[ \a new2OldBg[ i ]].
- * This method is equivalent to renumberAndReduce() except that convention in input is
- * \c new2old and \b not \c old2new.
- * This method is equivalent to selectByTupleId() except that it prevents coping data
- * from behind the end of \a this array.
- * For more info on renumbering see \ref numbering.
- * \param [in] new2OldBg - pointer to the beginning of a permutation array that gives a
- * tuple index in \a this array to fill the i-th tuple in the new array.
- * \param [in] new2OldEnd - specifies the end of the permutation array that starts at
- * \a new2OldBg, so that pointer to a tuple index (\a pi) varies as this:
- * \a new2OldBg <= \a pi < \a new2OldEnd.
- * \return DataArrayInt * - the new instance of DataArrayInt that the caller
- * is to delete using decrRef() as it is no more needed.
- * \throw If \a new2OldEnd - \a new2OldBg > \a this->getNumberOfTuples().
+ * This method look at \a this if it can be considered as a range defined by the 3-tuple ( \a strt , \a sttoopp , \a stteepp ).
+ * If false is returned the tuple must be ignored. If true is returned \a this can be considered by a range( \a strt , \a sttoopp , \a stteepp ).
+ * This method works only if \a this is allocated and single component. If not an exception will be thrown.
+ *
+ * \param [out] strt - the start of the range (included) if true is returned.
+ * \param [out] sttoopp - the end of the range (not included) if true is returned.
+ * \param [out] stteepp - the step of the range if true is returned.
+ * \return the verdict of the check.
+ *
+ * \sa DataArray::GetNumberOfItemGivenBES
*/
-DataArrayInt *DataArrayInt::selectByTupleIdSafe(const int *new2OldBg, const int *new2OldEnd) const
+bool DataArrayInt::isRange(int& strt, int& sttoopp, int& stteepp) const
{
checkAllocated();
- MCAuto<DataArrayInt> ret=DataArrayInt::New();
- int nbComp=getNumberOfComponents();
- int oldNbOfTuples=getNumberOfTuples();
- ret->alloc((int)std::distance(new2OldBg,new2OldEnd),nbComp);
- ret->copyStringInfoFrom(*this);
- int *pt=ret->getPointer();
- const int *srcPt=getConstPointer();
- int i=0;
- for(const int *w=new2OldBg;w!=new2OldEnd;w++,i++)
- if(*w>=0 && *w<oldNbOfTuples)
- std::copy(srcPt+(*w)*nbComp,srcPt+((*w)+1)*nbComp,pt+i*nbComp);
- else
- throw INTERP_KERNEL::Exception("DataArrayInt::selectByTupleIdSafe : some ids has been detected to be out of [0,this->getNumberOfTuples) !");
- ret->copyStringInfoFrom(*this);
- return ret.retn();
+ if(getNumberOfComponents()!=1)
+ throw INTERP_KERNEL::Exception("DataArrayInt::isRange : this must be single component array !");
+ int nbTuples(getNumberOfTuples());
+ if(nbTuples==0)
+ { strt=0; sttoopp=0; stteepp=1; return true; }
+ const int *pt(begin());
+ strt=*pt;
+ if(nbTuples==1)
+ { sttoopp=strt+1; stteepp=1; return true; }
+ strt=*pt; sttoopp=pt[nbTuples-1];
+ if(strt==sttoopp)
+ return false;
+ if(sttoopp>strt)
+ {
+ sttoopp++;
+ int a(sttoopp-1-strt),tmp(strt);
+ if(a%(nbTuples-1)!=0)
+ return false;
+ stteepp=a/(nbTuples-1);
+ for(int i=0;i<nbTuples;i++,tmp+=stteepp)
+ if(pt[i]!=tmp)
+ return false;
+ return true;
+ }
+ else
+ {
+ sttoopp--;
+ int a(strt-sttoopp-1),tmp(strt);
+ if(a%(nbTuples-1)!=0)
+ return false;
+ stteepp=-(a/(nbTuples-1));
+ for(int i=0;i<nbTuples;i++,tmp+=stteepp)
+ if(pt[i]!=tmp)
+ return false;
+ return true;
+ }
}
/*!
- * Returns a shorten copy of \a this array. The new DataArrayInt contains every
- * (\a bg + \c i * \a step)-th tuple of \a this array located before the \a end2-th
- * tuple. Indices of the selected tuples are the same as ones returned by the Python
- * command \c range( \a bg, \a end2, \a step ).
- * This method is equivalent to selectByTupleIdSafe() except that the input array is
- * not constructed explicitly.
- * For more info on renumbering see \ref numbering.
- * \param [in] bg - index of the first tuple to copy from \a this array.
- * \param [in] end2 - index of the tuple before which the tuples to copy are located.
- * \param [in] step - index increment to get index of the next tuple to copy.
- * \return DataArrayInt * - the new instance of DataArrayInt that the caller
- * is to delete using decrRef() as it is no more needed.
- * \sa DataArrayInt::substr.
+ * Creates a one-dimensional DataArrayInt (\a res) whose contents are computed from
+ * values of \a this (\a a) and the given (\a indArr) arrays as follows:
+ * \a res[ \a indArr[ \a a[ i ]]] = i. I.e. for each value in place i \a v = \a a[ i ],
+ * new value in place \a indArr[ \a v ] is i.
+ * \param [in] indArrBg - the array holding indices within the result array to assign
+ * indices of values of \a this array pointing to values of \a indArrBg.
+ * \param [in] indArrEnd - specifies the end of the array \a indArrBg, so that
+ * the last value of \a indArrBg is \a indArrEnd[ -1 ].
+ * \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.
+ * \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::selectByTupleIdSafeSlice(int bg, int end2, int step) const
+DataArrayInt *DataArrayInt::transformWithIndArrR(const int *indArrBg, const int *indArrEnd) const
{
checkAllocated();
+ if(getNumberOfComponents()!=1)
+ throw INTERP_KERNEL::Exception("Call transformWithIndArrR method on DataArrayInt with only one component, you can call 'rearrange' method before !");
+ int nbElemsIn=(int)std::distance(indArrBg,indArrEnd);
+ int nbOfTuples=getNumberOfTuples();
+ const int *pt=getConstPointer();
MCAuto<DataArrayInt> ret=DataArrayInt::New();
- int nbComp=getNumberOfComponents();
- int newNbOfTuples=GetNumberOfItemGivenBESRelative(bg,end2,step,"DataArrayInt::selectByTupleIdSafeSlice : ");
- ret->alloc(newNbOfTuples,nbComp);
- int *pt=ret->getPointer();
- const int *srcPt=getConstPointer()+bg*nbComp;
- for(int i=0;i<newNbOfTuples;i++,srcPt+=step*nbComp)
- std::copy(srcPt,srcPt+nbComp,pt+i*nbComp);
- ret->copyStringInfoFrom(*this);
- return ret.retn();
-}
-
-/*!
- * Returns a shorten copy of \a this array. The new DataArrayInt contains ranges
- * of tuples specified by \a ranges parameter.
- * For more info on renumbering see \ref numbering.
- * \param [in] ranges - std::vector of std::pair's each of which defines a range
- * of tuples in [\c begin,\c end) format.
- * \return DataArrayInt * - the new instance of DataArrayInt that the caller
- * is to delete using decrRef() as it is no more needed.
- * \throw If \a end < \a begin.
- * \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
-{
- checkAllocated();
- int nbOfComp=getNumberOfComponents();
- int nbOfTuplesThis=getNumberOfTuples();
- if(ranges.empty())
- {
- MCAuto<DataArrayInt> ret=DataArrayInt::New();
- ret->alloc(0,nbOfComp);
- ret->copyStringInfoFrom(*this);
- return ret.retn();
- }
- int ref=ranges.front().first;
- int nbOfTuples=0;
- bool isIncreasing=true;
- for(std::vector<std::pair<int,int> >::const_iterator it=ranges.begin();it!=ranges.end();it++)
+ ret->alloc(nbOfTuples,1);
+ ret->fillWithValue(-1);
+ int *tmp=ret->getPointer();
+ for(int i=0;i<nbOfTuples;i++,pt++)
{
- if((*it).first<=(*it).second)
+ if(*pt>=0 && *pt<nbElemsIn)
{
- if((*it).first>=0 && (*it).second<=nbOfTuplesThis)
- {
- nbOfTuples+=(*it).second-(*it).first;
- if(isIncreasing)
- isIncreasing=ref<=(*it).first;
- ref=(*it).second;
- }
+ int pos=indArrBg[*pt];
+ if(pos>=0 && pos<nbOfTuples)
+ tmp[pos]=i;
else
{
- std::ostringstream oss; oss << "DataArrayInt::selectByTupleRanges : on range #" << std::distance(ranges.begin(),it);
- oss << " (" << (*it).first << "," << (*it).second << ") is greater than number of tuples of this :" << nbOfTuples << " !";
+ std::ostringstream oss; oss << "DataArrayInt::transformWithIndArrR : error on tuple #" << i << " value of new pos is " << pos << " ( indArrBg[" << *pt << "]) ! Should be in [0," << nbOfTuples << ") !";
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
}
else
{
- std::ostringstream oss; oss << "DataArrayInt::selectByTupleRanges : on range #" << std::distance(ranges.begin(),it);
- oss << " (" << (*it).first << "," << (*it).second << ") end is before begin !";
+ std::ostringstream oss; oss << "DataArrayInt::transformWithIndArrR : error on tuple #" << i << " value is " << *pt << " and indirectionnal array as a size equal to " << nbElemsIn << " !";
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
}
- if(isIncreasing && nbOfTuplesThis==nbOfTuples)
- return deepCopy();
- MCAuto<DataArrayInt> ret=DataArrayInt::New();
- ret->alloc(nbOfTuples,nbOfComp);
- ret->copyStringInfoFrom(*this);
- const int *src=getConstPointer();
- int *work=ret->getPointer();
- for(std::vector<std::pair<int,int> >::const_iterator it=ranges.begin();it!=ranges.end();it++)
- work=std::copy(src+(*it).first*nbOfComp,src+(*it).second*nbOfComp,work);
return ret.retn();
}
/*!
- * Returns a new DataArrayInt containing a renumbering map in "Old to New" mode.
- * This map, if applied to \a this array, would make it sorted. For example, if
- * \a this array contents are [9,10,0,6,4,11,3,7] then the contents of the result array
- * are [5,6,0,3,2,7,1,4]; if this result array (\a res) is used as an argument in call
- * \a this->renumber(\a res) then the returned array contains [0,3,4,6,7,9,10,11].
- * This method is useful for renumbering (in MED file for example). For more info
- * on renumbering see \ref numbering.
- * \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.
- * \throw If there are equal values in \a this array.
- */
-DataArrayInt *DataArrayInt::checkAndPreparePermutation() const
-{
- checkAllocated();
- if(getNumberOfComponents()!=1)
- throw INTERP_KERNEL::Exception("DataArrayInt::checkAndPreparePermutation : number of components must == 1 !");
- int nbTuples=getNumberOfTuples();
- const int *pt=getConstPointer();
- int *pt2=CheckAndPreparePermutation(pt,pt+nbTuples);
- DataArrayInt *ret=DataArrayInt::New();
- ret->useArray(pt2,true,C_DEALLOC,nbTuples,1);
- return ret;
-}
-
-/*!
- * This method tries to find the permutation to apply to the first input \a ids1 to obtain the same array (without considering strings informations) the second
- * input array \a ids2.
- * \a ids1 and \a ids2 are expected to be both a list of ids (both with number of components equal to one) not sorted and with values that can be negative.
- * This method will throw an exception is no such permutation array can be obtained. It is typically the case if there is some ids in \a ids1 not in \a ids2 or
- * inversely.
- * In case of success (no throw) : \c ids1->renumber(ret)->isEqual(ids2) where \a ret is the return of this method.
- *
- * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
- * array using decrRef() as it is no more needed.
- * \throw If either ids1 or ids2 is null not allocated or not with one components.
+ * Creates a one-dimensional DataArrayInt of given length, whose contents are computed
+ * from values of \a this array, which is supposed to contain a renumbering map in
+ * "Old to New" mode. The result array contains a renumbering map in "New to Old" mode.
+ * To know how to use the renumbering maps see \ref numbering.
+ * \param [in] newNbOfElem - the number of tuples 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
+ * 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::FindPermutationFromFirstToSecond(const DataArrayInt *ids1, const DataArrayInt *ids2)
-{
- if(!ids1 || !ids2)
- throw INTERP_KERNEL::Exception("DataArrayInt::FindPermutationFromFirstToSecond : the two input arrays must be not null !");
- if(!ids1->isAllocated() || !ids2->isAllocated())
- throw INTERP_KERNEL::Exception("DataArrayInt::FindPermutationFromFirstToSecond : the two input arrays must be allocated !");
- if(ids1->getNumberOfComponents()!=1 || ids2->getNumberOfComponents()!=1)
- throw INTERP_KERNEL::Exception("DataArrayInt::FindPermutationFromFirstToSecond : the two input arrays have exactly one component !");
- if(ids1->getNumberOfTuples()!=ids2->getNumberOfTuples())
- {
- std::ostringstream oss; oss << "DataArrayInt::FindPermutationFromFirstToSecond : first array has " << ids1->getNumberOfTuples() << " tuples and the second one " << ids2->getNumberOfTuples() << " tuples ! No chance to find a permutation between the 2 arrays !";
- throw INTERP_KERNEL::Exception(oss.str().c_str());
- }
- MCAuto<DataArrayInt> p1(ids1->deepCopy());
- MCAuto<DataArrayInt> p2(ids2->deepCopy());
- p1->sort(true); p2->sort(true);
- if(!p1->isEqualWithoutConsideringStr(*p2))
- throw INTERP_KERNEL::Exception("DataArrayInt::FindPermutationFromFirstToSecond : the two arrays are not lying on same ids ! Impossible to find a permutation between the 2 arrays !");
- p1=ids1->checkAndPreparePermutation();
- p2=ids2->checkAndPreparePermutation();
- p2=p2->invertArrayO2N2N2O(p2->getNumberOfTuples());
- p2=p2->selectByTupleIdSafe(p1->begin(),p1->end());
- return p2.retn();
-}
-
-/*!
- * Returns two arrays describing a surjective mapping from \a this set of values (\a A)
- * onto a set of values of size \a targetNb (\a B). The surjective function is
- * \a B[ \a A[ i ]] = i. That is to say that for each \a id in [0,\a targetNb), where \a
- * targetNb < \a this->getNumberOfTuples(), there exists at least one tupleId (\a tid) so
- * that <em> this->getIJ( tid, 0 ) == id</em>. <br>
- * The first of out arrays returns indices of elements of \a this array, grouped by their
- * place in the set \a B. The second out array is the index of the first one; it shows how
- * many elements of \a A are mapped into each element of \a B. <br>
- * For more info on
- * mapping and its usage in renumbering see \ref numbering. <br>
- * \b Example:
- * - \a this: [0,3,2,3,2,2,1,2]
- * - \a targetNb: 4
- * - \a arr: [0, 6, 2,4,5,7, 1,3]
- * - \a arrI: [0,1,2,6,8]
- *
- * This result means: <br>
- * the element of \a B 0 encounters within \a A once (\a arrI[ 0+1 ] - \a arrI[ 0 ]) and
- * its index within \a A is 0 ( \a arr[ 0:1 ] == \a arr[ \a arrI[ 0 ] : \a arrI[ 0+1 ]]);<br>
- * the element of \a B 2 encounters within \a A 4 times (\a arrI[ 2+1 ] - \a arrI[ 2 ]) and
- * its indices within \a A are [2,4,5,7] ( \a arr[ 2:6 ] == \a arr[ \a arrI[ 2 ] :
- * \a arrI[ 2+1 ]]); <br> etc.
- * \param [in] targetNb - the size of the set \a B. \a targetNb must be equal or more
- * than the maximal value of \a A.
- * \param [out] arr - a new instance of DataArrayInt returning indices of
- * elements of \a this, grouped by their place in the set \a B. The caller is to delete
- * this array using decrRef() as it is no more needed.
- * \param [out] arrI - a new instance of DataArrayInt returning size of groups of equal
- * elements of \a this. 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.
- * \throw If any value in \a this is more or equal to \a targetNb.
- */
-void DataArrayInt::changeSurjectiveFormat(int targetNb, DataArrayInt *&arr, DataArrayInt *&arrI) const
+DataArrayInt *DataArrayInt::invertArrayO2N2N2O(int newNbOfElem) const
{
- checkAllocated();
- if(getNumberOfComponents()!=1)
- throw INTERP_KERNEL::Exception("DataArrayInt::changeSurjectiveFormat : number of components must == 1 !");
- int nbOfTuples=getNumberOfTuples();
- MCAuto<DataArrayInt> ret(DataArrayInt::New());
- MCAuto<DataArrayInt> retI(DataArrayInt::New());
- retI->alloc(targetNb+1,1);
- const int *input=getConstPointer();
- std::vector< std::vector<int> > tmp(targetNb);
- for(int i=0;i<nbOfTuples;i++)
+ MCAuto<DataArrayInt> ret=DataArrayInt::New();
+ ret->alloc(newNbOfElem,1);
+ int nbOfOldNodes=getNumberOfTuples();
+ const int *old2New=getConstPointer();
+ int *pt=ret->getPointer();
+ for(int i=0;i!=nbOfOldNodes;i++)
{
- int tmp2=input[i];
- if(tmp2>=0 && tmp2<targetNb)
- tmp[tmp2].push_back(i);
- else
+ int newp(old2New[i]);
+ if(newp!=-1)
{
- std::ostringstream oss; oss << "DataArrayInt::changeSurjectiveFormat : At pos " << i << " presence of element " << tmp2 << " ! should be in [0," << targetNb << ") !";
- throw INTERP_KERNEL::Exception(oss.str().c_str());
+ 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());
+ }
}
}
- int *retIPtr=retI->getPointer();
- *retIPtr=0;
- for(std::vector< std::vector<int> >::const_iterator it1=tmp.begin();it1!=tmp.end();it1++,retIPtr++)
- retIPtr[1]=retIPtr[0]+(int)((*it1).size());
- if(nbOfTuples!=retI->getIJ(targetNb,0))
- throw INTERP_KERNEL::Exception("DataArrayInt::changeSurjectiveFormat : big problem should never happen !");
- ret->alloc(nbOfTuples,1);
- int *retPtr=ret->getPointer();
- for(std::vector< std::vector<int> >::const_iterator it1=tmp.begin();it1!=tmp.end();it1++)
- retPtr=std::copy((*it1).begin(),(*it1).end(),retPtr);
- arr=ret.retn();
- arrI=retI.retn();
+ return ret.retn();
}
-
/*!
- * Returns a new DataArrayInt containing a renumbering map in "Old to New" mode computed
- * from a zip representation of a surjective format (returned e.g. by
- * \ref MEDCoupling::DataArrayDouble::findCommonTuples() "DataArrayDouble::findCommonTuples()"
- * for example). The result array minimizes the permutation. <br>
- * For more info on renumbering see \ref numbering. <br>
- * \b Example: <br>
- * - \a nbOfOldTuples: 10
- * - \a arr : [0,3, 5,7,9]
- * - \a arrIBg : [0,2,5]
- * - \a newNbOfTuples: 7
- * - result array : [0,1,2,0,3,4,5,4,6,4]
- *
- * \param [in] nbOfOldTuples - number of tuples in the initial array \a arr.
- * \param [in] arr - the array of tuple indices grouped by \a arrIBg array.
- * \param [in] arrIBg - the array dividing all indices stored in \a arr into groups of
- * (indices of) equal values. Its every element (except the last one) points to
- * the first element of a group of equal values.
- * \param [in] arrIEnd - specifies the end of \a arrIBg, so that the last element of \a
- * arrIBg is \a arrIEnd[ -1 ].
- * \param [out] newNbOfTuples - number of tuples after surjection application.
- * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
- * array using decrRef() as it is no more needed.
- * \throw If any value of \a arr breaks condition ( 0 <= \a arr[ i ] < \a nbOfOldTuples ).
+ * 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::ConvertIndexArrayToO2N(int nbOfOldTuples, const int *arr, const int *arrIBg, const int *arrIEnd, int &newNbOfTuples)
+DataArrayInt *DataArrayInt::invertArrayO2N2N2OBis(int newNbOfElem) const
{
MCAuto<DataArrayInt> ret=DataArrayInt::New();
- ret->alloc(nbOfOldTuples,1);
+ ret->alloc(newNbOfElem,1);
+ int nbOfOldNodes=getNumberOfTuples();
+ const int *old2New=getConstPointer();
int *pt=ret->getPointer();
- std::fill(pt,pt+nbOfOldTuples,-1);
- int nbOfGrps=((int)std::distance(arrIBg,arrIEnd))-1;
- const int *cIPtr=arrIBg;
- for(int i=0;i<nbOfGrps;i++)
- pt[arr[cIPtr[i]]]=-(i+2);
- int newNb=0;
- for(int iNode=0;iNode<nbOfOldTuples;iNode++)
+ for(int i=nbOfOldNodes-1;i>=0;i--)
{
- if(pt[iNode]<0)
+ int newp(old2New[i]);
+ if(newp!=-1)
{
- if(pt[iNode]==-1)
- pt[iNode]=newNb++;
+ if(newp>=0 && newp<newNbOfElem)
+ pt[newp]=i;
else
{
- int grpId=-(pt[iNode]+2);
- for(int j=cIPtr[grpId];j<cIPtr[grpId+1];j++)
- {
- if(arr[j]>=0 && arr[j]<nbOfOldTuples)
- pt[arr[j]]=newNb;
- else
- {
- std::ostringstream oss; oss << "DataArrayInt::ConvertIndexArrayToO2N : With element #" << j << " value is " << arr[j] << " should be in [0," << nbOfOldTuples << ") !";
- throw INTERP_KERNEL::Exception(oss.str().c_str());
- }
- }
- newNb++;
+ 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());
}
}
}
- newNbOfTuples=newNb;
return ret.retn();
}
/*!
- * Returns a new DataArrayInt containing a renumbering map in "New to Old" mode,
- * which if applied to \a this array would make it sorted ascendingly.
- * For more info on renumbering see \ref numbering. <br>
- * \b Example: <br>
- * - \a this: [2,0,1,1,0,1,2,0,1,1,0,0]
- * - result: [10,0,5,6,1,7,11,2,8,9,3,4]
- * - after applying result to \a this: [0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2]
+ * Creates a one-dimensional DataArrayInt of given length, whose contents are computed
+ * from values of \a this array, which is supposed to contain a renumbering map in
+ * "New to Old" mode. The result array contains a renumbering map in "Old to New" mode.
+ * To know how to use the renumbering maps see \ref numbering.
+ * \param [in] newNbOfElem - the number of tuples 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
+ * needed.
+ *
+ * \if ENABLE_EXAMPLES
+ * \ref cpp_mcdataarrayint_invertarrayn2o2o2n "Here is a C++ example".
*
- * \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.
+ * \ref py_mcdataarrayint_invertarrayn2o2o2n "Here is a Python example".
+ * \endif
*/
-DataArrayInt *DataArrayInt::buildPermArrPerLevel() const
+DataArrayInt *DataArrayInt::invertArrayN2O2O2N(int oldNbOfElem) const
{
checkAllocated();
- if(getNumberOfComponents()!=1)
- throw INTERP_KERNEL::Exception("DataArrayInt::buildPermArrPerLevel : number of components must == 1 !");
- int nbOfTuples=getNumberOfTuples();
- const int *pt=getConstPointer();
- std::map<int,int> m;
MCAuto<DataArrayInt> ret=DataArrayInt::New();
- ret->alloc(nbOfTuples,1);
- int *opt=ret->getPointer();
- for(int i=0;i<nbOfTuples;i++,pt++,opt++)
+ ret->alloc(oldNbOfElem,1);
+ const int *new2Old=getConstPointer();
+ int *pt=ret->getPointer();
+ std::fill(pt,pt+oldNbOfElem,-1);
+ int nbOfNewElems=getNumberOfTuples();
+ for(int i=0;i<nbOfNewElems;i++)
{
- int val=*pt;
- std::map<int,int>::iterator it=m.find(val);
- if(it!=m.end())
- {
- *opt=(*it).second;
- (*it).second++;
- }
+ int v(new2Old[i]);
+ if(v>=0 && v<oldNbOfElem)
+ pt[v]=i;
else
{
- *opt=0;
- m.insert(std::pair<int,int>(val,1));
+ std::ostringstream oss; oss << "DataArrayInt::invertArrayN2O2O2N : in new id #" << i << " old value is " << v << " expected to be in [0," << oldNbOfElem << ") !";
+ throw INTERP_KERNEL::Exception(oss.str().c_str());
}
}
- int sum=0;
- for(std::map<int,int>::iterator it=m.begin();it!=m.end();it++)
- {
- int vt=(*it).second;
- (*it).second=sum;
- sum+=vt;
- }
- pt=getConstPointer();
- opt=ret->getPointer();
- for(int i=0;i<nbOfTuples;i++,pt++,opt++)
- *opt+=m[*pt];
- //
return ret.retn();
}
/*!
- * Checks if contents of \a this array are equal to that of an array filled with
- * iota(). This method is particularly useful for DataArrayInt instances that represent
- * a renumbering array to check the real need in renumbering. This method checks than \a this can be considered as an identity function
- * of a set having \a sizeExpected elements into itself.
+ * Equivalent to DataArrayInt::isEqual except that if false the reason of
+ * mismatch is given.
+ *
+ * \param [in] other the instance to be compared with \a this
+ * \param [out] reason In case of inequality returns the reason.
+ * \sa DataArrayInt::isEqual
+ */
+bool DataArrayInt::isEqualIfNotWhy(const DataArrayInt& other, std::string& reason) const
+{
+ if(!areInfoEqualsIfNotWhy(other,reason))
+ return false;
+ return _mem.isEqual(other._mem,0,reason);
+}
+
+/*!
+ * Checks if \a this and another DataArrayInt are fully equal. For more info see
+ * \ref MEDCouplingArrayBasicsCompare.
+ * \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
+{
+ std::string tmp;
+ return isEqualIfNotWhy(other,tmp);
+}
+
+/*!
+ * Checks if values of \a this and another DataArrayInt are equal. For more info see
+ * \ref MEDCouplingArrayBasicsCompare.
+ * \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
+{
+ std::string tmp;
+ return _mem.isEqual(other._mem,0,tmp);
+}
+
+/*!
+ * Checks if values of \a this and another DataArrayInt are equal. Comparison is
+ * performed on sorted value sequences.
+ * For more info see\ref MEDCouplingArrayBasicsCompare.
+ * \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
+{
+ MCAuto<DataArrayInt> a=deepCopy();
+ MCAuto<DataArrayInt> b=other.deepCopy();
+ a->sort();
+ b->sort();
+ return a->isEqualWithoutConsideringStr(*b);
+}
+
+/*!
+ * 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.
+ * For performance reasons \a this is expected to be sorted ascendingly. If not an exception will be thrown.
*
- * \param [in] sizeExpected - The number of elements expected.
- * \return bool - \a true if \a this array contents == \a range( \a this->getNumberOfTuples())
- * \throw If \a this is not allocated.
- * \throw If \a this->getNumberOfComponents() != 1.
+ * \param [in] v - the vector of 'flags' to be compared with \a this.
+ *
+ * \throw If \a this is not sorted ascendingly.
+ * \throw If \a this has not exactly one component.
+ * \throw If \a this is not allocated.
*/
-bool DataArrayInt::isIota(int sizeExpected) const
+bool DataArrayInt::isFittingWith(const std::vector<bool>& v) const
{
checkAllocated();
if(getNumberOfComponents()!=1)
- return false;
- int nbOfTuples(getNumberOfTuples());
- if(nbOfTuples!=sizeExpected)
- return false;
- const int *pt=getConstPointer();
- for(int i=0;i<nbOfTuples;i++,pt++)
- if(*pt!=i)
- return false;
- return true;
+ throw INTERP_KERNEL::Exception("DataArrayInt::isFittingWith : number of components of this should be equal to one !");
+ const int *w(begin()),*end2(end());
+ int refVal=-std::numeric_limits<int>::max();
+ int i=0;
+ std::vector<bool>::const_iterator it(v.begin());
+ for(;it!=v.end();it++,i++)
+ {
+ if(*it)
+ {
+ if(w!=end2)
+ {
+ if(*w++==i)
+ {
+ if(i>refVal)
+ refVal=i;
+ else
+ {
+ std::ostringstream oss; oss << "DataArrayInt::isFittingWith : At pos #" << std::distance(begin(),w-1) << " this is not sorted ascendingly !";
+ throw INTERP_KERNEL::Exception(oss.str().c_str());
+ }
+ }
+ else
+ return false;
+ }
+ else
+ return false;
+ }
+ }
+ return w==end2;
}
/*!
- * Checks if all values in \a this array are equal to \a val.
- * \param [in] val - value to check equality of array values to.
- * \return bool - \a true if all values are \a val.
- * \throw If \a this is not allocated.
- * \throw If \a this->getNumberOfComponents() != 1
+ * This method assumes that \a this has one component and is allocated. This method scans all tuples in \a this and for all tuple equal to \a val
+ * put True to the corresponding entry in \a vec.
+ * \a vec is expected to be with the same size than the number of tuples of \a this.
+ *
+ * \sa DataArrayInt::switchOnTupleNotEqualTo.
*/
-bool DataArrayInt::isUniform(int val) const
+void DataArrayInt::switchOnTupleEqualTo(int val, std::vector<bool>& vec) const
{
checkAllocated();
if(getNumberOfComponents()!=1)
- throw INTERP_KERNEL::Exception("DataArrayInt::isUniform : must be applied on DataArrayInt with only one component, you can call 'rearrange' method before !");
- int nbOfTuples=getNumberOfTuples();
- const int *w=getConstPointer();
- const int *end2=w+nbOfTuples;
- for(;w!=end2;w++)
- if(*w!=val)
- return false;
- return true;
+ throw INTERP_KERNEL::Exception("DataArrayInt::switchOnTupleEqualTo : number of components of this should be equal to one !");
+ int nbOfTuples(getNumberOfTuples());
+ if(nbOfTuples!=(int)vec.size())
+ throw INTERP_KERNEL::Exception("DataArrayInt::switchOnTupleEqualTo : number of tuples of this should be equal to size of input vector of bool !");
+ const int *pt(begin());
+ for(int i=0;i<nbOfTuples;i++)
+ if(pt[i]==val)
+ vec[i]=true;
}
/*!
- * Creates a new DataArrayDouble and assigns all (textual and numerical) data of \a this
- * array to the new one.
- * \return DataArrayDouble * - the new instance of DataArrayInt.
+ * This method assumes that \a this has one component and is allocated. This method scans all tuples in \a this and for all tuple different from \a val
+ * put True to the corresponding entry in \a vec.
+ * \a vec is expected to be with the same size than the number of tuples of \a this.
+ *
+ * \sa DataArrayInt::switchOnTupleEqualTo.
*/
-DataArrayDouble *DataArrayInt::convertToDblArr() const
+void DataArrayInt::switchOnTupleNotEqualTo(int val, std::vector<bool>& vec) const
{
checkAllocated();
- DataArrayDouble *ret=DataArrayDouble::New();
- ret->alloc(getNumberOfTuples(),getNumberOfComponents());
- std::size_t nbOfVals=getNbOfElems();
- const int *src=getConstPointer();
- double *dest=ret->getPointer();
- std::copy(src,src+nbOfVals,dest);
- ret->copyStringInfoFrom(*this);
- return ret;
+ if(getNumberOfComponents()!=1)
+ throw INTERP_KERNEL::Exception("DataArrayInt::switchOnTupleNotEqualTo : number of components of this should be equal to one !");
+ int nbOfTuples(getNumberOfTuples());
+ if(nbOfTuples!=(int)vec.size())
+ throw INTERP_KERNEL::Exception("DataArrayInt::switchOnTupleNotEqualTo : number of tuples of this should be equal to size of input vector of bool !");
+ const int *pt(begin());
+ for(int i=0;i<nbOfTuples;i++)
+ if(pt[i]!=val)
+ vec[i]=true;
}
/*!
- * Returns a shorten copy of \a this array. The new DataArrayInt contains all
- * tuples starting from the \a tupleIdBg-th tuple and including all tuples located before
- * the \a tupleIdEnd-th one. This methods has a similar behavior as std::string::substr().
- * This method is a specialization of selectByTupleIdSafeSlice().
- * \param [in] tupleIdBg - index of the first tuple to copy from \a this array.
- * \param [in] tupleIdEnd - index of the tuple before which the tuples to copy are located.
- * If \a tupleIdEnd == -1, all the tuples till the end of \a this array are copied.
- * \return DataArrayInt * - the new instance of DataArrayInt that the caller
- * is to delete using decrRef() as it is no more needed.
- * \throw If \a tupleIdBg < 0.
- * \throw If \a tupleIdBg > \a this->getNumberOfTuples().
- \throw If \a tupleIdEnd != -1 && \a tupleIdEnd < \a this->getNumberOfTuples().
- * \sa DataArrayInt::selectByTupleIdSafeSlice
+ * 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::substr(int tupleIdBg, int tupleIdEnd) const
+DataArrayInt *DataArrayInt::sumPerTuple() const
{
checkAllocated();
- int nbt=getNumberOfTuples();
- if(tupleIdBg<0)
- throw INTERP_KERNEL::Exception("DataArrayInt::substr : The tupleIdBg parameter must be greater than 0 !");
- if(tupleIdBg>nbt)
- throw INTERP_KERNEL::Exception("DataArrayInt::substr : The tupleIdBg parameter is greater than number of tuples !");
- int trueEnd=tupleIdEnd;
- if(tupleIdEnd!=-1)
- {
- if(tupleIdEnd>nbt)
- throw INTERP_KERNEL::Exception("DataArrayInt::substr : The tupleIdBg parameter is greater or equal than number of tuples !");
- }
- else
- trueEnd=nbt;
- int nbComp=getNumberOfComponents();
- MCAuto<DataArrayInt> ret=DataArrayInt::New();
- ret->alloc(trueEnd-tupleIdBg,nbComp);
- ret->copyStringInfoFrom(*this);
- std::copy(getConstPointer()+tupleIdBg*nbComp,getConstPointer()+trueEnd*nbComp,ret->getPointer());
+ int nbOfComp(getNumberOfComponents()),nbOfTuple(getNumberOfTuples());
+ MCAuto<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();
}
/*!
- * Changes the number of components within \a this array so that its raw data **does
- * not** change, instead splitting this data into tuples changes.
- * \warning This method erases all (name and unit) component info set before!
- * \param [in] newNbOfComp - number of components for \a this array to have.
- * \throw If \a this is not allocated
- * \throw If getNbOfElems() % \a newNbOfCompo != 0.
- * \throw If \a newNbOfCompo is lower than 1.
- * \throw If the rearrange method would lead to a number of tuples higher than 2147483647 (maximal capacity of int32 !).
- * \warning This method erases all (name and unit) component info set before!
+ * 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.
*/
-void DataArrayInt::rearrange(int newNbOfCompo)
+void DataArrayInt::checkMonotonic(bool increasing) const
{
- checkAllocated();
- if(newNbOfCompo<1)
- throw INTERP_KERNEL::Exception("DataArrayInt::rearrange : input newNbOfCompo must be > 0 !");
- std::size_t nbOfElems=getNbOfElems();
- if(nbOfElems%newNbOfCompo!=0)
- throw INTERP_KERNEL::Exception("DataArrayInt::rearrange : nbOfElems%newNbOfCompo!=0 !");
- if(nbOfElems/newNbOfCompo>(std::size_t)std::numeric_limits<int>::max())
- throw INTERP_KERNEL::Exception("DataArrayInt::rearrange : the rearrangement leads to too high number of tuples (> 2147483647) !");
- _info_on_compo.clear();
- _info_on_compo.resize(newNbOfCompo);
- declareAsNew();
+ 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 !");
+ }
}
/*!
- * Changes the number of components within \a this array to be equal to its number
- * of tuples, and inversely its number of tuples to become equal to its number of
- * components. So that its raw data **does not** change, instead splitting this
- * data into tuples changes.
- * \warning This method erases all (name and unit) component info set before!
- * \warning Do not confuse this method with fromNoInterlace() and toNoInterlace()!
+ * 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.
- * \sa rearrange()
*/
-void DataArrayInt::transpose()
+bool DataArrayInt::isMonotonic(bool increasing) const
{
checkAllocated();
- int nbOfTuples=getNumberOfTuples();
- rearrange(nbOfTuples);
+ if(getNumberOfComponents()!=1)
+ throw INTERP_KERNEL::Exception("DataArrayInt::isMonotonic : only supported with 'this' array with ONE component !");
+ int nbOfElements=getNumberOfTuples();
+ const int *ptr=getConstPointer();
+ if(nbOfElements==0)
+ return true;
+ int ref=ptr[0];
+ if(increasing)
+ {
+ for(int i=1;i<nbOfElements;i++)
+ {
+ if(ptr[i]>=ref)
+ ref=ptr[i];
+ else
+ return false;
+ }
+ }
+ else
+ {
+ for(int i=1;i<nbOfElements;i++)
+ {
+ if(ptr[i]<=ref)
+ ref=ptr[i];
+ else
+ return false;
+ }
+ }
+ return true;
}
/*!
- * Returns a shorten or extended copy of \a this array. If \a newNbOfComp is less
- * than \a this->getNumberOfComponents() then the result array is shorten as each tuple
- * is truncated to have \a newNbOfComp components, keeping first components. If \a
- * newNbOfComp is more than \a this->getNumberOfComponents() then the result array is
- * expanded as each tuple is populated with \a dftValue to have \a newNbOfComp
- * components.
- * \param [in] newNbOfComp - number of components for the new array to have.
- * \param [in] dftValue - value assigned to new values added to the new array.
- * \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.
+ * This method check that array consistently INCREASING or DECREASING in value.
*/
-DataArrayInt *DataArrayInt::changeNbOfComponents(int newNbOfComp, int dftValue) const
+bool DataArrayInt::isStrictlyMonotonic(bool increasing) const
{
checkAllocated();
- MCAuto<DataArrayInt> ret=DataArrayInt::New();
- ret->alloc(getNumberOfTuples(),newNbOfComp);
- const int *oldc=getConstPointer();
- int *nc=ret->getPointer();
- int nbOfTuples=getNumberOfTuples();
- int oldNbOfComp=getNumberOfComponents();
- int dim=std::min(oldNbOfComp,newNbOfComp);
- for(int i=0;i<nbOfTuples;i++)
+ if(getNumberOfComponents()!=1)
+ throw INTERP_KERNEL::Exception("DataArrayInt::isStrictlyMonotonic : only supported with 'this' array with ONE component !");
+ int nbOfElements=getNumberOfTuples();
+ const int *ptr=getConstPointer();
+ if(nbOfElements==0)
+ return true;
+ int ref=ptr[0];
+ if(increasing)
+ {
+ for(int i=1;i<nbOfElements;i++)
+ {
+ if(ptr[i]>ref)
+ ref=ptr[i];
+ else
+ return false;
+ }
+ }
+ else
{
- int j=0;
- for(;j<dim;j++)
- nc[newNbOfComp*i+j]=oldc[i*oldNbOfComp+j];
- for(;j<newNbOfComp;j++)
- nc[newNbOfComp*i+j]=dftValue;
+ for(int i=1;i<nbOfElements;i++)
+ {
+ if(ptr[i]<ref)
+ ref=ptr[i];
+ else
+ return false;
+ }
}
- ret->setName(getName());
- for(int i=0;i<dim;i++)
- ret->setInfoOnComponent(i,getInfoOnComponent(i));
- ret->setName(getName());
- return ret.retn();
+ return true;
}
/*!
- * Changes number of tuples in the array. If the new number of tuples is smaller
- * than the current number the array is truncated, otherwise the array is extended.
- * \param [in] nbOfTuples - new number of tuples.
- * \throw If \a this is not allocated.
- * \throw If \a nbOfTuples is negative.
+ * This method check that array consistently INCREASING or DECREASING in value.
*/
-void DataArrayInt::reAlloc(int nbOfTuples)
+void DataArrayInt::checkStrictlyMonotonic(bool increasing) const
{
- if(nbOfTuples<0)
- throw INTERP_KERNEL::Exception("DataArrayInt::reAlloc : input new number of tuples should be >=0 !");
- checkAllocated();
- _mem.reAlloc(getNumberOfComponents()*(std::size_t)nbOfTuples);
- declareAsNew();
+ 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 !");
+ }
}
-
/*!
- * Returns a copy of \a this array composed of selected components.
- * The new DataArrayInt has the same number of tuples but includes components
- * specified by \a compoIds parameter. So that getNbOfElems() of the result array
- * can be either less, same or more than \a this->getNbOfElems().
- * \param [in] compoIds - sequence of zero based indices of components to include
- * into the new array.
- * \return DataArrayInt * - the new instance of DataArrayInt that the caller
- * is to delete using decrRef() as it is no more needed.
- * \throw If \a this is not allocated.
- * \throw If a component index (\a i) is not valid:
- * \a i < 0 || \a i >= \a this->getNumberOfComponents().
- *
+ * 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 py_mcdataarrayint_keepselectedcomponents "Here is a Python example".
+ * \ref cpp_mcdataarrayint_buildpermutationarr "Here is a C++ example".
+ *
+ * \ref py_mcdataarrayint_buildpermutationarr "Here is a Python example".
* \endif
*/
-DataArrayInt *DataArrayInt::keepSelectedComponents(const std::vector<int>& compoIds) const
+DataArrayInt *DataArrayInt::buildPermutationArr(const DataArrayInt& other) const
{
checkAllocated();
- MCAuto<DataArrayInt> ret(DataArrayInt::New());
- int newNbOfCompo=(int)compoIds.size();
- int oldNbOfCompo=getNumberOfComponents();
- for(std::vector<int>::const_iterator it=compoIds.begin();it!=compoIds.end();it++)
- DataArray::CheckValueInRange(oldNbOfCompo,(*it),"keepSelectedComponents invalid requested component");
- int nbOfTuples=getNumberOfTuples();
- ret->alloc(nbOfTuples,newNbOfCompo);
- ret->copyPartOfStringInfoFrom(*this,compoIds);
- const int *oldc=getConstPointer();
- int *nc=ret->getPointer();
- for(int i=0;i<nbOfTuples;i++)
- for(int j=0;j<newNbOfCompo;j++,nc++)
- *nc=oldc[i*oldNbOfCompo+compoIds[j]];
+ if(getNumberOfComponents()!=1 || other.getNumberOfComponents()!=1)
+ throw INTERP_KERNEL::Exception("DataArrayInt::buildPermutationArr : 'this' and 'other' have to have exactly ONE component !");
+ int nbTuple=getNumberOfTuples();
+ other.checkAllocated();
+ if(nbTuple!=other.getNumberOfTuples())
+ throw INTERP_KERNEL::Exception("DataArrayInt::buildPermutationArr : 'this' and 'other' must have the same number of tuple !");
+ MCAuto<DataArrayInt> ret=DataArrayInt::New();
+ ret->alloc(nbTuple,1);
+ ret->fillWithValue(-1);
+ const int *pt=getConstPointer();
+ std::map<int,int> mm;
+ for(int i=0;i<nbTuple;i++)
+ mm[pt[i]]=i;
+ pt=other.getConstPointer();
+ int *retToFill=ret->getPointer();
+ for(int 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();
}
/*!
- * Appends components of another array to components of \a this one, tuple by tuple.
- * So that the number of tuples of \a this array remains the same and the number of
- * components increases.
- * \param [in] other - the DataArrayInt to append to \a this one.
- * \throw If \a this is not allocated.
- * \throw If \a this and \a other arrays have different number of tuples.
+ * Elements of \a partOfThis are expected to be included in \a this.
+ * The returned array \a ret is so that this[ret]==partOfThis
*
- * \if ENABLE_EXAMPLES
- * \ref cpp_mcdataarrayint_meldwith "Here is a C++ example".
+ * 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].
*
- * \ref py_mcdataarrayint_meldwith "Here is a Python example".
- * \endif
+ * \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.
*/
-void DataArrayInt::meldWith(const DataArrayInt *other)
+DataArrayInt *DataArrayInt::indicesOfSubPart(const DataArrayInt& partOfThis) const
{
- if(!other)
- throw INTERP_KERNEL::Exception("DataArrayInt::meldWith : DataArrayInt pointer in input is NULL !");
- checkAllocated();
- other->checkAllocated();
- int nbOfTuples=getNumberOfTuples();
- if(nbOfTuples!=other->getNumberOfTuples())
- throw INTERP_KERNEL::Exception("DataArrayInt::meldWith : mismatch of number of tuples !");
- int nbOfComp1=getNumberOfComponents();
- int nbOfComp2=other->getNumberOfComponents();
- int *newArr=(int *)malloc(nbOfTuples*(nbOfComp1+nbOfComp2)*sizeof(int));
- int *w=newArr;
- const int *inp1=getConstPointer();
- const int *inp2=other->getConstPointer();
- for(int i=0;i<nbOfTuples;i++,inp1+=nbOfComp1,inp2+=nbOfComp2)
+ if(getNumberOfComponents()!=1 || partOfThis.getNumberOfComponents()!=1)
+ throw INTERP_KERNEL::Exception("DataArrayInt::indicesOfSubPart : this and input array must be one component array !");
+ checkAllocated(); partOfThis.checkAllocated();
+ int thisNbTuples(getNumberOfTuples()),nbTuples(partOfThis.getNumberOfTuples());
+ const int *thisPt(begin()),*pt(partOfThis.begin());
+ MCAuto<DataArrayInt> ret(DataArrayInt::New());
+ ret->alloc(nbTuples,1);
+ int *retPt(ret->getPointer());
+ std::map<int,int> m;
+ for(int i=0;i<thisNbTuples;i++,thisPt++)
+ m[*thisPt]=i;
+ if(m.size()!=thisNbTuples)
+ throw INTERP_KERNEL::Exception("DataArrayInt::indicesOfSubPart : some elements appears more than once !");
+ for(int i=0;i<nbTuples;i++,retPt++,pt++)
{
- w=std::copy(inp1,inp1+nbOfComp1,w);
- w=std::copy(inp2,inp2+nbOfComp2,w);
+ std::map<int,int>::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());
+ }
}
- useArray(newArr,true,C_DEALLOC,nbOfTuples,nbOfComp1+nbOfComp2);
- std::vector<int> compIds(nbOfComp2);
- for(int i=0;i<nbOfComp2;i++)
- compIds[i]=nbOfComp1+i;
- copyPartOfStringInfoFrom2(compIds,*other);
+ return ret.retn();
}
-/*!
- * Copy all components in a specified order from another DataArrayInt.
- * The specified components become the first ones in \a this array.
- * Both numerical and textual data is copied. The number of tuples in \a this and
- * the other array can be different.
- * \param [in] a - the array to copy data from.
- * \param [in] compoIds - sequence of zero based indices of components, data of which is
- * to be copied.
- * \throw If \a a 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)
+void DataArrayInt::aggregate(const DataArrayInt *other)
{
- if(!a)
- throw INTERP_KERNEL::Exception("DataArrayInt::setSelectedComponents : input DataArrayInt is NULL !");
- checkAllocated();
- a->checkAllocated();
- copyPartOfStringInfoFrom2(compoIds,*a);
- std::size_t partOfCompoSz=compoIds.size();
- int nbOfCompo=getNumberOfComponents();
- int nbOfTuples=std::min(getNumberOfTuples(),a->getNumberOfTuples());
- const int *ac=a->getConstPointer();
- int *nc=getPointer();
- for(int i=0;i<nbOfTuples;i++)
- for(std::size_t j=0;j<partOfCompoSz;j++,ac++)
- nc[nbOfCompo*i+compoIds[j]]=*ac;
+ if(!other)
+ throw INTERP_KERNEL::Exception("DataArrayInt::aggregate : null pointer !");
+ if(getNumberOfComponents()!=other->getNumberOfComponents())
+ throw INTERP_KERNEL::Exception("DataArrayInt::aggregate : mismatch number of components !");
+ _mem.insertAtTheEnd(other->begin(),other->end());
}
/*!
- * Copy all values from another DataArrayInt into specified tuples and components
- * of \a this array. Textual data is not copied.
- * The tree parameters defining set of indices of tuples and components are similar to
- * the tree parameters of the Python function \c range(\c start,\c stop,\c step).
- * \param [in] a - the array to copy values from.
- * \param [in] bgTuples - index of the first tuple of \a this array to assign values to.
- * \param [in] endTuples - index of the tuple before which the tuples to assign to
- * are located.
- * \param [in] stepTuples - index increment to get index of the next tuple to assign to.
- * \param [in] bgComp - index of the first component of \a this array to assign values to.
- * \param [in] endComp - index of the component before which the components to assign
- * to are located.
- * \param [in] stepComp - index increment to get index of the next component to assign to.
- * \param [in] strictCompoCompare - if \a true (by default), then \a a->getNumberOfComponents()
- * must be equal to the number of columns to assign to, else an
- * exception is thrown; if \a false, then it is only required that \a
- * a->getNbOfElems() equals to number of values to assign to (this condition
- * must be respected even if \a strictCompoCompare is \a true). The number of
- * values to assign to is given by following Python expression:
- * \a nbTargetValues =
- * \c len(\c range(\a bgTuples,\a endTuples,\a stepTuples)) *
- * \c len(\c range(\a bgComp,\a endComp,\a stepComp)).
- * \throw If \a a is NULL.
- * \throw If \a a is not allocated.
- * \throw If \a this is not allocated.
- * \throw If parameters specifying tuples and components to assign to do not give a
- * non-empty range of increasing indices.
- * \throw If \a a->getNbOfElems() != \a nbTargetValues.
- * \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
+ * Returns a new DataArrayInt holding the same values as \a this array but differently
+ * arranged in memory. If \a this array holds 2 components of 3 values:
+ * \f$ x_0,x_1,x_2,y_0,y_1,y_2 \f$, then the result array holds these values arranged
+ * as follows: \f$ x_0,y_0,x_1,y_1,x_2,y_2 \f$.
+ * \warning Do not confuse this method with transpose()!
+ * \return DataArrayInt * - the new instance of DataArrayInt that the caller
+ * is to delete using decrRef() as it is no more needed.
+ * \throw If \a this is not allocated.
*/
-void DataArrayInt::setPartOfValues1(const DataArrayInt *a, int bgTuples, int endTuples, int stepTuples, int bgComp, int endComp, int stepComp, bool strictCompoCompare)
+DataArrayInt *DataArrayInt::fromNoInterlace() const
{
- if(!a)
- throw INTERP_KERNEL::Exception("DataArrayInt::setPartOfValues1 : DataArrayInt pointer in input is NULL !");
- const char msg[]="DataArrayInt::setPartOfValues1";
checkAllocated();
- a->checkAllocated();
- int newNbOfTuples=DataArray::GetNumberOfItemGivenBES(bgTuples,endTuples,stepTuples,msg);
- int newNbOfComp=DataArray::GetNumberOfItemGivenBES(bgComp,endComp,stepComp,msg);
- int nbComp=getNumberOfComponents();
- int nbOfTuples=getNumberOfTuples();
- DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
- DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
- bool assignTech=true;
- if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
- {
- if(strictCompoCompare)
- a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
- }
- else
- {
- a->checkNbOfTuplesAndComp(1,newNbOfComp,msg);
- assignTech=false;
- }
- int *pt=getPointer()+bgTuples*nbComp+bgComp;
- const int *srcPt=a->getConstPointer();
- if(assignTech)
- {
- for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
- for(int j=0;j<newNbOfComp;j++,srcPt++)
- pt[j*stepComp]=*srcPt;
- }
- else
- {
- for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
- {
- const int *srcPt2=srcPt;
- for(int j=0;j<newNbOfComp;j++,srcPt2++)
- pt[j*stepComp]=*srcPt2;
- }
- }
+ if(_mem.isNull())
+ throw INTERP_KERNEL::Exception("DataArrayInt::fromNoInterlace : Not defined array !");
+ int *tab=_mem.fromNoInterlace(getNumberOfComponents());
+ DataArrayInt *ret=DataArrayInt::New();
+ ret->useArray(tab,true,C_DEALLOC,getNumberOfTuples(),getNumberOfComponents());
+ return ret;
}
/*!
- * Assign a given value to values at specified tuples and components of \a this array.
- * The tree parameters defining set of indices of tuples and components are similar to
- * the tree parameters of the Python function \c range(\c start,\c stop,\c step)..
- * \param [in] a - the value to assign.
- * \param [in] bgTuples - index of the first tuple of \a this array to assign to.
- * \param [in] endTuples - index of the tuple before which the tuples to assign to
- * are located.
- * \param [in] stepTuples - index increment to get index of the next tuple to assign to.
- * \param [in] bgComp - index of the first component of \a this array to assign to.
- * \param [in] endComp - index of the component before which the components to assign
- * to are located.
- * \param [in] stepComp - index increment to get index of the next component to assign to.
+ * Returns a new DataArrayInt holding the same values as \a this array but differently
+ * arranged in memory. If \a this array holds 2 components of 3 values:
+ * \f$ x_0,y_0,x_1,y_1,x_2,y_2 \f$, then the result array holds these values arranged
+ * as follows: \f$ x_0,x_1,x_2,y_0,y_1,y_2 \f$.
+ * \warning Do not confuse this method with transpose()!
+ * \return DataArrayInt * - the new instance of DataArrayInt that the caller
+ * is to delete using decrRef() as it is no more needed.
* \throw If \a this is not allocated.
- * \throw If parameters specifying tuples and components to assign to, do not give a
- * non-empty range of increasing indices or indices are out of a valid range
- * for \c 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)
+DataArrayInt *DataArrayInt::toNoInterlace() const
{
- const char msg[]="DataArrayInt::setPartOfValuesSimple1";
checkAllocated();
- int newNbOfTuples=DataArray::GetNumberOfItemGivenBES(bgTuples,endTuples,stepTuples,msg);
- int newNbOfComp=DataArray::GetNumberOfItemGivenBES(bgComp,endComp,stepComp,msg);
- int nbComp=getNumberOfComponents();
- int nbOfTuples=getNumberOfTuples();
- DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
- DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
- int *pt=getPointer()+bgTuples*nbComp+bgComp;
- for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
- for(int j=0;j<newNbOfComp;j++)
- pt[j*stepComp]=a;
+ if(_mem.isNull())
+ throw INTERP_KERNEL::Exception("DataArrayInt::toNoInterlace : Not defined array !");
+ int *tab=_mem.toNoInterlace(getNumberOfComponents());
+ DataArrayInt *ret=DataArrayInt::New();
+ ret->useArray(tab,true,C_DEALLOC,getNumberOfTuples(),getNumberOfComponents());
+ return ret;
}
-
/*!
- * Copy all values from another DataArrayInt (\a a) into specified tuples and
- * components of \a this array. Textual data is not copied.
- * The tuples and components to assign to are defined by C arrays of indices.
- * There are two *modes of usage*:
- * - If \a a->getNbOfElems() equals to number of values to assign to, then every value
- * of \a a is assigned to its own location within \a this array.
- * - If \a a includes one tuple, then all values of \a a are assigned to the specified
- * components of every specified tuple of \a this array. In this mode it is required
- * that \a a->getNumberOfComponents() equals to the number of specified components.
- *
- * \param [in] a - the array to copy values from.
- * \param [in] bgTuples - pointer to an array of tuple indices of \a this array to
- * assign values of \a a to.
- * \param [in] endTuples - specifies the end of the array \a bgTuples, so that
- * pointer to a tuple index <em>(pi)</em> varies as this:
- * \a bgTuples <= \a pi < \a endTuples.
- * \param [in] bgComp - pointer to an array of component indices of \a this array to
- * assign values of \a a to.
- * \param [in] endComp - specifies the end of the array \a bgTuples, so that
- * pointer to a component index <em>(pi)</em> varies as this:
- * \a bgComp <= \a pi < \a endComp.
- * \param [in] strictCompoCompare - this parameter is checked only if the
- * *mode of usage* is the first; if it is \a true (default),
- * then \a a->getNumberOfComponents() must be equal
- * to the number of specified columns, else this is not required.
- * \throw If \a a is NULL.
- * \throw If \a a is not allocated.
+ * Returns a new DataArrayInt containing a renumbering map in "Old to New" mode.
+ * This map, if applied to \a this array, would make it sorted. For example, if
+ * \a this array contents are [9,10,0,6,4,11,3,7] then the contents of the result array
+ * are [5,6,0,3,2,7,1,4]; if this result array (\a res) is used as an argument in call
+ * \a this->renumber(\a res) then the returned array contains [0,3,4,6,7,9,10,11].
+ * This method is useful for renumbering (in MED file for example). For more info
+ * on renumbering see \ref numbering.
+ * \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 any index of tuple/component given by <em>bgTuples / bgComp</em> is
- * out of a valid range for \a this array.
- * \throw In the first *mode of usage*, if <em>strictCompoCompare == true </em> and
- * if <em> a->getNumberOfComponents() != (endComp - bgComp) </em>.
- * \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
+ * \throw If \a this->getNumberOfComponents() != 1.
+ * \throw If there are equal values in \a this array.
*/
-void DataArrayInt::setPartOfValues2(const DataArrayInt *a, const int *bgTuples, const int *endTuples, const int *bgComp, const int *endComp, bool strictCompoCompare)
+DataArrayInt *DataArrayInt::checkAndPreparePermutation() const
{
- if(!a)
- throw INTERP_KERNEL::Exception("DataArrayInt::setPartOfValues2 : DataArrayInt pointer in input is NULL !");
- const char msg[]="DataArrayInt::setPartOfValues2";
checkAllocated();
- a->checkAllocated();
- int nbComp=getNumberOfComponents();
- int nbOfTuples=getNumberOfTuples();
- for(const int *z=bgComp;z!=endComp;z++)
- DataArray::CheckValueInRange(nbComp,*z,"invalid component id");
- int newNbOfTuples=(int)std::distance(bgTuples,endTuples);
- int newNbOfComp=(int)std::distance(bgComp,endComp);
- bool assignTech=true;
- if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
- {
- if(strictCompoCompare)
- a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
- }
- else
- {
- a->checkNbOfTuplesAndComp(1,newNbOfComp,msg);
- assignTech=false;
- }
- int *pt=getPointer();
- const int *srcPt=a->getConstPointer();
- if(assignTech)
- {
- for(const int *w=bgTuples;w!=endTuples;w++)
- {
- DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
- for(const int *z=bgComp;z!=endComp;z++,srcPt++)
- {
- pt[(std::size_t)(*w)*nbComp+(*z)]=*srcPt;
- }
- }
- }
- else
- {
- for(const int *w=bgTuples;w!=endTuples;w++)
- {
- const int *srcPt2=srcPt;
- DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
- for(const int *z=bgComp;z!=endComp;z++,srcPt2++)
- {
- pt[(std::size_t)(*w)*nbComp+(*z)]=*srcPt2;
- }
- }
- }
+ if(getNumberOfComponents()!=1)
+ throw INTERP_KERNEL::Exception("DataArrayInt::checkAndPreparePermutation : number of components must == 1 !");
+ int nbTuples=getNumberOfTuples();
+ const int *pt=getConstPointer();
+ int *pt2=CheckAndPreparePermutation(pt,pt+nbTuples);
+ DataArrayInt *ret=DataArrayInt::New();
+ ret->useArray(pt2,true,C_DEALLOC,nbTuples,1);
+ return ret;
}
/*!
- * Assign a given value to values at specified tuples and components of \a this array.
- * The tuples and components to assign to are defined by C arrays of indices.
- * \param [in] a - the value to assign.
- * \param [in] bgTuples - pointer to an array of tuple indices of \a this array to
- * assign \a a to.
- * \param [in] endTuples - specifies the end of the array \a bgTuples, so that
- * pointer to a tuple index (\a pi) varies as this:
- * \a bgTuples <= \a pi < \a endTuples.
- * \param [in] bgComp - pointer to an array of component indices of \a this array to
- * assign \a a to.
- * \param [in] endComp - specifies the end of the array \a bgTuples, so that
- * pointer to a component index (\a pi) varies as this:
- * \a bgComp <= \a pi < \a endComp.
- * \throw If \a this is not allocated.
- * \throw If any index of tuple/component given by <em>bgTuples / bgComp</em> is
- * out of a valid range for \a this array.
+ * This method tries to find the permutation to apply to the first input \a ids1 to obtain the same array (without considering strings informations) the second
+ * input array \a ids2.
+ * \a ids1 and \a ids2 are expected to be both a list of ids (both with number of components equal to one) not sorted and with values that can be negative.
+ * This method will throw an exception is no such permutation array can be obtained. It is typically the case if there is some ids in \a ids1 not in \a ids2 or
+ * inversely.
+ * In case of success (no throw) : \c ids1->renumber(ret)->isEqual(ids2) where \a ret is the return of this method.
*
- * \if ENABLE_EXAMPLES
- * \ref py_mcdataarrayint_setpartofvaluessimple2 "Here is a Python example".
- * \endif
+ * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
+ * array using decrRef() as it is no more needed.
+ * \throw If either ids1 or ids2 is null not allocated or not with one components.
+ *
*/
-void DataArrayInt::setPartOfValuesSimple2(int a, const int *bgTuples, const int *endTuples, const int *bgComp, const int *endComp)
+DataArrayInt *DataArrayInt::FindPermutationFromFirstToSecond(const DataArrayInt *ids1, const DataArrayInt *ids2)
{
- checkAllocated();
- int nbComp=getNumberOfComponents();
- int nbOfTuples=getNumberOfTuples();
- for(const int *z=bgComp;z!=endComp;z++)
- DataArray::CheckValueInRange(nbComp,*z,"invalid component id");
- int *pt=getPointer();
- for(const int *w=bgTuples;w!=endTuples;w++)
- for(const int *z=bgComp;z!=endComp;z++)
- {
- DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
- pt[(std::size_t)(*w)*nbComp+(*z)]=a;
- }
+ if(!ids1 || !ids2)
+ throw INTERP_KERNEL::Exception("DataArrayInt::FindPermutationFromFirstToSecond : the two input arrays must be not null !");
+ if(!ids1->isAllocated() || !ids2->isAllocated())
+ throw INTERP_KERNEL::Exception("DataArrayInt::FindPermutationFromFirstToSecond : the two input arrays must be allocated !");
+ if(ids1->getNumberOfComponents()!=1 || ids2->getNumberOfComponents()!=1)
+ throw INTERP_KERNEL::Exception("DataArrayInt::FindPermutationFromFirstToSecond : the two input arrays have exactly one component !");
+ if(ids1->getNumberOfTuples()!=ids2->getNumberOfTuples())
+ {
+ std::ostringstream oss; oss << "DataArrayInt::FindPermutationFromFirstToSecond : first array has " << ids1->getNumberOfTuples() << " tuples and the second one " << ids2->getNumberOfTuples() << " tuples ! No chance to find a permutation between the 2 arrays !";
+ throw INTERP_KERNEL::Exception(oss.str().c_str());
+ }
+ MCAuto<DataArrayInt> p1(ids1->deepCopy());
+ MCAuto<DataArrayInt> p2(ids2->deepCopy());
+ p1->sort(true); p2->sort(true);
+ if(!p1->isEqualWithoutConsideringStr(*p2))
+ throw INTERP_KERNEL::Exception("DataArrayInt::FindPermutationFromFirstToSecond : the two arrays are not lying on same ids ! Impossible to find a permutation between the 2 arrays !");
+ p1=ids1->checkAndPreparePermutation();
+ p2=ids2->checkAndPreparePermutation();
+ p2=p2->invertArrayO2N2N2O(p2->getNumberOfTuples());
+ p2=p2->selectByTupleIdSafe(p1->begin(),p1->end());
+ return p2.retn();
}
/*!
- * Copy all values from another DataArrayInt (\a a) into specified tuples and
- * components of \a this array. Textual data is not copied.
- * The tuples to assign to are defined by a C array of indices.
- * The components to assign to are defined by three values similar to parameters of
- * the Python function \c range(\c start,\c stop,\c step).
- * There are two *modes of usage*:
- * - If \a a->getNbOfElems() equals to number of values to assign to, then every value
- * of \a a is assigned to its own location within \a this array.
- * - If \a a includes one tuple, then all values of \a a are assigned to the specified
- * components of every specified tuple of \a this array. In this mode it is required
- * that \a a->getNumberOfComponents() equals to the number of specified components.
+ * Returns two arrays describing a surjective mapping from \a this set of values (\a A)
+ * onto a set of values of size \a targetNb (\a B). The surjective function is
+ * \a B[ \a A[ i ]] = i. That is to say that for each \a id in [0,\a targetNb), where \a
+ * targetNb < \a this->getNumberOfTuples(), there exists at least one tupleId (\a tid) so
+ * that <em> this->getIJ( tid, 0 ) == id</em>. <br>
+ * The first of out arrays returns indices of elements of \a this array, grouped by their
+ * place in the set \a B. The second out array is the index of the first one; it shows how
+ * many elements of \a A are mapped into each element of \a B. <br>
+ * For more info on
+ * mapping and its usage in renumbering see \ref numbering. <br>
+ * \b Example:
+ * - \a this: [0,3,2,3,2,2,1,2]
+ * - \a targetNb: 4
+ * - \a arr: [0, 6, 2,4,5,7, 1,3]
+ * - \a arrI: [0,1,2,6,8]
*
- * \param [in] a - the array to copy values from.
- * \param [in] bgTuples - pointer to an array of tuple indices of \a this array to
- * assign values of \a a to.
- * \param [in] endTuples - specifies the end of the array \a bgTuples, so that
- * pointer to a tuple index <em>(pi)</em> varies as this:
- * \a bgTuples <= \a pi < \a endTuples.
- * \param [in] bgComp - index of the first component of \a this array to assign to.
- * \param [in] endComp - index of the component before which the components to assign
- * to are located.
- * \param [in] stepComp - index increment to get index of the next component to assign to.
- * \param [in] strictCompoCompare - this parameter is checked only in the first
- * *mode of usage*; if \a strictCompoCompare is \a true (default),
- * then \a a->getNumberOfComponents() must be equal
- * to the number of specified columns, else this is not required.
- * \throw If \a a is NULL.
- * \throw If \a a is not allocated.
+ * This result means: <br>
+ * the element of \a B 0 encounters within \a A once (\a arrI[ 0+1 ] - \a arrI[ 0 ]) and
+ * its index within \a A is 0 ( \a arr[ 0:1 ] == \a arr[ \a arrI[ 0 ] : \a arrI[ 0+1 ]]);<br>
+ * the element of \a B 2 encounters within \a A 4 times (\a arrI[ 2+1 ] - \a arrI[ 2 ]) and
+ * its indices within \a A are [2,4,5,7] ( \a arr[ 2:6 ] == \a arr[ \a arrI[ 2 ] :
+ * \a arrI[ 2+1 ]]); <br> etc.
+ * \param [in] targetNb - the size of the set \a B. \a targetNb must be equal or more
+ * than the maximal value of \a A.
+ * \param [out] arr - a new instance of DataArrayInt returning indices of
+ * elements of \a this, grouped by their place in the set \a B. The caller is to delete
+ * this array using decrRef() as it is no more needed.
+ * \param [out] arrI - a new instance of DataArrayInt returning size of groups of equal
+ * elements of \a this. The caller is to delete this array using decrRef() as it
+ * is no more needed.
* \throw If \a this is not allocated.
- * \throw If any index of tuple given by \a bgTuples is out of a valid range for
- * \a this array.
- * \throw In the first *mode of usage*, if <em>strictCompoCompare == true </em> and
- * if <em> a->getNumberOfComponents()</em> is unequal to the number of components
- * defined by <em>(bgComp,endComp,stepComp)</em>.
- * \throw In the second *mode of usage*, if \a a->getNumberOfTuples() != 1 or
- * <em> a->getNumberOfComponents()</em> is unequal to the number of components
- * defined by <em>(bgComp,endComp,stepComp)</em>.
- * \throw If parameters specifying components to assign to, do not give a
- * non-empty range of increasing indices or indices are out of a valid range
- * for \c this array.
- *
- * \if ENABLE_EXAMPLES
- * \ref py_mcdataarrayint_setpartofvalues3 "Here is a Python example".
- * \endif
+ * \throw If \a this->getNumberOfComponents() != 1.
+ * \throw If any value in \a this is more or equal to \a targetNb.
*/
-void DataArrayInt::setPartOfValues3(const DataArrayInt *a, const int *bgTuples, const int *endTuples, int bgComp, int endComp, int stepComp, bool strictCompoCompare)
+void DataArrayInt::changeSurjectiveFormat(int targetNb, DataArrayInt *&arr, DataArrayInt *&arrI) const
{
- if(!a)
- throw INTERP_KERNEL::Exception("DataArrayInt::setPartOfValues3 : DataArrayInt pointer in input is NULL !");
- const char msg[]="DataArrayInt::setPartOfValues3";
checkAllocated();
- a->checkAllocated();
- int newNbOfComp=DataArray::GetNumberOfItemGivenBES(bgComp,endComp,stepComp,msg);
- int nbComp=getNumberOfComponents();
+ if(getNumberOfComponents()!=1)
+ throw INTERP_KERNEL::Exception("DataArrayInt::changeSurjectiveFormat : number of components must == 1 !");
int nbOfTuples=getNumberOfTuples();
- DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
- int newNbOfTuples=(int)std::distance(bgTuples,endTuples);
- bool assignTech=true;
- if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
- {
- if(strictCompoCompare)
- a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
- }
- else
- {
- a->checkNbOfTuplesAndComp(1,newNbOfComp,msg);
- assignTech=false;
- }
- int *pt=getPointer()+bgComp;
- const int *srcPt=a->getConstPointer();
- if(assignTech)
- {
- for(const int *w=bgTuples;w!=endTuples;w++)
- for(int j=0;j<newNbOfComp;j++,srcPt++)
- {
- DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
- pt[(std::size_t)(*w)*nbComp+j*stepComp]=*srcPt;
- }
- }
- else
+ MCAuto<DataArrayInt> ret(DataArrayInt::New());
+ MCAuto<DataArrayInt> retI(DataArrayInt::New());
+ retI->alloc(targetNb+1,1);
+ const int *input=getConstPointer();
+ std::vector< std::vector<int> > tmp(targetNb);
+ for(int i=0;i<nbOfTuples;i++)
{
- for(const int *w=bgTuples;w!=endTuples;w++)
+ int tmp2=input[i];
+ if(tmp2>=0 && tmp2<targetNb)
+ tmp[tmp2].push_back(i);
+ else
{
- const int *srcPt2=srcPt;
- for(int j=0;j<newNbOfComp;j++,srcPt2++)
- {
- DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
- pt[(std::size_t)(*w)*nbComp+j*stepComp]=*srcPt2;
- }
+ std::ostringstream oss; oss << "DataArrayInt::changeSurjectiveFormat : At pos " << i << " presence of element " << tmp2 << " ! should be in [0," << targetNb << ") !";
+ throw INTERP_KERNEL::Exception(oss.str().c_str());
}
}
+ int *retIPtr=retI->getPointer();
+ *retIPtr=0;
+ for(std::vector< std::vector<int> >::const_iterator it1=tmp.begin();it1!=tmp.end();it1++,retIPtr++)
+ retIPtr[1]=retIPtr[0]+(int)((*it1).size());
+ if(nbOfTuples!=retI->getIJ(targetNb,0))
+ throw INTERP_KERNEL::Exception("DataArrayInt::changeSurjectiveFormat : big problem should never happen !");
+ ret->alloc(nbOfTuples,1);
+ int *retPtr=ret->getPointer();
+ for(std::vector< std::vector<int> >::const_iterator it1=tmp.begin();it1!=tmp.end();it1++)
+ retPtr=std::copy((*it1).begin(),(*it1).end(),retPtr);
+ arr=ret.retn();
+ arrI=retI.retn();
}
+
/*!
- * Assign a given value to values at specified tuples and components of \a this array.
- * The tuples to assign to are defined by a C array of indices.
- * The components to assign to are defined by three values similar to parameters of
- * the Python function \c range(\c start,\c stop,\c step).
- * \param [in] a - the value to assign.
- * \param [in] bgTuples - pointer to an array of tuple indices of \a this array to
- * assign \a a to.
- * \param [in] endTuples - specifies the end of the array \a bgTuples, so that
- * pointer to a tuple index <em>(pi)</em> varies as this:
- * \a bgTuples <= \a pi < \a endTuples.
- * \param [in] bgComp - index of the first component of \a this array to assign to.
- * \param [in] endComp - index of the component before which the components to assign
- * to are located.
- * \param [in] stepComp - index increment to get index of the next component to assign to.
- * \throw If \a this is not allocated.
- * \throw If any index of tuple given by \a bgTuples is out of a valid range for
- * \a this array.
- * \throw If parameters specifying components to assign to, do not give a
- * non-empty range of increasing indices or indices are out of a valid range
- * for \c this array.
+ * Returns a new DataArrayInt containing a renumbering map in "Old to New" mode computed
+ * from a zip representation of a surjective format (returned e.g. by
+ * \ref MEDCoupling::DataArrayDouble::findCommonTuples() "DataArrayDouble::findCommonTuples()"
+ * for example). The result array minimizes the permutation. <br>
+ * For more info on renumbering see \ref numbering. <br>
+ * \b Example: <br>
+ * - \a nbOfOldTuples: 10
+ * - \a arr : [0,3, 5,7,9]
+ * - \a arrIBg : [0,2,5]
+ * - \a newNbOfTuples: 7
+ * - result array : [0,1,2,0,3,4,5,4,6,4]
*
- * \if ENABLE_EXAMPLES
- * \ref py_mcdataarrayint_setpartofvaluessimple3 "Here is a Python example".
- * \endif
+ * \param [in] nbOfOldTuples - number of tuples in the initial array \a arr.
+ * \param [in] arr - the array of tuple indices grouped by \a arrIBg array.
+ * \param [in] arrIBg - the array dividing all indices stored in \a arr into groups of
+ * (indices of) equal values. Its every element (except the last one) points to
+ * the first element of a group of equal values.
+ * \param [in] arrIEnd - specifies the end of \a arrIBg, so that the last element of \a
+ * arrIBg is \a arrIEnd[ -1 ].
+ * \param [out] newNbOfTuples - number of tuples after surjection application.
+ * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
+ * array using decrRef() as it is no more needed.
+ * \throw If any value of \a arr breaks condition ( 0 <= \a arr[ i ] < \a nbOfOldTuples ).
*/
-void DataArrayInt::setPartOfValuesSimple3(int a, const int *bgTuples, const int *endTuples, int bgComp, int endComp, int stepComp)
-{
- const char msg[]="DataArrayInt::setPartOfValuesSimple3";
- checkAllocated();
- int newNbOfComp=DataArray::GetNumberOfItemGivenBES(bgComp,endComp,stepComp,msg);
- int nbComp=getNumberOfComponents();
- int nbOfTuples=getNumberOfTuples();
- DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
- int *pt=getPointer()+bgComp;
- for(const int *w=bgTuples;w!=endTuples;w++)
- for(int j=0;j<newNbOfComp;j++)
- {
- DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
- pt[(std::size_t)(*w)*nbComp+j*stepComp]=a;
- }
-}
-
-void DataArrayInt::setPartOfValues4(const DataArrayInt *a, int bgTuples, int endTuples, int stepTuples, const int *bgComp, const int *endComp, bool strictCompoCompare)
+DataArrayInt *DataArrayInt::ConvertIndexArrayToO2N(int nbOfOldTuples, const int *arr, const int *arrIBg, const int *arrIEnd, int &newNbOfTuples)
{
- if(!a)
- throw INTERP_KERNEL::Exception("DataArrayInt::setPartOfValues4 : input DataArrayInt is NULL !");
- const char msg[]="DataArrayInt::setPartOfValues4";
- checkAllocated();
- a->checkAllocated();
- int newNbOfTuples=DataArray::GetNumberOfItemGivenBES(bgTuples,endTuples,stepTuples,msg);
- int newNbOfComp=(int)std::distance(bgComp,endComp);
- int nbComp=getNumberOfComponents();
- for(const int *z=bgComp;z!=endComp;z++)
- DataArray::CheckValueInRange(nbComp,*z,"invalid component id");
- int nbOfTuples=getNumberOfTuples();
- DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
- bool assignTech=true;
- if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
- {
- if(strictCompoCompare)
- a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
- }
- else
- {
- a->checkNbOfTuplesAndComp(1,newNbOfComp,msg);
- assignTech=false;
- }
- const int *srcPt=a->getConstPointer();
- int *pt=getPointer()+bgTuples*nbComp;
- if(assignTech)
- {
- for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
- for(const int *z=bgComp;z!=endComp;z++,srcPt++)
- pt[*z]=*srcPt;
- }
- else
+ MCAuto<DataArrayInt> ret=DataArrayInt::New();
+ ret->alloc(nbOfOldTuples,1);
+ int *pt=ret->getPointer();
+ std::fill(pt,pt+nbOfOldTuples,-1);
+ int nbOfGrps=((int)std::distance(arrIBg,arrIEnd))-1;
+ const int *cIPtr=arrIBg;
+ for(int i=0;i<nbOfGrps;i++)
+ pt[arr[cIPtr[i]]]=-(i+2);
+ int newNb=0;
+ for(int iNode=0;iNode<nbOfOldTuples;iNode++)
{
- for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
+ if(pt[iNode]<0)
{
- const int *srcPt2=srcPt;
- for(const int *z=bgComp;z!=endComp;z++,srcPt2++)
- pt[*z]=*srcPt2;
+ if(pt[iNode]==-1)
+ pt[iNode]=newNb++;
+ else
+ {
+ int grpId=-(pt[iNode]+2);
+ for(int j=cIPtr[grpId];j<cIPtr[grpId+1];j++)
+ {
+ if(arr[j]>=0 && arr[j]<nbOfOldTuples)
+ pt[arr[j]]=newNb;
+ else
+ {
+ std::ostringstream oss; oss << "DataArrayInt::ConvertIndexArrayToO2N : With element #" << j << " value is " << arr[j] << " should be in [0," << nbOfOldTuples << ") !";
+ throw INTERP_KERNEL::Exception(oss.str().c_str());
+ }
+ }
+ newNb++;
+ }
}
}
+ newNbOfTuples=newNb;
+ return ret.retn();
}
-void DataArrayInt::setPartOfValuesSimple4(int a, int bgTuples, int endTuples, int stepTuples, const int *bgComp, const int *endComp)
-{
- const char msg[]="DataArrayInt::setPartOfValuesSimple4";
- checkAllocated();
- int newNbOfTuples=DataArray::GetNumberOfItemGivenBES(bgTuples,endTuples,stepTuples,msg);
- int nbComp=getNumberOfComponents();
- for(const int *z=bgComp;z!=endComp;z++)
- DataArray::CheckValueInRange(nbComp,*z,"invalid component id");
- int nbOfTuples=getNumberOfTuples();
- DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
- int *pt=getPointer()+bgTuples*nbComp;
- for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
- for(const int *z=bgComp;z!=endComp;z++)
- pt[*z]=a;
-}
-
-/*!
- * Copy some tuples from another DataArrayInt into specified tuples
- * of \a this array. Textual data is not copied. Both arrays must have equal number of
- * components.
- * Both the tuples to assign and the tuples to assign to are defined by a DataArrayInt.
- * All components of selected tuples are copied.
- * \param [in] a - the array to copy values from.
- * \param [in] tuplesSelec - the array specifying both source tuples of \a a and
- * target tuples of \a this. \a tuplesSelec has two components, and the
- * first component specifies index of the source tuple and the second
- * one specifies index of the target tuple.
+/*!
+ * Returns a new DataArrayInt containing a renumbering map in "New to Old" mode,
+ * which if applied to \a this array would make it sorted ascendingly.
+ * For more info on renumbering see \ref numbering. <br>
+ * \b Example: <br>
+ * - \a this: [2,0,1,1,0,1,2,0,1,1,0,0]
+ * - result: [10,0,5,6,1,7,11,2,8,9,3,4]
+ * - after applying result to \a this: [0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2]
+ *
+ * \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 a is NULL.
- * \throw If \a a is not allocated.
- * \throw If \a tuplesSelec is NULL.
- * \throw If \a tuplesSelec is not allocated.
- * \throw If <em>this->getNumberOfComponents() != a->getNumberOfComponents()</em>.
- * \throw If \a tuplesSelec->getNumberOfComponents() != 2.
- * \throw If any tuple index given by \a tuplesSelec is out of a valid range for
- * the corresponding (\a this or \a a) array.
+ * \throw If \a this->getNumberOfComponents() != 1.
*/
-void DataArrayInt::setPartOfValuesAdv(const DataArrayInt *a, const DataArrayInt *tuplesSelec)
+DataArrayInt *DataArrayInt::buildPermArrPerLevel() const
{
- if(!a || !tuplesSelec)
- throw INTERP_KERNEL::Exception("DataArrayInt::setPartOfValuesAdv : DataArrayInt pointer in input is NULL !");
checkAllocated();
- a->checkAllocated();
- tuplesSelec->checkAllocated();
- int nbOfComp=getNumberOfComponents();
- if(nbOfComp!=a->getNumberOfComponents())
- throw INTERP_KERNEL::Exception("DataArrayInt::setPartOfValuesAdv : This and a do not have the same number of components !");
- if(tuplesSelec->getNumberOfComponents()!=2)
- throw INTERP_KERNEL::Exception("DataArrayInt::setPartOfValuesAdv : Expecting to have a tuple selector DataArrayInt instance with exactly 2 components !");
- int thisNt=getNumberOfTuples();
- int aNt=a->getNumberOfTuples();
- int *valsToSet=getPointer();
- const int *valsSrc=a->getConstPointer();
- for(const int *tuple=tuplesSelec->begin();tuple!=tuplesSelec->end();tuple+=2)
- {
- if(tuple[1]>=0 && tuple[1]<aNt)
- {
- if(tuple[0]>=0 && tuple[0]<thisNt)
- std::copy(valsSrc+nbOfComp*tuple[1],valsSrc+nbOfComp*(tuple[1]+1),valsToSet+nbOfComp*tuple[0]);
- else
- {
- std::ostringstream oss; oss << "DataArrayInt::setPartOfValuesAdv : Tuple #" << std::distance(tuplesSelec->begin(),tuple)/2;
- oss << " of 'tuplesSelec' request of tuple id #" << tuple[0] << " in 'this' ! It should be in [0," << thisNt << ") !";
- throw INTERP_KERNEL::Exception(oss.str().c_str());
- }
+ if(getNumberOfComponents()!=1)
+ throw INTERP_KERNEL::Exception("DataArrayInt::buildPermArrPerLevel : number of components must == 1 !");
+ int nbOfTuples=getNumberOfTuples();
+ const int *pt=getConstPointer();
+ std::map<int,int> m;
+ MCAuto<DataArrayInt> ret=DataArrayInt::New();
+ ret->alloc(nbOfTuples,1);
+ int *opt=ret->getPointer();
+ for(int i=0;i<nbOfTuples;i++,pt++,opt++)
+ {
+ int val=*pt;
+ std::map<int,int>::iterator it=m.find(val);
+ if(it!=m.end())
+ {
+ *opt=(*it).second;
+ (*it).second++;
}
else
{
- std::ostringstream oss; oss << "DataArrayInt::setPartOfValuesAdv : Tuple #" << std::distance(tuplesSelec->begin(),tuple)/2;
- oss << " of 'tuplesSelec' request of tuple id #" << tuple[1] << " in 'a' ! It should be in [0," << aNt << ") !";
- throw INTERP_KERNEL::Exception(oss.str().c_str());
+ *opt=0;
+ m.insert(std::pair<int,int>(val,1));
}
}
+ int sum=0;
+ for(std::map<int,int>::iterator it=m.begin();it!=m.end();it++)
+ {
+ int vt=(*it).second;
+ (*it).second=sum;
+ sum+=vt;
+ }
+ pt=getConstPointer();
+ opt=ret->getPointer();
+ for(int i=0;i<nbOfTuples;i++,pt++,opt++)
+ *opt+=m[*pt];
+ //
+ return ret.retn();
}
/*!
- * Copy some tuples from another DataArrayInt (\a aBase) into contiguous tuples
- * of \a this array. Textual data is not copied. Both arrays must have equal number of
- * components.
- * The tuples to assign to are defined by index of the first tuple, and
- * their number is defined by \a tuplesSelec->getNumberOfTuples().
- * The tuples to copy are defined by values of a DataArrayInt.
- * All components of selected tuples are copied.
- * \param [in] tupleIdStart - index of the first tuple of \a this array to assign
- * values to.
- * \param [in] aBase - the array to copy values from.
- * \param [in] tuplesSelec - the array specifying tuples of \a aBase to copy.
+ * Checks if \a this array has the given size, and if its contents is equal to an array filled with
+ * iota(). This method is particularly useful for DataArrayInt instances that represent
+ * a renumbering array, to check if there is a real need in renumbering.
+ * This method checks than \a this can be considered as an identity mapping
+ * of a set having \a sizeExpected elements into itself.
+ *
+ * \param [in] sizeExpected - The number of elements expected.
+ * \return bool - \a true if \a this array contents == \a range( \a this->getNumberOfTuples())
* \throw If \a this is not allocated.
- * \throw If \a aBase is NULL.
- * \throw If \a aBase is not allocated.
- * \throw If \a tuplesSelec is NULL.
- * \throw If \a tuplesSelec is not allocated.
- * \throw If <em>this->getNumberOfComponents() != a->getNumberOfComponents()</em>.
- * \throw If \a tuplesSelec->getNumberOfComponents() != 1.
- * \throw If <em>tupleIdStart + tuplesSelec->getNumberOfTuples() > this->getNumberOfTuples().</em>
- * \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)
-{
- if(!aBase || !tuplesSelec)
- throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues : input DataArray is NULL !");
- const DataArrayInt *a=dynamic_cast<const DataArrayInt *>(aBase);
- if(!a)
- throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues : input DataArray aBase is not a DataArrayInt !");
+ * \throw If \a this->getNumberOfComponents() != 1.
+ */
+bool DataArrayInt::isIota(int sizeExpected) const
+{
checkAllocated();
- a->checkAllocated();
- tuplesSelec->checkAllocated();
- int nbOfComp=getNumberOfComponents();
- if(nbOfComp!=a->getNumberOfComponents())
- throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues : This and a do not have the same number of components !");
- if(tuplesSelec->getNumberOfComponents()!=1)
- throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues : Expecting to have a tuple selector DataArrayInt instance with exactly 1 component !");
- int thisNt=getNumberOfTuples();
- int aNt=a->getNumberOfTuples();
- int nbOfTupleToWrite=tuplesSelec->getNumberOfTuples();
- int *valsToSet=getPointer()+tupleIdStart*nbOfComp;
- if(tupleIdStart+nbOfTupleToWrite>thisNt)
- throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues : invalid number range of values to write !");
- const int *valsSrc=a->getConstPointer();
- for(const int *tuple=tuplesSelec->begin();tuple!=tuplesSelec->end();tuple++,valsToSet+=nbOfComp)
- {
- if(*tuple>=0 && *tuple<aNt)
- {
- std::copy(valsSrc+nbOfComp*(*tuple),valsSrc+nbOfComp*(*tuple+1),valsToSet);
- }
- else
- {
- std::ostringstream oss; oss << "DataArrayInt::setContigPartOfSelectedValues : Tuple #" << std::distance(tuplesSelec->begin(),tuple);
- oss << " of 'tuplesSelec' request of tuple id #" << *tuple << " in 'a' ! It should be in [0," << aNt << ") !";
- throw INTERP_KERNEL::Exception(oss.str().c_str());
- }
- }
+ if(getNumberOfComponents()!=1)
+ return false;
+ int nbOfTuples(getNumberOfTuples());
+ if(nbOfTuples!=sizeExpected)
+ return false;
+ const int *pt=getConstPointer();
+ for(int i=0;i<nbOfTuples;i++,pt++)
+ if(*pt!=i)
+ return false;
+ return true;
}
/*!
- * Copy some tuples from another DataArrayInt (\a aBase) into contiguous tuples
- * of \a this array. Textual data is not copied. Both arrays must have equal number of
- * components.
- * The tuples to copy are defined by three values similar to parameters of
- * the Python function \c range(\c start,\c stop,\c step).
- * The tuples to assign to are defined by index of the first tuple, and
- * their number is defined by number of tuples to copy.
- * All components of selected tuples are copied.
- * \param [in] tupleIdStart - index of the first tuple of \a this array to assign
- * values to.
- * \param [in] aBase - the array to copy values from.
- * \param [in] bg - index of the first tuple to copy of the array \a aBase.
- * \param [in] end2 - index of the tuple of \a aBase before which the tuples to copy
- * are located.
- * \param [in] step - index increment to get index of the next tuple to copy.
+ * Checks if all values in \a this array are equal to \a val.
+ * \param [in] val - value to check equality of array values to.
+ * \return bool - \a true if all values are \a val.
* \throw If \a this is not allocated.
- * \throw If \a aBase is NULL.
- * \throw If \a aBase is not allocated.
- * \throw If <em>this->getNumberOfComponents() != aBase->getNumberOfComponents()</em>.
- * \throw If <em>tupleIdStart + len(range(bg,end2,step)) > this->getNumberOfTuples().</em>
- * \throw If parameters specifying tuples to copy, do not give a
- * non-empty range of increasing indices or indices are out of a valid range
- * for the array \a aBase.
+ * \throw If \a this->getNumberOfComponents() != 1
*/
-void DataArrayInt::setContigPartOfSelectedValuesSlice(int tupleIdStart, const DataArray *aBase, int bg, int end2, int step)
+bool DataArrayInt::isUniform(int val) const
{
- if(!aBase)
- throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValuesSlice : input DataArray is NULL !");
- const DataArrayInt *a=dynamic_cast<const DataArrayInt *>(aBase);
- if(!a)
- throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValuesSlice : input DataArray aBase is not a DataArrayInt !");
checkAllocated();
- a->checkAllocated();
- int nbOfComp=getNumberOfComponents();
- const char msg[]="DataArrayInt::setContigPartOfSelectedValuesSlice";
- int nbOfTupleToWrite=DataArray::GetNumberOfItemGivenBES(bg,end2,step,msg);
- if(nbOfComp!=a->getNumberOfComponents())
- throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValuesSlice : This and a do not have the same number of components !");
- int thisNt=getNumberOfTuples();
- int aNt=a->getNumberOfTuples();
- int *valsToSet=getPointer()+tupleIdStart*nbOfComp;
- if(tupleIdStart+nbOfTupleToWrite>thisNt)
- throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValuesSlice : invalid number range of values to write !");
- if(end2>aNt)
- throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValuesSlice : invalid range of values to read !");
- const int *valsSrc=a->getConstPointer()+bg*nbOfComp;
- for(int i=0;i<nbOfTupleToWrite;i++,valsToSet+=nbOfComp,valsSrc+=step*nbOfComp)
- {
- std::copy(valsSrc,valsSrc+nbOfComp,valsToSet);
- }
-}
-
-/*!
- * Returns a value located at specified tuple and component.
- * This method is equivalent to DataArrayInt::getIJ() except that validity of
- * parameters is checked. So this method is safe but expensive if used to go through
- * all values of \a this.
- * \param [in] tupleId - index of tuple of interest.
- * \param [in] compoId - index of component of interest.
- * \return double - value located by \a tupleId and \a compoId.
+ if(getNumberOfComponents()!=1)
+ throw INTERP_KERNEL::Exception("DataArrayInt::isUniform : must be applied on DataArrayInt with only one component, you can call 'rearrange' method before !");
+ int nbOfTuples=getNumberOfTuples();
+ const int *w=getConstPointer();
+ const int *end2=w+nbOfTuples;
+ for(;w!=end2;w++)
+ if(*w!=val)
+ return false;
+ return true;
+}
+
+/*!
+ * Checks if all values in \a this array are unique.
+ * \return bool - \a true if condition above is true
* \throw If \a this is not allocated.
- * \throw If condition <em>( 0 <= tupleId < this->getNumberOfTuples() )</em> is violated.
- * \throw If condition <em>( 0 <= compoId < this->getNumberOfComponents() )</em> is violated.
+ * \throw If \a this->getNumberOfComponents() != 1
*/
-int DataArrayInt::getIJSafe(int tupleId, int compoId) const
+bool DataArrayInt::hasUniqueValues() const
{
checkAllocated();
- if(tupleId<0 || tupleId>=getNumberOfTuples())
- {
- std::ostringstream oss; oss << "DataArrayInt::getIJSafe : request for tupleId " << tupleId << " should be in [0," << getNumberOfTuples() << ") !";
- throw INTERP_KERNEL::Exception(oss.str().c_str());
- }
- if(compoId<0 || compoId>=getNumberOfComponents())
- {
- std::ostringstream oss; oss << "DataArrayInt::getIJSafe : request for compoId " << compoId << " should be in [0," << getNumberOfComponents() << ") !";
- throw INTERP_KERNEL::Exception(oss.str().c_str());
- }
- return _mem[tupleId*_info_on_compo.size()+compoId];
+ if(getNumberOfComponents()!=1)
+ throw INTERP_KERNEL::Exception("DataArrayInt::hasOnlyUniqueValues: must be applied on DataArrayInt with only one component, you can call 'rearrange' method before !");
+ int nbOfTuples(getNumberOfTuples());
+ std::set<int> s(begin(),end()); // in C++11, should use unordered_set (O(1) complexity)
+ if (s.size() != nbOfTuples)
+ return false;
+ return true;
}
/*!
- * Returns the first value of \a this.
- * \return int - the last value of \a this array.
- * \throw If \a this is not allocated.
- * \throw If \a this->getNumberOfComponents() != 1.
- * \throw If \a this->getNumberOfTuples() < 1.
+ * Creates a new DataArrayDouble and assigns all (textual and numerical) data of \a this
+ * array to the new one.
+ * \return DataArrayDouble * - the new instance of DataArrayInt.
*/
-int DataArrayInt::front() const
+DataArrayDouble *DataArrayInt::convertToDblArr() const
{
checkAllocated();
- if(getNumberOfComponents()!=1)
- throw INTERP_KERNEL::Exception("DataArrayInt::front : number of components not equal to one !");
- int nbOfTuples=getNumberOfTuples();
- if(nbOfTuples<1)
- throw INTERP_KERNEL::Exception("DataArrayInt::front : number of tuples must be >= 1 !");
- return *(getConstPointer());
+ DataArrayDouble *ret=DataArrayDouble::New();
+ ret->alloc(getNumberOfTuples(),getNumberOfComponents());
+ std::size_t nbOfVals=getNbOfElems();
+ const int *src=getConstPointer();
+ double *dest=ret->getPointer();
+ std::copy(src,src+nbOfVals,dest);
+ ret->copyStringInfoFrom(*this);
+ return ret;
}
/*!
- * Returns the last value of \a this.
- * \return int - the last value of \a this array.
+ * Appends components of another array to components of \a this one, tuple by tuple.
+ * So that the number of tuples of \a this array remains the same and the number of
+ * components increases.
+ * \param [in] other - the DataArrayInt to append to \a this one.
* \throw If \a this is not allocated.
- * \throw If \a this->getNumberOfComponents() != 1.
- * \throw If \a this->getNumberOfTuples() < 1.
+ * \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
*/
-int DataArrayInt::back() const
+void DataArrayInt::meldWith(const DataArrayInt *other)
{
+ if(!other)
+ throw INTERP_KERNEL::Exception("DataArrayInt::meldWith : DataArrayInt pointer in input is NULL !");
checkAllocated();
- if(getNumberOfComponents()!=1)
- throw INTERP_KERNEL::Exception("DataArrayInt::back : number of components not equal to one !");
+ other->checkAllocated();
int nbOfTuples=getNumberOfTuples();
- if(nbOfTuples<1)
- throw INTERP_KERNEL::Exception("DataArrayInt::back : number of tuples must be >= 1 !");
- return *(getConstPointer()+nbOfTuples-1);
+ if(nbOfTuples!=other->getNumberOfTuples())
+ throw INTERP_KERNEL::Exception("DataArrayInt::meldWith : mismatch of number of tuples !");
+ int nbOfComp1=getNumberOfComponents();
+ int nbOfComp2=other->getNumberOfComponents();
+ int *newArr=(int *)malloc(nbOfTuples*(nbOfComp1+nbOfComp2)*sizeof(int));
+ int *w=newArr;
+ const int *inp1=getConstPointer();
+ const int *inp2=other->getConstPointer();
+ for(int i=0;i<nbOfTuples;i++,inp1+=nbOfComp1,inp2+=nbOfComp2)
+ {
+ w=std::copy(inp1,inp1+nbOfComp1,w);
+ w=std::copy(inp2,inp2+nbOfComp2,w);
+ }
+ useArray(newArr,true,C_DEALLOC,nbOfTuples,nbOfComp1+nbOfComp2);
+ std::vector<int> compIds(nbOfComp2);
+ for(int i=0;i<nbOfComp2;i++)
+ compIds[i]=nbOfComp1+i;
+ copyPartOfStringInfoFrom2(compIds,*other);
+}
+
+/*!
+ * Copy all components in a specified order from another DataArrayInt.
+ * The specified components become the first ones in \a this array.
+ * Both numerical and textual data is copied. The number of tuples in \a this and
+ * the other array can be different.
+ * \param [in] a - the array to copy data from.
+ * \param [in] compoIds - sequence of zero based indices of components, data of which is
+ * to be copied.
+ * \throw If \a a 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)
+{
+ if(!a)
+ throw INTERP_KERNEL::Exception("DataArrayInt::setSelectedComponents : input DataArrayInt is NULL !");
+ checkAllocated();
+ a->checkAllocated();
+ copyPartOfStringInfoFrom2(compoIds,*a);
+ std::size_t partOfCompoSz=compoIds.size();
+ int nbOfCompo=getNumberOfComponents();
+ int nbOfTuples=std::min(getNumberOfTuples(),a->getNumberOfTuples());
+ const int *ac=a->getConstPointer();
+ int *nc=getPointer();
+ for(int i=0;i<nbOfTuples;i++)
+ for(std::size_t j=0;j<partOfCompoSz;j++,ac++)
+ nc[nbOfCompo*i+compoIds[j]]=*ac;
}
/*!
* the input vector. An INTERP_KERNEL::Exception is thrown too if \b this is not allocated.
*
* \return tuple id where \b tupl is. -1 if no such tuple exists in \b this.
- * \sa DataArrayInt::search, DataArrayInt::presenceOfTuple.
+ * \sa DataArrayInt::findIdSequence, DataArrayInt::presenceOfTuple.
*/
int DataArrayInt::findIdFirstEqualTuple(const std::vector<int>& tupl) const
{
* This method differs from DataArrayInt::findIdFirstEqualTuple in that the position is internal raw data is not considered here contrary to DataArrayInt::findIdFirstEqualTuple.
* \sa DataArrayInt::findIdFirstEqualTuple
*/
-int DataArrayInt::search(const std::vector<int>& vals) const
+int DataArrayInt::findIdSequence(const std::vector<int>& vals) const
{
checkAllocated();
int nbOfCompo=getNumberOfComponents();
if(nbOfCompo!=1)
- throw INTERP_KERNEL::Exception("DataArrayInt::search : works only for DataArrayInt instance with one component !");
+ throw INTERP_KERNEL::Exception("DataArrayInt::findIdSequence : works only for DataArrayInt instance with one component !");
const int *cptr=getConstPointer();
std::size_t nbOfVals=getNbOfElems();
const int *loc=std::search(cptr,cptr+nbOfVals,vals.begin(),vals.end());
return ret.retn();
}
-/*!
- * Returns the maximal value and its location within \a this one-dimensional array.
- * \param [out] tupleId - index of the tuple holding the maximal value.
- * \return int - the maximal value among all values of \a this array.
- * \throw If \a this->getNumberOfComponents() != 1
- * \throw If \a this->getNumberOfTuples() < 1
- */
-int DataArrayInt::getMaxValue(int& tupleId) const
-{
- checkAllocated();
- if(getNumberOfComponents()!=1)
- throw INTERP_KERNEL::Exception("DataArrayInt::getMaxValue : must be applied on DataArrayInt with only one component !");
- int nbOfTuples=getNumberOfTuples();
- if(nbOfTuples<=0)
- throw INTERP_KERNEL::Exception("DataArrayInt::getMaxValue : array exists but number of tuples must be > 0 !");
- const int *vals=getConstPointer();
- const int *loc=std::max_element(vals,vals+nbOfTuples);
- tupleId=(int)std::distance(vals,loc);
- return *loc;
-}
-
-/*!
- * Returns the maximal value within \a this array that is allowed to have more than
- * one component.
- * \return int - the maximal value among all values of \a this array.
- * \throw If \a this is not allocated.
- */
-int DataArrayInt::getMaxValueInArray() const
-{
- checkAllocated();
- const int *loc=std::max_element(begin(),end());
- return *loc;
-}
-
-/*!
- * Returns the minimal value and its location within \a this one-dimensional array.
- * \param [out] tupleId - index of the tuple holding the minimal value.
- * \return int - the minimal value among all values of \a this array.
- * \throw If \a this->getNumberOfComponents() != 1
- * \throw If \a this->getNumberOfTuples() < 1
- */
-int DataArrayInt::getMinValue(int& tupleId) const
-{
- checkAllocated();
- if(getNumberOfComponents()!=1)
- throw INTERP_KERNEL::Exception("DataArrayInt::getMaxValue : must be applied on DataArrayInt with only one component !");
- int nbOfTuples=getNumberOfTuples();
- if(nbOfTuples<=0)
- throw INTERP_KERNEL::Exception("DataArrayInt::getMaxValue : array exists but number of tuples must be > 0 !");
- const int *vals=getConstPointer();
- const int *loc=std::min_element(vals,vals+nbOfTuples);
- tupleId=(int)std::distance(vals,loc);
- return *loc;
-}
-
-/*!
- * Returns the minimal value within \a this array that is allowed to have more than
- * one component.
- * \return int - the minimal value among all values of \a this array.
- * \throw If \a this is not allocated.
- */
-int DataArrayInt::getMinValueInArray() const
-{
- checkAllocated();
- const int *loc=std::min_element(begin(),end());
- return *loc;
-}
-
/*!
* Returns in a single walk in \a this the min value and the max value in \a this.
* \a this is expected to be single component array.
{ tmp[3]=conn[2];}
std::copy(tmp,tmp+4,conn);
}
+ else
+ {//here we are sure to have (std::count(conn,conn+4,conn[1])==2)
+ if(conn[1]==conn[3])
+ std::swap(conn[2],conn[3]);
+ }
}
}
}