#include "MEDCouplingMemArray.txx"
#include "MEDCouplingAutoRefCountObjectPtr.hxx"
+#include "BBTree.txx"
#include "GenMathFormulae.hxx"
+#include "InterpKernelAutoPtr.hxx"
#include "InterpKernelExprParser.hxx"
#include <set>
}
}
-std::size_t DataArray::getHeapMemorySize() const
+std::size_t DataArray::getHeapMemorySizeWithoutChildren() const
{
std::size_t sz1=_name.capacity();
std::size_t sz2=_info_on_compo.capacity();
return sz1+sz2+sz3;
}
+std::vector<RefCountObject *> DataArray::getDirectChildren() const
+{
+ return std::vector<RefCountObject *>();
+}
+
/*!
* Sets the attribute \a _name of \a this array.
* See \ref MEDCouplingArrayBasicsName "DataArrays infos" for more information.
_info_on_compo=info;
}
+/*!
+ * This method is only a dispatcher towards DataArrayDouble::setPartOfValues3, DataArrayInt::setPartOfValues3, DataArrayChar::setPartOfValues3 depending on the true
+ * type of \a this and \a aBase.
+ *
+ * \throw If \a aBase and \a this do not have the same type.
+ *
+ * \sa DataArrayDouble::setPartOfValues3, DataArrayInt::setPartOfValues3, DataArrayChar::setPartOfValues3.
+ */
+void DataArray::setPartOfValuesBase3(const DataArray *aBase, const int *bgTuples, const int *endTuples, int bgComp, int endComp, int stepComp, bool strictCompoCompare) throw(INTERP_KERNEL::Exception)
+{
+ if(!aBase)
+ throw INTERP_KERNEL::Exception("DataArray::setPartOfValuesBase3 : input aBase object is NULL !");
+ DataArrayDouble *this1(dynamic_cast<DataArrayDouble *>(this));
+ DataArrayInt *this2(dynamic_cast<DataArrayInt *>(this));
+ DataArrayChar *this3(dynamic_cast<DataArrayChar *>(this));
+ const DataArrayDouble *a1(dynamic_cast<const DataArrayDouble *>(aBase));
+ const DataArrayInt *a2(dynamic_cast<const DataArrayInt *>(aBase));
+ const DataArrayChar *a3(dynamic_cast<const DataArrayChar *>(aBase));
+ if(this1 && a1)
+ {
+ this1->setPartOfValues3(a1,bgTuples,endTuples,bgComp,endComp,stepComp,strictCompoCompare);
+ return ;
+ }
+ if(this2 && a2)
+ {
+ this2->setPartOfValues3(a2,bgTuples,endTuples,bgComp,endComp,stepComp,strictCompoCompare);
+ return ;
+ }
+ if(this3 && a3)
+ {
+ this3->setPartOfValues3(a3,bgTuples,endTuples,bgComp,endComp,stepComp,strictCompoCompare);
+ return ;
+ }
+ throw INTERP_KERNEL::Exception("DataArray::setPartOfValuesBase3 : input aBase object and this do not have the same type !");
+}
+
std::vector<std::string> DataArray::getVarsOnComponent() const throw(INTERP_KERNEL::Exception)
{
int nbOfCompo=(int)_info_on_compo.size();
return info.substr(p1+1,p2-p1-1);
}
+/*!
+ * Returns a new DataArray by concatenating all given arrays, so that (1) the number
+ * of tuples in the result array is a sum of the number of tuples of given arrays and (2)
+ * 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] arrs - a sequence of arrays to include in the result array. All arrays must have the same type.
+ * \return DataArray * - the new instance of DataArray (that can be either DataArrayInt, DataArrayDouble, DataArrayChar).
+ * The caller is to delete this result array using decrRef() as it is no more
+ * needed.
+ * \throw If all arrays within \a arrs are NULL.
+ * \throw If all not null arrays in \a arrs have not the same type.
+ * \throw If getNumberOfComponents() of arrays within \a arrs.
+ */
+DataArray *DataArray::Aggregate(const std::vector<const DataArray *>& arrs) throw(INTERP_KERNEL::Exception)
+{
+ std::vector<const DataArray *> arr2;
+ for(std::vector<const DataArray *>::const_iterator it=arrs.begin();it!=arrs.end();it++)
+ if(*it)
+ arr2.push_back(*it);
+ if(arr2.empty())
+ throw INTERP_KERNEL::Exception("DataArray::Aggregate : only null instance in input vector !");
+ std::vector<const DataArrayDouble *> arrd;
+ std::vector<const DataArrayInt *> arri;
+ std::vector<const DataArrayChar *> arrc;
+ for(std::vector<const DataArray *>::const_iterator it=arr2.begin();it!=arr2.end();it++)
+ {
+ const DataArrayDouble *a=dynamic_cast<const DataArrayDouble *>(*it);
+ if(a)
+ { arrd.push_back(a); continue; }
+ const DataArrayInt *b=dynamic_cast<const DataArrayInt *>(*it);
+ if(b)
+ { arri.push_back(b); continue; }
+ const DataArrayChar *c=dynamic_cast<const DataArrayChar *>(*it);
+ if(c)
+ { arrc.push_back(c); continue; }
+ throw INTERP_KERNEL::Exception("DataArray::Aggregate : presence of not null instance in inuput that is not in [DataArrayDouble, DataArrayInt, DataArrayChar] !");
+ }
+ if(arr2.size()==arrd.size())
+ return DataArrayDouble::Aggregate(arrd);
+ if(arr2.size()==arri.size())
+ return DataArrayInt::Aggregate(arri);
+ if(arr2.size()==arrc.size())
+ return DataArrayChar::Aggregate(arrc);
+ throw INTERP_KERNEL::Exception("DataArray::Aggregate : all input arrays must have the same type !");
+}
+
/*!
* Sets information on a component specified by an index.
* To know more on format of this information
_mem.destroy();
}
-std::size_t DataArrayDouble::getHeapMemorySize() const
+std::size_t DataArrayDouble::getHeapMemorySizeWithoutChildren() const
{
- std::size_t sz=_mem.getNbOfElemAllocated();
+ std::size_t sz(_mem.getNbOfElemAllocated());
sz*=sizeof(double);
- return DataArray::getHeapMemorySize()+sz;
+ return DataArray::getHeapMemorySizeWithoutChildren()+sz;
}
/*!
/*!
* This method \b do \b not modify content of \a this. It only modify its memory footprint if the allocated memory is to high regarding real data to store.
*
- * \sa DataArrayDouble::getHeapMemorySize, DataArrayDouble::reserve
+ * \sa DataArrayDouble::getHeapMemorySizeWithoutChildren, DataArrayDouble::reserve
*/
void DataArrayDouble::pack() const throw(INTERP_KERNEL::Exception)
{
return ret.str();
}
-void DataArrayDouble::writeVTK(std::ostream& ofs, int indent, const char *nameInFile) const throw(INTERP_KERNEL::Exception)
+void DataArrayDouble::writeVTK(std::ostream& ofs, int indent, const char *nameInFile, DataArrayByte *byteArr) const throw(INTERP_KERNEL::Exception)
{
+ static const char SPACE[4]={' ',' ',' ',' '};
+ checkAllocated();
std::string idt(indent,' ');
ofs.precision(17);
ofs << idt << "<DataArray type=\"Float32\" Name=\"" << nameInFile << "\" NumberOfComponents=\"" << getNumberOfComponents() << "\"";
- ofs << " format=\"ascii\" RangeMin=\"" << getMinValueInArray() << "\" RangeMax=\"" << getMaxValueInArray() << "\">\n" << idt;
- std::copy(begin(),end(),std::ostream_iterator<double>(ofs," "));
+ if(byteArr)
+ {
+ ofs << " format=\"appended\" offset=\"" << byteArr->getNumberOfTuples() << "\">";
+ INTERP_KERNEL::AutoPtr<float> tmp(new float[getNbOfElems()]);
+ std::copy(begin(),end(),(float *)tmp);
+ const char *data(reinterpret_cast<const char *>((float *)tmp));
+ std::size_t sz(getNbOfElems()*sizeof(float));
+ byteArr->insertAtTheEnd(data,data+sz);
+ byteArr->insertAtTheEnd(SPACE,SPACE+4);
+ }
+ else
+ {
+ ofs << " RangeMin=\"" << getMinValueInArray() << "\" RangeMax=\"" << getMaxValueInArray() << "\" format=\"ascii\">\n" << idt;
+ std::copy(begin(),end(),std::ostream_iterator<double>(ofs," "));
+ }
ofs << std::endl << idt << "</DataArray>\n";
}
return ret.retn();
}
+/*!
+ * This method expects that \a this and \a otherBBoxFrmt arrays are bounding box arrays ( as the output of MEDCouplingPointSet::getBoundingBoxForBBTree method ).
+ * This method will return a DataArrayInt array having the same number of tuples than \a this. This returned array tells for each cell in \a this
+ * how many bounding boxes in \a otherBBoxFrmt.
+ * So, this method expects that \a this and \a otherBBoxFrmt have the same number of components.
+ *
+ * \param [in] otherBBoxFrmt - It is an array .
+ * \param [in] eps - the absolute precision of the detection. when eps < 0 the bboxes are enlarged so more interactions are detected. Inversely when > 0 the bboxes are stretched.
+ * \sa MEDCouplingPointSet::getBoundingBoxForBBTree
+ * \throw If \a this and \a otherBBoxFrmt have not the same number of components.
+ * \throw If \a this and \a otherBBoxFrmt number of components is not even (BBox format).
+ */
+DataArrayInt *DataArrayDouble::computeNbOfInteractionsWith(const DataArrayDouble *otherBBoxFrmt, double eps) const throw(INTERP_KERNEL::Exception)
+{
+ if(!otherBBoxFrmt)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::computeNbOfInteractionsWith : input array is NULL !");
+ if(!isAllocated() || !otherBBoxFrmt->isAllocated())
+ throw INTERP_KERNEL::Exception("DataArrayDouble::computeNbOfInteractionsWith : this and input array must be allocated !");
+ int nbOfComp(getNumberOfComponents()),nbOfTuples(getNumberOfTuples());
+ if(nbOfComp!=otherBBoxFrmt->getNumberOfComponents())
+ {
+ std::ostringstream oss; oss << "DataArrayDouble::computeNbOfInteractionsWith : this number of components (" << nbOfComp << ") must be equal to the number of components of input array (" << otherBBoxFrmt->getNumberOfComponents() << ") !";
+ throw INTERP_KERNEL::Exception(oss.str().c_str());
+ }
+ if(nbOfComp%2!=0)
+ {
+ std::ostringstream oss; oss << "DataArrayDouble::computeNbOfInteractionsWith : Number of components (" << nbOfComp << ") is not even ! It should be to be compatible with bbox format !";
+ throw INTERP_KERNEL::Exception(oss.str().c_str());
+ }
+ MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(nbOfTuples,1);
+ const double *thisBBPtr(begin());
+ int *retPtr(ret->getPointer());
+ switch(nbOfComp/2)
+ {
+ case 3:
+ {
+ BBTree<3,int> bbt(otherBBoxFrmt->begin(),0,0,otherBBoxFrmt->getNumberOfTuples(),eps);
+ for(int i=0;i<nbOfTuples;i++,retPtr++,thisBBPtr+=nbOfComp)
+ *retPtr=bbt.getNbOfIntersectingElems(thisBBPtr);
+ break;
+ }
+ case 2:
+ {
+ BBTree<2,int> bbt(otherBBoxFrmt->begin(),0,0,otherBBoxFrmt->getNumberOfTuples(),eps);
+ for(int i=0;i<nbOfTuples;i++,retPtr++,thisBBPtr+=nbOfComp)
+ *retPtr=bbt.getNbOfIntersectingElems(thisBBPtr);
+ break;
+ }
+ case 1:
+ {
+ BBTree<1,int> bbt(otherBBoxFrmt->begin(),0,0,otherBBoxFrmt->getNumberOfTuples(),eps);
+ for(int i=0;i<nbOfTuples;i++,retPtr++,thisBBPtr+=nbOfComp)
+ *retPtr=bbt.getNbOfIntersectingElems(thisBBPtr);
+ break;
+ }
+ defaut:
+ 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
}
/*!
- * Copy some tuples from another DataArrayDouble (\a a) into contiguous tuples
+ * 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
* 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] a - the array to copy values from.
+ * \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 a is NULL.
- * \throw If \a a 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 <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 a array.
+ * \a aBase array.
*/
void DataArrayDouble::setContigPartOfSelectedValues(int tupleIdStart, const DataArray *aBase, const DataArrayInt *tuplesSelec) throw(INTERP_KERNEL::Exception)
{
}
/*!
- * Copy some tuples from another DataArrayDouble (\a a) into contiguous tuples
+ * 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
* 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] a - the array to copy values from.
- * \param [in] bg - index of the first tuple to copy of the array \a a.
- * \param [in] end2 - index of the tuple of \a a before which the tuples to copy
+ * \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 a is NULL.
- * \throw If \a a is not allocated.
- * \throw If <em>this->getNumberOfComponents() != a->getNumberOfComponents()</em>.
+ * \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 a.
+ * for the array \a aBase.
*/
void DataArrayDouble::setContigPartOfSelectedValues2(int tupleIdStart, const DataArray *aBase, int bg, int end2, int step) throw(INTERP_KERNEL::Exception)
{
_mem.destroy();
}
-std::size_t DataArrayInt::getHeapMemorySize() const
+std::size_t DataArrayInt::getHeapMemorySizeWithoutChildren() const
{
- std::size_t sz=_mem.getNbOfElemAllocated();
+ std::size_t sz(_mem.getNbOfElemAllocated());
sz*=sizeof(int);
- return DataArray::getHeapMemorySize()+sz;
+ return DataArray::getHeapMemorySizeWithoutChildren()+sz;
}
/*!
/*!
* This method \b do \b not modify content of \a this. It only modify its memory footprint if the allocated memory is to high regarding real data to store.
*
- * \sa DataArrayInt::getHeapMemorySize, DataArrayInt::reserve
+ * \sa DataArrayInt::getHeapMemorySizeWithoutChildren, DataArrayInt::reserve
*/
void DataArrayInt::pack() const throw(INTERP_KERNEL::Exception)
{
return ret.str();
}
-void DataArrayInt::writeVTK(std::ostream& ofs, int indent, const char *type, const char *nameInFile) const throw(INTERP_KERNEL::Exception)
+void DataArrayInt::writeVTK(std::ostream& ofs, int indent, const char *type, const char *nameInFile, DataArrayByte *byteArr) const throw(INTERP_KERNEL::Exception)
{
+ static const char SPACE[4]={' ',' ',' ',' '};
checkAllocated();
std::string idt(indent,' ');
ofs << idt << "<DataArray type=\"" << type << "\" Name=\"" << nameInFile << "\" NumberOfComponents=\"" << getNumberOfComponents() << "\"";
- ofs << " format=\"ascii\" RangeMin=\"" << getMinValueInArray() << "\" RangeMax=\"" << getMaxValueInArray() << "\">\n" << idt;
- std::copy(begin(),end(),std::ostream_iterator<int>(ofs," "));
+ if(byteArr)
+ {
+ ofs << " format=\"appended\" offset=\"" << byteArr->getNumberOfTuples() << "\">";
+ if(std::string(type)=="Int32")
+ {
+ const char *data(reinterpret_cast<const char *>(begin()));
+ std::size_t sz(getNbOfElems()*sizeof(int));
+ byteArr->insertAtTheEnd(data,data+sz);
+ byteArr->insertAtTheEnd(SPACE,SPACE+4);
+ }
+ else if(std::string(type)=="Int8")
+ {
+ INTERP_KERNEL::AutoPtr<char> tmp(new char[getNbOfElems()]);
+ std::copy(begin(),end(),(char *)tmp);
+ byteArr->insertAtTheEnd((char *)tmp,(char *)tmp+getNbOfElems());
+ byteArr->insertAtTheEnd(SPACE,SPACE+4);
+ }
+ else if(std::string(type)=="UInt8")
+ {
+ INTERP_KERNEL::AutoPtr<unsigned char> tmp(new unsigned char[getNbOfElems()]);
+ std::copy(begin(),end(),(unsigned char *)tmp);
+ byteArr->insertAtTheEnd((unsigned char *)tmp,(unsigned char *)tmp+getNbOfElems());
+ byteArr->insertAtTheEnd(SPACE,SPACE+4);
+ }
+ else
+ throw INTERP_KERNEL::Exception("DataArrayInt::writeVTK : Only Int32, Int8 and UInt8 supported !");
+ }
+ else
+ {
+ ofs << " RangeMin=\"" << getMinValueInArray() << "\" RangeMax=\"" << getMaxValueInArray() << "\" format=\"ascii\">\n" << idt;
+ std::copy(begin(),end(),std::ostream_iterator<int>(ofs," "));
+ }
ofs << std::endl << idt << "</DataArray>\n";
}
const int *old2New=getConstPointer();
int *pt=ret->getPointer();
for(int i=0;i!=nbOfOldNodes;i++)
- if(old2New[i]!=-1)
- pt[old2New[i]]=i;
+ {
+ int newp(old2New[i]);
+ if(newp!=-1)
+ {
+ if(newp>=0 && newp<newNbOfElem)
+ pt[newp]=i;
+ else
+ {
+ std::ostringstream oss; oss << "DataArrayInt::invertArrayO2N2N2O : At place #" << i << " the newplace is " << newp << " must be in [0," << newNbOfElem << ") !";
+ throw INTERP_KERNEL::Exception(oss.str().c_str());
+ }
+ }
+ }
return ret.retn();
}
const int *old2New=getConstPointer();
int *pt=ret->getPointer();
for(int i=nbOfOldNodes-1;i>=0;i--)
- if(old2New[i]!=-1)
- pt[old2New[i]]=i;
+ {
+ int newp(old2New[i]);
+ if(newp!=-1)
+ {
+ if(newp>=0 && newp<newNbOfElem)
+ pt[newp]=i;
+ else
+ {
+ std::ostringstream oss; oss << "DataArrayInt::invertArrayO2N2N2OBis : At place #" << i << " the newplace is " << newp << " must be in [0," << newNbOfElem << ") !";
+ throw INTERP_KERNEL::Exception(oss.str().c_str());
+ }
+ }
+ }
return ret.retn();
}
std::fill(pt,pt+oldNbOfElem,-1);
int nbOfNewElems=getNumberOfTuples();
for(int i=0;i<nbOfNewElems;i++)
- pt[new2Old[i]]=i;
+ {
+ 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());
+ }
+ }
return ret.retn();
}
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
}
- return false;
+ else
+ return false;
}
else
return false;
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.
+ *
+ */
+DataArrayInt *DataArrayInt::FindPermutationFromFirstToSecond(const DataArrayInt *ids1, const DataArrayInt *ids2) throw(INTERP_KERNEL::Exception)
+{
+ 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());
+ }
+ MEDCouplingAutoRefCountObjectPtr<DataArrayInt> p1(ids1->deepCpy());
+ MEDCouplingAutoRefCountObjectPtr<DataArrayInt> p2(ids2->deepCpy());
+ 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
}
/*!
- * Copy some tuples from another DataArrayInt (\a a) into contiguous tuples
+ * 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
* 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] a - the array to copy values from.
- * \param [in] tuplesSelec - the array specifying tuples of \a a to copy.
+ * \param [in] aBase - the array to copy values from.
+ * \param [in] tuplesSelec - the array specifying tuples of \a aBase to copy.
* \throw If \a this is not allocated.
- * \throw If \a a is NULL.
- * \throw If \a a 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 a array.
+ * \a aBase array.
*/
void DataArrayInt::setContigPartOfSelectedValues(int tupleIdStart, const DataArray *aBase, const DataArrayInt *tuplesSelec) throw(INTERP_KERNEL::Exception)
{
}
/*!
- * Copy some tuples from another DataArrayInt (\a a) into contiguous tuples
+ * 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
* 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] a - the array to copy values from.
- * \param [in] bg - index of the first tuple to copy of the array \a a.
- * \param [in] end2 - index of the tuple of \a a before which the tuples to copy
+ * \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 a is NULL.
- * \throw If \a a is not allocated.
- * \throw If <em>this->getNumberOfComponents() != a->getNumberOfComponents()</em>.
+ * \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 a.
+ * for the array \a aBase.
*/
void DataArrayInt::setContigPartOfSelectedValues2(int tupleIdStart, const DataArray *aBase, int bg, int end2, int step) throw(INTERP_KERNEL::Exception)
{
return ret.retn();
}
+/*!
+ * Returns a new DataArrayInt whose contents is computed using \a this that must be a
+ * scaled array (monotonically increasing).
+from that of \a this and \a
+ * offsets arrays as follows. \a offsets is a one-dimensional array considered as an
+ * "index" array of a "iota" array, thus, whose each element gives an index of a group
+ * beginning within the "iota" array. And \a this is a one-dimensional array
+ * considered as a selector of groups described by \a offsets to include into the result array.
+ * \throw If \a is NULL.
+ * \throw If \a this is not allocated.
+ * \throw If \a this->getNumberOfComponents() != 1.
+ * \throw If \a this->getNumberOfTuples() == 0.
+ * \throw If \a this is not monotonically increasing.
+ * \throw If any element of ids in ( \a gb \a end \a step ) points outside the scale in \a this.
+ *
+ * \b Example: <br>
+ * - \a bg , \a end and \a step : (0,5,2)
+ * - \a this: [0,3,6,10,14,20]
+ * - result array: [0,0,0, 2,2,2,2, 4,4,4,4,4,4] == <br>
+ */
+DataArrayInt *DataArrayInt::buildExplicitArrOfSliceOnScaledArr(int bg, int end, int step) const throw(INTERP_KERNEL::Exception)
+{
+ if(!isAllocated())
+ throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrOfSliceOnScaledArr : not allocated array !");
+ if(getNumberOfComponents()!=1)
+ throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrOfSliceOnScaledArr : number of components is expected to be equal to one !");
+ int nbOfTuples(getNumberOfTuples());
+ if(nbOfTuples==0)
+ throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrOfSliceOnScaledArr : number of tuples must be != 0 !");
+ const int *ids(begin());
+ int nbOfEltsInSlc(GetNumberOfItemGivenBESRelative(bg,end,step,"DataArrayInt::buildExplicitArrOfSliceOnScaledArr")),sz(0),pos(bg);
+ for(int i=0;i<nbOfEltsInSlc;i++,pos+=step)
+ {
+ if(pos>=0 && pos<nbOfTuples-1)
+ {
+ int delta(ids[pos+1]-ids[pos]);
+ sz+=delta;
+ if(delta<0)
+ {
+ std::ostringstream oss; oss << "DataArrayInt::buildExplicitArrOfSliceOnScaledArr : At pos #" << i << " of input slice, value is " << pos << " and at this pos this is not monotonically increasing !";
+ throw INTERP_KERNEL::Exception(oss.str().c_str());
+ }
+ }
+ else
+ {
+ std::ostringstream oss; oss << "DataArrayInt::buildExplicitArrOfSliceOnScaledArr : At pos #" << i << " of input slice, value is " << pos << " should be in [0," << nbOfTuples-1 << ") !";
+ throw INTERP_KERNEL::Exception(oss.str().c_str());
+ }
+ }
+ MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(sz,1);
+ int *retPtr(ret->getPointer());
+ pos=bg;
+ for(int i=0;i<nbOfEltsInSlc;i++,pos+=step)
+ {
+ int delta(ids[pos+1]-ids[pos]);
+ for(int j=0;j<delta;j++,retPtr++)
+ *retPtr=pos;
+ }
+ return ret.retn();
+}
+
/*!
* Given in input ranges \a ranges, it returns a newly allocated DataArrayInt instance having one component and the same number of tuples than \a this.
* For each tuple at place **i** in \a this it tells which is the first range in \a ranges that contains value \c this->getIJ(i,0) and put the result
return ret;
}
+/*!
+ * This method split ids in [0, \c this->getNumberOfTuples() ) using \a this array as a field of weight (>=0 each).
+ * The aim of this method is to return a set of \a nbOfSlices chunk of contiguous ids as balanced as possible.
+ *
+ * \param [in] nbOfSlices - number of slices expected.
+ * \return - a vector having a size equal to \a nbOfSlices giving the start (included) and the stop (excluded) of each chunks.
+ *
+ * \sa DataArray::GetSlice
+ * \throw If \a this is not allocated or not with exactly one component.
+ * \throw If an element in \a this if < 0.
+ */
+std::vector< std::pair<int,int> > DataArrayInt::splitInBalancedSlices(int nbOfSlices) const throw(INTERP_KERNEL::Exception)
+{
+ if(!isAllocated() || getNumberOfComponents()!=1)
+ throw INTERP_KERNEL::Exception("DataArrayInt::splitInBalancedSlices : this array should have number of components equal to one and must be allocated !");
+ if(nbOfSlices<=0)
+ throw INTERP_KERNEL::Exception("DataArrayInt::splitInBalancedSlices : number of slices must be >= 1 !");
+ int sum(accumulate(0)),nbOfTuples(getNumberOfTuples());
+ int sumPerSlc(sum/nbOfSlices),pos(0);
+ const int *w(begin());
+ std::vector< std::pair<int,int> > ret(nbOfSlices);
+ for(int i=0;i<nbOfSlices;i++)
+ {
+ std::pair<int,int> p(pos,-1);
+ int locSum(0);
+ while(locSum<sumPerSlc && pos<nbOfTuples) { pos++; locSum+=*w++; }
+ if(i!=nbOfSlices-1)
+ p.second=pos;
+ else
+ p.second=nbOfTuples;
+ ret[i]=p;
+ }
+ return ret;
+}
+
/*!
* Returns a new DataArrayInt that is a sum of two given arrays. There are 3
* valid cases.
setName(tinyInfoS[0].c_str());
if(isAllocated())
{
- int nbOfCompo=getNumberOfComponents();
+ int nbOfCompo=tinyInfoI[1];
for(int i=0;i<nbOfCompo;i++)
setInfoOnComponent(i,tinyInfoS[i+1].c_str());
}
