1 // Copyright (C) 2007-2014 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, or (at your option) any later version.
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 std::string& 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]));
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));
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 std::string& 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 std::string& 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 std::string& 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 std::string& 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 std::string& 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 std::string& 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 std::string& 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 std::string& 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 std::string& 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 std::string& 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 std::string& 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 std::string& 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 std::string& 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 std::string& 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 int *dest=ret->getPointer();
1352 // to make Visual C++ happy : instead of std::size_t nbOfVals=getNbOfElems(); std::copy(src,src+nbOfVals,dest);
1353 for(const double *src=begin();src!=end();src++,dest++)
1355 ret->copyStringInfoFrom(*this);
1360 * Returns a new DataArrayDouble holding the same values as \a this array but differently
1361 * arranged in memory. If \a this array holds 2 components of 3 values:
1362 * \f$ x_0,x_1,x_2,y_0,y_1,y_2 \f$, then the result array holds these values arranged
1363 * as follows: \f$ x_0,y_0,x_1,y_1,x_2,y_2 \f$.
1364 * \warning Do not confuse this method with transpose()!
1365 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1366 * is to delete using decrRef() as it is no more needed.
1367 * \throw If \a this is not allocated.
1369 DataArrayDouble *DataArrayDouble::fromNoInterlace() const
1372 throw INTERP_KERNEL::Exception("DataArrayDouble::fromNoInterlace : Not defined array !");
1373 double *tab=_mem.fromNoInterlace(getNumberOfComponents());
1374 DataArrayDouble *ret=DataArrayDouble::New();
1375 ret->useArray(tab,true,C_DEALLOC,getNumberOfTuples(),getNumberOfComponents());
1380 * Returns a new DataArrayDouble holding the same values as \a this array but differently
1381 * arranged in memory. If \a this array holds 2 components of 3 values:
1382 * \f$ x_0,y_0,x_1,y_1,x_2,y_2 \f$, then the result array holds these values arranged
1383 * as follows: \f$ x_0,x_1,x_2,y_0,y_1,y_2 \f$.
1384 * \warning Do not confuse this method with transpose()!
1385 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1386 * is to delete using decrRef() as it is no more needed.
1387 * \throw If \a this is not allocated.
1389 DataArrayDouble *DataArrayDouble::toNoInterlace() const
1392 throw INTERP_KERNEL::Exception("DataArrayDouble::toNoInterlace : Not defined array !");
1393 double *tab=_mem.toNoInterlace(getNumberOfComponents());
1394 DataArrayDouble *ret=DataArrayDouble::New();
1395 ret->useArray(tab,true,C_DEALLOC,getNumberOfTuples(),getNumberOfComponents());
1400 * Permutes values of \a this array as required by \a old2New array. The values are
1401 * permuted so that \c new[ \a old2New[ i ]] = \c old[ i ]. Number of tuples remains
1402 * the same as in \this one.
1403 * If a permutation reduction is needed, substr() or selectByTupleId() should be used.
1404 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
1405 * \param [in] old2New - C array of length equal to \a this->getNumberOfTuples()
1406 * giving a new position for i-th old value.
1408 void DataArrayDouble::renumberInPlace(const int *old2New)
1411 int nbTuples=getNumberOfTuples();
1412 int nbOfCompo=getNumberOfComponents();
1413 double *tmp=new double[nbTuples*nbOfCompo];
1414 const double *iptr=getConstPointer();
1415 for(int i=0;i<nbTuples;i++)
1418 if(v>=0 && v<nbTuples)
1419 std::copy(iptr+nbOfCompo*i,iptr+nbOfCompo*(i+1),tmp+nbOfCompo*v);
1422 std::ostringstream oss; oss << "DataArrayDouble::renumberInPlace : At place #" << i << " value is " << v << " ! Should be in [0," << nbTuples << ") !";
1423 throw INTERP_KERNEL::Exception(oss.str().c_str());
1426 std::copy(tmp,tmp+nbTuples*nbOfCompo,getPointer());
1432 * Permutes values of \a this array as required by \a new2Old array. The values are
1433 * permuted so that \c new[ i ] = \c old[ \a new2Old[ i ]]. Number of tuples remains
1434 * the same as in \this one.
1435 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
1436 * \param [in] new2Old - C array of length equal to \a this->getNumberOfTuples()
1437 * giving a previous position of i-th new value.
1438 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1439 * is to delete using decrRef() as it is no more needed.
1441 void DataArrayDouble::renumberInPlaceR(const int *new2Old)
1444 int nbTuples=getNumberOfTuples();
1445 int nbOfCompo=getNumberOfComponents();
1446 double *tmp=new double[nbTuples*nbOfCompo];
1447 const double *iptr=getConstPointer();
1448 for(int i=0;i<nbTuples;i++)
1451 if(v>=0 && v<nbTuples)
1452 std::copy(iptr+nbOfCompo*v,iptr+nbOfCompo*(v+1),tmp+nbOfCompo*i);
1455 std::ostringstream oss; oss << "DataArrayDouble::renumberInPlaceR : At place #" << i << " value is " << v << " ! Should be in [0," << nbTuples << ") !";
1456 throw INTERP_KERNEL::Exception(oss.str().c_str());
1459 std::copy(tmp,tmp+nbTuples*nbOfCompo,getPointer());
1465 * Returns a copy of \a this array with values permuted as required by \a old2New array.
1466 * The values are permuted so that \c new[ \a old2New[ i ]] = \c old[ i ].
1467 * Number of tuples in the result array remains the same as in \this one.
1468 * If a permutation reduction is needed, renumberAndReduce() should be used.
1469 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
1470 * \param [in] old2New - C array of length equal to \a this->getNumberOfTuples()
1471 * giving a new position for i-th old value.
1472 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1473 * is to delete using decrRef() as it is no more needed.
1474 * \throw If \a this is not allocated.
1476 DataArrayDouble *DataArrayDouble::renumber(const int *old2New) const
1479 int nbTuples=getNumberOfTuples();
1480 int nbOfCompo=getNumberOfComponents();
1481 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
1482 ret->alloc(nbTuples,nbOfCompo);
1483 ret->copyStringInfoFrom(*this);
1484 const double *iptr=getConstPointer();
1485 double *optr=ret->getPointer();
1486 for(int i=0;i<nbTuples;i++)
1487 std::copy(iptr+nbOfCompo*i,iptr+nbOfCompo*(i+1),optr+nbOfCompo*old2New[i]);
1488 ret->copyStringInfoFrom(*this);
1493 * Returns a copy of \a this array with values permuted as required by \a new2Old array.
1494 * The values are permuted so that \c new[ i ] = \c old[ \a new2Old[ i ]]. Number of
1495 * tuples in the result array remains the same as in \this one.
1496 * If a permutation reduction is needed, substr() or selectByTupleId() should be used.
1497 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
1498 * \param [in] new2Old - C array of length equal to \a this->getNumberOfTuples()
1499 * giving a previous position of i-th new value.
1500 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1501 * is to delete using decrRef() as it is no more needed.
1503 DataArrayDouble *DataArrayDouble::renumberR(const int *new2Old) const
1506 int nbTuples=getNumberOfTuples();
1507 int nbOfCompo=getNumberOfComponents();
1508 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
1509 ret->alloc(nbTuples,nbOfCompo);
1510 ret->copyStringInfoFrom(*this);
1511 const double *iptr=getConstPointer();
1512 double *optr=ret->getPointer();
1513 for(int i=0;i<nbTuples;i++)
1514 std::copy(iptr+nbOfCompo*new2Old[i],iptr+nbOfCompo*(new2Old[i]+1),optr+i*nbOfCompo);
1515 ret->copyStringInfoFrom(*this);
1520 * Returns a shorten and permuted copy of \a this array. The new DataArrayDouble is
1521 * of size \a newNbOfTuple and it's values are permuted as required by \a old2New array.
1522 * The values are permuted so that \c new[ \a old2New[ i ]] = \c old[ i ] for all
1523 * \a old2New[ i ] >= 0. In other words every i-th tuple in \a this array, for which
1524 * \a old2New[ i ] is negative, is missing from the result array.
1525 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
1526 * \param [in] old2New - C array of length equal to \a this->getNumberOfTuples()
1527 * giving a new position for i-th old tuple and giving negative position for
1528 * for i-th old tuple that should be omitted.
1529 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1530 * is to delete using decrRef() as it is no more needed.
1532 DataArrayDouble *DataArrayDouble::renumberAndReduce(const int *old2New, int newNbOfTuple) const
1535 int nbTuples=getNumberOfTuples();
1536 int nbOfCompo=getNumberOfComponents();
1537 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
1538 ret->alloc(newNbOfTuple,nbOfCompo);
1539 const double *iptr=getConstPointer();
1540 double *optr=ret->getPointer();
1541 for(int i=0;i<nbTuples;i++)
1545 std::copy(iptr+i*nbOfCompo,iptr+(i+1)*nbOfCompo,optr+w*nbOfCompo);
1547 ret->copyStringInfoFrom(*this);
1552 * Returns a shorten and permuted copy of \a this array. The new DataArrayDouble is
1553 * of size \a new2OldEnd - \a new2OldBg and it's values are permuted as required by
1554 * \a new2OldBg array.
1555 * The values are permuted so that \c new[ i ] = \c old[ \a new2OldBg[ i ]].
1556 * This method is equivalent to renumberAndReduce() except that convention in input is
1557 * \c new2old and \b not \c old2new.
1558 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
1559 * \param [in] new2OldBg - pointer to the beginning of a permutation array that gives a
1560 * tuple index in \a this array to fill the i-th tuple in the new array.
1561 * \param [in] new2OldEnd - specifies the end of the permutation array that starts at
1562 * \a new2OldBg, so that pointer to a tuple index (\a pi) varies as this:
1563 * \a new2OldBg <= \a pi < \a new2OldEnd.
1564 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1565 * is to delete using decrRef() as it is no more needed.
1567 DataArrayDouble *DataArrayDouble::selectByTupleId(const int *new2OldBg, const int *new2OldEnd) const
1570 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
1571 int nbComp=getNumberOfComponents();
1572 ret->alloc((int)std::distance(new2OldBg,new2OldEnd),nbComp);
1573 ret->copyStringInfoFrom(*this);
1574 double *pt=ret->getPointer();
1575 const double *srcPt=getConstPointer();
1577 for(const int *w=new2OldBg;w!=new2OldEnd;w++,i++)
1578 std::copy(srcPt+(*w)*nbComp,srcPt+((*w)+1)*nbComp,pt+i*nbComp);
1579 ret->copyStringInfoFrom(*this);
1584 * Returns a shorten and permuted copy of \a this array. The new DataArrayDouble is
1585 * of size \a new2OldEnd - \a new2OldBg and it's values are permuted as required by
1586 * \a new2OldBg array.
1587 * The values are permuted so that \c new[ i ] = \c old[ \a new2OldBg[ i ]].
1588 * This method is equivalent to renumberAndReduce() except that convention in input is
1589 * \c new2old and \b not \c old2new.
1590 * This method is equivalent to selectByTupleId() except that it prevents coping data
1591 * from behind the end of \a this array.
1592 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
1593 * \param [in] new2OldBg - pointer to the beginning of a permutation array that gives a
1594 * tuple index in \a this array to fill the i-th tuple in the new array.
1595 * \param [in] new2OldEnd - specifies the end of the permutation array that starts at
1596 * \a new2OldBg, so that pointer to a tuple index (\a pi) varies as this:
1597 * \a new2OldBg <= \a pi < \a new2OldEnd.
1598 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1599 * is to delete using decrRef() as it is no more needed.
1600 * \throw If \a new2OldEnd - \a new2OldBg > \a this->getNumberOfTuples().
1602 DataArrayDouble *DataArrayDouble::selectByTupleIdSafe(const int *new2OldBg, const int *new2OldEnd) const
1605 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
1606 int nbComp=getNumberOfComponents();
1607 int oldNbOfTuples=getNumberOfTuples();
1608 ret->alloc((int)std::distance(new2OldBg,new2OldEnd),nbComp);
1609 ret->copyStringInfoFrom(*this);
1610 double *pt=ret->getPointer();
1611 const double *srcPt=getConstPointer();
1613 for(const int *w=new2OldBg;w!=new2OldEnd;w++,i++)
1614 if(*w>=0 && *w<oldNbOfTuples)
1615 std::copy(srcPt+(*w)*nbComp,srcPt+((*w)+1)*nbComp,pt+i*nbComp);
1617 throw INTERP_KERNEL::Exception("DataArrayDouble::selectByTupleIdSafe : some ids has been detected to be out of [0,this->getNumberOfTuples) !");
1618 ret->copyStringInfoFrom(*this);
1623 * Returns a shorten copy of \a this array. The new DataArrayDouble contains every
1624 * (\a bg + \c i * \a step)-th tuple of \a this array located before the \a end2-th
1625 * tuple. Indices of the selected tuples are the same as ones returned by the Python
1626 * command \c range( \a bg, \a end2, \a step ).
1627 * This method is equivalent to selectByTupleIdSafe() except that the input array is
1628 * not constructed explicitly.
1629 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
1630 * \param [in] bg - index of the first tuple to copy from \a this array.
1631 * \param [in] end2 - index of the tuple before which the tuples to copy are located.
1632 * \param [in] step - index increment to get index of the next tuple to copy.
1633 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1634 * is to delete using decrRef() as it is no more needed.
1635 * \sa DataArrayDouble::substr.
1637 DataArrayDouble *DataArrayDouble::selectByTupleId2(int bg, int end2, int step) const
1640 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
1641 int nbComp=getNumberOfComponents();
1642 int newNbOfTuples=GetNumberOfItemGivenBESRelative(bg,end2,step,"DataArrayDouble::selectByTupleId2 : ");
1643 ret->alloc(newNbOfTuples,nbComp);
1644 double *pt=ret->getPointer();
1645 const double *srcPt=getConstPointer()+bg*nbComp;
1646 for(int i=0;i<newNbOfTuples;i++,srcPt+=step*nbComp)
1647 std::copy(srcPt,srcPt+nbComp,pt+i*nbComp);
1648 ret->copyStringInfoFrom(*this);
1653 * Returns a shorten copy of \a this array. The new DataArrayDouble contains ranges
1654 * of tuples specified by \a ranges parameter.
1655 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
1656 * \param [in] ranges - std::vector of std::pair's each of which defines a range
1657 * of tuples in [\c begin,\c end) format.
1658 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1659 * is to delete using decrRef() as it is no more needed.
1660 * \throw If \a end < \a begin.
1661 * \throw If \a end > \a this->getNumberOfTuples().
1662 * \throw If \a this is not allocated.
1664 DataArray *DataArrayDouble::selectByTupleRanges(const std::vector<std::pair<int,int> >& ranges) const
1667 int nbOfComp=getNumberOfComponents();
1668 int nbOfTuplesThis=getNumberOfTuples();
1671 DataArrayDouble *ret=DataArrayDouble::New();
1672 ret->alloc(0,nbOfComp);
1673 ret->copyStringInfoFrom(*this);
1676 int ref=ranges.front().first;
1678 bool isIncreasing=true;
1679 for(std::vector<std::pair<int,int> >::const_iterator it=ranges.begin();it!=ranges.end();it++)
1681 if((*it).first<=(*it).second)
1683 if((*it).first>=0 && (*it).second<=nbOfTuplesThis)
1685 nbOfTuples+=(*it).second-(*it).first;
1687 isIncreasing=ref<=(*it).first;
1692 std::ostringstream oss; oss << "DataArrayDouble::selectByTupleRanges : on range #" << std::distance(ranges.begin(),it);
1693 oss << " (" << (*it).first << "," << (*it).second << ") is greater than number of tuples of this :" << nbOfTuples << " !";
1694 throw INTERP_KERNEL::Exception(oss.str().c_str());
1699 std::ostringstream oss; oss << "DataArrayDouble::selectByTupleRanges : on range #" << std::distance(ranges.begin(),it);
1700 oss << " (" << (*it).first << "," << (*it).second << ") end is before begin !";
1701 throw INTERP_KERNEL::Exception(oss.str().c_str());
1704 if(isIncreasing && nbOfTuplesThis==nbOfTuples)
1706 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
1707 ret->alloc(nbOfTuples,nbOfComp);
1708 ret->copyStringInfoFrom(*this);
1709 const double *src=getConstPointer();
1710 double *work=ret->getPointer();
1711 for(std::vector<std::pair<int,int> >::const_iterator it=ranges.begin();it!=ranges.end();it++)
1712 work=std::copy(src+(*it).first*nbOfComp,src+(*it).second*nbOfComp,work);
1717 * Returns a shorten copy of \a this array. The new DataArrayDouble contains all
1718 * tuples starting from the \a tupleIdBg-th tuple and including all tuples located before
1719 * the \a tupleIdEnd-th one. This methods has a similar behavior as std::string::substr().
1720 * This method is a specialization of selectByTupleId2().
1721 * \param [in] tupleIdBg - index of the first tuple to copy from \a this array.
1722 * \param [in] tupleIdEnd - index of the tuple before which the tuples to copy are located.
1723 * If \a tupleIdEnd == -1, all the tuples till the end of \a this array are copied.
1724 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1725 * is to delete using decrRef() as it is no more needed.
1726 * \throw If \a tupleIdBg < 0.
1727 * \throw If \a tupleIdBg > \a this->getNumberOfTuples().
1728 \throw If \a tupleIdEnd != -1 && \a tupleIdEnd < \a this->getNumberOfTuples().
1729 * \sa DataArrayDouble::selectByTupleId2
1731 DataArrayDouble *DataArrayDouble::substr(int tupleIdBg, int tupleIdEnd) const
1734 int nbt=getNumberOfTuples();
1736 throw INTERP_KERNEL::Exception("DataArrayDouble::substr : The tupleIdBg parameter must be greater than 0 !");
1738 throw INTERP_KERNEL::Exception("DataArrayDouble::substr : The tupleIdBg parameter is greater than number of tuples !");
1739 int trueEnd=tupleIdEnd;
1743 throw INTERP_KERNEL::Exception("DataArrayDouble::substr : The tupleIdBg parameter is greater or equal than number of tuples !");
1747 int nbComp=getNumberOfComponents();
1748 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
1749 ret->alloc(trueEnd-tupleIdBg,nbComp);
1750 ret->copyStringInfoFrom(*this);
1751 std::copy(getConstPointer()+tupleIdBg*nbComp,getConstPointer()+trueEnd*nbComp,ret->getPointer());
1756 * Returns a shorten or extended copy of \a this array. If \a newNbOfComp is less
1757 * than \a this->getNumberOfComponents() then the result array is shorten as each tuple
1758 * is truncated to have \a newNbOfComp components, keeping first components. If \a
1759 * newNbOfComp is more than \a this->getNumberOfComponents() then the result array is
1760 * expanded as each tuple is populated with \a dftValue to have \a newNbOfComp
1762 * \param [in] newNbOfComp - number of components for the new array to have.
1763 * \param [in] dftValue - value assigned to new values added to the new array.
1764 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1765 * is to delete using decrRef() as it is no more needed.
1766 * \throw If \a this is not allocated.
1768 DataArrayDouble *DataArrayDouble::changeNbOfComponents(int newNbOfComp, double dftValue) const
1771 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
1772 ret->alloc(getNumberOfTuples(),newNbOfComp);
1773 const double *oldc=getConstPointer();
1774 double *nc=ret->getPointer();
1775 int nbOfTuples=getNumberOfTuples();
1776 int oldNbOfComp=getNumberOfComponents();
1777 int dim=std::min(oldNbOfComp,newNbOfComp);
1778 for(int i=0;i<nbOfTuples;i++)
1782 nc[newNbOfComp*i+j]=oldc[i*oldNbOfComp+j];
1783 for(;j<newNbOfComp;j++)
1784 nc[newNbOfComp*i+j]=dftValue;
1786 ret->setName(getName());
1787 for(int i=0;i<dim;i++)
1788 ret->setInfoOnComponent(i,getInfoOnComponent(i));
1789 ret->setName(getName());
1794 * Changes the number of components within \a this array so that its raw data **does
1795 * not** change, instead splitting this data into tuples changes.
1796 * \warning This method erases all (name and unit) component info set before!
1797 * \param [in] newNbOfComp - number of components for \a this array to have.
1798 * \throw If \a this is not allocated
1799 * \throw If getNbOfElems() % \a newNbOfCompo != 0.
1800 * \throw If \a newNbOfCompo is lower than 1.
1801 * \throw If the rearrange method would lead to a number of tuples higher than 2147483647 (maximal capacity of int32 !).
1802 * \warning This method erases all (name and unit) component info set before!
1804 void DataArrayDouble::rearrange(int newNbOfCompo)
1808 throw INTERP_KERNEL::Exception("DataArrayDouble::rearrange : input newNbOfCompo must be > 0 !");
1809 std::size_t nbOfElems=getNbOfElems();
1810 if(nbOfElems%newNbOfCompo!=0)
1811 throw INTERP_KERNEL::Exception("DataArrayDouble::rearrange : nbOfElems%newNbOfCompo!=0 !");
1812 if(nbOfElems/newNbOfCompo>(std::size_t)std::numeric_limits<int>::max())
1813 throw INTERP_KERNEL::Exception("DataArrayDouble::rearrange : the rearrangement leads to too high number of tuples (> 2147483647) !");
1814 _info_on_compo.clear();
1815 _info_on_compo.resize(newNbOfCompo);
1820 * Changes the number of components within \a this array to be equal to its number
1821 * of tuples, and inversely its number of tuples to become equal to its number of
1822 * components. So that its raw data **does not** change, instead splitting this
1823 * data into tuples changes.
1824 * \warning This method erases all (name and unit) component info set before!
1825 * \warning Do not confuse this method with fromNoInterlace() and toNoInterlace()!
1826 * \throw If \a this is not allocated.
1829 void DataArrayDouble::transpose()
1832 int nbOfTuples=getNumberOfTuples();
1833 rearrange(nbOfTuples);
1837 * Returns a copy of \a this array composed of selected components.
1838 * The new DataArrayDouble has the same number of tuples but includes components
1839 * specified by \a compoIds parameter. So that getNbOfElems() of the result array
1840 * can be either less, same or more than \a this->getNbOfElems().
1841 * \param [in] compoIds - sequence of zero based indices of components to include
1842 * into the new array.
1843 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1844 * is to delete using decrRef() as it is no more needed.
1845 * \throw If \a this is not allocated.
1846 * \throw If a component index (\a i) is not valid:
1847 * \a i < 0 || \a i >= \a this->getNumberOfComponents().
1849 * \ref py_mcdataarraydouble_KeepSelectedComponents "Here is a Python example".
1851 DataArray *DataArrayDouble::keepSelectedComponents(const std::vector<int>& compoIds) const
1854 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret(DataArrayDouble::New());
1855 std::size_t newNbOfCompo=compoIds.size();
1856 int oldNbOfCompo=getNumberOfComponents();
1857 for(std::vector<int>::const_iterator it=compoIds.begin();it!=compoIds.end();it++)
1858 if((*it)<0 || (*it)>=oldNbOfCompo)
1860 std::ostringstream oss; oss << "DataArrayDouble::keepSelectedComponents : invalid requested component : " << *it << " whereas it should be in [0," << oldNbOfCompo << ") !";
1861 throw INTERP_KERNEL::Exception(oss.str().c_str());
1863 int nbOfTuples=getNumberOfTuples();
1864 ret->alloc(nbOfTuples,(int)newNbOfCompo);
1865 ret->copyPartOfStringInfoFrom(*this,compoIds);
1866 const double *oldc=getConstPointer();
1867 double *nc=ret->getPointer();
1868 for(int i=0;i<nbOfTuples;i++)
1869 for(std::size_t j=0;j<newNbOfCompo;j++,nc++)
1870 *nc=oldc[i*oldNbOfCompo+compoIds[j]];
1875 * Appends components of another array to components of \a this one, tuple by tuple.
1876 * So that the number of tuples of \a this array remains the same and the number of
1877 * components increases.
1878 * \param [in] other - the DataArrayDouble to append to \a this one.
1879 * \throw If \a this is not allocated.
1880 * \throw If \a this and \a other arrays have different number of tuples.
1882 * \ref cpp_mcdataarraydouble_meldwith "Here is a C++ example".
1884 * \ref py_mcdataarraydouble_meldwith "Here is a Python example".
1886 void DataArrayDouble::meldWith(const DataArrayDouble *other)
1889 other->checkAllocated();
1890 int nbOfTuples=getNumberOfTuples();
1891 if(nbOfTuples!=other->getNumberOfTuples())
1892 throw INTERP_KERNEL::Exception("DataArrayDouble::meldWith : mismatch of number of tuples !");
1893 int nbOfComp1=getNumberOfComponents();
1894 int nbOfComp2=other->getNumberOfComponents();
1895 double *newArr=(double *)malloc((nbOfTuples*(nbOfComp1+nbOfComp2))*sizeof(double));
1897 const double *inp1=getConstPointer();
1898 const double *inp2=other->getConstPointer();
1899 for(int i=0;i<nbOfTuples;i++,inp1+=nbOfComp1,inp2+=nbOfComp2)
1901 w=std::copy(inp1,inp1+nbOfComp1,w);
1902 w=std::copy(inp2,inp2+nbOfComp2,w);
1904 useArray(newArr,true,C_DEALLOC,nbOfTuples,nbOfComp1+nbOfComp2);
1905 std::vector<int> compIds(nbOfComp2);
1906 for(int i=0;i<nbOfComp2;i++)
1907 compIds[i]=nbOfComp1+i;
1908 copyPartOfStringInfoFrom2(compIds,*other);
1912 * This method checks that all tuples in \a other are in \a this.
1913 * If true, the output param \a tupleIds contains the tuples ids of \a this that correspond to tupes in \a this.
1914 * 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.
1916 * \param [in] other - the array having the same number of components than \a this.
1917 * \param [out] tupleIds - the tuple ids containing the same number of tuples than \a other has.
1918 * \sa DataArrayDouble::findCommonTuples
1920 bool DataArrayDouble::areIncludedInMe(const DataArrayDouble *other, double prec, DataArrayInt *&tupleIds) const
1923 throw INTERP_KERNEL::Exception("DataArrayDouble::areIncludedInMe : input array is NULL !");
1924 checkAllocated(); other->checkAllocated();
1925 if(getNumberOfComponents()!=other->getNumberOfComponents())
1926 throw INTERP_KERNEL::Exception("DataArrayDouble::areIncludedInMe : the number of components does not match !");
1927 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> a=DataArrayDouble::Aggregate(this,other);
1928 DataArrayInt *c=0,*ci=0;
1929 a->findCommonTuples(prec,getNumberOfTuples(),c,ci);
1930 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> cSafe(c),ciSafe(ci);
1931 int newNbOfTuples=-1;
1932 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ids=DataArrayInt::BuildOld2NewArrayFromSurjectiveFormat2(a->getNumberOfTuples(),c->begin(),ci->begin(),ci->end(),newNbOfTuples);
1933 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret1=ids->selectByTupleId2(getNumberOfTuples(),a->getNumberOfTuples(),1);
1934 tupleIds=ret1.retn();
1935 return newNbOfTuples==getNumberOfTuples();
1939 * Searches for tuples coincident within \a prec tolerance. Each tuple is considered
1940 * as coordinates of a point in getNumberOfComponents()-dimensional space. The
1941 * distance separating two points is computed with the infinite norm.
1943 * Indices of coincident tuples are stored in output arrays.
1944 * A pair of arrays (\a comm, \a commIndex) is called "Surjective Format 2".
1946 * This method is typically used by MEDCouplingPointSet::findCommonNodes() and
1947 * MEDCouplingUMesh::mergeNodes().
1948 * \param [in] prec - minimal absolute distance between two tuples (infinite norm) at which they are
1949 * considered not coincident.
1950 * \param [in] limitTupleId - limit tuple id. If all tuples within a group of coincident
1951 * tuples have id strictly lower than \a limitTupleId then they are not returned.
1952 * \param [out] comm - the array holding ids (== indices) of coincident tuples.
1953 * \a comm->getNumberOfComponents() == 1.
1954 * \a comm->getNumberOfTuples() == \a commIndex->back().
1955 * \param [out] commIndex - the array dividing all indices stored in \a comm into
1956 * groups of (indices of) coincident tuples. Its every value is a tuple
1957 * index where a next group of tuples begins. For example the second
1958 * group of tuples in \a comm is described by following range of indices:
1959 * [ \a commIndex[1], \a commIndex[2] ). \a commIndex->getNumberOfTuples()-1
1960 * gives the number of groups of coincident tuples.
1961 * \throw If \a this is not allocated.
1962 * \throw If the number of components is not in [1,2,3,4].
1964 * \ref cpp_mcdataarraydouble_findcommontuples "Here is a C++ example".
1966 * \ref py_mcdataarraydouble_findcommontuples "Here is a Python example".
1967 * \sa DataArrayInt::BuildOld2NewArrayFromSurjectiveFormat2(), DataArrayDouble::areIncludedInMe
1969 void DataArrayDouble::findCommonTuples(double prec, int limitTupleId, DataArrayInt *&comm, DataArrayInt *&commIndex) const
1972 int nbOfCompo=getNumberOfComponents();
1973 if ((nbOfCompo<1) || (nbOfCompo>4)) //test before work
1974 throw INTERP_KERNEL::Exception("DataArrayDouble::findCommonTuples : Unexpected spacedim of coords. Must be 1, 2, 3 or 4.");
1976 int nbOfTuples=getNumberOfTuples();
1978 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> c(DataArrayInt::New()),cI(DataArrayInt::New()); c->alloc(0,1); cI->pushBackSilent(0);
1982 findCommonTuplesAlg<4>(begin(),nbOfTuples,limitTupleId,prec,c,cI);
1985 findCommonTuplesAlg<3>(begin(),nbOfTuples,limitTupleId,prec,c,cI);
1988 findCommonTuplesAlg<2>(begin(),nbOfTuples,limitTupleId,prec,c,cI);
1991 findCommonTuplesAlg<1>(begin(),nbOfTuples,limitTupleId,prec,c,cI);
1994 throw INTERP_KERNEL::Exception("DataArrayDouble::findCommonTuples : nb of components managed are 1,2,3 and 4 ! not implemented for other number of components !");
1997 commIndex=cI.retn();
2002 * \param [in] nbTimes specifies the nb of times each tuples in \a this will be duplicated contiguouly in returned DataArrayDouble instance.
2003 * \a nbTimes should be at least equal to 1.
2004 * \return a newly allocated DataArrayDouble having one component and number of tuples equal to \a nbTimes * \c this->getNumberOfTuples.
2005 * \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.
2007 DataArrayDouble *DataArrayDouble::duplicateEachTupleNTimes(int nbTimes) const
2010 if(getNumberOfComponents()!=1)
2011 throw INTERP_KERNEL::Exception("DataArrayDouble::duplicateEachTupleNTimes : this should have only one component !");
2013 throw INTERP_KERNEL::Exception("DataArrayDouble::duplicateEachTupleNTimes : nb times should be >= 1 !");
2014 int nbTuples=getNumberOfTuples();
2015 const double *inPtr=getConstPointer();
2016 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New(); ret->alloc(nbTimes*nbTuples,1);
2017 double *retPtr=ret->getPointer();
2018 for(int i=0;i<nbTuples;i++,inPtr++)
2021 for(int j=0;j<nbTimes;j++,retPtr++)
2024 ret->copyStringInfoFrom(*this);
2029 * This methods returns the minimal distance between the two set of points \a this and \a other.
2030 * So \a this and \a other have to have the same number of components. If not an INTERP_KERNEL::Exception will be thrown.
2031 * This method works only if number of components of \a this (equal to those of \a other) is in 1, 2 or 3.
2033 * \param [out] thisTupleId the tuple id in \a this corresponding to the returned minimal distance
2034 * \param [out] otherTupleId the tuple id in \a other corresponding to the returned minimal distance
2035 * \return the minimal distance between the two set of points \a this and \a other.
2036 * \sa DataArrayDouble::findClosestTupleId
2038 double DataArrayDouble::minimalDistanceTo(const DataArrayDouble *other, int& thisTupleId, int& otherTupleId) const
2040 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> part1=findClosestTupleId(other);
2041 int nbOfCompo(getNumberOfComponents());
2042 int otherNbTuples(other->getNumberOfTuples());
2043 const double *thisPt(begin()),*otherPt(other->begin());
2044 const int *part1Pt(part1->begin());
2045 double ret=std::numeric_limits<double>::max();
2046 for(int i=0;i<otherNbTuples;i++,part1Pt++,otherPt+=nbOfCompo)
2049 for(int j=0;j<nbOfCompo;j++)
2050 tmp+=(otherPt[j]-thisPt[nbOfCompo*(*part1Pt)+j])*(otherPt[j]-thisPt[nbOfCompo*(*part1Pt)+j]);
2052 { ret=tmp; thisTupleId=*part1Pt; otherTupleId=i; }
2058 * This methods returns for each tuple in \a other which tuple in \a this is the closest.
2059 * So \a this and \a other have to have the same number of components. If not an INTERP_KERNEL::Exception will be thrown.
2060 * This method works only if number of components of \a this (equal to those of \a other) is in 1, 2 or 3.
2062 * \return a newly allocated (new object to be dealt by the caller) DataArrayInt having \c other->getNumberOfTuples() tuples and one components.
2063 * \sa DataArrayDouble::minimalDistanceTo
2065 DataArrayInt *DataArrayDouble::findClosestTupleId(const DataArrayDouble *other) const
2068 throw INTERP_KERNEL::Exception("DataArrayDouble::findClosestTupleId : other instance is NULL !");
2069 checkAllocated(); other->checkAllocated();
2070 int nbOfCompo=getNumberOfComponents();
2071 if(nbOfCompo!=other->getNumberOfComponents())
2073 std::ostringstream oss; oss << "DataArrayDouble::findClosestTupleId : number of components in this is " << nbOfCompo;
2074 oss << ", whereas number of components in other is " << other->getNumberOfComponents() << "! Should be equal !";
2075 throw INTERP_KERNEL::Exception(oss.str().c_str());
2077 int nbOfTuples=other->getNumberOfTuples();
2078 int thisNbOfTuples=getNumberOfTuples();
2079 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(nbOfTuples,1);
2081 getMinMaxPerComponent(bounds);
2086 double xDelta(fabs(bounds[1]-bounds[0])),yDelta(fabs(bounds[3]-bounds[2])),zDelta(fabs(bounds[5]-bounds[4]));
2087 double delta=std::max(xDelta,yDelta); delta=std::max(delta,zDelta);
2088 double characSize=pow((delta*delta*delta)/((double)thisNbOfTuples),1./3.);
2089 BBTreePts<3,int> myTree(begin(),0,0,getNumberOfTuples(),characSize*1e-12);
2090 FindClosestTupleIdAlg<3>(myTree,3.*characSize*characSize,other->begin(),nbOfTuples,begin(),thisNbOfTuples,ret->getPointer());
2095 double xDelta(fabs(bounds[1]-bounds[0])),yDelta(fabs(bounds[3]-bounds[2]));
2096 double delta=std::max(xDelta,yDelta);
2097 double characSize=sqrt(delta/(double)thisNbOfTuples);
2098 BBTreePts<2,int> myTree(begin(),0,0,getNumberOfTuples(),characSize*1e-12);
2099 FindClosestTupleIdAlg<2>(myTree,2.*characSize*characSize,other->begin(),nbOfTuples,begin(),thisNbOfTuples,ret->getPointer());
2104 double characSize=fabs(bounds[1]-bounds[0])/thisNbOfTuples;
2105 BBTreePts<1,int> myTree(begin(),0,0,getNumberOfTuples(),characSize*1e-12);
2106 FindClosestTupleIdAlg<1>(myTree,1.*characSize*characSize,other->begin(),nbOfTuples,begin(),thisNbOfTuples,ret->getPointer());
2110 throw INTERP_KERNEL::Exception("Unexpected spacedim of coords for findClosestTupleId. Must be 1, 2 or 3.");
2116 * This method expects that \a this and \a otherBBoxFrmt arrays are bounding box arrays ( as the output of MEDCouplingPointSet::getBoundingBoxForBBTree method ).
2117 * 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
2118 * how many bounding boxes in \a otherBBoxFrmt.
2119 * So, this method expects that \a this and \a otherBBoxFrmt have the same number of components.
2121 * \param [in] otherBBoxFrmt - It is an array .
2122 * \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.
2123 * \sa MEDCouplingPointSet::getBoundingBoxForBBTree
2124 * \throw If \a this and \a otherBBoxFrmt have not the same number of components.
2125 * \throw If \a this and \a otherBBoxFrmt number of components is not even (BBox format).
2127 DataArrayInt *DataArrayDouble::computeNbOfInteractionsWith(const DataArrayDouble *otherBBoxFrmt, double eps) const
2130 throw INTERP_KERNEL::Exception("DataArrayDouble::computeNbOfInteractionsWith : input array is NULL !");
2131 if(!isAllocated() || !otherBBoxFrmt->isAllocated())
2132 throw INTERP_KERNEL::Exception("DataArrayDouble::computeNbOfInteractionsWith : this and input array must be allocated !");
2133 int nbOfComp(getNumberOfComponents()),nbOfTuples(getNumberOfTuples());
2134 if(nbOfComp!=otherBBoxFrmt->getNumberOfComponents())
2136 std::ostringstream oss; oss << "DataArrayDouble::computeNbOfInteractionsWith : this number of components (" << nbOfComp << ") must be equal to the number of components of input array (" << otherBBoxFrmt->getNumberOfComponents() << ") !";
2137 throw INTERP_KERNEL::Exception(oss.str().c_str());
2141 std::ostringstream oss; oss << "DataArrayDouble::computeNbOfInteractionsWith : Number of components (" << nbOfComp << ") is not even ! It should be to be compatible with bbox format !";
2142 throw INTERP_KERNEL::Exception(oss.str().c_str());
2144 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(nbOfTuples,1);
2145 const double *thisBBPtr(begin());
2146 int *retPtr(ret->getPointer());
2151 BBTree<3,int> bbt(otherBBoxFrmt->begin(),0,0,otherBBoxFrmt->getNumberOfTuples(),eps);
2152 for(int i=0;i<nbOfTuples;i++,retPtr++,thisBBPtr+=nbOfComp)
2153 *retPtr=bbt.getNbOfIntersectingElems(thisBBPtr);
2158 BBTree<2,int> bbt(otherBBoxFrmt->begin(),0,0,otherBBoxFrmt->getNumberOfTuples(),eps);
2159 for(int i=0;i<nbOfTuples;i++,retPtr++,thisBBPtr+=nbOfComp)
2160 *retPtr=bbt.getNbOfIntersectingElems(thisBBPtr);
2165 BBTree<1,int> bbt(otherBBoxFrmt->begin(),0,0,otherBBoxFrmt->getNumberOfTuples(),eps);
2166 for(int i=0;i<nbOfTuples;i++,retPtr++,thisBBPtr+=nbOfComp)
2167 *retPtr=bbt.getNbOfIntersectingElems(thisBBPtr);
2171 throw INTERP_KERNEL::Exception("DataArrayDouble::computeNbOfInteractionsWith : space dimension supported are [1,2,3] !");
2178 * Returns a copy of \a this array by excluding coincident tuples. Each tuple is
2179 * considered as coordinates of a point in getNumberOfComponents()-dimensional
2180 * space. The distance between tuples is computed using norm2. If several tuples are
2181 * not far each from other than \a prec, only one of them remains in the result
2182 * array. The order of tuples in the result array is same as in \a this one except
2183 * that coincident tuples are excluded.
2184 * \param [in] prec - minimal absolute distance between two tuples at which they are
2185 * considered not coincident.
2186 * \param [in] limitTupleId - limit tuple id. If all tuples within a group of coincident
2187 * tuples have id strictly lower than \a limitTupleId then they are not excluded.
2188 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
2189 * is to delete using decrRef() as it is no more needed.
2190 * \throw If \a this is not allocated.
2191 * \throw If the number of components is not in [1,2,3,4].
2193 * \ref py_mcdataarraydouble_getdifferentvalues "Here is a Python example".
2195 DataArrayDouble *DataArrayDouble::getDifferentValues(double prec, int limitTupleId) const
2198 DataArrayInt *c0=0,*cI0=0;
2199 findCommonTuples(prec,limitTupleId,c0,cI0);
2200 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> c(c0),cI(cI0);
2201 int newNbOfTuples=-1;
2202 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> o2n=DataArrayInt::BuildOld2NewArrayFromSurjectiveFormat2(getNumberOfTuples(),c0->begin(),cI0->begin(),cI0->end(),newNbOfTuples);
2203 return renumberAndReduce(o2n->getConstPointer(),newNbOfTuples);
2207 * Copy all components in a specified order from another DataArrayDouble.
2208 * Both numerical and textual data is copied. The number of tuples in \a this and
2209 * the other array can be different.
2210 * \param [in] a - the array to copy data from.
2211 * \param [in] compoIds - sequence of zero based indices of components, data of which is
2213 * \throw If \a a is NULL.
2214 * \throw If \a compoIds.size() != \a a->getNumberOfComponents().
2215 * \throw If \a compoIds[i] < 0 or \a compoIds[i] > \a this->getNumberOfComponents().
2217 * \ref py_mcdataarraydouble_setselectedcomponents "Here is a Python example".
2219 void DataArrayDouble::setSelectedComponents(const DataArrayDouble *a, const std::vector<int>& compoIds)
2222 throw INTERP_KERNEL::Exception("DataArrayDouble::setSelectedComponents : input DataArrayDouble is NULL !");
2224 copyPartOfStringInfoFrom2(compoIds,*a);
2225 std::size_t partOfCompoSz=compoIds.size();
2226 int nbOfCompo=getNumberOfComponents();
2227 int nbOfTuples=std::min(getNumberOfTuples(),a->getNumberOfTuples());
2228 const double *ac=a->getConstPointer();
2229 double *nc=getPointer();
2230 for(int i=0;i<nbOfTuples;i++)
2231 for(std::size_t j=0;j<partOfCompoSz;j++,ac++)
2232 nc[nbOfCompo*i+compoIds[j]]=*ac;
2236 * Copy all values from another DataArrayDouble into specified tuples and components
2237 * of \a this array. Textual data is not copied.
2238 * The tree parameters defining set of indices of tuples and components are similar to
2239 * the tree parameters of the Python function \c range(\c start,\c stop,\c step).
2240 * \param [in] a - the array to copy values from.
2241 * \param [in] bgTuples - index of the first tuple of \a this array to assign values to.
2242 * \param [in] endTuples - index of the tuple before which the tuples to assign to
2244 * \param [in] stepTuples - index increment to get index of the next tuple to assign to.
2245 * \param [in] bgComp - index of the first component of \a this array to assign values to.
2246 * \param [in] endComp - index of the component before which the components to assign
2248 * \param [in] stepComp - index increment to get index of the next component to assign to.
2249 * \param [in] strictCompoCompare - if \a true (by default), then \a a->getNumberOfComponents()
2250 * must be equal to the number of columns to assign to, else an
2251 * exception is thrown; if \a false, then it is only required that \a
2252 * a->getNbOfElems() equals to number of values to assign to (this condition
2253 * must be respected even if \a strictCompoCompare is \a true). The number of
2254 * values to assign to is given by following Python expression:
2255 * \a nbTargetValues =
2256 * \c len(\c range(\a bgTuples,\a endTuples,\a stepTuples)) *
2257 * \c len(\c range(\a bgComp,\a endComp,\a stepComp)).
2258 * \throw If \a a is NULL.
2259 * \throw If \a a is not allocated.
2260 * \throw If \a this is not allocated.
2261 * \throw If parameters specifying tuples and components to assign to do not give a
2262 * non-empty range of increasing indices.
2263 * \throw If \a a->getNbOfElems() != \a nbTargetValues.
2264 * \throw If \a strictCompoCompare == \a true && \a a->getNumberOfComponents() !=
2265 * \c len(\c range(\a bgComp,\a endComp,\a stepComp)).
2267 * \ref py_mcdataarraydouble_setpartofvalues1 "Here is a Python example".
2269 void DataArrayDouble::setPartOfValues1(const DataArrayDouble *a, int bgTuples, int endTuples, int stepTuples, int bgComp, int endComp, int stepComp, bool strictCompoCompare)
2272 throw INTERP_KERNEL::Exception("DataArrayDouble::setPartOfValues1 : input DataArrayDouble is NULL !");
2273 const char msg[]="DataArrayDouble::setPartOfValues1";
2275 a->checkAllocated();
2276 int newNbOfTuples=DataArray::GetNumberOfItemGivenBES(bgTuples,endTuples,stepTuples,msg);
2277 int newNbOfComp=DataArray::GetNumberOfItemGivenBES(bgComp,endComp,stepComp,msg);
2278 int nbComp=getNumberOfComponents();
2279 int nbOfTuples=getNumberOfTuples();
2280 DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
2281 DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
2282 bool assignTech=true;
2283 if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
2285 if(strictCompoCompare)
2286 a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
2290 a->checkNbOfTuplesAndComp(1,newNbOfComp,msg);
2293 const double *srcPt=a->getConstPointer();
2294 double *pt=getPointer()+bgTuples*nbComp+bgComp;
2297 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
2298 for(int j=0;j<newNbOfComp;j++,srcPt++)
2299 pt[j*stepComp]=*srcPt;
2303 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
2305 const double *srcPt2=srcPt;
2306 for(int j=0;j<newNbOfComp;j++,srcPt2++)
2307 pt[j*stepComp]=*srcPt2;
2313 * Assign a given value to values at specified tuples and components of \a this array.
2314 * The tree parameters defining set of indices of tuples and components are similar to
2315 * the tree parameters of the Python function \c range(\c start,\c stop,\c step)..
2316 * \param [in] a - the value to assign.
2317 * \param [in] bgTuples - index of the first tuple of \a this array to assign to.
2318 * \param [in] endTuples - index of the tuple before which the tuples to assign to
2320 * \param [in] stepTuples - index increment to get index of the next tuple to assign to.
2321 * \param [in] bgComp - index of the first component of \a this array to assign to.
2322 * \param [in] endComp - index of the component before which the components to assign
2324 * \param [in] stepComp - index increment to get index of the next component to assign to.
2325 * \throw If \a this is not allocated.
2326 * \throw If parameters specifying tuples and components to assign to, do not give a
2327 * non-empty range of increasing indices or indices are out of a valid range
2330 * \ref py_mcdataarraydouble_setpartofvaluessimple1 "Here is a Python example".
2332 void DataArrayDouble::setPartOfValuesSimple1(double a, int bgTuples, int endTuples, int stepTuples, int bgComp, int endComp, int stepComp)
2334 const char msg[]="DataArrayDouble::setPartOfValuesSimple1";
2336 int newNbOfTuples=DataArray::GetNumberOfItemGivenBES(bgTuples,endTuples,stepTuples,msg);
2337 int newNbOfComp=DataArray::GetNumberOfItemGivenBES(bgComp,endComp,stepComp,msg);
2338 int nbComp=getNumberOfComponents();
2339 int nbOfTuples=getNumberOfTuples();
2340 DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
2341 DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
2342 double *pt=getPointer()+bgTuples*nbComp+bgComp;
2343 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
2344 for(int j=0;j<newNbOfComp;j++)
2349 * Copy all values from another DataArrayDouble (\a a) into specified tuples and
2350 * components of \a this array. Textual data is not copied.
2351 * The tuples and components to assign to are defined by C arrays of indices.
2352 * There are two *modes of usage*:
2353 * - If \a a->getNbOfElems() equals to number of values to assign to, then every value
2354 * of \a a is assigned to its own location within \a this array.
2355 * - If \a a includes one tuple, then all values of \a a are assigned to the specified
2356 * components of every specified tuple of \a this array. In this mode it is required
2357 * that \a a->getNumberOfComponents() equals to the number of specified components.
2359 * \param [in] a - the array to copy values from.
2360 * \param [in] bgTuples - pointer to an array of tuple indices of \a this array to
2361 * assign values of \a a to.
2362 * \param [in] endTuples - specifies the end of the array \a bgTuples, so that
2363 * pointer to a tuple index <em>(pi)</em> varies as this:
2364 * \a bgTuples <= \a pi < \a endTuples.
2365 * \param [in] bgComp - pointer to an array of component indices of \a this array to
2366 * assign values of \a a to.
2367 * \param [in] endComp - specifies the end of the array \a bgTuples, so that
2368 * pointer to a component index <em>(pi)</em> varies as this:
2369 * \a bgComp <= \a pi < \a endComp.
2370 * \param [in] strictCompoCompare - this parameter is checked only if the
2371 * *mode of usage* is the first; if it is \a true (default),
2372 * then \a a->getNumberOfComponents() must be equal
2373 * to the number of specified columns, else this is not required.
2374 * \throw If \a a is NULL.
2375 * \throw If \a a is not allocated.
2376 * \throw If \a this is not allocated.
2377 * \throw If any index of tuple/component given by <em>bgTuples / bgComp</em> is
2378 * out of a valid range for \a this array.
2379 * \throw In the first *mode of usage*, if <em>strictCompoCompare == true </em> and
2380 * if <em> a->getNumberOfComponents() != (endComp - bgComp) </em>.
2381 * \throw In the second *mode of usage*, if \a a->getNumberOfTuples() != 1 or
2382 * <em> a->getNumberOfComponents() != (endComp - bgComp)</em>.
2384 * \ref py_mcdataarraydouble_setpartofvalues2 "Here is a Python example".
2386 void DataArrayDouble::setPartOfValues2(const DataArrayDouble *a, const int *bgTuples, const int *endTuples, const int *bgComp, const int *endComp, bool strictCompoCompare)
2389 throw INTERP_KERNEL::Exception("DataArrayDouble::setPartOfValues2 : input DataArrayDouble is NULL !");
2390 const char msg[]="DataArrayDouble::setPartOfValues2";
2392 a->checkAllocated();
2393 int nbComp=getNumberOfComponents();
2394 int nbOfTuples=getNumberOfTuples();
2395 for(const int *z=bgComp;z!=endComp;z++)
2396 DataArray::CheckValueInRange(nbComp,*z,"invalid component id");
2397 int newNbOfTuples=(int)std::distance(bgTuples,endTuples);
2398 int newNbOfComp=(int)std::distance(bgComp,endComp);
2399 bool assignTech=true;
2400 if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
2402 if(strictCompoCompare)
2403 a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
2407 a->checkNbOfTuplesAndComp(1,newNbOfComp,msg);
2410 double *pt=getPointer();
2411 const double *srcPt=a->getConstPointer();
2414 for(const int *w=bgTuples;w!=endTuples;w++)
2416 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
2417 for(const int *z=bgComp;z!=endComp;z++,srcPt++)
2419 pt[(std::size_t)(*w)*nbComp+(*z)]=*srcPt;
2425 for(const int *w=bgTuples;w!=endTuples;w++)
2427 const double *srcPt2=srcPt;
2428 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
2429 for(const int *z=bgComp;z!=endComp;z++,srcPt2++)
2431 pt[(std::size_t)(*w)*nbComp+(*z)]=*srcPt2;
2438 * Assign a given value to values at specified tuples and components of \a this array.
2439 * The tuples and components to assign to are defined by C arrays of indices.
2440 * \param [in] a - the value to assign.
2441 * \param [in] bgTuples - pointer to an array of tuple indices of \a this array to
2443 * \param [in] endTuples - specifies the end of the array \a bgTuples, so that
2444 * pointer to a tuple index (\a pi) varies as this:
2445 * \a bgTuples <= \a pi < \a endTuples.
2446 * \param [in] bgComp - pointer to an array of component indices of \a this array to
2448 * \param [in] endComp - specifies the end of the array \a bgTuples, so that
2449 * pointer to a component index (\a pi) varies as this:
2450 * \a bgComp <= \a pi < \a endComp.
2451 * \throw If \a this is not allocated.
2452 * \throw If any index of tuple/component given by <em>bgTuples / bgComp</em> is
2453 * out of a valid range for \a this array.
2455 * \ref py_mcdataarraydouble_setpartofvaluessimple2 "Here is a Python example".
2457 void DataArrayDouble::setPartOfValuesSimple2(double a, const int *bgTuples, const int *endTuples, const int *bgComp, const int *endComp)
2460 int nbComp=getNumberOfComponents();
2461 int nbOfTuples=getNumberOfTuples();
2462 for(const int *z=bgComp;z!=endComp;z++)
2463 DataArray::CheckValueInRange(nbComp,*z,"invalid component id");
2464 double *pt=getPointer();
2465 for(const int *w=bgTuples;w!=endTuples;w++)
2466 for(const int *z=bgComp;z!=endComp;z++)
2468 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
2469 pt[(std::size_t)(*w)*nbComp+(*z)]=a;
2474 * Copy all values from another DataArrayDouble (\a a) into specified tuples and
2475 * components of \a this array. Textual data is not copied.
2476 * The tuples to assign to are defined by a C array of indices.
2477 * The components to assign to are defined by three values similar to parameters of
2478 * the Python function \c range(\c start,\c stop,\c step).
2479 * There are two *modes of usage*:
2480 * - If \a a->getNbOfElems() equals to number of values to assign to, then every value
2481 * of \a a is assigned to its own location within \a this array.
2482 * - If \a a includes one tuple, then all values of \a a are assigned to the specified
2483 * components of every specified tuple of \a this array. In this mode it is required
2484 * that \a a->getNumberOfComponents() equals to the number of specified components.
2486 * \param [in] a - the array to copy values from.
2487 * \param [in] bgTuples - pointer to an array of tuple indices of \a this array to
2488 * assign values of \a a to.
2489 * \param [in] endTuples - specifies the end of the array \a bgTuples, so that
2490 * pointer to a tuple index <em>(pi)</em> varies as this:
2491 * \a bgTuples <= \a pi < \a endTuples.
2492 * \param [in] bgComp - index of the first component of \a this array to assign to.
2493 * \param [in] endComp - index of the component before which the components to assign
2495 * \param [in] stepComp - index increment to get index of the next component to assign to.
2496 * \param [in] strictCompoCompare - this parameter is checked only in the first
2497 * *mode of usage*; if \a strictCompoCompare is \a true (default),
2498 * then \a a->getNumberOfComponents() must be equal
2499 * to the number of specified columns, else this is not required.
2500 * \throw If \a a is NULL.
2501 * \throw If \a a is not allocated.
2502 * \throw If \a this is not allocated.
2503 * \throw If any index of tuple given by \a bgTuples is out of a valid range for
2505 * \throw In the first *mode of usage*, if <em>strictCompoCompare == true </em> and
2506 * if <em> a->getNumberOfComponents()</em> is unequal to the number of components
2507 * defined by <em>(bgComp,endComp,stepComp)</em>.
2508 * \throw In the second *mode of usage*, if \a a->getNumberOfTuples() != 1 or
2509 * <em> a->getNumberOfComponents()</em> is unequal to the number of components
2510 * defined by <em>(bgComp,endComp,stepComp)</em>.
2511 * \throw If parameters specifying components to assign to, do not give a
2512 * non-empty range of increasing indices or indices are out of a valid range
2515 * \ref py_mcdataarraydouble_setpartofvalues3 "Here is a Python example".
2517 void DataArrayDouble::setPartOfValues3(const DataArrayDouble *a, const int *bgTuples, const int *endTuples, int bgComp, int endComp, int stepComp, bool strictCompoCompare)
2520 throw INTERP_KERNEL::Exception("DataArrayDouble::setPartOfValues3 : input DataArrayDouble is NULL !");
2521 const char msg[]="DataArrayDouble::setPartOfValues3";
2523 a->checkAllocated();
2524 int newNbOfComp=DataArray::GetNumberOfItemGivenBES(bgComp,endComp,stepComp,msg);
2525 int nbComp=getNumberOfComponents();
2526 int nbOfTuples=getNumberOfTuples();
2527 DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
2528 int newNbOfTuples=(int)std::distance(bgTuples,endTuples);
2529 bool assignTech=true;
2530 if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
2532 if(strictCompoCompare)
2533 a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
2537 a->checkNbOfTuplesAndComp(1,newNbOfComp,msg);
2540 double *pt=getPointer()+bgComp;
2541 const double *srcPt=a->getConstPointer();
2544 for(const int *w=bgTuples;w!=endTuples;w++)
2545 for(int j=0;j<newNbOfComp;j++,srcPt++)
2547 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
2548 pt[(std::size_t)(*w)*nbComp+j*stepComp]=*srcPt;
2553 for(const int *w=bgTuples;w!=endTuples;w++)
2555 const double *srcPt2=srcPt;
2556 for(int j=0;j<newNbOfComp;j++,srcPt2++)
2558 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
2559 pt[(std::size_t)(*w)*nbComp+j*stepComp]=*srcPt2;
2566 * Assign a given value to values at specified tuples and components of \a this array.
2567 * The tuples to assign to are defined by a C array of indices.
2568 * The components to assign to are defined by three values similar to parameters of
2569 * the Python function \c range(\c start,\c stop,\c step).
2570 * \param [in] a - the value to assign.
2571 * \param [in] bgTuples - pointer to an array of tuple indices of \a this array to
2573 * \param [in] endTuples - specifies the end of the array \a bgTuples, so that
2574 * pointer to a tuple index <em>(pi)</em> varies as this:
2575 * \a bgTuples <= \a pi < \a endTuples.
2576 * \param [in] bgComp - index of the first component of \a this array to assign to.
2577 * \param [in] endComp - index of the component before which the components to assign
2579 * \param [in] stepComp - index increment to get index of the next component to assign to.
2580 * \throw If \a this is not allocated.
2581 * \throw If any index of tuple given by \a bgTuples is out of a valid range for
2583 * \throw If parameters specifying components to assign to, do not give a
2584 * non-empty range of increasing indices or indices are out of a valid range
2587 * \ref py_mcdataarraydouble_setpartofvaluessimple3 "Here is a Python example".
2589 void DataArrayDouble::setPartOfValuesSimple3(double a, const int *bgTuples, const int *endTuples, int bgComp, int endComp, int stepComp)
2591 const char msg[]="DataArrayDouble::setPartOfValuesSimple3";
2593 int newNbOfComp=DataArray::GetNumberOfItemGivenBES(bgComp,endComp,stepComp,msg);
2594 int nbComp=getNumberOfComponents();
2595 int nbOfTuples=getNumberOfTuples();
2596 DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
2597 double *pt=getPointer()+bgComp;
2598 for(const int *w=bgTuples;w!=endTuples;w++)
2599 for(int j=0;j<newNbOfComp;j++)
2601 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
2602 pt[(std::size_t)(*w)*nbComp+j*stepComp]=a;
2607 * Copy all values from another DataArrayDouble into specified tuples and components
2608 * of \a this array. Textual data is not copied.
2609 * The tree parameters defining set of indices of tuples and components are similar to
2610 * the tree parameters of the Python function \c range(\c start,\c stop,\c step).
2611 * \param [in] a - the array to copy values from.
2612 * \param [in] bgTuples - index of the first tuple of \a this array to assign values to.
2613 * \param [in] endTuples - index of the tuple before which the tuples to assign to
2615 * \param [in] stepTuples - index increment to get index of the next tuple to assign to.
2616 * \param [in] bgComp - pointer to an array of component indices of \a this array to
2618 * \param [in] endComp - specifies the end of the array \a bgTuples, so that
2619 * pointer to a component index (\a pi) varies as this:
2620 * \a bgComp <= \a pi < \a endComp.
2621 * \param [in] strictCompoCompare - if \a true (by default), then \a a->getNumberOfComponents()
2622 * must be equal to the number of columns to assign to, else an
2623 * exception is thrown; if \a false, then it is only required that \a
2624 * a->getNbOfElems() equals to number of values to assign to (this condition
2625 * must be respected even if \a strictCompoCompare is \a true). The number of
2626 * values to assign to is given by following Python expression:
2627 * \a nbTargetValues =
2628 * \c len(\c range(\a bgTuples,\a endTuples,\a stepTuples)) *
2629 * \c len(\c range(\a bgComp,\a endComp,\a stepComp)).
2630 * \throw If \a a is NULL.
2631 * \throw If \a a is not allocated.
2632 * \throw If \a this is not allocated.
2633 * \throw If parameters specifying tuples and components to assign to do not give a
2634 * non-empty range of increasing indices.
2635 * \throw If \a a->getNbOfElems() != \a nbTargetValues.
2636 * \throw If \a strictCompoCompare == \a true && \a a->getNumberOfComponents() !=
2637 * \c len(\c range(\a bgComp,\a endComp,\a stepComp)).
2640 void DataArrayDouble::setPartOfValues4(const DataArrayDouble *a, int bgTuples, int endTuples, int stepTuples, const int *bgComp, const int *endComp, bool strictCompoCompare)
2643 throw INTERP_KERNEL::Exception("DataArrayDouble::setPartOfValues4 : input DataArrayDouble is NULL !");
2644 const char msg[]="DataArrayDouble::setPartOfValues4";
2646 a->checkAllocated();
2647 int newNbOfTuples=DataArray::GetNumberOfItemGivenBES(bgTuples,endTuples,stepTuples,msg);
2648 int newNbOfComp=(int)std::distance(bgComp,endComp);
2649 int nbComp=getNumberOfComponents();
2650 for(const int *z=bgComp;z!=endComp;z++)
2651 DataArray::CheckValueInRange(nbComp,*z,"invalid component id");
2652 int nbOfTuples=getNumberOfTuples();
2653 DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
2654 bool assignTech=true;
2655 if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
2657 if(strictCompoCompare)
2658 a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
2662 a->checkNbOfTuplesAndComp(1,newNbOfComp,msg);
2665 const double *srcPt=a->getConstPointer();
2666 double *pt=getPointer()+bgTuples*nbComp;
2669 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
2670 for(const int *z=bgComp;z!=endComp;z++,srcPt++)
2675 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
2677 const double *srcPt2=srcPt;
2678 for(const int *z=bgComp;z!=endComp;z++,srcPt2++)
2684 void DataArrayDouble::setPartOfValuesSimple4(double a, int bgTuples, int endTuples, int stepTuples, const int *bgComp, const int *endComp)
2686 const char msg[]="DataArrayDouble::setPartOfValuesSimple4";
2688 int newNbOfTuples=DataArray::GetNumberOfItemGivenBES(bgTuples,endTuples,stepTuples,msg);
2689 int nbComp=getNumberOfComponents();
2690 for(const int *z=bgComp;z!=endComp;z++)
2691 DataArray::CheckValueInRange(nbComp,*z,"invalid component id");
2692 int nbOfTuples=getNumberOfTuples();
2693 DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
2694 double *pt=getPointer()+bgTuples*nbComp;
2695 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
2696 for(const int *z=bgComp;z!=endComp;z++)
2701 * Copy some tuples from another DataArrayDouble into specified tuples
2702 * of \a this array. Textual data is not copied. Both arrays must have equal number of
2704 * Both the tuples to assign and the tuples to assign to are defined by a DataArrayInt.
2705 * All components of selected tuples are copied.
2706 * \param [in] a - the array to copy values from.
2707 * \param [in] tuplesSelec - the array specifying both source tuples of \a a and
2708 * target tuples of \a this. \a tuplesSelec has two components, and the
2709 * first component specifies index of the source tuple and the second
2710 * one specifies index of the target tuple.
2711 * \throw If \a this is not allocated.
2712 * \throw If \a a is NULL.
2713 * \throw If \a a is not allocated.
2714 * \throw If \a tuplesSelec is NULL.
2715 * \throw If \a tuplesSelec is not allocated.
2716 * \throw If <em>this->getNumberOfComponents() != a->getNumberOfComponents()</em>.
2717 * \throw If \a tuplesSelec->getNumberOfComponents() != 2.
2718 * \throw If any tuple index given by \a tuplesSelec is out of a valid range for
2719 * the corresponding (\a this or \a a) array.
2721 void DataArrayDouble::setPartOfValuesAdv(const DataArrayDouble *a, const DataArrayInt *tuplesSelec)
2723 if(!a || !tuplesSelec)
2724 throw INTERP_KERNEL::Exception("DataArrayDouble::setPartOfValuesAdv : input DataArrayDouble is NULL !");
2726 a->checkAllocated();
2727 tuplesSelec->checkAllocated();
2728 int nbOfComp=getNumberOfComponents();
2729 if(nbOfComp!=a->getNumberOfComponents())
2730 throw INTERP_KERNEL::Exception("DataArrayDouble::setPartOfValuesAdv : This and a do not have the same number of components !");
2731 if(tuplesSelec->getNumberOfComponents()!=2)
2732 throw INTERP_KERNEL::Exception("DataArrayDouble::setPartOfValuesAdv : Expecting to have a tuple selector DataArrayInt instance with exactly 2 components !");
2733 int thisNt=getNumberOfTuples();
2734 int aNt=a->getNumberOfTuples();
2735 double *valsToSet=getPointer();
2736 const double *valsSrc=a->getConstPointer();
2737 for(const int *tuple=tuplesSelec->begin();tuple!=tuplesSelec->end();tuple+=2)
2739 if(tuple[1]>=0 && tuple[1]<aNt)
2741 if(tuple[0]>=0 && tuple[0]<thisNt)
2742 std::copy(valsSrc+nbOfComp*tuple[1],valsSrc+nbOfComp*(tuple[1]+1),valsToSet+nbOfComp*tuple[0]);
2745 std::ostringstream oss; oss << "DataArrayDouble::setPartOfValuesAdv : Tuple #" << std::distance(tuplesSelec->begin(),tuple)/2;
2746 oss << " of 'tuplesSelec' request of tuple id #" << tuple[0] << " in 'this' ! It should be in [0," << thisNt << ") !";
2747 throw INTERP_KERNEL::Exception(oss.str().c_str());
2752 std::ostringstream oss; oss << "DataArrayDouble::setPartOfValuesAdv : Tuple #" << std::distance(tuplesSelec->begin(),tuple)/2;
2753 oss << " of 'tuplesSelec' request of tuple id #" << tuple[1] << " in 'a' ! It should be in [0," << aNt << ") !";
2754 throw INTERP_KERNEL::Exception(oss.str().c_str());
2760 * Copy some tuples from another DataArrayDouble (\a aBase) into contiguous tuples
2761 * of \a this array. Textual data is not copied. Both arrays must have equal number of
2763 * The tuples to assign to are defined by index of the first tuple, and
2764 * their number is defined by \a tuplesSelec->getNumberOfTuples().
2765 * The tuples to copy are defined by values of a DataArrayInt.
2766 * All components of selected tuples are copied.
2767 * \param [in] tupleIdStart - index of the first tuple of \a this array to assign
2769 * \param [in] aBase - the array to copy values from.
2770 * \param [in] tuplesSelec - the array specifying tuples of \a a to copy.
2771 * \throw If \a this is not allocated.
2772 * \throw If \a aBase is NULL.
2773 * \throw If \a aBase is not allocated.
2774 * \throw If \a tuplesSelec is NULL.
2775 * \throw If \a tuplesSelec is not allocated.
2776 * \throw If <em>this->getNumberOfComponents() != aBase->getNumberOfComponents()</em>.
2777 * \throw If \a tuplesSelec->getNumberOfComponents() != 1.
2778 * \throw If <em>tupleIdStart + tuplesSelec->getNumberOfTuples() > this->getNumberOfTuples().</em>
2779 * \throw If any tuple index given by \a tuplesSelec is out of a valid range for
2782 void DataArrayDouble::setContigPartOfSelectedValues(int tupleIdStart, const DataArray *aBase, const DataArrayInt *tuplesSelec)
2784 if(!aBase || !tuplesSelec)
2785 throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues : input DataArray is NULL !");
2786 const DataArrayDouble *a=dynamic_cast<const DataArrayDouble *>(aBase);
2788 throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues : input DataArray aBase is not a DataArrayDouble !");
2790 a->checkAllocated();
2791 tuplesSelec->checkAllocated();
2792 int nbOfComp=getNumberOfComponents();
2793 if(nbOfComp!=a->getNumberOfComponents())
2794 throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues : This and a do not have the same number of components !");
2795 if(tuplesSelec->getNumberOfComponents()!=1)
2796 throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues : Expecting to have a tuple selector DataArrayInt instance with exactly 1 component !");
2797 int thisNt=getNumberOfTuples();
2798 int aNt=a->getNumberOfTuples();
2799 int nbOfTupleToWrite=tuplesSelec->getNumberOfTuples();
2800 double *valsToSet=getPointer()+tupleIdStart*nbOfComp;
2801 if(tupleIdStart+nbOfTupleToWrite>thisNt)
2802 throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues : invalid number range of values to write !");
2803 const double *valsSrc=a->getConstPointer();
2804 for(const int *tuple=tuplesSelec->begin();tuple!=tuplesSelec->end();tuple++,valsToSet+=nbOfComp)
2806 if(*tuple>=0 && *tuple<aNt)
2808 std::copy(valsSrc+nbOfComp*(*tuple),valsSrc+nbOfComp*(*tuple+1),valsToSet);
2812 std::ostringstream oss; oss << "DataArrayDouble::setContigPartOfSelectedValues : Tuple #" << std::distance(tuplesSelec->begin(),tuple);
2813 oss << " of 'tuplesSelec' request of tuple id #" << *tuple << " in 'a' ! It should be in [0," << aNt << ") !";
2814 throw INTERP_KERNEL::Exception(oss.str().c_str());
2820 * Copy some tuples from another DataArrayDouble (\a aBase) into contiguous tuples
2821 * of \a this array. Textual data is not copied. Both arrays must have equal number of
2823 * The tuples to copy are defined by three values similar to parameters of
2824 * the Python function \c range(\c start,\c stop,\c step).
2825 * The tuples to assign to are defined by index of the first tuple, and
2826 * their number is defined by number of tuples to copy.
2827 * All components of selected tuples are copied.
2828 * \param [in] tupleIdStart - index of the first tuple of \a this array to assign
2830 * \param [in] aBase - the array to copy values from.
2831 * \param [in] bg - index of the first tuple to copy of the array \a aBase.
2832 * \param [in] end2 - index of the tuple of \a aBase before which the tuples to copy
2834 * \param [in] step - index increment to get index of the next tuple to copy.
2835 * \throw If \a this is not allocated.
2836 * \throw If \a aBase is NULL.
2837 * \throw If \a aBase is not allocated.
2838 * \throw If <em>this->getNumberOfComponents() != aBase->getNumberOfComponents()</em>.
2839 * \throw If <em>tupleIdStart + len(range(bg,end2,step)) > this->getNumberOfTuples().</em>
2840 * \throw If parameters specifying tuples to copy, do not give a
2841 * non-empty range of increasing indices or indices are out of a valid range
2842 * for the array \a aBase.
2844 void DataArrayDouble::setContigPartOfSelectedValues2(int tupleIdStart, const DataArray *aBase, int bg, int end2, int step)
2847 throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues2 : input DataArray is NULL !");
2848 const DataArrayDouble *a=dynamic_cast<const DataArrayDouble *>(aBase);
2850 throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues2 : input DataArray aBase is not a DataArrayDouble !");
2852 a->checkAllocated();
2853 int nbOfComp=getNumberOfComponents();
2854 const char msg[]="DataArrayDouble::setContigPartOfSelectedValues2";
2855 int nbOfTupleToWrite=DataArray::GetNumberOfItemGivenBES(bg,end2,step,msg);
2856 if(nbOfComp!=a->getNumberOfComponents())
2857 throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues2 : This and a do not have the same number of components !");
2858 int thisNt=getNumberOfTuples();
2859 int aNt=a->getNumberOfTuples();
2860 double *valsToSet=getPointer()+tupleIdStart*nbOfComp;
2861 if(tupleIdStart+nbOfTupleToWrite>thisNt)
2862 throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues2 : invalid number range of values to write !");
2864 throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues2 : invalid range of values to read !");
2865 const double *valsSrc=a->getConstPointer()+bg*nbOfComp;
2866 for(int i=0;i<nbOfTupleToWrite;i++,valsToSet+=nbOfComp,valsSrc+=step*nbOfComp)
2868 std::copy(valsSrc,valsSrc+nbOfComp,valsToSet);
2873 * Returns a value located at specified tuple and component.
2874 * This method is equivalent to DataArrayDouble::getIJ() except that validity of
2875 * parameters is checked. So this method is safe but expensive if used to go through
2876 * all values of \a this.
2877 * \param [in] tupleId - index of tuple of interest.
2878 * \param [in] compoId - index of component of interest.
2879 * \return double - value located by \a tupleId and \a compoId.
2880 * \throw If \a this is not allocated.
2881 * \throw If condition <em>( 0 <= tupleId < this->getNumberOfTuples() )</em> is violated.
2882 * \throw If condition <em>( 0 <= compoId < this->getNumberOfComponents() )</em> is violated.
2884 double DataArrayDouble::getIJSafe(int tupleId, int compoId) const
2887 if(tupleId<0 || tupleId>=getNumberOfTuples())
2889 std::ostringstream oss; oss << "DataArrayDouble::getIJSafe : request for tupleId " << tupleId << " should be in [0," << getNumberOfTuples() << ") !";
2890 throw INTERP_KERNEL::Exception(oss.str().c_str());
2892 if(compoId<0 || compoId>=getNumberOfComponents())
2894 std::ostringstream oss; oss << "DataArrayDouble::getIJSafe : request for compoId " << compoId << " should be in [0," << getNumberOfComponents() << ") !";
2895 throw INTERP_KERNEL::Exception(oss.str().c_str());
2897 return _mem[tupleId*_info_on_compo.size()+compoId];
2901 * Returns the first value of \a this.
2902 * \return double - the last value of \a this array.
2903 * \throw If \a this is not allocated.
2904 * \throw If \a this->getNumberOfComponents() != 1.
2905 * \throw If \a this->getNumberOfTuples() < 1.
2907 double DataArrayDouble::front() const
2910 if(getNumberOfComponents()!=1)
2911 throw INTERP_KERNEL::Exception("DataArrayDouble::front : number of components not equal to one !");
2912 int nbOfTuples=getNumberOfTuples();
2914 throw INTERP_KERNEL::Exception("DataArrayDouble::front : number of tuples must be >= 1 !");
2915 return *(getConstPointer());
2919 * Returns the last value of \a this.
2920 * \return double - the last value of \a this array.
2921 * \throw If \a this is not allocated.
2922 * \throw If \a this->getNumberOfComponents() != 1.
2923 * \throw If \a this->getNumberOfTuples() < 1.
2925 double DataArrayDouble::back() const
2928 if(getNumberOfComponents()!=1)
2929 throw INTERP_KERNEL::Exception("DataArrayDouble::back : number of components not equal to one !");
2930 int nbOfTuples=getNumberOfTuples();
2932 throw INTERP_KERNEL::Exception("DataArrayDouble::back : number of tuples must be >= 1 !");
2933 return *(getConstPointer()+nbOfTuples-1);
2936 void DataArrayDouble::SetArrayIn(DataArrayDouble *newArray, DataArrayDouble* &arrayToSet)
2938 if(newArray!=arrayToSet)
2941 arrayToSet->decrRef();
2942 arrayToSet=newArray;
2944 arrayToSet->incrRef();
2949 * Sets a C array to be used as raw data of \a this. The previously set info
2950 * of components is retained and re-sized.
2951 * For more info see \ref MEDCouplingArraySteps1.
2952 * \param [in] array - the C array to be used as raw data of \a this.
2953 * \param [in] ownership - if \a true, \a array will be deallocated at destruction of \a this.
2954 * \param [in] type - specifies how to deallocate \a array. If \a type == ParaMEDMEM::CPP_DEALLOC,
2955 * \c delete [] \c array; will be called. If \a type == ParaMEDMEM::C_DEALLOC,
2956 * \c free(\c array ) will be called.
2957 * \param [in] nbOfTuple - new number of tuples in \a this.
2958 * \param [in] nbOfCompo - new number of components in \a this.
2960 void DataArrayDouble::useArray(const double *array, bool ownership, DeallocType type, int nbOfTuple, int nbOfCompo)
2962 _info_on_compo.resize(nbOfCompo);
2963 _mem.useArray(array,ownership,type,(std::size_t)nbOfTuple*nbOfCompo);
2967 void DataArrayDouble::useExternalArrayWithRWAccess(const double *array, int nbOfTuple, int nbOfCompo)
2969 _info_on_compo.resize(nbOfCompo);
2970 _mem.useExternalArrayWithRWAccess(array,(std::size_t)nbOfTuple*nbOfCompo);
2975 * Checks if 0.0 value is present in \a this array. If it is the case, an exception
2977 * \throw If zero is found in \a this array.
2979 void DataArrayDouble::checkNoNullValues() const
2981 const double *tmp=getConstPointer();
2982 std::size_t nbOfElems=getNbOfElems();
2983 const double *where=std::find(tmp,tmp+nbOfElems,0.);
2984 if(where!=tmp+nbOfElems)
2985 throw INTERP_KERNEL::Exception("A value 0.0 have been detected !");
2989 * Computes minimal and maximal value in each component. An output array is filled
2990 * with \c 2 * \a this->getNumberOfComponents() values, so the caller is to allocate
2991 * enough memory before calling this method.
2992 * \param [out] bounds - array of size at least 2 *\a this->getNumberOfComponents().
2993 * It is filled as follows:<br>
2994 * \a bounds[0] = \c min_of_component_0 <br>
2995 * \a bounds[1] = \c max_of_component_0 <br>
2996 * \a bounds[2] = \c min_of_component_1 <br>
2997 * \a bounds[3] = \c max_of_component_1 <br>
3000 void DataArrayDouble::getMinMaxPerComponent(double *bounds) const
3003 int dim=getNumberOfComponents();
3004 for (int idim=0; idim<dim; idim++)
3006 bounds[idim*2]=std::numeric_limits<double>::max();
3007 bounds[idim*2+1]=-std::numeric_limits<double>::max();
3009 const double *ptr=getConstPointer();
3010 int nbOfTuples=getNumberOfTuples();
3011 for(int i=0;i<nbOfTuples;i++)
3013 for(int idim=0;idim<dim;idim++)
3015 if(bounds[idim*2]>ptr[i*dim+idim])
3017 bounds[idim*2]=ptr[i*dim+idim];
3019 if(bounds[idim*2+1]<ptr[i*dim+idim])
3021 bounds[idim*2+1]=ptr[i*dim+idim];
3028 * This method retrieves a newly allocated DataArrayDouble instance having same number of tuples than \a this and twice number of components than \a this
3029 * to store both the min and max per component of each tuples.
3030 * \param [in] epsilon the width of the bbox (identical in each direction) - 0.0 by default
3032 * \return a newly created DataArrayDouble instance having \c this->getNumberOfTuples() tuples and 2 * \c this->getNumberOfComponent() components
3034 * \throw If \a this is not allocated yet.
3036 DataArrayDouble *DataArrayDouble::computeBBoxPerTuple(double epsilon) const
3039 const double *dataPtr=getConstPointer();
3040 int nbOfCompo=getNumberOfComponents();
3041 int nbTuples=getNumberOfTuples();
3042 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> bbox=DataArrayDouble::New();
3043 bbox->alloc(nbTuples,2*nbOfCompo);
3044 double *bboxPtr=bbox->getPointer();
3045 for(int i=0;i<nbTuples;i++)
3047 for(int j=0;j<nbOfCompo;j++)
3049 bboxPtr[2*nbOfCompo*i+2*j]=dataPtr[nbOfCompo*i+j]-epsilon;
3050 bboxPtr[2*nbOfCompo*i+2*j+1]=dataPtr[nbOfCompo*i+j]+epsilon;
3057 * For each tuples **t** in \a other, this method retrieves tuples in \a this that are equal to **t**.
3058 * Two tuples are considered equal if the euclidian distance between the two tuples is lower than \a eps.
3060 * \param [in] other a DataArrayDouble having same number of components than \a this.
3061 * \param [in] eps absolute precision representing distance (using infinite norm) between 2 tuples behind which 2 tuples are considered equal.
3062 * \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.
3063 * \a cI allows to extract information in \a c.
3064 * \param [out] cI is an indirection array that allows to extract the data contained in \a c.
3066 * \throw In case of:
3067 * - \a this is not allocated
3068 * - \a other is not allocated or null
3069 * - \a this and \a other do not have the same number of components
3070 * - if number of components of \a this is not in [1,2,3]
3072 * \sa MEDCouplingPointSet::getNodeIdsNearPoints, DataArrayDouble::getDifferentValues
3074 void DataArrayDouble::computeTupleIdsNearTuples(const DataArrayDouble *other, double eps, DataArrayInt *& c, DataArrayInt *& cI) const
3077 throw INTERP_KERNEL::Exception("DataArrayDouble::computeTupleIdsNearTuples : input pointer other is null !");
3079 other->checkAllocated();
3080 int nbOfCompo=getNumberOfComponents();
3081 int otherNbOfCompo=other->getNumberOfComponents();
3082 if(nbOfCompo!=otherNbOfCompo)
3083 throw INTERP_KERNEL::Exception("DataArrayDouble::computeTupleIdsNearTuples : number of components should be equal between this and other !");
3084 int nbOfTuplesOther=other->getNumberOfTuples();
3085 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> cArr(DataArrayInt::New()),cIArr(DataArrayInt::New()); cArr->alloc(0,1); cIArr->pushBackSilent(0);
3090 BBTreePts<3,int> myTree(begin(),0,0,getNumberOfTuples(),eps);
3091 FindTupleIdsNearTuplesAlg<3>(myTree,other->getConstPointer(),nbOfTuplesOther,eps,cArr,cIArr);
3096 BBTreePts<2,int> myTree(begin(),0,0,getNumberOfTuples(),eps);
3097 FindTupleIdsNearTuplesAlg<2>(myTree,other->getConstPointer(),nbOfTuplesOther,eps,cArr,cIArr);
3102 BBTreePts<1,int> myTree(begin(),0,0,getNumberOfTuples(),eps);
3103 FindTupleIdsNearTuplesAlg<1>(myTree,other->getConstPointer(),nbOfTuplesOther,eps,cArr,cIArr);
3107 throw INTERP_KERNEL::Exception("Unexpected spacedim of coords for computeTupleIdsNearTuples. Must be 1, 2 or 3.");
3109 c=cArr.retn(); cI=cIArr.retn();
3113 * 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
3114 * around origin of 'radius' 1.
3116 * \param [in] eps absolute epsilon. under that value of delta between max and min no scale is performed.
3118 void DataArrayDouble::recenterForMaxPrecision(double eps)
3121 int dim=getNumberOfComponents();
3122 std::vector<double> bounds(2*dim);
3123 getMinMaxPerComponent(&bounds[0]);
3124 for(int i=0;i<dim;i++)
3126 double delta=bounds[2*i+1]-bounds[2*i];
3127 double offset=(bounds[2*i]+bounds[2*i+1])/2.;
3129 applyLin(1./delta,-offset/delta,i);
3131 applyLin(1.,-offset,i);
3136 * Returns the maximal value and its location within \a this one-dimensional array.
3137 * \param [out] tupleId - index of the tuple holding the maximal value.
3138 * \return double - the maximal value among all values of \a this array.
3139 * \throw If \a this->getNumberOfComponents() != 1
3140 * \throw If \a this->getNumberOfTuples() < 1
3142 double DataArrayDouble::getMaxValue(int& tupleId) const
3145 if(getNumberOfComponents()!=1)
3146 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 !");
3147 int nbOfTuples=getNumberOfTuples();
3149 throw INTERP_KERNEL::Exception("DataArrayDouble::getMaxValue : array exists but number of tuples must be > 0 !");
3150 const double *vals=getConstPointer();
3151 const double *loc=std::max_element(vals,vals+nbOfTuples);
3152 tupleId=(int)std::distance(vals,loc);
3157 * Returns the maximal value within \a this array that is allowed to have more than
3159 * \return double - the maximal value among all values of \a this array.
3160 * \throw If \a this is not allocated.
3162 double DataArrayDouble::getMaxValueInArray() const
3165 const double *loc=std::max_element(begin(),end());
3170 * Returns the maximal value and all its locations within \a this one-dimensional array.
3171 * \param [out] tupleIds - a new instance of DataArrayInt containg indices of
3172 * tuples holding the maximal value. The caller is to delete it using
3173 * decrRef() as it is no more needed.
3174 * \return double - the maximal value among all values of \a this array.
3175 * \throw If \a this->getNumberOfComponents() != 1
3176 * \throw If \a this->getNumberOfTuples() < 1
3178 double DataArrayDouble::getMaxValue2(DataArrayInt*& tupleIds) const
3182 double ret=getMaxValue(tmp);
3183 tupleIds=getIdsInRange(ret,ret);
3188 * Returns the minimal value and its location within \a this one-dimensional array.
3189 * \param [out] tupleId - index of the tuple holding the minimal value.
3190 * \return double - the minimal value among all values of \a this array.
3191 * \throw If \a this->getNumberOfComponents() != 1
3192 * \throw If \a this->getNumberOfTuples() < 1
3194 double DataArrayDouble::getMinValue(int& tupleId) const
3197 if(getNumberOfComponents()!=1)
3198 throw INTERP_KERNEL::Exception("DataArrayDouble::getMinValue : must be applied on DataArrayDouble with only one component, you can call 'rearrange' method before call 'getMinValueInArray' method !");
3199 int nbOfTuples=getNumberOfTuples();
3201 throw INTERP_KERNEL::Exception("DataArrayDouble::getMinValue : array exists but number of tuples must be > 0 !");
3202 const double *vals=getConstPointer();
3203 const double *loc=std::min_element(vals,vals+nbOfTuples);
3204 tupleId=(int)std::distance(vals,loc);
3209 * Returns the minimal value within \a this array that is allowed to have more than
3211 * \return double - the minimal value among all values of \a this array.
3212 * \throw If \a this is not allocated.
3214 double DataArrayDouble::getMinValueInArray() const
3217 const double *loc=std::min_element(begin(),end());
3222 * Returns the minimal value and all its locations within \a this one-dimensional array.
3223 * \param [out] tupleIds - a new instance of DataArrayInt containg indices of
3224 * tuples holding the minimal value. The caller is to delete it using
3225 * decrRef() as it is no more needed.
3226 * \return double - the minimal value among all values of \a this array.
3227 * \throw If \a this->getNumberOfComponents() != 1
3228 * \throw If \a this->getNumberOfTuples() < 1
3230 double DataArrayDouble::getMinValue2(DataArrayInt*& tupleIds) const
3234 double ret=getMinValue(tmp);
3235 tupleIds=getIdsInRange(ret,ret);
3240 * 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.
3241 * This method only works for single component array.
3243 * \return a value in [ 0, \c this->getNumberOfTuples() )
3245 * \throw If \a this is not allocated
3248 int DataArrayDouble::count(double value, double eps) const
3252 if(getNumberOfComponents()!=1)
3253 throw INTERP_KERNEL::Exception("DataArrayDouble::count : must be applied on DataArrayDouble with only one component, you can call 'rearrange' method before !");
3254 const double *vals=begin();
3255 int nbOfTuples=getNumberOfTuples();
3256 for(int i=0;i<nbOfTuples;i++,vals++)
3257 if(fabs(*vals-value)<=eps)
3263 * Returns the average value of \a this one-dimensional array.
3264 * \return double - the average value over all values of \a this array.
3265 * \throw If \a this->getNumberOfComponents() != 1
3266 * \throw If \a this->getNumberOfTuples() < 1
3268 double DataArrayDouble::getAverageValue() const
3270 if(getNumberOfComponents()!=1)
3271 throw INTERP_KERNEL::Exception("DataArrayDouble::getAverageValue : must be applied on DataArrayDouble with only one component, you can call 'rearrange' method before !");
3272 int nbOfTuples=getNumberOfTuples();
3274 throw INTERP_KERNEL::Exception("DataArrayDouble::getAverageValue : array exists but number of tuples must be > 0 !");
3275 const double *vals=getConstPointer();
3276 double ret=std::accumulate(vals,vals+nbOfTuples,0.);
3277 return ret/nbOfTuples;
3281 * Returns the Euclidean norm of the vector defined by \a this array.
3282 * \return double - the value of the Euclidean norm, i.e.
3283 * the square root of the inner product of vector.
3284 * \throw If \a this is not allocated.
3286 double DataArrayDouble::norm2() const
3290 std::size_t nbOfElems=getNbOfElems();
3291 const double *pt=getConstPointer();
3292 for(std::size_t i=0;i<nbOfElems;i++,pt++)
3298 * Returns the maximum norm of the vector defined by \a this array.
3299 * This method works even if the number of components is diferent from one.
3300 * If the number of elements in \a this is 0, -1. is returned.
3301 * \return double - the value of the maximum norm, i.e.
3302 * the maximal absolute value among values of \a this array (whatever its number of components).
3303 * \throw If \a this is not allocated.
3305 double DataArrayDouble::normMax() const
3309 std::size_t nbOfElems(getNbOfElems());
3310 const double *pt(getConstPointer());
3311 for(std::size_t i=0;i<nbOfElems;i++,pt++)
3313 double val(std::abs(*pt));
3321 * Returns the minimum norm (absolute value) of the vector defined by \a this array.
3322 * This method works even if the number of components is diferent from one.
3323 * If the number of elements in \a this is 0, std::numeric_limits<double>::max() is returned.
3324 * \return double - the value of the minimum norm, i.e.
3325 * the minimal absolute value among values of \a this array (whatever its number of components).
3326 * \throw If \a this is not allocated.
3328 double DataArrayDouble::normMin() const
3331 double ret(std::numeric_limits<double>::max());
3332 std::size_t nbOfElems(getNbOfElems());
3333 const double *pt(getConstPointer());
3334 for(std::size_t i=0;i<nbOfElems;i++,pt++)
3336 double val(std::abs(*pt));
3344 * Accumulates values of each component of \a this array.
3345 * \param [out] res - an array of length \a this->getNumberOfComponents(), allocated
3346 * by the caller, that is filled by this method with sum value for each
3348 * \throw If \a this is not allocated.
3350 void DataArrayDouble::accumulate(double *res) const
3353 const double *ptr=getConstPointer();
3354 int nbTuple=getNumberOfTuples();
3355 int nbComps=getNumberOfComponents();
3356 std::fill(res,res+nbComps,0.);
3357 for(int i=0;i<nbTuple;i++)
3358 std::transform(ptr+i*nbComps,ptr+(i+1)*nbComps,res,res,std::plus<double>());
3362 * This method returns the min distance from an external tuple defined by [ \a tupleBg , \a tupleEnd ) to \a this and
3363 * the first tuple in \a this that matches the returned distance. If there is no tuples in \a this an exception will be thrown.
3366 * \a this is expected to be allocated and expected to have a number of components equal to the distance from \a tupleBg to
3367 * \a tupleEnd. If not an exception will be thrown.
3369 * \param [in] tupleBg start pointer (included) of input external tuple
3370 * \param [in] tupleEnd end pointer (not included) of input external tuple
3371 * \param [out] tupleId the tuple id in \a this that matches the min of distance between \a this and input external tuple
3372 * \return the min distance.
3373 * \sa MEDCouplingUMesh::distanceToPoint
3375 double DataArrayDouble::distanceToTuple(const double *tupleBg, const double *tupleEnd, int& tupleId) const
3378 int nbTuple=getNumberOfTuples();
3379 int nbComps=getNumberOfComponents();
3380 if(nbComps!=(int)std::distance(tupleBg,tupleEnd))
3381 { 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()); }
3383 throw INTERP_KERNEL::Exception("DataArrayDouble::distanceToTuple : no tuple in this ! No distance to compute !");
3384 double ret0=std::numeric_limits<double>::max();
3386 const double *work=getConstPointer();
3387 for(int i=0;i<nbTuple;i++)
3390 for(int j=0;j<nbComps;j++,work++)
3391 val+=(*work-tupleBg[j])*((*work-tupleBg[j]));
3395 { ret0=val; tupleId=i; }
3401 * Accumulate values of the given component of \a this array.
3402 * \param [in] compId - the index of the component of interest.
3403 * \return double - a sum value of \a compId-th component.
3404 * \throw If \a this is not allocated.
3405 * \throw If \a the condition ( 0 <= \a compId < \a this->getNumberOfComponents() ) is
3408 double DataArrayDouble::accumulate(int compId) const
3411 const double *ptr=getConstPointer();
3412 int nbTuple=getNumberOfTuples();
3413 int nbComps=getNumberOfComponents();
3414 if(compId<0 || compId>=nbComps)
3415 throw INTERP_KERNEL::Exception("DataArrayDouble::accumulate : Invalid compId specified : No such nb of components !");
3417 for(int i=0;i<nbTuple;i++)
3418 ret+=ptr[i*nbComps+compId];
3423 * This method accumulate using addition tuples in \a this using input index array [ \a bgOfIndex, \a endOfIndex ).
3424 * The returned array will have same number of components than \a this and number of tuples equal to
3425 * \c std::distance(bgOfIndex,endOfIndex) \b minus \b one.
3427 * The input index array is expected to be ascendingly sorted in which the all referenced ids should be in [0, \c this->getNumberOfTuples).
3428 * 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.
3430 * \param [in] bgOfIndex - begin (included) of the input index array.
3431 * \param [in] endOfIndex - end (excluded) of the input index array.
3432 * \return DataArrayDouble * - the new instance having the same number of components than \a this.
3434 * \throw If bgOfIndex or end is NULL.
3435 * \throw If input index array is not ascendingly sorted.
3436 * \throw If there is an id in [ \a bgOfIndex, \a endOfIndex ) not in [0, \c this->getNumberOfTuples).
3437 * \throw If std::distance(bgOfIndex,endOfIndex)==0.
3439 DataArrayDouble *DataArrayDouble::accumulatePerChunck(const int *bgOfIndex, const int *endOfIndex) const
3441 if(!bgOfIndex || !endOfIndex)
3442 throw INTERP_KERNEL::Exception("DataArrayDouble::accumulatePerChunck : input pointer NULL !");
3444 int nbCompo=getNumberOfComponents();
3445 int nbOfTuples=getNumberOfTuples();
3446 int sz=(int)std::distance(bgOfIndex,endOfIndex);
3448 throw INTERP_KERNEL::Exception("DataArrayDouble::accumulatePerChunck : invalid size of input index array !");
3450 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New(); ret->alloc(sz,nbCompo);
3451 const int *w=bgOfIndex;
3452 if(*w<0 || *w>=nbOfTuples)
3453 throw INTERP_KERNEL::Exception("DataArrayDouble::accumulatePerChunck : The first element of the input index not in [0,nbOfTuples) !");
3454 const double *srcPt=begin()+(*w)*nbCompo;
3455 double *tmp=ret->getPointer();
3456 for(int i=0;i<sz;i++,tmp+=nbCompo,w++)
3458 std::fill(tmp,tmp+nbCompo,0.);
3461 for(int j=w[0];j<w[1];j++,srcPt+=nbCompo)
3463 if(j>=0 && j<nbOfTuples)
3464 std::transform(srcPt,srcPt+nbCompo,tmp,tmp,std::plus<double>());
3467 std::ostringstream oss; oss << "DataArrayDouble::accumulatePerChunck : At rank #" << i << " the input index array points to id " << j << " should be in [0," << nbOfTuples << ") !";
3468 throw INTERP_KERNEL::Exception(oss.str().c_str());
3474 std::ostringstream oss; oss << "DataArrayDouble::accumulatePerChunck : At rank #" << i << " the input index array is not in ascendingly sorted.";
3475 throw INTERP_KERNEL::Exception(oss.str().c_str());
3478 ret->copyStringInfoFrom(*this);
3483 * Converts each 2D point defined by the tuple of \a this array from the Polar to the
3484 * Cartesian coordinate system. The two components of the tuple of \a this array are
3485 * considered to contain (1) radius and (2) angle of the point in the Polar CS.
3486 * \return DataArrayDouble * - the new instance of DataArrayDouble, whose each tuple
3487 * contains X and Y coordinates of the point in the Cartesian CS. The caller
3488 * is to delete this array using decrRef() as it is no more needed. The array
3489 * does not contain any textual info on components.
3490 * \throw If \a this->getNumberOfComponents() != 2.
3492 DataArrayDouble *DataArrayDouble::fromPolarToCart() const
3495 int nbOfComp=getNumberOfComponents();
3497 throw INTERP_KERNEL::Exception("DataArrayDouble::fromPolarToCart : must be an array with exactly 2 components !");
3498 int nbOfTuple=getNumberOfTuples();
3499 DataArrayDouble *ret=DataArrayDouble::New();
3500 ret->alloc(nbOfTuple,2);
3501 double *w=ret->getPointer();
3502 const double *wIn=getConstPointer();
3503 for(int i=0;i<nbOfTuple;i++,w+=2,wIn+=2)
3505 w[0]=wIn[0]*cos(wIn[1]);
3506 w[1]=wIn[0]*sin(wIn[1]);
3512 * Converts each 3D point defined by the tuple of \a this array from the Cylindrical to
3513 * the Cartesian coordinate system. The three components of the tuple of \a this array
3514 * are considered to contain (1) radius, (2) azimuth and (3) altitude of the point in
3515 * the Cylindrical CS.
3516 * \return DataArrayDouble * - the new instance of DataArrayDouble, whose each tuple
3517 * contains X, Y and Z coordinates of the point in the Cartesian CS. The info
3518 * on the third component is copied from \a this array. The caller
3519 * is to delete this array using decrRef() as it is no more needed.
3520 * \throw If \a this->getNumberOfComponents() != 3.
3522 DataArrayDouble *DataArrayDouble::fromCylToCart() const
3525 int nbOfComp=getNumberOfComponents();
3527 throw INTERP_KERNEL::Exception("DataArrayDouble::fromCylToCart : must be an array with exactly 3 components !");
3528 int nbOfTuple=getNumberOfTuples();
3529 DataArrayDouble *ret=DataArrayDouble::New();
3530 ret->alloc(getNumberOfTuples(),3);
3531 double *w=ret->getPointer();
3532 const double *wIn=getConstPointer();
3533 for(int i=0;i<nbOfTuple;i++,w+=3,wIn+=3)
3535 w[0]=wIn[0]*cos(wIn[1]);
3536 w[1]=wIn[0]*sin(wIn[1]);
3539 ret->setInfoOnComponent(2,getInfoOnComponent(2));
3544 * Converts each 3D point defined by the tuple of \a this array from the Spherical to
3545 * the Cartesian coordinate system. The three components of the tuple of \a this array
3546 * are considered to contain (1) radius, (2) polar angle and (3) azimuthal angle of the
3547 * point in the Cylindrical CS.
3548 * \return DataArrayDouble * - the new instance of DataArrayDouble, whose each tuple
3549 * contains X, Y and Z coordinates of the point in the Cartesian CS. The info
3550 * on the third component is copied from \a this array. The caller
3551 * is to delete this array using decrRef() as it is no more needed.
3552 * \throw If \a this->getNumberOfComponents() != 3.
3554 DataArrayDouble *DataArrayDouble::fromSpherToCart() const
3557 int nbOfComp=getNumberOfComponents();
3559 throw INTERP_KERNEL::Exception("DataArrayDouble::fromSpherToCart : must be an array with exactly 3 components !");
3560 int nbOfTuple=getNumberOfTuples();
3561 DataArrayDouble *ret=DataArrayDouble::New();
3562 ret->alloc(getNumberOfTuples(),3);
3563 double *w=ret->getPointer();
3564 const double *wIn=getConstPointer();
3565 for(int i=0;i<nbOfTuple;i++,w+=3,wIn+=3)
3567 w[0]=wIn[0]*cos(wIn[2])*sin(wIn[1]);
3568 w[1]=wIn[0]*sin(wIn[2])*sin(wIn[1]);
3569 w[2]=wIn[0]*cos(wIn[1]);
3575 * Computes the doubly contracted product of every tensor defined by the tuple of \a this
3576 * array contating 6 components.
3577 * \return DataArrayDouble * - the new instance of DataArrayDouble, whose each tuple
3578 * is calculated from the tuple <em>(t)</em> of \a this array as follows:
3579 * \f$ t[0]^2+t[1]^2+t[2]^2+2*t[3]^2+2*t[4]^2+2*t[5]^2\f$.
3580 * The caller is to delete this result array using decrRef() as it is no more needed.
3581 * \throw If \a this->getNumberOfComponents() != 6.
3583 DataArrayDouble *DataArrayDouble::doublyContractedProduct() const
3586 int nbOfComp=getNumberOfComponents();
3588 throw INTERP_KERNEL::Exception("DataArrayDouble::doublyContractedProduct : must be an array with exactly 6 components !");
3589 DataArrayDouble *ret=DataArrayDouble::New();
3590 int nbOfTuple=getNumberOfTuples();
3591 ret->alloc(nbOfTuple,1);
3592 const double *src=getConstPointer();
3593 double *dest=ret->getPointer();
3594 for(int i=0;i<nbOfTuple;i++,dest++,src+=6)
3595 *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];
3600 * Computes the determinant of every square matrix defined by the tuple of \a this
3601 * array, which contains either 4, 6 or 9 components. The case of 6 components
3602 * corresponds to that of the upper triangular matrix.
3603 * \return DataArrayDouble * - the new instance of DataArrayDouble, whose each tuple
3604 * is the determinant of matrix of the corresponding tuple of \a this array.
3605 * The caller is to delete this result array using decrRef() as it is no more
3607 * \throw If \a this->getNumberOfComponents() is not in [4,6,9].
3609 DataArrayDouble *DataArrayDouble::determinant() const
3612 DataArrayDouble *ret=DataArrayDouble::New();
3613 int nbOfTuple=getNumberOfTuples();
3614 ret->alloc(nbOfTuple,1);
3615 const double *src=getConstPointer();
3616 double *dest=ret->getPointer();
3617 switch(getNumberOfComponents())
3620 for(int i=0;i<nbOfTuple;i++,dest++,src+=6)
3621 *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];
3624 for(int i=0;i<nbOfTuple;i++,dest++,src+=4)
3625 *dest=src[0]*src[3]-src[1]*src[2];
3628 for(int i=0;i<nbOfTuple;i++,dest++,src+=9)
3629 *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];
3633 throw INTERP_KERNEL::Exception("DataArrayDouble::determinant : Invalid number of components ! must be in 4,6,9 !");
3638 * Computes 3 eigenvalues of every upper triangular matrix defined by the tuple of
3639 * \a this array, which contains 6 components.
3640 * \return DataArrayDouble * - the new instance of DataArrayDouble containing 3
3641 * components, whose each tuple contains the eigenvalues of the matrix of
3642 * corresponding tuple of \a this array.
3643 * The caller is to delete this result array using decrRef() as it is no more
3645 * \throw If \a this->getNumberOfComponents() != 6.
3647 DataArrayDouble *DataArrayDouble::eigenValues() const
3650 int nbOfComp=getNumberOfComponents();
3652 throw INTERP_KERNEL::Exception("DataArrayDouble::eigenValues : must be an array with exactly 6 components !");
3653 DataArrayDouble *ret=DataArrayDouble::New();
3654 int nbOfTuple=getNumberOfTuples();
3655 ret->alloc(nbOfTuple,3);
3656 const double *src=getConstPointer();
3657 double *dest=ret->getPointer();
3658 for(int i=0;i<nbOfTuple;i++,dest+=3,src+=6)
3659 INTERP_KERNEL::computeEigenValues6(src,dest);
3664 * Computes 3 eigenvectors of every upper triangular matrix defined by the tuple of
3665 * \a this array, which contains 6 components.
3666 * \return DataArrayDouble * - the new instance of DataArrayDouble containing 9
3667 * components, whose each tuple contains 3 eigenvectors of the matrix of
3668 * corresponding tuple of \a this array.
3669 * The caller is to delete this result array using decrRef() as it is no more
3671 * \throw If \a this->getNumberOfComponents() != 6.
3673 DataArrayDouble *DataArrayDouble::eigenVectors() const
3676 int nbOfComp=getNumberOfComponents();
3678 throw INTERP_KERNEL::Exception("DataArrayDouble::eigenVectors : must be an array with exactly 6 components !");
3679 DataArrayDouble *ret=DataArrayDouble::New();
3680 int nbOfTuple=getNumberOfTuples();
3681 ret->alloc(nbOfTuple,9);
3682 const double *src=getConstPointer();
3683 double *dest=ret->getPointer();
3684 for(int i=0;i<nbOfTuple;i++,src+=6)
3687 INTERP_KERNEL::computeEigenValues6(src,tmp);
3688 for(int j=0;j<3;j++,dest+=3)
3689 INTERP_KERNEL::computeEigenVectorForEigenValue6(src,tmp[j],1e-12,dest);
3695 * Computes the inverse matrix of every matrix defined by the tuple of \a this
3696 * array, which contains either 4, 6 or 9 components. The case of 6 components
3697 * corresponds to that of the upper triangular matrix.
3698 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
3699 * same number of components as \a this one, whose each tuple is the inverse
3700 * matrix of the matrix of corresponding tuple of \a this array.
3701 * The caller is to delete this result array using decrRef() as it is no more
3703 * \throw If \a this->getNumberOfComponents() is not in [4,6,9].
3705 DataArrayDouble *DataArrayDouble::inverse() const
3708 int nbOfComp=getNumberOfComponents();
3709 if(nbOfComp!=6 && nbOfComp!=9 && nbOfComp!=4)
3710 throw INTERP_KERNEL::Exception("DataArrayDouble::inversion : must be an array with 4,6 or 9 components !");
3711 DataArrayDouble *ret=DataArrayDouble::New();
3712 int nbOfTuple=getNumberOfTuples();
3713 ret->alloc(nbOfTuple,nbOfComp);
3714 const double *src=getConstPointer();
3715 double *dest=ret->getPointer();
3717 for(int i=0;i<nbOfTuple;i++,dest+=6,src+=6)
3719 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];
3720 dest[0]=(src[1]*src[2]-src[4]*src[4])/det;
3721 dest[1]=(src[0]*src[2]-src[5]*src[5])/det;
3722 dest[2]=(src[0]*src[1]-src[3]*src[3])/det;
3723 dest[3]=(src[5]*src[4]-src[3]*src[2])/det;
3724 dest[4]=(src[5]*src[3]-src[0]*src[4])/det;
3725 dest[5]=(src[3]*src[4]-src[1]*src[5])/det;
3727 else if(nbOfComp==4)
3728 for(int i=0;i<nbOfTuple;i++,dest+=4,src+=4)
3730 double det=src[0]*src[3]-src[1]*src[2];
3732 dest[1]=-src[1]/det;
3733 dest[2]=-src[2]/det;
3737 for(int i=0;i<nbOfTuple;i++,dest+=9,src+=9)
3739 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];
3740 dest[0]=(src[4]*src[8]-src[7]*src[5])/det;
3741 dest[1]=(src[7]*src[2]-src[1]*src[8])/det;
3742 dest[2]=(src[1]*src[5]-src[4]*src[2])/det;
3743 dest[3]=(src[6]*src[5]-src[3]*src[8])/det;
3744 dest[4]=(src[0]*src[8]-src[6]*src[2])/det;
3745 dest[5]=(src[2]*src[3]-src[0]*src[5])/det;
3746 dest[6]=(src[3]*src[7]-src[6]*src[4])/det;
3747 dest[7]=(src[6]*src[1]-src[0]*src[7])/det;
3748 dest[8]=(src[0]*src[4]-src[1]*src[3])/det;
3754 * Computes the trace of every matrix defined by the tuple of \a this
3755 * array, which contains either 4, 6 or 9 components. The case of 6 components
3756 * corresponds to that of the upper triangular matrix.
3757 * \return DataArrayDouble * - the new instance of DataArrayDouble containing
3758 * 1 component, whose each tuple is the trace of
3759 * the matrix of corresponding tuple of \a this array.
3760 * The caller is to delete this result array using decrRef() as it is no more
3762 * \throw If \a this->getNumberOfComponents() is not in [4,6,9].
3764 DataArrayDouble *DataArrayDouble::trace() const
3767 int nbOfComp=getNumberOfComponents();
3768 if(nbOfComp!=6 && nbOfComp!=9 && nbOfComp!=4)
3769 throw INTERP_KERNEL::Exception("DataArrayDouble::trace : must be an array with 4,6 or 9 components !");
3770 DataArrayDouble *ret=DataArrayDouble::New();
3771 int nbOfTuple=getNumberOfTuples();
3772 ret->alloc(nbOfTuple,1);
3773 const double *src=getConstPointer();
3774 double *dest=ret->getPointer();
3776 for(int i=0;i<nbOfTuple;i++,dest++,src+=6)
3777 *dest=src[0]+src[1]+src[2];
3778 else if(nbOfComp==4)
3779 for(int i=0;i<nbOfTuple;i++,dest++,src+=4)
3780 *dest=src[0]+src[3];
3782 for(int i=0;i<nbOfTuple;i++,dest++,src+=9)
3783 *dest=src[0]+src[4]+src[8];
3788 * Computes the stress deviator tensor of every stress tensor defined by the tuple of
3789 * \a this array, which contains 6 components.
3790 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
3791 * same number of components and tuples as \a this array.
3792 * The caller is to delete this result array using decrRef() as it is no more
3794 * \throw If \a this->getNumberOfComponents() != 6.
3796 DataArrayDouble *DataArrayDouble::deviator() const
3799 int nbOfComp=getNumberOfComponents();
3801 throw INTERP_KERNEL::Exception("DataArrayDouble::deviator : must be an array with exactly 6 components !");
3802 DataArrayDouble *ret=DataArrayDouble::New();
3803 int nbOfTuple=getNumberOfTuples();
3804 ret->alloc(nbOfTuple,6);
3805 const double *src=getConstPointer();
3806 double *dest=ret->getPointer();
3807 for(int i=0;i<nbOfTuple;i++,dest+=6,src+=6)
3809 double tr=(src[0]+src[1]+src[2])/3.;
3821 * Computes the magnitude of every vector defined by the tuple of
3823 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
3824 * same number of tuples as \a this array and one component.
3825 * The caller is to delete this result array using decrRef() as it is no more
3827 * \throw If \a this is not allocated.
3829 DataArrayDouble *DataArrayDouble::magnitude() const
3832 int nbOfComp=getNumberOfComponents();
3833 DataArrayDouble *ret=DataArrayDouble::New();
3834 int nbOfTuple=getNumberOfTuples();
3835 ret->alloc(nbOfTuple,1);
3836 const double *src=getConstPointer();
3837 double *dest=ret->getPointer();
3838 for(int i=0;i<nbOfTuple;i++,dest++)
3841 for(int j=0;j<nbOfComp;j++,src++)
3849 * Computes for each tuple the sum of number of components values in the tuple and return it.
3851 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
3852 * same number of tuples as \a this array and one component.
3853 * The caller is to delete this result array using decrRef() as it is no more
3855 * \throw If \a this is not allocated.
3857 DataArrayDouble *DataArrayDouble::sumPerTuple() const
3860 int nbOfComp(getNumberOfComponents()),nbOfTuple(getNumberOfTuples());
3861 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret(DataArrayDouble::New());
3862 ret->alloc(nbOfTuple,1);
3863 const double *src(getConstPointer());
3864 double *dest(ret->getPointer());
3865 for(int i=0;i<nbOfTuple;i++,dest++,src+=nbOfComp)
3866 *dest=std::accumulate(src,src+nbOfComp,0.);
3871 * Computes the maximal value within every tuple of \a this array.
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::maxPerTupleWithCompoId
3879 DataArrayDouble *DataArrayDouble::maxPerTuple() const
3882 int nbOfComp=getNumberOfComponents();
3883 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
3884 int nbOfTuple=getNumberOfTuples();
3885 ret->alloc(nbOfTuple,1);
3886 const double *src=getConstPointer();
3887 double *dest=ret->getPointer();
3888 for(int i=0;i<nbOfTuple;i++,dest++,src+=nbOfComp)
3889 *dest=*std::max_element(src,src+nbOfComp);
3894 * Computes the maximal value within every tuple of \a this array and it returns the first component
3895 * id for each tuple that corresponds to the maximal value within the tuple.
3897 * \param [out] compoIdOfMaxPerTuple - the new new instance of DataArrayInt containing the
3898 * same number of tuples and only one component.
3899 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
3900 * same number of tuples as \a this array and one component.
3901 * The caller is to delete this result array using decrRef() as it is no more
3903 * \throw If \a this is not allocated.
3904 * \sa DataArrayDouble::maxPerTuple
3906 DataArrayDouble *DataArrayDouble::maxPerTupleWithCompoId(DataArrayInt* &compoIdOfMaxPerTuple) const
3909 int nbOfComp=getNumberOfComponents();
3910 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret0=DataArrayDouble::New();
3911 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret1=DataArrayInt::New();
3912 int nbOfTuple=getNumberOfTuples();
3913 ret0->alloc(nbOfTuple,1); ret1->alloc(nbOfTuple,1);
3914 const double *src=getConstPointer();
3915 double *dest=ret0->getPointer(); int *dest1=ret1->getPointer();
3916 for(int i=0;i<nbOfTuple;i++,dest++,dest1++,src+=nbOfComp)
3918 const double *loc=std::max_element(src,src+nbOfComp);
3920 *dest1=(int)std::distance(src,loc);
3922 compoIdOfMaxPerTuple=ret1.retn();
3927 * This method returns a newly allocated DataArrayDouble instance having one component and \c this->getNumberOfTuples() * \c this->getNumberOfTuples() tuples.
3928 * \n This returned array contains the euclidian distance for each tuple in \a this.
3929 * \n So the returned array can be seen as a dense symmetrical matrix whose diagonal elements are equal to 0.
3930 * \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)
3932 * \warning use this method with care because it can leads to big amount of consumed memory !
3934 * \return A newly allocated (huge) ParaMEDMEM::DataArrayDouble instance that the caller should deal with.
3936 * \throw If \a this is not allocated.
3938 * \sa DataArrayDouble::buildEuclidianDistanceDenseMatrixWith
3940 DataArrayDouble *DataArrayDouble::buildEuclidianDistanceDenseMatrix() const
3943 int nbOfComp=getNumberOfComponents();
3944 int nbOfTuples=getNumberOfTuples();
3945 const double *inData=getConstPointer();
3946 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
3947 ret->alloc(nbOfTuples*nbOfTuples,1);
3948 double *outData=ret->getPointer();
3949 for(int i=0;i<nbOfTuples;i++)
3951 outData[i*nbOfTuples+i]=0.;
3952 for(int j=i+1;j<nbOfTuples;j++)
3955 for(int k=0;k<nbOfComp;k++)
3956 { double delta=inData[i*nbOfComp+k]-inData[j*nbOfComp+k]; dist+=delta*delta; }
3958 outData[i*nbOfTuples+j]=dist;
3959 outData[j*nbOfTuples+i]=dist;
3966 * This method returns a newly allocated DataArrayDouble instance having one component and \c this->getNumberOfTuples() * \c other->getNumberOfTuples() tuples.
3967 * \n This returned array contains the euclidian distance for each tuple in \a other with each tuple in \a this.
3968 * \n So the returned array can be seen as a dense rectangular matrix with \c other->getNumberOfTuples() rows and \c this->getNumberOfTuples() columns.
3969 * \n Output rectangular matrix is sorted along rows.
3970 * \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)
3972 * \warning use this method with care because it can leads to big amount of consumed memory !
3974 * \param [in] other DataArrayDouble instance having same number of components than \a this.
3975 * \return A newly allocated (huge) ParaMEDMEM::DataArrayDouble instance that the caller should deal with.
3977 * \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.
3979 * \sa DataArrayDouble::buildEuclidianDistanceDenseMatrix
3981 DataArrayDouble *DataArrayDouble::buildEuclidianDistanceDenseMatrixWith(const DataArrayDouble *other) const
3984 throw INTERP_KERNEL::Exception("DataArrayDouble::buildEuclidianDistanceDenseMatrixWith : input parameter is null !");
3986 other->checkAllocated();
3987 int nbOfComp=getNumberOfComponents();
3988 int otherNbOfComp=other->getNumberOfComponents();
3989 if(nbOfComp!=otherNbOfComp)
3991 std::ostringstream oss; oss << "DataArrayDouble::buildEuclidianDistanceDenseMatrixWith : this nb of compo=" << nbOfComp << " and other nb of compo=" << otherNbOfComp << ". It should match !";
3992 throw INTERP_KERNEL::Exception(oss.str().c_str());
3994 int nbOfTuples=getNumberOfTuples();
3995 int otherNbOfTuples=other->getNumberOfTuples();
3996 const double *inData=getConstPointer();
3997 const double *inDataOther=other->getConstPointer();
3998 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
3999 ret->alloc(otherNbOfTuples*nbOfTuples,1);
4000 double *outData=ret->getPointer();
4001 for(int i=0;i<otherNbOfTuples;i++,inDataOther+=nbOfComp)
4003 for(int j=0;j<nbOfTuples;j++)
4006 for(int k=0;k<nbOfComp;k++)
4007 { double delta=inDataOther[k]-inData[j*nbOfComp+k]; dist+=delta*delta; }
4009 outData[i*nbOfTuples+j]=dist;
4016 * Sorts value within every tuple of \a this array.
4017 * \param [in] asc - if \a true, the values are sorted in ascending order, else,
4018 * in descending order.
4019 * \throw If \a this is not allocated.
4021 void DataArrayDouble::sortPerTuple(bool asc)
4024 double *pt=getPointer();
4025 int nbOfTuple=getNumberOfTuples();
4026 int nbOfComp=getNumberOfComponents();
4028 for(int i=0;i<nbOfTuple;i++,pt+=nbOfComp)
4029 std::sort(pt,pt+nbOfComp);
4031 for(int i=0;i<nbOfTuple;i++,pt+=nbOfComp)
4032 std::sort(pt,pt+nbOfComp,std::greater<double>());
4037 * Converts every value of \a this array to its absolute value.
4038 * \b WARNING this method is non const. If a new DataArrayDouble instance should be built containing the result of abs DataArrayDouble::computeAbs
4039 * should be called instead.
4041 * \throw If \a this is not allocated.
4042 * \sa DataArrayDouble::computeAbs
4044 void DataArrayDouble::abs()
4047 double *ptr(getPointer());
4048 std::size_t nbOfElems(getNbOfElems());
4049 std::transform(ptr,ptr+nbOfElems,ptr,std::ptr_fun<double,double>(fabs));
4054 * This method builds a new instance of \a this object containing the result of std::abs applied of all elements in \a this.
4055 * This method is a const method (that do not change any values in \a this) contrary to DataArrayDouble::abs method.
4057 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
4058 * same number of tuples and component as \a this array.
4059 * The caller is to delete this result array using decrRef() as it is no more
4061 * \throw If \a this is not allocated.
4062 * \sa DataArrayDouble::abs
4064 DataArrayDouble *DataArrayDouble::computeAbs() const
4067 DataArrayDouble *newArr(DataArrayDouble::New());
4068 int nbOfTuples(getNumberOfTuples());
4069 int nbOfComp(getNumberOfComponents());
4070 newArr->alloc(nbOfTuples,nbOfComp);
4071 std::transform(begin(),end(),newArr->getPointer(),std::ptr_fun<double,double>(fabs));
4072 newArr->copyStringInfoFrom(*this);
4077 * Apply a liner function to a given component of \a this array, so that
4078 * an array element <em>(x)</em> becomes \f$ a * x + b \f$.
4079 * \param [in] a - the first coefficient of the function.
4080 * \param [in] b - the second coefficient of the function.
4081 * \param [in] compoId - the index of component to modify.
4082 * \throw If \a this is not allocated.
4084 void DataArrayDouble::applyLin(double a, double b, int compoId)
4087 double *ptr=getPointer()+compoId;
4088 int nbOfComp=getNumberOfComponents();
4089 int nbOfTuple=getNumberOfTuples();
4090 for(int i=0;i<nbOfTuple;i++,ptr+=nbOfComp)
4096 * Apply a liner function to all elements of \a this array, so that
4097 * an element _x_ becomes \f$ a * x + b \f$.
4098 * \param [in] a - the first coefficient of the function.
4099 * \param [in] b - the second coefficient of the function.
4100 * \throw If \a this is not allocated.
4102 void DataArrayDouble::applyLin(double a, double b)
4105 double *ptr=getPointer();
4106 std::size_t nbOfElems=getNbOfElems();
4107 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
4113 * Modify all elements of \a this array, so that
4114 * an element _x_ becomes \f$ numerator / x \f$.
4115 * \warning If an exception is thrown because of presence of 0.0 element in \a this
4116 * array, all elements processed before detection of the zero element remain
4118 * \param [in] numerator - the numerator used to modify array elements.
4119 * \throw If \a this is not allocated.
4120 * \throw If there is an element equal to 0.0 in \a this array.
4122 void DataArrayDouble::applyInv(double numerator)
4125 double *ptr=getPointer();
4126 std::size_t nbOfElems=getNbOfElems();
4127 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
4129 if(std::abs(*ptr)>std::numeric_limits<double>::min())
4131 *ptr=numerator/(*ptr);
4135 std::ostringstream oss; oss << "DataArrayDouble::applyInv : presence of null value in tuple #" << i/getNumberOfComponents() << " component #" << i%getNumberOfComponents();
4137 throw INTERP_KERNEL::Exception(oss.str().c_str());
4144 * Returns a full copy of \a this array except that sign of all elements is reversed.
4145 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
4146 * same number of tuples and component as \a this array.
4147 * The caller is to delete this result array using decrRef() as it is no more
4149 * \throw If \a this is not allocated.
4151 DataArrayDouble *DataArrayDouble::negate() const
4154 DataArrayDouble *newArr=DataArrayDouble::New();
4155 int nbOfTuples=getNumberOfTuples();
4156 int nbOfComp=getNumberOfComponents();
4157 newArr->alloc(nbOfTuples,nbOfComp);
4158 const double *cptr=getConstPointer();
4159 std::transform(cptr,cptr+nbOfTuples*nbOfComp,newArr->getPointer(),std::negate<double>());
4160 newArr->copyStringInfoFrom(*this);
4165 * Modify all elements of \a this array, so that
4166 * an element _x_ becomes <em> val ^ x </em>. Contrary to DataArrayInt::applyPow
4167 * all values in \a this have to be >= 0 if val is \b not integer.
4168 * \param [in] val - the value used to apply pow on all array elements.
4169 * \throw If \a this is not allocated.
4170 * \warning If an exception is thrown because of presence of 0 element in \a this
4171 * array and \a val is \b not integer, all elements processed before detection of the zero element remain
4174 void DataArrayDouble::applyPow(double val)
4177 double *ptr=getPointer();
4178 std::size_t nbOfElems=getNbOfElems();
4180 bool isInt=((double)val2)==val;
4183 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
4189 std::ostringstream oss; oss << "DataArrayDouble::applyPow (double) : At elem # " << i << " value is " << *ptr << " ! must be >=0. !";
4190 throw INTERP_KERNEL::Exception(oss.str().c_str());
4196 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
4197 *ptr=pow(*ptr,val2);
4203 * Modify all elements of \a this array, so that
4204 * an element _x_ becomes \f$ val ^ x \f$.
4205 * \param [in] val - the value used to apply pow on all array elements.
4206 * \throw If \a this is not allocated.
4207 * \throw If \a val < 0.
4208 * \warning If an exception is thrown because of presence of 0 element in \a this
4209 * array, all elements processed before detection of the zero element remain
4212 void DataArrayDouble::applyRPow(double val)
4216 throw INTERP_KERNEL::Exception("DataArrayDouble::applyRPow : the input value has to be >= 0 !");
4217 double *ptr=getPointer();
4218 std::size_t nbOfElems=getNbOfElems();
4219 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
4225 * Returns a new DataArrayDouble created from \a this one by applying \a
4226 * FunctionToEvaluate to every tuple of \a this array. Textual data is not copied.
4227 * For more info see \ref MEDCouplingArrayApplyFunc
4228 * \param [in] nbOfComp - number of components in the result array.
4229 * \param [in] func - the \a FunctionToEvaluate declared as
4230 * \c bool (*\a func)(\c const \c double *\a pos, \c double *\a res),
4231 * where \a pos points to the first component of a tuple of \a this array
4232 * and \a res points to the first component of a tuple of the result array.
4233 * Note that length (number of components) of \a pos can differ from
4235 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
4236 * same number of tuples as \a this array.
4237 * The caller is to delete this result array using decrRef() as it is no more
4239 * \throw If \a this is not allocated.
4240 * \throw If \a func returns \a false.
4242 DataArrayDouble *DataArrayDouble::applyFunc(int nbOfComp, FunctionToEvaluate func) const
4245 DataArrayDouble *newArr=DataArrayDouble::New();
4246 int nbOfTuples=getNumberOfTuples();
4247 int oldNbOfComp=getNumberOfComponents();
4248 newArr->alloc(nbOfTuples,nbOfComp);
4249 const double *ptr=getConstPointer();
4250 double *ptrToFill=newArr->getPointer();
4251 for(int i=0;i<nbOfTuples;i++)
4253 if(!func(ptr+i*oldNbOfComp,ptrToFill+i*nbOfComp))
4255 std::ostringstream oss; oss << "For tuple # " << i << " with value (";
4256 std::copy(ptr+oldNbOfComp*i,ptr+oldNbOfComp*(i+1),std::ostream_iterator<double>(oss,", "));
4257 oss << ") : Evaluation of function failed !";
4259 throw INTERP_KERNEL::Exception(oss.str().c_str());
4266 * Returns a new DataArrayDouble created from \a this one by applying a function to every
4267 * tuple of \a this array. Textual data is not copied.
4268 * For more info see \ref MEDCouplingArrayApplyFunc1.
4269 * \param [in] nbOfComp - number of components in the result array.
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 as \a this array and \a nbOfComp components.
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(int nbOfComp, const std::string& func) const
4282 INTERP_KERNEL::ExprParser expr(func);
4284 std::set<std::string> vars;
4285 expr.getTrueSetOfVars(vars);
4286 int oldNbOfComp=getNumberOfComponents();
4287 if((int)vars.size()>oldNbOfComp)
4289 std::ostringstream oss; oss << "The field has " << oldNbOfComp << " components and there are ";
4290 oss << vars.size() << " variables : ";
4291 std::copy(vars.begin(),vars.end(),std::ostream_iterator<std::string>(oss," "));
4292 throw INTERP_KERNEL::Exception(oss.str().c_str());
4294 std::vector<std::string> varsV(vars.begin(),vars.end());
4295 expr.prepareExprEvaluation(varsV,oldNbOfComp,nbOfComp);
4297 DataArrayDouble *newArr=DataArrayDouble::New();
4298 int nbOfTuples=getNumberOfTuples();
4299 newArr->alloc(nbOfTuples,nbOfComp);
4300 const double *ptr=getConstPointer();
4301 double *ptrToFill=newArr->getPointer();
4302 for(int i=0;i<nbOfTuples;i++)
4306 expr.evaluateExpr(nbOfComp,ptr+i*oldNbOfComp,ptrToFill+i*nbOfComp);
4308 catch(INTERP_KERNEL::Exception& e)
4310 std::ostringstream oss; oss << "For tuple # " << i << " with value (";
4311 std::copy(ptr+oldNbOfComp*i,ptr+oldNbOfComp*(i+1),std::ostream_iterator<double>(oss,", "));
4312 oss << ") : Evaluation of function failed !" << e.what();
4314 throw INTERP_KERNEL::Exception(oss.str().c_str());
4321 * Returns a new DataArrayDouble created from \a this one by applying a function to every
4322 * tuple of \a this array. Textual data is not copied.
4323 * For more info see \ref MEDCouplingArrayApplyFunc0.
4324 * \param [in] func - the expression defining how to transform a tuple of \a this array.
4325 * Supported expressions are described \ref MEDCouplingArrayApplyFuncExpr "here".
4326 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
4327 * same number of tuples and components as \a this array.
4328 * The caller is to delete this result array using decrRef() as it is no more
4330 * \throw If \a this is not allocated.
4331 * \throw If computing \a func fails.
4333 DataArrayDouble *DataArrayDouble::applyFunc(const std::string& func) const
4336 INTERP_KERNEL::ExprParser expr(func);
4338 expr.prepareExprEvaluationVec();
4340 DataArrayDouble *newArr=DataArrayDouble::New();
4341 int nbOfTuples=getNumberOfTuples();
4342 int nbOfComp=getNumberOfComponents();
4343 newArr->alloc(nbOfTuples,nbOfComp);
4344 const double *ptr=getConstPointer();
4345 double *ptrToFill=newArr->getPointer();
4346 for(int i=0;i<nbOfTuples;i++)
4350 expr.evaluateExpr(nbOfComp,ptr+i*nbOfComp,ptrToFill+i*nbOfComp);
4352 catch(INTERP_KERNEL::Exception& e)
4354 std::ostringstream oss; oss << "For tuple # " << i << " with value (";
4355 std::copy(ptr+nbOfComp*i,ptr+nbOfComp*(i+1),std::ostream_iterator<double>(oss,", "));
4356 oss << ") : Evaluation of function failed ! " << e.what();
4358 throw INTERP_KERNEL::Exception(oss.str().c_str());
4365 * Returns a new DataArrayDouble created from \a this one by applying a function to every
4366 * tuple of \a this array. Textual data is not copied.
4367 * For more info see \ref MEDCouplingArrayApplyFunc2.
4368 * \param [in] nbOfComp - number of components in the result array.
4369 * \param [in] func - the expression defining how to transform a tuple of \a this array.
4370 * Supported expressions are described \ref MEDCouplingArrayApplyFuncExpr "here".
4371 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
4372 * same number of tuples as \a this array.
4373 * The caller is to delete this result array using decrRef() as it is no more
4375 * \throw If \a this is not allocated.
4376 * \throw If \a func contains vars that are not in \a this->getInfoOnComponent().
4377 * \throw If computing \a func fails.
4379 DataArrayDouble *DataArrayDouble::applyFunc2(int nbOfComp, const std::string& func) const
4382 INTERP_KERNEL::ExprParser expr(func);
4384 std::set<std::string> vars;
4385 expr.getTrueSetOfVars(vars);
4386 int oldNbOfComp=getNumberOfComponents();
4387 if((int)vars.size()>oldNbOfComp)
4389 std::ostringstream oss; oss << "The field has " << oldNbOfComp << " components and there are ";
4390 oss << vars.size() << " variables : ";
4391 std::copy(vars.begin(),vars.end(),std::ostream_iterator<std::string>(oss," "));
4392 throw INTERP_KERNEL::Exception(oss.str().c_str());
4394 expr.prepareExprEvaluation(getVarsOnComponent(),oldNbOfComp,nbOfComp);
4396 DataArrayDouble *newArr=DataArrayDouble::New();
4397 int nbOfTuples=getNumberOfTuples();
4398 newArr->alloc(nbOfTuples,nbOfComp);
4399 const double *ptr=getConstPointer();
4400 double *ptrToFill=newArr->getPointer();
4401 for(int i=0;i<nbOfTuples;i++)
4405 expr.evaluateExpr(nbOfComp,ptr+i*oldNbOfComp,ptrToFill+i*nbOfComp);
4407 catch(INTERP_KERNEL::Exception& e)
4409 std::ostringstream oss; oss << "For tuple # " << i << " with value (";
4410 std::copy(ptr+oldNbOfComp*i,ptr+oldNbOfComp*(i+1),std::ostream_iterator<double>(oss,", "));
4411 oss << ") : Evaluation of function failed !" << e.what();
4413 throw INTERP_KERNEL::Exception(oss.str().c_str());
4420 * Returns a new DataArrayDouble created from \a this one by applying a function to every
4421 * tuple of \a this array. Textual data is not copied.
4422 * For more info see \ref MEDCouplingArrayApplyFunc3.
4423 * \param [in] nbOfComp - number of components in the result array.
4424 * \param [in] varsOrder - sequence of vars defining their order.
4425 * \param [in] func - the expression defining how to transform a tuple of \a this array.
4426 * Supported expressions are described \ref MEDCouplingArrayApplyFuncExpr "here".
4427 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
4428 * same number of tuples as \a this array.
4429 * The caller is to delete this result array using decrRef() as it is no more
4431 * \throw If \a this is not allocated.
4432 * \throw If \a func contains vars not in \a varsOrder.
4433 * \throw If computing \a func fails.
4435 DataArrayDouble *DataArrayDouble::applyFunc3(int nbOfComp, const std::vector<std::string>& varsOrder, const std::string& func) const
4438 INTERP_KERNEL::ExprParser expr(func);
4440 std::set<std::string> vars;
4441 expr.getTrueSetOfVars(vars);
4442 int oldNbOfComp=getNumberOfComponents();
4443 if((int)vars.size()>oldNbOfComp)
4445 std::ostringstream oss; oss << "The field has " << oldNbOfComp << " components and there are ";
4446 oss << vars.size() << " variables : ";
4447 std::copy(vars.begin(),vars.end(),std::ostream_iterator<std::string>(oss," "));
4448 throw INTERP_KERNEL::Exception(oss.str().c_str());
4450 expr.prepareExprEvaluation(varsOrder,oldNbOfComp,nbOfComp);
4452 DataArrayDouble *newArr=DataArrayDouble::New();
4453 int nbOfTuples=getNumberOfTuples();
4454 newArr->alloc(nbOfTuples,nbOfComp);
4455 const double *ptr=getConstPointer();
4456 double *ptrToFill=newArr->getPointer();
4457 for(int i=0;i<nbOfTuples;i++)
4461 expr.evaluateExpr(nbOfComp,ptr+i*oldNbOfComp,ptrToFill+i*nbOfComp);
4463 catch(INTERP_KERNEL::Exception& e)
4465 std::ostringstream oss; oss << "For tuple # " << i << " with value (";
4466 std::copy(ptr+oldNbOfComp*i,ptr+oldNbOfComp*(i+1),std::ostream_iterator<double>(oss,", "));
4467 oss << ") : Evaluation of function failed !" << e.what();
4469 throw INTERP_KERNEL::Exception(oss.str().c_str());
4475 void DataArrayDouble::applyFuncFast32(const std::string& func)
4478 INTERP_KERNEL::ExprParser expr(func);
4480 char *funcStr=expr.compileX86();
4482 *((void **)&funcPtr)=funcStr;//he he...
4484 double *ptr=getPointer();
4485 int nbOfComp=getNumberOfComponents();
4486 int nbOfTuples=getNumberOfTuples();
4487 int nbOfElems=nbOfTuples*nbOfComp;
4488 for(int i=0;i<nbOfElems;i++,ptr++)
4493 void DataArrayDouble::applyFuncFast64(const std::string& func)
4496 INTERP_KERNEL::ExprParser expr(func);
4498 char *funcStr=expr.compileX86_64();
4500 *((void **)&funcPtr)=funcStr;//he he...
4502 double *ptr=getPointer();
4503 int nbOfComp=getNumberOfComponents();
4504 int nbOfTuples=getNumberOfTuples();
4505 int nbOfElems=nbOfTuples*nbOfComp;
4506 for(int i=0;i<nbOfElems;i++,ptr++)
4511 DataArrayDoubleIterator *DataArrayDouble::iterator()
4513 return new DataArrayDoubleIterator(this);
4517 * Returns a new DataArrayInt contating indices of tuples of \a this one-dimensional
4518 * array whose values are within a given range. Textual data is not copied.
4519 * \param [in] vmin - a lowest acceptable value (included).
4520 * \param [in] vmax - a greatest acceptable value (included).
4521 * \return DataArrayInt * - the new instance of DataArrayInt.
4522 * The caller is to delete this result array using decrRef() as it is no more
4524 * \throw If \a this->getNumberOfComponents() != 1.
4526 * \sa DataArrayDouble::getIdsNotInRange
4528 * \ref cpp_mcdataarraydouble_getidsinrange "Here is a C++ example".<br>
4529 * \ref py_mcdataarraydouble_getidsinrange "Here is a Python example".
4531 DataArrayInt *DataArrayDouble::getIdsInRange(double vmin, double vmax) const
4534 if(getNumberOfComponents()!=1)
4535 throw INTERP_KERNEL::Exception("DataArrayDouble::getIdsInRange : this must have exactly one component !");
4536 const double *cptr(begin());
4537 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
4538 int nbOfTuples(getNumberOfTuples());
4539 for(int i=0;i<nbOfTuples;i++,cptr++)
4540 if(*cptr>=vmin && *cptr<=vmax)
4541 ret->pushBackSilent(i);
4546 * Returns a new DataArrayInt contating indices of tuples of \a this one-dimensional
4547 * array whose values are not within a given range. Textual data is not copied.
4548 * \param [in] vmin - a lowest not acceptable value (excluded).
4549 * \param [in] vmax - a greatest not acceptable value (excluded).
4550 * \return DataArrayInt * - the new instance of DataArrayInt.
4551 * The caller is to delete this result array using decrRef() as it is no more
4553 * \throw If \a this->getNumberOfComponents() != 1.
4555 * \sa DataArrayDouble::getIdsInRange
4557 DataArrayInt *DataArrayDouble::getIdsNotInRange(double vmin, double vmax) const
4560 if(getNumberOfComponents()!=1)
4561 throw INTERP_KERNEL::Exception("DataArrayDouble::getIdsNotInRange : this must have exactly one component !");
4562 const double *cptr(begin());
4563 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
4564 int nbOfTuples(getNumberOfTuples());
4565 for(int i=0;i<nbOfTuples;i++,cptr++)
4566 if(*cptr<vmin || *cptr>vmax)
4567 ret->pushBackSilent(i);
4572 * Returns a new DataArrayDouble by concatenating two given arrays, so that (1) the number
4573 * of tuples in the result array is a sum of the number of tuples of given arrays and (2)
4574 * the number of component in the result array is same as that of each of given arrays.
4575 * Info on components is copied from the first of the given arrays. Number of components
4576 * in the given arrays must be the same.
4577 * \param [in] a1 - an array to include in the result array.
4578 * \param [in] a2 - another array to include in the result array.
4579 * \return DataArrayDouble * - the new instance of DataArrayDouble.
4580 * The caller is to delete this result array using decrRef() as it is no more
4582 * \throw If both \a a1 and \a a2 are NULL.
4583 * \throw If \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents().
4585 DataArrayDouble *DataArrayDouble::Aggregate(const DataArrayDouble *a1, const DataArrayDouble *a2)
4587 std::vector<const DataArrayDouble *> tmp(2);
4588 tmp[0]=a1; tmp[1]=a2;
4589 return Aggregate(tmp);
4593 * Returns a new DataArrayDouble by concatenating all given arrays, so that (1) the number
4594 * of tuples in the result array is a sum of the number of tuples of given arrays and (2)
4595 * the number of component in the result array is same as that of each of given arrays.
4596 * Info on components is copied from the first of the given arrays. Number of components
4597 * in the given arrays must be the same.
4598 * If the number of non null of elements in \a arr is equal to one the returned object is a copy of it
4599 * not the object itself.
4600 * \param [in] arr - a sequence of arrays to include in the result array.
4601 * \return DataArrayDouble * - the new instance of DataArrayDouble.
4602 * The caller is to delete this result array using decrRef() as it is no more
4604 * \throw If all arrays within \a arr are NULL.
4605 * \throw If getNumberOfComponents() of arrays within \a arr.
4607 DataArrayDouble *DataArrayDouble::Aggregate(const std::vector<const DataArrayDouble *>& arr)
4609 std::vector<const DataArrayDouble *> a;
4610 for(std::vector<const DataArrayDouble *>::const_iterator it4=arr.begin();it4!=arr.end();it4++)
4614 throw INTERP_KERNEL::Exception("DataArrayDouble::Aggregate : input list must contain at least one NON EMPTY DataArrayDouble !");
4615 std::vector<const DataArrayDouble *>::const_iterator it=a.begin();
4616 int nbOfComp=(*it)->getNumberOfComponents();
4617 int nbt=(*it++)->getNumberOfTuples();
4618 for(int i=1;it!=a.end();it++,i++)
4620 if((*it)->getNumberOfComponents()!=nbOfComp)
4621 throw INTERP_KERNEL::Exception("DataArrayDouble::Aggregate : Nb of components mismatch for array aggregation !");
4622 nbt+=(*it)->getNumberOfTuples();
4624 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
4625 ret->alloc(nbt,nbOfComp);
4626 double *pt=ret->getPointer();
4627 for(it=a.begin();it!=a.end();it++)
4628 pt=std::copy((*it)->getConstPointer(),(*it)->getConstPointer()+(*it)->getNbOfElems(),pt);
4629 ret->copyStringInfoFrom(*(a[0]));
4634 * Returns a new DataArrayDouble by aggregating two given arrays, so that (1) the number
4635 * of components in the result array is a sum of the number of components of given arrays
4636 * and (2) the number of tuples in the result array is same as that of each of given
4637 * arrays. In other words the i-th tuple of result array includes all components of
4638 * i-th tuples of all given arrays.
4639 * Number of tuples in the given arrays must be the same.
4640 * \param [in] a1 - an array to include in the result array.
4641 * \param [in] a2 - another array to include in the result array.
4642 * \return DataArrayDouble * - the new instance of DataArrayDouble.
4643 * The caller is to delete this result array using decrRef() as it is no more
4645 * \throw If both \a a1 and \a a2 are NULL.
4646 * \throw If any given array is not allocated.
4647 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
4649 DataArrayDouble *DataArrayDouble::Meld(const DataArrayDouble *a1, const DataArrayDouble *a2)
4651 std::vector<const DataArrayDouble *> arr(2);
4652 arr[0]=a1; arr[1]=a2;
4657 * Returns a new DataArrayDouble by aggregating all given arrays, so that (1) the number
4658 * of components in the result array is a sum of the number of components of given arrays
4659 * and (2) the number of tuples in the result array is same as that of each of given
4660 * arrays. In other words the i-th tuple of result array includes all components of
4661 * i-th tuples of all given arrays.
4662 * Number of tuples in the given arrays must be the same.
4663 * \param [in] arr - a sequence of arrays to include in the result 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 all arrays within \a arr are NULL.
4668 * \throw If any given array is not allocated.
4669 * \throw If getNumberOfTuples() of arrays within \a arr is different.
4671 DataArrayDouble *DataArrayDouble::Meld(const std::vector<const DataArrayDouble *>& arr)
4673 std::vector<const DataArrayDouble *> a;
4674 for(std::vector<const DataArrayDouble *>::const_iterator it4=arr.begin();it4!=arr.end();it4++)
4678 throw INTERP_KERNEL::Exception("DataArrayDouble::Meld : input list must contain at least one NON EMPTY DataArrayDouble !");
4679 std::vector<const DataArrayDouble *>::const_iterator it;
4680 for(it=a.begin();it!=a.end();it++)
4681 (*it)->checkAllocated();
4683 int nbOfTuples=(*it)->getNumberOfTuples();
4684 std::vector<int> nbc(a.size());
4685 std::vector<const double *> pts(a.size());
4686 nbc[0]=(*it)->getNumberOfComponents();
4687 pts[0]=(*it++)->getConstPointer();
4688 for(int i=1;it!=a.end();it++,i++)
4690 if(nbOfTuples!=(*it)->getNumberOfTuples())
4691 throw INTERP_KERNEL::Exception("DataArrayDouble::Meld : mismatch of number of tuples !");
4692 nbc[i]=(*it)->getNumberOfComponents();
4693 pts[i]=(*it)->getConstPointer();
4695 int totalNbOfComp=std::accumulate(nbc.begin(),nbc.end(),0);
4696 DataArrayDouble *ret=DataArrayDouble::New();
4697 ret->alloc(nbOfTuples,totalNbOfComp);
4698 double *retPtr=ret->getPointer();
4699 for(int i=0;i<nbOfTuples;i++)
4700 for(int j=0;j<(int)a.size();j++)
4702 retPtr=std::copy(pts[j],pts[j]+nbc[j],retPtr);
4706 for(int i=0;i<(int)a.size();i++)
4707 for(int j=0;j<nbc[i];j++,k++)
4708 ret->setInfoOnComponent(k,a[i]->getInfoOnComponent(j));
4713 * Returns a new DataArrayDouble containing a dot product of two given arrays, so that
4714 * the i-th tuple of the result array is a sum of products of j-th components of i-th
4715 * tuples of given arrays (\f$ a_i = \sum_{j=1}^n a1_j * a2_j \f$).
4716 * Info on components and name is copied from the first of the given arrays.
4717 * Number of tuples and components in the given arrays must be the same.
4718 * \param [in] a1 - a given array.
4719 * \param [in] a2 - another given array.
4720 * \return DataArrayDouble * - the new instance of DataArrayDouble.
4721 * The caller is to delete this result array using decrRef() as it is no more
4723 * \throw If either \a a1 or \a a2 is NULL.
4724 * \throw If any given array is not allocated.
4725 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
4726 * \throw If \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents()
4728 DataArrayDouble *DataArrayDouble::Dot(const DataArrayDouble *a1, const DataArrayDouble *a2)
4731 throw INTERP_KERNEL::Exception("DataArrayDouble::Dot : input DataArrayDouble instance is NULL !");
4732 a1->checkAllocated();
4733 a2->checkAllocated();
4734 int nbOfComp=a1->getNumberOfComponents();
4735 if(nbOfComp!=a2->getNumberOfComponents())
4736 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Dot !");
4737 int nbOfTuple=a1->getNumberOfTuples();
4738 if(nbOfTuple!=a2->getNumberOfTuples())
4739 throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array Dot !");
4740 DataArrayDouble *ret=DataArrayDouble::New();
4741 ret->alloc(nbOfTuple,1);
4742 double *retPtr=ret->getPointer();
4743 const double *a1Ptr=a1->getConstPointer();
4744 const double *a2Ptr=a2->getConstPointer();
4745 for(int i=0;i<nbOfTuple;i++)
4748 for(int j=0;j<nbOfComp;j++)
4749 sum+=a1Ptr[i*nbOfComp+j]*a2Ptr[i*nbOfComp+j];
4752 ret->setInfoOnComponent(0,a1->getInfoOnComponent(0));
4753 ret->setName(a1->getName());
4758 * Returns a new DataArrayDouble containing a cross product of two given arrays, so that
4759 * the i-th tuple of the result array contains 3 components of a vector which is a cross
4760 * product of two vectors defined by the i-th tuples of given arrays.
4761 * Info on components is copied from the first of the given arrays.
4762 * Number of tuples in the given arrays must be the same.
4763 * Number of components in the given arrays must be 3.
4764 * \param [in] a1 - a given array.
4765 * \param [in] a2 - another given array.
4766 * \return DataArrayDouble * - the new instance of DataArrayDouble.
4767 * The caller is to delete this result array using decrRef() as it is no more
4769 * \throw If either \a a1 or \a a2 is NULL.
4770 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
4771 * \throw If \a a1->getNumberOfComponents() != 3
4772 * \throw If \a a2->getNumberOfComponents() != 3
4774 DataArrayDouble *DataArrayDouble::CrossProduct(const DataArrayDouble *a1, const DataArrayDouble *a2)
4777 throw INTERP_KERNEL::Exception("DataArrayDouble::CrossProduct : input DataArrayDouble instance is NULL !");
4778 int nbOfComp=a1->getNumberOfComponents();
4779 if(nbOfComp!=a2->getNumberOfComponents())
4780 throw INTERP_KERNEL::Exception("Nb of components mismatch for array crossProduct !");
4782 throw INTERP_KERNEL::Exception("Nb of components must be equal to 3 for array crossProduct !");
4783 int nbOfTuple=a1->getNumberOfTuples();
4784 if(nbOfTuple!=a2->getNumberOfTuples())
4785 throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array crossProduct !");
4786 DataArrayDouble *ret=DataArrayDouble::New();
4787 ret->alloc(nbOfTuple,3);
4788 double *retPtr=ret->getPointer();
4789 const double *a1Ptr=a1->getConstPointer();
4790 const double *a2Ptr=a2->getConstPointer();
4791 for(int i=0;i<nbOfTuple;i++)
4793 retPtr[3*i]=a1Ptr[3*i+1]*a2Ptr[3*i+2]-a1Ptr[3*i+2]*a2Ptr[3*i+1];
4794 retPtr[3*i+1]=a1Ptr[3*i+2]*a2Ptr[3*i]-a1Ptr[3*i]*a2Ptr[3*i+2];
4795 retPtr[3*i+2]=a1Ptr[3*i]*a2Ptr[3*i+1]-a1Ptr[3*i+1]*a2Ptr[3*i];
4797 ret->copyStringInfoFrom(*a1);
4802 * Returns a new DataArrayDouble containing maximal values of two given arrays.
4803 * Info on components is copied from the first of the given arrays.
4804 * Number of tuples and components in the given arrays must be the same.
4805 * \param [in] a1 - an array to compare values with another one.
4806 * \param [in] a2 - another array to compare values with the first one.
4807 * \return DataArrayDouble * - the new instance of DataArrayDouble.
4808 * The caller is to delete this result array using decrRef() as it is no more
4810 * \throw If either \a a1 or \a a2 is NULL.
4811 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
4812 * \throw If \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents()
4814 DataArrayDouble *DataArrayDouble::Max(const DataArrayDouble *a1, const DataArrayDouble *a2)
4817 throw INTERP_KERNEL::Exception("DataArrayDouble::Max : input DataArrayDouble instance is NULL !");
4818 int nbOfComp=a1->getNumberOfComponents();
4819 if(nbOfComp!=a2->getNumberOfComponents())
4820 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Max !");
4821 int nbOfTuple=a1->getNumberOfTuples();
4822 if(nbOfTuple!=a2->getNumberOfTuples())
4823 throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array Max !");
4824 DataArrayDouble *ret=DataArrayDouble::New();
4825 ret->alloc(nbOfTuple,nbOfComp);
4826 double *retPtr=ret->getPointer();
4827 const double *a1Ptr=a1->getConstPointer();
4828 const double *a2Ptr=a2->getConstPointer();
4829 int nbElem=nbOfTuple*nbOfComp;
4830 for(int i=0;i<nbElem;i++)
4831 retPtr[i]=std::max(a1Ptr[i],a2Ptr[i]);
4832 ret->copyStringInfoFrom(*a1);
4837 * Returns a new DataArrayDouble containing minimal values of two given arrays.
4838 * Info on components is copied from the first of the given arrays.
4839 * Number of tuples and components in the given arrays must be the same.
4840 * \param [in] a1 - an array to compare values with another one.
4841 * \param [in] a2 - another array to compare values with the first one.
4842 * \return DataArrayDouble * - the new instance of DataArrayDouble.
4843 * The caller is to delete this result array using decrRef() as it is no more
4845 * \throw If either \a a1 or \a a2 is NULL.
4846 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
4847 * \throw If \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents()
4849 DataArrayDouble *DataArrayDouble::Min(const DataArrayDouble *a1, const DataArrayDouble *a2)
4852 throw INTERP_KERNEL::Exception("DataArrayDouble::Min : input DataArrayDouble instance is NULL !");
4853 int nbOfComp=a1->getNumberOfComponents();
4854 if(nbOfComp!=a2->getNumberOfComponents())
4855 throw INTERP_KERNEL::Exception("Nb of components mismatch for array min !");
4856 int nbOfTuple=a1->getNumberOfTuples();
4857 if(nbOfTuple!=a2->getNumberOfTuples())
4858 throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array min !");
4859 DataArrayDouble *ret=DataArrayDouble::New();
4860 ret->alloc(nbOfTuple,nbOfComp);
4861 double *retPtr=ret->getPointer();
4862 const double *a1Ptr=a1->getConstPointer();
4863 const double *a2Ptr=a2->getConstPointer();
4864 int nbElem=nbOfTuple*nbOfComp;
4865 for(int i=0;i<nbElem;i++)
4866 retPtr[i]=std::min(a1Ptr[i],a2Ptr[i]);
4867 ret->copyStringInfoFrom(*a1);
4872 * Returns a new DataArrayDouble that is a sum of two given arrays. There are 3
4874 * 1. The arrays have same number of tuples and components. Then each value of
4875 * the result array (_a_) is a sum of the corresponding values of \a a1 and \a a2,
4876 * i.e.: _a_ [ i, j ] = _a1_ [ i, j ] + _a2_ [ i, j ].
4877 * 2. The arrays have same number of tuples and one array, say _a2_, has one
4879 * _a_ [ i, j ] = _a1_ [ i, j ] + _a2_ [ i, 0 ].
4880 * 3. The arrays have same number of components and one array, say _a2_, has one
4882 * _a_ [ i, j ] = _a1_ [ i, j ] + _a2_ [ 0, j ].
4884 * Info on components is copied either from the first array (in the first case) or from
4885 * the array with maximal number of elements (getNbOfElems()).
4886 * \param [in] a1 - an array to sum up.
4887 * \param [in] a2 - another array to sum up.
4888 * \return DataArrayDouble * - the new instance of DataArrayDouble.
4889 * The caller is to delete this result array using decrRef() as it is no more
4891 * \throw If either \a a1 or \a a2 is NULL.
4892 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
4893 * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
4894 * none of them has number of tuples or components equal to 1.
4896 DataArrayDouble *DataArrayDouble::Add(const DataArrayDouble *a1, const DataArrayDouble *a2)
4899 throw INTERP_KERNEL::Exception("DataArrayDouble::Add : input DataArrayDouble instance is NULL !");
4900 int nbOfTuple=a1->getNumberOfTuples();
4901 int nbOfTuple2=a2->getNumberOfTuples();
4902 int nbOfComp=a1->getNumberOfComponents();
4903 int nbOfComp2=a2->getNumberOfComponents();
4904 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=0;
4905 if(nbOfTuple==nbOfTuple2)
4907 if(nbOfComp==nbOfComp2)
4909 ret=DataArrayDouble::New();
4910 ret->alloc(nbOfTuple,nbOfComp);
4911 std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::plus<double>());
4912 ret->copyStringInfoFrom(*a1);
4916 int nbOfCompMin,nbOfCompMax;
4917 const DataArrayDouble *aMin, *aMax;
4918 if(nbOfComp>nbOfComp2)
4920 nbOfCompMin=nbOfComp2; nbOfCompMax=nbOfComp;
4925 nbOfCompMin=nbOfComp; nbOfCompMax=nbOfComp2;
4930 ret=DataArrayDouble::New();
4931 ret->alloc(nbOfTuple,nbOfCompMax);
4932 const double *aMinPtr=aMin->getConstPointer();
4933 const double *aMaxPtr=aMax->getConstPointer();
4934 double *res=ret->getPointer();
4935 for(int i=0;i<nbOfTuple;i++)
4936 res=std::transform(aMaxPtr+i*nbOfCompMax,aMaxPtr+(i+1)*nbOfCompMax,res,std::bind2nd(std::plus<double>(),aMinPtr[i]));
4937 ret->copyStringInfoFrom(*aMax);
4940 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Add !");
4943 else if((nbOfTuple==1 && nbOfTuple2>1) || (nbOfTuple>1 && nbOfTuple2==1))
4945 if(nbOfComp==nbOfComp2)
4947 int nbOfTupleMax=std::max(nbOfTuple,nbOfTuple2);
4948 const DataArrayDouble *aMin=nbOfTuple>nbOfTuple2?a2:a1;
4949 const DataArrayDouble *aMax=nbOfTuple>nbOfTuple2?a1:a2;
4950 const double *aMinPtr=aMin->getConstPointer(),*aMaxPtr=aMax->getConstPointer();
4951 ret=DataArrayDouble::New();
4952 ret->alloc(nbOfTupleMax,nbOfComp);
4953 double *res=ret->getPointer();
4954 for(int i=0;i<nbOfTupleMax;i++)
4955 res=std::transform(aMaxPtr+i*nbOfComp,aMaxPtr+(i+1)*nbOfComp,aMinPtr,res,std::plus<double>());
4956 ret->copyStringInfoFrom(*aMax);
4959 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Add !");
4962 throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array Add !");
4967 * Adds values of another DataArrayDouble to values of \a this one. There are 3
4969 * 1. The arrays have same number of tuples and components. Then each value of
4970 * \a other array is added to the corresponding value of \a this array, i.e.:
4971 * _a_ [ i, j ] += _other_ [ i, j ].
4972 * 2. The arrays have same number of tuples and \a other array has one component. Then
4973 * _a_ [ i, j ] += _other_ [ i, 0 ].
4974 * 3. The arrays have same number of components and \a other array has one tuple. Then
4975 * _a_ [ i, j ] += _a2_ [ 0, j ].
4977 * \param [in] other - an array to add to \a this one.
4978 * \throw If \a other is NULL.
4979 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
4980 * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
4981 * \a other has number of both tuples and components not equal to 1.
4983 void DataArrayDouble::addEqual(const DataArrayDouble *other)
4986 throw INTERP_KERNEL::Exception("DataArrayDouble::addEqual : input DataArrayDouble instance is NULL !");
4987 const char *msg="Nb of tuples mismatch for DataArrayDouble::addEqual !";
4989 other->checkAllocated();
4990 int nbOfTuple=getNumberOfTuples();
4991 int nbOfTuple2=other->getNumberOfTuples();
4992 int nbOfComp=getNumberOfComponents();
4993 int nbOfComp2=other->getNumberOfComponents();
4994 if(nbOfTuple==nbOfTuple2)
4996 if(nbOfComp==nbOfComp2)
4998 std::transform(begin(),end(),other->begin(),getPointer(),std::plus<double>());
5000 else if(nbOfComp2==1)
5002 double *ptr=getPointer();
5003 const double *ptrc=other->getConstPointer();
5004 for(int i=0;i<nbOfTuple;i++)
5005 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::plus<double>(),*ptrc++));
5008 throw INTERP_KERNEL::Exception(msg);
5010 else if(nbOfTuple2==1)
5012 if(nbOfComp2==nbOfComp)
5014 double *ptr=getPointer();
5015 const double *ptrc=other->getConstPointer();
5016 for(int i=0;i<nbOfTuple;i++)
5017 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::plus<double>());
5020 throw INTERP_KERNEL::Exception(msg);
5023 throw INTERP_KERNEL::Exception(msg);
5028 * Returns a new DataArrayDouble that is a subtraction of two given arrays. There are 3
5030 * 1. The arrays have same number of tuples and components. Then each value of
5031 * the result array (_a_) is a subtraction of the corresponding values of \a a1 and
5032 * \a a2, i.e.: _a_ [ i, j ] = _a1_ [ i, j ] - _a2_ [ i, j ].
5033 * 2. The arrays have same number of tuples and one array, say _a2_, has one
5035 * _a_ [ i, j ] = _a1_ [ i, j ] - _a2_ [ i, 0 ].
5036 * 3. The arrays have same number of components and one array, say _a2_, has one
5038 * _a_ [ i, j ] = _a1_ [ i, j ] - _a2_ [ 0, j ].
5040 * Info on components is copied either from the first array (in the first case) or from
5041 * the array with maximal number of elements (getNbOfElems()).
5042 * \param [in] a1 - an array to subtract from.
5043 * \param [in] a2 - an array to subtract.
5044 * \return DataArrayDouble * - the new instance of DataArrayDouble.
5045 * The caller is to delete this result array using decrRef() as it is no more
5047 * \throw If either \a a1 or \a a2 is NULL.
5048 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
5049 * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
5050 * none of them has number of tuples or components equal to 1.
5052 DataArrayDouble *DataArrayDouble::Substract(const DataArrayDouble *a1, const DataArrayDouble *a2)
5055 throw INTERP_KERNEL::Exception("DataArrayDouble::Substract : input DataArrayDouble instance is NULL !");
5056 int nbOfTuple1=a1->getNumberOfTuples();
5057 int nbOfTuple2=a2->getNumberOfTuples();
5058 int nbOfComp1=a1->getNumberOfComponents();
5059 int nbOfComp2=a2->getNumberOfComponents();
5060 if(nbOfTuple2==nbOfTuple1)
5062 if(nbOfComp1==nbOfComp2)
5064 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
5065 ret->alloc(nbOfTuple2,nbOfComp1);
5066 std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::minus<double>());
5067 ret->copyStringInfoFrom(*a1);
5070 else if(nbOfComp2==1)
5072 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
5073 ret->alloc(nbOfTuple1,nbOfComp1);
5074 const double *a2Ptr=a2->getConstPointer();
5075 const double *a1Ptr=a1->getConstPointer();
5076 double *res=ret->getPointer();
5077 for(int i=0;i<nbOfTuple1;i++)
5078 res=std::transform(a1Ptr+i*nbOfComp1,a1Ptr+(i+1)*nbOfComp1,res,std::bind2nd(std::minus<double>(),a2Ptr[i]));
5079 ret->copyStringInfoFrom(*a1);
5084 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Substract !");
5088 else if(nbOfTuple2==1)
5090 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Substract !");
5091 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
5092 ret->alloc(nbOfTuple1,nbOfComp1);
5093 const double *a1ptr=a1->getConstPointer(),*a2ptr=a2->getConstPointer();
5094 double *pt=ret->getPointer();
5095 for(int i=0;i<nbOfTuple1;i++)
5096 pt=std::transform(a1ptr+i*nbOfComp1,a1ptr+(i+1)*nbOfComp1,a2ptr,pt,std::minus<double>());
5097 ret->copyStringInfoFrom(*a1);
5102 a1->checkNbOfTuples(nbOfTuple2,"Nb of tuples mismatch for array Substract !");//will always throw an exception
5108 * Subtract values of another DataArrayDouble from values of \a this one. There are 3
5110 * 1. The arrays have same number of tuples and components. Then each value of
5111 * \a other array is subtracted from the corresponding value of \a this array, i.e.:
5112 * _a_ [ i, j ] -= _other_ [ i, j ].
5113 * 2. The arrays have same number of tuples and \a other array has one component. Then
5114 * _a_ [ i, j ] -= _other_ [ i, 0 ].
5115 * 3. The arrays have same number of components and \a other array has one tuple. Then
5116 * _a_ [ i, j ] -= _a2_ [ 0, j ].
5118 * \param [in] other - an array to subtract from \a this one.
5119 * \throw If \a other is NULL.
5120 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
5121 * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
5122 * \a other has number of both tuples and components not equal to 1.
5124 void DataArrayDouble::substractEqual(const DataArrayDouble *other)
5127 throw INTERP_KERNEL::Exception("DataArrayDouble::substractEqual : input DataArrayDouble instance is NULL !");
5128 const char *msg="Nb of tuples mismatch for DataArrayDouble::substractEqual !";
5130 other->checkAllocated();
5131 int nbOfTuple=getNumberOfTuples();
5132 int nbOfTuple2=other->getNumberOfTuples();
5133 int nbOfComp=getNumberOfComponents();
5134 int nbOfComp2=other->getNumberOfComponents();
5135 if(nbOfTuple==nbOfTuple2)
5137 if(nbOfComp==nbOfComp2)
5139 std::transform(begin(),end(),other->begin(),getPointer(),std::minus<double>());
5141 else if(nbOfComp2==1)
5143 double *ptr=getPointer();
5144 const double *ptrc=other->getConstPointer();
5145 for(int i=0;i<nbOfTuple;i++)
5146 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::minus<double>(),*ptrc++));
5149 throw INTERP_KERNEL::Exception(msg);
5151 else if(nbOfTuple2==1)
5153 if(nbOfComp2==nbOfComp)
5155 double *ptr=getPointer();
5156 const double *ptrc=other->getConstPointer();
5157 for(int i=0;i<nbOfTuple;i++)
5158 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::minus<double>());
5161 throw INTERP_KERNEL::Exception(msg);
5164 throw INTERP_KERNEL::Exception(msg);
5169 * Returns a new DataArrayDouble that is a product of two given arrays. There are 3
5171 * 1. The arrays have same number of tuples and components. Then each value of
5172 * the result array (_a_) is a product of the corresponding values of \a a1 and
5173 * \a a2, i.e. _a_ [ i, j ] = _a1_ [ i, j ] * _a2_ [ i, j ].
5174 * 2. The arrays have same number of tuples and one array, say _a2_, has one
5176 * _a_ [ i, j ] = _a1_ [ i, j ] * _a2_ [ i, 0 ].
5177 * 3. The arrays have same number of components and one array, say _a2_, has one
5179 * _a_ [ i, j ] = _a1_ [ i, j ] * _a2_ [ 0, j ].
5181 * Info on components is copied either from the first array (in the first case) or from
5182 * the array with maximal number of elements (getNbOfElems()).
5183 * \param [in] a1 - a factor array.
5184 * \param [in] a2 - another factor array.
5185 * \return DataArrayDouble * - the new instance of DataArrayDouble.
5186 * The caller is to delete this result array using decrRef() as it is no more
5188 * \throw If either \a a1 or \a a2 is NULL.
5189 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
5190 * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
5191 * none of them has number of tuples or components equal to 1.
5193 DataArrayDouble *DataArrayDouble::Multiply(const DataArrayDouble *a1, const DataArrayDouble *a2)
5196 throw INTERP_KERNEL::Exception("DataArrayDouble::Multiply : input DataArrayDouble instance is NULL !");
5197 int nbOfTuple=a1->getNumberOfTuples();
5198 int nbOfTuple2=a2->getNumberOfTuples();
5199 int nbOfComp=a1->getNumberOfComponents();
5200 int nbOfComp2=a2->getNumberOfComponents();
5201 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=0;
5202 if(nbOfTuple==nbOfTuple2)
5204 if(nbOfComp==nbOfComp2)
5206 ret=DataArrayDouble::New();
5207 ret->alloc(nbOfTuple,nbOfComp);
5208 std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::multiplies<double>());
5209 ret->copyStringInfoFrom(*a1);
5213 int nbOfCompMin,nbOfCompMax;
5214 const DataArrayDouble *aMin, *aMax;
5215 if(nbOfComp>nbOfComp2)
5217 nbOfCompMin=nbOfComp2; nbOfCompMax=nbOfComp;
5222 nbOfCompMin=nbOfComp; nbOfCompMax=nbOfComp2;
5227 ret=DataArrayDouble::New();
5228 ret->alloc(nbOfTuple,nbOfCompMax);
5229 const double *aMinPtr=aMin->getConstPointer();
5230 const double *aMaxPtr=aMax->getConstPointer();
5231 double *res=ret->getPointer();
5232 for(int i=0;i<nbOfTuple;i++)
5233 res=std::transform(aMaxPtr+i*nbOfCompMax,aMaxPtr+(i+1)*nbOfCompMax,res,std::bind2nd(std::multiplies<double>(),aMinPtr[i]));
5234 ret->copyStringInfoFrom(*aMax);
5237 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Multiply !");
5240 else if((nbOfTuple==1 && nbOfTuple2>1) || (nbOfTuple>1 && nbOfTuple2==1))
5242 if(nbOfComp==nbOfComp2)
5244 int nbOfTupleMax=std::max(nbOfTuple,nbOfTuple2);
5245 const DataArrayDouble *aMin=nbOfTuple>nbOfTuple2?a2:a1;
5246 const DataArrayDouble *aMax=nbOfTuple>nbOfTuple2?a1:a2;
5247 const double *aMinPtr=aMin->getConstPointer(),*aMaxPtr=aMax->getConstPointer();
5248 ret=DataArrayDouble::New();
5249 ret->alloc(nbOfTupleMax,nbOfComp);
5250 double *res=ret->getPointer();
5251 for(int i=0;i<nbOfTupleMax;i++)
5252 res=std::transform(aMaxPtr+i*nbOfComp,aMaxPtr+(i+1)*nbOfComp,aMinPtr,res,std::multiplies<double>());
5253 ret->copyStringInfoFrom(*aMax);
5256 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Multiply !");
5259 throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array Multiply !");
5264 * Multiply values of another DataArrayDouble to values of \a this one. There are 3
5266 * 1. The arrays have same number of tuples and components. Then each value of
5267 * \a other array is multiplied to the corresponding value of \a this array, i.e.
5268 * _this_ [ i, j ] *= _other_ [ i, j ].
5269 * 2. The arrays have same number of tuples and \a other array has one component. Then
5270 * _this_ [ i, j ] *= _other_ [ i, 0 ].
5271 * 3. The arrays have same number of components and \a other array has one tuple. Then
5272 * _this_ [ i, j ] *= _a2_ [ 0, j ].
5274 * \param [in] other - an array to multiply to \a this one.
5275 * \throw If \a other is NULL.
5276 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
5277 * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
5278 * \a other has number of both tuples and components not equal to 1.
5280 void DataArrayDouble::multiplyEqual(const DataArrayDouble *other)
5283 throw INTERP_KERNEL::Exception("DataArrayDouble::multiplyEqual : input DataArrayDouble instance is NULL !");
5284 const char *msg="Nb of tuples mismatch for DataArrayDouble::multiplyEqual !";
5286 other->checkAllocated();
5287 int nbOfTuple=getNumberOfTuples();
5288 int nbOfTuple2=other->getNumberOfTuples();
5289 int nbOfComp=getNumberOfComponents();
5290 int nbOfComp2=other->getNumberOfComponents();
5291 if(nbOfTuple==nbOfTuple2)
5293 if(nbOfComp==nbOfComp2)
5295 std::transform(begin(),end(),other->begin(),getPointer(),std::multiplies<double>());
5297 else if(nbOfComp2==1)
5299 double *ptr=getPointer();
5300 const double *ptrc=other->getConstPointer();
5301 for(int i=0;i<nbOfTuple;i++)
5302 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::multiplies<double>(),*ptrc++));
5305 throw INTERP_KERNEL::Exception(msg);
5307 else if(nbOfTuple2==1)
5309 if(nbOfComp2==nbOfComp)
5311 double *ptr=getPointer();
5312 const double *ptrc=other->getConstPointer();
5313 for(int i=0;i<nbOfTuple;i++)
5314 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::multiplies<double>());
5317 throw INTERP_KERNEL::Exception(msg);
5320 throw INTERP_KERNEL::Exception(msg);
5325 * Returns a new DataArrayDouble that is a division of two given arrays. There are 3
5327 * 1. The arrays have same number of tuples and components. Then each value of
5328 * the result array (_a_) is a division of the corresponding values of \a a1 and
5329 * \a a2, i.e.: _a_ [ i, j ] = _a1_ [ i, j ] / _a2_ [ i, j ].
5330 * 2. The arrays have same number of tuples and one array, say _a2_, has one
5332 * _a_ [ i, j ] = _a1_ [ i, j ] / _a2_ [ i, 0 ].
5333 * 3. The arrays have same number of components and one array, say _a2_, has one
5335 * _a_ [ i, j ] = _a1_ [ i, j ] / _a2_ [ 0, j ].
5337 * Info on components is copied either from the first array (in the first case) or from
5338 * the array with maximal number of elements (getNbOfElems()).
5339 * \warning No check of division by zero is performed!
5340 * \param [in] a1 - a numerator array.
5341 * \param [in] a2 - a denominator array.
5342 * \return DataArrayDouble * - the new instance of DataArrayDouble.
5343 * The caller is to delete this result array using decrRef() as it is no more
5345 * \throw If either \a a1 or \a a2 is NULL.
5346 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
5347 * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
5348 * none of them has number of tuples or components equal to 1.
5350 DataArrayDouble *DataArrayDouble::Divide(const DataArrayDouble *a1, const DataArrayDouble *a2)
5353 throw INTERP_KERNEL::Exception("DataArrayDouble::Divide : input DataArrayDouble instance is NULL !");
5354 int nbOfTuple1=a1->getNumberOfTuples();
5355 int nbOfTuple2=a2->getNumberOfTuples();
5356 int nbOfComp1=a1->getNumberOfComponents();
5357 int nbOfComp2=a2->getNumberOfComponents();
5358 if(nbOfTuple2==nbOfTuple1)
5360 if(nbOfComp1==nbOfComp2)
5362 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
5363 ret->alloc(nbOfTuple2,nbOfComp1);
5364 std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::divides<double>());
5365 ret->copyStringInfoFrom(*a1);
5368 else if(nbOfComp2==1)
5370 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
5371 ret->alloc(nbOfTuple1,nbOfComp1);
5372 const double *a2Ptr=a2->getConstPointer();
5373 const double *a1Ptr=a1->getConstPointer();
5374 double *res=ret->getPointer();
5375 for(int i=0;i<nbOfTuple1;i++)
5376 res=std::transform(a1Ptr+i*nbOfComp1,a1Ptr+(i+1)*nbOfComp1,res,std::bind2nd(std::divides<double>(),a2Ptr[i]));
5377 ret->copyStringInfoFrom(*a1);
5382 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Divide !");
5386 else if(nbOfTuple2==1)
5388 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Divide !");
5389 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
5390 ret->alloc(nbOfTuple1,nbOfComp1);
5391 const double *a1ptr=a1->getConstPointer(),*a2ptr=a2->getConstPointer();
5392 double *pt=ret->getPointer();
5393 for(int i=0;i<nbOfTuple1;i++)
5394 pt=std::transform(a1ptr+i*nbOfComp1,a1ptr+(i+1)*nbOfComp1,a2ptr,pt,std::divides<double>());
5395 ret->copyStringInfoFrom(*a1);
5400 a1->checkNbOfTuples(nbOfTuple2,"Nb of tuples mismatch for array Divide !");//will always throw an exception
5406 * Divide values of \a this array by values of another DataArrayDouble. There are 3
5408 * 1. The arrays have same number of tuples and components. Then each value of
5409 * \a this array is divided by the corresponding value of \a other one, i.e.:
5410 * _a_ [ i, j ] /= _other_ [ i, j ].
5411 * 2. The arrays have same number of tuples and \a other array has one component. Then
5412 * _a_ [ i, j ] /= _other_ [ i, 0 ].
5413 * 3. The arrays have same number of components and \a other array has one tuple. Then
5414 * _a_ [ i, j ] /= _a2_ [ 0, j ].
5416 * \warning No check of division by zero is performed!
5417 * \param [in] other - an array to divide \a this one by.
5418 * \throw If \a other is NULL.
5419 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
5420 * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
5421 * \a other has number of both tuples and components not equal to 1.
5423 void DataArrayDouble::divideEqual(const DataArrayDouble *other)
5426 throw INTERP_KERNEL::Exception("DataArrayDouble::divideEqual : input DataArrayDouble instance is NULL !");
5427 const char *msg="Nb of tuples mismatch for DataArrayDouble::divideEqual !";
5429 other->checkAllocated();
5430 int nbOfTuple=getNumberOfTuples();
5431 int nbOfTuple2=other->getNumberOfTuples();
5432 int nbOfComp=getNumberOfComponents();
5433 int nbOfComp2=other->getNumberOfComponents();
5434 if(nbOfTuple==nbOfTuple2)
5436 if(nbOfComp==nbOfComp2)
5438 std::transform(begin(),end(),other->begin(),getPointer(),std::divides<double>());
5440 else if(nbOfComp2==1)
5442 double *ptr=getPointer();
5443 const double *ptrc=other->getConstPointer();
5444 for(int i=0;i<nbOfTuple;i++)
5445 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::divides<double>(),*ptrc++));
5448 throw INTERP_KERNEL::Exception(msg);
5450 else if(nbOfTuple2==1)
5452 if(nbOfComp2==nbOfComp)
5454 double *ptr=getPointer();
5455 const double *ptrc=other->getConstPointer();
5456 for(int i=0;i<nbOfTuple;i++)
5457 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::divides<double>());
5460 throw INTERP_KERNEL::Exception(msg);
5463 throw INTERP_KERNEL::Exception(msg);
5468 * Returns a new DataArrayDouble that is the result of pow of two given arrays. There are 3
5471 * \param [in] a1 - an array to pow up.
5472 * \param [in] a2 - another array to sum up.
5473 * \return DataArrayDouble * - the new instance of DataArrayDouble.
5474 * The caller is to delete this result array using decrRef() as it is no more
5476 * \throw If either \a a1 or \a a2 is NULL.
5477 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
5478 * \throw If \a a1->getNumberOfComponents() != 1 or \a a2->getNumberOfComponents() != 1.
5479 * \throw If there is a negative value in \a a1.
5481 DataArrayDouble *DataArrayDouble::Pow(const DataArrayDouble *a1, const DataArrayDouble *a2)
5484 throw INTERP_KERNEL::Exception("DataArrayDouble::Pow : at least one of input instances is null !");
5485 int nbOfTuple=a1->getNumberOfTuples();
5486 int nbOfTuple2=a2->getNumberOfTuples();
5487 int nbOfComp=a1->getNumberOfComponents();
5488 int nbOfComp2=a2->getNumberOfComponents();
5489 if(nbOfTuple!=nbOfTuple2)
5490 throw INTERP_KERNEL::Exception("DataArrayDouble::Pow : number of tuples mismatches !");
5491 if(nbOfComp!=1 || nbOfComp2!=1)
5492 throw INTERP_KERNEL::Exception("DataArrayDouble::Pow : number of components of both arrays must be equal to 1 !");
5493 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New(); ret->alloc(nbOfTuple,1);
5494 const double *ptr1(a1->begin()),*ptr2(a2->begin());
5495 double *ptr=ret->getPointer();
5496 for(int i=0;i<nbOfTuple;i++,ptr1++,ptr2++,ptr++)
5500 *ptr=pow(*ptr1,*ptr2);
5504 std::ostringstream oss; oss << "DataArrayDouble::Pow : on tuple #" << i << " of a1 value is < 0 (" << *ptr1 << ") !";
5505 throw INTERP_KERNEL::Exception(oss.str().c_str());
5512 * Apply pow on values of another DataArrayDouble to values of \a this one.
5514 * \param [in] other - an array to pow to \a this one.
5515 * \throw If \a other is NULL.
5516 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples()
5517 * \throw If \a this->getNumberOfComponents() != 1 or \a other->getNumberOfComponents() != 1
5518 * \throw If there is a negative value in \a this.
5520 void DataArrayDouble::powEqual(const DataArrayDouble *other)
5523 throw INTERP_KERNEL::Exception("DataArrayDouble::powEqual : input instance is null !");
5524 int nbOfTuple=getNumberOfTuples();
5525 int nbOfTuple2=other->getNumberOfTuples();
5526 int nbOfComp=getNumberOfComponents();
5527 int nbOfComp2=other->getNumberOfComponents();
5528 if(nbOfTuple!=nbOfTuple2)
5529 throw INTERP_KERNEL::Exception("DataArrayDouble::powEqual : number of tuples mismatches !");
5530 if(nbOfComp!=1 || nbOfComp2!=1)
5531 throw INTERP_KERNEL::Exception("DataArrayDouble::powEqual : number of components of both arrays must be equal to 1 !");
5532 double *ptr=getPointer();
5533 const double *ptrc=other->begin();
5534 for(int i=0;i<nbOfTuple;i++,ptrc++,ptr++)
5537 *ptr=pow(*ptr,*ptrc);
5540 std::ostringstream oss; oss << "DataArrayDouble::powEqual : on tuple #" << i << " of this value is < 0 (" << *ptr << ") !";
5541 throw INTERP_KERNEL::Exception(oss.str().c_str());
5548 * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
5551 void DataArrayDouble::getTinySerializationIntInformation(std::vector<int>& tinyInfo) const
5556 tinyInfo[0]=getNumberOfTuples();
5557 tinyInfo[1]=getNumberOfComponents();
5567 * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
5570 void DataArrayDouble::getTinySerializationStrInformation(std::vector<std::string>& tinyInfo) const
5574 int nbOfCompo=getNumberOfComponents();
5575 tinyInfo.resize(nbOfCompo+1);
5576 tinyInfo[0]=getName();
5577 for(int i=0;i<nbOfCompo;i++)
5578 tinyInfo[i+1]=getInfoOnComponent(i);
5583 tinyInfo[0]=getName();
5588 * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
5589 * This method returns if a feeding is needed.
5591 bool DataArrayDouble::resizeForUnserialization(const std::vector<int>& tinyInfoI)
5593 int nbOfTuple=tinyInfoI[0];
5594 int nbOfComp=tinyInfoI[1];
5595 if(nbOfTuple!=-1 || nbOfComp!=-1)
5597 alloc(nbOfTuple,nbOfComp);
5604 * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
5606 void DataArrayDouble::finishUnserialization(const std::vector<int>& tinyInfoI, const std::vector<std::string>& tinyInfoS)
5608 setName(tinyInfoS[0]);
5611 int nbOfCompo=getNumberOfComponents();
5612 for(int i=0;i<nbOfCompo;i++)
5613 setInfoOnComponent(i,tinyInfoS[i+1]);
5617 DataArrayDoubleIterator::DataArrayDoubleIterator(DataArrayDouble *da):_da(da),_tuple_id(0),_nb_comp(0),_nb_tuple(0)
5622 if(_da->isAllocated())
5624 _nb_comp=da->getNumberOfComponents();
5625 _nb_tuple=da->getNumberOfTuples();
5626 _pt=da->getPointer();
5631 DataArrayDoubleIterator::~DataArrayDoubleIterator()
5637 DataArrayDoubleTuple *DataArrayDoubleIterator::nextt()
5639 if(_tuple_id<_nb_tuple)
5642 DataArrayDoubleTuple *ret=new DataArrayDoubleTuple(_pt,_nb_comp);
5650 DataArrayDoubleTuple::DataArrayDoubleTuple(double *pt, int nbOfComp):_pt(pt),_nb_of_compo(nbOfComp)
5655 std::string DataArrayDoubleTuple::repr() const
5657 std::ostringstream oss; oss.precision(17); oss << "(";
5658 for(int i=0;i<_nb_of_compo-1;i++)
5659 oss << _pt[i] << ", ";
5660 oss << _pt[_nb_of_compo-1] << ")";
5664 double DataArrayDoubleTuple::doubleValue() const
5668 throw INTERP_KERNEL::Exception("DataArrayDoubleTuple::doubleValue : DataArrayDoubleTuple instance has not exactly 1 component -> Not possible to convert it into a double precision float !");
5672 * This method returns a newly allocated instance the caller should dealed with by a ParaMEDMEM::DataArrayDouble::decrRef.
5673 * This method performs \b no copy of data. The content is only referenced using ParaMEDMEM::DataArrayDouble::useArray with ownership set to \b false.
5674 * 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
5675 * \b nbOfCompo=1 and \bnbOfTuples==this->_nb_of_elem.
5677 DataArrayDouble *DataArrayDoubleTuple::buildDADouble(int nbOfTuples, int nbOfCompo) const
5679 if((_nb_of_compo==nbOfCompo && nbOfTuples==1) || (_nb_of_compo==nbOfTuples && nbOfCompo==1))
5681 DataArrayDouble *ret=DataArrayDouble::New();
5682 ret->useExternalArrayWithRWAccess(_pt,nbOfTuples,nbOfCompo);
5687 std::ostringstream oss; oss << "DataArrayDoubleTuple::buildDADouble : unable to build a requested DataArrayDouble instance with nbofTuple=" << nbOfTuples << " and nbOfCompo=" << nbOfCompo;
5688 oss << ".\nBecause the number of elements in this is " << _nb_of_compo << " !";
5689 throw INTERP_KERNEL::Exception(oss.str().c_str());
5694 * Returns a new instance of DataArrayInt. The caller is to delete this array
5695 * using decrRef() as it is no more needed.
5697 DataArrayInt *DataArrayInt::New()
5699 return new DataArrayInt;
5703 * Checks if raw data is allocated. Read more on the raw data
5704 * in \ref MEDCouplingArrayBasicsTuplesAndCompo "DataArrays infos" for more information.
5705 * \return bool - \a true if the raw data is allocated, \a false else.
5707 bool DataArrayInt::isAllocated() const
5709 return getConstPointer()!=0;
5713 * Checks if raw data is allocated and throws an exception if it is not the case.
5714 * \throw If the raw data is not allocated.
5716 void DataArrayInt::checkAllocated() const
5719 throw INTERP_KERNEL::Exception("DataArrayInt::checkAllocated : Array is defined but not allocated ! Call alloc or setValues method first !");
5723 * This method desallocated \a this without modification of informations relative to the components.
5724 * After call of this method, DataArrayInt::isAllocated will return false.
5725 * If \a this is already not allocated, \a this is let unchanged.
5727 void DataArrayInt::desallocate()
5732 std::size_t DataArrayInt::getHeapMemorySizeWithoutChildren() const
5734 std::size_t sz(_mem.getNbOfElemAllocated());
5736 return DataArray::getHeapMemorySizeWithoutChildren()+sz;
5740 * Returns the only one value in \a this, if and only if number of elements
5741 * (nb of tuples * nb of components) is equal to 1, and that \a this is allocated.
5742 * \return double - the sole value stored in \a this array.
5743 * \throw If at least one of conditions stated above is not fulfilled.
5745 int DataArrayInt::intValue() const
5749 if(getNbOfElems()==1)
5751 return *getConstPointer();
5754 throw INTERP_KERNEL::Exception("DataArrayInt::intValue : DataArrayInt instance is allocated but number of elements is not equal to 1 !");
5757 throw INTERP_KERNEL::Exception("DataArrayInt::intValue : DataArrayInt instance is not allocated !");
5761 * Returns an integer value characterizing \a this array, which is useful for a quick
5762 * comparison of many instances of DataArrayInt.
5763 * \return int - the hash value.
5764 * \throw If \a this is not allocated.
5766 int DataArrayInt::getHashCode() const
5769 std::size_t nbOfElems=getNbOfElems();
5770 int ret=nbOfElems*65536;
5775 const int *pt=begin();
5776 for(std::size_t i=0;i<nbOfElems;i+=delta)
5777 ret0+=pt[i] & 0x1FFF;
5782 * Checks the number of tuples.
5783 * \return bool - \a true if getNumberOfTuples() == 0, \a false else.
5784 * \throw If \a this is not allocated.
5786 bool DataArrayInt::empty() const
5789 return getNumberOfTuples()==0;
5793 * Returns a full copy of \a this. For more info on copying data arrays see
5794 * \ref MEDCouplingArrayBasicsCopyDeep.
5795 * \return DataArrayInt * - a new instance of DataArrayInt.
5797 DataArrayInt *DataArrayInt::deepCpy() const
5799 return new DataArrayInt(*this);
5803 * Returns either a \a deep or \a shallow copy of this array. For more info see
5804 * \ref MEDCouplingArrayBasicsCopyDeep and \ref MEDCouplingArrayBasicsCopyShallow.
5805 * \param [in] dCpy - if \a true, a deep copy is returned, else, a shallow one.
5806 * \return DataArrayInt * - either a new instance of DataArrayInt (if \a dCpy
5807 * == \a true) or \a this instance (if \a dCpy == \a false).
5809 DataArrayInt *DataArrayInt::performCpy(bool dCpy) const
5816 return const_cast<DataArrayInt *>(this);
5821 * Copies all the data from another DataArrayInt. For more info see
5822 * \ref MEDCouplingArrayBasicsCopyDeepAssign.
5823 * \param [in] other - another instance of DataArrayInt to copy data from.
5824 * \throw If the \a other is not allocated.
5826 void DataArrayInt::cpyFrom(const DataArrayInt& other)
5828 other.checkAllocated();
5829 int nbOfTuples=other.getNumberOfTuples();
5830 int nbOfComp=other.getNumberOfComponents();
5831 allocIfNecessary(nbOfTuples,nbOfComp);
5832 std::size_t nbOfElems=(std::size_t)nbOfTuples*nbOfComp;
5833 int *pt=getPointer();
5834 const int *ptI=other.getConstPointer();
5835 for(std::size_t i=0;i<nbOfElems;i++)
5837 copyStringInfoFrom(other);
5841 * This method reserve nbOfElems elements in memory ( nbOfElems*4 bytes ) \b without impacting the number of tuples in \a this.
5842 * 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.
5843 * If \a this has not already been allocated, number of components is set to one.
5844 * This method allows to reduce number of reallocations on invokation of DataArrayInt::pushBackSilent and DataArrayInt::pushBackValsSilent on \a this.
5846 * \sa DataArrayInt::pack, DataArrayInt::pushBackSilent, DataArrayInt::pushBackValsSilent
5848 void DataArrayInt::reserve(std::size_t nbOfElems)
5850 int nbCompo=getNumberOfComponents();
5853 _mem.reserve(nbOfElems);
5857 _mem.reserve(nbOfElems);
5858 _info_on_compo.resize(1);
5861 throw INTERP_KERNEL::Exception("DataArrayInt::reserve : not available for DataArrayInt with number of components different than 1 !");
5865 * 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
5866 * of counter. So the caller is expected to call TimeLabel::declareAsNew on \a this at the end of the push session.
5868 * \param [in] val the value to be added in \a this
5869 * \throw If \a this has already been allocated with number of components different from one.
5870 * \sa DataArrayInt::pushBackValsSilent
5872 void DataArrayInt::pushBackSilent(int val)
5874 int nbCompo=getNumberOfComponents();
5879 _info_on_compo.resize(1);
5883 throw INTERP_KERNEL::Exception("DataArrayInt::pushBackSilent : not available for DataArrayInt with number of components different than 1 !");
5887 * 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
5888 * of counter. So the caller is expected to call TimeLabel::declareAsNew on \a this at the end of the push session.
5890 * \param [in] valsBg - an array of values to push at the end of \this.
5891 * \param [in] valsEnd - specifies the end of the array \a valsBg, so that
5892 * the last value of \a valsBg is \a valsEnd[ -1 ].
5893 * \throw If \a this has already been allocated with number of components different from one.
5894 * \sa DataArrayInt::pushBackSilent
5896 void DataArrayInt::pushBackValsSilent(const int *valsBg, const int *valsEnd)
5898 int nbCompo=getNumberOfComponents();
5900 _mem.insertAtTheEnd(valsBg,valsEnd);
5903 _info_on_compo.resize(1);
5904 _mem.insertAtTheEnd(valsBg,valsEnd);
5907 throw INTERP_KERNEL::Exception("DataArrayInt::pushBackValsSilent : not available for DataArrayInt with number of components different than 1 !");
5911 * This method returns silently ( without updating time label in \a this ) the last value, if any and suppress it.
5912 * \throw If \a this is already empty.
5913 * \throw If \a this has number of components different from one.
5915 int DataArrayInt::popBackSilent()
5917 if(getNumberOfComponents()==1)
5918 return _mem.popBack();
5920 throw INTERP_KERNEL::Exception("DataArrayInt::popBackSilent : not available for DataArrayInt with number of components different than 1 !");
5924 * 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.
5926 * \sa DataArrayInt::getHeapMemorySizeWithoutChildren, DataArrayInt::reserve
5928 void DataArrayInt::pack() const
5934 * Allocates the raw data in memory. If exactly as same memory as needed already
5935 * allocated, it is not re-allocated.
5936 * \param [in] nbOfTuple - number of tuples of data to allocate.
5937 * \param [in] nbOfCompo - number of components of data to allocate.
5938 * \throw If \a nbOfTuple < 0 or \a nbOfCompo < 0.
5940 void DataArrayInt::allocIfNecessary(int nbOfTuple, int nbOfCompo)
5944 if(nbOfTuple!=getNumberOfTuples() || nbOfCompo!=getNumberOfComponents())
5945 alloc(nbOfTuple,nbOfCompo);
5948 alloc(nbOfTuple,nbOfCompo);
5952 * Allocates the raw data in memory. If the memory was already allocated, then it is
5953 * freed and re-allocated. See an example of this method use
5954 * \ref MEDCouplingArraySteps1WC "here".
5955 * \param [in] nbOfTuple - number of tuples of data to allocate.
5956 * \param [in] nbOfCompo - number of components of data to allocate.
5957 * \throw If \a nbOfTuple < 0 or \a nbOfCompo < 0.
5959 void DataArrayInt::alloc(int nbOfTuple, int nbOfCompo)
5961 if(nbOfTuple<0 || nbOfCompo<0)
5962 throw INTERP_KERNEL::Exception("DataArrayInt::alloc : request for negative length of data !");
5963 _info_on_compo.resize(nbOfCompo);
5964 _mem.alloc(nbOfCompo*(std::size_t)nbOfTuple);
5969 * Assign zero to all values in \a this array. To know more on filling arrays see
5970 * \ref MEDCouplingArrayFill.
5971 * \throw If \a this is not allocated.
5973 void DataArrayInt::fillWithZero()
5976 _mem.fillWithValue(0);
5981 * Assign \a val to all values in \a this array. To know more on filling arrays see
5982 * \ref MEDCouplingArrayFill.
5983 * \param [in] val - the value to fill with.
5984 * \throw If \a this is not allocated.
5986 void DataArrayInt::fillWithValue(int val)
5989 _mem.fillWithValue(val);
5994 * Set all values in \a this array so that the i-th element equals to \a init + i
5995 * (i starts from zero). To know more on filling arrays see \ref MEDCouplingArrayFill.
5996 * \param [in] init - value to assign to the first element of array.
5997 * \throw If \a this->getNumberOfComponents() != 1
5998 * \throw If \a this is not allocated.
6000 void DataArrayInt::iota(int init)
6003 if(getNumberOfComponents()!=1)
6004 throw INTERP_KERNEL::Exception("DataArrayInt::iota : works only for arrays with only one component, you can call 'rearrange' method before !");
6005 int *ptr=getPointer();
6006 int ntuples=getNumberOfTuples();
6007 for(int i=0;i<ntuples;i++)
6013 * Returns a textual and human readable representation of \a this instance of
6014 * DataArrayInt. This text is shown when a DataArrayInt is printed in Python.
6015 * \return std::string - text describing \a this DataArrayInt.
6017 std::string DataArrayInt::repr() const
6019 std::ostringstream ret;
6024 std::string DataArrayInt::reprZip() const
6026 std::ostringstream ret;
6031 void DataArrayInt::writeVTK(std::ostream& ofs, int indent, const std::string& type, const std::string& nameInFile, DataArrayByte *byteArr) const
6033 static const char SPACE[4]={' ',' ',' ',' '};
6035 std::string idt(indent,' ');
6036 ofs << idt << "<DataArray type=\"" << type << "\" Name=\"" << nameInFile << "\" NumberOfComponents=\"" << getNumberOfComponents() << "\"";
6039 ofs << " format=\"appended\" offset=\"" << byteArr->getNumberOfTuples() << "\">";
6040 if(std::string(type)=="Int32")
6042 const char *data(reinterpret_cast<const char *>(begin()));
6043 std::size_t sz(getNbOfElems()*sizeof(int));
6044 byteArr->insertAtTheEnd(data,data+sz);
6045 byteArr->insertAtTheEnd(SPACE,SPACE+4);
6047 else if(std::string(type)=="Int8")
6049 INTERP_KERNEL::AutoPtr<char> tmp(new char[getNbOfElems()]);
6050 std::copy(begin(),end(),(char *)tmp);
6051 byteArr->insertAtTheEnd((char *)tmp,(char *)tmp+getNbOfElems());
6052 byteArr->insertAtTheEnd(SPACE,SPACE+4);
6054 else if(std::string(type)=="UInt8")
6056 INTERP_KERNEL::AutoPtr<unsigned char> tmp(new unsigned char[getNbOfElems()]);
6057 std::copy(begin(),end(),(unsigned char *)tmp);
6058 byteArr->insertAtTheEnd((unsigned char *)tmp,(unsigned char *)tmp+getNbOfElems());
6059 byteArr->insertAtTheEnd(SPACE,SPACE+4);
6062 throw INTERP_KERNEL::Exception("DataArrayInt::writeVTK : Only Int32, Int8 and UInt8 supported !");
6066 ofs << " RangeMin=\"" << getMinValueInArray() << "\" RangeMax=\"" << getMaxValueInArray() << "\" format=\"ascii\">\n" << idt;
6067 std::copy(begin(),end(),std::ostream_iterator<int>(ofs," "));
6069 ofs << std::endl << idt << "</DataArray>\n";
6072 void DataArrayInt::reprStream(std::ostream& stream) const
6074 stream << "Name of int array : \"" << _name << "\"\n";
6075 reprWithoutNameStream(stream);
6078 void DataArrayInt::reprZipStream(std::ostream& stream) const
6080 stream << "Name of int array : \"" << _name << "\"\n";
6081 reprZipWithoutNameStream(stream);
6084 void DataArrayInt::reprWithoutNameStream(std::ostream& stream) const
6086 DataArray::reprWithoutNameStream(stream);
6087 _mem.repr(getNumberOfComponents(),stream);
6090 void DataArrayInt::reprZipWithoutNameStream(std::ostream& stream) const
6092 DataArray::reprWithoutNameStream(stream);
6093 _mem.reprZip(getNumberOfComponents(),stream);
6096 void DataArrayInt::reprCppStream(const std::string& varName, std::ostream& stream) const
6098 int nbTuples=getNumberOfTuples(),nbComp=getNumberOfComponents();
6099 const int *data=getConstPointer();
6100 stream << "DataArrayInt *" << varName << "=DataArrayInt::New();" << std::endl;
6101 if(nbTuples*nbComp>=1)
6103 stream << "const int " << varName << "Data[" << nbTuples*nbComp << "]={";
6104 std::copy(data,data+nbTuples*nbComp-1,std::ostream_iterator<int>(stream,","));
6105 stream << data[nbTuples*nbComp-1] << "};" << std::endl;
6106 stream << varName << "->useArray(" << varName << "Data,false,CPP_DEALLOC," << nbTuples << "," << nbComp << ");" << std::endl;
6109 stream << varName << "->alloc(" << nbTuples << "," << nbComp << ");" << std::endl;
6110 stream << varName << "->setName(\"" << getName() << "\");" << std::endl;
6114 * Method that gives a quick overvien of \a this for python.
6116 void DataArrayInt::reprQuickOverview(std::ostream& stream) const
6118 static const std::size_t MAX_NB_OF_BYTE_IN_REPR=300;
6119 stream << "DataArrayInt C++ instance at " << this << ". ";
6122 int nbOfCompo=(int)_info_on_compo.size();
6125 int nbOfTuples=getNumberOfTuples();
6126 stream << "Number of tuples : " << nbOfTuples << ". Number of components : " << nbOfCompo << "." << std::endl;
6127 reprQuickOverviewData(stream,MAX_NB_OF_BYTE_IN_REPR);
6130 stream << "Number of components : 0.";
6133 stream << "*** No data allocated ****";
6136 void DataArrayInt::reprQuickOverviewData(std::ostream& stream, std::size_t maxNbOfByteInRepr) const
6138 const int *data=begin();
6139 int nbOfTuples=getNumberOfTuples();
6140 int nbOfCompo=(int)_info_on_compo.size();
6141 std::ostringstream oss2; oss2 << "[";
6142 std::string oss2Str(oss2.str());
6143 bool isFinished=true;
6144 for(int i=0;i<nbOfTuples && isFinished;i++)
6149 for(int j=0;j<nbOfCompo;j++,data++)
6152 if(j!=nbOfCompo-1) oss2 << ", ";
6158 if(i!=nbOfTuples-1) oss2 << ", ";
6159 std::string oss3Str(oss2.str());
6160 if(oss3Str.length()<maxNbOfByteInRepr)
6172 * Modifies \a this one-dimensional array so that each value \a v = \a indArrBg[ \a v ],
6173 * i.e. a current value is used as in index to get a new value from \a indArrBg.
6174 * \param [in] indArrBg - pointer to the first element of array of new values to assign
6176 * \param [in] indArrEnd - specifies the end of the array \a indArrBg, so that
6177 * the last value of \a indArrBg is \a indArrEnd[ -1 ].
6178 * \throw If \a this->getNumberOfComponents() != 1
6179 * \throw If any value of \a this can't be used as a valid index for
6180 * [\a indArrBg, \a indArrEnd).
6182 void DataArrayInt::transformWithIndArr(const int *indArrBg, const int *indArrEnd)
6185 if(getNumberOfComponents()!=1)
6186 throw INTERP_KERNEL::Exception("Call transformWithIndArr method on DataArrayInt with only one component, you can call 'rearrange' method before !");
6187 int nbElemsIn=(int)std::distance(indArrBg,indArrEnd);
6188 int nbOfTuples=getNumberOfTuples();
6189 int *pt=getPointer();
6190 for(int i=0;i<nbOfTuples;i++,pt++)
6192 if(*pt>=0 && *pt<nbElemsIn)
6196 std::ostringstream oss; oss << "DataArrayInt::transformWithIndArr : error on tuple #" << i << " of this value is " << *pt << ", should be in [0," << nbElemsIn << ") !";
6197 throw INTERP_KERNEL::Exception(oss.str().c_str());
6204 * Computes distribution of values of \a this one-dimensional array between given value
6205 * ranges (casts). This method is typically useful for entity number spliting by types,
6207 * \warning The values contained in \a arrBg should be sorted ascendently. No
6208 * check of this is be done. If not, the result is not warranted.
6209 * \param [in] arrBg - the array of ascending values defining the value ranges. The i-th
6210 * value of \a arrBg (\a arrBg[ i ]) gives the lowest value of the i-th range,
6211 * and the greatest value of the i-th range equals to \a arrBg[ i+1 ] - 1. \a
6212 * arrBg containing \a n values defines \a n-1 ranges. The last value of \a arrBg
6213 * should be more than every value in \a this array.
6214 * \param [in] arrEnd - specifies the end of the array \a arrBg, so that
6215 * the last value of \a arrBg is \a arrEnd[ -1 ].
6216 * \param [out] castArr - a new instance of DataArrayInt, of same size as \a this array
6217 * (same number of tuples and components), the caller is to delete
6218 * using decrRef() as it is no more needed.
6219 * This array contains indices of ranges for every value of \a this array. I.e.
6220 * the i-th value of \a castArr gives the index of range the i-th value of \a this
6221 * belongs to. Or, in other words, this parameter contains for each tuple in \a
6222 * this in which cast it holds.
6223 * \param [out] rankInsideCast - a new instance of DataArrayInt, of same size as \a this
6224 * array, the caller is to delete using decrRef() as it is no more needed.
6225 * This array contains ranks of values of \a this array within ranges
6226 * they belongs to. I.e. the i-th value of \a rankInsideCast gives the rank of
6227 * the i-th value of \a this array within the \a castArr[ i ]-th range, to which
6228 * the i-th value of \a this belongs to. Or, in other words, this param contains
6229 * for each tuple its rank inside its cast. The rank is computed as difference
6230 * between the value and the lowest value of range.
6231 * \param [out] castsPresent - a new instance of DataArrayInt, containing indices of
6232 * ranges (casts) to which at least one value of \a this array belongs.
6233 * Or, in other words, this param contains the casts that \a this contains.
6234 * The caller is to delete this array using decrRef() as it is no more needed.
6236 * \b Example: If \a this contains [6,5,0,3,2,7,8,1,4] and \a arrBg contains [0,4,9] then
6237 * the output of this method will be :
6238 * - \a castArr : [1,1,0,0,0,1,1,0,1]
6239 * - \a rankInsideCast: [2,1,0,3,2,3,4,1,0]
6240 * - \a castsPresent : [0,1]
6242 * I.e. values of \a this array belong to 2 ranges: #0 and #1. Value 6 belongs to the
6243 * range #1 and its rank within this range is 2; etc.
6245 * \throw If \a this->getNumberOfComponents() != 1.
6246 * \throw If \a arrEnd - arrBg < 2.
6247 * \throw If any value of \a this is not less than \a arrEnd[-1].
6249 void DataArrayInt::splitByValueRange(const int *arrBg, const int *arrEnd,
6250 DataArrayInt *& castArr, DataArrayInt *& rankInsideCast, DataArrayInt *& castsPresent) const throw(INTERP_KERNEL::Exception)
6253 if(getNumberOfComponents()!=1)
6254 throw INTERP_KERNEL::Exception("Call splitByValueRange method on DataArrayInt with only one component, you can call 'rearrange' method before !");
6255 int nbOfTuples=getNumberOfTuples();
6256 std::size_t nbOfCast=std::distance(arrBg,arrEnd);
6258 throw INTERP_KERNEL::Exception("DataArrayInt::splitByValueRange : The input array giving the cast range values should be of size >=2 !");
6260 const int *work=getConstPointer();
6261 typedef std::reverse_iterator<const int *> rintstart;
6262 rintstart bg(arrEnd);//OK no problem because size of 'arr' is greater or equal 2
6263 rintstart end2(arrBg);
6264 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret1=DataArrayInt::New();
6265 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret2=DataArrayInt::New();
6266 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret3=DataArrayInt::New();
6267 ret1->alloc(nbOfTuples,1);
6268 ret2->alloc(nbOfTuples,1);
6269 int *ret1Ptr=ret1->getPointer();
6270 int *ret2Ptr=ret2->getPointer();
6271 std::set<std::size_t> castsDetected;
6272 for(int i=0;i<nbOfTuples;i++)
6274 rintstart res=std::find_if(bg,end2,std::bind2nd(std::less_equal<int>(), work[i]));
6275 std::size_t pos=std::distance(bg,res);
6276 std::size_t pos2=nbOfCast-pos;
6279 ret1Ptr[i]=(int)pos2;
6280 ret2Ptr[i]=work[i]-arrBg[pos2];
6281 castsDetected.insert(pos2);
6285 std::ostringstream oss; oss << "DataArrayInt::splitByValueRange : At rank #" << i << " the value is " << work[i] << " should be in [0," << *bg << ") !";
6286 throw INTERP_KERNEL::Exception(oss.str().c_str());
6289 ret3->alloc((int)castsDetected.size(),1);
6290 std::copy(castsDetected.begin(),castsDetected.end(),ret3->getPointer());
6291 castArr=ret1.retn();
6292 rankInsideCast=ret2.retn();
6293 castsPresent=ret3.retn();
6297 * Creates a one-dimensional DataArrayInt (\a res) whose contents are computed from
6298 * values of \a this (\a a) and the given (\a indArr) arrays as follows:
6299 * \a res[ \a indArr[ \a a[ i ]]] = i. I.e. for each value in place i \a v = \a a[ i ],
6300 * new value in place \a indArr[ \a v ] is i.
6301 * \param [in] indArrBg - the array holding indices within the result array to assign
6302 * indices of values of \a this array pointing to values of \a indArrBg.
6303 * \param [in] indArrEnd - specifies the end of the array \a indArrBg, so that
6304 * the last value of \a indArrBg is \a indArrEnd[ -1 ].
6305 * \return DataArrayInt * - the new instance of DataArrayInt.
6306 * The caller is to delete this result array using decrRef() as it is no more
6308 * \throw If \a this->getNumberOfComponents() != 1.
6309 * \throw If any value of \a this array is not a valid index for \a indArrBg array.
6310 * \throw If any value of \a indArrBg is not a valid index for \a this array.
6312 DataArrayInt *DataArrayInt::transformWithIndArrR(const int *indArrBg, const int *indArrEnd) const
6315 if(getNumberOfComponents()!=1)
6316 throw INTERP_KERNEL::Exception("Call transformWithIndArrR method on DataArrayInt with only one component, you can call 'rearrange' method before !");
6317 int nbElemsIn=(int)std::distance(indArrBg,indArrEnd);
6318 int nbOfTuples=getNumberOfTuples();
6319 const int *pt=getConstPointer();
6320 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
6321 ret->alloc(nbOfTuples,1);
6322 ret->fillWithValue(-1);
6323 int *tmp=ret->getPointer();
6324 for(int i=0;i<nbOfTuples;i++,pt++)
6326 if(*pt>=0 && *pt<nbElemsIn)
6328 int pos=indArrBg[*pt];
6329 if(pos>=0 && pos<nbOfTuples)
6333 std::ostringstream oss; oss << "DataArrayInt::transformWithIndArrR : error on tuple #" << i << " value of new pos is " << pos << " ( indArrBg[" << *pt << "]) ! Should be in [0," << nbOfTuples << ") !";
6334 throw INTERP_KERNEL::Exception(oss.str().c_str());
6339 std::ostringstream oss; oss << "DataArrayInt::transformWithIndArrR : error on tuple #" << i << " value is " << *pt << " and indirectionnal array as a size equal to " << nbElemsIn << " !";
6340 throw INTERP_KERNEL::Exception(oss.str().c_str());
6347 * Creates a one-dimensional DataArrayInt of given length, whose contents are computed
6348 * from values of \a this array, which is supposed to contain a renumbering map in
6349 * "Old to New" mode. The result array contains a renumbering map in "New to Old" mode.
6350 * To know how to use the renumbering maps see \ref MEDCouplingArrayRenumbering.
6351 * \param [in] newNbOfElem - the number of tuples in the result array.
6352 * \return DataArrayInt * - the new instance of DataArrayInt.
6353 * The caller is to delete this result array using decrRef() as it is no more
6356 * \ref cpp_mcdataarrayint_invertarrayo2n2n2o "Here is a C++ example".<br>
6357 * \ref py_mcdataarrayint_invertarrayo2n2n2o "Here is a Python example".
6359 DataArrayInt *DataArrayInt::invertArrayO2N2N2O(int newNbOfElem) const
6361 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
6362 ret->alloc(newNbOfElem,1);
6363 int nbOfOldNodes=getNumberOfTuples();
6364 const int *old2New=getConstPointer();
6365 int *pt=ret->getPointer();
6366 for(int i=0;i!=nbOfOldNodes;i++)
6368 int newp(old2New[i]);
6371 if(newp>=0 && newp<newNbOfElem)
6375 std::ostringstream oss; oss << "DataArrayInt::invertArrayO2N2N2O : At place #" << i << " the newplace is " << newp << " must be in [0," << newNbOfElem << ") !";
6376 throw INTERP_KERNEL::Exception(oss.str().c_str());
6384 * This method is similar to DataArrayInt::invertArrayO2N2N2O except that
6385 * 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]
6387 DataArrayInt *DataArrayInt::invertArrayO2N2N2OBis(int newNbOfElem) const
6389 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
6390 ret->alloc(newNbOfElem,1);
6391 int nbOfOldNodes=getNumberOfTuples();
6392 const int *old2New=getConstPointer();
6393 int *pt=ret->getPointer();
6394 for(int i=nbOfOldNodes-1;i>=0;i--)
6396 int newp(old2New[i]);
6399 if(newp>=0 && newp<newNbOfElem)
6403 std::ostringstream oss; oss << "DataArrayInt::invertArrayO2N2N2OBis : At place #" << i << " the newplace is " << newp << " must be in [0," << newNbOfElem << ") !";
6404 throw INTERP_KERNEL::Exception(oss.str().c_str());
6412 * Creates a one-dimensional DataArrayInt of given length, whose contents are computed
6413 * from values of \a this array, which is supposed to contain a renumbering map in
6414 * "New to Old" mode. The result array contains a renumbering map in "Old to New" mode.
6415 * To know how to use the renumbering maps see \ref MEDCouplingArrayRenumbering.
6416 * \param [in] newNbOfElem - the number of tuples in the result array.
6417 * \return DataArrayInt * - the new instance of DataArrayInt.
6418 * The caller is to delete this result array using decrRef() as it is no more
6421 * \ref cpp_mcdataarrayint_invertarrayn2o2o2n "Here is a C++ example".
6423 * \ref py_mcdataarrayint_invertarrayn2o2o2n "Here is a Python example".
6425 DataArrayInt *DataArrayInt::invertArrayN2O2O2N(int oldNbOfElem) const
6428 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
6429 ret->alloc(oldNbOfElem,1);
6430 const int *new2Old=getConstPointer();
6431 int *pt=ret->getPointer();
6432 std::fill(pt,pt+oldNbOfElem,-1);
6433 int nbOfNewElems=getNumberOfTuples();
6434 for(int i=0;i<nbOfNewElems;i++)
6437 if(v>=0 && v<oldNbOfElem)
6441 std::ostringstream oss; oss << "DataArrayInt::invertArrayN2O2O2N : in new id #" << i << " old value is " << v << " expected to be in [0," << oldNbOfElem << ") !";
6442 throw INTERP_KERNEL::Exception(oss.str().c_str());
6449 * Equivalent to DataArrayInt::isEqual except that if false the reason of
6450 * mismatch is given.
6452 * \param [in] other the instance to be compared with \a this
6453 * \param [out] reason In case of inequality returns the reason.
6454 * \sa DataArrayInt::isEqual
6456 bool DataArrayInt::isEqualIfNotWhy(const DataArrayInt& other, std::string& reason) const
6458 if(!areInfoEqualsIfNotWhy(other,reason))
6460 return _mem.isEqual(other._mem,0,reason);
6464 * Checks if \a this and another DataArrayInt are fully equal. For more info see
6465 * \ref MEDCouplingArrayBasicsCompare.
6466 * \param [in] other - an instance of DataArrayInt to compare with \a this one.
6467 * \return bool - \a true if the two arrays are equal, \a false else.
6469 bool DataArrayInt::isEqual(const DataArrayInt& other) const
6472 return isEqualIfNotWhy(other,tmp);
6476 * Checks if values of \a this and another DataArrayInt are equal. For more info see
6477 * \ref MEDCouplingArrayBasicsCompare.
6478 * \param [in] other - an instance of DataArrayInt to compare with \a this one.
6479 * \return bool - \a true if the values of two arrays are equal, \a false else.
6481 bool DataArrayInt::isEqualWithoutConsideringStr(const DataArrayInt& other) const
6484 return _mem.isEqual(other._mem,0,tmp);
6488 * Checks if values of \a this and another DataArrayInt are equal. Comparison is
6489 * performed on sorted value sequences.
6490 * For more info see\ref MEDCouplingArrayBasicsCompare.
6491 * \param [in] other - an instance of DataArrayInt to compare with \a this one.
6492 * \return bool - \a true if the sorted values of two arrays are equal, \a false else.
6494 bool DataArrayInt::isEqualWithoutConsideringStrAndOrder(const DataArrayInt& other) const
6496 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> a=deepCpy();
6497 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> b=other.deepCpy();
6500 return a->isEqualWithoutConsideringStr(*b);
6504 * This method compares content of input vector \a v and \a this.
6505 * 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.
6506 * For performance reasons \a this is expected to be sorted ascendingly. If not an exception will be thrown.
6508 * \param [in] v - the vector of 'flags' to be compared with \a this.
6510 * \throw If \a this is not sorted ascendingly.
6511 * \throw If \a this has not exactly one component.
6512 * \throw If \a this is not allocated.
6514 bool DataArrayInt::isFittingWith(const std::vector<bool>& v) const
6517 if(getNumberOfComponents()!=1)
6518 throw INTERP_KERNEL::Exception("DataArrayInt::isFittingWith : number of components of this should be equal to one !");
6519 const int *w(begin()),*end2(end());
6520 int refVal=-std::numeric_limits<int>::max();
6522 std::vector<bool>::const_iterator it(v.begin());
6523 for(;it!=v.end();it++,i++)
6535 std::ostringstream oss; oss << "DataArrayInt::isFittingWith : At pos #" << std::distance(begin(),w-1) << " this is not sorted ascendingly !";
6536 throw INTERP_KERNEL::Exception(oss.str().c_str());
6550 * Sorts values of the array.
6551 * \param [in] asc - \a true means ascending order, \a false, descending.
6552 * \throw If \a this is not allocated.
6553 * \throw If \a this->getNumberOfComponents() != 1.
6555 void DataArrayInt::sort(bool asc)
6558 if(getNumberOfComponents()!=1)
6559 throw INTERP_KERNEL::Exception("DataArrayInt::sort : only supported with 'this' array with ONE component !");
6565 * Computes for each tuple the sum of number of components values in the tuple and return it.
6567 * \return DataArrayInt * - the new instance of DataArrayInt containing the
6568 * same number of tuples as \a this array and one component.
6569 * The caller is to delete this result array using decrRef() as it is no more
6571 * \throw If \a this is not allocated.
6573 DataArrayInt *DataArrayInt::sumPerTuple() const
6576 int nbOfComp(getNumberOfComponents()),nbOfTuple(getNumberOfTuples());
6577 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New());
6578 ret->alloc(nbOfTuple,1);
6579 const int *src(getConstPointer());
6580 int *dest(ret->getPointer());
6581 for(int i=0;i<nbOfTuple;i++,dest++,src+=nbOfComp)
6582 *dest=std::accumulate(src,src+nbOfComp,0);
6587 * Reverse the array values.
6588 * \throw If \a this->getNumberOfComponents() < 1.
6589 * \throw If \a this is not allocated.
6591 void DataArrayInt::reverse()
6594 _mem.reverse(getNumberOfComponents());
6599 * Checks that \a this array is consistently **increasing** or **decreasing** in value.
6600 * If not an exception is thrown.
6601 * \param [in] increasing - if \a true, the array values should be increasing.
6602 * \throw If sequence of values is not strictly monotonic in agreement with \a
6604 * \throw If \a this->getNumberOfComponents() != 1.
6605 * \throw If \a this is not allocated.
6607 void DataArrayInt::checkMonotonic(bool increasing) const
6609 if(!isMonotonic(increasing))
6612 throw INTERP_KERNEL::Exception("DataArrayInt::checkMonotonic : 'this' is not INCREASING monotonic !");
6614 throw INTERP_KERNEL::Exception("DataArrayInt::checkMonotonic : 'this' is not DECREASING monotonic !");
6619 * Checks that \a this array is consistently **increasing** or **decreasing** in value.
6620 * \param [in] increasing - if \a true, array values should be increasing.
6621 * \return bool - \a true if values change in accordance with \a increasing arg.
6622 * \throw If \a this->getNumberOfComponents() != 1.
6623 * \throw If \a this is not allocated.
6625 bool DataArrayInt::isMonotonic(bool increasing) const
6628 if(getNumberOfComponents()!=1)
6629 throw INTERP_KERNEL::Exception("DataArrayInt::isMonotonic : only supported with 'this' array with ONE component !");
6630 int nbOfElements=getNumberOfTuples();
6631 const int *ptr=getConstPointer();
6637 for(int i=1;i<nbOfElements;i++)
6647 for(int i=1;i<nbOfElements;i++)
6659 * This method check that array consistently INCREASING or DECREASING in value.
6661 bool DataArrayInt::isStrictlyMonotonic(bool increasing) const
6664 if(getNumberOfComponents()!=1)
6665 throw INTERP_KERNEL::Exception("DataArrayInt::isStrictlyMonotonic : only supported with 'this' array with ONE component !");
6666 int nbOfElements=getNumberOfTuples();
6667 const int *ptr=getConstPointer();
6673 for(int i=1;i<nbOfElements;i++)
6683 for(int i=1;i<nbOfElements;i++)
6695 * This method check that array consistently INCREASING or DECREASING in value.
6697 void DataArrayInt::checkStrictlyMonotonic(bool increasing) const
6699 if(!isStrictlyMonotonic(increasing))
6702 throw INTERP_KERNEL::Exception("DataArrayInt::checkStrictlyMonotonic : 'this' is not strictly INCREASING monotonic !");
6704 throw INTERP_KERNEL::Exception("DataArrayInt::checkStrictlyMonotonic : 'this' is not strictly DECREASING monotonic !");
6709 * Creates a new one-dimensional DataArrayInt of the same size as \a this and a given
6710 * one-dimensional arrays that must be of the same length. The result array describes
6711 * correspondence between \a this and \a other arrays, so that
6712 * <em> other.getIJ(i,0) == this->getIJ(ret->getIJ(i),0)</em>. If such a permutation is
6713 * not possible because some element in \a other is not in \a this, an exception is thrown.
6714 * \param [in] other - an array to compute permutation to.
6715 * \return DataArrayInt * - a new instance of DataArrayInt, which is a permutation array
6716 * from \a this to \a other. The caller is to delete this array using decrRef() as it is
6718 * \throw If \a this->getNumberOfComponents() != 1.
6719 * \throw If \a other->getNumberOfComponents() != 1.
6720 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples().
6721 * \throw If \a other includes a value which is not in \a this array.
6723 * \ref cpp_mcdataarrayint_buildpermutationarr "Here is a C++ example".
6725 * \ref py_mcdataarrayint_buildpermutationarr "Here is a Python example".
6727 DataArrayInt *DataArrayInt::buildPermutationArr(const DataArrayInt& other) const
6730 if(getNumberOfComponents()!=1 || other.getNumberOfComponents()!=1)
6731 throw INTERP_KERNEL::Exception("DataArrayInt::buildPermutationArr : 'this' and 'other' have to have exactly ONE component !");
6732 int nbTuple=getNumberOfTuples();
6733 other.checkAllocated();
6734 if(nbTuple!=other.getNumberOfTuples())
6735 throw INTERP_KERNEL::Exception("DataArrayInt::buildPermutationArr : 'this' and 'other' must have the same number of tuple !");
6736 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
6737 ret->alloc(nbTuple,1);
6738 ret->fillWithValue(-1);
6739 const int *pt=getConstPointer();
6740 std::map<int,int> mm;
6741 for(int i=0;i<nbTuple;i++)
6743 pt=other.getConstPointer();
6744 int *retToFill=ret->getPointer();
6745 for(int i=0;i<nbTuple;i++)
6747 std::map<int,int>::const_iterator it=mm.find(pt[i]);
6750 std::ostringstream oss; oss << "DataArrayInt::buildPermutationArr : Arrays mismatch : element (" << pt[i] << ") in 'other' not findable in 'this' !";
6751 throw INTERP_KERNEL::Exception(oss.str().c_str());
6753 retToFill[i]=(*it).second;
6759 * Sets a C array to be used as raw data of \a this. The previously set info
6760 * of components is retained and re-sized.
6761 * For more info see \ref MEDCouplingArraySteps1.
6762 * \param [in] array - the C array to be used as raw data of \a this.
6763 * \param [in] ownership - if \a true, \a array will be deallocated at destruction of \a this.
6764 * \param [in] type - specifies how to deallocate \a array. If \a type == ParaMEDMEM::CPP_DEALLOC,
6765 * \c delete [] \c array; will be called. If \a type == ParaMEDMEM::C_DEALLOC,
6766 * \c free(\c array ) will be called.
6767 * \param [in] nbOfTuple - new number of tuples in \a this.
6768 * \param [in] nbOfCompo - new number of components in \a this.
6770 void DataArrayInt::useArray(const int *array, bool ownership, DeallocType type, int nbOfTuple, int nbOfCompo)
6772 _info_on_compo.resize(nbOfCompo);
6773 _mem.useArray(array,ownership,type,nbOfTuple*nbOfCompo);
6777 void DataArrayInt::useExternalArrayWithRWAccess(const int *array, int nbOfTuple, int nbOfCompo)
6779 _info_on_compo.resize(nbOfCompo);
6780 _mem.useExternalArrayWithRWAccess(array,nbOfTuple*nbOfCompo);
6785 * Returns a new DataArrayInt holding the same values as \a this array but differently
6786 * arranged in memory. If \a this array holds 2 components of 3 values:
6787 * \f$ x_0,x_1,x_2,y_0,y_1,y_2 \f$, then the result array holds these values arranged
6788 * as follows: \f$ x_0,y_0,x_1,y_1,x_2,y_2 \f$.
6789 * \warning Do not confuse this method with transpose()!
6790 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
6791 * is to delete using decrRef() as it is no more needed.
6792 * \throw If \a this is not allocated.
6794 DataArrayInt *DataArrayInt::fromNoInterlace() const
6798 throw INTERP_KERNEL::Exception("DataArrayInt::fromNoInterlace : Not defined array !");
6799 int *tab=_mem.fromNoInterlace(getNumberOfComponents());
6800 DataArrayInt *ret=DataArrayInt::New();
6801 ret->useArray(tab,true,C_DEALLOC,getNumberOfTuples(),getNumberOfComponents());
6806 * Returns a new DataArrayInt holding the same values as \a this array but differently
6807 * arranged in memory. If \a this array holds 2 components of 3 values:
6808 * \f$ x_0,y_0,x_1,y_1,x_2,y_2 \f$, then the result array holds these values arranged
6809 * as follows: \f$ x_0,x_1,x_2,y_0,y_1,y_2 \f$.
6810 * \warning Do not confuse this method with transpose()!
6811 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
6812 * is to delete using decrRef() as it is no more needed.
6813 * \throw If \a this is not allocated.
6815 DataArrayInt *DataArrayInt::toNoInterlace() const
6819 throw INTERP_KERNEL::Exception("DataArrayInt::toNoInterlace : Not defined array !");
6820 int *tab=_mem.toNoInterlace(getNumberOfComponents());
6821 DataArrayInt *ret=DataArrayInt::New();
6822 ret->useArray(tab,true,C_DEALLOC,getNumberOfTuples(),getNumberOfComponents());
6827 * Permutes values of \a this array as required by \a old2New array. The values are
6828 * permuted so that \c new[ \a old2New[ i ]] = \c old[ i ]. Number of tuples remains
6829 * the same as in \this one.
6830 * If a permutation reduction is needed, substr() or selectByTupleId() should be used.
6831 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
6832 * \param [in] old2New - C array of length equal to \a this->getNumberOfTuples()
6833 * giving a new position for i-th old value.
6835 void DataArrayInt::renumberInPlace(const int *old2New)
6838 int nbTuples=getNumberOfTuples();
6839 int nbOfCompo=getNumberOfComponents();
6840 int *tmp=new int[nbTuples*nbOfCompo];
6841 const int *iptr=getConstPointer();
6842 for(int i=0;i<nbTuples;i++)
6845 if(v>=0 && v<nbTuples)
6846 std::copy(iptr+nbOfCompo*i,iptr+nbOfCompo*(i+1),tmp+nbOfCompo*v);
6849 std::ostringstream oss; oss << "DataArrayInt::renumberInPlace : At place #" << i << " value is " << v << " ! Should be in [0," << nbTuples << ") !";
6850 throw INTERP_KERNEL::Exception(oss.str().c_str());
6853 std::copy(tmp,tmp+nbTuples*nbOfCompo,getPointer());
6859 * Permutes values of \a this array as required by \a new2Old array. The values are
6860 * permuted so that \c new[ i ] = \c old[ \a new2Old[ i ]]. Number of tuples remains
6861 * the same as in \this one.
6862 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
6863 * \param [in] new2Old - C array of length equal to \a this->getNumberOfTuples()
6864 * giving a previous position of i-th new value.
6865 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
6866 * is to delete using decrRef() as it is no more needed.
6868 void DataArrayInt::renumberInPlaceR(const int *new2Old)
6871 int nbTuples=getNumberOfTuples();
6872 int nbOfCompo=getNumberOfComponents();
6873 int *tmp=new int[nbTuples*nbOfCompo];
6874 const int *iptr=getConstPointer();
6875 for(int i=0;i<nbTuples;i++)
6878 if(v>=0 && v<nbTuples)
6879 std::copy(iptr+nbOfCompo*v,iptr+nbOfCompo*(v+1),tmp+nbOfCompo*i);
6882 std::ostringstream oss; oss << "DataArrayInt::renumberInPlaceR : At place #" << i << " value is " << v << " ! Should be in [0," << nbTuples << ") !";
6883 throw INTERP_KERNEL::Exception(oss.str().c_str());
6886 std::copy(tmp,tmp+nbTuples*nbOfCompo,getPointer());
6892 * Returns a copy of \a this array with values permuted as required by \a old2New array.
6893 * The values are permuted so that \c new[ \a old2New[ i ]] = \c old[ i ].
6894 * Number of tuples in the result array remains the same as in \this one.
6895 * If a permutation reduction is needed, renumberAndReduce() should be used.
6896 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
6897 * \param [in] old2New - C array of length equal to \a this->getNumberOfTuples()
6898 * giving a new position for i-th old value.
6899 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
6900 * is to delete using decrRef() as it is no more needed.
6901 * \throw If \a this is not allocated.
6903 DataArrayInt *DataArrayInt::renumber(const int *old2New) const
6906 int nbTuples=getNumberOfTuples();
6907 int nbOfCompo=getNumberOfComponents();
6908 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
6909 ret->alloc(nbTuples,nbOfCompo);
6910 ret->copyStringInfoFrom(*this);
6911 const int *iptr=getConstPointer();
6912 int *optr=ret->getPointer();
6913 for(int i=0;i<nbTuples;i++)
6914 std::copy(iptr+nbOfCompo*i,iptr+nbOfCompo*(i+1),optr+nbOfCompo*old2New[i]);
6915 ret->copyStringInfoFrom(*this);
6920 * Returns a copy of \a this array with values permuted as required by \a new2Old array.
6921 * The values are permuted so that \c new[ i ] = \c old[ \a new2Old[ i ]]. Number of
6922 * tuples in the result array remains the same as in \this one.
6923 * If a permutation reduction is needed, substr() or selectByTupleId() should be used.
6924 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
6925 * \param [in] new2Old - C array of length equal to \a this->getNumberOfTuples()
6926 * giving a previous position of i-th new value.
6927 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
6928 * is to delete using decrRef() as it is no more needed.
6930 DataArrayInt *DataArrayInt::renumberR(const int *new2Old) const
6933 int nbTuples=getNumberOfTuples();
6934 int nbOfCompo=getNumberOfComponents();
6935 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
6936 ret->alloc(nbTuples,nbOfCompo);
6937 ret->copyStringInfoFrom(*this);
6938 const int *iptr=getConstPointer();
6939 int *optr=ret->getPointer();
6940 for(int i=0;i<nbTuples;i++)
6941 std::copy(iptr+nbOfCompo*new2Old[i],iptr+nbOfCompo*(new2Old[i]+1),optr+nbOfCompo*i);
6942 ret->copyStringInfoFrom(*this);
6947 * Returns a shorten and permuted copy of \a this array. The new DataArrayInt is
6948 * of size \a newNbOfTuple and it's values are permuted as required by \a old2New array.
6949 * The values are permuted so that \c new[ \a old2New[ i ]] = \c old[ i ] for all
6950 * \a old2New[ i ] >= 0. In other words every i-th tuple in \a this array, for which
6951 * \a old2New[ i ] is negative, is missing from the result array.
6952 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
6953 * \param [in] old2New - C array of length equal to \a this->getNumberOfTuples()
6954 * giving a new position for i-th old tuple and giving negative position for
6955 * for i-th old tuple that should be omitted.
6956 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
6957 * is to delete using decrRef() as it is no more needed.
6959 DataArrayInt *DataArrayInt::renumberAndReduce(const int *old2New, int newNbOfTuple) const
6962 int nbTuples=getNumberOfTuples();
6963 int nbOfCompo=getNumberOfComponents();
6964 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
6965 ret->alloc(newNbOfTuple,nbOfCompo);
6966 const int *iptr=getConstPointer();
6967 int *optr=ret->getPointer();
6968 for(int i=0;i<nbTuples;i++)
6972 std::copy(iptr+i*nbOfCompo,iptr+(i+1)*nbOfCompo,optr+w*nbOfCompo);
6974 ret->copyStringInfoFrom(*this);
6979 * Returns a shorten and permuted copy of \a this array. The new DataArrayInt is
6980 * of size \a new2OldEnd - \a new2OldBg and it's values are permuted as required by
6981 * \a new2OldBg array.
6982 * The values are permuted so that \c new[ i ] = \c old[ \a new2OldBg[ i ]].
6983 * This method is equivalent to renumberAndReduce() except that convention in input is
6984 * \c new2old and \b not \c old2new.
6985 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
6986 * \param [in] new2OldBg - pointer to the beginning of a permutation array that gives a
6987 * tuple index in \a this array to fill the i-th tuple in the new array.
6988 * \param [in] new2OldEnd - specifies the end of the permutation array that starts at
6989 * \a new2OldBg, so that pointer to a tuple index (\a pi) varies as this:
6990 * \a new2OldBg <= \a pi < \a new2OldEnd.
6991 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
6992 * is to delete using decrRef() as it is no more needed.
6994 DataArrayInt *DataArrayInt::selectByTupleId(const int *new2OldBg, const int *new2OldEnd) const
6997 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
6998 int nbComp=getNumberOfComponents();
6999 ret->alloc((int)std::distance(new2OldBg,new2OldEnd),nbComp);
7000 ret->copyStringInfoFrom(*this);
7001 int *pt=ret->getPointer();
7002 const int *srcPt=getConstPointer();
7004 for(const int *w=new2OldBg;w!=new2OldEnd;w++,i++)
7005 std::copy(srcPt+(*w)*nbComp,srcPt+((*w)+1)*nbComp,pt+i*nbComp);
7006 ret->copyStringInfoFrom(*this);
7011 * Returns a shorten and permuted copy of \a this array. The new DataArrayInt is
7012 * of size \a new2OldEnd - \a new2OldBg and it's values are permuted as required by
7013 * \a new2OldBg array.
7014 * The values are permuted so that \c new[ i ] = \c old[ \a new2OldBg[ i ]].
7015 * This method is equivalent to renumberAndReduce() except that convention in input is
7016 * \c new2old and \b not \c old2new.
7017 * This method is equivalent to selectByTupleId() except that it prevents coping data
7018 * from behind the end of \a this array.
7019 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
7020 * \param [in] new2OldBg - pointer to the beginning of a permutation array that gives a
7021 * tuple index in \a this array to fill the i-th tuple in the new array.
7022 * \param [in] new2OldEnd - specifies the end of the permutation array that starts at
7023 * \a new2OldBg, so that pointer to a tuple index (\a pi) varies as this:
7024 * \a new2OldBg <= \a pi < \a new2OldEnd.
7025 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
7026 * is to delete using decrRef() as it is no more needed.
7027 * \throw If \a new2OldEnd - \a new2OldBg > \a this->getNumberOfTuples().
7029 DataArrayInt *DataArrayInt::selectByTupleIdSafe(const int *new2OldBg, const int *new2OldEnd) const
7032 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7033 int nbComp=getNumberOfComponents();
7034 int oldNbOfTuples=getNumberOfTuples();
7035 ret->alloc((int)std::distance(new2OldBg,new2OldEnd),nbComp);
7036 ret->copyStringInfoFrom(*this);
7037 int *pt=ret->getPointer();
7038 const int *srcPt=getConstPointer();
7040 for(const int *w=new2OldBg;w!=new2OldEnd;w++,i++)
7041 if(*w>=0 && *w<oldNbOfTuples)
7042 std::copy(srcPt+(*w)*nbComp,srcPt+((*w)+1)*nbComp,pt+i*nbComp);
7044 throw INTERP_KERNEL::Exception("DataArrayInt::selectByTupleIdSafe : some ids has been detected to be out of [0,this->getNumberOfTuples) !");
7045 ret->copyStringInfoFrom(*this);
7050 * Returns a shorten copy of \a this array. The new DataArrayInt contains every
7051 * (\a bg + \c i * \a step)-th tuple of \a this array located before the \a end2-th
7052 * tuple. Indices of the selected tuples are the same as ones returned by the Python
7053 * command \c range( \a bg, \a end2, \a step ).
7054 * This method is equivalent to selectByTupleIdSafe() except that the input array is
7055 * not constructed explicitly.
7056 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
7057 * \param [in] bg - index of the first tuple to copy from \a this array.
7058 * \param [in] end2 - index of the tuple before which the tuples to copy are located.
7059 * \param [in] step - index increment to get index of the next tuple to copy.
7060 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
7061 * is to delete using decrRef() as it is no more needed.
7062 * \sa DataArrayInt::substr.
7064 DataArrayInt *DataArrayInt::selectByTupleId2(int bg, int end2, int step) const
7067 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7068 int nbComp=getNumberOfComponents();
7069 int newNbOfTuples=GetNumberOfItemGivenBESRelative(bg,end2,step,"DataArrayInt::selectByTupleId2 : ");
7070 ret->alloc(newNbOfTuples,nbComp);
7071 int *pt=ret->getPointer();
7072 const int *srcPt=getConstPointer()+bg*nbComp;
7073 for(int i=0;i<newNbOfTuples;i++,srcPt+=step*nbComp)
7074 std::copy(srcPt,srcPt+nbComp,pt+i*nbComp);
7075 ret->copyStringInfoFrom(*this);
7080 * Returns a shorten copy of \a this array. The new DataArrayInt contains ranges
7081 * of tuples specified by \a ranges parameter.
7082 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
7083 * \param [in] ranges - std::vector of std::pair's each of which defines a range
7084 * of tuples in [\c begin,\c end) format.
7085 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
7086 * is to delete using decrRef() as it is no more needed.
7087 * \throw If \a end < \a begin.
7088 * \throw If \a end > \a this->getNumberOfTuples().
7089 * \throw If \a this is not allocated.
7091 DataArray *DataArrayInt::selectByTupleRanges(const std::vector<std::pair<int,int> >& ranges) const
7094 int nbOfComp=getNumberOfComponents();
7095 int nbOfTuplesThis=getNumberOfTuples();
7098 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7099 ret->alloc(0,nbOfComp);
7100 ret->copyStringInfoFrom(*this);
7103 int ref=ranges.front().first;
7105 bool isIncreasing=true;
7106 for(std::vector<std::pair<int,int> >::const_iterator it=ranges.begin();it!=ranges.end();it++)
7108 if((*it).first<=(*it).second)
7110 if((*it).first>=0 && (*it).second<=nbOfTuplesThis)
7112 nbOfTuples+=(*it).second-(*it).first;
7114 isIncreasing=ref<=(*it).first;
7119 std::ostringstream oss; oss << "DataArrayInt::selectByTupleRanges : on range #" << std::distance(ranges.begin(),it);
7120 oss << " (" << (*it).first << "," << (*it).second << ") is greater than number of tuples of this :" << nbOfTuples << " !";
7121 throw INTERP_KERNEL::Exception(oss.str().c_str());
7126 std::ostringstream oss; oss << "DataArrayInt::selectByTupleRanges : on range #" << std::distance(ranges.begin(),it);
7127 oss << " (" << (*it).first << "," << (*it).second << ") end is before begin !";
7128 throw INTERP_KERNEL::Exception(oss.str().c_str());
7131 if(isIncreasing && nbOfTuplesThis==nbOfTuples)
7133 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7134 ret->alloc(nbOfTuples,nbOfComp);
7135 ret->copyStringInfoFrom(*this);
7136 const int *src=getConstPointer();
7137 int *work=ret->getPointer();
7138 for(std::vector<std::pair<int,int> >::const_iterator it=ranges.begin();it!=ranges.end();it++)
7139 work=std::copy(src+(*it).first*nbOfComp,src+(*it).second*nbOfComp,work);
7144 * Returns a new DataArrayInt containing a renumbering map in "Old to New" mode.
7145 * This map, if applied to \a this array, would make it sorted. For example, if
7146 * \a this array contents are [9,10,0,6,4,11,3,7] then the contents of the result array
7147 * are [5,6,0,3,2,7,1,4]; if this result array (\a res) is used as an argument in call
7148 * \a this->renumber(\a res) then the returned array contains [0,3,4,6,7,9,10,11].
7149 * This method is useful for renumbering (in MED file for example). For more info
7150 * on renumbering see \ref MEDCouplingArrayRenumbering.
7151 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
7152 * array using decrRef() as it is no more needed.
7153 * \throw If \a this is not allocated.
7154 * \throw If \a this->getNumberOfComponents() != 1.
7155 * \throw If there are equal values in \a this array.
7157 DataArrayInt *DataArrayInt::checkAndPreparePermutation() const
7160 if(getNumberOfComponents()!=1)
7161 throw INTERP_KERNEL::Exception("DataArrayInt::checkAndPreparePermutation : number of components must == 1 !");
7162 int nbTuples=getNumberOfTuples();
7163 const int *pt=getConstPointer();
7164 int *pt2=CheckAndPreparePermutation(pt,pt+nbTuples);
7165 DataArrayInt *ret=DataArrayInt::New();
7166 ret->useArray(pt2,true,C_DEALLOC,nbTuples,1);
7171 * 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
7172 * input array \a ids2.
7173 * \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.
7174 * 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
7176 * In case of success (no throw) : \c ids1->renumber(ret)->isEqual(ids2) where \a ret is the return of this method.
7178 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
7179 * array using decrRef() as it is no more needed.
7180 * \throw If either ids1 or ids2 is null not allocated or not with one components.
7183 DataArrayInt *DataArrayInt::FindPermutationFromFirstToSecond(const DataArrayInt *ids1, const DataArrayInt *ids2)
7186 throw INTERP_KERNEL::Exception("DataArrayInt::FindPermutationFromFirstToSecond : the two input arrays must be not null !");
7187 if(!ids1->isAllocated() || !ids2->isAllocated())
7188 throw INTERP_KERNEL::Exception("DataArrayInt::FindPermutationFromFirstToSecond : the two input arrays must be allocated !");
7189 if(ids1->getNumberOfComponents()!=1 || ids2->getNumberOfComponents()!=1)
7190 throw INTERP_KERNEL::Exception("DataArrayInt::FindPermutationFromFirstToSecond : the two input arrays have exactly one component !");
7191 if(ids1->getNumberOfTuples()!=ids2->getNumberOfTuples())
7193 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 !";
7194 throw INTERP_KERNEL::Exception(oss.str().c_str());
7196 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> p1(ids1->deepCpy());
7197 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> p2(ids2->deepCpy());
7198 p1->sort(true); p2->sort(true);
7199 if(!p1->isEqualWithoutConsideringStr(*p2))
7200 throw INTERP_KERNEL::Exception("DataArrayInt::FindPermutationFromFirstToSecond : the two arrays are not lying on same ids ! Impossible to find a permutation between the 2 arrays !");
7201 p1=ids1->checkAndPreparePermutation();
7202 p2=ids2->checkAndPreparePermutation();
7203 p2=p2->invertArrayO2N2N2O(p2->getNumberOfTuples());
7204 p2=p2->selectByTupleIdSafe(p1->begin(),p1->end());
7209 * Returns two arrays describing a surjective mapping from \a this set of values (\a A)
7210 * onto a set of values of size \a targetNb (\a B). The surjective function is
7211 * \a B[ \a A[ i ]] = i. That is to say that for each \a id in [0,\a targetNb), where \a
7212 * targetNb < \a this->getNumberOfTuples(), there exists at least one tupleId (\a tid) so
7213 * that <em> this->getIJ( tid, 0 ) == id</em>. <br>
7214 * The first of out arrays returns indices of elements of \a this array, grouped by their
7215 * place in the set \a B. The second out array is the index of the first one; it shows how
7216 * many elements of \a A are mapped into each element of \a B. <br>
7218 * mapping and its usage in renumbering see \ref MEDCouplingArrayRenumbering. <br>
7220 * - \a this: [0,3,2,3,2,2,1,2]
7222 * - \a arr: [0, 6, 2,4,5,7, 1,3]
7223 * - \a arrI: [0,1,2,6,8]
7225 * This result means: <br>
7226 * the element of \a B 0 encounters within \a A once (\a arrI[ 0+1 ] - \a arrI[ 0 ]) and
7227 * its index within \a A is 0 ( \a arr[ 0:1 ] == \a arr[ \a arrI[ 0 ] : \a arrI[ 0+1 ]]);<br>
7228 * the element of \a B 2 encounters within \a A 4 times (\a arrI[ 2+1 ] - \a arrI[ 2 ]) and
7229 * its indices within \a A are [2,4,5,7] ( \a arr[ 2:6 ] == \a arr[ \a arrI[ 2 ] :
7230 * \a arrI[ 2+1 ]]); <br> etc.
7231 * \param [in] targetNb - the size of the set \a B. \a targetNb must be equal or more
7232 * than the maximal value of \a A.
7233 * \param [out] arr - a new instance of DataArrayInt returning indices of
7234 * elements of \a this, grouped by their place in the set \a B. The caller is to delete
7235 * this array using decrRef() as it is no more needed.
7236 * \param [out] arrI - a new instance of DataArrayInt returning size of groups of equal
7237 * elements of \a this. The caller is to delete this array using decrRef() as it
7238 * is no more needed.
7239 * \throw If \a this is not allocated.
7240 * \throw If \a this->getNumberOfComponents() != 1.
7241 * \throw If any value in \a this is more or equal to \a targetNb.
7243 void DataArrayInt::changeSurjectiveFormat(int targetNb, DataArrayInt *&arr, DataArrayInt *&arrI) const
7246 if(getNumberOfComponents()!=1)
7247 throw INTERP_KERNEL::Exception("DataArrayInt::changeSurjectiveFormat : number of components must == 1 !");
7248 int nbOfTuples=getNumberOfTuples();
7249 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New());
7250 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> retI(DataArrayInt::New());
7251 retI->alloc(targetNb+1,1);
7252 const int *input=getConstPointer();
7253 std::vector< std::vector<int> > tmp(targetNb);
7254 for(int i=0;i<nbOfTuples;i++)
7257 if(tmp2>=0 && tmp2<targetNb)
7258 tmp[tmp2].push_back(i);
7261 std::ostringstream oss; oss << "DataArrayInt::changeSurjectiveFormat : At pos " << i << " presence of element " << tmp2 << " ! should be in [0," << targetNb << ") !";
7262 throw INTERP_KERNEL::Exception(oss.str().c_str());
7265 int *retIPtr=retI->getPointer();
7267 for(std::vector< std::vector<int> >::const_iterator it1=tmp.begin();it1!=tmp.end();it1++,retIPtr++)
7268 retIPtr[1]=retIPtr[0]+(int)((*it1).size());
7269 if(nbOfTuples!=retI->getIJ(targetNb,0))
7270 throw INTERP_KERNEL::Exception("DataArrayInt::changeSurjectiveFormat : big problem should never happen !");
7271 ret->alloc(nbOfTuples,1);
7272 int *retPtr=ret->getPointer();
7273 for(std::vector< std::vector<int> >::const_iterator it1=tmp.begin();it1!=tmp.end();it1++)
7274 retPtr=std::copy((*it1).begin(),(*it1).end(),retPtr);
7281 * Returns a new DataArrayInt containing a renumbering map in "Old to New" mode computed
7282 * from a zip representation of a surjective format (returned e.g. by
7283 * \ref ParaMEDMEM::DataArrayDouble::findCommonTuples() "DataArrayDouble::findCommonTuples()"
7284 * for example). The result array minimizes the permutation. <br>
7285 * For more info on renumbering see \ref MEDCouplingArrayRenumbering. <br>
7287 * - \a nbOfOldTuples: 10
7288 * - \a arr : [0,3, 5,7,9]
7289 * - \a arrIBg : [0,2,5]
7290 * - \a newNbOfTuples: 7
7291 * - result array : [0,1,2,0,3,4,5,4,6,4]
7293 * \param [in] nbOfOldTuples - number of tuples in the initial array \a arr.
7294 * \param [in] arr - the array of tuple indices grouped by \a arrIBg array.
7295 * \param [in] arrIBg - the array dividing all indices stored in \a arr into groups of
7296 * (indices of) equal values. Its every element (except the last one) points to
7297 * the first element of a group of equal values.
7298 * \param [in] arrIEnd - specifies the end of \a arrIBg, so that the last element of \a
7299 * arrIBg is \a arrIEnd[ -1 ].
7300 * \param [out] newNbOfTuples - number of tuples after surjection application.
7301 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
7302 * array using decrRef() as it is no more needed.
7303 * \throw If any value of \a arr breaks condition ( 0 <= \a arr[ i ] < \a nbOfOldTuples ).
7305 DataArrayInt *DataArrayInt::BuildOld2NewArrayFromSurjectiveFormat2(int nbOfOldTuples, const int *arr, const int *arrIBg, const int *arrIEnd, int &newNbOfTuples)
7307 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7308 ret->alloc(nbOfOldTuples,1);
7309 int *pt=ret->getPointer();
7310 std::fill(pt,pt+nbOfOldTuples,-1);
7311 int nbOfGrps=((int)std::distance(arrIBg,arrIEnd))-1;
7312 const int *cIPtr=arrIBg;
7313 for(int i=0;i<nbOfGrps;i++)
7314 pt[arr[cIPtr[i]]]=-(i+2);
7316 for(int iNode=0;iNode<nbOfOldTuples;iNode++)
7324 int grpId=-(pt[iNode]+2);
7325 for(int j=cIPtr[grpId];j<cIPtr[grpId+1];j++)
7327 if(arr[j]>=0 && arr[j]<nbOfOldTuples)
7331 std::ostringstream oss; oss << "DataArrayInt::BuildOld2NewArrayFromSurjectiveFormat2 : With element #" << j << " value is " << arr[j] << " should be in [0," << nbOfOldTuples << ") !";
7332 throw INTERP_KERNEL::Exception(oss.str().c_str());
7339 newNbOfTuples=newNb;
7344 * Returns a new DataArrayInt containing a renumbering map in "New to Old" mode,
7345 * which if applied to \a this array would make it sorted ascendingly.
7346 * For more info on renumbering see \ref MEDCouplingArrayRenumbering. <br>
7348 * - \a this: [2,0,1,1,0,1,2,0,1,1,0,0]
7349 * - result: [10,0,5,6,1,7,11,2,8,9,3,4]
7350 * - after applying result to \a this: [0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2]
7352 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
7353 * array using decrRef() as it is no more needed.
7354 * \throw If \a this is not allocated.
7355 * \throw If \a this->getNumberOfComponents() != 1.
7357 DataArrayInt *DataArrayInt::buildPermArrPerLevel() const
7360 if(getNumberOfComponents()!=1)
7361 throw INTERP_KERNEL::Exception("DataArrayInt::buildPermArrPerLevel : number of components must == 1 !");
7362 int nbOfTuples=getNumberOfTuples();
7363 const int *pt=getConstPointer();
7364 std::map<int,int> m;
7365 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7366 ret->alloc(nbOfTuples,1);
7367 int *opt=ret->getPointer();
7368 for(int i=0;i<nbOfTuples;i++,pt++,opt++)
7371 std::map<int,int>::iterator it=m.find(val);
7380 m.insert(std::pair<int,int>(val,1));
7384 for(std::map<int,int>::iterator it=m.begin();it!=m.end();it++)
7386 int vt=(*it).second;
7390 pt=getConstPointer();
7391 opt=ret->getPointer();
7392 for(int i=0;i<nbOfTuples;i++,pt++,opt++)
7399 * Checks if contents of \a this array are equal to that of an array filled with
7400 * iota(). This method is particularly useful for DataArrayInt instances that represent
7401 * a renumbering array to check the real need in renumbering.
7402 * \return bool - \a true if \a this array contents == \a range( \a this->getNumberOfTuples())
7403 * \throw If \a this is not allocated.
7404 * \throw If \a this->getNumberOfComponents() != 1.
7406 bool DataArrayInt::isIdentity() const
7409 if(getNumberOfComponents()!=1)
7411 int nbOfTuples=getNumberOfTuples();
7412 const int *pt=getConstPointer();
7413 for(int i=0;i<nbOfTuples;i++,pt++)
7420 * Checks if all values in \a this array are equal to \a val.
7421 * \param [in] val - value to check equality of array values to.
7422 * \return bool - \a true if all values are \a val.
7423 * \throw If \a this is not allocated.
7424 * \throw If \a this->getNumberOfComponents() != 1
7426 bool DataArrayInt::isUniform(int val) const
7429 if(getNumberOfComponents()!=1)
7430 throw INTERP_KERNEL::Exception("DataArrayInt::isUniform : must be applied on DataArrayInt with only one component, you can call 'rearrange' method before !");
7431 int nbOfTuples=getNumberOfTuples();
7432 const int *w=getConstPointer();
7433 const int *end2=w+nbOfTuples;
7441 * Creates a new DataArrayDouble and assigns all (textual and numerical) data of \a this
7442 * array to the new one.
7443 * \return DataArrayDouble * - the new instance of DataArrayInt.
7445 DataArrayDouble *DataArrayInt::convertToDblArr() const
7448 DataArrayDouble *ret=DataArrayDouble::New();
7449 ret->alloc(getNumberOfTuples(),getNumberOfComponents());
7450 std::size_t nbOfVals=getNbOfElems();
7451 const int *src=getConstPointer();
7452 double *dest=ret->getPointer();
7453 std::copy(src,src+nbOfVals,dest);
7454 ret->copyStringInfoFrom(*this);
7459 * Returns a shorten copy of \a this array. The new DataArrayInt contains all
7460 * tuples starting from the \a tupleIdBg-th tuple and including all tuples located before
7461 * the \a tupleIdEnd-th one. This methods has a similar behavior as std::string::substr().
7462 * This method is a specialization of selectByTupleId2().
7463 * \param [in] tupleIdBg - index of the first tuple to copy from \a this array.
7464 * \param [in] tupleIdEnd - index of the tuple before which the tuples to copy are located.
7465 * If \a tupleIdEnd == -1, all the tuples till the end of \a this array are copied.
7466 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
7467 * is to delete using decrRef() as it is no more needed.
7468 * \throw If \a tupleIdBg < 0.
7469 * \throw If \a tupleIdBg > \a this->getNumberOfTuples().
7470 \throw If \a tupleIdEnd != -1 && \a tupleIdEnd < \a this->getNumberOfTuples().
7471 * \sa DataArrayInt::selectByTupleId2
7473 DataArrayInt *DataArrayInt::substr(int tupleIdBg, int tupleIdEnd) const
7476 int nbt=getNumberOfTuples();
7478 throw INTERP_KERNEL::Exception("DataArrayInt::substr : The tupleIdBg parameter must be greater than 0 !");
7480 throw INTERP_KERNEL::Exception("DataArrayInt::substr : The tupleIdBg parameter is greater than number of tuples !");
7481 int trueEnd=tupleIdEnd;
7485 throw INTERP_KERNEL::Exception("DataArrayInt::substr : The tupleIdBg parameter is greater or equal than number of tuples !");
7489 int nbComp=getNumberOfComponents();
7490 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7491 ret->alloc(trueEnd-tupleIdBg,nbComp);
7492 ret->copyStringInfoFrom(*this);
7493 std::copy(getConstPointer()+tupleIdBg*nbComp,getConstPointer()+trueEnd*nbComp,ret->getPointer());
7498 * Changes the number of components within \a this array so that its raw data **does
7499 * not** change, instead splitting this data into tuples changes.
7500 * \warning This method erases all (name and unit) component info set before!
7501 * \param [in] newNbOfComp - number of components for \a this array to have.
7502 * \throw If \a this is not allocated
7503 * \throw If getNbOfElems() % \a newNbOfCompo != 0.
7504 * \throw If \a newNbOfCompo is lower than 1.
7505 * \throw If the rearrange method would lead to a number of tuples higher than 2147483647 (maximal capacity of int32 !).
7506 * \warning This method erases all (name and unit) component info set before!
7508 void DataArrayInt::rearrange(int newNbOfCompo)
7512 throw INTERP_KERNEL::Exception("DataArrayInt::rearrange : input newNbOfCompo must be > 0 !");
7513 std::size_t nbOfElems=getNbOfElems();
7514 if(nbOfElems%newNbOfCompo!=0)
7515 throw INTERP_KERNEL::Exception("DataArrayInt::rearrange : nbOfElems%newNbOfCompo!=0 !");
7516 if(nbOfElems/newNbOfCompo>(std::size_t)std::numeric_limits<int>::max())
7517 throw INTERP_KERNEL::Exception("DataArrayInt::rearrange : the rearrangement leads to too high number of tuples (> 2147483647) !");
7518 _info_on_compo.clear();
7519 _info_on_compo.resize(newNbOfCompo);
7524 * Changes the number of components within \a this array to be equal to its number
7525 * of tuples, and inversely its number of tuples to become equal to its number of
7526 * components. So that its raw data **does not** change, instead splitting this
7527 * data into tuples changes.
7528 * \warning This method erases all (name and unit) component info set before!
7529 * \warning Do not confuse this method with fromNoInterlace() and toNoInterlace()!
7530 * \throw If \a this is not allocated.
7533 void DataArrayInt::transpose()
7536 int nbOfTuples=getNumberOfTuples();
7537 rearrange(nbOfTuples);
7541 * Returns a shorten or extended copy of \a this array. If \a newNbOfComp is less
7542 * than \a this->getNumberOfComponents() then the result array is shorten as each tuple
7543 * is truncated to have \a newNbOfComp components, keeping first components. If \a
7544 * newNbOfComp is more than \a this->getNumberOfComponents() then the result array is
7545 * expanded as each tuple is populated with \a dftValue to have \a newNbOfComp
7547 * \param [in] newNbOfComp - number of components for the new array to have.
7548 * \param [in] dftValue - value assigned to new values added to the new array.
7549 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
7550 * is to delete using decrRef() as it is no more needed.
7551 * \throw If \a this is not allocated.
7553 DataArrayInt *DataArrayInt::changeNbOfComponents(int newNbOfComp, int dftValue) const
7556 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7557 ret->alloc(getNumberOfTuples(),newNbOfComp);
7558 const int *oldc=getConstPointer();
7559 int *nc=ret->getPointer();
7560 int nbOfTuples=getNumberOfTuples();
7561 int oldNbOfComp=getNumberOfComponents();
7562 int dim=std::min(oldNbOfComp,newNbOfComp);
7563 for(int i=0;i<nbOfTuples;i++)
7567 nc[newNbOfComp*i+j]=oldc[i*oldNbOfComp+j];
7568 for(;j<newNbOfComp;j++)
7569 nc[newNbOfComp*i+j]=dftValue;
7571 ret->setName(getName());
7572 for(int i=0;i<dim;i++)
7573 ret->setInfoOnComponent(i,getInfoOnComponent(i));
7574 ret->setName(getName());
7579 * Changes number of tuples in the array. If the new number of tuples is smaller
7580 * than the current number the array is truncated, otherwise the array is extended.
7581 * \param [in] nbOfTuples - new number of tuples.
7582 * \throw If \a this is not allocated.
7583 * \throw If \a nbOfTuples is negative.
7585 void DataArrayInt::reAlloc(int nbOfTuples)
7588 throw INTERP_KERNEL::Exception("DataArrayInt::reAlloc : input new number of tuples should be >=0 !");
7590 _mem.reAlloc(getNumberOfComponents()*(std::size_t)nbOfTuples);
7596 * Returns a copy of \a this array composed of selected components.
7597 * The new DataArrayInt has the same number of tuples but includes components
7598 * specified by \a compoIds parameter. So that getNbOfElems() of the result array
7599 * can be either less, same or more than \a this->getNbOfElems().
7600 * \param [in] compoIds - sequence of zero based indices of components to include
7601 * into the new array.
7602 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
7603 * is to delete using decrRef() as it is no more needed.
7604 * \throw If \a this is not allocated.
7605 * \throw If a component index (\a i) is not valid:
7606 * \a i < 0 || \a i >= \a this->getNumberOfComponents().
7608 * \ref py_mcdataarrayint_keepselectedcomponents "Here is a Python example".
7610 DataArray *DataArrayInt::keepSelectedComponents(const std::vector<int>& compoIds) const
7613 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New());
7614 int newNbOfCompo=(int)compoIds.size();
7615 int oldNbOfCompo=getNumberOfComponents();
7616 for(std::vector<int>::const_iterator it=compoIds.begin();it!=compoIds.end();it++)
7617 DataArray::CheckValueInRange(oldNbOfCompo,(*it),"keepSelectedComponents invalid requested component");
7618 int nbOfTuples=getNumberOfTuples();
7619 ret->alloc(nbOfTuples,newNbOfCompo);
7620 ret->copyPartOfStringInfoFrom(*this,compoIds);
7621 const int *oldc=getConstPointer();
7622 int *nc=ret->getPointer();
7623 for(int i=0;i<nbOfTuples;i++)
7624 for(int j=0;j<newNbOfCompo;j++,nc++)
7625 *nc=oldc[i*oldNbOfCompo+compoIds[j]];
7630 * Appends components of another array to components of \a this one, tuple by tuple.
7631 * So that the number of tuples of \a this array remains the same and the number of
7632 * components increases.
7633 * \param [in] other - the DataArrayInt to append to \a this one.
7634 * \throw If \a this is not allocated.
7635 * \throw If \a this and \a other arrays have different number of tuples.
7637 * \ref cpp_mcdataarrayint_meldwith "Here is a C++ example".
7639 * \ref py_mcdataarrayint_meldwith "Here is a Python example".
7641 void DataArrayInt::meldWith(const DataArrayInt *other)
7644 throw INTERP_KERNEL::Exception("DataArrayInt::meldWith : DataArrayInt pointer in input is NULL !");
7646 other->checkAllocated();
7647 int nbOfTuples=getNumberOfTuples();
7648 if(nbOfTuples!=other->getNumberOfTuples())
7649 throw INTERP_KERNEL::Exception("DataArrayInt::meldWith : mismatch of number of tuples !");
7650 int nbOfComp1=getNumberOfComponents();
7651 int nbOfComp2=other->getNumberOfComponents();
7652 int *newArr=(int *)malloc(nbOfTuples*(nbOfComp1+nbOfComp2)*sizeof(int));
7654 const int *inp1=getConstPointer();
7655 const int *inp2=other->getConstPointer();
7656 for(int i=0;i<nbOfTuples;i++,inp1+=nbOfComp1,inp2+=nbOfComp2)
7658 w=std::copy(inp1,inp1+nbOfComp1,w);
7659 w=std::copy(inp2,inp2+nbOfComp2,w);
7661 useArray(newArr,true,C_DEALLOC,nbOfTuples,nbOfComp1+nbOfComp2);
7662 std::vector<int> compIds(nbOfComp2);
7663 for(int i=0;i<nbOfComp2;i++)
7664 compIds[i]=nbOfComp1+i;
7665 copyPartOfStringInfoFrom2(compIds,*other);
7669 * Copy all components in a specified order from another DataArrayInt.
7670 * The specified components become the first ones in \a this array.
7671 * Both numerical and textual data is copied. The number of tuples in \a this and
7672 * the other array can be different.
7673 * \param [in] a - the array to copy data from.
7674 * \param [in] compoIds - sequence of zero based indices of components, data of which is
7676 * \throw If \a a is NULL.
7677 * \throw If \a compoIds.size() != \a a->getNumberOfComponents().
7678 * \throw If \a compoIds[i] < 0 or \a compoIds[i] > \a this->getNumberOfComponents().
7680 * \ref py_mcdataarrayint_setselectedcomponents "Here is a Python example".
7682 void DataArrayInt::setSelectedComponents(const DataArrayInt *a, const std::vector<int>& compoIds)
7685 throw INTERP_KERNEL::Exception("DataArrayInt::setSelectedComponents : input DataArrayInt is NULL !");
7687 a->checkAllocated();
7688 copyPartOfStringInfoFrom2(compoIds,*a);
7689 std::size_t partOfCompoSz=compoIds.size();
7690 int nbOfCompo=getNumberOfComponents();
7691 int nbOfTuples=std::min(getNumberOfTuples(),a->getNumberOfTuples());
7692 const int *ac=a->getConstPointer();
7693 int *nc=getPointer();
7694 for(int i=0;i<nbOfTuples;i++)
7695 for(std::size_t j=0;j<partOfCompoSz;j++,ac++)
7696 nc[nbOfCompo*i+compoIds[j]]=*ac;
7700 * Copy all values from another DataArrayInt into specified tuples and components
7701 * of \a this array. Textual data is not copied.
7702 * The tree parameters defining set of indices of tuples and components are similar to
7703 * the tree parameters of the Python function \c range(\c start,\c stop,\c step).
7704 * \param [in] a - the array to copy values from.
7705 * \param [in] bgTuples - index of the first tuple of \a this array to assign values to.
7706 * \param [in] endTuples - index of the tuple before which the tuples to assign to
7708 * \param [in] stepTuples - index increment to get index of the next tuple to assign to.
7709 * \param [in] bgComp - index of the first component of \a this array to assign values to.
7710 * \param [in] endComp - index of the component before which the components to assign
7712 * \param [in] stepComp - index increment to get index of the next component to assign to.
7713 * \param [in] strictCompoCompare - if \a true (by default), then \a a->getNumberOfComponents()
7714 * must be equal to the number of columns to assign to, else an
7715 * exception is thrown; if \a false, then it is only required that \a
7716 * a->getNbOfElems() equals to number of values to assign to (this condition
7717 * must be respected even if \a strictCompoCompare is \a true). The number of
7718 * values to assign to is given by following Python expression:
7719 * \a nbTargetValues =
7720 * \c len(\c range(\a bgTuples,\a endTuples,\a stepTuples)) *
7721 * \c len(\c range(\a bgComp,\a endComp,\a stepComp)).
7722 * \throw If \a a is NULL.
7723 * \throw If \a a is not allocated.
7724 * \throw If \a this is not allocated.
7725 * \throw If parameters specifying tuples and components to assign to do not give a
7726 * non-empty range of increasing indices.
7727 * \throw If \a a->getNbOfElems() != \a nbTargetValues.
7728 * \throw If \a strictCompoCompare == \a true && \a a->getNumberOfComponents() !=
7729 * \c len(\c range(\a bgComp,\a endComp,\a stepComp)).
7731 * \ref py_mcdataarrayint_setpartofvalues1 "Here is a Python example".
7733 void DataArrayInt::setPartOfValues1(const DataArrayInt *a, int bgTuples, int endTuples, int stepTuples, int bgComp, int endComp, int stepComp, bool strictCompoCompare)
7736 throw INTERP_KERNEL::Exception("DataArrayInt::setPartOfValues1 : DataArrayInt pointer in input is NULL !");
7737 const char msg[]="DataArrayInt::setPartOfValues1";
7739 a->checkAllocated();
7740 int newNbOfTuples=DataArray::GetNumberOfItemGivenBES(bgTuples,endTuples,stepTuples,msg);
7741 int newNbOfComp=DataArray::GetNumberOfItemGivenBES(bgComp,endComp,stepComp,msg);
7742 int nbComp=getNumberOfComponents();
7743 int nbOfTuples=getNumberOfTuples();
7744 DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
7745 DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
7746 bool assignTech=true;
7747 if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
7749 if(strictCompoCompare)
7750 a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
7754 a->checkNbOfTuplesAndComp(1,newNbOfComp,msg);
7757 int *pt=getPointer()+bgTuples*nbComp+bgComp;
7758 const int *srcPt=a->getConstPointer();
7761 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
7762 for(int j=0;j<newNbOfComp;j++,srcPt++)
7763 pt[j*stepComp]=*srcPt;
7767 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
7769 const int *srcPt2=srcPt;
7770 for(int j=0;j<newNbOfComp;j++,srcPt2++)
7771 pt[j*stepComp]=*srcPt2;
7777 * Assign a given value to values at specified tuples and components of \a this array.
7778 * The tree parameters defining set of indices of tuples and components are similar to
7779 * the tree parameters of the Python function \c range(\c start,\c stop,\c step)..
7780 * \param [in] a - the value to assign.
7781 * \param [in] bgTuples - index of the first tuple of \a this array to assign to.
7782 * \param [in] endTuples - index of the tuple before which the tuples to assign to
7784 * \param [in] stepTuples - index increment to get index of the next tuple to assign to.
7785 * \param [in] bgComp - index of the first component of \a this array to assign to.
7786 * \param [in] endComp - index of the component before which the components to assign
7788 * \param [in] stepComp - index increment to get index of the next component to assign to.
7789 * \throw If \a this is not allocated.
7790 * \throw If parameters specifying tuples and components to assign to, do not give a
7791 * non-empty range of increasing indices or indices are out of a valid range
7794 * \ref py_mcdataarrayint_setpartofvaluessimple1 "Here is a Python example".
7796 void DataArrayInt::setPartOfValuesSimple1(int a, int bgTuples, int endTuples, int stepTuples, int bgComp, int endComp, int stepComp)
7798 const char msg[]="DataArrayInt::setPartOfValuesSimple1";
7800 int newNbOfTuples=DataArray::GetNumberOfItemGivenBES(bgTuples,endTuples,stepTuples,msg);
7801 int newNbOfComp=DataArray::GetNumberOfItemGivenBES(bgComp,endComp,stepComp,msg);
7802 int nbComp=getNumberOfComponents();
7803 int nbOfTuples=getNumberOfTuples();
7804 DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
7805 DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
7806 int *pt=getPointer()+bgTuples*nbComp+bgComp;
7807 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
7808 for(int j=0;j<newNbOfComp;j++)
7814 * Copy all values from another DataArrayInt (\a a) into specified tuples and
7815 * components of \a this array. Textual data is not copied.
7816 * The tuples and components to assign to are defined by C arrays of indices.
7817 * There are two *modes of usage*:
7818 * - If \a a->getNbOfElems() equals to number of values to assign to, then every value
7819 * of \a a is assigned to its own location within \a this array.
7820 * - If \a a includes one tuple, then all values of \a a are assigned to the specified
7821 * components of every specified tuple of \a this array. In this mode it is required
7822 * that \a a->getNumberOfComponents() equals to the number of specified components.
7824 * \param [in] a - the array to copy values from.
7825 * \param [in] bgTuples - pointer to an array of tuple indices of \a this array to
7826 * assign values of \a a to.
7827 * \param [in] endTuples - specifies the end of the array \a bgTuples, so that
7828 * pointer to a tuple index <em>(pi)</em> varies as this:
7829 * \a bgTuples <= \a pi < \a endTuples.
7830 * \param [in] bgComp - pointer to an array of component indices of \a this array to
7831 * assign values of \a a to.
7832 * \param [in] endComp - specifies the end of the array \a bgTuples, so that
7833 * pointer to a component index <em>(pi)</em> varies as this:
7834 * \a bgComp <= \a pi < \a endComp.
7835 * \param [in] strictCompoCompare - this parameter is checked only if the
7836 * *mode of usage* is the first; if it is \a true (default),
7837 * then \a a->getNumberOfComponents() must be equal
7838 * to the number of specified columns, else this is not required.
7839 * \throw If \a a is NULL.
7840 * \throw If \a a is not allocated.
7841 * \throw If \a this is not allocated.
7842 * \throw If any index of tuple/component given by <em>bgTuples / bgComp</em> is
7843 * out of a valid range for \a this array.
7844 * \throw In the first *mode of usage*, if <em>strictCompoCompare == true </em> and
7845 * if <em> a->getNumberOfComponents() != (endComp - bgComp) </em>.
7846 * \throw In the second *mode of usage*, if \a a->getNumberOfTuples() != 1 or
7847 * <em> a->getNumberOfComponents() != (endComp - bgComp)</em>.
7849 * \ref py_mcdataarrayint_setpartofvalues2 "Here is a Python example".
7851 void DataArrayInt::setPartOfValues2(const DataArrayInt *a, const int *bgTuples, const int *endTuples, const int *bgComp, const int *endComp, bool strictCompoCompare)
7854 throw INTERP_KERNEL::Exception("DataArrayInt::setPartOfValues2 : DataArrayInt pointer in input is NULL !");
7855 const char msg[]="DataArrayInt::setPartOfValues2";
7857 a->checkAllocated();
7858 int nbComp=getNumberOfComponents();
7859 int nbOfTuples=getNumberOfTuples();
7860 for(const int *z=bgComp;z!=endComp;z++)
7861 DataArray::CheckValueInRange(nbComp,*z,"invalid component id");
7862 int newNbOfTuples=(int)std::distance(bgTuples,endTuples);
7863 int newNbOfComp=(int)std::distance(bgComp,endComp);
7864 bool assignTech=true;
7865 if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
7867 if(strictCompoCompare)
7868 a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
7872 a->checkNbOfTuplesAndComp(1,newNbOfComp,msg);
7875 int *pt=getPointer();
7876 const int *srcPt=a->getConstPointer();
7879 for(const int *w=bgTuples;w!=endTuples;w++)
7881 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
7882 for(const int *z=bgComp;z!=endComp;z++,srcPt++)
7884 pt[(std::size_t)(*w)*nbComp+(*z)]=*srcPt;
7890 for(const int *w=bgTuples;w!=endTuples;w++)
7892 const int *srcPt2=srcPt;
7893 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
7894 for(const int *z=bgComp;z!=endComp;z++,srcPt2++)
7896 pt[(std::size_t)(*w)*nbComp+(*z)]=*srcPt2;
7903 * Assign a given value to values at specified tuples and components of \a this array.
7904 * The tuples and components to assign to are defined by C arrays of indices.
7905 * \param [in] a - the value to assign.
7906 * \param [in] bgTuples - pointer to an array of tuple indices of \a this array to
7908 * \param [in] endTuples - specifies the end of the array \a bgTuples, so that
7909 * pointer to a tuple index (\a pi) varies as this:
7910 * \a bgTuples <= \a pi < \a endTuples.
7911 * \param [in] bgComp - pointer to an array of component indices of \a this array to
7913 * \param [in] endComp - specifies the end of the array \a bgTuples, so that
7914 * pointer to a component index (\a pi) varies as this:
7915 * \a bgComp <= \a pi < \a endComp.
7916 * \throw If \a this is not allocated.
7917 * \throw If any index of tuple/component given by <em>bgTuples / bgComp</em> is
7918 * out of a valid range for \a this array.
7920 * \ref py_mcdataarrayint_setpartofvaluessimple2 "Here is a Python example".
7922 void DataArrayInt::setPartOfValuesSimple2(int a, const int *bgTuples, const int *endTuples, const int *bgComp, const int *endComp)
7925 int nbComp=getNumberOfComponents();
7926 int nbOfTuples=getNumberOfTuples();
7927 for(const int *z=bgComp;z!=endComp;z++)
7928 DataArray::CheckValueInRange(nbComp,*z,"invalid component id");
7929 int *pt=getPointer();
7930 for(const int *w=bgTuples;w!=endTuples;w++)
7931 for(const int *z=bgComp;z!=endComp;z++)
7933 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
7934 pt[(std::size_t)(*w)*nbComp+(*z)]=a;
7939 * Copy all values from another DataArrayInt (\a a) into specified tuples and
7940 * components of \a this array. Textual data is not copied.
7941 * The tuples to assign to are defined by a C array of indices.
7942 * The components to assign to are defined by three values similar to parameters of
7943 * the Python function \c range(\c start,\c stop,\c step).
7944 * There are two *modes of usage*:
7945 * - If \a a->getNbOfElems() equals to number of values to assign to, then every value
7946 * of \a a is assigned to its own location within \a this array.
7947 * - If \a a includes one tuple, then all values of \a a are assigned to the specified
7948 * components of every specified tuple of \a this array. In this mode it is required
7949 * that \a a->getNumberOfComponents() equals to the number of specified components.
7951 * \param [in] a - the array to copy values from.
7952 * \param [in] bgTuples - pointer to an array of tuple indices of \a this array to
7953 * assign values of \a a to.
7954 * \param [in] endTuples - specifies the end of the array \a bgTuples, so that
7955 * pointer to a tuple index <em>(pi)</em> varies as this:
7956 * \a bgTuples <= \a pi < \a endTuples.
7957 * \param [in] bgComp - index of the first component of \a this array to assign to.
7958 * \param [in] endComp - index of the component before which the components to assign
7960 * \param [in] stepComp - index increment to get index of the next component to assign to.
7961 * \param [in] strictCompoCompare - this parameter is checked only in the first
7962 * *mode of usage*; if \a strictCompoCompare is \a true (default),
7963 * then \a a->getNumberOfComponents() must be equal
7964 * to the number of specified columns, else this is not required.
7965 * \throw If \a a is NULL.
7966 * \throw If \a a is not allocated.
7967 * \throw If \a this is not allocated.
7968 * \throw If any index of tuple given by \a bgTuples is out of a valid range for
7970 * \throw In the first *mode of usage*, if <em>strictCompoCompare == true </em> and
7971 * if <em> a->getNumberOfComponents()</em> is unequal to the number of components
7972 * defined by <em>(bgComp,endComp,stepComp)</em>.
7973 * \throw In the second *mode of usage*, if \a a->getNumberOfTuples() != 1 or
7974 * <em> a->getNumberOfComponents()</em> is unequal to the number of components
7975 * defined by <em>(bgComp,endComp,stepComp)</em>.
7976 * \throw If parameters specifying components to assign to, do not give a
7977 * non-empty range of increasing indices or indices are out of a valid range
7980 * \ref py_mcdataarrayint_setpartofvalues3 "Here is a Python example".
7982 void DataArrayInt::setPartOfValues3(const DataArrayInt *a, const int *bgTuples, const int *endTuples, int bgComp, int endComp, int stepComp, bool strictCompoCompare)
7985 throw INTERP_KERNEL::Exception("DataArrayInt::setPartOfValues3 : DataArrayInt pointer in input is NULL !");
7986 const char msg[]="DataArrayInt::setPartOfValues3";
7988 a->checkAllocated();
7989 int newNbOfComp=DataArray::GetNumberOfItemGivenBES(bgComp,endComp,stepComp,msg);
7990 int nbComp=getNumberOfComponents();
7991 int nbOfTuples=getNumberOfTuples();
7992 DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
7993 int newNbOfTuples=(int)std::distance(bgTuples,endTuples);
7994 bool assignTech=true;
7995 if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
7997 if(strictCompoCompare)
7998 a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
8002 a->checkNbOfTuplesAndComp(1,newNbOfComp,msg);
8005 int *pt=getPointer()+bgComp;
8006 const int *srcPt=a->getConstPointer();
8009 for(const int *w=bgTuples;w!=endTuples;w++)
8010 for(int j=0;j<newNbOfComp;j++,srcPt++)
8012 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
8013 pt[(std::size_t)(*w)*nbComp+j*stepComp]=*srcPt;
8018 for(const int *w=bgTuples;w!=endTuples;w++)
8020 const int *srcPt2=srcPt;
8021 for(int j=0;j<newNbOfComp;j++,srcPt2++)
8023 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
8024 pt[(std::size_t)(*w)*nbComp+j*stepComp]=*srcPt2;
8031 * Assign a given value to values at specified tuples and components of \a this array.
8032 * The tuples to assign to are defined by a C array of indices.
8033 * The components to assign to are defined by three values similar to parameters of
8034 * the Python function \c range(\c start,\c stop,\c step).
8035 * \param [in] a - the value to assign.
8036 * \param [in] bgTuples - pointer to an array of tuple indices of \a this array to
8038 * \param [in] endTuples - specifies the end of the array \a bgTuples, so that
8039 * pointer to a tuple index <em>(pi)</em> varies as this:
8040 * \a bgTuples <= \a pi < \a endTuples.
8041 * \param [in] bgComp - index of the first component of \a this array to assign to.
8042 * \param [in] endComp - index of the component before which the components to assign
8044 * \param [in] stepComp - index increment to get index of the next component to assign to.
8045 * \throw If \a this is not allocated.
8046 * \throw If any index of tuple given by \a bgTuples is out of a valid range for
8048 * \throw If parameters specifying components to assign to, do not give a
8049 * non-empty range of increasing indices or indices are out of a valid range
8052 * \ref py_mcdataarrayint_setpartofvaluessimple3 "Here is a Python example".
8054 void DataArrayInt::setPartOfValuesSimple3(int a, const int *bgTuples, const int *endTuples, int bgComp, int endComp, int stepComp)
8056 const char msg[]="DataArrayInt::setPartOfValuesSimple3";
8058 int newNbOfComp=DataArray::GetNumberOfItemGivenBES(bgComp,endComp,stepComp,msg);
8059 int nbComp=getNumberOfComponents();
8060 int nbOfTuples=getNumberOfTuples();
8061 DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
8062 int *pt=getPointer()+bgComp;
8063 for(const int *w=bgTuples;w!=endTuples;w++)
8064 for(int j=0;j<newNbOfComp;j++)
8066 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
8067 pt[(std::size_t)(*w)*nbComp+j*stepComp]=a;
8071 void DataArrayInt::setPartOfValues4(const DataArrayInt *a, int bgTuples, int endTuples, int stepTuples, const int *bgComp, const int *endComp, bool strictCompoCompare)
8074 throw INTERP_KERNEL::Exception("DataArrayInt::setPartOfValues4 : input DataArrayInt is NULL !");
8075 const char msg[]="DataArrayInt::setPartOfValues4";
8077 a->checkAllocated();
8078 int newNbOfTuples=DataArray::GetNumberOfItemGivenBES(bgTuples,endTuples,stepTuples,msg);
8079 int newNbOfComp=(int)std::distance(bgComp,endComp);
8080 int nbComp=getNumberOfComponents();
8081 for(const int *z=bgComp;z!=endComp;z++)
8082 DataArray::CheckValueInRange(nbComp,*z,"invalid component id");
8083 int nbOfTuples=getNumberOfTuples();
8084 DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
8085 bool assignTech=true;
8086 if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
8088 if(strictCompoCompare)
8089 a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
8093 a->checkNbOfTuplesAndComp(1,newNbOfComp,msg);
8096 const int *srcPt=a->getConstPointer();
8097 int *pt=getPointer()+bgTuples*nbComp;
8100 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
8101 for(const int *z=bgComp;z!=endComp;z++,srcPt++)
8106 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
8108 const int *srcPt2=srcPt;
8109 for(const int *z=bgComp;z!=endComp;z++,srcPt2++)
8115 void DataArrayInt::setPartOfValuesSimple4(int a, int bgTuples, int endTuples, int stepTuples, const int *bgComp, const int *endComp)
8117 const char msg[]="DataArrayInt::setPartOfValuesSimple4";
8119 int newNbOfTuples=DataArray::GetNumberOfItemGivenBES(bgTuples,endTuples,stepTuples,msg);
8120 int nbComp=getNumberOfComponents();
8121 for(const int *z=bgComp;z!=endComp;z++)
8122 DataArray::CheckValueInRange(nbComp,*z,"invalid component id");
8123 int nbOfTuples=getNumberOfTuples();
8124 DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
8125 int *pt=getPointer()+bgTuples*nbComp;
8126 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
8127 for(const int *z=bgComp;z!=endComp;z++)
8132 * Copy some tuples from another DataArrayInt into specified tuples
8133 * of \a this array. Textual data is not copied. Both arrays must have equal number of
8135 * Both the tuples to assign and the tuples to assign to are defined by a DataArrayInt.
8136 * All components of selected tuples are copied.
8137 * \param [in] a - the array to copy values from.
8138 * \param [in] tuplesSelec - the array specifying both source tuples of \a a and
8139 * target tuples of \a this. \a tuplesSelec has two components, and the
8140 * first component specifies index of the source tuple and the second
8141 * one specifies index of the target tuple.
8142 * \throw If \a this is not allocated.
8143 * \throw If \a a is NULL.
8144 * \throw If \a a is not allocated.
8145 * \throw If \a tuplesSelec is NULL.
8146 * \throw If \a tuplesSelec is not allocated.
8147 * \throw If <em>this->getNumberOfComponents() != a->getNumberOfComponents()</em>.
8148 * \throw If \a tuplesSelec->getNumberOfComponents() != 2.
8149 * \throw If any tuple index given by \a tuplesSelec is out of a valid range for
8150 * the corresponding (\a this or \a a) array.
8152 void DataArrayInt::setPartOfValuesAdv(const DataArrayInt *a, const DataArrayInt *tuplesSelec)
8154 if(!a || !tuplesSelec)
8155 throw INTERP_KERNEL::Exception("DataArrayInt::setPartOfValuesAdv : DataArrayInt pointer in input is NULL !");
8157 a->checkAllocated();
8158 tuplesSelec->checkAllocated();
8159 int nbOfComp=getNumberOfComponents();
8160 if(nbOfComp!=a->getNumberOfComponents())
8161 throw INTERP_KERNEL::Exception("DataArrayInt::setPartOfValuesAdv : This and a do not have the same number of components !");
8162 if(tuplesSelec->getNumberOfComponents()!=2)
8163 throw INTERP_KERNEL::Exception("DataArrayInt::setPartOfValuesAdv : Expecting to have a tuple selector DataArrayInt instance with exactly 2 components !");
8164 int thisNt=getNumberOfTuples();
8165 int aNt=a->getNumberOfTuples();
8166 int *valsToSet=getPointer();
8167 const int *valsSrc=a->getConstPointer();
8168 for(const int *tuple=tuplesSelec->begin();tuple!=tuplesSelec->end();tuple+=2)
8170 if(tuple[1]>=0 && tuple[1]<aNt)
8172 if(tuple[0]>=0 && tuple[0]<thisNt)
8173 std::copy(valsSrc+nbOfComp*tuple[1],valsSrc+nbOfComp*(tuple[1]+1),valsToSet+nbOfComp*tuple[0]);
8176 std::ostringstream oss; oss << "DataArrayInt::setPartOfValuesAdv : Tuple #" << std::distance(tuplesSelec->begin(),tuple)/2;
8177 oss << " of 'tuplesSelec' request of tuple id #" << tuple[0] << " in 'this' ! It should be in [0," << thisNt << ") !";
8178 throw INTERP_KERNEL::Exception(oss.str().c_str());
8183 std::ostringstream oss; oss << "DataArrayInt::setPartOfValuesAdv : Tuple #" << std::distance(tuplesSelec->begin(),tuple)/2;
8184 oss << " of 'tuplesSelec' request of tuple id #" << tuple[1] << " in 'a' ! It should be in [0," << aNt << ") !";
8185 throw INTERP_KERNEL::Exception(oss.str().c_str());
8191 * Copy some tuples from another DataArrayInt (\a aBase) into contiguous tuples
8192 * of \a this array. Textual data is not copied. Both arrays must have equal number of
8194 * The tuples to assign to are defined by index of the first tuple, and
8195 * their number is defined by \a tuplesSelec->getNumberOfTuples().
8196 * The tuples to copy are defined by values of a DataArrayInt.
8197 * All components of selected tuples are copied.
8198 * \param [in] tupleIdStart - index of the first tuple of \a this array to assign
8200 * \param [in] aBase - the array to copy values from.
8201 * \param [in] tuplesSelec - the array specifying tuples of \a aBase to copy.
8202 * \throw If \a this is not allocated.
8203 * \throw If \a aBase is NULL.
8204 * \throw If \a aBase is not allocated.
8205 * \throw If \a tuplesSelec is NULL.
8206 * \throw If \a tuplesSelec is not allocated.
8207 * \throw If <em>this->getNumberOfComponents() != a->getNumberOfComponents()</em>.
8208 * \throw If \a tuplesSelec->getNumberOfComponents() != 1.
8209 * \throw If <em>tupleIdStart + tuplesSelec->getNumberOfTuples() > this->getNumberOfTuples().</em>
8210 * \throw If any tuple index given by \a tuplesSelec is out of a valid range for
8213 void DataArrayInt::setContigPartOfSelectedValues(int tupleIdStart, const DataArray *aBase, const DataArrayInt *tuplesSelec)
8215 if(!aBase || !tuplesSelec)
8216 throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues : input DataArray is NULL !");
8217 const DataArrayInt *a=dynamic_cast<const DataArrayInt *>(aBase);
8219 throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues : input DataArray aBase is not a DataArrayInt !");
8221 a->checkAllocated();
8222 tuplesSelec->checkAllocated();
8223 int nbOfComp=getNumberOfComponents();
8224 if(nbOfComp!=a->getNumberOfComponents())
8225 throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues : This and a do not have the same number of components !");
8226 if(tuplesSelec->getNumberOfComponents()!=1)
8227 throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues : Expecting to have a tuple selector DataArrayInt instance with exactly 1 component !");
8228 int thisNt=getNumberOfTuples();
8229 int aNt=a->getNumberOfTuples();
8230 int nbOfTupleToWrite=tuplesSelec->getNumberOfTuples();
8231 int *valsToSet=getPointer()+tupleIdStart*nbOfComp;
8232 if(tupleIdStart+nbOfTupleToWrite>thisNt)
8233 throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues : invalid number range of values to write !");
8234 const int *valsSrc=a->getConstPointer();
8235 for(const int *tuple=tuplesSelec->begin();tuple!=tuplesSelec->end();tuple++,valsToSet+=nbOfComp)
8237 if(*tuple>=0 && *tuple<aNt)
8239 std::copy(valsSrc+nbOfComp*(*tuple),valsSrc+nbOfComp*(*tuple+1),valsToSet);
8243 std::ostringstream oss; oss << "DataArrayInt::setContigPartOfSelectedValues : Tuple #" << std::distance(tuplesSelec->begin(),tuple);
8244 oss << " of 'tuplesSelec' request of tuple id #" << *tuple << " in 'a' ! It should be in [0," << aNt << ") !";
8245 throw INTERP_KERNEL::Exception(oss.str().c_str());
8251 * Copy some tuples from another DataArrayInt (\a aBase) into contiguous tuples
8252 * of \a this array. Textual data is not copied. Both arrays must have equal number of
8254 * The tuples to copy are defined by three values similar to parameters of
8255 * the Python function \c range(\c start,\c stop,\c step).
8256 * The tuples to assign to are defined by index of the first tuple, and
8257 * their number is defined by number of tuples to copy.
8258 * All components of selected tuples are copied.
8259 * \param [in] tupleIdStart - index of the first tuple of \a this array to assign
8261 * \param [in] aBase - the array to copy values from.
8262 * \param [in] bg - index of the first tuple to copy of the array \a aBase.
8263 * \param [in] end2 - index of the tuple of \a aBase before which the tuples to copy
8265 * \param [in] step - index increment to get index of the next tuple to copy.
8266 * \throw If \a this is not allocated.
8267 * \throw If \a aBase is NULL.
8268 * \throw If \a aBase is not allocated.
8269 * \throw If <em>this->getNumberOfComponents() != aBase->getNumberOfComponents()</em>.
8270 * \throw If <em>tupleIdStart + len(range(bg,end2,step)) > this->getNumberOfTuples().</em>
8271 * \throw If parameters specifying tuples to copy, do not give a
8272 * non-empty range of increasing indices or indices are out of a valid range
8273 * for the array \a aBase.
8275 void DataArrayInt::setContigPartOfSelectedValues2(int tupleIdStart, const DataArray *aBase, int bg, int end2, int step)
8278 throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues2 : input DataArray is NULL !");
8279 const DataArrayInt *a=dynamic_cast<const DataArrayInt *>(aBase);
8281 throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues2 : input DataArray aBase is not a DataArrayInt !");
8283 a->checkAllocated();
8284 int nbOfComp=getNumberOfComponents();
8285 const char msg[]="DataArrayInt::setContigPartOfSelectedValues2";
8286 int nbOfTupleToWrite=DataArray::GetNumberOfItemGivenBES(bg,end2,step,msg);
8287 if(nbOfComp!=a->getNumberOfComponents())
8288 throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues2 : This and a do not have the same number of components !");
8289 int thisNt=getNumberOfTuples();
8290 int aNt=a->getNumberOfTuples();
8291 int *valsToSet=getPointer()+tupleIdStart*nbOfComp;
8292 if(tupleIdStart+nbOfTupleToWrite>thisNt)
8293 throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues2 : invalid number range of values to write !");
8295 throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues2 : invalid range of values to read !");
8296 const int *valsSrc=a->getConstPointer()+bg*nbOfComp;
8297 for(int i=0;i<nbOfTupleToWrite;i++,valsToSet+=nbOfComp,valsSrc+=step*nbOfComp)
8299 std::copy(valsSrc,valsSrc+nbOfComp,valsToSet);
8304 * Returns a value located at specified tuple and component.
8305 * This method is equivalent to DataArrayInt::getIJ() except that validity of
8306 * parameters is checked. So this method is safe but expensive if used to go through
8307 * all values of \a this.
8308 * \param [in] tupleId - index of tuple of interest.
8309 * \param [in] compoId - index of component of interest.
8310 * \return double - value located by \a tupleId and \a compoId.
8311 * \throw If \a this is not allocated.
8312 * \throw If condition <em>( 0 <= tupleId < this->getNumberOfTuples() )</em> is violated.
8313 * \throw If condition <em>( 0 <= compoId < this->getNumberOfComponents() )</em> is violated.
8315 int DataArrayInt::getIJSafe(int tupleId, int compoId) const
8318 if(tupleId<0 || tupleId>=getNumberOfTuples())
8320 std::ostringstream oss; oss << "DataArrayInt::getIJSafe : request for tupleId " << tupleId << " should be in [0," << getNumberOfTuples() << ") !";
8321 throw INTERP_KERNEL::Exception(oss.str().c_str());
8323 if(compoId<0 || compoId>=getNumberOfComponents())
8325 std::ostringstream oss; oss << "DataArrayInt::getIJSafe : request for compoId " << compoId << " should be in [0," << getNumberOfComponents() << ") !";
8326 throw INTERP_KERNEL::Exception(oss.str().c_str());
8328 return _mem[tupleId*_info_on_compo.size()+compoId];
8332 * Returns the first value of \a this.
8333 * \return int - the last value of \a this array.
8334 * \throw If \a this is not allocated.
8335 * \throw If \a this->getNumberOfComponents() != 1.
8336 * \throw If \a this->getNumberOfTuples() < 1.
8338 int DataArrayInt::front() const
8341 if(getNumberOfComponents()!=1)
8342 throw INTERP_KERNEL::Exception("DataArrayInt::front : number of components not equal to one !");
8343 int nbOfTuples=getNumberOfTuples();
8345 throw INTERP_KERNEL::Exception("DataArrayInt::front : number of tuples must be >= 1 !");
8346 return *(getConstPointer());
8350 * Returns the last value of \a this.
8351 * \return int - the last value of \a this array.
8352 * \throw If \a this is not allocated.
8353 * \throw If \a this->getNumberOfComponents() != 1.
8354 * \throw If \a this->getNumberOfTuples() < 1.
8356 int DataArrayInt::back() const
8359 if(getNumberOfComponents()!=1)
8360 throw INTERP_KERNEL::Exception("DataArrayInt::back : number of components not equal to one !");
8361 int nbOfTuples=getNumberOfTuples();
8363 throw INTERP_KERNEL::Exception("DataArrayInt::back : number of tuples must be >= 1 !");
8364 return *(getConstPointer()+nbOfTuples-1);
8368 * Assign pointer to one array to a pointer to another appay. Reference counter of
8369 * \a arrayToSet is incremented / decremented.
8370 * \param [in] newArray - the pointer to array to assign to \a arrayToSet.
8371 * \param [in,out] arrayToSet - the pointer to array to assign to.
8373 void DataArrayInt::SetArrayIn(DataArrayInt *newArray, DataArrayInt* &arrayToSet)
8375 if(newArray!=arrayToSet)
8378 arrayToSet->decrRef();
8379 arrayToSet=newArray;
8381 arrayToSet->incrRef();
8385 DataArrayIntIterator *DataArrayInt::iterator()
8387 return new DataArrayIntIterator(this);
8391 * Creates a new DataArrayInt containing IDs (indices) of tuples holding value equal to a
8393 * \param [in] val - the value to find within \a this.
8394 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
8395 * array using decrRef() as it is no more needed.
8396 * \throw If \a this is not allocated.
8397 * \throw If \a this->getNumberOfComponents() != 1.
8398 * \sa DataArrayInt::getIdsEqualTuple
8400 DataArrayInt *DataArrayInt::getIdsEqual(int val) const
8403 if(getNumberOfComponents()!=1)
8404 throw INTERP_KERNEL::Exception("DataArrayInt::getIdsEqual : the array must have only one component, you can call 'rearrange' method before !");
8405 const int *cptr(getConstPointer());
8406 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
8407 int nbOfTuples=getNumberOfTuples();
8408 for(int i=0;i<nbOfTuples;i++,cptr++)
8410 ret->pushBackSilent(i);
8415 * Creates a new DataArrayInt containing IDs (indices) of tuples holding value \b not
8416 * equal to a given one.
8417 * \param [in] val - the value to ignore within \a this.
8418 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
8419 * array using decrRef() as it is no more needed.
8420 * \throw If \a this is not allocated.
8421 * \throw If \a this->getNumberOfComponents() != 1.
8423 DataArrayInt *DataArrayInt::getIdsNotEqual(int val) const
8426 if(getNumberOfComponents()!=1)
8427 throw INTERP_KERNEL::Exception("DataArrayInt::getIdsNotEqual : the array must have only one component, you can call 'rearrange' method before !");
8428 const int *cptr(getConstPointer());
8429 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
8430 int nbOfTuples=getNumberOfTuples();
8431 for(int i=0;i<nbOfTuples;i++,cptr++)
8433 ret->pushBackSilent(i);
8438 * Creates a new DataArrayInt containing IDs (indices) of tuples holding tuple equal to those defined by [ \a tupleBg , \a tupleEnd )
8439 * This method is an extension of DataArrayInt::getIdsEqual method.
8441 * \param [in] tupleBg - the begin (included) of the input tuple to find within \a this.
8442 * \param [in] tupleEnd - the end (excluded) of the input tuple to find within \a this.
8443 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
8444 * array using decrRef() as it is no more needed.
8445 * \throw If \a this is not allocated.
8446 * \throw If \a this->getNumberOfComponents() != std::distance(tupleBg,tupleEnd).
8447 * \throw If \a this->getNumberOfComponents() is equal to 0.
8448 * \sa DataArrayInt::getIdsEqual
8450 DataArrayInt *DataArrayInt::getIdsEqualTuple(const int *tupleBg, const int *tupleEnd) const
8452 std::size_t nbOfCompoExp(std::distance(tupleBg,tupleEnd));
8454 if(getNumberOfComponents()!=(int)nbOfCompoExp)
8456 std::ostringstream oss; oss << "DataArrayInt::getIdsEqualTuple : mismatch of number of components. Input tuple has " << nbOfCompoExp << " whereas this array has " << getNumberOfComponents() << " components !";
8457 throw INTERP_KERNEL::Exception(oss.str().c_str());
8460 throw INTERP_KERNEL::Exception("DataArrayInt::getIdsEqualTuple : number of components should be > 0 !");
8461 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
8462 const int *bg(begin()),*end2(end()),*work(begin());
8465 work=std::search(work,end2,tupleBg,tupleEnd);
8468 std::size_t pos(std::distance(bg,work));
8469 if(pos%nbOfCompoExp==0)
8470 ret->pushBackSilent(pos/nbOfCompoExp);
8478 * Assigns \a newValue to all elements holding \a oldValue within \a this
8479 * one-dimensional array.
8480 * \param [in] oldValue - the value to replace.
8481 * \param [in] newValue - the value to assign.
8482 * \return int - number of replacements performed.
8483 * \throw If \a this is not allocated.
8484 * \throw If \a this->getNumberOfComponents() != 1.
8486 int DataArrayInt::changeValue(int oldValue, int newValue)
8489 if(getNumberOfComponents()!=1)
8490 throw INTERP_KERNEL::Exception("DataArrayInt::changeValue : the array must have only one component, you can call 'rearrange' method before !");
8491 int *start=getPointer();
8492 int *end2=start+getNbOfElems();
8494 for(int *val=start;val!=end2;val++)
8506 * Creates a new DataArrayInt containing IDs (indices) of tuples holding value equal to
8507 * one of given values.
8508 * \param [in] valsBg - an array of values to find within \a this array.
8509 * \param [in] valsEnd - specifies the end of the array \a valsBg, so that
8510 * the last value of \a valsBg is \a valsEnd[ -1 ].
8511 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
8512 * array using decrRef() as it is no more needed.
8513 * \throw If \a this->getNumberOfComponents() != 1.
8515 DataArrayInt *DataArrayInt::getIdsEqualList(const int *valsBg, const int *valsEnd) const
8517 if(getNumberOfComponents()!=1)
8518 throw INTERP_KERNEL::Exception("DataArrayInt::getIdsEqualList : the array must have only one component, you can call 'rearrange' method before !");
8519 std::set<int> vals2(valsBg,valsEnd);
8520 const int *cptr=getConstPointer();
8521 std::vector<int> res;
8522 int nbOfTuples=getNumberOfTuples();
8523 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
8524 for(int i=0;i<nbOfTuples;i++,cptr++)
8525 if(vals2.find(*cptr)!=vals2.end())
8526 ret->pushBackSilent(i);
8531 * Creates a new DataArrayInt containing IDs (indices) of tuples holding values \b not
8532 * equal to any of given values.
8533 * \param [in] valsBg - an array of values to ignore within \a this array.
8534 * \param [in] valsEnd - specifies the end of the array \a valsBg, so that
8535 * the last value of \a valsBg is \a valsEnd[ -1 ].
8536 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
8537 * array using decrRef() as it is no more needed.
8538 * \throw If \a this->getNumberOfComponents() != 1.
8540 DataArrayInt *DataArrayInt::getIdsNotEqualList(const int *valsBg, const int *valsEnd) const
8542 if(getNumberOfComponents()!=1)
8543 throw INTERP_KERNEL::Exception("DataArrayInt::getIdsNotEqualList : the array must have only one component, you can call 'rearrange' method before !");
8544 std::set<int> vals2(valsBg,valsEnd);
8545 const int *cptr=getConstPointer();
8546 std::vector<int> res;
8547 int nbOfTuples=getNumberOfTuples();
8548 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
8549 for(int i=0;i<nbOfTuples;i++,cptr++)
8550 if(vals2.find(*cptr)==vals2.end())
8551 ret->pushBackSilent(i);
8556 * This method is an extension of DataArrayInt::locateValue method because this method works for DataArrayInt with
8557 * any number of components excepted 0 (an INTERP_KERNEL::Exception is thrown in this case).
8558 * This method searches in \b this is there is a tuple that matched the input parameter \b tupl.
8559 * If any the tuple id is returned. If not -1 is returned.
8561 * This method throws an INTERP_KERNEL::Exception if the number of components in \b this mismatches with the size of
8562 * the input vector. An INTERP_KERNEL::Exception is thrown too if \b this is not allocated.
8564 * \return tuple id where \b tupl is. -1 if no such tuple exists in \b this.
8565 * \sa DataArrayInt::search, DataArrayInt::presenceOfTuple.
8567 int DataArrayInt::locateTuple(const std::vector<int>& tupl) const
8570 int nbOfCompo=getNumberOfComponents();
8572 throw INTERP_KERNEL::Exception("DataArrayInt::locateTuple : 0 components in 'this' !");
8573 if(nbOfCompo!=(int)tupl.size())
8575 std::ostringstream oss; oss << "DataArrayInt::locateTuple : 'this' contains " << nbOfCompo << " components and searching for a tuple of length " << tupl.size() << " !";
8576 throw INTERP_KERNEL::Exception(oss.str().c_str());
8578 const int *cptr=getConstPointer();
8579 std::size_t nbOfVals=getNbOfElems();
8580 for(const int *work=cptr;work!=cptr+nbOfVals;)
8582 work=std::search(work,cptr+nbOfVals,tupl.begin(),tupl.end());
8583 if(work!=cptr+nbOfVals)
8585 if(std::distance(cptr,work)%nbOfCompo!=0)
8588 return std::distance(cptr,work)/nbOfCompo;
8595 * This method searches the sequence specified in input parameter \b vals in \b this.
8596 * This works only for DataArrayInt having number of components equal to one (if not an INTERP_KERNEL::Exception will be thrown).
8597 * This method differs from DataArrayInt::locateTuple in that the position is internal raw data is not considered here contrary to DataArrayInt::locateTuple.
8598 * \sa DataArrayInt::locateTuple
8600 int DataArrayInt::search(const std::vector<int>& vals) const
8603 int nbOfCompo=getNumberOfComponents();
8605 throw INTERP_KERNEL::Exception("DataArrayInt::search : works only for DataArrayInt instance with one component !");
8606 const int *cptr=getConstPointer();
8607 std::size_t nbOfVals=getNbOfElems();
8608 const int *loc=std::search(cptr,cptr+nbOfVals,vals.begin(),vals.end());
8609 if(loc!=cptr+nbOfVals)
8610 return std::distance(cptr,loc);
8615 * This method expects to be called when number of components of this is equal to one.
8616 * This method returns the tuple id, if it exists, of the first tuple equal to \b value.
8617 * If not any tuple contains \b value -1 is returned.
8618 * \sa DataArrayInt::presenceOfValue
8620 int DataArrayInt::locateValue(int value) const
8623 if(getNumberOfComponents()!=1)
8624 throw INTERP_KERNEL::Exception("DataArrayInt::presenceOfValue : the array must have only one component, you can call 'rearrange' method before !");
8625 const int *cptr=getConstPointer();
8626 int nbOfTuples=getNumberOfTuples();
8627 const int *ret=std::find(cptr,cptr+nbOfTuples,value);
8628 if(ret!=cptr+nbOfTuples)
8629 return std::distance(cptr,ret);
8634 * This method expects to be called when number of components of this is equal to one.
8635 * This method returns the tuple id, if it exists, of the first tuple so that the value is contained in \b vals.
8636 * If not any tuple contains one of the values contained in 'vals' false is returned.
8637 * \sa DataArrayInt::presenceOfValue
8639 int DataArrayInt::locateValue(const std::vector<int>& vals) const
8642 if(getNumberOfComponents()!=1)
8643 throw INTERP_KERNEL::Exception("DataArrayInt::presenceOfValue : the array must have only one component, you can call 'rearrange' method before !");
8644 std::set<int> vals2(vals.begin(),vals.end());
8645 const int *cptr=getConstPointer();
8646 int nbOfTuples=getNumberOfTuples();
8647 for(const int *w=cptr;w!=cptr+nbOfTuples;w++)
8648 if(vals2.find(*w)!=vals2.end())
8649 return std::distance(cptr,w);
8654 * This method returns the number of values in \a this that are equals to input parameter \a value.
8655 * This method only works for single component array.
8657 * \return a value in [ 0, \c this->getNumberOfTuples() )
8659 * \throw If \a this is not allocated
8662 int DataArrayInt::count(int value) const
8666 if(getNumberOfComponents()!=1)
8667 throw INTERP_KERNEL::Exception("DataArrayInt::count : must be applied on DataArrayInt with only one component, you can call 'rearrange' method before !");
8668 const int *vals=begin();
8669 int nbOfTuples=getNumberOfTuples();
8670 for(int i=0;i<nbOfTuples;i++,vals++)
8677 * This method is an extension of DataArrayInt::presenceOfValue method because this method works for DataArrayInt with
8678 * any number of components excepted 0 (an INTERP_KERNEL::Exception is thrown in this case).
8679 * This method searches in \b this is there is a tuple that matched the input parameter \b tupl.
8680 * This method throws an INTERP_KERNEL::Exception if the number of components in \b this mismatches with the size of
8681 * the input vector. An INTERP_KERNEL::Exception is thrown too if \b this is not allocated.
8682 * \sa DataArrayInt::locateTuple
8684 bool DataArrayInt::presenceOfTuple(const std::vector<int>& tupl) const
8686 return locateTuple(tupl)!=-1;
8691 * Returns \a true if a given value is present within \a this one-dimensional array.
8692 * \param [in] value - the value to find within \a this array.
8693 * \return bool - \a true in case if \a value is present within \a this array.
8694 * \throw If \a this is not allocated.
8695 * \throw If \a this->getNumberOfComponents() != 1.
8698 bool DataArrayInt::presenceOfValue(int value) const
8700 return locateValue(value)!=-1;
8704 * This method expects to be called when number of components of this is equal to one.
8705 * This method returns true if it exists a tuple so that the value is contained in \b vals.
8706 * If not any tuple contains one of the values contained in 'vals' false is returned.
8707 * \sa DataArrayInt::locateValue
8709 bool DataArrayInt::presenceOfValue(const std::vector<int>& vals) const
8711 return locateValue(vals)!=-1;
8715 * Accumulates values of each component of \a this array.
8716 * \param [out] res - an array of length \a this->getNumberOfComponents(), allocated
8717 * by the caller, that is filled by this method with sum value for each
8719 * \throw If \a this is not allocated.
8721 void DataArrayInt::accumulate(int *res) const
8724 const int *ptr=getConstPointer();
8725 int nbTuple=getNumberOfTuples();
8726 int nbComps=getNumberOfComponents();
8727 std::fill(res,res+nbComps,0);
8728 for(int i=0;i<nbTuple;i++)
8729 std::transform(ptr+i*nbComps,ptr+(i+1)*nbComps,res,res,std::plus<int>());
8732 int DataArrayInt::accumulate(int compId) const
8735 const int *ptr=getConstPointer();
8736 int nbTuple=getNumberOfTuples();
8737 int nbComps=getNumberOfComponents();
8738 if(compId<0 || compId>=nbComps)
8739 throw INTERP_KERNEL::Exception("DataArrayInt::accumulate : Invalid compId specified : No such nb of components !");
8741 for(int i=0;i<nbTuple;i++)
8742 ret+=ptr[i*nbComps+compId];
8747 * This method accumulate using addition tuples in \a this using input index array [ \a bgOfIndex, \a endOfIndex ).
8748 * The returned array will have same number of components than \a this and number of tuples equal to
8749 * \c std::distance(bgOfIndex,endOfIndex) \b minus \b one.
8751 * The input index array is expected to be ascendingly sorted in which the all referenced ids should be in [0, \c this->getNumberOfTuples).
8753 * \param [in] bgOfIndex - begin (included) of the input index array.
8754 * \param [in] endOfIndex - end (excluded) of the input index array.
8755 * \return DataArrayInt * - the new instance having the same number of components than \a this.
8757 * \throw If bgOfIndex or end is NULL.
8758 * \throw If input index array is not ascendingly sorted.
8759 * \throw If there is an id in [ \a bgOfIndex, \a endOfIndex ) not in [0, \c this->getNumberOfTuples).
8760 * \throw If std::distance(bgOfIndex,endOfIndex)==0.
8762 DataArrayInt *DataArrayInt::accumulatePerChunck(const int *bgOfIndex, const int *endOfIndex) const
8764 if(!bgOfIndex || !endOfIndex)
8765 throw INTERP_KERNEL::Exception("DataArrayInt::accumulatePerChunck : input pointer NULL !");
8767 int nbCompo=getNumberOfComponents();
8768 int nbOfTuples=getNumberOfTuples();
8769 int sz=(int)std::distance(bgOfIndex,endOfIndex);
8771 throw INTERP_KERNEL::Exception("DataArrayInt::accumulatePerChunck : invalid size of input index array !");
8773 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(sz,nbCompo);
8774 const int *w=bgOfIndex;
8775 if(*w<0 || *w>=nbOfTuples)
8776 throw INTERP_KERNEL::Exception("DataArrayInt::accumulatePerChunck : The first element of the input index not in [0,nbOfTuples) !");
8777 const int *srcPt=begin()+(*w)*nbCompo;
8778 int *tmp=ret->getPointer();
8779 for(int i=0;i<sz;i++,tmp+=nbCompo,w++)
8781 std::fill(tmp,tmp+nbCompo,0);
8784 for(int j=w[0];j<w[1];j++,srcPt+=nbCompo)
8786 if(j>=0 && j<nbOfTuples)
8787 std::transform(srcPt,srcPt+nbCompo,tmp,tmp,std::plus<int>());
8790 std::ostringstream oss; oss << "DataArrayInt::accumulatePerChunck : At rank #" << i << " the input index array points to id " << j << " should be in [0," << nbOfTuples << ") !";
8791 throw INTERP_KERNEL::Exception(oss.str().c_str());
8797 std::ostringstream oss; oss << "DataArrayInt::accumulatePerChunck : At rank #" << i << " the input index array is not in ascendingly sorted.";
8798 throw INTERP_KERNEL::Exception(oss.str().c_str());
8801 ret->copyStringInfoFrom(*this);
8806 * Returns a new DataArrayInt by concatenating two given arrays, so that (1) the number
8807 * of tuples in the result array is <em> a1->getNumberOfTuples() + a2->getNumberOfTuples() -
8808 * offsetA2</em> and (2)
8809 * the number of component in the result array is same as that of each of given arrays.
8810 * First \a offsetA2 tuples of \a a2 are skipped and thus are missing from the result array.
8811 * Info on components is copied from the first of the given arrays. Number of components
8812 * in the given arrays must be the same.
8813 * \param [in] a1 - an array to include in the result array.
8814 * \param [in] a2 - another array to include in the result array.
8815 * \param [in] offsetA2 - number of tuples of \a a2 to skip.
8816 * \return DataArrayInt * - the new instance of DataArrayInt.
8817 * The caller is to delete this result array using decrRef() as it is no more
8819 * \throw If either \a a1 or \a a2 is NULL.
8820 * \throw If \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents().
8822 DataArrayInt *DataArrayInt::Aggregate(const DataArrayInt *a1, const DataArrayInt *a2, int offsetA2)
8825 throw INTERP_KERNEL::Exception("DataArrayInt::Aggregate : input DataArrayInt instance is NULL !");
8826 int nbOfComp=a1->getNumberOfComponents();
8827 if(nbOfComp!=a2->getNumberOfComponents())
8828 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Aggregation !");
8829 int nbOfTuple1=a1->getNumberOfTuples();
8830 int nbOfTuple2=a2->getNumberOfTuples();
8831 DataArrayInt *ret=DataArrayInt::New();
8832 ret->alloc(nbOfTuple1+nbOfTuple2-offsetA2,nbOfComp);
8833 int *pt=std::copy(a1->getConstPointer(),a1->getConstPointer()+nbOfTuple1*nbOfComp,ret->getPointer());
8834 std::copy(a2->getConstPointer()+offsetA2*nbOfComp,a2->getConstPointer()+nbOfTuple2*nbOfComp,pt);
8835 ret->copyStringInfoFrom(*a1);
8840 * Returns a new DataArrayInt by concatenating all given arrays, so that (1) the number
8841 * of tuples in the result array is a sum of the number of tuples of given arrays and (2)
8842 * the number of component in the result array is same as that of each of given arrays.
8843 * Info on components is copied from the first of the given arrays. Number of components
8844 * in the given arrays must be the same.
8845 * If the number of non null of elements in \a arr is equal to one the returned object is a copy of it
8846 * not the object itself.
8847 * \param [in] arr - a sequence of arrays to include in the result array.
8848 * \return DataArrayInt * - the new instance of DataArrayInt.
8849 * The caller is to delete this result array using decrRef() as it is no more
8851 * \throw If all arrays within \a arr are NULL.
8852 * \throw If getNumberOfComponents() of arrays within \a arr.
8854 DataArrayInt *DataArrayInt::Aggregate(const std::vector<const DataArrayInt *>& arr)
8856 std::vector<const DataArrayInt *> a;
8857 for(std::vector<const DataArrayInt *>::const_iterator it4=arr.begin();it4!=arr.end();it4++)
8861 throw INTERP_KERNEL::Exception("DataArrayInt::Aggregate : input list must be NON EMPTY !");
8862 std::vector<const DataArrayInt *>::const_iterator it=a.begin();
8863 int nbOfComp=(*it)->getNumberOfComponents();
8864 int nbt=(*it++)->getNumberOfTuples();
8865 for(int i=1;it!=a.end();it++,i++)
8867 if((*it)->getNumberOfComponents()!=nbOfComp)
8868 throw INTERP_KERNEL::Exception("DataArrayInt::Aggregate : Nb of components mismatch for array aggregation !");
8869 nbt+=(*it)->getNumberOfTuples();
8871 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
8872 ret->alloc(nbt,nbOfComp);
8873 int *pt=ret->getPointer();
8874 for(it=a.begin();it!=a.end();it++)
8875 pt=std::copy((*it)->getConstPointer(),(*it)->getConstPointer()+(*it)->getNbOfElems(),pt);
8876 ret->copyStringInfoFrom(*(a[0]));
8881 * This method takes as input a list of DataArrayInt instances \a arrs that represent each a packed index arrays.
8882 * A packed index array is an allocated array with one component, and at least one tuple. The first element
8883 * of each array in \a arrs must be 0. Each array in \a arrs is expected to be increasingly monotonic.
8884 * 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.
8886 * \return DataArrayInt * - a new object to be managed by the caller.
8888 DataArrayInt *DataArrayInt::AggregateIndexes(const std::vector<const DataArrayInt *>& arrs)
8891 for(std::vector<const DataArrayInt *>::const_iterator it4=arrs.begin();it4!=arrs.end();it4++)
8895 (*it4)->checkAllocated();
8896 if((*it4)->getNumberOfComponents()!=1)
8898 std::ostringstream oss; oss << "DataArrayInt::AggregateIndexes : presence of a DataArrayInt instance with nb of compo != 1 at pos " << std::distance(arrs.begin(),it4) << " !";
8899 throw INTERP_KERNEL::Exception(oss.str().c_str());
8901 int nbTupl=(*it4)->getNumberOfTuples();
8904 std::ostringstream oss; oss << "DataArrayInt::AggregateIndexes : presence of a DataArrayInt instance with nb of tuples < 1 at pos " << std::distance(arrs.begin(),it4) << " !";
8905 throw INTERP_KERNEL::Exception(oss.str().c_str());
8907 if((*it4)->front()!=0)
8909 std::ostringstream oss; oss << "DataArrayInt::AggregateIndexes : presence of a DataArrayInt instance with front value != 0 at pos " << std::distance(arrs.begin(),it4) << " !";
8910 throw INTERP_KERNEL::Exception(oss.str().c_str());
8916 std::ostringstream oss; oss << "DataArrayInt::AggregateIndexes : presence of a null instance at pos " << std::distance(arrs.begin(),it4) << " !";
8917 throw INTERP_KERNEL::Exception(oss.str().c_str());
8921 throw INTERP_KERNEL::Exception("DataArrayInt::AggregateIndexes : input list must be NON EMPTY !");
8922 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
8923 ret->alloc(retSz,1);
8924 int *pt=ret->getPointer(); *pt++=0;
8925 for(std::vector<const DataArrayInt *>::const_iterator it=arrs.begin();it!=arrs.end();it++)
8926 pt=std::transform((*it)->begin()+1,(*it)->end(),pt,std::bind2nd(std::plus<int>(),pt[-1]));
8927 ret->copyStringInfoFrom(*(arrs[0]));
8932 * Returns the maximal value and its location within \a this one-dimensional array.
8933 * \param [out] tupleId - index of the tuple holding the maximal value.
8934 * \return int - the maximal value among all values of \a this array.
8935 * \throw If \a this->getNumberOfComponents() != 1
8936 * \throw If \a this->getNumberOfTuples() < 1
8938 int DataArrayInt::getMaxValue(int& tupleId) const
8941 if(getNumberOfComponents()!=1)
8942 throw INTERP_KERNEL::Exception("DataArrayInt::getMaxValue : must be applied on DataArrayInt with only one component !");
8943 int nbOfTuples=getNumberOfTuples();
8945 throw INTERP_KERNEL::Exception("DataArrayInt::getMaxValue : array exists but number of tuples must be > 0 !");
8946 const int *vals=getConstPointer();
8947 const int *loc=std::max_element(vals,vals+nbOfTuples);
8948 tupleId=(int)std::distance(vals,loc);
8953 * Returns the maximal value within \a this array that is allowed to have more than
8955 * \return int - the maximal value among all values of \a this array.
8956 * \throw If \a this is not allocated.
8958 int DataArrayInt::getMaxValueInArray() const
8961 const int *loc=std::max_element(begin(),end());
8966 * Returns the minimal value and its location within \a this one-dimensional array.
8967 * \param [out] tupleId - index of the tuple holding the minimal value.
8968 * \return int - the minimal value among all values of \a this array.
8969 * \throw If \a this->getNumberOfComponents() != 1
8970 * \throw If \a this->getNumberOfTuples() < 1
8972 int DataArrayInt::getMinValue(int& tupleId) const
8975 if(getNumberOfComponents()!=1)
8976 throw INTERP_KERNEL::Exception("DataArrayInt::getMaxValue : must be applied on DataArrayInt with only one component !");
8977 int nbOfTuples=getNumberOfTuples();
8979 throw INTERP_KERNEL::Exception("DataArrayInt::getMaxValue : array exists but number of tuples must be > 0 !");
8980 const int *vals=getConstPointer();
8981 const int *loc=std::min_element(vals,vals+nbOfTuples);
8982 tupleId=(int)std::distance(vals,loc);
8987 * Returns the minimal value within \a this array that is allowed to have more than
8989 * \return int - the minimal value among all values of \a this array.
8990 * \throw If \a this is not allocated.
8992 int DataArrayInt::getMinValueInArray() const
8995 const int *loc=std::min_element(begin(),end());
9000 * Converts every value of \a this array to its absolute value.
9001 * \b WARNING this method is non const. If a new DataArrayInt instance should be built containing the result of abs DataArrayInt::computeAbs
9002 * should be called instead.
9004 * \throw If \a this is not allocated.
9005 * \sa DataArrayInt::computeAbs
9007 void DataArrayInt::abs()
9010 int *ptr(getPointer());
9011 std::size_t nbOfElems(getNbOfElems());
9012 std::transform(ptr,ptr+nbOfElems,ptr,std::ptr_fun<int,int>(std::abs));
9017 * This method builds a new instance of \a this object containing the result of std::abs applied of all elements in \a this.
9018 * This method is a const method (that do not change any values in \a this) contrary to DataArrayInt::abs method.
9020 * \return DataArrayInt * - the new instance of DataArrayInt containing the
9021 * same number of tuples and component as \a this array.
9022 * The caller is to delete this result array using decrRef() as it is no more
9024 * \throw If \a this is not allocated.
9025 * \sa DataArrayInt::abs
9027 DataArrayInt *DataArrayInt::computeAbs() const
9030 DataArrayInt *newArr(DataArrayInt::New());
9031 int nbOfTuples(getNumberOfTuples());
9032 int nbOfComp(getNumberOfComponents());
9033 newArr->alloc(nbOfTuples,nbOfComp);
9034 std::transform(begin(),end(),newArr->getPointer(),std::ptr_fun<int,int>(std::abs));
9035 newArr->copyStringInfoFrom(*this);
9040 * Apply a liner function to a given component of \a this array, so that
9041 * an array element <em>(x)</em> becomes \f$ a * x + b \f$.
9042 * \param [in] a - the first coefficient of the function.
9043 * \param [in] b - the second coefficient of the function.
9044 * \param [in] compoId - the index of component to modify.
9045 * \throw If \a this is not allocated.
9047 void DataArrayInt::applyLin(int a, int b, int compoId)
9050 int *ptr=getPointer()+compoId;
9051 int nbOfComp=getNumberOfComponents();
9052 int nbOfTuple=getNumberOfTuples();
9053 for(int i=0;i<nbOfTuple;i++,ptr+=nbOfComp)
9059 * Apply a liner function to all elements of \a this array, so that
9060 * an element _x_ becomes \f$ a * x + b \f$.
9061 * \param [in] a - the first coefficient of the function.
9062 * \param [in] b - the second coefficient of the function.
9063 * \throw If \a this is not allocated.
9065 void DataArrayInt::applyLin(int a, int b)
9068 int *ptr=getPointer();
9069 std::size_t nbOfElems=getNbOfElems();
9070 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
9076 * Returns a full copy of \a this array except that sign of all elements is reversed.
9077 * \return DataArrayInt * - the new instance of DataArrayInt containing the
9078 * same number of tuples and component as \a this array.
9079 * The caller is to delete this result array using decrRef() as it is no more
9081 * \throw If \a this is not allocated.
9083 DataArrayInt *DataArrayInt::negate() const
9086 DataArrayInt *newArr=DataArrayInt::New();
9087 int nbOfTuples=getNumberOfTuples();
9088 int nbOfComp=getNumberOfComponents();
9089 newArr->alloc(nbOfTuples,nbOfComp);
9090 const int *cptr=getConstPointer();
9091 std::transform(cptr,cptr+nbOfTuples*nbOfComp,newArr->getPointer(),std::negate<int>());
9092 newArr->copyStringInfoFrom(*this);
9097 * Modify all elements of \a this array, so that
9098 * an element _x_ becomes \f$ numerator / x \f$.
9099 * \warning If an exception is thrown because of presence of 0 element in \a this
9100 * array, all elements processed before detection of the zero element remain
9102 * \param [in] numerator - the numerator used to modify array elements.
9103 * \throw If \a this is not allocated.
9104 * \throw If there is an element equal to 0 in \a this array.
9106 void DataArrayInt::applyInv(int numerator)
9109 int *ptr=getPointer();
9110 std::size_t nbOfElems=getNbOfElems();
9111 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
9115 *ptr=numerator/(*ptr);
9119 std::ostringstream oss; oss << "DataArrayInt::applyInv : presence of null value in tuple #" << i/getNumberOfComponents() << " component #" << i%getNumberOfComponents();
9121 throw INTERP_KERNEL::Exception(oss.str().c_str());
9128 * Modify all elements of \a this array, so that
9129 * an element _x_ becomes \f$ x / val \f$.
9130 * \param [in] val - the denominator used to modify array elements.
9131 * \throw If \a this is not allocated.
9132 * \throw If \a val == 0.
9134 void DataArrayInt::applyDivideBy(int val)
9137 throw INTERP_KERNEL::Exception("DataArrayInt::applyDivideBy : Trying to divide by 0 !");
9139 int *ptr=getPointer();
9140 std::size_t nbOfElems=getNbOfElems();
9141 std::transform(ptr,ptr+nbOfElems,ptr,std::bind2nd(std::divides<int>(),val));
9146 * Modify all elements of \a this array, so that
9147 * an element _x_ becomes <em> x % val </em>.
9148 * \param [in] val - the divisor used to modify array elements.
9149 * \throw If \a this is not allocated.
9150 * \throw If \a val <= 0.
9152 void DataArrayInt::applyModulus(int val)
9155 throw INTERP_KERNEL::Exception("DataArrayInt::applyDivideBy : Trying to operate modulus on value <= 0 !");
9157 int *ptr=getPointer();
9158 std::size_t nbOfElems=getNbOfElems();
9159 std::transform(ptr,ptr+nbOfElems,ptr,std::bind2nd(std::modulus<int>(),val));
9164 * This method works only on data array with one component.
9165 * This method returns a newly allocated array storing stored ascendantly tuple ids in \b this so that
9166 * this[*id] in [\b vmin,\b vmax)
9168 * \param [in] vmin begin of range. This value is included in range (included).
9169 * \param [in] vmax end of range. This value is \b not included in range (excluded).
9170 * \return a newly allocated data array that the caller should deal with.
9172 * \sa DataArrayInt::getIdsNotInRange
9174 DataArrayInt *DataArrayInt::getIdsInRange(int vmin, int vmax) const
9177 if(getNumberOfComponents()!=1)
9178 throw INTERP_KERNEL::Exception("DataArrayInt::getIdsInRange : this must have exactly one component !");
9179 const int *cptr(begin());
9180 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
9181 int nbOfTuples(getNumberOfTuples());
9182 for(int i=0;i<nbOfTuples;i++,cptr++)
9183 if(*cptr>=vmin && *cptr<vmax)
9184 ret->pushBackSilent(i);
9189 * This method works only on data array with one component.
9190 * This method returns a newly allocated array storing stored ascendantly tuple ids in \b this so that
9191 * this[*id] \b not in [\b vmin,\b vmax)
9193 * \param [in] vmin begin of range. This value is \b not included in range (excluded).
9194 * \param [in] vmax end of range. This value is included in range (included).
9195 * \return a newly allocated data array that the caller should deal with.
9197 * \sa DataArrayInt::getIdsInRange
9199 DataArrayInt *DataArrayInt::getIdsNotInRange(int vmin, int vmax) const
9202 if(getNumberOfComponents()!=1)
9203 throw INTERP_KERNEL::Exception("DataArrayInt::getIdsNotInRange : this must have exactly one component !");
9204 const int *cptr(getConstPointer());
9205 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
9206 int nbOfTuples(getNumberOfTuples());
9207 for(int i=0;i<nbOfTuples;i++,cptr++)
9208 if(*cptr<vmin || *cptr>=vmax)
9209 ret->pushBackSilent(i);
9214 * This method works only on data array with one component.
9215 * 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.
9217 * \param [in] vmin begin of range. This value is included in range (included).
9218 * \param [in] vmax end of range. This value is \b not included in range (excluded).
9219 * \return if all ids in \a this are so that (*this)[i]==i for all i in [ 0, \c this->getNumberOfTuples() ). */
9220 bool DataArrayInt::checkAllIdsInRange(int vmin, int vmax) const
9223 if(getNumberOfComponents()!=1)
9224 throw INTERP_KERNEL::Exception("DataArrayInt::checkAllIdsInRange : this must have exactly one component !");
9225 int nbOfTuples=getNumberOfTuples();
9227 const int *cptr=getConstPointer();
9228 for(int i=0;i<nbOfTuples;i++,cptr++)
9230 if(*cptr>=vmin && *cptr<vmax)
9231 { ret=ret && *cptr==i; }
9234 std::ostringstream oss; oss << "DataArrayInt::checkAllIdsInRange : tuple #" << i << " has value " << *cptr << " should be in [" << vmin << "," << vmax << ") !";
9235 throw INTERP_KERNEL::Exception(oss.str().c_str());
9242 * Modify all elements of \a this array, so that
9243 * an element _x_ becomes <em> val % x </em>.
9244 * \warning If an exception is thrown because of presence of an element <= 0 in \a this
9245 * array, all elements processed before detection of the zero element remain
9247 * \param [in] val - the divident used to modify array elements.
9248 * \throw If \a this is not allocated.
9249 * \throw If there is an element equal to or less than 0 in \a this array.
9251 void DataArrayInt::applyRModulus(int val)
9254 int *ptr=getPointer();
9255 std::size_t nbOfElems=getNbOfElems();
9256 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
9264 std::ostringstream oss; oss << "DataArrayInt::applyRModulus : presence of value <=0 in tuple #" << i/getNumberOfComponents() << " component #" << i%getNumberOfComponents();
9266 throw INTERP_KERNEL::Exception(oss.str().c_str());
9273 * Modify all elements of \a this array, so that
9274 * an element _x_ becomes <em> val ^ x </em>.
9275 * \param [in] val - the value used to apply pow on all array elements.
9276 * \throw If \a this is not allocated.
9277 * \throw If \a val < 0.
9279 void DataArrayInt::applyPow(int val)
9283 throw INTERP_KERNEL::Exception("DataArrayInt::applyPow : input pow in < 0 !");
9284 int *ptr=getPointer();
9285 std::size_t nbOfElems=getNbOfElems();
9288 std::fill(ptr,ptr+nbOfElems,1);
9291 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
9294 for(int j=0;j<val;j++)
9302 * Modify all elements of \a this array, so that
9303 * an element _x_ becomes \f$ val ^ x \f$.
9304 * \param [in] val - the value used to apply pow on all array elements.
9305 * \throw If \a this is not allocated.
9306 * \throw If there is an element < 0 in \a this array.
9307 * \warning If an exception is thrown because of presence of 0 element in \a this
9308 * array, all elements processed before detection of the zero element remain
9311 void DataArrayInt::applyRPow(int val)
9314 int *ptr=getPointer();
9315 std::size_t nbOfElems=getNbOfElems();
9316 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
9321 for(int j=0;j<*ptr;j++)
9327 std::ostringstream oss; oss << "DataArrayInt::applyRPow : presence of negative value in tuple #" << i/getNumberOfComponents() << " component #" << i%getNumberOfComponents();
9329 throw INTERP_KERNEL::Exception(oss.str().c_str());
9336 * Returns a new DataArrayInt by aggregating two given arrays, so that (1) the number
9337 * of components in the result array is a sum of the number of components of given arrays
9338 * and (2) the number of tuples in the result array is same as that of each of given
9339 * arrays. In other words the i-th tuple of result array includes all components of
9340 * i-th tuples of all given arrays.
9341 * Number of tuples in the given arrays must be the same.
9342 * \param [in] a1 - an array to include in the result array.
9343 * \param [in] a2 - another array to include in the result array.
9344 * \return DataArrayInt * - the new instance of DataArrayInt.
9345 * The caller is to delete this result array using decrRef() as it is no more
9347 * \throw If both \a a1 and \a a2 are NULL.
9348 * \throw If any given array is not allocated.
9349 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
9351 DataArrayInt *DataArrayInt::Meld(const DataArrayInt *a1, const DataArrayInt *a2)
9353 std::vector<const DataArrayInt *> arr(2);
9354 arr[0]=a1; arr[1]=a2;
9359 * Returns a new DataArrayInt by aggregating all given arrays, so that (1) the number
9360 * of components in the result array is a sum of the number of components of given arrays
9361 * and (2) the number of tuples in the result array is same as that of each of given
9362 * arrays. In other words the i-th tuple of result array includes all components of
9363 * i-th tuples of all given arrays.
9364 * Number of tuples in the given arrays must be the same.
9365 * \param [in] arr - a sequence of arrays to include in the result array.
9366 * \return DataArrayInt * - the new instance of DataArrayInt.
9367 * The caller is to delete this result array using decrRef() as it is no more
9369 * \throw If all arrays within \a arr are NULL.
9370 * \throw If any given array is not allocated.
9371 * \throw If getNumberOfTuples() of arrays within \a arr is different.
9373 DataArrayInt *DataArrayInt::Meld(const std::vector<const DataArrayInt *>& arr)
9375 std::vector<const DataArrayInt *> a;
9376 for(std::vector<const DataArrayInt *>::const_iterator it4=arr.begin();it4!=arr.end();it4++)
9380 throw INTERP_KERNEL::Exception("DataArrayInt::Meld : array must be NON empty !");
9381 std::vector<const DataArrayInt *>::const_iterator it;
9382 for(it=a.begin();it!=a.end();it++)
9383 (*it)->checkAllocated();
9385 int nbOfTuples=(*it)->getNumberOfTuples();
9386 std::vector<int> nbc(a.size());
9387 std::vector<const int *> pts(a.size());
9388 nbc[0]=(*it)->getNumberOfComponents();
9389 pts[0]=(*it++)->getConstPointer();
9390 for(int i=1;it!=a.end();it++,i++)
9392 if(nbOfTuples!=(*it)->getNumberOfTuples())
9393 throw INTERP_KERNEL::Exception("DataArrayInt::meld : mismatch of number of tuples !");
9394 nbc[i]=(*it)->getNumberOfComponents();
9395 pts[i]=(*it)->getConstPointer();
9397 int totalNbOfComp=std::accumulate(nbc.begin(),nbc.end(),0);
9398 DataArrayInt *ret=DataArrayInt::New();
9399 ret->alloc(nbOfTuples,totalNbOfComp);
9400 int *retPtr=ret->getPointer();
9401 for(int i=0;i<nbOfTuples;i++)
9402 for(int j=0;j<(int)a.size();j++)
9404 retPtr=std::copy(pts[j],pts[j]+nbc[j],retPtr);
9408 for(int i=0;i<(int)a.size();i++)
9409 for(int j=0;j<nbc[i];j++,k++)
9410 ret->setInfoOnComponent(k,a[i]->getInfoOnComponent(j));
9415 * Returns a new DataArrayInt which is a minimal partition of elements of \a groups.
9416 * The i-th item of the result array is an ID of a set of elements belonging to a
9417 * unique set of groups, which the i-th element is a part of. This set of elements
9418 * belonging to a unique set of groups is called \a family, so the result array contains
9419 * IDs of families each element belongs to.
9421 * \b Example: if we have two groups of elements: \a group1 [0,4] and \a group2 [ 0,1,2 ],
9422 * then there are 3 families:
9423 * - \a family1 (with ID 1) contains element [0] belonging to ( \a group1 + \a group2 ),
9424 * - \a family2 (with ID 2) contains elements [4] belonging to ( \a group1 ),
9425 * - \a family3 (with ID 3) contains element [1,2] belonging to ( \a group2 ), <br>
9426 * and the result array contains IDs of families [ 1,3,3,0,2 ]. <br> Note a family ID 0 which
9427 * stands for the element #3 which is in none of groups.
9429 * \param [in] groups - sequence of groups of element IDs.
9430 * \param [in] newNb - total number of elements; it must be more than max ID of element
9432 * \param [out] fidsOfGroups - IDs of families the elements of each group belong to.
9433 * \return DataArrayInt * - a new instance of DataArrayInt containing IDs of families
9434 * each element with ID from range [0, \a newNb ) belongs to. The caller is to
9435 * delete this array using decrRef() as it is no more needed.
9436 * \throw If any element ID in \a groups violates condition ( 0 <= ID < \a newNb ).
9438 DataArrayInt *DataArrayInt::MakePartition(const std::vector<const DataArrayInt *>& groups, int newNb, std::vector< std::vector<int> >& fidsOfGroups)
9440 std::vector<const DataArrayInt *> groups2;
9441 for(std::vector<const DataArrayInt *>::const_iterator it4=groups.begin();it4!=groups.end();it4++)
9443 groups2.push_back(*it4);
9444 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
9445 ret->alloc(newNb,1);
9446 int *retPtr=ret->getPointer();
9447 std::fill(retPtr,retPtr+newNb,0);
9449 for(std::vector<const DataArrayInt *>::const_iterator iter=groups2.begin();iter!=groups2.end();iter++)
9451 const int *ptr=(*iter)->getConstPointer();
9452 std::size_t nbOfElem=(*iter)->getNbOfElems();
9454 for(int j=0;j<sfid;j++)
9457 for(std::size_t i=0;i<nbOfElem;i++)
9459 if(ptr[i]>=0 && ptr[i]<newNb)
9461 if(retPtr[ptr[i]]==j)
9469 std::ostringstream oss; oss << "DataArrayInt::MakePartition : In group \"" << (*iter)->getName() << "\" in tuple #" << i << " value = " << ptr[i] << " ! Should be in [0," << newNb;
9471 throw INTERP_KERNEL::Exception(oss.str().c_str());
9478 fidsOfGroups.clear();
9479 fidsOfGroups.resize(groups2.size());
9481 for(std::vector<const DataArrayInt *>::const_iterator iter=groups2.begin();iter!=groups2.end();iter++,grId++)
9484 const int *ptr=(*iter)->getConstPointer();
9485 std::size_t nbOfElem=(*iter)->getNbOfElems();
9486 for(const int *p=ptr;p!=ptr+nbOfElem;p++)
9487 tmp.insert(retPtr[*p]);
9488 fidsOfGroups[grId].insert(fidsOfGroups[grId].end(),tmp.begin(),tmp.end());
9494 * Returns a new DataArrayInt which contains all elements of given one-dimensional
9495 * arrays. The result array does not contain any duplicates and its values
9496 * are sorted in ascending order.
9497 * \param [in] arr - sequence of DataArrayInt's to unite.
9498 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
9499 * array using decrRef() as it is no more needed.
9500 * \throw If any \a arr[i] is not allocated.
9501 * \throw If \a arr[i]->getNumberOfComponents() != 1.
9503 DataArrayInt *DataArrayInt::BuildUnion(const std::vector<const DataArrayInt *>& arr)
9505 std::vector<const DataArrayInt *> a;
9506 for(std::vector<const DataArrayInt *>::const_iterator it4=arr.begin();it4!=arr.end();it4++)
9509 for(std::vector<const DataArrayInt *>::const_iterator it=a.begin();it!=a.end();it++)
9511 (*it)->checkAllocated();
9512 if((*it)->getNumberOfComponents()!=1)
9513 throw INTERP_KERNEL::Exception("DataArrayInt::BuildUnion : only single component allowed !");
9517 for(std::vector<const DataArrayInt *>::const_iterator it=a.begin();it!=a.end();it++)
9519 const int *pt=(*it)->getConstPointer();
9520 int nbOfTuples=(*it)->getNumberOfTuples();
9521 r.insert(pt,pt+nbOfTuples);
9523 DataArrayInt *ret=DataArrayInt::New();
9524 ret->alloc((int)r.size(),1);
9525 std::copy(r.begin(),r.end(),ret->getPointer());
9530 * Returns a new DataArrayInt which contains elements present in each of given one-dimensional
9531 * arrays. The result array does not contain any duplicates and its values
9532 * are sorted in ascending order.
9533 * \param [in] arr - sequence of DataArrayInt's to intersect.
9534 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
9535 * array using decrRef() as it is no more needed.
9536 * \throw If any \a arr[i] is not allocated.
9537 * \throw If \a arr[i]->getNumberOfComponents() != 1.
9539 DataArrayInt *DataArrayInt::BuildIntersection(const std::vector<const DataArrayInt *>& arr)
9541 std::vector<const DataArrayInt *> a;
9542 for(std::vector<const DataArrayInt *>::const_iterator it4=arr.begin();it4!=arr.end();it4++)
9545 for(std::vector<const DataArrayInt *>::const_iterator it=a.begin();it!=a.end();it++)
9547 (*it)->checkAllocated();
9548 if((*it)->getNumberOfComponents()!=1)
9549 throw INTERP_KERNEL::Exception("DataArrayInt::BuildIntersection : only single component allowed !");
9553 for(std::vector<const DataArrayInt *>::const_iterator it=a.begin();it!=a.end();it++)
9555 const int *pt=(*it)->getConstPointer();
9556 int nbOfTuples=(*it)->getNumberOfTuples();
9557 std::set<int> s1(pt,pt+nbOfTuples);
9561 std::set_intersection(r.begin(),r.end(),s1.begin(),s1.end(),inserter(r2,r2.end()));
9567 DataArrayInt *ret(DataArrayInt::New());
9568 ret->alloc((int)r.size(),1);
9569 std::copy(r.begin(),r.end(),ret->getPointer());
9574 * This method allows to put a vector of vector of integer into a more compact data stucture (skyline).
9575 * This method is not available into python because no available optimized data structure available to map std::vector< std::vector<int> >.
9577 * \param [in] v the input data structure to be translate into skyline format.
9578 * \param [out] data the first element of the skyline format. The user is expected to deal with newly allocated array.
9579 * \param [out] dataIndex the second element of the skyline format.
9581 void DataArrayInt::PutIntoToSkylineFrmt(const std::vector< std::vector<int> >& v, DataArrayInt *& data, DataArrayInt *& dataIndex)
9583 int sz((int)v.size());
9584 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret0(DataArrayInt::New()),ret1(DataArrayInt::New());
9585 ret1->alloc(sz+1,1);
9586 int *pt(ret1->getPointer()); *pt=0;
9587 for(int i=0;i<sz;i++,pt++)
9588 pt[1]=pt[0]+(int)v[i].size();
9589 ret0->alloc(ret1->back(),1);
9590 pt=ret0->getPointer();
9591 for(int i=0;i<sz;i++)
9592 pt=std::copy(v[i].begin(),v[i].end(),pt);
9593 data=ret0.retn(); dataIndex=ret1.retn();
9597 * Returns a new DataArrayInt which contains a complement of elements of \a this
9598 * one-dimensional array. I.e. the result array contains all elements from the range [0,
9599 * \a nbOfElement) not present in \a this array.
9600 * \param [in] nbOfElement - maximal size of the result array.
9601 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
9602 * array using decrRef() as it is no more needed.
9603 * \throw If \a this is not allocated.
9604 * \throw If \a this->getNumberOfComponents() != 1.
9605 * \throw If any element \a x of \a this array violates condition ( 0 <= \a x < \a
9608 DataArrayInt *DataArrayInt::buildComplement(int nbOfElement) const
9611 if(getNumberOfComponents()!=1)
9612 throw INTERP_KERNEL::Exception("DataArrayInt::buildComplement : only single component allowed !");
9613 std::vector<bool> tmp(nbOfElement);
9614 const int *pt=getConstPointer();
9615 int nbOfTuples=getNumberOfTuples();
9616 for(const int *w=pt;w!=pt+nbOfTuples;w++)
9617 if(*w>=0 && *w<nbOfElement)
9620 throw INTERP_KERNEL::Exception("DataArrayInt::buildComplement : an element is not in valid range : [0,nbOfElement) !");
9621 int nbOfRetVal=(int)std::count(tmp.begin(),tmp.end(),false);
9622 DataArrayInt *ret=DataArrayInt::New();
9623 ret->alloc(nbOfRetVal,1);
9625 int *retPtr=ret->getPointer();
9626 for(int i=0;i<nbOfElement;i++)
9633 * Returns a new DataArrayInt containing elements of \a this one-dimensional missing
9634 * from an \a other one-dimensional array.
9635 * \param [in] other - a DataArrayInt containing elements not to include in the result array.
9636 * \return DataArrayInt * - a new instance of DataArrayInt with one component. The
9637 * caller is to delete this array using decrRef() as it is no more needed.
9638 * \throw If \a other is NULL.
9639 * \throw If \a other is not allocated.
9640 * \throw If \a other->getNumberOfComponents() != 1.
9641 * \throw If \a this is not allocated.
9642 * \throw If \a this->getNumberOfComponents() != 1.
9643 * \sa DataArrayInt::buildSubstractionOptimized()
9645 DataArrayInt *DataArrayInt::buildSubstraction(const DataArrayInt *other) const
9648 throw INTERP_KERNEL::Exception("DataArrayInt::buildSubstraction : DataArrayInt pointer in input is NULL !");
9650 other->checkAllocated();
9651 if(getNumberOfComponents()!=1)
9652 throw INTERP_KERNEL::Exception("DataArrayInt::buildSubstraction : only single component allowed !");
9653 if(other->getNumberOfComponents()!=1)
9654 throw INTERP_KERNEL::Exception("DataArrayInt::buildSubstraction : only single component allowed for other type !");
9655 const int *pt=getConstPointer();
9656 int nbOfTuples=getNumberOfTuples();
9657 std::set<int> s1(pt,pt+nbOfTuples);
9658 pt=other->getConstPointer();
9659 nbOfTuples=other->getNumberOfTuples();
9660 std::set<int> s2(pt,pt+nbOfTuples);
9662 std::set_difference(s1.begin(),s1.end(),s2.begin(),s2.end(),std::back_insert_iterator< std::vector<int> >(r));
9663 DataArrayInt *ret=DataArrayInt::New();
9664 ret->alloc((int)r.size(),1);
9665 std::copy(r.begin(),r.end(),ret->getPointer());
9670 * \a this is expected to have one component and to be sorted ascendingly (as for \a other).
9671 * \a other is expected to be a part of \a this. If not DataArrayInt::buildSubstraction should be called instead.
9673 * \param [in] other an array with one component and expected to be sorted ascendingly.
9674 * \ret list of ids in \a this but not in \a other.
9675 * \sa DataArrayInt::buildSubstraction
9677 DataArrayInt *DataArrayInt::buildSubstractionOptimized(const DataArrayInt *other) const
9679 static const char *MSG="DataArrayInt::buildSubstractionOptimized : only single component allowed !";
9680 if(!other) throw INTERP_KERNEL::Exception("DataArrayInt::buildSubstractionOptimized : NULL input array !");
9681 checkAllocated(); other->checkAllocated();
9682 if(getNumberOfComponents()!=1) throw INTERP_KERNEL::Exception(MSG);
9683 if(other->getNumberOfComponents()!=1) throw INTERP_KERNEL::Exception(MSG);
9684 const int *pt1Bg(begin()),*pt1End(end()),*pt2Bg(other->begin()),*pt2End(other->end()),*work1(pt1Bg),*work2(pt2Bg);
9685 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
9686 for(;work1!=pt1End;work1++)
9688 if(work2!=pt2End && *work1==*work2)
9691 ret->pushBackSilent(*work1);
9698 * Returns a new DataArrayInt which contains all elements of \a this and a given
9699 * one-dimensional arrays. The result array does not contain any duplicates
9700 * and its values are sorted in ascending order.
9701 * \param [in] other - an array to unite with \a this one.
9702 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
9703 * array using decrRef() as it is no more needed.
9704 * \throw If \a this or \a other is not allocated.
9705 * \throw If \a this->getNumberOfComponents() != 1.
9706 * \throw If \a other->getNumberOfComponents() != 1.
9708 DataArrayInt *DataArrayInt::buildUnion(const DataArrayInt *other) const
9710 std::vector<const DataArrayInt *>arrs(2);
9711 arrs[0]=this; arrs[1]=other;
9712 return BuildUnion(arrs);
9717 * Returns a new DataArrayInt which contains elements present in both \a this and a given
9718 * one-dimensional arrays. The result array does not contain any duplicates
9719 * and its values are sorted in ascending order.
9720 * \param [in] other - an array to intersect with \a this one.
9721 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
9722 * array using decrRef() as it is no more needed.
9723 * \throw If \a this or \a other is not allocated.
9724 * \throw If \a this->getNumberOfComponents() != 1.
9725 * \throw If \a other->getNumberOfComponents() != 1.
9727 DataArrayInt *DataArrayInt::buildIntersection(const DataArrayInt *other) const
9729 std::vector<const DataArrayInt *>arrs(2);
9730 arrs[0]=this; arrs[1]=other;
9731 return BuildIntersection(arrs);
9735 * This method can be applied on allocated with one component DataArrayInt instance.
9736 * This method is typically relevant for sorted arrays. All consecutive duplicated items in \a this will appear only once in returned DataArrayInt instance.
9737 * 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]
9739 * \return a newly allocated array that contain the result of the unique operation applied on \a this.
9740 * \throw if \a this is not allocated or if \a this has not exactly one component.
9742 DataArrayInt *DataArrayInt::buildUnique() const
9745 if(getNumberOfComponents()!=1)
9746 throw INTERP_KERNEL::Exception("DataArrayInt::buildUnique : only single component allowed !");
9747 int nbOfTuples=getNumberOfTuples();
9748 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> tmp=deepCpy();
9749 int *data=tmp->getPointer();
9750 int *last=std::unique(data,data+nbOfTuples);
9751 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
9752 ret->alloc(std::distance(data,last),1);
9753 std::copy(data,last,ret->getPointer());
9758 * Returns a new DataArrayInt which contains size of every of groups described by \a this
9759 * "index" array. Such "index" array is returned for example by
9760 * \ref ParaMEDMEM::MEDCouplingUMesh::buildDescendingConnectivity
9761 * "MEDCouplingUMesh::buildDescendingConnectivity" and
9762 * \ref ParaMEDMEM::MEDCouplingUMesh::getNodalConnectivityIndex
9763 * "MEDCouplingUMesh::getNodalConnectivityIndex" etc.
9764 * This method preforms the reverse operation of DataArrayInt::computeOffsets2.
9765 * \return DataArrayInt * - a new instance of DataArrayInt, whose number of tuples
9766 * equals to \a this->getNumberOfComponents() - 1, and number of components is 1.
9767 * The caller is to delete this array using decrRef() as it is no more needed.
9768 * \throw If \a this is not allocated.
9769 * \throw If \a this->getNumberOfComponents() != 1.
9770 * \throw If \a this->getNumberOfTuples() < 2.
9773 * - this contains [1,3,6,7,7,9,15]
9774 * - result array contains [2,3,1,0,2,6],
9775 * where 2 = 3 - 1, 3 = 6 - 3, 1 = 7 - 6 etc.
9777 * \sa DataArrayInt::computeOffsets2
9779 DataArrayInt *DataArrayInt::deltaShiftIndex() const
9782 if(getNumberOfComponents()!=1)
9783 throw INTERP_KERNEL::Exception("DataArrayInt::deltaShiftIndex : only single component allowed !");
9784 int nbOfTuples=getNumberOfTuples();
9786 throw INTERP_KERNEL::Exception("DataArrayInt::deltaShiftIndex : 1 tuple at least must be present in 'this' !");
9787 const int *ptr=getConstPointer();
9788 DataArrayInt *ret=DataArrayInt::New();
9789 ret->alloc(nbOfTuples-1,1);
9790 int *out=ret->getPointer();
9791 std::transform(ptr+1,ptr+nbOfTuples,ptr,out,std::minus<int>());
9796 * Modifies \a this one-dimensional array so that value of each element \a x
9797 * of \a this array (\a a) is computed as \f$ x_i = \sum_{j=0}^{i-1} a[ j ] \f$.
9798 * Or: for each i>0 new[i]=new[i-1]+old[i-1] for i==0 new[i]=0. Number of tuples
9799 * and components remains the same.<br>
9800 * This method is useful for allToAllV in MPI with contiguous policy. This method
9801 * differs from computeOffsets2() in that the number of tuples is \b not changed by
9803 * \throw If \a this is not allocated.
9804 * \throw If \a this->getNumberOfComponents() != 1.
9807 * - Before \a this contains [3,5,1,2,0,8]
9808 * - After \a this contains [0,3,8,9,11,11]<br>
9809 * Note that the last element 19 = 11 + 8 is missing because size of \a this
9810 * array is retained and thus there is no space to store the last element.
9812 void DataArrayInt::computeOffsets()
9815 if(getNumberOfComponents()!=1)
9816 throw INTERP_KERNEL::Exception("DataArrayInt::computeOffsets : only single component allowed !");
9817 int nbOfTuples=getNumberOfTuples();
9820 int *work=getPointer();
9823 for(int i=1;i<nbOfTuples;i++)
9826 work[i]=work[i-1]+tmp;
9834 * Modifies \a this one-dimensional array so that value of each element \a x
9835 * of \a this array (\a a) is computed as \f$ x_i = \sum_{j=0}^{i-1} a[ j ] \f$.
9836 * Or: for each i>0 new[i]=new[i-1]+old[i-1] for i==0 new[i]=0. Number
9837 * components remains the same and number of tuples is inceamented by one.<br>
9838 * This method is useful for allToAllV in MPI with contiguous policy. This method
9839 * differs from computeOffsets() in that the number of tuples is changed by this one.
9840 * This method preforms the reverse operation of DataArrayInt::deltaShiftIndex.
9841 * \throw If \a this is not allocated.
9842 * \throw If \a this->getNumberOfComponents() != 1.
9845 * - Before \a this contains [3,5,1,2,0,8]
9846 * - After \a this contains [0,3,8,9,11,11,19]<br>
9847 * \sa DataArrayInt::deltaShiftIndex
9849 void DataArrayInt::computeOffsets2()
9852 if(getNumberOfComponents()!=1)
9853 throw INTERP_KERNEL::Exception("DataArrayInt::computeOffsets2 : only single component allowed !");
9854 int nbOfTuples=getNumberOfTuples();
9855 int *ret=(int *)malloc((nbOfTuples+1)*sizeof(int));
9858 const int *work=getConstPointer();
9860 for(int i=0;i<nbOfTuples;i++)
9861 ret[i+1]=work[i]+ret[i];
9862 useArray(ret,true,C_DEALLOC,nbOfTuples+1,1);
9867 * Returns two new DataArrayInt instances whose contents is computed from that of \a this and \a listOfIds arrays as follows.
9868 * \a this is expected to be an offset format ( as returned by DataArrayInt::computeOffsets2 ) that is to say with one component
9869 * and ** sorted strictly increasingly **. \a listOfIds is expected to be sorted ascendingly (not strictly needed for \a listOfIds).
9870 * This methods searches in \a this, considered as a set of contiguous \c this->getNumberOfComponents() ranges, all ids in \a listOfIds
9871 * filling completely one of the ranges in \a this.
9873 * \param [in] listOfIds a list of ids that has to be sorted ascendingly.
9874 * \param [out] rangeIdsFetched the range ids fetched
9875 * \param [out] idsInInputListThatFetch contains the list of ids in \a listOfIds that are \b fully included in a range in \a this. So
9876 * \a idsInInputListThatFetch is a part of input \a listOfIds.
9878 * \sa DataArrayInt::computeOffsets2
9881 * - \a this : [0,3,7,9,15,18]
9882 * - \a listOfIds contains [0,1,2,3,7,8,15,16,17]
9883 * - \a rangeIdsFetched result array: [0,2,4]
9884 * - \a idsInInputListThatFetch result array: [0,1,2,7,8,15,16,17]
9885 * In this example id 3 in input \a listOfIds is alone so it do not appear in output \a idsInInputListThatFetch.
9888 void DataArrayInt::searchRangesInListOfIds(const DataArrayInt *listOfIds, DataArrayInt *& rangeIdsFetched, DataArrayInt *& idsInInputListThatFetch) const
9891 throw INTERP_KERNEL::Exception("DataArrayInt::searchRangesInListOfIds : input list of ids is null !");
9892 listOfIds->checkAllocated(); checkAllocated();
9893 if(listOfIds->getNumberOfComponents()!=1)
9894 throw INTERP_KERNEL::Exception("DataArrayInt::searchRangesInListOfIds : input list of ids must have exactly one component !");
9895 if(getNumberOfComponents()!=1)
9896 throw INTERP_KERNEL::Exception("DataArrayInt::searchRangesInListOfIds : this must have exactly one component !");
9897 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret0=DataArrayInt::New(); ret0->alloc(0,1);
9898 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret1=DataArrayInt::New(); ret1->alloc(0,1);
9899 const int *tupEnd(listOfIds->end()),*offBg(begin()),*offEnd(end()-1);
9900 const int *tupPtr(listOfIds->begin()),*offPtr(offBg);
9901 while(tupPtr!=tupEnd && offPtr!=offEnd)
9903 if(*tupPtr==*offPtr)
9906 while(i<offPtr[1] && *tupPtr==i && tupPtr!=tupEnd) { i++; tupPtr++; }
9909 ret0->pushBackSilent((int)std::distance(offBg,offPtr));
9910 ret1->pushBackValsSilent(tupPtr-(offPtr[1]-offPtr[0]),tupPtr);
9915 { if(*tupPtr<*offPtr) tupPtr++; else offPtr++; }
9917 rangeIdsFetched=ret0.retn();
9918 idsInInputListThatFetch=ret1.retn();
9922 * Returns a new DataArrayInt whose contents is computed from that of \a this and \a
9923 * offsets arrays as follows. \a offsets is a one-dimensional array considered as an
9924 * "index" array of a "iota" array, thus, whose each element gives an index of a group
9925 * beginning within the "iota" array. And \a this is a one-dimensional array
9926 * considered as a selector of groups described by \a offsets to include into the result array.
9927 * \throw If \a offsets is NULL.
9928 * \throw If \a offsets is not allocated.
9929 * \throw If \a offsets->getNumberOfComponents() != 1.
9930 * \throw If \a offsets is not monotonically increasing.
9931 * \throw If \a this is not allocated.
9932 * \throw If \a this->getNumberOfComponents() != 1.
9933 * \throw If any element of \a this is not a valid index for \a offsets array.
9936 * - \a this: [0,2,3]
9937 * - \a offsets: [0,3,6,10,14,20]
9938 * - result array: [0,1,2,6,7,8,9,10,11,12,13] == <br>
9939 * \c range(0,3) + \c range(6,10) + \c range(10,14) ==<br>
9940 * \c range( \a offsets[ \a this[0] ], offsets[ \a this[0]+1 ]) +
9941 * \c range( \a offsets[ \a this[1] ], offsets[ \a this[1]+1 ]) +
9942 * \c range( \a offsets[ \a this[2] ], offsets[ \a this[2]+1 ])
9944 DataArrayInt *DataArrayInt::buildExplicitArrByRanges(const DataArrayInt *offsets) const
9947 throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrByRanges : DataArrayInt pointer in input is NULL !");
9949 if(getNumberOfComponents()!=1)
9950 throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrByRanges : only single component allowed !");
9951 offsets->checkAllocated();
9952 if(offsets->getNumberOfComponents()!=1)
9953 throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrByRanges : input array should have only single component !");
9954 int othNbTuples=offsets->getNumberOfTuples()-1;
9955 int nbOfTuples=getNumberOfTuples();
9956 int retNbOftuples=0;
9957 const int *work=getConstPointer();
9958 const int *offPtr=offsets->getConstPointer();
9959 for(int i=0;i<nbOfTuples;i++)
9962 if(val>=0 && val<othNbTuples)
9964 int delta=offPtr[val+1]-offPtr[val];
9966 retNbOftuples+=delta;
9969 std::ostringstream oss; oss << "DataArrayInt::buildExplicitArrByRanges : Tuple #" << val << " of offset array has a delta < 0 !";
9970 throw INTERP_KERNEL::Exception(oss.str().c_str());
9975 std::ostringstream oss; oss << "DataArrayInt::buildExplicitArrByRanges : Tuple #" << i << " in this contains " << val;
9976 oss << " whereas offsets array is of size " << othNbTuples+1 << " !";
9977 throw INTERP_KERNEL::Exception(oss.str().c_str());
9980 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
9981 ret->alloc(retNbOftuples,1);
9982 int *retPtr=ret->getPointer();
9983 for(int i=0;i<nbOfTuples;i++)
9986 int start=offPtr[val];
9987 int off=offPtr[val+1]-start;
9988 for(int j=0;j<off;j++,retPtr++)
9995 * Returns a new DataArrayInt whose contents is computed using \a this that must be a
9996 * scaled array (monotonically increasing).
9997 from that of \a this and \a
9998 * offsets arrays as follows. \a offsets is a one-dimensional array considered as an
9999 * "index" array of a "iota" array, thus, whose each element gives an index of a group
10000 * beginning within the "iota" array. And \a this is a one-dimensional array
10001 * considered as a selector of groups described by \a offsets to include into the result array.
10002 * \throw If \a is NULL.
10003 * \throw If \a this is not allocated.
10004 * \throw If \a this->getNumberOfComponents() != 1.
10005 * \throw If \a this->getNumberOfTuples() == 0.
10006 * \throw If \a this is not monotonically increasing.
10007 * \throw If any element of ids in ( \a bg \a stop \a step ) points outside the scale in \a this.
10010 * - \a bg , \a stop and \a step : (0,5,2)
10011 * - \a this: [0,3,6,10,14,20]
10012 * - result array: [0,0,0, 2,2,2,2, 4,4,4,4,4,4] == <br>
10014 DataArrayInt *DataArrayInt::buildExplicitArrOfSliceOnScaledArr(int bg, int stop, int step) const
10017 throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrOfSliceOnScaledArr : not allocated array !");
10018 if(getNumberOfComponents()!=1)
10019 throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrOfSliceOnScaledArr : number of components is expected to be equal to one !");
10020 int nbOfTuples(getNumberOfTuples());
10022 throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrOfSliceOnScaledArr : number of tuples must be != 0 !");
10023 const int *ids(begin());
10024 int nbOfEltsInSlc(GetNumberOfItemGivenBESRelative(bg,stop,step,"DataArrayInt::buildExplicitArrOfSliceOnScaledArr")),sz(0),pos(bg);
10025 for(int i=0;i<nbOfEltsInSlc;i++,pos+=step)
10027 if(pos>=0 && pos<nbOfTuples-1)
10029 int delta(ids[pos+1]-ids[pos]);
10033 std::ostringstream oss; oss << "DataArrayInt::buildExplicitArrOfSliceOnScaledArr : At pos #" << i << " of input slice, value is " << pos << " and at this pos this is not monotonically increasing !";
10034 throw INTERP_KERNEL::Exception(oss.str().c_str());
10039 std::ostringstream oss; oss << "DataArrayInt::buildExplicitArrOfSliceOnScaledArr : At pos #" << i << " of input slice, value is " << pos << " should be in [0," << nbOfTuples-1 << ") !";
10040 throw INTERP_KERNEL::Exception(oss.str().c_str());
10043 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(sz,1);
10044 int *retPtr(ret->getPointer());
10046 for(int i=0;i<nbOfEltsInSlc;i++,pos+=step)
10048 int delta(ids[pos+1]-ids[pos]);
10049 for(int j=0;j<delta;j++,retPtr++)
10056 * 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.
10057 * 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
10058 * in tuple **i** of returned DataArrayInt.
10059 * If ranges overlapped (in theory it should not) this method do not detect it and always returns the first range.
10061 * 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)]
10062 * The return DataArrayInt will contain : **[0,4,1,2,2,3]**
10064 * \param [in] ranges typically come from output of MEDCouplingUMesh::ComputeRangesFromTypeDistribution. Each range is specified like this : 1st component is
10065 * for lower value included and 2nd component is the upper value of corresponding range **excluded**.
10066 * \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
10067 * is thrown if no ranges in \a ranges contains value in \a this.
10069 * \sa DataArrayInt::findIdInRangeForEachTuple
10071 DataArrayInt *DataArrayInt::findRangeIdForEachTuple(const DataArrayInt *ranges) const
10074 throw INTERP_KERNEL::Exception("DataArrayInt::findRangeIdForEachTuple : null input pointer !");
10075 if(ranges->getNumberOfComponents()!=2)
10076 throw INTERP_KERNEL::Exception("DataArrayInt::findRangeIdForEachTuple : input DataArrayInt instance should have 2 components !");
10078 if(getNumberOfComponents()!=1)
10079 throw INTERP_KERNEL::Exception("DataArrayInt::findRangeIdForEachTuple : this should have only one component !");
10080 int nbTuples=getNumberOfTuples();
10081 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(nbTuples,1);
10082 int nbOfRanges=ranges->getNumberOfTuples();
10083 const int *rangesPtr=ranges->getConstPointer();
10084 int *retPtr=ret->getPointer();
10085 const int *inPtr=getConstPointer();
10086 for(int i=0;i<nbTuples;i++,retPtr++)
10090 for(int j=0;j<nbOfRanges && !found;j++)
10091 if(val>=rangesPtr[2*j] && val<rangesPtr[2*j+1])
10092 { *retPtr=j; found=true; }
10097 std::ostringstream oss; oss << "DataArrayInt::findRangeIdForEachTuple : tuple #" << i << " not found by any ranges !";
10098 throw INTERP_KERNEL::Exception(oss.str().c_str());
10105 * 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.
10106 * 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
10107 * in tuple **i** of returned DataArrayInt.
10108 * If ranges overlapped (in theory it should not) this method do not detect it and always returns the sub position of the first range.
10110 * 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)]
10111 * The return DataArrayInt will contain : **[1,2,4,0,2,2]**
10112 * This method is often called in pair with DataArrayInt::findRangeIdForEachTuple method.
10114 * \param [in] ranges typically come from output of MEDCouplingUMesh::ComputeRangesFromTypeDistribution. Each range is specified like this : 1st component is
10115 * for lower value included and 2nd component is the upper value of corresponding range **excluded**.
10116 * \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
10117 * is thrown if no ranges in \a ranges contains value in \a this.
10118 * \sa DataArrayInt::findRangeIdForEachTuple
10120 DataArrayInt *DataArrayInt::findIdInRangeForEachTuple(const DataArrayInt *ranges) const
10123 throw INTERP_KERNEL::Exception("DataArrayInt::findIdInRangeForEachTuple : null input pointer !");
10124 if(ranges->getNumberOfComponents()!=2)
10125 throw INTERP_KERNEL::Exception("DataArrayInt::findIdInRangeForEachTuple : input DataArrayInt instance should have 2 components !");
10127 if(getNumberOfComponents()!=1)
10128 throw INTERP_KERNEL::Exception("DataArrayInt::findIdInRangeForEachTuple : this should have only one component !");
10129 int nbTuples=getNumberOfTuples();
10130 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(nbTuples,1);
10131 int nbOfRanges=ranges->getNumberOfTuples();
10132 const int *rangesPtr=ranges->getConstPointer();
10133 int *retPtr=ret->getPointer();
10134 const int *inPtr=getConstPointer();
10135 for(int i=0;i<nbTuples;i++,retPtr++)
10139 for(int j=0;j<nbOfRanges && !found;j++)
10140 if(val>=rangesPtr[2*j] && val<rangesPtr[2*j+1])
10141 { *retPtr=val-rangesPtr[2*j]; found=true; }
10146 std::ostringstream oss; oss << "DataArrayInt::findIdInRangeForEachTuple : tuple #" << i << " not found by any ranges !";
10147 throw INTERP_KERNEL::Exception(oss.str().c_str());
10155 * \param [in] nbTimes specifies the nb of times each tuples in \a this will be duplicated contiguouly in returned DataArrayInt instance.
10156 * \a nbTimes should be at least equal to 1.
10157 * \return a newly allocated DataArrayInt having one component and number of tuples equal to \a nbTimes * \c this->getNumberOfTuples.
10158 * \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.
10160 DataArrayInt *DataArrayInt::duplicateEachTupleNTimes(int nbTimes) const
10163 if(getNumberOfComponents()!=1)
10164 throw INTERP_KERNEL::Exception("DataArrayInt::duplicateEachTupleNTimes : this should have only one component !");
10166 throw INTERP_KERNEL::Exception("DataArrayInt::duplicateEachTupleNTimes : nb times should be >= 1 !");
10167 int nbTuples=getNumberOfTuples();
10168 const int *inPtr=getConstPointer();
10169 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(nbTimes*nbTuples,1);
10170 int *retPtr=ret->getPointer();
10171 for(int i=0;i<nbTuples;i++,inPtr++)
10174 for(int j=0;j<nbTimes;j++,retPtr++)
10177 ret->copyStringInfoFrom(*this);
10182 * This method returns all different values found in \a this. This method throws if \a this has not been allocated.
10183 * But the number of components can be different from one.
10184 * \return a newly allocated array (that should be dealt by the caller) containing different values in \a this.
10186 DataArrayInt *DataArrayInt::getDifferentValues() const
10190 ret.insert(begin(),end());
10191 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret2=DataArrayInt::New(); ret2->alloc((int)ret.size(),1);
10192 std::copy(ret.begin(),ret.end(),ret2->getPointer());
10193 return ret2.retn();
10197 * This method is a refinement of DataArrayInt::getDifferentValues because it returns not only different values in \a this but also, for each of
10198 * them it tells which tuple id have this id.
10199 * This method works only on arrays with one component (if it is not the case call DataArrayInt::rearrange(1) ).
10200 * This method returns two arrays having same size.
10201 * 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.
10202 * 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]]
10204 std::vector<DataArrayInt *> DataArrayInt::partitionByDifferentValues(std::vector<int>& differentIds) const
10207 if(getNumberOfComponents()!=1)
10208 throw INTERP_KERNEL::Exception("DataArrayInt::partitionByDifferentValues : this should have only one component !");
10210 std::map<int,int> m,m2,m3;
10211 for(const int *w=begin();w!=end();w++)
10213 differentIds.resize(m.size());
10214 std::vector<DataArrayInt *> ret(m.size());
10215 std::vector<int *> retPtr(m.size());
10216 for(std::map<int,int>::const_iterator it=m.begin();it!=m.end();it++,id++)
10218 m2[(*it).first]=id;
10219 ret[id]=DataArrayInt::New();
10220 ret[id]->alloc((*it).second,1);
10221 retPtr[id]=ret[id]->getPointer();
10222 differentIds[id]=(*it).first;
10225 for(const int *w=begin();w!=end();w++,id++)
10227 retPtr[m2[*w]][m3[*w]++]=id;
10233 * This method split ids in [0, \c this->getNumberOfTuples() ) using \a this array as a field of weight (>=0 each).
10234 * The aim of this method is to return a set of \a nbOfSlices chunk of contiguous ids as balanced as possible.
10236 * \param [in] nbOfSlices - number of slices expected.
10237 * \return - a vector having a size equal to \a nbOfSlices giving the start (included) and the stop (excluded) of each chunks.
10239 * \sa DataArray::GetSlice
10240 * \throw If \a this is not allocated or not with exactly one component.
10241 * \throw If an element in \a this if < 0.
10243 std::vector< std::pair<int,int> > DataArrayInt::splitInBalancedSlices(int nbOfSlices) const
10245 if(!isAllocated() || getNumberOfComponents()!=1)
10246 throw INTERP_KERNEL::Exception("DataArrayInt::splitInBalancedSlices : this array should have number of components equal to one and must be allocated !");
10248 throw INTERP_KERNEL::Exception("DataArrayInt::splitInBalancedSlices : number of slices must be >= 1 !");
10249 int sum(accumulate(0)),nbOfTuples(getNumberOfTuples());
10250 int sumPerSlc(sum/nbOfSlices),pos(0);
10251 const int *w(begin());
10252 std::vector< std::pair<int,int> > ret(nbOfSlices);
10253 for(int i=0;i<nbOfSlices;i++)
10255 std::pair<int,int> p(pos,-1);
10257 while(locSum<sumPerSlc && pos<nbOfTuples) { pos++; locSum+=*w++; }
10258 if(i!=nbOfSlices-1)
10261 p.second=nbOfTuples;
10268 * Returns a new DataArrayInt that is a sum of two given arrays. There are 3
10270 * 1. The arrays have same number of tuples and components. Then each value of
10271 * the result array (_a_) is a sum of the corresponding values of \a a1 and \a a2,
10272 * i.e.: _a_ [ i, j ] = _a1_ [ i, j ] + _a2_ [ i, j ].
10273 * 2. The arrays have same number of tuples and one array, say _a2_, has one
10275 * _a_ [ i, j ] = _a1_ [ i, j ] + _a2_ [ i, 0 ].
10276 * 3. The arrays have same number of components and one array, say _a2_, has one
10278 * _a_ [ i, j ] = _a1_ [ i, j ] + _a2_ [ 0, j ].
10280 * Info on components is copied either from the first array (in the first case) or from
10281 * the array with maximal number of elements (getNbOfElems()).
10282 * \param [in] a1 - an array to sum up.
10283 * \param [in] a2 - another array to sum up.
10284 * \return DataArrayInt * - the new instance of DataArrayInt.
10285 * The caller is to delete this result array using decrRef() as it is no more
10287 * \throw If either \a a1 or \a a2 is NULL.
10288 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
10289 * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
10290 * none of them has number of tuples or components equal to 1.
10292 DataArrayInt *DataArrayInt::Add(const DataArrayInt *a1, const DataArrayInt *a2)
10295 throw INTERP_KERNEL::Exception("DataArrayInt::Add : input DataArrayInt instance is NULL !");
10296 int nbOfTuple=a1->getNumberOfTuples();
10297 int nbOfTuple2=a2->getNumberOfTuples();
10298 int nbOfComp=a1->getNumberOfComponents();
10299 int nbOfComp2=a2->getNumberOfComponents();
10300 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=0;
10301 if(nbOfTuple==nbOfTuple2)
10303 if(nbOfComp==nbOfComp2)
10305 ret=DataArrayInt::New();
10306 ret->alloc(nbOfTuple,nbOfComp);
10307 std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::plus<int>());
10308 ret->copyStringInfoFrom(*a1);
10312 int nbOfCompMin,nbOfCompMax;
10313 const DataArrayInt *aMin, *aMax;
10314 if(nbOfComp>nbOfComp2)
10316 nbOfCompMin=nbOfComp2; nbOfCompMax=nbOfComp;
10321 nbOfCompMin=nbOfComp; nbOfCompMax=nbOfComp2;
10326 ret=DataArrayInt::New();
10327 ret->alloc(nbOfTuple,nbOfCompMax);
10328 const int *aMinPtr=aMin->getConstPointer();
10329 const int *aMaxPtr=aMax->getConstPointer();
10330 int *res=ret->getPointer();
10331 for(int i=0;i<nbOfTuple;i++)
10332 res=std::transform(aMaxPtr+i*nbOfCompMax,aMaxPtr+(i+1)*nbOfCompMax,res,std::bind2nd(std::plus<int>(),aMinPtr[i]));
10333 ret->copyStringInfoFrom(*aMax);
10336 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Add !");
10339 else if((nbOfTuple==1 && nbOfTuple2>1) || (nbOfTuple>1 && nbOfTuple2==1))
10341 if(nbOfComp==nbOfComp2)
10343 int nbOfTupleMax=std::max(nbOfTuple,nbOfTuple2);
10344 const DataArrayInt *aMin=nbOfTuple>nbOfTuple2?a2:a1;
10345 const DataArrayInt *aMax=nbOfTuple>nbOfTuple2?a1:a2;
10346 const int *aMinPtr=aMin->getConstPointer(),*aMaxPtr=aMax->getConstPointer();
10347 ret=DataArrayInt::New();
10348 ret->alloc(nbOfTupleMax,nbOfComp);
10349 int *res=ret->getPointer();
10350 for(int i=0;i<nbOfTupleMax;i++)
10351 res=std::transform(aMaxPtr+i*nbOfComp,aMaxPtr+(i+1)*nbOfComp,aMinPtr,res,std::plus<int>());
10352 ret->copyStringInfoFrom(*aMax);
10355 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Add !");
10358 throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array Add !");
10363 * Adds values of another DataArrayInt to values of \a this one. There are 3
10365 * 1. The arrays have same number of tuples and components. Then each value of
10366 * \a other array is added to the corresponding value of \a this array, i.e.:
10367 * _a_ [ i, j ] += _other_ [ i, j ].
10368 * 2. The arrays have same number of tuples and \a other array has one component. Then
10369 * _a_ [ i, j ] += _other_ [ i, 0 ].
10370 * 3. The arrays have same number of components and \a other array has one tuple. Then
10371 * _a_ [ i, j ] += _a2_ [ 0, j ].
10373 * \param [in] other - an array to add to \a this one.
10374 * \throw If \a other is NULL.
10375 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
10376 * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
10377 * \a other has number of both tuples and components not equal to 1.
10379 void DataArrayInt::addEqual(const DataArrayInt *other)
10382 throw INTERP_KERNEL::Exception("DataArrayInt::addEqual : input DataArrayInt instance is NULL !");
10383 const char *msg="Nb of tuples mismatch for DataArrayInt::addEqual !";
10384 checkAllocated(); other->checkAllocated();
10385 int nbOfTuple=getNumberOfTuples();
10386 int nbOfTuple2=other->getNumberOfTuples();
10387 int nbOfComp=getNumberOfComponents();
10388 int nbOfComp2=other->getNumberOfComponents();
10389 if(nbOfTuple==nbOfTuple2)
10391 if(nbOfComp==nbOfComp2)
10393 std::transform(begin(),end(),other->begin(),getPointer(),std::plus<int>());
10395 else if(nbOfComp2==1)
10397 int *ptr=getPointer();
10398 const int *ptrc=other->getConstPointer();
10399 for(int i=0;i<nbOfTuple;i++)
10400 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::plus<int>(),*ptrc++));
10403 throw INTERP_KERNEL::Exception(msg);
10405 else if(nbOfTuple2==1)
10407 if(nbOfComp2==nbOfComp)
10409 int *ptr=getPointer();
10410 const int *ptrc=other->getConstPointer();
10411 for(int i=0;i<nbOfTuple;i++)
10412 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::plus<int>());
10415 throw INTERP_KERNEL::Exception(msg);
10418 throw INTERP_KERNEL::Exception(msg);
10423 * Returns a new DataArrayInt that is a subtraction of two given arrays. There are 3
10425 * 1. The arrays have same number of tuples and components. Then each value of
10426 * the result array (_a_) is a subtraction of the corresponding values of \a a1 and
10427 * \a a2, i.e.: _a_ [ i, j ] = _a1_ [ i, j ] - _a2_ [ i, j ].
10428 * 2. The arrays have same number of tuples and one array, say _a2_, has one
10430 * _a_ [ i, j ] = _a1_ [ i, j ] - _a2_ [ i, 0 ].
10431 * 3. The arrays have same number of components and one array, say _a2_, has one
10433 * _a_ [ i, j ] = _a1_ [ i, j ] - _a2_ [ 0, j ].
10435 * Info on components is copied either from the first array (in the first case) or from
10436 * the array with maximal number of elements (getNbOfElems()).
10437 * \param [in] a1 - an array to subtract from.
10438 * \param [in] a2 - an array to subtract.
10439 * \return DataArrayInt * - the new instance of DataArrayInt.
10440 * The caller is to delete this result array using decrRef() as it is no more
10442 * \throw If either \a a1 or \a a2 is NULL.
10443 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
10444 * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
10445 * none of them has number of tuples or components equal to 1.
10447 DataArrayInt *DataArrayInt::Substract(const DataArrayInt *a1, const DataArrayInt *a2)
10450 throw INTERP_KERNEL::Exception("DataArrayInt::Substract : input DataArrayInt instance is NULL !");
10451 int nbOfTuple1=a1->getNumberOfTuples();
10452 int nbOfTuple2=a2->getNumberOfTuples();
10453 int nbOfComp1=a1->getNumberOfComponents();
10454 int nbOfComp2=a2->getNumberOfComponents();
10455 if(nbOfTuple2==nbOfTuple1)
10457 if(nbOfComp1==nbOfComp2)
10459 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
10460 ret->alloc(nbOfTuple2,nbOfComp1);
10461 std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::minus<int>());
10462 ret->copyStringInfoFrom(*a1);
10465 else if(nbOfComp2==1)
10467 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
10468 ret->alloc(nbOfTuple1,nbOfComp1);
10469 const int *a2Ptr=a2->getConstPointer();
10470 const int *a1Ptr=a1->getConstPointer();
10471 int *res=ret->getPointer();
10472 for(int i=0;i<nbOfTuple1;i++)
10473 res=std::transform(a1Ptr+i*nbOfComp1,a1Ptr+(i+1)*nbOfComp1,res,std::bind2nd(std::minus<int>(),a2Ptr[i]));
10474 ret->copyStringInfoFrom(*a1);
10479 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Substract !");
10483 else if(nbOfTuple2==1)
10485 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Substract !");
10486 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
10487 ret->alloc(nbOfTuple1,nbOfComp1);
10488 const int *a1ptr=a1->getConstPointer(),*a2ptr=a2->getConstPointer();
10489 int *pt=ret->getPointer();
10490 for(int i=0;i<nbOfTuple1;i++)
10491 pt=std::transform(a1ptr+i*nbOfComp1,a1ptr+(i+1)*nbOfComp1,a2ptr,pt,std::minus<int>());
10492 ret->copyStringInfoFrom(*a1);
10497 a1->checkNbOfTuples(nbOfTuple2,"Nb of tuples mismatch for array Substract !");//will always throw an exception
10503 * Subtract values of another DataArrayInt from values of \a this one. There are 3
10505 * 1. The arrays have same number of tuples and components. Then each value of
10506 * \a other array is subtracted from the corresponding value of \a this array, i.e.:
10507 * _a_ [ i, j ] -= _other_ [ i, j ].
10508 * 2. The arrays have same number of tuples and \a other array has one component. Then
10509 * _a_ [ i, j ] -= _other_ [ i, 0 ].
10510 * 3. The arrays have same number of components and \a other array has one tuple. Then
10511 * _a_ [ i, j ] -= _a2_ [ 0, j ].
10513 * \param [in] other - an array to subtract from \a this one.
10514 * \throw If \a other is NULL.
10515 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
10516 * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
10517 * \a other has number of both tuples and components not equal to 1.
10519 void DataArrayInt::substractEqual(const DataArrayInt *other)
10522 throw INTERP_KERNEL::Exception("DataArrayInt::substractEqual : input DataArrayInt instance is NULL !");
10523 const char *msg="Nb of tuples mismatch for DataArrayInt::substractEqual !";
10524 checkAllocated(); other->checkAllocated();
10525 int nbOfTuple=getNumberOfTuples();
10526 int nbOfTuple2=other->getNumberOfTuples();
10527 int nbOfComp=getNumberOfComponents();
10528 int nbOfComp2=other->getNumberOfComponents();
10529 if(nbOfTuple==nbOfTuple2)
10531 if(nbOfComp==nbOfComp2)
10533 std::transform(begin(),end(),other->begin(),getPointer(),std::minus<int>());
10535 else if(nbOfComp2==1)
10537 int *ptr=getPointer();
10538 const int *ptrc=other->getConstPointer();
10539 for(int i=0;i<nbOfTuple;i++)
10540 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::minus<int>(),*ptrc++));
10543 throw INTERP_KERNEL::Exception(msg);
10545 else if(nbOfTuple2==1)
10547 int *ptr=getPointer();
10548 const int *ptrc=other->getConstPointer();
10549 for(int i=0;i<nbOfTuple;i++)
10550 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::minus<int>());
10553 throw INTERP_KERNEL::Exception(msg);
10558 * Returns a new DataArrayInt that is a product of two given arrays. There are 3
10560 * 1. The arrays have same number of tuples and components. Then each value of
10561 * the result array (_a_) is a product of the corresponding values of \a a1 and
10562 * \a a2, i.e.: _a_ [ i, j ] = _a1_ [ i, j ] * _a2_ [ i, j ].
10563 * 2. The arrays have same number of tuples and one array, say _a2_, has one
10565 * _a_ [ i, j ] = _a1_ [ i, j ] * _a2_ [ i, 0 ].
10566 * 3. The arrays have same number of components and one array, say _a2_, has one
10568 * _a_ [ i, j ] = _a1_ [ i, j ] * _a2_ [ 0, j ].
10570 * Info on components is copied either from the first array (in the first case) or from
10571 * the array with maximal number of elements (getNbOfElems()).
10572 * \param [in] a1 - a factor array.
10573 * \param [in] a2 - another factor array.
10574 * \return DataArrayInt * - the new instance of DataArrayInt.
10575 * The caller is to delete this result array using decrRef() as it is no more
10577 * \throw If either \a a1 or \a a2 is NULL.
10578 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
10579 * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
10580 * none of them has number of tuples or components equal to 1.
10582 DataArrayInt *DataArrayInt::Multiply(const DataArrayInt *a1, const DataArrayInt *a2)
10585 throw INTERP_KERNEL::Exception("DataArrayInt::Multiply : input DataArrayInt instance is NULL !");
10586 int nbOfTuple=a1->getNumberOfTuples();
10587 int nbOfTuple2=a2->getNumberOfTuples();
10588 int nbOfComp=a1->getNumberOfComponents();
10589 int nbOfComp2=a2->getNumberOfComponents();
10590 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=0;
10591 if(nbOfTuple==nbOfTuple2)
10593 if(nbOfComp==nbOfComp2)
10595 ret=DataArrayInt::New();
10596 ret->alloc(nbOfTuple,nbOfComp);
10597 std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::multiplies<int>());
10598 ret->copyStringInfoFrom(*a1);
10602 int nbOfCompMin,nbOfCompMax;
10603 const DataArrayInt *aMin, *aMax;
10604 if(nbOfComp>nbOfComp2)
10606 nbOfCompMin=nbOfComp2; nbOfCompMax=nbOfComp;
10611 nbOfCompMin=nbOfComp; nbOfCompMax=nbOfComp2;
10616 ret=DataArrayInt::New();
10617 ret->alloc(nbOfTuple,nbOfCompMax);
10618 const int *aMinPtr=aMin->getConstPointer();
10619 const int *aMaxPtr=aMax->getConstPointer();
10620 int *res=ret->getPointer();
10621 for(int i=0;i<nbOfTuple;i++)
10622 res=std::transform(aMaxPtr+i*nbOfCompMax,aMaxPtr+(i+1)*nbOfCompMax,res,std::bind2nd(std::multiplies<int>(),aMinPtr[i]));
10623 ret->copyStringInfoFrom(*aMax);
10626 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Multiply !");
10629 else if((nbOfTuple==1 && nbOfTuple2>1) || (nbOfTuple>1 && nbOfTuple2==1))
10631 if(nbOfComp==nbOfComp2)
10633 int nbOfTupleMax=std::max(nbOfTuple,nbOfTuple2);
10634 const DataArrayInt *aMin=nbOfTuple>nbOfTuple2?a2:a1;
10635 const DataArrayInt *aMax=nbOfTuple>nbOfTuple2?a1:a2;
10636 const int *aMinPtr=aMin->getConstPointer(),*aMaxPtr=aMax->getConstPointer();
10637 ret=DataArrayInt::New();
10638 ret->alloc(nbOfTupleMax,nbOfComp);
10639 int *res=ret->getPointer();
10640 for(int i=0;i<nbOfTupleMax;i++)
10641 res=std::transform(aMaxPtr+i*nbOfComp,aMaxPtr+(i+1)*nbOfComp,aMinPtr,res,std::multiplies<int>());
10642 ret->copyStringInfoFrom(*aMax);
10645 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Multiply !");
10648 throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array Multiply !");
10654 * Multiply values of another DataArrayInt to values of \a this one. There are 3
10656 * 1. The arrays have same number of tuples and components. Then each value of
10657 * \a other array is multiplied to the corresponding value of \a this array, i.e.:
10658 * _a_ [ i, j ] *= _other_ [ i, j ].
10659 * 2. The arrays have same number of tuples and \a other array has one component. Then
10660 * _a_ [ i, j ] *= _other_ [ i, 0 ].
10661 * 3. The arrays have same number of components and \a other array has one tuple. Then
10662 * _a_ [ i, j ] *= _a2_ [ 0, j ].
10664 * \param [in] other - an array to multiply to \a this one.
10665 * \throw If \a other is NULL.
10666 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
10667 * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
10668 * \a other has number of both tuples and components not equal to 1.
10670 void DataArrayInt::multiplyEqual(const DataArrayInt *other)
10673 throw INTERP_KERNEL::Exception("DataArrayInt::multiplyEqual : input DataArrayInt instance is NULL !");
10674 const char *msg="Nb of tuples mismatch for DataArrayInt::multiplyEqual !";
10675 checkAllocated(); other->checkAllocated();
10676 int nbOfTuple=getNumberOfTuples();
10677 int nbOfTuple2=other->getNumberOfTuples();
10678 int nbOfComp=getNumberOfComponents();
10679 int nbOfComp2=other->getNumberOfComponents();
10680 if(nbOfTuple==nbOfTuple2)
10682 if(nbOfComp==nbOfComp2)
10684 std::transform(begin(),end(),other->begin(),getPointer(),std::multiplies<int>());
10686 else if(nbOfComp2==1)
10688 int *ptr=getPointer();
10689 const int *ptrc=other->getConstPointer();
10690 for(int i=0;i<nbOfTuple;i++)
10691 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::multiplies<int>(),*ptrc++));
10694 throw INTERP_KERNEL::Exception(msg);
10696 else if(nbOfTuple2==1)
10698 if(nbOfComp2==nbOfComp)
10700 int *ptr=getPointer();
10701 const int *ptrc=other->getConstPointer();
10702 for(int i=0;i<nbOfTuple;i++)
10703 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::multiplies<int>());
10706 throw INTERP_KERNEL::Exception(msg);
10709 throw INTERP_KERNEL::Exception(msg);
10715 * Returns a new DataArrayInt that is a division of two given arrays. There are 3
10717 * 1. The arrays have same number of tuples and components. Then each value of
10718 * the result array (_a_) is a division of the corresponding values of \a a1 and
10719 * \a a2, i.e.: _a_ [ i, j ] = _a1_ [ i, j ] / _a2_ [ i, j ].
10720 * 2. The arrays have same number of tuples and one array, say _a2_, has one
10722 * _a_ [ i, j ] = _a1_ [ i, j ] / _a2_ [ i, 0 ].
10723 * 3. The arrays have same number of components and one array, say _a2_, has one
10725 * _a_ [ i, j ] = _a1_ [ i, j ] / _a2_ [ 0, j ].
10727 * Info on components is copied either from the first array (in the first case) or from
10728 * the array with maximal number of elements (getNbOfElems()).
10729 * \warning No check of division by zero is performed!
10730 * \param [in] a1 - a numerator array.
10731 * \param [in] a2 - a denominator array.
10732 * \return DataArrayInt * - the new instance of DataArrayInt.
10733 * The caller is to delete this result array using decrRef() as it is no more
10735 * \throw If either \a a1 or \a a2 is NULL.
10736 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
10737 * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
10738 * none of them has number of tuples or components equal to 1.
10740 DataArrayInt *DataArrayInt::Divide(const DataArrayInt *a1, const DataArrayInt *a2)
10743 throw INTERP_KERNEL::Exception("DataArrayInt::Divide : input DataArrayInt instance is NULL !");
10744 int nbOfTuple1=a1->getNumberOfTuples();
10745 int nbOfTuple2=a2->getNumberOfTuples();
10746 int nbOfComp1=a1->getNumberOfComponents();
10747 int nbOfComp2=a2->getNumberOfComponents();
10748 if(nbOfTuple2==nbOfTuple1)
10750 if(nbOfComp1==nbOfComp2)
10752 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
10753 ret->alloc(nbOfTuple2,nbOfComp1);
10754 std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::divides<int>());
10755 ret->copyStringInfoFrom(*a1);
10758 else if(nbOfComp2==1)
10760 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
10761 ret->alloc(nbOfTuple1,nbOfComp1);
10762 const int *a2Ptr=a2->getConstPointer();
10763 const int *a1Ptr=a1->getConstPointer();
10764 int *res=ret->getPointer();
10765 for(int i=0;i<nbOfTuple1;i++)
10766 res=std::transform(a1Ptr+i*nbOfComp1,a1Ptr+(i+1)*nbOfComp1,res,std::bind2nd(std::divides<int>(),a2Ptr[i]));
10767 ret->copyStringInfoFrom(*a1);
10772 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Divide !");
10776 else if(nbOfTuple2==1)
10778 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Divide !");
10779 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
10780 ret->alloc(nbOfTuple1,nbOfComp1);
10781 const int *a1ptr=a1->getConstPointer(),*a2ptr=a2->getConstPointer();
10782 int *pt=ret->getPointer();
10783 for(int i=0;i<nbOfTuple1;i++)
10784 pt=std::transform(a1ptr+i*nbOfComp1,a1ptr+(i+1)*nbOfComp1,a2ptr,pt,std::divides<int>());
10785 ret->copyStringInfoFrom(*a1);
10790 a1->checkNbOfTuples(nbOfTuple2,"Nb of tuples mismatch for array Divide !");//will always throw an exception
10796 * Divide values of \a this array by values of another DataArrayInt. There are 3
10798 * 1. The arrays have same number of tuples and components. Then each value of
10799 * \a this array is divided by the corresponding value of \a other one, i.e.:
10800 * _a_ [ i, j ] /= _other_ [ i, j ].
10801 * 2. The arrays have same number of tuples and \a other array has one component. Then
10802 * _a_ [ i, j ] /= _other_ [ i, 0 ].
10803 * 3. The arrays have same number of components and \a other array has one tuple. Then
10804 * _a_ [ i, j ] /= _a2_ [ 0, j ].
10806 * \warning No check of division by zero is performed!
10807 * \param [in] other - an array to divide \a this one by.
10808 * \throw If \a other is NULL.
10809 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
10810 * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
10811 * \a other has number of both tuples and components not equal to 1.
10813 void DataArrayInt::divideEqual(const DataArrayInt *other)
10816 throw INTERP_KERNEL::Exception("DataArrayInt::divideEqual : input DataArrayInt instance is NULL !");
10817 const char *msg="Nb of tuples mismatch for DataArrayInt::divideEqual !";
10818 checkAllocated(); other->checkAllocated();
10819 int nbOfTuple=getNumberOfTuples();
10820 int nbOfTuple2=other->getNumberOfTuples();
10821 int nbOfComp=getNumberOfComponents();
10822 int nbOfComp2=other->getNumberOfComponents();
10823 if(nbOfTuple==nbOfTuple2)
10825 if(nbOfComp==nbOfComp2)
10827 std::transform(begin(),end(),other->begin(),getPointer(),std::divides<int>());
10829 else if(nbOfComp2==1)
10831 int *ptr=getPointer();
10832 const int *ptrc=other->getConstPointer();
10833 for(int i=0;i<nbOfTuple;i++)
10834 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::divides<int>(),*ptrc++));
10837 throw INTERP_KERNEL::Exception(msg);
10839 else if(nbOfTuple2==1)
10841 if(nbOfComp2==nbOfComp)
10843 int *ptr=getPointer();
10844 const int *ptrc=other->getConstPointer();
10845 for(int i=0;i<nbOfTuple;i++)
10846 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::divides<int>());
10849 throw INTERP_KERNEL::Exception(msg);
10852 throw INTERP_KERNEL::Exception(msg);
10858 * Returns a new DataArrayInt that is a modulus of two given arrays. There are 3
10860 * 1. The arrays have same number of tuples and components. Then each value of
10861 * the result array (_a_) is a division of the corresponding values of \a a1 and
10862 * \a a2, i.e.: _a_ [ i, j ] = _a1_ [ i, j ] % _a2_ [ i, j ].
10863 * 2. The arrays have same number of tuples and one array, say _a2_, has one
10865 * _a_ [ i, j ] = _a1_ [ i, j ] % _a2_ [ i, 0 ].
10866 * 3. The arrays have same number of components and one array, say _a2_, has one
10868 * _a_ [ i, j ] = _a1_ [ i, j ] % _a2_ [ 0, j ].
10870 * Info on components is copied either from the first array (in the first case) or from
10871 * the array with maximal number of elements (getNbOfElems()).
10872 * \warning No check of division by zero is performed!
10873 * \param [in] a1 - a dividend array.
10874 * \param [in] a2 - a divisor array.
10875 * \return DataArrayInt * - the new instance of DataArrayInt.
10876 * The caller is to delete this result array using decrRef() as it is no more
10878 * \throw If either \a a1 or \a a2 is NULL.
10879 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
10880 * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
10881 * none of them has number of tuples or components equal to 1.
10883 DataArrayInt *DataArrayInt::Modulus(const DataArrayInt *a1, const DataArrayInt *a2)
10886 throw INTERP_KERNEL::Exception("DataArrayInt::Modulus : input DataArrayInt instance is NULL !");
10887 int nbOfTuple1=a1->getNumberOfTuples();
10888 int nbOfTuple2=a2->getNumberOfTuples();
10889 int nbOfComp1=a1->getNumberOfComponents();
10890 int nbOfComp2=a2->getNumberOfComponents();
10891 if(nbOfTuple2==nbOfTuple1)
10893 if(nbOfComp1==nbOfComp2)
10895 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
10896 ret->alloc(nbOfTuple2,nbOfComp1);
10897 std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::modulus<int>());
10898 ret->copyStringInfoFrom(*a1);
10901 else if(nbOfComp2==1)
10903 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
10904 ret->alloc(nbOfTuple1,nbOfComp1);
10905 const int *a2Ptr=a2->getConstPointer();
10906 const int *a1Ptr=a1->getConstPointer();
10907 int *res=ret->getPointer();
10908 for(int i=0;i<nbOfTuple1;i++)
10909 res=std::transform(a1Ptr+i*nbOfComp1,a1Ptr+(i+1)*nbOfComp1,res,std::bind2nd(std::modulus<int>(),a2Ptr[i]));
10910 ret->copyStringInfoFrom(*a1);
10915 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Modulus !");
10919 else if(nbOfTuple2==1)
10921 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Modulus !");
10922 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
10923 ret->alloc(nbOfTuple1,nbOfComp1);
10924 const int *a1ptr=a1->getConstPointer(),*a2ptr=a2->getConstPointer();
10925 int *pt=ret->getPointer();
10926 for(int i=0;i<nbOfTuple1;i++)
10927 pt=std::transform(a1ptr+i*nbOfComp1,a1ptr+(i+1)*nbOfComp1,a2ptr,pt,std::modulus<int>());
10928 ret->copyStringInfoFrom(*a1);
10933 a1->checkNbOfTuples(nbOfTuple2,"Nb of tuples mismatch for array Modulus !");//will always throw an exception
10939 * Modify \a this array so that each value becomes a modulus of division of this value by
10940 * a value of another DataArrayInt. There are 3 valid cases.
10941 * 1. The arrays have same number of tuples and components. Then each value of
10942 * \a this array is divided by the corresponding value of \a other one, i.e.:
10943 * _a_ [ i, j ] %= _other_ [ i, j ].
10944 * 2. The arrays have same number of tuples and \a other array has one component. Then
10945 * _a_ [ i, j ] %= _other_ [ i, 0 ].
10946 * 3. The arrays have same number of components and \a other array has one tuple. Then
10947 * _a_ [ i, j ] %= _a2_ [ 0, j ].
10949 * \warning No check of division by zero is performed!
10950 * \param [in] other - a divisor array.
10951 * \throw If \a other is NULL.
10952 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
10953 * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
10954 * \a other has number of both tuples and components not equal to 1.
10956 void DataArrayInt::modulusEqual(const DataArrayInt *other)
10959 throw INTERP_KERNEL::Exception("DataArrayInt::modulusEqual : input DataArrayInt instance is NULL !");
10960 const char *msg="Nb of tuples mismatch for DataArrayInt::modulusEqual !";
10961 checkAllocated(); other->checkAllocated();
10962 int nbOfTuple=getNumberOfTuples();
10963 int nbOfTuple2=other->getNumberOfTuples();
10964 int nbOfComp=getNumberOfComponents();
10965 int nbOfComp2=other->getNumberOfComponents();
10966 if(nbOfTuple==nbOfTuple2)
10968 if(nbOfComp==nbOfComp2)
10970 std::transform(begin(),end(),other->begin(),getPointer(),std::modulus<int>());
10972 else if(nbOfComp2==1)
10974 if(nbOfComp2==nbOfComp)
10976 int *ptr=getPointer();
10977 const int *ptrc=other->getConstPointer();
10978 for(int i=0;i<nbOfTuple;i++)
10979 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::modulus<int>(),*ptrc++));
10982 throw INTERP_KERNEL::Exception(msg);
10985 throw INTERP_KERNEL::Exception(msg);
10987 else if(nbOfTuple2==1)
10989 int *ptr=getPointer();
10990 const int *ptrc=other->getConstPointer();
10991 for(int i=0;i<nbOfTuple;i++)
10992 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::modulus<int>());
10995 throw INTERP_KERNEL::Exception(msg);
11000 * Returns a new DataArrayInt that is the result of pow of two given arrays. There are 3
11003 * \param [in] a1 - an array to pow up.
11004 * \param [in] a2 - another array to sum up.
11005 * \return DataArrayInt * - the new instance of DataArrayInt.
11006 * The caller is to delete this result array using decrRef() as it is no more
11008 * \throw If either \a a1 or \a a2 is NULL.
11009 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
11010 * \throw If \a a1->getNumberOfComponents() != 1 or \a a2->getNumberOfComponents() != 1.
11011 * \throw If there is a negative value in \a a2.
11013 DataArrayInt *DataArrayInt::Pow(const DataArrayInt *a1, const DataArrayInt *a2)
11016 throw INTERP_KERNEL::Exception("DataArrayInt::Pow : at least one of input instances is null !");
11017 int nbOfTuple=a1->getNumberOfTuples();
11018 int nbOfTuple2=a2->getNumberOfTuples();
11019 int nbOfComp=a1->getNumberOfComponents();
11020 int nbOfComp2=a2->getNumberOfComponents();
11021 if(nbOfTuple!=nbOfTuple2)
11022 throw INTERP_KERNEL::Exception("DataArrayInt::Pow : number of tuples mismatches !");
11023 if(nbOfComp!=1 || nbOfComp2!=1)
11024 throw INTERP_KERNEL::Exception("DataArrayInt::Pow : number of components of both arrays must be equal to 1 !");
11025 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(nbOfTuple,1);
11026 const int *ptr1(a1->begin()),*ptr2(a2->begin());
11027 int *ptr=ret->getPointer();
11028 for(int i=0;i<nbOfTuple;i++,ptr1++,ptr2++,ptr++)
11033 for(int j=0;j<*ptr2;j++)
11039 std::ostringstream oss; oss << "DataArrayInt::Pow : on tuple #" << i << " of a2 value is < 0 (" << *ptr2 << ") !";
11040 throw INTERP_KERNEL::Exception(oss.str().c_str());
11047 * Apply pow on values of another DataArrayInt to values of \a this one.
11049 * \param [in] other - an array to pow to \a this one.
11050 * \throw If \a other is NULL.
11051 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples()
11052 * \throw If \a this->getNumberOfComponents() != 1 or \a other->getNumberOfComponents() != 1
11053 * \throw If there is a negative value in \a other.
11055 void DataArrayInt::powEqual(const DataArrayInt *other)
11058 throw INTERP_KERNEL::Exception("DataArrayInt::powEqual : input instance is null !");
11059 int nbOfTuple=getNumberOfTuples();
11060 int nbOfTuple2=other->getNumberOfTuples();
11061 int nbOfComp=getNumberOfComponents();
11062 int nbOfComp2=other->getNumberOfComponents();
11063 if(nbOfTuple!=nbOfTuple2)
11064 throw INTERP_KERNEL::Exception("DataArrayInt::powEqual : number of tuples mismatches !");
11065 if(nbOfComp!=1 || nbOfComp2!=1)
11066 throw INTERP_KERNEL::Exception("DataArrayInt::powEqual : number of components of both arrays must be equal to 1 !");
11067 int *ptr=getPointer();
11068 const int *ptrc=other->begin();
11069 for(int i=0;i<nbOfTuple;i++,ptrc++,ptr++)
11074 for(int j=0;j<*ptrc;j++)
11080 std::ostringstream oss; oss << "DataArrayInt::powEqual : on tuple #" << i << " of other value is < 0 (" << *ptrc << ") !";
11081 throw INTERP_KERNEL::Exception(oss.str().c_str());
11088 * Returns a C array which is a renumbering map in "Old to New" mode for the input array.
11089 * This map, if applied to \a start array, would make it sorted. For example, if
11090 * \a start array contents are [9,10,0,6,4,11,3,7] then the contents of the result array is
11091 * [5,6,0,3,2,7,1,4].
11092 * \param [in] start - pointer to the first element of the array for which the
11093 * permutation map is computed.
11094 * \param [in] end - pointer specifying the end of the array \a start, so that
11095 * the last value of \a start is \a end[ -1 ].
11096 * \return int * - the result permutation array that the caller is to delete as it is no
11098 * \throw If there are equal values in the input array.
11100 int *DataArrayInt::CheckAndPreparePermutation(const int *start, const int *end)
11102 std::size_t sz=std::distance(start,end);
11103 int *ret=(int *)malloc(sz*sizeof(int));
11104 int *work=new int[sz];
11105 std::copy(start,end,work);
11106 std::sort(work,work+sz);
11107 if(std::unique(work,work+sz)!=work+sz)
11111 throw INTERP_KERNEL::Exception("Some elements are equals in the specified array !");
11113 std::map<int,int> m;
11114 for(int *workPt=work;workPt!=work+sz;workPt++)
11115 m[*workPt]=(int)std::distance(work,workPt);
11117 for(const int *iter=start;iter!=end;iter++,iter2++)
11124 * Returns a new DataArrayInt containing an arithmetic progression
11125 * that is equal to the sequence returned by Python \c range(\a begin,\a end,\a step )
11127 * \param [in] begin - the start value of the result sequence.
11128 * \param [in] end - limiting value, so that every value of the result array is less than
11130 * \param [in] step - specifies the increment or decrement.
11131 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
11132 * array using decrRef() as it is no more needed.
11133 * \throw If \a step == 0.
11134 * \throw If \a end < \a begin && \a step > 0.
11135 * \throw If \a end > \a begin && \a step < 0.
11137 DataArrayInt *DataArrayInt::Range(int begin, int end, int step)
11139 int nbOfTuples=GetNumberOfItemGivenBESRelative(begin,end,step,"DataArrayInt::Range");
11140 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
11141 ret->alloc(nbOfTuples,1);
11142 int *ptr=ret->getPointer();
11145 for(int i=begin;i<end;i+=step,ptr++)
11150 for(int i=begin;i>end;i+=step,ptr++)
11157 * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
11160 void DataArrayInt::getTinySerializationIntInformation(std::vector<int>& tinyInfo) const
11162 tinyInfo.resize(2);
11165 tinyInfo[0]=getNumberOfTuples();
11166 tinyInfo[1]=getNumberOfComponents();
11176 * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
11179 void DataArrayInt::getTinySerializationStrInformation(std::vector<std::string>& tinyInfo) const
11183 int nbOfCompo=getNumberOfComponents();
11184 tinyInfo.resize(nbOfCompo+1);
11185 tinyInfo[0]=getName();
11186 for(int i=0;i<nbOfCompo;i++)
11187 tinyInfo[i+1]=getInfoOnComponent(i);
11191 tinyInfo.resize(1);
11192 tinyInfo[0]=getName();
11197 * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
11198 * This method returns if a feeding is needed.
11200 bool DataArrayInt::resizeForUnserialization(const std::vector<int>& tinyInfoI)
11202 int nbOfTuple=tinyInfoI[0];
11203 int nbOfComp=tinyInfoI[1];
11204 if(nbOfTuple!=-1 || nbOfComp!=-1)
11206 alloc(nbOfTuple,nbOfComp);
11213 * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
11214 * This method returns if a feeding is needed.
11216 void DataArrayInt::finishUnserialization(const std::vector<int>& tinyInfoI, const std::vector<std::string>& tinyInfoS)
11218 setName(tinyInfoS[0]);
11221 int nbOfCompo=tinyInfoI[1];
11222 for(int i=0;i<nbOfCompo;i++)
11223 setInfoOnComponent(i,tinyInfoS[i+1]);
11227 DataArrayIntIterator::DataArrayIntIterator(DataArrayInt *da):_da(da),_pt(0),_tuple_id(0),_nb_comp(0),_nb_tuple(0)
11232 if(_da->isAllocated())
11234 _nb_comp=da->getNumberOfComponents();
11235 _nb_tuple=da->getNumberOfTuples();
11236 _pt=da->getPointer();
11241 DataArrayIntIterator::~DataArrayIntIterator()
11247 DataArrayIntTuple *DataArrayIntIterator::nextt()
11249 if(_tuple_id<_nb_tuple)
11252 DataArrayIntTuple *ret=new DataArrayIntTuple(_pt,_nb_comp);
11260 DataArrayIntTuple::DataArrayIntTuple(int *pt, int nbOfComp):_pt(pt),_nb_of_compo(nbOfComp)
11264 std::string DataArrayIntTuple::repr() const
11266 std::ostringstream oss; oss << "(";
11267 for(int i=0;i<_nb_of_compo-1;i++)
11268 oss << _pt[i] << ", ";
11269 oss << _pt[_nb_of_compo-1] << ")";
11273 int DataArrayIntTuple::intValue() const
11275 if(_nb_of_compo==1)
11277 throw INTERP_KERNEL::Exception("DataArrayIntTuple::intValue : DataArrayIntTuple instance has not exactly 1 component -> Not possible to convert it into an integer !");
11281 * This method returns a newly allocated instance the caller should dealed with by a ParaMEDMEM::DataArrayInt::decrRef.
11282 * This method performs \b no copy of data. The content is only referenced using ParaMEDMEM::DataArrayInt::useArray with ownership set to \b false.
11283 * 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
11284 * \b nbOfCompo=1 and \bnbOfTuples==this->_nb_of_elem.
11286 DataArrayInt *DataArrayIntTuple::buildDAInt(int nbOfTuples, int nbOfCompo) const
11288 if((_nb_of_compo==nbOfCompo && nbOfTuples==1) || (_nb_of_compo==nbOfTuples && nbOfCompo==1))
11290 DataArrayInt *ret=DataArrayInt::New();
11291 ret->useExternalArrayWithRWAccess(_pt,nbOfTuples,nbOfCompo);
11296 std::ostringstream oss; oss << "DataArrayIntTuple::buildDAInt : unable to build a requested DataArrayInt instance with nbofTuple=" << nbOfTuples << " and nbOfCompo=" << nbOfCompo;
11297 oss << ".\nBecause the number of elements in this is " << _nb_of_compo << " !";
11298 throw INTERP_KERNEL::Exception(oss.str().c_str());