1 // Copyright (C) 2007-2013 CEA/DEN, EDF R&D
3 // This library is free software; you can redistribute it and/or
4 // modify it under the terms of the GNU Lesser General Public
5 // License as published by the Free Software Foundation; either
6 // version 2.1 of the License.
8 // This library is distributed in the hope that it will be useful,
9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 // Lesser General Public License for more details.
13 // You should have received a copy of the GNU Lesser General Public
14 // License along with this library; if not, write to the Free Software
15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
19 // Author : Anthony Geay (CEA/DEN)
21 #include "MEDCouplingMemArray.txx"
22 #include "MEDCouplingAutoRefCountObjectPtr.hxx"
25 #include "GenMathFormulae.hxx"
26 #include "InterpKernelAutoPtr.hxx"
27 #include "InterpKernelExprParser.hxx"
36 typedef double (*MYFUNCPTR)(double);
38 using namespace ParaMEDMEM;
40 template<int SPACEDIM>
41 void DataArrayDouble::findCommonTuplesAlg(const double *bbox, int nbNodes, int limitNodeId, double prec, DataArrayInt *c, DataArrayInt *cI) const
43 const double *coordsPtr=getConstPointer();
44 BBTreePts<SPACEDIM,int> myTree(bbox,0,0,nbNodes,prec);
45 std::vector<bool> isDone(nbNodes);
46 for(int i=0;i<nbNodes;i++)
50 std::vector<int> intersectingElems;
51 myTree.getElementsAroundPoint(coordsPtr+i*SPACEDIM,intersectingElems);
52 if(intersectingElems.size()>1)
54 std::vector<int> commonNodes;
55 for(std::vector<int>::const_iterator it=intersectingElems.begin();it!=intersectingElems.end();it++)
59 commonNodes.push_back(*it);
62 if(!commonNodes.empty())
64 cI->pushBackSilent(cI->back()+(int)commonNodes.size()+1);
66 c->insertAtTheEnd(commonNodes.begin(),commonNodes.end());
73 template<int SPACEDIM>
74 void DataArrayDouble::FindTupleIdsNearTuplesAlg(const BBTreePts<SPACEDIM,int>& myTree, const double *pos, int nbOfTuples, double eps,
75 DataArrayInt *c, DataArrayInt *cI)
77 for(int i=0;i<nbOfTuples;i++)
79 std::vector<int> intersectingElems;
80 myTree.getElementsAroundPoint(pos+i*SPACEDIM,intersectingElems);
81 std::vector<int> commonNodes;
82 for(std::vector<int>::const_iterator it=intersectingElems.begin();it!=intersectingElems.end();it++)
83 commonNodes.push_back(*it);
84 cI->pushBackSilent(cI->back()+(int)commonNodes.size());
85 c->insertAtTheEnd(commonNodes.begin(),commonNodes.end());
89 template<int SPACEDIM>
90 void DataArrayDouble::FindClosestTupleIdAlg(const BBTreePts<SPACEDIM,int>& myTree, double dist, const double *pos, int nbOfTuples, const double *thisPt, int thisNbOfTuples, int *res)
95 for(int i=0;i<nbOfTuples;i++,p+=SPACEDIM,r++)
100 double ret=myTree.getElementsAroundPoint2(p,distOpt,elem);
101 if(ret!=std::numeric_limits<double>::max())
103 distOpt=std::max(ret,1e-4);
108 { distOpt=2*distOpt; continue; }
113 std::size_t DataArray::getHeapMemorySizeWithoutChildren() const
115 std::size_t sz1=_name.capacity();
116 std::size_t sz2=_info_on_compo.capacity();
118 for(std::vector<std::string>::const_iterator it=_info_on_compo.begin();it!=_info_on_compo.end();it++)
119 sz3+=(*it).capacity();
123 std::vector<const BigMemoryObject *> DataArray::getDirectChildren() const
125 return std::vector<const BigMemoryObject *>();
129 * Sets the attribute \a _name of \a this array.
130 * See \ref MEDCouplingArrayBasicsName "DataArrays infos" for more information.
131 * \param [in] name - new array name
133 void DataArray::setName(const char *name)
139 * Copies textual data from an \a other DataArray. The copied data are
140 * - the name attribute,
141 * - the information of components.
143 * For more information on these data see \ref MEDCouplingArrayBasicsName "DataArrays infos".
145 * \param [in] other - another instance of DataArray to copy the textual data from.
146 * \throw If number of components of \a this array differs from that of the \a other.
148 void DataArray::copyStringInfoFrom(const DataArray& other)
150 if(_info_on_compo.size()!=other._info_on_compo.size())
151 throw INTERP_KERNEL::Exception("Size of arrays mismatches on copyStringInfoFrom !");
153 _info_on_compo=other._info_on_compo;
156 void DataArray::copyPartOfStringInfoFrom(const DataArray& other, const std::vector<int>& compoIds)
158 int nbOfCompoOth=other.getNumberOfComponents();
159 std::size_t newNbOfCompo=compoIds.size();
160 for(std::size_t i=0;i<newNbOfCompo;i++)
161 if(compoIds[i]>=nbOfCompoOth || compoIds[i]<0)
163 std::ostringstream oss; oss << "Specified component id is out of range (" << compoIds[i] << ") compared with nb of actual components (" << nbOfCompoOth << ")";
164 throw INTERP_KERNEL::Exception(oss.str().c_str());
166 for(std::size_t i=0;i<newNbOfCompo;i++)
167 setInfoOnComponent((int)i,other.getInfoOnComponent(compoIds[i]).c_str());
170 void DataArray::copyPartOfStringInfoFrom2(const std::vector<int>& compoIds, const DataArray& other)
172 int nbOfCompo=getNumberOfComponents();
173 std::size_t partOfCompoToSet=compoIds.size();
174 if((int)partOfCompoToSet!=other.getNumberOfComponents())
175 throw INTERP_KERNEL::Exception("Given compoIds has not the same size as number of components of given array !");
176 for(std::size_t i=0;i<partOfCompoToSet;i++)
177 if(compoIds[i]>=nbOfCompo || compoIds[i]<0)
179 std::ostringstream oss; oss << "Specified component id is out of range (" << compoIds[i] << ") compared with nb of actual components (" << nbOfCompo << ")";
180 throw INTERP_KERNEL::Exception(oss.str().c_str());
182 for(std::size_t i=0;i<partOfCompoToSet;i++)
183 setInfoOnComponent(compoIds[i],other.getInfoOnComponent((int)i).c_str());
186 bool DataArray::areInfoEqualsIfNotWhy(const DataArray& other, std::string& reason) const
188 std::ostringstream oss;
189 if(_name!=other._name)
191 oss << "Names DataArray mismatch : this name=\"" << _name << " other name=\"" << other._name << "\" !";
195 if(_info_on_compo!=other._info_on_compo)
197 oss << "Components DataArray mismatch : \nThis components=";
198 for(std::vector<std::string>::const_iterator it=_info_on_compo.begin();it!=_info_on_compo.end();it++)
199 oss << "\"" << *it << "\",";
200 oss << "\nOther components=";
201 for(std::vector<std::string>::const_iterator it=other._info_on_compo.begin();it!=other._info_on_compo.end();it++)
202 oss << "\"" << *it << "\",";
210 * Compares textual information of \a this DataArray with that of an \a other one.
211 * The compared data are
212 * - the name attribute,
213 * - the information of components.
215 * For more information on these data see \ref MEDCouplingArrayBasicsName "DataArrays infos".
216 * \param [in] other - another instance of DataArray to compare the textual data of.
217 * \return bool - \a true if the textual information is same, \a false else.
219 bool DataArray::areInfoEquals(const DataArray& other) const
222 return areInfoEqualsIfNotWhy(other,tmp);
225 void DataArray::reprWithoutNameStream(std::ostream& stream) const
227 stream << "Number of components : "<< getNumberOfComponents() << "\n";
228 stream << "Info of these components : ";
229 for(std::vector<std::string>::const_iterator iter=_info_on_compo.begin();iter!=_info_on_compo.end();iter++)
230 stream << "\"" << *iter << "\" ";
234 std::string DataArray::cppRepr(const char *varName) const
236 std::ostringstream ret;
237 reprCppStream(varName,ret);
242 * Sets information on all components. To know more on format of this information
243 * see \ref MEDCouplingArrayBasicsCompoName "DataArrays infos".
244 * \param [in] info - a vector of strings.
245 * \throw If size of \a info differs from the number of components of \a this.
247 void DataArray::setInfoOnComponents(const std::vector<std::string>& info)
249 if(getNumberOfComponents()!=(int)info.size())
251 std::ostringstream oss; oss << "DataArray::setInfoOnComponents : input is of size " << info.size() << " whereas number of components is equal to " << getNumberOfComponents() << " !";
252 throw INTERP_KERNEL::Exception(oss.str().c_str());
258 * This method is only a dispatcher towards DataArrayDouble::setPartOfValues3, DataArrayInt::setPartOfValues3, DataArrayChar::setPartOfValues3 depending on the true
259 * type of \a this and \a aBase.
261 * \throw If \a aBase and \a this do not have the same type.
263 * \sa DataArrayDouble::setPartOfValues3, DataArrayInt::setPartOfValues3, DataArrayChar::setPartOfValues3.
265 void DataArray::setPartOfValuesBase3(const DataArray *aBase, const int *bgTuples, const int *endTuples, int bgComp, int endComp, int stepComp, bool strictCompoCompare)
268 throw INTERP_KERNEL::Exception("DataArray::setPartOfValuesBase3 : input aBase object is NULL !");
269 DataArrayDouble *this1(dynamic_cast<DataArrayDouble *>(this));
270 DataArrayInt *this2(dynamic_cast<DataArrayInt *>(this));
271 DataArrayChar *this3(dynamic_cast<DataArrayChar *>(this));
272 const DataArrayDouble *a1(dynamic_cast<const DataArrayDouble *>(aBase));
273 const DataArrayInt *a2(dynamic_cast<const DataArrayInt *>(aBase));
274 const DataArrayChar *a3(dynamic_cast<const DataArrayChar *>(aBase));
277 this1->setPartOfValues3(a1,bgTuples,endTuples,bgComp,endComp,stepComp,strictCompoCompare);
282 this2->setPartOfValues3(a2,bgTuples,endTuples,bgComp,endComp,stepComp,strictCompoCompare);
287 this3->setPartOfValues3(a3,bgTuples,endTuples,bgComp,endComp,stepComp,strictCompoCompare);
290 throw INTERP_KERNEL::Exception("DataArray::setPartOfValuesBase3 : input aBase object and this do not have the same type !");
293 std::vector<std::string> DataArray::getVarsOnComponent() const
295 int nbOfCompo=(int)_info_on_compo.size();
296 std::vector<std::string> ret(nbOfCompo);
297 for(int i=0;i<nbOfCompo;i++)
298 ret[i]=getVarOnComponent(i);
302 std::vector<std::string> DataArray::getUnitsOnComponent() const
304 int nbOfCompo=(int)_info_on_compo.size();
305 std::vector<std::string> ret(nbOfCompo);
306 for(int i=0;i<nbOfCompo;i++)
307 ret[i]=getUnitOnComponent(i);
312 * Returns information on a component specified by an index.
313 * To know more on format of this information
314 * see \ref MEDCouplingArrayBasicsCompoName "DataArrays infos".
315 * \param [in] i - the index (zero based) of the component of interest.
316 * \return std::string - a string containing the information on \a i-th component.
317 * \throw If \a i is not a valid component index.
319 std::string DataArray::getInfoOnComponent(int i) const
321 if(i<(int)_info_on_compo.size() && i>=0)
322 return _info_on_compo[i];
325 std::ostringstream oss; oss << "DataArray::getInfoOnComponent : Specified component id is out of range (" << i << ") compared with nb of actual components (" << (int) _info_on_compo.size();
326 throw INTERP_KERNEL::Exception(oss.str().c_str());
331 * Returns the var part of the full information of the \a i-th component.
332 * For example, if \c getInfoOnComponent(0) returns "SIGXY [N/m^2]", then
333 * \c getVarOnComponent(0) returns "SIGXY".
334 * If a unit part of information is not detected by presence of
335 * two square brackets, then the full information is returned.
336 * To read more about the component information format, see
337 * \ref MEDCouplingArrayBasicsCompoName "DataArrays infos".
338 * \param [in] i - the index (zero based) of the component of interest.
339 * \return std::string - a string containing the var information, or the full info.
340 * \throw If \a i is not a valid component index.
342 std::string DataArray::getVarOnComponent(int i) const
344 if(i<(int)_info_on_compo.size() && i>=0)
346 return GetVarNameFromInfo(_info_on_compo[i]);
350 std::ostringstream oss; oss << "DataArray::getVarOnComponent : Specified component id is out of range (" << i << ") compared with nb of actual components (" << (int) _info_on_compo.size();
351 throw INTERP_KERNEL::Exception(oss.str().c_str());
356 * Returns the unit part of the full information of the \a i-th component.
357 * For example, if \c getInfoOnComponent(0) returns "SIGXY [ N/m^2]", then
358 * \c getUnitOnComponent(0) returns " N/m^2".
359 * If a unit part of information is not detected by presence of
360 * two square brackets, then an empty string is returned.
361 * To read more about the component information format, see
362 * \ref MEDCouplingArrayBasicsCompoName "DataArrays infos".
363 * \param [in] i - the index (zero based) of the component of interest.
364 * \return std::string - a string containing the unit information, if any, or "".
365 * \throw If \a i is not a valid component index.
367 std::string DataArray::getUnitOnComponent(int i) const
369 if(i<(int)_info_on_compo.size() && i>=0)
371 return GetUnitFromInfo(_info_on_compo[i]);
375 std::ostringstream oss; oss << "DataArray::getUnitOnComponent : Specified component id is out of range (" << i << ") compared with nb of actual components (" << (int) _info_on_compo.size();
376 throw INTERP_KERNEL::Exception(oss.str().c_str());
381 * Returns the var part of the full component information.
382 * For example, if \a info == "SIGXY [N/m^2]", then this method returns "SIGXY".
383 * If a unit part of information is not detected by presence of
384 * two square brackets, then the whole \a info is returned.
385 * To read more about the component information format, see
386 * \ref MEDCouplingArrayBasicsCompoName "DataArrays infos".
387 * \param [in] info - the full component information.
388 * \return std::string - a string containing only var information, or the \a info.
390 std::string DataArray::GetVarNameFromInfo(const std::string& info)
392 std::size_t p1=info.find_last_of('[');
393 std::size_t p2=info.find_last_of(']');
394 if(p1==std::string::npos || p2==std::string::npos)
399 return std::string();
400 std::size_t p3=info.find_last_not_of(' ',p1-1);
401 return info.substr(0,p3+1);
405 * Returns the unit part of the full component information.
406 * For example, if \a info == "SIGXY [ N/m^2]", then this method returns " N/m^2".
407 * If a unit part of information is not detected by presence of
408 * two square brackets, then an empty string is returned.
409 * To read more about the component information format, see
410 * \ref MEDCouplingArrayBasicsCompoName "DataArrays infos".
411 * \param [in] info - the full component information.
412 * \return std::string - a string containing only unit information, if any, or "".
414 std::string DataArray::GetUnitFromInfo(const std::string& info)
416 std::size_t p1=info.find_last_of('[');
417 std::size_t p2=info.find_last_of(']');
418 if(p1==std::string::npos || p2==std::string::npos)
419 return std::string();
421 return std::string();
422 return info.substr(p1+1,p2-p1-1);
426 * Returns a new DataArray by concatenating all given arrays, so that (1) the number
427 * of tuples in the result array is a sum of the number of tuples of given arrays and (2)
428 * the number of component in the result array is same as that of each of given arrays.
429 * Info on components is copied from the first of the given arrays. Number of components
430 * in the given arrays must be the same.
431 * \param [in] arrs - a sequence of arrays to include in the result array. All arrays must have the same type.
432 * \return DataArray * - the new instance of DataArray (that can be either DataArrayInt, DataArrayDouble, DataArrayChar).
433 * The caller is to delete this result array using decrRef() as it is no more
435 * \throw If all arrays within \a arrs are NULL.
436 * \throw If all not null arrays in \a arrs have not the same type.
437 * \throw If getNumberOfComponents() of arrays within \a arrs.
439 DataArray *DataArray::Aggregate(const std::vector<const DataArray *>& arrs)
441 std::vector<const DataArray *> arr2;
442 for(std::vector<const DataArray *>::const_iterator it=arrs.begin();it!=arrs.end();it++)
446 throw INTERP_KERNEL::Exception("DataArray::Aggregate : only null instance in input vector !");
447 std::vector<const DataArrayDouble *> arrd;
448 std::vector<const DataArrayInt *> arri;
449 std::vector<const DataArrayChar *> arrc;
450 for(std::vector<const DataArray *>::const_iterator it=arr2.begin();it!=arr2.end();it++)
452 const DataArrayDouble *a=dynamic_cast<const DataArrayDouble *>(*it);
454 { arrd.push_back(a); continue; }
455 const DataArrayInt *b=dynamic_cast<const DataArrayInt *>(*it);
457 { arri.push_back(b); continue; }
458 const DataArrayChar *c=dynamic_cast<const DataArrayChar *>(*it);
460 { arrc.push_back(c); continue; }
461 throw INTERP_KERNEL::Exception("DataArray::Aggregate : presence of not null instance in inuput that is not in [DataArrayDouble, DataArrayInt, DataArrayChar] !");
463 if(arr2.size()==arrd.size())
464 return DataArrayDouble::Aggregate(arrd);
465 if(arr2.size()==arri.size())
466 return DataArrayInt::Aggregate(arri);
467 if(arr2.size()==arrc.size())
468 return DataArrayChar::Aggregate(arrc);
469 throw INTERP_KERNEL::Exception("DataArray::Aggregate : all input arrays must have the same type !");
473 * Sets information on a component specified by an index.
474 * To know more on format of this information
475 * see \ref MEDCouplingArrayBasicsCompoName "DataArrays infos".
476 * \warning Don't pass NULL as \a info!
477 * \param [in] i - the index (zero based) of the component of interest.
478 * \param [in] info - the string containing the information.
479 * \throw If \a i is not a valid component index.
481 void DataArray::setInfoOnComponent(int i, const char *info)
483 if(i<(int)_info_on_compo.size() && i>=0)
484 _info_on_compo[i]=info;
487 std::ostringstream oss; oss << "DataArray::setInfoOnComponent : Specified component id is out of range (" << i << ") compared with nb of actual components (" << (int) _info_on_compo.size();
488 throw INTERP_KERNEL::Exception(oss.str().c_str());
493 * Sets information on all components. This method can change number of components
494 * at certain conditions; if the conditions are not respected, an exception is thrown.
495 * The number of components can be changed in \a this only if \a this is not allocated.
496 * The condition of number of components must not be changed.
498 * To know more on format of the component information see
499 * \ref MEDCouplingArrayBasicsCompoName "DataArrays infos".
500 * \param [in] info - a vector of component infos.
501 * \throw If \a this->getNumberOfComponents() != \a info.size() && \a this->isAllocated()
503 void DataArray::setInfoAndChangeNbOfCompo(const std::vector<std::string>& info)
505 if(getNumberOfComponents()!=(int)info.size())
511 std::ostringstream oss; oss << "DataArray::setInfoAndChangeNbOfCompo : input is of size " << info.size() << " whereas number of components is equal to " << getNumberOfComponents() << " and this is already allocated !";
512 throw INTERP_KERNEL::Exception(oss.str().c_str());
519 void DataArray::checkNbOfTuples(int nbOfTuples, const char *msg) const
521 if(getNumberOfTuples()!=nbOfTuples)
523 std::ostringstream oss; oss << msg << " : mismatch number of tuples : expected " << nbOfTuples << " having " << getNumberOfTuples() << " !";
524 throw INTERP_KERNEL::Exception(oss.str().c_str());
528 void DataArray::checkNbOfComps(int nbOfCompo, const char *msg) const
530 if(getNumberOfComponents()!=nbOfCompo)
532 std::ostringstream oss; oss << msg << " : mismatch number of components : expected " << nbOfCompo << " having " << getNumberOfComponents() << " !";
533 throw INTERP_KERNEL::Exception(oss.str().c_str());
537 void DataArray::checkNbOfElems(std::size_t nbOfElems, const char *msg) const
539 if(getNbOfElems()!=nbOfElems)
541 std::ostringstream oss; oss << msg << " : mismatch number of elems : Expected " << nbOfElems << " having " << getNbOfElems() << " !";
542 throw INTERP_KERNEL::Exception(oss.str().c_str());
546 void DataArray::checkNbOfTuplesAndComp(const DataArray& other, const char *msg) const
548 if(getNumberOfTuples()!=other.getNumberOfTuples())
550 std::ostringstream oss; oss << msg << " : mismatch number of tuples : expected " << other.getNumberOfTuples() << " having " << getNumberOfTuples() << " !";
551 throw INTERP_KERNEL::Exception(oss.str().c_str());
553 if(getNumberOfComponents()!=other.getNumberOfComponents())
555 std::ostringstream oss; oss << msg << " : mismatch number of components : expected " << other.getNumberOfComponents() << " having " << getNumberOfComponents() << " !";
556 throw INTERP_KERNEL::Exception(oss.str().c_str());
560 void DataArray::checkNbOfTuplesAndComp(int nbOfTuples, int nbOfCompo, const char *msg) const
562 checkNbOfTuples(nbOfTuples,msg);
563 checkNbOfComps(nbOfCompo,msg);
567 * Simply this method checks that \b value is in [0,\b ref).
569 void DataArray::CheckValueInRange(int ref, int value, const char *msg)
571 if(value<0 || value>=ref)
573 std::ostringstream oss; oss << "DataArray::CheckValueInRange : " << msg << " ! Expected in range [0," << ref << "[ having " << value << " !";
574 throw INTERP_KERNEL::Exception(oss.str().c_str());
579 * This method checks that [\b start, \b end) is compliant with ref length \b value.
580 * typicaly start in [0,\b value) and end in [0,\b value). If value==start and start==end, it is supported.
582 void DataArray::CheckValueInRangeEx(int value, int start, int end, const char *msg)
584 if(start<0 || start>=value)
586 if(value!=start || end!=start)
588 std::ostringstream oss; oss << "DataArray::CheckValueInRangeEx : " << msg << " ! Expected start " << start << " of input range, in [0," << value << "[ !";
589 throw INTERP_KERNEL::Exception(oss.str().c_str());
592 if(end<0 || end>value)
594 std::ostringstream oss; oss << "DataArray::CheckValueInRangeEx : " << msg << " ! Expected end " << end << " of input range, in [0," << value << "] !";
595 throw INTERP_KERNEL::Exception(oss.str().c_str());
599 void DataArray::CheckClosingParInRange(int ref, int value, const char *msg)
601 if(value<0 || value>ref)
603 std::ostringstream oss; oss << "DataArray::CheckClosingParInRange : " << msg << " ! Expected input range in [0," << ref << "] having closing open parenthesis " << value << " !";
604 throw INTERP_KERNEL::Exception(oss.str().c_str());
609 * This method is useful to slice work among a pool of threads or processes. \a begin, \a end \a step is the input whole slice of work to perform,
610 * typically it is a whole slice of tuples of DataArray or cells, nodes of a mesh...
612 * The input \a sliceId should be an id in [0, \a nbOfSlices) that specifies the slice of work.
614 * \param [in] start - the start of the input slice of the whole work to perform splitted into slices.
615 * \param [in] stop - the stop of the input slice of the whole work to perform splitted into slices.
616 * \param [in] step - the step (that can be <0) of the input slice of the whole work to perform splitted into slices.
617 * \param [in] sliceId - the slice id considered
618 * \param [in] nbOfSlices - the number of slices (typically the number of cores on which the work is expected to be sliced)
619 * \param [out] startSlice - the start of the slice considered
620 * \param [out] stopSlice - the stop of the slice consided
622 * \throw If \a step == 0
623 * \throw If \a nbOfSlices not > 0
624 * \throw If \a sliceId not in [0,nbOfSlices)
626 void DataArray::GetSlice(int start, int stop, int step, int sliceId, int nbOfSlices, int& startSlice, int& stopSlice)
630 std::ostringstream oss; oss << "DataArray::GetSlice : nbOfSlices (" << nbOfSlices << ") must be > 0 !";
631 throw INTERP_KERNEL::Exception(oss.str().c_str());
633 if(sliceId<0 || sliceId>=nbOfSlices)
635 std::ostringstream oss; oss << "DataArray::GetSlice : sliceId (" << nbOfSlices << ") must be in [0 , nbOfSlices (" << nbOfSlices << ") ) !";
636 throw INTERP_KERNEL::Exception(oss.str().c_str());
638 int nbElems=GetNumberOfItemGivenBESRelative(start,stop,step,"DataArray::GetSlice");
639 int minNbOfElemsPerSlice=nbElems/nbOfSlices;
640 startSlice=start+minNbOfElemsPerSlice*step*sliceId;
641 if(sliceId<nbOfSlices-1)
642 stopSlice=start+minNbOfElemsPerSlice*step*(sliceId+1);
647 int DataArray::GetNumberOfItemGivenBES(int begin, int end, int step, const char *msg)
651 std::ostringstream oss; oss << msg << " : end before begin !";
652 throw INTERP_KERNEL::Exception(oss.str().c_str());
658 std::ostringstream oss; oss << msg << " : invalid step should be > 0 !";
659 throw INTERP_KERNEL::Exception(oss.str().c_str());
661 return (end-1-begin)/step+1;
664 int DataArray::GetNumberOfItemGivenBESRelative(int begin, int end, int step, const char *msg)
667 throw INTERP_KERNEL::Exception("DataArray::GetNumberOfItemGivenBES : step=0 is not allowed !");
668 if(end<begin && step>0)
670 std::ostringstream oss; oss << msg << " : end before begin whereas step is positive !";
671 throw INTERP_KERNEL::Exception(oss.str().c_str());
673 if(begin<end && step<0)
675 std::ostringstream oss; oss << msg << " : invalid step should be > 0 !";
676 throw INTERP_KERNEL::Exception(oss.str().c_str());
679 return (std::max(begin,end)-1-std::min(begin,end))/std::abs(step)+1;
684 int DataArray::GetPosOfItemGivenBESRelativeNoThrow(int value, int begin, int end, int step)
690 if(begin<=value && value<end)
692 if((value-begin)%step==0)
693 return (value-begin)/step;
702 if(begin>=value && value>end)
704 if((begin-value)%(-step)==0)
705 return (begin-value)/(-step);
718 * Returns a new instance of DataArrayDouble. The caller is to delete this array
719 * using decrRef() as it is no more needed.
721 DataArrayDouble *DataArrayDouble::New()
723 return new DataArrayDouble;
727 * Checks if raw data is allocated. Read more on the raw data
728 * in \ref MEDCouplingArrayBasicsTuplesAndCompo "DataArrays infos" for more information.
729 * \return bool - \a true if the raw data is allocated, \a false else.
731 bool DataArrayDouble::isAllocated() const
733 return getConstPointer()!=0;
737 * Checks if raw data is allocated and throws an exception if it is not the case.
738 * \throw If the raw data is not allocated.
740 void DataArrayDouble::checkAllocated() const
743 throw INTERP_KERNEL::Exception("DataArrayDouble::checkAllocated : Array is defined but not allocated ! Call alloc or setValues method first !");
747 * This method desallocated \a this without modification of informations relative to the components.
748 * After call of this method, DataArrayDouble::isAllocated will return false.
749 * If \a this is already not allocated, \a this is let unchanged.
751 void DataArrayDouble::desallocate()
756 std::size_t DataArrayDouble::getHeapMemorySizeWithoutChildren() const
758 std::size_t sz(_mem.getNbOfElemAllocated());
760 return DataArray::getHeapMemorySizeWithoutChildren()+sz;
764 * Returns the only one value in \a this, if and only if number of elements
765 * (nb of tuples * nb of components) is equal to 1, and that \a this is allocated.
766 * \return double - the sole value stored in \a this array.
767 * \throw If at least one of conditions stated above is not fulfilled.
769 double DataArrayDouble::doubleValue() const
773 if(getNbOfElems()==1)
775 return *getConstPointer();
778 throw INTERP_KERNEL::Exception("DataArrayDouble::doubleValue : DataArrayDouble instance is allocated but number of elements is not equal to 1 !");
781 throw INTERP_KERNEL::Exception("DataArrayDouble::doubleValue : DataArrayDouble instance is not allocated !");
785 * Checks the number of tuples.
786 * \return bool - \a true if getNumberOfTuples() == 0, \a false else.
787 * \throw If \a this is not allocated.
789 bool DataArrayDouble::empty() const
792 return getNumberOfTuples()==0;
796 * Returns a full copy of \a this. For more info on copying data arrays see
797 * \ref MEDCouplingArrayBasicsCopyDeep.
798 * \return DataArrayDouble * - a new instance of DataArrayDouble. The caller is to
799 * delete this array using decrRef() as it is no more needed.
801 DataArrayDouble *DataArrayDouble::deepCpy() const
803 return new DataArrayDouble(*this);
807 * Returns either a \a deep or \a shallow copy of this array. For more info see
808 * \ref MEDCouplingArrayBasicsCopyDeep and \ref MEDCouplingArrayBasicsCopyShallow.
809 * \param [in] dCpy - if \a true, a deep copy is returned, else, a shallow one.
810 * \return DataArrayDouble * - either a new instance of DataArrayDouble (if \a dCpy
811 * == \a true) or \a this instance (if \a dCpy == \a false).
813 DataArrayDouble *DataArrayDouble::performCpy(bool dCpy) const
820 return const_cast<DataArrayDouble *>(this);
825 * Copies all the data from another DataArrayDouble. For more info see
826 * \ref MEDCouplingArrayBasicsCopyDeepAssign.
827 * \param [in] other - another instance of DataArrayDouble to copy data from.
828 * \throw If the \a other is not allocated.
830 void DataArrayDouble::cpyFrom(const DataArrayDouble& other)
832 other.checkAllocated();
833 int nbOfTuples=other.getNumberOfTuples();
834 int nbOfComp=other.getNumberOfComponents();
835 allocIfNecessary(nbOfTuples,nbOfComp);
836 std::size_t nbOfElems=(std::size_t)nbOfTuples*nbOfComp;
837 double *pt=getPointer();
838 const double *ptI=other.getConstPointer();
839 for(std::size_t i=0;i<nbOfElems;i++)
841 copyStringInfoFrom(other);
845 * This method reserve nbOfElems elements in memory ( nbOfElems*8 bytes ) \b without impacting the number of tuples in \a this.
846 * 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.
847 * If \a this has not already been allocated, number of components is set to one.
848 * This method allows to reduce number of reallocations on invokation of DataArrayDouble::pushBackSilent and DataArrayDouble::pushBackValsSilent on \a this.
850 * \sa DataArrayDouble::pack, DataArrayDouble::pushBackSilent, DataArrayDouble::pushBackValsSilent
852 void DataArrayDouble::reserve(std::size_t nbOfElems)
854 int nbCompo=getNumberOfComponents();
857 _mem.reserve(nbOfElems);
861 _mem.reserve(nbOfElems);
862 _info_on_compo.resize(1);
865 throw INTERP_KERNEL::Exception("DataArrayDouble::reserve : not available for DataArrayDouble with number of components different than 1 !");
869 * 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
870 * of counter. So the caller is expected to call TimeLabel::declareAsNew on \a this at the end of the push session.
872 * \param [in] val the value to be added in \a this
873 * \throw If \a this has already been allocated with number of components different from one.
874 * \sa DataArrayDouble::pushBackValsSilent
876 void DataArrayDouble::pushBackSilent(double val)
878 int nbCompo=getNumberOfComponents();
883 _info_on_compo.resize(1);
887 throw INTERP_KERNEL::Exception("DataArrayDouble::pushBackSilent : not available for DataArrayDouble with number of components different than 1 !");
891 * 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
892 * of counter. So the caller is expected to call TimeLabel::declareAsNew on \a this at the end of the push session.
894 * \param [in] valsBg - an array of values to push at the end of \this.
895 * \param [in] valsEnd - specifies the end of the array \a valsBg, so that
896 * the last value of \a valsBg is \a valsEnd[ -1 ].
897 * \throw If \a this has already been allocated with number of components different from one.
898 * \sa DataArrayDouble::pushBackSilent
900 void DataArrayDouble::pushBackValsSilent(const double *valsBg, const double *valsEnd)
902 int nbCompo=getNumberOfComponents();
904 _mem.insertAtTheEnd(valsBg,valsEnd);
907 _info_on_compo.resize(1);
908 _mem.insertAtTheEnd(valsBg,valsEnd);
911 throw INTERP_KERNEL::Exception("DataArrayDouble::pushBackValsSilent : not available for DataArrayDouble with number of components different than 1 !");
915 * This method returns silently ( without updating time label in \a this ) the last value, if any and suppress it.
916 * \throw If \a this is already empty.
917 * \throw If \a this has number of components different from one.
919 double DataArrayDouble::popBackSilent()
921 if(getNumberOfComponents()==1)
922 return _mem.popBack();
924 throw INTERP_KERNEL::Exception("DataArrayDouble::popBackSilent : not available for DataArrayDouble with number of components different than 1 !");
928 * 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.
930 * \sa DataArrayDouble::getHeapMemorySizeWithoutChildren, DataArrayDouble::reserve
932 void DataArrayDouble::pack() const
938 * Allocates the raw data in memory. If exactly same memory as needed already
939 * allocated, it is not re-allocated.
940 * \param [in] nbOfTuple - number of tuples of data to allocate.
941 * \param [in] nbOfCompo - number of components of data to allocate.
942 * \throw If \a nbOfTuple < 0 or \a nbOfCompo < 0.
944 void DataArrayDouble::allocIfNecessary(int nbOfTuple, int nbOfCompo)
948 if(nbOfTuple!=getNumberOfTuples() || nbOfCompo!=getNumberOfComponents())
949 alloc(nbOfTuple,nbOfCompo);
952 alloc(nbOfTuple,nbOfCompo);
956 * Allocates the raw data in memory. If the memory was already allocated, then it is
957 * freed and re-allocated. See an example of this method use
958 * \ref MEDCouplingArraySteps1WC "here".
959 * \param [in] nbOfTuple - number of tuples of data to allocate.
960 * \param [in] nbOfCompo - number of components of data to allocate.
961 * \throw If \a nbOfTuple < 0 or \a nbOfCompo < 0.
963 void DataArrayDouble::alloc(int nbOfTuple, int nbOfCompo)
965 if(nbOfTuple<0 || nbOfCompo<0)
966 throw INTERP_KERNEL::Exception("DataArrayDouble::alloc : request for negative length of data !");
967 _info_on_compo.resize(nbOfCompo);
968 _mem.alloc(nbOfCompo*(std::size_t)nbOfTuple);
973 * Assign zero to all values in \a this array. To know more on filling arrays see
974 * \ref MEDCouplingArrayFill.
975 * \throw If \a this is not allocated.
977 void DataArrayDouble::fillWithZero()
980 _mem.fillWithValue(0.);
985 * Assign \a val to all values in \a this array. To know more on filling arrays see
986 * \ref MEDCouplingArrayFill.
987 * \param [in] val - the value to fill with.
988 * \throw If \a this is not allocated.
990 void DataArrayDouble::fillWithValue(double val)
993 _mem.fillWithValue(val);
998 * Set all values in \a this array so that the i-th element equals to \a init + i
999 * (i starts from zero). To know more on filling arrays see \ref MEDCouplingArrayFill.
1000 * \param [in] init - value to assign to the first element of array.
1001 * \throw If \a this->getNumberOfComponents() != 1
1002 * \throw If \a this is not allocated.
1004 void DataArrayDouble::iota(double init)
1007 if(getNumberOfComponents()!=1)
1008 throw INTERP_KERNEL::Exception("DataArrayDouble::iota : works only for arrays with only one component, you can call 'rearrange' method before !");
1009 double *ptr=getPointer();
1010 int ntuples=getNumberOfTuples();
1011 for(int i=0;i<ntuples;i++)
1012 ptr[i]=init+double(i);
1017 * Checks if all values in \a this array are equal to \a val at precision \a eps.
1018 * \param [in] val - value to check equality of array values to.
1019 * \param [in] eps - precision to check the equality.
1020 * \return bool - \a true if all values are in range (_val_ - _eps_; _val_ + _eps_),
1022 * \throw If \a this->getNumberOfComponents() != 1
1023 * \throw If \a this is not allocated.
1025 bool DataArrayDouble::isUniform(double val, double eps) const
1028 if(getNumberOfComponents()!=1)
1029 throw INTERP_KERNEL::Exception("DataArrayDouble::isUniform : must be applied on DataArrayDouble with only one component, you can call 'rearrange' method before !");
1030 int nbOfTuples=getNumberOfTuples();
1031 const double *w=getConstPointer();
1032 const double *end2=w+nbOfTuples;
1033 const double vmin=val-eps;
1034 const double vmax=val+eps;
1036 if(*w<vmin || *w>vmax)
1042 * Sorts values of the array.
1043 * \param [in] asc - \a true means ascending order, \a false, descending.
1044 * \throw If \a this is not allocated.
1045 * \throw If \a this->getNumberOfComponents() != 1.
1047 void DataArrayDouble::sort(bool asc)
1050 if(getNumberOfComponents()!=1)
1051 throw INTERP_KERNEL::Exception("DataArrayDouble::sort : only supported with 'this' array with ONE component !");
1057 * Reverse the array values.
1058 * \throw If \a this->getNumberOfComponents() < 1.
1059 * \throw If \a this is not allocated.
1061 void DataArrayDouble::reverse()
1064 _mem.reverse(getNumberOfComponents());
1069 * Checks that \a this array is consistently **increasing** or **decreasing** in value,
1070 * with at least absolute difference value of |\a eps| at each step.
1071 * If not an exception is thrown.
1072 * \param [in] increasing - if \a true, the array values should be increasing.
1073 * \param [in] eps - minimal absolute difference between the neighbor values at which
1074 * the values are considered different.
1075 * \throw If sequence of values is not strictly monotonic in agreement with \a
1077 * \throw If \a this->getNumberOfComponents() != 1.
1078 * \throw If \a this is not allocated.
1080 void DataArrayDouble::checkMonotonic(bool increasing, double eps) const
1082 if(!isMonotonic(increasing,eps))
1085 throw INTERP_KERNEL::Exception("DataArrayDouble::checkMonotonic : 'this' is not INCREASING monotonic !");
1087 throw INTERP_KERNEL::Exception("DataArrayDouble::checkMonotonic : 'this' is not DECREASING monotonic !");
1092 * Checks that \a this array is consistently **increasing** or **decreasing** in value,
1093 * with at least absolute difference value of |\a eps| at each step.
1094 * \param [in] increasing - if \a true, array values should be increasing.
1095 * \param [in] eps - minimal absolute difference between the neighbor values at which
1096 * the values are considered different.
1097 * \return bool - \a true if values change in accordance with \a increasing arg.
1098 * \throw If \a this->getNumberOfComponents() != 1.
1099 * \throw If \a this is not allocated.
1101 bool DataArrayDouble::isMonotonic(bool increasing, double eps) const
1104 if(getNumberOfComponents()!=1)
1105 throw INTERP_KERNEL::Exception("DataArrayDouble::isMonotonic : only supported with 'this' array with ONE component !");
1106 int nbOfElements=getNumberOfTuples();
1107 const double *ptr=getConstPointer();
1111 double absEps=fabs(eps);
1114 for(int i=1;i<nbOfElements;i++)
1116 if(ptr[i]<(ref+absEps))
1124 for(int i=1;i<nbOfElements;i++)
1126 if(ptr[i]>(ref-absEps))
1135 * Returns a textual and human readable representation of \a this instance of
1136 * DataArrayDouble. This text is shown when a DataArrayDouble is printed in Python.
1137 * \return std::string - text describing \a this DataArrayDouble.
1139 std::string DataArrayDouble::repr() const
1141 std::ostringstream ret;
1146 std::string DataArrayDouble::reprZip() const
1148 std::ostringstream ret;
1153 void DataArrayDouble::writeVTK(std::ostream& ofs, int indent, const char *nameInFile, DataArrayByte *byteArr) const
1155 static const char SPACE[4]={' ',' ',' ',' '};
1157 std::string idt(indent,' ');
1159 ofs << idt << "<DataArray type=\"Float32\" Name=\"" << nameInFile << "\" NumberOfComponents=\"" << getNumberOfComponents() << "\"";
1162 ofs << " format=\"appended\" offset=\"" << byteArr->getNumberOfTuples() << "\">";
1163 INTERP_KERNEL::AutoPtr<float> tmp(new float[getNbOfElems()]);
1165 // to make Visual C++ happy : instead of std::copy(begin(),end(),(float *)tmp);
1166 for(const double *src=begin();src!=end();src++,pt++)
1168 const char *data(reinterpret_cast<const char *>((float *)tmp));
1169 std::size_t sz(getNbOfElems()*sizeof(float));
1170 byteArr->insertAtTheEnd(data,data+sz);
1171 byteArr->insertAtTheEnd(SPACE,SPACE+4);
1175 ofs << " RangeMin=\"" << getMinValueInArray() << "\" RangeMax=\"" << getMaxValueInArray() << "\" format=\"ascii\">\n" << idt;
1176 std::copy(begin(),end(),std::ostream_iterator<double>(ofs," "));
1178 ofs << std::endl << idt << "</DataArray>\n";
1181 void DataArrayDouble::reprStream(std::ostream& stream) const
1183 stream << "Name of double array : \"" << _name << "\"\n";
1184 reprWithoutNameStream(stream);
1187 void DataArrayDouble::reprZipStream(std::ostream& stream) const
1189 stream << "Name of double array : \"" << _name << "\"\n";
1190 reprZipWithoutNameStream(stream);
1193 void DataArrayDouble::reprWithoutNameStream(std::ostream& stream) const
1195 DataArray::reprWithoutNameStream(stream);
1196 stream.precision(17);
1197 _mem.repr(getNumberOfComponents(),stream);
1200 void DataArrayDouble::reprZipWithoutNameStream(std::ostream& stream) const
1202 DataArray::reprWithoutNameStream(stream);
1203 stream.precision(17);
1204 _mem.reprZip(getNumberOfComponents(),stream);
1207 void DataArrayDouble::reprCppStream(const char *varName, std::ostream& stream) const
1209 int nbTuples=getNumberOfTuples(),nbComp=getNumberOfComponents();
1210 const double *data=getConstPointer();
1211 stream.precision(17);
1212 stream << "DataArrayDouble *" << varName << "=DataArrayDouble::New();" << std::endl;
1213 if(nbTuples*nbComp>=1)
1215 stream << "const double " << varName << "Data[" << nbTuples*nbComp << "]={";
1216 std::copy(data,data+nbTuples*nbComp-1,std::ostream_iterator<double>(stream,","));
1217 stream << data[nbTuples*nbComp-1] << "};" << std::endl;
1218 stream << varName << "->useArray(" << varName << "Data,false,CPP_DEALLOC," << nbTuples << "," << nbComp << ");" << std::endl;
1221 stream << varName << "->alloc(" << nbTuples << "," << nbComp << ");" << std::endl;
1222 stream << varName << "->setName(\"" << getName() << "\");" << std::endl;
1226 * Method that gives a quick overvien of \a this for python.
1228 void DataArrayDouble::reprQuickOverview(std::ostream& stream) const
1230 static const std::size_t MAX_NB_OF_BYTE_IN_REPR=300;
1231 stream << "DataArrayDouble C++ instance at " << this << ". ";
1234 int nbOfCompo=(int)_info_on_compo.size();
1237 int nbOfTuples=getNumberOfTuples();
1238 stream << "Number of tuples : " << nbOfTuples << ". Number of components : " << nbOfCompo << "." << std::endl;
1239 reprQuickOverviewData(stream,MAX_NB_OF_BYTE_IN_REPR);
1242 stream << "Number of components : 0.";
1245 stream << "*** No data allocated ****";
1248 void DataArrayDouble::reprQuickOverviewData(std::ostream& stream, std::size_t maxNbOfByteInRepr) const
1250 const double *data=begin();
1251 int nbOfTuples=getNumberOfTuples();
1252 int nbOfCompo=(int)_info_on_compo.size();
1253 std::ostringstream oss2; oss2 << "[";
1255 std::string oss2Str(oss2.str());
1256 bool isFinished=true;
1257 for(int i=0;i<nbOfTuples && isFinished;i++)
1262 for(int j=0;j<nbOfCompo;j++,data++)
1265 if(j!=nbOfCompo-1) oss2 << ", ";
1271 if(i!=nbOfTuples-1) oss2 << ", ";
1272 std::string oss3Str(oss2.str());
1273 if(oss3Str.length()<maxNbOfByteInRepr)
1285 * Equivalent to DataArrayDouble::isEqual except that if false the reason of
1286 * mismatch is given.
1288 * \param [in] other the instance to be compared with \a this
1289 * \param [in] prec the precision to compare numeric data of the arrays.
1290 * \param [out] reason In case of inequality returns the reason.
1291 * \sa DataArrayDouble::isEqual
1293 bool DataArrayDouble::isEqualIfNotWhy(const DataArrayDouble& other, double prec, std::string& reason) const
1295 if(!areInfoEqualsIfNotWhy(other,reason))
1297 return _mem.isEqual(other._mem,prec,reason);
1301 * Checks if \a this and another DataArrayDouble are fully equal. For more info see
1302 * \ref MEDCouplingArrayBasicsCompare.
1303 * \param [in] other - an instance of DataArrayDouble to compare with \a this one.
1304 * \param [in] prec - precision value to compare numeric data of the arrays.
1305 * \return bool - \a true if the two arrays are equal, \a false else.
1307 bool DataArrayDouble::isEqual(const DataArrayDouble& other, double prec) const
1310 return isEqualIfNotWhy(other,prec,tmp);
1314 * Checks if values of \a this and another DataArrayDouble are equal. For more info see
1315 * \ref MEDCouplingArrayBasicsCompare.
1316 * \param [in] other - an instance of DataArrayDouble to compare with \a this one.
1317 * \param [in] prec - precision value to compare numeric data of the arrays.
1318 * \return bool - \a true if the values of two arrays are equal, \a false else.
1320 bool DataArrayDouble::isEqualWithoutConsideringStr(const DataArrayDouble& other, double prec) const
1323 return _mem.isEqual(other._mem,prec,tmp);
1327 * Changes number of tuples in the array. If the new number of tuples is smaller
1328 * than the current number the array is truncated, otherwise the array is extended.
1329 * \param [in] nbOfTuples - new number of tuples.
1330 * \throw If \a this is not allocated.
1331 * \throw If \a nbOfTuples is negative.
1333 void DataArrayDouble::reAlloc(int nbOfTuples)
1336 throw INTERP_KERNEL::Exception("DataArrayDouble::reAlloc : input new number of tuples should be >=0 !");
1338 _mem.reAlloc(getNumberOfComponents()*(std::size_t)nbOfTuples);
1343 * Creates a new DataArrayInt and assigns all (textual and numerical) data of \a this
1344 * array to the new one.
1345 * \return DataArrayInt * - the new instance of DataArrayInt.
1347 DataArrayInt *DataArrayDouble::convertToIntArr() const
1349 DataArrayInt *ret=DataArrayInt::New();
1350 ret->alloc(getNumberOfTuples(),getNumberOfComponents());
1351 std::size_t nbOfVals=getNbOfElems();
1352 int *dest=ret->getPointer();
1353 // to make Visual C++ happy : instead of std::copy(src,src+nbOfVals,dest);
1354 for(const double *src=begin();src!=end();src++,dest++)
1356 ret->copyStringInfoFrom(*this);
1361 * Returns a new DataArrayDouble holding the same values as \a this array but differently
1362 * arranged in memory. If \a this array holds 2 components of 3 values:
1363 * \f$ x_0,x_1,x_2,y_0,y_1,y_2 \f$, then the result array holds these values arranged
1364 * as follows: \f$ x_0,y_0,x_1,y_1,x_2,y_2 \f$.
1365 * \warning Do not confuse this method with transpose()!
1366 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1367 * is to delete using decrRef() as it is no more needed.
1368 * \throw If \a this is not allocated.
1370 DataArrayDouble *DataArrayDouble::fromNoInterlace() const
1373 throw INTERP_KERNEL::Exception("DataArrayDouble::fromNoInterlace : Not defined array !");
1374 double *tab=_mem.fromNoInterlace(getNumberOfComponents());
1375 DataArrayDouble *ret=DataArrayDouble::New();
1376 ret->useArray(tab,true,C_DEALLOC,getNumberOfTuples(),getNumberOfComponents());
1381 * Returns a new DataArrayDouble holding the same values as \a this array but differently
1382 * arranged in memory. If \a this array holds 2 components of 3 values:
1383 * \f$ x_0,y_0,x_1,y_1,x_2,y_2 \f$, then the result array holds these values arranged
1384 * as follows: \f$ x_0,x_1,x_2,y_0,y_1,y_2 \f$.
1385 * \warning Do not confuse this method with transpose()!
1386 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1387 * is to delete using decrRef() as it is no more needed.
1388 * \throw If \a this is not allocated.
1390 DataArrayDouble *DataArrayDouble::toNoInterlace() const
1393 throw INTERP_KERNEL::Exception("DataArrayDouble::toNoInterlace : Not defined array !");
1394 double *tab=_mem.toNoInterlace(getNumberOfComponents());
1395 DataArrayDouble *ret=DataArrayDouble::New();
1396 ret->useArray(tab,true,C_DEALLOC,getNumberOfTuples(),getNumberOfComponents());
1401 * Permutes values of \a this array as required by \a old2New array. The values are
1402 * permuted so that \c new[ \a old2New[ i ]] = \c old[ i ]. Number of tuples remains
1403 * the same as in \this one.
1404 * If a permutation reduction is needed, substr() or selectByTupleId() should be used.
1405 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
1406 * \param [in] old2New - C array of length equal to \a this->getNumberOfTuples()
1407 * giving a new position for i-th old value.
1409 void DataArrayDouble::renumberInPlace(const int *old2New)
1412 int nbTuples=getNumberOfTuples();
1413 int nbOfCompo=getNumberOfComponents();
1414 double *tmp=new double[nbTuples*nbOfCompo];
1415 const double *iptr=getConstPointer();
1416 for(int i=0;i<nbTuples;i++)
1419 if(v>=0 && v<nbTuples)
1420 std::copy(iptr+nbOfCompo*i,iptr+nbOfCompo*(i+1),tmp+nbOfCompo*v);
1423 std::ostringstream oss; oss << "DataArrayDouble::renumberInPlace : At place #" << i << " value is " << v << " ! Should be in [0," << nbTuples << ") !";
1424 throw INTERP_KERNEL::Exception(oss.str().c_str());
1427 std::copy(tmp,tmp+nbTuples*nbOfCompo,getPointer());
1433 * Permutes values of \a this array as required by \a new2Old array. The values are
1434 * permuted so that \c new[ i ] = \c old[ \a new2Old[ i ]]. Number of tuples remains
1435 * the same as in \this one.
1436 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
1437 * \param [in] new2Old - C array of length equal to \a this->getNumberOfTuples()
1438 * giving a previous position of i-th new value.
1439 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1440 * is to delete using decrRef() as it is no more needed.
1442 void DataArrayDouble::renumberInPlaceR(const int *new2Old)
1445 int nbTuples=getNumberOfTuples();
1446 int nbOfCompo=getNumberOfComponents();
1447 double *tmp=new double[nbTuples*nbOfCompo];
1448 const double *iptr=getConstPointer();
1449 for(int i=0;i<nbTuples;i++)
1452 if(v>=0 && v<nbTuples)
1453 std::copy(iptr+nbOfCompo*v,iptr+nbOfCompo*(v+1),tmp+nbOfCompo*i);
1456 std::ostringstream oss; oss << "DataArrayDouble::renumberInPlaceR : At place #" << i << " value is " << v << " ! Should be in [0," << nbTuples << ") !";
1457 throw INTERP_KERNEL::Exception(oss.str().c_str());
1460 std::copy(tmp,tmp+nbTuples*nbOfCompo,getPointer());
1466 * Returns a copy of \a this array with values permuted as required by \a old2New array.
1467 * The values are permuted so that \c new[ \a old2New[ i ]] = \c old[ i ].
1468 * Number of tuples in the result array remains the same as in \this one.
1469 * If a permutation reduction is needed, renumberAndReduce() should be used.
1470 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
1471 * \param [in] old2New - C array of length equal to \a this->getNumberOfTuples()
1472 * giving a new position for i-th old value.
1473 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1474 * is to delete using decrRef() as it is no more needed.
1475 * \throw If \a this is not allocated.
1477 DataArrayDouble *DataArrayDouble::renumber(const int *old2New) const
1480 int nbTuples=getNumberOfTuples();
1481 int nbOfCompo=getNumberOfComponents();
1482 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
1483 ret->alloc(nbTuples,nbOfCompo);
1484 ret->copyStringInfoFrom(*this);
1485 const double *iptr=getConstPointer();
1486 double *optr=ret->getPointer();
1487 for(int i=0;i<nbTuples;i++)
1488 std::copy(iptr+nbOfCompo*i,iptr+nbOfCompo*(i+1),optr+nbOfCompo*old2New[i]);
1489 ret->copyStringInfoFrom(*this);
1494 * Returns a copy of \a this array with values permuted as required by \a new2Old array.
1495 * The values are permuted so that \c new[ i ] = \c old[ \a new2Old[ i ]]. Number of
1496 * tuples in the result array remains the same as in \this one.
1497 * If a permutation reduction is needed, substr() or selectByTupleId() should be used.
1498 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
1499 * \param [in] new2Old - C array of length equal to \a this->getNumberOfTuples()
1500 * giving a previous position of i-th new value.
1501 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1502 * is to delete using decrRef() as it is no more needed.
1504 DataArrayDouble *DataArrayDouble::renumberR(const int *new2Old) const
1507 int nbTuples=getNumberOfTuples();
1508 int nbOfCompo=getNumberOfComponents();
1509 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
1510 ret->alloc(nbTuples,nbOfCompo);
1511 ret->copyStringInfoFrom(*this);
1512 const double *iptr=getConstPointer();
1513 double *optr=ret->getPointer();
1514 for(int i=0;i<nbTuples;i++)
1515 std::copy(iptr+nbOfCompo*new2Old[i],iptr+nbOfCompo*(new2Old[i]+1),optr+i*nbOfCompo);
1516 ret->copyStringInfoFrom(*this);
1521 * Returns a shorten and permuted copy of \a this array. The new DataArrayDouble is
1522 * of size \a newNbOfTuple and it's values are permuted as required by \a old2New array.
1523 * The values are permuted so that \c new[ \a old2New[ i ]] = \c old[ i ] for all
1524 * \a old2New[ i ] >= 0. In other words every i-th tuple in \a this array, for which
1525 * \a old2New[ i ] is negative, is missing from the result array.
1526 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
1527 * \param [in] old2New - C array of length equal to \a this->getNumberOfTuples()
1528 * giving a new position for i-th old tuple and giving negative position for
1529 * for i-th old tuple that should be omitted.
1530 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1531 * is to delete using decrRef() as it is no more needed.
1533 DataArrayDouble *DataArrayDouble::renumberAndReduce(const int *old2New, int newNbOfTuple) const
1536 int nbTuples=getNumberOfTuples();
1537 int nbOfCompo=getNumberOfComponents();
1538 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
1539 ret->alloc(newNbOfTuple,nbOfCompo);
1540 const double *iptr=getConstPointer();
1541 double *optr=ret->getPointer();
1542 for(int i=0;i<nbTuples;i++)
1546 std::copy(iptr+i*nbOfCompo,iptr+(i+1)*nbOfCompo,optr+w*nbOfCompo);
1548 ret->copyStringInfoFrom(*this);
1553 * Returns a shorten and permuted copy of \a this array. The new DataArrayDouble is
1554 * of size \a new2OldEnd - \a new2OldBg and it's values are permuted as required by
1555 * \a new2OldBg array.
1556 * The values are permuted so that \c new[ i ] = \c old[ \a new2OldBg[ i ]].
1557 * This method is equivalent to renumberAndReduce() except that convention in input is
1558 * \c new2old and \b not \c old2new.
1559 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
1560 * \param [in] new2OldBg - pointer to the beginning of a permutation array that gives a
1561 * tuple index in \a this array to fill the i-th tuple in the new array.
1562 * \param [in] new2OldEnd - specifies the end of the permutation array that starts at
1563 * \a new2OldBg, so that pointer to a tuple index (\a pi) varies as this:
1564 * \a new2OldBg <= \a pi < \a new2OldEnd.
1565 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1566 * is to delete using decrRef() as it is no more needed.
1568 DataArrayDouble *DataArrayDouble::selectByTupleId(const int *new2OldBg, const int *new2OldEnd) const
1571 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
1572 int nbComp=getNumberOfComponents();
1573 ret->alloc((int)std::distance(new2OldBg,new2OldEnd),nbComp);
1574 ret->copyStringInfoFrom(*this);
1575 double *pt=ret->getPointer();
1576 const double *srcPt=getConstPointer();
1578 for(const int *w=new2OldBg;w!=new2OldEnd;w++,i++)
1579 std::copy(srcPt+(*w)*nbComp,srcPt+((*w)+1)*nbComp,pt+i*nbComp);
1580 ret->copyStringInfoFrom(*this);
1585 * Returns a shorten and permuted copy of \a this array. The new DataArrayDouble is
1586 * of size \a new2OldEnd - \a new2OldBg and it's values are permuted as required by
1587 * \a new2OldBg array.
1588 * The values are permuted so that \c new[ i ] = \c old[ \a new2OldBg[ i ]].
1589 * This method is equivalent to renumberAndReduce() except that convention in input is
1590 * \c new2old and \b not \c old2new.
1591 * This method is equivalent to selectByTupleId() except that it prevents coping data
1592 * from behind the end of \a this array.
1593 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
1594 * \param [in] new2OldBg - pointer to the beginning of a permutation array that gives a
1595 * tuple index in \a this array to fill the i-th tuple in the new array.
1596 * \param [in] new2OldEnd - specifies the end of the permutation array that starts at
1597 * \a new2OldBg, so that pointer to a tuple index (\a pi) varies as this:
1598 * \a new2OldBg <= \a pi < \a new2OldEnd.
1599 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1600 * is to delete using decrRef() as it is no more needed.
1601 * \throw If \a new2OldEnd - \a new2OldBg > \a this->getNumberOfTuples().
1603 DataArrayDouble *DataArrayDouble::selectByTupleIdSafe(const int *new2OldBg, const int *new2OldEnd) const
1606 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
1607 int nbComp=getNumberOfComponents();
1608 int oldNbOfTuples=getNumberOfTuples();
1609 ret->alloc((int)std::distance(new2OldBg,new2OldEnd),nbComp);
1610 ret->copyStringInfoFrom(*this);
1611 double *pt=ret->getPointer();
1612 const double *srcPt=getConstPointer();
1614 for(const int *w=new2OldBg;w!=new2OldEnd;w++,i++)
1615 if(*w>=0 && *w<oldNbOfTuples)
1616 std::copy(srcPt+(*w)*nbComp,srcPt+((*w)+1)*nbComp,pt+i*nbComp);
1618 throw INTERP_KERNEL::Exception("DataArrayDouble::selectByTupleIdSafe : some ids has been detected to be out of [0,this->getNumberOfTuples) !");
1619 ret->copyStringInfoFrom(*this);
1624 * Returns a shorten copy of \a this array. The new DataArrayDouble contains every
1625 * (\a bg + \c i * \a step)-th tuple of \a this array located before the \a end2-th
1626 * tuple. Indices of the selected tuples are the same as ones returned by the Python
1627 * command \c range( \a bg, \a end2, \a step ).
1628 * This method is equivalent to selectByTupleIdSafe() except that the input array is
1629 * not constructed explicitly.
1630 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
1631 * \param [in] bg - index of the first tuple to copy from \a this array.
1632 * \param [in] end2 - index of the tuple before which the tuples to copy are located.
1633 * \param [in] step - index increment to get index of the next tuple to copy.
1634 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1635 * is to delete using decrRef() as it is no more needed.
1636 * \sa DataArrayDouble::substr.
1638 DataArrayDouble *DataArrayDouble::selectByTupleId2(int bg, int end2, int step) const
1641 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
1642 int nbComp=getNumberOfComponents();
1643 int newNbOfTuples=GetNumberOfItemGivenBESRelative(bg,end2,step,"DataArrayDouble::selectByTupleId2 : ");
1644 ret->alloc(newNbOfTuples,nbComp);
1645 double *pt=ret->getPointer();
1646 const double *srcPt=getConstPointer()+bg*nbComp;
1647 for(int i=0;i<newNbOfTuples;i++,srcPt+=step*nbComp)
1648 std::copy(srcPt,srcPt+nbComp,pt+i*nbComp);
1649 ret->copyStringInfoFrom(*this);
1654 * Returns a shorten copy of \a this array. The new DataArrayDouble contains ranges
1655 * of tuples specified by \a ranges parameter.
1656 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
1657 * \param [in] ranges - std::vector of std::pair's each of which defines a range
1658 * of tuples in [\c begin,\c end) format.
1659 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1660 * is to delete using decrRef() as it is no more needed.
1661 * \throw If \a end < \a begin.
1662 * \throw If \a end > \a this->getNumberOfTuples().
1663 * \throw If \a this is not allocated.
1665 DataArray *DataArrayDouble::selectByTupleRanges(const std::vector<std::pair<int,int> >& ranges) const
1668 int nbOfComp=getNumberOfComponents();
1669 int nbOfTuplesThis=getNumberOfTuples();
1672 DataArrayDouble *ret=DataArrayDouble::New();
1673 ret->alloc(0,nbOfComp);
1674 ret->copyStringInfoFrom(*this);
1677 int ref=ranges.front().first;
1679 bool isIncreasing=true;
1680 for(std::vector<std::pair<int,int> >::const_iterator it=ranges.begin();it!=ranges.end();it++)
1682 if((*it).first<=(*it).second)
1684 if((*it).first>=0 && (*it).second<=nbOfTuplesThis)
1686 nbOfTuples+=(*it).second-(*it).first;
1688 isIncreasing=ref<=(*it).first;
1693 std::ostringstream oss; oss << "DataArrayDouble::selectByTupleRanges : on range #" << std::distance(ranges.begin(),it);
1694 oss << " (" << (*it).first << "," << (*it).second << ") is greater than number of tuples of this :" << nbOfTuples << " !";
1695 throw INTERP_KERNEL::Exception(oss.str().c_str());
1700 std::ostringstream oss; oss << "DataArrayDouble::selectByTupleRanges : on range #" << std::distance(ranges.begin(),it);
1701 oss << " (" << (*it).first << "," << (*it).second << ") end is before begin !";
1702 throw INTERP_KERNEL::Exception(oss.str().c_str());
1705 if(isIncreasing && nbOfTuplesThis==nbOfTuples)
1707 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
1708 ret->alloc(nbOfTuples,nbOfComp);
1709 ret->copyStringInfoFrom(*this);
1710 const double *src=getConstPointer();
1711 double *work=ret->getPointer();
1712 for(std::vector<std::pair<int,int> >::const_iterator it=ranges.begin();it!=ranges.end();it++)
1713 work=std::copy(src+(*it).first*nbOfComp,src+(*it).second*nbOfComp,work);
1718 * Returns a shorten copy of \a this array. The new DataArrayDouble contains all
1719 * tuples starting from the \a tupleIdBg-th tuple and including all tuples located before
1720 * the \a tupleIdEnd-th one. This methods has a similar behavior as std::string::substr().
1721 * This method is a specialization of selectByTupleId2().
1722 * \param [in] tupleIdBg - index of the first tuple to copy from \a this array.
1723 * \param [in] tupleIdEnd - index of the tuple before which the tuples to copy are located.
1724 * If \a tupleIdEnd == -1, all the tuples till the end of \a this array are copied.
1725 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1726 * is to delete using decrRef() as it is no more needed.
1727 * \throw If \a tupleIdBg < 0.
1728 * \throw If \a tupleIdBg > \a this->getNumberOfTuples().
1729 \throw If \a tupleIdEnd != -1 && \a tupleIdEnd < \a this->getNumberOfTuples().
1730 * \sa DataArrayDouble::selectByTupleId2
1732 DataArrayDouble *DataArrayDouble::substr(int tupleIdBg, int tupleIdEnd) const
1735 int nbt=getNumberOfTuples();
1737 throw INTERP_KERNEL::Exception("DataArrayDouble::substr : The tupleIdBg parameter must be greater than 0 !");
1739 throw INTERP_KERNEL::Exception("DataArrayDouble::substr : The tupleIdBg parameter is greater than number of tuples !");
1740 int trueEnd=tupleIdEnd;
1744 throw INTERP_KERNEL::Exception("DataArrayDouble::substr : The tupleIdBg parameter is greater or equal than number of tuples !");
1748 int nbComp=getNumberOfComponents();
1749 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
1750 ret->alloc(trueEnd-tupleIdBg,nbComp);
1751 ret->copyStringInfoFrom(*this);
1752 std::copy(getConstPointer()+tupleIdBg*nbComp,getConstPointer()+trueEnd*nbComp,ret->getPointer());
1757 * Returns a shorten or extended copy of \a this array. If \a newNbOfComp is less
1758 * than \a this->getNumberOfComponents() then the result array is shorten as each tuple
1759 * is truncated to have \a newNbOfComp components, keeping first components. If \a
1760 * newNbOfComp is more than \a this->getNumberOfComponents() then the result array is
1761 * expanded as each tuple is populated with \a dftValue to have \a newNbOfComp
1763 * \param [in] newNbOfComp - number of components for the new array to have.
1764 * \param [in] dftValue - value assigned to new values added to the new array.
1765 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1766 * is to delete using decrRef() as it is no more needed.
1767 * \throw If \a this is not allocated.
1769 DataArrayDouble *DataArrayDouble::changeNbOfComponents(int newNbOfComp, double dftValue) const
1772 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
1773 ret->alloc(getNumberOfTuples(),newNbOfComp);
1774 const double *oldc=getConstPointer();
1775 double *nc=ret->getPointer();
1776 int nbOfTuples=getNumberOfTuples();
1777 int oldNbOfComp=getNumberOfComponents();
1778 int dim=std::min(oldNbOfComp,newNbOfComp);
1779 for(int i=0;i<nbOfTuples;i++)
1783 nc[newNbOfComp*i+j]=oldc[i*oldNbOfComp+j];
1784 for(;j<newNbOfComp;j++)
1785 nc[newNbOfComp*i+j]=dftValue;
1787 ret->setName(getName().c_str());
1788 for(int i=0;i<dim;i++)
1789 ret->setInfoOnComponent(i,getInfoOnComponent(i).c_str());
1790 ret->setName(getName().c_str());
1795 * Changes the number of components within \a this array so that its raw data **does
1796 * not** change, instead splitting this data into tuples changes.
1797 * \warning This method erases all (name and unit) component info set before!
1798 * \param [in] newNbOfComp - number of components for \a this array to have.
1799 * \throw If \a this is not allocated
1800 * \throw If getNbOfElems() % \a newNbOfCompo != 0.
1801 * \throw If \a newNbOfCompo is lower than 1.
1802 * \throw If the rearrange method would lead to a number of tuples higher than 2147483647 (maximal capacity of int32 !).
1803 * \warning This method erases all (name and unit) component info set before!
1805 void DataArrayDouble::rearrange(int newNbOfCompo)
1809 throw INTERP_KERNEL::Exception("DataArrayDouble::rearrange : input newNbOfCompo must be > 0 !");
1810 std::size_t nbOfElems=getNbOfElems();
1811 if(nbOfElems%newNbOfCompo!=0)
1812 throw INTERP_KERNEL::Exception("DataArrayDouble::rearrange : nbOfElems%newNbOfCompo!=0 !");
1813 if(nbOfElems/newNbOfCompo>(std::size_t)std::numeric_limits<int>::max())
1814 throw INTERP_KERNEL::Exception("DataArrayDouble::rearrange : the rearrangement leads to too high number of tuples (> 2147483647) !");
1815 _info_on_compo.clear();
1816 _info_on_compo.resize(newNbOfCompo);
1821 * Changes the number of components within \a this array to be equal to its number
1822 * of tuples, and inversely its number of tuples to become equal to its number of
1823 * components. So that its raw data **does not** change, instead splitting this
1824 * data into tuples changes.
1825 * \warning This method erases all (name and unit) component info set before!
1826 * \warning Do not confuse this method with fromNoInterlace() and toNoInterlace()!
1827 * \throw If \a this is not allocated.
1830 void DataArrayDouble::transpose()
1833 int nbOfTuples=getNumberOfTuples();
1834 rearrange(nbOfTuples);
1838 * Returns a copy of \a this array composed of selected components.
1839 * The new DataArrayDouble has the same number of tuples but includes components
1840 * specified by \a compoIds parameter. So that getNbOfElems() of the result array
1841 * can be either less, same or more than \a this->getNbOfElems().
1842 * \param [in] compoIds - sequence of zero based indices of components to include
1843 * into the new array.
1844 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1845 * is to delete using decrRef() as it is no more needed.
1846 * \throw If \a this is not allocated.
1847 * \throw If a component index (\a i) is not valid:
1848 * \a i < 0 || \a i >= \a this->getNumberOfComponents().
1850 * \ref py_mcdataarraydouble_KeepSelectedComponents "Here is a Python example".
1852 DataArray *DataArrayDouble::keepSelectedComponents(const std::vector<int>& compoIds) const
1855 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret(DataArrayDouble::New());
1856 std::size_t newNbOfCompo=compoIds.size();
1857 int oldNbOfCompo=getNumberOfComponents();
1858 for(std::vector<int>::const_iterator it=compoIds.begin();it!=compoIds.end();it++)
1859 if((*it)<0 || (*it)>=oldNbOfCompo)
1861 std::ostringstream oss; oss << "DataArrayDouble::keepSelectedComponents : invalid requested component : " << *it << " whereas it should be in [0," << oldNbOfCompo << ") !";
1862 throw INTERP_KERNEL::Exception(oss.str().c_str());
1864 int nbOfTuples=getNumberOfTuples();
1865 ret->alloc(nbOfTuples,(int)newNbOfCompo);
1866 ret->copyPartOfStringInfoFrom(*this,compoIds);
1867 const double *oldc=getConstPointer();
1868 double *nc=ret->getPointer();
1869 for(int i=0;i<nbOfTuples;i++)
1870 for(std::size_t j=0;j<newNbOfCompo;j++,nc++)
1871 *nc=oldc[i*oldNbOfCompo+compoIds[j]];
1876 * Appends components of another array to components of \a this one, tuple by tuple.
1877 * So that the number of tuples of \a this array remains the same and the number of
1878 * components increases.
1879 * \param [in] other - the DataArrayDouble to append to \a this one.
1880 * \throw If \a this is not allocated.
1881 * \throw If \a this and \a other arrays have different number of tuples.
1883 * \ref cpp_mcdataarraydouble_meldwith "Here is a C++ example".
1885 * \ref py_mcdataarraydouble_meldwith "Here is a Python example".
1887 void DataArrayDouble::meldWith(const DataArrayDouble *other)
1890 other->checkAllocated();
1891 int nbOfTuples=getNumberOfTuples();
1892 if(nbOfTuples!=other->getNumberOfTuples())
1893 throw INTERP_KERNEL::Exception("DataArrayDouble::meldWith : mismatch of number of tuples !");
1894 int nbOfComp1=getNumberOfComponents();
1895 int nbOfComp2=other->getNumberOfComponents();
1896 double *newArr=(double *)malloc((nbOfTuples*(nbOfComp1+nbOfComp2))*sizeof(double));
1898 const double *inp1=getConstPointer();
1899 const double *inp2=other->getConstPointer();
1900 for(int i=0;i<nbOfTuples;i++,inp1+=nbOfComp1,inp2+=nbOfComp2)
1902 w=std::copy(inp1,inp1+nbOfComp1,w);
1903 w=std::copy(inp2,inp2+nbOfComp2,w);
1905 useArray(newArr,true,C_DEALLOC,nbOfTuples,nbOfComp1+nbOfComp2);
1906 std::vector<int> compIds(nbOfComp2);
1907 for(int i=0;i<nbOfComp2;i++)
1908 compIds[i]=nbOfComp1+i;
1909 copyPartOfStringInfoFrom2(compIds,*other);
1913 * This method checks that all tuples in \a other are in \a this.
1914 * If true, the output param \a tupleIds contains the tuples ids of \a this that correspond to tupes in \a this.
1915 * 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.
1917 * \param [in] other - the array having the same number of components than \a this.
1918 * \param [out] tupleIds - the tuple ids containing the same number of tuples than \a other has.
1919 * \sa DataArrayDouble::findCommonTuples
1921 bool DataArrayDouble::areIncludedInMe(const DataArrayDouble *other, double prec, DataArrayInt *&tupleIds) const
1924 throw INTERP_KERNEL::Exception("DataArrayDouble::areIncludedInMe : input array is NULL !");
1925 checkAllocated(); other->checkAllocated();
1926 if(getNumberOfComponents()!=other->getNumberOfComponents())
1927 throw INTERP_KERNEL::Exception("DataArrayDouble::areIncludedInMe : the number of components does not match !");
1928 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> a=DataArrayDouble::Aggregate(this,other);
1929 DataArrayInt *c=0,*ci=0;
1930 a->findCommonTuples(prec,getNumberOfTuples(),c,ci);
1931 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> cSafe(c),ciSafe(ci);
1932 int newNbOfTuples=-1;
1933 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ids=DataArrayInt::BuildOld2NewArrayFromSurjectiveFormat2(a->getNumberOfTuples(),c->begin(),ci->begin(),ci->end(),newNbOfTuples);
1934 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret1=ids->selectByTupleId2(getNumberOfTuples(),a->getNumberOfTuples(),1);
1935 tupleIds=ret1.retn();
1936 return newNbOfTuples==getNumberOfTuples();
1940 * Searches for tuples coincident within \a prec tolerance. Each tuple is considered
1941 * as coordinates of a point in getNumberOfComponents()-dimensional space. The
1942 * distance separating two points is computed with the infinite norm.
1944 * Indices of coincident tuples are stored in output arrays.
1945 * A pair of arrays (\a comm, \a commIndex) is called "Surjective Format 2".
1947 * This method is typically used by MEDCouplingPointSet::findCommonNodes() and
1948 * MEDCouplingUMesh::mergeNodes().
1949 * \param [in] prec - minimal absolute distance between two tuples (infinite norm) at which they are
1950 * considered not coincident.
1951 * \param [in] limitTupleId - limit tuple id. If all tuples within a group of coincident
1952 * tuples have id strictly lower than \a limitTupleId then they are not returned.
1953 * \param [out] comm - the array holding ids (== indices) of coincident tuples.
1954 * \a comm->getNumberOfComponents() == 1.
1955 * \a comm->getNumberOfTuples() == \a commIndex->back().
1956 * \param [out] commIndex - the array dividing all indices stored in \a comm into
1957 * groups of (indices of) coincident tuples. Its every value is a tuple
1958 * index where a next group of tuples begins. For example the second
1959 * group of tuples in \a comm is described by following range of indices:
1960 * [ \a commIndex[1], \a commIndex[2] ). \a commIndex->getNumberOfTuples()-1
1961 * gives the number of groups of coincident tuples.
1962 * \throw If \a this is not allocated.
1963 * \throw If the number of components is not in [1,2,3].
1965 * \ref cpp_mcdataarraydouble_findcommontuples "Here is a C++ example".
1967 * \ref py_mcdataarraydouble_findcommontuples "Here is a Python example".
1968 * \sa DataArrayInt::BuildOld2NewArrayFromSurjectiveFormat2(), DataArrayDouble::areIncludedInMe
1970 void DataArrayDouble::findCommonTuples(double prec, int limitTupleId, DataArrayInt *&comm, DataArrayInt *&commIndex) const
1973 int nbOfCompo=getNumberOfComponents();
1974 if ((nbOfCompo<1) || (nbOfCompo>3)) //test before work
1975 throw INTERP_KERNEL::Exception("DataArrayDouble::findCommonTuples : Unexpected spacedim of coords. Must be 1, 2 or 3.");
1977 int nbOfTuples=getNumberOfTuples();
1979 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> c(DataArrayInt::New()),cI(DataArrayInt::New()); c->alloc(0,1); cI->pushBackSilent(0);
1983 findCommonTuplesAlg<3>(begin(),nbOfTuples,limitTupleId,prec,c,cI);
1986 findCommonTuplesAlg<2>(begin(),nbOfTuples,limitTupleId,prec,c,cI);
1989 findCommonTuplesAlg<1>(begin(),nbOfTuples,limitTupleId,prec,c,cI);
1992 throw INTERP_KERNEL::Exception("DataArrayDouble::findCommonTuples : nb of components managed are 1,2 and 3 ! not implemented for other number of components !");
1995 commIndex=cI.retn();
2000 * \param [in] nbTimes specifies the nb of times each tuples in \a this will be duplicated contiguouly in returned DataArrayDouble instance.
2001 * \a nbTimes should be at least equal to 1.
2002 * \return a newly allocated DataArrayDouble having one component and number of tuples equal to \a nbTimes * \c this->getNumberOfTuples.
2003 * \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.
2005 DataArrayDouble *DataArrayDouble::duplicateEachTupleNTimes(int nbTimes) const
2008 if(getNumberOfComponents()!=1)
2009 throw INTERP_KERNEL::Exception("DataArrayDouble::duplicateEachTupleNTimes : this should have only one component !");
2011 throw INTERP_KERNEL::Exception("DataArrayDouble::duplicateEachTupleNTimes : nb times should be >= 1 !");
2012 int nbTuples=getNumberOfTuples();
2013 const double *inPtr=getConstPointer();
2014 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New(); ret->alloc(nbTimes*nbTuples,1);
2015 double *retPtr=ret->getPointer();
2016 for(int i=0;i<nbTuples;i++,inPtr++)
2019 for(int j=0;j<nbTimes;j++,retPtr++)
2022 ret->copyStringInfoFrom(*this);
2027 * This methods returns the minimal distance between the two set of points \a this and \a other.
2028 * So \a this and \a other have to have the same number of components. If not an INTERP_KERNEL::Exception will be thrown.
2029 * This method works only if number of components of \a this (equal to those of \a other) is in 1, 2 or 3.
2031 * \param [out] thisTupleId the tuple id in \a this corresponding to the returned minimal distance
2032 * \param [out] otherTupleId the tuple id in \a other corresponding to the returned minimal distance
2033 * \return the minimal distance between the two set of points \a this and \a other.
2034 * \sa DataArrayDouble::findClosestTupleId
2036 double DataArrayDouble::minimalDistanceTo(const DataArrayDouble *other, int& thisTupleId, int& otherTupleId) const
2038 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> part1=findClosestTupleId(other);
2039 int nbOfCompo(getNumberOfComponents());
2040 int otherNbTuples(other->getNumberOfTuples());
2041 const double *thisPt(begin()),*otherPt(other->begin());
2042 const int *part1Pt(part1->begin());
2043 double ret=std::numeric_limits<double>::max();
2044 for(int i=0;i<otherNbTuples;i++,part1Pt++,otherPt+=nbOfCompo)
2047 for(int j=0;j<nbOfCompo;j++)
2048 tmp+=(otherPt[j]-thisPt[nbOfCompo*(*part1Pt)+j])*(otherPt[j]-thisPt[nbOfCompo*(*part1Pt)+j]);
2050 { ret=tmp; thisTupleId=*part1Pt; otherTupleId=i; }
2056 * This methods returns for each tuple in \a other which tuple in \a this is the closest.
2057 * So \a this and \a other have to have the same number of components. If not an INTERP_KERNEL::Exception will be thrown.
2058 * This method works only if number of components of \a this (equal to those of \a other) is in 1, 2 or 3.
2060 * \return a newly allocated (new object to be dealt by the caller) DataArrayInt having \c other->getNumberOfTuples() tuples and one components.
2061 * \sa DataArrayDouble::minimalDistanceTo
2063 DataArrayInt *DataArrayDouble::findClosestTupleId(const DataArrayDouble *other) const
2066 throw INTERP_KERNEL::Exception("DataArrayDouble::findClosestTupleId : other instance is NULL !");
2067 checkAllocated(); other->checkAllocated();
2068 int nbOfCompo=getNumberOfComponents();
2069 if(nbOfCompo!=other->getNumberOfComponents())
2071 std::ostringstream oss; oss << "DataArrayDouble::findClosestTupleId : number of components in this is " << nbOfCompo;
2072 oss << ", whereas number of components in other is " << other->getNumberOfComponents() << "! Should be equal !";
2073 throw INTERP_KERNEL::Exception(oss.str().c_str());
2075 int nbOfTuples=other->getNumberOfTuples();
2076 int thisNbOfTuples=getNumberOfTuples();
2077 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(nbOfTuples,1);
2079 getMinMaxPerComponent(bounds);
2084 double xDelta(fabs(bounds[1]-bounds[0])),yDelta(fabs(bounds[3]-bounds[2])),zDelta(fabs(bounds[5]-bounds[4]));
2085 double delta=std::max(xDelta,yDelta); delta=std::max(delta,zDelta);
2086 double characSize=pow((delta*delta*delta)/((double)thisNbOfTuples),1./3.);
2087 BBTreePts<3,int> myTree(begin(),0,0,getNumberOfTuples(),characSize*1e-12);
2088 FindClosestTupleIdAlg<3>(myTree,3.*characSize*characSize,other->begin(),nbOfTuples,begin(),thisNbOfTuples,ret->getPointer());
2093 double xDelta(fabs(bounds[1]-bounds[0])),yDelta(fabs(bounds[3]-bounds[2]));
2094 double delta=std::max(xDelta,yDelta);
2095 double characSize=sqrt(delta/(double)thisNbOfTuples);
2096 BBTreePts<2,int> myTree(begin(),0,0,getNumberOfTuples(),characSize*1e-12);
2097 FindClosestTupleIdAlg<2>(myTree,2.*characSize*characSize,other->begin(),nbOfTuples,begin(),thisNbOfTuples,ret->getPointer());
2102 double characSize=fabs(bounds[1]-bounds[0])/thisNbOfTuples;
2103 BBTreePts<1,int> myTree(begin(),0,0,getNumberOfTuples(),characSize*1e-12);
2104 FindClosestTupleIdAlg<1>(myTree,1.*characSize*characSize,other->begin(),nbOfTuples,begin(),thisNbOfTuples,ret->getPointer());
2108 throw INTERP_KERNEL::Exception("Unexpected spacedim of coords for findClosestTupleId. Must be 1, 2 or 3.");
2114 * This method expects that \a this and \a otherBBoxFrmt arrays are bounding box arrays ( as the output of MEDCouplingPointSet::getBoundingBoxForBBTree method ).
2115 * 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
2116 * how many bounding boxes in \a otherBBoxFrmt.
2117 * So, this method expects that \a this and \a otherBBoxFrmt have the same number of components.
2119 * \param [in] otherBBoxFrmt - It is an array .
2120 * \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.
2121 * \sa MEDCouplingPointSet::getBoundingBoxForBBTree
2122 * \throw If \a this and \a otherBBoxFrmt have not the same number of components.
2123 * \throw If \a this and \a otherBBoxFrmt number of components is not even (BBox format).
2125 DataArrayInt *DataArrayDouble::computeNbOfInteractionsWith(const DataArrayDouble *otherBBoxFrmt, double eps) const
2128 throw INTERP_KERNEL::Exception("DataArrayDouble::computeNbOfInteractionsWith : input array is NULL !");
2129 if(!isAllocated() || !otherBBoxFrmt->isAllocated())
2130 throw INTERP_KERNEL::Exception("DataArrayDouble::computeNbOfInteractionsWith : this and input array must be allocated !");
2131 int nbOfComp(getNumberOfComponents()),nbOfTuples(getNumberOfTuples());
2132 if(nbOfComp!=otherBBoxFrmt->getNumberOfComponents())
2134 std::ostringstream oss; oss << "DataArrayDouble::computeNbOfInteractionsWith : this number of components (" << nbOfComp << ") must be equal to the number of components of input array (" << otherBBoxFrmt->getNumberOfComponents() << ") !";
2135 throw INTERP_KERNEL::Exception(oss.str().c_str());
2139 std::ostringstream oss; oss << "DataArrayDouble::computeNbOfInteractionsWith : Number of components (" << nbOfComp << ") is not even ! It should be to be compatible with bbox format !";
2140 throw INTERP_KERNEL::Exception(oss.str().c_str());
2142 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(nbOfTuples,1);
2143 const double *thisBBPtr(begin());
2144 int *retPtr(ret->getPointer());
2149 BBTree<3,int> bbt(otherBBoxFrmt->begin(),0,0,otherBBoxFrmt->getNumberOfTuples(),eps);
2150 for(int i=0;i<nbOfTuples;i++,retPtr++,thisBBPtr+=nbOfComp)
2151 *retPtr=bbt.getNbOfIntersectingElems(thisBBPtr);
2156 BBTree<2,int> bbt(otherBBoxFrmt->begin(),0,0,otherBBoxFrmt->getNumberOfTuples(),eps);
2157 for(int i=0;i<nbOfTuples;i++,retPtr++,thisBBPtr+=nbOfComp)
2158 *retPtr=bbt.getNbOfIntersectingElems(thisBBPtr);
2163 BBTree<1,int> bbt(otherBBoxFrmt->begin(),0,0,otherBBoxFrmt->getNumberOfTuples(),eps);
2164 for(int i=0;i<nbOfTuples;i++,retPtr++,thisBBPtr+=nbOfComp)
2165 *retPtr=bbt.getNbOfIntersectingElems(thisBBPtr);
2169 throw INTERP_KERNEL::Exception("DataArrayDouble::computeNbOfInteractionsWith : space dimension supported are [1,2,3] !");
2176 * Returns a copy of \a this array by excluding coincident tuples. Each tuple is
2177 * considered as coordinates of a point in getNumberOfComponents()-dimensional
2178 * space. The distance between tuples is computed using norm2. If several tuples are
2179 * not far each from other than \a prec, only one of them remains in the result
2180 * array. The order of tuples in the result array is same as in \a this one except
2181 * that coincident tuples are excluded.
2182 * \param [in] prec - minimal absolute distance between two tuples at which they are
2183 * considered not coincident.
2184 * \param [in] limitTupleId - limit tuple id. If all tuples within a group of coincident
2185 * tuples have id strictly lower than \a limitTupleId then they are not excluded.
2186 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
2187 * is to delete using decrRef() as it is no more needed.
2188 * \throw If \a this is not allocated.
2189 * \throw If the number of components is not in [1,2,3].
2191 * \ref py_mcdataarraydouble_getdifferentvalues "Here is a Python example".
2193 DataArrayDouble *DataArrayDouble::getDifferentValues(double prec, int limitTupleId) const
2196 DataArrayInt *c0=0,*cI0=0;
2197 findCommonTuples(prec,limitTupleId,c0,cI0);
2198 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> c(c0),cI(cI0);
2199 int newNbOfTuples=-1;
2200 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> o2n=DataArrayInt::BuildOld2NewArrayFromSurjectiveFormat2(getNumberOfTuples(),c0->begin(),cI0->begin(),cI0->end(),newNbOfTuples);
2201 return renumberAndReduce(o2n->getConstPointer(),newNbOfTuples);
2205 * Copy all components in a specified order from another DataArrayDouble.
2206 * Both numerical and textual data is copied. The number of tuples in \a this and
2207 * the other array can be different.
2208 * \param [in] a - the array to copy data from.
2209 * \param [in] compoIds - sequence of zero based indices of components, data of which is
2211 * \throw If \a a is NULL.
2212 * \throw If \a compoIds.size() != \a a->getNumberOfComponents().
2213 * \throw If \a compoIds[i] < 0 or \a compoIds[i] > \a this->getNumberOfComponents().
2215 * \ref py_mcdataarraydouble_setselectedcomponents "Here is a Python example".
2217 void DataArrayDouble::setSelectedComponents(const DataArrayDouble *a, const std::vector<int>& compoIds)
2220 throw INTERP_KERNEL::Exception("DataArrayDouble::setSelectedComponents : input DataArrayDouble is NULL !");
2222 copyPartOfStringInfoFrom2(compoIds,*a);
2223 std::size_t partOfCompoSz=compoIds.size();
2224 int nbOfCompo=getNumberOfComponents();
2225 int nbOfTuples=std::min(getNumberOfTuples(),a->getNumberOfTuples());
2226 const double *ac=a->getConstPointer();
2227 double *nc=getPointer();
2228 for(int i=0;i<nbOfTuples;i++)
2229 for(std::size_t j=0;j<partOfCompoSz;j++,ac++)
2230 nc[nbOfCompo*i+compoIds[j]]=*ac;
2234 * Copy all values from another DataArrayDouble into specified tuples and components
2235 * of \a this array. Textual data is not copied.
2236 * The tree parameters defining set of indices of tuples and components are similar to
2237 * the tree parameters of the Python function \c range(\c start,\c stop,\c step).
2238 * \param [in] a - the array to copy values from.
2239 * \param [in] bgTuples - index of the first tuple of \a this array to assign values to.
2240 * \param [in] endTuples - index of the tuple before which the tuples to assign to
2242 * \param [in] stepTuples - index increment to get index of the next tuple to assign to.
2243 * \param [in] bgComp - index of the first component of \a this array to assign values to.
2244 * \param [in] endComp - index of the component before which the components to assign
2246 * \param [in] stepComp - index increment to get index of the next component to assign to.
2247 * \param [in] strictCompoCompare - if \a true (by default), then \a a->getNumberOfComponents()
2248 * must be equal to the number of columns to assign to, else an
2249 * exception is thrown; if \a false, then it is only required that \a
2250 * a->getNbOfElems() equals to number of values to assign to (this condition
2251 * must be respected even if \a strictCompoCompare is \a true). The number of
2252 * values to assign to is given by following Python expression:
2253 * \a nbTargetValues =
2254 * \c len(\c range(\a bgTuples,\a endTuples,\a stepTuples)) *
2255 * \c len(\c range(\a bgComp,\a endComp,\a stepComp)).
2256 * \throw If \a a is NULL.
2257 * \throw If \a a is not allocated.
2258 * \throw If \a this is not allocated.
2259 * \throw If parameters specifying tuples and components to assign to do not give a
2260 * non-empty range of increasing indices.
2261 * \throw If \a a->getNbOfElems() != \a nbTargetValues.
2262 * \throw If \a strictCompoCompare == \a true && \a a->getNumberOfComponents() !=
2263 * \c len(\c range(\a bgComp,\a endComp,\a stepComp)).
2265 * \ref py_mcdataarraydouble_setpartofvalues1 "Here is a Python example".
2267 void DataArrayDouble::setPartOfValues1(const DataArrayDouble *a, int bgTuples, int endTuples, int stepTuples, int bgComp, int endComp, int stepComp, bool strictCompoCompare)
2270 throw INTERP_KERNEL::Exception("DataArrayDouble::setPartOfValues1 : input DataArrayDouble is NULL !");
2271 const char msg[]="DataArrayDouble::setPartOfValues1";
2273 a->checkAllocated();
2274 int newNbOfTuples=DataArray::GetNumberOfItemGivenBES(bgTuples,endTuples,stepTuples,msg);
2275 int newNbOfComp=DataArray::GetNumberOfItemGivenBES(bgComp,endComp,stepComp,msg);
2276 int nbComp=getNumberOfComponents();
2277 int nbOfTuples=getNumberOfTuples();
2278 DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
2279 DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
2280 bool assignTech=true;
2281 if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
2283 if(strictCompoCompare)
2284 a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
2288 a->checkNbOfTuplesAndComp(1,newNbOfComp,msg);
2291 const double *srcPt=a->getConstPointer();
2292 double *pt=getPointer()+bgTuples*nbComp+bgComp;
2295 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
2296 for(int j=0;j<newNbOfComp;j++,srcPt++)
2297 pt[j*stepComp]=*srcPt;
2301 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
2303 const double *srcPt2=srcPt;
2304 for(int j=0;j<newNbOfComp;j++,srcPt2++)
2305 pt[j*stepComp]=*srcPt2;
2311 * Assign a given value to values at specified tuples and components of \a this array.
2312 * The tree parameters defining set of indices of tuples and components are similar to
2313 * the tree parameters of the Python function \c range(\c start,\c stop,\c step)..
2314 * \param [in] a - the value to assign.
2315 * \param [in] bgTuples - index of the first tuple of \a this array to assign to.
2316 * \param [in] endTuples - index of the tuple before which the tuples to assign to
2318 * \param [in] stepTuples - index increment to get index of the next tuple to assign to.
2319 * \param [in] bgComp - index of the first component of \a this array to assign to.
2320 * \param [in] endComp - index of the component before which the components to assign
2322 * \param [in] stepComp - index increment to get index of the next component to assign to.
2323 * \throw If \a this is not allocated.
2324 * \throw If parameters specifying tuples and components to assign to, do not give a
2325 * non-empty range of increasing indices or indices are out of a valid range
2328 * \ref py_mcdataarraydouble_setpartofvaluessimple1 "Here is a Python example".
2330 void DataArrayDouble::setPartOfValuesSimple1(double a, int bgTuples, int endTuples, int stepTuples, int bgComp, int endComp, int stepComp)
2332 const char msg[]="DataArrayDouble::setPartOfValuesSimple1";
2334 int newNbOfTuples=DataArray::GetNumberOfItemGivenBES(bgTuples,endTuples,stepTuples,msg);
2335 int newNbOfComp=DataArray::GetNumberOfItemGivenBES(bgComp,endComp,stepComp,msg);
2336 int nbComp=getNumberOfComponents();
2337 int nbOfTuples=getNumberOfTuples();
2338 DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
2339 DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
2340 double *pt=getPointer()+bgTuples*nbComp+bgComp;
2341 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
2342 for(int j=0;j<newNbOfComp;j++)
2347 * Copy all values from another DataArrayDouble (\a a) into specified tuples and
2348 * components of \a this array. Textual data is not copied.
2349 * The tuples and components to assign to are defined by C arrays of indices.
2350 * There are two *modes of usage*:
2351 * - If \a a->getNbOfElems() equals to number of values to assign to, then every value
2352 * of \a a is assigned to its own location within \a this array.
2353 * - If \a a includes one tuple, then all values of \a a are assigned to the specified
2354 * components of every specified tuple of \a this array. In this mode it is required
2355 * that \a a->getNumberOfComponents() equals to the number of specified components.
2357 * \param [in] a - the array to copy values from.
2358 * \param [in] bgTuples - pointer to an array of tuple indices of \a this array to
2359 * assign values of \a a to.
2360 * \param [in] endTuples - specifies the end of the array \a bgTuples, so that
2361 * pointer to a tuple index <em>(pi)</em> varies as this:
2362 * \a bgTuples <= \a pi < \a endTuples.
2363 * \param [in] bgComp - pointer to an array of component indices of \a this array to
2364 * assign values of \a a to.
2365 * \param [in] endComp - specifies the end of the array \a bgTuples, so that
2366 * pointer to a component index <em>(pi)</em> varies as this:
2367 * \a bgComp <= \a pi < \a endComp.
2368 * \param [in] strictCompoCompare - this parameter is checked only if the
2369 * *mode of usage* is the first; if it is \a true (default),
2370 * then \a a->getNumberOfComponents() must be equal
2371 * to the number of specified columns, else this is not required.
2372 * \throw If \a a is NULL.
2373 * \throw If \a a is not allocated.
2374 * \throw If \a this is not allocated.
2375 * \throw If any index of tuple/component given by <em>bgTuples / bgComp</em> is
2376 * out of a valid range for \a this array.
2377 * \throw In the first *mode of usage*, if <em>strictCompoCompare == true </em> and
2378 * if <em> a->getNumberOfComponents() != (endComp - bgComp) </em>.
2379 * \throw In the second *mode of usage*, if \a a->getNumberOfTuples() != 1 or
2380 * <em> a->getNumberOfComponents() != (endComp - bgComp)</em>.
2382 * \ref py_mcdataarraydouble_setpartofvalues2 "Here is a Python example".
2384 void DataArrayDouble::setPartOfValues2(const DataArrayDouble *a, const int *bgTuples, const int *endTuples, const int *bgComp, const int *endComp, bool strictCompoCompare)
2387 throw INTERP_KERNEL::Exception("DataArrayDouble::setPartOfValues2 : input DataArrayDouble is NULL !");
2388 const char msg[]="DataArrayDouble::setPartOfValues2";
2390 a->checkAllocated();
2391 int nbComp=getNumberOfComponents();
2392 int nbOfTuples=getNumberOfTuples();
2393 for(const int *z=bgComp;z!=endComp;z++)
2394 DataArray::CheckValueInRange(nbComp,*z,"invalid component id");
2395 int newNbOfTuples=(int)std::distance(bgTuples,endTuples);
2396 int newNbOfComp=(int)std::distance(bgComp,endComp);
2397 bool assignTech=true;
2398 if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
2400 if(strictCompoCompare)
2401 a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
2405 a->checkNbOfTuplesAndComp(1,newNbOfComp,msg);
2408 double *pt=getPointer();
2409 const double *srcPt=a->getConstPointer();
2412 for(const int *w=bgTuples;w!=endTuples;w++)
2414 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
2415 for(const int *z=bgComp;z!=endComp;z++,srcPt++)
2417 pt[(std::size_t)(*w)*nbComp+(*z)]=*srcPt;
2423 for(const int *w=bgTuples;w!=endTuples;w++)
2425 const double *srcPt2=srcPt;
2426 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
2427 for(const int *z=bgComp;z!=endComp;z++,srcPt2++)
2429 pt[(std::size_t)(*w)*nbComp+(*z)]=*srcPt2;
2436 * Assign a given value to values at specified tuples and components of \a this array.
2437 * The tuples and components to assign to are defined by C arrays of indices.
2438 * \param [in] a - the value to assign.
2439 * \param [in] bgTuples - pointer to an array of tuple indices of \a this array to
2441 * \param [in] endTuples - specifies the end of the array \a bgTuples, so that
2442 * pointer to a tuple index (\a pi) varies as this:
2443 * \a bgTuples <= \a pi < \a endTuples.
2444 * \param [in] bgComp - pointer to an array of component indices of \a this array to
2446 * \param [in] endComp - specifies the end of the array \a bgTuples, so that
2447 * pointer to a component index (\a pi) varies as this:
2448 * \a bgComp <= \a pi < \a endComp.
2449 * \throw If \a this is not allocated.
2450 * \throw If any index of tuple/component given by <em>bgTuples / bgComp</em> is
2451 * out of a valid range for \a this array.
2453 * \ref py_mcdataarraydouble_setpartofvaluessimple2 "Here is a Python example".
2455 void DataArrayDouble::setPartOfValuesSimple2(double a, const int *bgTuples, const int *endTuples, const int *bgComp, const int *endComp)
2458 int nbComp=getNumberOfComponents();
2459 int nbOfTuples=getNumberOfTuples();
2460 for(const int *z=bgComp;z!=endComp;z++)
2461 DataArray::CheckValueInRange(nbComp,*z,"invalid component id");
2462 double *pt=getPointer();
2463 for(const int *w=bgTuples;w!=endTuples;w++)
2464 for(const int *z=bgComp;z!=endComp;z++)
2466 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
2467 pt[(std::size_t)(*w)*nbComp+(*z)]=a;
2472 * Copy all values from another DataArrayDouble (\a a) into specified tuples and
2473 * components of \a this array. Textual data is not copied.
2474 * The tuples to assign to are defined by a C array of indices.
2475 * The components to assign to are defined by three values similar to parameters of
2476 * the Python function \c range(\c start,\c stop,\c step).
2477 * There are two *modes of usage*:
2478 * - If \a a->getNbOfElems() equals to number of values to assign to, then every value
2479 * of \a a is assigned to its own location within \a this array.
2480 * - If \a a includes one tuple, then all values of \a a are assigned to the specified
2481 * components of every specified tuple of \a this array. In this mode it is required
2482 * that \a a->getNumberOfComponents() equals to the number of specified components.
2484 * \param [in] a - the array to copy values from.
2485 * \param [in] bgTuples - pointer to an array of tuple indices of \a this array to
2486 * assign values of \a a to.
2487 * \param [in] endTuples - specifies the end of the array \a bgTuples, so that
2488 * pointer to a tuple index <em>(pi)</em> varies as this:
2489 * \a bgTuples <= \a pi < \a endTuples.
2490 * \param [in] bgComp - index of the first component of \a this array to assign to.
2491 * \param [in] endComp - index of the component before which the components to assign
2493 * \param [in] stepComp - index increment to get index of the next component to assign to.
2494 * \param [in] strictCompoCompare - this parameter is checked only in the first
2495 * *mode of usage*; if \a strictCompoCompare is \a true (default),
2496 * then \a a->getNumberOfComponents() must be equal
2497 * to the number of specified columns, else this is not required.
2498 * \throw If \a a is NULL.
2499 * \throw If \a a is not allocated.
2500 * \throw If \a this is not allocated.
2501 * \throw If any index of tuple given by \a bgTuples is out of a valid range for
2503 * \throw In the first *mode of usage*, if <em>strictCompoCompare == true </em> and
2504 * if <em> a->getNumberOfComponents()</em> is unequal to the number of components
2505 * defined by <em>(bgComp,endComp,stepComp)</em>.
2506 * \throw In the second *mode of usage*, if \a a->getNumberOfTuples() != 1 or
2507 * <em> a->getNumberOfComponents()</em> is unequal to the number of components
2508 * defined by <em>(bgComp,endComp,stepComp)</em>.
2509 * \throw If parameters specifying components to assign to, do not give a
2510 * non-empty range of increasing indices or indices are out of a valid range
2513 * \ref py_mcdataarraydouble_setpartofvalues3 "Here is a Python example".
2515 void DataArrayDouble::setPartOfValues3(const DataArrayDouble *a, const int *bgTuples, const int *endTuples, int bgComp, int endComp, int stepComp, bool strictCompoCompare)
2518 throw INTERP_KERNEL::Exception("DataArrayDouble::setPartOfValues3 : input DataArrayDouble is NULL !");
2519 const char msg[]="DataArrayDouble::setPartOfValues3";
2521 a->checkAllocated();
2522 int newNbOfComp=DataArray::GetNumberOfItemGivenBES(bgComp,endComp,stepComp,msg);
2523 int nbComp=getNumberOfComponents();
2524 int nbOfTuples=getNumberOfTuples();
2525 DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
2526 int newNbOfTuples=(int)std::distance(bgTuples,endTuples);
2527 bool assignTech=true;
2528 if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
2530 if(strictCompoCompare)
2531 a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
2535 a->checkNbOfTuplesAndComp(1,newNbOfComp,msg);
2538 double *pt=getPointer()+bgComp;
2539 const double *srcPt=a->getConstPointer();
2542 for(const int *w=bgTuples;w!=endTuples;w++)
2543 for(int j=0;j<newNbOfComp;j++,srcPt++)
2545 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
2546 pt[(std::size_t)(*w)*nbComp+j*stepComp]=*srcPt;
2551 for(const int *w=bgTuples;w!=endTuples;w++)
2553 const double *srcPt2=srcPt;
2554 for(int j=0;j<newNbOfComp;j++,srcPt2++)
2556 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
2557 pt[(std::size_t)(*w)*nbComp+j*stepComp]=*srcPt2;
2564 * Assign a given value to values at specified tuples and components of \a this array.
2565 * The tuples to assign to are defined by a C array of indices.
2566 * The components to assign to are defined by three values similar to parameters of
2567 * the Python function \c range(\c start,\c stop,\c step).
2568 * \param [in] a - the value to assign.
2569 * \param [in] bgTuples - pointer to an array of tuple indices of \a this array to
2571 * \param [in] endTuples - specifies the end of the array \a bgTuples, so that
2572 * pointer to a tuple index <em>(pi)</em> varies as this:
2573 * \a bgTuples <= \a pi < \a endTuples.
2574 * \param [in] bgComp - index of the first component of \a this array to assign to.
2575 * \param [in] endComp - index of the component before which the components to assign
2577 * \param [in] stepComp - index increment to get index of the next component to assign to.
2578 * \throw If \a this is not allocated.
2579 * \throw If any index of tuple given by \a bgTuples is out of a valid range for
2581 * \throw If parameters specifying components to assign to, do not give a
2582 * non-empty range of increasing indices or indices are out of a valid range
2585 * \ref py_mcdataarraydouble_setpartofvaluessimple3 "Here is a Python example".
2587 void DataArrayDouble::setPartOfValuesSimple3(double a, const int *bgTuples, const int *endTuples, int bgComp, int endComp, int stepComp)
2589 const char msg[]="DataArrayDouble::setPartOfValuesSimple3";
2591 int newNbOfComp=DataArray::GetNumberOfItemGivenBES(bgComp,endComp,stepComp,msg);
2592 int nbComp=getNumberOfComponents();
2593 int nbOfTuples=getNumberOfTuples();
2594 DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
2595 double *pt=getPointer()+bgComp;
2596 for(const int *w=bgTuples;w!=endTuples;w++)
2597 for(int j=0;j<newNbOfComp;j++)
2599 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
2600 pt[(std::size_t)(*w)*nbComp+j*stepComp]=a;
2605 * Copy all values from another DataArrayDouble into specified tuples and components
2606 * of \a this array. Textual data is not copied.
2607 * The tree parameters defining set of indices of tuples and components are similar to
2608 * the tree parameters of the Python function \c range(\c start,\c stop,\c step).
2609 * \param [in] a - the array to copy values from.
2610 * \param [in] bgTuples - index of the first tuple of \a this array to assign values to.
2611 * \param [in] endTuples - index of the tuple before which the tuples to assign to
2613 * \param [in] stepTuples - index increment to get index of the next tuple to assign to.
2614 * \param [in] bgComp - pointer to an array of component indices of \a this array to
2616 * \param [in] endComp - specifies the end of the array \a bgTuples, so that
2617 * pointer to a component index (\a pi) varies as this:
2618 * \a bgComp <= \a pi < \a endComp.
2619 * \param [in] strictCompoCompare - if \a true (by default), then \a a->getNumberOfComponents()
2620 * must be equal to the number of columns to assign to, else an
2621 * exception is thrown; if \a false, then it is only required that \a
2622 * a->getNbOfElems() equals to number of values to assign to (this condition
2623 * must be respected even if \a strictCompoCompare is \a true). The number of
2624 * values to assign to is given by following Python expression:
2625 * \a nbTargetValues =
2626 * \c len(\c range(\a bgTuples,\a endTuples,\a stepTuples)) *
2627 * \c len(\c range(\a bgComp,\a endComp,\a stepComp)).
2628 * \throw If \a a is NULL.
2629 * \throw If \a a is not allocated.
2630 * \throw If \a this is not allocated.
2631 * \throw If parameters specifying tuples and components to assign to do not give a
2632 * non-empty range of increasing indices.
2633 * \throw If \a a->getNbOfElems() != \a nbTargetValues.
2634 * \throw If \a strictCompoCompare == \a true && \a a->getNumberOfComponents() !=
2635 * \c len(\c range(\a bgComp,\a endComp,\a stepComp)).
2638 void DataArrayDouble::setPartOfValues4(const DataArrayDouble *a, int bgTuples, int endTuples, int stepTuples, const int *bgComp, const int *endComp, bool strictCompoCompare)
2641 throw INTERP_KERNEL::Exception("DataArrayDouble::setPartOfValues4 : input DataArrayDouble is NULL !");
2642 const char msg[]="DataArrayDouble::setPartOfValues4";
2644 a->checkAllocated();
2645 int newNbOfTuples=DataArray::GetNumberOfItemGivenBES(bgTuples,endTuples,stepTuples,msg);
2646 int newNbOfComp=(int)std::distance(bgComp,endComp);
2647 int nbComp=getNumberOfComponents();
2648 for(const int *z=bgComp;z!=endComp;z++)
2649 DataArray::CheckValueInRange(nbComp,*z,"invalid component id");
2650 int nbOfTuples=getNumberOfTuples();
2651 DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
2652 bool assignTech=true;
2653 if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
2655 if(strictCompoCompare)
2656 a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
2660 a->checkNbOfTuplesAndComp(1,newNbOfComp,msg);
2663 const double *srcPt=a->getConstPointer();
2664 double *pt=getPointer()+bgTuples*nbComp;
2667 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
2668 for(const int *z=bgComp;z!=endComp;z++,srcPt++)
2673 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
2675 const double *srcPt2=srcPt;
2676 for(const int *z=bgComp;z!=endComp;z++,srcPt2++)
2682 void DataArrayDouble::setPartOfValuesSimple4(double a, int bgTuples, int endTuples, int stepTuples, const int *bgComp, const int *endComp)
2684 const char msg[]="DataArrayDouble::setPartOfValuesSimple4";
2686 int newNbOfTuples=DataArray::GetNumberOfItemGivenBES(bgTuples,endTuples,stepTuples,msg);
2687 int nbComp=getNumberOfComponents();
2688 for(const int *z=bgComp;z!=endComp;z++)
2689 DataArray::CheckValueInRange(nbComp,*z,"invalid component id");
2690 int nbOfTuples=getNumberOfTuples();
2691 DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
2692 double *pt=getPointer()+bgTuples*nbComp;
2693 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
2694 for(const int *z=bgComp;z!=endComp;z++)
2699 * Copy some tuples from another DataArrayDouble into specified tuples
2700 * of \a this array. Textual data is not copied. Both arrays must have equal number of
2702 * Both the tuples to assign and the tuples to assign to are defined by a DataArrayInt.
2703 * All components of selected tuples are copied.
2704 * \param [in] a - the array to copy values from.
2705 * \param [in] tuplesSelec - the array specifying both source tuples of \a a and
2706 * target tuples of \a this. \a tuplesSelec has two components, and the
2707 * first component specifies index of the source tuple and the second
2708 * one specifies index of the target tuple.
2709 * \throw If \a this is not allocated.
2710 * \throw If \a a is NULL.
2711 * \throw If \a a is not allocated.
2712 * \throw If \a tuplesSelec is NULL.
2713 * \throw If \a tuplesSelec is not allocated.
2714 * \throw If <em>this->getNumberOfComponents() != a->getNumberOfComponents()</em>.
2715 * \throw If \a tuplesSelec->getNumberOfComponents() != 2.
2716 * \throw If any tuple index given by \a tuplesSelec is out of a valid range for
2717 * the corresponding (\a this or \a a) array.
2719 void DataArrayDouble::setPartOfValuesAdv(const DataArrayDouble *a, const DataArrayInt *tuplesSelec)
2721 if(!a || !tuplesSelec)
2722 throw INTERP_KERNEL::Exception("DataArrayDouble::setPartOfValuesAdv : input DataArrayDouble is NULL !");
2724 a->checkAllocated();
2725 tuplesSelec->checkAllocated();
2726 int nbOfComp=getNumberOfComponents();
2727 if(nbOfComp!=a->getNumberOfComponents())
2728 throw INTERP_KERNEL::Exception("DataArrayDouble::setPartOfValuesAdv : This and a do not have the same number of components !");
2729 if(tuplesSelec->getNumberOfComponents()!=2)
2730 throw INTERP_KERNEL::Exception("DataArrayDouble::setPartOfValuesAdv : Expecting to have a tuple selector DataArrayInt instance with exactly 2 components !");
2731 int thisNt=getNumberOfTuples();
2732 int aNt=a->getNumberOfTuples();
2733 double *valsToSet=getPointer();
2734 const double *valsSrc=a->getConstPointer();
2735 for(const int *tuple=tuplesSelec->begin();tuple!=tuplesSelec->end();tuple+=2)
2737 if(tuple[1]>=0 && tuple[1]<aNt)
2739 if(tuple[0]>=0 && tuple[0]<thisNt)
2740 std::copy(valsSrc+nbOfComp*tuple[1],valsSrc+nbOfComp*(tuple[1]+1),valsToSet+nbOfComp*tuple[0]);
2743 std::ostringstream oss; oss << "DataArrayDouble::setPartOfValuesAdv : Tuple #" << std::distance(tuplesSelec->begin(),tuple)/2;
2744 oss << " of 'tuplesSelec' request of tuple id #" << tuple[0] << " in 'this' ! It should be in [0," << thisNt << ") !";
2745 throw INTERP_KERNEL::Exception(oss.str().c_str());
2750 std::ostringstream oss; oss << "DataArrayDouble::setPartOfValuesAdv : Tuple #" << std::distance(tuplesSelec->begin(),tuple)/2;
2751 oss << " of 'tuplesSelec' request of tuple id #" << tuple[1] << " in 'a' ! It should be in [0," << aNt << ") !";
2752 throw INTERP_KERNEL::Exception(oss.str().c_str());
2758 * Copy some tuples from another DataArrayDouble (\a aBase) into contiguous tuples
2759 * of \a this array. Textual data is not copied. Both arrays must have equal number of
2761 * The tuples to assign to are defined by index of the first tuple, and
2762 * their number is defined by \a tuplesSelec->getNumberOfTuples().
2763 * The tuples to copy are defined by values of a DataArrayInt.
2764 * All components of selected tuples are copied.
2765 * \param [in] tupleIdStart - index of the first tuple of \a this array to assign
2767 * \param [in] aBase - the array to copy values from.
2768 * \param [in] tuplesSelec - the array specifying tuples of \a a to copy.
2769 * \throw If \a this is not allocated.
2770 * \throw If \a aBase is NULL.
2771 * \throw If \a aBase is not allocated.
2772 * \throw If \a tuplesSelec is NULL.
2773 * \throw If \a tuplesSelec is not allocated.
2774 * \throw If <em>this->getNumberOfComponents() != aBase->getNumberOfComponents()</em>.
2775 * \throw If \a tuplesSelec->getNumberOfComponents() != 1.
2776 * \throw If <em>tupleIdStart + tuplesSelec->getNumberOfTuples() > this->getNumberOfTuples().</em>
2777 * \throw If any tuple index given by \a tuplesSelec is out of a valid range for
2780 void DataArrayDouble::setContigPartOfSelectedValues(int tupleIdStart, const DataArray *aBase, const DataArrayInt *tuplesSelec)
2782 if(!aBase || !tuplesSelec)
2783 throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues : input DataArray is NULL !");
2784 const DataArrayDouble *a=dynamic_cast<const DataArrayDouble *>(aBase);
2786 throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues : input DataArray aBase is not a DataArrayDouble !");
2788 a->checkAllocated();
2789 tuplesSelec->checkAllocated();
2790 int nbOfComp=getNumberOfComponents();
2791 if(nbOfComp!=a->getNumberOfComponents())
2792 throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues : This and a do not have the same number of components !");
2793 if(tuplesSelec->getNumberOfComponents()!=1)
2794 throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues : Expecting to have a tuple selector DataArrayInt instance with exactly 1 component !");
2795 int thisNt=getNumberOfTuples();
2796 int aNt=a->getNumberOfTuples();
2797 int nbOfTupleToWrite=tuplesSelec->getNumberOfTuples();
2798 double *valsToSet=getPointer()+tupleIdStart*nbOfComp;
2799 if(tupleIdStart+nbOfTupleToWrite>thisNt)
2800 throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues : invalid number range of values to write !");
2801 const double *valsSrc=a->getConstPointer();
2802 for(const int *tuple=tuplesSelec->begin();tuple!=tuplesSelec->end();tuple++,valsToSet+=nbOfComp)
2804 if(*tuple>=0 && *tuple<aNt)
2806 std::copy(valsSrc+nbOfComp*(*tuple),valsSrc+nbOfComp*(*tuple+1),valsToSet);
2810 std::ostringstream oss; oss << "DataArrayDouble::setContigPartOfSelectedValues : Tuple #" << std::distance(tuplesSelec->begin(),tuple);
2811 oss << " of 'tuplesSelec' request of tuple id #" << *tuple << " in 'a' ! It should be in [0," << aNt << ") !";
2812 throw INTERP_KERNEL::Exception(oss.str().c_str());
2818 * Copy some tuples from another DataArrayDouble (\a aBase) into contiguous tuples
2819 * of \a this array. Textual data is not copied. Both arrays must have equal number of
2821 * The tuples to copy are defined by three values similar to parameters of
2822 * the Python function \c range(\c start,\c stop,\c step).
2823 * The tuples to assign to are defined by index of the first tuple, and
2824 * their number is defined by number of tuples to copy.
2825 * All components of selected tuples are copied.
2826 * \param [in] tupleIdStart - index of the first tuple of \a this array to assign
2828 * \param [in] aBase - the array to copy values from.
2829 * \param [in] bg - index of the first tuple to copy of the array \a aBase.
2830 * \param [in] end2 - index of the tuple of \a aBase before which the tuples to copy
2832 * \param [in] step - index increment to get index of the next tuple to copy.
2833 * \throw If \a this is not allocated.
2834 * \throw If \a aBase is NULL.
2835 * \throw If \a aBase is not allocated.
2836 * \throw If <em>this->getNumberOfComponents() != aBase->getNumberOfComponents()</em>.
2837 * \throw If <em>tupleIdStart + len(range(bg,end2,step)) > this->getNumberOfTuples().</em>
2838 * \throw If parameters specifying tuples to copy, do not give a
2839 * non-empty range of increasing indices or indices are out of a valid range
2840 * for the array \a aBase.
2842 void DataArrayDouble::setContigPartOfSelectedValues2(int tupleIdStart, const DataArray *aBase, int bg, int end2, int step)
2845 throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues2 : input DataArray is NULL !");
2846 const DataArrayDouble *a=dynamic_cast<const DataArrayDouble *>(aBase);
2848 throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues2 : input DataArray aBase is not a DataArrayDouble !");
2850 a->checkAllocated();
2851 int nbOfComp=getNumberOfComponents();
2852 const char msg[]="DataArrayDouble::setContigPartOfSelectedValues2";
2853 int nbOfTupleToWrite=DataArray::GetNumberOfItemGivenBES(bg,end2,step,msg);
2854 if(nbOfComp!=a->getNumberOfComponents())
2855 throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues2 : This and a do not have the same number of components !");
2856 int thisNt=getNumberOfTuples();
2857 int aNt=a->getNumberOfTuples();
2858 double *valsToSet=getPointer()+tupleIdStart*nbOfComp;
2859 if(tupleIdStart+nbOfTupleToWrite>thisNt)
2860 throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues2 : invalid number range of values to write !");
2862 throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues2 : invalid range of values to read !");
2863 const double *valsSrc=a->getConstPointer()+bg*nbOfComp;
2864 for(int i=0;i<nbOfTupleToWrite;i++,valsToSet+=nbOfComp,valsSrc+=step*nbOfComp)
2866 std::copy(valsSrc,valsSrc+nbOfComp,valsToSet);
2871 * Returns a value located at specified tuple and component.
2872 * This method is equivalent to DataArrayDouble::getIJ() except that validity of
2873 * parameters is checked. So this method is safe but expensive if used to go through
2874 * all values of \a this.
2875 * \param [in] tupleId - index of tuple of interest.
2876 * \param [in] compoId - index of component of interest.
2877 * \return double - value located by \a tupleId and \a compoId.
2878 * \throw If \a this is not allocated.
2879 * \throw If condition <em>( 0 <= tupleId < this->getNumberOfTuples() )</em> is violated.
2880 * \throw If condition <em>( 0 <= compoId < this->getNumberOfComponents() )</em> is violated.
2882 double DataArrayDouble::getIJSafe(int tupleId, int compoId) const
2885 if(tupleId<0 || tupleId>=getNumberOfTuples())
2887 std::ostringstream oss; oss << "DataArrayDouble::getIJSafe : request for tupleId " << tupleId << " should be in [0," << getNumberOfTuples() << ") !";
2888 throw INTERP_KERNEL::Exception(oss.str().c_str());
2890 if(compoId<0 || compoId>=getNumberOfComponents())
2892 std::ostringstream oss; oss << "DataArrayDouble::getIJSafe : request for compoId " << compoId << " should be in [0," << getNumberOfComponents() << ") !";
2893 throw INTERP_KERNEL::Exception(oss.str().c_str());
2895 return _mem[tupleId*_info_on_compo.size()+compoId];
2899 * Returns the first value of \a this.
2900 * \return double - the last value of \a this array.
2901 * \throw If \a this is not allocated.
2902 * \throw If \a this->getNumberOfComponents() != 1.
2903 * \throw If \a this->getNumberOfTuples() < 1.
2905 double DataArrayDouble::front() const
2908 if(getNumberOfComponents()!=1)
2909 throw INTERP_KERNEL::Exception("DataArrayDouble::front : number of components not equal to one !");
2910 int nbOfTuples=getNumberOfTuples();
2912 throw INTERP_KERNEL::Exception("DataArrayDouble::front : number of tuples must be >= 1 !");
2913 return *(getConstPointer());
2917 * Returns the last value of \a this.
2918 * \return double - the last value of \a this array.
2919 * \throw If \a this is not allocated.
2920 * \throw If \a this->getNumberOfComponents() != 1.
2921 * \throw If \a this->getNumberOfTuples() < 1.
2923 double DataArrayDouble::back() const
2926 if(getNumberOfComponents()!=1)
2927 throw INTERP_KERNEL::Exception("DataArrayDouble::back : number of components not equal to one !");
2928 int nbOfTuples=getNumberOfTuples();
2930 throw INTERP_KERNEL::Exception("DataArrayDouble::back : number of tuples must be >= 1 !");
2931 return *(getConstPointer()+nbOfTuples-1);
2934 void DataArrayDouble::SetArrayIn(DataArrayDouble *newArray, DataArrayDouble* &arrayToSet)
2936 if(newArray!=arrayToSet)
2939 arrayToSet->decrRef();
2940 arrayToSet=newArray;
2942 arrayToSet->incrRef();
2947 * Sets a C array to be used as raw data of \a this. The previously set info
2948 * of components is retained and re-sized.
2949 * For more info see \ref MEDCouplingArraySteps1.
2950 * \param [in] array - the C array to be used as raw data of \a this.
2951 * \param [in] ownership - if \a true, \a array will be deallocated at destruction of \a this.
2952 * \param [in] type - specifies how to deallocate \a array. If \a type == ParaMEDMEM::CPP_DEALLOC,
2953 * \c delete [] \c array; will be called. If \a type == ParaMEDMEM::C_DEALLOC,
2954 * \c free(\c array ) will be called.
2955 * \param [in] nbOfTuple - new number of tuples in \a this.
2956 * \param [in] nbOfCompo - new number of components in \a this.
2958 void DataArrayDouble::useArray(const double *array, bool ownership, DeallocType type, int nbOfTuple, int nbOfCompo)
2960 _info_on_compo.resize(nbOfCompo);
2961 _mem.useArray(array,ownership,type,(std::size_t)nbOfTuple*nbOfCompo);
2965 void DataArrayDouble::useExternalArrayWithRWAccess(const double *array, int nbOfTuple, int nbOfCompo)
2967 _info_on_compo.resize(nbOfCompo);
2968 _mem.useExternalArrayWithRWAccess(array,(std::size_t)nbOfTuple*nbOfCompo);
2973 * Checks if 0.0 value is present in \a this array. If it is the case, an exception
2975 * \throw If zero is found in \a this array.
2977 void DataArrayDouble::checkNoNullValues() const
2979 const double *tmp=getConstPointer();
2980 std::size_t nbOfElems=getNbOfElems();
2981 const double *where=std::find(tmp,tmp+nbOfElems,0.);
2982 if(where!=tmp+nbOfElems)
2983 throw INTERP_KERNEL::Exception("A value 0.0 have been detected !");
2987 * Computes minimal and maximal value in each component. An output array is filled
2988 * with \c 2 * \a this->getNumberOfComponents() values, so the caller is to allocate
2989 * enough memory before calling this method.
2990 * \param [out] bounds - array of size at least 2 *\a this->getNumberOfComponents().
2991 * It is filled as follows:<br>
2992 * \a bounds[0] = \c min_of_component_0 <br>
2993 * \a bounds[1] = \c max_of_component_0 <br>
2994 * \a bounds[2] = \c min_of_component_1 <br>
2995 * \a bounds[3] = \c max_of_component_1 <br>
2998 void DataArrayDouble::getMinMaxPerComponent(double *bounds) const
3001 int dim=getNumberOfComponents();
3002 for (int idim=0; idim<dim; idim++)
3004 bounds[idim*2]=std::numeric_limits<double>::max();
3005 bounds[idim*2+1]=-std::numeric_limits<double>::max();
3007 const double *ptr=getConstPointer();
3008 int nbOfTuples=getNumberOfTuples();
3009 for(int i=0;i<nbOfTuples;i++)
3011 for(int idim=0;idim<dim;idim++)
3013 if(bounds[idim*2]>ptr[i*dim+idim])
3015 bounds[idim*2]=ptr[i*dim+idim];
3017 if(bounds[idim*2+1]<ptr[i*dim+idim])
3019 bounds[idim*2+1]=ptr[i*dim+idim];
3026 * This method retrieves a newly allocated DataArrayDouble instance having same number of tuples than \a this and twice number of components than \a this
3027 * to store both the min and max per component of each tuples.
3028 * \param [in] epsilon the width of the bbox (identical in each direction) - 0.0 by default
3030 * \return a newly created DataArrayDouble instance having \c this->getNumberOfTuples() tuples and 2 * \c this->getNumberOfComponent() components
3032 * \throw If \a this is not allocated yet.
3034 DataArrayDouble *DataArrayDouble::computeBBoxPerTuple(double epsilon) const
3037 const double *dataPtr=getConstPointer();
3038 int nbOfCompo=getNumberOfComponents();
3039 int nbTuples=getNumberOfTuples();
3040 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> bbox=DataArrayDouble::New();
3041 bbox->alloc(nbTuples,2*nbOfCompo);
3042 double *bboxPtr=bbox->getPointer();
3043 for(int i=0;i<nbTuples;i++)
3045 for(int j=0;j<nbOfCompo;j++)
3047 bboxPtr[2*nbOfCompo*i+2*j]=dataPtr[nbOfCompo*i+j]-epsilon;
3048 bboxPtr[2*nbOfCompo*i+2*j+1]=dataPtr[nbOfCompo*i+j]+epsilon;
3055 * For each tuples **t** in \a other, this method retrieves tuples in \a this that are equal to **t**.
3056 * Two tuples are considered equal if the euclidian distance between the two tuples is lower than \a eps.
3058 * \param [in] other a DataArrayDouble having same number of components than \a this.
3059 * \param [in] eps absolute precision representing distance (using infinite norm) between 2 tuples behind which 2 tuples are considered equal.
3060 * \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.
3061 * \a cI allows to extract information in \a c.
3062 * \param [out] cI is an indirection array that allows to extract the data contained in \a c.
3064 * \throw In case of:
3065 * - \a this is not allocated
3066 * - \a other is not allocated or null
3067 * - \a this and \a other do not have the same number of components
3068 * - if number of components of \a this is not in [1,2,3]
3070 * \sa MEDCouplingPointSet::getNodeIdsNearPoints, DataArrayDouble::getDifferentValues
3072 void DataArrayDouble::computeTupleIdsNearTuples(const DataArrayDouble *other, double eps, DataArrayInt *& c, DataArrayInt *& cI) const
3075 throw INTERP_KERNEL::Exception("DataArrayDouble::computeTupleIdsNearTuples : input pointer other is null !");
3077 other->checkAllocated();
3078 int nbOfCompo=getNumberOfComponents();
3079 int otherNbOfCompo=other->getNumberOfComponents();
3080 if(nbOfCompo!=otherNbOfCompo)
3081 throw INTERP_KERNEL::Exception("DataArrayDouble::computeTupleIdsNearTuples : number of components should be equal between this and other !");
3082 int nbOfTuplesOther=other->getNumberOfTuples();
3083 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> cArr(DataArrayInt::New()),cIArr(DataArrayInt::New()); cArr->alloc(0,1); cIArr->pushBackSilent(0);
3088 BBTreePts<3,int> myTree(begin(),0,0,getNumberOfTuples(),eps);
3089 FindTupleIdsNearTuplesAlg<3>(myTree,other->getConstPointer(),nbOfTuplesOther,eps,cArr,cIArr);
3094 BBTreePts<2,int> myTree(begin(),0,0,getNumberOfTuples(),eps);
3095 FindTupleIdsNearTuplesAlg<2>(myTree,other->getConstPointer(),nbOfTuplesOther,eps,cArr,cIArr);
3100 BBTreePts<1,int> myTree(begin(),0,0,getNumberOfTuples(),eps);
3101 FindTupleIdsNearTuplesAlg<1>(myTree,other->getConstPointer(),nbOfTuplesOther,eps,cArr,cIArr);
3105 throw INTERP_KERNEL::Exception("Unexpected spacedim of coords for computeTupleIdsNearTuples. Must be 1, 2 or 3.");
3107 c=cArr.retn(); cI=cIArr.retn();
3111 * 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
3112 * around origin of 'radius' 1.
3114 * \param [in] eps absolute epsilon. under that value of delta between max and min no scale is performed.
3116 void DataArrayDouble::recenterForMaxPrecision(double eps)
3119 int dim=getNumberOfComponents();
3120 std::vector<double> bounds(2*dim);
3121 getMinMaxPerComponent(&bounds[0]);
3122 for(int i=0;i<dim;i++)
3124 double delta=bounds[2*i+1]-bounds[2*i];
3125 double offset=(bounds[2*i]+bounds[2*i+1])/2.;
3127 applyLin(1./delta,-offset/delta,i);
3129 applyLin(1.,-offset,i);
3134 * Returns the maximal value and its location within \a this one-dimensional array.
3135 * \param [out] tupleId - index of the tuple holding the maximal value.
3136 * \return double - the maximal value among all values of \a this array.
3137 * \throw If \a this->getNumberOfComponents() != 1
3138 * \throw If \a this->getNumberOfTuples() < 1
3140 double DataArrayDouble::getMaxValue(int& tupleId) const
3143 if(getNumberOfComponents()!=1)
3144 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 !");
3145 int nbOfTuples=getNumberOfTuples();
3147 throw INTERP_KERNEL::Exception("DataArrayDouble::getMaxValue : array exists but number of tuples must be > 0 !");
3148 const double *vals=getConstPointer();
3149 const double *loc=std::max_element(vals,vals+nbOfTuples);
3150 tupleId=(int)std::distance(vals,loc);
3155 * Returns the maximal value within \a this array that is allowed to have more than
3157 * \return double - the maximal value among all values of \a this array.
3158 * \throw If \a this is not allocated.
3160 double DataArrayDouble::getMaxValueInArray() const
3163 const double *loc=std::max_element(begin(),end());
3168 * Returns the maximal value and all its locations within \a this one-dimensional array.
3169 * \param [out] tupleIds - a new instance of DataArrayInt containg indices of
3170 * tuples holding the maximal value. The caller is to delete it using
3171 * decrRef() as it is no more needed.
3172 * \return double - the maximal value among all values of \a this array.
3173 * \throw If \a this->getNumberOfComponents() != 1
3174 * \throw If \a this->getNumberOfTuples() < 1
3176 double DataArrayDouble::getMaxValue2(DataArrayInt*& tupleIds) const
3180 double ret=getMaxValue(tmp);
3181 tupleIds=getIdsInRange(ret,ret);
3186 * Returns the minimal value and its location within \a this one-dimensional array.
3187 * \param [out] tupleId - index of the tuple holding the minimal value.
3188 * \return double - the minimal value among all values of \a this array.
3189 * \throw If \a this->getNumberOfComponents() != 1
3190 * \throw If \a this->getNumberOfTuples() < 1
3192 double DataArrayDouble::getMinValue(int& tupleId) const
3195 if(getNumberOfComponents()!=1)
3196 throw INTERP_KERNEL::Exception("DataArrayDouble::getMinValue : must be applied on DataArrayDouble with only one component, you can call 'rearrange' method before call 'getMinValueInArray' method !");
3197 int nbOfTuples=getNumberOfTuples();
3199 throw INTERP_KERNEL::Exception("DataArrayDouble::getMinValue : array exists but number of tuples must be > 0 !");
3200 const double *vals=getConstPointer();
3201 const double *loc=std::min_element(vals,vals+nbOfTuples);
3202 tupleId=(int)std::distance(vals,loc);
3207 * Returns the minimal value within \a this array that is allowed to have more than
3209 * \return double - the minimal value among all values of \a this array.
3210 * \throw If \a this is not allocated.
3212 double DataArrayDouble::getMinValueInArray() const
3215 const double *loc=std::min_element(begin(),end());
3220 * Returns the minimal value and all its locations within \a this one-dimensional array.
3221 * \param [out] tupleIds - a new instance of DataArrayInt containg indices of
3222 * tuples holding the minimal value. The caller is to delete it using
3223 * decrRef() as it is no more needed.
3224 * \return double - the minimal value among all values of \a this array.
3225 * \throw If \a this->getNumberOfComponents() != 1
3226 * \throw If \a this->getNumberOfTuples() < 1
3228 double DataArrayDouble::getMinValue2(DataArrayInt*& tupleIds) const
3232 double ret=getMinValue(tmp);
3233 tupleIds=getIdsInRange(ret,ret);
3238 * 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.
3239 * This method only works for single component array.
3241 * \return a value in [ 0, \c this->getNumberOfTuples() )
3243 * \throw If \a this is not allocated
3246 int DataArrayDouble::count(double value, double eps) const
3250 if(getNumberOfComponents()!=1)
3251 throw INTERP_KERNEL::Exception("DataArrayDouble::count : must be applied on DataArrayDouble with only one component, you can call 'rearrange' method before !");
3252 const double *vals=begin();
3253 int nbOfTuples=getNumberOfTuples();
3254 for(int i=0;i<nbOfTuples;i++,vals++)
3255 if(fabs(*vals-value)<=eps)
3261 * Returns the average value of \a this one-dimensional array.
3262 * \return double - the average value over all values of \a this array.
3263 * \throw If \a this->getNumberOfComponents() != 1
3264 * \throw If \a this->getNumberOfTuples() < 1
3266 double DataArrayDouble::getAverageValue() const
3268 if(getNumberOfComponents()!=1)
3269 throw INTERP_KERNEL::Exception("DataArrayDouble::getAverageValue : must be applied on DataArrayDouble with only one component, you can call 'rearrange' method before !");
3270 int nbOfTuples=getNumberOfTuples();
3272 throw INTERP_KERNEL::Exception("DataArrayDouble::getAverageValue : array exists but number of tuples must be > 0 !");
3273 const double *vals=getConstPointer();
3274 double ret=std::accumulate(vals,vals+nbOfTuples,0.);
3275 return ret/nbOfTuples;
3279 * Returns the Euclidean norm of the vector defined by \a this array.
3280 * \return double - the value of the Euclidean norm, i.e.
3281 * the square root of the inner product of vector.
3282 * \throw If \a this is not allocated.
3284 double DataArrayDouble::norm2() const
3288 std::size_t nbOfElems=getNbOfElems();
3289 const double *pt=getConstPointer();
3290 for(std::size_t i=0;i<nbOfElems;i++,pt++)
3296 * Returns the maximum norm of the vector defined by \a this array.
3297 * \return double - the value of the maximum norm, i.e.
3298 * the maximal absolute value among values of \a this array.
3299 * \throw If \a this is not allocated.
3301 double DataArrayDouble::normMax() const
3305 std::size_t nbOfElems=getNbOfElems();
3306 const double *pt=getConstPointer();
3307 for(std::size_t i=0;i<nbOfElems;i++,pt++)
3309 double val=std::abs(*pt);
3317 * Accumulates values of each component of \a this array.
3318 * \param [out] res - an array of length \a this->getNumberOfComponents(), allocated
3319 * by the caller, that is filled by this method with sum value for each
3321 * \throw If \a this is not allocated.
3323 void DataArrayDouble::accumulate(double *res) const
3326 const double *ptr=getConstPointer();
3327 int nbTuple=getNumberOfTuples();
3328 int nbComps=getNumberOfComponents();
3329 std::fill(res,res+nbComps,0.);
3330 for(int i=0;i<nbTuple;i++)
3331 std::transform(ptr+i*nbComps,ptr+(i+1)*nbComps,res,res,std::plus<double>());
3335 * This method returns the min distance from an external tuple defined by [ \a tupleBg , \a tupleEnd ) to \a this and
3336 * the first tuple in \a this that matches the returned distance. If there is no tuples in \a this an exception will be thrown.
3339 * \a this is expected to be allocated and expected to have a number of components equal to the distance from \a tupleBg to
3340 * \a tupleEnd. If not an exception will be thrown.
3342 * \param [in] tupleBg start pointer (included) of input external tuple
3343 * \param [in] tupleEnd end pointer (not included) of input external tuple
3344 * \param [out] tupleId the tuple id in \a this that matches the min of distance between \a this and input external tuple
3345 * \return the min distance.
3346 * \sa MEDCouplingUMesh::distanceToPoint
3348 double DataArrayDouble::distanceToTuple(const double *tupleBg, const double *tupleEnd, int& tupleId) const
3351 int nbTuple=getNumberOfTuples();
3352 int nbComps=getNumberOfComponents();
3353 if(nbComps!=(int)std::distance(tupleBg,tupleEnd))
3354 { 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()); }
3356 throw INTERP_KERNEL::Exception("DataArrayDouble::distanceToTuple : no tuple in this ! No distance to compute !");
3357 double ret0=std::numeric_limits<double>::max();
3359 const double *work=getConstPointer();
3360 for(int i=0;i<nbTuple;i++)
3363 for(int j=0;j<nbComps;j++,work++)
3364 val+=(*work-tupleBg[j])*((*work-tupleBg[j]));
3368 { ret0=val; tupleId=i; }
3374 * Accumulate values of the given component of \a this array.
3375 * \param [in] compId - the index of the component of interest.
3376 * \return double - a sum value of \a compId-th component.
3377 * \throw If \a this is not allocated.
3378 * \throw If \a the condition ( 0 <= \a compId < \a this->getNumberOfComponents() ) is
3381 double DataArrayDouble::accumulate(int compId) const
3384 const double *ptr=getConstPointer();
3385 int nbTuple=getNumberOfTuples();
3386 int nbComps=getNumberOfComponents();
3387 if(compId<0 || compId>=nbComps)
3388 throw INTERP_KERNEL::Exception("DataArrayDouble::accumulate : Invalid compId specified : No such nb of components !");
3390 for(int i=0;i<nbTuple;i++)
3391 ret+=ptr[i*nbComps+compId];
3396 * This method accumulate using addition tuples in \a this using input index array [ \a bgOfIndex, \a endOfIndex ).
3397 * The returned array will have same number of components than \a this and number of tuples equal to
3398 * \c std::distance(bgOfIndex,endOfIndex) \b minus \b one.
3400 * The input index array is expected to be ascendingly sorted in which the all referenced ids should be in [0, \c this->getNumberOfTuples).
3401 * 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.
3403 * \param [in] bgOfIndex - begin (included) of the input index array.
3404 * \param [in] endOfIndex - end (excluded) of the input index array.
3405 * \return DataArrayDouble * - the new instance having the same number of components than \a this.
3407 * \throw If bgOfIndex or end is NULL.
3408 * \throw If input index array is not ascendingly sorted.
3409 * \throw If there is an id in [ \a bgOfIndex, \a endOfIndex ) not in [0, \c this->getNumberOfTuples).
3410 * \throw If std::distance(bgOfIndex,endOfIndex)==0.
3412 DataArrayDouble *DataArrayDouble::accumulatePerChunck(const int *bgOfIndex, const int *endOfIndex) const
3414 if(!bgOfIndex || !endOfIndex)
3415 throw INTERP_KERNEL::Exception("DataArrayDouble::accumulatePerChunck : input pointer NULL !");
3417 int nbCompo=getNumberOfComponents();
3418 int nbOfTuples=getNumberOfTuples();
3419 int sz=(int)std::distance(bgOfIndex,endOfIndex);
3421 throw INTERP_KERNEL::Exception("DataArrayDouble::accumulatePerChunck : invalid size of input index array !");
3423 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New(); ret->alloc(sz,nbCompo);
3424 const int *w=bgOfIndex;
3425 if(*w<0 || *w>=nbOfTuples)
3426 throw INTERP_KERNEL::Exception("DataArrayDouble::accumulatePerChunck : The first element of the input index not in [0,nbOfTuples) !");
3427 const double *srcPt=begin()+(*w)*nbCompo;
3428 double *tmp=ret->getPointer();
3429 for(int i=0;i<sz;i++,tmp+=nbCompo,w++)
3431 std::fill(tmp,tmp+nbCompo,0.);
3434 for(int j=w[0];j<w[1];j++,srcPt+=nbCompo)
3436 if(j>=0 && j<nbOfTuples)
3437 std::transform(srcPt,srcPt+nbCompo,tmp,tmp,std::plus<double>());
3440 std::ostringstream oss; oss << "DataArrayDouble::accumulatePerChunck : At rank #" << i << " the input index array points to id " << j << " should be in [0," << nbOfTuples << ") !";
3441 throw INTERP_KERNEL::Exception(oss.str().c_str());
3447 std::ostringstream oss; oss << "DataArrayDouble::accumulatePerChunck : At rank #" << i << " the input index array is not in ascendingly sorted.";
3448 throw INTERP_KERNEL::Exception(oss.str().c_str());
3451 ret->copyStringInfoFrom(*this);
3456 * Converts each 2D point defined by the tuple of \a this array from the Polar to the
3457 * Cartesian coordinate system. The two components of the tuple of \a this array are
3458 * considered to contain (1) radius and (2) angle of the point in the Polar CS.
3459 * \return DataArrayDouble * - the new instance of DataArrayDouble, whose each tuple
3460 * contains X and Y coordinates of the point in the Cartesian CS. The caller
3461 * is to delete this array using decrRef() as it is no more needed. The array
3462 * does not contain any textual info on components.
3463 * \throw If \a this->getNumberOfComponents() != 2.
3465 DataArrayDouble *DataArrayDouble::fromPolarToCart() const
3468 int nbOfComp=getNumberOfComponents();
3470 throw INTERP_KERNEL::Exception("DataArrayDouble::fromPolarToCart : must be an array with exactly 2 components !");
3471 int nbOfTuple=getNumberOfTuples();
3472 DataArrayDouble *ret=DataArrayDouble::New();
3473 ret->alloc(nbOfTuple,2);
3474 double *w=ret->getPointer();
3475 const double *wIn=getConstPointer();
3476 for(int i=0;i<nbOfTuple;i++,w+=2,wIn+=2)
3478 w[0]=wIn[0]*cos(wIn[1]);
3479 w[1]=wIn[0]*sin(wIn[1]);
3485 * Converts each 3D point defined by the tuple of \a this array from the Cylindrical to
3486 * the Cartesian coordinate system. The three components of the tuple of \a this array
3487 * are considered to contain (1) radius, (2) azimuth and (3) altitude of the point in
3488 * the Cylindrical CS.
3489 * \return DataArrayDouble * - the new instance of DataArrayDouble, whose each tuple
3490 * contains X, Y and Z coordinates of the point in the Cartesian CS. The info
3491 * on the third component is copied from \a this array. The caller
3492 * is to delete this array using decrRef() as it is no more needed.
3493 * \throw If \a this->getNumberOfComponents() != 3.
3495 DataArrayDouble *DataArrayDouble::fromCylToCart() const
3498 int nbOfComp=getNumberOfComponents();
3500 throw INTERP_KERNEL::Exception("DataArrayDouble::fromCylToCart : must be an array with exactly 3 components !");
3501 int nbOfTuple=getNumberOfTuples();
3502 DataArrayDouble *ret=DataArrayDouble::New();
3503 ret->alloc(getNumberOfTuples(),3);
3504 double *w=ret->getPointer();
3505 const double *wIn=getConstPointer();
3506 for(int i=0;i<nbOfTuple;i++,w+=3,wIn+=3)
3508 w[0]=wIn[0]*cos(wIn[1]);
3509 w[1]=wIn[0]*sin(wIn[1]);
3512 ret->setInfoOnComponent(2,getInfoOnComponent(2).c_str());
3517 * Converts each 3D point defined by the tuple of \a this array from the Spherical to
3518 * the Cartesian coordinate system. The three components of the tuple of \a this array
3519 * are considered to contain (1) radius, (2) polar angle and (3) azimuthal angle of the
3520 * point in the Cylindrical CS.
3521 * \return DataArrayDouble * - the new instance of DataArrayDouble, whose each tuple
3522 * contains X, Y and Z coordinates of the point in the Cartesian CS. The info
3523 * on the third component is copied from \a this array. The caller
3524 * is to delete this array using decrRef() as it is no more needed.
3525 * \throw If \a this->getNumberOfComponents() != 3.
3527 DataArrayDouble *DataArrayDouble::fromSpherToCart() const
3530 int nbOfComp=getNumberOfComponents();
3532 throw INTERP_KERNEL::Exception("DataArrayDouble::fromSpherToCart : must be an array with exactly 3 components !");
3533 int nbOfTuple=getNumberOfTuples();
3534 DataArrayDouble *ret=DataArrayDouble::New();
3535 ret->alloc(getNumberOfTuples(),3);
3536 double *w=ret->getPointer();
3537 const double *wIn=getConstPointer();
3538 for(int i=0;i<nbOfTuple;i++,w+=3,wIn+=3)
3540 w[0]=wIn[0]*cos(wIn[2])*sin(wIn[1]);
3541 w[1]=wIn[0]*sin(wIn[2])*sin(wIn[1]);
3542 w[2]=wIn[0]*cos(wIn[1]);
3548 * Computes the doubly contracted product of every tensor defined by the tuple of \a this
3549 * array contating 6 components.
3550 * \return DataArrayDouble * - the new instance of DataArrayDouble, whose each tuple
3551 * is calculated from the tuple <em>(t)</em> of \a this array as follows:
3552 * \f$ t[0]^2+t[1]^2+t[2]^2+2*t[3]^2+2*t[4]^2+2*t[5]^2\f$.
3553 * The caller is to delete this result array using decrRef() as it is no more needed.
3554 * \throw If \a this->getNumberOfComponents() != 6.
3556 DataArrayDouble *DataArrayDouble::doublyContractedProduct() const
3559 int nbOfComp=getNumberOfComponents();
3561 throw INTERP_KERNEL::Exception("DataArrayDouble::doublyContractedProduct : must be an array with exactly 6 components !");
3562 DataArrayDouble *ret=DataArrayDouble::New();
3563 int nbOfTuple=getNumberOfTuples();
3564 ret->alloc(nbOfTuple,1);
3565 const double *src=getConstPointer();
3566 double *dest=ret->getPointer();
3567 for(int i=0;i<nbOfTuple;i++,dest++,src+=6)
3568 *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];
3573 * Computes the determinant of every square matrix defined by the tuple of \a this
3574 * array, which contains either 4, 6 or 9 components. The case of 6 components
3575 * corresponds to that of the upper triangular matrix.
3576 * \return DataArrayDouble * - the new instance of DataArrayDouble, whose each tuple
3577 * is the determinant of matrix of the corresponding tuple of \a this array.
3578 * The caller is to delete this result array using decrRef() as it is no more
3580 * \throw If \a this->getNumberOfComponents() is not in [4,6,9].
3582 DataArrayDouble *DataArrayDouble::determinant() const
3585 DataArrayDouble *ret=DataArrayDouble::New();
3586 int nbOfTuple=getNumberOfTuples();
3587 ret->alloc(nbOfTuple,1);
3588 const double *src=getConstPointer();
3589 double *dest=ret->getPointer();
3590 switch(getNumberOfComponents())
3593 for(int i=0;i<nbOfTuple;i++,dest++,src+=6)
3594 *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];
3597 for(int i=0;i<nbOfTuple;i++,dest++,src+=4)
3598 *dest=src[0]*src[3]-src[1]*src[2];
3601 for(int i=0;i<nbOfTuple;i++,dest++,src+=9)
3602 *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];
3606 throw INTERP_KERNEL::Exception("DataArrayDouble::determinant : Invalid number of components ! must be in 4,6,9 !");
3611 * Computes 3 eigenvalues of every upper triangular matrix defined by the tuple of
3612 * \a this array, which contains 6 components.
3613 * \return DataArrayDouble * - the new instance of DataArrayDouble containing 3
3614 * components, whose each tuple contains the eigenvalues of the matrix of
3615 * corresponding tuple of \a this array.
3616 * The caller is to delete this result array using decrRef() as it is no more
3618 * \throw If \a this->getNumberOfComponents() != 6.
3620 DataArrayDouble *DataArrayDouble::eigenValues() const
3623 int nbOfComp=getNumberOfComponents();
3625 throw INTERP_KERNEL::Exception("DataArrayDouble::eigenValues : must be an array with exactly 6 components !");
3626 DataArrayDouble *ret=DataArrayDouble::New();
3627 int nbOfTuple=getNumberOfTuples();
3628 ret->alloc(nbOfTuple,3);
3629 const double *src=getConstPointer();
3630 double *dest=ret->getPointer();
3631 for(int i=0;i<nbOfTuple;i++,dest+=3,src+=6)
3632 INTERP_KERNEL::computeEigenValues6(src,dest);
3637 * Computes 3 eigenvectors of every upper triangular matrix defined by the tuple of
3638 * \a this array, which contains 6 components.
3639 * \return DataArrayDouble * - the new instance of DataArrayDouble containing 9
3640 * components, whose each tuple contains 3 eigenvectors of the matrix of
3641 * corresponding tuple of \a this array.
3642 * The caller is to delete this result array using decrRef() as it is no more
3644 * \throw If \a this->getNumberOfComponents() != 6.
3646 DataArrayDouble *DataArrayDouble::eigenVectors() const
3649 int nbOfComp=getNumberOfComponents();
3651 throw INTERP_KERNEL::Exception("DataArrayDouble::eigenVectors : must be an array with exactly 6 components !");
3652 DataArrayDouble *ret=DataArrayDouble::New();
3653 int nbOfTuple=getNumberOfTuples();
3654 ret->alloc(nbOfTuple,9);
3655 const double *src=getConstPointer();
3656 double *dest=ret->getPointer();
3657 for(int i=0;i<nbOfTuple;i++,src+=6)
3660 INTERP_KERNEL::computeEigenValues6(src,tmp);
3661 for(int j=0;j<3;j++,dest+=3)
3662 INTERP_KERNEL::computeEigenVectorForEigenValue6(src,tmp[j],1e-12,dest);
3668 * Computes the inverse matrix of every matrix defined by the tuple of \a this
3669 * array, which contains either 4, 6 or 9 components. The case of 6 components
3670 * corresponds to that of the upper triangular matrix.
3671 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
3672 * same number of components as \a this one, whose each tuple is the inverse
3673 * matrix of the matrix of corresponding tuple of \a this array.
3674 * The caller is to delete this result array using decrRef() as it is no more
3676 * \throw If \a this->getNumberOfComponents() is not in [4,6,9].
3678 DataArrayDouble *DataArrayDouble::inverse() const
3681 int nbOfComp=getNumberOfComponents();
3682 if(nbOfComp!=6 && nbOfComp!=9 && nbOfComp!=4)
3683 throw INTERP_KERNEL::Exception("DataArrayDouble::inversion : must be an array with 4,6 or 9 components !");
3684 DataArrayDouble *ret=DataArrayDouble::New();
3685 int nbOfTuple=getNumberOfTuples();
3686 ret->alloc(nbOfTuple,nbOfComp);
3687 const double *src=getConstPointer();
3688 double *dest=ret->getPointer();
3690 for(int i=0;i<nbOfTuple;i++,dest+=6,src+=6)
3692 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];
3693 dest[0]=(src[1]*src[2]-src[4]*src[4])/det;
3694 dest[1]=(src[0]*src[2]-src[5]*src[5])/det;
3695 dest[2]=(src[0]*src[1]-src[3]*src[3])/det;
3696 dest[3]=(src[5]*src[4]-src[3]*src[2])/det;
3697 dest[4]=(src[5]*src[3]-src[0]*src[4])/det;
3698 dest[5]=(src[3]*src[4]-src[1]*src[5])/det;
3700 else if(nbOfComp==4)
3701 for(int i=0;i<nbOfTuple;i++,dest+=4,src+=4)
3703 double det=src[0]*src[3]-src[1]*src[2];
3705 dest[1]=-src[1]/det;
3706 dest[2]=-src[2]/det;
3710 for(int i=0;i<nbOfTuple;i++,dest+=9,src+=9)
3712 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];
3713 dest[0]=(src[4]*src[8]-src[7]*src[5])/det;
3714 dest[1]=(src[7]*src[2]-src[1]*src[8])/det;
3715 dest[2]=(src[1]*src[5]-src[4]*src[2])/det;
3716 dest[3]=(src[6]*src[5]-src[3]*src[8])/det;
3717 dest[4]=(src[0]*src[8]-src[6]*src[2])/det;
3718 dest[5]=(src[2]*src[3]-src[0]*src[5])/det;
3719 dest[6]=(src[3]*src[7]-src[6]*src[4])/det;
3720 dest[7]=(src[6]*src[1]-src[0]*src[7])/det;
3721 dest[8]=(src[0]*src[4]-src[1]*src[3])/det;
3727 * Computes the trace of every matrix defined by the tuple of \a this
3728 * array, which contains either 4, 6 or 9 components. The case of 6 components
3729 * corresponds to that of the upper triangular matrix.
3730 * \return DataArrayDouble * - the new instance of DataArrayDouble containing
3731 * 1 component, whose each tuple is the trace of
3732 * the matrix of corresponding tuple of \a this array.
3733 * The caller is to delete this result array using decrRef() as it is no more
3735 * \throw If \a this->getNumberOfComponents() is not in [4,6,9].
3737 DataArrayDouble *DataArrayDouble::trace() const
3740 int nbOfComp=getNumberOfComponents();
3741 if(nbOfComp!=6 && nbOfComp!=9 && nbOfComp!=4)
3742 throw INTERP_KERNEL::Exception("DataArrayDouble::trace : must be an array with 4,6 or 9 components !");
3743 DataArrayDouble *ret=DataArrayDouble::New();
3744 int nbOfTuple=getNumberOfTuples();
3745 ret->alloc(nbOfTuple,1);
3746 const double *src=getConstPointer();
3747 double *dest=ret->getPointer();
3749 for(int i=0;i<nbOfTuple;i++,dest++,src+=6)
3750 *dest=src[0]+src[1]+src[2];
3751 else if(nbOfComp==4)
3752 for(int i=0;i<nbOfTuple;i++,dest++,src+=4)
3753 *dest=src[0]+src[3];
3755 for(int i=0;i<nbOfTuple;i++,dest++,src+=9)
3756 *dest=src[0]+src[4]+src[8];
3761 * Computes the stress deviator tensor of every stress tensor defined by the tuple of
3762 * \a this array, which contains 6 components.
3763 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
3764 * same number of components and tuples as \a this array.
3765 * The caller is to delete this result array using decrRef() as it is no more
3767 * \throw If \a this->getNumberOfComponents() != 6.
3769 DataArrayDouble *DataArrayDouble::deviator() const
3772 int nbOfComp=getNumberOfComponents();
3774 throw INTERP_KERNEL::Exception("DataArrayDouble::deviator : must be an array with exactly 6 components !");
3775 DataArrayDouble *ret=DataArrayDouble::New();
3776 int nbOfTuple=getNumberOfTuples();
3777 ret->alloc(nbOfTuple,6);
3778 const double *src=getConstPointer();
3779 double *dest=ret->getPointer();
3780 for(int i=0;i<nbOfTuple;i++,dest+=6,src+=6)
3782 double tr=(src[0]+src[1]+src[2])/3.;
3794 * Computes the magnitude of every vector defined by the tuple of
3796 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
3797 * same number of tuples as \a this array and one component.
3798 * The caller is to delete this result array using decrRef() as it is no more
3800 * \throw If \a this is not allocated.
3802 DataArrayDouble *DataArrayDouble::magnitude() const
3805 int nbOfComp=getNumberOfComponents();
3806 DataArrayDouble *ret=DataArrayDouble::New();
3807 int nbOfTuple=getNumberOfTuples();
3808 ret->alloc(nbOfTuple,1);
3809 const double *src=getConstPointer();
3810 double *dest=ret->getPointer();
3811 for(int i=0;i<nbOfTuple;i++,dest++)
3814 for(int j=0;j<nbOfComp;j++,src++)
3822 * Computes for each tuple the sum of number of components values in the tuple and return it.
3824 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
3825 * same number of tuples as \a this array and one component.
3826 * The caller is to delete this result array using decrRef() as it is no more
3828 * \throw If \a this is not allocated.
3830 DataArrayDouble *DataArrayDouble::sumPerTuple() const
3833 int nbOfComp(getNumberOfComponents()),nbOfTuple(getNumberOfTuples());
3834 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret(DataArrayDouble::New());
3835 ret->alloc(nbOfTuple,1);
3836 const double *src(getConstPointer());
3837 double *dest(ret->getPointer());
3838 for(int i=0;i<nbOfTuple;i++,dest++,src+=nbOfComp)
3839 *dest=std::accumulate(src,src+nbOfComp,0.);
3844 * Computes the maximal value within every tuple of \a this array.
3845 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
3846 * same number of tuples as \a this array and one component.
3847 * The caller is to delete this result array using decrRef() as it is no more
3849 * \throw If \a this is not allocated.
3850 * \sa DataArrayDouble::maxPerTupleWithCompoId
3852 DataArrayDouble *DataArrayDouble::maxPerTuple() const
3855 int nbOfComp=getNumberOfComponents();
3856 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
3857 int nbOfTuple=getNumberOfTuples();
3858 ret->alloc(nbOfTuple,1);
3859 const double *src=getConstPointer();
3860 double *dest=ret->getPointer();
3861 for(int i=0;i<nbOfTuple;i++,dest++,src+=nbOfComp)
3862 *dest=*std::max_element(src,src+nbOfComp);
3867 * Computes the maximal value within every tuple of \a this array and it returns the first component
3868 * id for each tuple that corresponds to the maximal value within the tuple.
3870 * \param [out] compoIdOfMaxPerTuple - the new new instance of DataArrayInt containing the
3871 * same number of tuples and only one component.
3872 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
3873 * same number of tuples as \a this array and one component.
3874 * The caller is to delete this result array using decrRef() as it is no more
3876 * \throw If \a this is not allocated.
3877 * \sa DataArrayDouble::maxPerTuple
3879 DataArrayDouble *DataArrayDouble::maxPerTupleWithCompoId(DataArrayInt* &compoIdOfMaxPerTuple) const
3882 int nbOfComp=getNumberOfComponents();
3883 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret0=DataArrayDouble::New();
3884 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret1=DataArrayInt::New();
3885 int nbOfTuple=getNumberOfTuples();
3886 ret0->alloc(nbOfTuple,1); ret1->alloc(nbOfTuple,1);
3887 const double *src=getConstPointer();
3888 double *dest=ret0->getPointer(); int *dest1=ret1->getPointer();
3889 for(int i=0;i<nbOfTuple;i++,dest++,dest1++,src+=nbOfComp)
3891 const double *loc=std::max_element(src,src+nbOfComp);
3893 *dest1=(int)std::distance(src,loc);
3895 compoIdOfMaxPerTuple=ret1.retn();
3900 * This method returns a newly allocated DataArrayDouble instance having one component and \c this->getNumberOfTuples() * \c this->getNumberOfTuples() tuples.
3901 * \n This returned array contains the euclidian distance for each tuple in \a this.
3902 * \n So the returned array can be seen as a dense symmetrical matrix whose diagonal elements are equal to 0.
3903 * \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)
3905 * \warning use this method with care because it can leads to big amount of consumed memory !
3907 * \return A newly allocated (huge) ParaMEDMEM::DataArrayDouble instance that the caller should deal with.
3909 * \throw If \a this is not allocated.
3911 * \sa DataArrayDouble::buildEuclidianDistanceDenseMatrixWith
3913 DataArrayDouble *DataArrayDouble::buildEuclidianDistanceDenseMatrix() const
3916 int nbOfComp=getNumberOfComponents();
3917 int nbOfTuples=getNumberOfTuples();
3918 const double *inData=getConstPointer();
3919 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
3920 ret->alloc(nbOfTuples*nbOfTuples,1);
3921 double *outData=ret->getPointer();
3922 for(int i=0;i<nbOfTuples;i++)
3924 outData[i*nbOfTuples+i]=0.;
3925 for(int j=i+1;j<nbOfTuples;j++)
3928 for(int k=0;k<nbOfComp;k++)
3929 { double delta=inData[i*nbOfComp+k]-inData[j*nbOfComp+k]; dist+=delta*delta; }
3931 outData[i*nbOfTuples+j]=dist;
3932 outData[j*nbOfTuples+i]=dist;
3939 * This method returns a newly allocated DataArrayDouble instance having one component and \c this->getNumberOfTuples() * \c other->getNumberOfTuples() tuples.
3940 * \n This returned array contains the euclidian distance for each tuple in \a other with each tuple in \a this.
3941 * \n So the returned array can be seen as a dense rectangular matrix with \c other->getNumberOfTuples() rows and \c this->getNumberOfTuples() columns.
3942 * \n Output rectangular matrix is sorted along rows.
3943 * \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)
3945 * \warning use this method with care because it can leads to big amount of consumed memory !
3947 * \param [in] other DataArrayDouble instance having same number of components than \a this.
3948 * \return A newly allocated (huge) ParaMEDMEM::DataArrayDouble instance that the caller should deal with.
3950 * \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.
3952 * \sa DataArrayDouble::buildEuclidianDistanceDenseMatrix
3954 DataArrayDouble *DataArrayDouble::buildEuclidianDistanceDenseMatrixWith(const DataArrayDouble *other) const
3957 throw INTERP_KERNEL::Exception("DataArrayDouble::buildEuclidianDistanceDenseMatrixWith : input parameter is null !");
3959 other->checkAllocated();
3960 int nbOfComp=getNumberOfComponents();
3961 int otherNbOfComp=other->getNumberOfComponents();
3962 if(nbOfComp!=otherNbOfComp)
3964 std::ostringstream oss; oss << "DataArrayDouble::buildEuclidianDistanceDenseMatrixWith : this nb of compo=" << nbOfComp << " and other nb of compo=" << otherNbOfComp << ". It should match !";
3965 throw INTERP_KERNEL::Exception(oss.str().c_str());
3967 int nbOfTuples=getNumberOfTuples();
3968 int otherNbOfTuples=other->getNumberOfTuples();
3969 const double *inData=getConstPointer();
3970 const double *inDataOther=other->getConstPointer();
3971 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
3972 ret->alloc(otherNbOfTuples*nbOfTuples,1);
3973 double *outData=ret->getPointer();
3974 for(int i=0;i<otherNbOfTuples;i++,inDataOther+=nbOfComp)
3976 for(int j=0;j<nbOfTuples;j++)
3979 for(int k=0;k<nbOfComp;k++)
3980 { double delta=inDataOther[k]-inData[j*nbOfComp+k]; dist+=delta*delta; }
3982 outData[i*nbOfTuples+j]=dist;
3989 * Sorts value within every tuple of \a this array.
3990 * \param [in] asc - if \a true, the values are sorted in ascending order, else,
3991 * in descending order.
3992 * \throw If \a this is not allocated.
3994 void DataArrayDouble::sortPerTuple(bool asc)
3997 double *pt=getPointer();
3998 int nbOfTuple=getNumberOfTuples();
3999 int nbOfComp=getNumberOfComponents();
4001 for(int i=0;i<nbOfTuple;i++,pt+=nbOfComp)
4002 std::sort(pt,pt+nbOfComp);
4004 for(int i=0;i<nbOfTuple;i++,pt+=nbOfComp)
4005 std::sort(pt,pt+nbOfComp,std::greater<double>());
4010 * Converts every value of \a this array to its absolute value.
4011 * \throw If \a this is not allocated.
4013 void DataArrayDouble::abs()
4016 double *ptr=getPointer();
4017 std::size_t nbOfElems=getNbOfElems();
4018 std::transform(ptr,ptr+nbOfElems,ptr,std::ptr_fun<double,double>(fabs));
4023 * Apply a liner function to a given component of \a this array, so that
4024 * an array element <em>(x)</em> becomes \f$ a * x + b \f$.
4025 * \param [in] a - the first coefficient of the function.
4026 * \param [in] b - the second coefficient of the function.
4027 * \param [in] compoId - the index of component to modify.
4028 * \throw If \a this is not allocated.
4030 void DataArrayDouble::applyLin(double a, double b, int compoId)
4033 double *ptr=getPointer()+compoId;
4034 int nbOfComp=getNumberOfComponents();
4035 int nbOfTuple=getNumberOfTuples();
4036 for(int i=0;i<nbOfTuple;i++,ptr+=nbOfComp)
4042 * Apply a liner function to all elements of \a this array, so that
4043 * an element _x_ becomes \f$ a * x + b \f$.
4044 * \param [in] a - the first coefficient of the function.
4045 * \param [in] b - the second coefficient of the function.
4046 * \throw If \a this is not allocated.
4048 void DataArrayDouble::applyLin(double a, double b)
4051 double *ptr=getPointer();
4052 std::size_t nbOfElems=getNbOfElems();
4053 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
4059 * Modify all elements of \a this array, so that
4060 * an element _x_ becomes \f$ numerator / x \f$.
4061 * \warning If an exception is thrown because of presence of 0.0 element in \a this
4062 * array, all elements processed before detection of the zero element remain
4064 * \param [in] numerator - the numerator used to modify array elements.
4065 * \throw If \a this is not allocated.
4066 * \throw If there is an element equal to 0.0 in \a this array.
4068 void DataArrayDouble::applyInv(double numerator)
4071 double *ptr=getPointer();
4072 std::size_t nbOfElems=getNbOfElems();
4073 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
4075 if(std::abs(*ptr)>std::numeric_limits<double>::min())
4077 *ptr=numerator/(*ptr);
4081 std::ostringstream oss; oss << "DataArrayDouble::applyInv : presence of null value in tuple #" << i/getNumberOfComponents() << " component #" << i%getNumberOfComponents();
4083 throw INTERP_KERNEL::Exception(oss.str().c_str());
4090 * Returns a full copy of \a this array except that sign of all elements is reversed.
4091 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
4092 * same number of tuples and component as \a this array.
4093 * The caller is to delete this result array using decrRef() as it is no more
4095 * \throw If \a this is not allocated.
4097 DataArrayDouble *DataArrayDouble::negate() const
4100 DataArrayDouble *newArr=DataArrayDouble::New();
4101 int nbOfTuples=getNumberOfTuples();
4102 int nbOfComp=getNumberOfComponents();
4103 newArr->alloc(nbOfTuples,nbOfComp);
4104 const double *cptr=getConstPointer();
4105 std::transform(cptr,cptr+nbOfTuples*nbOfComp,newArr->getPointer(),std::negate<double>());
4106 newArr->copyStringInfoFrom(*this);
4111 * Modify all elements of \a this array, so that
4112 * an element _x_ becomes <em> val ^ x </em>. Contrary to DataArrayInt::applyPow
4113 * all values in \a this have to be >= 0 if val is \b not integer.
4114 * \param [in] val - the value used to apply pow on all array elements.
4115 * \throw If \a this is not allocated.
4116 * \warning If an exception is thrown because of presence of 0 element in \a this
4117 * array and \a val is \b not integer, all elements processed before detection of the zero element remain
4120 void DataArrayDouble::applyPow(double val)
4123 double *ptr=getPointer();
4124 std::size_t nbOfElems=getNbOfElems();
4126 bool isInt=((double)val2)==val;
4129 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
4135 std::ostringstream oss; oss << "DataArrayDouble::applyPow (double) : At elem # " << i << " value is " << *ptr << " ! must be >=0. !";
4136 throw INTERP_KERNEL::Exception(oss.str().c_str());
4142 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
4143 *ptr=pow(*ptr,val2);
4149 * Modify all elements of \a this array, so that
4150 * an element _x_ becomes \f$ val ^ x \f$.
4151 * \param [in] val - the value used to apply pow on all array elements.
4152 * \throw If \a this is not allocated.
4153 * \throw If \a val < 0.
4154 * \warning If an exception is thrown because of presence of 0 element in \a this
4155 * array, all elements processed before detection of the zero element remain
4158 void DataArrayDouble::applyRPow(double val)
4162 throw INTERP_KERNEL::Exception("DataArrayDouble::applyRPow : the input value has to be >= 0 !");
4163 double *ptr=getPointer();
4164 std::size_t nbOfElems=getNbOfElems();
4165 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
4171 * Returns a new DataArrayDouble created from \a this one by applying \a
4172 * FunctionToEvaluate to every tuple of \a this array. Textual data is not copied.
4173 * For more info see \ref MEDCouplingArrayApplyFunc
4174 * \param [in] nbOfComp - number of components in the result array.
4175 * \param [in] func - the \a FunctionToEvaluate declared as
4176 * \c bool (*\a func)(\c const \c double *\a pos, \c double *\a res),
4177 * where \a pos points to the first component of a tuple of \a this array
4178 * and \a res points to the first component of a tuple of the result array.
4179 * Note that length (number of components) of \a pos can differ from
4181 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
4182 * same number of tuples as \a this array.
4183 * The caller is to delete this result array using decrRef() as it is no more
4185 * \throw If \a this is not allocated.
4186 * \throw If \a func returns \a false.
4188 DataArrayDouble *DataArrayDouble::applyFunc(int nbOfComp, FunctionToEvaluate func) const
4191 DataArrayDouble *newArr=DataArrayDouble::New();
4192 int nbOfTuples=getNumberOfTuples();
4193 int oldNbOfComp=getNumberOfComponents();
4194 newArr->alloc(nbOfTuples,nbOfComp);
4195 const double *ptr=getConstPointer();
4196 double *ptrToFill=newArr->getPointer();
4197 for(int i=0;i<nbOfTuples;i++)
4199 if(!func(ptr+i*oldNbOfComp,ptrToFill+i*nbOfComp))
4201 std::ostringstream oss; oss << "For tuple # " << i << " with value (";
4202 std::copy(ptr+oldNbOfComp*i,ptr+oldNbOfComp*(i+1),std::ostream_iterator<double>(oss,", "));
4203 oss << ") : Evaluation of function failed !";
4205 throw INTERP_KERNEL::Exception(oss.str().c_str());
4212 * Returns a new DataArrayDouble created from \a this one by applying a function to every
4213 * tuple of \a this array. Textual data is not copied.
4214 * For more info see \ref MEDCouplingArrayApplyFunc1.
4215 * \param [in] nbOfComp - number of components in the result array.
4216 * \param [in] func - the expression defining how to transform a tuple of \a this array.
4217 * Supported expressions are described \ref MEDCouplingArrayApplyFuncExpr "here".
4218 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
4219 * same number of tuples as \a this array and \a nbOfComp components.
4220 * The caller is to delete this result array using decrRef() as it is no more
4222 * \throw If \a this is not allocated.
4223 * \throw If computing \a func fails.
4225 DataArrayDouble *DataArrayDouble::applyFunc(int nbOfComp, const char *func) const
4228 INTERP_KERNEL::ExprParser expr(func);
4230 std::set<std::string> vars;
4231 expr.getTrueSetOfVars(vars);
4232 int oldNbOfComp=getNumberOfComponents();
4233 if((int)vars.size()>oldNbOfComp)
4235 std::ostringstream oss; oss << "The field has " << oldNbOfComp << " components and there are ";
4236 oss << vars.size() << " variables : ";
4237 std::copy(vars.begin(),vars.end(),std::ostream_iterator<std::string>(oss," "));
4238 throw INTERP_KERNEL::Exception(oss.str().c_str());
4240 std::vector<std::string> varsV(vars.begin(),vars.end());
4241 expr.prepareExprEvaluation(varsV,oldNbOfComp,nbOfComp);
4243 DataArrayDouble *newArr=DataArrayDouble::New();
4244 int nbOfTuples=getNumberOfTuples();
4245 newArr->alloc(nbOfTuples,nbOfComp);
4246 const double *ptr=getConstPointer();
4247 double *ptrToFill=newArr->getPointer();
4248 for(int i=0;i<nbOfTuples;i++)
4252 expr.evaluateExpr(nbOfComp,ptr+i*oldNbOfComp,ptrToFill+i*nbOfComp);
4254 catch(INTERP_KERNEL::Exception& e)
4256 std::ostringstream oss; oss << "For tuple # " << i << " with value (";
4257 std::copy(ptr+oldNbOfComp*i,ptr+oldNbOfComp*(i+1),std::ostream_iterator<double>(oss,", "));
4258 oss << ") : Evaluation of function failed !" << e.what();
4260 throw INTERP_KERNEL::Exception(oss.str().c_str());
4267 * Returns a new DataArrayDouble created from \a this one by applying a function to every
4268 * tuple of \a this array. Textual data is not copied.
4269 * For more info see \ref MEDCouplingArrayApplyFunc0.
4270 * \param [in] func - the expression defining how to transform a tuple of \a this array.
4271 * Supported expressions are described \ref MEDCouplingArrayApplyFuncExpr "here".
4272 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
4273 * same number of tuples and components as \a this array.
4274 * The caller is to delete this result array using decrRef() as it is no more
4276 * \throw If \a this is not allocated.
4277 * \throw If computing \a func fails.
4279 DataArrayDouble *DataArrayDouble::applyFunc(const char *func) const
4282 INTERP_KERNEL::ExprParser expr(func);
4284 expr.prepareExprEvaluationVec();
4286 DataArrayDouble *newArr=DataArrayDouble::New();
4287 int nbOfTuples=getNumberOfTuples();
4288 int nbOfComp=getNumberOfComponents();
4289 newArr->alloc(nbOfTuples,nbOfComp);
4290 const double *ptr=getConstPointer();
4291 double *ptrToFill=newArr->getPointer();
4292 for(int i=0;i<nbOfTuples;i++)
4296 expr.evaluateExpr(nbOfComp,ptr+i*nbOfComp,ptrToFill+i*nbOfComp);
4298 catch(INTERP_KERNEL::Exception& e)
4300 std::ostringstream oss; oss << "For tuple # " << i << " with value (";
4301 std::copy(ptr+nbOfComp*i,ptr+nbOfComp*(i+1),std::ostream_iterator<double>(oss,", "));
4302 oss << ") : Evaluation of function failed ! " << e.what();
4304 throw INTERP_KERNEL::Exception(oss.str().c_str());
4311 * Returns a new DataArrayDouble created from \a this one by applying a function to every
4312 * tuple of \a this array. Textual data is not copied.
4313 * For more info see \ref MEDCouplingArrayApplyFunc2.
4314 * \param [in] nbOfComp - number of components in the result array.
4315 * \param [in] func - the expression defining how to transform a tuple of \a this array.
4316 * Supported expressions are described \ref MEDCouplingArrayApplyFuncExpr "here".
4317 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
4318 * same number of tuples as \a this array.
4319 * The caller is to delete this result array using decrRef() as it is no more
4321 * \throw If \a this is not allocated.
4322 * \throw If \a func contains vars that are not in \a this->getInfoOnComponent().
4323 * \throw If computing \a func fails.
4325 DataArrayDouble *DataArrayDouble::applyFunc2(int nbOfComp, const char *func) const
4328 INTERP_KERNEL::ExprParser expr(func);
4330 std::set<std::string> vars;
4331 expr.getTrueSetOfVars(vars);
4332 int oldNbOfComp=getNumberOfComponents();
4333 if((int)vars.size()>oldNbOfComp)
4335 std::ostringstream oss; oss << "The field has " << oldNbOfComp << " components and there are ";
4336 oss << vars.size() << " variables : ";
4337 std::copy(vars.begin(),vars.end(),std::ostream_iterator<std::string>(oss," "));
4338 throw INTERP_KERNEL::Exception(oss.str().c_str());
4340 expr.prepareExprEvaluation(getVarsOnComponent(),oldNbOfComp,nbOfComp);
4342 DataArrayDouble *newArr=DataArrayDouble::New();
4343 int nbOfTuples=getNumberOfTuples();
4344 newArr->alloc(nbOfTuples,nbOfComp);
4345 const double *ptr=getConstPointer();
4346 double *ptrToFill=newArr->getPointer();
4347 for(int i=0;i<nbOfTuples;i++)
4351 expr.evaluateExpr(nbOfComp,ptr+i*oldNbOfComp,ptrToFill+i*nbOfComp);
4353 catch(INTERP_KERNEL::Exception& e)
4355 std::ostringstream oss; oss << "For tuple # " << i << " with value (";
4356 std::copy(ptr+oldNbOfComp*i,ptr+oldNbOfComp*(i+1),std::ostream_iterator<double>(oss,", "));
4357 oss << ") : Evaluation of function failed !" << e.what();
4359 throw INTERP_KERNEL::Exception(oss.str().c_str());
4366 * Returns a new DataArrayDouble created from \a this one by applying a function to every
4367 * tuple of \a this array. Textual data is not copied.
4368 * For more info see \ref MEDCouplingArrayApplyFunc3.
4369 * \param [in] nbOfComp - number of components in the result array.
4370 * \param [in] varsOrder - sequence of vars defining their order.
4371 * \param [in] func - the expression defining how to transform a tuple of \a this array.
4372 * Supported expressions are described \ref MEDCouplingArrayApplyFuncExpr "here".
4373 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
4374 * same number of tuples as \a this array.
4375 * The caller is to delete this result array using decrRef() as it is no more
4377 * \throw If \a this is not allocated.
4378 * \throw If \a func contains vars not in \a varsOrder.
4379 * \throw If computing \a func fails.
4381 DataArrayDouble *DataArrayDouble::applyFunc3(int nbOfComp, const std::vector<std::string>& varsOrder, const char *func) const
4384 INTERP_KERNEL::ExprParser expr(func);
4386 std::set<std::string> vars;
4387 expr.getTrueSetOfVars(vars);
4388 int oldNbOfComp=getNumberOfComponents();
4389 if((int)vars.size()>oldNbOfComp)
4391 std::ostringstream oss; oss << "The field has " << oldNbOfComp << " components and there are ";
4392 oss << vars.size() << " variables : ";
4393 std::copy(vars.begin(),vars.end(),std::ostream_iterator<std::string>(oss," "));
4394 throw INTERP_KERNEL::Exception(oss.str().c_str());
4396 expr.prepareExprEvaluation(varsOrder,oldNbOfComp,nbOfComp);
4398 DataArrayDouble *newArr=DataArrayDouble::New();
4399 int nbOfTuples=getNumberOfTuples();
4400 newArr->alloc(nbOfTuples,nbOfComp);
4401 const double *ptr=getConstPointer();
4402 double *ptrToFill=newArr->getPointer();
4403 for(int i=0;i<nbOfTuples;i++)
4407 expr.evaluateExpr(nbOfComp,ptr+i*oldNbOfComp,ptrToFill+i*nbOfComp);
4409 catch(INTERP_KERNEL::Exception& e)
4411 std::ostringstream oss; oss << "For tuple # " << i << " with value (";
4412 std::copy(ptr+oldNbOfComp*i,ptr+oldNbOfComp*(i+1),std::ostream_iterator<double>(oss,", "));
4413 oss << ") : Evaluation of function failed !" << e.what();
4415 throw INTERP_KERNEL::Exception(oss.str().c_str());
4421 void DataArrayDouble::applyFuncFast32(const char *func)
4424 INTERP_KERNEL::ExprParser expr(func);
4426 char *funcStr=expr.compileX86();
4428 *((void **)&funcPtr)=funcStr;//he he...
4430 double *ptr=getPointer();
4431 int nbOfComp=getNumberOfComponents();
4432 int nbOfTuples=getNumberOfTuples();
4433 int nbOfElems=nbOfTuples*nbOfComp;
4434 for(int i=0;i<nbOfElems;i++,ptr++)
4439 void DataArrayDouble::applyFuncFast64(const char *func)
4442 INTERP_KERNEL::ExprParser expr(func);
4444 char *funcStr=expr.compileX86_64();
4446 *((void **)&funcPtr)=funcStr;//he he...
4448 double *ptr=getPointer();
4449 int nbOfComp=getNumberOfComponents();
4450 int nbOfTuples=getNumberOfTuples();
4451 int nbOfElems=nbOfTuples*nbOfComp;
4452 for(int i=0;i<nbOfElems;i++,ptr++)
4457 DataArrayDoubleIterator *DataArrayDouble::iterator()
4459 return new DataArrayDoubleIterator(this);
4463 * Returns a new DataArrayInt contating indices of tuples of \a this one-dimensional
4464 * array whose values are within a given range. Textual data is not copied.
4465 * \param [in] vmin - a lowest acceptable value (included).
4466 * \param [in] vmax - a greatest acceptable value (included).
4467 * \return DataArrayInt * - the new instance of DataArrayInt.
4468 * The caller is to delete this result array using decrRef() as it is no more
4470 * \throw If \a this->getNumberOfComponents() != 1.
4472 * \sa DataArrayDouble::getIdsNotInRange
4474 * \ref cpp_mcdataarraydouble_getidsinrange "Here is a C++ example".<br>
4475 * \ref py_mcdataarraydouble_getidsinrange "Here is a Python example".
4477 DataArrayInt *DataArrayDouble::getIdsInRange(double vmin, double vmax) const
4480 if(getNumberOfComponents()!=1)
4481 throw INTERP_KERNEL::Exception("DataArrayDouble::getIdsInRange : this must have exactly one component !");
4482 const double *cptr(begin());
4483 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
4484 int nbOfTuples(getNumberOfTuples());
4485 for(int i=0;i<nbOfTuples;i++,cptr++)
4486 if(*cptr>=vmin && *cptr<=vmax)
4487 ret->pushBackSilent(i);
4492 * Returns a new DataArrayInt contating indices of tuples of \a this one-dimensional
4493 * array whose values are not within a given range. Textual data is not copied.
4494 * \param [in] vmin - a lowest not acceptable value (excluded).
4495 * \param [in] vmax - a greatest not acceptable value (excluded).
4496 * \return DataArrayInt * - the new instance of DataArrayInt.
4497 * The caller is to delete this result array using decrRef() as it is no more
4499 * \throw If \a this->getNumberOfComponents() != 1.
4501 * \sa DataArrayDouble::getIdsInRange
4503 DataArrayInt *DataArrayDouble::getIdsNotInRange(double vmin, double vmax) const
4506 if(getNumberOfComponents()!=1)
4507 throw INTERP_KERNEL::Exception("DataArrayDouble::getIdsNotInRange : this must have exactly one component !");
4508 const double *cptr(begin());
4509 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
4510 int nbOfTuples(getNumberOfTuples());
4511 for(int i=0;i<nbOfTuples;i++,cptr++)
4512 if(*cptr<vmin || *cptr>vmax)
4513 ret->pushBackSilent(i);
4518 * Returns a new DataArrayDouble by concatenating two given arrays, so that (1) the number
4519 * of tuples in the result array is a sum of the number of tuples of given arrays and (2)
4520 * the number of component in the result array is same as that of each of given arrays.
4521 * Info on components is copied from the first of the given arrays. Number of components
4522 * in the given arrays must be the same.
4523 * \param [in] a1 - an array to include in the result array.
4524 * \param [in] a2 - another array to include in the result array.
4525 * \return DataArrayDouble * - the new instance of DataArrayDouble.
4526 * The caller is to delete this result array using decrRef() as it is no more
4528 * \throw If both \a a1 and \a a2 are NULL.
4529 * \throw If \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents().
4531 DataArrayDouble *DataArrayDouble::Aggregate(const DataArrayDouble *a1, const DataArrayDouble *a2)
4533 std::vector<const DataArrayDouble *> tmp(2);
4534 tmp[0]=a1; tmp[1]=a2;
4535 return Aggregate(tmp);
4539 * Returns a new DataArrayDouble by concatenating all given arrays, so that (1) the number
4540 * of tuples in the result array is a sum of the number of tuples of given arrays and (2)
4541 * the number of component in the result array is same as that of each of given arrays.
4542 * Info on components is copied from the first of the given arrays. Number of components
4543 * in the given arrays must be the same.
4544 * \param [in] arr - a sequence of arrays to include in the result array.
4545 * \return DataArrayDouble * - the new instance of DataArrayDouble.
4546 * The caller is to delete this result array using decrRef() as it is no more
4548 * \throw If all arrays within \a arr are NULL.
4549 * \throw If getNumberOfComponents() of arrays within \a arr.
4551 DataArrayDouble *DataArrayDouble::Aggregate(const std::vector<const DataArrayDouble *>& arr)
4553 std::vector<const DataArrayDouble *> a;
4554 for(std::vector<const DataArrayDouble *>::const_iterator it4=arr.begin();it4!=arr.end();it4++)
4558 throw INTERP_KERNEL::Exception("DataArrayDouble::Aggregate : input list must contain at least one NON EMPTY DataArrayDouble !");
4559 std::vector<const DataArrayDouble *>::const_iterator it=a.begin();
4560 int nbOfComp=(*it)->getNumberOfComponents();
4561 int nbt=(*it++)->getNumberOfTuples();
4562 for(int i=1;it!=a.end();it++,i++)
4564 if((*it)->getNumberOfComponents()!=nbOfComp)
4565 throw INTERP_KERNEL::Exception("DataArrayDouble::Aggregate : Nb of components mismatch for array aggregation !");
4566 nbt+=(*it)->getNumberOfTuples();
4568 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
4569 ret->alloc(nbt,nbOfComp);
4570 double *pt=ret->getPointer();
4571 for(it=a.begin();it!=a.end();it++)
4572 pt=std::copy((*it)->getConstPointer(),(*it)->getConstPointer()+(*it)->getNbOfElems(),pt);
4573 ret->copyStringInfoFrom(*(a[0]));
4578 * Returns a new DataArrayDouble by aggregating two given arrays, so that (1) the number
4579 * of components in the result array is a sum of the number of components of given arrays
4580 * and (2) the number of tuples in the result array is same as that of each of given
4581 * arrays. In other words the i-th tuple of result array includes all components of
4582 * i-th tuples of all given arrays.
4583 * Number of tuples in the given arrays must be the same.
4584 * \param [in] a1 - an array to include in the result array.
4585 * \param [in] a2 - another array to include in the result array.
4586 * \return DataArrayDouble * - the new instance of DataArrayDouble.
4587 * The caller is to delete this result array using decrRef() as it is no more
4589 * \throw If both \a a1 and \a a2 are NULL.
4590 * \throw If any given array is not allocated.
4591 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
4593 DataArrayDouble *DataArrayDouble::Meld(const DataArrayDouble *a1, const DataArrayDouble *a2)
4595 std::vector<const DataArrayDouble *> arr(2);
4596 arr[0]=a1; arr[1]=a2;
4601 * Returns a new DataArrayDouble by aggregating all given arrays, so that (1) the number
4602 * of components in the result array is a sum of the number of components of given arrays
4603 * and (2) the number of tuples in the result array is same as that of each of given
4604 * arrays. In other words the i-th tuple of result array includes all components of
4605 * i-th tuples of all given arrays.
4606 * Number of tuples in the given arrays must be the same.
4607 * \param [in] arr - a sequence of arrays to include in the result array.
4608 * \return DataArrayDouble * - the new instance of DataArrayDouble.
4609 * The caller is to delete this result array using decrRef() as it is no more
4611 * \throw If all arrays within \a arr are NULL.
4612 * \throw If any given array is not allocated.
4613 * \throw If getNumberOfTuples() of arrays within \a arr is different.
4615 DataArrayDouble *DataArrayDouble::Meld(const std::vector<const DataArrayDouble *>& arr)
4617 std::vector<const DataArrayDouble *> a;
4618 for(std::vector<const DataArrayDouble *>::const_iterator it4=arr.begin();it4!=arr.end();it4++)
4622 throw INTERP_KERNEL::Exception("DataArrayDouble::Meld : input list must contain at least one NON EMPTY DataArrayDouble !");
4623 std::vector<const DataArrayDouble *>::const_iterator it;
4624 for(it=a.begin();it!=a.end();it++)
4625 (*it)->checkAllocated();
4627 int nbOfTuples=(*it)->getNumberOfTuples();
4628 std::vector<int> nbc(a.size());
4629 std::vector<const double *> pts(a.size());
4630 nbc[0]=(*it)->getNumberOfComponents();
4631 pts[0]=(*it++)->getConstPointer();
4632 for(int i=1;it!=a.end();it++,i++)
4634 if(nbOfTuples!=(*it)->getNumberOfTuples())
4635 throw INTERP_KERNEL::Exception("DataArrayDouble::Meld : mismatch of number of tuples !");
4636 nbc[i]=(*it)->getNumberOfComponents();
4637 pts[i]=(*it)->getConstPointer();
4639 int totalNbOfComp=std::accumulate(nbc.begin(),nbc.end(),0);
4640 DataArrayDouble *ret=DataArrayDouble::New();
4641 ret->alloc(nbOfTuples,totalNbOfComp);
4642 double *retPtr=ret->getPointer();
4643 for(int i=0;i<nbOfTuples;i++)
4644 for(int j=0;j<(int)a.size();j++)
4646 retPtr=std::copy(pts[j],pts[j]+nbc[j],retPtr);
4650 for(int i=0;i<(int)a.size();i++)
4651 for(int j=0;j<nbc[i];j++,k++)
4652 ret->setInfoOnComponent(k,a[i]->getInfoOnComponent(j).c_str());
4657 * Returns a new DataArrayDouble containing a dot product of two given arrays, so that
4658 * the i-th tuple of the result array is a sum of products of j-th components of i-th
4659 * tuples of given arrays (\f$ a_i = \sum_{j=1}^n a1_j * a2_j \f$).
4660 * Info on components and name is copied from the first of the given arrays.
4661 * Number of tuples and components in the given arrays must be the same.
4662 * \param [in] a1 - a given array.
4663 * \param [in] a2 - another given array.
4664 * \return DataArrayDouble * - the new instance of DataArrayDouble.
4665 * The caller is to delete this result array using decrRef() as it is no more
4667 * \throw If either \a a1 or \a a2 is NULL.
4668 * \throw If any given array is not allocated.
4669 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
4670 * \throw If \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents()
4672 DataArrayDouble *DataArrayDouble::Dot(const DataArrayDouble *a1, const DataArrayDouble *a2)
4675 throw INTERP_KERNEL::Exception("DataArrayDouble::Dot : input DataArrayDouble instance is NULL !");
4676 a1->checkAllocated();
4677 a2->checkAllocated();
4678 int nbOfComp=a1->getNumberOfComponents();
4679 if(nbOfComp!=a2->getNumberOfComponents())
4680 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Dot !");
4681 int nbOfTuple=a1->getNumberOfTuples();
4682 if(nbOfTuple!=a2->getNumberOfTuples())
4683 throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array Dot !");
4684 DataArrayDouble *ret=DataArrayDouble::New();
4685 ret->alloc(nbOfTuple,1);
4686 double *retPtr=ret->getPointer();
4687 const double *a1Ptr=a1->getConstPointer();
4688 const double *a2Ptr=a2->getConstPointer();
4689 for(int i=0;i<nbOfTuple;i++)
4692 for(int j=0;j<nbOfComp;j++)
4693 sum+=a1Ptr[i*nbOfComp+j]*a2Ptr[i*nbOfComp+j];
4696 ret->setInfoOnComponent(0,a1->getInfoOnComponent(0).c_str());
4697 ret->setName(a1->getName().c_str());
4702 * Returns a new DataArrayDouble containing a cross product of two given arrays, so that
4703 * the i-th tuple of the result array contains 3 components of a vector which is a cross
4704 * product of two vectors defined by the i-th tuples of given arrays.
4705 * Info on components is copied from the first of the given arrays.
4706 * Number of tuples in the given arrays must be the same.
4707 * Number of components in the given arrays must be 3.
4708 * \param [in] a1 - a given array.
4709 * \param [in] a2 - another given array.
4710 * \return DataArrayDouble * - the new instance of DataArrayDouble.
4711 * The caller is to delete this result array using decrRef() as it is no more
4713 * \throw If either \a a1 or \a a2 is NULL.
4714 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
4715 * \throw If \a a1->getNumberOfComponents() != 3
4716 * \throw If \a a2->getNumberOfComponents() != 3
4718 DataArrayDouble *DataArrayDouble::CrossProduct(const DataArrayDouble *a1, const DataArrayDouble *a2)
4721 throw INTERP_KERNEL::Exception("DataArrayDouble::CrossProduct : input DataArrayDouble instance is NULL !");
4722 int nbOfComp=a1->getNumberOfComponents();
4723 if(nbOfComp!=a2->getNumberOfComponents())
4724 throw INTERP_KERNEL::Exception("Nb of components mismatch for array crossProduct !");
4726 throw INTERP_KERNEL::Exception("Nb of components must be equal to 3 for array crossProduct !");
4727 int nbOfTuple=a1->getNumberOfTuples();
4728 if(nbOfTuple!=a2->getNumberOfTuples())
4729 throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array crossProduct !");
4730 DataArrayDouble *ret=DataArrayDouble::New();
4731 ret->alloc(nbOfTuple,3);
4732 double *retPtr=ret->getPointer();
4733 const double *a1Ptr=a1->getConstPointer();
4734 const double *a2Ptr=a2->getConstPointer();
4735 for(int i=0;i<nbOfTuple;i++)
4737 retPtr[3*i]=a1Ptr[3*i+1]*a2Ptr[3*i+2]-a1Ptr[3*i+2]*a2Ptr[3*i+1];
4738 retPtr[3*i+1]=a1Ptr[3*i+2]*a2Ptr[3*i]-a1Ptr[3*i]*a2Ptr[3*i+2];
4739 retPtr[3*i+2]=a1Ptr[3*i]*a2Ptr[3*i+1]-a1Ptr[3*i+1]*a2Ptr[3*i];
4741 ret->copyStringInfoFrom(*a1);
4746 * Returns a new DataArrayDouble containing maximal values of two given arrays.
4747 * Info on components is copied from the first of the given arrays.
4748 * Number of tuples and components in the given arrays must be the same.
4749 * \param [in] a1 - an array to compare values with another one.
4750 * \param [in] a2 - another array to compare values with the first one.
4751 * \return DataArrayDouble * - the new instance of DataArrayDouble.
4752 * The caller is to delete this result array using decrRef() as it is no more
4754 * \throw If either \a a1 or \a a2 is NULL.
4755 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
4756 * \throw If \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents()
4758 DataArrayDouble *DataArrayDouble::Max(const DataArrayDouble *a1, const DataArrayDouble *a2)
4761 throw INTERP_KERNEL::Exception("DataArrayDouble::Max : input DataArrayDouble instance is NULL !");
4762 int nbOfComp=a1->getNumberOfComponents();
4763 if(nbOfComp!=a2->getNumberOfComponents())
4764 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Max !");
4765 int nbOfTuple=a1->getNumberOfTuples();
4766 if(nbOfTuple!=a2->getNumberOfTuples())
4767 throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array Max !");
4768 DataArrayDouble *ret=DataArrayDouble::New();
4769 ret->alloc(nbOfTuple,nbOfComp);
4770 double *retPtr=ret->getPointer();
4771 const double *a1Ptr=a1->getConstPointer();
4772 const double *a2Ptr=a2->getConstPointer();
4773 int nbElem=nbOfTuple*nbOfComp;
4774 for(int i=0;i<nbElem;i++)
4775 retPtr[i]=std::max(a1Ptr[i],a2Ptr[i]);
4776 ret->copyStringInfoFrom(*a1);
4781 * Returns a new DataArrayDouble containing minimal values of two given arrays.
4782 * Info on components is copied from the first of the given arrays.
4783 * Number of tuples and components in the given arrays must be the same.
4784 * \param [in] a1 - an array to compare values with another one.
4785 * \param [in] a2 - another array to compare values with the first one.
4786 * \return DataArrayDouble * - the new instance of DataArrayDouble.
4787 * The caller is to delete this result array using decrRef() as it is no more
4789 * \throw If either \a a1 or \a a2 is NULL.
4790 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
4791 * \throw If \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents()
4793 DataArrayDouble *DataArrayDouble::Min(const DataArrayDouble *a1, const DataArrayDouble *a2)
4796 throw INTERP_KERNEL::Exception("DataArrayDouble::Min : input DataArrayDouble instance is NULL !");
4797 int nbOfComp=a1->getNumberOfComponents();
4798 if(nbOfComp!=a2->getNumberOfComponents())
4799 throw INTERP_KERNEL::Exception("Nb of components mismatch for array min !");
4800 int nbOfTuple=a1->getNumberOfTuples();
4801 if(nbOfTuple!=a2->getNumberOfTuples())
4802 throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array min !");
4803 DataArrayDouble *ret=DataArrayDouble::New();
4804 ret->alloc(nbOfTuple,nbOfComp);
4805 double *retPtr=ret->getPointer();
4806 const double *a1Ptr=a1->getConstPointer();
4807 const double *a2Ptr=a2->getConstPointer();
4808 int nbElem=nbOfTuple*nbOfComp;
4809 for(int i=0;i<nbElem;i++)
4810 retPtr[i]=std::min(a1Ptr[i],a2Ptr[i]);
4811 ret->copyStringInfoFrom(*a1);
4816 * Returns a new DataArrayDouble that is a sum of two given arrays. There are 3
4818 * 1. The arrays have same number of tuples and components. Then each value of
4819 * the result array (_a_) is a sum of the corresponding values of \a a1 and \a a2,
4820 * i.e.: _a_ [ i, j ] = _a1_ [ i, j ] + _a2_ [ i, j ].
4821 * 2. The arrays have same number of tuples and one array, say _a2_, has one
4823 * _a_ [ i, j ] = _a1_ [ i, j ] + _a2_ [ i, 0 ].
4824 * 3. The arrays have same number of components and one array, say _a2_, has one
4826 * _a_ [ i, j ] = _a1_ [ i, j ] + _a2_ [ 0, j ].
4828 * Info on components is copied either from the first array (in the first case) or from
4829 * the array with maximal number of elements (getNbOfElems()).
4830 * \param [in] a1 - an array to sum up.
4831 * \param [in] a2 - another array to sum up.
4832 * \return DataArrayDouble * - the new instance of DataArrayDouble.
4833 * The caller is to delete this result array using decrRef() as it is no more
4835 * \throw If either \a a1 or \a a2 is NULL.
4836 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
4837 * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
4838 * none of them has number of tuples or components equal to 1.
4840 DataArrayDouble *DataArrayDouble::Add(const DataArrayDouble *a1, const DataArrayDouble *a2)
4843 throw INTERP_KERNEL::Exception("DataArrayDouble::Add : input DataArrayDouble instance is NULL !");
4844 int nbOfTuple=a1->getNumberOfTuples();
4845 int nbOfTuple2=a2->getNumberOfTuples();
4846 int nbOfComp=a1->getNumberOfComponents();
4847 int nbOfComp2=a2->getNumberOfComponents();
4848 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=0;
4849 if(nbOfTuple==nbOfTuple2)
4851 if(nbOfComp==nbOfComp2)
4853 ret=DataArrayDouble::New();
4854 ret->alloc(nbOfTuple,nbOfComp);
4855 std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::plus<double>());
4856 ret->copyStringInfoFrom(*a1);
4860 int nbOfCompMin,nbOfCompMax;
4861 const DataArrayDouble *aMin, *aMax;
4862 if(nbOfComp>nbOfComp2)
4864 nbOfCompMin=nbOfComp2; nbOfCompMax=nbOfComp;
4869 nbOfCompMin=nbOfComp; nbOfCompMax=nbOfComp2;
4874 ret=DataArrayDouble::New();
4875 ret->alloc(nbOfTuple,nbOfCompMax);
4876 const double *aMinPtr=aMin->getConstPointer();
4877 const double *aMaxPtr=aMax->getConstPointer();
4878 double *res=ret->getPointer();
4879 for(int i=0;i<nbOfTuple;i++)
4880 res=std::transform(aMaxPtr+i*nbOfCompMax,aMaxPtr+(i+1)*nbOfCompMax,res,std::bind2nd(std::plus<double>(),aMinPtr[i]));
4881 ret->copyStringInfoFrom(*aMax);
4884 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Add !");
4887 else if((nbOfTuple==1 && nbOfTuple2>1) || (nbOfTuple>1 && nbOfTuple2==1))
4889 if(nbOfComp==nbOfComp2)
4891 int nbOfTupleMax=std::max(nbOfTuple,nbOfTuple2);
4892 const DataArrayDouble *aMin=nbOfTuple>nbOfTuple2?a2:a1;
4893 const DataArrayDouble *aMax=nbOfTuple>nbOfTuple2?a1:a2;
4894 const double *aMinPtr=aMin->getConstPointer(),*aMaxPtr=aMax->getConstPointer();
4895 ret=DataArrayDouble::New();
4896 ret->alloc(nbOfTupleMax,nbOfComp);
4897 double *res=ret->getPointer();
4898 for(int i=0;i<nbOfTupleMax;i++)
4899 res=std::transform(aMaxPtr+i*nbOfComp,aMaxPtr+(i+1)*nbOfComp,aMinPtr,res,std::plus<double>());
4900 ret->copyStringInfoFrom(*aMax);
4903 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Add !");
4906 throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array Add !");
4911 * Adds values of another DataArrayDouble to values of \a this one. There are 3
4913 * 1. The arrays have same number of tuples and components. Then each value of
4914 * \a other array is added to the corresponding value of \a this array, i.e.:
4915 * _a_ [ i, j ] += _other_ [ i, j ].
4916 * 2. The arrays have same number of tuples and \a other array has one component. Then
4917 * _a_ [ i, j ] += _other_ [ i, 0 ].
4918 * 3. The arrays have same number of components and \a other array has one tuple. Then
4919 * _a_ [ i, j ] += _a2_ [ 0, j ].
4921 * \param [in] other - an array to add to \a this one.
4922 * \throw If \a other is NULL.
4923 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
4924 * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
4925 * \a other has number of both tuples and components not equal to 1.
4927 void DataArrayDouble::addEqual(const DataArrayDouble *other)
4930 throw INTERP_KERNEL::Exception("DataArrayDouble::addEqual : input DataArrayDouble instance is NULL !");
4931 const char *msg="Nb of tuples mismatch for DataArrayDouble::addEqual !";
4933 other->checkAllocated();
4934 int nbOfTuple=getNumberOfTuples();
4935 int nbOfTuple2=other->getNumberOfTuples();
4936 int nbOfComp=getNumberOfComponents();
4937 int nbOfComp2=other->getNumberOfComponents();
4938 if(nbOfTuple==nbOfTuple2)
4940 if(nbOfComp==nbOfComp2)
4942 std::transform(begin(),end(),other->begin(),getPointer(),std::plus<double>());
4944 else if(nbOfComp2==1)
4946 double *ptr=getPointer();
4947 const double *ptrc=other->getConstPointer();
4948 for(int i=0;i<nbOfTuple;i++)
4949 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::plus<double>(),*ptrc++));
4952 throw INTERP_KERNEL::Exception(msg);
4954 else if(nbOfTuple2==1)
4956 if(nbOfComp2==nbOfComp)
4958 double *ptr=getPointer();
4959 const double *ptrc=other->getConstPointer();
4960 for(int i=0;i<nbOfTuple;i++)
4961 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::plus<double>());
4964 throw INTERP_KERNEL::Exception(msg);
4967 throw INTERP_KERNEL::Exception(msg);
4972 * Returns a new DataArrayDouble that is a subtraction of two given arrays. There are 3
4974 * 1. The arrays have same number of tuples and components. Then each value of
4975 * the result array (_a_) is a subtraction of the corresponding values of \a a1 and
4976 * \a a2, i.e.: _a_ [ i, j ] = _a1_ [ i, j ] - _a2_ [ i, j ].
4977 * 2. The arrays have same number of tuples and one array, say _a2_, has one
4979 * _a_ [ i, j ] = _a1_ [ i, j ] - _a2_ [ i, 0 ].
4980 * 3. The arrays have same number of components and one array, say _a2_, has one
4982 * _a_ [ i, j ] = _a1_ [ i, j ] - _a2_ [ 0, j ].
4984 * Info on components is copied either from the first array (in the first case) or from
4985 * the array with maximal number of elements (getNbOfElems()).
4986 * \param [in] a1 - an array to subtract from.
4987 * \param [in] a2 - an array to subtract.
4988 * \return DataArrayDouble * - the new instance of DataArrayDouble.
4989 * The caller is to delete this result array using decrRef() as it is no more
4991 * \throw If either \a a1 or \a a2 is NULL.
4992 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
4993 * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
4994 * none of them has number of tuples or components equal to 1.
4996 DataArrayDouble *DataArrayDouble::Substract(const DataArrayDouble *a1, const DataArrayDouble *a2)
4999 throw INTERP_KERNEL::Exception("DataArrayDouble::Substract : input DataArrayDouble instance is NULL !");
5000 int nbOfTuple1=a1->getNumberOfTuples();
5001 int nbOfTuple2=a2->getNumberOfTuples();
5002 int nbOfComp1=a1->getNumberOfComponents();
5003 int nbOfComp2=a2->getNumberOfComponents();
5004 if(nbOfTuple2==nbOfTuple1)
5006 if(nbOfComp1==nbOfComp2)
5008 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
5009 ret->alloc(nbOfTuple2,nbOfComp1);
5010 std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::minus<double>());
5011 ret->copyStringInfoFrom(*a1);
5014 else if(nbOfComp2==1)
5016 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
5017 ret->alloc(nbOfTuple1,nbOfComp1);
5018 const double *a2Ptr=a2->getConstPointer();
5019 const double *a1Ptr=a1->getConstPointer();
5020 double *res=ret->getPointer();
5021 for(int i=0;i<nbOfTuple1;i++)
5022 res=std::transform(a1Ptr+i*nbOfComp1,a1Ptr+(i+1)*nbOfComp1,res,std::bind2nd(std::minus<double>(),a2Ptr[i]));
5023 ret->copyStringInfoFrom(*a1);
5028 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Substract !");
5032 else if(nbOfTuple2==1)
5034 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Substract !");
5035 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
5036 ret->alloc(nbOfTuple1,nbOfComp1);
5037 const double *a1ptr=a1->getConstPointer(),*a2ptr=a2->getConstPointer();
5038 double *pt=ret->getPointer();
5039 for(int i=0;i<nbOfTuple1;i++)
5040 pt=std::transform(a1ptr+i*nbOfComp1,a1ptr+(i+1)*nbOfComp1,a2ptr,pt,std::minus<double>());
5041 ret->copyStringInfoFrom(*a1);
5046 a1->checkNbOfTuples(nbOfTuple2,"Nb of tuples mismatch for array Substract !");//will always throw an exception
5052 * Subtract values of another DataArrayDouble from values of \a this one. There are 3
5054 * 1. The arrays have same number of tuples and components. Then each value of
5055 * \a other array is subtracted from the corresponding value of \a this array, i.e.:
5056 * _a_ [ i, j ] -= _other_ [ i, j ].
5057 * 2. The arrays have same number of tuples and \a other array has one component. Then
5058 * _a_ [ i, j ] -= _other_ [ i, 0 ].
5059 * 3. The arrays have same number of components and \a other array has one tuple. Then
5060 * _a_ [ i, j ] -= _a2_ [ 0, j ].
5062 * \param [in] other - an array to subtract from \a this one.
5063 * \throw If \a other is NULL.
5064 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
5065 * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
5066 * \a other has number of both tuples and components not equal to 1.
5068 void DataArrayDouble::substractEqual(const DataArrayDouble *other)
5071 throw INTERP_KERNEL::Exception("DataArrayDouble::substractEqual : input DataArrayDouble instance is NULL !");
5072 const char *msg="Nb of tuples mismatch for DataArrayDouble::substractEqual !";
5074 other->checkAllocated();
5075 int nbOfTuple=getNumberOfTuples();
5076 int nbOfTuple2=other->getNumberOfTuples();
5077 int nbOfComp=getNumberOfComponents();
5078 int nbOfComp2=other->getNumberOfComponents();
5079 if(nbOfTuple==nbOfTuple2)
5081 if(nbOfComp==nbOfComp2)
5083 std::transform(begin(),end(),other->begin(),getPointer(),std::minus<double>());
5085 else if(nbOfComp2==1)
5087 double *ptr=getPointer();
5088 const double *ptrc=other->getConstPointer();
5089 for(int i=0;i<nbOfTuple;i++)
5090 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::minus<double>(),*ptrc++));
5093 throw INTERP_KERNEL::Exception(msg);
5095 else if(nbOfTuple2==1)
5097 if(nbOfComp2==nbOfComp)
5099 double *ptr=getPointer();
5100 const double *ptrc=other->getConstPointer();
5101 for(int i=0;i<nbOfTuple;i++)
5102 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::minus<double>());
5105 throw INTERP_KERNEL::Exception(msg);
5108 throw INTERP_KERNEL::Exception(msg);
5113 * Returns a new DataArrayDouble that is a product of two given arrays. There are 3
5115 * 1. The arrays have same number of tuples and components. Then each value of
5116 * the result array (_a_) is a product of the corresponding values of \a a1 and
5117 * \a a2, i.e. _a_ [ i, j ] = _a1_ [ i, j ] * _a2_ [ i, j ].
5118 * 2. The arrays have same number of tuples and one array, say _a2_, has one
5120 * _a_ [ i, j ] = _a1_ [ i, j ] * _a2_ [ i, 0 ].
5121 * 3. The arrays have same number of components and one array, say _a2_, has one
5123 * _a_ [ i, j ] = _a1_ [ i, j ] * _a2_ [ 0, j ].
5125 * Info on components is copied either from the first array (in the first case) or from
5126 * the array with maximal number of elements (getNbOfElems()).
5127 * \param [in] a1 - a factor array.
5128 * \param [in] a2 - another factor array.
5129 * \return DataArrayDouble * - the new instance of DataArrayDouble.
5130 * The caller is to delete this result array using decrRef() as it is no more
5132 * \throw If either \a a1 or \a a2 is NULL.
5133 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
5134 * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
5135 * none of them has number of tuples or components equal to 1.
5137 DataArrayDouble *DataArrayDouble::Multiply(const DataArrayDouble *a1, const DataArrayDouble *a2)
5140 throw INTERP_KERNEL::Exception("DataArrayDouble::Multiply : input DataArrayDouble instance is NULL !");
5141 int nbOfTuple=a1->getNumberOfTuples();
5142 int nbOfTuple2=a2->getNumberOfTuples();
5143 int nbOfComp=a1->getNumberOfComponents();
5144 int nbOfComp2=a2->getNumberOfComponents();
5145 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=0;
5146 if(nbOfTuple==nbOfTuple2)
5148 if(nbOfComp==nbOfComp2)
5150 ret=DataArrayDouble::New();
5151 ret->alloc(nbOfTuple,nbOfComp);
5152 std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::multiplies<double>());
5153 ret->copyStringInfoFrom(*a1);
5157 int nbOfCompMin,nbOfCompMax;
5158 const DataArrayDouble *aMin, *aMax;
5159 if(nbOfComp>nbOfComp2)
5161 nbOfCompMin=nbOfComp2; nbOfCompMax=nbOfComp;
5166 nbOfCompMin=nbOfComp; nbOfCompMax=nbOfComp2;
5171 ret=DataArrayDouble::New();
5172 ret->alloc(nbOfTuple,nbOfCompMax);
5173 const double *aMinPtr=aMin->getConstPointer();
5174 const double *aMaxPtr=aMax->getConstPointer();
5175 double *res=ret->getPointer();
5176 for(int i=0;i<nbOfTuple;i++)
5177 res=std::transform(aMaxPtr+i*nbOfCompMax,aMaxPtr+(i+1)*nbOfCompMax,res,std::bind2nd(std::multiplies<double>(),aMinPtr[i]));
5178 ret->copyStringInfoFrom(*aMax);
5181 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Multiply !");
5184 else if((nbOfTuple==1 && nbOfTuple2>1) || (nbOfTuple>1 && nbOfTuple2==1))
5186 if(nbOfComp==nbOfComp2)
5188 int nbOfTupleMax=std::max(nbOfTuple,nbOfTuple2);
5189 const DataArrayDouble *aMin=nbOfTuple>nbOfTuple2?a2:a1;
5190 const DataArrayDouble *aMax=nbOfTuple>nbOfTuple2?a1:a2;
5191 const double *aMinPtr=aMin->getConstPointer(),*aMaxPtr=aMax->getConstPointer();
5192 ret=DataArrayDouble::New();
5193 ret->alloc(nbOfTupleMax,nbOfComp);
5194 double *res=ret->getPointer();
5195 for(int i=0;i<nbOfTupleMax;i++)
5196 res=std::transform(aMaxPtr+i*nbOfComp,aMaxPtr+(i+1)*nbOfComp,aMinPtr,res,std::multiplies<double>());
5197 ret->copyStringInfoFrom(*aMax);
5200 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Multiply !");
5203 throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array Multiply !");
5208 * Multiply values of another DataArrayDouble to values of \a this one. There are 3
5210 * 1. The arrays have same number of tuples and components. Then each value of
5211 * \a other array is multiplied to the corresponding value of \a this array, i.e.
5212 * _this_ [ i, j ] *= _other_ [ i, j ].
5213 * 2. The arrays have same number of tuples and \a other array has one component. Then
5214 * _this_ [ i, j ] *= _other_ [ i, 0 ].
5215 * 3. The arrays have same number of components and \a other array has one tuple. Then
5216 * _this_ [ i, j ] *= _a2_ [ 0, j ].
5218 * \param [in] other - an array to multiply to \a this one.
5219 * \throw If \a other is NULL.
5220 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
5221 * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
5222 * \a other has number of both tuples and components not equal to 1.
5224 void DataArrayDouble::multiplyEqual(const DataArrayDouble *other)
5227 throw INTERP_KERNEL::Exception("DataArrayDouble::multiplyEqual : input DataArrayDouble instance is NULL !");
5228 const char *msg="Nb of tuples mismatch for DataArrayDouble::multiplyEqual !";
5230 other->checkAllocated();
5231 int nbOfTuple=getNumberOfTuples();
5232 int nbOfTuple2=other->getNumberOfTuples();
5233 int nbOfComp=getNumberOfComponents();
5234 int nbOfComp2=other->getNumberOfComponents();
5235 if(nbOfTuple==nbOfTuple2)
5237 if(nbOfComp==nbOfComp2)
5239 std::transform(begin(),end(),other->begin(),getPointer(),std::multiplies<double>());
5241 else if(nbOfComp2==1)
5243 double *ptr=getPointer();
5244 const double *ptrc=other->getConstPointer();
5245 for(int i=0;i<nbOfTuple;i++)
5246 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::multiplies<double>(),*ptrc++));
5249 throw INTERP_KERNEL::Exception(msg);
5251 else if(nbOfTuple2==1)
5253 if(nbOfComp2==nbOfComp)
5255 double *ptr=getPointer();
5256 const double *ptrc=other->getConstPointer();
5257 for(int i=0;i<nbOfTuple;i++)
5258 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::multiplies<double>());
5261 throw INTERP_KERNEL::Exception(msg);
5264 throw INTERP_KERNEL::Exception(msg);
5269 * Returns a new DataArrayDouble that is a division of two given arrays. There are 3
5271 * 1. The arrays have same number of tuples and components. Then each value of
5272 * the result array (_a_) is a division of the corresponding values of \a a1 and
5273 * \a a2, i.e.: _a_ [ i, j ] = _a1_ [ i, j ] / _a2_ [ i, j ].
5274 * 2. The arrays have same number of tuples and one array, say _a2_, has one
5276 * _a_ [ i, j ] = _a1_ [ i, j ] / _a2_ [ i, 0 ].
5277 * 3. The arrays have same number of components and one array, say _a2_, has one
5279 * _a_ [ i, j ] = _a1_ [ i, j ] / _a2_ [ 0, j ].
5281 * Info on components is copied either from the first array (in the first case) or from
5282 * the array with maximal number of elements (getNbOfElems()).
5283 * \warning No check of division by zero is performed!
5284 * \param [in] a1 - a numerator array.
5285 * \param [in] a2 - a denominator array.
5286 * \return DataArrayDouble * - the new instance of DataArrayDouble.
5287 * The caller is to delete this result array using decrRef() as it is no more
5289 * \throw If either \a a1 or \a a2 is NULL.
5290 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
5291 * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
5292 * none of them has number of tuples or components equal to 1.
5294 DataArrayDouble *DataArrayDouble::Divide(const DataArrayDouble *a1, const DataArrayDouble *a2)
5297 throw INTERP_KERNEL::Exception("DataArrayDouble::Divide : input DataArrayDouble instance is NULL !");
5298 int nbOfTuple1=a1->getNumberOfTuples();
5299 int nbOfTuple2=a2->getNumberOfTuples();
5300 int nbOfComp1=a1->getNumberOfComponents();
5301 int nbOfComp2=a2->getNumberOfComponents();
5302 if(nbOfTuple2==nbOfTuple1)
5304 if(nbOfComp1==nbOfComp2)
5306 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
5307 ret->alloc(nbOfTuple2,nbOfComp1);
5308 std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::divides<double>());
5309 ret->copyStringInfoFrom(*a1);
5312 else if(nbOfComp2==1)
5314 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
5315 ret->alloc(nbOfTuple1,nbOfComp1);
5316 const double *a2Ptr=a2->getConstPointer();
5317 const double *a1Ptr=a1->getConstPointer();
5318 double *res=ret->getPointer();
5319 for(int i=0;i<nbOfTuple1;i++)
5320 res=std::transform(a1Ptr+i*nbOfComp1,a1Ptr+(i+1)*nbOfComp1,res,std::bind2nd(std::divides<double>(),a2Ptr[i]));
5321 ret->copyStringInfoFrom(*a1);
5326 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Divide !");
5330 else if(nbOfTuple2==1)
5332 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Divide !");
5333 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
5334 ret->alloc(nbOfTuple1,nbOfComp1);
5335 const double *a1ptr=a1->getConstPointer(),*a2ptr=a2->getConstPointer();
5336 double *pt=ret->getPointer();
5337 for(int i=0;i<nbOfTuple1;i++)
5338 pt=std::transform(a1ptr+i*nbOfComp1,a1ptr+(i+1)*nbOfComp1,a2ptr,pt,std::divides<double>());
5339 ret->copyStringInfoFrom(*a1);
5344 a1->checkNbOfTuples(nbOfTuple2,"Nb of tuples mismatch for array Divide !");//will always throw an exception
5350 * Divide values of \a this array by values of another DataArrayDouble. There are 3
5352 * 1. The arrays have same number of tuples and components. Then each value of
5353 * \a this array is divided by the corresponding value of \a other one, i.e.:
5354 * _a_ [ i, j ] /= _other_ [ i, j ].
5355 * 2. The arrays have same number of tuples and \a other array has one component. Then
5356 * _a_ [ i, j ] /= _other_ [ i, 0 ].
5357 * 3. The arrays have same number of components and \a other array has one tuple. Then
5358 * _a_ [ i, j ] /= _a2_ [ 0, j ].
5360 * \warning No check of division by zero is performed!
5361 * \param [in] other - an array to divide \a this one by.
5362 * \throw If \a other is NULL.
5363 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
5364 * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
5365 * \a other has number of both tuples and components not equal to 1.
5367 void DataArrayDouble::divideEqual(const DataArrayDouble *other)
5370 throw INTERP_KERNEL::Exception("DataArrayDouble::divideEqual : input DataArrayDouble instance is NULL !");
5371 const char *msg="Nb of tuples mismatch for DataArrayDouble::divideEqual !";
5373 other->checkAllocated();
5374 int nbOfTuple=getNumberOfTuples();
5375 int nbOfTuple2=other->getNumberOfTuples();
5376 int nbOfComp=getNumberOfComponents();
5377 int nbOfComp2=other->getNumberOfComponents();
5378 if(nbOfTuple==nbOfTuple2)
5380 if(nbOfComp==nbOfComp2)
5382 std::transform(begin(),end(),other->begin(),getPointer(),std::divides<double>());
5384 else if(nbOfComp2==1)
5386 double *ptr=getPointer();
5387 const double *ptrc=other->getConstPointer();
5388 for(int i=0;i<nbOfTuple;i++)
5389 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::divides<double>(),*ptrc++));
5392 throw INTERP_KERNEL::Exception(msg);
5394 else if(nbOfTuple2==1)
5396 if(nbOfComp2==nbOfComp)
5398 double *ptr=getPointer();
5399 const double *ptrc=other->getConstPointer();
5400 for(int i=0;i<nbOfTuple;i++)
5401 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::divides<double>());
5404 throw INTERP_KERNEL::Exception(msg);
5407 throw INTERP_KERNEL::Exception(msg);
5412 * Returns a new DataArrayDouble that is the result of pow of two given arrays. There are 3
5415 * \param [in] a1 - an array to pow up.
5416 * \param [in] a2 - another array to sum up.
5417 * \return DataArrayDouble * - the new instance of DataArrayDouble.
5418 * The caller is to delete this result array using decrRef() as it is no more
5420 * \throw If either \a a1 or \a a2 is NULL.
5421 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
5422 * \throw If \a a1->getNumberOfComponents() != 1 or \a a2->getNumberOfComponents() != 1.
5423 * \throw If there is a negative value in \a a1.
5425 DataArrayDouble *DataArrayDouble::Pow(const DataArrayDouble *a1, const DataArrayDouble *a2)
5428 throw INTERP_KERNEL::Exception("DataArrayDouble::Pow : at least one of input instances is null !");
5429 int nbOfTuple=a1->getNumberOfTuples();
5430 int nbOfTuple2=a2->getNumberOfTuples();
5431 int nbOfComp=a1->getNumberOfComponents();
5432 int nbOfComp2=a2->getNumberOfComponents();
5433 if(nbOfTuple!=nbOfTuple2)
5434 throw INTERP_KERNEL::Exception("DataArrayDouble::Pow : number of tuples mismatches !");
5435 if(nbOfComp!=1 || nbOfComp2!=1)
5436 throw INTERP_KERNEL::Exception("DataArrayDouble::Pow : number of components of both arrays must be equal to 1 !");
5437 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New(); ret->alloc(nbOfTuple,1);
5438 const double *ptr1(a1->begin()),*ptr2(a2->begin());
5439 double *ptr=ret->getPointer();
5440 for(int i=0;i<nbOfTuple;i++,ptr1++,ptr2++,ptr++)
5444 *ptr=pow(*ptr1,*ptr2);
5448 std::ostringstream oss; oss << "DataArrayDouble::Pow : on tuple #" << i << " of a1 value is < 0 (" << *ptr1 << ") !";
5449 throw INTERP_KERNEL::Exception(oss.str().c_str());
5456 * Apply pow on values of another DataArrayDouble to values of \a this one.
5458 * \param [in] other - an array to pow to \a this one.
5459 * \throw If \a other is NULL.
5460 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples()
5461 * \throw If \a this->getNumberOfComponents() != 1 or \a other->getNumberOfComponents() != 1
5462 * \throw If there is a negative value in \a this.
5464 void DataArrayDouble::powEqual(const DataArrayDouble *other)
5467 throw INTERP_KERNEL::Exception("DataArrayDouble::powEqual : input instance is null !");
5468 int nbOfTuple=getNumberOfTuples();
5469 int nbOfTuple2=other->getNumberOfTuples();
5470 int nbOfComp=getNumberOfComponents();
5471 int nbOfComp2=other->getNumberOfComponents();
5472 if(nbOfTuple!=nbOfTuple2)
5473 throw INTERP_KERNEL::Exception("DataArrayDouble::powEqual : number of tuples mismatches !");
5474 if(nbOfComp!=1 || nbOfComp2!=1)
5475 throw INTERP_KERNEL::Exception("DataArrayDouble::powEqual : number of components of both arrays must be equal to 1 !");
5476 double *ptr=getPointer();
5477 const double *ptrc=other->begin();
5478 for(int i=0;i<nbOfTuple;i++,ptrc++,ptr++)
5481 *ptr=pow(*ptr,*ptrc);
5484 std::ostringstream oss; oss << "DataArrayDouble::powEqual : on tuple #" << i << " of this value is < 0 (" << *ptr << ") !";
5485 throw INTERP_KERNEL::Exception(oss.str().c_str());
5492 * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
5495 void DataArrayDouble::getTinySerializationIntInformation(std::vector<int>& tinyInfo) const
5500 tinyInfo[0]=getNumberOfTuples();
5501 tinyInfo[1]=getNumberOfComponents();
5511 * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
5514 void DataArrayDouble::getTinySerializationStrInformation(std::vector<std::string>& tinyInfo) const
5518 int nbOfCompo=getNumberOfComponents();
5519 tinyInfo.resize(nbOfCompo+1);
5520 tinyInfo[0]=getName();
5521 for(int i=0;i<nbOfCompo;i++)
5522 tinyInfo[i+1]=getInfoOnComponent(i);
5527 tinyInfo[0]=getName();
5532 * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
5533 * This method returns if a feeding is needed.
5535 bool DataArrayDouble::resizeForUnserialization(const std::vector<int>& tinyInfoI)
5537 int nbOfTuple=tinyInfoI[0];
5538 int nbOfComp=tinyInfoI[1];
5539 if(nbOfTuple!=-1 || nbOfComp!=-1)
5541 alloc(nbOfTuple,nbOfComp);
5548 * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
5550 void DataArrayDouble::finishUnserialization(const std::vector<int>& tinyInfoI, const std::vector<std::string>& tinyInfoS)
5552 setName(tinyInfoS[0].c_str());
5555 int nbOfCompo=getNumberOfComponents();
5556 for(int i=0;i<nbOfCompo;i++)
5557 setInfoOnComponent(i,tinyInfoS[i+1].c_str());
5561 DataArrayDoubleIterator::DataArrayDoubleIterator(DataArrayDouble *da):_da(da),_tuple_id(0),_nb_comp(0),_nb_tuple(0)
5566 if(_da->isAllocated())
5568 _nb_comp=da->getNumberOfComponents();
5569 _nb_tuple=da->getNumberOfTuples();
5570 _pt=da->getPointer();
5575 DataArrayDoubleIterator::~DataArrayDoubleIterator()
5581 DataArrayDoubleTuple *DataArrayDoubleIterator::nextt()
5583 if(_tuple_id<_nb_tuple)
5586 DataArrayDoubleTuple *ret=new DataArrayDoubleTuple(_pt,_nb_comp);
5594 DataArrayDoubleTuple::DataArrayDoubleTuple(double *pt, int nbOfComp):_pt(pt),_nb_of_compo(nbOfComp)
5599 std::string DataArrayDoubleTuple::repr() const
5601 std::ostringstream oss; oss.precision(17); oss << "(";
5602 for(int i=0;i<_nb_of_compo-1;i++)
5603 oss << _pt[i] << ", ";
5604 oss << _pt[_nb_of_compo-1] << ")";
5608 double DataArrayDoubleTuple::doubleValue() const
5612 throw INTERP_KERNEL::Exception("DataArrayDoubleTuple::doubleValue : DataArrayDoubleTuple instance has not exactly 1 component -> Not possible to convert it into a double precision float !");
5616 * This method returns a newly allocated instance the caller should dealed with by a ParaMEDMEM::DataArrayDouble::decrRef.
5617 * This method performs \b no copy of data. The content is only referenced using ParaMEDMEM::DataArrayDouble::useArray with ownership set to \b false.
5618 * 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
5619 * \b nbOfCompo=1 and \bnbOfTuples==this->_nb_of_elem.
5621 DataArrayDouble *DataArrayDoubleTuple::buildDADouble(int nbOfTuples, int nbOfCompo) const
5623 if((_nb_of_compo==nbOfCompo && nbOfTuples==1) || (_nb_of_compo==nbOfTuples && nbOfCompo==1))
5625 DataArrayDouble *ret=DataArrayDouble::New();
5626 ret->useExternalArrayWithRWAccess(_pt,nbOfTuples,nbOfCompo);
5631 std::ostringstream oss; oss << "DataArrayDoubleTuple::buildDADouble : unable to build a requested DataArrayDouble instance with nbofTuple=" << nbOfTuples << " and nbOfCompo=" << nbOfCompo;
5632 oss << ".\nBecause the number of elements in this is " << _nb_of_compo << " !";
5633 throw INTERP_KERNEL::Exception(oss.str().c_str());
5638 * Returns a new instance of DataArrayInt. The caller is to delete this array
5639 * using decrRef() as it is no more needed.
5641 DataArrayInt *DataArrayInt::New()
5643 return new DataArrayInt;
5647 * Checks if raw data is allocated. Read more on the raw data
5648 * in \ref MEDCouplingArrayBasicsTuplesAndCompo "DataArrays infos" for more information.
5649 * \return bool - \a true if the raw data is allocated, \a false else.
5651 bool DataArrayInt::isAllocated() const
5653 return getConstPointer()!=0;
5657 * Checks if raw data is allocated and throws an exception if it is not the case.
5658 * \throw If the raw data is not allocated.
5660 void DataArrayInt::checkAllocated() const
5663 throw INTERP_KERNEL::Exception("DataArrayInt::checkAllocated : Array is defined but not allocated ! Call alloc or setValues method first !");
5667 * This method desallocated \a this without modification of informations relative to the components.
5668 * After call of this method, DataArrayInt::isAllocated will return false.
5669 * If \a this is already not allocated, \a this is let unchanged.
5671 void DataArrayInt::desallocate()
5676 std::size_t DataArrayInt::getHeapMemorySizeWithoutChildren() const
5678 std::size_t sz(_mem.getNbOfElemAllocated());
5680 return DataArray::getHeapMemorySizeWithoutChildren()+sz;
5684 * Returns the only one value in \a this, if and only if number of elements
5685 * (nb of tuples * nb of components) is equal to 1, and that \a this is allocated.
5686 * \return double - the sole value stored in \a this array.
5687 * \throw If at least one of conditions stated above is not fulfilled.
5689 int DataArrayInt::intValue() const
5693 if(getNbOfElems()==1)
5695 return *getConstPointer();
5698 throw INTERP_KERNEL::Exception("DataArrayInt::intValue : DataArrayInt instance is allocated but number of elements is not equal to 1 !");
5701 throw INTERP_KERNEL::Exception("DataArrayInt::intValue : DataArrayInt instance is not allocated !");
5705 * Returns an integer value characterizing \a this array, which is useful for a quick
5706 * comparison of many instances of DataArrayInt.
5707 * \return int - the hash value.
5708 * \throw If \a this is not allocated.
5710 int DataArrayInt::getHashCode() const
5713 std::size_t nbOfElems=getNbOfElems();
5714 int ret=nbOfElems*65536;
5719 const int *pt=begin();
5720 for(std::size_t i=0;i<nbOfElems;i+=delta)
5721 ret0+=pt[i] & 0x1FFF;
5726 * Checks the number of tuples.
5727 * \return bool - \a true if getNumberOfTuples() == 0, \a false else.
5728 * \throw If \a this is not allocated.
5730 bool DataArrayInt::empty() const
5733 return getNumberOfTuples()==0;
5737 * Returns a full copy of \a this. For more info on copying data arrays see
5738 * \ref MEDCouplingArrayBasicsCopyDeep.
5739 * \return DataArrayInt * - a new instance of DataArrayInt.
5741 DataArrayInt *DataArrayInt::deepCpy() const
5743 return new DataArrayInt(*this);
5747 * Returns either a \a deep or \a shallow copy of this array. For more info see
5748 * \ref MEDCouplingArrayBasicsCopyDeep and \ref MEDCouplingArrayBasicsCopyShallow.
5749 * \param [in] dCpy - if \a true, a deep copy is returned, else, a shallow one.
5750 * \return DataArrayInt * - either a new instance of DataArrayInt (if \a dCpy
5751 * == \a true) or \a this instance (if \a dCpy == \a false).
5753 DataArrayInt *DataArrayInt::performCpy(bool dCpy) const
5760 return const_cast<DataArrayInt *>(this);
5765 * Copies all the data from another DataArrayInt. For more info see
5766 * \ref MEDCouplingArrayBasicsCopyDeepAssign.
5767 * \param [in] other - another instance of DataArrayInt to copy data from.
5768 * \throw If the \a other is not allocated.
5770 void DataArrayInt::cpyFrom(const DataArrayInt& other)
5772 other.checkAllocated();
5773 int nbOfTuples=other.getNumberOfTuples();
5774 int nbOfComp=other.getNumberOfComponents();
5775 allocIfNecessary(nbOfTuples,nbOfComp);
5776 std::size_t nbOfElems=(std::size_t)nbOfTuples*nbOfComp;
5777 int *pt=getPointer();
5778 const int *ptI=other.getConstPointer();
5779 for(std::size_t i=0;i<nbOfElems;i++)
5781 copyStringInfoFrom(other);
5785 * This method reserve nbOfElems elements in memory ( nbOfElems*4 bytes ) \b without impacting the number of tuples in \a this.
5786 * 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.
5787 * If \a this has not already been allocated, number of components is set to one.
5788 * This method allows to reduce number of reallocations on invokation of DataArrayInt::pushBackSilent and DataArrayInt::pushBackValsSilent on \a this.
5790 * \sa DataArrayInt::pack, DataArrayInt::pushBackSilent, DataArrayInt::pushBackValsSilent
5792 void DataArrayInt::reserve(std::size_t nbOfElems)
5794 int nbCompo=getNumberOfComponents();
5797 _mem.reserve(nbOfElems);
5801 _mem.reserve(nbOfElems);
5802 _info_on_compo.resize(1);
5805 throw INTERP_KERNEL::Exception("DataArrayInt::reserve : not available for DataArrayInt with number of components different than 1 !");
5809 * 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
5810 * of counter. So the caller is expected to call TimeLabel::declareAsNew on \a this at the end of the push session.
5812 * \param [in] val the value to be added in \a this
5813 * \throw If \a this has already been allocated with number of components different from one.
5814 * \sa DataArrayInt::pushBackValsSilent
5816 void DataArrayInt::pushBackSilent(int val)
5818 int nbCompo=getNumberOfComponents();
5823 _info_on_compo.resize(1);
5827 throw INTERP_KERNEL::Exception("DataArrayInt::pushBackSilent : not available for DataArrayInt with number of components different than 1 !");
5831 * 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
5832 * of counter. So the caller is expected to call TimeLabel::declareAsNew on \a this at the end of the push session.
5834 * \param [in] valsBg - an array of values to push at the end of \this.
5835 * \param [in] valsEnd - specifies the end of the array \a valsBg, so that
5836 * the last value of \a valsBg is \a valsEnd[ -1 ].
5837 * \throw If \a this has already been allocated with number of components different from one.
5838 * \sa DataArrayInt::pushBackSilent
5840 void DataArrayInt::pushBackValsSilent(const int *valsBg, const int *valsEnd)
5842 int nbCompo=getNumberOfComponents();
5844 _mem.insertAtTheEnd(valsBg,valsEnd);
5847 _info_on_compo.resize(1);
5848 _mem.insertAtTheEnd(valsBg,valsEnd);
5851 throw INTERP_KERNEL::Exception("DataArrayInt::pushBackValsSilent : not available for DataArrayInt with number of components different than 1 !");
5855 * This method returns silently ( without updating time label in \a this ) the last value, if any and suppress it.
5856 * \throw If \a this is already empty.
5857 * \throw If \a this has number of components different from one.
5859 int DataArrayInt::popBackSilent()
5861 if(getNumberOfComponents()==1)
5862 return _mem.popBack();
5864 throw INTERP_KERNEL::Exception("DataArrayInt::popBackSilent : not available for DataArrayInt with number of components different than 1 !");
5868 * 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.
5870 * \sa DataArrayInt::getHeapMemorySizeWithoutChildren, DataArrayInt::reserve
5872 void DataArrayInt::pack() const
5878 * Allocates the raw data in memory. If exactly as same memory as needed already
5879 * allocated, it is not re-allocated.
5880 * \param [in] nbOfTuple - number of tuples of data to allocate.
5881 * \param [in] nbOfCompo - number of components of data to allocate.
5882 * \throw If \a nbOfTuple < 0 or \a nbOfCompo < 0.
5884 void DataArrayInt::allocIfNecessary(int nbOfTuple, int nbOfCompo)
5888 if(nbOfTuple!=getNumberOfTuples() || nbOfCompo!=getNumberOfComponents())
5889 alloc(nbOfTuple,nbOfCompo);
5892 alloc(nbOfTuple,nbOfCompo);
5896 * Allocates the raw data in memory. If the memory was already allocated, then it is
5897 * freed and re-allocated. See an example of this method use
5898 * \ref MEDCouplingArraySteps1WC "here".
5899 * \param [in] nbOfTuple - number of tuples of data to allocate.
5900 * \param [in] nbOfCompo - number of components of data to allocate.
5901 * \throw If \a nbOfTuple < 0 or \a nbOfCompo < 0.
5903 void DataArrayInt::alloc(int nbOfTuple, int nbOfCompo)
5905 if(nbOfTuple<0 || nbOfCompo<0)
5906 throw INTERP_KERNEL::Exception("DataArrayInt::alloc : request for negative length of data !");
5907 _info_on_compo.resize(nbOfCompo);
5908 _mem.alloc(nbOfCompo*(std::size_t)nbOfTuple);
5913 * Assign zero to all values in \a this array. To know more on filling arrays see
5914 * \ref MEDCouplingArrayFill.
5915 * \throw If \a this is not allocated.
5917 void DataArrayInt::fillWithZero()
5920 _mem.fillWithValue(0);
5925 * Assign \a val to all values in \a this array. To know more on filling arrays see
5926 * \ref MEDCouplingArrayFill.
5927 * \param [in] val - the value to fill with.
5928 * \throw If \a this is not allocated.
5930 void DataArrayInt::fillWithValue(int val)
5933 _mem.fillWithValue(val);
5938 * Set all values in \a this array so that the i-th element equals to \a init + i
5939 * (i starts from zero). To know more on filling arrays see \ref MEDCouplingArrayFill.
5940 * \param [in] init - value to assign to the first element of array.
5941 * \throw If \a this->getNumberOfComponents() != 1
5942 * \throw If \a this is not allocated.
5944 void DataArrayInt::iota(int init)
5947 if(getNumberOfComponents()!=1)
5948 throw INTERP_KERNEL::Exception("DataArrayInt::iota : works only for arrays with only one component, you can call 'rearrange' method before !");
5949 int *ptr=getPointer();
5950 int ntuples=getNumberOfTuples();
5951 for(int i=0;i<ntuples;i++)
5957 * Returns a textual and human readable representation of \a this instance of
5958 * DataArrayInt. This text is shown when a DataArrayInt is printed in Python.
5959 * \return std::string - text describing \a this DataArrayInt.
5961 std::string DataArrayInt::repr() const
5963 std::ostringstream ret;
5968 std::string DataArrayInt::reprZip() const
5970 std::ostringstream ret;
5975 void DataArrayInt::writeVTK(std::ostream& ofs, int indent, const char *type, const char *nameInFile, DataArrayByte *byteArr) const
5977 static const char SPACE[4]={' ',' ',' ',' '};
5979 std::string idt(indent,' ');
5980 ofs << idt << "<DataArray type=\"" << type << "\" Name=\"" << nameInFile << "\" NumberOfComponents=\"" << getNumberOfComponents() << "\"";
5983 ofs << " format=\"appended\" offset=\"" << byteArr->getNumberOfTuples() << "\">";
5984 if(std::string(type)=="Int32")
5986 const char *data(reinterpret_cast<const char *>(begin()));
5987 std::size_t sz(getNbOfElems()*sizeof(int));
5988 byteArr->insertAtTheEnd(data,data+sz);
5989 byteArr->insertAtTheEnd(SPACE,SPACE+4);
5991 else if(std::string(type)=="Int8")
5993 INTERP_KERNEL::AutoPtr<char> tmp(new char[getNbOfElems()]);
5994 std::copy(begin(),end(),(char *)tmp);
5995 byteArr->insertAtTheEnd((char *)tmp,(char *)tmp+getNbOfElems());
5996 byteArr->insertAtTheEnd(SPACE,SPACE+4);
5998 else if(std::string(type)=="UInt8")
6000 INTERP_KERNEL::AutoPtr<unsigned char> tmp(new unsigned char[getNbOfElems()]);
6001 std::copy(begin(),end(),(unsigned char *)tmp);
6002 byteArr->insertAtTheEnd((unsigned char *)tmp,(unsigned char *)tmp+getNbOfElems());
6003 byteArr->insertAtTheEnd(SPACE,SPACE+4);
6006 throw INTERP_KERNEL::Exception("DataArrayInt::writeVTK : Only Int32, Int8 and UInt8 supported !");
6010 ofs << " RangeMin=\"" << getMinValueInArray() << "\" RangeMax=\"" << getMaxValueInArray() << "\" format=\"ascii\">\n" << idt;
6011 std::copy(begin(),end(),std::ostream_iterator<int>(ofs," "));
6013 ofs << std::endl << idt << "</DataArray>\n";
6016 void DataArrayInt::reprStream(std::ostream& stream) const
6018 stream << "Name of int array : \"" << _name << "\"\n";
6019 reprWithoutNameStream(stream);
6022 void DataArrayInt::reprZipStream(std::ostream& stream) const
6024 stream << "Name of int array : \"" << _name << "\"\n";
6025 reprZipWithoutNameStream(stream);
6028 void DataArrayInt::reprWithoutNameStream(std::ostream& stream) const
6030 DataArray::reprWithoutNameStream(stream);
6031 _mem.repr(getNumberOfComponents(),stream);
6034 void DataArrayInt::reprZipWithoutNameStream(std::ostream& stream) const
6036 DataArray::reprWithoutNameStream(stream);
6037 _mem.reprZip(getNumberOfComponents(),stream);
6040 void DataArrayInt::reprCppStream(const char *varName, std::ostream& stream) const
6042 int nbTuples=getNumberOfTuples(),nbComp=getNumberOfComponents();
6043 const int *data=getConstPointer();
6044 stream << "DataArrayInt *" << varName << "=DataArrayInt::New();" << std::endl;
6045 if(nbTuples*nbComp>=1)
6047 stream << "const int " << varName << "Data[" << nbTuples*nbComp << "]={";
6048 std::copy(data,data+nbTuples*nbComp-1,std::ostream_iterator<int>(stream,","));
6049 stream << data[nbTuples*nbComp-1] << "};" << std::endl;
6050 stream << varName << "->useArray(" << varName << "Data,false,CPP_DEALLOC," << nbTuples << "," << nbComp << ");" << std::endl;
6053 stream << varName << "->alloc(" << nbTuples << "," << nbComp << ");" << std::endl;
6054 stream << varName << "->setName(\"" << getName() << "\");" << std::endl;
6058 * Method that gives a quick overvien of \a this for python.
6060 void DataArrayInt::reprQuickOverview(std::ostream& stream) const
6062 static const std::size_t MAX_NB_OF_BYTE_IN_REPR=300;
6063 stream << "DataArrayInt C++ instance at " << this << ". ";
6066 int nbOfCompo=(int)_info_on_compo.size();
6069 int nbOfTuples=getNumberOfTuples();
6070 stream << "Number of tuples : " << nbOfTuples << ". Number of components : " << nbOfCompo << "." << std::endl;
6071 reprQuickOverviewData(stream,MAX_NB_OF_BYTE_IN_REPR);
6074 stream << "Number of components : 0.";
6077 stream << "*** No data allocated ****";
6080 void DataArrayInt::reprQuickOverviewData(std::ostream& stream, std::size_t maxNbOfByteInRepr) const
6082 const int *data=begin();
6083 int nbOfTuples=getNumberOfTuples();
6084 int nbOfCompo=(int)_info_on_compo.size();
6085 std::ostringstream oss2; oss2 << "[";
6086 std::string oss2Str(oss2.str());
6087 bool isFinished=true;
6088 for(int i=0;i<nbOfTuples && isFinished;i++)
6093 for(int j=0;j<nbOfCompo;j++,data++)
6096 if(j!=nbOfCompo-1) oss2 << ", ";
6102 if(i!=nbOfTuples-1) oss2 << ", ";
6103 std::string oss3Str(oss2.str());
6104 if(oss3Str.length()<maxNbOfByteInRepr)
6116 * Modifies \a this one-dimensional array so that each value \a v = \a indArrBg[ \a v ],
6117 * i.e. a current value is used as in index to get a new value from \a indArrBg.
6118 * \param [in] indArrBg - pointer to the first element of array of new values to assign
6120 * \param [in] indArrEnd - specifies the end of the array \a indArrBg, so that
6121 * the last value of \a indArrBg is \a indArrEnd[ -1 ].
6122 * \throw If \a this->getNumberOfComponents() != 1
6123 * \throw If any value of \a this can't be used as a valid index for
6124 * [\a indArrBg, \a indArrEnd).
6126 void DataArrayInt::transformWithIndArr(const int *indArrBg, const int *indArrEnd)
6129 if(getNumberOfComponents()!=1)
6130 throw INTERP_KERNEL::Exception("Call transformWithIndArr method on DataArrayInt with only one component, you can call 'rearrange' method before !");
6131 int nbElemsIn=(int)std::distance(indArrBg,indArrEnd);
6132 int nbOfTuples=getNumberOfTuples();
6133 int *pt=getPointer();
6134 for(int i=0;i<nbOfTuples;i++,pt++)
6136 if(*pt>=0 && *pt<nbElemsIn)
6140 std::ostringstream oss; oss << "DataArrayInt::transformWithIndArr : error on tuple #" << i << " of this value is " << *pt << ", should be in [0," << nbElemsIn << ") !";
6141 throw INTERP_KERNEL::Exception(oss.str().c_str());
6148 * Computes distribution of values of \a this one-dimensional array between given value
6149 * ranges (casts). This method is typically useful for entity number spliting by types,
6151 * \warning The values contained in \a arrBg should be sorted ascendently. No
6152 * check of this is be done. If not, the result is not warranted.
6153 * \param [in] arrBg - the array of ascending values defining the value ranges. The i-th
6154 * value of \a arrBg (\a arrBg[ i ]) gives the lowest value of the i-th range,
6155 * and the greatest value of the i-th range equals to \a arrBg[ i+1 ] - 1. \a
6156 * arrBg containing \a n values defines \a n-1 ranges. The last value of \a arrBg
6157 * should be more than every value in \a this array.
6158 * \param [in] arrEnd - specifies the end of the array \a arrBg, so that
6159 * the last value of \a arrBg is \a arrEnd[ -1 ].
6160 * \param [out] castArr - a new instance of DataArrayInt, of same size as \a this array
6161 * (same number of tuples and components), the caller is to delete
6162 * using decrRef() as it is no more needed.
6163 * This array contains indices of ranges for every value of \a this array. I.e.
6164 * the i-th value of \a castArr gives the index of range the i-th value of \a this
6165 * belongs to. Or, in other words, this parameter contains for each tuple in \a
6166 * this in which cast it holds.
6167 * \param [out] rankInsideCast - a new instance of DataArrayInt, of same size as \a this
6168 * array, the caller is to delete using decrRef() as it is no more needed.
6169 * This array contains ranks of values of \a this array within ranges
6170 * they belongs to. I.e. the i-th value of \a rankInsideCast gives the rank of
6171 * the i-th value of \a this array within the \a castArr[ i ]-th range, to which
6172 * the i-th value of \a this belongs to. Or, in other words, this param contains
6173 * for each tuple its rank inside its cast. The rank is computed as difference
6174 * between the value and the lowest value of range.
6175 * \param [out] castsPresent - a new instance of DataArrayInt, containing indices of
6176 * ranges (casts) to which at least one value of \a this array belongs.
6177 * Or, in other words, this param contains the casts that \a this contains.
6178 * The caller is to delete this array using decrRef() as it is no more needed.
6180 * \b Example: If \a this contains [6,5,0,3,2,7,8,1,4] and \a arrBg contains [0,4,9] then
6181 * the output of this method will be :
6182 * - \a castArr : [1,1,0,0,0,1,1,0,1]
6183 * - \a rankInsideCast: [2,1,0,3,2,3,4,1,0]
6184 * - \a castsPresent : [0,1]
6186 * I.e. values of \a this array belong to 2 ranges: #0 and #1. Value 6 belongs to the
6187 * range #1 and its rank within this range is 2; etc.
6189 * \throw If \a this->getNumberOfComponents() != 1.
6190 * \throw If \a arrEnd - arrBg < 2.
6191 * \throw If any value of \a this is not less than \a arrEnd[-1].
6193 void DataArrayInt::splitByValueRange(const int *arrBg, const int *arrEnd,
6194 DataArrayInt *& castArr, DataArrayInt *& rankInsideCast, DataArrayInt *& castsPresent) const throw(INTERP_KERNEL::Exception)
6197 if(getNumberOfComponents()!=1)
6198 throw INTERP_KERNEL::Exception("Call splitByValueRange method on DataArrayInt with only one component, you can call 'rearrange' method before !");
6199 int nbOfTuples=getNumberOfTuples();
6200 std::size_t nbOfCast=std::distance(arrBg,arrEnd);
6202 throw INTERP_KERNEL::Exception("DataArrayInt::splitByValueRange : The input array giving the cast range values should be of size >=2 !");
6204 const int *work=getConstPointer();
6205 typedef std::reverse_iterator<const int *> rintstart;
6206 rintstart bg(arrEnd);//OK no problem because size of 'arr' is greater or equal 2
6207 rintstart end2(arrBg);
6208 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret1=DataArrayInt::New();
6209 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret2=DataArrayInt::New();
6210 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret3=DataArrayInt::New();
6211 ret1->alloc(nbOfTuples,1);
6212 ret2->alloc(nbOfTuples,1);
6213 int *ret1Ptr=ret1->getPointer();
6214 int *ret2Ptr=ret2->getPointer();
6215 std::set<std::size_t> castsDetected;
6216 for(int i=0;i<nbOfTuples;i++)
6218 rintstart res=std::find_if(bg,end2,std::bind2nd(std::less_equal<int>(), work[i]));
6219 std::size_t pos=std::distance(bg,res);
6220 std::size_t pos2=nbOfCast-pos;
6223 ret1Ptr[i]=(int)pos2;
6224 ret2Ptr[i]=work[i]-arrBg[pos2];
6225 castsDetected.insert(pos2);
6229 std::ostringstream oss; oss << "DataArrayInt::splitByValueRange : At rank #" << i << " the value is " << work[i] << " should be in [0," << *bg << ") !";
6230 throw INTERP_KERNEL::Exception(oss.str().c_str());
6233 ret3->alloc((int)castsDetected.size(),1);
6234 std::copy(castsDetected.begin(),castsDetected.end(),ret3->getPointer());
6235 castArr=ret1.retn();
6236 rankInsideCast=ret2.retn();
6237 castsPresent=ret3.retn();
6241 * Creates a one-dimensional DataArrayInt (\a res) whose contents are computed from
6242 * values of \a this (\a a) and the given (\a indArr) arrays as follows:
6243 * \a res[ \a indArr[ \a a[ i ]]] = i. I.e. for each value in place i \a v = \a a[ i ],
6244 * new value in place \a indArr[ \a v ] is i.
6245 * \param [in] indArrBg - the array holding indices within the result array to assign
6246 * indices of values of \a this array pointing to values of \a indArrBg.
6247 * \param [in] indArrEnd - specifies the end of the array \a indArrBg, so that
6248 * the last value of \a indArrBg is \a indArrEnd[ -1 ].
6249 * \return DataArrayInt * - the new instance of DataArrayInt.
6250 * The caller is to delete this result array using decrRef() as it is no more
6252 * \throw If \a this->getNumberOfComponents() != 1.
6253 * \throw If any value of \a this array is not a valid index for \a indArrBg array.
6254 * \throw If any value of \a indArrBg is not a valid index for \a this array.
6256 DataArrayInt *DataArrayInt::transformWithIndArrR(const int *indArrBg, const int *indArrEnd) const
6259 if(getNumberOfComponents()!=1)
6260 throw INTERP_KERNEL::Exception("Call transformWithIndArrR method on DataArrayInt with only one component, you can call 'rearrange' method before !");
6261 int nbElemsIn=(int)std::distance(indArrBg,indArrEnd);
6262 int nbOfTuples=getNumberOfTuples();
6263 const int *pt=getConstPointer();
6264 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
6265 ret->alloc(nbOfTuples,1);
6266 ret->fillWithValue(-1);
6267 int *tmp=ret->getPointer();
6268 for(int i=0;i<nbOfTuples;i++,pt++)
6270 if(*pt>=0 && *pt<nbElemsIn)
6272 int pos=indArrBg[*pt];
6273 if(pos>=0 && pos<nbOfTuples)
6277 std::ostringstream oss; oss << "DataArrayInt::transformWithIndArrR : error on tuple #" << i << " value of new pos is " << pos << " ( indArrBg[" << *pt << "]) ! Should be in [0," << nbOfTuples << ") !";
6278 throw INTERP_KERNEL::Exception(oss.str().c_str());
6283 std::ostringstream oss; oss << "DataArrayInt::transformWithIndArrR : error on tuple #" << i << " value is " << *pt << " and indirectionnal array as a size equal to " << nbElemsIn << " !";
6284 throw INTERP_KERNEL::Exception(oss.str().c_str());
6291 * Creates a one-dimensional DataArrayInt of given length, whose contents are computed
6292 * from values of \a this array, which is supposed to contain a renumbering map in
6293 * "Old to New" mode. The result array contains a renumbering map in "New to Old" mode.
6294 * To know how to use the renumbering maps see \ref MEDCouplingArrayRenumbering.
6295 * \param [in] newNbOfElem - the number of tuples in the result array.
6296 * \return DataArrayInt * - the new instance of DataArrayInt.
6297 * The caller is to delete this result array using decrRef() as it is no more
6300 * \ref cpp_mcdataarrayint_invertarrayo2n2n2o "Here is a C++ example".<br>
6301 * \ref py_mcdataarrayint_invertarrayo2n2n2o "Here is a Python example".
6303 DataArrayInt *DataArrayInt::invertArrayO2N2N2O(int newNbOfElem) const
6305 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
6306 ret->alloc(newNbOfElem,1);
6307 int nbOfOldNodes=getNumberOfTuples();
6308 const int *old2New=getConstPointer();
6309 int *pt=ret->getPointer();
6310 for(int i=0;i!=nbOfOldNodes;i++)
6312 int newp(old2New[i]);
6315 if(newp>=0 && newp<newNbOfElem)
6319 std::ostringstream oss; oss << "DataArrayInt::invertArrayO2N2N2O : At place #" << i << " the newplace is " << newp << " must be in [0," << newNbOfElem << ") !";
6320 throw INTERP_KERNEL::Exception(oss.str().c_str());
6328 * This method is similar to DataArrayInt::invertArrayO2N2N2O except that
6329 * 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]
6331 DataArrayInt *DataArrayInt::invertArrayO2N2N2OBis(int newNbOfElem) const
6333 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
6334 ret->alloc(newNbOfElem,1);
6335 int nbOfOldNodes=getNumberOfTuples();
6336 const int *old2New=getConstPointer();
6337 int *pt=ret->getPointer();
6338 for(int i=nbOfOldNodes-1;i>=0;i--)
6340 int newp(old2New[i]);
6343 if(newp>=0 && newp<newNbOfElem)
6347 std::ostringstream oss; oss << "DataArrayInt::invertArrayO2N2N2OBis : At place #" << i << " the newplace is " << newp << " must be in [0," << newNbOfElem << ") !";
6348 throw INTERP_KERNEL::Exception(oss.str().c_str());
6356 * Creates a one-dimensional DataArrayInt of given length, whose contents are computed
6357 * from values of \a this array, which is supposed to contain a renumbering map in
6358 * "New to Old" mode. The result array contains a renumbering map in "Old to New" mode.
6359 * To know how to use the renumbering maps see \ref MEDCouplingArrayRenumbering.
6360 * \param [in] newNbOfElem - the number of tuples in the result array.
6361 * \return DataArrayInt * - the new instance of DataArrayInt.
6362 * The caller is to delete this result array using decrRef() as it is no more
6365 * \ref cpp_mcdataarrayint_invertarrayn2o2o2n "Here is a C++ example".
6367 * \ref py_mcdataarrayint_invertarrayn2o2o2n "Here is a Python example".
6369 DataArrayInt *DataArrayInt::invertArrayN2O2O2N(int oldNbOfElem) const
6372 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
6373 ret->alloc(oldNbOfElem,1);
6374 const int *new2Old=getConstPointer();
6375 int *pt=ret->getPointer();
6376 std::fill(pt,pt+oldNbOfElem,-1);
6377 int nbOfNewElems=getNumberOfTuples();
6378 for(int i=0;i<nbOfNewElems;i++)
6381 if(v>=0 && v<oldNbOfElem)
6385 std::ostringstream oss; oss << "DataArrayInt::invertArrayN2O2O2N : in new id #" << i << " old value is " << v << " expected to be in [0," << oldNbOfElem << ") !";
6386 throw INTERP_KERNEL::Exception(oss.str().c_str());
6393 * Equivalent to DataArrayInt::isEqual except that if false the reason of
6394 * mismatch is given.
6396 * \param [in] other the instance to be compared with \a this
6397 * \param [out] reason In case of inequality returns the reason.
6398 * \sa DataArrayInt::isEqual
6400 bool DataArrayInt::isEqualIfNotWhy(const DataArrayInt& other, std::string& reason) const
6402 if(!areInfoEqualsIfNotWhy(other,reason))
6404 return _mem.isEqual(other._mem,0,reason);
6408 * Checks if \a this and another DataArrayInt are fully equal. For more info see
6409 * \ref MEDCouplingArrayBasicsCompare.
6410 * \param [in] other - an instance of DataArrayInt to compare with \a this one.
6411 * \return bool - \a true if the two arrays are equal, \a false else.
6413 bool DataArrayInt::isEqual(const DataArrayInt& other) const
6416 return isEqualIfNotWhy(other,tmp);
6420 * Checks if values of \a this and another DataArrayInt are equal. For more info see
6421 * \ref MEDCouplingArrayBasicsCompare.
6422 * \param [in] other - an instance of DataArrayInt to compare with \a this one.
6423 * \return bool - \a true if the values of two arrays are equal, \a false else.
6425 bool DataArrayInt::isEqualWithoutConsideringStr(const DataArrayInt& other) const
6428 return _mem.isEqual(other._mem,0,tmp);
6432 * Checks if values of \a this and another DataArrayInt are equal. Comparison is
6433 * performed on sorted value sequences.
6434 * For more info see\ref MEDCouplingArrayBasicsCompare.
6435 * \param [in] other - an instance of DataArrayInt to compare with \a this one.
6436 * \return bool - \a true if the sorted values of two arrays are equal, \a false else.
6438 bool DataArrayInt::isEqualWithoutConsideringStrAndOrder(const DataArrayInt& other) const
6440 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> a=deepCpy();
6441 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> b=other.deepCpy();
6444 return a->isEqualWithoutConsideringStr(*b);
6448 * This method compares content of input vector \a v and \a this.
6449 * 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.
6450 * For performance reasons \a this is expected to be sorted ascendingly. If not an exception will be thrown.
6452 * \param [in] v - the vector of 'flags' to be compared with \a this.
6454 * \throw If \a this is not sorted ascendingly.
6455 * \throw If \a this has not exactly one component.
6456 * \throw If \a this is not allocated.
6458 bool DataArrayInt::isFittingWith(const std::vector<bool>& v) const
6461 if(getNumberOfComponents()!=1)
6462 throw INTERP_KERNEL::Exception("DataArrayInt::isFittingWith : number of components of this should be equal to one !");
6463 int nbOfTuples(getNumberOfTuples());
6464 const int *w(begin()),*end2(end());
6465 int refVal=-std::numeric_limits<int>::max();
6467 std::vector<bool>::const_iterator it(v.begin());
6468 for(;it!=v.end();it++,i++)
6480 std::ostringstream oss; oss << "DataArrayInt::isFittingWith : At pos #" << std::distance(begin(),w-1) << " this is not sorted ascendingly !";
6481 throw INTERP_KERNEL::Exception(oss.str().c_str());
6495 * Sorts values of the array.
6496 * \param [in] asc - \a true means ascending order, \a false, descending.
6497 * \throw If \a this is not allocated.
6498 * \throw If \a this->getNumberOfComponents() != 1.
6500 void DataArrayInt::sort(bool asc)
6503 if(getNumberOfComponents()!=1)
6504 throw INTERP_KERNEL::Exception("DataArrayInt::sort : only supported with 'this' array with ONE component !");
6510 * Computes for each tuple the sum of number of components values in the tuple and return it.
6512 * \return DataArrayInt * - the new instance of DataArrayInt containing the
6513 * same number of tuples as \a this array and one component.
6514 * The caller is to delete this result array using decrRef() as it is no more
6516 * \throw If \a this is not allocated.
6518 DataArrayInt *DataArrayInt::sumPerTuple() const
6521 int nbOfComp(getNumberOfComponents()),nbOfTuple(getNumberOfTuples());
6522 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New());
6523 ret->alloc(nbOfTuple,1);
6524 const int *src(getConstPointer());
6525 int *dest(ret->getPointer());
6526 for(int i=0;i<nbOfTuple;i++,dest++,src+=nbOfComp)
6527 *dest=std::accumulate(src,src+nbOfComp,0);
6532 * Reverse the array values.
6533 * \throw If \a this->getNumberOfComponents() < 1.
6534 * \throw If \a this is not allocated.
6536 void DataArrayInt::reverse()
6539 _mem.reverse(getNumberOfComponents());
6544 * Checks that \a this array is consistently **increasing** or **decreasing** in value.
6545 * If not an exception is thrown.
6546 * \param [in] increasing - if \a true, the array values should be increasing.
6547 * \throw If sequence of values is not strictly monotonic in agreement with \a
6549 * \throw If \a this->getNumberOfComponents() != 1.
6550 * \throw If \a this is not allocated.
6552 void DataArrayInt::checkMonotonic(bool increasing) const
6554 if(!isMonotonic(increasing))
6557 throw INTERP_KERNEL::Exception("DataArrayInt::checkMonotonic : 'this' is not INCREASING monotonic !");
6559 throw INTERP_KERNEL::Exception("DataArrayInt::checkMonotonic : 'this' is not DECREASING monotonic !");
6564 * Checks that \a this array is consistently **increasing** or **decreasing** in value.
6565 * \param [in] increasing - if \a true, array values should be increasing.
6566 * \return bool - \a true if values change in accordance with \a increasing arg.
6567 * \throw If \a this->getNumberOfComponents() != 1.
6568 * \throw If \a this is not allocated.
6570 bool DataArrayInt::isMonotonic(bool increasing) const
6573 if(getNumberOfComponents()!=1)
6574 throw INTERP_KERNEL::Exception("DataArrayInt::isMonotonic : only supported with 'this' array with ONE component !");
6575 int nbOfElements=getNumberOfTuples();
6576 const int *ptr=getConstPointer();
6582 for(int i=1;i<nbOfElements;i++)
6592 for(int i=1;i<nbOfElements;i++)
6604 * This method check that array consistently INCREASING or DECREASING in value.
6606 bool DataArrayInt::isStrictlyMonotonic(bool increasing) const
6609 if(getNumberOfComponents()!=1)
6610 throw INTERP_KERNEL::Exception("DataArrayInt::isStrictlyMonotonic : only supported with 'this' array with ONE component !");
6611 int nbOfElements=getNumberOfTuples();
6612 const int *ptr=getConstPointer();
6618 for(int i=1;i<nbOfElements;i++)
6628 for(int i=1;i<nbOfElements;i++)
6640 * This method check that array consistently INCREASING or DECREASING in value.
6642 void DataArrayInt::checkStrictlyMonotonic(bool increasing) const
6644 if(!isStrictlyMonotonic(increasing))
6647 throw INTERP_KERNEL::Exception("DataArrayInt::checkStrictlyMonotonic : 'this' is not strictly INCREASING monotonic !");
6649 throw INTERP_KERNEL::Exception("DataArrayInt::checkStrictlyMonotonic : 'this' is not strictly DECREASING monotonic !");
6654 * Creates a new one-dimensional DataArrayInt of the same size as \a this and a given
6655 * one-dimensional arrays that must be of the same length. The result array describes
6656 * correspondence between \a this and \a other arrays, so that
6657 * <em> other.getIJ(i,0) == this->getIJ(ret->getIJ(i),0)</em>. If such a permutation is
6658 * not possible because some element in \a other is not in \a this, an exception is thrown.
6659 * \param [in] other - an array to compute permutation to.
6660 * \return DataArrayInt * - a new instance of DataArrayInt, which is a permutation array
6661 * from \a this to \a other. The caller is to delete this array using decrRef() as it is
6663 * \throw If \a this->getNumberOfComponents() != 1.
6664 * \throw If \a other->getNumberOfComponents() != 1.
6665 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples().
6666 * \throw If \a other includes a value which is not in \a this array.
6668 * \ref cpp_mcdataarrayint_buildpermutationarr "Here is a C++ example".
6670 * \ref py_mcdataarrayint_buildpermutationarr "Here is a Python example".
6672 DataArrayInt *DataArrayInt::buildPermutationArr(const DataArrayInt& other) const
6675 if(getNumberOfComponents()!=1 || other.getNumberOfComponents()!=1)
6676 throw INTERP_KERNEL::Exception("DataArrayInt::buildPermutationArr : 'this' and 'other' have to have exactly ONE component !");
6677 int nbTuple=getNumberOfTuples();
6678 other.checkAllocated();
6679 if(nbTuple!=other.getNumberOfTuples())
6680 throw INTERP_KERNEL::Exception("DataArrayInt::buildPermutationArr : 'this' and 'other' must have the same number of tuple !");
6681 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
6682 ret->alloc(nbTuple,1);
6683 ret->fillWithValue(-1);
6684 const int *pt=getConstPointer();
6685 std::map<int,int> mm;
6686 for(int i=0;i<nbTuple;i++)
6688 pt=other.getConstPointer();
6689 int *retToFill=ret->getPointer();
6690 for(int i=0;i<nbTuple;i++)
6692 std::map<int,int>::const_iterator it=mm.find(pt[i]);
6695 std::ostringstream oss; oss << "DataArrayInt::buildPermutationArr : Arrays mismatch : element (" << pt[i] << ") in 'other' not findable in 'this' !";
6696 throw INTERP_KERNEL::Exception(oss.str().c_str());
6698 retToFill[i]=(*it).second;
6704 * Sets a C array to be used as raw data of \a this. The previously set info
6705 * of components is retained and re-sized.
6706 * For more info see \ref MEDCouplingArraySteps1.
6707 * \param [in] array - the C array to be used as raw data of \a this.
6708 * \param [in] ownership - if \a true, \a array will be deallocated at destruction of \a this.
6709 * \param [in] type - specifies how to deallocate \a array. If \a type == ParaMEDMEM::CPP_DEALLOC,
6710 * \c delete [] \c array; will be called. If \a type == ParaMEDMEM::C_DEALLOC,
6711 * \c free(\c array ) will be called.
6712 * \param [in] nbOfTuple - new number of tuples in \a this.
6713 * \param [in] nbOfCompo - new number of components in \a this.
6715 void DataArrayInt::useArray(const int *array, bool ownership, DeallocType type, int nbOfTuple, int nbOfCompo)
6717 _info_on_compo.resize(nbOfCompo);
6718 _mem.useArray(array,ownership,type,nbOfTuple*nbOfCompo);
6722 void DataArrayInt::useExternalArrayWithRWAccess(const int *array, int nbOfTuple, int nbOfCompo)
6724 _info_on_compo.resize(nbOfCompo);
6725 _mem.useExternalArrayWithRWAccess(array,nbOfTuple*nbOfCompo);
6730 * Returns a new DataArrayInt holding the same values as \a this array but differently
6731 * arranged in memory. If \a this array holds 2 components of 3 values:
6732 * \f$ x_0,x_1,x_2,y_0,y_1,y_2 \f$, then the result array holds these values arranged
6733 * as follows: \f$ x_0,y_0,x_1,y_1,x_2,y_2 \f$.
6734 * \warning Do not confuse this method with transpose()!
6735 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
6736 * is to delete using decrRef() as it is no more needed.
6737 * \throw If \a this is not allocated.
6739 DataArrayInt *DataArrayInt::fromNoInterlace() const
6743 throw INTERP_KERNEL::Exception("DataArrayInt::fromNoInterlace : Not defined array !");
6744 int *tab=_mem.fromNoInterlace(getNumberOfComponents());
6745 DataArrayInt *ret=DataArrayInt::New();
6746 ret->useArray(tab,true,C_DEALLOC,getNumberOfTuples(),getNumberOfComponents());
6751 * Returns a new DataArrayInt holding the same values as \a this array but differently
6752 * arranged in memory. If \a this array holds 2 components of 3 values:
6753 * \f$ x_0,y_0,x_1,y_1,x_2,y_2 \f$, then the result array holds these values arranged
6754 * as follows: \f$ x_0,x_1,x_2,y_0,y_1,y_2 \f$.
6755 * \warning Do not confuse this method with transpose()!
6756 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
6757 * is to delete using decrRef() as it is no more needed.
6758 * \throw If \a this is not allocated.
6760 DataArrayInt *DataArrayInt::toNoInterlace() const
6764 throw INTERP_KERNEL::Exception("DataArrayInt::toNoInterlace : Not defined array !");
6765 int *tab=_mem.toNoInterlace(getNumberOfComponents());
6766 DataArrayInt *ret=DataArrayInt::New();
6767 ret->useArray(tab,true,C_DEALLOC,getNumberOfTuples(),getNumberOfComponents());
6772 * Permutes values of \a this array as required by \a old2New array. The values are
6773 * permuted so that \c new[ \a old2New[ i ]] = \c old[ i ]. Number of tuples remains
6774 * the same as in \this one.
6775 * If a permutation reduction is needed, substr() or selectByTupleId() should be used.
6776 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
6777 * \param [in] old2New - C array of length equal to \a this->getNumberOfTuples()
6778 * giving a new position for i-th old value.
6780 void DataArrayInt::renumberInPlace(const int *old2New)
6783 int nbTuples=getNumberOfTuples();
6784 int nbOfCompo=getNumberOfComponents();
6785 int *tmp=new int[nbTuples*nbOfCompo];
6786 const int *iptr=getConstPointer();
6787 for(int i=0;i<nbTuples;i++)
6790 if(v>=0 && v<nbTuples)
6791 std::copy(iptr+nbOfCompo*i,iptr+nbOfCompo*(i+1),tmp+nbOfCompo*v);
6794 std::ostringstream oss; oss << "DataArrayInt::renumberInPlace : At place #" << i << " value is " << v << " ! Should be in [0," << nbTuples << ") !";
6795 throw INTERP_KERNEL::Exception(oss.str().c_str());
6798 std::copy(tmp,tmp+nbTuples*nbOfCompo,getPointer());
6804 * Permutes values of \a this array as required by \a new2Old array. The values are
6805 * permuted so that \c new[ i ] = \c old[ \a new2Old[ i ]]. Number of tuples remains
6806 * the same as in \this one.
6807 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
6808 * \param [in] new2Old - C array of length equal to \a this->getNumberOfTuples()
6809 * giving a previous position of i-th new value.
6810 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
6811 * is to delete using decrRef() as it is no more needed.
6813 void DataArrayInt::renumberInPlaceR(const int *new2Old)
6816 int nbTuples=getNumberOfTuples();
6817 int nbOfCompo=getNumberOfComponents();
6818 int *tmp=new int[nbTuples*nbOfCompo];
6819 const int *iptr=getConstPointer();
6820 for(int i=0;i<nbTuples;i++)
6823 if(v>=0 && v<nbTuples)
6824 std::copy(iptr+nbOfCompo*v,iptr+nbOfCompo*(v+1),tmp+nbOfCompo*i);
6827 std::ostringstream oss; oss << "DataArrayInt::renumberInPlaceR : At place #" << i << " value is " << v << " ! Should be in [0," << nbTuples << ") !";
6828 throw INTERP_KERNEL::Exception(oss.str().c_str());
6831 std::copy(tmp,tmp+nbTuples*nbOfCompo,getPointer());
6837 * Returns a copy of \a this array with values permuted as required by \a old2New array.
6838 * The values are permuted so that \c new[ \a old2New[ i ]] = \c old[ i ].
6839 * Number of tuples in the result array remains the same as in \this one.
6840 * If a permutation reduction is needed, renumberAndReduce() should be used.
6841 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
6842 * \param [in] old2New - C array of length equal to \a this->getNumberOfTuples()
6843 * giving a new position for i-th old value.
6844 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
6845 * is to delete using decrRef() as it is no more needed.
6846 * \throw If \a this is not allocated.
6848 DataArrayInt *DataArrayInt::renumber(const int *old2New) const
6851 int nbTuples=getNumberOfTuples();
6852 int nbOfCompo=getNumberOfComponents();
6853 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
6854 ret->alloc(nbTuples,nbOfCompo);
6855 ret->copyStringInfoFrom(*this);
6856 const int *iptr=getConstPointer();
6857 int *optr=ret->getPointer();
6858 for(int i=0;i<nbTuples;i++)
6859 std::copy(iptr+nbOfCompo*i,iptr+nbOfCompo*(i+1),optr+nbOfCompo*old2New[i]);
6860 ret->copyStringInfoFrom(*this);
6865 * Returns a copy of \a this array with values permuted as required by \a new2Old array.
6866 * The values are permuted so that \c new[ i ] = \c old[ \a new2Old[ i ]]. Number of
6867 * tuples in the result array remains the same as in \this one.
6868 * If a permutation reduction is needed, substr() or selectByTupleId() should be used.
6869 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
6870 * \param [in] new2Old - C array of length equal to \a this->getNumberOfTuples()
6871 * giving a previous position of i-th new value.
6872 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
6873 * is to delete using decrRef() as it is no more needed.
6875 DataArrayInt *DataArrayInt::renumberR(const int *new2Old) const
6878 int nbTuples=getNumberOfTuples();
6879 int nbOfCompo=getNumberOfComponents();
6880 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
6881 ret->alloc(nbTuples,nbOfCompo);
6882 ret->copyStringInfoFrom(*this);
6883 const int *iptr=getConstPointer();
6884 int *optr=ret->getPointer();
6885 for(int i=0;i<nbTuples;i++)
6886 std::copy(iptr+nbOfCompo*new2Old[i],iptr+nbOfCompo*(new2Old[i]+1),optr+nbOfCompo*i);
6887 ret->copyStringInfoFrom(*this);
6892 * Returns a shorten and permuted copy of \a this array. The new DataArrayInt is
6893 * of size \a newNbOfTuple and it's values are permuted as required by \a old2New array.
6894 * The values are permuted so that \c new[ \a old2New[ i ]] = \c old[ i ] for all
6895 * \a old2New[ i ] >= 0. In other words every i-th tuple in \a this array, for which
6896 * \a old2New[ i ] is negative, is missing from the result array.
6897 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
6898 * \param [in] old2New - C array of length equal to \a this->getNumberOfTuples()
6899 * giving a new position for i-th old tuple and giving negative position for
6900 * for i-th old tuple that should be omitted.
6901 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
6902 * is to delete using decrRef() as it is no more needed.
6904 DataArrayInt *DataArrayInt::renumberAndReduce(const int *old2New, int newNbOfTuple) const
6907 int nbTuples=getNumberOfTuples();
6908 int nbOfCompo=getNumberOfComponents();
6909 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
6910 ret->alloc(newNbOfTuple,nbOfCompo);
6911 const int *iptr=getConstPointer();
6912 int *optr=ret->getPointer();
6913 for(int i=0;i<nbTuples;i++)
6917 std::copy(iptr+i*nbOfCompo,iptr+(i+1)*nbOfCompo,optr+w*nbOfCompo);
6919 ret->copyStringInfoFrom(*this);
6924 * Returns a shorten and permuted copy of \a this array. The new DataArrayInt is
6925 * of size \a new2OldEnd - \a new2OldBg and it's values are permuted as required by
6926 * \a new2OldBg array.
6927 * The values are permuted so that \c new[ i ] = \c old[ \a new2OldBg[ i ]].
6928 * This method is equivalent to renumberAndReduce() except that convention in input is
6929 * \c new2old and \b not \c old2new.
6930 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
6931 * \param [in] new2OldBg - pointer to the beginning of a permutation array that gives a
6932 * tuple index in \a this array to fill the i-th tuple in the new array.
6933 * \param [in] new2OldEnd - specifies the end of the permutation array that starts at
6934 * \a new2OldBg, so that pointer to a tuple index (\a pi) varies as this:
6935 * \a new2OldBg <= \a pi < \a new2OldEnd.
6936 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
6937 * is to delete using decrRef() as it is no more needed.
6939 DataArrayInt *DataArrayInt::selectByTupleId(const int *new2OldBg, const int *new2OldEnd) const
6942 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
6943 int nbComp=getNumberOfComponents();
6944 ret->alloc((int)std::distance(new2OldBg,new2OldEnd),nbComp);
6945 ret->copyStringInfoFrom(*this);
6946 int *pt=ret->getPointer();
6947 const int *srcPt=getConstPointer();
6949 for(const int *w=new2OldBg;w!=new2OldEnd;w++,i++)
6950 std::copy(srcPt+(*w)*nbComp,srcPt+((*w)+1)*nbComp,pt+i*nbComp);
6951 ret->copyStringInfoFrom(*this);
6956 * Returns a shorten and permuted copy of \a this array. The new DataArrayInt is
6957 * of size \a new2OldEnd - \a new2OldBg and it's values are permuted as required by
6958 * \a new2OldBg array.
6959 * The values are permuted so that \c new[ i ] = \c old[ \a new2OldBg[ i ]].
6960 * This method is equivalent to renumberAndReduce() except that convention in input is
6961 * \c new2old and \b not \c old2new.
6962 * This method is equivalent to selectByTupleId() except that it prevents coping data
6963 * from behind the end of \a this array.
6964 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
6965 * \param [in] new2OldBg - pointer to the beginning of a permutation array that gives a
6966 * tuple index in \a this array to fill the i-th tuple in the new array.
6967 * \param [in] new2OldEnd - specifies the end of the permutation array that starts at
6968 * \a new2OldBg, so that pointer to a tuple index (\a pi) varies as this:
6969 * \a new2OldBg <= \a pi < \a new2OldEnd.
6970 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
6971 * is to delete using decrRef() as it is no more needed.
6972 * \throw If \a new2OldEnd - \a new2OldBg > \a this->getNumberOfTuples().
6974 DataArrayInt *DataArrayInt::selectByTupleIdSafe(const int *new2OldBg, const int *new2OldEnd) const
6977 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
6978 int nbComp=getNumberOfComponents();
6979 int oldNbOfTuples=getNumberOfTuples();
6980 ret->alloc((int)std::distance(new2OldBg,new2OldEnd),nbComp);
6981 ret->copyStringInfoFrom(*this);
6982 int *pt=ret->getPointer();
6983 const int *srcPt=getConstPointer();
6985 for(const int *w=new2OldBg;w!=new2OldEnd;w++,i++)
6986 if(*w>=0 && *w<oldNbOfTuples)
6987 std::copy(srcPt+(*w)*nbComp,srcPt+((*w)+1)*nbComp,pt+i*nbComp);
6989 throw INTERP_KERNEL::Exception("DataArrayInt::selectByTupleIdSafe : some ids has been detected to be out of [0,this->getNumberOfTuples) !");
6990 ret->copyStringInfoFrom(*this);
6995 * Returns a shorten copy of \a this array. The new DataArrayInt contains every
6996 * (\a bg + \c i * \a step)-th tuple of \a this array located before the \a end2-th
6997 * tuple. Indices of the selected tuples are the same as ones returned by the Python
6998 * command \c range( \a bg, \a end2, \a step ).
6999 * This method is equivalent to selectByTupleIdSafe() except that the input array is
7000 * not constructed explicitly.
7001 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
7002 * \param [in] bg - index of the first tuple to copy from \a this array.
7003 * \param [in] end2 - index of the tuple before which the tuples to copy are located.
7004 * \param [in] step - index increment to get index of the next tuple to copy.
7005 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
7006 * is to delete using decrRef() as it is no more needed.
7007 * \sa DataArrayInt::substr.
7009 DataArrayInt *DataArrayInt::selectByTupleId2(int bg, int end2, int step) const
7012 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7013 int nbComp=getNumberOfComponents();
7014 int newNbOfTuples=GetNumberOfItemGivenBESRelative(bg,end2,step,"DataArrayInt::selectByTupleId2 : ");
7015 ret->alloc(newNbOfTuples,nbComp);
7016 int *pt=ret->getPointer();
7017 const int *srcPt=getConstPointer()+bg*nbComp;
7018 for(int i=0;i<newNbOfTuples;i++,srcPt+=step*nbComp)
7019 std::copy(srcPt,srcPt+nbComp,pt+i*nbComp);
7020 ret->copyStringInfoFrom(*this);
7025 * Returns a shorten copy of \a this array. The new DataArrayInt contains ranges
7026 * of tuples specified by \a ranges parameter.
7027 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
7028 * \param [in] ranges - std::vector of std::pair's each of which defines a range
7029 * of tuples in [\c begin,\c end) format.
7030 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
7031 * is to delete using decrRef() as it is no more needed.
7032 * \throw If \a end < \a begin.
7033 * \throw If \a end > \a this->getNumberOfTuples().
7034 * \throw If \a this is not allocated.
7036 DataArray *DataArrayInt::selectByTupleRanges(const std::vector<std::pair<int,int> >& ranges) const
7039 int nbOfComp=getNumberOfComponents();
7040 int nbOfTuplesThis=getNumberOfTuples();
7043 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7044 ret->alloc(0,nbOfComp);
7045 ret->copyStringInfoFrom(*this);
7048 int ref=ranges.front().first;
7050 bool isIncreasing=true;
7051 for(std::vector<std::pair<int,int> >::const_iterator it=ranges.begin();it!=ranges.end();it++)
7053 if((*it).first<=(*it).second)
7055 if((*it).first>=0 && (*it).second<=nbOfTuplesThis)
7057 nbOfTuples+=(*it).second-(*it).first;
7059 isIncreasing=ref<=(*it).first;
7064 std::ostringstream oss; oss << "DataArrayInt::selectByTupleRanges : on range #" << std::distance(ranges.begin(),it);
7065 oss << " (" << (*it).first << "," << (*it).second << ") is greater than number of tuples of this :" << nbOfTuples << " !";
7066 throw INTERP_KERNEL::Exception(oss.str().c_str());
7071 std::ostringstream oss; oss << "DataArrayInt::selectByTupleRanges : on range #" << std::distance(ranges.begin(),it);
7072 oss << " (" << (*it).first << "," << (*it).second << ") end is before begin !";
7073 throw INTERP_KERNEL::Exception(oss.str().c_str());
7076 if(isIncreasing && nbOfTuplesThis==nbOfTuples)
7078 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7079 ret->alloc(nbOfTuples,nbOfComp);
7080 ret->copyStringInfoFrom(*this);
7081 const int *src=getConstPointer();
7082 int *work=ret->getPointer();
7083 for(std::vector<std::pair<int,int> >::const_iterator it=ranges.begin();it!=ranges.end();it++)
7084 work=std::copy(src+(*it).first*nbOfComp,src+(*it).second*nbOfComp,work);
7089 * Returns a new DataArrayInt containing a renumbering map in "Old to New" mode.
7090 * This map, if applied to \a this array, would make it sorted. For example, if
7091 * \a this array contents are [9,10,0,6,4,11,3,7] then the contents of the result array
7092 * are [5,6,0,3,2,7,1,4]; if this result array (\a res) is used as an argument in call
7093 * \a this->renumber(\a res) then the returned array contains [0,3,4,6,7,9,10,11].
7094 * This method is useful for renumbering (in MED file for example). For more info
7095 * on renumbering see \ref MEDCouplingArrayRenumbering.
7096 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
7097 * array using decrRef() as it is no more needed.
7098 * \throw If \a this is not allocated.
7099 * \throw If \a this->getNumberOfComponents() != 1.
7100 * \throw If there are equal values in \a this array.
7102 DataArrayInt *DataArrayInt::checkAndPreparePermutation() const
7105 if(getNumberOfComponents()!=1)
7106 throw INTERP_KERNEL::Exception("DataArrayInt::checkAndPreparePermutation : number of components must == 1 !");
7107 int nbTuples=getNumberOfTuples();
7108 const int *pt=getConstPointer();
7109 int *pt2=CheckAndPreparePermutation(pt,pt+nbTuples);
7110 DataArrayInt *ret=DataArrayInt::New();
7111 ret->useArray(pt2,true,C_DEALLOC,nbTuples,1);
7116 * 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
7117 * input array \a ids2.
7118 * \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.
7119 * 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
7121 * In case of success (no throw) : \c ids1->renumber(ret)->isEqual(ids2) where \a ret is the return of this method.
7123 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
7124 * array using decrRef() as it is no more needed.
7125 * \throw If either ids1 or ids2 is null not allocated or not with one components.
7128 DataArrayInt *DataArrayInt::FindPermutationFromFirstToSecond(const DataArrayInt *ids1, const DataArrayInt *ids2)
7131 throw INTERP_KERNEL::Exception("DataArrayInt::FindPermutationFromFirstToSecond : the two input arrays must be not null !");
7132 if(!ids1->isAllocated() || !ids2->isAllocated())
7133 throw INTERP_KERNEL::Exception("DataArrayInt::FindPermutationFromFirstToSecond : the two input arrays must be allocated !");
7134 if(ids1->getNumberOfComponents()!=1 || ids2->getNumberOfComponents()!=1)
7135 throw INTERP_KERNEL::Exception("DataArrayInt::FindPermutationFromFirstToSecond : the two input arrays have exactly one component !");
7136 if(ids1->getNumberOfTuples()!=ids2->getNumberOfTuples())
7138 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 !";
7139 throw INTERP_KERNEL::Exception(oss.str().c_str());
7141 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> p1(ids1->deepCpy());
7142 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> p2(ids2->deepCpy());
7143 p1->sort(true); p2->sort(true);
7144 if(!p1->isEqualWithoutConsideringStr(*p2))
7145 throw INTERP_KERNEL::Exception("DataArrayInt::FindPermutationFromFirstToSecond : the two arrays are not lying on same ids ! Impossible to find a permutation between the 2 arrays !");
7146 p1=ids1->checkAndPreparePermutation();
7147 p2=ids2->checkAndPreparePermutation();
7148 p2=p2->invertArrayO2N2N2O(p2->getNumberOfTuples());
7149 p2=p2->selectByTupleIdSafe(p1->begin(),p1->end());
7154 * Returns two arrays describing a surjective mapping from \a this set of values (\a A)
7155 * onto a set of values of size \a targetNb (\a B). The surjective function is
7156 * \a B[ \a A[ i ]] = i. That is to say that for each \a id in [0,\a targetNb), where \a
7157 * targetNb < \a this->getNumberOfTuples(), there exists at least one tupleId (\a tid) so
7158 * that <em> this->getIJ( tid, 0 ) == id</em>. <br>
7159 * The first of out arrays returns indices of elements of \a this array, grouped by their
7160 * place in the set \a B. The second out array is the index of the first one; it shows how
7161 * many elements of \a A are mapped into each element of \a B. <br>
7163 * mapping and its usage in renumbering see \ref MEDCouplingArrayRenumbering. <br>
7165 * - \a this: [0,3,2,3,2,2,1,2]
7167 * - \a arr: [0, 6, 2,4,5,7, 1,3]
7168 * - \a arrI: [0,1,2,6,8]
7170 * This result means: <br>
7171 * the element of \a B 0 encounters within \a A once (\a arrI[ 0+1 ] - \a arrI[ 0 ]) and
7172 * its index within \a A is 0 ( \a arr[ 0:1 ] == \a arr[ \a arrI[ 0 ] : \a arrI[ 0+1 ]]);<br>
7173 * the element of \a B 2 encounters within \a A 4 times (\a arrI[ 2+1 ] - \a arrI[ 2 ]) and
7174 * its indices within \a A are [2,4,5,7] ( \a arr[ 2:6 ] == \a arr[ \a arrI[ 2 ] :
7175 * \a arrI[ 2+1 ]]); <br> etc.
7176 * \param [in] targetNb - the size of the set \a B. \a targetNb must be equal or more
7177 * than the maximal value of \a A.
7178 * \param [out] arr - a new instance of DataArrayInt returning indices of
7179 * elements of \a this, grouped by their place in the set \a B. The caller is to delete
7180 * this array using decrRef() as it is no more needed.
7181 * \param [out] arrI - a new instance of DataArrayInt returning size of groups of equal
7182 * elements of \a this. The caller is to delete this array using decrRef() as it
7183 * is no more needed.
7184 * \throw If \a this is not allocated.
7185 * \throw If \a this->getNumberOfComponents() != 1.
7186 * \throw If any value in \a this is more or equal to \a targetNb.
7188 void DataArrayInt::changeSurjectiveFormat(int targetNb, DataArrayInt *&arr, DataArrayInt *&arrI) const
7191 if(getNumberOfComponents()!=1)
7192 throw INTERP_KERNEL::Exception("DataArrayInt::changeSurjectiveFormat : number of components must == 1 !");
7193 int nbOfTuples=getNumberOfTuples();
7194 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New());
7195 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> retI(DataArrayInt::New());
7196 retI->alloc(targetNb+1,1);
7197 const int *input=getConstPointer();
7198 std::vector< std::vector<int> > tmp(targetNb);
7199 for(int i=0;i<nbOfTuples;i++)
7202 if(tmp2>=0 && tmp2<targetNb)
7203 tmp[tmp2].push_back(i);
7206 std::ostringstream oss; oss << "DataArrayInt::changeSurjectiveFormat : At pos " << i << " presence of element " << tmp2 << " ! should be in [0," << targetNb << ") !";
7207 throw INTERP_KERNEL::Exception(oss.str().c_str());
7210 int *retIPtr=retI->getPointer();
7212 for(std::vector< std::vector<int> >::const_iterator it1=tmp.begin();it1!=tmp.end();it1++,retIPtr++)
7213 retIPtr[1]=retIPtr[0]+(int)((*it1).size());
7214 if(nbOfTuples!=retI->getIJ(targetNb,0))
7215 throw INTERP_KERNEL::Exception("DataArrayInt::changeSurjectiveFormat : big problem should never happen !");
7216 ret->alloc(nbOfTuples,1);
7217 int *retPtr=ret->getPointer();
7218 for(std::vector< std::vector<int> >::const_iterator it1=tmp.begin();it1!=tmp.end();it1++)
7219 retPtr=std::copy((*it1).begin(),(*it1).end(),retPtr);
7226 * Returns a new DataArrayInt containing a renumbering map in "Old to New" mode computed
7227 * from a zip representation of a surjective format (returned e.g. by
7228 * \ref ParaMEDMEM::DataArrayDouble::findCommonTuples() "DataArrayDouble::findCommonTuples()"
7229 * for example). The result array minimizes the permutation. <br>
7230 * For more info on renumbering see \ref MEDCouplingArrayRenumbering. <br>
7232 * - \a nbOfOldTuples: 10
7233 * - \a arr : [0,3, 5,7,9]
7234 * - \a arrIBg : [0,2,5]
7235 * - \a newNbOfTuples: 7
7236 * - result array : [0,1,2,0,3,4,5,4,6,4]
7238 * \param [in] nbOfOldTuples - number of tuples in the initial array \a arr.
7239 * \param [in] arr - the array of tuple indices grouped by \a arrIBg array.
7240 * \param [in] arrIBg - the array dividing all indices stored in \a arr into groups of
7241 * (indices of) equal values. Its every element (except the last one) points to
7242 * the first element of a group of equal values.
7243 * \param [in] arrIEnd - specifies the end of \a arrIBg, so that the last element of \a
7244 * arrIBg is \a arrIEnd[ -1 ].
7245 * \param [out] newNbOfTuples - number of tuples after surjection application.
7246 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
7247 * array using decrRef() as it is no more needed.
7248 * \throw If any value of \a arr breaks condition ( 0 <= \a arr[ i ] < \a nbOfOldTuples ).
7250 DataArrayInt *DataArrayInt::BuildOld2NewArrayFromSurjectiveFormat2(int nbOfOldTuples, const int *arr, const int *arrIBg, const int *arrIEnd, int &newNbOfTuples)
7252 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7253 ret->alloc(nbOfOldTuples,1);
7254 int *pt=ret->getPointer();
7255 std::fill(pt,pt+nbOfOldTuples,-1);
7256 int nbOfGrps=((int)std::distance(arrIBg,arrIEnd))-1;
7257 const int *cIPtr=arrIBg;
7258 for(int i=0;i<nbOfGrps;i++)
7259 pt[arr[cIPtr[i]]]=-(i+2);
7261 for(int iNode=0;iNode<nbOfOldTuples;iNode++)
7269 int grpId=-(pt[iNode]+2);
7270 for(int j=cIPtr[grpId];j<cIPtr[grpId+1];j++)
7272 if(arr[j]>=0 && arr[j]<nbOfOldTuples)
7276 std::ostringstream oss; oss << "DataArrayInt::BuildOld2NewArrayFromSurjectiveFormat2 : With element #" << j << " value is " << arr[j] << " should be in [0," << nbOfOldTuples << ") !";
7277 throw INTERP_KERNEL::Exception(oss.str().c_str());
7284 newNbOfTuples=newNb;
7289 * Returns a new DataArrayInt containing a renumbering map in "New to Old" mode,
7290 * which if applied to \a this array would make it sorted ascendingly.
7291 * For more info on renumbering see \ref MEDCouplingArrayRenumbering. <br>
7293 * - \a this: [2,0,1,1,0,1,2,0,1,1,0,0]
7294 * - result: [10,0,5,6,1,7,11,2,8,9,3,4]
7295 * - after applying result to \a this: [0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2]
7297 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
7298 * array using decrRef() as it is no more needed.
7299 * \throw If \a this is not allocated.
7300 * \throw If \a this->getNumberOfComponents() != 1.
7302 DataArrayInt *DataArrayInt::buildPermArrPerLevel() const
7305 if(getNumberOfComponents()!=1)
7306 throw INTERP_KERNEL::Exception("DataArrayInt::buildPermArrPerLevel : number of components must == 1 !");
7307 int nbOfTuples=getNumberOfTuples();
7308 const int *pt=getConstPointer();
7309 std::map<int,int> m;
7310 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7311 ret->alloc(nbOfTuples,1);
7312 int *opt=ret->getPointer();
7313 for(int i=0;i<nbOfTuples;i++,pt++,opt++)
7316 std::map<int,int>::iterator it=m.find(val);
7325 m.insert(std::pair<int,int>(val,1));
7329 for(std::map<int,int>::iterator it=m.begin();it!=m.end();it++)
7331 int vt=(*it).second;
7335 pt=getConstPointer();
7336 opt=ret->getPointer();
7337 for(int i=0;i<nbOfTuples;i++,pt++,opt++)
7344 * Checks if contents of \a this array are equal to that of an array filled with
7345 * iota(). This method is particularly useful for DataArrayInt instances that represent
7346 * a renumbering array to check the real need in renumbering.
7347 * \return bool - \a true if \a this array contents == \a range( \a this->getNumberOfTuples())
7348 * \throw If \a this is not allocated.
7349 * \throw If \a this->getNumberOfComponents() != 1.
7351 bool DataArrayInt::isIdentity() const
7354 if(getNumberOfComponents()!=1)
7356 int nbOfTuples=getNumberOfTuples();
7357 const int *pt=getConstPointer();
7358 for(int i=0;i<nbOfTuples;i++,pt++)
7365 * Checks if all values in \a this array are equal to \a val.
7366 * \param [in] val - value to check equality of array values to.
7367 * \return bool - \a true if all values are \a val.
7368 * \throw If \a this is not allocated.
7369 * \throw If \a this->getNumberOfComponents() != 1
7371 bool DataArrayInt::isUniform(int val) const
7374 if(getNumberOfComponents()!=1)
7375 throw INTERP_KERNEL::Exception("DataArrayInt::isUniform : must be applied on DataArrayInt with only one component, you can call 'rearrange' method before !");
7376 int nbOfTuples=getNumberOfTuples();
7377 const int *w=getConstPointer();
7378 const int *end2=w+nbOfTuples;
7386 * Creates a new DataArrayDouble and assigns all (textual and numerical) data of \a this
7387 * array to the new one.
7388 * \return DataArrayDouble * - the new instance of DataArrayInt.
7390 DataArrayDouble *DataArrayInt::convertToDblArr() const
7393 DataArrayDouble *ret=DataArrayDouble::New();
7394 ret->alloc(getNumberOfTuples(),getNumberOfComponents());
7395 std::size_t nbOfVals=getNbOfElems();
7396 const int *src=getConstPointer();
7397 double *dest=ret->getPointer();
7398 std::copy(src,src+nbOfVals,dest);
7399 ret->copyStringInfoFrom(*this);
7404 * Returns a shorten copy of \a this array. The new DataArrayInt contains all
7405 * tuples starting from the \a tupleIdBg-th tuple and including all tuples located before
7406 * the \a tupleIdEnd-th one. This methods has a similar behavior as std::string::substr().
7407 * This method is a specialization of selectByTupleId2().
7408 * \param [in] tupleIdBg - index of the first tuple to copy from \a this array.
7409 * \param [in] tupleIdEnd - index of the tuple before which the tuples to copy are located.
7410 * If \a tupleIdEnd == -1, all the tuples till the end of \a this array are copied.
7411 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
7412 * is to delete using decrRef() as it is no more needed.
7413 * \throw If \a tupleIdBg < 0.
7414 * \throw If \a tupleIdBg > \a this->getNumberOfTuples().
7415 \throw If \a tupleIdEnd != -1 && \a tupleIdEnd < \a this->getNumberOfTuples().
7416 * \sa DataArrayInt::selectByTupleId2
7418 DataArrayInt *DataArrayInt::substr(int tupleIdBg, int tupleIdEnd) const
7421 int nbt=getNumberOfTuples();
7423 throw INTERP_KERNEL::Exception("DataArrayInt::substr : The tupleIdBg parameter must be greater than 0 !");
7425 throw INTERP_KERNEL::Exception("DataArrayInt::substr : The tupleIdBg parameter is greater than number of tuples !");
7426 int trueEnd=tupleIdEnd;
7430 throw INTERP_KERNEL::Exception("DataArrayInt::substr : The tupleIdBg parameter is greater or equal than number of tuples !");
7434 int nbComp=getNumberOfComponents();
7435 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7436 ret->alloc(trueEnd-tupleIdBg,nbComp);
7437 ret->copyStringInfoFrom(*this);
7438 std::copy(getConstPointer()+tupleIdBg*nbComp,getConstPointer()+trueEnd*nbComp,ret->getPointer());
7443 * Changes the number of components within \a this array so that its raw data **does
7444 * not** change, instead splitting this data into tuples changes.
7445 * \warning This method erases all (name and unit) component info set before!
7446 * \param [in] newNbOfComp - number of components for \a this array to have.
7447 * \throw If \a this is not allocated
7448 * \throw If getNbOfElems() % \a newNbOfCompo != 0.
7449 * \throw If \a newNbOfCompo is lower than 1.
7450 * \throw If the rearrange method would lead to a number of tuples higher than 2147483647 (maximal capacity of int32 !).
7451 * \warning This method erases all (name and unit) component info set before!
7453 void DataArrayInt::rearrange(int newNbOfCompo)
7457 throw INTERP_KERNEL::Exception("DataArrayInt::rearrange : input newNbOfCompo must be > 0 !");
7458 std::size_t nbOfElems=getNbOfElems();
7459 if(nbOfElems%newNbOfCompo!=0)
7460 throw INTERP_KERNEL::Exception("DataArrayInt::rearrange : nbOfElems%newNbOfCompo!=0 !");
7461 if(nbOfElems/newNbOfCompo>(std::size_t)std::numeric_limits<int>::max())
7462 throw INTERP_KERNEL::Exception("DataArrayInt::rearrange : the rearrangement leads to too high number of tuples (> 2147483647) !");
7463 _info_on_compo.clear();
7464 _info_on_compo.resize(newNbOfCompo);
7469 * Changes the number of components within \a this array to be equal to its number
7470 * of tuples, and inversely its number of tuples to become equal to its number of
7471 * components. So that its raw data **does not** change, instead splitting this
7472 * data into tuples changes.
7473 * \warning This method erases all (name and unit) component info set before!
7474 * \warning Do not confuse this method with fromNoInterlace() and toNoInterlace()!
7475 * \throw If \a this is not allocated.
7478 void DataArrayInt::transpose()
7481 int nbOfTuples=getNumberOfTuples();
7482 rearrange(nbOfTuples);
7486 * Returns a shorten or extended copy of \a this array. If \a newNbOfComp is less
7487 * than \a this->getNumberOfComponents() then the result array is shorten as each tuple
7488 * is truncated to have \a newNbOfComp components, keeping first components. If \a
7489 * newNbOfComp is more than \a this->getNumberOfComponents() then the result array is
7490 * expanded as each tuple is populated with \a dftValue to have \a newNbOfComp
7492 * \param [in] newNbOfComp - number of components for the new array to have.
7493 * \param [in] dftValue - value assigned to new values added to the new array.
7494 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
7495 * is to delete using decrRef() as it is no more needed.
7496 * \throw If \a this is not allocated.
7498 DataArrayInt *DataArrayInt::changeNbOfComponents(int newNbOfComp, int dftValue) const
7501 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7502 ret->alloc(getNumberOfTuples(),newNbOfComp);
7503 const int *oldc=getConstPointer();
7504 int *nc=ret->getPointer();
7505 int nbOfTuples=getNumberOfTuples();
7506 int oldNbOfComp=getNumberOfComponents();
7507 int dim=std::min(oldNbOfComp,newNbOfComp);
7508 for(int i=0;i<nbOfTuples;i++)
7512 nc[newNbOfComp*i+j]=oldc[i*oldNbOfComp+j];
7513 for(;j<newNbOfComp;j++)
7514 nc[newNbOfComp*i+j]=dftValue;
7516 ret->setName(getName().c_str());
7517 for(int i=0;i<dim;i++)
7518 ret->setInfoOnComponent(i,getInfoOnComponent(i).c_str());
7519 ret->setName(getName().c_str());
7524 * Changes number of tuples in the array. If the new number of tuples is smaller
7525 * than the current number the array is truncated, otherwise the array is extended.
7526 * \param [in] nbOfTuples - new number of tuples.
7527 * \throw If \a this is not allocated.
7528 * \throw If \a nbOfTuples is negative.
7530 void DataArrayInt::reAlloc(int nbOfTuples)
7533 throw INTERP_KERNEL::Exception("DataArrayInt::reAlloc : input new number of tuples should be >=0 !");
7535 _mem.reAlloc(getNumberOfComponents()*(std::size_t)nbOfTuples);
7541 * Returns a copy of \a this array composed of selected components.
7542 * The new DataArrayInt has the same number of tuples but includes components
7543 * specified by \a compoIds parameter. So that getNbOfElems() of the result array
7544 * can be either less, same or more than \a this->getNbOfElems().
7545 * \param [in] compoIds - sequence of zero based indices of components to include
7546 * into the new array.
7547 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
7548 * is to delete using decrRef() as it is no more needed.
7549 * \throw If \a this is not allocated.
7550 * \throw If a component index (\a i) is not valid:
7551 * \a i < 0 || \a i >= \a this->getNumberOfComponents().
7553 * \ref py_mcdataarrayint_keepselectedcomponents "Here is a Python example".
7555 DataArray *DataArrayInt::keepSelectedComponents(const std::vector<int>& compoIds) const
7558 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New());
7559 int newNbOfCompo=(int)compoIds.size();
7560 int oldNbOfCompo=getNumberOfComponents();
7561 for(std::vector<int>::const_iterator it=compoIds.begin();it!=compoIds.end();it++)
7562 DataArray::CheckValueInRange(oldNbOfCompo,(*it),"keepSelectedComponents invalid requested component");
7563 int nbOfTuples=getNumberOfTuples();
7564 ret->alloc(nbOfTuples,newNbOfCompo);
7565 ret->copyPartOfStringInfoFrom(*this,compoIds);
7566 const int *oldc=getConstPointer();
7567 int *nc=ret->getPointer();
7568 for(int i=0;i<nbOfTuples;i++)
7569 for(int j=0;j<newNbOfCompo;j++,nc++)
7570 *nc=oldc[i*oldNbOfCompo+compoIds[j]];
7575 * Appends components of another array to components of \a this one, tuple by tuple.
7576 * So that the number of tuples of \a this array remains the same and the number of
7577 * components increases.
7578 * \param [in] other - the DataArrayInt to append to \a this one.
7579 * \throw If \a this is not allocated.
7580 * \throw If \a this and \a other arrays have different number of tuples.
7582 * \ref cpp_mcdataarrayint_meldwith "Here is a C++ example".
7584 * \ref py_mcdataarrayint_meldwith "Here is a Python example".
7586 void DataArrayInt::meldWith(const DataArrayInt *other)
7589 throw INTERP_KERNEL::Exception("DataArrayInt::meldWith : DataArrayInt pointer in input is NULL !");
7591 other->checkAllocated();
7592 int nbOfTuples=getNumberOfTuples();
7593 if(nbOfTuples!=other->getNumberOfTuples())
7594 throw INTERP_KERNEL::Exception("DataArrayInt::meldWith : mismatch of number of tuples !");
7595 int nbOfComp1=getNumberOfComponents();
7596 int nbOfComp2=other->getNumberOfComponents();
7597 int *newArr=(int *)malloc(nbOfTuples*(nbOfComp1+nbOfComp2)*sizeof(int));
7599 const int *inp1=getConstPointer();
7600 const int *inp2=other->getConstPointer();
7601 for(int i=0;i<nbOfTuples;i++,inp1+=nbOfComp1,inp2+=nbOfComp2)
7603 w=std::copy(inp1,inp1+nbOfComp1,w);
7604 w=std::copy(inp2,inp2+nbOfComp2,w);
7606 useArray(newArr,true,C_DEALLOC,nbOfTuples,nbOfComp1+nbOfComp2);
7607 std::vector<int> compIds(nbOfComp2);
7608 for(int i=0;i<nbOfComp2;i++)
7609 compIds[i]=nbOfComp1+i;
7610 copyPartOfStringInfoFrom2(compIds,*other);
7614 * Copy all components in a specified order from another DataArrayInt.
7615 * The specified components become the first ones in \a this array.
7616 * Both numerical and textual data is copied. The number of tuples in \a this and
7617 * the other array can be different.
7618 * \param [in] a - the array to copy data from.
7619 * \param [in] compoIds - sequence of zero based indices of components, data of which is
7621 * \throw If \a a is NULL.
7622 * \throw If \a compoIds.size() != \a a->getNumberOfComponents().
7623 * \throw If \a compoIds[i] < 0 or \a compoIds[i] > \a this->getNumberOfComponents().
7625 * \ref py_mcdataarrayint_setselectedcomponents "Here is a Python example".
7627 void DataArrayInt::setSelectedComponents(const DataArrayInt *a, const std::vector<int>& compoIds)
7630 throw INTERP_KERNEL::Exception("DataArrayInt::setSelectedComponents : input DataArrayInt is NULL !");
7632 a->checkAllocated();
7633 copyPartOfStringInfoFrom2(compoIds,*a);
7634 std::size_t partOfCompoSz=compoIds.size();
7635 int nbOfCompo=getNumberOfComponents();
7636 int nbOfTuples=std::min(getNumberOfTuples(),a->getNumberOfTuples());
7637 const int *ac=a->getConstPointer();
7638 int *nc=getPointer();
7639 for(int i=0;i<nbOfTuples;i++)
7640 for(std::size_t j=0;j<partOfCompoSz;j++,ac++)
7641 nc[nbOfCompo*i+compoIds[j]]=*ac;
7645 * Copy all values from another DataArrayInt into specified tuples and components
7646 * of \a this array. Textual data is not copied.
7647 * The tree parameters defining set of indices of tuples and components are similar to
7648 * the tree parameters of the Python function \c range(\c start,\c stop,\c step).
7649 * \param [in] a - the array to copy values from.
7650 * \param [in] bgTuples - index of the first tuple of \a this array to assign values to.
7651 * \param [in] endTuples - index of the tuple before which the tuples to assign to
7653 * \param [in] stepTuples - index increment to get index of the next tuple to assign to.
7654 * \param [in] bgComp - index of the first component of \a this array to assign values to.
7655 * \param [in] endComp - index of the component before which the components to assign
7657 * \param [in] stepComp - index increment to get index of the next component to assign to.
7658 * \param [in] strictCompoCompare - if \a true (by default), then \a a->getNumberOfComponents()
7659 * must be equal to the number of columns to assign to, else an
7660 * exception is thrown; if \a false, then it is only required that \a
7661 * a->getNbOfElems() equals to number of values to assign to (this condition
7662 * must be respected even if \a strictCompoCompare is \a true). The number of
7663 * values to assign to is given by following Python expression:
7664 * \a nbTargetValues =
7665 * \c len(\c range(\a bgTuples,\a endTuples,\a stepTuples)) *
7666 * \c len(\c range(\a bgComp,\a endComp,\a stepComp)).
7667 * \throw If \a a is NULL.
7668 * \throw If \a a is not allocated.
7669 * \throw If \a this is not allocated.
7670 * \throw If parameters specifying tuples and components to assign to do not give a
7671 * non-empty range of increasing indices.
7672 * \throw If \a a->getNbOfElems() != \a nbTargetValues.
7673 * \throw If \a strictCompoCompare == \a true && \a a->getNumberOfComponents() !=
7674 * \c len(\c range(\a bgComp,\a endComp,\a stepComp)).
7676 * \ref py_mcdataarrayint_setpartofvalues1 "Here is a Python example".
7678 void DataArrayInt::setPartOfValues1(const DataArrayInt *a, int bgTuples, int endTuples, int stepTuples, int bgComp, int endComp, int stepComp, bool strictCompoCompare)
7681 throw INTERP_KERNEL::Exception("DataArrayInt::setPartOfValues1 : DataArrayInt pointer in input is NULL !");
7682 const char msg[]="DataArrayInt::setPartOfValues1";
7684 a->checkAllocated();
7685 int newNbOfTuples=DataArray::GetNumberOfItemGivenBES(bgTuples,endTuples,stepTuples,msg);
7686 int newNbOfComp=DataArray::GetNumberOfItemGivenBES(bgComp,endComp,stepComp,msg);
7687 int nbComp=getNumberOfComponents();
7688 int nbOfTuples=getNumberOfTuples();
7689 DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
7690 DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
7691 bool assignTech=true;
7692 if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
7694 if(strictCompoCompare)
7695 a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
7699 a->checkNbOfTuplesAndComp(1,newNbOfComp,msg);
7702 int *pt=getPointer()+bgTuples*nbComp+bgComp;
7703 const int *srcPt=a->getConstPointer();
7706 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
7707 for(int j=0;j<newNbOfComp;j++,srcPt++)
7708 pt[j*stepComp]=*srcPt;
7712 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
7714 const int *srcPt2=srcPt;
7715 for(int j=0;j<newNbOfComp;j++,srcPt2++)
7716 pt[j*stepComp]=*srcPt2;
7722 * Assign a given value to values at specified tuples and components of \a this array.
7723 * The tree parameters defining set of indices of tuples and components are similar to
7724 * the tree parameters of the Python function \c range(\c start,\c stop,\c step)..
7725 * \param [in] a - the value to assign.
7726 * \param [in] bgTuples - index of the first tuple of \a this array to assign to.
7727 * \param [in] endTuples - index of the tuple before which the tuples to assign to
7729 * \param [in] stepTuples - index increment to get index of the next tuple to assign to.
7730 * \param [in] bgComp - index of the first component of \a this array to assign to.
7731 * \param [in] endComp - index of the component before which the components to assign
7733 * \param [in] stepComp - index increment to get index of the next component to assign to.
7734 * \throw If \a this is not allocated.
7735 * \throw If parameters specifying tuples and components to assign to, do not give a
7736 * non-empty range of increasing indices or indices are out of a valid range
7739 * \ref py_mcdataarrayint_setpartofvaluessimple1 "Here is a Python example".
7741 void DataArrayInt::setPartOfValuesSimple1(int a, int bgTuples, int endTuples, int stepTuples, int bgComp, int endComp, int stepComp)
7743 const char msg[]="DataArrayInt::setPartOfValuesSimple1";
7745 int newNbOfTuples=DataArray::GetNumberOfItemGivenBES(bgTuples,endTuples,stepTuples,msg);
7746 int newNbOfComp=DataArray::GetNumberOfItemGivenBES(bgComp,endComp,stepComp,msg);
7747 int nbComp=getNumberOfComponents();
7748 int nbOfTuples=getNumberOfTuples();
7749 DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
7750 DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
7751 int *pt=getPointer()+bgTuples*nbComp+bgComp;
7752 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
7753 for(int j=0;j<newNbOfComp;j++)
7759 * Copy all values from another DataArrayInt (\a a) into specified tuples and
7760 * components of \a this array. Textual data is not copied.
7761 * The tuples and components to assign to are defined by C arrays of indices.
7762 * There are two *modes of usage*:
7763 * - If \a a->getNbOfElems() equals to number of values to assign to, then every value
7764 * of \a a is assigned to its own location within \a this array.
7765 * - If \a a includes one tuple, then all values of \a a are assigned to the specified
7766 * components of every specified tuple of \a this array. In this mode it is required
7767 * that \a a->getNumberOfComponents() equals to the number of specified components.
7769 * \param [in] a - the array to copy values from.
7770 * \param [in] bgTuples - pointer to an array of tuple indices of \a this array to
7771 * assign values of \a a to.
7772 * \param [in] endTuples - specifies the end of the array \a bgTuples, so that
7773 * pointer to a tuple index <em>(pi)</em> varies as this:
7774 * \a bgTuples <= \a pi < \a endTuples.
7775 * \param [in] bgComp - pointer to an array of component indices of \a this array to
7776 * assign values of \a a to.
7777 * \param [in] endComp - specifies the end of the array \a bgTuples, so that
7778 * pointer to a component index <em>(pi)</em> varies as this:
7779 * \a bgComp <= \a pi < \a endComp.
7780 * \param [in] strictCompoCompare - this parameter is checked only if the
7781 * *mode of usage* is the first; if it is \a true (default),
7782 * then \a a->getNumberOfComponents() must be equal
7783 * to the number of specified columns, else this is not required.
7784 * \throw If \a a is NULL.
7785 * \throw If \a a is not allocated.
7786 * \throw If \a this is not allocated.
7787 * \throw If any index of tuple/component given by <em>bgTuples / bgComp</em> is
7788 * out of a valid range for \a this array.
7789 * \throw In the first *mode of usage*, if <em>strictCompoCompare == true </em> and
7790 * if <em> a->getNumberOfComponents() != (endComp - bgComp) </em>.
7791 * \throw In the second *mode of usage*, if \a a->getNumberOfTuples() != 1 or
7792 * <em> a->getNumberOfComponents() != (endComp - bgComp)</em>.
7794 * \ref py_mcdataarrayint_setpartofvalues2 "Here is a Python example".
7796 void DataArrayInt::setPartOfValues2(const DataArrayInt *a, const int *bgTuples, const int *endTuples, const int *bgComp, const int *endComp, bool strictCompoCompare)
7799 throw INTERP_KERNEL::Exception("DataArrayInt::setPartOfValues2 : DataArrayInt pointer in input is NULL !");
7800 const char msg[]="DataArrayInt::setPartOfValues2";
7802 a->checkAllocated();
7803 int nbComp=getNumberOfComponents();
7804 int nbOfTuples=getNumberOfTuples();
7805 for(const int *z=bgComp;z!=endComp;z++)
7806 DataArray::CheckValueInRange(nbComp,*z,"invalid component id");
7807 int newNbOfTuples=(int)std::distance(bgTuples,endTuples);
7808 int newNbOfComp=(int)std::distance(bgComp,endComp);
7809 bool assignTech=true;
7810 if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
7812 if(strictCompoCompare)
7813 a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
7817 a->checkNbOfTuplesAndComp(1,newNbOfComp,msg);
7820 int *pt=getPointer();
7821 const int *srcPt=a->getConstPointer();
7824 for(const int *w=bgTuples;w!=endTuples;w++)
7826 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
7827 for(const int *z=bgComp;z!=endComp;z++,srcPt++)
7829 pt[(std::size_t)(*w)*nbComp+(*z)]=*srcPt;
7835 for(const int *w=bgTuples;w!=endTuples;w++)
7837 const int *srcPt2=srcPt;
7838 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
7839 for(const int *z=bgComp;z!=endComp;z++,srcPt2++)
7841 pt[(std::size_t)(*w)*nbComp+(*z)]=*srcPt2;
7848 * Assign a given value to values at specified tuples and components of \a this array.
7849 * The tuples and components to assign to are defined by C arrays of indices.
7850 * \param [in] a - the value to assign.
7851 * \param [in] bgTuples - pointer to an array of tuple indices of \a this array to
7853 * \param [in] endTuples - specifies the end of the array \a bgTuples, so that
7854 * pointer to a tuple index (\a pi) varies as this:
7855 * \a bgTuples <= \a pi < \a endTuples.
7856 * \param [in] bgComp - pointer to an array of component indices of \a this array to
7858 * \param [in] endComp - specifies the end of the array \a bgTuples, so that
7859 * pointer to a component index (\a pi) varies as this:
7860 * \a bgComp <= \a pi < \a endComp.
7861 * \throw If \a this is not allocated.
7862 * \throw If any index of tuple/component given by <em>bgTuples / bgComp</em> is
7863 * out of a valid range for \a this array.
7865 * \ref py_mcdataarrayint_setpartofvaluessimple2 "Here is a Python example".
7867 void DataArrayInt::setPartOfValuesSimple2(int a, const int *bgTuples, const int *endTuples, const int *bgComp, const int *endComp)
7870 int nbComp=getNumberOfComponents();
7871 int nbOfTuples=getNumberOfTuples();
7872 for(const int *z=bgComp;z!=endComp;z++)
7873 DataArray::CheckValueInRange(nbComp,*z,"invalid component id");
7874 int *pt=getPointer();
7875 for(const int *w=bgTuples;w!=endTuples;w++)
7876 for(const int *z=bgComp;z!=endComp;z++)
7878 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
7879 pt[(std::size_t)(*w)*nbComp+(*z)]=a;
7884 * Copy all values from another DataArrayInt (\a a) into specified tuples and
7885 * components of \a this array. Textual data is not copied.
7886 * The tuples to assign to are defined by a C array of indices.
7887 * The components to assign to are defined by three values similar to parameters of
7888 * the Python function \c range(\c start,\c stop,\c step).
7889 * There are two *modes of usage*:
7890 * - If \a a->getNbOfElems() equals to number of values to assign to, then every value
7891 * of \a a is assigned to its own location within \a this array.
7892 * - If \a a includes one tuple, then all values of \a a are assigned to the specified
7893 * components of every specified tuple of \a this array. In this mode it is required
7894 * that \a a->getNumberOfComponents() equals to the number of specified components.
7896 * \param [in] a - the array to copy values from.
7897 * \param [in] bgTuples - pointer to an array of tuple indices of \a this array to
7898 * assign values of \a a to.
7899 * \param [in] endTuples - specifies the end of the array \a bgTuples, so that
7900 * pointer to a tuple index <em>(pi)</em> varies as this:
7901 * \a bgTuples <= \a pi < \a endTuples.
7902 * \param [in] bgComp - index of the first component of \a this array to assign to.
7903 * \param [in] endComp - index of the component before which the components to assign
7905 * \param [in] stepComp - index increment to get index of the next component to assign to.
7906 * \param [in] strictCompoCompare - this parameter is checked only in the first
7907 * *mode of usage*; if \a strictCompoCompare is \a true (default),
7908 * then \a a->getNumberOfComponents() must be equal
7909 * to the number of specified columns, else this is not required.
7910 * \throw If \a a is NULL.
7911 * \throw If \a a is not allocated.
7912 * \throw If \a this is not allocated.
7913 * \throw If any index of tuple given by \a bgTuples is out of a valid range for
7915 * \throw In the first *mode of usage*, if <em>strictCompoCompare == true </em> and
7916 * if <em> a->getNumberOfComponents()</em> is unequal to the number of components
7917 * defined by <em>(bgComp,endComp,stepComp)</em>.
7918 * \throw In the second *mode of usage*, if \a a->getNumberOfTuples() != 1 or
7919 * <em> a->getNumberOfComponents()</em> is unequal to the number of components
7920 * defined by <em>(bgComp,endComp,stepComp)</em>.
7921 * \throw If parameters specifying components to assign to, do not give a
7922 * non-empty range of increasing indices or indices are out of a valid range
7925 * \ref py_mcdataarrayint_setpartofvalues3 "Here is a Python example".
7927 void DataArrayInt::setPartOfValues3(const DataArrayInt *a, const int *bgTuples, const int *endTuples, int bgComp, int endComp, int stepComp, bool strictCompoCompare)
7930 throw INTERP_KERNEL::Exception("DataArrayInt::setPartOfValues3 : DataArrayInt pointer in input is NULL !");
7931 const char msg[]="DataArrayInt::setPartOfValues3";
7933 a->checkAllocated();
7934 int newNbOfComp=DataArray::GetNumberOfItemGivenBES(bgComp,endComp,stepComp,msg);
7935 int nbComp=getNumberOfComponents();
7936 int nbOfTuples=getNumberOfTuples();
7937 DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
7938 int newNbOfTuples=(int)std::distance(bgTuples,endTuples);
7939 bool assignTech=true;
7940 if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
7942 if(strictCompoCompare)
7943 a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
7947 a->checkNbOfTuplesAndComp(1,newNbOfComp,msg);
7950 int *pt=getPointer()+bgComp;
7951 const int *srcPt=a->getConstPointer();
7954 for(const int *w=bgTuples;w!=endTuples;w++)
7955 for(int j=0;j<newNbOfComp;j++,srcPt++)
7957 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
7958 pt[(std::size_t)(*w)*nbComp+j*stepComp]=*srcPt;
7963 for(const int *w=bgTuples;w!=endTuples;w++)
7965 const int *srcPt2=srcPt;
7966 for(int j=0;j<newNbOfComp;j++,srcPt2++)
7968 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
7969 pt[(std::size_t)(*w)*nbComp+j*stepComp]=*srcPt2;
7976 * Assign a given value to values at specified tuples and components of \a this array.
7977 * The tuples to assign to are defined by a C array of indices.
7978 * The components to assign to are defined by three values similar to parameters of
7979 * the Python function \c range(\c start,\c stop,\c step).
7980 * \param [in] a - the value to assign.
7981 * \param [in] bgTuples - pointer to an array of tuple indices of \a this array to
7983 * \param [in] endTuples - specifies the end of the array \a bgTuples, so that
7984 * pointer to a tuple index <em>(pi)</em> varies as this:
7985 * \a bgTuples <= \a pi < \a endTuples.
7986 * \param [in] bgComp - index of the first component of \a this array to assign to.
7987 * \param [in] endComp - index of the component before which the components to assign
7989 * \param [in] stepComp - index increment to get index of the next component to assign to.
7990 * \throw If \a this is not allocated.
7991 * \throw If any index of tuple given by \a bgTuples is out of a valid range for
7993 * \throw If parameters specifying components to assign to, do not give a
7994 * non-empty range of increasing indices or indices are out of a valid range
7997 * \ref py_mcdataarrayint_setpartofvaluessimple3 "Here is a Python example".
7999 void DataArrayInt::setPartOfValuesSimple3(int a, const int *bgTuples, const int *endTuples, int bgComp, int endComp, int stepComp)
8001 const char msg[]="DataArrayInt::setPartOfValuesSimple3";
8003 int newNbOfComp=DataArray::GetNumberOfItemGivenBES(bgComp,endComp,stepComp,msg);
8004 int nbComp=getNumberOfComponents();
8005 int nbOfTuples=getNumberOfTuples();
8006 DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
8007 int *pt=getPointer()+bgComp;
8008 for(const int *w=bgTuples;w!=endTuples;w++)
8009 for(int j=0;j<newNbOfComp;j++)
8011 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
8012 pt[(std::size_t)(*w)*nbComp+j*stepComp]=a;
8016 void DataArrayInt::setPartOfValues4(const DataArrayInt *a, int bgTuples, int endTuples, int stepTuples, const int *bgComp, const int *endComp, bool strictCompoCompare)
8019 throw INTERP_KERNEL::Exception("DataArrayInt::setPartOfValues4 : input DataArrayInt is NULL !");
8020 const char msg[]="DataArrayInt::setPartOfValues4";
8022 a->checkAllocated();
8023 int newNbOfTuples=DataArray::GetNumberOfItemGivenBES(bgTuples,endTuples,stepTuples,msg);
8024 int newNbOfComp=(int)std::distance(bgComp,endComp);
8025 int nbComp=getNumberOfComponents();
8026 for(const int *z=bgComp;z!=endComp;z++)
8027 DataArray::CheckValueInRange(nbComp,*z,"invalid component id");
8028 int nbOfTuples=getNumberOfTuples();
8029 DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
8030 bool assignTech=true;
8031 if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
8033 if(strictCompoCompare)
8034 a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
8038 a->checkNbOfTuplesAndComp(1,newNbOfComp,msg);
8041 const int *srcPt=a->getConstPointer();
8042 int *pt=getPointer()+bgTuples*nbComp;
8045 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
8046 for(const int *z=bgComp;z!=endComp;z++,srcPt++)
8051 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
8053 const int *srcPt2=srcPt;
8054 for(const int *z=bgComp;z!=endComp;z++,srcPt2++)
8060 void DataArrayInt::setPartOfValuesSimple4(int a, int bgTuples, int endTuples, int stepTuples, const int *bgComp, const int *endComp)
8062 const char msg[]="DataArrayInt::setPartOfValuesSimple4";
8064 int newNbOfTuples=DataArray::GetNumberOfItemGivenBES(bgTuples,endTuples,stepTuples,msg);
8065 int nbComp=getNumberOfComponents();
8066 for(const int *z=bgComp;z!=endComp;z++)
8067 DataArray::CheckValueInRange(nbComp,*z,"invalid component id");
8068 int nbOfTuples=getNumberOfTuples();
8069 DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
8070 int *pt=getPointer()+bgTuples*nbComp;
8071 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
8072 for(const int *z=bgComp;z!=endComp;z++)
8077 * Copy some tuples from another DataArrayInt into specified tuples
8078 * of \a this array. Textual data is not copied. Both arrays must have equal number of
8080 * Both the tuples to assign and the tuples to assign to are defined by a DataArrayInt.
8081 * All components of selected tuples are copied.
8082 * \param [in] a - the array to copy values from.
8083 * \param [in] tuplesSelec - the array specifying both source tuples of \a a and
8084 * target tuples of \a this. \a tuplesSelec has two components, and the
8085 * first component specifies index of the source tuple and the second
8086 * one specifies index of the target tuple.
8087 * \throw If \a this is not allocated.
8088 * \throw If \a a is NULL.
8089 * \throw If \a a is not allocated.
8090 * \throw If \a tuplesSelec is NULL.
8091 * \throw If \a tuplesSelec is not allocated.
8092 * \throw If <em>this->getNumberOfComponents() != a->getNumberOfComponents()</em>.
8093 * \throw If \a tuplesSelec->getNumberOfComponents() != 2.
8094 * \throw If any tuple index given by \a tuplesSelec is out of a valid range for
8095 * the corresponding (\a this or \a a) array.
8097 void DataArrayInt::setPartOfValuesAdv(const DataArrayInt *a, const DataArrayInt *tuplesSelec)
8099 if(!a || !tuplesSelec)
8100 throw INTERP_KERNEL::Exception("DataArrayInt::setPartOfValuesAdv : DataArrayInt pointer in input is NULL !");
8102 a->checkAllocated();
8103 tuplesSelec->checkAllocated();
8104 int nbOfComp=getNumberOfComponents();
8105 if(nbOfComp!=a->getNumberOfComponents())
8106 throw INTERP_KERNEL::Exception("DataArrayInt::setPartOfValuesAdv : This and a do not have the same number of components !");
8107 if(tuplesSelec->getNumberOfComponents()!=2)
8108 throw INTERP_KERNEL::Exception("DataArrayInt::setPartOfValuesAdv : Expecting to have a tuple selector DataArrayInt instance with exactly 2 components !");
8109 int thisNt=getNumberOfTuples();
8110 int aNt=a->getNumberOfTuples();
8111 int *valsToSet=getPointer();
8112 const int *valsSrc=a->getConstPointer();
8113 for(const int *tuple=tuplesSelec->begin();tuple!=tuplesSelec->end();tuple+=2)
8115 if(tuple[1]>=0 && tuple[1]<aNt)
8117 if(tuple[0]>=0 && tuple[0]<thisNt)
8118 std::copy(valsSrc+nbOfComp*tuple[1],valsSrc+nbOfComp*(tuple[1]+1),valsToSet+nbOfComp*tuple[0]);
8121 std::ostringstream oss; oss << "DataArrayInt::setPartOfValuesAdv : Tuple #" << std::distance(tuplesSelec->begin(),tuple)/2;
8122 oss << " of 'tuplesSelec' request of tuple id #" << tuple[0] << " in 'this' ! It should be in [0," << thisNt << ") !";
8123 throw INTERP_KERNEL::Exception(oss.str().c_str());
8128 std::ostringstream oss; oss << "DataArrayInt::setPartOfValuesAdv : Tuple #" << std::distance(tuplesSelec->begin(),tuple)/2;
8129 oss << " of 'tuplesSelec' request of tuple id #" << tuple[1] << " in 'a' ! It should be in [0," << aNt << ") !";
8130 throw INTERP_KERNEL::Exception(oss.str().c_str());
8136 * Copy some tuples from another DataArrayInt (\a aBase) into contiguous tuples
8137 * of \a this array. Textual data is not copied. Both arrays must have equal number of
8139 * The tuples to assign to are defined by index of the first tuple, and
8140 * their number is defined by \a tuplesSelec->getNumberOfTuples().
8141 * The tuples to copy are defined by values of a DataArrayInt.
8142 * All components of selected tuples are copied.
8143 * \param [in] tupleIdStart - index of the first tuple of \a this array to assign
8145 * \param [in] aBase - the array to copy values from.
8146 * \param [in] tuplesSelec - the array specifying tuples of \a aBase to copy.
8147 * \throw If \a this is not allocated.
8148 * \throw If \a aBase is NULL.
8149 * \throw If \a aBase is not allocated.
8150 * \throw If \a tuplesSelec is NULL.
8151 * \throw If \a tuplesSelec is not allocated.
8152 * \throw If <em>this->getNumberOfComponents() != a->getNumberOfComponents()</em>.
8153 * \throw If \a tuplesSelec->getNumberOfComponents() != 1.
8154 * \throw If <em>tupleIdStart + tuplesSelec->getNumberOfTuples() > this->getNumberOfTuples().</em>
8155 * \throw If any tuple index given by \a tuplesSelec is out of a valid range for
8158 void DataArrayInt::setContigPartOfSelectedValues(int tupleIdStart, const DataArray *aBase, const DataArrayInt *tuplesSelec)
8160 if(!aBase || !tuplesSelec)
8161 throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues : input DataArray is NULL !");
8162 const DataArrayInt *a=dynamic_cast<const DataArrayInt *>(aBase);
8164 throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues : input DataArray aBase is not a DataArrayInt !");
8166 a->checkAllocated();
8167 tuplesSelec->checkAllocated();
8168 int nbOfComp=getNumberOfComponents();
8169 if(nbOfComp!=a->getNumberOfComponents())
8170 throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues : This and a do not have the same number of components !");
8171 if(tuplesSelec->getNumberOfComponents()!=1)
8172 throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues : Expecting to have a tuple selector DataArrayInt instance with exactly 1 component !");
8173 int thisNt=getNumberOfTuples();
8174 int aNt=a->getNumberOfTuples();
8175 int nbOfTupleToWrite=tuplesSelec->getNumberOfTuples();
8176 int *valsToSet=getPointer()+tupleIdStart*nbOfComp;
8177 if(tupleIdStart+nbOfTupleToWrite>thisNt)
8178 throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues : invalid number range of values to write !");
8179 const int *valsSrc=a->getConstPointer();
8180 for(const int *tuple=tuplesSelec->begin();tuple!=tuplesSelec->end();tuple++,valsToSet+=nbOfComp)
8182 if(*tuple>=0 && *tuple<aNt)
8184 std::copy(valsSrc+nbOfComp*(*tuple),valsSrc+nbOfComp*(*tuple+1),valsToSet);
8188 std::ostringstream oss; oss << "DataArrayInt::setContigPartOfSelectedValues : Tuple #" << std::distance(tuplesSelec->begin(),tuple);
8189 oss << " of 'tuplesSelec' request of tuple id #" << *tuple << " in 'a' ! It should be in [0," << aNt << ") !";
8190 throw INTERP_KERNEL::Exception(oss.str().c_str());
8196 * Copy some tuples from another DataArrayInt (\a aBase) into contiguous tuples
8197 * of \a this array. Textual data is not copied. Both arrays must have equal number of
8199 * The tuples to copy are defined by three values similar to parameters of
8200 * the Python function \c range(\c start,\c stop,\c step).
8201 * The tuples to assign to are defined by index of the first tuple, and
8202 * their number is defined by number of tuples to copy.
8203 * All components of selected tuples are copied.
8204 * \param [in] tupleIdStart - index of the first tuple of \a this array to assign
8206 * \param [in] aBase - the array to copy values from.
8207 * \param [in] bg - index of the first tuple to copy of the array \a aBase.
8208 * \param [in] end2 - index of the tuple of \a aBase before which the tuples to copy
8210 * \param [in] step - index increment to get index of the next tuple to copy.
8211 * \throw If \a this is not allocated.
8212 * \throw If \a aBase is NULL.
8213 * \throw If \a aBase is not allocated.
8214 * \throw If <em>this->getNumberOfComponents() != aBase->getNumberOfComponents()</em>.
8215 * \throw If <em>tupleIdStart + len(range(bg,end2,step)) > this->getNumberOfTuples().</em>
8216 * \throw If parameters specifying tuples to copy, do not give a
8217 * non-empty range of increasing indices or indices are out of a valid range
8218 * for the array \a aBase.
8220 void DataArrayInt::setContigPartOfSelectedValues2(int tupleIdStart, const DataArray *aBase, int bg, int end2, int step)
8223 throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues2 : input DataArray is NULL !");
8224 const DataArrayInt *a=dynamic_cast<const DataArrayInt *>(aBase);
8226 throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues2 : input DataArray aBase is not a DataArrayInt !");
8228 a->checkAllocated();
8229 int nbOfComp=getNumberOfComponents();
8230 const char msg[]="DataArrayInt::setContigPartOfSelectedValues2";
8231 int nbOfTupleToWrite=DataArray::GetNumberOfItemGivenBES(bg,end2,step,msg);
8232 if(nbOfComp!=a->getNumberOfComponents())
8233 throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues2 : This and a do not have the same number of components !");
8234 int thisNt=getNumberOfTuples();
8235 int aNt=a->getNumberOfTuples();
8236 int *valsToSet=getPointer()+tupleIdStart*nbOfComp;
8237 if(tupleIdStart+nbOfTupleToWrite>thisNt)
8238 throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues2 : invalid number range of values to write !");
8240 throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues2 : invalid range of values to read !");
8241 const int *valsSrc=a->getConstPointer()+bg*nbOfComp;
8242 for(int i=0;i<nbOfTupleToWrite;i++,valsToSet+=nbOfComp,valsSrc+=step*nbOfComp)
8244 std::copy(valsSrc,valsSrc+nbOfComp,valsToSet);
8249 * Returns a value located at specified tuple and component.
8250 * This method is equivalent to DataArrayInt::getIJ() except that validity of
8251 * parameters is checked. So this method is safe but expensive if used to go through
8252 * all values of \a this.
8253 * \param [in] tupleId - index of tuple of interest.
8254 * \param [in] compoId - index of component of interest.
8255 * \return double - value located by \a tupleId and \a compoId.
8256 * \throw If \a this is not allocated.
8257 * \throw If condition <em>( 0 <= tupleId < this->getNumberOfTuples() )</em> is violated.
8258 * \throw If condition <em>( 0 <= compoId < this->getNumberOfComponents() )</em> is violated.
8260 int DataArrayInt::getIJSafe(int tupleId, int compoId) const
8263 if(tupleId<0 || tupleId>=getNumberOfTuples())
8265 std::ostringstream oss; oss << "DataArrayInt::getIJSafe : request for tupleId " << tupleId << " should be in [0," << getNumberOfTuples() << ") !";
8266 throw INTERP_KERNEL::Exception(oss.str().c_str());
8268 if(compoId<0 || compoId>=getNumberOfComponents())
8270 std::ostringstream oss; oss << "DataArrayInt::getIJSafe : request for compoId " << compoId << " should be in [0," << getNumberOfComponents() << ") !";
8271 throw INTERP_KERNEL::Exception(oss.str().c_str());
8273 return _mem[tupleId*_info_on_compo.size()+compoId];
8277 * Returns the first value of \a this.
8278 * \return int - the last value of \a this array.
8279 * \throw If \a this is not allocated.
8280 * \throw If \a this->getNumberOfComponents() != 1.
8281 * \throw If \a this->getNumberOfTuples() < 1.
8283 int DataArrayInt::front() const
8286 if(getNumberOfComponents()!=1)
8287 throw INTERP_KERNEL::Exception("DataArrayInt::front : number of components not equal to one !");
8288 int nbOfTuples=getNumberOfTuples();
8290 throw INTERP_KERNEL::Exception("DataArrayInt::front : number of tuples must be >= 1 !");
8291 return *(getConstPointer());
8295 * Returns the last value of \a this.
8296 * \return int - the last value of \a this array.
8297 * \throw If \a this is not allocated.
8298 * \throw If \a this->getNumberOfComponents() != 1.
8299 * \throw If \a this->getNumberOfTuples() < 1.
8301 int DataArrayInt::back() const
8304 if(getNumberOfComponents()!=1)
8305 throw INTERP_KERNEL::Exception("DataArrayInt::back : number of components not equal to one !");
8306 int nbOfTuples=getNumberOfTuples();
8308 throw INTERP_KERNEL::Exception("DataArrayInt::back : number of tuples must be >= 1 !");
8309 return *(getConstPointer()+nbOfTuples-1);
8313 * Assign pointer to one array to a pointer to another appay. Reference counter of
8314 * \a arrayToSet is incremented / decremented.
8315 * \param [in] newArray - the pointer to array to assign to \a arrayToSet.
8316 * \param [in,out] arrayToSet - the pointer to array to assign to.
8318 void DataArrayInt::SetArrayIn(DataArrayInt *newArray, DataArrayInt* &arrayToSet)
8320 if(newArray!=arrayToSet)
8323 arrayToSet->decrRef();
8324 arrayToSet=newArray;
8326 arrayToSet->incrRef();
8330 DataArrayIntIterator *DataArrayInt::iterator()
8332 return new DataArrayIntIterator(this);
8336 * Creates a new DataArrayInt containing IDs (indices) of tuples holding value equal to a
8338 * \param [in] val - the value to find within \a this.
8339 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
8340 * array using decrRef() as it is no more needed.
8341 * \throw If \a this is not allocated.
8342 * \throw If \a this->getNumberOfComponents() != 1.
8344 DataArrayInt *DataArrayInt::getIdsEqual(int val) const
8347 if(getNumberOfComponents()!=1)
8348 throw INTERP_KERNEL::Exception("DataArrayInt::getIdsEqual : the array must have only one component, you can call 'rearrange' method before !");
8349 const int *cptr=getConstPointer();
8350 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
8351 int nbOfTuples=getNumberOfTuples();
8352 for(int i=0;i<nbOfTuples;i++,cptr++)
8354 ret->pushBackSilent(i);
8359 * Creates a new DataArrayInt containing IDs (indices) of tuples holding value \b not
8360 * equal to a given one.
8361 * \param [in] val - the value to ignore within \a this.
8362 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
8363 * array using decrRef() as it is no more needed.
8364 * \throw If \a this is not allocated.
8365 * \throw If \a this->getNumberOfComponents() != 1.
8367 DataArrayInt *DataArrayInt::getIdsNotEqual(int val) const
8370 if(getNumberOfComponents()!=1)
8371 throw INTERP_KERNEL::Exception("DataArrayInt::getIdsNotEqual : the array must have only one component, you can call 'rearrange' method before !");
8372 const int *cptr=getConstPointer();
8373 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
8374 int nbOfTuples=getNumberOfTuples();
8375 for(int i=0;i<nbOfTuples;i++,cptr++)
8377 ret->pushBackSilent(i);
8383 * Assigns \a newValue to all elements holding \a oldValue within \a this
8384 * one-dimensional array.
8385 * \param [in] oldValue - the value to replace.
8386 * \param [in] newValue - the value to assign.
8387 * \return int - number of replacements performed.
8388 * \throw If \a this is not allocated.
8389 * \throw If \a this->getNumberOfComponents() != 1.
8391 int DataArrayInt::changeValue(int oldValue, int newValue)
8394 if(getNumberOfComponents()!=1)
8395 throw INTERP_KERNEL::Exception("DataArrayInt::changeValue : the array must have only one component, you can call 'rearrange' method before !");
8396 int *start=getPointer();
8397 int *end2=start+getNbOfElems();
8399 for(int *val=start;val!=end2;val++)
8411 * Creates a new DataArrayInt containing IDs (indices) of tuples holding value equal to
8412 * one of given values.
8413 * \param [in] valsBg - an array of values to find within \a this array.
8414 * \param [in] valsEnd - specifies the end of the array \a valsBg, so that
8415 * the last value of \a valsBg is \a valsEnd[ -1 ].
8416 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
8417 * array using decrRef() as it is no more needed.
8418 * \throw If \a this->getNumberOfComponents() != 1.
8420 DataArrayInt *DataArrayInt::getIdsEqualList(const int *valsBg, const int *valsEnd) const
8422 if(getNumberOfComponents()!=1)
8423 throw INTERP_KERNEL::Exception("DataArrayInt::getIdsEqualList : the array must have only one component, you can call 'rearrange' method before !");
8424 std::set<int> vals2(valsBg,valsEnd);
8425 const int *cptr=getConstPointer();
8426 std::vector<int> res;
8427 int nbOfTuples=getNumberOfTuples();
8428 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
8429 for(int i=0;i<nbOfTuples;i++,cptr++)
8430 if(vals2.find(*cptr)!=vals2.end())
8431 ret->pushBackSilent(i);
8436 * Creates a new DataArrayInt containing IDs (indices) of tuples holding values \b not
8437 * equal to any of given values.
8438 * \param [in] valsBg - an array of values to ignore within \a this array.
8439 * \param [in] valsEnd - specifies the end of the array \a valsBg, so that
8440 * the last value of \a valsBg is \a valsEnd[ -1 ].
8441 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
8442 * array using decrRef() as it is no more needed.
8443 * \throw If \a this->getNumberOfComponents() != 1.
8445 DataArrayInt *DataArrayInt::getIdsNotEqualList(const int *valsBg, const int *valsEnd) const
8447 if(getNumberOfComponents()!=1)
8448 throw INTERP_KERNEL::Exception("DataArrayInt::getIdsNotEqualList : the array must have only one component, you can call 'rearrange' method before !");
8449 std::set<int> vals2(valsBg,valsEnd);
8450 const int *cptr=getConstPointer();
8451 std::vector<int> res;
8452 int nbOfTuples=getNumberOfTuples();
8453 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
8454 for(int i=0;i<nbOfTuples;i++,cptr++)
8455 if(vals2.find(*cptr)==vals2.end())
8456 ret->pushBackSilent(i);
8461 * This method is an extension of DataArrayInt::locateValue method because this method works for DataArrayInt with
8462 * any number of components excepted 0 (an INTERP_KERNEL::Exception is thrown in this case).
8463 * This method searches in \b this is there is a tuple that matched the input parameter \b tupl.
8464 * If any the tuple id is returned. If not -1 is returned.
8466 * This method throws an INTERP_KERNEL::Exception if the number of components in \b this mismatches with the size of
8467 * the input vector. An INTERP_KERNEL::Exception is thrown too if \b this is not allocated.
8469 * \return tuple id where \b tupl is. -1 if no such tuple exists in \b this.
8470 * \sa DataArrayInt::search, DataArrayInt::presenceOfTuple.
8472 int DataArrayInt::locateTuple(const std::vector<int>& tupl) const
8475 int nbOfCompo=getNumberOfComponents();
8477 throw INTERP_KERNEL::Exception("DataArrayInt::locateTuple : 0 components in 'this' !");
8478 if(nbOfCompo!=(int)tupl.size())
8480 std::ostringstream oss; oss << "DataArrayInt::locateTuple : 'this' contains " << nbOfCompo << " components and searching for a tuple of length " << tupl.size() << " !";
8481 throw INTERP_KERNEL::Exception(oss.str().c_str());
8483 const int *cptr=getConstPointer();
8484 std::size_t nbOfVals=getNbOfElems();
8485 for(const int *work=cptr;work!=cptr+nbOfVals;)
8487 work=std::search(work,cptr+nbOfVals,tupl.begin(),tupl.end());
8488 if(work!=cptr+nbOfVals)
8490 if(std::distance(cptr,work)%nbOfCompo!=0)
8493 return std::distance(cptr,work)/nbOfCompo;
8500 * This method searches the sequence specified in input parameter \b vals in \b this.
8501 * This works only for DataArrayInt having number of components equal to one (if not an INTERP_KERNEL::Exception will be thrown).
8502 * This method differs from DataArrayInt::locateTuple in that the position is internal raw data is not considered here contrary to DataArrayInt::locateTuple.
8503 * \sa DataArrayInt::locateTuple
8505 int DataArrayInt::search(const std::vector<int>& vals) const
8508 int nbOfCompo=getNumberOfComponents();
8510 throw INTERP_KERNEL::Exception("DataArrayInt::search : works only for DataArrayInt instance with one component !");
8511 const int *cptr=getConstPointer();
8512 std::size_t nbOfVals=getNbOfElems();
8513 const int *loc=std::search(cptr,cptr+nbOfVals,vals.begin(),vals.end());
8514 if(loc!=cptr+nbOfVals)
8515 return std::distance(cptr,loc);
8520 * This method expects to be called when number of components of this is equal to one.
8521 * This method returns the tuple id, if it exists, of the first tuple equal to \b value.
8522 * If not any tuple contains \b value -1 is returned.
8523 * \sa DataArrayInt::presenceOfValue
8525 int DataArrayInt::locateValue(int value) const
8528 if(getNumberOfComponents()!=1)
8529 throw INTERP_KERNEL::Exception("DataArrayInt::presenceOfValue : the array must have only one component, you can call 'rearrange' method before !");
8530 const int *cptr=getConstPointer();
8531 int nbOfTuples=getNumberOfTuples();
8532 const int *ret=std::find(cptr,cptr+nbOfTuples,value);
8533 if(ret!=cptr+nbOfTuples)
8534 return std::distance(cptr,ret);
8539 * This method expects to be called when number of components of this is equal to one.
8540 * This method returns the tuple id, if it exists, of the first tuple so that the value is contained in \b vals.
8541 * If not any tuple contains one of the values contained in 'vals' false is returned.
8542 * \sa DataArrayInt::presenceOfValue
8544 int DataArrayInt::locateValue(const std::vector<int>& vals) const
8547 if(getNumberOfComponents()!=1)
8548 throw INTERP_KERNEL::Exception("DataArrayInt::presenceOfValue : the array must have only one component, you can call 'rearrange' method before !");
8549 std::set<int> vals2(vals.begin(),vals.end());
8550 const int *cptr=getConstPointer();
8551 int nbOfTuples=getNumberOfTuples();
8552 for(const int *w=cptr;w!=cptr+nbOfTuples;w++)
8553 if(vals2.find(*w)!=vals2.end())
8554 return std::distance(cptr,w);
8559 * This method returns the number of values in \a this that are equals to input parameter \a value.
8560 * This method only works for single component array.
8562 * \return a value in [ 0, \c this->getNumberOfTuples() )
8564 * \throw If \a this is not allocated
8567 int DataArrayInt::count(int value) const
8571 if(getNumberOfComponents()!=1)
8572 throw INTERP_KERNEL::Exception("DataArrayInt::count : must be applied on DataArrayInt with only one component, you can call 'rearrange' method before !");
8573 const int *vals=begin();
8574 int nbOfTuples=getNumberOfTuples();
8575 for(int i=0;i<nbOfTuples;i++,vals++)
8582 * This method is an extension of DataArrayInt::presenceOfValue method because this method works for DataArrayInt with
8583 * any number of components excepted 0 (an INTERP_KERNEL::Exception is thrown in this case).
8584 * This method searches in \b this is there is a tuple that matched the input parameter \b tupl.
8585 * This method throws an INTERP_KERNEL::Exception if the number of components in \b this mismatches with the size of
8586 * the input vector. An INTERP_KERNEL::Exception is thrown too if \b this is not allocated.
8587 * \sa DataArrayInt::locateTuple
8589 bool DataArrayInt::presenceOfTuple(const std::vector<int>& tupl) const
8591 return locateTuple(tupl)!=-1;
8596 * Returns \a true if a given value is present within \a this one-dimensional array.
8597 * \param [in] value - the value to find within \a this array.
8598 * \return bool - \a true in case if \a value is present within \a this array.
8599 * \throw If \a this is not allocated.
8600 * \throw If \a this->getNumberOfComponents() != 1.
8603 bool DataArrayInt::presenceOfValue(int value) const
8605 return locateValue(value)!=-1;
8609 * This method expects to be called when number of components of this is equal to one.
8610 * This method returns true if it exists a tuple so that the value is contained in \b vals.
8611 * If not any tuple contains one of the values contained in 'vals' false is returned.
8612 * \sa DataArrayInt::locateValue
8614 bool DataArrayInt::presenceOfValue(const std::vector<int>& vals) const
8616 return locateValue(vals)!=-1;
8620 * Accumulates values of each component of \a this array.
8621 * \param [out] res - an array of length \a this->getNumberOfComponents(), allocated
8622 * by the caller, that is filled by this method with sum value for each
8624 * \throw If \a this is not allocated.
8626 void DataArrayInt::accumulate(int *res) const
8629 const int *ptr=getConstPointer();
8630 int nbTuple=getNumberOfTuples();
8631 int nbComps=getNumberOfComponents();
8632 std::fill(res,res+nbComps,0);
8633 for(int i=0;i<nbTuple;i++)
8634 std::transform(ptr+i*nbComps,ptr+(i+1)*nbComps,res,res,std::plus<int>());
8637 int DataArrayInt::accumulate(int compId) const
8640 const int *ptr=getConstPointer();
8641 int nbTuple=getNumberOfTuples();
8642 int nbComps=getNumberOfComponents();
8643 if(compId<0 || compId>=nbComps)
8644 throw INTERP_KERNEL::Exception("DataArrayInt::accumulate : Invalid compId specified : No such nb of components !");
8646 for(int i=0;i<nbTuple;i++)
8647 ret+=ptr[i*nbComps+compId];
8652 * This method accumulate using addition tuples in \a this using input index array [ \a bgOfIndex, \a endOfIndex ).
8653 * The returned array will have same number of components than \a this and number of tuples equal to
8654 * \c std::distance(bgOfIndex,endOfIndex) \b minus \b one.
8656 * The input index array is expected to be ascendingly sorted in which the all referenced ids should be in [0, \c this->getNumberOfTuples).
8658 * \param [in] bgOfIndex - begin (included) of the input index array.
8659 * \param [in] endOfIndex - end (excluded) of the input index array.
8660 * \return DataArrayInt * - the new instance having the same number of components than \a this.
8662 * \throw If bgOfIndex or end is NULL.
8663 * \throw If input index array is not ascendingly sorted.
8664 * \throw If there is an id in [ \a bgOfIndex, \a endOfIndex ) not in [0, \c this->getNumberOfTuples).
8665 * \throw If std::distance(bgOfIndex,endOfIndex)==0.
8667 DataArrayInt *DataArrayInt::accumulatePerChunck(const int *bgOfIndex, const int *endOfIndex) const
8669 if(!bgOfIndex || !endOfIndex)
8670 throw INTERP_KERNEL::Exception("DataArrayInt::accumulatePerChunck : input pointer NULL !");
8672 int nbCompo=getNumberOfComponents();
8673 int nbOfTuples=getNumberOfTuples();
8674 int sz=(int)std::distance(bgOfIndex,endOfIndex);
8676 throw INTERP_KERNEL::Exception("DataArrayInt::accumulatePerChunck : invalid size of input index array !");
8678 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(sz,nbCompo);
8679 const int *w=bgOfIndex;
8680 if(*w<0 || *w>=nbOfTuples)
8681 throw INTERP_KERNEL::Exception("DataArrayInt::accumulatePerChunck : The first element of the input index not in [0,nbOfTuples) !");
8682 const int *srcPt=begin()+(*w)*nbCompo;
8683 int *tmp=ret->getPointer();
8684 for(int i=0;i<sz;i++,tmp+=nbCompo,w++)
8686 std::fill(tmp,tmp+nbCompo,0);
8689 for(int j=w[0];j<w[1];j++,srcPt+=nbCompo)
8691 if(j>=0 && j<nbOfTuples)
8692 std::transform(srcPt,srcPt+nbCompo,tmp,tmp,std::plus<int>());
8695 std::ostringstream oss; oss << "DataArrayInt::accumulatePerChunck : At rank #" << i << " the input index array points to id " << j << " should be in [0," << nbOfTuples << ") !";
8696 throw INTERP_KERNEL::Exception(oss.str().c_str());
8702 std::ostringstream oss; oss << "DataArrayInt::accumulatePerChunck : At rank #" << i << " the input index array is not in ascendingly sorted.";
8703 throw INTERP_KERNEL::Exception(oss.str().c_str());
8706 ret->copyStringInfoFrom(*this);
8711 * Returns a new DataArrayInt by concatenating two given arrays, so that (1) the number
8712 * of tuples in the result array is <em> a1->getNumberOfTuples() + a2->getNumberOfTuples() -
8713 * offsetA2</em> and (2)
8714 * the number of component in the result array is same as that of each of given arrays.
8715 * First \a offsetA2 tuples of \a a2 are skipped and thus are missing from the result array.
8716 * Info on components is copied from the first of the given arrays. Number of components
8717 * in the given arrays must be the same.
8718 * \param [in] a1 - an array to include in the result array.
8719 * \param [in] a2 - another array to include in the result array.
8720 * \param [in] offsetA2 - number of tuples of \a a2 to skip.
8721 * \return DataArrayInt * - the new instance of DataArrayInt.
8722 * The caller is to delete this result array using decrRef() as it is no more
8724 * \throw If either \a a1 or \a a2 is NULL.
8725 * \throw If \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents().
8727 DataArrayInt *DataArrayInt::Aggregate(const DataArrayInt *a1, const DataArrayInt *a2, int offsetA2)
8730 throw INTERP_KERNEL::Exception("DataArrayInt::Aggregate : input DataArrayInt instance is NULL !");
8731 int nbOfComp=a1->getNumberOfComponents();
8732 if(nbOfComp!=a2->getNumberOfComponents())
8733 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Aggregation !");
8734 int nbOfTuple1=a1->getNumberOfTuples();
8735 int nbOfTuple2=a2->getNumberOfTuples();
8736 DataArrayInt *ret=DataArrayInt::New();
8737 ret->alloc(nbOfTuple1+nbOfTuple2-offsetA2,nbOfComp);
8738 int *pt=std::copy(a1->getConstPointer(),a1->getConstPointer()+nbOfTuple1*nbOfComp,ret->getPointer());
8739 std::copy(a2->getConstPointer()+offsetA2*nbOfComp,a2->getConstPointer()+nbOfTuple2*nbOfComp,pt);
8740 ret->copyStringInfoFrom(*a1);
8745 * Returns a new DataArrayInt by concatenating all given arrays, so that (1) the number
8746 * of tuples in the result array is a sum of the number of tuples of given arrays and (2)
8747 * the number of component in the result array is same as that of each of given arrays.
8748 * Info on components is copied from the first of the given arrays. Number of components
8749 * in the given arrays must be the same.
8750 * \param [in] arr - a sequence of arrays to include in the result array.
8751 * \return DataArrayInt * - the new instance of DataArrayInt.
8752 * The caller is to delete this result array using decrRef() as it is no more
8754 * \throw If all arrays within \a arr are NULL.
8755 * \throw If getNumberOfComponents() of arrays within \a arr.
8757 DataArrayInt *DataArrayInt::Aggregate(const std::vector<const DataArrayInt *>& arr)
8759 std::vector<const DataArrayInt *> a;
8760 for(std::vector<const DataArrayInt *>::const_iterator it4=arr.begin();it4!=arr.end();it4++)
8764 throw INTERP_KERNEL::Exception("DataArrayInt::Aggregate : input list must be NON EMPTY !");
8765 std::vector<const DataArrayInt *>::const_iterator it=a.begin();
8766 int nbOfComp=(*it)->getNumberOfComponents();
8767 int nbt=(*it++)->getNumberOfTuples();
8768 for(int i=1;it!=a.end();it++,i++)
8770 if((*it)->getNumberOfComponents()!=nbOfComp)
8771 throw INTERP_KERNEL::Exception("DataArrayInt::Aggregate : Nb of components mismatch for array aggregation !");
8772 nbt+=(*it)->getNumberOfTuples();
8774 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
8775 ret->alloc(nbt,nbOfComp);
8776 int *pt=ret->getPointer();
8777 for(it=a.begin();it!=a.end();it++)
8778 pt=std::copy((*it)->getConstPointer(),(*it)->getConstPointer()+(*it)->getNbOfElems(),pt);
8779 ret->copyStringInfoFrom(*(a[0]));
8784 * This method takes as input a list of DataArrayInt instances \a arrs that represent each a packed index arrays.
8785 * A packed index array is an allocated array with one component, and at least one tuple. The first element
8786 * of each array in \a arrs must be 0. Each array in \a arrs is expected to be increasingly monotonic.
8787 * This method is useful for users that want to aggregate a pair of DataArrayInt representing an indexed data (typically nodal connectivity index in unstructured meshes.
8789 * \return DataArrayInt * - a new object to be managed by the caller.
8791 DataArrayInt *DataArrayInt::AggregateIndexes(const std::vector<const DataArrayInt *>& arrs)
8794 for(std::vector<const DataArrayInt *>::const_iterator it4=arrs.begin();it4!=arrs.end();it4++)
8798 (*it4)->checkAllocated();
8799 if((*it4)->getNumberOfComponents()!=1)
8801 std::ostringstream oss; oss << "DataArrayInt::AggregateIndexes : presence of a DataArrayInt instance with nb of compo != 1 at pos " << std::distance(arrs.begin(),it4) << " !";
8802 throw INTERP_KERNEL::Exception(oss.str().c_str());
8804 int nbTupl=(*it4)->getNumberOfTuples();
8807 std::ostringstream oss; oss << "DataArrayInt::AggregateIndexes : presence of a DataArrayInt instance with nb of tuples < 1 at pos " << std::distance(arrs.begin(),it4) << " !";
8808 throw INTERP_KERNEL::Exception(oss.str().c_str());
8810 if((*it4)->front()!=0)
8812 std::ostringstream oss; oss << "DataArrayInt::AggregateIndexes : presence of a DataArrayInt instance with front value != 0 at pos " << std::distance(arrs.begin(),it4) << " !";
8813 throw INTERP_KERNEL::Exception(oss.str().c_str());
8819 std::ostringstream oss; oss << "DataArrayInt::AggregateIndexes : presence of a null instance at pos " << std::distance(arrs.begin(),it4) << " !";
8820 throw INTERP_KERNEL::Exception(oss.str().c_str());
8824 throw INTERP_KERNEL::Exception("DataArrayInt::AggregateIndexes : input list must be NON EMPTY !");
8825 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
8826 ret->alloc(retSz,1);
8827 int *pt=ret->getPointer(); *pt++=0;
8828 for(std::vector<const DataArrayInt *>::const_iterator it=arrs.begin();it!=arrs.end();it++)
8829 pt=std::transform((*it)->begin()+1,(*it)->end(),pt,std::bind2nd(std::plus<int>(),pt[-1]));
8830 ret->copyStringInfoFrom(*(arrs[0]));
8835 * Returns the maximal value and its location within \a this one-dimensional array.
8836 * \param [out] tupleId - index of the tuple holding the maximal value.
8837 * \return int - the maximal value among all values of \a this array.
8838 * \throw If \a this->getNumberOfComponents() != 1
8839 * \throw If \a this->getNumberOfTuples() < 1
8841 int DataArrayInt::getMaxValue(int& tupleId) const
8844 if(getNumberOfComponents()!=1)
8845 throw INTERP_KERNEL::Exception("DataArrayInt::getMaxValue : must be applied on DataArrayInt with only one component !");
8846 int nbOfTuples=getNumberOfTuples();
8848 throw INTERP_KERNEL::Exception("DataArrayInt::getMaxValue : array exists but number of tuples must be > 0 !");
8849 const int *vals=getConstPointer();
8850 const int *loc=std::max_element(vals,vals+nbOfTuples);
8851 tupleId=(int)std::distance(vals,loc);
8856 * Returns the maximal value within \a this array that is allowed to have more than
8858 * \return int - the maximal value among all values of \a this array.
8859 * \throw If \a this is not allocated.
8861 int DataArrayInt::getMaxValueInArray() const
8864 const int *loc=std::max_element(begin(),end());
8869 * Returns the minimal value and its location within \a this one-dimensional array.
8870 * \param [out] tupleId - index of the tuple holding the minimal value.
8871 * \return int - the minimal value among all values of \a this array.
8872 * \throw If \a this->getNumberOfComponents() != 1
8873 * \throw If \a this->getNumberOfTuples() < 1
8875 int DataArrayInt::getMinValue(int& tupleId) const
8878 if(getNumberOfComponents()!=1)
8879 throw INTERP_KERNEL::Exception("DataArrayInt::getMaxValue : must be applied on DataArrayInt with only one component !");
8880 int nbOfTuples=getNumberOfTuples();
8882 throw INTERP_KERNEL::Exception("DataArrayInt::getMaxValue : array exists but number of tuples must be > 0 !");
8883 const int *vals=getConstPointer();
8884 const int *loc=std::min_element(vals,vals+nbOfTuples);
8885 tupleId=(int)std::distance(vals,loc);
8890 * Returns the minimal value within \a this array that is allowed to have more than
8892 * \return int - the minimal value among all values of \a this array.
8893 * \throw If \a this is not allocated.
8895 int DataArrayInt::getMinValueInArray() const
8898 const int *loc=std::min_element(begin(),end());
8903 * Converts every value of \a this array to its absolute value.
8904 * \throw If \a this is not allocated.
8906 void DataArrayInt::abs()
8909 int *ptr=getPointer();
8910 std::size_t nbOfElems=getNbOfElems();
8911 std::transform(ptr,ptr+nbOfElems,ptr,std::ptr_fun<int,int>(std::abs));
8916 * Apply a liner function to a given component of \a this array, so that
8917 * an array element <em>(x)</em> becomes \f$ a * x + b \f$.
8918 * \param [in] a - the first coefficient of the function.
8919 * \param [in] b - the second coefficient of the function.
8920 * \param [in] compoId - the index of component to modify.
8921 * \throw If \a this is not allocated.
8923 void DataArrayInt::applyLin(int a, int b, int compoId)
8926 int *ptr=getPointer()+compoId;
8927 int nbOfComp=getNumberOfComponents();
8928 int nbOfTuple=getNumberOfTuples();
8929 for(int i=0;i<nbOfTuple;i++,ptr+=nbOfComp)
8935 * Apply a liner function to all elements of \a this array, so that
8936 * an element _x_ becomes \f$ a * x + b \f$.
8937 * \param [in] a - the first coefficient of the function.
8938 * \param [in] b - the second coefficient of the function.
8939 * \throw If \a this is not allocated.
8941 void DataArrayInt::applyLin(int a, int b)
8944 int *ptr=getPointer();
8945 std::size_t nbOfElems=getNbOfElems();
8946 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
8952 * Returns a full copy of \a this array except that sign of all elements is reversed.
8953 * \return DataArrayInt * - the new instance of DataArrayInt containing the
8954 * same number of tuples and component as \a this array.
8955 * The caller is to delete this result array using decrRef() as it is no more
8957 * \throw If \a this is not allocated.
8959 DataArrayInt *DataArrayInt::negate() const
8962 DataArrayInt *newArr=DataArrayInt::New();
8963 int nbOfTuples=getNumberOfTuples();
8964 int nbOfComp=getNumberOfComponents();
8965 newArr->alloc(nbOfTuples,nbOfComp);
8966 const int *cptr=getConstPointer();
8967 std::transform(cptr,cptr+nbOfTuples*nbOfComp,newArr->getPointer(),std::negate<int>());
8968 newArr->copyStringInfoFrom(*this);
8973 * Modify all elements of \a this array, so that
8974 * an element _x_ becomes \f$ numerator / x \f$.
8975 * \warning If an exception is thrown because of presence of 0 element in \a this
8976 * array, all elements processed before detection of the zero element remain
8978 * \param [in] numerator - the numerator used to modify array elements.
8979 * \throw If \a this is not allocated.
8980 * \throw If there is an element equal to 0 in \a this array.
8982 void DataArrayInt::applyInv(int numerator)
8985 int *ptr=getPointer();
8986 std::size_t nbOfElems=getNbOfElems();
8987 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
8991 *ptr=numerator/(*ptr);
8995 std::ostringstream oss; oss << "DataArrayInt::applyInv : presence of null value in tuple #" << i/getNumberOfComponents() << " component #" << i%getNumberOfComponents();
8997 throw INTERP_KERNEL::Exception(oss.str().c_str());
9004 * Modify all elements of \a this array, so that
9005 * an element _x_ becomes \f$ x / val \f$.
9006 * \param [in] val - the denominator used to modify array elements.
9007 * \throw If \a this is not allocated.
9008 * \throw If \a val == 0.
9010 void DataArrayInt::applyDivideBy(int val)
9013 throw INTERP_KERNEL::Exception("DataArrayInt::applyDivideBy : Trying to divide by 0 !");
9015 int *ptr=getPointer();
9016 std::size_t nbOfElems=getNbOfElems();
9017 std::transform(ptr,ptr+nbOfElems,ptr,std::bind2nd(std::divides<int>(),val));
9022 * Modify all elements of \a this array, so that
9023 * an element _x_ becomes <em> x % val </em>.
9024 * \param [in] val - the divisor used to modify array elements.
9025 * \throw If \a this is not allocated.
9026 * \throw If \a val <= 0.
9028 void DataArrayInt::applyModulus(int val)
9031 throw INTERP_KERNEL::Exception("DataArrayInt::applyDivideBy : Trying to operate modulus on value <= 0 !");
9033 int *ptr=getPointer();
9034 std::size_t nbOfElems=getNbOfElems();
9035 std::transform(ptr,ptr+nbOfElems,ptr,std::bind2nd(std::modulus<int>(),val));
9040 * This method works only on data array with one component.
9041 * This method returns a newly allocated array storing stored ascendantly tuple ids in \b this so that
9042 * this[*id] in [\b vmin,\b vmax)
9044 * \param [in] vmin begin of range. This value is included in range (included).
9045 * \param [in] vmax end of range. This value is \b not included in range (excluded).
9046 * \return a newly allocated data array that the caller should deal with.
9048 * \sa DataArrayInt::getIdsNotInRange
9050 DataArrayInt *DataArrayInt::getIdsInRange(int vmin, int vmax) const
9053 if(getNumberOfComponents()!=1)
9054 throw INTERP_KERNEL::Exception("DataArrayInt::getIdsInRange : this must have exactly one component !");
9055 const int *cptr(begin());
9056 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
9057 int nbOfTuples(getNumberOfTuples());
9058 for(int i=0;i<nbOfTuples;i++,cptr++)
9059 if(*cptr>=vmin && *cptr<vmax)
9060 ret->pushBackSilent(i);
9065 * This method works only on data array with one component.
9066 * This method returns a newly allocated array storing stored ascendantly tuple ids in \b this so that
9067 * this[*id] \b not in [\b vmin,\b vmax)
9069 * \param [in] vmin begin of range. This value is \b not included in range (excluded).
9070 * \param [in] vmax end of range. This value is included in range (included).
9071 * \return a newly allocated data array that the caller should deal with.
9073 * \sa DataArrayInt::getIdsInRange
9075 DataArrayInt *DataArrayInt::getIdsNotInRange(int vmin, int vmax) const
9078 if(getNumberOfComponents()!=1)
9079 throw INTERP_KERNEL::Exception("DataArrayInt::getIdsNotInRange : this must have exactly one component !");
9080 const int *cptr(getConstPointer());
9081 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
9082 int nbOfTuples(getNumberOfTuples());
9083 for(int i=0;i<nbOfTuples;i++,cptr++)
9084 if(*cptr<vmin || *cptr>=vmax)
9085 ret->pushBackSilent(i);
9090 * This method works only on data array with one component.
9091 * This method checks that all ids in \b this are in [ \b vmin, \b vmax ). If there is at least one element in \a this not in [ \b vmin, \b vmax ) an exception will be thrown.
9093 * \param [in] vmin begin of range. This value is included in range (included).
9094 * \param [in] vmax end of range. This value is \b not included in range (excluded).
9095 * \return if all ids in \a this are so that (*this)[i]==i for all i in [ 0, \c this->getNumberOfTuples() ). */
9096 bool DataArrayInt::checkAllIdsInRange(int vmin, int vmax) const
9099 if(getNumberOfComponents()!=1)
9100 throw INTERP_KERNEL::Exception("DataArrayInt::checkAllIdsInRange : this must have exactly one component !");
9101 int nbOfTuples=getNumberOfTuples();
9103 const int *cptr=getConstPointer();
9104 for(int i=0;i<nbOfTuples;i++,cptr++)
9106 if(*cptr>=vmin && *cptr<vmax)
9107 { ret=ret && *cptr==i; }
9110 std::ostringstream oss; oss << "DataArrayInt::checkAllIdsInRange : tuple #" << i << " has value " << *cptr << " should be in [" << vmin << "," << vmax << ") !";
9111 throw INTERP_KERNEL::Exception(oss.str().c_str());
9118 * Modify all elements of \a this array, so that
9119 * an element _x_ becomes <em> val % x </em>.
9120 * \warning If an exception is thrown because of presence of an element <= 0 in \a this
9121 * array, all elements processed before detection of the zero element remain
9123 * \param [in] val - the divident used to modify array elements.
9124 * \throw If \a this is not allocated.
9125 * \throw If there is an element equal to or less than 0 in \a this array.
9127 void DataArrayInt::applyRModulus(int val)
9130 int *ptr=getPointer();
9131 std::size_t nbOfElems=getNbOfElems();
9132 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
9140 std::ostringstream oss; oss << "DataArrayInt::applyRModulus : presence of value <=0 in tuple #" << i/getNumberOfComponents() << " component #" << i%getNumberOfComponents();
9142 throw INTERP_KERNEL::Exception(oss.str().c_str());
9149 * Modify all elements of \a this array, so that
9150 * an element _x_ becomes <em> val ^ x </em>.
9151 * \param [in] val - the value used to apply pow on all array elements.
9152 * \throw If \a this is not allocated.
9153 * \throw If \a val < 0.
9155 void DataArrayInt::applyPow(int val)
9159 throw INTERP_KERNEL::Exception("DataArrayInt::applyPow : input pow in < 0 !");
9160 int *ptr=getPointer();
9161 std::size_t nbOfElems=getNbOfElems();
9164 std::fill(ptr,ptr+nbOfElems,1);
9167 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
9170 for(int j=0;j<val;j++)
9178 * Modify all elements of \a this array, so that
9179 * an element _x_ becomes \f$ val ^ x \f$.
9180 * \param [in] val - the value used to apply pow on all array elements.
9181 * \throw If \a this is not allocated.
9182 * \throw If there is an element < 0 in \a this array.
9183 * \warning If an exception is thrown because of presence of 0 element in \a this
9184 * array, all elements processed before detection of the zero element remain
9187 void DataArrayInt::applyRPow(int val)
9190 int *ptr=getPointer();
9191 std::size_t nbOfElems=getNbOfElems();
9192 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
9197 for(int j=0;j<*ptr;j++)
9203 std::ostringstream oss; oss << "DataArrayInt::applyRPow : presence of negative value in tuple #" << i/getNumberOfComponents() << " component #" << i%getNumberOfComponents();
9205 throw INTERP_KERNEL::Exception(oss.str().c_str());
9212 * Returns a new DataArrayInt by aggregating two given arrays, so that (1) the number
9213 * of components in the result array is a sum of the number of components of given arrays
9214 * and (2) the number of tuples in the result array is same as that of each of given
9215 * arrays. In other words the i-th tuple of result array includes all components of
9216 * i-th tuples of all given arrays.
9217 * Number of tuples in the given arrays must be the same.
9218 * \param [in] a1 - an array to include in the result array.
9219 * \param [in] a2 - another array to include in the result array.
9220 * \return DataArrayInt * - the new instance of DataArrayInt.
9221 * The caller is to delete this result array using decrRef() as it is no more
9223 * \throw If both \a a1 and \a a2 are NULL.
9224 * \throw If any given array is not allocated.
9225 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
9227 DataArrayInt *DataArrayInt::Meld(const DataArrayInt *a1, const DataArrayInt *a2)
9229 std::vector<const DataArrayInt *> arr(2);
9230 arr[0]=a1; arr[1]=a2;
9235 * Returns a new DataArrayInt by aggregating all given arrays, so that (1) the number
9236 * of components in the result array is a sum of the number of components of given arrays
9237 * and (2) the number of tuples in the result array is same as that of each of given
9238 * arrays. In other words the i-th tuple of result array includes all components of
9239 * i-th tuples of all given arrays.
9240 * Number of tuples in the given arrays must be the same.
9241 * \param [in] arr - a sequence of arrays to include in the result array.
9242 * \return DataArrayInt * - the new instance of DataArrayInt.
9243 * The caller is to delete this result array using decrRef() as it is no more
9245 * \throw If all arrays within \a arr are NULL.
9246 * \throw If any given array is not allocated.
9247 * \throw If getNumberOfTuples() of arrays within \a arr is different.
9249 DataArrayInt *DataArrayInt::Meld(const std::vector<const DataArrayInt *>& arr)
9251 std::vector<const DataArrayInt *> a;
9252 for(std::vector<const DataArrayInt *>::const_iterator it4=arr.begin();it4!=arr.end();it4++)
9256 throw INTERP_KERNEL::Exception("DataArrayInt::Meld : array must be NON empty !");
9257 std::vector<const DataArrayInt *>::const_iterator it;
9258 for(it=a.begin();it!=a.end();it++)
9259 (*it)->checkAllocated();
9261 int nbOfTuples=(*it)->getNumberOfTuples();
9262 std::vector<int> nbc(a.size());
9263 std::vector<const int *> pts(a.size());
9264 nbc[0]=(*it)->getNumberOfComponents();
9265 pts[0]=(*it++)->getConstPointer();
9266 for(int i=1;it!=a.end();it++,i++)
9268 if(nbOfTuples!=(*it)->getNumberOfTuples())
9269 throw INTERP_KERNEL::Exception("DataArrayInt::meld : mismatch of number of tuples !");
9270 nbc[i]=(*it)->getNumberOfComponents();
9271 pts[i]=(*it)->getConstPointer();
9273 int totalNbOfComp=std::accumulate(nbc.begin(),nbc.end(),0);
9274 DataArrayInt *ret=DataArrayInt::New();
9275 ret->alloc(nbOfTuples,totalNbOfComp);
9276 int *retPtr=ret->getPointer();
9277 for(int i=0;i<nbOfTuples;i++)
9278 for(int j=0;j<(int)a.size();j++)
9280 retPtr=std::copy(pts[j],pts[j]+nbc[j],retPtr);
9284 for(int i=0;i<(int)a.size();i++)
9285 for(int j=0;j<nbc[i];j++,k++)
9286 ret->setInfoOnComponent(k,a[i]->getInfoOnComponent(j).c_str());
9291 * Returns a new DataArrayInt which is a minimal partition of elements of \a groups.
9292 * The i-th item of the result array is an ID of a set of elements belonging to a
9293 * unique set of groups, which the i-th element is a part of. This set of elements
9294 * belonging to a unique set of groups is called \a family, so the result array contains
9295 * IDs of families each element belongs to.
9297 * \b Example: if we have two groups of elements: \a group1 [0,4] and \a group2 [ 0,1,2 ],
9298 * then there are 3 families:
9299 * - \a family1 (with ID 1) contains element [0] belonging to ( \a group1 + \a group2 ),
9300 * - \a family2 (with ID 2) contains elements [4] belonging to ( \a group1 ),
9301 * - \a family3 (with ID 3) contains element [1,2] belonging to ( \a group2 ), <br>
9302 * and the result array contains IDs of families [ 1,3,3,0,2 ]. <br> Note a family ID 0 which
9303 * stands for the element #3 which is in none of groups.
9305 * \param [in] groups - sequence of groups of element IDs.
9306 * \param [in] newNb - total number of elements; it must be more than max ID of element
9308 * \param [out] fidsOfGroups - IDs of families the elements of each group belong to.
9309 * \return DataArrayInt * - a new instance of DataArrayInt containing IDs of families
9310 * each element with ID from range [0, \a newNb ) belongs to. The caller is to
9311 * delete this array using decrRef() as it is no more needed.
9312 * \throw If any element ID in \a groups violates condition ( 0 <= ID < \a newNb ).
9314 DataArrayInt *DataArrayInt::MakePartition(const std::vector<const DataArrayInt *>& groups, int newNb, std::vector< std::vector<int> >& fidsOfGroups)
9316 std::vector<const DataArrayInt *> groups2;
9317 for(std::vector<const DataArrayInt *>::const_iterator it4=groups.begin();it4!=groups.end();it4++)
9319 groups2.push_back(*it4);
9320 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
9321 ret->alloc(newNb,1);
9322 int *retPtr=ret->getPointer();
9323 std::fill(retPtr,retPtr+newNb,0);
9325 for(std::vector<const DataArrayInt *>::const_iterator iter=groups2.begin();iter!=groups2.end();iter++)
9327 const int *ptr=(*iter)->getConstPointer();
9328 std::size_t nbOfElem=(*iter)->getNbOfElems();
9330 for(int j=0;j<sfid;j++)
9333 for(std::size_t i=0;i<nbOfElem;i++)
9335 if(ptr[i]>=0 && ptr[i]<newNb)
9337 if(retPtr[ptr[i]]==j)
9345 std::ostringstream oss; oss << "DataArrayInt::MakePartition : In group \"" << (*iter)->getName() << "\" in tuple #" << i << " value = " << ptr[i] << " ! Should be in [0," << newNb;
9347 throw INTERP_KERNEL::Exception(oss.str().c_str());
9354 fidsOfGroups.clear();
9355 fidsOfGroups.resize(groups2.size());
9357 for(std::vector<const DataArrayInt *>::const_iterator iter=groups2.begin();iter!=groups2.end();iter++,grId++)
9360 const int *ptr=(*iter)->getConstPointer();
9361 std::size_t nbOfElem=(*iter)->getNbOfElems();
9362 for(const int *p=ptr;p!=ptr+nbOfElem;p++)
9363 tmp.insert(retPtr[*p]);
9364 fidsOfGroups[grId].insert(fidsOfGroups[grId].end(),tmp.begin(),tmp.end());
9370 * Returns a new DataArrayInt which contains all elements of given one-dimensional
9371 * arrays. The result array does not contain any duplicates and its values
9372 * are sorted in ascending order.
9373 * \param [in] arr - sequence of DataArrayInt's to unite.
9374 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
9375 * array using decrRef() as it is no more needed.
9376 * \throw If any \a arr[i] is not allocated.
9377 * \throw If \a arr[i]->getNumberOfComponents() != 1.
9379 DataArrayInt *DataArrayInt::BuildUnion(const std::vector<const DataArrayInt *>& arr)
9381 std::vector<const DataArrayInt *> a;
9382 for(std::vector<const DataArrayInt *>::const_iterator it4=arr.begin();it4!=arr.end();it4++)
9385 for(std::vector<const DataArrayInt *>::const_iterator it=a.begin();it!=a.end();it++)
9387 (*it)->checkAllocated();
9388 if((*it)->getNumberOfComponents()!=1)
9389 throw INTERP_KERNEL::Exception("DataArrayInt::BuildUnion : only single component allowed !");
9393 for(std::vector<const DataArrayInt *>::const_iterator it=a.begin();it!=a.end();it++)
9395 const int *pt=(*it)->getConstPointer();
9396 int nbOfTuples=(*it)->getNumberOfTuples();
9397 r.insert(pt,pt+nbOfTuples);
9399 DataArrayInt *ret=DataArrayInt::New();
9400 ret->alloc((int)r.size(),1);
9401 std::copy(r.begin(),r.end(),ret->getPointer());
9406 * Returns a new DataArrayInt which contains elements present in each of given one-dimensional
9407 * arrays. The result array does not contain any duplicates and its values
9408 * are sorted in ascending order.
9409 * \param [in] arr - sequence of DataArrayInt's to intersect.
9410 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
9411 * array using decrRef() as it is no more needed.
9412 * \throw If any \a arr[i] is not allocated.
9413 * \throw If \a arr[i]->getNumberOfComponents() != 1.
9415 DataArrayInt *DataArrayInt::BuildIntersection(const std::vector<const DataArrayInt *>& arr)
9417 std::vector<const DataArrayInt *> a;
9418 for(std::vector<const DataArrayInt *>::const_iterator it4=arr.begin();it4!=arr.end();it4++)
9421 for(std::vector<const DataArrayInt *>::const_iterator it=a.begin();it!=a.end();it++)
9423 (*it)->checkAllocated();
9424 if((*it)->getNumberOfComponents()!=1)
9425 throw INTERP_KERNEL::Exception("DataArrayInt::BuildIntersection : only single component allowed !");
9429 for(std::vector<const DataArrayInt *>::const_iterator it=a.begin();it!=a.end();it++)
9431 const int *pt=(*it)->getConstPointer();
9432 int nbOfTuples=(*it)->getNumberOfTuples();
9433 std::set<int> s1(pt,pt+nbOfTuples);
9437 std::set_intersection(r.begin(),r.end(),s1.begin(),s1.end(),inserter(r2,r2.end()));
9443 DataArrayInt *ret=DataArrayInt::New();
9444 ret->alloc((int)r.size(),1);
9445 std::copy(r.begin(),r.end(),ret->getPointer());
9450 * Returns a new DataArrayInt which contains a complement of elements of \a this
9451 * one-dimensional array. I.e. the result array contains all elements from the range [0,
9452 * \a nbOfElement) not present in \a this array.
9453 * \param [in] nbOfElement - maximal size of the result array.
9454 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
9455 * array using decrRef() as it is no more needed.
9456 * \throw If \a this is not allocated.
9457 * \throw If \a this->getNumberOfComponents() != 1.
9458 * \throw If any element \a x of \a this array violates condition ( 0 <= \a x < \a
9461 DataArrayInt *DataArrayInt::buildComplement(int nbOfElement) const
9464 if(getNumberOfComponents()!=1)
9465 throw INTERP_KERNEL::Exception("DataArrayInt::buildComplement : only single component allowed !");
9466 std::vector<bool> tmp(nbOfElement);
9467 const int *pt=getConstPointer();
9468 int nbOfTuples=getNumberOfTuples();
9469 for(const int *w=pt;w!=pt+nbOfTuples;w++)
9470 if(*w>=0 && *w<nbOfElement)
9473 throw INTERP_KERNEL::Exception("DataArrayInt::buildComplement : an element is not in valid range : [0,nbOfElement) !");
9474 int nbOfRetVal=(int)std::count(tmp.begin(),tmp.end(),false);
9475 DataArrayInt *ret=DataArrayInt::New();
9476 ret->alloc(nbOfRetVal,1);
9478 int *retPtr=ret->getPointer();
9479 for(int i=0;i<nbOfElement;i++)
9486 * Returns a new DataArrayInt containing elements of \a this one-dimensional missing
9487 * from an \a other one-dimensional array.
9488 * \param [in] other - a DataArrayInt containing elements not to include in the result array.
9489 * \return DataArrayInt * - a new instance of DataArrayInt with one component. The
9490 * caller is to delete this array using decrRef() as it is no more needed.
9491 * \throw If \a other is NULL.
9492 * \throw If \a other is not allocated.
9493 * \throw If \a other->getNumberOfComponents() != 1.
9494 * \throw If \a this is not allocated.
9495 * \throw If \a this->getNumberOfComponents() != 1.
9496 * \sa DataArrayInt::buildSubstractionOptimized()
9498 DataArrayInt *DataArrayInt::buildSubstraction(const DataArrayInt *other) const
9501 throw INTERP_KERNEL::Exception("DataArrayInt::buildSubstraction : DataArrayInt pointer in input is NULL !");
9503 other->checkAllocated();
9504 if(getNumberOfComponents()!=1)
9505 throw INTERP_KERNEL::Exception("DataArrayInt::buildSubstraction : only single component allowed !");
9506 if(other->getNumberOfComponents()!=1)
9507 throw INTERP_KERNEL::Exception("DataArrayInt::buildSubstraction : only single component allowed for other type !");
9508 const int *pt=getConstPointer();
9509 int nbOfTuples=getNumberOfTuples();
9510 std::set<int> s1(pt,pt+nbOfTuples);
9511 pt=other->getConstPointer();
9512 nbOfTuples=other->getNumberOfTuples();
9513 std::set<int> s2(pt,pt+nbOfTuples);
9515 std::set_difference(s1.begin(),s1.end(),s2.begin(),s2.end(),std::back_insert_iterator< std::vector<int> >(r));
9516 DataArrayInt *ret=DataArrayInt::New();
9517 ret->alloc((int)r.size(),1);
9518 std::copy(r.begin(),r.end(),ret->getPointer());
9523 * \a this is expected to have one component and to be sorted ascendingly (as for \a other).
9524 * \a other is expected to be a part of \a this. If not DataArrayInt::buildSubstraction should be called instead.
9526 * \param [in] other an array with one component and expected to be sorted ascendingly.
9527 * \ret list of ids in \a this but not in \a other.
9528 * \sa DataArrayInt::buildSubstraction
9530 DataArrayInt *DataArrayInt::buildSubstractionOptimized(const DataArrayInt *other) const
9532 static const char *MSG="DataArrayInt::buildSubstractionOptimized : only single component allowed !";
9533 if(!other) throw INTERP_KERNEL::Exception("DataArrayInt::buildSubstractionOptimized : NULL input array !");
9534 checkAllocated(); other->checkAllocated();
9535 if(getNumberOfComponents()!=1) throw INTERP_KERNEL::Exception(MSG);
9536 if(other->getNumberOfComponents()!=1) throw INTERP_KERNEL::Exception(MSG);
9537 const int *pt1Bg(begin()),*pt1End(end()),*pt2Bg(other->begin()),*pt2End(other->end()),*work1(pt1Bg),*work2(pt2Bg);
9538 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
9539 for(;work1!=pt1End;work1++)
9541 if(work2!=pt2End && *work1==*work2)
9544 ret->pushBackSilent(*work1);
9551 * Returns a new DataArrayInt which contains all elements of \a this and a given
9552 * one-dimensional arrays. The result array does not contain any duplicates
9553 * and its values are sorted in ascending order.
9554 * \param [in] other - an array to unite with \a this one.
9555 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
9556 * array using decrRef() as it is no more needed.
9557 * \throw If \a this or \a other is not allocated.
9558 * \throw If \a this->getNumberOfComponents() != 1.
9559 * \throw If \a other->getNumberOfComponents() != 1.
9561 DataArrayInt *DataArrayInt::buildUnion(const DataArrayInt *other) const
9563 std::vector<const DataArrayInt *>arrs(2);
9564 arrs[0]=this; arrs[1]=other;
9565 return BuildUnion(arrs);
9570 * Returns a new DataArrayInt which contains elements present in both \a this and a given
9571 * one-dimensional arrays. The result array does not contain any duplicates
9572 * and its values are sorted in ascending order.
9573 * \param [in] other - an array to intersect with \a this one.
9574 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
9575 * array using decrRef() as it is no more needed.
9576 * \throw If \a this or \a other is not allocated.
9577 * \throw If \a this->getNumberOfComponents() != 1.
9578 * \throw If \a other->getNumberOfComponents() != 1.
9580 DataArrayInt *DataArrayInt::buildIntersection(const DataArrayInt *other) const
9582 std::vector<const DataArrayInt *>arrs(2);
9583 arrs[0]=this; arrs[1]=other;
9584 return BuildIntersection(arrs);
9588 * This method can be applied on allocated with one component DataArrayInt instance.
9589 * This method is typically relevant for sorted arrays. All consecutive duplicated items in \a this will appear only once in returned DataArrayInt instance.
9590 * Example : if \a this contains [1,2,2,3,3,3,3,4,5,5,7,7,7,19] the returned array will contain [1,2,3,4,5,7,19]
9592 * \return a newly allocated array that contain the result of the unique operation applied on \a this.
9593 * \throw if \a this is not allocated or if \a this has not exactly one component.
9595 DataArrayInt *DataArrayInt::buildUnique() const
9598 if(getNumberOfComponents()!=1)
9599 throw INTERP_KERNEL::Exception("DataArrayInt::buildUnique : only single component allowed !");
9600 int nbOfTuples=getNumberOfTuples();
9601 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> tmp=deepCpy();
9602 int *data=tmp->getPointer();
9603 int *last=std::unique(data,data+nbOfTuples);
9604 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
9605 ret->alloc(std::distance(data,last),1);
9606 std::copy(data,last,ret->getPointer());
9611 * Returns a new DataArrayInt which contains size of every of groups described by \a this
9612 * "index" array. Such "index" array is returned for example by
9613 * \ref ParaMEDMEM::MEDCouplingUMesh::buildDescendingConnectivity
9614 * "MEDCouplingUMesh::buildDescendingConnectivity" and
9615 * \ref ParaMEDMEM::MEDCouplingUMesh::getNodalConnectivityIndex
9616 * "MEDCouplingUMesh::getNodalConnectivityIndex" etc.
9617 * This method preforms the reverse operation of DataArrayInt::computeOffsets2.
9618 * \return DataArrayInt * - a new instance of DataArrayInt, whose number of tuples
9619 * equals to \a this->getNumberOfComponents() - 1, and number of components is 1.
9620 * The caller is to delete this array using decrRef() as it is no more needed.
9621 * \throw If \a this is not allocated.
9622 * \throw If \a this->getNumberOfComponents() != 1.
9623 * \throw If \a this->getNumberOfTuples() < 2.
9626 * - this contains [1,3,6,7,7,9,15]
9627 * - result array contains [2,3,1,0,2,6],
9628 * where 2 = 3 - 1, 3 = 6 - 3, 1 = 7 - 6 etc.
9630 * \sa DataArrayInt::computeOffsets2
9632 DataArrayInt *DataArrayInt::deltaShiftIndex() const
9635 if(getNumberOfComponents()!=1)
9636 throw INTERP_KERNEL::Exception("DataArrayInt::deltaShiftIndex : only single component allowed !");
9637 int nbOfTuples=getNumberOfTuples();
9639 throw INTERP_KERNEL::Exception("DataArrayInt::deltaShiftIndex : 1 tuple at least must be present in 'this' !");
9640 const int *ptr=getConstPointer();
9641 DataArrayInt *ret=DataArrayInt::New();
9642 ret->alloc(nbOfTuples-1,1);
9643 int *out=ret->getPointer();
9644 std::transform(ptr+1,ptr+nbOfTuples,ptr,out,std::minus<int>());
9649 * Modifies \a this one-dimensional array so that value of each element \a x
9650 * of \a this array (\a a) is computed as \f$ x_i = \sum_{j=0}^{i-1} a[ j ] \f$.
9651 * Or: for each i>0 new[i]=new[i-1]+old[i-1] for i==0 new[i]=0. Number of tuples
9652 * and components remains the same.<br>
9653 * This method is useful for allToAllV in MPI with contiguous policy. This method
9654 * differs from computeOffsets2() in that the number of tuples is \b not changed by
9656 * \throw If \a this is not allocated.
9657 * \throw If \a this->getNumberOfComponents() != 1.
9660 * - Before \a this contains [3,5,1,2,0,8]
9661 * - After \a this contains [0,3,8,9,11,11]<br>
9662 * Note that the last element 19 = 11 + 8 is missing because size of \a this
9663 * array is retained and thus there is no space to store the last element.
9665 void DataArrayInt::computeOffsets()
9668 if(getNumberOfComponents()!=1)
9669 throw INTERP_KERNEL::Exception("DataArrayInt::computeOffsets : only single component allowed !");
9670 int nbOfTuples=getNumberOfTuples();
9673 int *work=getPointer();
9676 for(int i=1;i<nbOfTuples;i++)
9679 work[i]=work[i-1]+tmp;
9687 * Modifies \a this one-dimensional array so that value of each element \a x
9688 * of \a this array (\a a) is computed as \f$ x_i = \sum_{j=0}^{i-1} a[ j ] \f$.
9689 * Or: for each i>0 new[i]=new[i-1]+old[i-1] for i==0 new[i]=0. Number
9690 * components remains the same and number of tuples is inceamented by one.<br>
9691 * This method is useful for allToAllV in MPI with contiguous policy. This method
9692 * differs from computeOffsets() in that the number of tuples is changed by this one.
9693 * This method preforms the reverse operation of DataArrayInt::deltaShiftIndex.
9694 * \throw If \a this is not allocated.
9695 * \throw If \a this->getNumberOfComponents() != 1.
9698 * - Before \a this contains [3,5,1,2,0,8]
9699 * - After \a this contains [0,3,8,9,11,11,19]<br>
9700 * \sa DataArrayInt::deltaShiftIndex
9702 void DataArrayInt::computeOffsets2()
9705 if(getNumberOfComponents()!=1)
9706 throw INTERP_KERNEL::Exception("DataArrayInt::computeOffsets2 : only single component allowed !");
9707 int nbOfTuples=getNumberOfTuples();
9708 int *ret=(int *)malloc((nbOfTuples+1)*sizeof(int));
9711 const int *work=getConstPointer();
9713 for(int i=0;i<nbOfTuples;i++)
9714 ret[i+1]=work[i]+ret[i];
9715 useArray(ret,true,C_DEALLOC,nbOfTuples+1,1);
9720 * Returns two new DataArrayInt instances whose contents is computed from that of \a this and \a listOfIds arrays as follows.
9721 * \a this is expected to be an offset format ( as returned by DataArrayInt::computeOffsets2 ) that is to say with one component
9722 * and ** sorted strictly increasingly **. \a listOfIds is expected to be sorted ascendingly (not strictly needed for \a listOfIds).
9723 * This methods searches in \a this, considered as a set of contiguous \c this->getNumberOfComponents() ranges, all ids in \a listOfIds
9724 * filling completely one of the ranges in \a this.
9726 * \param [in] listOfIds a list of ids that has to be sorted ascendingly.
9727 * \param [out] rangeIdsFetched the range ids fetched
9728 * \param [out] idsInInputListThatFetch contains the list of ids in \a listOfIds that are \b fully included in a range in \a this. So
9729 * \a idsInInputListThatFetch is a part of input \a listOfIds.
9731 * \sa DataArrayInt::computeOffsets2
9734 * - \a this : [0,3,7,9,15,18]
9735 * - \a listOfIds contains [0,1,2,3,7,8,15,16,17]
9736 * - \a rangeIdsFetched result array: [0,2,4]
9737 * - \a idsInInputListThatFetch result array: [0,1,2,7,8,15,16,17]
9738 * In this example id 3 in input \a listOfIds is alone so it do not appear in output \a idsInInputListThatFetch.
9741 void DataArrayInt::searchRangesInListOfIds(const DataArrayInt *listOfIds, DataArrayInt *& rangeIdsFetched, DataArrayInt *& idsInInputListThatFetch) const
9744 throw INTERP_KERNEL::Exception("DataArrayInt::searchRangesInListOfIds : input list of ids is null !");
9745 listOfIds->checkAllocated(); checkAllocated();
9746 if(listOfIds->getNumberOfComponents()!=1)
9747 throw INTERP_KERNEL::Exception("DataArrayInt::searchRangesInListOfIds : input list of ids must have exactly one component !");
9748 if(getNumberOfComponents()!=1)
9749 throw INTERP_KERNEL::Exception("DataArrayInt::searchRangesInListOfIds : this must have exactly one component !");
9750 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret0=DataArrayInt::New(); ret0->alloc(0,1);
9751 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret1=DataArrayInt::New(); ret1->alloc(0,1);
9752 const int *tupEnd(listOfIds->end()),*offBg(begin()),*offEnd(end()-1);
9753 const int *tupPtr(listOfIds->begin()),*offPtr(offBg);
9754 while(tupPtr!=tupEnd && offPtr!=offEnd)
9756 if(*tupPtr==*offPtr)
9759 while(i<offPtr[1] && *tupPtr==i && tupPtr!=tupEnd) { i++; tupPtr++; }
9762 ret0->pushBackSilent((int)std::distance(offBg,offPtr));
9763 ret1->pushBackValsSilent(tupPtr-(offPtr[1]-offPtr[0]),tupPtr);
9768 { if(*tupPtr<*offPtr) tupPtr++; else offPtr++; }
9770 rangeIdsFetched=ret0.retn();
9771 idsInInputListThatFetch=ret1.retn();
9775 * Returns a new DataArrayInt whose contents is computed from that of \a this and \a
9776 * offsets arrays as follows. \a offsets is a one-dimensional array considered as an
9777 * "index" array of a "iota" array, thus, whose each element gives an index of a group
9778 * beginning within the "iota" array. And \a this is a one-dimensional array
9779 * considered as a selector of groups described by \a offsets to include into the result array.
9780 * \throw If \a offsets is NULL.
9781 * \throw If \a offsets is not allocated.
9782 * \throw If \a offsets->getNumberOfComponents() != 1.
9783 * \throw If \a offsets is not monotonically increasing.
9784 * \throw If \a this is not allocated.
9785 * \throw If \a this->getNumberOfComponents() != 1.
9786 * \throw If any element of \a this is not a valid index for \a offsets array.
9789 * - \a this: [0,2,3]
9790 * - \a offsets: [0,3,6,10,14,20]
9791 * - result array: [0,1,2,6,7,8,9,10,11,12,13] == <br>
9792 * \c range(0,3) + \c range(6,10) + \c range(10,14) ==<br>
9793 * \c range( \a offsets[ \a this[0] ], offsets[ \a this[0]+1 ]) +
9794 * \c range( \a offsets[ \a this[1] ], offsets[ \a this[1]+1 ]) +
9795 * \c range( \a offsets[ \a this[2] ], offsets[ \a this[2]+1 ])
9797 DataArrayInt *DataArrayInt::buildExplicitArrByRanges(const DataArrayInt *offsets) const
9800 throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrByRanges : DataArrayInt pointer in input is NULL !");
9802 if(getNumberOfComponents()!=1)
9803 throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrByRanges : only single component allowed !");
9804 offsets->checkAllocated();
9805 if(offsets->getNumberOfComponents()!=1)
9806 throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrByRanges : input array should have only single component !");
9807 int othNbTuples=offsets->getNumberOfTuples()-1;
9808 int nbOfTuples=getNumberOfTuples();
9809 int retNbOftuples=0;
9810 const int *work=getConstPointer();
9811 const int *offPtr=offsets->getConstPointer();
9812 for(int i=0;i<nbOfTuples;i++)
9815 if(val>=0 && val<othNbTuples)
9817 int delta=offPtr[val+1]-offPtr[val];
9819 retNbOftuples+=delta;
9822 std::ostringstream oss; oss << "DataArrayInt::buildExplicitArrByRanges : Tuple #" << val << " of offset array has a delta < 0 !";
9823 throw INTERP_KERNEL::Exception(oss.str().c_str());
9828 std::ostringstream oss; oss << "DataArrayInt::buildExplicitArrByRanges : Tuple #" << i << " in this contains " << val;
9829 oss << " whereas offsets array is of size " << othNbTuples+1 << " !";
9830 throw INTERP_KERNEL::Exception(oss.str().c_str());
9833 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
9834 ret->alloc(retNbOftuples,1);
9835 int *retPtr=ret->getPointer();
9836 for(int i=0;i<nbOfTuples;i++)
9839 int start=offPtr[val];
9840 int off=offPtr[val+1]-start;
9841 for(int j=0;j<off;j++,retPtr++)
9848 * Returns a new DataArrayInt whose contents is computed using \a this that must be a
9849 * scaled array (monotonically increasing).
9850 from that of \a this and \a
9851 * offsets arrays as follows. \a offsets is a one-dimensional array considered as an
9852 * "index" array of a "iota" array, thus, whose each element gives an index of a group
9853 * beginning within the "iota" array. And \a this is a one-dimensional array
9854 * considered as a selector of groups described by \a offsets to include into the result array.
9855 * \throw If \a is NULL.
9856 * \throw If \a this is not allocated.
9857 * \throw If \a this->getNumberOfComponents() != 1.
9858 * \throw If \a this->getNumberOfTuples() == 0.
9859 * \throw If \a this is not monotonically increasing.
9860 * \throw If any element of ids in ( \a gb \a end \a step ) points outside the scale in \a this.
9863 * - \a bg , \a end and \a step : (0,5,2)
9864 * - \a this: [0,3,6,10,14,20]
9865 * - result array: [0,0,0, 2,2,2,2, 4,4,4,4,4,4] == <br>
9867 DataArrayInt *DataArrayInt::buildExplicitArrOfSliceOnScaledArr(int bg, int end, int step) const
9870 throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrOfSliceOnScaledArr : not allocated array !");
9871 if(getNumberOfComponents()!=1)
9872 throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrOfSliceOnScaledArr : number of components is expected to be equal to one !");
9873 int nbOfTuples(getNumberOfTuples());
9875 throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrOfSliceOnScaledArr : number of tuples must be != 0 !");
9876 const int *ids(begin());
9877 int nbOfEltsInSlc(GetNumberOfItemGivenBESRelative(bg,end,step,"DataArrayInt::buildExplicitArrOfSliceOnScaledArr")),sz(0),pos(bg);
9878 for(int i=0;i<nbOfEltsInSlc;i++,pos+=step)
9880 if(pos>=0 && pos<nbOfTuples-1)
9882 int delta(ids[pos+1]-ids[pos]);
9886 std::ostringstream oss; oss << "DataArrayInt::buildExplicitArrOfSliceOnScaledArr : At pos #" << i << " of input slice, value is " << pos << " and at this pos this is not monotonically increasing !";
9887 throw INTERP_KERNEL::Exception(oss.str().c_str());
9892 std::ostringstream oss; oss << "DataArrayInt::buildExplicitArrOfSliceOnScaledArr : At pos #" << i << " of input slice, value is " << pos << " should be in [0," << nbOfTuples-1 << ") !";
9893 throw INTERP_KERNEL::Exception(oss.str().c_str());
9896 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(sz,1);
9897 int *retPtr(ret->getPointer());
9899 for(int i=0;i<nbOfEltsInSlc;i++,pos+=step)
9901 int delta(ids[pos+1]-ids[pos]);
9902 for(int j=0;j<delta;j++,retPtr++)
9909 * 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.
9910 * 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
9911 * in tuple **i** of returned DataArrayInt.
9912 * If ranges overlapped (in theory it should not) this method do not detect it and always returns the first range.
9914 * For example if \a this contains : [1,24,7,8,10,17] and \a ranges contains [(0,3),(3,8),(8,15),(15,22),(22,30)]
9915 * The return DataArrayInt will contain : **[0,4,1,2,2,3]**
9917 * \param [in] ranges typically come from output of MEDCouplingUMesh::ComputeRangesFromTypeDistribution. Each range is specified like this : 1st component is
9918 * for lower value included and 2nd component is the upper value of corresponding range **excluded**.
9919 * \throw If offsets is a null pointer or does not have 2 components or if \a this is not allocated or \a this do not have exactly one component. To finish an exception
9920 * is thrown if no ranges in \a ranges contains value in \a this.
9922 * \sa DataArrayInt::findIdInRangeForEachTuple
9924 DataArrayInt *DataArrayInt::findRangeIdForEachTuple(const DataArrayInt *ranges) const
9927 throw INTERP_KERNEL::Exception("DataArrayInt::findRangeIdForEachTuple : null input pointer !");
9928 if(ranges->getNumberOfComponents()!=2)
9929 throw INTERP_KERNEL::Exception("DataArrayInt::findRangeIdForEachTuple : input DataArrayInt instance should have 2 components !");
9931 if(getNumberOfComponents()!=1)
9932 throw INTERP_KERNEL::Exception("DataArrayInt::findRangeIdForEachTuple : this should have only one component !");
9933 int nbTuples=getNumberOfTuples();
9934 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(nbTuples,1);
9935 int nbOfRanges=ranges->getNumberOfTuples();
9936 const int *rangesPtr=ranges->getConstPointer();
9937 int *retPtr=ret->getPointer();
9938 const int *inPtr=getConstPointer();
9939 for(int i=0;i<nbTuples;i++,retPtr++)
9943 for(int j=0;j<nbOfRanges && !found;j++)
9944 if(val>=rangesPtr[2*j] && val<rangesPtr[2*j+1])
9945 { *retPtr=j; found=true; }
9950 std::ostringstream oss; oss << "DataArrayInt::findRangeIdForEachTuple : tuple #" << i << " not found by any ranges !";
9951 throw INTERP_KERNEL::Exception(oss.str().c_str());
9958 * 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.
9959 * For each tuple at place **i** in \a this it tells which is the sub position of the first range in \a ranges that contains value \c this->getIJ(i,0) and put the result
9960 * in tuple **i** of returned DataArrayInt.
9961 * If ranges overlapped (in theory it should not) this method do not detect it and always returns the sub position of the first range.
9963 * For example if \a this contains : [1,24,7,8,10,17] and \a ranges contains [(0,3),(3,8),(8,15),(15,22),(22,30)]
9964 * The return DataArrayInt will contain : **[1,2,4,0,2,2]**
9965 * This method is often called in pair with DataArrayInt::findRangeIdForEachTuple method.
9967 * \param [in] ranges typically come from output of MEDCouplingUMesh::ComputeRangesFromTypeDistribution. Each range is specified like this : 1st component is
9968 * for lower value included and 2nd component is the upper value of corresponding range **excluded**.
9969 * \throw If offsets is a null pointer or does not have 2 components or if \a this is not allocated or \a this do not have exactly one component. To finish an exception
9970 * is thrown if no ranges in \a ranges contains value in \a this.
9971 * \sa DataArrayInt::findRangeIdForEachTuple
9973 DataArrayInt *DataArrayInt::findIdInRangeForEachTuple(const DataArrayInt *ranges) const
9976 throw INTERP_KERNEL::Exception("DataArrayInt::findIdInRangeForEachTuple : null input pointer !");
9977 if(ranges->getNumberOfComponents()!=2)
9978 throw INTERP_KERNEL::Exception("DataArrayInt::findIdInRangeForEachTuple : input DataArrayInt instance should have 2 components !");
9980 if(getNumberOfComponents()!=1)
9981 throw INTERP_KERNEL::Exception("DataArrayInt::findIdInRangeForEachTuple : this should have only one component !");
9982 int nbTuples=getNumberOfTuples();
9983 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(nbTuples,1);
9984 int nbOfRanges=ranges->getNumberOfTuples();
9985 const int *rangesPtr=ranges->getConstPointer();
9986 int *retPtr=ret->getPointer();
9987 const int *inPtr=getConstPointer();
9988 for(int i=0;i<nbTuples;i++,retPtr++)
9992 for(int j=0;j<nbOfRanges && !found;j++)
9993 if(val>=rangesPtr[2*j] && val<rangesPtr[2*j+1])
9994 { *retPtr=val-rangesPtr[2*j]; found=true; }
9999 std::ostringstream oss; oss << "DataArrayInt::findIdInRangeForEachTuple : tuple #" << i << " not found by any ranges !";
10000 throw INTERP_KERNEL::Exception(oss.str().c_str());
10008 * \param [in] nbTimes specifies the nb of times each tuples in \a this will be duplicated contiguouly in returned DataArrayInt instance.
10009 * \a nbTimes should be at least equal to 1.
10010 * \return a newly allocated DataArrayInt having one component and number of tuples equal to \a nbTimes * \c this->getNumberOfTuples.
10011 * \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.
10013 DataArrayInt *DataArrayInt::duplicateEachTupleNTimes(int nbTimes) const
10016 if(getNumberOfComponents()!=1)
10017 throw INTERP_KERNEL::Exception("DataArrayInt::duplicateEachTupleNTimes : this should have only one component !");
10019 throw INTERP_KERNEL::Exception("DataArrayInt::duplicateEachTupleNTimes : nb times should be >= 1 !");
10020 int nbTuples=getNumberOfTuples();
10021 const int *inPtr=getConstPointer();
10022 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(nbTimes*nbTuples,1);
10023 int *retPtr=ret->getPointer();
10024 for(int i=0;i<nbTuples;i++,inPtr++)
10027 for(int j=0;j<nbTimes;j++,retPtr++)
10030 ret->copyStringInfoFrom(*this);
10035 * This method returns all different values found in \a this. This method throws if \a this has not been allocated.
10036 * But the number of components can be different from one.
10037 * \return a newly allocated array (that should be dealt by the caller) containing different values in \a this.
10039 DataArrayInt *DataArrayInt::getDifferentValues() const
10043 ret.insert(begin(),end());
10044 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret2=DataArrayInt::New(); ret2->alloc((int)ret.size(),1);
10045 std::copy(ret.begin(),ret.end(),ret2->getPointer());
10046 return ret2.retn();
10050 * This method is a refinement of DataArrayInt::getDifferentValues because it returns not only different values in \a this but also, for each of
10051 * them it tells which tuple id have this id.
10052 * This method works only on arrays with one component (if it is not the case call DataArrayInt::rearrange(1) ).
10053 * This method returns two arrays having same size.
10054 * The instances of DataArrayInt in the returned vector have be specially allocated and computed by this method. Each of them should be dealt by the caller of this method.
10055 * Example : if this is equal to [1,0,1,2,0,2,2,-3,2] -> differentIds=[-3,0,1,2] and returned array will be equal to [[7],[1,4],[0,2],[3,5,6,8]]
10057 std::vector<DataArrayInt *> DataArrayInt::partitionByDifferentValues(std::vector<int>& differentIds) const
10060 if(getNumberOfComponents()!=1)
10061 throw INTERP_KERNEL::Exception("DataArrayInt::partitionByDifferentValues : this should have only one component !");
10063 std::map<int,int> m,m2,m3;
10064 for(const int *w=begin();w!=end();w++)
10066 differentIds.resize(m.size());
10067 std::vector<DataArrayInt *> ret(m.size());
10068 std::vector<int *> retPtr(m.size());
10069 for(std::map<int,int>::const_iterator it=m.begin();it!=m.end();it++,id++)
10071 m2[(*it).first]=id;
10072 ret[id]=DataArrayInt::New();
10073 ret[id]->alloc((*it).second,1);
10074 retPtr[id]=ret[id]->getPointer();
10075 differentIds[id]=(*it).first;
10078 for(const int *w=begin();w!=end();w++,id++)
10080 retPtr[m2[*w]][m3[*w]++]=id;
10086 * This method split ids in [0, \c this->getNumberOfTuples() ) using \a this array as a field of weight (>=0 each).
10087 * The aim of this method is to return a set of \a nbOfSlices chunk of contiguous ids as balanced as possible.
10089 * \param [in] nbOfSlices - number of slices expected.
10090 * \return - a vector having a size equal to \a nbOfSlices giving the start (included) and the stop (excluded) of each chunks.
10092 * \sa DataArray::GetSlice
10093 * \throw If \a this is not allocated or not with exactly one component.
10094 * \throw If an element in \a this if < 0.
10096 std::vector< std::pair<int,int> > DataArrayInt::splitInBalancedSlices(int nbOfSlices) const
10098 if(!isAllocated() || getNumberOfComponents()!=1)
10099 throw INTERP_KERNEL::Exception("DataArrayInt::splitInBalancedSlices : this array should have number of components equal to one and must be allocated !");
10101 throw INTERP_KERNEL::Exception("DataArrayInt::splitInBalancedSlices : number of slices must be >= 1 !");
10102 int sum(accumulate(0)),nbOfTuples(getNumberOfTuples());
10103 int sumPerSlc(sum/nbOfSlices),pos(0);
10104 const int *w(begin());
10105 std::vector< std::pair<int,int> > ret(nbOfSlices);
10106 for(int i=0;i<nbOfSlices;i++)
10108 std::pair<int,int> p(pos,-1);
10110 while(locSum<sumPerSlc && pos<nbOfTuples) { pos++; locSum+=*w++; }
10111 if(i!=nbOfSlices-1)
10114 p.second=nbOfTuples;
10121 * Returns a new DataArrayInt that is a sum of two given arrays. There are 3
10123 * 1. The arrays have same number of tuples and components. Then each value of
10124 * the result array (_a_) is a sum of the corresponding values of \a a1 and \a a2,
10125 * i.e.: _a_ [ i, j ] = _a1_ [ i, j ] + _a2_ [ i, j ].
10126 * 2. The arrays have same number of tuples and one array, say _a2_, has one
10128 * _a_ [ i, j ] = _a1_ [ i, j ] + _a2_ [ i, 0 ].
10129 * 3. The arrays have same number of components and one array, say _a2_, has one
10131 * _a_ [ i, j ] = _a1_ [ i, j ] + _a2_ [ 0, j ].
10133 * Info on components is copied either from the first array (in the first case) or from
10134 * the array with maximal number of elements (getNbOfElems()).
10135 * \param [in] a1 - an array to sum up.
10136 * \param [in] a2 - another array to sum up.
10137 * \return DataArrayInt * - the new instance of DataArrayInt.
10138 * The caller is to delete this result array using decrRef() as it is no more
10140 * \throw If either \a a1 or \a a2 is NULL.
10141 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
10142 * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
10143 * none of them has number of tuples or components equal to 1.
10145 DataArrayInt *DataArrayInt::Add(const DataArrayInt *a1, const DataArrayInt *a2)
10148 throw INTERP_KERNEL::Exception("DataArrayInt::Add : input DataArrayInt instance is NULL !");
10149 int nbOfTuple=a1->getNumberOfTuples();
10150 int nbOfTuple2=a2->getNumberOfTuples();
10151 int nbOfComp=a1->getNumberOfComponents();
10152 int nbOfComp2=a2->getNumberOfComponents();
10153 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=0;
10154 if(nbOfTuple==nbOfTuple2)
10156 if(nbOfComp==nbOfComp2)
10158 ret=DataArrayInt::New();
10159 ret->alloc(nbOfTuple,nbOfComp);
10160 std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::plus<int>());
10161 ret->copyStringInfoFrom(*a1);
10165 int nbOfCompMin,nbOfCompMax;
10166 const DataArrayInt *aMin, *aMax;
10167 if(nbOfComp>nbOfComp2)
10169 nbOfCompMin=nbOfComp2; nbOfCompMax=nbOfComp;
10174 nbOfCompMin=nbOfComp; nbOfCompMax=nbOfComp2;
10179 ret=DataArrayInt::New();
10180 ret->alloc(nbOfTuple,nbOfCompMax);
10181 const int *aMinPtr=aMin->getConstPointer();
10182 const int *aMaxPtr=aMax->getConstPointer();
10183 int *res=ret->getPointer();
10184 for(int i=0;i<nbOfTuple;i++)
10185 res=std::transform(aMaxPtr+i*nbOfCompMax,aMaxPtr+(i+1)*nbOfCompMax,res,std::bind2nd(std::plus<int>(),aMinPtr[i]));
10186 ret->copyStringInfoFrom(*aMax);
10189 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Add !");
10192 else if((nbOfTuple==1 && nbOfTuple2>1) || (nbOfTuple>1 && nbOfTuple2==1))
10194 if(nbOfComp==nbOfComp2)
10196 int nbOfTupleMax=std::max(nbOfTuple,nbOfTuple2);
10197 const DataArrayInt *aMin=nbOfTuple>nbOfTuple2?a2:a1;
10198 const DataArrayInt *aMax=nbOfTuple>nbOfTuple2?a1:a2;
10199 const int *aMinPtr=aMin->getConstPointer(),*aMaxPtr=aMax->getConstPointer();
10200 ret=DataArrayInt::New();
10201 ret->alloc(nbOfTupleMax,nbOfComp);
10202 int *res=ret->getPointer();
10203 for(int i=0;i<nbOfTupleMax;i++)
10204 res=std::transform(aMaxPtr+i*nbOfComp,aMaxPtr+(i+1)*nbOfComp,aMinPtr,res,std::plus<int>());
10205 ret->copyStringInfoFrom(*aMax);
10208 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Add !");
10211 throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array Add !");
10216 * Adds values of another DataArrayInt to values of \a this one. There are 3
10218 * 1. The arrays have same number of tuples and components. Then each value of
10219 * \a other array is added to the corresponding value of \a this array, i.e.:
10220 * _a_ [ i, j ] += _other_ [ i, j ].
10221 * 2. The arrays have same number of tuples and \a other array has one component. Then
10222 * _a_ [ i, j ] += _other_ [ i, 0 ].
10223 * 3. The arrays have same number of components and \a other array has one tuple. Then
10224 * _a_ [ i, j ] += _a2_ [ 0, j ].
10226 * \param [in] other - an array to add to \a this one.
10227 * \throw If \a other is NULL.
10228 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
10229 * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
10230 * \a other has number of both tuples and components not equal to 1.
10232 void DataArrayInt::addEqual(const DataArrayInt *other)
10235 throw INTERP_KERNEL::Exception("DataArrayInt::addEqual : input DataArrayInt instance is NULL !");
10236 const char *msg="Nb of tuples mismatch for DataArrayInt::addEqual !";
10237 checkAllocated(); other->checkAllocated();
10238 int nbOfTuple=getNumberOfTuples();
10239 int nbOfTuple2=other->getNumberOfTuples();
10240 int nbOfComp=getNumberOfComponents();
10241 int nbOfComp2=other->getNumberOfComponents();
10242 if(nbOfTuple==nbOfTuple2)
10244 if(nbOfComp==nbOfComp2)
10246 std::transform(begin(),end(),other->begin(),getPointer(),std::plus<int>());
10248 else if(nbOfComp2==1)
10250 int *ptr=getPointer();
10251 const int *ptrc=other->getConstPointer();
10252 for(int i=0;i<nbOfTuple;i++)
10253 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::plus<int>(),*ptrc++));
10256 throw INTERP_KERNEL::Exception(msg);
10258 else if(nbOfTuple2==1)
10260 if(nbOfComp2==nbOfComp)
10262 int *ptr=getPointer();
10263 const int *ptrc=other->getConstPointer();
10264 for(int i=0;i<nbOfTuple;i++)
10265 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::plus<int>());
10268 throw INTERP_KERNEL::Exception(msg);
10271 throw INTERP_KERNEL::Exception(msg);
10276 * Returns a new DataArrayInt that is a subtraction of two given arrays. There are 3
10278 * 1. The arrays have same number of tuples and components. Then each value of
10279 * the result array (_a_) is a subtraction of the corresponding values of \a a1 and
10280 * \a a2, i.e.: _a_ [ i, j ] = _a1_ [ i, j ] - _a2_ [ i, j ].
10281 * 2. The arrays have same number of tuples and one array, say _a2_, has one
10283 * _a_ [ i, j ] = _a1_ [ i, j ] - _a2_ [ i, 0 ].
10284 * 3. The arrays have same number of components and one array, say _a2_, has one
10286 * _a_ [ i, j ] = _a1_ [ i, j ] - _a2_ [ 0, j ].
10288 * Info on components is copied either from the first array (in the first case) or from
10289 * the array with maximal number of elements (getNbOfElems()).
10290 * \param [in] a1 - an array to subtract from.
10291 * \param [in] a2 - an array to subtract.
10292 * \return DataArrayInt * - the new instance of DataArrayInt.
10293 * The caller is to delete this result array using decrRef() as it is no more
10295 * \throw If either \a a1 or \a a2 is NULL.
10296 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
10297 * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
10298 * none of them has number of tuples or components equal to 1.
10300 DataArrayInt *DataArrayInt::Substract(const DataArrayInt *a1, const DataArrayInt *a2)
10303 throw INTERP_KERNEL::Exception("DataArrayInt::Substract : input DataArrayInt instance is NULL !");
10304 int nbOfTuple1=a1->getNumberOfTuples();
10305 int nbOfTuple2=a2->getNumberOfTuples();
10306 int nbOfComp1=a1->getNumberOfComponents();
10307 int nbOfComp2=a2->getNumberOfComponents();
10308 if(nbOfTuple2==nbOfTuple1)
10310 if(nbOfComp1==nbOfComp2)
10312 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
10313 ret->alloc(nbOfTuple2,nbOfComp1);
10314 std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::minus<int>());
10315 ret->copyStringInfoFrom(*a1);
10318 else if(nbOfComp2==1)
10320 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
10321 ret->alloc(nbOfTuple1,nbOfComp1);
10322 const int *a2Ptr=a2->getConstPointer();
10323 const int *a1Ptr=a1->getConstPointer();
10324 int *res=ret->getPointer();
10325 for(int i=0;i<nbOfTuple1;i++)
10326 res=std::transform(a1Ptr+i*nbOfComp1,a1Ptr+(i+1)*nbOfComp1,res,std::bind2nd(std::minus<int>(),a2Ptr[i]));
10327 ret->copyStringInfoFrom(*a1);
10332 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Substract !");
10336 else if(nbOfTuple2==1)
10338 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Substract !");
10339 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
10340 ret->alloc(nbOfTuple1,nbOfComp1);
10341 const int *a1ptr=a1->getConstPointer(),*a2ptr=a2->getConstPointer();
10342 int *pt=ret->getPointer();
10343 for(int i=0;i<nbOfTuple1;i++)
10344 pt=std::transform(a1ptr+i*nbOfComp1,a1ptr+(i+1)*nbOfComp1,a2ptr,pt,std::minus<int>());
10345 ret->copyStringInfoFrom(*a1);
10350 a1->checkNbOfTuples(nbOfTuple2,"Nb of tuples mismatch for array Substract !");//will always throw an exception
10356 * Subtract values of another DataArrayInt from values of \a this one. There are 3
10358 * 1. The arrays have same number of tuples and components. Then each value of
10359 * \a other array is subtracted from the corresponding value of \a this array, i.e.:
10360 * _a_ [ i, j ] -= _other_ [ i, j ].
10361 * 2. The arrays have same number of tuples and \a other array has one component. Then
10362 * _a_ [ i, j ] -= _other_ [ i, 0 ].
10363 * 3. The arrays have same number of components and \a other array has one tuple. Then
10364 * _a_ [ i, j ] -= _a2_ [ 0, j ].
10366 * \param [in] other - an array to subtract from \a this one.
10367 * \throw If \a other is NULL.
10368 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
10369 * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
10370 * \a other has number of both tuples and components not equal to 1.
10372 void DataArrayInt::substractEqual(const DataArrayInt *other)
10375 throw INTERP_KERNEL::Exception("DataArrayInt::substractEqual : input DataArrayInt instance is NULL !");
10376 const char *msg="Nb of tuples mismatch for DataArrayInt::substractEqual !";
10377 checkAllocated(); other->checkAllocated();
10378 int nbOfTuple=getNumberOfTuples();
10379 int nbOfTuple2=other->getNumberOfTuples();
10380 int nbOfComp=getNumberOfComponents();
10381 int nbOfComp2=other->getNumberOfComponents();
10382 if(nbOfTuple==nbOfTuple2)
10384 if(nbOfComp==nbOfComp2)
10386 std::transform(begin(),end(),other->begin(),getPointer(),std::minus<int>());
10388 else if(nbOfComp2==1)
10390 int *ptr=getPointer();
10391 const int *ptrc=other->getConstPointer();
10392 for(int i=0;i<nbOfTuple;i++)
10393 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::minus<int>(),*ptrc++));
10396 throw INTERP_KERNEL::Exception(msg);
10398 else if(nbOfTuple2==1)
10400 int *ptr=getPointer();
10401 const int *ptrc=other->getConstPointer();
10402 for(int i=0;i<nbOfTuple;i++)
10403 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::minus<int>());
10406 throw INTERP_KERNEL::Exception(msg);
10411 * Returns a new DataArrayInt that is a product of two given arrays. There are 3
10413 * 1. The arrays have same number of tuples and components. Then each value of
10414 * the result array (_a_) is a product of the corresponding values of \a a1 and
10415 * \a a2, i.e.: _a_ [ i, j ] = _a1_ [ i, j ] * _a2_ [ i, j ].
10416 * 2. The arrays have same number of tuples and one array, say _a2_, has one
10418 * _a_ [ i, j ] = _a1_ [ i, j ] * _a2_ [ i, 0 ].
10419 * 3. The arrays have same number of components and one array, say _a2_, has one
10421 * _a_ [ i, j ] = _a1_ [ i, j ] * _a2_ [ 0, j ].
10423 * Info on components is copied either from the first array (in the first case) or from
10424 * the array with maximal number of elements (getNbOfElems()).
10425 * \param [in] a1 - a factor array.
10426 * \param [in] a2 - another factor array.
10427 * \return DataArrayInt * - the new instance of DataArrayInt.
10428 * The caller is to delete this result array using decrRef() as it is no more
10430 * \throw If either \a a1 or \a a2 is NULL.
10431 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
10432 * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
10433 * none of them has number of tuples or components equal to 1.
10435 DataArrayInt *DataArrayInt::Multiply(const DataArrayInt *a1, const DataArrayInt *a2)
10438 throw INTERP_KERNEL::Exception("DataArrayInt::Multiply : input DataArrayInt instance is NULL !");
10439 int nbOfTuple=a1->getNumberOfTuples();
10440 int nbOfTuple2=a2->getNumberOfTuples();
10441 int nbOfComp=a1->getNumberOfComponents();
10442 int nbOfComp2=a2->getNumberOfComponents();
10443 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=0;
10444 if(nbOfTuple==nbOfTuple2)
10446 if(nbOfComp==nbOfComp2)
10448 ret=DataArrayInt::New();
10449 ret->alloc(nbOfTuple,nbOfComp);
10450 std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::multiplies<int>());
10451 ret->copyStringInfoFrom(*a1);
10455 int nbOfCompMin,nbOfCompMax;
10456 const DataArrayInt *aMin, *aMax;
10457 if(nbOfComp>nbOfComp2)
10459 nbOfCompMin=nbOfComp2; nbOfCompMax=nbOfComp;
10464 nbOfCompMin=nbOfComp; nbOfCompMax=nbOfComp2;
10469 ret=DataArrayInt::New();
10470 ret->alloc(nbOfTuple,nbOfCompMax);
10471 const int *aMinPtr=aMin->getConstPointer();
10472 const int *aMaxPtr=aMax->getConstPointer();
10473 int *res=ret->getPointer();
10474 for(int i=0;i<nbOfTuple;i++)
10475 res=std::transform(aMaxPtr+i*nbOfCompMax,aMaxPtr+(i+1)*nbOfCompMax,res,std::bind2nd(std::multiplies<int>(),aMinPtr[i]));
10476 ret->copyStringInfoFrom(*aMax);
10479 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Multiply !");
10482 else if((nbOfTuple==1 && nbOfTuple2>1) || (nbOfTuple>1 && nbOfTuple2==1))
10484 if(nbOfComp==nbOfComp2)
10486 int nbOfTupleMax=std::max(nbOfTuple,nbOfTuple2);
10487 const DataArrayInt *aMin=nbOfTuple>nbOfTuple2?a2:a1;
10488 const DataArrayInt *aMax=nbOfTuple>nbOfTuple2?a1:a2;
10489 const int *aMinPtr=aMin->getConstPointer(),*aMaxPtr=aMax->getConstPointer();
10490 ret=DataArrayInt::New();
10491 ret->alloc(nbOfTupleMax,nbOfComp);
10492 int *res=ret->getPointer();
10493 for(int i=0;i<nbOfTupleMax;i++)
10494 res=std::transform(aMaxPtr+i*nbOfComp,aMaxPtr+(i+1)*nbOfComp,aMinPtr,res,std::multiplies<int>());
10495 ret->copyStringInfoFrom(*aMax);
10498 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Multiply !");
10501 throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array Multiply !");
10507 * Multiply values of another DataArrayInt to values of \a this one. There are 3
10509 * 1. The arrays have same number of tuples and components. Then each value of
10510 * \a other array is multiplied to the corresponding value of \a this array, i.e.:
10511 * _a_ [ i, j ] *= _other_ [ i, j ].
10512 * 2. The arrays have same number of tuples and \a other array has one component. Then
10513 * _a_ [ i, j ] *= _other_ [ i, 0 ].
10514 * 3. The arrays have same number of components and \a other array has one tuple. Then
10515 * _a_ [ i, j ] *= _a2_ [ 0, j ].
10517 * \param [in] other - an array to multiply to \a this one.
10518 * \throw If \a other is NULL.
10519 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
10520 * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
10521 * \a other has number of both tuples and components not equal to 1.
10523 void DataArrayInt::multiplyEqual(const DataArrayInt *other)
10526 throw INTERP_KERNEL::Exception("DataArrayInt::multiplyEqual : input DataArrayInt instance is NULL !");
10527 const char *msg="Nb of tuples mismatch for DataArrayInt::multiplyEqual !";
10528 checkAllocated(); other->checkAllocated();
10529 int nbOfTuple=getNumberOfTuples();
10530 int nbOfTuple2=other->getNumberOfTuples();
10531 int nbOfComp=getNumberOfComponents();
10532 int nbOfComp2=other->getNumberOfComponents();
10533 if(nbOfTuple==nbOfTuple2)
10535 if(nbOfComp==nbOfComp2)
10537 std::transform(begin(),end(),other->begin(),getPointer(),std::multiplies<int>());
10539 else if(nbOfComp2==1)
10541 int *ptr=getPointer();
10542 const int *ptrc=other->getConstPointer();
10543 for(int i=0;i<nbOfTuple;i++)
10544 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::multiplies<int>(),*ptrc++));
10547 throw INTERP_KERNEL::Exception(msg);
10549 else if(nbOfTuple2==1)
10551 if(nbOfComp2==nbOfComp)
10553 int *ptr=getPointer();
10554 const int *ptrc=other->getConstPointer();
10555 for(int i=0;i<nbOfTuple;i++)
10556 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::multiplies<int>());
10559 throw INTERP_KERNEL::Exception(msg);
10562 throw INTERP_KERNEL::Exception(msg);
10568 * Returns a new DataArrayInt that is a division of two given arrays. There are 3
10570 * 1. The arrays have same number of tuples and components. Then each value of
10571 * the result array (_a_) is a division of the corresponding values of \a a1 and
10572 * \a a2, i.e.: _a_ [ i, j ] = _a1_ [ i, j ] / _a2_ [ i, j ].
10573 * 2. The arrays have same number of tuples and one array, say _a2_, has one
10575 * _a_ [ i, j ] = _a1_ [ i, j ] / _a2_ [ i, 0 ].
10576 * 3. The arrays have same number of components and one array, say _a2_, has one
10578 * _a_ [ i, j ] = _a1_ [ i, j ] / _a2_ [ 0, j ].
10580 * Info on components is copied either from the first array (in the first case) or from
10581 * the array with maximal number of elements (getNbOfElems()).
10582 * \warning No check of division by zero is performed!
10583 * \param [in] a1 - a numerator array.
10584 * \param [in] a2 - a denominator array.
10585 * \return DataArrayInt * - the new instance of DataArrayInt.
10586 * The caller is to delete this result array using decrRef() as it is no more
10588 * \throw If either \a a1 or \a a2 is NULL.
10589 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
10590 * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
10591 * none of them has number of tuples or components equal to 1.
10593 DataArrayInt *DataArrayInt::Divide(const DataArrayInt *a1, const DataArrayInt *a2)
10596 throw INTERP_KERNEL::Exception("DataArrayInt::Divide : input DataArrayInt instance is NULL !");
10597 int nbOfTuple1=a1->getNumberOfTuples();
10598 int nbOfTuple2=a2->getNumberOfTuples();
10599 int nbOfComp1=a1->getNumberOfComponents();
10600 int nbOfComp2=a2->getNumberOfComponents();
10601 if(nbOfTuple2==nbOfTuple1)
10603 if(nbOfComp1==nbOfComp2)
10605 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
10606 ret->alloc(nbOfTuple2,nbOfComp1);
10607 std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::divides<int>());
10608 ret->copyStringInfoFrom(*a1);
10611 else if(nbOfComp2==1)
10613 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
10614 ret->alloc(nbOfTuple1,nbOfComp1);
10615 const int *a2Ptr=a2->getConstPointer();
10616 const int *a1Ptr=a1->getConstPointer();
10617 int *res=ret->getPointer();
10618 for(int i=0;i<nbOfTuple1;i++)
10619 res=std::transform(a1Ptr+i*nbOfComp1,a1Ptr+(i+1)*nbOfComp1,res,std::bind2nd(std::divides<int>(),a2Ptr[i]));
10620 ret->copyStringInfoFrom(*a1);
10625 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Divide !");
10629 else if(nbOfTuple2==1)
10631 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Divide !");
10632 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
10633 ret->alloc(nbOfTuple1,nbOfComp1);
10634 const int *a1ptr=a1->getConstPointer(),*a2ptr=a2->getConstPointer();
10635 int *pt=ret->getPointer();
10636 for(int i=0;i<nbOfTuple1;i++)
10637 pt=std::transform(a1ptr+i*nbOfComp1,a1ptr+(i+1)*nbOfComp1,a2ptr,pt,std::divides<int>());
10638 ret->copyStringInfoFrom(*a1);
10643 a1->checkNbOfTuples(nbOfTuple2,"Nb of tuples mismatch for array Divide !");//will always throw an exception
10649 * Divide values of \a this array by values of another DataArrayInt. There are 3
10651 * 1. The arrays have same number of tuples and components. Then each value of
10652 * \a this array is divided by the corresponding value of \a other one, i.e.:
10653 * _a_ [ i, j ] /= _other_ [ i, j ].
10654 * 2. The arrays have same number of tuples and \a other array has one component. Then
10655 * _a_ [ i, j ] /= _other_ [ i, 0 ].
10656 * 3. The arrays have same number of components and \a other array has one tuple. Then
10657 * _a_ [ i, j ] /= _a2_ [ 0, j ].
10659 * \warning No check of division by zero is performed!
10660 * \param [in] other - an array to divide \a this one by.
10661 * \throw If \a other is NULL.
10662 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
10663 * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
10664 * \a other has number of both tuples and components not equal to 1.
10666 void DataArrayInt::divideEqual(const DataArrayInt *other)
10669 throw INTERP_KERNEL::Exception("DataArrayInt::divideEqual : input DataArrayInt instance is NULL !");
10670 const char *msg="Nb of tuples mismatch for DataArrayInt::divideEqual !";
10671 checkAllocated(); other->checkAllocated();
10672 int nbOfTuple=getNumberOfTuples();
10673 int nbOfTuple2=other->getNumberOfTuples();
10674 int nbOfComp=getNumberOfComponents();
10675 int nbOfComp2=other->getNumberOfComponents();
10676 if(nbOfTuple==nbOfTuple2)
10678 if(nbOfComp==nbOfComp2)
10680 std::transform(begin(),end(),other->begin(),getPointer(),std::divides<int>());
10682 else if(nbOfComp2==1)
10684 int *ptr=getPointer();
10685 const int *ptrc=other->getConstPointer();
10686 for(int i=0;i<nbOfTuple;i++)
10687 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::divides<int>(),*ptrc++));
10690 throw INTERP_KERNEL::Exception(msg);
10692 else if(nbOfTuple2==1)
10694 if(nbOfComp2==nbOfComp)
10696 int *ptr=getPointer();
10697 const int *ptrc=other->getConstPointer();
10698 for(int i=0;i<nbOfTuple;i++)
10699 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::divides<int>());
10702 throw INTERP_KERNEL::Exception(msg);
10705 throw INTERP_KERNEL::Exception(msg);
10711 * Returns a new DataArrayInt that is a modulus of two given arrays. There are 3
10713 * 1. The arrays have same number of tuples and components. Then each value of
10714 * the result array (_a_) is a division of the corresponding values of \a a1 and
10715 * \a a2, i.e.: _a_ [ i, j ] = _a1_ [ i, j ] % _a2_ [ i, j ].
10716 * 2. The arrays have same number of tuples and one array, say _a2_, has one
10718 * _a_ [ i, j ] = _a1_ [ i, j ] % _a2_ [ i, 0 ].
10719 * 3. The arrays have same number of components and one array, say _a2_, has one
10721 * _a_ [ i, j ] = _a1_ [ i, j ] % _a2_ [ 0, j ].
10723 * Info on components is copied either from the first array (in the first case) or from
10724 * the array with maximal number of elements (getNbOfElems()).
10725 * \warning No check of division by zero is performed!
10726 * \param [in] a1 - a dividend array.
10727 * \param [in] a2 - a divisor array.
10728 * \return DataArrayInt * - the new instance of DataArrayInt.
10729 * The caller is to delete this result array using decrRef() as it is no more
10731 * \throw If either \a a1 or \a a2 is NULL.
10732 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
10733 * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
10734 * none of them has number of tuples or components equal to 1.
10736 DataArrayInt *DataArrayInt::Modulus(const DataArrayInt *a1, const DataArrayInt *a2)
10739 throw INTERP_KERNEL::Exception("DataArrayInt::Modulus : input DataArrayInt instance is NULL !");
10740 int nbOfTuple1=a1->getNumberOfTuples();
10741 int nbOfTuple2=a2->getNumberOfTuples();
10742 int nbOfComp1=a1->getNumberOfComponents();
10743 int nbOfComp2=a2->getNumberOfComponents();
10744 if(nbOfTuple2==nbOfTuple1)
10746 if(nbOfComp1==nbOfComp2)
10748 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
10749 ret->alloc(nbOfTuple2,nbOfComp1);
10750 std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::modulus<int>());
10751 ret->copyStringInfoFrom(*a1);
10754 else if(nbOfComp2==1)
10756 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
10757 ret->alloc(nbOfTuple1,nbOfComp1);
10758 const int *a2Ptr=a2->getConstPointer();
10759 const int *a1Ptr=a1->getConstPointer();
10760 int *res=ret->getPointer();
10761 for(int i=0;i<nbOfTuple1;i++)
10762 res=std::transform(a1Ptr+i*nbOfComp1,a1Ptr+(i+1)*nbOfComp1,res,std::bind2nd(std::modulus<int>(),a2Ptr[i]));
10763 ret->copyStringInfoFrom(*a1);
10768 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Modulus !");
10772 else if(nbOfTuple2==1)
10774 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Modulus !");
10775 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
10776 ret->alloc(nbOfTuple1,nbOfComp1);
10777 const int *a1ptr=a1->getConstPointer(),*a2ptr=a2->getConstPointer();
10778 int *pt=ret->getPointer();
10779 for(int i=0;i<nbOfTuple1;i++)
10780 pt=std::transform(a1ptr+i*nbOfComp1,a1ptr+(i+1)*nbOfComp1,a2ptr,pt,std::modulus<int>());
10781 ret->copyStringInfoFrom(*a1);
10786 a1->checkNbOfTuples(nbOfTuple2,"Nb of tuples mismatch for array Modulus !");//will always throw an exception
10792 * Modify \a this array so that each value becomes a modulus of division of this value by
10793 * a value of another DataArrayInt. There are 3 valid cases.
10794 * 1. The arrays have same number of tuples and components. Then each value of
10795 * \a this array is divided by the corresponding value of \a other one, i.e.:
10796 * _a_ [ i, j ] %= _other_ [ i, j ].
10797 * 2. The arrays have same number of tuples and \a other array has one component. Then
10798 * _a_ [ i, j ] %= _other_ [ i, 0 ].
10799 * 3. The arrays have same number of components and \a other array has one tuple. Then
10800 * _a_ [ i, j ] %= _a2_ [ 0, j ].
10802 * \warning No check of division by zero is performed!
10803 * \param [in] other - a divisor array.
10804 * \throw If \a other is NULL.
10805 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
10806 * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
10807 * \a other has number of both tuples and components not equal to 1.
10809 void DataArrayInt::modulusEqual(const DataArrayInt *other)
10812 throw INTERP_KERNEL::Exception("DataArrayInt::modulusEqual : input DataArrayInt instance is NULL !");
10813 const char *msg="Nb of tuples mismatch for DataArrayInt::modulusEqual !";
10814 checkAllocated(); other->checkAllocated();
10815 int nbOfTuple=getNumberOfTuples();
10816 int nbOfTuple2=other->getNumberOfTuples();
10817 int nbOfComp=getNumberOfComponents();
10818 int nbOfComp2=other->getNumberOfComponents();
10819 if(nbOfTuple==nbOfTuple2)
10821 if(nbOfComp==nbOfComp2)
10823 std::transform(begin(),end(),other->begin(),getPointer(),std::modulus<int>());
10825 else if(nbOfComp2==1)
10827 if(nbOfComp2==nbOfComp)
10829 int *ptr=getPointer();
10830 const int *ptrc=other->getConstPointer();
10831 for(int i=0;i<nbOfTuple;i++)
10832 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::modulus<int>(),*ptrc++));
10835 throw INTERP_KERNEL::Exception(msg);
10838 throw INTERP_KERNEL::Exception(msg);
10840 else if(nbOfTuple2==1)
10842 int *ptr=getPointer();
10843 const int *ptrc=other->getConstPointer();
10844 for(int i=0;i<nbOfTuple;i++)
10845 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::modulus<int>());
10848 throw INTERP_KERNEL::Exception(msg);
10853 * Returns a new DataArrayInt that is the result of pow of two given arrays. There are 3
10856 * \param [in] a1 - an array to pow up.
10857 * \param [in] a2 - another array to sum up.
10858 * \return DataArrayInt * - the new instance of DataArrayInt.
10859 * The caller is to delete this result array using decrRef() as it is no more
10861 * \throw If either \a a1 or \a a2 is NULL.
10862 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
10863 * \throw If \a a1->getNumberOfComponents() != 1 or \a a2->getNumberOfComponents() != 1.
10864 * \throw If there is a negative value in \a a2.
10866 DataArrayInt *DataArrayInt::Pow(const DataArrayInt *a1, const DataArrayInt *a2)
10869 throw INTERP_KERNEL::Exception("DataArrayInt::Pow : at least one of input instances is null !");
10870 int nbOfTuple=a1->getNumberOfTuples();
10871 int nbOfTuple2=a2->getNumberOfTuples();
10872 int nbOfComp=a1->getNumberOfComponents();
10873 int nbOfComp2=a2->getNumberOfComponents();
10874 if(nbOfTuple!=nbOfTuple2)
10875 throw INTERP_KERNEL::Exception("DataArrayInt::Pow : number of tuples mismatches !");
10876 if(nbOfComp!=1 || nbOfComp2!=1)
10877 throw INTERP_KERNEL::Exception("DataArrayInt::Pow : number of components of both arrays must be equal to 1 !");
10878 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(nbOfTuple,1);
10879 const int *ptr1(a1->begin()),*ptr2(a2->begin());
10880 int *ptr=ret->getPointer();
10881 for(int i=0;i<nbOfTuple;i++,ptr1++,ptr2++,ptr++)
10886 for(int j=0;j<*ptr2;j++)
10892 std::ostringstream oss; oss << "DataArrayInt::Pow : on tuple #" << i << " of a2 value is < 0 (" << *ptr2 << ") !";
10893 throw INTERP_KERNEL::Exception(oss.str().c_str());
10900 * Apply pow on values of another DataArrayInt to values of \a this one.
10902 * \param [in] other - an array to pow to \a this one.
10903 * \throw If \a other is NULL.
10904 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples()
10905 * \throw If \a this->getNumberOfComponents() != 1 or \a other->getNumberOfComponents() != 1
10906 * \throw If there is a negative value in \a other.
10908 void DataArrayInt::powEqual(const DataArrayInt *other)
10911 throw INTERP_KERNEL::Exception("DataArrayInt::powEqual : input instance is null !");
10912 int nbOfTuple=getNumberOfTuples();
10913 int nbOfTuple2=other->getNumberOfTuples();
10914 int nbOfComp=getNumberOfComponents();
10915 int nbOfComp2=other->getNumberOfComponents();
10916 if(nbOfTuple!=nbOfTuple2)
10917 throw INTERP_KERNEL::Exception("DataArrayInt::powEqual : number of tuples mismatches !");
10918 if(nbOfComp!=1 || nbOfComp2!=1)
10919 throw INTERP_KERNEL::Exception("DataArrayInt::powEqual : number of components of both arrays must be equal to 1 !");
10920 int *ptr=getPointer();
10921 const int *ptrc=other->begin();
10922 for(int i=0;i<nbOfTuple;i++,ptrc++,ptr++)
10927 for(int j=0;j<*ptrc;j++)
10933 std::ostringstream oss; oss << "DataArrayInt::powEqual : on tuple #" << i << " of other value is < 0 (" << *ptrc << ") !";
10934 throw INTERP_KERNEL::Exception(oss.str().c_str());
10941 * Returns a C array which is a renumbering map in "Old to New" mode for the input array.
10942 * This map, if applied to \a start array, would make it sorted. For example, if
10943 * \a start array contents are [9,10,0,6,4,11,3,7] then the contents of the result array is
10944 * [5,6,0,3,2,7,1,4].
10945 * \param [in] start - pointer to the first element of the array for which the
10946 * permutation map is computed.
10947 * \param [in] end - pointer specifying the end of the array \a start, so that
10948 * the last value of \a start is \a end[ -1 ].
10949 * \return int * - the result permutation array that the caller is to delete as it is no
10951 * \throw If there are equal values in the input array.
10953 int *DataArrayInt::CheckAndPreparePermutation(const int *start, const int *end)
10955 std::size_t sz=std::distance(start,end);
10956 int *ret=(int *)malloc(sz*sizeof(int));
10957 int *work=new int[sz];
10958 std::copy(start,end,work);
10959 std::sort(work,work+sz);
10960 if(std::unique(work,work+sz)!=work+sz)
10964 throw INTERP_KERNEL::Exception("Some elements are equals in the specified array !");
10966 std::map<int,int> m;
10967 for(int *workPt=work;workPt!=work+sz;workPt++)
10968 m[*workPt]=(int)std::distance(work,workPt);
10970 for(const int *iter=start;iter!=end;iter++,iter2++)
10977 * Returns a new DataArrayInt containing an arithmetic progression
10978 * that is equal to the sequence returned by Python \c range(\a begin,\a end,\a step )
10980 * \param [in] begin - the start value of the result sequence.
10981 * \param [in] end - limiting value, so that every value of the result array is less than
10983 * \param [in] step - specifies the increment or decrement.
10984 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
10985 * array using decrRef() as it is no more needed.
10986 * \throw If \a step == 0.
10987 * \throw If \a end < \a begin && \a step > 0.
10988 * \throw If \a end > \a begin && \a step < 0.
10990 DataArrayInt *DataArrayInt::Range(int begin, int end, int step)
10992 int nbOfTuples=GetNumberOfItemGivenBESRelative(begin,end,step,"DataArrayInt::Range");
10993 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
10994 ret->alloc(nbOfTuples,1);
10995 int *ptr=ret->getPointer();
10998 for(int i=begin;i<end;i+=step,ptr++)
11003 for(int i=begin;i>end;i+=step,ptr++)
11010 * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
11013 void DataArrayInt::getTinySerializationIntInformation(std::vector<int>& tinyInfo) const
11015 tinyInfo.resize(2);
11018 tinyInfo[0]=getNumberOfTuples();
11019 tinyInfo[1]=getNumberOfComponents();
11029 * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
11032 void DataArrayInt::getTinySerializationStrInformation(std::vector<std::string>& tinyInfo) const
11036 int nbOfCompo=getNumberOfComponents();
11037 tinyInfo.resize(nbOfCompo+1);
11038 tinyInfo[0]=getName();
11039 for(int i=0;i<nbOfCompo;i++)
11040 tinyInfo[i+1]=getInfoOnComponent(i);
11044 tinyInfo.resize(1);
11045 tinyInfo[0]=getName();
11050 * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
11051 * This method returns if a feeding is needed.
11053 bool DataArrayInt::resizeForUnserialization(const std::vector<int>& tinyInfoI)
11055 int nbOfTuple=tinyInfoI[0];
11056 int nbOfComp=tinyInfoI[1];
11057 if(nbOfTuple!=-1 || nbOfComp!=-1)
11059 alloc(nbOfTuple,nbOfComp);
11066 * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
11067 * This method returns if a feeding is needed.
11069 void DataArrayInt::finishUnserialization(const std::vector<int>& tinyInfoI, const std::vector<std::string>& tinyInfoS)
11071 setName(tinyInfoS[0].c_str());
11074 int nbOfCompo=tinyInfoI[1];
11075 for(int i=0;i<nbOfCompo;i++)
11076 setInfoOnComponent(i,tinyInfoS[i+1].c_str());
11080 DataArrayIntIterator::DataArrayIntIterator(DataArrayInt *da):_da(da),_pt(0),_tuple_id(0),_nb_comp(0),_nb_tuple(0)
11085 if(_da->isAllocated())
11087 _nb_comp=da->getNumberOfComponents();
11088 _nb_tuple=da->getNumberOfTuples();
11089 _pt=da->getPointer();
11094 DataArrayIntIterator::~DataArrayIntIterator()
11100 DataArrayIntTuple *DataArrayIntIterator::nextt()
11102 if(_tuple_id<_nb_tuple)
11105 DataArrayIntTuple *ret=new DataArrayIntTuple(_pt,_nb_comp);
11113 DataArrayIntTuple::DataArrayIntTuple(int *pt, int nbOfComp):_pt(pt),_nb_of_compo(nbOfComp)
11117 std::string DataArrayIntTuple::repr() const
11119 std::ostringstream oss; oss << "(";
11120 for(int i=0;i<_nb_of_compo-1;i++)
11121 oss << _pt[i] << ", ";
11122 oss << _pt[_nb_of_compo-1] << ")";
11126 int DataArrayIntTuple::intValue() const
11128 if(_nb_of_compo==1)
11130 throw INTERP_KERNEL::Exception("DataArrayIntTuple::intValue : DataArrayIntTuple instance has not exactly 1 component -> Not possible to convert it into an integer !");
11134 * This method returns a newly allocated instance the caller should dealed with by a ParaMEDMEM::DataArrayInt::decrRef.
11135 * This method performs \b no copy of data. The content is only referenced using ParaMEDMEM::DataArrayInt::useArray with ownership set to \b false.
11136 * 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
11137 * \b nbOfCompo=1 and \bnbOfTuples==this->_nb_of_elem.
11139 DataArrayInt *DataArrayIntTuple::buildDAInt(int nbOfTuples, int nbOfCompo) const
11141 if((_nb_of_compo==nbOfCompo && nbOfTuples==1) || (_nb_of_compo==nbOfTuples && nbOfCompo==1))
11143 DataArrayInt *ret=DataArrayInt::New();
11144 ret->useExternalArrayWithRWAccess(_pt,nbOfTuples,nbOfCompo);
11149 std::ostringstream oss; oss << "DataArrayIntTuple::buildDAInt : unable to build a requested DataArrayInt instance with nbofTuple=" << nbOfTuples << " and nbOfCompo=" << nbOfCompo;
11150 oss << ".\nBecause the number of elements in this is " << _nb_of_compo << " !";
11151 throw INTERP_KERNEL::Exception(oss.str().c_str());